Concurrency: Erlang vs Java

Its fashionable to extol the high-performance of Erlang concurrency these days. Programming Erlang, Section 8.11, has this problem:

Write a ring benchmark. Create N processes in a ring. Send a message
round the ring M times so that a total of N * M messages get
sent. Time how long this takes for different values of N and M.

Well, I copied off the Java program from here: http://www.sics.se/~joe/ericsson/du98024.html

And then I wrote this Erlang program:

-module(threadperftest).
-compile(export_all).

timeit() ->
 register(mainproc, self()),
 io:format(" Procs,  Mesgs, SpawnTotal,  SpawnProc,   RunTotal,    RunMesg~n", []),
 timeit_aux(1000, 1000, 10000),
 init:stop().

timeit_aux(NProcs, NMsgs, NProcsMax) ->
 if NProcs =<>
     main([NProcs, NMsgs]),
     timeit_aux(NProcs+1000, NMsgs, NProcsMax);
    true -> void
 end.
    
main([N, M]) ->
 {_, _W0} = statistics(wall_clock),
 FirstPid = spawn(fun loop0/0),
 % io:format("First: ~p~n", [FirstPid]),
 LastPid = setup(N-1, FirstPid),
 FirstPid ! LastPid,
 {_, W1} = statistics(wall_clock),
 LastPid ! M,
 receive
 stop ->
     void
 end,
 {_, W2} = statistics(wall_clock),
 io:format("~6B, ~6B, ~10g, ~10g, ~10g, ~10g~n", [N, M, W1*1.0, 1.0*W1/N, W2*1.0, W2*1000.0/(M*N+N)]).

setup(0, PrevPid) ->
 PrevPid;
setup(HowMany, PrevPid) ->
 Pid = spawn(fun() -> loop(PrevPid) end),
 % io:format("~p: Linking to: ~p~n", [Pid, PrevPid]),
 setup(HowMany - 1, Pid).

loop0() ->
 receive
 LinkedPid when is_pid(LinkedPid) ->
     % io:format("First: ~p: Linking to ~p~n", [self(), LinkedPid]),
     loop1(LinkedPid);
 X ->
     erlang:error({unknownMessageError, X, self()})
 end.

loop1(LinkedPid) ->
 receive
 M when is_integer(M), M > 0 ->
     % io:format("~p: Received: ~p~n", [self(), M]),
     LinkedPid ! (M-1),
     loop1(LinkedPid);
 M when is_integer(M), M =:= 0 ->
     % io:format("~p: Received: ~p, Terminating~n", [self(), M]),
     mainproc ! stop,
     done;
 X ->
     erlang:error({unknownMessageError, X, self()})
 end.
  
loop(LinkedPid) ->
 receive
 M when is_integer(M), M > 0 ->
     % io:format("~p: Received: ~p~n", [self(), M]),
     LinkedPid ! M,
     loop(LinkedPid);
 M when is_integer(M), M =:= 0 ->
     % io:format("~p: Received: ~p, Terminating~n", [self(), M]),
     LinkedPid ! M,
     done;
 X ->
     erlang:error({unknownMessageError, X, self()})
 end.

The performance is something like this (all times are in milliseconds, except the last one, which is in microseconds):

 Procs,  Mesgs, SpawnTotal,  SpawnProc,   RunTotal,    RunMesg
 1000,   1000, 0.00000e+0, 0.00000e+0,    266.000,   0.265734
 2000,   1000,    16.0000, 8.00000e-3,    562.000,   0.280719
 3000,   1000, 0.00000e+0, 0.00000e+0,    969.000,   0.322677
 4000,   1000, 0.00000e+0, 0.00000e+0,    1672.00,   0.417582
 5000,   1000,    15.0000, 3.00000e-3,    2469.00,   0.493307
 6000,   1000,    16.0000, 2.66667e-3,    3234.00,   0.538462
 7000,   1000,    16.0000, 2.28571e-3,    4015.00,   0.572998
 8000,   1000,    16.0000, 2.00000e-3,    4750.00,   0.593157
 9000,   1000,    31.0000, 3.44444e-3,    5469.00,   0.607060
10000,   1000,    31.0000, 3.10000e-3,    6375.00,   0.636863

The numbers in the RunMesg column are the time it takes to send one message from one process to another. Why is it increasing? Does the runtime have to do more work to find the target process?

Here is the Java output (program below):

 Procs,  Mesgs, SpawnTotal, SpawnProcs,   RunTotal,   RunMesg
  100,   1000,     16.000,      0.160,  15531.000,     15.531
  200,   1000,     62.000,      0.310,  27047.000,     27.047
  300,   1000,     94.000,      0.313,  37828.000,     37.828
  400,   1000,    125.000,      0.313,  46859.000,     46.859
  500,   1000,    141.000,      0.282,  54578.000,     54.578
  600,   1000,    203.000,      0.338,  60594.000,     60.594
  700,   1000,    234.000,      0.334,  65282.000,     65.282
  800,   1000,    406.000,      0.508,  68156.000,     68.156
  900,   1000,    484.000,      0.538,  69782.000,     69.782
 1000,   1000,    735.000,      0.735,  70015.000,     70.015

The last column is in milliseconds whereas for Erlang it was in microseconds, AND the number of procs is 100-1000, whereas for Erlang they were 1000-10,000.