| /******************************************************************************* |
| * 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 |
| * |
| * Created on: 28 nov. 2011 |
| * |
| * Contributors: |
| * Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr |
| * - Initial API and implementation |
| ******************************************************************************/ |
| |
| #ifndef SEW_SYMBEX_CONTROLLER_UNIT_MANAGER_H_ |
| #define SEW_SYMBEX_CONTROLLER_UNIT_MANAGER_H_ |
| |
| #include <fam/api/AbstractProcessorUnit.h> |
| |
| #include <collection/Typedef.h> |
| |
| #include <fam/api/CompositeControllerUnit.h> |
| #include <fam/api/MainProcessorUnit.h> |
| #include <fam/api/ProcessorUnitAutoRegistration.h> |
| |
| #include <fam/queue/ExecutionQueue.h> |
| |
| #include <fam/redundancy/RedundancyFilter.h> |
| |
| |
| namespace sep |
| { |
| |
| |
| class AvmPrimitiveProcessor; |
| class Builder; |
| class Configuration; |
| class SymbexEngine; |
| class WObject; |
| |
| |
| class SymbexControllerUnitManager : public RunnableElement |
| { |
| |
| AVM_DECLARE_CLONABLE_CLASS( SymbexControllerUnitManager ) |
| |
| protected: |
| /** |
| * TYPEDEF |
| */ |
| typedef List< AbstractProcessorUnit * > ListOfControllerUnits; |
| |
| public: |
| typedef ListOfControllerUnits::iterator rw_controller_iterator; |
| typedef ListOfControllerUnits::const_iterator controller_iterator; |
| |
| |
| protected: |
| /** |
| * ATTRIBUTE |
| */ |
| SymbexEngine & mSymbexEngine; |
| |
| bool mAutoConfigure; |
| bool mAutoStart; |
| |
| ExecutionQueue mQueueProcessor; |
| |
| MainProcessorUnit mMainProcessor; |
| |
| RedundancyFilter mRedundancyProcessor; |
| |
| CompositeControllerUnit mControllerUnits; |
| |
| CompositeControllerUnit mPreprocessorControllerUnits; |
| CompositeControllerUnit mPostprocessorControllerUnits; |
| |
| CompositeControllerUnit mPrefilterControllerUnits; |
| CompositeControllerUnit mPostfilterControllerUnits; |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // Computing Variables |
| rw_controller_iterator processorIt; |
| rw_controller_iterator processorItEnd; |
| |
| |
| public: |
| |
| /** |
| * CONSTRUCTOR |
| * Default |
| */ |
| SymbexControllerUnitManager( |
| SymbexEngine & anEngine, WObject * wfParameterObject) |
| : RunnableElement( |
| CLASS_KIND_T( SymbexControllerUnitManager ), wfParameterObject), |
| |
| mSymbexEngine( anEngine ), |
| |
| mAutoConfigure( false ), |
| mAutoStart( false ), |
| |
| mQueueProcessor( *this ), |
| mMainProcessor( *this ), |
| mRedundancyProcessor( *this ), |
| |
| mControllerUnits( *this ), |
| |
| mPreprocessorControllerUnits( *this ), |
| mPostprocessorControllerUnits( *this ), |
| |
| mPrefilterControllerUnits( *this ), |
| mPostfilterControllerUnits( *this ), |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // Computing Variables |
| processorIt( ), |
| processorItEnd( ) |
| { |
| //!! NOTHING |
| } |
| |
| |
| /** |
| * DESTRUCTOR |
| */ |
| virtual ~SymbexControllerUnitManager() |
| { |
| AbstractProcessorUnit * itProcessor = NULL; |
| |
| while( mControllerUnits.nonempty() ) |
| { |
| itProcessor = mControllerUnits.pop_last(); |
| |
| // Don't delete << mMainProcessor | mQueueProcessor >> |
| if( (itProcessor != (& mMainProcessor )) |
| && (itProcessor != (& mQueueProcessor)) |
| && (itProcessor != (& mRedundancyProcessor)) ) |
| { |
| delete( itProcessor ); |
| } |
| } |
| } |
| |
| |
| inline virtual void append(AbstractProcessorUnit * aProcessor) |
| { |
| AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( aProcessor ) |
| << "Processor Unit !!!" |
| << SEND_EXIT; |
| |
| //!![MIGRATION] |
| // AVM_OS_ASSERT_WARNING_ALERT( aProcessor != (& mMainProcessor) ) |
| // << "Unexpected MainProcessor !!!" |
| // << SEND_ALERT; |
| // AVM_OS_ASSERT_WARNING_ALERT( aProcessor != (& mQueueProcessor) ) |
| // << "Unexpected QueueProcessor !!!" |
| // << SEND_ALERT; |
| // AVM_OS_ASSERT_WARNING_ALERT( aProcessor != (& mRedundancyProcessor) ) |
| // << "Unexpected QueueProcessor !!!" |
| // << SEND_ALERT; |
| |
| // Don't append << mMainProcessor | mQueueProcessor >> |
| if( (aProcessor != (& mMainProcessor)) |
| && (aProcessor != (& mQueueProcessor)) |
| && (aProcessor != (& mRedundancyProcessor)) ) |
| { |
| mControllerUnits.append( aProcessor ); |
| } |
| } |
| |
| /** |
| * GETTER |
| * mSymbexEngine |
| * Configuration |
| */ |
| inline SymbexEngine & getSymbexEngine() |
| { |
| return( mSymbexEngine ); |
| } |
| |
| inline const SymbexEngine & getSymbexEngine() const |
| { |
| return( mSymbexEngine ); |
| } |
| |
| /** |
| * GETTER |
| * Configuration |
| */ |
| Configuration & getConfiguration() const; |
| |
| /** |
| * GETTER |
| * Builder |
| */ |
| Builder & getBuilder(); |
| |
| /** |
| * GETTER |
| * AvmPrimitiveProcessor |
| */ |
| AvmPrimitiveProcessor & getPrimitiveProcessor(); |
| |
| |
| /** |
| * GETTER |
| * mAutoConfigure |
| * mAutoStart |
| */ |
| inline bool isAutoConfigure() const |
| { |
| return( mAutoConfigure ); |
| } |
| |
| inline bool isAutoStart() const |
| { |
| return( mAutoStart ); |
| } |
| |
| |
| /** |
| * GETTER |
| * mExecutionQueue |
| */ |
| inline ExecutionQueue & getExecutionQueue() |
| { |
| return( mQueueProcessor ); |
| } |
| |
| |
| /** |
| * GETTER |
| * mMainProcessor |
| */ |
| inline MainProcessorUnit & getMainProcessor() |
| { |
| return( mMainProcessor ); |
| } |
| |
| inline const MainProcessorUnit & getMainProcessor() const |
| { |
| return( mMainProcessor ); |
| } |
| |
| /** |
| * GETTER |
| * mRedundancyProcessor |
| */ |
| inline RedundancyFilter & getRedundancyProcessor() |
| { |
| return( mRedundancyProcessor ); |
| } |
| |
| |
| /** |
| * GETTER |
| * mControllerUnits |
| */ |
| inline CompositeControllerUnit & getControllerUnits() |
| { |
| return( mControllerUnits ); |
| } |
| |
| /** |
| * GETTER |
| * mControllerUnits |
| * by parameter WObject / FullyQualifiedNameID |
| */ |
| inline AbstractProcessorUnit * getControllerUnit( |
| const IProcessorUnitRegistration & aRegisterTool) |
| { |
| if( mMainProcessor.isRegisterTool( aRegisterTool ) ) |
| { |
| return( & mMainProcessor ); |
| } |
| else if( mQueueProcessor.isRegisterTool( aRegisterTool ) ) |
| { |
| return( & mQueueProcessor ); |
| } |
| else if( mRedundancyProcessor.isRegisterTool( aRegisterTool ) ) |
| { |
| return( & mRedundancyProcessor ); |
| } |
| else |
| { |
| return( mControllerUnits.getControllerUnit( aRegisterTool ) ); |
| } |
| } |
| |
| inline AbstractProcessorUnit * getControllerUnit( |
| WObject * wfProcessorObject) |
| { |
| if( mMainProcessor.getParameterWObject() == wfProcessorObject ) |
| { |
| return( & mMainProcessor ); |
| } |
| else if( mQueueProcessor.getParameterWObject() == wfProcessorObject ) |
| { |
| return( & mQueueProcessor ); |
| } |
| else if( mRedundancyProcessor.getParameterWObject() == wfProcessorObject ) |
| { |
| return( & mRedundancyProcessor ); |
| } |
| else |
| { |
| return( mControllerUnits.getControllerUnit( wfProcessorObject ) ); |
| } |
| } |
| |
| inline AbstractProcessorUnit * getControllerUnit( |
| const std::string & aFullyQualifiedNameID) |
| { |
| if( mMainProcessor.getParameterWObject() |
| ->fqnEquals( aFullyQualifiedNameID ) ) |
| { |
| return( & mMainProcessor ); |
| } |
| else if( mQueueProcessor.getParameterWObject() |
| ->fqnEquals( aFullyQualifiedNameID ) ) |
| { |
| return( & mQueueProcessor ); |
| } |
| else if( mRedundancyProcessor.getParameterWObject() |
| ->fqnEquals( aFullyQualifiedNameID ) ) |
| { |
| return( & mRedundancyProcessor ); |
| } |
| else |
| { |
| return( mControllerUnits.getControllerUnit( aFullyQualifiedNameID ) ); |
| } |
| } |
| |
| |
| /** |
| * GETTER |
| * mPreprocessor |
| * mPreprocessorControllerUnits |
| */ |
| inline CompositeControllerUnit & getPreprocessor() |
| { |
| return( mPreprocessorControllerUnits ); |
| } |
| |
| inline void addPreprocessor(AbstractProcessorUnit * aFAM) |
| { |
| mPreprocessorControllerUnits.addControllerUnit( aFAM ); |
| } |
| |
| inline void appendPreprocessor(AbstractProcessorUnit * aFAM) |
| { |
| mPreprocessorControllerUnits.appendControllerUnit( aFAM ); |
| } |
| |
| inline bool registerPreprocessor(AbstractProcessorUnit * aFAM) |
| { |
| return( mPreprocessorControllerUnits.registerPreprocessor( aFAM ) ); |
| } |
| |
| |
| /** |
| * GETTER |
| * mPostprocessor |
| * mPostprocessorControllerUnits |
| */ |
| inline CompositeControllerUnit & getPostprocessor() |
| { |
| return( mPostprocessorControllerUnits ); |
| } |
| |
| inline void addPostprocessor(AbstractProcessorUnit * aFAM) |
| { |
| mPostprocessorControllerUnits.addControllerUnit( aFAM ); |
| } |
| |
| inline void appendPostprocessor(AbstractProcessorUnit * aFAM) |
| { |
| mPostprocessorControllerUnits.appendControllerUnit( aFAM ); |
| } |
| |
| inline bool registerPostprocessor(AbstractProcessorUnit * aFAM) |
| { |
| return( mPostprocessorControllerUnits.registerPostprocessor( aFAM ) ); |
| } |
| |
| |
| /** |
| * GETTER |
| * mPrefilter |
| * mPrefilterControllerUnits |
| */ |
| inline CompositeControllerUnit & getPrefilter() |
| { |
| return( mPrefilterControllerUnits ); |
| } |
| |
| inline void addPrefilter(AbstractProcessorUnit * aFAM) |
| { |
| mPrefilterControllerUnits.addControllerUnit( aFAM ); |
| } |
| |
| inline void appendPrefilter(AbstractProcessorUnit * aFAM) |
| { |
| mPrefilterControllerUnits.appendControllerUnit( aFAM ); |
| } |
| |
| inline bool registerPrefilter(AbstractProcessorUnit * aFAM) |
| { |
| return( mPrefilterControllerUnits.registerPrefilter( aFAM ) ); |
| } |
| |
| |
| /** |
| * GETTER |
| * mPostfilter |
| * mPostfilterControllerUnits |
| */ |
| inline CompositeControllerUnit & getPostfilter() |
| { |
| return( mPostfilterControllerUnits ); |
| } |
| |
| inline void addPostfilter(AbstractProcessorUnit * aFAM) |
| { |
| mPostfilterControllerUnits.addControllerUnit( aFAM ); |
| } |
| |
| inline void appendPostfilter(AbstractProcessorUnit * aFAM) |
| { |
| mPostfilterControllerUnits.appendControllerUnit( aFAM ); |
| } |
| |
| inline bool registerPostfilter(AbstractProcessorUnit * aFAM) |
| { |
| return( mPostfilterControllerUnits.registerPostfilter( aFAM ) ); |
| } |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // CONFIGURE API |
| //////////////////////////////////////////////////////////////////////////// |
| |
| virtual bool preConfigure(); |
| |
| virtual bool configure(); |
| |
| virtual bool configureImpl() |
| { |
| return( true ); |
| } |
| |
| inline bool configureControllerUnits() |
| { |
| return( mControllerUnits.configureControllerUnits() ); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // INIT / EXIT API |
| //////////////////////////////////////////////////////////////////////////// |
| virtual bool initImpl(); |
| |
| virtual bool exitImpl(); |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // ( PRE / POST ) PROCESS API |
| //////////////////////////////////////////////////////////////////////////// |
| |
| virtual bool preprocess(); |
| |
| virtual bool postprocess(); |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // FILTERING API |
| //////////////////////////////////////////////////////////////////////////// |
| |
| virtual bool filteringInitialize(); |
| |
| virtual bool filteringFinalize(); |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // ( PRE / POST ) FILTER API |
| //////////////////////////////////////////////////////////////////////////// |
| |
| virtual bool prefilter(); |
| |
| bool finalizePrefiltering(); |
| |
| |
| virtual bool postfilter(); |
| |
| bool finalizePostfiltering(); |
| |
| |
| /** |
| * Has Work |
| */ |
| inline bool hasWork() const |
| { |
| return( mQueueProcessor.hasWork() ); |
| } |
| |
| inline bool hasReadyWork() const |
| { |
| return( mQueueProcessor.hasReadyWork() ); |
| } |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // PROCESSOR REQUEST API |
| //////////////////////////////////////////////////////////////////////////// |
| /** |
| * REQUEST_STOP_STATUS |
| */ |
| inline virtual void handleRequestStop() |
| { |
| mQueueProcessor.handleRequestStop(); |
| } |
| |
| /** |
| * REQUEST_RELEASE_STATUS |
| */ |
| inline virtual void handleRequestRelease() |
| { |
| mQueueProcessor.handleRequestRelease(); |
| } |
| |
| inline void handleRequestRelease(AbstractProcessorUnit * aRequestor) |
| { |
| mPrefilterControllerUnits.handleRequestRelease(aRequestor); |
| |
| mPostfilterControllerUnits.handleRequestRelease(aRequestor); |
| |
| aRequestor->handleRequestRelease(); |
| } |
| |
| /** |
| * REQUEST_RESET_STATUS |
| */ |
| inline virtual void handleRequestReset() |
| { |
| mQueueProcessor.handleRequestReset(); |
| } |
| |
| /** |
| * REQUEST_RESTART_STATUS |
| */ |
| inline virtual void handleRequestRestart() |
| { |
| mQueueProcessor.handleRequestRestart(); |
| } |
| |
| /** |
| * REQUEST_CONTINUE_STATUS |
| */ |
| inline virtual void handleRequestContinue() |
| { |
| mQueueProcessor.handleRequestContinue(); |
| } |
| |
| /** |
| * REQUEST_REQUEUE_WAITING_STATUS |
| */ |
| inline virtual void handleRequestRequeueWaiting( |
| AbstractProcessorUnit * aRequestor) |
| { |
| mQueueProcessor.handleRequestRequeueWaiting( aRequestor ); |
| } |
| |
| /** |
| * REQUEST_REQUEUE_RESERVE_STATUS |
| */ |
| inline virtual void handleRequestRequeueReserve( |
| AbstractProcessorUnit * aRequestor) |
| { |
| mQueueProcessor.handleRequestRequeueReserve( aRequestor ); |
| } |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // REPORT API |
| //////////////////////////////////////////////////////////////////////////// |
| |
| virtual void report(OutStream & os) const; |
| |
| |
| /** |
| * EVAL TRACE |
| */ |
| virtual void traceBoundEval(OutStream & os) const; |
| |
| virtual void tracePreEval(OutStream & os, |
| const ExecutionContext & anEC) const; |
| |
| virtual void tracePostEval(OutStream & os, |
| const ExecutionContext & anEC) const; |
| |
| virtual void reportEval(OutStream & os) const; |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // UNIT TEST API |
| //////////////////////////////////////////////////////////////////////////// |
| |
| virtual void tddUnitReport(OutStream & os) const; |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // NON-REGRESSION TEST API |
| //////////////////////////////////////////////////////////////////////////// |
| |
| virtual void tddRegressionReport(OutStream & os) const; |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // SERIALIZATION API |
| //////////////////////////////////////////////////////////////////////////// |
| |
| virtual void toStream(OutStream & os) const; |
| |
| }; |
| |
| |
| } /* namespace sep */ |
| |
| #endif /* SEW_SYMBEX_CONTROLLER_UNIT_MANAGER_H_ */ |