Try elixir / OTP

dping.ex

defmodule PingPong do
  def ping(pid) do
    send pid, {:ping, self()}
    receive do
      :pong -> :ok
    end
  end

  def pong do
    receive do
      {:ping, sender} -> send sender, :pong
    end
    pong()
  end
end

defmodule Comparison do
  def start_remote do
    pid = setup_remote_process :two@hubert
    do_times 10, fn -> ping_for_millis pid, 1000 end
  end

  def start_local do
    pid = setup_local_process()
    do_times 10, fn -> ping_for_millis pid, 1000 end
  end

  defp setup_remote_process(node_name) do
    Node.connect node_name
    Node.spawn node_name, PingPong, :pong, []
  end

  defp setup_local_process do
    spawn PingPong, :pong, []
  end

  defp ping_for_millis(pid, millis) do
    ping_for_millis pid, millis, :os.system_time(:millisecond), 0
  end

  defp ping_for_millis(pid, millis, start, counter) do
    cond do
      :os.system_time(:millisecond) - start >= millis -> counter
      true ->
        PingPong.ping pid
        ping_for_millis pid, millis, start, counter + 1
    end
  end

  defp do_times(times, func) do
    cond do
      times <= 0 -> :ok
      true ->
        result = func.()
        IO.puts("#{result} ping pongs")
        do_times times - 1, func
    end
  end
end

defmodule Benchmark do
  def measure(function) do
    function
    |> :timer.tc
    |> elem(0)
    |> Kernel./(1_000_000)
  end
end