View Source README
Tim
the tiny timer.
Sometimes you want a simple tool to estimate execution time. Tim
can help!
explanation-and-usage
Explanation and usage
Tim
provides the macro time
that takes any valid Elixir expression and returns a map
containing several statistics for the expression's execution time, the result of the
evaluated expression, and the expression's string representation. To use
time
, require or import Tim
into your environment and pipe in the expression:
require Tim
1..10
|> Enum.map(& &1 * 2/((1 + 10) * 10))
|> Enum.sum()
|> Tim.time()
# returns (actual timing numbers will vary)
%{
expr: "1..10 |> Enum.map(&(&1 * 2 / ((1 + 10) * 10))) |> Enum.sum()",
max: 46,
mean: 46.0,
median: 46,
min: 46,
n: 1,
result: 1.0
}
All times are in microseconds.
The time
macro takes a second argument that is the number n
of times the expression
is executed to gather timing statistics. When the above expression is piped into
Time.time(100)
, the result will look something like
%{
expr: "1..10 |> Enum.map(&(&1 * 2 / ((1 + 10) * 10))) |> Enum.sum()",
max: 71,
mean: 13.83,
median: 12,
min: 10,
n: 100,
result: 1.0
}
under-the-hood
Under the hood
The body of the Tim.time
macro wraps around Erlang's :timer.tc
function that returns {<execution time in microseconds>, <result value>}
. The reason that time
is a macro is so
that the entire expression remains unevaluated until called inside :timer.tc
. To generate timing
statistics over independent executions, :timer.tc
and the expression are evaluated n
times.