gistfile1.txt

1> tail_vs_direct:run_double_direct(1000000).
% ...
<0.250.0> double_direct Pass# 999900
  {total_heap_size,16926904}
  {heap_size,12834421}
  {memory,135416080}
  {stack_size,3999614}
  {reductions,17868909}
  System memory: 12344328
  Total runtime memory: 216423592
<0.250.0> double_direct Pass# 1000000
  {total_heap_size,16926904}
  {heap_size,12834421}
  {memory,135416080}
  {stack_size,4000011}
  {reductions,17870603}
  System memory: 12344912
  Total runtime memory: 216424240

2> tail_vs_direct:run_double_tail(1000000).
% ...
<0.252.0> double_tail Pass# 999900
  {total_heap_size,6076043}
  {heap_size,833026}
  {memory,48609192}
  {stack_size,15}
  {reductions,17630710}
  System memory: 12300600
  Total runtime memory: 129463744
<0.252.0> double_tail Pass# 1000000
  {total_heap_size,6076698}
  {heap_size,833026}
  {memory,48614432}
  {stack_size,12}
  {reductions,17632404}
  System memory: 12300840
  Total runtime memory: 129469544

3> tail_vs_direct:run_upper_direct(100000, "some string we'll upper case").
% ...
<0.258.0> upper_direct Pass# 99900
  {total_heap_size,12979176}
  {heap_size,12834421}
  {memory,103834256}
  {stack_size,399614}
  {reductions,28180600}
  System memory: 12300512
  Total runtime memory: 192921576
<0.258.0> upper_direct Pass# 100000
  {total_heap_size,12980486}
  {heap_size,12834421}
  {memory,103844736}
  {stack_size,400011}
  {reductions,28207830}
  System memory: 12300896
  Total runtime memory: 192932536

4> tail_vs_direct:run_upper_tail(100000, "some string we'll upper case").
<0.260.0> upper_tail Pass# 99900
  {total_heap_size,12181979}
  {heap_size,1439468}
  {memory,97456680}
  {stack_size,15}
  {reductions,27988227}
  System memory: 12301376
  Total runtime memory: 186537720
<0.260.0> upper_tail Pass# 100000
  {total_heap_size,12183289}
  {heap_size,1439468}
  {memory,97467160}
  {stack_size,12}
  {reductions,28015457}
  System memory: 12301408
  Total runtime memory: 186548328

tail_vs_direct.erl

-module(tail_vs_direct).
-export([run_upper_tail/2, run_upper_direct/2, run_double_tail/1, run_double_direct/1]).


run_upper_tail(N, String) ->
    List = lists:duplicate(N, String),
    spawn(fun() -> upper_tail(List) end).


run_upper_direct(N, String) ->
    List = lists:duplicate(N, String),
    spawn(fun() -> upper_direct(List) end).


run_double_tail(N) ->
    spawn(fun() -> double_tail(lists:seq(1, N)) end).


run_double_direct(N) ->
    spawn(fun() -> double_direct(lists:seq(1, N)) end).


upper_tail(L) ->
    upper_tail(L, [], 0).


upper_tail([], Acc, Pass) ->
    ok = stats(?FUNCTION_NAME, Pass),
    lists:reverse(Acc);
upper_tail([H | T], Acc, Pass) ->
    NewValue = upper(H),
    case Pass rem 100 == 0 of
        true  -> stats(?FUNCTION_NAME, Pass);
        false -> ok
    end,
    upper_tail(T, [NewValue | Acc], Pass + 1).


upper_direct(L) ->
    upper_direct(L, 0).


upper_direct([], Pass) ->
    ok = stats(?FUNCTION_NAME, Pass),
    [];
upper_direct([H | T], Pass) ->
    NewValue = upper(H),
    case Pass rem 100 == 0 of
        true  -> stats(?FUNCTION_NAME, Pass);
        false -> ok
    end,
    [NewValue | upper_direct(T, Pass + 1)].


upper(Value) ->
    string:uppercase(Value).


double_tail(L) ->
    double_tail(L, [], 0).


double_tail([], Acc, Pass) ->
    ok = stats(?FUNCTION_NAME, Pass),
    lists:reverse(Acc);
double_tail([H | T], Acc, Pass) ->
    NewValue = double(H),
    case Pass rem 100 == 0 of
        true  -> stats(?FUNCTION_NAME, Pass);
        false -> ok
    end,
    double_tail(T, [NewValue | Acc], Pass + 1).


double_direct(L) ->
    double_direct(L, 0).


double_direct([], Pass) ->
    ok = stats(?FUNCTION_NAME, Pass),
    [];
double_direct([H | T], Pass) ->
    NewValue = double(H),
    case Pass rem 100 == 0 of
        true  -> stats(?FUNCTION_NAME, Pass);
        false -> ok
    end,
    [NewValue | double_direct(T, Pass + 1)].


double(Value) ->
    2 * Value.


stats(Fun, Pass) ->
    Self = self(),
    TotalHeap = process_info(Self, total_heap_size),
    CurrentHeap = process_info(Self, heap_size),
    Memory = process_info(Self, memory),
    Stack = process_info(Self, stack_size),
    Reductions = process_info(Self, reductions),
    System = erlang:memory(system),
    Total = erlang:memory(total),
    Message =
        "~p ~p Pass# ~p~n"
        "  ~p~n"
        "  ~p~n"
        "  ~p~n"
        "  ~p~n"
        "  ~p~n"
        "  System memory: ~p~n"
        "  Total runtime memory: ~p~n",
    io:format(Message, [Self, Fun, Pass, TotalHeap, CurrentHeap, Memory, Stack, Reductions, System, Total]).