anchor.diff:  bulk_sendsend2(Terms, BinSize, BusyBufSize) ->
       ct:timetrap({seconds, 30}),
   
  -    io:format("Sending ~w binaries, each of size ~w K",
  +    io:format("\nSending ~w binaries, each of size ~w K",
                 [Terms, BinSize]),
       {ok, NodeRecv} = start_node(bulk_receiver),
       Recv = spawn(NodeRecv, erlang, apply, [fun receiver/2, [0, 0]]),
  -    Bin = list_to_binary(lists:duplicate(BinSize*1024, 253)),
  -    %%Size = Terms*size(Bin),
  +    Bin = binary:copy(<<253>>, BinSize*1024),
   
       %% SLF LEFT OFF HERE.
       %% When the caller uses small hunks, like 4k via
  
positive.code:     %% default busy size and "+zdbbl 5", and if the 5 case gets
      %% "many many more" monitor messages, then we know we're working.
  
      {ok, NodeSend} = start_node(bulk_sender, "+zdbbl " ++ integer_to_list(BusyBufSize)),
      _Send = spawn(NodeSend, erlang, apply, [fun sendersender/4, [self(), Recv, Bin, Terms]]),
      {Elapsed, {_TermsN, SizeN}, MonitorCount} =
      receive
          %% On some platforms (windows), the time taken is 0 so we
          %% simulate that some little time has passed.
          {sendersender, {0.0,T,MC}} ->
              {0.0015, T, MC};
          {sendersender, BigRes} ->
              BigRes
      end,
      stop_node(NodeRecv),
      stop_node(NodeSend),
      {trunc(SizeN/1024/Elapsed+0.5), MonitorCount}.
  
  sender(To, _Bin, 0) ->
      To ! {done, self()},
      receive
          Any ->
              Any
      end;
  sender(To, Bin, Left) ->
      To ! {term, Bin},
      sender(To, Bin, Left-1).
  
  %% Sender process to be run on a slave node
  
  sendersender(Parent, To, Bin, Left) ->
      erlang:system_monitor(self(), [busy_dist_port]),
      [spawn(fun() -> sendersender2(To, Bin, Left, false) end) ||
       _ <- lists:seq(1,1)],
      {USec, {Res, MonitorCount}} =
      timer:tc(?MODULE, sendersender2, [To, Bin, Left, true]),
      Parent ! {sendersender, {USec/1000000, Res, MonitorCount}}.
  
  sendersender2(To, Bin, Left, SendDone) ->
      sendersender3(To, Bin, Left, SendDone, 0).
  
  sendersender3(To, _Bin, 0, SendDone, MonitorCount) ->
      if SendDone ->
             To ! {done, self()};
         true ->
             ok
      end,
      receive
          {monitor, _Pid, _Type, _Info} ->
              sendersender3(To, _Bin, 0, SendDone, MonitorCount + 1)
      after 0 ->
                if SendDone ->
                       receive
                           Any when is_tuple(Any), size(Any) == 2 ->
                               {Any, MonitorCount}
                       end;
                   true ->
                       exit(normal)
                end
      end;
  sendersender3(To, Bin, Left, SendDone, MonitorCount) ->
      To ! {term, Bin},
      %%timer:sleep(50),
      sendersender3(To, Bin, Left-1, SendDone, MonitorCount).
  
  %% Receiver process to be run on a slave node.
  
  receiver(Terms, Size) ->
      receive
          {term, Bin} ->
              receiver(Terms+1, Size+size(Bin));
          {done, ReplyTo} ->
              ReplyTo ! {Terms, Size}
      end.
  
negative.code: bulk_send_big(Config) when is_list(Config) ->
      bulk_send(32, 64).
  
  bulk_send(Terms, BinSize) ->
      ct:timetrap({seconds, 30}),
  
      io:format("Sending ~w binaries, each of size ~w K", [Terms, BinSize]),
      {ok, Node} = start_node(bulk_receiver),
      Recv = spawn(Node, erlang, apply, [fun receiver/2, [0, 0]]),
      Bin = binary:copy(<<253>>, BinSize*1024),
      Size = Terms*size(Bin),
      {Elapsed, {Terms, Size}} = test_server:timecall(?MODULE, sender,
                                                      [Recv, Bin, Terms]),
      stop_node(Node),
      {comment, integer_to_list(round(Size/1024/max(1,Elapsed))) ++ " K/s"}.
  
  sender(To, _Bin, 0) ->
      To ! {done, self()},
      receive
          Any ->
              Any
      end;
  sender(To, Bin, Left) ->
      To ! {term, Bin},
      sender(To, Bin, Left-1).
  
  bulk_send_bigbig(Config) when is_list(Config) ->
      Terms = 32*5,
      BinSize = 4,
      {Rate1, MonitorCount1} = bulk_sendsend2(Terms, BinSize,   5),
      {Rate2, MonitorCount2} = bulk_sendsend2(Terms, BinSize, 995),
      Ratio = if MonitorCount2 == 0 -> MonitorCount1 / 1.0;
                 true               -> MonitorCount1 / MonitorCount2
              end,
      Comment0 = io_lib:format("~p K/s, ~p K/s, "
                               "~p monitor msgs, ~p monitor msgs, "
                               "~.1f monitor ratio",
                               [Rate1,Rate2,MonitorCount1,
                                MonitorCount2,Ratio]),
      Comment = lists:flatten(Comment0),
      if
          %% A somewhat arbitrary ratio, but hopefully one that will
          %% accommodate a wide range of CPU speeds.
  