The R13B03 release.OTP_R13B03

1 files changed, 683 insertions, 0 deletions

diff --git a/erts/preloaded/src/erlang.erl b/erts/preloaded/src/erlang.erl
new file mode 100644
index 0000000000..6f92b319b7
--- /dev/null
+++ b/erts/preloaded/src/erlang.erl
@@ -0,0 +1,683 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 1996-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(erlang).
+
+-export([apply/2,apply/3,spawn/4,spawn_link/4,
+	 spawn_monitor/1,spawn_monitor/3,
+	 spawn_opt/2,spawn_opt/3,spawn_opt/4,spawn_opt/5,
+	 disconnect_node/1]).
+-export([spawn/1, spawn_link/1, spawn/2, spawn_link/2]).
+-export([yield/0]).
+-export([crasher/6]).
+-export([fun_info/1]).
+-export([send_nosuspend/2, send_nosuspend/3]).
+-export([localtime_to_universaltime/1]).
+-export([suspend_process/1]).
+-export([min/2,max/2]).
+
+-export([dlink/1, dunlink/1, dsend/2, dsend/3, dgroup_leader/2,
+	 dexit/2, dmonitor_node/3, dmonitor_p/2]).
+
+-export([delay_trap/2]).
+
+-export([set_cookie/2, get_cookie/0]).
+
+-export([nodes/0]).
+
+-export([concat_binary/1]).
+
+-export([list_to_integer/2,integer_to_list/2]).
+
+-export([flush_monitor_message/2]).
+
+-export([set_cpu_topology/1, format_cpu_topology/1]).
+
+-export([await_proc_exit/3]).
+
+-deprecated([hash/2]).
+
+-compile(nowarn_bif_clash).
+
+apply(Fun, Args) ->
+    apply(Fun, Args).
+
+apply(Mod, Name, Args) ->
+    apply(Mod, Name, Args).
+
+
+% Spawns with a fun
+spawn(F) when is_function(F) ->
+    spawn(erlang, apply, [F, []]);
+spawn({M,F}=MF) when is_atom(M), is_atom(F) ->
+    spawn(erlang, apply, [MF, []]);
+spawn(F) ->
+    erlang:error(badarg, [F]).
+
+spawn(N, F) when N =:= node() ->
+    spawn(F);
+spawn(N, F) when is_function(F) ->
+    spawn(N, erlang, apply, [F, []]);
+spawn(N, {M,F}=MF) when is_atom(M), is_atom(F) ->
+    spawn(N, erlang, apply, [MF, []]);
+spawn(N, F) ->
+    erlang:error(badarg, [N, F]).
+
+spawn_link(F) when is_function(F) ->
+    spawn_link(erlang, apply, [F, []]);
+spawn_link({M,F}=MF) when is_atom(M), is_atom(F) ->
+    spawn_link(erlang, apply, [MF, []]);
+spawn_link(F) ->
+    erlang:error(badarg, [F]).
+
+spawn_link(N, F) when N =:= node() ->
+    spawn_link(F);
+spawn_link(N, F) when is_function(F) ->
+    spawn_link(N, erlang, apply, [F, []]);
+spawn_link(N, {M,F}=MF) when is_atom(M), is_atom(F) ->
+    spawn_link(N, erlang, apply, [MF, []]);
+spawn_link(N, F) ->
+    erlang:error(badarg, [N, F]).
+
+%% Spawn and atomically set up a monitor.
+
+spawn_monitor(F) when is_function(F, 0) ->
+    erlang:spawn_opt({erlang,apply,[F,[]],[monitor]});
+spawn_monitor(F) ->
+    erlang:error(badarg, [F]).
+
+spawn_monitor(M, F, A) when is_atom(M), is_atom(F), is_list(A) ->
+    erlang:spawn_opt({M,F,A,[monitor]});
+spawn_monitor(M, F, A) ->
+    erlang:error(badarg, [M,F,A]).
+
+spawn_opt(F, O) when is_function(F) ->
+    spawn_opt(erlang, apply, [F, []], O);
+spawn_opt({M,F}=MF, O) when is_atom(M), is_atom(F) ->
+    spawn_opt(erlang, apply, [MF, []], O);
+spawn_opt({M,F,A}, O) -> % For (undocumented) backward compatibility
+    spawn_opt(M, F, A, O);
+spawn_opt(F, O) ->
+    erlang:error(badarg, [F, O]).
+
+spawn_opt(N, F, O) when N =:= node() ->
+    spawn_opt(F, O);
+spawn_opt(N, F, O) when is_function(F) ->
+    spawn_opt(N, erlang, apply, [F, []], O);
+spawn_opt(N, {M,F}=MF, O) when is_atom(M), is_atom(F) ->
+    spawn_opt(N, erlang, apply, [MF, []], O);
+spawn_opt(N, F, O) ->
+    erlang:error(badarg, [N, F, O]).
+
+% Spawns with MFA
+
+spawn(N,M,F,A) when N =:= node(), is_atom(M), is_atom(F), is_list(A) ->
+    spawn(M,F,A);
+spawn(N,M,F,A) when is_atom(N), is_atom(M), is_atom(F) ->
+    case is_well_formed_list(A) of
+	true ->
+	    ok;
+	false ->
+	    erlang:error(badarg, [N, M, F, A])
+    end,
+    case catch gen_server:call({net_kernel,N},
+			       {spawn,M,F,A,group_leader()},
+			       infinity) of
+	Pid when is_pid(Pid) ->
+	    Pid;
+	Error ->
+	    case remote_spawn_error(Error, {no_link, N, M, F, A, []}) of
+		{fault, Fault} ->
+		    erlang:error(Fault, [N, M, F, A]);
+		Pid ->
+		    Pid
+	    end
+    end;
+spawn(N,M,F,A) ->
+    erlang:error(badarg, [N, M, F, A]).
+
+spawn_link(N,M,F,A) when N =:= node(), is_atom(M), is_atom(F), is_list(A) ->
+    spawn_link(M,F,A);
+spawn_link(N,M,F,A) when is_atom(N), is_atom(M), is_atom(F) ->
+    case is_well_formed_list(A) of
+	true ->
+	    ok;
+	_ ->
+	    erlang:error(badarg, [N, M, F, A])
+    end,
+    case catch gen_server:call({net_kernel,N},
+			       {spawn_link,M,F,A,group_leader()},
+			       infinity) of
+	Pid when is_pid(Pid) ->
+	    Pid;
+	Error ->
+	    case remote_spawn_error(Error, {link, N, M, F, A, []}) of
+		{fault, Fault} ->
+		    erlang:error(Fault, [N, M, F, A]);
+		Pid ->
+		    Pid
+	    end
+    end;
+spawn_link(N,M,F,A) ->
+    erlang:error(badarg, [N, M, F, A]).
+
+spawn_opt(M, F, A, Opts) ->
+    case catch erlang:spawn_opt({M,F,A,Opts}) of
+	{'EXIT',{Reason,_}} ->
+	    erlang:error(Reason, [M,F,A,Opts]);
+	Res ->
+	    Res
+    end.
+
+spawn_opt(N, M, F, A, O) when N =:= node(),
+			      is_atom(M), is_atom(F), is_list(A),
+			      is_list(O) ->
+    spawn_opt(M, F, A, O);
+spawn_opt(N, M, F, A, O) when is_atom(N), is_atom(M), is_atom(F) ->
+    case {is_well_formed_list(A), is_well_formed_list(O)} of
+	{true, true} ->
+	    ok;
+	_ ->
+	    erlang:error(badarg, [N, M, F, A, O])
+    end,
+    case lists:member(monitor, O) of
+	false -> ok;
+	true -> erlang:error(badarg, [N, M, F, A, O])
+    end,
+    {L,NO} = lists:foldl(fun (link, {_, NewOpts}) ->
+				 {link, NewOpts};
+			     (Opt, {LO, NewOpts}) ->
+				 {LO, [Opt|NewOpts]}
+			 end,
+			 {no_link,[]},
+			 O),
+    case catch gen_server:call({net_kernel,N},
+			       {spawn_opt,M,F,A,NO,L,group_leader()},
+			       infinity) of
+	Pid when is_pid(Pid) ->
+	    Pid;
+	Error ->
+	    case remote_spawn_error(Error, {L, N, M, F, A, NO}) of
+		{fault, Fault} ->
+		    erlang:error(Fault, [N, M, F, A, O]);
+		Pid ->
+		    Pid
+	    end
+    end;
+spawn_opt(N,M,F,A,O) ->
+    erlang:error(badarg, [N,M,F,A,O]).
+
+remote_spawn_error({'EXIT', {{nodedown,N}, _}}, {L, N, M, F, A, O}) ->
+    {Opts, LL} = case L =:= link of
+		     true ->
+			 {[link|O], [link]};
+		     false ->
+			 {O, []}
+		 end,
+    spawn_opt(erlang,crasher,[N,M,F,A,Opts,noconnection], LL);
+remote_spawn_error({'EXIT', {Reason, _}}, _) ->
+    {fault, Reason};
+remote_spawn_error({'EXIT', Reason}, _) ->
+    {fault, Reason};
+remote_spawn_error(Other, _) ->
+    {fault, Other}.
+    
+is_well_formed_list([]) ->
+    true;
+is_well_formed_list([_|Rest]) ->
+    is_well_formed_list(Rest);
+is_well_formed_list(_) ->
+    false.
+
+crasher(Node,Mod,Fun,Args,[],Reason) ->
+    error_logger:warning_msg("** Can not start ~w:~w,~w on ~w **~n",
+			     [Mod,Fun,Args,Node]),
+    exit(Reason);
+crasher(Node,Mod,Fun,Args,Opts,Reason) ->
+    error_logger:warning_msg("** Can not start ~w:~w,~w (~w) on ~w **~n",
+			     [Mod,Fun,Args,Opts,Node]),
+    exit(Reason).
+
+yield() ->
+    erlang:yield().
+
+nodes() -> erlang:nodes(visible).
+
+disconnect_node(Node) -> net_kernel:disconnect(Node).
+
+fun_info(Fun) when is_function(Fun) ->
+    Keys = [type,env,arity,name,uniq,index,new_uniq,new_index,module,pid],
+    fun_info_1(Keys, Fun, []).
+
+fun_info_1([K|Ks], Fun, A) ->
+    case erlang:fun_info(Fun, K) of
+	{K,undefined} -> fun_info_1(Ks, Fun, A);
+	{K,_}=P -> fun_info_1(Ks, Fun, [P|A])
+    end;
+fun_info_1([], _, A) -> A.
+
+-type dst() :: pid() | port() | atom() | {atom(), node()}.
+
+-spec send_nosuspend(dst(), term()) -> boolean().
+send_nosuspend(Pid, Msg) ->
+    send_nosuspend(Pid, Msg, []).
+
+-spec send_nosuspend(dst(), term(), ['noconnect' | 'nosuspend']) -> boolean().
+send_nosuspend(Pid, Msg, Opts) ->
+    case erlang:send(Pid, Msg, [nosuspend|Opts]) of
+	ok -> true;
+	_  -> false
+    end.
+
+localtime_to_universaltime(Localtime) ->
+    erlang:localtime_to_universaltime(Localtime, undefined).
+
+suspend_process(P) ->
+    case catch erlang:suspend_process(P, []) of
+	{'EXIT', {Reason, _}} -> erlang:error(Reason, [P]);
+	{'EXIT', Reason} -> erlang:error(Reason, [P]);
+	Res -> Res
+    end.
+
+%%
+%% If the emulator wants to perform a distributed command and
+%% a connection is not established to the actual node the following 
+%% functions is called in order to set up the connection and then 
+%% reactivate the command.
+%%
+
+dlink(Pid) ->
+    case net_kernel:connect(node(Pid)) of
+	true -> link(Pid);
+	false -> erlang:dist_exit(self(), noconnection, Pid), true
+    end.
+
+%% Can this ever happen?
+dunlink(Pid) ->
+    case net_kernel:connect(node(Pid)) of
+	true -> unlink(Pid);
+	false -> true
+    end.
+
+dmonitor_node(Node, Flag, []) ->
+    case net_kernel:connect(Node) of
+	true -> erlang:monitor_node(Node, Flag, []);
+	false -> self() ! {nodedown, Node}, true
+    end;
+
+dmonitor_node(Node, Flag, Opts) ->
+    case lists:member(allow_passive_connect,Opts) of
+	true ->
+	    case net_kernel:passive_cnct(Node) of
+		true -> erlang:monitor_node(Node, Flag, Opts);
+		false -> self() ! {nodedown, Node}, true
+	    end;
+	_ ->
+	    dmonitor_node(Node,Flag,[])
+    end.
+
+dgroup_leader(Leader, Pid) ->
+    case net_kernel:connect(node(Pid)) of
+	true -> group_leader(Leader, Pid);
+	false -> true  %% bad arg ?
+    end.
+
+dexit(Pid, Reason) -> 
+    case net_kernel:connect(node(Pid)) of
+	true -> exit(Pid, Reason);
+	false -> true
+    end.
+
+dsend(Pid, Msg) when is_pid(Pid) ->
+    case net_kernel:connect(node(Pid)) of
+	true -> erlang:send(Pid, Msg);
+	false -> Msg
+    end;
+dsend(Port, Msg) when is_port(Port) ->
+    case net_kernel:connect(node(Port)) of
+	true -> erlang:send(Port, Msg);
+	false -> Msg
+    end;
+dsend({Name, Node}, Msg) ->
+    case net_kernel:connect(Node) of
+	true -> erlang:send({Name,Node}, Msg);
+	false -> Msg;
+	ignored -> Msg				% Not distributed.
+    end.
+
+dsend(Pid, Msg, Opts) when is_pid(Pid) ->
+    case net_kernel:connect(node(Pid)) of
+	true -> erlang:send(Pid, Msg, Opts);
+	false -> ok
+    end;
+dsend(Port, Msg, Opts) when is_port(Port) ->
+    case net_kernel:connect(node(Port)) of
+	true -> erlang:send(Port, Msg, Opts);
+	false -> ok
+    end;
+dsend({Name, Node}, Msg, Opts) ->
+    case net_kernel:connect(Node) of
+	true -> erlang:send({Name,Node}, Msg, Opts);
+	false -> ok;
+	ignored -> ok				% Not distributed.
+    end.
+
+dmonitor_p(process, ProcSpec) ->
+    %% ProcSpec = pid() | {atom(),atom()}
+    %% ProcSpec CANNOT be an atom because a locally registered process
+    %% is never handled here.
+
+    Node = case ProcSpec of
+	       {S,N} when is_atom(S), is_atom(N), N =/= node() -> N;
+	       _ when is_pid(ProcSpec) -> node(ProcSpec)
+	   end,
+    case net_kernel:connect(Node) of
+	true ->
+	    erlang:monitor(process, ProcSpec);
+	false ->
+	    Ref = make_ref(),
+	    self() ! {'DOWN', Ref, process, ProcSpec, noconnection},
+	    Ref
+    end.
+
+%%
+%% Trap function used when modified timing has been enabled.
+%%
+
+delay_trap(Result, 0) -> erlang:yield(), Result;
+delay_trap(Result, Timeout) -> receive after Timeout -> Result end.
+
+%%
+%% The business with different in and out cookies represented
+%% everywhere is discarded.
+%% A node has a cookie, connections/messages to that node use that cookie.
+%% Messages to us use our cookie. IF we change our cookie, other nodes 
+%% have to reflect that, which we cannot forsee.
+%%
+set_cookie(Node, C) when Node =/= nonode@nohost, is_atom(Node) ->
+    Res = case C of
+	      _ when is_atom(C) ->
+		  auth:set_cookie(Node, C);
+	      {CI,CO} when is_atom(CI), is_atom(CO) ->
+		  auth:set_cookie(Node, {CI, CO});
+	      _ ->
+		  error
+	  end,
+    case Res of
+	error -> exit(badarg);
+	Other -> Other
+    end.
+	    
+get_cookie() ->
+    auth:get_cookie().
+
+concat_binary(List) ->
+    list_to_binary(List).
+
+integer_to_list(I, 10) ->
+    erlang:integer_to_list(I);
+integer_to_list(I, Base) 
+  when is_integer(I), is_integer(Base), Base >= 2, Base =< 1+$Z-$A+10 ->
+    if I < 0 ->
+	    [$-|integer_to_list(-I, Base, [])];
+       true ->
+	    integer_to_list(I, Base, [])
+    end;
+integer_to_list(I, Base) ->
+    erlang:error(badarg, [I, Base]).
+
+integer_to_list(I0, Base, R0) ->
+    D = I0 rem Base,
+    I1 = I0 div Base,
+    R1 = if D >= 10 ->
+		 [D-10+$A|R0];
+	    true ->
+		 [D+$0|R0]
+	 end,
+    if I1 =:= 0 ->
+	    R1;
+       true ->
+	    integer_to_list(I1, Base, R1)
+    end.
+
+
+
+list_to_integer(L, 10) ->
+    erlang:list_to_integer(L);
+list_to_integer(L, Base)
+  when is_list(L), is_integer(Base), Base >= 2, Base =< 1+$Z-$A+10 ->
+    case list_to_integer_sign(L, Base) of 
+	I when is_integer(I) ->
+	    I;
+	Fault ->
+	    erlang:error(Fault, [L,Base])
+    end;
+list_to_integer(L, Base) ->
+    erlang:error(badarg, [L,Base]).
+
+list_to_integer_sign([$-|[_|_]=L], Base) ->
+    case list_to_integer(L, Base, 0) of
+	I when is_integer(I) ->
+	    -I;
+	I ->
+	    I
+    end;
+list_to_integer_sign([$+|[_|_]=L], Base) ->
+    list_to_integer(L, Base, 0);
+list_to_integer_sign([_|_]=L, Base) ->
+    list_to_integer(L, Base, 0);
+list_to_integer_sign(_, _) ->
+    badarg.
+
+list_to_integer([D|L], Base, I) 
+  when is_integer(D), D >= $0, D =< $9, D < Base+$0 ->
+    list_to_integer(L, Base, I*Base + D-$0);
+list_to_integer([D|L], Base, I) 
+  when is_integer(D), D >= $A, D < Base+$A-10 ->
+    list_to_integer(L, Base, I*Base + D-$A+10);
+list_to_integer([D|L], Base, I) 
+  when is_integer(D), D >= $a, D < Base+$a-10 ->
+    list_to_integer(L, Base, I*Base + D-$a+10);
+list_to_integer([], _, I) ->
+    I;
+list_to_integer(_, _, _) ->
+    badarg.
+
+%% erlang:flush_monitor_message/2 is for internal use only!
+%%
+%% erlang:demonitor(Ref, [flush]) traps to
+%% erlang:flush_monitor_message(Ref, Res) when
+%% it needs to flush a monitor message.
+flush_monitor_message(Ref, Res) when is_reference(Ref), is_atom(Res) ->
+    receive {_, Ref, _, _, _} -> ok after 0 -> ok end,
+    Res.
+
+-record(cpu, {node = -1,
+	      processor = -1,
+	      processor_node = -1,
+	      core = -1,
+	      thread = -1,
+	      logical = -1}).
+
+%% erlang:set_cpu_topology/1 is for internal use only!
+%%
+%% erlang:system_flag(cpu_topology, CpuTopology) traps to 
+%% erlang:set_cpu_topology(CpuTopology).
+set_cpu_topology(CpuTopology) ->
+    try format_cpu_topology(erlang:system_flag(internal_cpu_topology,
+					       cput_e2i(CpuTopology)))
+    catch
+	Class:Exception when Class =/= error; Exception =/= internal_error -> 
+	    erlang:error(badarg, [CpuTopology])
+    end.
+
+cput_e2i_clvl({logical, _}, _PLvl) ->
+    #cpu.logical;
+cput_e2i_clvl([E | _], PLvl) ->
+    case element(1, E) of
+	node -> case PLvl of
+		    0 -> #cpu.node;
+		    #cpu.processor -> #cpu.processor_node
+		end;
+	processor -> case PLvl of
+			 0 -> #cpu.node;
+			 #cpu.node -> #cpu.processor
+		     end;
+	core -> #cpu.core;
+	thread -> #cpu.thread
+    end.
+
+cput_e2i(undefined) ->
+    undefined;
+cput_e2i(E) ->
+    rvrs(cput_e2i(E, -1, -1, #cpu{}, 0, cput_e2i_clvl(E, 0), [])).
+
+cput_e2i([], _NId, _PId, _IS, _PLvl, _Lvl, Res) -> 
+    Res;
+cput_e2i([E|Es], NId0, PId, IS, PLvl, Lvl, Res0) -> 
+    case cput_e2i(E, NId0, PId, IS, PLvl, Lvl, Res0) of
+	[] ->
+	    cput_e2i(Es, NId0, PId, IS, PLvl, Lvl, Res0);
+	[#cpu{node = N,
+	      processor = P,
+	      processor_node = PN} = CPU|_] = Res1 ->
+	    NId1 = case N > PN of
+			 true -> N;
+			 false -> PN
+		     end,
+	    cput_e2i(Es, NId1, P, CPU, PLvl, Lvl, Res1)
+    end;
+cput_e2i({Tag, [], TagList}, Nid, PId, CPU, PLvl, Lvl, Res) ->
+    %% Currently [] is the only valid InfoList
+    cput_e2i({Tag, TagList}, Nid, PId, CPU, PLvl, Lvl, Res);
+cput_e2i({node, NL}, Nid0, PId, _CPU, 0, #cpu.node, Res) ->
+    Nid1 = Nid0+1,
+    Lvl = cput_e2i_clvl(NL, #cpu.node),
+    cput_e2i(NL, Nid1, PId, #cpu{node = Nid1}, #cpu.node, Lvl, Res);
+cput_e2i({processor, PL}, Nid, PId0, _CPU, 0, #cpu.node, Res) ->
+    PId1 = PId0+1,
+    Lvl = cput_e2i_clvl(PL, #cpu.processor),
+    cput_e2i(PL, Nid, PId1, #cpu{processor = PId1}, #cpu.processor, Lvl, Res);
+cput_e2i({processor, PL}, Nid, PId0, CPU, PLvl, CLvl, Res)
+  when PLvl < #cpu.processor, CLvl =< #cpu.processor ->
+    PId1 = PId0+1,
+    Lvl = cput_e2i_clvl(PL, #cpu.processor),
+    cput_e2i(PL, Nid, PId1, CPU#cpu{processor = PId1,
+				    processor_node = -1,
+				    core = -1,
+				    thread = -1}, #cpu.processor, Lvl, Res);
+cput_e2i({node, NL}, Nid0, PId, CPU, #cpu.processor, #cpu.processor_node,
+	 Res) ->
+    Nid1 = Nid0+1,
+    Lvl = cput_e2i_clvl(NL, #cpu.processor_node),
+    cput_e2i(NL, Nid1, PId, CPU#cpu{processor_node = Nid1},
+	     #cpu.processor_node, Lvl, Res);
+cput_e2i({core, CL}, Nid, PId, #cpu{core = C0} = CPU, PLvl, #cpu.core, Res)
+  when PLvl < #cpu.core ->
+    Lvl = cput_e2i_clvl(CL, #cpu.core),
+    cput_e2i(CL, Nid, PId, CPU#cpu{core = C0+1, thread = -1}, #cpu.core, Lvl,
+	     Res);
+cput_e2i({thread, TL}, Nid, PId, #cpu{thread = T0} = CPU, PLvl, #cpu.thread,
+	 Res) when PLvl < #cpu.thread ->
+    Lvl = cput_e2i_clvl(TL, #cpu.thread),
+    cput_e2i(TL, Nid, PId, CPU#cpu{thread = T0+1}, #cpu.thread, Lvl, Res);
+cput_e2i({logical, ID}, _Nid, PId, #cpu{processor=P, core=C, thread=T} = CPU,
+	 PLvl, #cpu.logical, Res)
+  when PLvl < #cpu.logical, is_integer(ID), 0 =< ID, ID < 65536 ->
+    [CPU#cpu{processor = case P of -1 -> PId+1; _ -> P end,
+	     core = case C of -1 -> 0; _ -> C end,
+	     thread = case T of -1 -> 0; _ -> T end,
+	     logical = ID} | Res].
+
+%% erlang:format_cpu_topology/1 is for internal use only!
+%%
+%% erlang:system_info(cpu_topology),
+%% and erlang:system_info({cpu_topology, Which}) traps to
+%% erlang:format_cpu_topology(InternalCpuTopology).
+format_cpu_topology(InternalCpuTopology) ->
+    try cput_i2e(InternalCpuTopology)
+    catch _ : _ -> erlang:error(internal_error, [InternalCpuTopology])
+    end.
+
+
+cput_i2e(undefined) -> undefined;
+cput_i2e(Is) -> cput_i2e(Is, true, #cpu.node, cput_i2e_tag_map()).
+
+cput_i2e([], _Frst, _Lvl, _TM) ->
+    [];
+cput_i2e([#cpu{logical = LID}| _], _Frst, Lvl, _TM) when Lvl == #cpu.logical ->
+    {logical, LID};
+cput_i2e([#cpu{} = I | Is], Frst, Lvl, TM) ->
+    cput_i2e(element(Lvl, I), Frst, Is, [I], Lvl, TM).
+
+cput_i2e(V, Frst, [I | Is], SameV, Lvl, TM) when V =:= element(Lvl, I) ->
+    cput_i2e(V, Frst, Is, [I | SameV], Lvl, TM);
+cput_i2e(-1, true, [], SameV, Lvl, TM) ->
+    cput_i2e(rvrs(SameV), true, Lvl+1, TM);
+cput_i2e(_V, true, [], SameV, Lvl, TM) when Lvl =/= #cpu.processor,
+                                            Lvl =/= #cpu.processor_node ->
+    cput_i2e(rvrs(SameV), true, Lvl+1, TM);
+cput_i2e(-1, _Frst, Is, SameV, #cpu.node, TM) ->
+    cput_i2e(rvrs(SameV), true, #cpu.processor, TM)
+	++ cput_i2e(Is, false, #cpu.node, TM);
+cput_i2e(_V, _Frst, Is, SameV, Lvl, TM) ->
+    [{cput_i2e_tag(Lvl, TM), cput_i2e(rvrs(SameV), true, Lvl+1, TM)}
+     | cput_i2e(Is, false, Lvl, TM)].
+
+cput_i2e_tag_map() -> list_to_tuple([cpu | record_info(fields, cpu)]).
+
+cput_i2e_tag(Lvl, TM) ->
+    case element(Lvl, TM) of processor_node -> node; Other -> Other end.
+
+rvrs([_] = L) -> L;
+rvrs(Xs) -> rvrs(Xs, []).
+
+rvrs([],Ys) -> Ys;
+rvrs([X|Xs],Ys) -> rvrs(Xs, [X|Ys]).
+
+%% erlang:await_proc_exit/3 is for internal use only!
+%%
+%% BIFs that need to await a specific process exit before
+%% returning traps to erlang:await_proc_exit/3.
+%%
+%% NOTE: This function is tightly coupled to
+%%       the implementation of the
+%%       erts_bif_prep_await_proc_exit_*()
+%%       functions in bif.c. Do not make
+%%       any changes to it without reading
+%%       the comment about them in bif.c!
+await_proc_exit(Proc, Op, Data) ->
+    Mon = erlang:monitor(process, Proc),
+    receive
+	{'DOWN', Mon, process, _Proc, Reason} ->
+	    case Op of
+		apply ->
+		    {M, F, A} = Data,
+		    erlang:apply(M, F, A);
+		data ->
+		    Data;
+		reason ->
+		    Reason
+	    end
+    end.
+
+min(A, B) when A > B -> B;
+min(A, _) -> A.
+
+max(A, B) when A < B -> B;
+max(A, _) -> A.