Method MoveTo_StopBeforePhase

Core/KernelSML/src/sml_RunScheduler.cpp:467–556

* @brief Users and applications can choose to have agents always * stop before a particular phase. If all agents have finished * finished running, this routine will check whether they * need to be stepped to a different phase. *********************************************************************/

*            need to be stepped to a different phase.
*********************************************************************/
void RunScheduler::MoveTo_StopBeforePhase(bool forever, smlRunStepSize runStepSize)
{
    // If we ran by decision_cycle and we've run the appropriate number of decisions,
    // then  step agent until it reached the correct phase where it should stop.
    // Just before this point, (in scheduler while loop) we've checked and fired the
    // OutputComplete and OutputGenerated events, so it should be fine to step
    // an agent by phases until it gets to StopBefore, and then step the other
    // agents in turn.
    //
    // If an interrupt was requested, it will be detected inside StepInClientThread
    // and the appropriate events will be generated.  The runResult will come back as
    // INTERRUPTED, and the while loops will exit so that the run stops.
    //
    // Support for "Run 0" is somewhat complicated, since we might very well
    // cross the I/O boundary.  So we'll try stepping til OUTPUT done, then generate
    // Update events, then step again til StopBeforePt is reached.  Note:  when we support
    // StopBeforeUpdateWorld, we'll need to explicitly check for that before generating events.
    
    if ((runStepSize == sml_DECISION) || forever)
    {
        for (AgentMapIter iter = m_pKernelSML->m_AgentMap.begin() ; iter != m_pKernelSML->m_AgentMap.end() ; iter++)
        {
            AgentSML* pAgentSML = iter->second ;
            if (pAgentSML->WasAgentOnRunList())
            {
                AgentSML* pAgent = pAgentSML ;
                smlPhase phase = pAgentSML->GetCurrentPhase() ;
                smlRunResult runResult = pAgentSML->GetResultOfLastRun() ;
                
                // as in Bug 648, it's possible that a client has requested STOP_AFTER_DECISION
                // while the agent was stopped at the m_StopBeforePhase, yet the agent run logic has
                // dropped thru to this point without generating the interrupt yet.
                if ((m_StopBeforePhase == phase) && (pAgent->GetRunState() == sml_RUNSTATE_STOPPED) &&
                        (pAgent->GetInterruptFlags() & sml_STOP_AFTER_DECISION_CYCLE))
                {
                    pAgent->SetRunState(sml_RUNSTATE_INTERRUPTED);
                    runResult = pAgent->StepInClientThread(sml_PHASE) ; // force interrupt
                }
                
                while ((phase != m_StopBeforePhase) && (sml_RUN_COMPLETED == runResult))
                {
                    runResult = pAgent->StepInClientThread(sml_PHASE) ;
                    phase = pAgentSML->GetCurrentPhase() ;
                    // don't cross Output-Input boundary here just to get to StopBefore phase for "Run 0"
                    if (sml_INPUT_PHASE == phase)
                    {
                        break;
                    }
                }
                pAgentSML->SetResultOfRun(runResult) ;
                
                // Notify listeners that this agent is finished running
                /* pAgent->FireRunEndsEvent() ; */   // not if supporting run0 over O/I boundary
            }
        }
        // If agents haven't reached the StopBeforePhase, then agents finished output
        // and we need to possibly generate the UpdateWorld events before stepping any further.
        // If not all agents finished output, then nothing will fire.