Merge branch 'lukas/OTP-22-rc2/misc-fixes/OTP-15773'

* lukas/OTP-22-rc2/misc-fixes/OTP-15773:
  erts: Yield correctly when iterating over distr exit messages
  erts: Fix cerl -rr to use correct etp file
  erts: Fix etp-process-info to print exiting and free processes
  tools: Adjust instrument abort tc to better trigger faults
  erts: Fix cleanup of message factory undo
  erts: Make dump_SUITE:free_dump not dump via rpc
  erts: Add extra debugging to dist frag testcases
  erts: Run smaller dist frag test to 32 bit machines
  erl_docgen: Remove accidentally merged debug printout
  erts: Fix z_SUITE to always look for cerl in ERL_TOP
  otp: make top Makefile app target respect TYPE variable
  vxworks: Make vxworks configure use environment CFLAGS
  erts: Make erts_free debug failure easier to diagnose
  erts: Fix gcc warning in to_erl

2 files changed, 50 insertions, 24 deletions

diff --git a/erts/emulator/test/distribution_SUITE.erl b/erts/emulator/test/distribution_SUITE.erl
index 6e31c73e10..973a8f4717 100644
--- a/erts/emulator/test/distribution_SUITE.erl
+++ b/erts/emulator/test/distribution_SUITE.erl
@@ -75,7 +75,7 @@
          optimistic_dflags_echo/0, optimistic_dflags_sender/1,
          roundtrip/1, bounce/1, do_dist_auto_connect/1, inet_rpc_server/1,
          dist_parallel_sender/3, dist_parallel_receiver/0,
-         dist_evil_parallel_receiver/0]).
+         dist_evil_parallel_receiver/0, make_busy/2]).
 
 %% epmd_module exports
 -export([start_link/0, register_node/2, register_node/3, port_please/2, address_please/3]).
@@ -1460,11 +1460,14 @@ measure_latency_large_message(Nodename, DataFun) ->
 
     Echo = spawn(N, fun F() -> receive {From, Msg} -> From ! Msg, F() end end),
 
-    case erlang:system_info(build_type) of
-        debug ->
+    BuildType = erlang:system_info(build_type),
+    WordSize = erlang:system_info(wordsize),
+
+    if
+        BuildType =/= opt; WordSize =:= 4 ->
             %% Test 3.2 MB and 32 MB and test the latency difference of sent messages
             Payloads = [{I, <<0:(I * 32 * 1024 * 8)>>} || I <- [1,10]];
-        _ ->
+        true ->
             %% Test 32 MB and 320 MB and test the latency difference of sent messages
             Payloads = [{I, <<0:(I * 32 * 1024 * 1024 * 8)>>} || I <- [1,10]]
     end,
@@ -1479,7 +1482,7 @@ measure_latency_large_message(Nodename, DataFun) ->
     stop_node(N),
 
     case {lists:max(Times), lists:min(Times)} of
-        {Max, Min} when Max * 0.25 > Min ->
+        {Max, Min} when Max * 0.25 > Min, BuildType =:= opt ->
             ct:fail({incorrect_latency, IndexTimes});
         _ ->
             ok
@@ -1504,13 +1507,19 @@ measure_latency(DataFun, Dropper, Echo, Payload) ->
              ok
      end || _ <- lists:seq(1,10)],
 
-    {TS, _} =
+    {TS, Times} =
         timer:tc(fun() ->
                          [begin
+                              T0 = erlang:monotonic_time(),
                               Echo ! {self(), hello},
-                              receive hello -> ok end
+                              receive hello -> ok end,
+                              (erlang:monotonic_time() - T0) / 1000000
                           end || _ <- lists:seq(1,100)]
                  end),
+    Avg = lists:sum(Times) / length(Times),
+    StdDev = math:sqrt(lists:sum([math:pow(V - Avg,2) || V <- Times]) / length(Times)),
+    ct:pal("Times: Avg: ~p Max: ~p Min: ~p Var: ~p",
+           [Avg, lists:max(Times), lists:min(Times), StdDev]),
     [begin
          Sender ! die,
          receive
diff --git a/erts/emulator/test/dump_SUITE.erl b/erts/emulator/test/dump_SUITE.erl
index 3b860ebdf6..9f8ac42fa9 100644
--- a/erts/emulator/test/dump_SUITE.erl
+++ b/erts/emulator/test/dump_SUITE.erl
@@ -137,26 +137,43 @@ exiting_dump(Config) when is_list(Config) ->
 free_dump(Config) when is_list(Config) ->
     Dump = filename:join(proplists:get_value(priv_dir, Config),"signal_abort.dump"),
 
-    {ok, Node} = start_node(Config),
-
-    Self = self(),
-
-    Pid = spawn_link(Node,
-                     fun() ->
-                             Self ! ready,
-                             receive
-                                 ok ->
-                                     unlink(Self),
-                                     exit(lists:duplicate(1000,1000))
-                             end
-                     end),
+    {ok, NodeA} = start_node(Config),
+    {ok, NodeB} = start_node(Config),
 
-    true = rpc:call(Node, os, putenv, ["ERL_CRASH_DUMP",Dump]),
 
-    [erlang:monitor(process, Pid) || _ <- lists:seq(1,10000)],
-    receive ready -> unlink(Pid), Pid ! ok end,
+    Self = self(),
 
-    rpc:call(Node, erlang, halt, ["dump"]),
+    PidA = spawn_link(
+             NodeA,
+             fun() ->
+                     Self ! ready,
+                     receive
+                         ok ->
+                             spawn(fun() ->
+                                           erlang:system_monitor(self(), [busy_dist_port]),
+                                           timer:sleep(5),
+                                           receive
+                                               M ->
+                                                   io:format("~p",[M]),
+                                                   erlang:halt("dump")
+                                           end
+                                   end),
+                             exit(lists:duplicate(1000000,100))
+                     end
+             end),
+
+    spawn_link(NodeB,
+               fun() ->
+                       [erlang:monitor(process, PidA) || _ <- lists:seq(1,10000)],
+                       Self ! done,
+                       receive _ -> ok end
+               end),
+
+    receive done -> ok end,
+    true = rpc:call(NodeA, os, putenv, ["ERL_CRASH_DUMP",Dump]),
+    ct:pal("~p",[rpc:call(NodeA, distribution_SUITE, make_busy, [NodeB, 1000])]),
+
+    receive ready -> unlink(PidA), PidA ! ok end,
 
     {ok, Bin} = get_dump_when_done(Dump),