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