X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FGraphExecutor%2FDataFlowExecutor_FiniteStateMachine.cxx;h=f43eb79f471679a6b37b18e9939950a66dcb90a4;hb=dad24b20fb0b0c18474caa7cb5b94652408b6743;hp=544945580357759f1345efabfff1d4e523e6d0c5;hpb=c46f174ce52809de76f2a22795db89d229aedc7e;p=modules%2Fsuperv.git diff --git a/src/GraphExecutor/DataFlowExecutor_FiniteStateMachine.cxx b/src/GraphExecutor/DataFlowExecutor_FiniteStateMachine.cxx index 5449455..f43eb79 100644 --- a/src/GraphExecutor/DataFlowExecutor_FiniteStateMachine.cxx +++ b/src/GraphExecutor/DataFlowExecutor_FiniteStateMachine.cxx @@ -45,41 +45,43 @@ void * start_function( void *p ) ; #define ToKillDoneState SUPERV::ToKillDoneState #define ToStopState SUPERV::ToStopState +#if 0 // States : -#define UnKnownState SUPERV::UnKnownState -#define DataUndefState SUPERV::DataUndefState -#define DataWaitingState SUPERV::DataWaitingState -#define DataReadyState SUPERV::DataReadyState -#define SuspendedReadyState SUPERV::SuspendedReadyState -#define SuspendedReadyToResumeState SUPERV::SuspendedReadyToResumeState -#define ResumedReadyState SUPERV::ResumedReadyState -#define KilledReadyState SUPERV::KilledReadyState -#define StoppedReadyState SUPERV::StoppedReadyState -#define ExecutingState SUPERV::ExecutingState -#define SuspendedExecutingState SUPERV::SuspendedExecutingState -#define ResumedExecutingState SUPERV::ResumedExecutingState -#define KilledExecutingState SUPERV::KilledExecutingState -#define StoppedExecutingState SUPERV::StoppedExecutingState -#define SuccessedExecutingState SUPERV::SuccessedExecutingState -#define ErroredExecutingState SUPERV::ErroredExecutingState -#define SuspendedSuccessedState SUPERV::SuspendedSuccessedState -#define SuspendedErroredState SUPERV::SuspendedErroredState -#define SuspendedSuccessedToReStartState SUPERV::SuspendedSuccessedToReStartState -#define SuspendedErroredToReStartState SUPERV::SuspendedErroredToReStartState -#define ResumedSuccessedState SUPERV::ResumedSuccessedState -#define ResumedErroredState SUPERV::ResumedErroredState -#define KilledSuccessedState SUPERV::KilledSuccessedState -#define KilledErroredState SUPERV::KilledErroredState -#define StoppedSuccessedState SUPERV::StoppedSuccessedState -#define StoppedErroredState SUPERV::StoppedErroredState -#define SuccessedState SUPERV::SuccessedState -#define ErroredState SUPERV::ErroredState -#define SuspendedState SUPERV::SuspendedState -#define KilledState SUPERV::KilledState -#define StoppedState SUPERV::StoppedState -#define ReRunnedState SUPERV::ReRunnedState -#define ReStartedState SUPERV::ReStartedState -#define NumberOfAutomatonStates SUPERV::NumberOfAutomatonStates +#define UnKnownState GraphExecutor::UnKnownState +#define DataUndefState GraphExecutor::DataUndefState +#define DataWaitingState GraphExecutor::DataWaitingState +#define DataReadyState GraphExecutor::DataReadyState +#define SuspendedReadyState GraphExecutor::SuspendedReadyState +#define SuspendedReadyToResumeState GraphExecutor::SuspendedReadyToResumeState +#define ResumedReadyState GraphExecutor::ResumedReadyState +#define KilledReadyState GraphExecutor::KilledReadyState +#define StoppedReadyState GraphExecutor::StoppedReadyState +#define ExecutingState GraphExecutor::ExecutingState +#define SuspendedExecutingState GraphExecutor::SuspendedExecutingState +#define ResumedExecutingState GraphExecutor::ResumedExecutingState +#define KilledExecutingState GraphExecutor::KilledExecutingState +#define StoppedExecutingState GraphExecutor::StoppedExecutingState +#define SuccessedExecutingState GraphExecutor::SuccessedExecutingState +#define ErroredExecutingState GraphExecutor::ErroredExecutingState +#define SuspendedSuccessedState GraphExecutor::SuspendedSuccessedState +#define SuspendedErroredState GraphExecutor::SuspendedErroredState +#define SuspendedSuccessedToReStartState GraphExecutor::SuspendedSuccessedToReStartState +#define SuspendedErroredToReStartState GraphExecutor::SuspendedErroredToReStartState +#define ResumedSuccessedState GraphExecutor::ResumedSuccessedState +#define ResumedErroredState GraphExecutor::ResumedErroredState +#define KilledSuccessedState GraphExecutor::KilledSuccessedState +#define KilledErroredState GraphExecutor::KilledErroredState +#define StoppedSuccessedState GraphExecutor::StoppedSuccessedState +#define StoppedErroredState GraphExecutor::StoppedErroredState +#define SuccessedState GraphExecutor::SuccessedState +#define ErroredState GraphExecutor::ErroredState +#define SuspendedState GraphExecutor::SuspendedState +#define KilledState GraphExecutor::KilledState +#define StoppedState GraphExecutor::StoppedState +#define ReStartedState GraphExecutor::ReStartedState +#define LoadingState GraphExecutor::LoadingState +#define NumberOfAutomatonStates GraphExecutor::NumberOfAutomatonStates +#endif // Events : #define UndefinedEvent GraphExecutor::UndefinedEvent @@ -123,7 +125,7 @@ void * start_function( void *p ) ; #define NumberOfEvents GraphExecutor::NumberOfEvents GraphExecutor::FiniteStateMachine::FiniteStateMachine() { -// cdebug_in << "FiniteStateMachine::FiniteStateMachine" << endl; + MESSAGE( "FiniteStateMachine::FiniteStateMachine" ) ; _ControlStateName[ VoidState ] = "VoidState" ; _ControlStateName[ ToSuspendStartState ]= "ToSuspendStartState" ; @@ -164,8 +166,8 @@ GraphExecutor::FiniteStateMachine::FiniteStateMachine() { _StateName[ SuspendedState ] = "SuspendedState" ; _StateName[ KilledState ] = "KilledState" ; _StateName[ StoppedState ] = "StoppedState" ; - _StateName[ ReRunnedState ] = "ReRunnedState" ; _StateName[ ReStartedState ] = "ReStartedState" ; + _StateName[ LoadingState ] = "LoadingState" ; _EventName[ UndefinedEvent ] = "UndefinedEvent" ; _EventName[ NewThreadEvent ] = "NewThreadEvent" ; @@ -227,7 +229,8 @@ GraphExecutor::FiniteStateMachine::FiniteStateMachine() { _ActionName[ Executing_StopAction ] = "Executing_StopAction" ; _ActionName[ Executing_SuccessAction ] = "Executing_SuccessAction" ; - _ActionName[ Executing_ErrorAction ] = "Executing_ErrorAction" ; +// _ActionName[ Executing_ErrorAction ] = "Executing_ErrorAction" ; + _ActionName[ Errored_ExecutingAction ] = "Errored_ExecutingAction" ; _ActionName[ Successed_SuccessAction ] = "Successed_SuccessAction" ; _ActionName[ Errored_ErrorAction ] = "Errored_ErrorAction" ; @@ -259,8 +262,6 @@ GraphExecutor::FiniteStateMachine::FiniteStateMachine() { _GraphStateName[ SUPERV::SuspendErroredState ] = "SuspendErroredState" ; _GraphStateName[ SUPERV::KillState ] = "KillState" ; _GraphStateName[ SUPERV::StopState ] = "StopState" ; - _GraphStateName[ SUPERV::ReRunState ] = "ReRunState" ; - _GraphStateName[ SUPERV::ReStartState ] = "ReStartState" ; int i , j ; // NewStates = _TransitionTable[ States ] [ Events ] @@ -268,7 +269,7 @@ GraphExecutor::FiniteStateMachine::FiniteStateMachine() { for ( i = 0 ; i < NumberOfAutomatonStates ; i++ ) { for ( j = 0 ; j < NumberOfEvents ; j++ ) { // id est = SameState and VoidAction - _TransitionTable[ i ][ j ] = (SUPERV::AutomatonState ) i ; + _TransitionTable[ i ][ j ] = (GraphExecutor::AutomatonState ) i ; _ActionTable[ i ][ j ] = GraphExecutor::ErrorAction ; } } @@ -283,6 +284,8 @@ GraphExecutor::FiniteStateMachine::FiniteStateMachine() { // SomeDataReadyEvent : _TransitionTable[ DataWaitingState ][ SomeDataReadyEvent ] = DataUndefState ; _ActionTable[ DataUndefState ][ SomeDataReadyEvent ] = DataWaiting_SomeDataReadyAction; + _TransitionTable[ DataReadyState ][ SomeDataReadyEvent ] = DataUndefState ; + _ActionTable[ DataUndefState ][ SomeDataReadyEvent ] = DataWaiting_SomeDataReadyAction; // NotAllDataReadyEvent : _TransitionTable[ DataUndefState ][ NotAllDataReadyEvent ] = DataWaitingState ; _ActionTable[ DataWaitingState ][ NotAllDataReadyEvent ] = DataUndef_NotAllDataReadyAction; @@ -353,12 +356,19 @@ GraphExecutor::FiniteStateMachine::FiniteStateMachine() { // SuspendedExecutingState : NO ResumeEvent 13-03-2003 _TransitionTable[ SuspendedExecutingState ][ SuccessEvent ] = SuccessedExecutingState ; _ActionTable[ SuccessedExecutingState ][ SuccessEvent ] = Executing_SuccessAction; +//JR 24.03.2005 : Debug for PAL8176 : abort of GOTONode +// ErrorEvent + _TransitionTable[ SuccessedState ][ ErrorEvent ] = ErroredExecutingState ; +// _ActionTable[ ErroredExecutingState ][ ErrorEvent ] = Executing_ErrorAction; + _ActionTable[ ErroredExecutingState ][ ErrorEvent ] = Errored_ExecutingAction; // ErrorEvent _TransitionTable[ ExecutingState ][ ErrorEvent ] = ErroredExecutingState ; - _ActionTable[ ErroredExecutingState ][ ErrorEvent ] = Executing_ErrorAction; +// _ActionTable[ ErroredExecutingState ][ ErrorEvent ] = Executing_ErrorAction; + _ActionTable[ ErroredExecutingState ][ ErrorEvent ] = Errored_ExecutingAction; // SuspendedExecutingState : NO ResumeEvent 13-03-2003 _TransitionTable[ SuspendedExecutingState ][ ErrorEvent ] = ErroredExecutingState ; - _ActionTable[ ErroredExecutingState ][ ErrorEvent ] = Executing_ErrorAction; +// _ActionTable[ ErroredExecutingState ][ ErrorEvent ] = Executing_ErrorAction; + _ActionTable[ ErroredExecutingState ][ ErrorEvent ] = Errored_ExecutingAction; // DONE-CONTROL : // SuccessedExecutingState - SuccessEvent @@ -451,8 +461,17 @@ GraphExecutor::FiniteStateMachine::FiniteStateMachine() { perror( msg ) ; } -// cdebug_out << "FiniteStateMachine::FiniteStateMachine _TransitionTable " -// << endl; +#if omniORB_4_0_5 + _SuperVisionComponent = SUPERV::SuperG::_nil() ; +#endif + + pthread_mutex_init( &_MutexPythonWait , NULL ) ; + _MutexPythonLocked = false ; + _ExecNumber = 0 ; + _GraphExecutingNumber = 0 ; + _PyInitModule = false ; + _DbgFileNumber = 0 ; + MESSAGE( "FiniteStateMachine::FiniteStateMachine _TransitionTable " ) ; } void * start_function( void *p ) { @@ -469,31 +488,224 @@ void * start_function( void *p ) { pthread_exit( PTHREAD_CANCELED ) ; } +int GraphExecutor::FiniteStateMachine::ExecNumber() { + PyLock() ; + _ExecNumber += 1 ; + int RetVal = _ExecNumber ; + _GraphExecutingNumber += 1 ; + PyUnLock() ; + return RetVal ; +} + +void GraphExecutor::FiniteStateMachine::Executed() { + PyLock() ; + _GraphExecutingNumber -= 1 ; + if ( _GraphExecutingNumber == 0 ) { + map< string , PyObject * >::iterator aPyFunction ; + for ( aPyFunction = _MapOfPyFunctions.begin() ; aPyFunction != _MapOfPyFunctions.end() ; aPyFunction++ ) { + if ( !strcmp( aPyFunction->first.c_str() , "PyObjRef" ) || + !strcmp( aPyFunction->first.c_str() , "PyObjIor" ) ) { + MESSAGE( "GraphExecutor::FiniteStateMachine::Executed " << aPyFunction->first << " keeped ..." + ) ; + } + else { + MESSAGE( "GraphExecutor::FiniteStateMachine::Executed " << aPyFunction->first << " erased ..." + ) ; + _MapOfPyFunctions.erase( aPyFunction->first ) ; + } + } + } + else { + MESSAGE( "GraphExecutor::FiniteStateMachine::Executed _GraphExecutingNumber " + << _GraphExecutingNumber << " != 0 ==> no erase" ) ; + } + PyUnLock() ; + return ; +} + +void GraphExecutor::FiniteStateMachine::PyInitModule( bool aPyInitModule ) { + _PyInitModule = aPyInitModule ; +} + +bool GraphExecutor::FiniteStateMachine::PyInitModule() { + bool InitedModule = _PyInitModule ; + _PyInitModule = true ; + return InitedModule ; +} + +void GraphExecutor::FiniteStateMachine::PyLock() { +// cout << pthread_self() << " GraphExecutor::FiniteStateMachine::PyLock " << &_MutexPythonWait << endl ; + if ( pthread_mutex_lock( &_MutexPythonWait ) ) { + perror( "GraphExecutor::FiniteStateMachine::PyLock" ) ; + exit( 0 ) ; + } + _MutexPythonLocked = true ; +// cout << pthread_self() << " GraphExecutor::FiniteStateMachine::PyLocked " << &_MutexPythonWait << endl ; +} + +void GraphExecutor::FiniteStateMachine::PyUnLock() { +// cout << pthread_self() << " GraphExecutor::FiniteStateMachine::PyUnLock " << &_MutexPythonWait << endl ; + if ( pthread_mutex_unlock( &_MutexPythonWait ) ) { + perror( "GraphExecutor::FiniteStateMachine::PyUnLock" ) ; + exit( 0 ) ; + } + _MutexPythonLocked = false ; +// cout << pthread_self() << " GraphExecutor::FiniteStateMachine::PyUnLocked " << &_MutexPythonWait << endl ; +} + +void GraphExecutor::FiniteStateMachine::PyLockReset() { + if ( _MutexPythonLocked ) { + PyUnLock() ; + } +} + +#define PyFunctionTrace 1 +PyObject * GraphExecutor::FiniteStateMachine::PyFunction( const char * aPyFuncName ) { + + PyObject * RetVal = NULL ; + bool PyObjRefIor = !strcmp( aPyFuncName , "PyObjRef" ) || !strcmp( aPyFuncName , "PyObjIor" ) ; + PyObject * PyFunctionMapped = _MapOfPyFunctions[ aPyFuncName ] ; + if ( _GraphExecutingNumber > 1 && !PyObjRefIor ) { + RetVal = PyFunctionMapped ; +#if PyFunctionTrace + MESSAGE( "GraphExecutor::FiniteStateMachine::PyFunction( '" << aPyFuncName << "' ) --> " ) ; + if ( RetVal ) { + MESSAGE( RetVal << " ob_refcnt " << RetVal->ob_refcnt ) ; + } + else { + MESSAGE( " NULL" ) ; + } +#endif + } + else { + RetVal = PyFunctionMapped ; +#if PyFunctionTrace + MESSAGE( "GraphExecutor::FiniteStateMachine::PyFunction( '" << aPyFuncName << "' ) --> " ) ; + if ( RetVal && PyObjRefIor ) { + MESSAGE( RetVal << " " << RetVal->ob_refcnt ) ; + } + else if ( RetVal ) { + MESSAGE( RetVal << " " << RetVal->ob_refcnt ) ; + } + else { + MESSAGE( " NULL" ) ; + } +#endif + } + + return RetVal ; +} + +bool GraphExecutor::FiniteStateMachine::PyFunction( const char * aPyFuncName , PyObject * aPyFunction ) { + + bool RetVal = false ; + if ( _MapOfPyFunctions[ aPyFuncName ] != NULL ) { +#if PyFunctionTrace + PyObject * aPyFunc = _MapOfPyFunctions[ aPyFuncName ] ; + MESSAGE( "GraphExecutor::FiniteStateMachine::PyFunction( '" << aPyFuncName << "' , aPyFunction " + << aPyFunction << " ) ob_refcnt " << aPyFunction->ob_refcnt << " already mapped : " + << aPyFunc << " ob_refcnt " << aPyFunc->ob_refcnt ) ; +#endif + } + else { + _MapOfPyFunctions[ aPyFuncName ] = aPyFunction ; +#if PyFunctionTrace + MESSAGE( "GraphExecutor::FiniteStateMachine::PyFunction( '" << aPyFuncName << "' ) " << aPyFunction + << " ) ob_refcnt " << aPyFunction->ob_refcnt << " mapped" ) ; +#endif + RetVal = true ; + } + + return RetVal ; +} + +bool GraphExecutor::FiniteStateMachine::ErasePyFunction( const char * aPyFuncName ) { + +#if PyFunctionTrace + MESSAGE( "GraphExecutor::FiniteStateMachine::ErasePyFunction( '" << aPyFuncName << "' )" ) ; +#endif + if ( _MapOfPyFunctions[ aPyFuncName ] != NULL ) { + _MapOfPyFunctions.erase( aPyFuncName ) ; + return true ; + } + return false ; +} + +/* +GraphBase::Graph * GraphExecutor::FiniteStateMachine::MapGraph( const char * aGraphName ) { + GraphBase::Graph * aGraph = _MapOfGraphs[ aGraphName ] ; + //cout << "MapGraph " << aGraphName << " --> " << aGraph << endl ; + return aGraph ; +} + +bool GraphExecutor::FiniteStateMachine::MapGraph( GraphBase::Graph * aGraph , const char * aGraphName ) { + if ( MapGraph( aGraphName ) ) { + return false ; + } + _MapOfGraphs[ aGraphName ] = aGraph ; + return true ; +} + +void GraphExecutor::FiniteStateMachine::EraseGraph( const char * aGraphName ) { + _MapOfGraphs.erase( aGraphName ) ; +} + +bool GraphExecutor::FiniteStateMachine::GraphName( const char * aGraphName ) { + return _MapOfGraphNames[ aGraphName ] ; +} + +string GraphExecutor::FiniteStateMachine::GraphInstanceName( const char * aGraphName ) { + int GraphInstanceNumber = _MapOfGraphNames[ aGraphName ] ; + if ( GraphInstanceNumber ) { + _MapOfGraphNames[ aGraphName ] = GraphInstanceNumber + 1 ; + } + else { + GraphInstanceNumber = 0 ; + _MapOfGraphNames[ aGraphName ] = GraphInstanceNumber + 1 ; + } + string theGraphInstanceName = string( aGraphName ) ; + if ( GraphInstanceNumber ) { + theGraphInstanceName += "_" ; + ostringstream astr ; +// astr << GraphInstanceNumber << ends ; + astr << GraphInstanceNumber ; + theGraphInstanceName += astr.str() ; + } + //cout << "GraphExecutor::FiniteStateMachine::GraphInstanceName( " << aGraphName << " ) --> " + // << theGraphInstanceName << endl ; + return theGraphInstanceName ; +} +*/ + void GraphExecutor::FiniteStateMachine::JoinThread() { if ( pthread_mutex_lock( &_MutexJoinWait ) ) { - perror("Join pthread_mutex_lock ") ; + perror("FiniteStateMachine:JoinThread pthread_mutex_lock ") ; exit( 0 ) ; } while ( _JoinThread ) { while ( _ThreadList.size() == 0) { -// MESSAGE( pthread_self() << " Join pthread_cond_wait" ); +// MESSAGE( pthread_self() << " FiniteStateMachine:Join pthread_cond_wait" ); if ( pthread_cond_wait( &_JoinWait , &_MutexJoinWait ) ) { - perror("Join pthread_cond_wait ") ; + perror("FiniteStateMachine:JoinThread pthread_cond_wait ") ; } } pthread_t _Thread = _ThreadList.front() ; -// MESSAGE( pthread_self() << " Join pthread_cond_waited : " << _Thread ) - _ThreadList.pop_front() ; -// MESSAGE( pthread_self() << " Join pthread_join : " << _Thread ); +// MESSAGE( pthread_self() << " FiniteStateMachine:JoinThread pthread_cond_waited : " << _Thread ) +// MESSAGE( pthread_self() << " FiniteStateMachine:JoinThread pthread_join : " << _Thread ); int joinsts = pthread_join( _Thread , NULL ) ; -// MESSAGE( pthread_self() << " Join pthread_joined : " << _Thread ); if ( joinsts ) { - perror("Join pthread_join ") ; -// exit( 0 ) ; + perror("FiniteStateMachine:JoinThread pthread_join ") ; + MESSAGE( pthread_self() << " FiniteStateMachine:JoinThread pthread_join : " << _Thread + << " Error" ); + exit( 0 ) ; + } + else { +// MESSAGE( pthread_self() << " FiniteStateMachine:JoinThread pthread_joined : " << _Thread ); + _ThreadList.pop_front() ; } } if ( pthread_mutex_unlock( &_MutexJoinWait ) ) { - perror("Join pthread_mutex_unlock ") ; + perror("FiniteStateMachine:JoinThread pthread_mutex_unlock ") ; exit( 0 ) ; } } @@ -516,3 +728,112 @@ void GraphExecutor::FiniteStateMachine::JoinThread( pthread_t aThread ) { } } +ostream & operator<< (ostream &f ,const GraphExecutor::AutomatonState & aState ) { + switch (aState) { + case GraphExecutor::UnKnownState : + f << "UnKnownState"; + break; + case GraphExecutor::DataUndefState : + f << "DataUndefState"; + break; + case GraphExecutor::DataWaitingState : + f << "DataWaitingState"; + break; + case GraphExecutor::DataReadyState : + f << "DataReadyState"; + break; + case GraphExecutor::SuspendedReadyState : + f << "SuspendedReadyState"; + break; + case GraphExecutor::SuspendedReadyToResumeState : + f << "SuspendedReadyToResumeState"; + break; + case GraphExecutor::ResumedReadyState : + f << "ResumedReadyState"; + break; + case GraphExecutor::KilledReadyState : + f << "KilledReadyState"; + break; + case GraphExecutor::StoppedReadyState : + f << "StoppedReadyState"; + break; + case GraphExecutor::ExecutingState : + f << "ExecutingState"; + break; + case GraphExecutor::SuspendedExecutingState : + f << "SuspendedExecutingState"; + break; + case GraphExecutor::ResumedExecutingState : + f << "ResumedExecutingState"; + break; + case GraphExecutor::KilledExecutingState : + f << "KilledExecutingState"; + break; + case GraphExecutor::StoppedExecutingState : + f << "StoppedExecutingState"; + break; + case GraphExecutor::SuccessedExecutingState : + f << "SuccessedExecutingState"; + break; + case GraphExecutor::ErroredExecutingState : + f << "ErroredExecutingState"; + break; + case GraphExecutor::SuspendedSuccessedState : + f << "SuspendedSuccessedState"; + break; + case GraphExecutor::SuspendedErroredState : + f << "SuspendedErroredState"; + break; + case GraphExecutor::ResumedSuccessedState : + f << "ResumedSuccessedState"; + break; + case GraphExecutor::ResumedErroredState : + f << "ResumedErroredState"; + break; + case GraphExecutor::KilledSuccessedState : + f << "KilledSuccessedState"; + break; + case GraphExecutor::KilledErroredState : + f << "KilledErroredState"; + break; + case GraphExecutor::StoppedSuccessedState : + f << "StoppedSuccessedState"; + break; + case GraphExecutor::StoppedErroredState : + f << "StoppedErroredState"; + break; + case GraphExecutor::SuccessedState : + f << "SuccessedState"; + break; + case GraphExecutor::ErroredState : + f << "ErroredState"; + break; + case GraphExecutor::SuspendedState : + f << "SuspendedState"; + break; + case GraphExecutor::KilledState : + f << "KilledState"; + break; + case GraphExecutor::StoppedState : + f << "StoppedState"; + break; + case GraphExecutor::SuspendedSuccessedToReStartState : + f << "SuspendedSuccessedToReStartState"; + break; + case GraphExecutor::SuspendedErroredToReStartState : + f << "SuspendedErroredToReStartState"; + break; + case GraphExecutor::ReStartedState : + f << "ReStartedState"; + break; + case GraphExecutor::LoadingState : + f << "LoadingState"; + break; + default : + f << "GraphExecutor::AutomatonState_?"; + break; + } + + return f; +} +