aboutsummaryrefslogtreecommitdiffstats
path: root/erts/emulator/test/node_container_SUITE.erl
diff options
context:
space:
mode:
authorErlang/OTP <[email protected]>2009-11-20 14:54:40 +0000
committerErlang/OTP <[email protected]>2009-11-20 14:54:40 +0000
commit84adefa331c4159d432d22840663c38f155cd4c1 (patch)
treebff9a9c66adda4df2106dfd0e5c053ab182a12bd /erts/emulator/test/node_container_SUITE.erl
downloadotp-84adefa331c4159d432d22840663c38f155cd4c1.tar.gz
otp-84adefa331c4159d432d22840663c38f155cd4c1.tar.bz2
otp-84adefa331c4159d432d22840663c38f155cd4c1.zip
The R13B03 release.OTP_R13B03
Diffstat (limited to 'erts/emulator/test/node_container_SUITE.erl')
-rw-r--r--erts/emulator/test/node_container_SUITE.erl1288
1 files changed, 1288 insertions, 0 deletions
diff --git a/erts/emulator/test/node_container_SUITE.erl b/erts/emulator/test/node_container_SUITE.erl
new file mode 100644
index 0000000000..f3d9eb783b
--- /dev/null
+++ b/erts/emulator/test/node_container_SUITE.erl
@@ -0,0 +1,1288 @@
+%%
+%% %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%
+%%
+
+%%%----------------------------------------------------------------------
+%%% File : node_container_SUITE.erl
+%%% Author : Rickard <[email protected]>
+%%% Purpose :
+%%% Created : 24 Jul 2002 by Rickard <[email protected]>
+%%%----------------------------------------------------------------------
+
+-module(node_container_SUITE).
+-author('[email protected]').
+
+%-define(line_trace, 1).
+
+-include("test_server.hrl").
+
+%-compile(export_all).
+-export([all/1, init_per_testcase/2, fin_per_testcase/2, end_per_suite/1,
+ node_container_refc_check/1]).
+
+-export([term_to_binary_to_term_eq/1,
+ round_trip_eq/1,
+ cmp/1,
+ ref_eq/1,
+ node_table_gc/1,
+ dist_link_refc/1,
+ dist_monitor_refc/1,
+ node_controller_refc/1,
+ ets_refc/1,
+ match_spec_refc/1,
+ timer_refc/1,
+ otp_4715/1,
+ pid_wrap/1,
+ port_wrap/1,
+ bad_nc/1,
+ unique_pid/1,
+ iter_max_procs/1]).
+
+-define(DEFAULT_TIMEOUT, ?t:minutes(10)).
+
+all(doc) -> [];
+all(suite) ->
+ [term_to_binary_to_term_eq,
+ round_trip_eq,
+ cmp,
+ ref_eq,
+ node_table_gc,
+ dist_link_refc,
+ dist_monitor_refc,
+ node_controller_refc,
+ ets_refc,
+ match_spec_refc,
+ timer_refc,
+ otp_4715,
+ pid_wrap,
+ port_wrap,
+ bad_nc,
+ unique_pid,
+ iter_max_procs].
+
+available_internal_state(Bool) when Bool == true; Bool == false ->
+ case {Bool,
+ (catch erts_debug:get_internal_state(available_internal_state))} of
+ {true, true} ->
+ true;
+ {false, true} ->
+ erts_debug:set_internal_state(available_internal_state, false),
+ true;
+ {true, _} ->
+ erts_debug:set_internal_state(available_internal_state, true),
+ false;
+ {false, _} ->
+ false
+ end.
+
+init_per_testcase(_Case, Config) when is_list(Config) ->
+ Dog = ?t:timetrap(?DEFAULT_TIMEOUT),
+ available_internal_state(true),
+ [{watchdog, Dog}|Config].
+
+fin_per_testcase(_Case, Config) when is_list(Config) ->
+ Dog = ?config(watchdog, Config),
+ ?t:timetrap_cancel(Dog),
+ ok.
+
+end_per_suite(_Config) ->
+ available_internal_state(false).
+
+%%%
+%%% The test cases -------------------------------------------------------------
+%%%
+
+-define(MAX_PIDS_PORTS, ((1 bsl 28) - 1)).
+
+%%
+%% Test case: term_to_binary_to_term_eq
+%%
+term_to_binary_to_term_eq(doc) ->
+ ["Tests that node container terms that are converted to external format "
+ "and back stay equal to themselves."];
+term_to_binary_to_term_eq(suite) -> [];
+term_to_binary_to_term_eq(Config) when is_list(Config) ->
+ ?line ThisNode = {node(), erlang:system_info(creation)},
+ % Get local node containers
+ ?line LPid = self(),
+ ?line LXPid = mk_pid(ThisNode, 32767, 8191),
+ ?line LPort = hd(erlang:ports()),
+ ?line LXPort = mk_port(ThisNode, 268435455),
+ ?line LLRef = make_ref(),
+ ?line LHLRef = mk_ref(ThisNode, [47, 11]),
+ ?line LSRef = mk_ref(ThisNode, [4711]),
+ % Test local nc:s
+ ?line LPid = binary_to_term(term_to_binary(LPid)),
+ ?line LXPid = binary_to_term(term_to_binary(LXPid)),
+ ?line LPort = binary_to_term(term_to_binary(LPort)),
+ ?line LXPort = binary_to_term(term_to_binary(LXPort)),
+ ?line LLRef = binary_to_term(term_to_binary(LLRef)),
+ ?line LHLRef = binary_to_term(term_to_binary(LHLRef)),
+ ?line LSRef = binary_to_term(term_to_binary(LSRef)),
+ % Get remote node containers
+ ?line RNode = {get_nodename(), 3},
+ ?line RPid = mk_pid(RNode, 4711, 1),
+ ?line RXPid = mk_pid(RNode, 32767, 8191),
+ ?line RPort = mk_port(RNode, 4711),
+ ?line RXPort = mk_port(RNode, 268435455),
+ ?line RLRef = mk_ref(RNode, [4711, 4711, 4711]),
+ ?line RHLRef = mk_ref(RNode, [4711, 4711]),
+ ?line RSRef = mk_ref(RNode, [4711]),
+ % Test remote nc:s
+ ?line RPid = binary_to_term(term_to_binary(RPid)),
+ ?line RXPid = binary_to_term(term_to_binary(RXPid)),
+ ?line RPort = binary_to_term(term_to_binary(RPort)),
+ ?line RXPort = binary_to_term(term_to_binary(RXPort)),
+ ?line RLRef = binary_to_term(term_to_binary(RLRef)),
+ ?line RHLRef = binary_to_term(term_to_binary(RHLRef)),
+ ?line RSRef = binary_to_term(term_to_binary(RSRef)),
+ ?line nc_refc_check(node()),
+ ?line ok.
+
+
+%%
+%% Test case: round_trip_eq
+%%
+round_trip_eq(doc) ->
+ ["Tests that node containers that are sent beteen nodes stay equal to "
+ "themselves."];
+round_trip_eq(suite) -> [];
+round_trip_eq(Config) when is_list(Config) ->
+ ?line ThisNode = {node(), erlang:system_info(creation)},
+ ?line NodeFirstName = get_nodefirstname(),
+ ?line ?line {ok, Node} = start_node(NodeFirstName),
+ ?line Self = self(),
+ ?line RPid = spawn_link(Node,
+ fun () ->
+ receive
+ {Self, Data} ->
+ Self ! {self(), Data}
+ end
+ end),
+ ?line SentPid = self(),
+ ?line SentXPid = mk_pid(ThisNode, 17471, 8190),
+ ?line SentPort = hd(erlang:ports()),
+ ?line SentXPort = mk_port(ThisNode, 268435451),
+ ?line SentLRef = make_ref(),
+ ?line SentHLRef = mk_ref(ThisNode, [4711, 17]),
+ ?line SentSRef = mk_ref(ThisNode, [4711]),
+ ?line RPid ! {Self, {SentPid,
+ SentXPid,
+ SentPort,
+ SentXPort,
+ SentLRef,
+ SentHLRef,
+ SentSRef}},
+ receive
+ {RPid, {RecPid,
+ RecXPid,
+ RecPort,
+ RecXPort,
+ RecLRef,
+ RecHLRef,
+ RecSRef}} ->
+ ?line stop_node(Node),
+ ?line SentPid = RecPid,
+ ?line SentXPid = RecXPid,
+ ?line SentPort = RecPort,
+ ?line SentXPort = RecXPort,
+ ?line SentLRef = RecLRef,
+ ?line SentHLRef = RecHLRef,
+ ?line SentSRef = RecSRef,
+ ?line nc_refc_check(node()),
+ ?line ok
+ end.
+
+
+
+%%
+%% Test case: cmp
+%%
+cmp(doc) ->
+ ["Tests that Erlang term comparison works as it should on node "
+ "containers."];
+cmp(suite) -> [];
+cmp(Config) when is_list(Config) ->
+
+ %% Inter type comparison ---------------------------------------------------
+
+ %% The Erlang term order:
+ %% number < atom < ref < fun < port < pid < tuple < nil < cons < binary
+ RNode = {get_nodename(), 2},
+
+ IRef = make_ref(),
+ ERef = mk_ref({get_nodename(), 2}, [1,2,3]),
+
+ IPid = self(),
+ EPid = mk_pid(RNode, 1, 2),
+
+ IPort = hd(erlang:ports()),
+ EPort = mk_port(RNode, 1),
+
+ %% Test pids ----------------------------------------------------
+ ?line true = 1 < IPid,
+ ?line true = 1.3 < IPid,
+ ?line true = (1 bsl 64) < IPid,
+ ?line true = an_atom < IPid,
+ ?line true = IRef < IPid,
+ ?line true = ERef < IPid,
+ ?line true = fun () -> a_fun end < IPid,
+ ?line true = IPort < IPid,
+ ?line true = EPort < IPid,
+ ?line true = IPid < {a, tuple},
+ ?line true = IPid < [],
+ ?line true = IPid < [a|cons],
+ ?line true = IPid < <<"a binary">>,
+
+ ?line true = 1 < EPid,
+ ?line true = 1.3 < EPid,
+ ?line true = (1 bsl 64) < EPid,
+ ?line true = an_atom < EPid,
+ ?line true = IRef < EPid,
+ ?line true = ERef < EPid,
+ ?line true = fun () -> a_fun end < EPid,
+ ?line true = IPort < EPid,
+ ?line true = EPort < EPid,
+ ?line true = EPid < {a, tuple},
+ ?line true = EPid < [],
+ ?line true = EPid < [a|cons],
+ ?line true = EPid < <<"a binary">>,
+
+ %% Test ports --------------------------------------------------
+ ?line true = 1 < IPort,
+ ?line true = 1.3 < IPort,
+ ?line true = (1 bsl 64) < IPort,
+ ?line true = an_atom < IPort,
+ ?line true = IRef < IPort,
+ ?line true = ERef < IPort,
+ ?line true = fun () -> a_fun end < IPort,
+ ?line true = IPort < IPid,
+ ?line true = IPort < EPid,
+ ?line true = IPort < {a, tuple},
+ ?line true = IPort < [],
+ ?line true = IPort < [a|cons],
+ ?line true = IPort < <<"a binary">>,
+
+ ?line true = 1 < EPort,
+ ?line true = 1.3 < EPort,
+ ?line true = (1 bsl 64) < EPort,
+ ?line true = an_atom < EPort,
+ ?line true = IRef < EPort,
+ ?line true = ERef < EPort,
+ ?line true = fun () -> a_fun end < EPort,
+ ?line true = EPort < IPid,
+ ?line true = EPort < EPid,
+ ?line true = EPort < {a, tuple},
+ ?line true = EPort < [],
+ ?line true = EPort < [a|cons],
+ ?line true = EPort < <<"a binary">>,
+
+ %% Test refs ----------------------------------------------------
+ ?line true = 1 < IRef,
+ ?line true = 1.3 < IRef,
+ ?line true = (1 bsl 64) < IRef,
+ ?line true = an_atom < IRef,
+ ?line true = IRef < fun () -> a_fun end,
+ ?line true = IRef < IPort,
+ ?line true = IRef < EPort,
+ ?line true = IRef < IPid,
+ ?line true = IRef < EPid,
+ ?line true = IRef < {a, tuple},
+ ?line true = IRef < [],
+ ?line true = IRef < [a|cons],
+ ?line true = IRef < <<"a binary">>,
+
+ ?line true = 1 < ERef,
+ ?line true = 1.3 < ERef,
+ ?line true = (1 bsl 64) < ERef,
+ ?line true = an_atom < ERef,
+ ?line true = ERef < fun () -> a_fun end,
+ ?line true = ERef < IPort,
+ ?line true = ERef < EPort,
+ ?line true = ERef < IPid,
+ ?line true = ERef < EPid,
+ ?line true = ERef < {a, tuple},
+ ?line true = ERef < [],
+ ?line true = ERef < [a|cons],
+ ?line true = ERef < <<"a binary">>,
+
+
+ %% Intra type comparison ---------------------------------------------------
+
+
+ %% Test pids ----------------------------------------------------
+ %%
+ %% Significance (most -> least):
+ %% serial, number, nodename, creation
+ %%
+
+ ?line Pid = mk_pid({b@b, 2}, 4711, 1),
+
+ ?line true = mk_pid({a@b, 1}, 4710, 2) > Pid,
+ ?line true = mk_pid({a@b, 1}, 4712, 1) > Pid,
+ ?line true = mk_pid({c@b, 1}, 4711, 1) > Pid,
+ ?line true = mk_pid({b@b, 3}, 4711, 1) > Pid,
+ ?line true = mk_pid({b@b, 2}, 4711, 1) =:= Pid,
+
+ %% Test ports ---------------------------------------------------
+ %%
+ %% Significance (most -> least):
+ %% nodename, creation, number
+ %%
+ %% OBS: Comparison between ports has changed in R9. This
+ %% since it wasn't stable in R8 (and eariler releases).
+ %% Significance used to be: dist_slot, number,
+ %% creation.
+
+ ?line Port = mk_port({b@b, 2}, 4711),
+
+ ?line true = mk_port({c@b, 1}, 4710) > Port,
+ ?line true = mk_port({b@b, 3}, 4710) > Port,
+ ?line true = mk_port({b@b, 2}, 4712) > Port,
+ ?line true = mk_port({b@b, 2}, 4711) =:= Port,
+
+ %% Test refs ----------------------------------------------------
+ %% Significance (most -> least):
+ %% nodename, creation, (number high, number mid), number low,
+ %%
+ %% OBS: Comparison between refs has changed in R9. This
+ %% since it wasn't stable in R8 (and eariler releases).
+ %% Significance used to be: dist_slot, number,
+ %% creation.
+ %%
+
+ ?line Ref = mk_ref({b@b, 2}, [4711, 4711, 4711]),
+
+ ?line true = mk_ref({c@b, 1}, [4710, 4710, 4710]) > Ref,
+ ?line true = mk_ref({b@b, 3}, [4710, 4710, 4710]) > Ref,
+ ?line true = mk_ref({b@b, 2}, [4710, 4710, 4712]) > Ref,
+ ?line true = mk_ref({b@b, 2}, [4710, 4712, 4711]) > Ref,
+ ?line true = mk_ref({b@b, 2}, [4712, 4711, 4711]) > Ref,
+ ?line true = mk_ref({b@b, 2}, [4711, 4711, 4711]) =:= Ref,
+
+ ok.
+
+%%
+%% Test case: ref_eq
+%%
+ref_eq(doc) -> ["Test that one word refs \"works\"."];
+ref_eq(suite) -> [];
+ref_eq(Config) when is_list(Config) ->
+ ?line ThisNode = {node(), erlang:system_info(creation)},
+ ?line AnotherNode = {get_nodename(),2},
+ ?line LLongRef = mk_ref(ThisNode, [4711, 0, 0]),
+ ?line LHalfLongRef = mk_ref(ThisNode, [4711, 0]),
+ ?line LShortRef = mk_ref(ThisNode, [4711]),
+ ?line true = LLongRef =:= LShortRef,
+ ?line true = LLongRef =:= LHalfLongRef,
+ ?line true = LLongRef =:= LLongRef,
+ ?line true = LHalfLongRef =:= LShortRef,
+ ?line true = LHalfLongRef =:= LHalfLongRef,
+ ?line true = LShortRef =:= LShortRef,
+ ?line false = LShortRef == mk_ref(ThisNode, [4711, 0, 1]), % Not any more
+ ?line RLongRef = mk_ref(AnotherNode, [4711, 0, 0]),
+ ?line RHalfLongRef = mk_ref(AnotherNode, [4711, 0]),
+ ?line RShortRef = mk_ref(AnotherNode, [4711]),
+ ?line true = RLongRef =:= RShortRef,
+ ?line true = RLongRef =:= RHalfLongRef,
+ ?line true = RLongRef =:= RLongRef,
+ ?line true = RHalfLongRef =:= RShortRef,
+ ?line true = RHalfLongRef =:= RHalfLongRef,
+ ?line true = RShortRef =:= RShortRef,
+ ?line false = RShortRef == mk_ref(AnotherNode, [4711, 0, 1]), % Not any more
+ ?line nc_refc_check(node()),
+ ?line ok.
+
+%%
+%% Test case: node_table_gc
+%%
+node_table_gc(doc) ->
+ ["Tests that node tables are garbage collected."];
+node_table_gc(suite) -> [];
+node_table_gc(Config) when is_list(Config) ->
+ ?line PreKnown = nodes(known),
+ ?line ?t:format("PreKnown = ~p~n", [PreKnown]),
+ ?line make_node_garbage(0, 200000, 1000, []),
+ ?line PostKnown = nodes(known),
+ ?line PostAreas = erlang:system_info(allocated_areas),
+ ?line ?t:format("PostKnown = ~p~n", [PostKnown]),
+ ?line ?t:format("PostAreas = ~p~n", [PostAreas]),
+ ?line true = length(PostKnown) =< length(PreKnown),
+ ?line nc_refc_check(node()),
+ ?line ok.
+
+make_node_garbage(N, L, I, Ps) when N < L ->
+ ?line Self = self(),
+ ?line P = spawn_link(fun () ->
+ % Generate two node entries and one dist
+ % entry per node name
+ ?line PL1 = make_faked_pid_list(N,
+ I div 2,
+ 1),
+ ?line put(a, PL1),
+ ?line PL2 = make_faked_pid_list(N,
+ I div 2,
+ 2),
+ ?line put(b, PL2),
+ ?line Self ! {self(), length(nodes(known))}
+ end),
+ ?line receive
+ {P, KnownLength} ->
+ ?line true = KnownLength >= I div 2
+ end,
+ ?line make_node_garbage(N+(I div 2)*2, L, I, [P|Ps]);
+make_node_garbage(_, _, _, Ps) ->
+ %% Cleanup garbage...
+ ProcIsCleanedUp
+ = fun (Proc) ->
+ undefined == erts_debug:get_internal_state({process_status,
+ Proc})
+ end,
+ lists:foreach(fun (P) -> wait_until(fun () -> ProcIsCleanedUp(P) end) end,
+ Ps),
+ ?line case erlang:system_info(heap_type) of
+ shared -> ?line garbage_collect();
+ _ -> ?line ok
+ end,
+ ?line ok.
+
+
+make_faked_pid_list(Start, No, Creation) ->
+ make_faked_pid_list(Start, No, Creation, []).
+
+make_faked_pid_list(_Start, 0, _Creation, Acc) ->
+ Acc;
+make_faked_pid_list(Start, No, Creation, Acc) ->
+ make_faked_pid_list(Start+1,
+ No-1,
+ Creation,
+ [mk_pid({"faked_node-"
+ ++ integer_to_list(Start rem 50000)
+ ++ "@"
+ ++ atom_to_list(?MODULE),
+ Creation},
+ 4711,
+ 3) | Acc]).
+
+%%
+%% Test case: dist_link_refc
+%%
+dist_link_refc(doc) ->
+ ["Tests that external reference counts are incremented and decremented "
+ "as they should for distributed links"];
+dist_link_refc(suite) -> [];
+dist_link_refc(Config) when is_list(Config) ->
+ ?line NodeFirstName = get_nodefirstname(),
+ ?line ?line {ok, Node} = start_node(NodeFirstName),
+ ?line RP = spawn_execer(Node),
+ ?line LP = spawn_link_execer(node()),
+ ?line true = sync_exec(RP, fun () -> link(LP) end),
+ ?line wait_until(fun () ->
+ ?line {links, Links} = process_info(LP, links),
+ ?line lists:member(RP, Links)
+ end),
+ ?line NodeCre = sync_exec(RP, fun() -> erlang:system_info(creation) end),
+ ?line 1 = reference_type_count(
+ link,
+ refering_entity_id({process, LP},
+ get_node_references({Node, NodeCre}))),
+ ?line exec(RP, fun() -> exit(normal) end),
+ ?line wait_until(fun () ->
+ ?line {links, Links} = process_info(LP, links),
+ ?line not lists:member(RP, Links)
+ end),
+ ?line 0 = reference_type_count(
+ link,
+ refering_entity_id({process, LP},
+ get_node_references({Node, NodeCre}))),
+ ?line exit(LP, normal),
+ ?line stop_node(Node),
+ ?line nc_refc_check(node()),
+ ?line ok.
+
+
+%%
+%% Test case: dist_monitor_refc
+%%
+dist_monitor_refc(doc) ->
+ ["Tests that external reference counts are incremented and decremented "
+ "as they should for distributed monitors"];
+dist_monitor_refc(suite) -> [];
+dist_monitor_refc(Config) when is_list(Config) ->
+ ?line NodeFirstName = get_nodefirstname(),
+ ?line {ok, Node} = start_node(NodeFirstName),
+ ?line RP = spawn_execer(Node),
+ ?line LP = spawn_link_execer(node()),
+ ?line RMon = sync_exec(RP, fun () -> erlang:monitor(process, LP) end),
+ ?line true = is_reference(RMon),
+ ?line LMon = sync_exec(LP, fun () -> erlang:monitor(process, RP) end),
+ ?line true = is_reference(LMon),
+ ?line NodeCre = sync_exec(RP, fun() -> erlang:system_info(creation) end),
+ ?line wait_until(fun () ->
+ ?line {monitored_by, MonBy}
+ = process_info(LP, monitored_by),
+ ?line {monitors, Mon}
+ = process_info(LP, monitors),
+ ?line (lists:member(RP, MonBy)
+ and lists:member({process,RP}, Mon))
+ end),
+ ?line 3 = reference_type_count(
+ monitor,
+ refering_entity_id({process, LP},
+ get_node_references({Node, NodeCre}))),
+ ?line exec(RP, fun () -> exit(normal) end),
+ ?line wait_until(fun () ->
+ ?line {monitored_by, MonBy}
+ = process_info(LP, monitored_by),
+ ?line {monitors, Mon}
+ = process_info(LP, monitors),
+ ?line ((not lists:member(RP, MonBy))
+ and (not lists:member({process,RP}, Mon)))
+ end),
+ ?line ok = sync_exec(LP,
+ fun () ->
+ receive
+ {'DOWN', LMon, process, _, _} ->
+ ok
+ end
+ end),
+ ?line 0 = reference_type_count(
+ link,
+ refering_entity_id({process, LP},
+ get_node_references({Node, NodeCre}))),
+ ?line exit(LP, normal),
+ ?line stop_node(Node),
+ ?line nc_refc_check(node()),
+ ?line ok.
+
+
+%%
+%% Test case: node_controller_refc
+%%
+node_controller_refc(doc) ->
+ ["Tests that external reference counts are incremented and decremented "
+ "as they should for entities controlling a connections."];
+node_controller_refc(suite) -> [];
+node_controller_refc(Config) when is_list(Config) ->
+ ?line NodeFirstName = get_nodefirstname(),
+ ?line ?line {ok, Node} = start_node(NodeFirstName),
+ ?line true = lists:member(Node, nodes()),
+ ?line 1 = reference_type_count(control, get_dist_references(Node)),
+ ?line P = spawn_link_execer(node()),
+ ?line Node
+ = sync_exec(P,
+ fun () ->
+ put(remote_net_kernel,
+ rpc:call(Node,erlang,whereis,[net_kernel])),
+ node(get(remote_net_kernel))
+ end),
+ ?line Creation = rpc:call(Node, erlang, system_info, [creation]),
+ ?line monitor_node(Node,true),
+ ?line stop_node(Node),
+ ?line receive {nodedown, Node} -> ok end,
+ ?line DistRefs = get_dist_references(Node),
+ ?line true = reference_type_count(node, DistRefs) > 0,
+ ?line 0 = reference_type_count(control, DistRefs),
+ % Get rid of all references to Node
+ ?line exec(P, fun () -> exit(normal) end),
+ ?line wait_until(fun () -> not is_process_alive(P) end),
+ ?line case erlang:system_info(heap_type) of
+ shared ->
+ ?line garbage_collect();
+ hybrid ->
+ ?line lists:foreach(fun (Proc) -> garbage_collect(Proc) end,
+ processes()),
+ ?line erlang:garbage_collect_message_area();
+ _ ->
+ ?line lists:foreach(fun (Proc) -> garbage_collect(Proc) end,
+ processes())
+ end,
+ ?line false = get_node_references({Node,Creation}),
+ ?line false = get_dist_references(Node),
+ ?line false = lists:member(Node, nodes(known)),
+ ?line nc_refc_check(node()),
+ ?line ok.
+
+%%
+%% Test case: ets_refc
+%%
+ets_refc(doc) ->
+ ["Tests that external reference counts are incremented and decremented "
+ "as they should for data stored in ets tables."];
+ets_refc(suite) -> [];
+ets_refc(Config) when is_list(Config) ->
+ ?line RNode = {get_nodename(), 1},
+ ?line RPid = mk_pid(RNode, 4711, 2),
+ ?line RPort = mk_port(RNode, 4711),
+ ?line RRef = mk_ref(RNode, [4711, 47, 11]),
+ ?line Tab = ets:new(ets_refc, []),
+ ?line 0 = reference_type_count(ets, get_node_references(RNode)),
+ ?line true = ets:insert(Tab, [{a, self()},
+ {b, RPid},
+ {c, hd(erlang:ports())},
+ {d, RPort},
+ {e, make_ref()}]),
+ ?line 2 = reference_type_count(ets, get_node_references(RNode)),
+ ?line true = ets:insert(Tab, {f, RRef}),
+ ?line 3 = reference_type_count(ets, get_node_references(RNode)),
+ ?line true = ets:delete(Tab, d),
+ ?line 2 = reference_type_count(ets, get_node_references(RNode)),
+ ?line true = ets:delete_all_objects(Tab),
+ ?line 0 = reference_type_count(ets, get_node_references(RNode)),
+ ?line true = ets:insert(Tab, [{b, RPid}, {e, make_ref()}]),
+ ?line 1 = reference_type_count(ets, get_node_references(RNode)),
+ ?line true = ets:delete(Tab),
+ ?line 0 = reference_type_count(ets, get_node_references(RNode)),
+ ?line nc_refc_check(node()),
+ ?line ok.
+
+%%
+%% Test case: match_spec_refc
+%%
+match_spec_refc(doc) ->
+ ["Tests that external reference counts are incremented and decremented "
+ "as they should for data stored in match specifications."];
+match_spec_refc(suite) -> [];
+match_spec_refc(Config) when is_list(Config) ->
+ ?line RNode = {get_nodename(), 1},
+ ?line RPid = mk_pid(RNode, 4711, 2),
+ ?line RPort = mk_port(RNode, 4711),
+ ?line RRef = mk_ref(RNode, [4711, 47, 11]),
+ ?line ok = do_match_spec_test(RNode, RPid, RPort, RRef),
+ ?line garbage_collect(),
+ ?line NodeRefs = get_node_references(RNode),
+ ?line 0 = reference_type_count(binary, NodeRefs),
+ ?line 0 = reference_type_count(ets, NodeRefs),
+ ?line nc_refc_check(node()),
+ ?line ok.
+
+do_match_spec_test(RNode, RPid, RPort, RRef) ->
+ ?line Tab = ets:new(match_spec_refc, []),
+ ?line true = ets:insert(Tab, [{a, RPid, RPort, RRef},
+ {b, self(), RPort, RRef},
+ {c, RPid, RPort, make_ref()},
+ {d, RPid, RPort, RRef}]),
+ ?line {M1, C1} = ets:select(Tab, [{{'$1',RPid,RPort,RRef},[],['$1']}], 1),
+ ?line NodeRefs = get_node_references(RNode),
+ ?line 3 = reference_type_count(binary, NodeRefs),
+ ?line 10 = reference_type_count(ets, NodeRefs),
+ ?line {M2, C2} = ets:select(C1),
+ ?line '$end_of_table' = ets:select(C2),
+ ?line ets:delete(Tab),
+ ?line [a,d] = lists:sort(M1++M2),
+ ?line ok.
+
+
+%%
+%% Test case: ets_refc
+%%
+timer_refc(doc) ->
+ ["Tests that external reference counts are incremented and decremented "
+ "as they should for data stored in bif timers."];
+timer_refc(suite) -> [];
+timer_refc(Config) when is_list(Config) ->
+ ?line RNode = {get_nodename(), 1},
+ ?line RPid = mk_pid(RNode, 4711, 2),
+ ?line RPort = mk_port(RNode, 4711),
+ ?line RRef = mk_ref(RNode, [4711, 47, 11]),
+ ?line 0 = reference_type_count(timer, get_node_references(RNode)),
+ ?line Pid = spawn(fun () -> receive after infinity -> ok end end),
+ ?line erlang:start_timer(10000, Pid, {RPid, RPort, RRef}),
+ ?line 3 = reference_type_count(timer, get_node_references(RNode)),
+ ?line exit(Pid, kill),
+ ?line Mon = erlang:monitor(process, Pid),
+ ?line receive {'DOWN', Mon, process, Pid, _} -> ok end,
+ ?line 0 = reference_type_count(timer, get_node_references(RNode)),
+ ?line erlang:send_after(500, Pid, {timer, RPid, RPort, RRef}),
+ ?line 0 = reference_type_count(timer, get_node_references(RNode)),
+ ?line erlang:send_after(500, self(), {timer, RPid, RPort, RRef}),
+ ?line erlang:send_after(400, bananfluga, {timer, RPid, RPort, RRef}),
+ ?line 6 = reference_type_count(timer, get_node_references(RNode)),
+ ?line receive {timer, RPid, RPort, RRef} -> ok end,
+ ?line 0 = reference_type_count(timer, get_node_references(RNode)),
+ ?line nc_refc_check(node()),
+ ?line ok.
+
+otp_4715(doc) -> [];
+otp_4715(suite) -> [];
+otp_4715(Config) when is_list(Config) ->
+ case ?t:is_release_available("r9b") of
+ true -> otp_4715_1(Config);
+ false -> {skip,"No R9B found"}
+ end.
+
+otp_4715_1(Config) ->
+ case erlang:system_info(compat_rel) of
+ 9 ->
+ ?line run_otp_4715(Config);
+ _ ->
+ ?line Pa = filename:dirname(code:which(?MODULE)),
+ ?line ?t:run_on_shielded_node(fun () ->
+ run_otp_4715(Config)
+ end,
+ "+R9 -pa " ++ Pa)
+ end.
+
+run_otp_4715(Config) when is_list(Config) ->
+ ?line erts_debug:set_internal_state(available_internal_state, true),
+ ?line PidList = [mk_pid({a@b, 1}, 4710, 2),
+ mk_pid({a@b, 1}, 4712, 1),
+ mk_pid({c@b, 1}, 4711, 1),
+ mk_pid({b@b, 3}, 4711, 1),
+ mk_pid({b@b, 2}, 4711, 1)],
+
+ ?line R9Sorted = old_mod:sort_on_old_node(PidList),
+ ?line R9Sorted = lists:sort(PidList).
+
+pid_wrap(doc) -> [];
+pid_wrap(suite) -> [];
+pid_wrap(Config) when is_list(Config) -> ?line pp_wrap(pid).
+
+port_wrap(doc) -> [];
+port_wrap(suite) -> [];
+port_wrap(Config) when is_list(Config) ->
+ ?line case ?t:os_type() of
+ {unix, _} ->
+ ?line pp_wrap(port);
+ _ ->
+ ?line {skip, "Only run on unix"}
+ end.
+
+get_next_id(pid) ->
+ erts_debug:get_internal_state(next_pid);
+get_next_id(port) ->
+ erts_debug:get_internal_state(next_port).
+
+set_next_id(pid, N) ->
+ erts_debug:set_internal_state(next_pid, N);
+set_next_id(port, N) ->
+ erts_debug:set_internal_state(next_port, N).
+
+pp_wrap(What) ->
+ ?line N = set_high_pp_next(What),
+ ?line Cre = N + 100,
+ ?line ?t:format("no creations = ~p~n", [Cre]),
+ ?line PreCre = get_next_id(What),
+ ?line ?t:format("pre creations = ~p~n", [PreCre]),
+ ?line true = is_integer(PreCre),
+ ?line do_pp_creations(What, Cre),
+ ?line PostCre = get_next_id(What),
+ ?line ?t:format("post creations = ~p~n", [PostCre]),
+ ?line true = is_integer(PostCre),
+ ?line true = PreCre > PostCre,
+ ?line Now = set_next_id(What, ?MAX_PIDS_PORTS div 2),
+ ?line ?t:format("reset to = ~p~n", [Now]),
+ ?line true = is_integer(Now),
+ ?line ok.
+
+set_high_pp_next(What) ->
+ ?line set_high_pp_next(What, ?MAX_PIDS_PORTS-1).
+
+set_high_pp_next(What, N) ->
+ ?line M = set_next_id(What, N),
+ ?line true = is_integer(M),
+ ?line case {M >= N, M =< ?MAX_PIDS_PORTS} of
+ {true, true} ->
+ ?line ?MAX_PIDS_PORTS - M + 1;
+ _ ->
+ ?line set_high_pp_next(What, N - 100)
+ end.
+
+do_pp_creations(_What, N) when is_integer(N), N =< 0 ->
+ ?line done;
+do_pp_creations(pid, N) when is_integer(N) ->
+ %% Create new pid and make sure it works...
+ ?line Me = self(),
+ ?line Ref = make_ref(),
+ ?line Pid = spawn_link(fun () ->
+ receive
+ Ref ->
+ Me ! Ref
+ end
+ end),
+ ?line Pid ! Ref,
+ ?line receive
+ Ref ->
+ ?line do_pp_creations(pid, N - 1)
+ end;
+do_pp_creations(port, N) when is_integer(N) ->
+ %% Create new port and make sure it works...
+ ?line "hej" = os:cmd("echo hej") -- "\n",
+ ?line do_pp_creations(port, N - 1).
+
+bad_nc(doc) -> [];
+bad_nc(suite) -> [];
+bad_nc(Config) when is_list(Config) ->
+ % Make sure emulator don't crash on bad node containers...
+ ?line MaxPidNum = (1 bsl 15) - 1,
+ ?line MaxPidSer = ?MAX_PIDS_PORTS bsr 15,
+ ?line ThisNode = {node(), erlang:system_info(creation)},
+ ?line {'EXIT', {badarg, mk_pid, _}}
+ = (catch mk_pid(ThisNode, MaxPidNum + 1, 17)),
+ ?line {'EXIT', {badarg, mk_pid, _}}
+ = (catch mk_pid(ThisNode, 4711, MaxPidSer + 1)),
+ ?line {'EXIT', {badarg, mk_port, _}}
+ = (catch mk_port(ThisNode, ?MAX_PIDS_PORTS + 1)),
+ ?line {'EXIT', {badarg, mk_ref, _}}
+ = (catch mk_ref(ThisNode,[(1 bsl 18), 4711, 4711])),
+ ?line {'EXIT', {badarg, mk_ref, _}}
+ = (catch mk_ref(ThisNode, [4711, 4711, 4711, 4711, 4711, 4711, 4711])),
+ ?line RemNode = {x@y, 2},
+ ?line {'EXIT', {badarg, mk_pid, _}}
+ = (catch mk_pid(RemNode, MaxPidNum + 1, MaxPidSer)),
+ ?line {'EXIT', {badarg, mk_pid, _}}
+ = (catch mk_pid(RemNode, MaxPidNum, MaxPidSer + 1)),
+ ?line {'EXIT', {badarg, mk_port, _}}
+ = (catch mk_port(RemNode, ?MAX_PIDS_PORTS + 1)),
+ ?line {'EXIT', {badarg, mk_ref, _}}
+ = (catch mk_ref(RemNode, [(1 bsl 18), 4711, 4711])),
+ ?line {'EXIT', {badarg, mk_ref, _}}
+ = (catch mk_ref(RemNode, [4711, 4711, 4711, 4711, 4711, 4711, 4711])),
+ ?line BadNode = {x@y, 4},
+ ?line {'EXIT', {badarg, mk_pid, _}}
+ = (catch mk_pid(BadNode, 4711, 17)),
+ ?line {'EXIT', {badarg, mk_port, _}}
+ = (catch mk_port(BadNode, 4711)),
+ ?line {'EXIT', {badarg, mk_ref, _}}
+ = (catch mk_ref(BadNode, [4711, 4711, 17])),
+ ?line ok.
+
+
+
+-define(NO_PIDS, 1000000).
+
+unique_pid(doc) -> [];
+unique_pid(suite) -> [];
+unique_pid(Config) when is_list(Config) ->
+ case catch erlang:system_info(modified_timing_level) of
+ Level when is_integer(Level) ->
+ {skip,
+ "Modified timing (level " ++ integer_to_list(Level)
+ ++ ") is enabled. spawn() is too slow for this "
+ " test when modified timing is enabled."};
+ _ ->
+ ?line ?NO_PIDS = length(lists:usort(mkpidlist(?NO_PIDS, []))),
+ ?line ok
+ end.
+
+mkpidlist(0, Ps) -> Ps;
+mkpidlist(N, Ps) -> mkpidlist(N-1, [spawn(fun () -> ok end)|Ps]).
+
+
+iter_max_procs(doc) -> [];
+iter_max_procs(suite) -> [];
+iter_max_procs(Config) when is_list(Config) ->
+ ?line NoMoreTests = make_ref(),
+ ?line erlang:send_after(10000, self(), NoMoreTests),
+ ?line Res = chk_max_proc_line(),
+ ?line Res = chk_max_proc_line(),
+ ?line done = chk_max_proc_line_until(NoMoreTests, Res),
+ ?line {comment,
+ io_lib:format("max processes = ~p; "
+ "process line length = ~p",
+ [element(2, Res), element(1, Res)])}.
+
+
+max_proc_line(Root, Parent, N) ->
+ Me = self(),
+ case catch spawn_link(fun () -> max_proc_line(Root, Me, N+1) end) of
+ {'EXIT', {system_limit, _}} when Root /= self() ->
+ Root ! {proc_line_length, N, self()},
+ receive remove_proc_line -> Parent ! {exiting, Me} end;
+ P when is_pid(P), Root =/= self() ->
+ receive {exiting, P} -> Parent ! {exiting, Me} end;
+ P when is_pid(P) ->
+ P;
+ Unexpected ->
+ exit({unexpected_spawn_result, Unexpected})
+ end.
+
+chk_max_proc_line() ->
+ ?line Child = max_proc_line(self(), self(), 0),
+ ?line receive
+ {proc_line_length, PLL, End} ->
+ ?line PC = erlang:system_info(process_count),
+ ?line LP = length(processes()),
+ ?line ?t:format("proc line length = ~p; "
+ "process count = ~p; "
+ "length processes = ~p~n",
+ [PLL, PC, LP]),
+ ?line End ! remove_proc_line,
+ ?line PC = LP,
+ ?line receive {exiting, Child} -> ok end,
+ ?line {PLL, PC}
+ end.
+
+chk_max_proc_line_until(NoMoreTests, Res) ->
+ receive
+ NoMoreTests ->
+ ?line done
+ after 0 ->
+ ?line Res = chk_max_proc_line(),
+ ?line chk_max_proc_line_until(NoMoreTests, Res)
+ end.
+
+%%
+%% -- Internal utils ---------------------------------------------------------
+%%
+
+-define(ND_REFS, erts_debug:get_internal_state(node_and_dist_references)).
+
+node_container_refc_check(Node) when is_atom(Node) ->
+ AIS = available_internal_state(true),
+ nc_refc_check(Node),
+ available_internal_state(AIS).
+
+nc_refc_check(Node) when is_atom(Node) ->
+ Ref = make_ref(),
+ Self = self(),
+ ?t:format("Starting reference count check of node ~w~n", [Node]),
+ spawn_link(Node,
+ fun () ->
+ {{node_references, NodeRefs},
+ {dist_references, DistRefs}} = ?ND_REFS,
+ check_nd_refc({node(), erlang:system_info(creation)},
+ NodeRefs,
+ DistRefs,
+ fun (ErrMsg) ->
+ Self ! {Ref, ErrMsg, failed},
+ exit(normal)
+ end),
+ Self ! {Ref, succeded}
+ end),
+ receive
+ {Ref, ErrorMsg, failed} ->
+ ?t:format("~s~n", [ErrorMsg]),
+ ?t:fail(reference_count_check_failed);
+ {Ref, succeded} ->
+ ?t:format("Reference count check of node ~w succeded!~n", [Node]),
+ ok
+ end.
+
+check_nd_refc({ThisNodeName, ThisCreation}, NodeRefs, DistRefs, Fail) ->
+ case catch begin
+ check_refc(ThisNodeName,ThisCreation,"node table",NodeRefs),
+ check_refc(ThisNodeName,ThisCreation,"dist table",DistRefs),
+ ok
+ end of
+ ok ->
+ ok;
+ {'EXIT', Reason} ->
+ {Y,Mo,D} = date(),
+ {H,Mi,S} = time(),
+ ErrMsg = io_lib:format("~n"
+ "*** Reference count check of node ~w "
+ "failed (~p) at ~w~w~w ~w:~w:~w~n"
+ "*** Node table references:~n ~p~n"
+ "*** Dist table references:~n ~p~n",
+ [node(), Reason, Y, Mo, D, H, Mi, S,
+ NodeRefs, DistRefs]),
+ Fail(lists:flatten(ErrMsg))
+ end.
+
+
+check_refc(ThisNodeName,ThisCreation,Table,EntryList) when is_list(EntryList) ->
+ lists:foreach(
+ fun ({Entry, Refc, ReferrerList}) ->
+ FoundRefs =
+ lists:foldl(
+ fun ({_Referrer, ReferencesList}, A1) ->
+ A1 + lists:foldl(fun ({_T,Rs},A2) ->
+ A2+Rs
+ end,
+ 0,
+ ReferencesList)
+ end,
+ 0,
+ ReferrerList),
+
+ %% Reference count equals found references ?
+ case Refc =:= FoundRefs of
+ true ->
+ ok;
+ false ->
+ exit({invalid_reference_count, Table, Entry})
+ end,
+
+ %% All entries in table referred to?
+ case {Entry, Refc} of
+ {ThisNodeName, 0} -> ok;
+ {{ThisNodeName, ThisCreation}, 0} -> ok;
+ {_, 0} -> exit({not_referred_entry_in_table, Table, Entry});
+ {_, _} -> ok
+ end
+
+ end,
+ EntryList),
+ ok.
+
+get_node_references({NodeName, Creation} = Node) when is_atom(NodeName),
+ is_integer(Creation) ->
+ {{node_references, NodeRefs},
+ {dist_references, DistRefs}} = ?ND_REFS,
+ check_nd_refc({node(), erlang:system_info(creation)},
+ NodeRefs,
+ DistRefs,
+ fun (ErrMsg) ->
+ ?t:format("~s", [ErrMsg]),
+ ?t:fail(reference_count_check_failed)
+ end),
+ find_references(Node, NodeRefs).
+
+get_dist_references(NodeName) when is_atom(NodeName) ->
+ ?line {{node_references, NodeRefs},
+ {dist_references, DistRefs}} = ?ND_REFS,
+ ?line check_nd_refc({node(), erlang:system_info(creation)},
+ NodeRefs,
+ DistRefs,
+ fun (ErrMsg) ->
+ ?line ?t:format("~s", [ErrMsg]),
+ ?line ?t:fail(reference_count_check_failed)
+ end),
+ ?line find_references(NodeName, DistRefs).
+
+find_references(N, NRefList) ->
+ case lists:keysearch(N, 1, NRefList) of
+ {value, {N, _, ReferrersList}} -> ReferrersList;
+ _ -> false
+ end.
+
+%% Currently unused
+% refering_entity_type(RefererType, ReferingEntities) ->
+% lists:filter(fun ({{RT, _}, _}) when RT == RefererType ->
+% true;
+% (_) ->
+% false
+% end,
+% ReferingEntities).
+
+refering_entity_id(ReferingEntityId, [{ReferingEntityId,_} = ReferingEntity
+ | _ReferingEntities]) ->
+ ReferingEntity;
+refering_entity_id(ReferingEntityId, [_ | ReferingEntities]) ->
+ refering_entity_id(ReferingEntityId, ReferingEntities);
+refering_entity_id(_, []) ->
+ false.
+
+reference_type_count(_, false) ->
+ 0;
+reference_type_count(Type, {_, _ReferenceCountList} = ReferingEntity) ->
+ reference_type_count(Type, [ReferingEntity]);
+reference_type_count(Type, ReferingEntities) when is_list(ReferingEntities) ->
+ lists:foldl(fun ({_, ReferenceCountList}, Acc1) ->
+ lists:foldl(fun ({T, N}, Acc2) when T == Type ->
+ N + Acc2;
+ (_, Acc2) ->
+ Acc2
+ end,
+ Acc1,
+ ReferenceCountList)
+ end,
+ 0,
+ ReferingEntities).
+
+
+start_node(Name, Args) ->
+ ?line Pa = filename:dirname(code:which(?MODULE)),
+ ?line Res = test_server:start_node(Name,
+ slave,
+ [{args, "-pa "++Pa++" "++Args}]),
+ ?line {ok, Node} = Res,
+ ?line rpc:call(Node, erts_debug, set_internal_state,
+ [available_internal_state, true]),
+ ?line Res.
+
+start_node(Name) ->
+ ?line start_node(Name, "").
+
+stop_node(Node) ->
+ ?line nc_refc_check(Node),
+ ?line true = test_server:stop_node(Node).
+
+hostname() ->
+ from($@, atom_to_list(node())).
+
+from(H, [H | T]) -> T;
+from(H, [_ | T]) -> from(H, T);
+from(_H, []) -> [].
+
+wait_until(Pred) ->
+ case Pred() of
+ true -> ok;
+ false -> receive after 100 -> wait_until(Pred) end
+ end.
+
+
+get_nodefirstname() ->
+ {A, B, C} = now(),
+ list_to_atom(atom_to_list(?MODULE)
+ ++ "-"
+ ++ integer_to_list(A)
+ ++ "-"
+ ++ integer_to_list(B)
+ ++ "-"
+ ++ integer_to_list(C)).
+
+get_nodename() ->
+ {A, B, C} = now(),
+ list_to_atom(atom_to_list(?MODULE)
+ ++ "-"
+ ++ integer_to_list(A)
+ ++ "-"
+ ++ integer_to_list(B)
+ ++ "-"
+ ++ integer_to_list(C)
+ ++ "@"
+ ++ hostname()).
+
+
+
+-define(VERSION_MAGIC, 131).
+
+-define(ATOM_EXT, 100).
+-define(REFERENCE_EXT, 101).
+-define(PORT_EXT, 102).
+-define(PID_EXT, 103).
+-define(NEW_REFERENCE_EXT, 114).
+
+uint32_be(Uint) when is_integer(Uint), 0 =< Uint, Uint < 1 bsl 32 ->
+ [(Uint bsr 24) band 16#ff,
+ (Uint bsr 16) band 16#ff,
+ (Uint bsr 8) band 16#ff,
+ Uint band 16#ff];
+uint32_be(Uint) ->
+ exit({badarg, uint32_be, [Uint]}).
+
+
+uint16_be(Uint) when is_integer(Uint), 0 =< Uint, Uint < 1 bsl 16 ->
+ [(Uint bsr 8) band 16#ff,
+ Uint band 16#ff];
+uint16_be(Uint) ->
+ exit({badarg, uint16_be, [Uint]}).
+
+uint8(Uint) when is_integer(Uint), 0 =< Uint, Uint < 1 bsl 8 ->
+ Uint band 16#ff;
+uint8(Uint) ->
+ exit({badarg, uint8, [Uint]}).
+
+
+
+mk_pid({NodeName, Creation}, Number, Serial) when is_atom(NodeName) ->
+ mk_pid({atom_to_list(NodeName), Creation}, Number, Serial);
+mk_pid({NodeName, Creation}, Number, Serial) ->
+ case catch binary_to_term(list_to_binary([?VERSION_MAGIC,
+ ?PID_EXT,
+ ?ATOM_EXT,
+ uint16_be(length(NodeName)),
+ NodeName,
+ uint32_be(Number),
+ uint32_be(Serial),
+ uint8(Creation)])) of
+ Pid when is_pid(Pid) ->
+ Pid;
+ {'EXIT', {badarg, _}} ->
+ exit({badarg, mk_pid, [{NodeName, Creation}, Number, Serial]});
+ Other ->
+ exit({unexpected_binary_to_term_result, Other})
+ end.
+
+mk_port({NodeName, Creation}, Number) when is_atom(NodeName) ->
+ mk_port({atom_to_list(NodeName), Creation}, Number);
+mk_port({NodeName, Creation}, Number) ->
+ case catch binary_to_term(list_to_binary([?VERSION_MAGIC,
+ ?PORT_EXT,
+ ?ATOM_EXT,
+ uint16_be(length(NodeName)),
+ NodeName,
+ uint32_be(Number),
+ uint8(Creation)])) of
+ Port when is_port(Port) ->
+ Port;
+ {'EXIT', {badarg, _}} ->
+ exit({badarg, mk_port, [{NodeName, Creation}, Number]});
+ Other ->
+ exit({unexpected_binary_to_term_result, Other})
+ end.
+
+mk_ref({NodeName, Creation}, Numbers) when is_atom(NodeName),
+ is_integer(Creation),
+ is_list(Numbers) ->
+ mk_ref({atom_to_list(NodeName), Creation}, Numbers);
+mk_ref({NodeName, Creation}, [Number]) when is_list(NodeName),
+ is_integer(Creation),
+ is_integer(Number) ->
+ case catch binary_to_term(list_to_binary([?VERSION_MAGIC,
+ ?REFERENCE_EXT,
+ ?ATOM_EXT,
+ uint16_be(length(NodeName)),
+ NodeName,
+ uint32_be(Number),
+ uint8(Creation)])) of
+ Ref when is_reference(Ref) ->
+ Ref;
+ {'EXIT', {badarg, _}} ->
+ exit({badarg, mk_ref, [{NodeName, Creation}, [Number]]});
+ Other ->
+ exit({unexpected_binary_to_term_result, Other})
+ end;
+mk_ref({NodeName, Creation}, Numbers) when is_list(NodeName),
+ is_integer(Creation),
+ is_list(Numbers) ->
+ case catch binary_to_term(list_to_binary([?VERSION_MAGIC,
+ ?NEW_REFERENCE_EXT,
+ uint16_be(length(Numbers)),
+ ?ATOM_EXT,
+ uint16_be(length(NodeName)),
+ NodeName,
+ uint8(Creation),
+ lists:map(fun (N) ->
+ uint32_be(N)
+ end,
+ Numbers)])) of
+ Ref when is_reference(Ref) ->
+ Ref;
+ {'EXIT', {badarg, _}} ->
+ exit({badarg, mk_ref, [{NodeName, Creation}, Numbers]});
+ Other ->
+ exit({unexpected_binary_to_term_result, Other})
+ end.
+
+exec_loop() ->
+ receive
+ {exec_fun, Fun} when is_function(Fun) ->
+ Fun();
+ {sync_exec_fun, From, Fun} when is_pid(From), is_function(Fun) ->
+ From ! {sync_exec_fun_res, self(), Fun()}
+ end,
+ exec_loop().
+
+spawn_execer(Node) ->
+ spawn(Node, fun () -> exec_loop() end).
+
+spawn_link_execer(Node) ->
+ spawn_link(Node, fun () -> exec_loop() end).
+
+exec(Pid, Fun) when is_pid(Pid), is_function(Fun) ->
+ Pid ! {exec_fun, Fun}.
+
+sync_exec(Pid, Fun) when is_pid(Pid), is_function(Fun) ->
+ Pid ! {sync_exec_fun, self(), Fun},
+ receive
+ {sync_exec_fun_res, Pid, Res} ->
+ Res
+ end.