Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Stop Guessing and Start Measuring - Benchmarkin...

Stop Guessing and Start Measuring - Benchmarking in Practice (Lambdadays)

“What’s the fastest way of doing this?” - you might ask yourself during development. Sure, you can guess - but how do you know? How long would that function take with a million elements? Is that tail-recursive function always faster?

Benchmarking is here to give you the answers, but there are many pitfalls in setting up a good benchmark and analyzing the results. This talk will guide you through, introduce best practices, and surprise you with some results along the way. You didn’t think that the order of arguments could influence its performance...or did you?

Tobias Pfeiffer

February 23, 2018
Tweet

More Decks by Tobias Pfeiffer

Other Decks in Programming

Transcript

  1. iex(1)> defmodule RepeatN do ...(1)> def repeat_n(_function, 0) do ...(1)>

    # noop ...(1)> end ...(1)> def repeat_n(function, 1) do ...(1)> function.() ...(1)> end ...(1)> def repeat_n(function, count) do ...(1)> function.() ...(1)> repeat_n(function, count - 1) ...(1)> end ...(1)> end {:module, RepeatN, ...}
  2. iex(1)> defmodule RepeatN do ...(1)> def repeat_n(_function, 0) do ...(1)>

    # noop ...(1)> end ...(1)> def repeat_n(function, 1) do ...(1)> function.() ...(1)> end ...(1)> def repeat_n(function, count) do ...(1)> function.() ...(1)> repeat_n(function, count - 1) ...(1)> end ...(1)> end {:module, RepeatN, ...} iex(2)> :timer.tc fn -> RepeatN.repeat_n(fn -> 0 end, 100) end {210, 0}
  3. iex(1)> defmodule RepeatN do ...(1)> def repeat_n(_function, 0) do ...(1)>

    # noop ...(1)> end ...(1)> def repeat_n(function, 1) do ...(1)> function.() ...(1)> end ...(1)> def repeat_n(function, count) do ...(1)> function.() ...(1)> repeat_n(function, count - 1) ...(1)> end ...(1)> end {:module, RepeatN, ...} iex(2)> :timer.tc fn -> RepeatN.repeat_n(fn -> 0 end, 100) end {210, 0} iex(3)> list = Enum.to_list(1..100) [...] iex(4)> :timer.tc fn -> Enum.each(list, fn(_) -> 0 end) end {165, :ok}
  4. iex(1)> defmodule RepeatN do ...(1)> def repeat_n(_function, 0) do ...(1)>

    # noop ...(1)> end ...(1)> def repeat_n(function, 1) do ...(1)> function.() ...(1)> end ...(1)> def repeat_n(function, count) do ...(1)> function.() ...(1)> repeat_n(function, count - 1) ...(1)> end ...(1)> end {:module, RepeatN, ...} iex(2)> :timer.tc fn -> RepeatN.repeat_n(fn -> 0 end, 100) end {210, 0} iex(3)> list = Enum.to_list(1..100) [...] iex(4)> :timer.tc fn -> Enum.each(list, fn(_) -> 0 end) end {165, :ok} iex(5)> :timer.tc fn -> Enum.each(list, fn(_) -> 0 end) end {170, :ok} iex(6)> :timer.tc fn -> Enum.each(list, fn(_) -> 0 end) end {184, :ok}
  5. • Way too few samples • Realistic data/multiple inputs? •

    No warmup • Non production environment • Does creating the list matter? • Is repeating really the bottle neck? • Repeatability? • Setup information • Running on battery • Lots of applications running Numerous Failures!
  6. n = 10_000 range = 1..n list = Enum.to_list range

    fun = fn -> 0 end Benchee.run %{ "Enum.each" => fn -> Enum.each(list, fn(_) -> fun.() end) end, "List comprehension" => fn -> for _ <- list, do: fun.() end, "Recursion" => fn -> RepeatN.repeat_n(fun, n) end }
  7. Name ips average deviation median 99th % Recursion 6.95 K

    143.80 μs ±2.76% 142 μs 156 μs Enum.each 4.21 K 237.70 μs ±6.47% 230 μs 278 μs List comprehension 3.07 K 325.88 μs ±10.02% 333 μs 373 μs Comparison: Recursion 6.95 K Enum.each 4.21 K - 1.65x slower List comprehension 3.07 K - 2.27x slower
  8. Name ips average deviation median 99th % Recursion 6.95 K

    143.80 μs ±2.76% 142 μs 156 μs Enum.each 4.21 K 237.70 μs ±6.47% 230 μs 278 μs List comprehension 3.07 K 325.88 μs ±10.02% 333 μs 373 μs Comparison: Recursion 6.95 K Enum.each 4.21 K - 1.65x slower List comprehension 3.07 K - 2.27x slower Iterations per Second
  9. Stop guessing and Start Measuring Benchmarking in Practice Tobias Pfeiffer

    @PragTob pragtob.info github.com/PragTob/benchee
  10. Flame Graph Elixir.Life.Board:map/2 El.. Elixir.Enum:-map/2-lc$^0/1-0-/2 El.. El.. El.. El.. Elixir.Life.Board:map/2

    Elixir.Life.Board:map/2 El.. El.. Elixir.Life.Board:map/2 Elixir.Enum:-map/2-lc$^0/1-0-/2 El.. El.. Elixir.Enum:-map/2-lc$^0/1-0-/2 Elixir.Enum:-map/2-lc$^0/1-0-/2 (0.47.0) Eli.. eflame:apply1/3 Elixir.Life:run_loop/3 Elixir.Life.Board:map/2 Elixir.Enum:-map/2-lc$^0/1-0-/2 El.. El.. El.. http://learningelixir.joekain.com/profiling-elixir-2/
  11. list = 1..10_000 |> Enum.to_list |> Enum.shuffle Benchee.run %{ "sort(fun)"

    => fn -> Enum.sort(list, &(&1 > &2)) end, "sort |> reverse" => fn -> list |> Enum.sort |> Enum.reverse end, "sort_by(-value)" => fn -> Enum.sort_by(list, fn(val) -> -val end) end }
  12. list = 1..10_000 |> Enum.to_list |> Enum.shuffle Benchee.run %{ "sort(fun)"

    => fn -> Enum.sort(list, &(&1 > &2)) end, "sort |> reverse" => fn -> list |> Enum.sort |> Enum.reverse end, "sort_by(-value)" => fn -> Enum.sort_by(list, fn(val) -> -val end) end }
  13. list = 1..10_000 |> Enum.to_list |> Enum.shuffle Benchee.run %{ "sort(fun)"

    => fn -> Enum.sort(list, &(&1 > &2)) end, "sort |> reverse" => fn -> list |> Enum.sort |> Enum.reverse end, "sort_by(-value)" => fn -> Enum.sort_by(list, fn(val) -> -val end) end }
  14. list = 1..10_000 |> Enum.to_list |> Enum.shuffle Benchee.run %{ "sort(fun)"

    => fn -> Enum.sort(list, &(&1 > &2)) end, "sort |> reverse" => fn -> list |> Enum.sort |> Enum.reverse end, "sort_by(-value)" => fn -> Enum.sort_by(list, fn(val) -> -val end) end }
  15. Name ips average deviation median 99th % sort |> reverse

    576.52 1.74 ms ±7.11% 1.70 ms 2.25 ms sort(fun) 241.21 4.15 ms ±3.04% 4.15 ms 4.60 ms sort_by(-value) 149.96 6.67 ms ±6.06% 6.50 ms 7.83 ms Comparison: sort |> reverse 576.52 sort(fun) 241.21 - 2.39x slower sort_by(-value) 149.96 - 3.84x slower
  16. “We should forget about small efficiencies, say about 97% of

    the time: premature optimization is the root of all evil.” Donald Knuth, 1974 (Computing Surveys, Vol 6, No 4, December 1974) Yup it’s there
  17. “Yet we should not pass up our opportunities in that

    critical 3%.” Donald Knuth, 1974 (Computing Surveys, Vol 6, No 4, December 1974) The very next sentence
  18. “(...) a 12 % improvement, easily obtained, is never considered

    marginal” Donald Knuth, 1974 (Computing Surveys, Vol 6, No 4, December 1974) Prior Paragraph
  19. Micro Macro Setup Complexity Execution Time Confidence of Real Impact

    Components involved Chance of Interference Application
  20. Micro Macro Setup Complexity Execution Time Confidence of Real Impact

    Components involved Chance of Interference Golden Middle Application
  21. • Elixir 1.6.1 • Erlang 20.2 • i5-7200U – 2

    x 2.5GHz (Up to 3.10GHz) • 8GB RAM • Linux Mint 18.3 - 64 bit (Ubuntu 16.04 base) System Specification
  22. System Specification tobi@comfy elixir_playground $ mix run bench/something.exs Operating System:

    Linux CPU Information: Intel(R) Core(TM) i5-7200U CPU @ 2.50GHz Number of Available Cores: 4 Available memory: 7.67 GB Elixir 1.6.1 Erlang 20.2 Benchmark suite executing with the following configuration: warmup: 2 s time: 5 s parallel: 1 inputs: none specified Estimated total run time: 21 s
  23. 1.3

  24. [info] GET / [debug] Processing by Rumbl.PageController.index/2 Parameters: %{} Pipelines:

    [:browser] [info] Sent 200 in 46ms [info] GET /sessions/new [debug] Processing by Rumbl.SessionController.new/2 Parameters: %{} Pipelines: [:browser] [info] Sent 200 in 5ms [info] GET /users/new [debug] Processing by Rumbl.UserController.new/2 Parameters: %{} Pipelines: [:browser] [info] Sent 200 in 7ms [info] POST /users [debug] Processing by Rumbl.UserController.create/2 Parameters: %{"_csrf_token" => "NUEUdRMNAiBfIHEeNwZkfA05PgAOJgAAf0ACXJqCjl7YojW+trdjdg==", "_utf8" => " ", "user" ✓ => %{"name" => "asdasd", "password" => "[FILTERED]", "username" => "Homer"}} Pipelines: [:browser] [debug] QUERY OK db=0.1ms begin [] [debug] QUERY OK db=0.9ms INSERT INTO "users" ("name","password_hash","username","inserted_at","updated_at") VALUES ($1,$2,$3,$4,$5) RETURNING "id" ["asdasd", "$2b$12$.qY/kpo0Dec7vMK1ClJoC.Lw77c3oGllX7uieZILMlFh2hFpJ3F.C", "Homer", {{2016, 12, 2}, {14, 10, 28, 0}}, {{2016, 12, 2}, {14, 10, 28, 0}}] Logging & Friends
  25. Benchee.run %{ "DB View" => fn -> LatestCourierLocation |> CourierLocation.with_courier_ids(courier_id)

    |> Repo.one(timeout: :infinity) end, "with_courier_ids" => fn -> CourierLocation.with_courier_ids(courier_id) |> Ecto.Query.order_by(desc: :time) |> Ecto.Query.limit(1) |> Repo.one(timeout: :infinity) end, "full custom" => fn -> CourierLocation |> Ecto.Query.where(courier_id: ^courier_id) |> Ecto.Query.order_by(desc: :time) |> Ecto.Query.limit(1) |> Repo.one(timeout: :infinity) end }
  26. Benchee.run %{ "DB View" => fn -> LatestCourierLocation |> CourierLocation.with_courier_ids(courier_id)

    |> Repo.one(timeout: :infinity) end, "with_courier_ids" => fn -> CourierLocation.with_courier_ids(courier_id) |> Ecto.Query.order_by(desc: :time) |> Ecto.Query.limit(1) |> Repo.one(timeout: :infinity) end, "full custom" => fn -> CourierLocation |> Ecto.Query.where(courier_id: ^courier_id) |> Ecto.Query.order_by(desc: :time) |> Ecto.Query.limit(1) |> Repo.one(timeout: :infinity) end } Database View
  27. Benchee.run %{ "DB View" => fn -> LatestCourierLocation |> CourierLocation.with_courier_ids(courier_id)

    |> Repo.one(timeout: :infinity) end, "with_courier_ids" => fn -> CourierLocation.with_courier_ids(courier_id) |> Ecto.Query.order_by(desc: :time) |> Ecto.Query.limit(1) |> Repo.one(timeout: :infinity) end, "full custom" => fn -> CourierLocation |> Ecto.Query.where(courier_id: ^courier_id) |> Ecto.Query.order_by(desc: :time) |> Ecto.Query.limit(1) |> Repo.one(timeout: :infinity) end } Only difference
  28. Benchee.run %{ "DB View" => fn -> LatestCourierLocation |> CourierLocation.with_courier_ids(courier_id)

    |> Repo.one(timeout: :infinity) end, "with_courier_ids" => fn -> CourierLocation.with_courier_ids(courier_id) |> Ecto.Query.order_by(desc: :time) |> Ecto.Query.limit(1) |> Repo.one(timeout: :infinity) end, "full custom" => fn -> CourierLocation |> Ecto.Query.where(courier_id: ^courier_id) |> Ecto.Query.order_by(desc: :time) |> Ecto.Query.limit(1) |> Repo.one(timeout: :infinity) end } Same
  29. Name ips average deviation median 99th % with_courier_ids 983.21 1.02

    ms ±43.22% 0.91 ms 3.19 ms full custom 855.07 1.17 ms ±53.86% 0.96 ms 4.25 ms DB View 0.21 4704.70 ms ±4.89% 4738.83 ms 4964.49 ms Comparison: with_courier_ids 983.21 full custom 855.07 - 1.15x slower DB View 0.21 - 4625.70x slower Another job well done?
  30. inputs = %{ "Big 2.3 Million locations" => 3799, "No

    locations" => 8901, "~200k locations" => 4238, "~20k locations" => 4201 } Benchee.run %{ ... "full custom" => fn(courier_id) -> CourierLocation |> Ecto.Query.where(courier_id: ^courier_id) |> Ecto.Query.order_by(desc: :time) |> Ecto.Query.limit(1) |> Repo.one(timeout: :infinity) end }, inputs: inputs, time: 25, warmup: 5 Inputs to the rescue!
  31. inputs = %{ "Big 2.3 Million locations" => 3799, "No

    locations" => 8901, "~200k locations" => 4238, "~20k locations" => 4201 } Benchee.run %{ ... "full custom" => fn(courier_id) -> CourierLocation |> Ecto.Query.where(courier_id: ^courier_id) |> Ecto.Query.order_by(desc: :time) |> Ecto.Query.limit(1) |> Repo.one(timeout: :infinity) end }, inputs: inputs, time: 25, warmup: 5 Inputs to the rescue!
  32. inputs = %{ "Big 2.3 Million locations" => 3799, "No

    locations" => 8901, "~200k locations" => 4238, "~20k locations" => 4201 } Benchee.run %{ ... "full custom" => fn(courier_id) -> CourierLocation |> Ecto.Query.where(courier_id: ^courier_id) |> Ecto.Query.order_by(desc: :time) |> Ecto.Query.limit(1) |> Repo.one(timeout: :infinity) end }, inputs: inputs, time: 25, warmup: 5 Inputs to the rescue!
  33. inputs = %{ "Big 2.3 Million locations" => 3799, "No

    locations" => 8901, "~200k locations" => 4238, "~20k locations" => 4201 } Benchee.run %{ ... "full custom" => fn(courier_id) -> CourierLocation |> Ecto.Query.where(courier_id: ^courier_id) |> Ecto.Query.order_by(desc: :time) |> Ecto.Query.limit(1) |> Repo.one(timeout: :infinity) end }, inputs: inputs, time: 25, warmup: 5 Inputs to the rescue!
  34. ##### With input Big 2.5 million locations ##### with_courier_ids 937.18

    full custom 843.24 - 1.11x slower DB View 0.22 - 4261.57x slower ##### With input ~200k locations ##### DB View 3.57 with_courier_ids 0.109 - 32.84x slower full custom 0.0978 - 36.53x slower ##### With input ~20k locations ##### DB View 31.73 with_courier_ids 0.104 - 305.37x slower full custom 0.0897 - 353.61x slower ##### With input No locations ##### Comparison: DB View 1885.48 with_courier_ids 0.0522 - 36123.13x slower full custom 0.0505 - 37367.23x slower
  35. ##### With input Big 2.5 million locations ##### with_courier_ids 937.18

    full custom 843.24 - 1.11x slower DB View 0.22 - 4261.57x slower ##### With input ~200k locations ##### DB View 3.57 with_courier_ids 0.109 - 32.84x slower full custom 0.0978 - 36.53x slower ##### With input ~20k locations ##### DB View 31.73 with_courier_ids 0.104 - 305.37x slower full custom 0.0897 - 353.61x slower ##### With input No locations ##### Comparison: DB View 1885.48 with_courier_ids 0.0522 - 36123.13x slower full custom 0.0505 - 37367.23x slower woops
  36. EXPLAIN ANALYZE SELECT c0."id", c0."courier_id", c0."location", c0."time", c0."accuracy", c0."inserted_at", c0."updated_at"

    FROM "courier_locations" AS c0 WHERE (c0."courier_id" = 3799) ORDER BY c0."time" DESC LIMIT 1; QUERY PLAN --------------------------------------------------------------- Limit (cost=0.43..0.83 rows=1 width=72) (actual time=1.840..1.841 rows=1 loops=1) -> Index Scan Backward using courier_locations_time_index on courier_locations c0 (cost=0.43..932600.17 rows=2386932 width=72) actual time=1.837..1.837 rows=1 loops=1) Filter: (courier_id = 3799) Rows Removed by Filter: 1371 Planning time: 0.190 ms Execution time: 1.894 ms (6 rows)
  37. EXPLAIN ANALYZE SELECT c0."id", c0."courier_id", c0."location", c0."time", c0."accuracy", c0."inserted_at", c0."updated_at"

    FROM "courier_locations" AS c0 WHERE (c0."courier_id" = 3799) ORDER BY c0."time" DESC LIMIT 1; QUERY PLAN --------------------------------------------------------------- Limit (cost=0.43..0.83 rows=1 width=72) (actual time=1.840..1.841 rows=1 loops=1) -> Index Scan Backward using courier_locations_time_index on courier_locations c0 (cost=0.43..932600.17 rows=2386932 width=72) actual time=1.837..1.837 rows=1 loops=1) Filter: (courier_id = 3799) Rows Removed by Filter: 1371 Planning time: 0.190 ms Execution time: 1.894 ms (6 rows)
  38. EXPLAIN ANALYZE SELECT c0."id", c0."courier_id", c0."location", c0."time", c0."accuracy", c0."inserted_at", c0."updated_at"

    FROM "courier_locations" AS c0 WHERE (c0."courier_id" = 3799) ORDER BY c0."time" DESC LIMIT 1; QUERY PLAN --------------------------------------------------------------- Limit (cost=0.43..0.83 rows=1 width=72) (actual time=1.840..1.841 rows=1 loops=1) -> Index Scan Backward using courier_locations_time_index on courier_locations c0 (cost=0.43..932600.17 rows=2386932 width=72) actual time=1.837..1.837 rows=1 loops=1) Filter: (courier_id = 3799) Rows Removed by Filter: 1371 Planning time: 0.190 ms Execution time: 1.894 ms (6 rows)
  39. EXPLAIN ANALYZE SELECT c0."id", c0."courier_id", c0."location", c0."time", c0."accuracy", c0."inserted_at", c0."updated_at"

    FROM "courier_locations" AS c0 WHERE (c0."courier_id" = 3799) ORDER BY c0."time" DESC LIMIT 1; QUERY PLAN --------------------------------------------------------------- Limit (cost=0.43..0.83 rows=1 width=72) (actual time=1.840..1.841 rows=1 loops=1) -> Index Scan Backward using courier_locations_time_index on courier_locations c0 (cost=0.43..932600.17 rows=2386932 width=72) actual time=1.837..1.837 rows=1 loops=1) Filter: (courier_id = 3799) Rows Removed by Filter: 1371 Planning time: 0.190 ms Execution time: 1.894 ms (6 rows)
  40. defmodule MyMap do def map_body([], _func), do: [] def map_body([head

    | tail], func) do [func.(head) | map_body(tail, func)] end end body
  41. defmodule MyMap do def map_body([], _func), do: [] def map_body([head

    | tail], func) do [func.(head) | map_body(tail, func)] end end body
  42. defmodule MyMap do def map_body([], _func), do: [] def map_body([head

    | tail], func) do [func.(head) | map_body(tail, func)] end end body
  43. defmodule MyMap do def map_body([], _func), do: [] def map_body([head

    | tail], func) do [func.(head) | map_body(tail, func)] end end body
  44. defmodule MyMap do def map_body([], _func), do: [] def map_body([head

    | tail], func) do [func.(head) | map_body(tail, func)] end end body
  45. defmodule MyMap do def map_tco(list, function) do Enum.reverse do_map_tco([], list,

    function) end defp do_map_tco(acc, [], _function) do acc end defp do_map_tco(acc, [head | tail], func) do do_map_tco([func.(head) | acc], tail, func) end end TCO
  46. defmodule MyMap do def map_tco(list, function) do Enum.reverse do_map_tco([], list,

    function) end defp do_map_tco(acc, [], _function) do acc end defp do_map_tco(acc, [head | tail], func) do do_map_tco([func.(head) | acc], tail, func) end end TCO
  47. defmodule MyMap do def map_tco(list, function) do Enum.reverse do_map_tco([], list,

    function) end defp do_map_tco(acc, [], _function) do acc end defp do_map_tco(acc, [head | tail], func) do do_map_tco([func.(head) | acc], tail, func) end end TCO
  48. defmodule MyMap do def map_tco(list, function) do Enum.reverse do_map_tco([], list,

    function) end defp do_map_tco(acc, [], _function) do acc end defp do_map_tco(acc, [head | tail], func) do do_map_tco([func.(head) | acc], tail, func) end end TCO
  49. defmodule MyMap do def map_tco(list, function) do Enum.reverse do_map_tco([], list,

    function) end defp do_map_tco(acc, [], _function) do acc end defp do_map_tco(acc, [head | tail], func) do do_map_tco([func.(head) | acc], tail, func) end end TCO
  50. defmodule MyMap do def map_tco(list, function) do Enum.reverse do_map_tco([], list,

    function) end defp do_map_tco(acc, [], _function) do acc end defp do_map_tco(acc, [head | tail], func) do do_map_tco([func.(head) | acc], tail, func) end end TCO
  51. defmodule MyMap do def map_tco(list, function) do Enum.reverse do_map_tco([], list,

    function) end defp do_map_tco(acc, [], _function) do acc end defp do_map_tco(acc, [head | tail], func) do do_map_tco([func.(head) | acc], tail, func) end end TCO
  52. defmodule MyMap do def map_tco(list, function) do Enum.reverse do_map_tco([], list,

    function) end defp do_map_tco(acc, [], _function) do acc end defp do_map_tco(acc, [head | tail], func) do do_map_tco([func.(head) | acc], tail, func) end end TCO
  53. defmodule MyMap do def map_tco(list, function) do Enum.reverse do_map_tco([], list,

    function) end defp do_map_tco(acc, [], _function) do acc end defp do_map_tco(acc, [head | tail], func) do do_map_tco([func.(head) | acc], tail, func) end end TCO
  54. defmodule MyMap do def map_tco(list, function) do Enum.reverse do_map_tco(list, function,

    []) end defp do_map_tco([], _function, acc) do acc end defp do_map_tco([head | tail], func, acc) do do_map_tco(tail, func, [func.(head) | acc]) end end arg_order
  55. map_fun = fn(i) -> i + 1 end inputs =

    %{ "Small (10 Thousand)" => Enum.to_list(1..10_000), "Middle (100 Thousand)" => Enum.to_list(1..100_000), "Big (1 Million)" => Enum.to_list(1..1_000_000), "Bigger (5 Million)" => Enum.to_list(1..5_000_000) } Benchee.run %{ "tail-recursive" => fn(list) -> MyMap.map_tco(list, map_fun) end, "stdlib map" => fn(list) -> Enum.map(list, map_fun) end, "body-recursive" => fn(list) -> MyMap.map_body(list, map_fun) end, "tail-rec arg-order" => fn(list) -> MyMap.map_tco_arg_order(list, map_fun) end } TCO
  56. map_fun = fn(i) -> i + 1 end inputs =

    %{ "Small (10 Thousand)" => Enum.to_list(1..10_000), "Middle (100 Thousand)" => Enum.to_list(1..100_000), "Big (1 Million)" => Enum.to_list(1..1_000_000), "Bigger (5 Million)" => Enum.to_list(1..5_000_000) } Benchee.run %{ "tail-recursive" => fn(list) -> MyMap.map_tco(list, map_fun) end, "stdlib map" => fn(list) -> Enum.map(list, map_fun) end, "body-recursive" => fn(list) -> MyMap.map_body(list, map_fun) end, "tail-rec arg-order" => fn(list) -> MyMap.map_tco_arg_order(list, map_fun) end } TCO
  57. map_fun = fn(i) -> i + 1 end inputs =

    %{ "Small (10 Thousand)" => Enum.to_list(1..10_000), "Middle (100 Thousand)" => Enum.to_list(1..100_000), "Big (1 Million)" => Enum.to_list(1..1_000_000), "Bigger (5 Million)" => Enum.to_list(1..5_000_000) } Benchee.run %{ "tail-recursive" => fn(list) -> MyMap.map_tco(list, map_fun) end, "stdlib map" => fn(list) -> Enum.map(list, map_fun) end, "body-recursive" => fn(list) -> MyMap.map_body(list, map_fun) end, "tail-rec arg-order" => fn(list) -> MyMap.map_tco_arg_order(list, map_fun) end } TCO
  58. ##### With input Small (10 Thousand) ##### stdlib map 5.05

    K body-recursive 5.00 K - 1.01x slower tail-rec arg-order 4.07 K - 1.24x slower tail-recursive 3.76 K - 1.34x slower ##### With input Middle (100 Thousand) ##### stdlib map 468.49 body-recursive 467.04 - 1.00x slower tail-rec arg-order 452.53 - 1.04x slower tail-recursive 417.20 - 1.12x slower ##### With input Big (1 Million) ##### body-recursive 40.33 stdlib map 38.89 - 1.04x slower tail-rec arg-order 37.69 - 1.07x slower tail-recursive 33.29 - 1.21x slower ##### With input Bigger (5 Million) ##### tail-rec arg-order 6.68 tail-recursive 6.35 - 1.05x slower stdlib map 5.60 - 1.19x slower body-recursive 5.39 - 1.24x slower TCO
  59. ##### With input Small (10 Thousand) ##### stdlib map 5.05

    K body-recursive 5.00 K - 1.01x slower tail-rec arg-order 4.07 K - 1.24x slower tail-recursive 3.76 K - 1.34x slower ##### With input Middle (100 Thousand) ##### stdlib map 468.49 body-recursive 467.04 - 1.00x slower tail-rec arg-order 452.53 - 1.04x slower tail-recursive 417.20 - 1.12x slower ##### With input Big (1 Million) ##### body-recursive 40.33 stdlib map 38.89 - 1.04x slower tail-rec arg-order 37.69 - 1.07x slower tail-recursive 33.29 - 1.21x slower ##### With input Bigger (5 Million) ##### tail-rec arg-order 6.68 tail-recursive 6.35 - 1.05x slower stdlib map 5.60 - 1.19x slower body-recursive 5.39 - 1.24x slower TCO
  60. ##### With input Small (10 Thousand) ##### stdlib map 5.05

    K body-recursive 5.00 K - 1.01x slower tail-rec arg-order 4.07 K - 1.24x slower tail-recursive 3.76 K - 1.34x slower ##### With input Middle (100 Thousand) ##### stdlib map 468.49 body-recursive 467.04 - 1.00x slower tail-rec arg-order 452.53 - 1.04x slower tail-recursive 417.20 - 1.12x slower ##### With input Big (1 Million) ##### body-recursive 40.33 stdlib map 38.89 - 1.04x slower tail-rec arg-order 37.69 - 1.07x slower tail-recursive 33.29 - 1.21x slower ##### With input Bigger (5 Million) ##### tail-rec arg-order 6.68 tail-recursive 6.35 - 1.05x slower stdlib map 5.60 - 1.19x slower body-recursive 5.39 - 1.24x slower Big Inputs
  61. ##### With input Small (10 Thousand) ##### stdlib map 5.05

    K body-recursive 5.00 K - 1.01x slower tail-rec arg-order 4.07 K - 1.24x slower tail-recursive 3.76 K - 1.34x slower ##### With input Middle (100 Thousand) ##### stdlib map 468.49 body-recursive 467.04 - 1.00x slower tail-rec arg-order 452.53 - 1.04x slower tail-recursive 417.20 - 1.12x slower ##### With input Big (1 Million) ##### body-recursive 40.33 stdlib map 38.89 - 1.04x slower tail-rec arg-order 37.69 - 1.07x slower tail-recursive 33.29 - 1.21x slower ##### With input Bigger (5 Million) ##### tail-rec arg-order 6.68 tail-recursive 6.35 - 1.05x slower stdlib map 5.60 - 1.19x slower body-recursive 5.39 - 1.24x slower Order matters!
  62. TCO

  63. WIP

  64. ##### With input Small (10 Thousand) ##### stdlib map 156.85

    KB body-recursive 156.85 KB - 1.00x memory usage tail-rec arg-order 291.46 KB - 1.86x memory usage tail-recursive 291.46 KB - 1.86x memory usage ##### With input Middle (100 Thousand) ##### stdlib map 1.53 MB body-recursive 1.53 MB - 1.00x memory usage tail-rec arg-order 1.80 MB - 1.18x memory usage tail-recursive 1.80 MB - 1.18x memory usage ##### With input Big (1 Million) ##### stdlib map 15.26 MB body-recursive 15.26 MB - 1.00x memory usage tail-rec arg-order 28.74 MB - 1.88x memory usage tail-recursive 28.74 MB - 1.88x memory usage ##### With input Bigger (5 Million) ##### tail-rec arg-order 150.15 MB tail-recursive 150.15 MB - 1.00x memory usage stdlib map 76.30 MB - 0.51x memory usage body-recursive 76.30 MB - 0.51x memory usage Memory
  65. ##### With input Small (10 Thousand) ##### stdlib map 156.85

    KB body-recursive 156.85 KB - 1.00x memory usage tail-rec arg-order 291.46 KB - 1.86x memory usage tail-recursive 291.46 KB - 1.86x memory usage ##### With input Middle (100 Thousand) ##### stdlib map 1.53 MB body-recursive 1.53 MB - 1.00x memory usage tail-rec arg-order 1.80 MB - 1.18x memory usage tail-recursive 1.80 MB - 1.18x memory usage ##### With input Big (1 Million) ##### stdlib map 15.26 MB body-recursive 15.26 MB - 1.00x memory usage tail-rec arg-order 28.74 MB - 1.88x memory usage tail-recursive 28.74 MB - 1.88x memory usage ##### With input Bigger (5 Million) ##### tail-rec arg-order 150.15 MB tail-recursive 150.15 MB - 1.00x memory usage stdlib map 76.30 MB - 0.51x memory usage body-recursive 76.30 MB - 0.51x memory usage Memory
  66. config |> Benchee.init |> Benchee.system |> Benchee.benchmark("job", fn -> magic

    end) |> Benchee.measure |> Benchee.statistics |> Benchee.Formatters.Console.output |> Benchee.Formatters.HTML.output A transformation of inputs
  67. defp standard_deviation(samples, average, iterations) do total_variance = Enum.reduce samples, 0,

    fn(sample, total) -> total + :math.pow((sample - average), 2) end variance = total_variance / iterations :math.sqrt variance end Standard Deviation
  68. defp standard_deviation(samples, average, iterations) do total_variance = Enum.reduce samples, 0,

    fn(sample, total) -> total + :math.pow((sample - average), 2) end variance = total_variance / iterations :math.sqrt variance end Spread of Values
  69. defp compute_median(run_times, iterations) do sorted = Enum.sort(run_times) middle = div(iterations,

    2) if Integer.is_odd(iterations) do sorted |> Enum.at(middle) |> to_float else (Enum.at(sorted, middle) + Enum.at(sorted, middle - 1)) / 2 end end Median