eprof
A Time Profiling Tool for Erlang
The module eprof
provides a set of functions for time
profiling of Erlang programs to find out how the execution time is
used. The profiling is done using the Erlang trace BIFs. Tracing of
local function calls for a specified set of processes is enabled when
profiling is begun, and disabled when profiling is stopped.
When using Eprof expect a slowdown in program execution.
Functions
start() -> {ok,Pid} | {error,Reason}
Pid = pid()
Reason = {already_started,Pid}
Starts the Eprof server which holds the internal state of the collected data.
start_profiling(Rootset) -> profiling | {error, Reason}
start_profiling(Rootset,Pattern) -> profiling | {error, Reason}
Rootset = [atom() | pid()]
Pattern = {Module, Function, Arity}
Module = Function = atom()
Arity = integer()
Reason = term()
Starts profiling for the processes in Rootset
(and any new
processes spawned from them). Information about activity in any
profiled process is stored in the Eprof database.
Rootset
is a list of pids and registered names.
The function returns profiling
if tracing could be enabled
for all processes in Rootset
, or error
otherwise.
A pattern can be selected to narrow the profiling. For instance ca a specific module be selected and only the code processes executes in that module will be profiled.
stop_profiling() -> profiling_stopped | profiling_already_stopped
Stops profiling started with start_profiling/1
or
profile/1
.
profile(Fun) -> profiling | {error, Reason}
profile(Rootset) -> profiling | {error, Reason}
profile(Rootset,Fun) -> {ok, Value} | {error,Reason}
profile(Rootset,Fun,Pattern) -> {ok, Value} | {error, Reason}
profile(Rootset,Module,Function,Args) -> {ok, Value} | {error, Reason}
profile(Rootset,Module,Function,Args,Pattern) -> {ok, Value} | {error, Reason}
Rootset = [atom() | pid()]
Fun = fun() -> term()
Pattern = {Module, Function, Arity}
Module = Function = atom()
Args = [term()]
Arity = integer()
Value = Reason = term()
This function first spawns a process P
which evaluates
Fun()
or apply(Module,Function,Args)
. Then, it
starts profiling for P
and the processes in Rootset
(and any new processes spawned from them). Information about
activity in any profiled process is stored in the Eprof database.
Rootset
is a list of pids and registered names.
If tracing could be enabled for P
and all processes in
Rootset
, the function returns {ok,Value}
when
Fun()
/apply
returns with the value Value
, or
{error,Reason}
if Fun()
/apply
fails with
exit reason Reason
. Otherwise it returns {error, Reason}
immediately.
The programmer must ensure that the function given as argument is truly synchronous and that no work continues after the function has returned a value.
analyze() -> ok
analyze(Type) -> ok
analyze(Type,Options) -> ok
Type = procs | total
Options = [{filter, Filter} | {sort, Sort}
Filter = [{calls, integer()} | {time, float()}]
Sort = time | calls | mfa
Call this function when profiling has been stopped to display the results per process, that is:
- how much time has been used by each process, and
- in which function calls this time has been spent.
Call analyze
with total
option when profiling has been stopped to display
the results per function call, that is in which function calls
the time has been spent.
Time is shown as percentage of total time and as absolute time.
log(File) -> ok
File = atom() | string()
This function ensures that the results displayed by
analyse/0
and total_analyse/0
are printed both to
the file File
and the screen.
stop() -> stopped
Stops the Eprof server.