| /******************************************************************************* |
| * 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 EXECUTIONCONTEXT_H_ |
| #define EXECUTIONCONTEXT_H_ |
| |
| #include <common/Element.h> |
| #include <fml/runtime/ExecutionContextFlags.h> |
| |
| #include <collection/List.h> |
| #include <collection/Vector.h> |
| |
| #include <common/BF.h> |
| |
| #include <fml/expression/ExpressionConstant.h> |
| #include <fml/expression/ExpressionConstructor.h> |
| |
| #include <fml/runtime/ExecutionData.h> |
| #include <fml/runtime/ExecutionInformation.h> |
| |
| |
| namespace sep |
| { |
| |
| class AbstractProcessorUnit; |
| class ExecutionContext; |
| class RuntimeID; |
| |
| |
| /** |
| * TYPEDEF |
| */ |
| typedef List < ExecutionContext * > ListOfExecutionContext; |
| typedef Vector< ExecutionContext * > VectorOfExecutionContext; |
| |
| typedef List < const ExecutionContext * > ListOfConstExecutionContext; |
| typedef Vector< const ExecutionContext * > VectorOfConstExecutionContext; |
| |
| |
| class ExecutionContextHeader : |
| public Element , |
| AVM_INJECT_INSTANCE_COUNTER_CLASS( ExecutionContextHeader ) |
| { |
| |
| AVM_DECLARE_CLONABLE_CLASS( ExecutionContextHeader ) |
| |
| |
| public: |
| /** |
| * ATTRIBUTES |
| * static |
| */ |
| static avm_uint32_t ID_NUMBER; |
| |
| protected: |
| /** |
| * ATTRIBUTES |
| */ |
| avm_uint32_t mIdNumber; |
| avm_uint32_t mEvalNumber; |
| |
| avm_uint32_t mHeight; |
| avm_uint32_t mWidth; |
| |
| avm_uint8_t mWeight; |
| |
| |
| |
| public: |
| /** |
| * CONSTRUCTOR |
| * Default |
| */ |
| ExecutionContextHeader() |
| : Element( CLASS_KIND_T( ExecutionContextHeader ) ), |
| mIdNumber( ID_NUMBER++ ), |
| mEvalNumber( 0 ), |
| mHeight( 0 ), |
| mWidth( 1 ), |
| mWeight( 0 ) |
| { |
| //!! NOTHING |
| } |
| |
| /** |
| * CONSTRUCTOR |
| * Copy |
| */ |
| ExecutionContextHeader(const ExecutionContextHeader & aHeader) |
| : Element( aHeader ), |
| mIdNumber( ID_NUMBER++ ), |
| mEvalNumber( aHeader.mEvalNumber ), |
| mHeight( aHeader.mHeight ), |
| mWidth( aHeader.mWidth ), |
| mWeight( 0 ) |
| { |
| //!! NOTHING |
| } |
| |
| |
| /** |
| * CONSTRUCTOR |
| * Other |
| */ |
| ExecutionContextHeader(avm_uint32_t aHeight, avm_uint32_t aWidth) |
| : Element( CLASS_KIND_T( ExecutionContextHeader ) ), |
| mIdNumber( ID_NUMBER++ ), |
| mEvalNumber( 0 ), |
| mHeight( aHeight ), |
| mWidth( aWidth ), |
| mWeight( 0 ) |
| { |
| //!! NOTHING |
| } |
| |
| |
| /** |
| * DESTRUCTOR |
| */ |
| virtual ~ExecutionContextHeader() |
| { |
| //!! NOTHING |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * ID_NUMBER |
| */ |
| inline static avm_uint32_t getCreateCounter() |
| { |
| return( ID_NUMBER ); |
| } |
| |
| inline static void setCreateCounter(avm_uint32_t aCreateCounter) |
| { |
| ID_NUMBER = aCreateCounter; |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mIdNumber |
| */ |
| inline avm_uint32_t getIdNumber() const |
| { |
| return( mIdNumber ); |
| } |
| |
| inline void setIdNumber(avm_uint32_t anIdNumber) |
| { |
| mIdNumber = anIdNumber; |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * |
| */ |
| inline avm_uint32_t getEvalNumber() const |
| { |
| return( mEvalNumber ); |
| } |
| |
| inline void setEvalNumber(avm_uint32_t anEvalNumber) |
| { |
| mEvalNumber = anEvalNumber; |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mHeight |
| */ |
| inline avm_uint32_t getHeight() const |
| { |
| return( mHeight ); |
| } |
| |
| inline void setHeight(avm_uint32_t aHeight) |
| { |
| mHeight = aHeight; |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mWidth |
| */ |
| inline avm_uint32_t getWidth() const |
| { |
| return( mWidth ); |
| } |
| |
| inline void setWidth(avm_uint32_t aWidth) |
| { |
| mWidth = aWidth; |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mWeight |
| */ |
| inline avm_uint8_t getWeight() const |
| { |
| return( mWeight ); |
| } |
| |
| inline avm_uint32_t getStrWeight() const |
| { |
| return( mWeight ); |
| } |
| |
| inline static avm_uint8_t getWeightMax() |
| { |
| return( AVM_NUMERIC_MAX_UINT8 ); |
| } |
| |
| inline bool isWeightMax() const |
| { |
| return( mWeight == AVM_NUMERIC_MAX_UINT8 ); |
| } |
| |
| inline bool isWeight(avm_uint8_t aWeight) const |
| { |
| return( mWeight == aWeight ); |
| } |
| |
| |
| inline void setWeight(avm_uint8_t aWeight) |
| { |
| mWeight = aWeight; |
| } |
| |
| |
| inline void setWeightMax() |
| { |
| mWeight = AVM_NUMERIC_MAX_UINT8; |
| } |
| |
| |
| inline void decrWeight(avm_uint8_t aWeight = 1) |
| { |
| if( mWeight != AVM_NUMERIC_MAX_UINT8 ) |
| { |
| mWeight -= aWeight; |
| } |
| } |
| |
| inline void incrWeight(avm_uint8_t aWeight = 1) |
| { |
| if( mWeight != AVM_NUMERIC_MAX_UINT8 ) |
| { |
| mWeight += aWeight; |
| } |
| } |
| |
| |
| /** |
| *************************************************************************** |
| * SERIALIZATION |
| *************************************************************************** |
| */ |
| |
| inline virtual std::string str() const |
| { |
| StringOutStream oss; |
| |
| oss << "Id:" << getIdNumber() << ", Ev:" << getEvalNumber() |
| << ", H:" << getHeight() << ", W:" << getWidth(); |
| if( getWeight() > 0 ) |
| { |
| oss << ", Q:" << getStrWeight(); |
| } |
| |
| return( oss.str() ); |
| } |
| |
| virtual void toStream(OutStream & out) const |
| { |
| out << TAB |
| << "Id:" << getIdNumber() << " , Ev:" << getEvalNumber() |
| << " , H:" << getHeight() << " , W:" << getWidth() |
| << " , Q:" << getStrWeight() |
| << EOL_FLUSH; |
| } |
| |
| }; |
| |
| |
| |
| class ExecutionContext : public Element , |
| public ExecutionContextFlagsImpl , |
| AVM_INJECT_INSTANCE_COUNTER_CLASS( ExecutionContext ) |
| { |
| |
| AVM_DECLARE_CLONABLE_CLASS( ExecutionContext ) |
| |
| public: |
| /** |
| * TRACE CONSTANT |
| */ |
| static avm_size_t EC_CHILD_TRACE_DEFAULT_SIZE; |
| |
| static avm_size_t EXECUTION_CONTEXT_CHILD_TRACE_MAX; |
| |
| /* |
| * DEFAULT NULL REFERENCE |
| */ |
| static ExecutionContext _NULL_; |
| |
| |
| protected: |
| /** |
| * TYPEDEF |
| */ |
| typedef APList < ExecutionContext * > APListOfExecutionContext; |
| |
| public: |
| typedef APListOfExecutionContext::iterator rw_child_iterator; |
| |
| typedef APListOfExecutionContext::const_iterator child_iterator; |
| |
| |
| /** |
| * ATTRIBUTES |
| */ |
| ExecutionContext * mContainer; |
| APListOfExecutionContext mChildContexts; |
| |
| BF mHeader; |
| |
| APExecutionData mExecutionData; |
| |
| BF mNodeCondition; |
| BF mNodeTimedCondition; |
| |
| BF mRunnableElementTrace; |
| BF mIOElementTrace; |
| |
| TableOfRuntimeFormState::TableOfAssignedFlag mTableOfAssignedFlag; |
| |
| BF mInformation; |
| |
| |
| public: |
| /** |
| * CONSTRUCTOR |
| * Default |
| */ |
| ExecutionContext() |
| : Element( CLASS_KIND_T( ExecutionContext ) ), |
| mContainer( NULL ), |
| mChildContexts( ), |
| mHeader(), |
| mExecutionData( ), |
| mNodeCondition( ), |
| mNodeTimedCondition( ), |
| mRunnableElementTrace( ), |
| mIOElementTrace( ), |
| mTableOfAssignedFlag( NULL ), |
| mInformation( ) |
| { |
| //!! NOTHING |
| } |
| |
| /** |
| * CONSTRUCTOR |
| * Copy |
| */ |
| ExecutionContext(const ExecutionContext & aContext) |
| : Element( aContext ), |
| mContainer( aContext.mContainer ), |
| mChildContexts( aContext.mChildContexts ), |
| |
| mHeader( aContext.mHeader ), |
| mExecutionData( aContext.mExecutionData ), |
| mNodeCondition( aContext.mNodeCondition ), |
| mNodeTimedCondition( aContext.mNodeTimedCondition ), |
| mRunnableElementTrace( aContext.mRunnableElementTrace ), |
| mIOElementTrace( aContext.mIOElementTrace ), |
| mTableOfAssignedFlag( aContext.mTableOfAssignedFlag ), |
| mInformation( aContext.mInformation ) |
| { |
| //!! NOTHING |
| } |
| |
| |
| /** |
| * CONSTRUCTOR |
| * Others |
| */ |
| ExecutionContext(APExecutionData & anExecutionData, |
| avm_uint32_t aHeight, avm_uint32_t aWidth) |
| : Element( CLASS_KIND_T( ExecutionContext ) ), |
| mContainer( NULL ), |
| mChildContexts( ), |
| |
| mHeader( new ExecutionContextHeader(aHeight , aWidth) ), |
| mExecutionData( anExecutionData ), |
| mNodeCondition( anExecutionData->getNodeCondition() ), |
| mNodeTimedCondition( anExecutionData->getNodeTimedCondition() ), |
| mRunnableElementTrace( anExecutionData->getRunnableElementTrace() ), |
| mIOElementTrace( anExecutionData->getIOElementTrace() ), |
| mTableOfAssignedFlag( anExecutionData->getTableOfAssignedFlag() ), |
| mInformation( ) |
| { |
| anExecutionData->setExecutionContext( this ); |
| } |
| |
| ExecutionContext(const ExecutionContext & aContainer, |
| APExecutionData & anExecutionData, |
| avm_uint32_t aHeight, avm_uint32_t aWidth) |
| : Element( CLASS_KIND_T( ExecutionContext ) ), |
| mContainer( const_cast< ExecutionContext * >(& aContainer) ), |
| mChildContexts( ), |
| |
| mHeader( new ExecutionContextHeader(aHeight , aWidth) ), |
| mExecutionData( anExecutionData ), |
| mNodeCondition( anExecutionData->getNodeCondition() ), |
| mNodeTimedCondition( anExecutionData->getNodeTimedCondition() ), |
| mRunnableElementTrace( anExecutionData->getRunnableElementTrace() ), |
| mIOElementTrace( anExecutionData->getIOElementTrace() ), |
| mTableOfAssignedFlag( anExecutionData->getTableOfAssignedFlag() ), |
| mInformation( ) |
| { |
| anExecutionData->setExecutionContext( this ); |
| } |
| |
| |
| /** |
| * DESTRUCTOR |
| */ |
| virtual ~ExecutionContext() |
| { |
| if( hasContainer() ) |
| { |
| //getContainer()->remove(this); |
| } |
| } |
| |
| inline void destroy() |
| { |
| mChildContexts.clear(); |
| |
| mHeader.destroy(); |
| |
| mExecutionData.destroy(); |
| |
| mNodeCondition.destroy(); |
| mNodeTimedCondition.destroy(); |
| |
| mRunnableElementTrace.destroy(); |
| mIOElementTrace.destroy(); |
| |
| mInformation.destroy(); |
| } |
| |
| /** |
| * _NULL_ |
| */ |
| inline bool isNull() const |
| { |
| return( this == (& ExecutionContext::_NULL_) ); |
| } |
| |
| inline bool isnotNull() const |
| { |
| return( this != (& ExecutionContext::_NULL_) ); |
| } |
| |
| /** |
| * cast to reference |
| */ |
| inline static const ExecutionContext & REF(const ExecutionContext * anEC) |
| { |
| return( ( anEC != NULL ) ? (* anEC) : ExecutionContext::_NULL_ ); |
| } |
| |
| /** |
| * GETTER - SETTER |
| * mContainer |
| */ |
| inline ExecutionContext * getContainer() const |
| { |
| return( mContainer ); |
| } |
| |
| inline const ExecutionContext & refContainer() const |
| { |
| return( * mContainer ); |
| } |
| |
| |
| inline bool hasContainer() const |
| { |
| return( mContainer != NULL ); |
| } |
| |
| inline void setContainer(ExecutionContext * anEC) |
| { |
| mContainer = anEC; |
| } |
| |
| |
| /** |
| * CLONE |
| */ |
| inline virtual ExecutionContext * cloneData() const |
| { |
| ExecutionContext * mCloneEC = new ExecutionContext( *this ); |
| mCloneEC->getAPExecutionData().makeWritable(); |
| |
| return( mCloneEC ); |
| } |
| |
| |
| /** |
| * INITIALIZATION with EXECUTION DATA / CONTEXT |
| */ |
| inline void initialize(const ExecutionContext & anInitialContext) |
| { |
| mContainer = anInitialContext.mContainer; |
| mChildContexts = anInitialContext.mChildContexts; |
| |
| mHeader = anInitialContext.mHeader; |
| mExecutionData = anInitialContext.mExecutionData; |
| |
| mNodeCondition = anInitialContext.mNodeCondition; |
| mNodeTimedCondition = anInitialContext.mNodeTimedCondition; |
| |
| mRunnableElementTrace = anInitialContext.mRunnableElementTrace; |
| mIOElementTrace = anInitialContext.mIOElementTrace; |
| |
| mTableOfAssignedFlag = anInitialContext.mTableOfAssignedFlag; |
| |
| mInformation = anInitialContext.mInformation; |
| } |
| |
| inline void initialize(const APExecutionData & anInitialData, |
| avm_uint32_t aHeight = 0, avm_uint32_t aWidth = 1) |
| { |
| mContainer = NULL; |
| |
| mHeader = new ExecutionContextHeader(aHeight, aWidth); |
| mExecutionData = anInitialData; |
| |
| if( anInitialData.valid() ) |
| { |
| mNodeCondition = anInitialData->getNodeCondition(); |
| mNodeTimedCondition = anInitialData->getNodeTimedCondition(); |
| |
| mRunnableElementTrace = anInitialData->getRunnableElementTrace(); |
| mIOElementTrace = anInitialData->getIOElementTrace(); |
| |
| mTableOfAssignedFlag = anInitialData->getTableOfAssignedFlag(); |
| } |
| } |
| |
| |
| /** |
| * RESET DATA BEFORE EVALUATION |
| */ |
| inline void resetDataBeforeEvaluation() |
| { |
| mExecutionData->setNodeCondition( ExpressionConstant::BOOLEAN_TRUE ); |
| mExecutionData->setNodeTimedCondition( ExpressionConstant::BOOLEAN_TRUE ); |
| |
| mExecutionData->setRunnableElementTrace( BF::REF_NULL ); |
| mExecutionData->setIOElementTrace( BF::REF_NULL ); |
| |
| // Due to basic pointer, not smart pointer |
| mTableOfAssignedFlag = mExecutionData->getTableOfAssignedFlag(); |
| mExecutionData->setTableOfAssignedFlag( NULL ); |
| } |
| |
| |
| /** |
| * RESTORE DATA AFTER EVALUATION |
| */ |
| inline void restoreDataAfterEvaluation() |
| { |
| mExecutionData->setNodeCondition( mNodeCondition ); |
| mExecutionData->setNodeTimedCondition( mNodeTimedCondition ); |
| |
| mExecutionData->setRunnableElementTrace( mRunnableElementTrace ); |
| mExecutionData->setIOElementTrace( mIOElementTrace ); |
| |
| mExecutionData->setTableOfAssignedFlag( mTableOfAssignedFlag ); |
| } |
| |
| |
| |
| /** |
| * GETTER |
| * mChildContexts |
| * Iterators |
| */ |
| inline rw_child_iterator begin() |
| { |
| return( mChildContexts.begin() ); |
| } |
| |
| inline rw_child_iterator end() |
| { |
| return( mChildContexts.end() ); |
| } |
| |
| inline rw_child_iterator eraseChildContext( |
| const rw_child_iterator & itChildCtx) |
| { |
| return( mChildContexts.erase( itChildCtx ) ); |
| } |
| |
| |
| inline child_iterator begin() const |
| { |
| return( mChildContexts.begin() ); |
| } |
| |
| inline child_iterator end() const |
| { |
| return( mChildContexts.end() ); |
| } |
| |
| |
| /** |
| * GETTER |
| * mChildContexts |
| */ |
| inline ExecutionContext * firstChildContext() const |
| { |
| return( mChildContexts.first() ); |
| } |
| |
| inline ExecutionContext * lastChildContext() const |
| { |
| return( mChildContexts.last() ); |
| } |
| |
| |
| inline bool hasChildContext() const |
| { |
| return( mChildContexts.nonempty() ); |
| } |
| |
| inline bool noChildContext() const |
| { |
| return( mChildContexts.empty() ); |
| } |
| |
| inline bool populatedChildContext() const |
| { |
| return( mChildContexts.populated() ); |
| } |
| |
| inline bool singleChildContext() const |
| { |
| return( mChildContexts.singleton() ); |
| } |
| |
| |
| inline bool isLeafNode() const |
| { |
| return( mChildContexts.empty() ); |
| } |
| |
| inline avm_size_t size() const |
| { |
| return( mChildContexts.size() ); |
| } |
| |
| |
| /** |
| * SETTER |
| * mChildContexts |
| */ |
| inline void appendChildContext(ExecutionContext * anEC) |
| { |
| mChildContexts.append( anEC ); |
| } |
| |
| inline void clearChildContext() |
| { |
| mChildContexts.clear(); |
| } |
| |
| inline void popLastChildContextTo(ExecutionContext * & anEC) |
| { |
| mChildContexts.pop_last_to( anEC ); |
| } |
| |
| inline void removeChildContext(ExecutionContext * anEC) |
| { |
| mChildContexts.remove( anEC ); |
| } |
| |
| |
| |
| inline APListOfExecutionContext & getNext() |
| { |
| return( mChildContexts ); |
| } |
| |
| inline bool hasNext() const |
| { |
| return( mChildContexts.nonempty() ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mHeader |
| */ |
| inline const BF & getHeader() const |
| { |
| return( mHeader ); |
| } |
| |
| inline ExecutionContextHeader * rawHeader() const |
| { |
| return( mHeader.to_ptr< ExecutionContextHeader >() ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * Container |
| */ |
| inline bool isRoot() const |
| { |
| return( not hasContainer() ); |
| } |
| |
| inline bool isnotRoot() const |
| { |
| return( hasContainer() ); |
| } |
| |
| |
| inline ExecutionContext * getPrevious() const |
| { |
| return( getContainer() ); |
| } |
| |
| |
| inline APExecutionData & getPreviousExecutionData() |
| { |
| return( getContainer()->getAPExecutionData() ); |
| } |
| |
| inline const APExecutionData & getPreviousExecutionData() const |
| { |
| return( getContainer()->getAPExecutionData() ); |
| } |
| |
| inline bool hasPrevious() const |
| { |
| return( hasContainer() ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mHeader trace indices |
| */ |
| inline static avm_uint32_t getCreateCounter() |
| { |
| return( ExecutionContextHeader::ID_NUMBER ); |
| } |
| |
| inline avm_uint32_t getIdNumber() const |
| { |
| return( rawHeader()->getIdNumber() ); |
| } |
| |
| |
| inline avm_uint32_t getEvalNumber() const |
| { |
| return( rawHeader()->getEvalNumber() ); |
| } |
| |
| inline bool isEvaluated() const |
| { |
| return( rawHeader()->getEvalNumber() > 0 ); |
| } |
| |
| inline void setEvalNumber(avm_uint32_t anEvalNumber) |
| { |
| rawHeader()->setEvalNumber(anEvalNumber); |
| } |
| |
| |
| inline avm_uint32_t getHeight() const |
| { |
| return( rawHeader()->getHeight() ); |
| } |
| |
| inline void setHeight(avm_uint32_t aHeight) |
| { |
| rawHeader()->setHeight(aHeight); |
| } |
| |
| |
| inline avm_uint32_t getWidth() const |
| { |
| return( rawHeader()->getWidth() ); |
| } |
| |
| inline void setWidth(avm_uint32_t aWidth) |
| { |
| rawHeader()->setWidth(aWidth); |
| } |
| |
| |
| inline avm_uint8_t getWeight() const |
| { |
| return( rawHeader()->getWeight() ); |
| } |
| |
| inline avm_uint32_t getStrWeight() const |
| { |
| return( rawHeader()->getStrWeight() ); |
| } |
| |
| inline static avm_uint8_t getWeightMax() |
| { |
| return( ExecutionContextHeader::getWeightMax() ); |
| } |
| |
| inline bool isWeightMax() const |
| { |
| return( rawHeader()->isWeightMax() ); |
| } |
| |
| inline bool isWeight(avm_uint8_t aWeight) const |
| { |
| return( rawHeader()->isWeight(aWeight) ); |
| } |
| |
| |
| inline void setWeight(avm_uint8_t aWeight) |
| { |
| rawHeader()->setWeight(aWeight); |
| } |
| |
| inline void setWeightMax() |
| { |
| rawHeader()->setWeightMax(); |
| } |
| |
| |
| inline avm_uint32_t getPrevEvalNumber() const |
| { |
| return( isRoot() ? 0 : getContainer()->getEvalNumber() ); |
| } |
| |
| inline avm_uint32_t getPrevHeight() const |
| { |
| return( isRoot() ? 0 : getContainer()->getHeight() ); |
| } |
| |
| inline avm_uint32_t getPrevIdNumber() const |
| { |
| return( isRoot() ? 0 : getContainer()->getIdNumber() ); |
| } |
| |
| inline avm_uint32_t getPrevWidth() const |
| { |
| return( isRoot() ? 0 : getContainer()->getWidth() ); |
| } |
| |
| inline avm_uint8_t getPrevsWeight() const |
| { |
| return( isRoot() ? 0 : getContainer()->getWeight() ); |
| } |
| |
| |
| /** |
| * LCA -LCRA |
| */ |
| const ExecutionContext * LCA(const ExecutionContext * anEC) const ; |
| |
| /** |
| * GETTER - SETTER |
| * mExecutionData |
| */ |
| inline APExecutionData & getAPExecutionData() |
| { |
| return( mExecutionData ); |
| } |
| |
| inline const APExecutionData & getAPExecutionData() const |
| { |
| return( mExecutionData ); |
| } |
| |
| inline ExecutionData * getExecutionData() const |
| { |
| return( mExecutionData ); |
| } |
| |
| inline const ExecutionData & refExecutionData() const |
| { |
| return( * mExecutionData ); |
| } |
| |
| inline ExecutionData & rwExecutionData() const |
| { |
| return( * mExecutionData ); |
| } |
| |
| |
| inline bool hasExecutionData() const |
| { |
| return( mExecutionData.valid() ); |
| } |
| |
| inline void setExecutionData(const APExecutionData & anExecutionData) |
| { |
| mExecutionData = anExecutionData; |
| } |
| |
| inline void makeWritableExecutionData() |
| { |
| mExecutionData.makeWritable(); |
| } |
| |
| |
| |
| /** |
| * 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 |
| * tableOfRuntimeFormState |
| */ |
| |
| bool checkRunningForm(const RuntimeID & aRID) |
| { |
| return( getAPExecutionData()->checkRunningForm( |
| getRunnableElementTrace(), aRID) ); |
| } |
| |
| |
| /** |
| * GETTER |
| * mTableOfAssignedFlag |
| */ |
| TableOfRuntimeFormState::TableOfAssignedFlag getTableOfAssignedFlag() const |
| { |
| return( mTableOfAssignedFlag ); |
| } |
| |
| void setTableOfAssignedFlag( |
| TableOfRuntimeFormState::TableOfAssignedFlag aTableOfAssignedFlag) |
| { |
| mTableOfAssignedFlag = aTableOfAssignedFlag; |
| } |
| |
| |
| |
| /** |
| * GETTER |
| * mNodeCondition && mNodeTimedCondition |
| */ |
| inline BF getAllNodeCondition() const |
| { |
| return( ExpressionConstructor::andExpr( |
| mNodeCondition, mNodeTimedCondition) ); |
| } |
| |
| |
| /** |
| * GETTER - SETTER |
| * mNodeCondition |
| */ |
| inline BF & getNodeCondition() |
| { |
| return( 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 BF & getNodeTimedCondition() |
| { |
| return( 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 |
| * 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 - SETTER - TESTER |
| * mInformation |
| */ |
| inline void addInfo( |
| const AbstractProcessorUnit & aProcessor, const BF & aData) |
| { |
| getUniqInformation()->addInfo(aProcessor, aData); |
| } |
| |
| inline void addInfo(const AbstractProcessorUnit & aProcessor, |
| const BF & anID, const BF & aData) |
| { |
| getUniqInformation()->addInfo(aProcessor, anID, aData); |
| } |
| |
| inline static void addInfo(ListOfExecutionContext & listOfEC, |
| const AbstractProcessorUnit & aProcessor, const BF & aData) |
| { |
| ListOfExecutionContext::iterator it = listOfEC.begin(); |
| ListOfExecutionContext::iterator itEnd = listOfEC.end(); |
| for( ; it != itEnd ; ++it ) |
| { |
| (*it)->addInfo(aProcessor,aData); |
| } |
| } |
| |
| inline GenericInfoData * getInfo( |
| const AbstractProcessorUnit & aProcessor, const BF & anID) const |
| { |
| return( mInformation.invalid() ? NULL : |
| mInformation.to_ptr< ExecutionInformation >()-> |
| getInfo(aProcessor, anID) ); |
| } |
| |
| |
| inline const BF & getInfoData( |
| const IProcessorUnitRegistration & aRegisterTool) const |
| { |
| return( mInformation.invalid() ? BF::REF_NULL : |
| mInformation.to_ptr< ExecutionInformation >()-> |
| getInfoData(aRegisterTool) ); |
| } |
| |
| inline const BF & getInfoData(const AbstractProcessorUnit & aProcessor) const |
| { |
| return( mInformation.invalid() ? BF::REF_NULL : |
| mInformation.to_ptr< ExecutionInformation >()-> |
| getInfoData(aProcessor) ); |
| } |
| |
| inline const BF & getInfoData( |
| const AbstractProcessorUnit & aProcessor, const BF & anID) const |
| { |
| return( mInformation.invalid() ? BF::REF_NULL : |
| mInformation.to_ptr< ExecutionInformation >()-> |
| getInfoData(aProcessor, anID) ); |
| } |
| |
| |
| inline const BFList & getInfos() const |
| { |
| AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( mInformation ) |
| << "Execution Information !!!" |
| << SEND_EXIT; |
| |
| return( getInformation()->getInfos() ); |
| } |
| |
| inline bool hasInfo() const |
| { |
| return( mInformation.valid() && |
| mInformation.to_ptr< ExecutionInformation >()->hasInfo() ); |
| } |
| |
| inline bool hasInfo(const AbstractProcessorUnit & aProcessor) const |
| { |
| return( mInformation.valid() && mInformation.to_ptr< |
| ExecutionInformation >()->hasInfo(aProcessor) ); |
| } |
| |
| inline bool noneInfo(const AbstractProcessorUnit & aProcessor) const |
| { |
| return( mInformation.invalid() || mInformation.to_ptr< |
| ExecutionInformation >()->noneInfo(aProcessor) ); |
| } |
| |
| inline bool hasInfo( |
| const AbstractProcessorUnit & aProcessor, const BF & anID) const |
| { |
| return( mInformation.valid() && mInformation.to_ptr< |
| ExecutionInformation >()-> hasInfo(aProcessor, anID) ); |
| } |
| |
| |
| inline bool hasInfoWithData( |
| const AbstractProcessorUnit & aProcessor, const BF & aData) const |
| { |
| return( mInformation.valid() && mInformation.to_ptr< |
| ExecutionInformation >()->hasInfoWithData(aProcessor, aData) ); |
| } |
| |
| inline bool hasInfo(const BF & anID) const |
| { |
| return( mInformation.valid() && |
| mInformation.to_ptr< ExecutionInformation >()->hasInfo(anID) ); |
| } |
| |
| inline bool hasInfo(Element * anID) const |
| { |
| return( mInformation.valid() && |
| mInformation.to_ptr< ExecutionInformation >()->hasInfo(anID) ); |
| } |
| |
| |
| inline ExecutionInformation * getUniqInformation() |
| { |
| if( not hasInformation() ) |
| { |
| mInformation.setPointer( new ExecutionInformation() ); |
| } |
| return( mInformation.to_ptr< ExecutionInformation >() ); |
| } |
| |
| inline ExecutionInformation * getInformation() const |
| { |
| return( mInformation.to_ptr< ExecutionInformation >() ); |
| } |
| |
| inline bool hasInformation() const |
| { |
| return( mInformation.valid() ); |
| } |
| |
| inline void setInformation(ExecutionInformation * anInformation) |
| { |
| mInformation.setPointer( anInformation ); |
| } |
| |
| |
| /** |
| * Serialization |
| */ |
| void toDebug(OutStream & out) const; |
| |
| void toDebugFet(OutStream & out) const; |
| |
| |
| template< class OS_T > |
| OS_T & osStrPosition(OS_T & out) const |
| { |
| out << "Id:" /*<< std::setw(4)*/ << getIdNumber(); |
| |
| out << " PE:"; |
| if ( hasContainer() ) |
| { |
| out /*<< std::setw(4)*/ << getContainer()->getEvalNumber(); |
| } |
| else |
| { |
| out << "ROOT"; |
| } |
| |
| out << " H:" /*<< std::setw(4)*/ << getHeight() |
| << " W:" /*<< std::setw(4)*/ << getWidth() |
| << " Q:" /*<< std::setw(2)*/ << getStrWeight(); |
| |
| return( out ); |
| } |
| |
| |
| inline virtual std::string str() const |
| { |
| return( osStrPosition( OSS() << "EC< " ) << " > " |
| << refExecutionData().strStateConf() ); |
| } |
| |
| virtual void toStream(OutStream & out) const; |
| |
| virtual void toFscn(OutStream & out, |
| const ExecutionData * aPreviousExecData) const; |
| |
| std::string str_min() const; |
| std::string str_position() const; |
| |
| void traceMinimum(OutStream & out) const; |
| void traceDefault(OutStream & out) const; |
| void debugDefault(OutStream & out) const; |
| |
| |
| static void traceMinimum(OutStream & out, |
| ListOfExecutionContext & listofEC, const std::string & header = ""); |
| |
| static void traceMinimum(OutStream & out, |
| VectorOfExecutionContext & listofEC, const std::string & header = ""); |
| |
| |
| static void traceDefault(OutStream & out, |
| ListOfExecutionContext & listofEC, const std::string & header = ""); |
| |
| static void traceDefault(OutStream & out, |
| VectorOfExecutionContext & listofEC, const std::string & header = ""); |
| |
| static void debugDefault(OutStream & out, |
| ListOfExecutionContext & listofEC, const std::string & header = ""); |
| |
| static void debugDefault(OutStream & out, |
| VectorOfExecutionContext & listofEC, const std::string & header = ""); |
| |
| |
| void writeTraceAfterExec(OutStream & out) const; |
| void traceDefaultPostEval(OutStream & out) const; |
| |
| inline void traceDefaultEval(OutStream & out) const |
| { |
| traceDefault(out); |
| if( hasNext() ) |
| { |
| traceDefaultPostEval(out); |
| } |
| } |
| |
| |
| void writeTraceBeforeExec(OutStream & out) const; |
| |
| void writeTraceForDeadlock(OutStream & out, |
| avm_uint32_t nDeadlockCounter) const; |
| |
| void writeTraceForRedundancy(OutStream & out, |
| ExecutionContext * aRedundantExecContext, |
| avm_uint32_t nRedundancyCounter) const; |
| |
| }; |
| |
| |
| } /* namespace sep */ |
| |
| #endif /*EXECUTIONCONTEXT_H_*/ |
