From 61935c77915a8e206a82cba1c9c9f64be462905d Mon Sep 17 00:00:00 2001 From: Raimo Niskanen Date: Thu, 21 Jun 2018 09:53:55 +0200 Subject: Clean up and optimize code and doc --- lib/stdlib/doc/src/gen_statem.xml | 228 ++++++++++++++++-------------- lib/stdlib/src/gen_statem.erl | 261 +++++++++++++++++++---------------- lib/stdlib/test/gen_statem_SUITE.erl | 73 ++++++---- 3 files changed, 314 insertions(+), 248 deletions(-) (limited to 'lib/stdlib') diff --git a/lib/stdlib/doc/src/gen_statem.xml b/lib/stdlib/doc/src/gen_statem.xml index eb0f7d24f0..dfecd235c9 100644 --- a/lib/stdlib/doc/src/gen_statem.xml +++ b/lib/stdlib/doc/src/gen_statem.xml @@ -167,7 +167,7 @@ erlang:'!' -----> Module:StateName/3

- The "state callback" for a specific + The state callback for a specific state in a gen_statem is the callback function that is called for all events in this state. It is selected depending on which @@ -179,7 +179,7 @@ erlang:'!' -----> Module:StateName/3 When the callback mode is state_functions, the state must be an atom and - is used as the state callback name; see + is used as the state callback name; see Module:StateName/3. This co-locates all code for a specific state in one function as the gen_statem engine @@ -192,7 +192,7 @@ erlang:'!' -----> Module:StateName/3 When the callback mode is handle_event_function, the state can be any term - and the state callback name is + and the state callback name is Module:handle_event/4. This makes it easy to branch depending on state or event as you desire. Be careful about which events you handle in which @@ -200,12 +200,36 @@ erlang:'!' -----> Module:StateName/3 forever creating an infinite busy loop.

- The gen_statem enqueues incoming events in order of arrival - and presents these to the - state callback - in that order. The state callback can postpone an event - so it is not retried in the current state. - After a state change the queue restarts with the postponed events. + When gen_statem receives a process message it is + converted into an event and the + state callback + is called with the event as two arguments: type and content. + When the + state callback + has processed the event it returns to gen_statem + which does a state transition. + If this state transition is to a different state, + that is: NextState =/= State, it is a state change. +

+

+ The + state callback + may return + transition actions + for gen_statem + to execute during the state transition, + for example to reply to a + gen_statem:call/2,3. +

+

+ One of the possible transition actions + is to postpone the current event. + Then it is not retried in the current state. + The gen_statem engine keeps a queue of events + divided into the postponed events + and the events still to process. + After a state change the queue restarts + with the postponed events.

The gen_statem event queue model is sufficient @@ -215,13 +239,17 @@ erlang:'!' -----> Module:StateName/3 to entering a new receive statement.

- The state callback + The + state callback can insert events using the - action() + transition actions next_event - and such an event is inserted as the next to present - to the state callback. That is, as if it is - the oldest incoming event. A dedicated + and such an event is inserted in the event queue + as the next to call the + state callback + with. + That is, as if it is the oldest incoming event. + A dedicated event_type() internal can be used for such events making them impossible to mistake for external events. @@ -236,24 +264,26 @@ erlang:'!' -----> Module:StateName/3

The gen_statem engine can automatically make a specialized call to the - state callback + state callback whenever a new state is entered; see state_enter(). This is for writing code common to all state entries. - Another way to do it is to insert an event at the state transition, - and/or to use a dedicated state transition function, + Another way to do it is to explicitly insert an event + at the state transition, + and/or to use a dedicated state transition function, but that is something you will have to remember - at every state transition to the state(s) that need it. + at every state transition to the state(s) that need it.

If you in gen_statem, for example, postpone - an event in one state and then call another state callback - of yours, you have not changed states and hence the postponed event - is not retried, which is logical but can be confusing. + an event in one state and then call another state callback + of yours, you have not done a state change + and hence the postponed event is not retried, + which is logical but can be confusing.

- For the details of a state transition, see type + For the details of a state transition, see type transition_option().

@@ -276,7 +306,8 @@ erlang:'!' -----> Module:StateName/3 The gen_statem process can go into hibernation; see proc_lib:hibernate/3. It is done when a - state callback or + state callback + or Module:init/1 specifies hibernate in the returned Actions @@ -551,7 +582,7 @@ handle_event(_, _, State, Data) -> callback mode is handle_event_function, the state can be any term. - After a state change (NextState =/= State), + After a state change (NextState =/= State), all postponed events are retried.

@@ -564,7 +595,7 @@ handle_event(_, _, State, Data) -> callback mode is state_functions, the state must be of this type. - After a state change (NextState =/= State), + After a state change (NextState =/= State), all postponed events are retried.

@@ -595,7 +626,7 @@ handle_event(_, _, State, Data) ->

internal events can only be generated by the - state machine itself through the state transition action + state machine itself through the transition action next_event.

@@ -633,9 +664,9 @@ handle_event(_, _, State, Data) -> This is the return type from Module:callback_mode/0 and selects - callback mode + callback mode and whether to do - state enter calls, + state enter calls, or not.

@@ -684,13 +715,15 @@ handle_event(_, _, State, Data) -> If Module:callback_mode/0 returns a list containing state_enter, - the gen_statem engine will, at every state change, + the gen_statem engine will, at every state change, call the state callback with arguments (enter, OldState, Data). This may look like an event but is really a call - performed after the previous state callback returned - and before any event is delivered to the new state callback. + performed after the previous + state callback + returned and before any event is delivered to the new + state callback. See Module:StateName/3 and @@ -703,27 +736,27 @@ handle_event(_, _, State, Data) -> repeat_state_and_data - tuple from the state callback. + tuple from the state callback.

If Module:callback_mode/0 - does not return such a list, no state enter calls are done. + does not return such a list, no state enter calls are done.

If Module:code_change/4 should transform the state, - it is regarded as a state rename and not a state change, - which will not cause a state enter call. + it is regarded as a state rename and not a state change, + which will not cause a state enter call.

- Note that a state enter call will be done + Note that a state enter call will be done right before entering the initial state even though this - formally is not a state change. - In this case OldState will be the same as State, - which cannot happen for a subsequent state change, - but will happen when repeating the state enter call. + actually is not a state change. + In this case OldState =:= State, + which can not happen for a subsequent state change, + but will happen when repeating the state enter call.

@@ -733,8 +766,11 @@ handle_event(_, _, State, Data) ->

Transition options can be set by actions - and modify the state transition. - Here are the sequence of steps for a state transition: + and modify the state transition. + The state transition takes place when the + state callback + has processed an event and returns. + Here are the sequence of steps for a state transition:

@@ -765,7 +801,7 @@ handle_event(_, _, State, Data) -> returned by the state callback that caused the state entry.

- Should this state enter call return any of + Should this state enter call return any of the mentioned repeat_* callback results it is repeated again, with the updated Data.

@@ -787,7 +823,8 @@ handle_event(_, _, State, Data) ->

- If the state changes, the queue of incoming events + If this is a state change, + the queue of incoming events is reset to start with the oldest postponed.

@@ -821,7 +858,7 @@ handle_event(_, _, State, Data) -> if the event queue is empty.

- A state change cancels a + A state change cancels a state_timeout() and any new transition option of this type belongs to the new state. @@ -830,7 +867,7 @@ handle_event(_, _, State, Data) ->

If there are enqueued events the - state callback + state callback for the possibly new state is called with the oldest enqueued event, and we start again from the top of this list. @@ -848,7 +885,7 @@ handle_event(_, _, State, Data) -> the next incoming message awakens the gen_statem, but if it is a system event it goes right back into hibernation. When a new message arrives the - state callback + state callback is called with the corresponding event, and we start again from the top of this sequence.

@@ -861,7 +898,7 @@ handle_event(_, _, State, Data) ->

If true, postpones the current event and retries - it when the state changes + it after a state change (NextState =/= State).

@@ -1021,9 +1058,9 @@ handle_event(_, _, State, Data) ->

- These state transition actions can be invoked by + These transition actions can be invoked by returning them from the - state callback + state callback when it is called with an event, from @@ -1054,7 +1091,7 @@ handle_event(_, _, State, Data) -> transition_option() postpone() - for this state transition. + for this state transition. This action is ignored when returned from Module:init/1 or given to @@ -1093,9 +1130,9 @@ handle_event(_, _, State, Data) ->

- These state transition actions can be invoked by + These transition actions can be invoked by returning them from the - state callback, from + state callback, from Module:init/1 or by giving them to enter_loop/5,6. @@ -1119,7 +1156,7 @@ handle_event(_, _, State, Data) -> Sets the transition_option() hibernate() - for this state transition. + for this state transition.

@@ -1129,9 +1166,9 @@ handle_event(_, _, State, Data) ->

- These state transition actions can be invoked by + These transition actions can be invoked by returning them from the - state callback, from + state callback, from Module:init/1 or by giving them to enter_loop/5,6. @@ -1147,7 +1184,7 @@ handle_event(_, _, State, Data) -> Short for {timeout,Time,Time}, that is, the time-out message is the time-out time. This form exists to make the - state callback + state callback return value {next_state,NextState,NewData,Time} allowed like for gen_fsm.

@@ -1193,9 +1230,9 @@ handle_event(_, _, State, Data) ->

- This state transition action can be invoked by + This transition action can be invoked by returning it from the - state callback, from + state callback, from Module:init/1 or by giving it to enter_loop/5,6. @@ -1210,7 +1247,7 @@ handle_event(_, _, State, Data) -> From must be the term from argument {call,From} in a call to a - state callback. + state callback.

Note that using this action from @@ -1219,7 +1256,7 @@ handle_event(_, _, State, Data) -> enter_loop/5,6 would be weird on the border of witchcraft since there has been no earlier call to a - state callback + state callback in this server.

@@ -1239,7 +1276,7 @@ handle_event(_, _, State, Data) -> The Actions are executed when entering the first state just as for a - state callback, + state callback, except that the action postpone is forced to false since there is no event to postpone.

@@ -1292,11 +1329,13 @@ handle_event(_, _, State, Data) -> next_state

- The gen_statem does a state transition to + The gen_statem does a state transition to NextState (which can be the same as the current state), sets NewData, and executes all Actions. + If NextState =/= CurrentState + the state transition is a state change.

@@ -1318,54 +1357,33 @@ handle_event(_, _, State, Data) -> keep_state

- The gen_statem keeps the current state, or - does a state transition to the current state if you like, - sets NewData, - and executes all Actions. - This is the same as + The same as {next_state,CurrentState,NewData,Actions}.

keep_state_and_data

- The gen_statem keeps the current state or - does a state transition to the current state if you like, - keeps the current server data, - and executes all Actions. - This is the same as - {next_state,CurrentState,CurrentData,Actions}. + The same as + {keep_state,CurrentData,Actions}.

repeat_state

- The gen_statem keeps the current state, or - does a state transition to the current state if you like, - sets NewData, - and executes all Actions. If the gen_statem runs with state enter calls, - the state enter call is repeated, see type + the state enter call is repeated, see type transition_option(), - otherwise repeat_state is the same as + other than that repeat_state is the same as keep_state.

repeat_state_and_data

- The gen_statem keeps the current state and data, or - does a state transition to the current state if you like, - and executes all Actions. - This is the same as + The same as {repeat_state,CurrentData,Actions}. - If the gen_statem runs with - state enter calls, - the state enter call is repeated, see type - transition_option(), - otherwise repeat_state_and_data is the same as - keep_state_and_data.

stop @@ -1408,14 +1426,15 @@ handle_event(_, _, State, Data) -> by sending a request and waiting until its reply arrives. The gen_statem calls the - state callback with + state callback + with event_type() {call,From} and event content Request.

A Reply is generated when a - state callback + state callback returns with {reply,From,Reply} as one action(), @@ -1484,7 +1503,8 @@ handle_event(_, _, State, Data) -> ignoring if the destination node or gen_statem does not exist. The gen_statem calls the - state callback with + state callback + with event_type() cast and event content Msg. @@ -1598,18 +1618,18 @@ handle_event(_, _, State, Data) -> call/2 when the reply cannot be defined in the return value of a - state callback. + state callback.

From must be the term from argument {call,From} to the - state callback. + state callback. A reply or multiple replies canalso be sent using one or several reply_action()s from a - state callback. + state callback.

@@ -1826,7 +1846,7 @@ handle_event(_, _, State, Data) -> for efficiency reasons, so this function is only called once after server start and after code change, but before the first - state callback + state callback in the current code version is called. More occasions may be added in future versions of gen_statem. @@ -1883,7 +1903,7 @@ handle_event(_, _, State, Data) ->

This callback is optional, so callback modules need not export it. If a release upgrade/downgrade with - Change={advanced,Extra} + Change = {advanced,Extra} specified in the .appup file is made when code_change/4 is not implemented the process will crash with exit reason undef. @@ -1893,7 +1913,7 @@ handle_event(_, _, State, Data) -> This function is called by a gen_statem when it is to update its internal state during a release upgrade/downgrade, that is, when the instruction {update,Module,Change,...}, - where Change={advanced,Extra}, is specified in the + where Change = {advanced,Extra}, is specified in the appup file. For more information, see OTP Design Principles. @@ -1933,13 +1953,13 @@ handle_event(_, _, State, Data) ->

Also note when upgrading a gen_statem, this function and hence - the Change={advanced,Extra} parameter in the + the Change = {advanced,Extra} parameter in the appup file is not only needed to update the internal state or to act on the Extra argument. It is also needed if an upgrade or downgrade should change callback mode, - or else the callback mode after the code change + or else the callback mode after the code change will not be honoured, most probably causing a server crash.

@@ -2148,7 +2168,7 @@ init(Args) -> erlang:error(not_implemented, [Args]). {call,From}, the caller waits for a reply. The reply can be sent from this or from any other - state callback + state callback by returning with {reply,From,Reply} in Actions, in Replies, @@ -2173,9 +2193,9 @@ init(Args) -> erlang:error(not_implemented, [Args]).

When the gen_statem runs with - state enter calls, + state enter calls, these functions are also called with arguments - (enter, OldState, ...) whenever the state changes. + (enter, OldState, ...) during every state change. In this case there are some restrictions on the actions that may be returned: diff --git a/lib/stdlib/src/gen_statem.erl b/lib/stdlib/src/gen_statem.erl index faa43fbc1e..24b268cd38 100644 --- a/lib/stdlib/src/gen_statem.erl +++ b/lib/stdlib/src/gen_statem.erl @@ -330,6 +330,7 @@ %% Type validation functions +%% - return true if the value is of the type, false otherwise -compile( {inline, [callback_mode/1, state_enter/1, @@ -1277,7 +1278,7 @@ parse_actions(StateCall, Debug, S, [Action|Actions], TransOpts) -> end. parse_actions_reply( - StateCall, ?not_sys_debug, S, Actions, TransOpts, + StateCall, ?not_sys_debug = Debug, S, Actions, TransOpts, From, Reply) -> %% case from(From) of @@ -1287,8 +1288,7 @@ parse_actions_reply( false -> [error, {bad_action_from_state_function,{reply,From,Reply}}, - ?STACKTRACE(), - ?not_sys_debug] + ?STACKTRACE(), Debug] end; parse_actions_reply( StateCall, Debug, #state{name = Name, state = State} = S, @@ -1302,12 +1302,11 @@ parse_actions_reply( false -> [error, {bad_action_from_state_function,{reply,From,Reply}}, - ?STACKTRACE(), - Debug] + ?STACKTRACE(), Debug] end. parse_actions_next_event( - StateCall, ?not_sys_debug, S, + StateCall, ?not_sys_debug = Debug, S, Actions, TransOpts, Type, Content) -> case event_type(Type) of true when StateCall -> @@ -1320,8 +1319,7 @@ parse_actions_next_event( [error, {bad_state_enter_action_from_state_function, {next_event,Type,Content}}, - ?STACKTRACE(), - ?not_sys_debug] + ?STACKTRACE(), Debug] end; parse_actions_next_event( StateCall, Debug, #state{name = Name, state = State} = S, @@ -1403,13 +1401,13 @@ parse_actions_timeout_add( loop_event_done( Parent, ?not_sys_debug, #state{postponed = P} = S, +%% #state{postponed = will_not_happen = P} = S, Events, Event, NextState, NewData, #trans_opts{ postpone = Postpone, hibernate = Hibernate, - timeouts_r = [], next_events_r = []}) -> + timeouts_r = [], next_events_r = NextEventsR}) -> %% - %% Optimize the simple cases - %% i.e no timer changes, no inserted events and no debug, + %% Optimize the simple cases i.e no debug and no timer changes, %% by duplicate stripped down code %% %% Fast path @@ -1417,14 +1415,12 @@ loop_event_done( case Postpone of true -> loop_event_done_fast( - Parent, Hibernate, - S, - Events, [Event|P], NextState, NewData); + Parent, Hibernate, S, + Events, [Event|P], NextState, NewData, NextEventsR); false -> loop_event_done_fast( - Parent, Hibernate, - S, - Events, P, NextState, NewData) + Parent, Hibernate, S, + Events, P, NextState, NewData, NextEventsR) end; loop_event_done( Parent, Debug_0, @@ -1456,26 +1452,23 @@ loop_event_done( {S#state.name,State}, {consume,Event_0,NextState})|P_0] end, - {Events_2,P_2,Timers_2} = - %% Move all postponed events to queue, - %% cancel the event timer, - %% and cancel the state timeout if the state changes - if - NextState =:= State -> - {Events_0,P_1, + {Events_2,P_2, + Timers_2} = + %% Cancel the event timeout + if + NextState =:= State -> + {Events_0,P_1, cancel_timer_by_type( timeout, {TimerTypes_0,CancelTimers_0})}; - true -> - {lists:reverse(P_1, Events_0), - [], - cancel_timer_by_type( - state_timeout, + true -> + %% Move all postponed events to queue + %% and cancel the state timeout + {lists:reverse(P_1, Events_0),[], + cancel_timer_by_type( + state_timeout, cancel_timer_by_type( timeout, {TimerTypes_0,CancelTimers_0}))} - %% The state timer is removed from TimerTypes - %% but remains in TimerRefs until we get - %% the cancel_timer msg - end, + end, {TimerRefs_3,{TimerTypes_3,CancelTimers_3},TimeoutEvents} = %% Stop and start timers parse_timers(TimerRefs_0, Timers_2, TimeoutsR), @@ -1495,114 +1488,144 @@ loop_event_done( hibernate = Hibernate}, lists:reverse(Events_4R)). +loop_event_done(Parent, Debug, S, Q) -> +%% io:format( +%% "loop_event_done:~n" +%% " state = ~p, data = ~p, postponed = ~p~n " +%% " timer_refs = ~p, timer_types = ~p, cancel_timers = ~p.~n" +%% " Q = ~p.~n", +%% [S#state.state,S#state.data,S#state.postponed, +%% S#state.timer_refs,S#state.timer_types,S#state.cancel_timers, +%% Q]), + case Q of + [] -> + %% Get a new event + loop(Parent, Debug, S); + [{Type,Content}|Events] -> + %% Loop until out of enqueued events + loop_event(Parent, Debug, S, Events, Type, Content) + end. + + %% Fast path %% +%% Cancel event timer and state timer only if running loop_event_done_fast( Parent, Hibernate, #state{ state = NextState, - timer_types = #{timeout := _} = TimerTypes, + timer_types = TimerTypes, cancel_timers = CancelTimers} = S, - Events, P, NextState, NewData) -> - %% - %% Same state, event timeout active - %% - loop_event_done_fast( - Parent, Hibernate, S, - Events, P, NextState, NewData, - cancel_timer_by_type( - timeout, {TimerTypes,CancelTimers})); -loop_event_done_fast( - Parent, Hibernate, - #state{state = NextState} = S, - Events, P, NextState, NewData) -> - %% + Events, P, NextState, NewData, NextEventsR) -> %% Same state - %% - loop_event_done( - Parent, ?not_sys_debug, - S#state{ - data = NewData, - postponed = P, - hibernate = Hibernate}, - Events); -loop_event_done_fast( - Parent, Hibernate, - #state{ - timer_types = #{timeout := _} = TimerTypes, - cancel_timers = CancelTimers} = S, - Events, P, NextState, NewData) -> - %% - %% State change, event timeout active - %% - loop_event_done_fast( - Parent, Hibernate, S, - lists:reverse(P, Events), [], NextState, NewData, - cancel_timer_by_type( - state_timeout, - cancel_timer_by_type( - timeout, {TimerTypes,CancelTimers}))); + case TimerTypes of + #{timeout := _} -> + %% Event timeout active + loop_event_done_fast_2( + Parent, Hibernate, S, + Events, P, NextState, NewData, NextEventsR, + cancel_timer_by_type( + timeout, {TimerTypes,CancelTimers})); + _ -> + %% No event timeout active + loop_event_done_fast_2( + Parent, Hibernate, S, + Events, P, NextState, NewData, NextEventsR, + {TimerTypes,CancelTimers}) + end; loop_event_done_fast( Parent, Hibernate, #state{ - timer_types = #{state_timeout := _} = TimerTypes, + timer_types = TimerTypes, cancel_timers = CancelTimers} = S, - Events, P, NextState, NewData) -> - %% - %% State change, state timeout active - %% - loop_event_done_fast( - Parent, Hibernate, S, - lists:reverse(P, Events), [], NextState, NewData, - cancel_timer_by_type( - state_timeout, - cancel_timer_by_type( - timeout, {TimerTypes,CancelTimers}))); + Events, P, NextState, NewData, NextEventsR) -> + %% State change + case TimerTypes of + #{timeout := _} -> + %% Event timeout active + %% - cancel state_timeout too since it is faster than inspecting + loop_event_done_fast( + Parent, Hibernate, S, + Events, P, NextState, NewData, NextEventsR, + cancel_timer_by_type( + state_timeout, + cancel_timer_by_type( + timeout, {TimerTypes,CancelTimers}))); + #{state_timeout := _} -> + %% State_timeout active but not event timeout + loop_event_done_fast( + Parent, Hibernate, S, + Events, P, NextState, NewData, NextEventsR, + cancel_timer_by_type( + state_timeout, {TimerTypes,CancelTimers})); + _ -> + %% No event nor state_timeout active + loop_event_done_fast( + Parent, Hibernate, S, + Events, P, NextState, NewData, NextEventsR, + {TimerTypes,CancelTimers}) + end. +%% +%% Retry postponed events loop_event_done_fast( - Parent, Hibernate, - #state{} = S, - Events, P, NextState, NewData) -> - %% - %% State change, no timeout to automatically cancel - %% - loop_event_done( - Parent, ?not_sys_debug, - S#state{ - state = NextState, - data = NewData, - postponed = [], - hibernate = Hibernate}, - lists:reverse(P, Events)). + Parent, Hibernate, S, + Events, P, NextState, NewData, NextEventsR, TimerTypes_CancelTimers) -> + case P of + %% Handle 0..2 postponed events without list reversal since + %% that will move out all live registers and back again + [] -> + loop_event_done_fast_2( + Parent, Hibernate, S, + Events, [], NextState, NewData, NextEventsR, + TimerTypes_CancelTimers); + [E] -> + loop_event_done_fast_2( + Parent, Hibernate, S, + [E|Events], [], NextState, NewData, NextEventsR, + TimerTypes_CancelTimers); + [E1,E2] -> + loop_event_done_fast_2( + Parent, Hibernate, S, + [E2,E1|Events], [], NextState, NewData, NextEventsR, + TimerTypes_CancelTimers); + _ -> + %% A bit slower path + loop_event_done_fast_2( + Parent, Hibernate, S, + lists:reverse(P, Events), [], NextState, NewData, NextEventsR, + TimerTypes_CancelTimers) + end. %% %% Fast path %% -loop_event_done_fast( +loop_event_done_fast_2( Parent, Hibernate, S, - Events, P, NextState, NewData, + Events, P, NextState, NewData, NextEventsR, {TimerTypes,CancelTimers}) -> %% - loop_event_done( - Parent, ?not_sys_debug, - S#state{ - state = NextState, - data = NewData, - postponed = P, - timer_types = TimerTypes, - cancel_timers = CancelTimers, - hibernate = Hibernate}, - Events). - -loop_event_done(Parent, Debug, S, Q) -> - case Q of + NewS = + S#state{ + state = NextState, + data = NewData, + postponed = P, + timer_types = TimerTypes, + cancel_timers = CancelTimers, + hibernate = Hibernate}, + case NextEventsR of + %% Handle 0..2 next events without list reversal since + %% that will move out all live registers and back again [] -> - %% Get a new event - loop(Parent, Debug, S); - [{Type,Content}|Events] -> - %% Loop until out of enqueued events - loop_event(Parent, Debug, S, Events, Type, Content) + loop_event_done(Parent, ?not_sys_debug, NewS, Events); + [E] -> + loop_event_done(Parent, ?not_sys_debug, NewS, [E|Events]); + [E2,E1] -> + loop_event_done(Parent, ?not_sys_debug, NewS, [E1,E2|Events]); + _ -> + %% A bit slower path + loop_event_done( + Parent, ?not_sys_debug, NewS, lists:reverse(NextEventsR, Events)) end. - %%--------------------------------------------------------------------------- %% Server loop helpers diff --git a/lib/stdlib/test/gen_statem_SUITE.erl b/lib/stdlib/test/gen_statem_SUITE.erl index 053233df9b..017939fdd6 100644 --- a/lib/stdlib/test/gen_statem_SUITE.erl +++ b/lib/stdlib/test/gen_statem_SUITE.erl @@ -121,7 +121,8 @@ end_per_testcase(_CaseName, Config) -> start1(Config) -> %%OldFl = process_flag(trap_exit, true), - {ok,Pid0} = gen_statem:start_link(?MODULE, start_arg(Config, []), []), + {ok,Pid0} = + gen_statem:start_link(?MODULE, start_arg(Config, []), [{debug,[trace]}]), ok = do_func_test(Pid0), ok = do_sync_func_test(Pid0), stop_it(Pid0), @@ -135,7 +136,8 @@ start1(Config) -> %% anonymous w. shutdown start2(Config) -> %% Dont link when shutdown - {ok,Pid0} = gen_statem:start(?MODULE, start_arg(Config, []), []), + {ok,Pid0} = + gen_statem:start(?MODULE, start_arg(Config, []), []), ok = do_func_test(Pid0), ok = do_sync_func_test(Pid0), stopped = gen_statem:call(Pid0, {stop,shutdown}), @@ -641,51 +643,72 @@ state_enter(_Config) -> end, start => fun (enter, Prev, N) -> - Self ! {enter,start,Prev,N}, + Self ! {N,enter,start,Prev}, {keep_state,N + 1}; (internal, Prev, N) -> - Self ! {internal,start,Prev,N}, + Self ! {N,internal,start,Prev}, {keep_state,N + 1}; + (timeout, M, N) -> + {keep_state, N + 1, + {reply, {Self,N}, {timeout,M}}}; ({call,From}, repeat, N) -> {repeat_state,N + 1, - [{reply,From,{repeat,start,N}}]}; + [{reply,From,{N,repeat,start}}]}; ({call,From}, echo, N) -> {next_state,wait,N + 1, - {reply,From,{echo,start,N}}}; + [{reply,From,{N,echo,start}},{timeout,0,N}]}; ({call,From}, {stop,Reason}, N) -> {stop_and_reply,Reason, - [{reply,From,{stop,N}}],N + 1} + [{reply,From,{N,stop}}],N + 1} end, wait => fun (enter, Prev, N) when N < 5 -> {repeat_state,N + 1, - {reply,{Self,N},{enter,Prev}}}; + [{reply,{Self,N},{enter,Prev}}, + {timeout,0,N}, + {state_timeout,0,N}]}; (enter, Prev, N) -> - Self ! {enter,wait,Prev,N}, - {keep_state,N + 1}; + Self ! {N,enter,wait,Prev}, + {keep_state,N + 1, + [{timeout,0,N}, + {state_timeout,0,N}]}; + (timeout, M, N) -> + {keep_state, N + 1, + {reply, {Self,N}, {timeout,M}}}; + (state_timeout, M, N) -> + {keep_state, N + 1, + {reply, {Self,N}, {state_timeout,M}}}; ({call,From}, repeat, N) -> {repeat_state_and_data, - [{reply,From,{repeat,wait,N}}]}; + [{reply,From,{N,repeat,wait}}, + {timeout,0,N}]}; ({call,From}, echo, N) -> {next_state,start,N + 1, [{next_event,internal,wait}, - {reply,From,{echo,wait,N}}]} + {reply,From,{N,echo,wait}}]} end}, {ok,STM} = gen_statem:start_link( - ?MODULE, {map_statem,Machine,[state_enter]}, []), - - [{enter,start,start,1}] = flush(), - {echo,start,2} = gen_statem:call(STM, echo), - [{3,{enter,start}},{4,{enter,start}},{enter,wait,start,5}] = flush(), - {wait,[6|_]} = sys:get_state(STM), - {repeat,wait,6} = gen_statem:call(STM, repeat), - [{enter,wait,wait,6}] = flush(), - {echo,wait,7} = gen_statem:call(STM, echo), - [{enter,start,wait,8},{internal,start,wait,9}] = flush(), - {repeat,start,10} = gen_statem:call(STM, repeat), - [{enter,start,start,11}] = flush(), - {stop,12} = gen_statem:call(STM, {stop,bye}), + ?MODULE, {map_statem,Machine,[state_enter]}, [{debug,[trace]}]), + + [{1,enter,start,start}] = flush(), + {2,echo,start} = gen_statem:call(STM, echo), + [{3,{enter,start}}, + {4,{enter,start}}, + {5,enter,wait,start}, + {6,{timeout,5}}, + {7,{state_timeout,5}}] = flush(), + {wait,[8|_]} = sys:get_state(STM), + {8,repeat,wait} = gen_statem:call(STM, repeat), + [{8,enter,wait,wait}, + {9,{timeout,8}}, + {10,{state_timeout,8}}] = flush(), + {11,echo,wait} = gen_statem:call(STM, echo), + [{12,enter,start,wait}, + {13,internal,start,wait}] = flush(), + {14,repeat,start} = gen_statem:call(STM, repeat), + [{15,enter,start,start}] = flush(), + {16,stop} = gen_statem:call(STM, {stop,bye}), [{'EXIT',STM,bye}] = flush(), {noproc,_} = -- cgit v1.2.3