CHSM A language system for extending C++ or Java for implementing reactive systems. Fabio Riccardi Paul J. Lucas fabio.riccardi@mac.com paul@lucasmail.org These slides are available at: http://chsm.sourceforge.net/chsm-slides.pdf
CHSM Overview: Motivation. State-Transition Diagrams vs. Statecharts. Statechart Features. Statechart Problems / Solution. CHSM Language Tour.
CHSM Motivation: Finite state machines (FSMs) are used in many computing and electronic applications including: Communications protocols Graphical user interfaces Handheld devices (watches, PDAs, phones) FSMs have problems when used in practice. Statecharts, and their associated concurrent, hierarchical, finite state machines (CHSMs) address these problems.
CHSM State-Transition Diagrams: Are “flat” and “global.” Tend to have replicated transitions: s a b c Experience exponential growth: a c ac ad ae + e = b d bc bd be
CHSM Statecharts 1: Immediate benefits Are hierarchical. Eliminate replicated transitions: p s a b c Eliminate exponential growth: p x y a c e b d
CHSM Statecharts 2: Default states & history Clusters have one default state. May be overridden by a history. p x y a c H e b d n e d d i r r e v o e b n a C History enters last active child state. Clusters may have a deep history.
CHSM Statecharts 3: Conditions, broadcasting, & actions Conditions (boolean expressions) can be tied to transitions. Broadcasting = send event upon transition. Actions performed upon transition. ( ) e m _ l a l c s l a l c δ a δ / { call_me(); } x n o t i i d n o c s a h α [x] c α b β / γ s t γ s a c d a o r b β
CHSM Statecharts: Problems Graphical notation requires sophisticated/expensive tools: STATEMATE: Doesn’t integrate into traditional environments (compilers/makefiles). Introduces “distance” between engineer and generated code. Costs $50K.
CHSM Statecharts: Solution A textual language system for statecharts solves the problems: Integrates easily into traditional development. Generates straight-forward code. Free (for non-commercial use).
CHSM Language Tour 1: Introduction Uses a host language (C++ or Java). Adds additional constructs (like lex and yacc). #include <iostream> declaration using namespace std; %% chsm hello is { state say_it { upon enter %{ cout << “hello, world!\n”; description %} } } %% main() { hello world; user code world.enter(); }
CHSM Language Tour 2: Event Parameters Mechanism to transmit additional data. Specified exactly like function formal arguments. int credit = 0; %% chsm vending_machine is { event coin( int value ); declare parameter state idle { coin -> collect; } state collect { upon enter %{ credit += coin->value; %} // ... access via -> operator } }
CHSM Language Tour 3: Derived Events Allow event hierarchies to be modeled: event core; event<core> user_input; event<user_input> mouse( int x, int y ); event<mouse> mouse_down; event<mouse> mouse_up; event<user_input> keystroke( unsigned modifiers ); event<keystroke> key_down( char key ); event<keystroke> key_up( char key ); // ... : s t s a c d a o r b o s l a n w o d _ y e k e r o c & , t u p n i _ r e Broadcast all base events. s u e , k o r t s y e k Inherit base-event parameters: ui.key_down( modifiers, key ); “modifiers” inherited from keystroke
CHSM Language Tour 4: Event Preconditions Mechanism to determine event suitability. Can be specified as a simple C++/Java expression: event mouse( int x, int y ) [ x >= 0 && y >= 0 ]; Or as a C++/Java function: event login( int pin ) %{ if ( pin == atm_card.pin ) return true; display( “INCORRECT PIN” ); return false; %}
CHSM Language Tour 5: Derived CHSMs Allow data and functions to be added to a CHSM: class vm_data : public CHSM::machine { public: derived from machine class struct item { char const *name; int price; }; vm_data( CHSM_MACHINE_ARGS, item const *items ) : CHSM::machine( CHSM_MACHINE_INIT ), item_( items ) { } protected: item const *item_; int num_items_; int credit_; }; uses <> syntax to specify derived CHSM %% chsm<vm_data> vending_machine( item const *items ) is { // ... }
CHSM Language Tour 6: Vending Machine Example 1 Event specification with preconditions: chsm<vm_data> vending_machine( item const *items ) is { event coin( int value ) %{ switch ( value ) case 1: case 5: case 10: case 25: return true; “coin” event cerr << “No foreign coins!\n”; precondition return false; %} event select( int id ) %{ if ( id < 0 || id >= num_items_ ) { cerr << “Invalid selection\n”; return false; } “select” event if ( credit_ >= item_[ id ].price ) precondition return true; cerr << “Please deposit another “ << item_[ id ].price - credit_ << “ cents\n”; return false; %} // ... continues ...
CHSM Language Tour 6: Vending Machine Example 2 “idle” state specification: state idle { upon enter %{ cout << “\nVending Macine:\n”; num_items_ = 0; for ( item const *i = &item_[0]; i->name; ++i ) cout << char(’A’ + num_items_++) << “. “ << i->name << “ (” << i->price << “)\n”; credit_ = 0; %} coin -> collect; } // ... continues ...
CHSM Language Tour 6: Vending Machine Example 3 “collect” state specification: state collect { upon enter %{ credit_ += coin->value; cout << “Credit: “ << credit_ << “ cents\n”; %} coin -> collect; select -> idle %{ cout << “Enjoy your “ << item_[ select->id ].name << “\n”; int change = credit_ - item_[ select->id ].price; if ( change > 0 ) cout << “Change: “ << change << “ cents\n”; %}; } // ... continues ...
CHSM Language Tour 6: Vending Machine Example 4 %% Interacting with vending_machine::item yummy_treats[] = { { “Cheese Puffs”, 65 }, a machine in a { “Potato Chips”, 80 }, program: { “Pretzels”, 60 }, 0 }; main() { vending_machine vm( yummy_treats ); vm.enter(); while ( !cin.eof() ) { cout << “Enter coins or selection: “; char buf[10]; cin.getline( buf, sizeof buf ); w o h s o t I U y ” o t if ( isdigit( *buf ) ) “ a s i s i h T a h t i w t vm.coin( atoi( buf ) ); c a r e t n i o t w o h else if ( isalpha( *buf ) ) e . n i h c a m vm.select( toupper( *buf ) - ‘A’ ); else cerr << “Invalid input\n”; } }
CHSM Language Tour 7: Derived States 1 Allow data and behavior to be added to a state. Example: Petri Nets: derived from state class class token : public CHSM::state { public: token( CHSM_STATE_ARGS ) : CHSM::state( CHSM_STATE_INIT ), tokens_( -1 ) { } bool enter( CHSM::event const &event, CHSM::state *from ) { if ( !CHSM::state::enter( event, from ) ) Override “enter” return false; method to ++tokens_; augment behavior return true; } int operator-=( int used ) { return tokens_ -= used + 1; } operator int() const { return tokens_; } private: int tokens_; };
CHSM Language Tour 7: Derived States 2 Petri Nets Example: Making water molecules: ${...} notation (borrowed from Unix int water_molecules; shells) accesses state objects %% chsm make_water is { set H20( H2, O2 ) { hydrogen[ ${H2} >= 1 && ${O2} >= 1 ] -> H20 %{ ${H2} -= 1, ${O2} -= 1; water_molecules += 2; %}; oxygen[ ${H2} >= 2 ] -> H2O %{ ${H2} -= 2; water_molecules += 2; %}; } is { state<token> H2 { hydrogen -> H2; } state<token> O2 { oxygen -> O2; } } } uses <> syntax to specify derived state
CHSM Real-World Example: Used at European Laboratory for Particle Physics (CERN) in control systems for experiments. Hardware: 40 embedded VME CPUs controlled by a cluster of 10 Unix workstations. Software: 40K lines of C++ for data acquisition. Statechart: 48 states, 114 transitions, 79 events, 34 conditions, 88 actions. Other, smaller statecharts in subsystems running concurrently. Staff: 100+ people; core system produced by 2.
CHSM License & Downloading: Free software under the GPL. Alternate commercial licenses available. Downloading: http://chsm.sourceforge.net/
Recommend
More recommend