From 0456b78d87e47c97b125b6a9448214d9e7b2e574 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20Chmielowski?= Date: Thu, 17 Jul 2014 10:50:43 +0200 Subject: [PATCH] Use p1_utils --- rebar.config.script | 3 +- src/p1_fsm.erl | 848 -------------------------------------------- tools/p1_prof.erl | 327 ----------------- 3 files changed, 2 insertions(+), 1176 deletions(-) delete mode 100644 src/p1_fsm.erl delete mode 100644 tools/p1_prof.erl diff --git a/rebar.config.script b/rebar.config.script index 4a2158066..5fadc7639 100644 --- a/rebar.config.script +++ b/rebar.config.script @@ -56,7 +56,8 @@ Deps = [{p1_cache_tab, ".*", {git, "git://github.com/processone/cache_tab"}}, {esip, ".*", {git, "git://github.com/processone/p1_sip"}}, {p1_stun, ".*", {git, "git://github.com/processone/stun"}}, {p1_yaml, ".*", {git, "git://github.com/processone/p1_yaml"}}, - {xmlrpc, ".*", {git, "git://github.com/rds13/xmlrpc"}}], + {xmlrpc, ".*", {git, "git://github.com/rds13/xmlrpc"}}, + {p1_utils, ".*", {git, "git://github.com/processone/p1_utils"}}], ConfigureCmd = fun(Pkg, Flags) -> {'get-deps', diff --git a/src/p1_fsm.erl b/src/p1_fsm.erl deleted file mode 100644 index 80f08c609..000000000 --- a/src/p1_fsm.erl +++ /dev/null @@ -1,848 +0,0 @@ -%% ``The contents of this file are subject to the Erlang Public License, -%% Version 1.1, (the "License"); you may not use this file except in -%% compliance with the License. You should have received a copy of the -%% Erlang Public License along with this software. If not, it can be -%% retrieved via the world wide web at http://www.erlang.org/. -%% -%% Software distributed under the License is distributed on an "AS IS" -%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See -%% the License for the specific language governing rights and limitations -%% under the License. -%% -%% The Initial Developer of the Original Code is Ericsson Utvecklings AB. -%% Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings -%% AB. All Rights Reserved.'' -%% -%% The code has been modified and improved by ProcessOne. -%% Copyright 2007-2014, ProcessOne -%% -%% The change adds the following features: -%% - You can send exit(priority_shutdown) to the p1_fsm process to -%% terminate immediatetly. If the fsm trap_exit process flag has been -%% set to true, the FSM terminate function will called. -%% - You can pass the gen_fsm options to control resource usage. -%% {max_queue, N} will exit the process with priority_shutdown -%% - You can limit the time processing a message (TODO): If the -%% message processing does not return in a given period of time, the -%% process will be terminated. -%% - You might customize the State data before sending it to error_logger -%% in case of a crash (just export the function print_state/1) -%% $Id$ -%% --module(p1_fsm). - -%%%----------------------------------------------------------------- -%%% -%%% This state machine is somewhat more pure than state_lib. It is -%%% still based on State dispatching (one function per state), but -%%% allows a function handle_event to take care of events in all states. -%%% It's not that pure anymore :( We also allow synchronized event sending. -%%% -%%% If the Parent process terminates the Module:terminate/2 -%%% function is called. -%%% -%%% The user module should export: -%%% -%%% init(Args) -%%% ==> {ok, StateName, StateData} -%%% {ok, StateName, StateData, Timeout} -%%% ignore -%%% {stop, Reason} -%%% -%%% StateName(Msg, StateData) -%%% -%%% ==> {next_state, NewStateName, NewStateData} -%%% {next_state, NewStateName, NewStateData, Timeout} -%%% {stop, Reason, NewStateData} -%%% Reason = normal | shutdown | Term terminate(State) is called -%%% -%%% StateName(Msg, From, StateData) -%%% -%%% ==> {next_state, NewStateName, NewStateData} -%%% {next_state, NewStateName, NewStateData, Timeout} -%%% {reply, Reply, NewStateName, NewStateData} -%%% {reply, Reply, NewStateName, NewStateData, Timeout} -%%% {stop, Reason, NewStateData} -%%% Reason = normal | shutdown | Term terminate(State) is called -%%% -%%% handle_event(Msg, StateName, StateData) -%%% -%%% ==> {next_state, NewStateName, NewStateData} -%%% {next_state, NewStateName, NewStateData, Timeout} -%%% {stop, Reason, Reply, NewStateData} -%%% {stop, Reason, NewStateData} -%%% Reason = normal | shutdown | Term terminate(State) is called -%%% -%%% handle_sync_event(Msg, From, StateName, StateData) -%%% -%%% ==> {next_state, NewStateName, NewStateData} -%%% {next_state, NewStateName, NewStateData, Timeout} -%%% {reply, Reply, NewStateName, NewStateData} -%%% {reply, Reply, NewStateName, NewStateData, Timeout} -%%% {stop, Reason, Reply, NewStateData} -%%% {stop, Reason, NewStateData} -%%% Reason = normal | shutdown | Term terminate(State) is called -%%% -%%% handle_info(Info, StateName) (e.g. {'EXIT', P, R}, {nodedown, N}, ... -%%% -%%% ==> {next_state, NewStateName, NewStateData} -%%% {next_state, NewStateName, NewStateData, Timeout} -%%% {stop, Reason, NewStateData} -%%% Reason = normal | shutdown | Term terminate(State) is called -%%% -%%% terminate(Reason, StateName, StateData) Let the user module clean up -%%% always called when server terminates -%%% -%%% ==> the return value is ignored -%%% -%%% -%%% The work flow (of the fsm) can be described as follows: -%%% -%%% User module fsm -%%% ----------- ------- -%%% start -----> start -%%% init <----- . -%%% -%%% loop -%%% StateName <----- . -%%% -%%% handle_event <----- . -%%% -%%% handle__sunc_event <----- . -%%% -%%% handle_info <----- . -%%% -%%% terminate <----- . -%%% -%%% -%%% --------------------------------------------------- - --export([start/3, start/4, - start_link/3, start_link/4, - send_event/2, sync_send_event/2, sync_send_event/3, - send_all_state_event/2, - sync_send_all_state_event/2, sync_send_all_state_event/3, - reply/2, - start_timer/2,send_event_after/2,cancel_timer/1, - enter_loop/4, enter_loop/5, enter_loop/6, wake_hib/7]). - -%% Internal exports --export([init_it/6, print_event/3, - system_continue/3, - system_terminate/4, - system_code_change/4, - format_status/2]). - --import(error_logger , [format/2]). - -%%% Internal gen_fsm state -%%% This state is used to defined resource control values: --record(limits, {max_queue :: non_neg_integer()}). - -%%% --------------------------------------------------- -%%% Interface functions. -%%% --------------------------------------------------- - --callback init(Args :: term()) -> - {ok, StateName :: atom(), StateData :: term()} | - {ok, StateName :: atom(), StateData :: term(), timeout() | hibernate} | - {stop, Reason :: term()} | ignore. --callback handle_event(Event :: term(), StateName :: atom(), - StateData :: term()) -> - {next_state, NextStateName :: atom(), NewStateData :: term()} | - {next_state, NextStateName :: atom(), NewStateData :: term(), - timeout() | hibernate} | - {migrate, NewStateData :: term(), - {Node :: atom(), M :: atom(), F :: atom(), A :: list()}, - Timeout :: timeout()} | - {stop, Reason :: term(), NewStateData :: term()}. --callback handle_sync_event(Event :: term(), From :: {pid(), Tag :: term()}, - StateName :: atom(), StateData :: term()) -> - {reply, Reply :: term(), NextStateName :: atom(), NewStateData :: term()} | - {reply, Reply :: term(), NextStateName :: atom(), NewStateData :: term(), - timeout() | hibernate} | - {next_state, NextStateName :: atom(), NewStateData :: term()} | - {next_state, NextStateName :: atom(), NewStateData :: term(), - timeout() | hibernate} | - {migrate, NewStateData :: term(), - {Node :: atom(), M :: atom(), F :: atom(), A :: list()}, - Timeout :: timeout()} | - {stop, Reason :: term(), Reply :: term(), NewStateData :: term()} | - {stop, Reason :: term(), NewStateData :: term()}. --callback handle_info(Info :: term(), StateName :: atom(), - StateData :: term()) -> - {next_state, NextStateName :: atom(), NewStateData :: term()} | - {next_state, NextStateName :: atom(), NewStateData :: term(), - timeout() | hibernate} | - {migrate, NewStateData :: term(), - {Node :: atom(), M :: atom(), F :: atom(), A :: list()}, - Timeout :: timeout()} | - {stop, Reason :: normal | term(), NewStateData :: term()}. --callback terminate(Reason :: normal | shutdown | {shutdown, term()} - | term(), StateName :: atom(), StateData :: term()) -> - term(). --callback code_change(OldVsn :: term() | {down, term()}, StateName :: atom(), - StateData :: term(), Extra :: term()) -> - {ok, NextStateName :: atom(), NewStateData :: term()}. - -%%% --------------------------------------------------- -%%% Starts a generic state machine. -%%% start(Mod, Args, Options) -%%% start(Name, Mod, Args, Options) -%%% start_link(Mod, Args, Options) -%%% start_link(Name, Mod, Args, Options) where: -%%% Name ::= {local, atom()} | {global, atom()} -%%% Mod ::= atom(), callback module implementing the 'real' fsm -%%% Args ::= term(), init arguments (to Mod:init/1) -%%% Options ::= [{debug, [Flag]}] -%%% Flag ::= trace | log | {logfile, File} | statistics | debug -%%% (debug == log && statistics) -%%% Returns: {ok, Pid} | -%%% {error, {already_started, Pid}} | -%%% {error, Reason} -%%% --------------------------------------------------- -start(Mod, Args, Options) -> - gen:start(?MODULE, nolink, Mod, Args, Options). - -start(Name, Mod, Args, Options) -> - gen:start(?MODULE, nolink, Name, Mod, Args, Options). - -start_link(Mod, Args, Options) -> - gen:start(?MODULE, link, Mod, Args, Options). - -start_link(Name, Mod, Args, Options) -> - gen:start(?MODULE, link, Name, Mod, Args, Options). - - -send_event({global, Name}, Event) -> - catch global:send(Name, {'$gen_event', Event}), - ok; -send_event(Name, Event) -> - Name ! {'$gen_event', Event}, - ok. - -sync_send_event(Name, Event) -> - case catch gen:call(Name, '$gen_sync_event', Event) of - {ok,Res} -> - Res; - {'EXIT',Reason} -> - exit({Reason, {?MODULE, sync_send_event, [Name, Event]}}) - end. - -sync_send_event(Name, Event, Timeout) -> - case catch gen:call(Name, '$gen_sync_event', Event, Timeout) of - {ok,Res} -> - Res; - {'EXIT',Reason} -> - exit({Reason, {?MODULE, sync_send_event, [Name, Event, Timeout]}}) - end. - -send_all_state_event({global, Name}, Event) -> - catch global:send(Name, {'$gen_all_state_event', Event}), - ok; -send_all_state_event(Name, Event) -> - Name ! {'$gen_all_state_event', Event}, - ok. - -sync_send_all_state_event(Name, Event) -> - case catch gen:call(Name, '$gen_sync_all_state_event', Event) of - {ok,Res} -> - Res; - {'EXIT',Reason} -> - exit({Reason, {?MODULE, sync_send_all_state_event, [Name, Event]}}) - end. - -sync_send_all_state_event(Name, Event, Timeout) -> - case catch gen:call(Name, '$gen_sync_all_state_event', Event, Timeout) of - {ok,Res} -> - Res; - {'EXIT',Reason} -> - exit({Reason, {?MODULE, sync_send_all_state_event, - [Name, Event, Timeout]}}) - end. - -%% Designed to be only callable within one of the callbacks -%% hence using the self() of this instance of the process. -%% This is to ensure that timers don't go astray in global -%% e.g. when straddling a failover, or turn up in a restarted -%% instance of the process. - -%% Returns Ref, sends event {timeout,Ref,Msg} after Time -%% to the (then) current state. -start_timer(Time, Msg) -> - erlang:start_timer(Time, self(), {'$gen_timer', Msg}). - -%% Returns Ref, sends Event after Time to the (then) current state. -send_event_after(Time, Event) -> - erlang:start_timer(Time, self(), {'$gen_event', Event}). - -%% Returns the remaing time for the timer if Ref referred to -%% an active timer/send_event_after, false otherwise. -cancel_timer(Ref) -> - case erlang:cancel_timer(Ref) of - false -> - receive {timeout, Ref, _} -> 0 - after 0 -> false - end; - RemainingTime -> - RemainingTime - end. - -%% enter_loop/4,5,6 -%% Makes an existing process into a gen_fsm. -%% The calling process will enter the gen_fsm receive loop and become a -%% gen_fsm process. -%% The process *must* have been started using one of the start functions -%% in proc_lib, see proc_lib(3). -%% The user is responsible for any initialization of the process, -%% including registering a name for it. -enter_loop(Mod, Options, StateName, StateData) -> - enter_loop(Mod, Options, StateName, StateData, self(), infinity). - -enter_loop(Mod, Options, StateName, StateData, ServerName = {_,_}) -> - enter_loop(Mod, Options, StateName, StateData, ServerName,infinity); -enter_loop(Mod, Options, StateName, StateData, Timeout) -> - enter_loop(Mod, Options, StateName, StateData, self(), Timeout). - -enter_loop(Mod, Options, StateName, StateData, ServerName, Timeout) -> - Name = get_proc_name(ServerName), - Parent = get_parent(), - Debug = gen:debug_options(Options), - Limits = limit_options(Options), - Queue = queue:new(), - QueueLen = 0, - loop(Parent, Name, StateName, StateData, Mod, Timeout, Debug, - Limits, Queue, QueueLen). - -get_proc_name(Pid) when is_pid(Pid) -> - Pid; -get_proc_name({local, Name}) -> - case process_info(self(), registered_name) of - {registered_name, Name} -> - Name; - {registered_name, _Name} -> - exit(process_not_registered); - [] -> - exit(process_not_registered) - end; -get_proc_name({global, Name}) -> - case global:whereis_name(Name) of - undefined -> - exit(process_not_registered_globally); - Pid when Pid==self() -> - Name; - _Pid -> - exit(process_not_registered_globally) - end. - -get_parent() -> - case get('$ancestors') of - [Parent | _] when is_pid(Parent) -> - Parent; - [Parent | _] when is_atom(Parent) -> - name_to_pid(Parent); - _ -> - exit(process_was_not_started_by_proc_lib) - end. - -name_to_pid(Name) -> - case whereis(Name) of - undefined -> - case global:whereis_name(Name) of - undefined -> - exit(could_not_find_registerd_name); - Pid -> - Pid - end; - Pid -> - Pid - end. - -%%% --------------------------------------------------- -%%% Initiate the new process. -%%% Register the name using the Rfunc function -%%% Calls the Mod:init/Args function. -%%% Finally an acknowledge is sent to Parent and the main -%%% loop is entered. -%%% --------------------------------------------------- -init_it(Starter, self, Name, Mod, Args, Options) -> - init_it(Starter, self(), Name, Mod, Args, Options); -init_it(Starter, Parent, Name0, Mod, Args, Options) -> - Name = name(Name0), - Debug = gen:debug_options(Options), - Limits = limit_options(Options), - Queue = queue:new(), - QueueLen = 0, - case catch Mod:init(Args) of - {ok, StateName, StateData} -> - proc_lib:init_ack(Starter, {ok, self()}), - loop(Parent, Name, StateName, StateData, Mod, infinity, Debug, Limits, Queue, QueueLen); - {ok, StateName, StateData, Timeout} -> - proc_lib:init_ack(Starter, {ok, self()}), - loop(Parent, Name, StateName, StateData, Mod, Timeout, Debug, Limits, Queue, QueueLen); - {stop, Reason} -> - proc_lib:init_ack(Starter, {error, Reason}), - exit(Reason); - ignore -> - proc_lib:init_ack(Starter, ignore), - exit(normal); - {'EXIT', Reason} -> - proc_lib:init_ack(Starter, {error, Reason}), - exit(Reason); - Else -> - Error = {bad_return_value, Else}, - proc_lib:init_ack(Starter, {error, Error}), - exit(Error) - end. - -name({local,Name}) -> Name; -name({global,Name}) -> Name; -name(Pid) when is_pid(Pid) -> Pid. - -%%----------------------------------------------------------------- -%% The MAIN loop -%%----------------------------------------------------------------- -loop(Parent, Name, StateName, StateData, Mod, hibernate, Debug, - Limits, Queue, QueueLen) - when QueueLen > 0 -> - case queue:out(Queue) of - {{value, Msg}, Queue1} -> - decode_msg(Msg, Parent, Name, StateName, StateData, Mod, hibernate, - Debug, Limits, Queue1, QueueLen - 1, false); - {empty, _} -> - Reason = internal_queue_error, - error_info(Mod, Reason, Name, hibernate, StateName, StateData, Debug), - exit(Reason) - end; -loop(Parent, Name, StateName, StateData, Mod, hibernate, Debug, - Limits, _Queue, _QueueLen) -> - proc_lib:hibernate(?MODULE,wake_hib, - [Parent, Name, StateName, StateData, Mod, - Debug, Limits]); -%% First we test if we have reach a defined limit ... -loop(Parent, Name, StateName, StateData, Mod, Time, Debug, - Limits, Queue, QueueLen) -> - try - message_queue_len(Limits, QueueLen) - %% TODO: We can add more limit checking here... - catch - {process_limit, Limit} -> - Reason = {process_limit, Limit}, - Msg = {'EXIT', Parent, {error, {process_limit, Limit}}}, - terminate(Reason, Name, Msg, Mod, StateName, StateData, Debug) - end, - process_message(Parent, Name, StateName, StateData, - Mod, Time, Debug, Limits, Queue, QueueLen). -%% ... then we can process a new message: -process_message(Parent, Name, StateName, StateData, Mod, Time, Debug, - Limits, Queue, QueueLen) -> - {Msg, Queue1, QueueLen1} = collect_messages(Queue, QueueLen, Time), - decode_msg(Msg,Parent, Name, StateName, StateData, Mod, Time, - Debug, Limits, Queue1, QueueLen1, false). - -collect_messages(Queue, QueueLen, Time) -> - receive - Input -> - case Input of - {'EXIT', _Parent, priority_shutdown} -> - {Input, Queue, QueueLen}; - _ -> - collect_messages( - queue:in(Input, Queue), QueueLen + 1, Time) - end - after 0 -> - case queue:out(Queue) of - {{value, Msg}, Queue1} -> - {Msg, Queue1, QueueLen - 1}; - {empty, _} -> - receive - Input -> - {Input, Queue, QueueLen} - after Time -> - {{'$gen_event', timeout}, Queue, QueueLen} - end - end - end. - - -wake_hib(Parent, Name, StateName, StateData, Mod, Debug, - Limits) -> - Msg = receive - Input -> - Input - end, - Queue = queue:new(), - QueueLen = 0, - decode_msg(Msg, Parent, Name, StateName, StateData, Mod, hibernate, - Debug, Limits, Queue, QueueLen, true). - -decode_msg(Msg,Parent, Name, StateName, StateData, Mod, Time, Debug, - Limits, Queue, QueueLen, Hib) -> - put('$internal_queue_len', QueueLen), - case Msg of - {system, From, Req} -> - sys:handle_system_msg(Req, From, Parent, ?MODULE, Debug, - [Name, StateName, StateData, - Mod, Time, Limits, Queue, QueueLen], Hib); - {'EXIT', Parent, Reason} -> - terminate(Reason, Name, Msg, Mod, StateName, StateData, Debug); - _Msg when Debug == [] -> - handle_msg(Msg, Parent, Name, StateName, StateData, - Mod, Time, Limits, Queue, QueueLen); - _Msg -> - Debug1 = sys:handle_debug(Debug, fun print_event/3, - {Name, StateName}, {in, Msg}), - handle_msg(Msg, Parent, Name, StateName, StateData, - Mod, Time, Debug1, Limits, Queue, QueueLen) - end. - -%%----------------------------------------------------------------- -%% Callback functions for system messages handling. -%%----------------------------------------------------------------- -system_continue(Parent, Debug, [Name, StateName, StateData, - Mod, Time, Limits, Queue, QueueLen]) -> - loop(Parent, Name, StateName, StateData, Mod, Time, Debug, - Limits, Queue, QueueLen). - --spec system_terminate(term(), _, _, [term(),...]) -> no_return(). - -system_terminate(Reason, _Parent, Debug, - [Name, StateName, StateData, Mod, _Time, _Limits]) -> - terminate(Reason, Name, [], Mod, StateName, StateData, Debug). - -system_code_change([Name, StateName, StateData, Mod, Time, - Limits, Queue, QueueLen], - _Module, OldVsn, Extra) -> - case catch Mod:code_change(OldVsn, StateName, StateData, Extra) of - {ok, NewStateName, NewStateData} -> - {ok, [Name, NewStateName, NewStateData, Mod, Time, - Limits, Queue, QueueLen]}; - Else -> Else - end. - -%%----------------------------------------------------------------- -%% Format debug messages. Print them as the call-back module sees -%% them, not as the real erlang messages. Use trace for that. -%%----------------------------------------------------------------- -print_event(Dev, {in, Msg}, {Name, StateName}) -> - case Msg of - {'$gen_event', Event} -> - io:format(Dev, "*DBG* ~p got event ~p in state ~w~n", - [Name, Event, StateName]); - {'$gen_all_state_event', Event} -> - io:format(Dev, - "*DBG* ~p got all_state_event ~p in state ~w~n", - [Name, Event, StateName]); - {timeout, Ref, {'$gen_timer', Message}} -> - io:format(Dev, - "*DBG* ~p got timer ~p in state ~w~n", - [Name, {timeout, Ref, Message}, StateName]); - {timeout, _Ref, {'$gen_event', Event}} -> - io:format(Dev, - "*DBG* ~p got timer ~p in state ~w~n", - [Name, Event, StateName]); - _ -> - io:format(Dev, "*DBG* ~p got ~p in state ~w~n", - [Name, Msg, StateName]) - end; -print_event(Dev, {out, Msg, To, StateName}, Name) -> - io:format(Dev, "*DBG* ~p sent ~p to ~w~n" - " and switched to state ~w~n", - [Name, Msg, To, StateName]); -print_event(Dev, return, {Name, StateName}) -> - io:format(Dev, "*DBG* ~p switched to state ~w~n", - [Name, StateName]). - -relay_messages(MRef, TRef, Clone, Queue) -> - lists:foreach( - fun(Msg) -> Clone ! Msg end, - queue:to_list(Queue)), - relay_messages(MRef, TRef, Clone). - -relay_messages(MRef, TRef, Clone) -> - receive - {'DOWN', MRef, process, Clone, Reason} -> - Reason; - {'EXIT', _Parent, _Reason} -> - {migrated, Clone}; - {timeout, TRef, timeout} -> - {migrated, Clone}; - Msg -> - Clone ! Msg, - relay_messages(MRef, TRef, Clone) - end. - -handle_msg(Msg, Parent, Name, StateName, StateData, Mod, _Time, - Limits, Queue, QueueLen) -> %No debug here - From = from(Msg), - case catch dispatch(Msg, Mod, StateName, StateData) of - {next_state, NStateName, NStateData} -> - loop(Parent, Name, NStateName, NStateData, - Mod, infinity, [], Limits, Queue, QueueLen); - {next_state, NStateName, NStateData, Time1} -> - loop(Parent, Name, NStateName, NStateData, Mod, Time1, [], - Limits, Queue, QueueLen); - {reply, Reply, NStateName, NStateData} when From =/= undefined -> - reply(From, Reply), - loop(Parent, Name, NStateName, NStateData, - Mod, infinity, [], Limits, Queue, QueueLen); - {reply, Reply, NStateName, NStateData, Time1} when From =/= undefined -> - reply(From, Reply), - loop(Parent, Name, NStateName, NStateData, Mod, Time1, [], - Limits, Queue, QueueLen); - {migrate, NStateData, {Node, M, F, A}, Time1} -> - Reason = case catch rpc:call(Node, M, F, A, 5000) of - {badrpc, _} = Err -> - {migration_error, Err}; - {'EXIT', _} = Err -> - {migration_error, Err}; - {error, _} = Err -> - {migration_error, Err}; - {ok, Clone} -> - process_flag(trap_exit, true), - MRef = erlang:monitor(process, Clone), - TRef = erlang:start_timer(Time1, self(), timeout), - relay_messages(MRef, TRef, Clone, Queue); - Reply -> - {migration_error, {bad_reply, Reply}} - end, - terminate(Reason, Name, Msg, Mod, StateName, NStateData, []); - {stop, Reason, NStateData} -> - terminate(Reason, Name, Msg, Mod, StateName, NStateData, []); - {stop, Reason, Reply, NStateData} when From =/= undefined -> - {'EXIT', R} = (catch terminate(Reason, Name, Msg, Mod, - StateName, NStateData, [])), - reply(From, Reply), - exit(R); - {'EXIT', What} -> - terminate(What, Name, Msg, Mod, StateName, StateData, []); - Reply -> - terminate({bad_return_value, Reply}, - Name, Msg, Mod, StateName, StateData, []) - end. - -handle_msg(Msg, Parent, Name, StateName, StateData, - Mod, _Time, Debug, Limits, Queue, QueueLen) -> - From = from(Msg), - case catch dispatch(Msg, Mod, StateName, StateData) of - {next_state, NStateName, NStateData} -> - Debug1 = sys:handle_debug(Debug, fun print_event/3, - {Name, NStateName}, return), - loop(Parent, Name, NStateName, NStateData, - Mod, infinity, Debug1, Limits, Queue, QueueLen); - {next_state, NStateName, NStateData, Time1} -> - Debug1 = sys:handle_debug(Debug, fun print_event/3, - {Name, NStateName}, return), - loop(Parent, Name, NStateName, NStateData, - Mod, Time1, Debug1, Limits, Queue, QueueLen); - {reply, Reply, NStateName, NStateData} when From =/= undefined -> - Debug1 = reply(Name, From, Reply, Debug, NStateName), - loop(Parent, Name, NStateName, NStateData, - Mod, infinity, Debug1, Limits, Queue, QueueLen); - {reply, Reply, NStateName, NStateData, Time1} when From =/= undefined -> - Debug1 = reply(Name, From, Reply, Debug, NStateName), - loop(Parent, Name, NStateName, NStateData, - Mod, Time1, Debug1, Limits, Queue, QueueLen); - {migrate, NStateData, {Node, M, F, A}, Time1} -> - Reason = case catch rpc:call(Node, M, F, A, Time1) of - {badrpc, R} -> - {migration_error, R}; - {'EXIT', R} -> - {migration_error, R}; - {error, R} -> - {migration_error, R}; - {ok, Clone} -> - process_flag(trap_exit, true), - MRef = erlang:monitor(process, Clone), - TRef = erlang:start_timer(Time1, self(), timeout), - relay_messages(MRef, TRef, Clone, Queue); - Reply -> - {migration_error, {bad_reply, Reply}} - end, - terminate(Reason, Name, Msg, Mod, StateName, NStateData, Debug); - {stop, Reason, NStateData} -> - terminate(Reason, Name, Msg, Mod, StateName, NStateData, Debug); - {stop, Reason, Reply, NStateData} when From =/= undefined -> - {'EXIT', R} = (catch terminate(Reason, Name, Msg, Mod, - StateName, NStateData, Debug)), - reply(Name, From, Reply, Debug, StateName), - exit(R); - {'EXIT', What} -> - terminate(What, Name, Msg, Mod, StateName, StateData, Debug); - Reply -> - terminate({bad_return_value, Reply}, - Name, Msg, Mod, StateName, StateData, Debug) - end. - -dispatch({'$gen_event', Event}, Mod, StateName, StateData) -> - Mod:StateName(Event, StateData); -dispatch({'$gen_all_state_event', Event}, Mod, StateName, StateData) -> - Mod:handle_event(Event, StateName, StateData); -dispatch({'$gen_sync_event', From, Event}, Mod, StateName, StateData) -> - Mod:StateName(Event, From, StateData); -dispatch({'$gen_sync_all_state_event', From, Event}, - Mod, StateName, StateData) -> - Mod:handle_sync_event(Event, From, StateName, StateData); -dispatch({timeout, Ref, {'$gen_timer', Msg}}, Mod, StateName, StateData) -> - Mod:StateName({timeout, Ref, Msg}, StateData); -dispatch({timeout, _Ref, {'$gen_event', Event}}, Mod, StateName, StateData) -> - Mod:StateName(Event, StateData); -dispatch(Info, Mod, StateName, StateData) -> - Mod:handle_info(Info, StateName, StateData). - -from({'$gen_sync_event', From, _Event}) -> From; -from({'$gen_sync_all_state_event', From, _Event}) -> From; -from(_) -> undefined. - -%% Send a reply to the client. -reply({To, Tag}, Reply) -> - catch To ! {Tag, Reply}. - -reply(Name, {To, Tag}, Reply, Debug, StateName) -> - reply({To, Tag}, Reply), - sys:handle_debug(Debug, fun print_event/3, Name, - {out, Reply, To, StateName}). - -%%% --------------------------------------------------- -%%% Terminate the server. -%%% --------------------------------------------------- - --spec terminate(term(), _, _, atom(), _, _, _) -> no_return(). - -terminate(Reason, Name, Msg, Mod, StateName, StateData, Debug) -> - case catch Mod:terminate(Reason, StateName, StateData) of - {'EXIT', R} -> - error_info(Mod, R, Name, Msg, StateName, StateData, Debug), - exit(R); - _ -> - case Reason of - normal -> - exit(normal); - shutdown -> - exit(shutdown); - priority_shutdown -> - %% Priority shutdown should be considered as - %% shutdown by SASL - exit(shutdown); - {process_limit, _Limit} -> - exit(Reason); - {migrated, _Clone} -> - exit(normal); - _ -> - error_info(Mod, Reason, Name, Msg, StateName, StateData, Debug), - exit(Reason) - end - end. - -error_info(Mod, Reason, Name, Msg, StateName, StateData, Debug) -> - Reason1 = - case Reason of - {undef,[{M,F,A}|MFAs]} -> - case code:is_loaded(M) of - false -> - {'module could not be loaded',[{M,F,A}|MFAs]}; - _ -> - case erlang:function_exported(M, F, length(A)) of - true -> - Reason; - false -> - {'function not exported',[{M,F,A}|MFAs]} - end - end; - _ -> - Reason - end, - StateToPrint = case erlang:function_exported(Mod, print_state, 1) of - true -> (catch Mod:print_state(StateData)); - false -> StateData - end, - Str = "** State machine ~p terminating \n" ++ - get_msg_str(Msg) ++ - "** When State == ~p~n" - "** Data == ~p~n" - "** Reason for termination = ~n** ~p~n", - format(Str, [Name, get_msg(Msg), StateName, StateToPrint, Reason1]), - sys:print_log(Debug), - ok. - -get_msg_str({'$gen_event', _Event}) -> - "** Last event in was ~p~n"; -get_msg_str({'$gen_sync_event', _Event}) -> - "** Last sync event in was ~p~n"; -get_msg_str({'$gen_all_state_event', _Event}) -> - "** Last event in was ~p (for all states)~n"; -get_msg_str({'$gen_sync_all_state_event', _Event}) -> - "** Last sync event in was ~p (for all states)~n"; -get_msg_str({timeout, _Ref, {'$gen_timer', _Msg}}) -> - "** Last timer event in was ~p~n"; -get_msg_str({timeout, _Ref, {'$gen_event', _Msg}}) -> - "** Last timer event in was ~p~n"; -get_msg_str(_Msg) -> - "** Last message in was ~p~n". - -get_msg({'$gen_event', Event}) -> Event; -get_msg({'$gen_sync_event', Event}) -> Event; -get_msg({'$gen_all_state_event', Event}) -> Event; -get_msg({'$gen_sync_all_state_event', Event}) -> Event; -get_msg({timeout, Ref, {'$gen_timer', Msg}}) -> {timeout, Ref, Msg}; -get_msg({timeout, _Ref, {'$gen_event', Event}}) -> Event; -get_msg(Msg) -> Msg. - -%%----------------------------------------------------------------- -%% Status information -%%----------------------------------------------------------------- -format_status(Opt, StatusData) -> - [PDict, SysState, Parent, Debug, [Name, StateName, StateData, Mod, _Time, _Limits, _Queue, _QueueLen]] = - StatusData, - NameTag = if is_pid(Name) -> - pid_to_list(Name); - is_atom(Name) -> - Name - end, - Header = lists:concat(["Status for state machine ", NameTag]), - Log = sys:get_debug(log, Debug, []), - Specfic = - case erlang:function_exported(Mod, format_status, 2) of - true -> - case catch Mod:format_status(Opt,[PDict,StateData]) of - {'EXIT', _} -> [{data, [{"StateData", StateData}]}]; - Else -> Else - end; - _ -> - [{data, [{"StateData", StateData}]}] - end, - [{header, Header}, - {data, [{"Status", SysState}, - {"Parent", Parent}, - {"Logged events", Log}, - {"StateName", StateName}]} | - Specfic]. - -%%----------------------------------------------------------------- -%% Resources limit management -%%----------------------------------------------------------------- -%% Extract know limit options -limit_options(Options) -> - limit_options(Options, #limits{}). -limit_options([], Limits) -> - Limits; -%% Maximum number of messages allowed in the process message queue -limit_options([{max_queue,N}|Options], Limits) - when is_integer(N) -> - NewLimits = Limits#limits{max_queue=N}, - limit_options(Options, NewLimits); -limit_options([_|Options], Limits) -> - limit_options(Options, Limits). - -%% Throw max_queue if we have reach the max queue size -%% Returns ok otherwise -message_queue_len(#limits{max_queue = undefined}, _QueueLen) -> - ok; -message_queue_len(#limits{max_queue = MaxQueue}, QueueLen) -> - Pid = self(), - case process_info(Pid, message_queue_len) of - {message_queue_len, N} when N + QueueLen > MaxQueue -> - throw({process_limit, {max_queue, N + QueueLen}}); - _ -> - ok - end. diff --git a/tools/p1_prof.erl b/tools/p1_prof.erl deleted file mode 100644 index c085f64fc..000000000 --- a/tools/p1_prof.erl +++ /dev/null @@ -1,327 +0,0 @@ -%%%------------------------------------------------------------------- -%%% File : p1_prof.erl -%%% Author : Evgeniy Khramtsov -%%% Description : Handy wrapper around eprof and fprof -%%% -%%% Created : 23 Jan 2010 by Evgeniy Khramtsov -%%% -%%% -%%% ejabberd, Copyright (C) 2002-2014 ProcessOne -%%% -%%% This program is free software; you can redistribute it and/or -%%% modify it under the terms of the GNU General Public License as -%%% published by the Free Software Foundation; either version 2 of the -%%% License, or (at your option) any later version. -%%% -%%% This program is distributed in the hope that it will be useful, -%%% but WITHOUT ANY WARRANTY; without even the implied warranty of -%%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -%%% General Public License for more details. -%%% -%%% You should have received a copy of the GNU General Public License along -%%% with this program; if not, write to the Free Software Foundation, Inc., -%%% 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. -%%% -%%%------------------------------------------------------------------- --module(p1_prof). - -%% API --export([eprof_start/0, eprof_stop/0, - fprof_start/0, fprof_start/1, - fprof_stop/0, fprof_analyze/0, - queue/0, queue/1, memory/0, memory/1, - reds/0, reds/1, trace/1, help/0, - q/0, m/0, r/0, q/1, m/1, r/1]). - --define(TRACE_FILE, "/tmp/fprof.trace"). --define(ANALYSIS_FILE, "/tmp/fprof.analysis"). - -%%==================================================================== -%% API -%%==================================================================== -eprof_start() -> - eprof:start(), - case get_procs() of - [] -> - {error, no_procs_found}; - Procs -> - eprof:start_profiling(Procs) - end. - -fprof_start() -> - fprof_start(0). - -fprof_start(Duration) -> - case get_procs() of - [] -> - {error, no_procs_found}; - Procs -> - case fprof:trace([start, {procs, Procs}, {file, ?TRACE_FILE}]) of - ok -> - io:format("Profiling started, writing trace data to ~s~n", - [?TRACE_FILE]), - if Duration > 0 -> - timer:sleep(Duration*1000), - fprof:trace([stop]), - fprof:stop(); - true-> - ok - end; - Err -> - io:format("Couldn't start profiling: ~p~n", [Err]), - Err - end - end. - -fprof_stop() -> - fprof:trace([stop]), - case fprof:profile([{file, ?TRACE_FILE}]) of - ok -> - case fprof:analyse([totals, no_details, {sort, own}, - no_callers, {dest, ?ANALYSIS_FILE}]) of - ok -> - fprof:stop(), - format_fprof_analyze(); - Err -> - io:format("Couldn't analyze: ~p~n", [Err]), - Err - end; - Err -> - io:format("Couldn't compile a trace into profile data: ~p~n", - [Err]), - Err - end. - -fprof_analyze() -> - fprof_stop(). - -eprof_stop() -> - eprof:stop_profiling(), - case erlang:function_exported(eprof, analyse, 0) of - true -> - apply(eprof, analyse, []); - false -> - eprof:analyze() - end. - -help() -> - M = ?MODULE, - io:format("Brief help:~n" - "~p:queue(N) - show top N pids sorted by queue length~n" - "~p:queue() - shorthand for ~p:queue(10)~n" - "~p:memory(N) - show top N pids sorted by memory usage~n" - "~p:memory() - shorthand for ~p:memory(10)~n" - "~p:reds(N) - show top N pids sorted by reductions~n" - "~p:reds() - shorthand for ~p:reds(10)~n" - "~p:q(N)|~p:q() - same as ~p:queue(N)|~p:queue()~n" - "~p:m(N)|~p:m() - same as ~p:memory(N)|~p:memory()~n" - "~p:r(N)|~p:r() - same as ~p:reds(N)|~p:reds()~n" - "~p:trace(Pid) - trace Pid; to stop tracing close " - "Erlang shell with Ctrl+C~n" - "~p:eprof_start() - start eprof on all available pids; " - "DO NOT use on production system!~n" - "~p:eprof_stop() - stop eprof and print result~n" - "~p:fprof_start() - start fprof on all available pids; " - "DO NOT use on production system!~n" - "~p:fprof_stop() - stop eprof and print formatted result~n" - "~p:fprof_start(N) - start and run fprof for N seconds; " - "use ~p:fprof_analyze() to analyze collected statistics and " - "print formatted result; use on production system with CARE~n" - "~p:fprof_analyze() - analyze previously collected statistics " - "using ~p:fprof_start(N) and print formatted result~n" - "~p:help() - print this help~n", - lists:duplicate(31, M)). - -q() -> - queue(). - -q(N) -> - queue(N). - -m() -> - memory(). - -m(N) -> - memory(N). - -r() -> - reds(). - -r(N) -> - reds(N). - -queue() -> - queue(10). - -memory() -> - memory(10). - -reds() -> - reds(10). - -queue(N) -> - dump(N, lists:reverse(lists:ukeysort(1, all_pids(queue)))). - -memory(N) -> - dump(N, lists:reverse(lists:ukeysort(3, all_pids(memory)))). - -reds(N) -> - dump(N, lists:reverse(lists:ukeysort(4, all_pids(reductions)))). - -trace(Pid) -> - erlang:trace(Pid, true, [send, 'receive']), - trace_loop(). - -trace_loop() -> - receive - M -> - io:format("~p~n", [M]), - trace_loop() - end. - -%%==================================================================== -%% Internal functions -%%==================================================================== -get_procs() -> - processes(). - -format_fprof_analyze() -> - case file:consult(?ANALYSIS_FILE) of - {ok, [_, [{totals, _, _, TotalOWN}] | Rest]} -> - OWNs = lists:flatmap( - fun({MFA, _, _, OWN}) -> - Percent = OWN*100/TotalOWN, - case round(Percent) of - 0 -> - []; - _ -> - [{mfa_to_list(MFA), Percent}] - end - end, Rest), - ACCs = collect_accs(Rest), - MaxACC = find_max(ACCs), - MaxOWN = find_max(OWNs), - io:format("=== Sorted by OWN:~n"), - lists:foreach( - fun({MFA, Per}) -> - L = length(MFA), - S = lists:duplicate(MaxOWN - L + 2, $ ), - io:format("~s~s~.2f%~n", [MFA, S, Per]) - end, lists:reverse(lists:keysort(2, OWNs))), - io:format("~n=== Sorted by ACC:~n"), - lists:foreach( - fun({MFA, Per}) -> - L = length(MFA), - S = lists:duplicate(MaxACC - L + 2, $ ), - io:format("~s~s~.2f%~n", [MFA, S, Per]) - end, lists:reverse(lists:keysort(2, ACCs))); - Err -> - Err - end. - -mfa_to_list({M, F, A}) -> - atom_to_list(M) ++ ":" ++ atom_to_list(F) ++ "/" ++ integer_to_list(A); -mfa_to_list(F) when is_atom(F) -> - atom_to_list(F). - -find_max(List) -> - find_max(List, 0). - -find_max([{V, _}|Tail], Acc) -> - find_max(Tail, lists:max([length(V), Acc])); -find_max([], Acc) -> - Acc. - -collect_accs(List) -> - List1 = lists:filter( - fun({MFA, _, _, _}) -> - case MFA of - {sys, _, _} -> - false; - suspend -> - false; - {gen_fsm, _, _} -> - false; - {p1_fsm, _, _} -> - false; - {gen, _, _} -> - false; - {gen_server, _, _} -> - false; - {proc_lib, _, _} -> - false; - _ -> - true - end - end, List), - TotalACC = lists:sum([A || {_, _, A, _} <- List1]), - lists:flatmap( - fun({MFA, _, ACC, _}) -> - Percent = ACC*100/TotalACC, - case round(Percent) of - 0 -> - []; - _ -> - [{mfa_to_list(MFA), Percent}] - end - end, List1). - -all_pids(Type) -> - lists:foldl( - fun(P, Acc) when P == self() -> - %% exclude ourself from statistics - Acc; - (P, Acc) -> - case catch process_info( - P, - [message_queue_len, - memory, - reductions, - dictionary, - current_function, - registered_name]) of - [{_, Len}, {_, Memory}, {_, Reds}, - {_, Dict}, {_, CurFun}, {_, RegName}] -> - IntQLen = case lists:keysearch('$internal_queue_len', 1, Dict) of - {value, {_, N}} -> - N; - _ -> - 0 - end, - if Type == queue andalso Len == 0 andalso IntQLen == 0 -> - Acc; - true -> - MaxLen = lists:max([Len, IntQLen]), - [{MaxLen, Len, Memory, Reds, Dict, CurFun, P, RegName}|Acc] - end; - _ -> - Acc - end - end, [], processes()). - -dump(N, Rs) -> - lists:foreach( - fun({_, MsgQLen, Memory, Reds, Dict, CurFun, Pid, RegName}) -> - PidStr = pid_to_list(Pid), - [_, Maj, Min] = string:tokens( - string:substr( - PidStr, 2, length(PidStr) - 2), "."), - io:format("** pid(0,~s,~s)~n" - "** registered name: ~p~n" - "** memory: ~p~n" - "** reductions: ~p~n" - "** message queue len: ~p~n" - "** current_function: ~p~n" - "** dictionary: ~p~n~n", - [Maj, Min, RegName, Memory, Reds, MsgQLen, CurFun, Dict]) - end, nthhead(N, Rs)). - -nthhead(N, L) -> - lists:reverse(nthhead(N, L, [])). - -nthhead(0, _L, Acc) -> - Acc; -nthhead(N, [H|T], Acc) -> - nthhead(N-1, T, [H|Acc]); -nthhead(_N, [], Acc) -> - Acc.