Hi, I'm using msm to store the state of many small objects. Each one is around 24 bytes on its own. However, I just found out from experimentation that a MSM state machine takes many bytes to store. For the following program, the print out is: entering: State1 104 48 This indicates that the very simple one-state, no-transition, machine is 104 bytes, and takes 48 bytes even to serialized. The front::state_machine_def, however, is only 1 byte, though I suspect thet real state is stored only in the 104-byte back::state_machine. Even the SimpleTutorial.cpp example, when I adapt it to print the size, shows 128 bytes. Theoretically, all this information take no more than a few bits to store, and one byte is generous. What's the internal representation of a state machine and how can I optimize the size of the representation? This matters for my use case because I have many small objects for which I want to maintain state, that are only ~20 bytes each. I thought perhaps I could mitigate this size problem by storing the serialized bytes but even the serialized bytes are many. I'm using boost 1.51 and gcc 4.7.2 on 64-bit Linux. Josh #include <iostream> #include <strstream> #include <boost/archive/text_oarchive.hpp> #include <boost/msm/back/state_machine.hpp> #include <boost/msm/front/functor_row.hpp> #include <boost/msm/front/state_machine_def.hpp> using namespace std; namespace mpl = boost::mpl; namespace msm = boost::msm; using namespace msm::front; struct Event { }; struct state_ : public msm::front::state_machine_def<state_> { struct State1 : public msm::front::state<> { // optional entry/exit methods template <class Event,class FSM> void on_entry(Event const&, FSM& f) { std::cout << "entering: State1" << std::endl; } template <class Event,class FSM> void on_exit(Event const&,FSM& ) { std::cout << "leaving: State1" << std::endl; } }; typedef State1 initial_state; struct transition_table : mpl::vector< > {}; }; typedef msm::back::state_machine<state_> State; int main() { State state; state.start(); cout << sizeof(state) << endl; ostrstream os; { boost::archive::text_oarchive oa(os); oa << state; } cout << os.pcount() << endl; return 0; }