Four Implementation Plans (C Comment Parser)

• Nested Switch
• State Table
• State Design Pattern [G4]
• Optimized

CParser FSM (undocked)

Nested Switch Implementation

• Uses state variable for first level discriminator
• Uses event signal for second level discriminator

enum Signal                        // enumeration for CParser signals
{
  CHAR_SIG, STAR_SIG, SLASH_SIG
};
enum State                         // enumeration for CParser states 
{
   CODE, SLASH, COMMENT, STAR
}; 
 
class CParser1
{
  private:
    State myState;                        // the scalar state-variable
    long myCommentCtr;                    // comment character counter
    /* ... */                             // other CParser1 attributes
  public: 
    void init()
    {
      myCommentCtr = 0; tran(CODE);   // default transiton
    }
    void dispatch(Signal sig);
    void tran(State target)
    {
      myState = target;
    }
    long getCommentCtr() const
    {
      return myCommentCtr;
    }
};

CParser FSM (undocked)

void CParser1::dispatch(Signal sig)
{
  switch (myState)
  {
    case CODE:
      switch (sig)
      {
        case SLASH_SIG:
          tran(SLASH);                          // transition to SLASH
          break;
      }
      break;
    case SLASH:
      switch (sig)
      {
        case STAR_SIG:
          myCommentCtr += 2;            // SLASH-STAR count as comment
          tran(COMMENT);                      // transition to COMMENT
          break;
        case CHAR_SIG:
        case SLASH_SIG:
          tran(CODE);                               // go back to CODE
          break;
      }
      break;
    case COMMENT:
      switch (sig)
      {
        case STAR_SIG:
          tran(STAR);                            // transition to STAR
          break;
        case CHAR_SIG:
        case SLASH_SIG:
          ++myCommentCtr;                    // count the comment char
          break; 
      }
      break;
    case STAR:
      switch (sig)
      {
        case STAR_SIG:
          ++myCommentCtr;                     // count STAR as comment
          break;
        case SLASH_SIG:
          myCommentCtr += 2;            // count STAR-SLASH as comment
          tran(CODE);                            // transition to CODE
          break;
        case CHAR_SIG:
          myCommentCtr += 2;                // count STAR-? as comment
          tran(COMMENT);                         // go back to COMMENT
          break;
       }
       break;
  }
}

Nested Switch Implementation - Conclusions

• Simple rules for structure of code
• But hard to reuse code
• Requires enumerating states and events (triggers)
• Small memory footprint
• Event dispatch time not constant - O(switch(n)) = O(log n)
• Not hierarchical
• Maintenance? (Change model topology ==> re-coding entry/exit actions)
• "Nested Switch" = the "goto" of reactive systems programming ?

State Table Implementation

C Comment Parser State Transition Table (FSM Model)
	Events
States	CHAR_SIG	STAR_SIG	SLASH_SIG
CODE			doNothing(); tran(SLASH);
SLASH	doNothing(); tran(CODE);	a2(); tran(COMMENT);	doNothing(); tran(CODE);
COMMENT	a1(); tran(COMMENT));	doNothing(); tran(STAR);	a1(); tran(COMMENT);
STAR	a2(); tran(COMMENT);	a1(); tran(STAR);	a2(); tran(CODE);

CParser FSM (undocked)

// generic "event processor" ...
class StateTable
{
public:
   typedef void (StateTable::*Action)();
     // defines type Action as pointer-to-method in StateTable
   struct Tran // defines table element as pair<pointer-to-member, unsigned>
   {
      Action action;
      unsigned nextState;
   };
   StateTable(Tran const *table, unsigned nStates, unsigned nSignals)
     : myTable(table), myNsignals(nSignals), myNstates(nStates)
     myTable contains address of 2-d table of Tran supplied by client 
   {}
   virtual ~StateTable()                          // virtual xctor
   {}
   void dispatch(unsigned sig)
   {
      register Tran const * t = myTable + myState*myNsignals + sig; 
        // table lookup: Tran * t = myTable[myState,sig];
      (this->*(t->action))(); // call action sequence
      myState = t->nextState; // "tran()"
   }
   void doNothing()
   {} 
protected:
   unsigned myState;
private:
   Tran const *myTable;
   unsigned myNsignals;
   unsigned myNstates;
};

// specific Comment Parser state machine ...
enum Event                          // enumeration for CParser events
{
   CHAR_SIG, STAR_SIG, SLASH_SIG, MAX_SIG
};

enum State                          // enumeration for CParser states 
{
   CODE, SLASH, COMMENT, STAR, MAX_STATE
};

class CParser2 : public StateTable          // CParser2 state machine
{
  public:
    CParser2() : StateTable(&myTable[0][0], MAX_STATE, MAX_SIG)
    {}
    void init()     // initial transition
    {
      myCommentCtr = 0; myState = CODE;
    }
    long getCommentCtr() const
    {
      return myCommentCtr;
    }
  private:
    void a1()                  // action method
    {
      myCommentCtr += 1;
    }
    void a2()                  // action method
    {
      myCommentCtr += 2;
    }
    static StateTable::Tran const myTable[MAX_STATE][MAX_SIG];
    long myCommentCtr;         // comment character counter
};

// initialize the "table", a 2-D array of unsigned int ("romable")
StateTable::Tran const CParser2::myTable[MAX_STATE][MAX_SIG] =
{
  {
    {&StateTable::doNothing, CODE },
    {&StateTable::doNothing, CODE },
    {&StateTable::doNothing, SLASH}
  },
  {
    {&StateTable::doNothing, CODE },
    {static_cast<StateTable::Action>(&CParser2::a2), COMMENT },
    {&StateTable::doNothing, CODE }
  },
  {
    {static_cast<StateTable::Action>(&CParser2::a1), COMMENT },
    {&StateTable::doNothing,STAR  },
    {static_cast<StateTable::Action>(&CParser2::a1), COMMENT }
  },
  {
    {static_cast<StateTable::Action>(&CParser2::a2), COMMENT },
    {static_cast<StateTable::Action>(&CParser2::a1), STAR },
    {static_cast<StateTable::Action>(&CParser2::a2), CODE }
  }
};

State Table Implementation - Conclusions

• Graphical representation of class StateTable:

• Maps directly to/from state table documentational organizer
• Requires enumeration of events (triggers) and states
• O(1) dispatch performance
• Code reuse: the base class
• Uses large state array, typically sparse (could be replaced w. hash table)
• Table is array of integers/addresses, romable
• Large number of action functions
• Complex initialization (state table initialization) - difficult to maintain
• Not hierarchical

State Design Pattern (OO Approach)

class CParser3;                              // Context class

class CParserState                           // abstract State
// not abstract class: defines inheritable "doNothing" actions
{      
  public:
    virtual void onCHAR(CParser3 *context, char ch)
    {}
    virtual void onSTAR(CParser3 *context)
    {}
    virtual void onSLASH(CParser3 *context)
    {}
};

class CodeState : public CParserState        // concrete State "Code"
{
  public:
    virtual void onSLASH(CParser3 *context);
};

class SlashState : public CParserState       // concrete State "Slash"
{
  public:
    virtual void onCHAR(CParser3 *context, char ch);
    virtual void onSTAR(CParser3 *context);
};

class CommentState : public CParserState     //concrete State "Comment"
{
  public:
    virtual void onCHAR(CParser3 *context, char ch);
    virtual void onSTAR(CParser3 *context);
    virtual void onSLASH(CParser3 *context);
};

class StarState : public CParserState        // concrete State "Star"
{
  public:
    virtual void onCHAR(CParser3 *context, char ch);
    virtual void onSTAR(CParser3 *context);
    virtual void onSLASH(CParser3 *context);
};

class CParser3                               // Context class
{
  friend class CodeState;
  friend class SlashState;
  friend class CommentState;
  friend class StarState;

  private:
    static CodeState    myCodeState;
    static SlashState   mySlashState;
    static CommentState myCommentState;
    static StarState    myStarState;
    CParserState *myState;
    long myCommentCtr;

  public:
    void init()
    {
       myCommentCtr = 0; tran(&myCodeState);
    }
    void tran(CParserState *target)
    {
      myState = target;
    }
    long getCommentCtr() const
    {
      return myCommentCtr;
    }
    void onCHAR(char ch)
    {
      myState->onCHAR(this, ch);
    }
    void onSTAR()
    {
      myState->onSTAR(this);
    }
    void onSLASH()
    {
      myState->onSLASH(this);
    }
};

CodeState    CParser3::myCodeState;
SlashState   CParser3::mySlashState;
CommentState CParser3::myCommentState;
StarState    CParser3::myStarState;

void CodeState::onSLASH(CParser3 *context)
{
  context->tran(&CParser3::mySlashState);
}
void SlashState::onCHAR(CParser3 *context, char ch)
{
  context->tran(&CParser3::myCodeState);
}
void SlashState::onSTAR(CParser3 *context)
{
  context->myCommentCtr += 2;
  context->tran(&CParser3::myCommentState);
}
void CommentState::onCHAR(CParser3 *context, char c)
{
  context->myCommentCtr++;
}
void CommentState::onSTAR(CParser3 *context)
{
  context->tran(&CParser3::myStarState);
}
void CommentState::onSLASH(CParser3 *context)
{
  context->myCommentCtr++;
}
void StarState::onCHAR(CParser3 *context, char ch)
{
  context->myCommentCtr += 2;
  context->tran(&CParser3::myCommentState);
}
void StarState::onSTAR(CParser3 *context)
{
  context->myCommentCtr++;
}
void StarState::onSLASH(CParser3 *context)
{
  context->myCommentCtr += 2;
  context->tran(&CParser3::myCodeState);
}

State Design Pattern - Conclusions

• Partioning of state behavior, localized into separate subclasses
• Efficient state transitions (re-assign a pointer)
• O(1) dispatch performance; degraded if client uses switch to select event handler
• Customize signature of each event handler
• Language type checking for event parameters
• Memory efficient: sharing of state child objects when no new data is introduced to child states (uses static data)
• No enumeration of states and events
• Context class has too many friends...
• Indirect access to Context parameters (via context
• Adding states == adding subclasses of State class
• Adding new events == adding event handlers to State interface (and overriding for subclasses where appropriate)
• Fine granularity event handlers
• Not hierarchical

Simplified State Design Pattern

Design Pattern Separate event handlers Design of event demultiplexing via sub-class design Runtime demultiplexing via polymorphism
Simplified Design Pattern Combine event handling into dispatch() Demultiplexing events done in various overrides of dispatch() Claim of "generic"

Optimized Approach

Combines ideas from Nested Switch State Table Simplified State Design Pattern class Fsm Plays role of context class from Simplified State Design Pattern Plays role of event processor from State Table Represents states as (pointers to) state handler methods

class Fsm
{
  public:
    typedef void                                       // return value
            (Fsm::*       // class the function pointer is a member of
                State)                       // pointer-to-member name
            (unsigned sig);                     // argument list
    Fsm(State initial) : myState(initial)                      // ctor
    {}
    virtual ~Fsm()                                     // virtual xtor
    {}
    void init()                                  // initial transition
    {
      (this->*myState)(0);
    }
    void dispatch(unsigned sig)
    {
      (this->*myState)(sig);
    }
  protected:
    void tran(State target)
    {
      myState = target;
    }
    #define TRAN(target_) tran(static_cast<State>(target_))
    State myState;
};

enum Event                          // enumeration for CParser events
{
  CHAR_SIG, STAR_SIG, SLASH_SIG
};

class CParser4 : public Fsm
{
  public:
    CParser4() : Fsm((State)initial) {}                        // ctor
    long getCommentCtr() const { return myCommentCtr; }
  private:
    long myCommentCtr;                    // comment character counter
    void initial(unsigned);                     // state-handler
    void code(unsigned sig);                    // state-handler
    void slash(unsigned sig);                   // state-handler
    void comment(unsigned sig);                 // state-handler
    void star(unsigned sig);                    // state-handler
};

void CParser4::initial(unsigned)         // initial pseudostate
{
  myCommentCtr = 0;
  TRAN(&CParser4::code);              // take the default transition
}
void CParser4::code(unsigned sig)
{
  switch (sig)
  {
    case SLASH_SIG:
      TRAN(&CParser4::slash);                // transition to "slash"
      break;
  }
}
void CParser4::slash(unsigned sig)
{
  switch (sig)
  {
    case STAR_SIG:
      myCommentCtr += 2;    // SLASH-STAR characters count as comment
      TRAN(&CParser4::comment);            // transition to "comment"
      break;
    case CHAR_SIG:
      TRAN(&CParser4::code);                     // go back to "code"
      break;
  }
}
void CParser4::comment(unsigned sig)
{
  switch (sig)
  {
    case STAR_SIG:
      TRAN(&CParser4::star);                  // transition to "star"
      break;
    case CHAR_SIG:
    case SLASH_SIG:
      ++myCommentCtr;                  // count the comment character
      break; 
  }
}
void CParser4::star(unsigned sig)
{
  switch (sig)
  {
    case STAR_SIG:
      ++myCommentCtr;               // count '*' as comment character
      break;
    case CHAR_SIG:
      myCommentCtr += 2;                   // count STAR-? as comment
      TRAN(&CParser4::comment);               // go back to "comment"
      break;
    case SLASH_SIG:
      myCommentCtr += 2;               // count STAR-SLASH as comment
      TRAN(&CParser4::code);                  // transition to "code"
      break;
   }
}

Optimized Approach - Conclusions

Requires enumerating events State-specific behavior partitioned/localized in separate handler methods Direct/efficient access to state machine attributes from state handler methods (friendship nor required) Small memory footprint (one address myState represents instance of Fsm) Code reuse: class Fsm Efficient state transitions (re-assign pointer myState)

Event dispatch performance: Replaces one layer of switch from Nested Switch with pointer-to-member-function (from O((log n)x(log n)) to O(log k)), where k < n) switch (inside handler method) can be replaced with table in places where temporal performance is an issue, achieving O(1) Scalable/flexible: Add state: add state handler method Add event: append event to enumeration, add case/code to relevant state handler methods Not hierarchical

Exceptions and FSM

• Exception handling incompatible w. RTC semantics
• FSM can represent all conditions of system, including fault conditions
• Try to avoid C++ exception handler
• If an exception is allowed to be thrown, be sure to catch inside FSM

Pointer to Member Functions and Efficiency

• Time Efficiency: time given to boiler plate processing, that is, excluding client-defined actions
• In Optimal FSM (OFSM), time efficiency depends on:
1. dispatch() - three machine instructions
2. tran() - one machine instruction
• OFSM Pointer-to-member mechanism is optimally fast
• OFSM Pointer-to-member mechanism performance may degrade slightly when using virtual state handlers, due to extra layer of indirection through the virtual function table
• OFSM Pointer-to-member does not work when using virtual state handlers and multiple inheritance:
1. State is a pointer-to-member of base class
2. Requires that derived class members be upcast to base class during processing
3. Multiple inheritance could make upcast ambiguous

Guards, Junctions, Choice Points

• Guard:

  if (guard())
  {
    action();
  }
  

• Junction (no orthogonal regions):

  if (guard1())
  {
    action1();
  }
  else if (guard2())
  {
    action2();
  }
  // optional default case:
  else
  {
    actionN();
  }
  

  Note the control over action order when guards are not mutually exclusive.
• Dynamic choice point:

if (dynamic_condition())
{
  if (guard1())
  {
    action1();
  }
  else if (guard2())
  {
    action2();
  }
  // optional default case:
  else
  {
    actionN();
  }
}

• Used reserved signals to trigger entry, exit actions
1. Defined by framework:

enum
{
  INIT_SIG = 1, EXIT_SIG, ENTRY_SIG, USER_SIG
}

2. Defined by client:

enum mySignals
{
  SIG1 = USER_SIG, SIG2, SIG3, ...
}

3. QHSM uses signal 0 for probing state hierarchy and the INIT_SIG to initialize states
• Elaborate definition of tran():

// old
void tran(State target)
{
  myState = target;
}

// new
void tran(State target)
{
  (this -> *myState)(EXIT_SIG);
  myState = target;
  (this -> *myState)(ENTRY_SIG);
}

• Entry and exit signals handled as any other signal, except that tran() is not called. E.g.:

void CParser4a::slash(unsigned sig)
{
  switch (sig)
  {
    case ENTRY_SIG:
      // entry_action
      break;
    case EXIT_SIG:
      // exit_action
      break;
    case STAR_SIG:
      myCommentCtr += 2;    // SLASH-STAR characters count as comment
      TRAN(&CParser4::comment);            // transition to "comment"
      break;
    case CHAR_SIG:
      TRAN(&CParser4::code);                     // go back to "code"
      break;
  }
}