org.eclipse.efm.symbex/src/sew/SymbexControllerUnitManager.cpp - efm/org.eclipse.efm-symbex - Git at Google

 /*******************************************************************************
  * 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
  ******************************************************************************/

 #include "SymbexControllerUnitManager.h"

 #include <fml/workflow/Query.h>
 #include <fml/workflow/WObject.h>

 #include <fam/api/ProcessorUnitFactory.h>
 #include <fam/api/ProcessorUnitRepository.h>

 #include <fam/queue/ExecutionQueue.h>

 #include <sew/SymbexEngine.h>


 namespace sep
 {


 /**
  * GETTER
  * Configuration
  */
 Configuration & SymbexControllerUnitManager::getConfiguration() const
 {
 	return( mSymbexEngine.getConfiguration() );
 }

 /**
  * GETTER
  * Builder
  */
 Builder & SymbexControllerUnitManager::getBuilder()
 {
 	return( mSymbexEngine.getBuilder() );
 }

 /**
  * GETTER
  * AvmPrimitiveProcessor
  */
 AvmPrimitiveProcessor & SymbexControllerUnitManager::getPrimitiveProcessor()
 {
 	return( mSymbexEngine.getPrimitiveProcessor() );
 }


 ////////////////////////////////////////////////////////////////////////////////
 // CONFIGURE  API
 ////////////////////////////////////////////////////////////////////////////////

 bool SymbexControllerUnitManager::preConfigure()
 {
 	WObject * theCONFIG = getParameterWObject();

 	theCONFIG = Query::getRegexWSequence(theCONFIG,
 				OR_WID2("manifest", "MANIFEST"), theCONFIG);

 	if( theCONFIG != WObject::_NULL_ )
 	{
 		mAutoStart = Query::getRegexWPropertyBoolean(
 				theCONFIG, CONS_WID2("auto", "start"), false);

 		mAutoConfigure = Query::getRegexWPropertyBoolean(
 				theCONFIG, CONS_WID2("auto", "conf(igure)?"), false);
 	}

 	return( mAutoConfigure || mAutoStart );
 }

 bool SymbexControllerUnitManager::configure()
 {
 	AVM_OS_LOG << _SEW_
 			<< "< start > SymbexControllerUnitManager::configure ..."
 			<< std::endl;

 	mConfigFlag = true;

 	if( preConfigure() )
 	{
 		//!! NOTHING
 	}

 	// Select MOE profile
 	WObject * moeProfile = Query::getRegexWSequence(
 			getParameterWObject(), OR_WID2("moe", "MOE"));
 	if( moeProfile == WObject::_NULL_ )
 	{
 		moeProfile = Query::getRegexWSequence(
 				getParameterWObject(), OR_WID2("moc", "MOC"));
 	}

 	// A Possible Specific Profile
 	WObject * aProfile = Query::getWPropertyWReferenceOrElse(
 			moeProfile, "moe", "profile", WObject::_NULL_);
 	if( aProfile != WObject::_NULL_ )
 	{
 		WObject * thePROPERTY = Query::getRegexWSequence(
 				aProfile, OR_WID2("property", "PROPERTY"));
 		if( thePROPERTY != WObject::_NULL_ )
 		{
 			moeProfile = thePROPERTY;
 		}
 		else
 		{
 			moeProfile = aProfile;
 		}
 	}

 	mConfigFlag = ProcessorUnitFactory::configure(*this,
 			getParameterWObject(), moeProfile)
 			&& mConfigFlag;


 AVM_IF_DEBUG_FLAG( CONFIGURING )
 	AVM_OS_LOG << "The process configuration:> " << std::endl;
 	toStream(AVM_OS_LOG);
 AVM_ENDIF_DEBUG_FLAG( CONFIGURING )

 	AVM_OS_LOG << _SEW_
 			<< "< end > SymbexControllerUnitManager::configure ... done."
 			<< std::endl;

 	return mConfigFlag;
 }


 ////////////////////////////////////////////////////////////////////////////////
 // INIT / EXIT  API
 ////////////////////////////////////////////////////////////////////////////////

 bool SymbexControllerUnitManager::initImpl()
 {
 	processorIt = mControllerUnits.begin();
 	processorItEnd = mControllerUnits.end();
 	for( ; processorIt != processorItEnd ; ++processorIt )
 	{
 		if( (*processorIt)->isEnablePlugin() )
 		{
 			if( not (*processorIt)->init() )
 			{
 				AVM_OS_CLOG  << "Failed to init the PLUGIN PROCESSOR << "
 						<< ( *processorIt)->getParameterWObject()
 								->getFullyQualifiedNameID()
 						<< " >> " << std::endl;

 				return( false );
 			}
 		}
 	}

 	return true;
 }

 bool SymbexControllerUnitManager::exitImpl()
 {
 	processorIt = mControllerUnits.begin();
 	processorItEnd = mControllerUnits.end();
 	for( ; processorIt != processorItEnd ; ++processorIt )
 	{
 		if( (*processorIt)->isEnablePlugin() )
 		{
 			if( not (*processorIt)->exit() )
 			{
 				AVM_OS_CLOG  << "Failed to exit the PLUGIN PROCESSOR << "
 						<< ( *processorIt)->getParameterWObject()
 								->getFullyQualifiedNameID()
 						<< " >> " << std::endl;

 				return( false );
 			}
 		}
 	}

 	return( true );
 }

 ////////////////////////////////////////////////////////////////////////////////
 // ( PRE / POST ) PROCESS  API
 ////////////////////////////////////////////////////////////////////////////////

 bool SymbexControllerUnitManager::preprocess()
 {
 	bool isOK = mMainProcessor.preprocess();

 	if( isOK )
 	{
 		isOK = mPreprocessorControllerUnits.preprocess();
 	}

 AVM_IF_DEBUG_ENABLED_AND( mMainProcessor.isDebugPreprocessing() )
 	mMainProcessor.debugPreprocessing();
 AVM_ENDIF_DEBUG_ENABLED_AND

 	return( isOK );
 }


 bool SymbexControllerUnitManager::postprocess()
 {
 	bool isOK = mMainProcessor.postprocess();

 	if( isOK )
 	{
 		isOK = mPostprocessorControllerUnits.postprocess();
 	}

 AVM_IF_DEBUG_ENABLED_AND( mMainProcessor.isDebugPostprocessing() )
 	mMainProcessor.debugPostprocessing();
 AVM_ENDIF_DEBUG_ENABLED_AND

 	return( isOK );
 }


 ////////////////////////////////////////////////////////////////////////////////
 // FILTERING  API
 ////////////////////////////////////////////////////////////////////////////////

 bool SymbexControllerUnitManager::filteringInitialize()
 {
 	bool isOK = true;

 	processorIt = mControllerUnits.begin();
 	processorItEnd = mControllerUnits.end();
 	for(  ; processorIt != processorItEnd ; ++processorIt )
 	{
 		if( (*processorIt)->isWeakEnableFilter() )
 		{
 			if( not (*processorIt)->filteringInitialize() )
 			{
 				isOK = false;

 				break;
 			}
 		}
 	}

 //	if( mMainProcessor.filteringInitialize() )
 //	{
 //		return( mPrefilterControllerUnits.filteringInitialize() );
 //	}
 //
 //	return( false );

 	AVM_IF_DEBUG_ENABLED_AND( mMainProcessor.isDebugFilteringInitialize() )
 		mMainProcessor.debugFilteringInitialize();
 	AVM_ENDIF_DEBUG_ENABLED_AND

 	return( isOK );
 }


 bool SymbexControllerUnitManager::filteringFinalize()
 {
 	bool isOK = true;

 	processorIt = mControllerUnits.begin();
 	processorItEnd = mControllerUnits.end();
 	for( ; processorIt != processorItEnd ; ++processorIt )
 	{
 		if( (*processorIt)->isWeakEnableFilter() )
 		{
 			if( not (*processorIt)->filteringFinalize() )
 			{
 				isOK = false;

 				break;
 			}
 		}
 	}

 //	if( mMainProcessor.filteringFinalize() )
 //	{
 //		return( mPrefilterControllerUnits.filteringFinalize() );
 //	}
 //
 //	return( false );

 	AVM_IF_DEBUG_ENABLED_AND( mMainProcessor.isDebugFilteringFinalize() )
 		mMainProcessor.debugFilteringFinalize();
 	AVM_ENDIF_DEBUG_ENABLED_AND

 	return( isOK );
 }


 ////////////////////////////////////////////////////////////////////////////////
 // ( PRE / POST ) FILTER  API
 ////////////////////////////////////////////////////////////////////////////////

 bool SymbexControllerUnitManager::prefilter()
 {
 AVM_IF_DEBUG_ENABLED_AND( mMainProcessor.isDebugPrefiltering() )
 	mMainProcessor.debugPrefiltering();
 AVM_ENDIF_DEBUG_ENABLED_AND


 	if( mMainProcessor.prefilter() )
 	{
 		if( mRedundancyProcessor.prefilter() )
 		{
 			return( mPrefilterControllerUnits.prefilter() );
 		}
 	}

 	return( false );
 }


 bool SymbexControllerUnitManager::finalizePrefiltering()
 {
 	bool isOK = mMainProcessor.finalizePrefiltering();

 AVM_IF_DEBUG_ENABLED_AND( mMainProcessor.isDebugPrefilteringFinalize() )
 	mMainProcessor.debugPrefilteringFinalize();
 AVM_ENDIF_DEBUG_ENABLED_AND

 	return( isOK );
 }


 bool SymbexControllerUnitManager::postfilter()
 {
 AVM_IF_DEBUG_ENABLED_AND( mMainProcessor.isDebugPostfiltering() )
 	mMainProcessor.debugPostfiltering();
 AVM_ENDIF_DEBUG_ENABLED_AND

 	if( mMainProcessor.postfilter() )
 	{
 		return( mPostfilterControllerUnits.postfilter() );
 	}

 	return( false );
 }


 bool SymbexControllerUnitManager::finalizePostfiltering()
 {
 	bool isOK = mMainProcessor.finalizePostfiltering();

 //	if( mMainProcessor.finalizePostfiltering() )
 //	{
 //		return( mPostfilterControllerUnits.finalizePostfiltering() );
 //	}
 //
 //	return( false );

 AVM_IF_DEBUG_ENABLED_AND( mMainProcessor.isDebugPostfilteringFinalize() )
 	mMainProcessor.debugPostfilteringFinalize();
 AVM_ENDIF_DEBUG_ENABLED_AND

 	return( isOK );
 }


 ////////////////////////////////////////////////////////////////////////////////
 // REPORT  API
 ////////////////////////////////////////////////////////////////////////////////

 void SymbexControllerUnitManager::report(OutStream & os) const
 {
 	if( mControllerUnits.nonempty() )
 	{
 		os << TAB << "REPORT" << EOL_INCR_INDENT;

 		mQueueProcessor.report(os);
 		os << std::flush;

 		mMainProcessor.report(os);
 		os << std::flush;

 		mRedundancyProcessor.report(os);
 		os << std::flush;

 		controller_iterator processorIt = mControllerUnits.begin();
 		controller_iterator processorItEnd = mControllerUnits.end();
 		for( ; processorIt != processorItEnd ; ++processorIt )
 		{
 			if( (*processorIt)->isEnablePlugin() )
 			{
 				(*processorIt)->report(os);
 				os << std::flush;
 			}
 		}

 		os << DECR_INDENT << std::flush;
 	}
 }


 /**
  * EVAL TRACE
  */
 void SymbexControllerUnitManager::traceBoundEval(OutStream & os) const
 {
 //	AVM_OS_ASSERT_FATAL_ERROR_EXIT(
 //		CompositeControllerUnit::first() == (& mMainProcessor) )
 //			<< "You found a BUG !!!"
 //			<< SEND_EXIT;

 	mMainProcessor.traceBoundEval(os);
 	os << std::flush;

 	controller_iterator processorIt = mControllerUnits.begin();
 	controller_iterator processorItEnd = mControllerUnits.end();
 	for( ; processorIt != processorItEnd ; ++processorIt )
 	{
 		if( (*processorIt)->isEnablePlugin() )
 		{
 			(*processorIt)->traceBoundEval(os);
 		}
 	}
 }


 void SymbexControllerUnitManager::tracePreEval(
 		OutStream & os, const ExecutionContext & anEC) const
 {
 //	AVM_OS_ASSERT_FATAL_ERROR_EXIT(
 //		CompositeControllerUnit::first() == (& mMainProcessor) )
 //			<< "You found a BUG !!!"
 //			<< SEND_EXIT;

 	mMainProcessor.tracePreEval(os, anEC);
 	os << std::flush;

 	controller_iterator processorIt = mControllerUnits.begin();
 	controller_iterator processorItEnd = mControllerUnits.end();
 	for( ; processorIt != processorItEnd ; ++processorIt )
 	{
 		if( (*processorIt)->isEnablePlugin() &&
 			(*processorIt)->isLifecycleRunnable() )
 		{
 			(*processorIt)->tracePreEval(os, anEC);
 		}
 	}
 }


 void SymbexControllerUnitManager::tracePostEval(
 		OutStream & os, const ExecutionContext & anEC) const
 {
 //	AVM_OS_ASSERT_FATAL_ERROR_EXIT(
 //		CompositeControllerUnit::first() == (& mMainProcessor) )
 //			<< "You found a BUG !!!"
 //			<< SEND_EXIT;

 	mMainProcessor.tracePostEval(os, anEC);
 	os << std::flush;

 	controller_iterator processorIt = mControllerUnits.begin();
 	controller_iterator processorItEnd = mControllerUnits.end();
 	for( ; processorIt != processorItEnd ; ++processorIt )
 	{
 		if( (*processorIt)->isEnablePlugin() &&
 			(*processorIt)->isLifecycleRunnable() )
 		{
 			(*processorIt)->tracePostEval(os, anEC);
 		}
 	}
 }


 void SymbexControllerUnitManager::reportEval(OutStream & os) const
 {
 //	AVM_OS_ASSERT_FATAL_ERROR_EXIT(
 //		CompositeControllerUnit::first() == (& mMainProcessor) )
 //			<< "You found a BUG !!!"
 //			<< SEND_EXIT;

 	mMainProcessor.reportEval(os);
 	os << std::flush;

 	controller_iterator processorIt = mControllerUnits.begin();
 	controller_iterator processorItEnd = mControllerUnits.end();
 	for( ; processorIt != processorItEnd ; ++processorIt )
 	{
 		if( (*processorIt)->isEnablePlugin() )
 		{
 			(*processorIt)->reportEval(os);
 		}
 	}
 }


 ////////////////////////////////////////////////////////////////////////////////
 // UNIT TEST API
 ////////////////////////////////////////////////////////////////////////////////

 void SymbexControllerUnitManager::tddUnitReport(OutStream & os) const
 {
 	mMainProcessor.tddUnitReport(os);

 	controller_iterator processorIt = mControllerUnits.begin();
 	controller_iterator processorItEnd = mControllerUnits.end();
 	for( ; processorIt != processorItEnd ; ++processorIt )
 	{
 		if( (*processorIt)->isEnablePlugin() )
 		{
 			(*processorIt)->tddUnitReport(os);
 		}
 	}
 }


 ////////////////////////////////////////////////////////////////////////////////
 // NON-REGRESSION TEST API
 ////////////////////////////////////////////////////////////////////////////////

 void SymbexControllerUnitManager::tddRegressionReport(OutStream & os) const
 {
 	mMainProcessor.tddRegressionReport(os);

 	controller_iterator processorIt = mControllerUnits.begin();
 	controller_iterator processorItEnd = mControllerUnits.end();
 	for( ; processorIt != processorItEnd ; ++processorIt )
 	{
 		if( (*processorIt)->isEnablePlugin() )
 		{
 			(*processorIt)->tddRegressionReport(os);
 		}
 	}
 }


 ////////////////////////////////////////////////////////////////////////////////
 // SERIALIZATION API
 ////////////////////////////////////////////////////////////////////////////////

 void SymbexControllerUnitManager::toStream(OutStream & os) const
 {
 //	if( mParameterWObject != NULL )
 //	{
 //		mParameterWObject->toStream(os);
 //	}

 	os << TAB << "moe:" << EOL_INCR_INDENT;

 	os << TAB << "supervisor = " << mMainProcessor.strUniqId()  << ";" << EOL;

 	os << TAB << "queue = " << mQueueProcessor.strUniqId() << ";" << EOL;

 	os << TAB << "redundancy = " << mRedundancyProcessor.strUniqId() << ";"
 			<< EOL2;

 	mPreprocessorControllerUnits.toStream(os, "pre_processor = " );

 	os << EOL;

 	mPrefilterControllerUnits.toStream(os, "pre_filter = " );

 	mPostfilterControllerUnits.toStream(os, "post_filter = " );

 	os << EOL;

 	mPostprocessorControllerUnits.toStream(os, "post_processor = " );

 	os << DECR_INDENT;

 }

 } /* namespace sep */
	/*******************************************************************************
	* 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
	******************************************************************************/

	#include "SymbexControllerUnitManager.h"

	#include <fml/workflow/Query.h>
	#include <fml/workflow/WObject.h>

	#include <fam/api/ProcessorUnitFactory.h>
	#include <fam/api/ProcessorUnitRepository.h>

	#include <fam/queue/ExecutionQueue.h>

	#include <sew/SymbexEngine.h>


	namespace sep
	{


	/**
	* GETTER
	* Configuration
	*/
	Configuration & SymbexControllerUnitManager::getConfiguration() const
	{
	return( mSymbexEngine.getConfiguration() );
	}

	/**
	* GETTER
	* Builder
	*/
	Builder & SymbexControllerUnitManager::getBuilder()
	{
	return( mSymbexEngine.getBuilder() );
	}

	/**
	* GETTER
	* AvmPrimitiveProcessor
	*/
	AvmPrimitiveProcessor & SymbexControllerUnitManager::getPrimitiveProcessor()
	{
	return( mSymbexEngine.getPrimitiveProcessor() );
	}


	////////////////////////////////////////////////////////////////////////////////
	// CONFIGURE API
	////////////////////////////////////////////////////////////////////////////////

	bool SymbexControllerUnitManager::preConfigure()
	{
	WObject * theCONFIG = getParameterWObject();

	theCONFIG = Query::getRegexWSequence(theCONFIG,
	OR_WID2("manifest", "MANIFEST"), theCONFIG);

	if( theCONFIG != WObject::_NULL_ )
	{
	mAutoStart = Query::getRegexWPropertyBoolean(
	theCONFIG, CONS_WID2("auto", "start"), false);

	mAutoConfigure = Query::getRegexWPropertyBoolean(
	theCONFIG, CONS_WID2("auto", "conf(igure)?"), false);
	}

	return( mAutoConfigure \|\| mAutoStart );
	}

	bool SymbexControllerUnitManager::configure()
	{
	AVM_OS_LOG << _SEW_
	<< "< start > SymbexControllerUnitManager::configure ..."
	<< std::endl;

	mConfigFlag = true;

	if( preConfigure() )
	{
	//!! NOTHING
	}

	// Select MOE profile
	WObject * moeProfile = Query::getRegexWSequence(
	getParameterWObject(), OR_WID2("moe", "MOE"));
	if( moeProfile == WObject::_NULL_ )
	{
	moeProfile = Query::getRegexWSequence(
	getParameterWObject(), OR_WID2("moc", "MOC"));
	}

	// A Possible Specific Profile
	WObject * aProfile = Query::getWPropertyWReferenceOrElse(
	moeProfile, "moe", "profile", WObject::_NULL_);
	if( aProfile != WObject::_NULL_ )
	{
	WObject * thePROPERTY = Query::getRegexWSequence(
	aProfile, OR_WID2("property", "PROPERTY"));
	if( thePROPERTY != WObject::_NULL_ )
	{
	moeProfile = thePROPERTY;
	}
	else
	{
	moeProfile = aProfile;
	}
	}

	mConfigFlag = ProcessorUnitFactory::configure(*this,
	getParameterWObject(), moeProfile)
	&& mConfigFlag;


	AVM_IF_DEBUG_FLAG( CONFIGURING )
	AVM_OS_LOG << "The process configuration:> " << std::endl;
	toStream(AVM_OS_LOG);
	AVM_ENDIF_DEBUG_FLAG( CONFIGURING )

	AVM_OS_LOG << _SEW_
	<< "< end > SymbexControllerUnitManager::configure ... done."
	<< std::endl;

	return mConfigFlag;
	}


	////////////////////////////////////////////////////////////////////////////////
	// INIT / EXIT API
	////////////////////////////////////////////////////////////////////////////////

	bool SymbexControllerUnitManager::initImpl()
	{
	processorIt = mControllerUnits.begin();
	processorItEnd = mControllerUnits.end();
	for( ; processorIt != processorItEnd ; ++processorIt )
	{
	if( (*processorIt)->isEnablePlugin() )
	{
	if( not (*processorIt)->init() )
	{
	AVM_OS_CLOG << "Failed to init the PLUGIN PROCESSOR << "
	<< ( *processorIt)->getParameterWObject()
	->getFullyQualifiedNameID()
	<< " >> " << std::endl;

	return( false );
	}
	}
	}

	return true;
	}

	bool SymbexControllerUnitManager::exitImpl()
	{
	processorIt = mControllerUnits.begin();
	processorItEnd = mControllerUnits.end();
	for( ; processorIt != processorItEnd ; ++processorIt )
	{
	if( (*processorIt)->isEnablePlugin() )
	{
	if( not (*processorIt)->exit() )
	{
	AVM_OS_CLOG << "Failed to exit the PLUGIN PROCESSOR << "
	<< ( *processorIt)->getParameterWObject()
	->getFullyQualifiedNameID()
	<< " >> " << std::endl;

	return( false );
	}
	}
	}

	return( true );
	}

	////////////////////////////////////////////////////////////////////////////////
	// ( PRE / POST ) PROCESS API
	////////////////////////////////////////////////////////////////////////////////

	bool SymbexControllerUnitManager::preprocess()
	{
	bool isOK = mMainProcessor.preprocess();

	if( isOK )
	{
	isOK = mPreprocessorControllerUnits.preprocess();
	}

	AVM_IF_DEBUG_ENABLED_AND( mMainProcessor.isDebugPreprocessing() )
	mMainProcessor.debugPreprocessing();
	AVM_ENDIF_DEBUG_ENABLED_AND

	return( isOK );
	}


	bool SymbexControllerUnitManager::postprocess()
	{
	bool isOK = mMainProcessor.postprocess();

	if( isOK )
	{
	isOK = mPostprocessorControllerUnits.postprocess();
	}

	AVM_IF_DEBUG_ENABLED_AND( mMainProcessor.isDebugPostprocessing() )
	mMainProcessor.debugPostprocessing();
	AVM_ENDIF_DEBUG_ENABLED_AND

	return( isOK );
	}



	////////////////////////////////////////////////////////////////////////////////
	// FILTERING API
	////////////////////////////////////////////////////////////////////////////////

	bool SymbexControllerUnitManager::filteringInitialize()
	{
	bool isOK = true;

	processorIt = mControllerUnits.begin();
	processorItEnd = mControllerUnits.end();
	for( ; processorIt != processorItEnd ; ++processorIt )
	{
	if( (*processorIt)->isWeakEnableFilter() )
	{
	if( not (*processorIt)->filteringInitialize() )
	{
	isOK = false;

	break;
	}
	}
	}

	// if( mMainProcessor.filteringInitialize() )
	// {
	// return( mPrefilterControllerUnits.filteringInitialize() );
	// }
	//
	// return( false );

	AVM_IF_DEBUG_ENABLED_AND( mMainProcessor.isDebugFilteringInitialize() )
	mMainProcessor.debugFilteringInitialize();
	AVM_ENDIF_DEBUG_ENABLED_AND

	return( isOK );
	}


	bool SymbexControllerUnitManager::filteringFinalize()
	{
	bool isOK = true;

	processorIt = mControllerUnits.begin();
	processorItEnd = mControllerUnits.end();
	for( ; processorIt != processorItEnd ; ++processorIt )
	{
	if( (*processorIt)->isWeakEnableFilter() )
	{
	if( not (*processorIt)->filteringFinalize() )
	{
	isOK = false;

	break;
	}
	}
	}

	// if( mMainProcessor.filteringFinalize() )
	// {
	// return( mPrefilterControllerUnits.filteringFinalize() );
	// }
	//
	// return( false );

	AVM_IF_DEBUG_ENABLED_AND( mMainProcessor.isDebugFilteringFinalize() )
	mMainProcessor.debugFilteringFinalize();
	AVM_ENDIF_DEBUG_ENABLED_AND

	return( isOK );
	}


	////////////////////////////////////////////////////////////////////////////////
	// ( PRE / POST ) FILTER API
	////////////////////////////////////////////////////////////////////////////////

	bool SymbexControllerUnitManager::prefilter()
	{
	AVM_IF_DEBUG_ENABLED_AND( mMainProcessor.isDebugPrefiltering() )
	mMainProcessor.debugPrefiltering();
	AVM_ENDIF_DEBUG_ENABLED_AND


	if( mMainProcessor.prefilter() )
	{
	if( mRedundancyProcessor.prefilter() )
	{
	return( mPrefilterControllerUnits.prefilter() );
	}
	}

	return( false );
	}


	bool SymbexControllerUnitManager::finalizePrefiltering()
	{
	bool isOK = mMainProcessor.finalizePrefiltering();

	AVM_IF_DEBUG_ENABLED_AND( mMainProcessor.isDebugPrefilteringFinalize() )
	mMainProcessor.debugPrefilteringFinalize();
	AVM_ENDIF_DEBUG_ENABLED_AND

	return( isOK );
	}


	bool SymbexControllerUnitManager::postfilter()
	{
	AVM_IF_DEBUG_ENABLED_AND( mMainProcessor.isDebugPostfiltering() )
	mMainProcessor.debugPostfiltering();
	AVM_ENDIF_DEBUG_ENABLED_AND

	if( mMainProcessor.postfilter() )
	{
	return( mPostfilterControllerUnits.postfilter() );
	}

	return( false );
	}


	bool SymbexControllerUnitManager::finalizePostfiltering()
	{
	bool isOK = mMainProcessor.finalizePostfiltering();

	// if( mMainProcessor.finalizePostfiltering() )
	// {
	// return( mPostfilterControllerUnits.finalizePostfiltering() );
	// }
	//
	// return( false );

	AVM_IF_DEBUG_ENABLED_AND( mMainProcessor.isDebugPostfilteringFinalize() )
	mMainProcessor.debugPostfilteringFinalize();
	AVM_ENDIF_DEBUG_ENABLED_AND

	return( isOK );
	}


	////////////////////////////////////////////////////////////////////////////////
	// REPORT API
	////////////////////////////////////////////////////////////////////////////////

	void SymbexControllerUnitManager::report(OutStream & os) const
	{
	if( mControllerUnits.nonempty() )
	{
	os << TAB << "REPORT" << EOL_INCR_INDENT;

	mQueueProcessor.report(os);
	os << std::flush;

	mMainProcessor.report(os);
	os << std::flush;

	mRedundancyProcessor.report(os);
	os << std::flush;

	controller_iterator processorIt = mControllerUnits.begin();
	controller_iterator processorItEnd = mControllerUnits.end();
	for( ; processorIt != processorItEnd ; ++processorIt )
	{
	if( (*processorIt)->isEnablePlugin() )
	{
	(*processorIt)->report(os);
	os << std::flush;
	}
	}

	os << DECR_INDENT << std::flush;
	}
	}


	/**
	* EVAL TRACE
	*/
	void SymbexControllerUnitManager::traceBoundEval(OutStream & os) const
	{
	// AVM_OS_ASSERT_FATAL_ERROR_EXIT(
	// CompositeControllerUnit::first() == (& mMainProcessor) )
	// << "You found a BUG !!!"
	// << SEND_EXIT;

	mMainProcessor.traceBoundEval(os);
	os << std::flush;

	controller_iterator processorIt = mControllerUnits.begin();
	controller_iterator processorItEnd = mControllerUnits.end();
	for( ; processorIt != processorItEnd ; ++processorIt )
	{
	if( (*processorIt)->isEnablePlugin() )
	{
	(*processorIt)->traceBoundEval(os);
	}
	}
	}


	void SymbexControllerUnitManager::tracePreEval(
	OutStream & os, const ExecutionContext & anEC) const
	{
	// AVM_OS_ASSERT_FATAL_ERROR_EXIT(
	// CompositeControllerUnit::first() == (& mMainProcessor) )
	// << "You found a BUG !!!"
	// << SEND_EXIT;

	mMainProcessor.tracePreEval(os, anEC);
	os << std::flush;

	controller_iterator processorIt = mControllerUnits.begin();
	controller_iterator processorItEnd = mControllerUnits.end();
	for( ; processorIt != processorItEnd ; ++processorIt )
	{
	if( (*processorIt)->isEnablePlugin() &&
	(*processorIt)->isLifecycleRunnable() )
	{
	(*processorIt)->tracePreEval(os, anEC);
	}
	}
	}


	void SymbexControllerUnitManager::tracePostEval(
	OutStream & os, const ExecutionContext & anEC) const
	{
	// AVM_OS_ASSERT_FATAL_ERROR_EXIT(
	// CompositeControllerUnit::first() == (& mMainProcessor) )
	// << "You found a BUG !!!"
	// << SEND_EXIT;

	mMainProcessor.tracePostEval(os, anEC);
	os << std::flush;

	controller_iterator processorIt = mControllerUnits.begin();
	controller_iterator processorItEnd = mControllerUnits.end();
	for( ; processorIt != processorItEnd ; ++processorIt )
	{
	if( (*processorIt)->isEnablePlugin() &&
	(*processorIt)->isLifecycleRunnable() )
	{
	(*processorIt)->tracePostEval(os, anEC);
	}
	}
	}


	void SymbexControllerUnitManager::reportEval(OutStream & os) const
	{
	// AVM_OS_ASSERT_FATAL_ERROR_EXIT(
	// CompositeControllerUnit::first() == (& mMainProcessor) )
	// << "You found a BUG !!!"
	// << SEND_EXIT;

	mMainProcessor.reportEval(os);
	os << std::flush;

	controller_iterator processorIt = mControllerUnits.begin();
	controller_iterator processorItEnd = mControllerUnits.end();
	for( ; processorIt != processorItEnd ; ++processorIt )
	{
	if( (*processorIt)->isEnablePlugin() )
	{
	(*processorIt)->reportEval(os);
	}
	}
	}


	////////////////////////////////////////////////////////////////////////////////
	// UNIT TEST API
	////////////////////////////////////////////////////////////////////////////////

	void SymbexControllerUnitManager::tddUnitReport(OutStream & os) const
	{
	mMainProcessor.tddUnitReport(os);

	controller_iterator processorIt = mControllerUnits.begin();
	controller_iterator processorItEnd = mControllerUnits.end();
	for( ; processorIt != processorItEnd ; ++processorIt )
	{
	if( (*processorIt)->isEnablePlugin() )
	{
	(*processorIt)->tddUnitReport(os);
	}
	}
	}


	////////////////////////////////////////////////////////////////////////////////
	// NON-REGRESSION TEST API
	////////////////////////////////////////////////////////////////////////////////

	void SymbexControllerUnitManager::tddRegressionReport(OutStream & os) const
	{
	mMainProcessor.tddRegressionReport(os);

	controller_iterator processorIt = mControllerUnits.begin();
	controller_iterator processorItEnd = mControllerUnits.end();
	for( ; processorIt != processorItEnd ; ++processorIt )
	{
	if( (*processorIt)->isEnablePlugin() )
	{
	(*processorIt)->tddRegressionReport(os);
	}
	}
	}


	////////////////////////////////////////////////////////////////////////////////
	// SERIALIZATION API
	////////////////////////////////////////////////////////////////////////////////

	void SymbexControllerUnitManager::toStream(OutStream & os) const
	{
	// if( mParameterWObject != NULL )
	// {
	// mParameterWObject->toStream(os);
	// }

	os << TAB << "moe:" << EOL_INCR_INDENT;

	os << TAB << "supervisor = " << mMainProcessor.strUniqId() << ";" << EOL;

	os << TAB << "queue = " << mQueueProcessor.strUniqId() << ";" << EOL;

	os << TAB << "redundancy = " << mRedundancyProcessor.strUniqId() << ";"
	<< EOL2;

	mPreprocessorControllerUnits.toStream(os, "pre_processor = " );

	os << EOL;

	mPrefilterControllerUnits.toStream(os, "pre_filter = " );

	mPostfilterControllerUnits.toStream(os, "post_filter = " );

	os << EOL;

	mPostprocessorControllerUnits.toStream(os, "post_processor = " );

	os << DECR_INDENT;

	}

	} /* namespace sep */