Hi, I’ve written a pooler using gen_statem, similar to poolboy but with a few differences, more control on how it can be configured (default workers, max workers (similar to overflow in poolboy) and waiting queue lenght), some more control on checking out the worker (immediate overload response, only timeout, unbound, not swallowing timeouts).

I’ve ran some tests with it and poolboy and the results are promising. What I’m wondering is if there’s any other more efficient poolers out there? Perhaps nif based? I’m asking because if not I would like to rewrite it in erlang (it’s mostly compatible with only some keyword lists for initialisation and naming which can be swapped for something else) and publish it publicly (and because poolboy is used in some public elixir libs if it was a better option it would be, well, better?).

They have slightly different semantics on how they control, the things but running poolboy with no “block”, and an :infinity timeout, against the unbound waiting queue, and 5_000 timeout, both with 100 workers, not overflow, results in this:

Interactive Elixir (1.9.0) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)> Queuer.Pool.test_queuer()
:ok
Total ok: 40000 - Total failed: 0
time: 1.13
iex(2)> Queuer.Pool.test_poolboy()
:ok
Total ok: 40000 - Total failed: 0
time: 41.639

The results are consistent across all range of workloads, workers, etc.

The tests are basically:

@total_reqs 20000
  
  def test_queuer(max \\ @total_reqs)  do
    pid = Process.whereis(__MODULE__)
    time = :erlang.system_time(:millisecond)
    receiver = spawn(__MODULE__, :keep_track, [time, 0, 0])
    feed_test_queuer(pid, receiver, 0, max)
    feed_test_queuer(pid, receiver, 0, max)
  end

  def feed_test_queuer(pid, receiver, count, max) when count < max do
    spawn(fn() ->
      case __MODULE__.checkout(pid, 5000, false) do
        {:ok, w_pid} ->
          :ok = GenServer.call(w_pid, :test)
          send(receiver, :ok)
          __MODULE__.checkin(pid, w_pid)
        error ->
          send(receiver, :failed)
          :error
      end
    end)
    feed_test_queuer(pid, receiver, count + 1, max)
  end

  def feed_test_queuer(_, _, _, _), do: :ok

  def test_poolboy(max \\ @total_reqs) do
    pid = Process.whereis(:worker)
    time = :erlang.system_time(:millisecond)
    receiver = spawn(__MODULE__, :keep_track, [time, 0, 0])
    feed_test_poolboy(pid, receiver, 0, max)
    feed_test_poolboy(pid, receiver, 0, max)
  end

  def feed_test_poolboy(pid, receiver, count, max) when count < max do
    spawn(fn() ->
      case :poolboy.checkout(pid, true, :infinity) do
        :full ->
          send(receiver, :failed)
          :error
        w_pid ->
          :ok = GenServer.call(w_pid, :test)
          send(receiver, :ok)
          :poolboy.checkin(pid, w_pid)
      end
    end)
    feed_test_poolboy(pid, receiver, count + 1, max)
  end

  def feed_test_poolboy(_, _, _, _), do: :ok
 
   def keep_track(time, c, f) when (c + f) == @total_reqs do
    time_now = :erlang.system_time(:millisecond)
    IO.puts("Total ok: #{c} - Total failed: #{f}")
    IO.inspect(((time_now - time) / 1000), label: "time")
  end
  
  def keep_track(time, count, failed) do
    receive do
      :ok -> keep_track(time, count + 1, failed)
      :failed -> keep_track(time, count, failed + 1)
    after
      10_000 ->
        :ok
    end
  end

In short, checkout a worker, call it for :ok, send a message to the “tracker”.
The worker module is:

defmodule WorkerTest do
  use GenServer

   def start_link do
    GenServer.start_link(__MODULE__, nil, [])
  end
  
  def start_link(_) do
    GenServer.start_link(__MODULE__, nil, [])
  end

  def init(_) do
    {:ok, nil}
  end

  def handle_call(:test, _from, state) do
    {:reply, :ok, state}
  end
end

(it has two start_links, because my queuer is passing 0 args to it)
Can you see something wrong with the way I’m testing both implementations?