eprof(3)
💖 eprof — a time profiling tool for Erlang 💖
okay so this is the manual page for eprof(3), straight out of the Erlang module definitions collection. it's a tool, bestie, and it's here to tell you where your program's time is actually going. let's get into it 🫶
✨ NAME ✨
eprof — A Time Profiling Tool for Erlang
🦋 DESCRIPTION 🦋
The module eprof gives you a set of functions for time profiling of Erlang programs, so you can find out how the execution time is being 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. no cap. your program is gonna walk instead of run, that's just the vibe of tracing.
🎀 DATA TYPES 🎀
analyze_type() :: procs | total.
trace_pattern_mfa() :: {atom(), atom(), arity() | '_'}.💅 FUNCTIONS 💅
🌸 analyze(TypeOpts) -> ok | nothing_to_analyze
analyze(TypeOpts) -> ok | nothing_to_analyze
when TypeOpts :: analyze_type().If TypeOpts is an atom, it's assumed to be a module name, and this call is equivalent to analyze(TypeOpts, []).
Otherwise, if TypeOpts is a list, it's assumed to be a list of options, and this call is equivalent to analyze(procs, TypeOpts).
🍓 analyze(Type, Options) -> ok | nothing_to_analyze
analyze(Type, Options) -> ok | nothing_to_analyze
when
Type :: analyze_type(),
Options :: [Option],
Option :: {filter, Filter} | {sort, Sort},
Filter ::
[{calls, non_neg_integer()} | {time, float()}],
Sort :: time | calls | mfa.Call this function when profiling has been stopped to display the results. (yes, stopped first — analyze does not want to be mid-sprint, she wants a finished story ✋)
If Type is procs, the time spent in each function is shown separately for each profiled process.
If Type is total, the time spent in each function is shown combined for each profiled process.
Time is shown as a percentage of total time and as absolute time in micro seconds. both! you get both! we love a thorough queen 💅
🧚 log(File) -> ok
log(File) -> ok when File :: atom() | file:filename().Call this function to make sure the results displayed by analyze/0,1,2 get printed to the file File as well as to the screen. so you don't lose the receipts, bestie 📝
💜 profile(Fun) -> {ok, Value} | {error, Reason}
profile(Fun) -> {ok, Value} | {error, Reason}
when
Fun :: fun(() -> term()),
Value :: term(),
Reason :: term();
(Rootset) -> profiling | {error, Reason}
when Rootset :: [atom() | pid()], Reason :: term().If FunRootset is a fun, this call is equivalent to profile([], FunRootset).
If FunRootset is a list, it's assumed to be a Rootset, and this call is equivalent to start_profiling(Rootset).
🌈 profile(Fun, Options) -> {ok, Value} | {error, Reason}
profile(Fun, Options) -> {ok, Value} | {error, Reason}
when
Fun :: fun(() -> term()),
Options ::
[set_on_spawn | {set_on_spawn, boolean()}],
Value :: term(),
Reason :: term();
(Rootset, Fun) -> {ok, Value} | {error, Reason}
when
Rootset :: [atom() | pid()],
Fun :: fun(() -> term()),
Value :: term(),
Reason :: term().If Arg1 is a fun and Arg2 is list, this call is equivalent to profile([], Arg1, {'_','_','_'}, Arg2).
If Arg1 is a list and Arg2 is a fun, this call is equivalent to profile(Arg1, Arg2, {'_','_','_'}, Arg1).
👑 profile(Rootset, Module, Function, Args) -> {ok, Value} | {error, Reason}
profile(Rootset, Module, Function, Args) ->
{ok, Value} | {error, Reason}
when
Rootset :: [atom() | pid()],
Module :: module(),
Function :: atom(),
Args :: [term()],
Value :: term(),
Reason :: term();
(Rootset, Fun, Pattern, Options) ->
{ok, Value} | {error, Reason}
when
Rootset :: [atom() | pid()],
Fun :: fun(() -> term()),
Pattern :: trace_pattern_mfa(),
Options ::
[set_on_spawn | {set_on_spawn, boolean()}],
Value :: term(),
Reason :: term().This function spawns a process that applies a fun or an an function, and then starts profiling for the spawned proceses as well as the processes in Rootset (and any new processes spawned from them).
(the original really does say "an an" and "proceses" — no, we're not fixing it, that's canon 💀)
If Arg1 is a fun, Arg2 is expected to be a trace pattern, and Arg3 a list of options. In that case, this call is equivalent to:
profile(Rootset, erlang, apply, [Arg1, []], Arg2, Arg3)If Arg1 is an atom, Arg1 is assumed to be a module name, Arg2 the name of the function in that module, and Arg3 a list of arguments to be used when calling that function. In that case, this call is equivalent to:
profile(Rootset, Arg1, Arg2, Arg3, {'_','_','_'}, [{set_on_spawn,
true}])🌟 profile(Rootset, Module, Function, Args, Pattern, Options) -> {ok, Value} | {error, Reason}
profile(Rootset, Module, Function, Args, Pattern, Options) ->
{ok, Value} | {error, Reason}
when
Rootset :: [atom() | pid()],
Module :: module(),
Function :: atom(),
Args :: [term()],
Pattern :: trace_pattern_mfa(),
Options ::
[set_on_spawn | {set_on_spawn, boolean()}],
Value :: term(),
Reason :: term().This function spawns a process P that apply(Module, Function, Args), and then starts profiling for P and the processes in Rootset (and any new processes spawned from them).
Rootset is a list of pids and registered names.
Information about activity in any profiled process is stored in the Eprof database.
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 set_on_spawn option will active call time tracing for all processes spawned by processes in the rootset. This is the default behaviour.
🚨 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. otherwise your numbers are lying to you and that's not the vibe, bestie. not the vibe at all 😭
🫶 start() -> {ok, Pid} | {error, Reason}
start() -> {ok, Pid} | {error, Reason}
when Pid :: pid(), Reason :: {already_started, Pid}.Starts the Eprof server, which holds the internal state of the collected data. main character keeps all the memory here ✨
🎀 start_profiling(Rootset, Pattern, Options) -> profiling | {error, Reason}
start_profiling(Rootset, Pattern, Options) ->
profiling | {error, Reason}
when
Rootset :: [atom() | pid()],
Pattern :: trace_pattern_mfa(),
Options ::
[set_on_spawn |
{set_on_spawn, boolean()}],
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, a specific module can be selected, and only the code executed in that module will be profiled. so you can be picky — pickiness is a virtue 💅
The set_on_spawn option will active call time tracing for all processes spawned by processes in the rootset. This is the default behaviour.
⭐ stop() -> stopped
stop() -> stopped.Stops the Eprof server.
🦋 stop_profiling() -> profiling_stopped | profiling_already_stopped
stop_profiling() -> profiling_stopped | profiling_already_stopped.Stops profiling started with start_profiling/1 or profile/1.
🌸 and that's the whole page! every option, every type, every equivalence — all accounted for. understanding acquired. periodt. 💖
Ericsson AB · tools 4.2.2 · eprof(3) — brought to you by the Ericsson AB girlies, and yes the manual page is literally named eprof(3) and lives in the same era as tools 4.2.2. slay 🎀✨
📦 where this page comes from
- ubuntu stonking: erlang-doc 1:29.0.6+dfsg-1 · Apache-2.0
- 💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash on : a language model's rewrite of the original, under its terms