I've already played with the Statechart library. I think it's a good
library but especially the fact that transitions take such a long time
isn't good in many situations like embedded systems for instance. Of
course Statechart has it's entitlement I think for you the new MSM
library (currently in review progress) is worth a look. State machines
build with MSM have very low overhead and are therefore very efficient.
I've taken a simple example to this mail. On my machine the state
machine with MSM is about 34 times faster than the one with Statechart.
Conoscenza Silente schrieb:
Hi All
Yesterday I started playing with Boost State Chart library
implementing state machines for my applications.
Each time I am moving into a new state I noticed that a new state is
created; this means that the constructor of the
boost::statechart::state class is called each time ( and the
destructor for the state that I am leaving ).
I would like to fasten up the whole process; let's say that I would
like to avoid the creation/destruction of the class each time using
object already allocated in memory that are deleted only at the exit
of the application.
Is this a good way in your opinion ?
I saw that there is an allocator template argument but at the state
where I am now I would lilke to not spend time in doing a new
allocator for that: do you know if there already in place something
that I can reuse for my purpose?
Thanks CS
_______________________________________________
Boost-users mailing list
Boost-users@lists.boost.org
http://lists.boost.org/mailman/listinfo.cgi/boost-users
#include
#include
#include
#include
#include
#include
#include
#include
#include
using namespace boost::statechart;
namespace test_sc
{
struct state_1;
struct state_2;
struct state_3;
struct state_4;
struct main_machine :
state_machine<
main_machine,
state_1
// without allocator I have 5.6 seconds (used also in events)
//,boost::pool_allocator< main_machine > // with this
// allocator I go to 10 sec used also in events
//,boost::fast_pool_allocator< main_machine > // with this
//allocator I go to 8.7 sec
> {};
struct event_1_2 : event< event_1_2
//, boost::fast_pool_allocator< event_1_2 >
{};
struct event_2_3 : event< event_2_3
//, boost::fast_pool_allocator< event_2_3 >
{};
struct event_3_4 : event< event_3_4
//, boost::fast_pool_allocator< event_3_4 >
{};
struct event_4_1 : event< event_4_1
//, boost::fast_pool_allocator< event_4_1 >
{};
struct state_1
: simple_state< state_1, main_machine >
{
typedef transition< event_1_2, state_2 > reactions;
};
struct state_2
: simple_state< state_2, main_machine >
{
typedef transition< event_2_3, state_3 > reactions;
};
struct state_3
: simple_state< state_3, main_machine >
{
//typedef transition< event_3_4, state_4 > arc; // it doesn't work
typedef transition< event_3_4, state_4 > reactions;
//state_3(){std::cout<<"3";}
//~state_3(){std::cout<<"~3";}
};
struct state_4
: simple_state< state_4, main_machine >
{
typedef transition< event_4_1, state_1 > reactions;
};
}
namespace msm = boost::msm;
namespace mpl = boost::mpl;
namespace test_msm // Concrete FSM implementation
{
struct event_1_2 {};
struct event_2_3 {};
struct event_3_4 {};
struct event_4_1 {};
// Concrete FSM implementation
struct main_machine_ : public msm::front::state_machine_def
{
// no need for exception handling or message queue
typedef int no_exception_thrown;
typedef int no_message_queue;
// The list of FSM states
struct state_1 : public msm::front::state<>
{
// optional entry/exit methods
//template
//void on_entry(Event const&,FSM& ) {std::cout << "entering: state_1" << std::endl;}
//template
//void on_exit(Event const&,FSM& ) {std::cout << "leaving: state_1" << std::endl;}
};
struct state_2 : public msm::front::state<>
{
// optional entry/exit methods
//template
//void on_entry(Event const&,FSM& ) {std::cout << "entering: state_2" << std::endl;}
//template
//void on_exit(Event const&,FSM& ) {std::cout << "leaving: state_2" << std::endl;}
};
struct state_3 : public msm::front::state<>
{
// optional entry/exit methods
//template
//void on_entry(Event const&,FSM& ) {std::cout << "entering: state_3" << std::endl;}
//template
//void on_exit(Event const&,FSM& ) {std::cout << "leaving: state_3" << std::endl;}
};
struct state_4 : public msm::front::state<>
{
// optional entry/exit methods
//template
//void on_entry(Event const&,FSM& ) {std::cout << "entering: state_4" << std::endl;}
//template
//void on_exit(Event const&,FSM& ) {std::cout << "leaving: state_4" << std::endl;}
};
// the initial state of the player SM. Must be defined
typedef state_1 initial_state;
struct transition_table : mpl::vector<
// Start Event Next Action Guard
// +---------+-------------+---------+---------------------+----------------------+
_row < state_1 , event_1_2 , state_2 >,
_row < state_2 , event_2_3 , state_3 >,
_row < state_3 , event_3_4 , state_4 >,
_row < state_4 , event_4_1 , state_1 >
// +---------+-------------+---------+---------------------+----------------------+
> {};
};
typedef msm::back::state_machine main_machine;
}
void main(){
test_sc::main_machine fsm;
fsm.initiate();
{
boost::progress_timer t; // count the time elapsed
// before distruction: not very precise
// for expected big differences
for( int i = 0; i < 1000000; i ++ ){
fsm.process_event( test_sc::event_1_2() );
fsm.process_event( test_sc::event_2_3() );
fsm.process_event( test_sc::event_3_4() );
fsm.process_event( test_sc::event_4_1() );
}
}
test_msm::main_machine fsm2;
fsm2.start();
{
boost::progress_timer t; // count the time elapsed
// before distruction: not very precise
// for expected big differences
for( int i = 0; i < 1000000; i ++ ){
fsm2.process_event( test_msm::event_1_2() );
fsm2.process_event( test_msm::event_2_3() );
fsm2.process_event( test_msm::event_3_4() );
fsm2.process_event( test_msm::event_4_1() );
}
}
}
