The R13B03 release.OTP_R13B03

1 files changed, 1107 insertions, 0 deletions

diff --git a/erts/emulator/test/estone_SUITE.erl b/erts/emulator/test/estone_SUITE.erl
new file mode 100644
index 0000000000..7fb92faf0d
--- /dev/null
+++ b/erts/emulator/test/estone_SUITE.erl
@@ -0,0 +1,1107 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2002-2009. All Rights Reserved.
+%% 
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%% 
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%% 
+%% %CopyrightEnd%
+
+-module(estone_SUITE).
+%% Test functions
+-export([all/1,estone/1]).
+-export([init_per_testcase/2, fin_per_testcase/2]).
+
+%% Internal exports for EStone tests
+-export([lists/1,
+	 msgp/1,
+	 msgp_medium/1,
+	 msgp_huge/1,
+	 pattern/1,
+	 trav/1,
+	 port_io/1,
+	 large_dataset_work/1,
+	 large_local_dataset_work/1,mk_big_procs/1,big_proc/0,
+	 alloc/1,
+	 bif_dispatch/1,
+	 binary_h/1,echo/1,
+	 ets/1,
+	 generic/1,req/2,gserv/4,handle_call/3,
+	 int_arith/1,
+	 float_arith/1,
+	 fcalls/1,remote0/1,remote1/1,app0/1,app1/1,
+	 timer/1,
+	 links/1,lproc/1,
+	 run_micro/3,p1/1,ppp/3,macro/2,micros/0]).
+
+
+-include("test_server.hrl").
+
+%% Test suite defines
+-define(default_timeout, ?t:minutes(10)).
+
+%% EStone defines
+-define(TOTAL, (3000 * 1000 * 100)).   %% 300 secs
+-define(BIGPROCS, 2).
+-define(BIGPROC_SIZE, 50).
+-define(STONEFACTOR, 31000000).   %% Factor to make the reference
+                             %% implementation to make 1000 TS_ESTONES.
+-record(micro,
+	{function, %% The name of the function implementing the micro
+	 weight,   %% How important is this in typical applications ??
+	 loops = 100,%% initial data
+	 tt1,      %% time to do one round
+	 str}).    %% Header string
+
+
+
+
+init_per_testcase(_Case, Config) ->
+    ?line Dog=test_server:timetrap(?default_timeout),
+    [{watchdog, Dog}|Config].
+fin_per_testcase(_Case, Config) ->
+    Dog=?config(watchdog, Config),
+    ?t:timetrap_cancel(Dog),
+    ok.
+
+all(suite) -> [estone].
+
+estone(suite) ->
+    [];
+estone(doc) ->
+    ["EStone Test"];
+estone(Config) when is_list(Config) ->
+    ?line DataDir = ?config(data_dir,Config),
+    ?line Mhz=get_cpu_speed(os:type(),DataDir),
+    ?line L = ?MODULE:macro(?MODULE:micros(),DataDir),
+    ?line {Total, Stones} = sum_micros(L, 0, 0),
+    ?line pp(Mhz,Total,Stones,L),
+    ?line {comment,Mhz ++ " MHz, " ++ 
+	   integer_to_list(Stones) ++ " ESTONES"}.
+
+%%
+%% Calculate CPU speed
+%%
+%% get_cpu_speed() now returns a string. For multiprocessor
+%% machines (at least on Solaris) the format is: <F1>+<F2>[+...]
+%%
+get_cpu_speed({win32, _},_DataDir) ->
+    RegH =
+	case catch win32reg:open([read]) of
+	    {ok, Handle} ->
+		Handle;
+	    _ ->
+		io:format("Error.~nCannot determine CPU clock"
+			  "frequency.~n"
+			  "Please set the environment variable"
+			  "\"CPU_SPEED\"~n"),
+		exit(self(), {error, no_cpu_speed})
+	end,
+    case win32reg:change_key(RegH,"\\hkey_local_machine\\hardware\\"
+			     "description\\system\\centralprocessor"
+			     "\\0") of
+	ok ->
+	    ok;
+	_ ->
+	    io:format("Error.~nRegistry seems to be damaged or"
+		      "unavailable.~n"
+		      "Please set the environment variable"
+		      "\"CPU_SPEED\",~nor correct your registry"
+		      "if possible.~n"),
+	    win32reg:close(RegH),
+	    exit(self(), {error, no_cpu_speed})
+    end,
+    case win32reg:value(RegH, "~MHZ") of
+	{ok, Speed} ->
+	    win32reg:close(RegH),
+	    integer_to_list(Speed);
+	_ ->
+	    io:format("Error.~nRegistry seems to be damaged or "
+		      "unavailable.~n"),
+	    io:format("Please set the environment variable"
+		      "\"CPU_SPEED\"~n"),
+	    win32reg:close(RegH),
+	    exit(self(), {error, no_cpu_speed})
+    end;
+get_cpu_speed({unix, sunos},DataDir) ->
+    os:cmd(filename:join(DataDir,"sunspeed.sh")) -- "\n";
+get_cpu_speed(_Other,_DataDir) ->
+    %% Cannot determine CPU speed
+    "UNKNOWN".
+
+
+%%
+%% Pretty Print EStone Result
+%%
+pp(Mhz,Total,Stones,Ms) ->
+    io:format("EStone test completed~n",[]),
+    io:format("**** CPU speed ~s MHz ****~n",[Mhz]),
+    io:format("**** Total time ~w seconds ****~n", [Total / 1000000]),
+    io:format("**** ESTONES = ~w ****~n~n", [Stones]),
+    io:format("~-31s      ~-12s  ~-10s   %    ~-10s ~n~n",
+	      ["    Title", "Millis", "Estone", "Loops"]),
+    erlang:display({'ESTONES', Stones}),
+    pp2(Ms).
+
+sum_micros([], Tot, Stones) -> {Tot, Stones};
+sum_micros([H|T], Tot, Sto) -> 
+    sum_micros(T, ks(microsecs, H) + Tot, ks(estones, H) + Sto).
+
+pp2([]) ->   ok;
+pp2([R|Tail]) ->
+    io:format("~-35s  ~-12w    ~-10w   ~-2w    ~-10w ~n",
+	      [ks(title,R), 
+	       round(ks(microsecs, R) / 1000), 
+	       ks(estones, R),
+	       ks(weight_percentage, R),
+	       ks(loops, R)]),
+    pp2(Tail).
+
+ks(K, L) ->
+    {value, {_, V}} = lists:keysearch(K, 1, L),
+    V.
+
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%% EStone test
+micro(lists) -> 
+     #micro{function = lists,
+	    weight = 7, 
+	    loops = 6400,
+	    str = "list manipulation"};
+micro(msgp) ->
+    #micro{function = msgp,
+	    weight = 10,
+	    loops = 1515,
+	    str = "small messages"};
+micro(msgp_medium) ->
+    #micro{function = msgp_medium,
+	    weight = 14,
+	    loops = 1527,
+	    str = "medium messages"};
+micro(msgp_huge) ->
+    #micro{function = msgp_huge,
+	    weight = 4,
+	    loops = 52,
+	    str = "huge messages"};
+
+micro(pattern) ->
+    #micro{function = pattern,
+	    weight = 5,
+	    loops = 1046,
+	    str = "pattern matching"};
+
+micro(trav) ->
+    #micro{function = trav,
+	    weight = 4,
+	    loops = 2834,
+	    str = "traverse"};
+
+micro(port_io) ->
+    #micro{function = port_io,
+	   weight = 12,
+	   loops = 4800,
+	   str = "Port i/o"};
+
+micro(large_dataset_work) ->
+    #micro{function = large_dataset_work,
+	   weight = 3,
+	   loops = 1193,
+	   str = "Work with large dataset"};
+
+micro(large_local_dataset_work) ->
+    #micro{function = large_local_dataset_work,
+	   weight = 3,
+	   loops = 1174,
+	   str = "Work with large local dataset"};
+
+micro(alloc) ->
+    #micro{function = alloc,
+	   weight = 2,
+	   loops = 3710,
+	   str = "Alloc and dealloc"};
+
+micro(bif_dispatch) ->
+    #micro{function = bif_dispatch,
+	   weight = 5,
+	   loops = 1623,
+	   str = "Bif dispatch"};
+
+micro(binary_h) ->
+    #micro{function = binary_h,
+	   weight = 4,
+	   loops = 581,
+	   str = "Binary handling"};
+micro(ets) ->
+    #micro{function = ets,
+	   weight = 6,
+	   loops = 342,
+	   str = "ets datadictionary"};
+micro(generic) ->
+    #micro{function = generic,
+	   weight = 9,
+	   loops = 7977,
+	   str = "Generic server (with timeout)"};
+micro(int_arith) ->
+    #micro{function = int_arith,
+	   weight = 3,
+	   loops = 4157,
+	   str = "Small Integer arithmetics"};
+micro(float_arith) ->
+    #micro{function = float_arith,
+	   weight = 1,
+	   loops = 5526,
+	   str = "Float arithmetics"};
+micro(fcalls) ->
+    #micro{function = fcalls,
+	   weight = 5,
+	   loops = 882,
+	   str = "Function calls"};
+
+micro(timer) ->
+    #micro{function = timer,
+	   weight = 2,
+	   loops = 2312,
+	   str = "Timers"};
+
+micro(links) ->
+    #micro{function = links,
+	   weight = 1,
+	   loops = 30,
+	   str = "Links"}.
+
+
+
+%% Return a list of micro's
+micros() ->
+    [
+     micro(lists),
+     micro(msgp),
+     micro(msgp_medium),
+     micro(msgp_huge),
+     micro(pattern),
+     micro(trav),
+     micro(port_io),
+     micro(large_dataset_work),
+     micro(large_local_dataset_work),
+     micro(alloc),
+     micro(bif_dispatch),
+     micro(binary_h),
+     micro(ets),
+     micro(generic),
+     micro(int_arith),
+     micro(float_arith),
+     micro(fcalls),
+     micro(timer),
+     micro(links)
+    ].
+
+macro(Ms,DataDir) ->
+    erlang:now(),  %% compensate for old 4.3 firsttime clock bug :-(
+    statistics(reductions),
+    statistics(runtime),
+    lists(500),  %% fixup cache on first round
+    run_micros(Ms,DataDir).
+
+run_micros([],_) -> 
+    io:nl(),
+    [];
+run_micros([H|T],DataDir) ->
+    R = run_micro(H,DataDir),
+    [R| run_micros(T,DataDir)].
+
+run_micro(M,DataDir) ->
+    Pid = spawn(?MODULE, run_micro, [self(),M,DataDir]),
+    Res = receive {Pid, Reply} -> Reply end,
+    {value,{title,Title}} = lists:keysearch(title,1,Reply),
+    {value,{estones,Estones}} = lists:keysearch(estones,1,Reply),
+    erlang:display({Title,Estones}),
+    Res.
+    
+
+run_micro(Top, M, DataDir) ->
+    EstoneCat = filename:join(DataDir,"estone_cat"),
+    put(estone_cat,EstoneCat),
+    Top ! {self(),  apply_micro(M)}.
+
+apply_micro(M) ->
+    {GC0, Words0, _} = statistics(garbage_collection),
+    statistics(reductions),
+    Before = erlang:now(),
+
+    Compensate = apply_micro(M#micro.function, M#micro.loops),
+    After = erlang:now(),
+    {GC1, Words1, _} = statistics(garbage_collection),
+    {_, Reds} = statistics(reductions),
+    Elapsed = subtr(Before, After),
+    MicroSecs = Elapsed - Compensate,
+    [{title, M#micro.str},
+     {tt1, M#micro.tt1},
+     {function, M#micro.function},
+     {weight_percentage, M#micro.weight},
+     {loops, M#micro.loops},
+     {microsecs,MicroSecs},
+     {estones, (M#micro.weight * M#micro.weight * ?STONEFACTOR) div MicroSecs},
+     {gcs, GC1 - GC0},
+     {kilo_word_reclaimed, (Words1 - Words0) div 1000},
+     {kilo_reductions, Reds div 1000},
+     {gc_intensity, gci(Elapsed, GC1 - GC0, Words1 - Words0)}].
+
+
+subtr(Before, After) ->
+    (element(1,After)*1000000000000
+     +element(2,After)*1000000+element(3,After)) -
+        (element(1,Before)*1000000000000
+         +element(2,Before)*1000000+element(3,Before)).
+
+gci(Micros, Words, Gcs) ->
+    ((256 * Gcs) / Micros) + (Words / Micros).
+
+apply_micro(Name, Loops) ->
+    io:format("~w(~w)~n", [Name, Loops]),
+    apply(?MODULE, Name, [Loops]).
+
+%%%%%%%%%%%% micro bench manipulating lists. %%%%%%%%%%%%%%%%%%%%%%%%%
+lists(I) ->
+    L1 = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+    L2 = "aaaaaaaaaa",
+    lists(I, L1, L2).
+
+lists(0, _,_) ->
+    0;
+lists(I, L1, L2) ->
+    revt(10, L1),
+    appt(10, L1, L2),
+    lists(I-1, L1, L2).
+
+revt(0, _) -> 
+    done;
+revt(I, L) -> 
+    reverse(L),
+    revt(I-1, L).
+
+reverse(L) ->
+    reverse(L, []).
+reverse([H|T], Ack) -> reverse(T, [H|Ack]);
+reverse([], Ack) -> Ack.
+
+append([H|T], L) ->
+    [H | append(T, L)];
+append([], L) ->
+    L.
+
+appt(0, _L1, _L2) -> ok;
+appt(I, L1, L2) ->
+    append(L1, L2),
+    appt(I-1, L1, L2).
+
+
+%%%%%%%%%%%%%%% small message passing and ctxt switching %%%%%%%
+msgp(I) ->
+    msgp(I, small()).
+
+msgp(0, _) -> 
+    0;
+msgp(I, Msg) ->
+    P1 = spawn(?MODULE, p1, [self()]),
+    P2 = spawn(?MODULE, p1, [P1]),
+    P3 = spawn(?MODULE, p1, [P2]),
+    P4 = spawn(?MODULE, p1, [P3]),
+    msgp_loop(100, P4, Msg),
+    msgp(I-1, Msg).
+
+p1(To) ->
+    receive
+	{_From, {message, X}} ->
+	    To ! {self(), {message, X}},
+	    p1(To);
+	stop ->
+	    To ! stop,
+	    exit(normal)
+    end.
+
+msgp_loop(0, P, _) ->
+    P ! stop,
+    receive 
+	stop -> ok
+    end;
+msgp_loop(I, P, Msg) ->
+    P ! {self(), {message, Msg}},
+    receive
+	{_From, {message, _}} ->
+	    msgp_loop(I-1, P, Msg)
+    end.
+
+%%%%%%%%%%%% large massage passing and ctxt switching %%%%%%%
+msgp_medium(I) ->
+        msgp_medium(I, big()).
+
+msgp_medium(0, _) -> 
+    0;
+msgp_medium(I, Msg) ->
+    P1 = spawn(?MODULE , p1, [self()]),
+    P2 = spawn(?MODULE, p1, [P1]),
+    P3 = spawn(?MODULE, p1, [P2]),
+    P4 = spawn(?MODULE, p1, [P3]),
+    msgp_loop(100, P4, Msg),
+    msgp_medium(I-1, Msg).
+
+
+
+%%%%%%%%%%%% huge massage passing and ctxt switching %%%%%%%
+msgp_huge(I) ->
+        msgp_huge(I, very_big(15)).
+
+msgp_huge(0, _) -> 
+    0;
+msgp_huge(I, Msg) ->
+    P1 = spawn(?MODULE , p1, [self()]),
+    P4 = spawn(?MODULE, p1, [P1]),
+    msgp_loop(100, P4, Msg),
+    msgp_huge(I-1, Msg).
+
+    
+%%%%%% typical protocol pattern matching %%%%%%%
+pattern(0) ->
+    0;
+pattern(I) ->
+    Tail = "aaabbaaababba",
+    P1 = [0, 1,2,3,4,5|Tail],
+    pat_loop1(100, P1),
+    pat_loop2(100, P1),
+    pat_loop3(100, P1),
+    pat_loop4(100, P1),
+    pat_loop5(100, P1),
+    pattern(I-1).
+
+pat_loop1(0, _) -> 
+    ok;
+pat_loop1(_I, [_, _X, _Y, 0 |_T])  ->
+    ok;
+pat_loop1(_I, [_, _X, _Y, 1| _T]) ->
+    ok;
+pat_loop1(_I, [_, _X, _Y, 2 | _T]) -> 
+    ok;
+pat_loop1(I, [_, X, Y, 3 | T]) ->
+    pat_loop1(I-1, [0, X,Y,3|T]).
+
+pat_loop2(0, _) ->
+    ok;
+pat_loop2(_I, [_X, Y | _Tail]) when Y bsl 1 == 0 ->
+    ok;
+pat_loop2(_I, [_X, Y | _Tail]) when Y bsl 2 == 0 ->
+    ok;
+pat_loop2(I, [X, Y | Tail]) when Y bsl 2 == 4 ->
+    pat_loop2(I-1, [X, Y |Tail]).
+
+
+pat_loop3(0, _) ->
+    ok;
+pat_loop3(_I, [{c, h} | _Tail]) -> 
+    ok;
+pat_loop3(_I, [1, 0 |_T]) ->
+    ok;
+pat_loop3(_I, [X, _Y |_Tail]) when is_binary(X), size(X) == 1 ->
+    ok;
+pat_loop3(_I, [no, _Y|_Tail]) -> 
+    ok;
+pat_loop3(_I, []) ->
+    ok;
+pat_loop3(_I, [X,_Y|_T]) when X /= 0 ->
+    ok;
+pat_loop3(_I, [2,3|_T]) ->
+    ok;
+pat_loop3(_I, [1, 2]) ->
+    ok;
+pat_loop3(I, [0, 1 |T]) ->
+    pat_loop3(I-1, [0,1|T]).
+
+
+pat_loop4(0, _) ->  ok;
+pat_loop4(_I, [20|_T]) -> ok;
+pat_loop4(_I, [219|_T]) -> ok;
+pat_loop4(_I, [18|_T]) -> ok;
+pat_loop4(_I, [17|_T]) -> ok;
+pat_loop4(_I, [16|_T]) -> ok;
+pat_loop4(_I, [15|_T]) -> ok;
+pat_loop4(_I, [14|_T]) -> ok;
+pat_loop4(_I, [13|_T]) -> ok;
+pat_loop4(_I, [12|_T]) -> ok;
+pat_loop4(_I, [11|_T]) -> ok;
+pat_loop4(_I, [10|_T]) -> ok;
+pat_loop4(_I, [9|_T]) -> ok;
+pat_loop4(_I, [8|_T]) -> ok;
+pat_loop4(_I, [7|_T]) -> ok;
+pat_loop4(_I, [6|_T]) -> ok;
+pat_loop4(_I, [5|_T]) -> ok;
+pat_loop4(_I, [4|_T]) -> ok;
+pat_loop4(_I, [3|_T]) -> ok;
+pat_loop4(_I, [1|_T]) -> ok;
+pat_loop4(_I, [21|_T]) -> ok;
+pat_loop4(_I, [22|_T]) -> ok;
+pat_loop4(_I, [23|_T]) -> ok;
+pat_loop4(_I, [24|_T]) -> ok;
+pat_loop4(_I, [25|_T]) -> ok;
+pat_loop4(_I, [26|_T]) -> ok;
+pat_loop4(_I, [27|_T]) -> ok;
+pat_loop4(I, [0|T]) -> 
+    pat_loop4(I-1, [0|T]).
+
+pat_loop5(0, _) -> ok;
+pat_loop5(_I, [0, 20|_T]) -> ok;
+pat_loop5(_I, [0, 19|_T]) -> ok;
+pat_loop5(_I, [0, 18|_T]) -> ok;
+pat_loop5(_I, [0, 17|_T]) -> ok;
+pat_loop5(_I, [0, 16|_T]) -> ok;
+pat_loop5(_I, [0, 15|_T]) -> ok;
+pat_loop5(_I, [0, 14|_T]) -> ok;
+pat_loop5(_I, [0, 13|_T]) -> ok;
+pat_loop5(_I, [0, 12|_T]) -> ok;
+pat_loop5(_I, [0, 11|_T]) -> ok;
+pat_loop5(_I, [0, 10|_T]) -> ok;
+pat_loop5(_I, [0, 9|_T]) -> ok;
+pat_loop5(_I, [0, 8|_T]) -> ok;
+pat_loop5(_I, [0, 7|_T]) -> ok;
+pat_loop5(_I, [0, 6|_T]) -> ok;
+pat_loop5(I, [0, 1|T]) -> 
+    pat_loop5(I-1, [0,1|T]).
+
+%%%%%%%%%% term traversal representing simple pattern matchhing %%%
+%%%%%%%%%                              + some arith
+trav(I) ->
+    X = very_big(10),
+    trav(I, X).
+
+trav(0, _) -> 0;
+trav(I, T) ->
+    do_trav(T),
+    trav(I-1, T).
+
+do_trav(T) when is_tuple(T) ->
+    tup_trav(T, 1, 1 + size(T));
+do_trav([H|T]) ->
+    do_trav(H) + do_trav(T);
+do_trav(X) when is_integer(X) -> 1;
+do_trav(_X) -> 0.
+tup_trav(_T, P, P) -> 0;
+tup_trav(T, P, End) ->
+    do_trav(element(P, T)) + tup_trav(T, P+1, End).
+
+
+%% Port I/O
+port_io(I) ->
+    EstoneCat = get(estone_cat),
+    Before = erlang:now(),
+    Pps = make_port_pids(5, I, EstoneCat),  %% 5 ports
+    send_procs(Pps, go),
+    After = erlang:now(),
+    wait_for_pids(Pps),
+    subtr(Before, After).
+
+make_port_pids(0, _, _) -> 
+    [];
+make_port_pids(NoPorts, J, EstoneCat) ->
+    [spawn(?MODULE, ppp, [self(),J,EstoneCat]) | make_port_pids(NoPorts-1, J, EstoneCat)].
+ppp(Top, I, EstoneCat) ->
+    P = open_port({spawn, EstoneCat}, []),%% cat sits at the other end
+    Str = lists:duplicate(200, 88), %% 200 X'es
+    Cmd = {self(), {command, Str}},
+    receive
+	go -> ok
+    end,
+    ppp_loop(P, I, Cmd),
+    Cmd2 = {self(), {command, "abcde"}},
+    Res = ppp_loop(P, I, Cmd2),
+    P ! {self(), close},
+    receive
+	{P, closed} ->
+	    closed
+    end,
+    Top ! {self(), Res}.
+    
+ppp_loop(_P, 0, _) ->
+    ok;
+ppp_loop(P, I, Cmd) ->
+    P ! Cmd,
+    receive
+	{P, _} ->  %% no match
+	    ppp_loop(P, I-1, Cmd)
+    end.
+
+%% Working with a very large non-working data set
+%% where the passive data resides in remote processes
+large_dataset_work(I) ->
+    {Minus, Ps} = timer:tc(?MODULE, mk_big_procs, [?BIGPROCS]),
+    trav(I),
+    lists(I),
+    send_procs(Ps, stop),
+    Minus. %% Don't count time to create the big procs.
+
+mk_big_procs(0) -> [];
+mk_big_procs(I) ->
+    [ mk_big_proc()| mk_big_procs(I-1)].
+
+mk_big_proc() ->
+    P = spawn(?MODULE, big_proc, []),
+    P ! {self(), running},
+    receive
+	{P, yes} -> P
+    end.
+
+big_proc() ->
+    X = very_big(?BIGPROC_SIZE), %% creates a big heap
+    Y = very_big(?BIGPROC_SIZE),
+    Z = very_big(?BIGPROC_SIZE),
+
+    receive
+	{From, running} ->
+	    From ! {self(), yes}
+    end,
+    receive
+	stop ->
+	    {X, Y, Z}  %% Can't be garbed away now by very (not super)
+                       %% smart compiler
+    end.
+
+%% Working with a large non-working data set
+%% where the data resides in the local process.
+large_local_dataset_work(I) ->
+    {Minus, _Data} = timer:tc(?MODULE, very_big, [?BIGPROC_SIZE]),
+    trav(I),
+    lists(I),
+    Minus.
+
+
+%% Fast allocation and also deallocation that is gc test
+%% Important to not let variable linger on the stack un-necessarily
+alloc(0) -> 0;
+alloc(I) ->
+    _X11 = very_big(),
+    _X12 = very_big(),
+    _X13 = very_big(),
+    _Z = [_X14 = very_big(),
+	  _X15 = very_big(),
+	  _X16 = very_big()],
+    _X17 = very_big(),
+    _X18 = very_big(),
+    _X19 = very_big(),
+    _X20 = very_big(),
+    _X21 = very_big(),
+    _X22 = very_big(),
+    _X23 = very_big(),
+    _X24 = very_big(),
+    alloc(I-1).
+
+%% Time to call bif's
+%% Lot's of element stuff which reflects the record code which
+%% is becomming more and more common
+bif_dispatch(0) ->
+    0;
+bif_dispatch(I) ->
+    disp(),    disp(),    disp(),    disp(),    disp(),    disp(),
+    disp(),    disp(),    disp(),    disp(),    disp(),    disp(),
+    bif_dispatch(I-1).
+
+disp() ->
+    Tup = {a},
+    L = [x],
+    self(),self(),self(),self(),self(),self(),self(),self(),self(),
+    make_ref(),
+    atom_to_list(''),
+    _X = list_to_atom([]),
+    tuple_to_list({}),
+    _X2 = list_to_tuple([]),
+    element(1, Tup),
+    element(1, Tup),
+    _Elem = element(1, Tup),element(1, Tup),element(1, Tup),element(1, Tup),
+    element(1, Tup),element(1, Tup),element(1, Tup),element(1, Tup),
+    element(1, Tup),element(1, Tup),element(1, Tup),element(1, Tup),
+    element(1, Tup),element(1, Tup),element(1, Tup),element(1, Tup),
+    setelement(1, Tup,k),
+    setelement(1, Tup,k),
+    setelement(1, Tup,k),setelement(1, Tup,k),setelement(1, Tup,k),
+    setelement(1, Tup,k),setelement(1, Tup,k),setelement(1, Tup,k),
+    setelement(1, Tup,k),
+    setelement(1, Tup,k),
+    setelement(1, Tup,k),
+    setelement(1, Tup,k),
+    _Y = setelement(1, Tup,k),
+    _Date = date(), time(),
+    put(a, 1),
+    get(a),
+    erase(a),
+    hd(L),
+    tl(L),
+    _Len = length(L),length(L),length(L),length(L),
+    node(),node(),node(),node(),node(),node(),node(),node(),
+    S=self(),
+    node(S),node(S),node(S),
+    size(Tup),
+    _W = whereis(code_server),whereis(code_server),
+    whereis(code_server),whereis(code_server),
+    whereis(code_server),whereis(code_server),
+    _W2 = whereis(code_server).
+    
+    
+%% Generic server like behaviour
+generic(I) ->
+    register(funky, spawn(?MODULE, gserv, [funky, ?MODULE, [], []])),
+    g_loop(I).
+
+g_loop(0) ->
+    exit(whereis(funky), kill),
+    0;
+g_loop(I) ->
+    ?MODULE:req(funky, {call, [abc]}),
+    ?MODULE:req(funky, {call, [abc]}),
+    ?MODULE:req(funky, {call, [abc]}),
+    ?MODULE:req(funky, {call, [abc]}),
+    ?MODULE:req(funky, {call, [xyz]}),
+    ?MODULE:req(funky, {call, [abc]}),
+    ?MODULE:req(funky, {call, [abc]}),
+    ?MODULE:req(funky, {call, [abc]}),
+    ?MODULE:req(funky, {call, [abc]}),
+    ?MODULE:req(funky, {call, [abc]}),
+    ?MODULE:req(funky, {call, [abc]}),
+    ?MODULE:req(funky, {call, [abc]}),
+    ?MODULE:req(funky, {call, [abc]}),
+    ?MODULE:req(funky, {call, [abc]}),
+    ?MODULE:req(funky, {call, [abc]}),
+    ?MODULE:req(funky, {call, [xyz]}),
+    ?MODULE:req(funky, {call, [abc]}),
+    ?MODULE:req(funky, {call, [abc]}),
+    ?MODULE:req(funky, {call, [abc]}),
+    ?MODULE:req(funky, {call, [abc]}),
+    ?MODULE:req(funky, {call, [abc]}),
+    ?MODULE:req(funky, {call, [abc]}),
+    g_loop(I-1).
+
+req(Name, Req) ->
+    R = make_ref(),
+    Name ! {self(), R, Req},
+    receive
+	{Name, R, Reply} -> Reply
+    after 2000 ->
+	    exit(timeout)
+    end.
+
+gserv(Name, Mod, State, Debug) ->
+    receive
+	{From, Ref, {call, Req}} when Debug == [] ->
+	    case catch apply(Mod, handle_call, [From, State, Req]) of
+		{reply, Reply, State2} ->
+		    From ! {Name, Ref, Reply},
+		    gserv(Name, Mod, State2, Debug);
+		{noreply, State2} ->
+		    gserv(Name, Mod, State2, Debug);
+		{'EXIT', Reason} ->
+		    exit(Reason)
+	    end;
+	{_From, _Ref, _Req} when Debug /= [] ->
+	    exit(nodebug)
+    end.
+
+handle_call(_From, _State, [xyz]) ->
+    R = atom_to_list(xyz),
+    {reply, R, []};
+handle_call(_From, State, [abc]) ->
+    R = 1 + 3,
+    {reply, R, [R | State]}.
+
+		    
+
+%% Binary handling, creating, manipulating and sending binaries
+binary_h(I) ->
+    Before = erlang:now(),
+    P = spawn(?MODULE, echo, [self()]),
+    B = list_to_binary(lists:duplicate(2000, 5)),
+    After = erlang:now(),
+    Compensate = subtr(Before, After),
+    binary_h_2(I, P, B),
+    Compensate.
+    
+binary_h_2(0, P, _B) ->
+    exit(P, kill);
+binary_h_2(I, P, B) ->
+    echo_loop(P, 20, B),
+    split_loop(B, {abc,1,2222,self(),"ancnd"}, 100),
+    binary_h_2(I-1, P, B).
+
+split_loop(_B, _, 0) -> 
+    ok;
+split_loop(B, Term, I) ->
+    {X, Y} = split_binary(B, I),
+    size(X),
+    binary_to_list(Y, 1, 2),
+    binary_to_term(term_to_binary(Term)),
+    split_loop(B, Term, I-1).
+    
+
+echo_loop(_P, 0, _B) -> 
+    k;
+echo_loop(P, I, B) ->
+    P ! B,
+    P ! B,
+    P ! B,
+    P ! B,
+    P ! B,
+    P ! B,
+    P ! B,
+    P ! B,
+    P ! B,
+    P ! B,
+    receive _ -> ok end,
+    receive _ -> ok end,
+    receive _ -> ok end,
+    receive _ -> ok end,
+    receive _ -> ok end,
+    receive _ -> ok end,
+    receive _ -> ok end,
+    receive _ -> ok end,
+    receive _ -> ok end,
+    receive _ -> ok end,
+    echo_loop(P, I-1, B).
+    
+
+ets(0) -> 
+    0;
+ets(I) ->
+    T1 = ets:new(a, [set]),
+    T2 = ets:new(c, [bag, private]),
+    L = [T1, T2],
+    run_tabs(L, L, 1),
+    ets:delete(T1),
+    ets:delete(T2),
+    ets(I-1).
+
+run_tabs(_, _, 0) ->
+    ok;
+run_tabs([], L, I) ->
+    run_tabs(L, L, I-1);
+run_tabs([Tab|Tail], L, I) ->
+    Begin = I * 20,
+    End = (I+1) * 20,
+    run_tab(Tab, Begin, End, I),
+    run_tabs(Tail, L, I).
+
+run_tab(_Tab, X, X, _) ->
+    ok;
+run_tab(Tab, Beg, End, J) ->
+    ets:insert(Tab, {Beg, J}),
+    ets:insert(Tab, {J, Beg}),
+    ets:insert(Tab, {{foo,Beg}, J}),
+    ets:insert(Tab, {{foo, J}, Beg}),
+    ets:delete(Tab, haha),
+    ets:match_delete(Tab, {k, j}),
+    ets:match(Tab, {Beg, '$1'}),
+    ets:match(Tab, {'$1', J}),
+    ets:delete(Tab, Beg),
+    K = ets:first(Tab),
+    _K2 = ets:next(Tab, K),
+    run_tab(Tab, Beg+1, End, J).
+    
+    
+%%%% Integer arith %%%%%
+int_arith(0) -> 
+    0;
+int_arith(I) ->
+    do_arith(I) +
+    do_arith(I) +
+    do_arith(I) +
+    do_arith(I) +
+    do_arith(I) +
+    do_arith(I) +
+    do_arith(I) +
+    do_arith(I) +
+    do_arith(I) +
+	66,
+    int_arith(I-1).
+
+do_arith(I) ->    
+    do_arith2(I) -
+    do_arith2(I) -
+    do_arith2(I) -
+    do_arith2(I) -
+    do_arith2(I) -
+    do_arith2(I) -
+    do_arith2(I) -
+	99.
+
+do_arith2(I) ->
+    X = 23,
+    _Y = 789 + I,
+    Z = I + 1,
+    U = (X bsl 1 bsr I) * X div 2 bsr 4,
+    U1 = Z + Z + Z + Z + X bsl 4 * 2 bsl 2,
+    Z - U + U1 div 2.
+
+    
+%%%% Float arith %%%%%
+float_arith(0) -> 
+    0;
+float_arith(I) ->
+    f_do_arith(I) +
+    f_do_arith(I) +
+    f_do_arith(I) +
+    f_do_arith(I) +
+    f_do_arith(I) +
+    f_do_arith(I) +
+    f_do_arith(I) +
+    f_do_arith(I) +
+    f_do_arith(I) +
+	66,
+    float_arith(I-1).
+
+f_do_arith(I) ->    
+    X = 23.4,
+    _Y = 789.99 + I,
+    Z = I + 1.88,
+    U = (X * 1 / I) * X / 2 * 4,
+    U1 = Z + Z + Z + Z + X * 4 * 2 / 2,
+    Z - U + U1 / 2.
+
+%%%% time to do various function calls
+fcalls(0) -> 
+    0;
+fcalls(I) ->
+    local0(400),
+    remote0(400),
+    app0(400),
+    local1(400),
+    remote1(400),
+    app1(400),
+    fcalls(I-1).
+
+
+local0(0) -> 0;
+local0(N) ->
+    local0(N-1).
+
+local1(0) -> 0;
+local1(N) ->
+    1+local1(N-1).
+
+remote0(0) -> 0;
+remote0(N) ->
+    ?MODULE:remote0(N-1).
+
+remote1(0) -> 0;
+remote1(N) ->
+    1+?MODULE:remote1(N-1).
+
+app0(0) -> 0;
+app0(N) ->
+    apply(?MODULE, app0, [N-1]).
+
+app1(0) -> 0;
+app1(N) ->
+    1 + apply(?MODULE, app1, [N-1]).
+
+%%%%%% jog the time queue implementation
+timer(I) ->
+    L = [50, 50, 50, 100, 1000, 3000, 8000, 50000, 100000],
+    timer(I, L).
+
+timer(0, _) -> 0;
+timer(N, L) ->
+    send_self(100),
+    recv(100,L, L),
+    timer(N-1).
+
+recv(0, _, _) ->
+    ok;
+recv(N, [], L) ->
+    recv(N, L, L);
+recv(N, [Timeout|Tail], L) ->
+    receive
+        hi_dude ->
+            recv(N-1, Tail, L)
+    after Timeout ->
+            io:format("XXXXX this wasn't supposed to happen???~n", []),
+            ok
+    end.
+
+send_self(0) ->
+    ok;
+send_self(N) ->
+    self() ! hi_dude,
+    send_self(N-1).
+
+
+%%%%%%%%%%%% managing many links %%%%%
+links(I) ->
+    L = mk_link_procs(100),
+    send_procs(L, {procs, L, I}),
+    wait_for_pids(L),
+    0.
+
+mk_link_procs(0) -> 
+    [];
+mk_link_procs(I) ->
+    [spawn_link(?MODULE, lproc, [self()]) | mk_link_procs(I-1)].
+
+
+lproc(Top) ->
+    process_flag(trap_exit,true),
+    receive
+	{procs, Procs, I} ->
+	    Top ! {self(), lproc(Procs, Procs, link, I)}
+    end.
+
+lproc(_, _, _, 0) ->
+    done;
+lproc([], Procs, link, I) ->
+    lproc(Procs, Procs, unlink, I-1);
+lproc([], Procs, unlink, I) ->
+    lproc(Procs, Procs, link, I-1);
+lproc([Pid|Tail], Procs, unlink, I) ->
+    unlink(Pid),
+    lproc(Tail, Procs, unlink, I);
+lproc([Pid|Tail], Procs, link, I) ->
+    link(Pid),
+    lproc(Tail, Procs, unlink, I).
+
+
+
+%%%%%%%%%%% various utility functions %%%%%%%
+
+echo(Pid) ->
+    receive
+	X -> Pid ! X,
+	     echo(Pid)
+    end.
+
+very_big() -> 
+    very_big(2).
+very_big(0) -> [];
+very_big(I) ->
+    {1,2,3,a,v,f,r,t,y,u,self(), self(), self(), 
+     "22222222222222222", {{"234", self()}}, 
+     [[very_big(I-1)]]}.
+ 
+big() ->
+    {self(), funky_stuff, baby, {1, [123, true,[]], "abcdef"}}.
+
+small() -> {self(), true}.    
+    
+%% Wait for a list of children to respond    
+wait_for_pids([]) -> 
+    ok;
+wait_for_pids([P|Tail]) ->
+    receive 
+	{P, _Res} -> wait_for_pids(Tail)
+    end.
+
+send_procs([P|Tail], Msg) -> P ! Msg, send_procs(Tail, Msg);
+send_procs([], _) -> ok.
+