org.eclipse.efm.symbex/src/fam/coverage/AvmCoverageOneTraceDriver.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: 19 nov. 2014
  *
  * Contributors:
  *  Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr
  *   - Initial API and implementation
  ******************************************************************************/

 #include "AvmCoverageOneTraceDriver.h"

 #include "AvmCoverageProcessor.h"
 #include "AvmCoverageTransitionView.h"

 #include <fml/executable/AvmTransition.h>

 #include <fml/runtime/ExecutionContext.h>
 #include <fml/runtime/ExecutionData.h>
 #include <fml/runtime/RuntimeID.h>

 #include <fml/trace/TracePoint.h>

 #include <fam/coverage/AvmCoverageTransitionView.h>

 #include <fam/queue/WaitingStrategy.h>

 #include <sew/SymbexControllerRequestManager.h>

 #include <functional>


 namespace sep
 {


 /**
  * CONSTRUCTOR
  * Default
  */
 AvmCoverageOneTraceDriver::AvmCoverageOneTraceDriver(
 		AvmCoverageProcessor & aCoverageProcessor, EvaluationEnvironment & anENV,
 		IHeuristicClass::ENUM_HEURISTIC_CLASS anHeuristicClass,
 		avm_size_t pathCountLimit, avm_size_t pathSizeLimit)
 : AvmCoverageAbstractView( aCoverageProcessor , NULL ),
 mTransitionCoverage( aCoverageProcessor.mTransitionCoverage ),
 ENV( anENV ),
 mTraceChecker( anENV ),

 mComputingPathCountLimit( pathCountLimit ),
 mComputingPathSizeLimit( pathSizeLimit ),
 mPathChecker(anHeuristicClass, pathCountLimit, pathSizeLimit),

 mTransitionTargetHistory( ),

 mCacheForDirectiveTraces( ),
 mDirectiveEC( NULL ),

 mDefaultPendingTraceSize( 4 ),

 mPendingTrace( & aCoverageProcessor.mTransitionCoverage ),

 mWaitingQueue( ),

 mGlobalUncoveredTransitions( ),
 mLastCollectedCoverCount( 0 ),

 mLocalUncoveredTransitions( ),

 // Computing drive variable
 saveWeightMin( 0 ),

 coverageMax( 0 ),
 coverageCount( 0 ),

 tmpTracePoint( NULL ),
 itTP( ),
 endTP( ),

 tmpTransition( NULL ),
 itTransition( ),
 endTransition( ),

 itTrace( ),
 endTrace( )
 {
 	// TODO Auto-generated constructor stub

 }


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

 bool AvmCoverageOneTraceDriver::configureImpl()
 {
 	return( true );
 }


 ////////////////////////////////////////////////////////////////////////////////
 // PROCESSOR FILTER API
 ////////////////////////////////////////////////////////////////////////////////

 bool AvmCoverageOneTraceDriver::prefiltering(ListOfExecutionContext & ecQueue)
 {
 //	endQueue = ecQueue.end();
 //	for( itQueue = ecQueue.begin() ; itQueue != endQueue ; ++itQueue )
 //	{
 //
 //	}

 	return( true );
 }

 bool AvmCoverageOneTraceDriver::postfiltering(ListOfExecutionContext & ecQueue)
 {
 	itQueue = ecQueue.begin();
 	endQueue = ecQueue.end();
 	for( ; itQueue != endQueue ; ++itQueue )
 	{
 		if( (*itQueue) == mDirectiveEC )
 		{
 			if( drive() )
 			{
 				return( true );
 			}
 		}
 	}

 	mCoverageProcessor.setRequestRequeueWaiting();

 	return( false );
 }


 ////////////////////////////////////////////////////////////////////////////////
 // PROCESSOR REQUEST API
 ////////////////////////////////////////////////////////////////////////////////
 /**
  * REQUEUE_WAITING
  */
 bool AvmCoverageOneTraceDriver::requeueWaitingTable(
 		WaitingStrategy & aWaitingStrategy,
 		avm_uint8_t aWeightMin, avm_uint8_t aWeightMax)
 {
 	// Global Update Cache for Directive Traces !!!
 	updateCacheForDirectiveTraces();


 	mWaitingQueue.clear();

 	saveWeightMin = aWeightMin;

 	aWeightMin = aWaitingStrategy.splicePriorQueueTable(
 			mWaitingQueue, saveWeightMin, aWeightMax);

 //	while( aWeightMin <= WEIGHT_WEAKLY_ACHIEVABLE )
 	while( aWeightMin <= WEIGHT_NON_PRIORITY )
 	{
 		itQueue = mWaitingQueue.begin();
 		endQueue = mWaitingQueue.end();
 		for( ; itQueue != endQueue ; ++itQueue )
 		{
 			if( checkDirectiveTrace(* (*itQueue)) )
 			{
 				(*itQueue)->setWeight( WEIGHT_SELECTED_ACHIEVABLE );

 				aWaitingStrategy.push( *itQueue );

 				itQueue = mWaitingQueue.erase( itQueue );

 				aWaitingStrategy.splice(aWeightMin, mWaitingQueue);

 				return( setDirectiveTrace() );
 			}
 		}

 		aWaitingStrategy.splice(aWeightMin, mWaitingQueue);

 		aWeightMin = aWaitingStrategy.splicePriorQueueTable(
 				mWaitingQueue, ++aWeightMin, aWeightMax);
 	}

 	aWaitingStrategy.splice(aWeightMin, mWaitingQueue);


 	if( mGlobalUncoveredTransitions.empty() )
 	{
 		mLastCollectedCoverCount = mCoverageStatistics.mNumberOfCovered;

 		mTransitionCoverage.collectUncoveredTransition(
 				mGlobalUncoveredTransitions);
 	}
 	else if( mLastCollectedCoverCount < mCoverageStatistics.mNumberOfCovered )
 	{
 		mLastCollectedCoverCount = mCoverageStatistics.mNumberOfCovered;

 		mTransitionCoverage.updateUncoveredTransition(
 				mGlobalUncoveredTransitions);
 	}


 	aWeightMin = aWaitingStrategy.splicePriorQueueTable(
 			mWaitingQueue, saveWeightMin, aWeightMax);

 	while( aWeightMin <= WEIGHT_UNKNOWN_ACHIEVABLE )
 	{
 		itQueue = mWaitingQueue.begin();
 		endQueue = mWaitingQueue.end();
 		for( ; itQueue != endQueue ; ++itQueue )
 		{
 			if( checkDirectiveTrace(*(*itQueue), mGlobalUncoveredTransitions) )
 			{
 				(*itQueue)->setWeight( WEIGHT_SELECTED_ACHIEVABLE );

 				aWaitingStrategy.push( *itQueue );

 				itQueue = mWaitingQueue.erase( itQueue );

 				aWaitingStrategy.splice(aWeightMin, mWaitingQueue);

 				return( setDirectiveTrace() );
 			}
 		}

 		aWaitingStrategy.splice(aWeightMin, mWaitingQueue);

 		aWeightMin = aWaitingStrategy.splicePriorQueueTable(
 				mWaitingQueue, ++aWeightMin, aWeightMax);
 	}

 	aWaitingStrategy.splice(aWeightMin, mWaitingQueue);

 	if( selectDirectiveTrace() )
 	{
 		aWaitingStrategy.remove( mDirectiveEC );

 		mDirectiveEC->setWeight( WEIGHT_SELECTED_ACHIEVABLE );

 		aWaitingStrategy.push( mDirectiveEC );

 AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )
 		AVM_OS_TRACE << "selectDirectiveTrace :> ";
 		mDirectiveEC->traceMinimum(AVM_OS_TRACE);
 		aWaitingStrategy.toStream(AVM_OS_TRACE);
 AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )

 		resetFailedTransitionTargetHistory();

 		return( setDirectiveTrace() );
 	}

 	resetFailedTransitionTargetHistory();

 	mCoverageProcessor.setRequestHeuristic();

 	return( false );
 }


 ////////////////////////////////////////////////////////////////////////////////
 // TRACE DRIVER API
 ////////////////////////////////////////////////////////////////////////////////

 /**
  * UPDATE
  * mCacheForDirectiveTraces
  */
 void AvmCoverageOneTraceDriver::appendDirectiveTraces(AvmTraceProperty & aTrace)
 {
 	if( mCacheForDirectiveTraces.empty() )
 	{
 		mCacheForDirectiveTraces.push_back( aTrace );
 	}
 //	else if( aTrace.isInf( std::less<avm_size_t>(),
 //			mCacheForDirectiveTraces.front() ) )
 	else if( aTrace.sizeLT( mCacheForDirectiveTraces.front() ) )
 	{
 		mCacheForDirectiveTraces.push_front( aTrace );
 	}
 	else if( aTrace.sizeGT( mCacheForDirectiveTraces.back() ) )
 	{
 		mCacheForDirectiveTraces.push_back( aTrace );
 	}
 	else
 	{
 		itTrace = mCacheForDirectiveTraces.begin();
 		endTrace = mCacheForDirectiveTraces.end();
 		for( ; itTrace != endTrace ; ++itTrace )
 		{
 			if( aTrace.sizeLT( *itTrace ) )
 			{
 				break;
 			}
 		}
 		mCacheForDirectiveTraces.insert(itTrace, aTrace);
 	}
 }


 bool AvmCoverageOneTraceDriver::checkDirectiveContext(
 		const ExecutionContext & aDirectiveEC, AvmTransition * aTransition)
 {
 	itTrace = mCacheForDirectiveTraces.begin();
 	endTrace = mCacheForDirectiveTraces.end();
 	for( ; itTrace != endTrace ; ++itTrace )
 	{
 		if( ((& aDirectiveEC) == (*itTrace).mEC) &&
 			(aTransition  == (*itTrace).backTransition()) )
 		{
 			return( true );
 		}
 	}

 	return( false );
 }


 bool AvmCoverageOneTraceDriver::computeDirectiveTrace(
 		const ExecutionContext & aDirectiveEC, AvmTransition * aTransition)
 {
 AVM_IF_DEBUG_LEVEL_FLAG2( HIGH , PROCESSOR , TRANSITION )
 	AVM_OS_TRACE << TAB << "AvmCoverageTraceDriver :>" << AVM_STR_INDENT;
 	aDirectiveEC.traceMinimum(AVM_OS_TRACE);
 	AVM_OS_TRACE << END_INDENT;
 	AVM_OS_TRACE << " |= " ; aTransition->toStreamHeader(AVM_OS_TRACE);
 	AVM_OS_TRACE << std::endl;// << INCR_INDENT;
 //	AvmTransition::toStream(AVM_OS_TRACE, mTransitionTargetHistory);
 //	AVM_OS_TRACE << DECR_INDENT;
 AVM_ENDIF_DEBUG_LEVEL_FLAG2( HIGH , PROCESSOR , TRANSITION )


 //	if( mTransitionTargetHistory.contains(aTransition) )
 //	{
 //		return( false );
 //	}
 //	else
 		if( checkDirectiveContext(aDirectiveEC, aTransition) )
 	{
 		return( false );
 	}
 	else
 	{
 		mPendingTrace.clear();

 		mDirectiveEC = const_cast< ExecutionContext *>( & aDirectiveEC );

 		RuntimeID aRID = aDirectiveEC.refExecutionData().getRuntimeID(
 				aTransition->getExecutable() );

 		if( mPathChecker.computePath(mPendingTrace,
 				mDirectiveEC, aRID, aTransition,
 				mHeuristicProperty.mDirectiveTraceHeuristicClass,
 				mHeuristicProperty.mDirectiveTraceCountLimit,
 				mHeuristicProperty.mDirectiveTraceSizeLimit) )
 		{
 			mPendingTrace.mEC = (& aDirectiveEC);

 AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )
 	mPathChecker.report(AVM_OS_COUT);
 	mPathChecker.report(AVM_OS_TRACE);
 	AVM_OS_TRACE << REPEAT(">>>>>>>>>>", 10) << std::endl;
 AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )

 			return( true );
 		}

 		return( false );
 	}
 }


 bool AvmCoverageOneTraceDriver::selectDirectiveTrace()
 {
 	if( mCacheForDirectiveTraces.nonempty() )
 	{
 		toStreamCache( AVM_OS_TRACE , "selectDirectiveTrace"  );

 		mPendingTrace.clear();
 		mPendingTrace.copyTrace( mCacheForDirectiveTraces.front() );

 		mDirectiveEC = const_cast< ExecutionContext * >( mPendingTrace.mEC );

 		mCacheForDirectiveTraces.pop_front();

 		return( true );
 	}

 	return( false );
 }

 bool AvmCoverageOneTraceDriver::setDirectiveTrace()
 {
 	mTransitionTargetHistory.push_front( mPendingTrace.backTransition() );

 AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )
 	AVM_OS_TRACE << std::endl << REPEAT("++++++++++", 10) << std::endl;
 	AVM_OS_TRACE << "ObjectiveTrace:> " << mDirectiveEC->str_min() << std::endl;
 	mPendingTrace.toStream(AVM_OS_TRACE, true);
 	AVM_OS_TRACE << REPEAT("++++++++++", 10) << std::endl;
 AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )

 	return( true );
 }


 bool AvmCoverageOneTraceDriver::updateCacheForDirectiveTraces(
 		const ExecutionContext & anEC)
 {
 	bool isUpdated = false;

 	if( //(mLastCollectedCoverCount == mCoverageStatistics.mNumberOfCovered) ||
 			mCacheForDirectiveTraces.empty() )
 	{
 		return( isUpdated );
 	}

 	endTrace = mCacheForDirectiveTraces.end();
 	for( itTrace = mCacheForDirectiveTraces.begin() ; itTrace != endTrace ; )
 	{
 		if( (*itTrace).mEC == (& anEC) )
 		{
 			isUpdated = true;

 			itTrace = mCacheForDirectiveTraces.erase( itTrace );
 		}
 		else
 		{
 			++itTrace;
 		}
 	}

 	return( isUpdated );
 }


 bool AvmCoverageOneTraceDriver::updateCacheForDirectiveTraces(
 		AvmTransition * aTransition)
 {
 	bool isUpdated = false;

 	mTransitionTargetHistory.remove( aTransition );

 	if( //(mLastCollectedCoverCount == mCoverageStatistics.mNumberOfCovered) ||
 			mCacheForDirectiveTraces.empty() )
 	{
 		return( isUpdated );
 	}

 	endTrace = mCacheForDirectiveTraces.end();
 	for( itTrace = mCacheForDirectiveTraces.begin() ; itTrace != endTrace ; )
 	{
 		tmpTransition = (*itTrace).backTransition();

 		if( tmpTransition == aTransition )
 		{
 			isUpdated = true;

 			itTrace = mCacheForDirectiveTraces.erase( itTrace );
 		}
 		else
 		{
 			++itTrace;
 		}
 	}

 	return( isUpdated );
 }


 bool AvmCoverageOneTraceDriver::updateCacheForDirectiveTraces()
 {
 //	mCacheForDirectiveTraces.clear();

 AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )
 	AVM_OS_TRACE << "updateCacheForDirectiveTraces:> size: "
 			<< mCacheForDirectiveTraces.size() << std::endl;
 AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )

 	updateTransitionTargetHistory();

 	bool isUpdated = false;

 	if( //(mLastCollectedCoverCount == mCoverageStatistics.mNumberOfCovered) ||
 			mCacheForDirectiveTraces.empty() )
 	{
 		return( isUpdated );
 	}

 	endTrace = mCacheForDirectiveTraces.end();
 	for( itTrace = mCacheForDirectiveTraces.begin() ; itTrace != endTrace ; )
 	{
 		tmpTransition = (*itTrace).backTransition();

 		if( (*itTrace).mEC->hasNext() )
 		{
 AVM_IF_DEBUG_LEVEL_FLAG2( HIGH , PROCESSOR , TRANSITION )
 	AVM_OS_TRACE << "remove<EC>";
 	(*itTrace).mEC->traceMinimum( AVM_OS_TRACE );
 	AVM_OS_TRACE << "\ttransition:> " << tmpTransition->getFullyQualifiedNameID() << std::endl;
 AVM_ENDIF_DEBUG_LEVEL_FLAG2( HIGH , PROCESSOR , TRANSITION )

 			isUpdated = true;

 			itTrace = mCacheForDirectiveTraces.erase( itTrace );
 		}
 		else if( mTransitionCoverage.testTransitionCoverage( tmpTransition ) )
 		{
 AVM_IF_DEBUG_LEVEL_FLAG2( HIGH , PROCESSOR , TRANSITION )
 	AVM_OS_TRACE << "remove<transition> ";
 	(*itTrace).mEC->traceMinimum( AVM_OS_TRACE );
 	AVM_OS_TRACE << "\ttransition:> " << tmpTransition->getFullyQualifiedNameID() << std::endl;
 AVM_ENDIF_DEBUG_LEVEL_FLAG2( HIGH , PROCESSOR , TRANSITION )

 			isUpdated = true;

 			itTrace = mCacheForDirectiveTraces.erase( itTrace );

 			mTransitionTargetHistory.remove( tmpTransition );
 		}
 		else
 		{

 AVM_IF_DEBUG_LEVEL_FLAG2( HIGH , PROCESSOR , TRANSITION )
 	AVM_OS_TRACE << "preserve :> "; (*itTrace).mEC->traceMinimum( AVM_OS_TRACE );
 	AVM_OS_TRACE << "\ttransition:> " << tmpTransition->getFullyQualifiedNameID() << std::endl;
 AVM_ENDIF_DEBUG_LEVEL_FLAG2( HIGH , PROCESSOR , TRANSITION )

 			++itTrace;
 		}
 	}

 AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )
 	AVM_OS_TRACE << "updateCacheForDirectiveTraces:> size<update>: "
 			<< mCacheForDirectiveTraces.size() << std::endl;
 AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )

 	return( isUpdated );
 }


 bool AvmCoverageOneTraceDriver::updateTransitionTargetHistory()
 {
 	bool isUpdated = false;

 	ListOfAvmTransition::iterator itTransition = mTransitionTargetHistory.begin();
 	ListOfAvmTransition::iterator endTransition = mTransitionTargetHistory.end();
 	for( ; itTransition != endTransition ; )
 	{
 		if( mTransitionCoverage.testTransitionCoverage( *itTransition ) )
 		{
 			itTransition = mTransitionTargetHistory.erase( itTransition );

 			isUpdated = true;
 		}
 		else
 		{
 			++itTransition;
 		}
 	}

 	return( isUpdated );
 }

 /**
  * Compute a directive trace
  */
 bool AvmCoverageOneTraceDriver::checkDirectiveTrace(
 		const ExecutionContext & anEC)
 {
 	mLocalUncoveredTransitions.clear();

 	mTransitionCoverage.collectUncoveredTransition(
 			anEC.refExecutionData(), mLocalUncoveredTransitions);

 AVM_IF_DEBUG_LEVEL_FLAG2( HIGH , PROCESSOR , TRANSITION )
 	AVM_OS_TRACE << "checkDirectiveTrace:> local uncovered transitions count: "
 			<< mLocalUncoveredTransitions.size() << std::endl;
 	VectorOfAvmTransition::const_iterator itTransition = mLocalUncoveredTransitions.begin();
 	VectorOfAvmTransition::const_iterator endTransition = mLocalUncoveredTransitions.end();
 	for( ; itTransition != endTransition ; ++itTransition )
 	{
 		AVM_OS_TRACE << "\t" << (*itTransition)->strTransitionHeader() << std::endl;
 	}
 AVM_ENDIF_DEBUG_LEVEL_FLAG2( HIGH , PROCESSOR , TRANSITION )

 	return( checkDirectiveTrace(anEC, mLocalUncoveredTransitions) );
 }


 bool AvmCoverageOneTraceDriver::checkDirectiveTrace(
 		const ExecutionContext & anEC,
 		const VectorOfAvmTransition & tableofTransitions)
 {
 AVM_IF_DEBUG_LEVEL_FLAG2( HIGH , PROCESSOR , TRANSITION )
 	AVM_OS_TRACE << std::endl << REPEAT("<<<<<<<<<<", 10) << std::endl;
 	AVM_OS_TRACE << "checkDirectiveTrace:> ";  anEC.traceMinimum(AVM_OS_TRACE);
 AVM_ENDIF_DEBUG_LEVEL_FLAG2( HIGH , PROCESSOR , TRANSITION )

 	itTransition = tableofTransitions.begin();
 	endTransition = tableofTransitions.end();
 	for( ; itTransition != endTransition ; ++itTransition )
 	{
 		if( computeDirectiveTrace(anEC, *itTransition) )
 		{
 			if( mPendingTrace.mSize < mDefaultPendingTraceSize )
 			{
 				return( true );
 			}
 			else
 			{
 				appendDirectiveTraces( mPendingTrace );
 			}
 		}
 	}

 	return( false );
 }


 bool AvmCoverageOneTraceDriver::drive()
 {
 AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )
 	AVM_OS_TRACE << std::endl << REPEAT("==========", 10) << std::endl;
 	AVM_OS_TRACE << "DirectiveTrace:> " << mDirectiveEC->str_min() << std::endl;
 	mPendingTrace.toStream(AVM_OS_TRACE);
 AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )

 	coverageMax = 0;

 	endTP = mPendingTrace.points.end();

 	endEC = mDirectiveEC->end();
 	for( itEC = mDirectiveEC->begin() ; itEC != endEC ; ++itEC )
 	{
 		coverageCount = 0;

 		for( itTP = mPendingTrace.points.begin() ; itTP != endTP ; ++itTP )
 		{
 			tmpTracePoint = (*itTP).to_ptr< TracePoint >();

 			if( mTraceChecker.isSatTransition(*(*itEC),
 					tmpTracePoint, (*itEC)->getRunnableElementTrace()) )
 			{
 				++coverageCount;
 			}
 			else
 			{
 				if( (coverageCount > 0) && tmpTracePoint->object->
 						as< AvmTransition >()->isUnstableSource() )
 				{
 					coverageCount = 0;
 				}

 				break;
 			}
 		}

 		if( coverageCount > coverageMax )
 		{
 			coverageMax = coverageCount;

 			mDirectiveEC = (*itEC);

 			mDirectiveEC->setWeight( WEIGHT_STRONGLY_ACHIEVABLE );
 		}
 		else
 		{
 			mTransitionCoverage.computeWeight( *itEC );

 //			(*itEC)->setWeight( WEIGHT_NON_PRIORITY );
 		}
 	}

 	if( coverageMax > 0 )
 	{
 		if( coverageMax < mPendingTrace.mSize )
 		{
 			mPendingTrace.pop_front( coverageMax );

 			mDirectiveEC->setWeight( WEIGHT_SELECTED_ACHIEVABLE );

 AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )
 	AVM_OS_TRACE << "HIT ! EC:> "; mDirectiveEC->traceMinimum(AVM_OS_TRACE);
 AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )
 		}
 		else
 		{
 			mTransitionTargetHistory.pop_front();

 			mPendingTrace.clear();

 AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )
 	AVM_OS_TRACE << "GOAL ACHIEVED !!!" << std::endl;
 AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )
 		}

 AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )
 	AVM_OS_TRACE << REPEAT("==========", 10) << std::endl;
 AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )

 		return( true );
 	}
 	else
 	{
 AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )
 	AVM_OS_TRACE << "GOAL FAILED !!!" << std::endl;
 	AVM_OS_TRACE << REPEAT("==========", 10) << std::endl;
 AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )

 		return( false );
 	}
 }


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

 void AvmCoverageOneTraceDriver::toStream(OutStream & os) const
 {
 	os << "Transition to reach :> ";

 	AvmTransition * aTransition = mPendingTrace.backTransition();

 	aTransition->toStreamHeader(os);
 	if( aTransition->hasInternalCommunicationCode() )
 	{
 		os << " ";
 		BaseCompiledForm::toStreamStaticCom(os,
 				aTransition->getInternalCommunicationCode());
 	}
 	os << EOL_FLUSH;

 	os << "Computed trace to reach it :> ";
 	mPendingTrace.toStream(os);

 	AVM_OS_TRACE << "GOAL " << ( goalAchieved() ? "ACHIEVED" : "FAILED" )
 			<< " !!!" << std::endl;
 }


 void AvmCoverageOneTraceDriver::toStreamCache(
 		OutStream & os, const std::string strMessage) const
 {
 	os << TAB << strMessage << "<size: " << mCacheForDirectiveTraces.size()
 			<< "> {" << EOL_INCR_INDENT;

 	ListOfAvmTraceProperty::const_iterator itTrace =
 			mCacheForDirectiveTraces.begin();
 	ListOfAvmTraceProperty::const_iterator endTrace =
 			mCacheForDirectiveTraces.end();
 	for( ; itTrace != endTrace ; ++itTrace )
 	{
 		(*itTrace).toStream(os, false);
 	}

 	os << TAB << "mTransitionTargetHistory<size: "
 			<< mTransitionTargetHistory.size() << ">" << EOL;
 	AvmTransition::toStream(os, mTransitionTargetHistory);

 	os << DECR_INDENT_TAB << "}" << EOL_FLUSH;
 }


 } /* 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: 19 nov. 2014
	*
	* Contributors:
	* Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr
	* - Initial API and implementation
	******************************************************************************/

	#include "AvmCoverageOneTraceDriver.h"

	#include "AvmCoverageProcessor.h"
	#include "AvmCoverageTransitionView.h"

	#include <fml/executable/AvmTransition.h>

	#include <fml/runtime/ExecutionContext.h>
	#include <fml/runtime/ExecutionData.h>
	#include <fml/runtime/RuntimeID.h>

	#include <fml/trace/TracePoint.h>

	#include <fam/coverage/AvmCoverageTransitionView.h>

	#include <fam/queue/WaitingStrategy.h>

	#include <sew/SymbexControllerRequestManager.h>

	#include <functional>


	namespace sep
	{


	/**
	* CONSTRUCTOR
	* Default
	*/
	AvmCoverageOneTraceDriver::AvmCoverageOneTraceDriver(
	AvmCoverageProcessor & aCoverageProcessor, EvaluationEnvironment & anENV,
	IHeuristicClass::ENUM_HEURISTIC_CLASS anHeuristicClass,
	avm_size_t pathCountLimit, avm_size_t pathSizeLimit)
	: AvmCoverageAbstractView( aCoverageProcessor , NULL ),
	mTransitionCoverage( aCoverageProcessor.mTransitionCoverage ),
	ENV( anENV ),
	mTraceChecker( anENV ),

	mComputingPathCountLimit( pathCountLimit ),
	mComputingPathSizeLimit( pathSizeLimit ),
	mPathChecker(anHeuristicClass, pathCountLimit, pathSizeLimit),

	mTransitionTargetHistory( ),

	mCacheForDirectiveTraces( ),
	mDirectiveEC( NULL ),

	mDefaultPendingTraceSize( 4 ),

	mPendingTrace( & aCoverageProcessor.mTransitionCoverage ),

	mWaitingQueue( ),

	mGlobalUncoveredTransitions( ),
	mLastCollectedCoverCount( 0 ),

	mLocalUncoveredTransitions( ),

	// Computing drive variable
	saveWeightMin( 0 ),

	coverageMax( 0 ),
	coverageCount( 0 ),

	tmpTracePoint( NULL ),
	itTP( ),
	endTP( ),

	tmpTransition( NULL ),
	itTransition( ),
	endTransition( ),

	itTrace( ),
	endTrace( )
	{
	// TODO Auto-generated constructor stub

	}


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

	bool AvmCoverageOneTraceDriver::configureImpl()
	{
	return( true );
	}


	////////////////////////////////////////////////////////////////////////////////
	// PROCESSOR FILTER API
	////////////////////////////////////////////////////////////////////////////////

	bool AvmCoverageOneTraceDriver::prefiltering(ListOfExecutionContext & ecQueue)
	{
	// endQueue = ecQueue.end();
	// for( itQueue = ecQueue.begin() ; itQueue != endQueue ; ++itQueue )
	// {
	//
	// }

	return( true );
	}

	bool AvmCoverageOneTraceDriver::postfiltering(ListOfExecutionContext & ecQueue)
	{
	itQueue = ecQueue.begin();
	endQueue = ecQueue.end();
	for( ; itQueue != endQueue ; ++itQueue )
	{
	if( (*itQueue) == mDirectiveEC )
	{
	if( drive() )
	{
	return( true );
	}
	}
	}

	mCoverageProcessor.setRequestRequeueWaiting();

	return( false );
	}



	////////////////////////////////////////////////////////////////////////////////
	// PROCESSOR REQUEST API
	////////////////////////////////////////////////////////////////////////////////
	/**
	* REQUEUE_WAITING
	*/
	bool AvmCoverageOneTraceDriver::requeueWaitingTable(
	WaitingStrategy & aWaitingStrategy,
	avm_uint8_t aWeightMin, avm_uint8_t aWeightMax)
	{
	// Global Update Cache for Directive Traces !!!
	updateCacheForDirectiveTraces();


	mWaitingQueue.clear();

	saveWeightMin = aWeightMin;

	aWeightMin = aWaitingStrategy.splicePriorQueueTable(
	mWaitingQueue, saveWeightMin, aWeightMax);

	// while( aWeightMin <= WEIGHT_WEAKLY_ACHIEVABLE )
	while( aWeightMin <= WEIGHT_NON_PRIORITY )
	{
	itQueue = mWaitingQueue.begin();
	endQueue = mWaitingQueue.end();
	for( ; itQueue != endQueue ; ++itQueue )
	{
	if( checkDirectiveTrace(* (*itQueue)) )
	{
	(*itQueue)->setWeight( WEIGHT_SELECTED_ACHIEVABLE );

	aWaitingStrategy.push( *itQueue );

	itQueue = mWaitingQueue.erase( itQueue );

	aWaitingStrategy.splice(aWeightMin, mWaitingQueue);

	return( setDirectiveTrace() );
	}
	}

	aWaitingStrategy.splice(aWeightMin, mWaitingQueue);

	aWeightMin = aWaitingStrategy.splicePriorQueueTable(
	mWaitingQueue, ++aWeightMin, aWeightMax);
	}

	aWaitingStrategy.splice(aWeightMin, mWaitingQueue);


	if( mGlobalUncoveredTransitions.empty() )
	{
	mLastCollectedCoverCount = mCoverageStatistics.mNumberOfCovered;

	mTransitionCoverage.collectUncoveredTransition(
	mGlobalUncoveredTransitions);
	}
	else if( mLastCollectedCoverCount < mCoverageStatistics.mNumberOfCovered )
	{
	mLastCollectedCoverCount = mCoverageStatistics.mNumberOfCovered;

	mTransitionCoverage.updateUncoveredTransition(
	mGlobalUncoveredTransitions);
	}


	aWeightMin = aWaitingStrategy.splicePriorQueueTable(
	mWaitingQueue, saveWeightMin, aWeightMax);

	while( aWeightMin <= WEIGHT_UNKNOWN_ACHIEVABLE )
	{
	itQueue = mWaitingQueue.begin();
	endQueue = mWaitingQueue.end();
	for( ; itQueue != endQueue ; ++itQueue )
	{
	if( checkDirectiveTrace((itQueue), mGlobalUncoveredTransitions) )
	{
	(*itQueue)->setWeight( WEIGHT_SELECTED_ACHIEVABLE );

	aWaitingStrategy.push( *itQueue );

	itQueue = mWaitingQueue.erase( itQueue );

	aWaitingStrategy.splice(aWeightMin, mWaitingQueue);

	return( setDirectiveTrace() );
	}
	}

	aWaitingStrategy.splice(aWeightMin, mWaitingQueue);

	aWeightMin = aWaitingStrategy.splicePriorQueueTable(
	mWaitingQueue, ++aWeightMin, aWeightMax);
	}

	aWaitingStrategy.splice(aWeightMin, mWaitingQueue);

	if( selectDirectiveTrace() )
	{
	aWaitingStrategy.remove( mDirectiveEC );

	mDirectiveEC->setWeight( WEIGHT_SELECTED_ACHIEVABLE );

	aWaitingStrategy.push( mDirectiveEC );

	AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )
	AVM_OS_TRACE << "selectDirectiveTrace :> ";
	mDirectiveEC->traceMinimum(AVM_OS_TRACE);
	aWaitingStrategy.toStream(AVM_OS_TRACE);
	AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )

	resetFailedTransitionTargetHistory();

	return( setDirectiveTrace() );
	}

	resetFailedTransitionTargetHistory();

	mCoverageProcessor.setRequestHeuristic();

	return( false );
	}


	////////////////////////////////////////////////////////////////////////////////
	// TRACE DRIVER API
	////////////////////////////////////////////////////////////////////////////////

	/**
	* UPDATE
	* mCacheForDirectiveTraces
	*/
	void AvmCoverageOneTraceDriver::appendDirectiveTraces(AvmTraceProperty & aTrace)
	{
	if( mCacheForDirectiveTraces.empty() )
	{
	mCacheForDirectiveTraces.push_back( aTrace );
	}
	// else if( aTrace.isInf( std::less<avm_size_t>(),
	// mCacheForDirectiveTraces.front() ) )
	else if( aTrace.sizeLT( mCacheForDirectiveTraces.front() ) )
	{
	mCacheForDirectiveTraces.push_front( aTrace );
	}
	else if( aTrace.sizeGT( mCacheForDirectiveTraces.back() ) )
	{
	mCacheForDirectiveTraces.push_back( aTrace );
	}
	else
	{
	itTrace = mCacheForDirectiveTraces.begin();
	endTrace = mCacheForDirectiveTraces.end();
	for( ; itTrace != endTrace ; ++itTrace )
	{
	if( aTrace.sizeLT( *itTrace ) )
	{
	break;
	}
	}
	mCacheForDirectiveTraces.insert(itTrace, aTrace);
	}
	}


	bool AvmCoverageOneTraceDriver::checkDirectiveContext(
	const ExecutionContext & aDirectiveEC, AvmTransition * aTransition)
	{
	itTrace = mCacheForDirectiveTraces.begin();
	endTrace = mCacheForDirectiveTraces.end();
	for( ; itTrace != endTrace ; ++itTrace )
	{
	if( ((& aDirectiveEC) == (*itTrace).mEC) &&
	(aTransition == (*itTrace).backTransition()) )
	{
	return( true );
	}
	}

	return( false );
	}


	bool AvmCoverageOneTraceDriver::computeDirectiveTrace(
	const ExecutionContext & aDirectiveEC, AvmTransition * aTransition)
	{
	AVM_IF_DEBUG_LEVEL_FLAG2( HIGH , PROCESSOR , TRANSITION )
	AVM_OS_TRACE << TAB << "AvmCoverageTraceDriver :>" << AVM_STR_INDENT;
	aDirectiveEC.traceMinimum(AVM_OS_TRACE);
	AVM_OS_TRACE << END_INDENT;
	AVM_OS_TRACE << " \|= " ; aTransition->toStreamHeader(AVM_OS_TRACE);
	AVM_OS_TRACE << std::endl;// << INCR_INDENT;
	// AvmTransition::toStream(AVM_OS_TRACE, mTransitionTargetHistory);
	// AVM_OS_TRACE << DECR_INDENT;
	AVM_ENDIF_DEBUG_LEVEL_FLAG2( HIGH , PROCESSOR , TRANSITION )


	// if( mTransitionTargetHistory.contains(aTransition) )
	// {
	// return( false );
	// }
	// else
	if( checkDirectiveContext(aDirectiveEC, aTransition) )
	{
	return( false );
	}
	else
	{
	mPendingTrace.clear();

	mDirectiveEC = const_cast< ExecutionContext *>( & aDirectiveEC );

	RuntimeID aRID = aDirectiveEC.refExecutionData().getRuntimeID(
	aTransition->getExecutable() );

	if( mPathChecker.computePath(mPendingTrace,
	mDirectiveEC, aRID, aTransition,
	mHeuristicProperty.mDirectiveTraceHeuristicClass,
	mHeuristicProperty.mDirectiveTraceCountLimit,
	mHeuristicProperty.mDirectiveTraceSizeLimit) )
	{
	mPendingTrace.mEC = (& aDirectiveEC);

	AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )
	mPathChecker.report(AVM_OS_COUT);
	mPathChecker.report(AVM_OS_TRACE);
	AVM_OS_TRACE << REPEAT(">>>>>>>>>>", 10) << std::endl;
	AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )

	return( true );
	}

	return( false );
	}
	}


	bool AvmCoverageOneTraceDriver::selectDirectiveTrace()
	{
	if( mCacheForDirectiveTraces.nonempty() )
	{
	toStreamCache( AVM_OS_TRACE , "selectDirectiveTrace" );

	mPendingTrace.clear();
	mPendingTrace.copyTrace( mCacheForDirectiveTraces.front() );

	mDirectiveEC = const_cast< ExecutionContext * >( mPendingTrace.mEC );

	mCacheForDirectiveTraces.pop_front();

	return( true );
	}

	return( false );
	}

	bool AvmCoverageOneTraceDriver::setDirectiveTrace()
	{
	mTransitionTargetHistory.push_front( mPendingTrace.backTransition() );

	AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )
	AVM_OS_TRACE << std::endl << REPEAT("++++++++++", 10) << std::endl;
	AVM_OS_TRACE << "ObjectiveTrace:> " << mDirectiveEC->str_min() << std::endl;
	mPendingTrace.toStream(AVM_OS_TRACE, true);
	AVM_OS_TRACE << REPEAT("++++++++++", 10) << std::endl;
	AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )

	return( true );
	}




	bool AvmCoverageOneTraceDriver::updateCacheForDirectiveTraces(
	const ExecutionContext & anEC)
	{
	bool isUpdated = false;

	if( //(mLastCollectedCoverCount == mCoverageStatistics.mNumberOfCovered) \|\|
	mCacheForDirectiveTraces.empty() )
	{
	return( isUpdated );
	}

	endTrace = mCacheForDirectiveTraces.end();
	for( itTrace = mCacheForDirectiveTraces.begin() ; itTrace != endTrace ; )
	{
	if( (*itTrace).mEC == (& anEC) )
	{
	isUpdated = true;

	itTrace = mCacheForDirectiveTraces.erase( itTrace );
	}
	else
	{
	++itTrace;
	}
	}

	return( isUpdated );
	}


	bool AvmCoverageOneTraceDriver::updateCacheForDirectiveTraces(
	AvmTransition * aTransition)
	{
	bool isUpdated = false;

	mTransitionTargetHistory.remove( aTransition );

	if( //(mLastCollectedCoverCount == mCoverageStatistics.mNumberOfCovered) \|\|
	mCacheForDirectiveTraces.empty() )
	{
	return( isUpdated );
	}

	endTrace = mCacheForDirectiveTraces.end();
	for( itTrace = mCacheForDirectiveTraces.begin() ; itTrace != endTrace ; )
	{
	tmpTransition = (*itTrace).backTransition();

	if( tmpTransition == aTransition )
	{
	isUpdated = true;

	itTrace = mCacheForDirectiveTraces.erase( itTrace );
	}
	else
	{
	++itTrace;
	}
	}

	return( isUpdated );
	}


	bool AvmCoverageOneTraceDriver::updateCacheForDirectiveTraces()
	{
	// mCacheForDirectiveTraces.clear();

	AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )
	AVM_OS_TRACE << "updateCacheForDirectiveTraces:> size: "
	<< mCacheForDirectiveTraces.size() << std::endl;
	AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )

	updateTransitionTargetHistory();

	bool isUpdated = false;

	if( //(mLastCollectedCoverCount == mCoverageStatistics.mNumberOfCovered) \|\|
	mCacheForDirectiveTraces.empty() )
	{
	return( isUpdated );
	}

	endTrace = mCacheForDirectiveTraces.end();
	for( itTrace = mCacheForDirectiveTraces.begin() ; itTrace != endTrace ; )
	{
	tmpTransition = (*itTrace).backTransition();

	if( (*itTrace).mEC->hasNext() )
	{
	AVM_IF_DEBUG_LEVEL_FLAG2( HIGH , PROCESSOR , TRANSITION )
	AVM_OS_TRACE << "remove<EC>";
	(*itTrace).mEC->traceMinimum( AVM_OS_TRACE );
	AVM_OS_TRACE << "\ttransition:> " << tmpTransition->getFullyQualifiedNameID() << std::endl;
	AVM_ENDIF_DEBUG_LEVEL_FLAG2( HIGH , PROCESSOR , TRANSITION )

	isUpdated = true;

	itTrace = mCacheForDirectiveTraces.erase( itTrace );
	}
	else if( mTransitionCoverage.testTransitionCoverage( tmpTransition ) )
	{
	AVM_IF_DEBUG_LEVEL_FLAG2( HIGH , PROCESSOR , TRANSITION )
	AVM_OS_TRACE << "remove<transition> ";
	(*itTrace).mEC->traceMinimum( AVM_OS_TRACE );
	AVM_OS_TRACE << "\ttransition:> " << tmpTransition->getFullyQualifiedNameID() << std::endl;
	AVM_ENDIF_DEBUG_LEVEL_FLAG2( HIGH , PROCESSOR , TRANSITION )

	isUpdated = true;

	itTrace = mCacheForDirectiveTraces.erase( itTrace );

	mTransitionTargetHistory.remove( tmpTransition );
	}
	else
	{

	AVM_IF_DEBUG_LEVEL_FLAG2( HIGH , PROCESSOR , TRANSITION )
	AVM_OS_TRACE << "preserve :> "; (*itTrace).mEC->traceMinimum( AVM_OS_TRACE );
	AVM_OS_TRACE << "\ttransition:> " << tmpTransition->getFullyQualifiedNameID() << std::endl;
	AVM_ENDIF_DEBUG_LEVEL_FLAG2( HIGH , PROCESSOR , TRANSITION )

	++itTrace;
	}
	}

	AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )
	AVM_OS_TRACE << "updateCacheForDirectiveTraces:> size<update>: "
	<< mCacheForDirectiveTraces.size() << std::endl;
	AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )

	return( isUpdated );
	}


	bool AvmCoverageOneTraceDriver::updateTransitionTargetHistory()
	{
	bool isUpdated = false;

	ListOfAvmTransition::iterator itTransition = mTransitionTargetHistory.begin();
	ListOfAvmTransition::iterator endTransition = mTransitionTargetHistory.end();
	for( ; itTransition != endTransition ; )
	{
	if( mTransitionCoverage.testTransitionCoverage( *itTransition ) )
	{
	itTransition = mTransitionTargetHistory.erase( itTransition );

	isUpdated = true;
	}
	else
	{
	++itTransition;
	}
	}

	return( isUpdated );
	}

	/**
	* Compute a directive trace
	*/
	bool AvmCoverageOneTraceDriver::checkDirectiveTrace(
	const ExecutionContext & anEC)
	{
	mLocalUncoveredTransitions.clear();

	mTransitionCoverage.collectUncoveredTransition(
	anEC.refExecutionData(), mLocalUncoveredTransitions);

	AVM_IF_DEBUG_LEVEL_FLAG2( HIGH , PROCESSOR , TRANSITION )
	AVM_OS_TRACE << "checkDirectiveTrace:> local uncovered transitions count: "
	<< mLocalUncoveredTransitions.size() << std::endl;
	VectorOfAvmTransition::const_iterator itTransition = mLocalUncoveredTransitions.begin();
	VectorOfAvmTransition::const_iterator endTransition = mLocalUncoveredTransitions.end();
	for( ; itTransition != endTransition ; ++itTransition )
	{
	AVM_OS_TRACE << "\t" << (*itTransition)->strTransitionHeader() << std::endl;
	}
	AVM_ENDIF_DEBUG_LEVEL_FLAG2( HIGH , PROCESSOR , TRANSITION )

	return( checkDirectiveTrace(anEC, mLocalUncoveredTransitions) );
	}


	bool AvmCoverageOneTraceDriver::checkDirectiveTrace(
	const ExecutionContext & anEC,
	const VectorOfAvmTransition & tableofTransitions)
	{
	AVM_IF_DEBUG_LEVEL_FLAG2( HIGH , PROCESSOR , TRANSITION )
	AVM_OS_TRACE << std::endl << REPEAT("<<<<<<<<<<", 10) << std::endl;
	AVM_OS_TRACE << "checkDirectiveTrace:> "; anEC.traceMinimum(AVM_OS_TRACE);
	AVM_ENDIF_DEBUG_LEVEL_FLAG2( HIGH , PROCESSOR , TRANSITION )

	itTransition = tableofTransitions.begin();
	endTransition = tableofTransitions.end();
	for( ; itTransition != endTransition ; ++itTransition )
	{
	if( computeDirectiveTrace(anEC, *itTransition) )
	{
	if( mPendingTrace.mSize < mDefaultPendingTraceSize )
	{
	return( true );
	}
	else
	{
	appendDirectiveTraces( mPendingTrace );
	}
	}
	}

	return( false );
	}


	bool AvmCoverageOneTraceDriver::drive()
	{
	AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )
	AVM_OS_TRACE << std::endl << REPEAT("==========", 10) << std::endl;
	AVM_OS_TRACE << "DirectiveTrace:> " << mDirectiveEC->str_min() << std::endl;
	mPendingTrace.toStream(AVM_OS_TRACE);
	AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )

	coverageMax = 0;

	endTP = mPendingTrace.points.end();

	endEC = mDirectiveEC->end();
	for( itEC = mDirectiveEC->begin() ; itEC != endEC ; ++itEC )
	{
	coverageCount = 0;

	for( itTP = mPendingTrace.points.begin() ; itTP != endTP ; ++itTP )
	{
	tmpTracePoint = (*itTP).to_ptr< TracePoint >();

	if( mTraceChecker.isSatTransition((itEC),
	tmpTracePoint, (*itEC)->getRunnableElementTrace()) )
	{
	++coverageCount;
	}
	else
	{
	if( (coverageCount > 0) && tmpTracePoint->object->
	as< AvmTransition >()->isUnstableSource() )
	{
	coverageCount = 0;
	}

	break;
	}
	}

	if( coverageCount > coverageMax )
	{
	coverageMax = coverageCount;

	mDirectiveEC = (*itEC);

	mDirectiveEC->setWeight( WEIGHT_STRONGLY_ACHIEVABLE );
	}
	else
	{
	mTransitionCoverage.computeWeight( *itEC );

	// (*itEC)->setWeight( WEIGHT_NON_PRIORITY );
	}
	}

	if( coverageMax > 0 )
	{
	if( coverageMax < mPendingTrace.mSize )
	{
	mPendingTrace.pop_front( coverageMax );

	mDirectiveEC->setWeight( WEIGHT_SELECTED_ACHIEVABLE );

	AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )
	AVM_OS_TRACE << "HIT ! EC:> "; mDirectiveEC->traceMinimum(AVM_OS_TRACE);
	AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )
	}
	else
	{
	mTransitionTargetHistory.pop_front();

	mPendingTrace.clear();

	AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )
	AVM_OS_TRACE << "GOAL ACHIEVED !!!" << std::endl;
	AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )
	}

	AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )
	AVM_OS_TRACE << REPEAT("==========", 10) << std::endl;
	AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )

	return( true );
	}
	else
	{
	AVM_IF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )
	AVM_OS_TRACE << "GOAL FAILED !!!" << std::endl;
	AVM_OS_TRACE << REPEAT("==========", 10) << std::endl;
	AVM_ENDIF_DEBUG_LEVEL_FLAG2( MEDIUM , PROCESSOR , TRANSITION )

	return( false );
	}
	}


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

	void AvmCoverageOneTraceDriver::toStream(OutStream & os) const
	{
	os << "Transition to reach :> ";

	AvmTransition * aTransition = mPendingTrace.backTransition();

	aTransition->toStreamHeader(os);
	if( aTransition->hasInternalCommunicationCode() )
	{
	os << " ";
	BaseCompiledForm::toStreamStaticCom(os,
	aTransition->getInternalCommunicationCode());
	}
	os << EOL_FLUSH;

	os << "Computed trace to reach it :> ";
	mPendingTrace.toStream(os);

	AVM_OS_TRACE << "GOAL " << ( goalAchieved() ? "ACHIEVED" : "FAILED" )
	<< " !!!" << std::endl;
	}


	void AvmCoverageOneTraceDriver::toStreamCache(
	OutStream & os, const std::string strMessage) const
	{
	os << TAB << strMessage << "<size: " << mCacheForDirectiveTraces.size()
	<< "> {" << EOL_INCR_INDENT;

	ListOfAvmTraceProperty::const_iterator itTrace =
	mCacheForDirectiveTraces.begin();
	ListOfAvmTraceProperty::const_iterator endTrace =
	mCacheForDirectiveTraces.end();
	for( ; itTrace != endTrace ; ++itTrace )
	{
	(*itTrace).toStream(os, false);
	}

	os << TAB << "mTransitionTargetHistory<size: "
	<< mTransitionTargetHistory.size() << ">" << EOL;
	AvmTransition::toStream(os, mTransitionTargetHistory);

	os << DECR_INDENT_TAB << "}" << EOL_FLUSH;
	}





	} /* namespace sep */