| /******************************************************************************* |
| * Copyright (c) 2016 CEA LIST. |
| * |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr |
| * - Initial API and implementation |
| ******************************************************************************/ |
| #ifndef EXECUTIONDATA_H_ |
| #define EXECUTIONDATA_H_ |
| |
| #include <base/SmartTable.h> |
| |
| #include <common/AvmPointer.h> |
| #include <common/Element.h> |
| #include <common/BF.h> |
| |
| #include <fml/expression/AvmCode.h> |
| |
| #include <collection/Typedef.h> |
| |
| #include <fml/expression/ExpressionConstructor.h> |
| |
| #include <fml/runtime/ExecutionLocation.h> |
| #include <fml/runtime/ExecutionSynchronizationPoint.h> |
| #include <fml/runtime/LocalRuntime.h> |
| #include <fml/runtime/RuntimeForm.h> |
| #include <fml/runtime/RuntimeID.h> |
| #include <fml/runtime/TableOfRuntimeFormState.h> |
| |
| |
| namespace sep |
| { |
| |
| class BaseBufferForm; |
| class BaseInstanceForm; |
| class Bitset; |
| |
| class ExecutionContext; |
| class ExecutableForm; |
| |
| class InstanceOfMachine; |
| |
| |
| /** |
| * TYPEDEF |
| */ |
| typedef SmartTable< RuntimeForm , DestroyElementPolicy > TableOfRuntimeT; |
| |
| |
| class ExecutionData : public Element , |
| AVM_INJECT_INSTANCE_COUNTER_CLASS( ExecutionData ) |
| { |
| |
| AVM_DECLARE_CLONABLE_CLASS( ExecutionData ) |
| |
| |
| public: |
| /** |
| * ATTRIBUTES |
| * static |
| */ |
| static avm_size_t PARAM_MACHINE_RUNTIME_OFFSET; |
| |
| static avm_size_t SYSTEM_RUNTIME_OFFSET; |
| |
| protected: |
| /** |
| * ATTRIBUTES |
| */ |
| ExecutionContext * mExecutionContext; |
| |
| BF mPathCondition; |
| BF mPathTimedCondition; |
| |
| bool mGlobalNodeConditionEnabledFlag; |
| bool mLocalNodeConditionEnabledFlag; |
| |
| BF mNodeCondition; |
| BF mNodeTimedCondition; |
| BF mRunnableElementTrace; |
| BF mIOElementTrace; |
| |
| BFCode mOnInit; |
| BFCode mOnSchedule; |
| |
| TableOfRuntimeT mTableOfRuntime; |
| |
| APTableOfRuntimeFormState mTableOfRFStateFlags; |
| |
| APStackOfLocalRuntime mStackOfLocalRuntime; |
| |
| public: |
| /** |
| * ATTRIBUTES |
| * public |
| */ |
| RuntimeID mRID; |
| bool mPreserveRID; |
| |
| // Routine Parameter[s] or Return Statement value[s] |
| BF mVALUE; |
| |
| AVM_EXEC_ENDING_STATUS mAEES; |
| |
| ExecutionLocationQueue mSTATEMENT_QUEUE; |
| |
| ExecutionSynchronizationPoint * mEXEC_SYNC_POINT; |
| |
| |
| public: |
| /** |
| * CONSTRUCTOR |
| * Default |
| */ |
| ExecutionData( avm_size_t aMachineCount ) |
| : Element( CLASS_KIND_T( ExecutionData ) ), |
| mExecutionContext( NULL ), |
| |
| mPathCondition( ), |
| mPathTimedCondition( ), |
| |
| mGlobalNodeConditionEnabledFlag( true ), |
| mLocalNodeConditionEnabledFlag( false ), |
| |
| mNodeCondition( ), |
| mNodeTimedCondition( ), |
| |
| mRunnableElementTrace( ), |
| mIOElementTrace( ), |
| |
| mOnInit( ), |
| mOnSchedule( ), |
| |
| mTableOfRuntime( aMachineCount ), |
| |
| mTableOfRFStateFlags( new TableOfRuntimeFormState(aMachineCount) ), |
| mStackOfLocalRuntime( ), |
| |
| // public Attributes |
| mRID( ), |
| mPreserveRID( false ), |
| mVALUE( ), |
| |
| mAEES( AEES_OK ), |
| |
| mSTATEMENT_QUEUE( ), |
| mEXEC_SYNC_POINT( NULL ) |
| { |
| //!! NOTHING |
| } |
| |
| |
| /** |
| * CONSTRUCTOR |
| * Copy |
| */ |
| ExecutionData(const ExecutionData & anED) |
| : Element( anED ), |
| mExecutionContext( anED.mExecutionContext ), |
| |
| mPathCondition( anED.mPathCondition ), |
| mPathTimedCondition( anED.mPathTimedCondition ), |
| |
| mGlobalNodeConditionEnabledFlag( anED.mGlobalNodeConditionEnabledFlag ), |
| mLocalNodeConditionEnabledFlag( anED.mLocalNodeConditionEnabledFlag ), |
| |
| mNodeCondition( anED.mNodeCondition ), |
| mNodeTimedCondition( anED.mNodeTimedCondition ), |
| |
| mRunnableElementTrace( anED.mRunnableElementTrace ), |
| mIOElementTrace( anED.mIOElementTrace ), |
| |
| mOnInit( anED.mOnInit ), |
| mOnSchedule( anED.mOnSchedule ), |
| |
| mTableOfRuntime( anED.mTableOfRuntime ), |
| |
| mTableOfRFStateFlags( anED.mTableOfRFStateFlags ), |
| mStackOfLocalRuntime( anED.mStackOfLocalRuntime ), |
| |
| // public Attributes |
| mRID(anED.mRID), |
| mPreserveRID( anED.mPreserveRID ), |
| mVALUE( anED.mVALUE ), |
| |
| mAEES( anED.mAEES ), |
| |
| mSTATEMENT_QUEUE( anED.mSTATEMENT_QUEUE ), |
| mEXEC_SYNC_POINT( (anED.mEXEC_SYNC_POINT != NULL) ? |
| new ExecutionSynchronizationPoint( *(anED.mEXEC_SYNC_POINT) ) : NULL ) |
| { |
| //!! NOTHING |
| } |
| |
| |
| /** |
| * DESTRUCTOR |
| */ |
| virtual ~ExecutionData() |
| { |
| delete( mEXEC_SYNC_POINT ); |
| } |
| |
| |
| /** |
| * resize |
| */ |
| void resize(avm_size_t newMachineCount) |
| { |
| mTableOfRuntime.makeWritableResize( newMachineCount ); |
| |
| mTableOfRFStateFlags.makeWritable(); |
| mTableOfRFStateFlags->resize(newMachineCount); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mExecutionContext |
| */ |
| inline ExecutionContext * getExecutionContext() const |
| { |
| return( mExecutionContext ); |
| } |
| |
| inline bool hasExecutionContext() const |
| { |
| return( mExecutionContext != NULL ); |
| } |
| |
| inline void setExecutionContext(ExecutionContext * anExecutionContext) |
| { |
| mExecutionContext = anExecutionContext; |
| } |
| |
| |
| /** |
| * GETTER |
| * mPathCondition && mPathTimedCondition |
| */ |
| inline BF getAllPathCondition() const |
| { |
| if( mPathTimedCondition.valid() |
| && mPathTimedCondition.isNotEqualTrue() ) |
| { |
| return( ExpressionConstructor::andExpr( |
| mPathCondition, mPathTimedCondition) ); |
| } |
| else |
| { |
| return( mPathCondition ); |
| } |
| } |
| |
| |
| inline BF andPathTimedCondition(const BF & aCondition) const |
| { |
| if( mPathTimedCondition.valid() ) |
| { |
| if( mPathTimedCondition.isEqualTrue() ) |
| { |
| return( aCondition ); |
| } |
| else if( mPathTimedCondition.isEqualFalse() ) |
| { |
| return( mPathTimedCondition ); |
| } |
| |
| return( ExpressionConstructor::andExpr( |
| mPathTimedCondition, aCondition) ); |
| } |
| else |
| { |
| return( aCondition ); |
| } |
| } |
| |
| /** |
| * GETTER - SETTER |
| * mPathCondition |
| */ |
| inline const BF & getPathCondition() const |
| { |
| return( mPathCondition ); |
| } |
| |
| inline bool hasPathCondition() const |
| { |
| return( mPathCondition.valid() ); |
| } |
| |
| inline void setPathCondition(const BF & aPathCondition) |
| { |
| mPathCondition = aPathCondition; |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mPathTimedCondition |
| */ |
| inline const BF & getPathTimedCondition() const |
| { |
| return( mPathTimedCondition ); |
| } |
| |
| inline bool hasPathTimedCondition() const |
| { |
| return( mPathTimedCondition.valid() ); |
| } |
| |
| inline void setPathTimedCondition(const BF & aPathTimedCondition) |
| { |
| mPathTimedCondition = aPathTimedCondition; |
| } |
| |
| |
| |
| /** |
| * GETTER |
| * mNodeCondition && mNodeTimedCondition |
| */ |
| inline BF getAllNodeCondition() const |
| { |
| if( mNodeTimedCondition.valid() && mNodeTimedCondition.isNotEqualTrue() ) |
| { |
| return( ExpressionConstructor::andExpr( |
| mNodeCondition, mNodeTimedCondition) ); |
| } |
| else |
| { |
| return( mNodeCondition ); |
| } |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mNodeCondition |
| */ |
| inline const BF & getNodeCondition() const |
| { |
| return( mNodeCondition ); |
| } |
| |
| inline bool hasNodeCondition() const |
| { |
| return( mNodeCondition.valid() ); |
| } |
| |
| inline void setNodeCondition(const BF & aCondition) |
| { |
| mNodeCondition = aCondition; |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mNodeTimedCondition |
| */ |
| inline const BF & getNodeTimedCondition() const |
| { |
| return( mNodeTimedCondition ); |
| } |
| |
| inline bool hasNodeTimedCondition() const |
| { |
| return( mNodeTimedCondition.valid() ); |
| } |
| |
| inline void setNodeTimedCondition(const BF & aTimedCondition) |
| { |
| mNodeTimedCondition = aTimedCondition; |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mGlobalNodeConditionEnabledFlag |
| * mLocalNodeConditionEnabledFlag |
| */ |
| inline bool isEnabledNodeCondition() const |
| { |
| return( mGlobalNodeConditionEnabledFlag || |
| mLocalNodeConditionEnabledFlag ); |
| } |
| |
| inline void setEnabledGlobalNodeCondition(bool aCondition = true) |
| { |
| mGlobalNodeConditionEnabledFlag = aCondition; |
| } |
| |
| inline void setEnabledLocalNodeCondition(bool aCondition = true) |
| { |
| mLocalNodeConditionEnabledFlag = aCondition; |
| } |
| |
| |
| /** |
| * Serialization |
| */ |
| void toStream(OutStream & os) const; |
| |
| inline std::string str() const |
| { |
| return( strStateConf() ); |
| } |
| |
| void toStreamData(OutStream & os) const; |
| |
| void toFscn(OutStream & os, const ExecutionData * aPreviousExecData) const; |
| |
| |
| /** |
| * string of a state configuration of an ExecutionData |
| * !UNUSED! |
| inline std::string strStateIdleOrRunning() const |
| { |
| if( getSystemRuntimeForm()->hasOnSchedule() |
| || getSystemRuntimeForm()->hasChild() ) |
| { |
| return( strStateIdleOrRunning( getSystemRuntimeForm() ) ); |
| } |
| else |
| { |
| return( "(" + strStateIdleOrRunning( getSystemRuntime() ) + ")" ); |
| } |
| } |
| |
| inline std::string strStateIdleOrRunning(const RuntimeForm & aRF) const |
| { |
| StringOutStream oss; |
| |
| toStreamStateIdleOrRunning(oss, aRF); |
| |
| return( oss.str() ); |
| } |
| * !UNUSED! |
| */ |
| |
| void toStreamStateIdleOrRunning( |
| OutStream & os, const RuntimeForm & aRF) const; |
| |
| /** |
| * string of a state configuration of an ExecutionData |
| * |
| * LIFELINE STATE IDENTIFIER |
| * %1% --> lifeline runtime pid |
| * %2% --> lifeline identifier |
| * %3% --> state runtime pid |
| * %4% --> state identifier |
| */ |
| OutStream & toStreamLifelineStateFormat( |
| OutStream & os, const RuntimeForm & aRF, |
| const std::string & formatLifelineStatePattern = "%3%:%4%") const; |
| |
| inline std::string strStateConf( |
| const std::string & formatLifelineStatePattern = "%3%:%4%") const |
| { |
| if( getSystemRuntime().hasOnSchedule() ) |
| { |
| return( strStateConf( |
| getSystemRuntime() , formatLifelineStatePattern ) ); |
| } |
| else |
| { |
| return( "(" + strStateConf( getSystemRuntime() , |
| formatLifelineStatePattern ) + ")" ); |
| } |
| } |
| |
| std::string strStateConf(const RuntimeForm & aRF, |
| const std::string & formatLifelineStatePattern = "%3%:%4%") const |
| { |
| StringOutStream oss; |
| |
| toStreamStateConf(oss, aRF, formatLifelineStatePattern); |
| |
| return( oss.str() ); |
| } |
| |
| void toStreamStateConf(OutStream & os, const RuntimeForm & aRF, |
| const std::string & formatLifelineStatePattern = "%3%:%4%") const; |
| |
| |
| /** |
| * string of a state configuration of an ExecutionData |
| */ |
| inline std::string strStateConfToFscn() const |
| { |
| if( getSystemRuntime().hasOnSchedule() |
| || getSystemRuntime().hasChild() ) |
| { |
| return( strStateConfToFscn( getSystemRuntime() ) ); |
| } |
| else |
| { |
| return( "(" + strStateConfToFscn( getSystemRuntime() ) + ")" ); |
| } |
| } |
| |
| inline std::string strStateConfToFscn(const RuntimeForm & aRF) const |
| { |
| StringOutStream oss; |
| |
| toStreamStateConfToFscn(oss, aRF); |
| |
| return( oss.str() ); |
| } |
| |
| void toStreamStateConfToFscn( |
| OutStream & os, const RuntimeForm & aRF) const; |
| |
| |
| /** |
| * GETTER - SETTER |
| * mRunnableElementTrace |
| */ |
| inline BF & getRunnableElementTrace() |
| { |
| return( mRunnableElementTrace ); |
| } |
| |
| inline const BF & getRunnableElementTrace() const |
| { |
| return( mRunnableElementTrace ); |
| } |
| |
| inline bool hasRunnableElementTrace() const |
| { |
| return( mRunnableElementTrace.valid() ); |
| } |
| |
| inline void setRunnableElementTrace(const BF & aRunnableElementTrace) |
| { |
| mRunnableElementTrace = aRunnableElementTrace; |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mIOElementTrace |
| */ |
| inline BF & getIOElementTrace() |
| { |
| return( mIOElementTrace ); |
| } |
| |
| inline const BF & getIOElementTrace() const |
| { |
| return( mIOElementTrace ); |
| } |
| |
| inline bool hasIOElementTrace() const |
| { |
| return( mIOElementTrace.valid() ); |
| } |
| |
| inline void setIOElementTrace(const BF & anIOElementTrace) |
| { |
| mIOElementTrace = anIOElementTrace; |
| } |
| |
| |
| /** |
| * GETTER |
| * mRunnableElementTrace |
| * mIOElementTrace |
| */ |
| //$DELETE |
| inline bool notEvaluated() const |
| { |
| return( mRunnableElementTrace.invalid() |
| && mIOElementTrace.invalid() ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mOnInit |
| */ |
| inline const BFCode & getOnInit() const |
| { |
| return( mOnInit ); |
| } |
| |
| inline bool hasOnInit() const |
| { |
| return( mOnInit.valid() ); |
| } |
| |
| inline void setOnInit(const BFCode & onInit) |
| { |
| mOnInit = onInit; |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mOnSchedule |
| */ |
| inline const BFCode & getOnSchedule() const |
| { |
| return( mOnSchedule ); |
| } |
| |
| inline bool hasOnSchedule() const |
| { |
| return( mOnSchedule.valid() ); |
| } |
| |
| inline void setOnSchedule(const BFCode & onSchedule) |
| { |
| mOnSchedule = onSchedule; |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mTableOfRuntimeForm |
| */ |
| inline const TableOfRuntimeT & getTableOfRuntime() const |
| { |
| return( mTableOfRuntime ); |
| } |
| |
| |
| inline RuntimeForm & getRuntime(avm_size_t offset) |
| { |
| return( mTableOfRuntime.ref(offset) ); |
| } |
| |
| inline const RuntimeForm & getRuntime(avm_size_t offset) const |
| { |
| return( mTableOfRuntime.ref(offset) ); |
| } |
| |
| |
| inline RuntimeForm & getRuntime(const RuntimeID & aRID) |
| { |
| return( mTableOfRuntime.ref( aRID.getOffset() ) ); |
| } |
| |
| inline const RuntimeForm & getRuntime(const RuntimeID & aRID) const |
| { |
| return( mTableOfRuntime.ref( aRID.getOffset() ) ); |
| } |
| |
| |
| inline const RuntimeForm * ptrRuntime(avm_size_t offset) const |
| { |
| return( mTableOfRuntime.at(offset) ); |
| } |
| |
| inline RuntimeForm * ptrRuntime(const RuntimeID & aRID) |
| { |
| return( mTableOfRuntime.at( aRID.getOffset() ) ); |
| } |
| |
| inline const RuntimeForm * ptrRuntime(const RuntimeID & aRID) const |
| { |
| return( mTableOfRuntime.at( aRID.getOffset() ) ); |
| } |
| |
| |
| inline const RuntimeID & getRuntimeID(avm_size_t rid) const |
| { |
| return( mTableOfRuntime.at(rid)->getRID() ); |
| } |
| |
| const RuntimeID & getRuntimeID(const ExecutableForm * anExecutable) const; |
| |
| const RuntimeID & getRuntimeID(InstanceOfMachine * anInstance) const; |
| |
| const RuntimeID & getRuntimeID( |
| const std::string & aFullyQualifiedNameID) const; |
| |
| const RuntimeID & getRuntimeIDByNameID(const std::string & aNameID) const; |
| |
| |
| RuntimeID getRuntimeContainerRID(const RuntimeID & aRID, |
| BaseInstanceForm * anInstance) const; |
| |
| RuntimeID getRuntimeContainerRID(BaseInstanceForm * anInstance) const |
| { |
| return( getRuntimeContainerRID(mRID, anInstance) ); |
| } |
| |
| |
| inline const BFCode & getRuntimeFormOnSchedule(const RuntimeID & aRID) const |
| { |
| return( mTableOfRuntime.at(aRID.getOffset())->getOnSchedule() ); |
| } |
| |
| inline const BFCode & getRuntimeFormOnDefer(const RuntimeID & aRID) const |
| { |
| return( mTableOfRuntime.at(aRID.getOffset())->getOnDefer() ); |
| } |
| |
| |
| |
| // assign <==> release_acquire |
| inline void saveRuntimeForm(avm_size_t offset, RuntimeForm * aRF) const |
| { |
| mTableOfRuntime.set(offset, aRF); |
| } |
| |
| // assign <==> release_acquire |
| inline void assignRuntimeForm(avm_size_t offset, RuntimeForm * aRF) const |
| { |
| mTableOfRuntime.assign(offset, aRF); |
| } |
| |
| |
| /*************************************************************************** |
| *************************************************************************** |
| * GETTER - SETTER |
| * mTableOfRuntime |
| * |
| * make writable |
| *************************************************************************** |
| */ |
| inline RuntimeForm & getWritableRuntime(const RuntimeID & aRID) |
| { |
| return( mTableOfRuntime.refWritable( aRID.getOffset() ) ); |
| } |
| |
| |
| /** |
| * GETTER |
| * for data in RuntimeForm DataTable |
| */ |
| const BF & getDataByQualifiedNameID( |
| const std::string & aQualifiedNameID, InstanceOfData * & var) const; |
| |
| const BF & getDataByNameID(const std::string & aNameID) const; |
| |
| |
| /** |
| * GETTER - SETTER |
| * mTableOfRFStateFlags |
| */ |
| inline const APTableOfRuntimeFormState & getRuntimeFormStateTable() const |
| { |
| return( mTableOfRFStateFlags ); |
| } |
| |
| |
| inline PROCESS_EVAL_STATE getRuntimeFormState(avm_size_t rid) const |
| { |
| return( mTableOfRFStateFlags->stateAt(rid) ); |
| } |
| |
| inline PROCESS_EVAL_STATE getRuntimeFormState( |
| const RuntimeID & aRID) const |
| { |
| return( mTableOfRFStateFlags->stateAt( aRID.getOffset() ) ); |
| } |
| |
| bool checkRunningForm( |
| const BF & aRunnableElementTrace, const RuntimeID & aRID); |
| |
| |
| // CREATED STATE |
| inline bool isCreated(const RuntimeID & aRID) const |
| { |
| return( mTableOfRFStateFlags->isCreated( aRID.getOffset() ) ); |
| } |
| |
| // LOADED STATE |
| inline bool isLoaded(const RuntimeID & aRID) const |
| { |
| return( mTableOfRFStateFlags->isLoaded( aRID.getOffset() ) ); |
| } |
| |
| // STARTING STATE |
| inline bool isStarting(const RuntimeID & aRID) const |
| { |
| return( mTableOfRFStateFlags->isStarting( aRID.getOffset() ) ); |
| } |
| |
| inline bool isIniting(const RuntimeID & aRID) const |
| { |
| return( mTableOfRFStateFlags->isIniting( aRID.getOffset() ) ); |
| } |
| |
| // STOPPING STATE |
| inline bool isStopping(const RuntimeID & aRID) const |
| { |
| return( mTableOfRFStateFlags->isStopping( aRID.getOffset() ) ); |
| } |
| |
| // STOPPED STATE |
| inline bool isStopped(const RuntimeID & aRID) const |
| { |
| return( mTableOfRFStateFlags->isStopped( aRID.getOffset() ) ); |
| } |
| |
| // FINALIZING STATE |
| inline bool isFinalizing(const RuntimeID & aRID) const |
| { |
| return( mTableOfRFStateFlags->isFinalizing( aRID.getOffset() ) ); |
| } |
| |
| // FINALIZED STATE |
| inline bool isFinalized(const RuntimeID & aRID) const |
| { |
| return( mTableOfRFStateFlags->isFinalized( aRID.getOffset() ) ); |
| } |
| |
| // DESTROYED STATE |
| inline bool isDestroyed(const RuntimeID & aRID) const |
| { |
| return( mTableOfRFStateFlags->isDestroyed( aRID.getOffset() ) ); |
| } |
| |
| // FINALIZED or DESTROYED STATE |
| inline bool isFinalizedOrDestroyed(const RuntimeID & aRID) const |
| { |
| return( mTableOfRFStateFlags-> |
| isFinalizedOrDestroyed( aRID.getOffset() ) ); |
| } |
| |
| // ALIVE STATE |
| inline bool isAlive(const RuntimeID & aRID) const |
| { |
| return( mTableOfRFStateFlags->isAlive( aRID.getOffset() ) ); |
| } |
| |
| // SUPENDED STATE |
| inline bool isSuspended(const RuntimeID & aRID) const |
| { |
| return( mTableOfRFStateFlags->isSuspended( aRID.getOffset() ) ); |
| } |
| |
| // WAITING STATE |
| inline bool isWaiting(const RuntimeID & aRID) const |
| { |
| return( mTableOfRFStateFlags->isWaiting( aRID.getOffset() ) ); |
| } |
| |
| // WAITING JOIN STATE |
| inline bool isWaitingJoin(const RuntimeID & aRID) const |
| { |
| return( mTableOfRFStateFlags->isWaitingJoin( aRID.getOffset() ) ); |
| } |
| |
| // DISABLE STATE |
| inline bool isDisable(const RuntimeID & aRID) const |
| { |
| return( mTableOfRFStateFlags->isDisable( aRID.getOffset() ) ); |
| } |
| |
| // DISABLE STATE |
| inline bool isAborted(const RuntimeID & aRID) const |
| { |
| return( mTableOfRFStateFlags->isAborted( aRID.getOffset() ) ); |
| } |
| |
| // DISABLE or ABORTED STATE |
| inline bool isDisableOrAborted(const RuntimeID & aRID) const |
| { |
| return( mTableOfRFStateFlags->isDisableOrAborted( aRID.getOffset() ) ); |
| } |
| |
| // IDLE STATE |
| inline bool isIdle() const |
| { |
| return( mTableOfRFStateFlags->isIdle( mRID.getOffset() ) ); |
| } |
| |
| inline bool isIdle(const RuntimeID & aRID) const |
| { |
| return( mTableOfRFStateFlags->isIdle( aRID.getOffset() ) ); |
| } |
| |
| // RUNNING STATE |
| inline bool isRunning(const RuntimeID & aRID) const |
| { |
| return( mTableOfRFStateFlags->isRunning( aRID.getOffset() ) ); |
| } |
| |
| // IDLE or RUNNING STATE |
| inline bool isIdleOrRunning(const RuntimeID & aRID) const |
| { |
| return( mTableOfRFStateFlags->isIdleOrRunning( aRID.getOffset() ) ); |
| } |
| |
| // RUNNABLE STATE |
| inline bool isRunnable(const RuntimeID & aRID) const |
| { |
| return( mTableOfRFStateFlags->isRunnable( aRID.getOffset() ) ); |
| } |
| |
| inline bool isunRunnable(const RuntimeID & aRID) const |
| { |
| return( mTableOfRFStateFlags->isunRunnable( aRID.getOffset() ) ); |
| } |
| |
| inline bool isunRunnableSystem() const |
| { |
| return( mTableOfRFStateFlags->isunRunnable( SYSTEM_RUNTIME_OFFSET ) ); |
| } |
| |
| // CREATED or RUNNABLE STATE |
| inline bool isCreatedOrRunnable(const RuntimeID & aRID) const |
| { |
| return( mTableOfRFStateFlags->isCreatedOrRunnable( aRID.getOffset() ) ); |
| } |
| |
| // DEFINED / UNDEFINED STATE |
| inline bool isDefinedPES(const RuntimeID & aRID) const |
| { |
| return( mTableOfRFStateFlags->isDefined( aRID.getOffset() ) ); |
| } |
| |
| inline bool isUndefinedPES(avm_offset_t offset) const |
| { |
| return( mTableOfRFStateFlags->isUndefined( offset ) ); |
| } |
| |
| inline void makeWritableRuntimeFormStateTable() |
| { |
| mTableOfRFStateFlags.makeWritable(); |
| } |
| |
| inline void mwsetRuntimeFormState(const RuntimeID & aRID, |
| PROCESS_EVAL_STATE aPES) |
| { |
| makeWritableRuntimeFormStateTable(); |
| |
| mTableOfRFStateFlags->stateSet(aRID.getOffset(), aPES); |
| } |
| |
| inline void setRuntimeFormState(const RuntimeID & aRID, |
| PROCESS_EVAL_STATE aPES) |
| { |
| mTableOfRFStateFlags->stateSet(aRID.getOffset(), aPES); |
| } |
| |
| |
| inline void mwsetRuntimeFormState(avm_size_t rid, |
| PROCESS_EVAL_STATE aPES) |
| { |
| makeWritableRuntimeFormStateTable(); |
| |
| mTableOfRFStateFlags->stateSet(rid, aPES); |
| } |
| |
| inline void setRuntimeFormState(avm_size_t rid, |
| PROCESS_EVAL_STATE aPES) |
| { |
| mTableOfRFStateFlags->stateSet(rid, aPES); |
| } |
| |
| |
| // ASSIGNABILITY |
| inline Bitset * getAssigned(avm_size_t rid) const |
| { |
| return( mTableOfRFStateFlags->getAssigned(rid) ); |
| } |
| |
| inline bool isAssigned(const RuntimeID & aRID, avm_size_t rid) const |
| { |
| return( mTableOfRFStateFlags->isAssigned(aRID.getOffset(), rid) ); |
| } |
| |
| |
| inline void mwsetAssigned(const RuntimeID & aRID, |
| avm_offset_t varOffset, bool flag = true) |
| { |
| makeWritableRuntimeFormStateTable(); |
| |
| mTableOfRFStateFlags->setAssigned(*this, |
| aRID.getOffset(), varOffset, flag); |
| } |
| |
| inline void setAssigned(const RuntimeID & aRID, |
| avm_offset_t varOffset, bool flag = true) |
| { |
| mTableOfRFStateFlags->setAssigned(*this, |
| aRID.getOffset(), varOffset, flag); |
| } |
| |
| |
| /** |
| * GETTER |
| * mTableOfAssignedFlag |
| */ |
| TableOfRuntimeFormState::TableOfAssignedFlag getTableOfAssignedFlag() |
| { |
| return( mTableOfRFStateFlags->getTableOfAssignedFlag() ); |
| } |
| |
| void setTableOfAssignedFlag( |
| TableOfRuntimeFormState::TableOfAssignedFlag aTableOfAssignedFlag) |
| { |
| mTableOfRFStateFlags->setTableOfAssignedFlag( aTableOfAssignedFlag ); |
| } |
| |
| |
| /** |
| * GETTER |
| * mSaveTableOfAssignedFlag |
| */ |
| TableOfRuntimeFormState:: |
| TableOfAssignedFlag getSaveTableOfAssignedFlag() const; |
| |
| /** |
| * GETTER - SETTER |
| * RuntimeForm CHILD |
| */ |
| inline const RuntimeID & getRuntimeFormChild(const RuntimeID & aRID, |
| const InstanceOfMachine * anInstance) const |
| { |
| AVM_OS_ASSERT_FATAL_ERROR_EXIT( getRuntime(aRID).getChild( |
| anInstance->getOffset() ).getInstance() == anInstance ) |
| << "Fatal Error: Bad child< " |
| << anInstance->getQualifiedNameID() |
| << " > Offset in runtime machine< " |
| << aRID.getQualifiedNameID() << " >!!!" |
| << SEND_EXIT; |
| |
| return( getRuntime(aRID).getChild(anInstance->getOffset()) ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mStackOfLocalRuntime |
| */ |
| inline void createLocalRuntimeStack() |
| { |
| mStackOfLocalRuntime = |
| APStackOfLocalRuntime( new StackOfLocalRuntime() ); |
| } |
| |
| inline void destroyLocalRuntimeStack() |
| { |
| mStackOfLocalRuntime.destroy(); |
| } |
| |
| inline APStackOfLocalRuntime & getLocalRuntimes() |
| { |
| return( mStackOfLocalRuntime ); |
| } |
| |
| inline const APStackOfLocalRuntime & getLocalRuntimes() const |
| { |
| return( mStackOfLocalRuntime ); |
| } |
| |
| |
| inline bool hasLocalRuntime() const |
| { |
| return( mStackOfLocalRuntime.valid() |
| && mStackOfLocalRuntime->nonempty() ); |
| } |
| |
| inline bool hasLocalRuntimeStack() const |
| { |
| return( mStackOfLocalRuntime.valid() ); |
| } |
| |
| inline void makeWritableLocalRuntimeStack() |
| { |
| if( mStackOfLocalRuntime.valid() ) |
| { |
| mStackOfLocalRuntime.makeWritable(); |
| } |
| else |
| { |
| mStackOfLocalRuntime.replacePointer( new StackOfLocalRuntime() ); |
| } |
| } |
| |
| inline void setLocalRuntime(avm_size_t offset, |
| const LocalRuntime & aLocalRuntime) |
| { |
| mStackOfLocalRuntime->setLocalRuntime(offset, aLocalRuntime); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mParametersRuntimeForm |
| */ |
| inline const ParametersRuntimeForm & getParametersRuntimeForm() const |
| { |
| return( static_cast< const ParametersRuntimeForm & >( |
| mTableOfRuntime.ref(PARAM_MACHINE_RUNTIME_OFFSET) ) ); |
| } |
| |
| inline ParametersRuntimeForm & getWritableParametersRuntimeForm() |
| { |
| ParametersRuntimeForm & pRF = static_cast< ParametersRuntimeForm & >( |
| mTableOfRuntime.refWritable(PARAM_MACHINE_RUNTIME_OFFSET) ); |
| |
| pRF.resetOffset(); |
| |
| return( pRF ); |
| |
| // return( static_cast< ParametersRuntimeForm & >( |
| // mTableOfRuntime.refWritable( |
| // PARAM_MACHINE_RUNTIME_OFFSET) ) ); |
| } |
| |
| inline BF bfParametersRuntimeForm() const |
| { |
| return( mTableOfRuntime.to_sp< BF >( PARAM_MACHINE_RUNTIME_OFFSET ) ); |
| } |
| |
| |
| inline const RuntimeID & getParametersRID() const |
| { |
| return( getRuntime(PARAM_MACHINE_RUNTIME_OFFSET).getRID() ); |
| } |
| |
| inline const BF & saveParameter(InstanceOfData * anInstance) |
| { |
| return( getWritableParametersRuntimeForm().saveParameter(anInstance) ); |
| } |
| |
| inline void appendParameters(BFList & paramList) |
| { |
| getWritableParametersRuntimeForm().appendParameters(paramList); |
| } |
| |
| |
| inline void saveParametersRuntimeForm( |
| ParametersRuntimeForm * paramsRF) const |
| { |
| mTableOfRuntime.set(PARAM_MACHINE_RUNTIME_OFFSET, paramsRF); |
| } |
| |
| inline void assignParametersRuntimeForm( |
| ParametersRuntimeForm * paramsRF) const |
| { |
| mTableOfRuntime.assign(PARAM_MACHINE_RUNTIME_OFFSET, paramsRF); |
| } |
| |
| inline void assignParametersRuntimeForm(const BF & paramsRF) const |
| { |
| mTableOfRuntime.assign(PARAM_MACHINE_RUNTIME_OFFSET, |
| paramsRF.to_ptr< RuntimeForm >() ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * System RuntimeForm |
| */ |
| inline const RuntimeForm & getSystemRuntime() const |
| { |
| return( getRuntime(SYSTEM_RUNTIME_OFFSET) ); |
| } |
| |
| inline const RuntimeID & getSystemRID() const |
| { |
| return( getRuntime(SYSTEM_RUNTIME_OFFSET).getRID() ); |
| } |
| |
| inline void setSystemRID() |
| { |
| setRID( getSystemRID() ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mRID |
| */ |
| inline const RuntimeID & getRID() const |
| { |
| return( mRID ); |
| } |
| |
| inline void setRID(const RuntimeID & aRID) |
| { |
| mRID = aRID; |
| } |
| |
| /* |
| * GETTER - SETTER |
| * Avm Ending Execution Status |
| */ |
| inline AVM_EXEC_ENDING_STATUS getAEES() const |
| { |
| return( mAEES ); |
| } |
| |
| inline void setAEES(AVM_EXEC_ENDING_STATUS anAEES) |
| { |
| mAEES = anAEES; |
| } |
| |
| |
| /* |
| * GETTER - SETTER |
| * Avm Execution Synchronization Point |
| */ |
| inline void pushExecSyncPoint( |
| ExecutionSynchronizationPoint * anExecSyncPoint) |
| { |
| if( mEXEC_SYNC_POINT == NULL ) |
| { |
| mEXEC_SYNC_POINT = anExecSyncPoint; |
| } |
| else |
| { |
| ExecutionSynchronizationPoint * lastESP = mEXEC_SYNC_POINT; |
| while( lastESP->next != NULL ) |
| { |
| lastESP = lastESP->next; |
| } |
| lastESP->next = anExecSyncPoint; |
| } |
| } |
| |
| |
| /** |
| * INSTANCIATION BOUND TEST |
| */ |
| bool couldBeInstanciated(InstanceOfMachine * anInstance) const; |
| |
| |
| /** |
| * COMPARISON |
| * OPERATOR |
| * |
| * TRIVIAL EQUALITY |
| */ |
| virtual bool isTEQ(const ExecutionData * anED) const |
| { |
| if( this == anED ) |
| { |
| return( true ); |
| } |
| else if( mTableOfRFStateFlags->equalsState( |
| anED->mTableOfRFStateFlags ) ) |
| { |
| return( (mTableOfRuntime == anED->mTableOfRuntime) |
| && mPathCondition.isTEQ(anED->mPathCondition) |
| && mPathTimedCondition.isTEQ(anED->mPathTimedCondition) |
| && (mStackOfLocalRuntime == anED->mStackOfLocalRuntime) ); |
| } |
| return( false ); |
| } |
| |
| inline bool isTNEQ(const ExecutionData * anED) const |
| { |
| return( not isTEQ( anED ) ); |
| } |
| |
| }; |
| |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////////// |
| // AVM SMART POINTER FOR ExecutionData |
| //////////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| |
| #define AVM_DEBUG_EXECUTION_DATA_POINTER true |
| #undef AVM_DEBUG_EXECUTION_DATA_POINTER |
| |
| #if defined(AVM_DEBUG_EXECUTION_DATA_POINTER) |
| |
| #define AVM_DECLARE_DEBUG_EXECUTION_DATA_PTR const ExecutionData * debugPTR; |
| |
| #define AVM_INIT_DEBUG_EXECUTION_DATA_PTR( ptr ) , debugPTR( ptr ) |
| |
| #define AVM_ASSIGN_STMNT_DEBUG_EXECUTION_DATA_PTR( ptr ) debugPTR = ptr; |
| |
| #define AVM_ASSIGN_EXPR_DEBUG_EXECUTION_DATA_PTR( ptr ) debugPTR = ptr |
| |
| #else |
| |
| #define AVM_DECLARE_DEBUG_EXECUTION_DATA_PTR |
| |
| #define AVM_INIT_DEBUG_EXECUTION_DATA_PTR( ptr ) |
| |
| #define AVM_ASSIGN_STMNT_DEBUG_EXECUTION_DATA_PTR( ptr ) |
| |
| #define AVM_ASSIGN_EXPR_DEBUG_EXECUTION_DATA_PTR( ptr ) ptr |
| |
| #endif |
| |
| |
| class APExecutionData : |
| public AvmPointer< ExecutionData , DestroyElementPolicy > |
| { |
| |
| private: |
| /** |
| * TYPEDEF |
| */ |
| typedef AvmPointer< ExecutionData , DestroyElementPolicy > base_this_type; |
| |
| |
| protected: |
| /** |
| * Only for debug facilities |
| */ |
| AVM_DECLARE_DEBUG_EXECUTION_DATA_PTR |
| |
| |
| public: |
| |
| /** |
| * CONSTRUCTOR |
| * Default |
| */ |
| APExecutionData() |
| : base_this_type( ) |
| AVM_INIT_DEBUG_EXECUTION_DATA_PTR( NULL ) |
| { |
| //!!! NOTHING |
| } |
| |
| explicit APExecutionData(ExecutionData * anED) |
| : base_this_type( AVM_ASSIGN_EXPR_DEBUG_EXECUTION_DATA_PTR( anED ) ) |
| { |
| //!!! NOTHING |
| } |
| |
| |
| |
| /** |
| * DESTRUCTOR |
| */ |
| virtual ~APExecutionData() |
| { |
| //!!! NOTHING |
| } |
| |
| |
| /** |
| * resize |
| */ |
| void resize(avm_size_t newMachineCount) |
| { |
| makeWritable(); |
| |
| raw_pointer()->resize(newMachineCount); |
| } |
| |
| |
| /** |
| * GETTER |
| * the Previous ExecutionData |
| */ |
| APExecutionData & getPrevious(); |
| |
| const APExecutionData & getPrevious() const; |
| |
| bool hasPrevious() const; |
| |
| |
| inline void mwsetPathCondition(const BF & mCondition) |
| { |
| makeWritable(); |
| |
| raw_pointer()->setPathCondition( mCondition ); |
| |
| } |
| |
| inline void mwsetPathTimedCondition(const BF & mCondition) |
| { |
| makeWritable(); |
| |
| raw_pointer()->setPathTimedCondition( mCondition ); |
| |
| } |
| |
| |
| /** |
| * SETTER |
| * make Modifiable |
| */ |
| inline void makeModifiableParamTable() |
| { |
| makeWritable(); |
| |
| // TODO Revoir la gestion de la liste des nouveaux parametres |
| // if( hasParam() && getParam()->isMultiple() ) |
| // { |
| // decRefCounter( getParam() ); |
| // setParam( new TableOfInstance() ); |
| // } |
| } |
| |
| |
| inline void makeModifiableLocalRuntime(LocalRuntime & aLocalRuntime) |
| { |
| makeWritable(); |
| |
| raw_pointer()->makeWritableLocalRuntimeStack(); |
| |
| aLocalRuntime.makeWritable(); |
| |
| raw_pointer()->setLocalRuntime( |
| aLocalRuntime.getOffset() , aLocalRuntime ); |
| } |
| |
| |
| inline RuntimeForm & getWritableRuntime(const RuntimeID & aRID) |
| { |
| makeWritable(); |
| |
| return( raw_pointer()->getWritableRuntime(aRID) ); |
| |
| } |
| |
| inline APTableOfData & getWritableRuntimeDataTable(const RuntimeID & aRID) |
| { |
| AVM_OS_ASSERT_FATAL_ERROR_EXIT( |
| raw_pointer()->getRuntime(aRID).hasDataTable() ) |
| << "Unexpected RuntimeForm without data !!!" |
| << SEND_EXIT; |
| |
| makeWritable(); |
| |
| return( raw_pointer()->getWritableRuntime(aRID).getWritableDataTable() ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mTableOfRFStateFlags |
| */ |
| |
| inline void mwsetRuntimeFormState( |
| const RuntimeID & aRID, PROCESS_EVAL_STATE aPES) |
| { |
| makeWritable(); |
| |
| raw_pointer()->mwsetRuntimeFormState(aRID.getOffset(), aPES); |
| } |
| |
| inline void mwsetRuntimeFormState(PROCESS_EVAL_STATE aPES) |
| { |
| mwsetRuntimeFormState(raw_pointer()->mRID, aPES); |
| } |
| |
| inline void mwsetRuntimeFormState(const RuntimeID & aRID, |
| PROCESS_EVAL_STATE oldPES, PROCESS_EVAL_STATE aPES) |
| { |
| makeWritable(); |
| |
| if( raw_pointer()->getRuntimeFormState(aRID) == oldPES ) |
| { |
| raw_pointer()->mwsetRuntimeFormState(aRID.getOffset(), aPES); |
| |
| raw_pointer()->setAEES( RuntimeDef::PES_to_AEES( |
| aPES, raw_pointer()->getAEES() ) ); |
| } |
| } |
| |
| |
| /** |
| * SETTER |
| * mOnSchedule |
| */ |
| inline void mwsetRuntimeFormOnSchedule( |
| const RuntimeID & aRID, const BFCode & onSchedule) |
| { |
| if( aRID.getExecutable()->isMutableSchedule() && |
| (onSchedule != raw_pointer()->getRuntime(aRID).getOnSchedule()) ) |
| { |
| makeWritable(); |
| |
| raw_pointer()->getWritableRuntime(aRID).setOnSchedule( onSchedule ); |
| } |
| } |
| |
| inline void mwsetRuntimeFormOnScheduleAndIdle(const RuntimeID & aRID) |
| { |
| mwsetRuntimeFormOnSchedule(aRID.getPRID(), aRID.getOnRunning()); |
| |
| // mwsetRuntimeFormOnSchedule(aRID.getPRID(), |
| // aRID.hasOnRunning() ? aRID.getOnRunning() : |
| // StatementConstructor::newOptiNopCode( |
| // OperatorManager::OPERATOR_RUN, aRID, |
| // AVM_ARG_MACHINE_RID) ); |
| |
| if( not raw_pointer()->isIdle() ) |
| { |
| raw_pointer()->mwsetRuntimeFormState(aRID, PROCESS_IDLE_STATE); |
| } |
| } |
| |
| |
| /** |
| * SETTER |
| * mDefer |
| */ |
| inline void mwsetRuntimeFormOnDefer( |
| const RuntimeID & aRID, const BFCode & onDefer) |
| { |
| makeWritable(); |
| |
| raw_pointer()->getWritableRuntime( aRID ).setOnDefer( onDefer ); |
| } |
| |
| |
| /* |
| * GETTER - SETTER |
| * Avm Execution Synchronization Point |
| */ |
| inline void pushExecSyncPoint( |
| ExecutionSynchronizationPoint * anExecSyncPoint) |
| { |
| makeWritable(); |
| |
| raw_pointer()->pushExecSyncPoint( anExecSyncPoint ); |
| } |
| |
| /* |
| * SETTER |
| * Avm Ending Execution Status |
| */ |
| inline void mwsetAEES(AVM_EXEC_ENDING_STATUS anAEES) |
| { |
| makeWritable(); |
| |
| raw_pointer()->setAEES( anAEES ); |
| } |
| |
| |
| /** |
| * SETTER |
| * mIOElementTrace |
| */ |
| inline void mwsetIOElementTrace(const BF & anIOElementTrace) |
| { |
| makeWritable(); |
| |
| raw_pointer()->setIOElementTrace( anIOElementTrace ); |
| } |
| |
| |
| /** |
| * SETTER |
| * mRunnableElementTrace |
| */ |
| inline void mwsetRunnableElementTrace(const BF & aRunnableElementTrace) |
| { |
| makeWritable(); |
| |
| raw_pointer()->setRunnableElementTrace(aRunnableElementTrace); |
| } |
| |
| |
| /** |
| * SETTER |
| * mRID |
| */ |
| |
| inline void mwsetRID(const RuntimeID & aRID) |
| { |
| makeWritable(); |
| raw_pointer()->setRID( aRID ); |
| } |
| |
| |
| |
| /** |
| * GETTER - SETTER |
| * mParametersRuntimeForm |
| */ |
| inline const BF & saveParameter(InstanceOfData * anInstance) |
| { |
| makeWritable(); |
| |
| return( raw_pointer()->saveParameter(anInstance) ); |
| } |
| |
| inline void appendParameters(BFList & paramList) |
| { |
| makeWritable(); |
| |
| raw_pointer()->appendParameters(paramList); |
| } |
| |
| |
| inline ParametersRuntimeForm & getWritableParametersRuntimeForm() |
| { |
| makeWritable(); |
| |
| return( raw_pointer()->getWritableParametersRuntimeForm() ); |
| } |
| |
| |
| |
| |
| /** |
| * COMPARISON |
| * OPERATOR |
| * |
| * TRIVIAL EQUALITY |
| */ |
| inline bool isTEQ(const APExecutionData & prevED) |
| { |
| return( raw_pointer()->isTEQ( prevED.raw_pointer() ) ); |
| } |
| |
| inline bool isTNEQ(const APExecutionData & prevED) |
| { |
| return( raw_pointer()->isTNEQ( prevED.raw_pointer() ) ); |
| } |
| |
| |
| /** |
| * DEFAULT NULL |
| */ |
| static APExecutionData REF_NULL; |
| |
| }; |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // TYPE DEFINITION for CONTAINER |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| typedef Collection< APExecutionData > CollectionOfAPExecutionData; |
| |
| typedef List < APExecutionData > ListOfAPExecutionData; |
| |
| typedef Vector < APExecutionData > VectorOfAPExecutionData; |
| |
| typedef Vector < ListOfAPExecutionData > VectorOfListOfAPExecutionData; |
| |
| |
| } |
| |
| #endif /*EXECUTIONDATA_H_*/ |
