Distributing Work example in Elixir.

distributing_work.ex

defmodule DistributingWork do
  # NOTE: When no more work, and no more active workers, return state (our answer)
  def process_work([], [], _, state), do: IO.puts inspect(state, char_lists: :as_lists)

  # NOTE: When no more work, and all workers are active, wait for workers to return
  def process_work(work, active, passive, state) when work == [] or passive == [] do
    receive do
      { worker, result } ->
        process_work(work, List.delete(active, worker), [worker | passive], [result | state])
    end
  end

  # NOTE: When there's still work to be done, 
  def process_work([{m,n}|rest], active, [worker | passive], state) do
    worker |> send({ self, {m, n} })
    process_work(rest, [worker | active], passive, state)
  end

  def worker do
    receive do
      { pid, {m, n} } -> 
        pid |> send({ self, sequential({m, n}) })
        worker
    end
  end

  def sequential({m, n}), do: ackermann(m, n)

  def ackermann(0, n), do: n + 1
  def ackermann(m, 0), do: ackermann(m-1, 1)
  def ackermann(m, n), do: ackermann(m-1, ackermann(m,n-1))

  def run(n) do  
    workers = 1..n |> Enum.map fn _ -> spawn(__MODULE__, :worker, []) end
    work    = [{1,9}, {1,9}, {1,9}, {1,9}]
    process_work(work, [], workers, [])
  end

end

s = :erlang.now
DistributingWork.run(1)
e = :erlang.now
IO.inspect :timer.now_diff(e, s) / (1000 * 1000)

s = :erlang.now
DistributingWork.run(2)
e = :erlang.now
IO.inspect :timer.now_diff(e, s) / (1000 * 1000)

s = :erlang.now
DistributingWork.run(3)
e = :erlang.now
IO.inspect :timer.now_diff(e, s) / (1000 * 1000)

s = :erlang.now
DistributingWork.run(4)
e = :erlang.now
IO.inspect :timer.now_diff(e, s) / (1000 * 1000)

1 Worker: 176.5097651 s
2 Workers: 94.590043 s
3 Workers: 93.485989 s
4 Workers: 53.710127 s