diff --git a/.dockerignore b/.dockerignore
new file mode 100644
index 00000000..e35d8850
--- /dev/null
+++ b/.dockerignore
@@ -0,0 +1 @@
+_build
diff --git a/Makefile b/Makefile
index 2dcd1134..c11458f6 100644
--- a/Makefile
+++ b/Makefile
@@ -10,4 +10,4 @@ clean:
 	dune clean
 
 bench:
-	@dune exec --release -- ./bench/main.exe
+	@dune exec --release -- ./bench/main.exe -budget 1
diff --git a/README.md b/README.md
index 8bda55ce..f5ebb2f3 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,5 @@
-[API Reference](https://ocaml-multicore.github.io/saturn/)
+[API Reference](https://ocaml-multicore.github.io/saturn/) ·
+[Benchmarks](https://bench.ci.dev/ocaml-multicore/saturn/branch/main)
 
 <!--
 ```ocaml
diff --git a/bench.Dockerfile b/bench.Dockerfile
new file mode 100644
index 00000000..9b395849
--- /dev/null
+++ b/bench.Dockerfile
@@ -0,0 +1,10 @@
+FROM ocaml/opam:debian-ocaml-5.1
+RUN sudo ln -sf /usr/bin/opam-2.1 /usr/bin/opam
+WORKDIR bench-dir
+COPY *.opam ./
+RUN opam remote add origin https://github.com/ocaml/opam-repository.git && \
+    opam update
+RUN opam pin -yn --with-version=dev .
+RUN opam install -y --deps-only --with-test .
+COPY . ./
+RUN opam exec -- dune build --release bench/main.exe
diff --git a/bench/README.md b/bench/README.md
index 0f71fd12..7ab7eb15 100644
--- a/bench/README.md
+++ b/bench/README.md
@@ -4,10 +4,4 @@ Benchmarks for Saturn
 
 Execute `make bench` from root of the repository to run the standard set of
 benchmarks. The output is in JSON, as it is intended to be consumed by
-ocaml-benchmark CI (in progress).
-
-# Specific structures
-
-Some benchmarks expose commandline interface targeting particular structures:
-
-- [mpmc_queue.exe](mpmc_queue_cmd.ml)
+[current-bench](https://bench.ci.dev/ocaml-multicore/saturn/branch/main/benchmark/default).
diff --git a/bench/bench_queue.ml b/bench/bench_queue.ml
new file mode 100644
index 00000000..c3568148
--- /dev/null
+++ b/bench/bench_queue.ml
@@ -0,0 +1,74 @@
+open Multicore_bench
+module Queue = Saturn_lockfree.Queue
+
+let run_one_domain ~budgetf ?(n_msgs = 50 * Util.iter_factor) () =
+  let t = Queue.create () in
+
+  let op push = if push then Queue.push t 101 else Queue.pop_opt t |> ignore in
+
+  let init _ =
+    assert (Queue.is_empty t);
+    Util.generate_push_and_pop_sequence n_msgs
+  in
+  let work _ bits = Util.Bits.iter op bits in
+
+  Times.record ~budgetf ~n_domains:1 ~init ~work ()
+  |> Times.to_thruput_metrics ~n:n_msgs ~singular:"message" ~config:"one domain"
+
+let run_one ~budgetf ?(n_adders = 2) ?(n_takers = 2)
+    ?(n_msgs = 50 * Util.iter_factor) () =
+  let n_domains = n_adders + n_takers in
+
+  let t = Queue.create () in
+
+  let n_msgs_to_take = Atomic.make 0 |> Multicore_magic.copy_as_padded in
+  let n_msgs_to_add = Atomic.make 0 |> Multicore_magic.copy_as_padded in
+
+  let init _ =
+    assert (Queue.is_empty t);
+    Atomic.set n_msgs_to_take n_msgs;
+    Atomic.set n_msgs_to_add n_msgs
+  in
+  let work i () =
+    if i < n_adders then
+      let rec work () =
+        let n = Util.alloc n_msgs_to_add in
+        if 0 < n then begin
+          for i = 1 to n do
+            Queue.push t i
+          done;
+          work ()
+        end
+      in
+      work ()
+    else
+      let rec work () =
+        let n = Util.alloc n_msgs_to_take in
+        if n <> 0 then
+          let rec loop n =
+            if 0 < n then
+              loop (n - Bool.to_int (Option.is_some (Queue.pop_opt t)))
+            else work ()
+          in
+          loop n
+      in
+      work ()
+  in
+
+  let config =
+    let format role n =
+      Printf.sprintf "%d %s%s" n role (if n = 1 then "" else "s")
+    in
+    Printf.sprintf "%s, %s"
+      (format "nb adder" n_adders)
+      (format "nb taker" n_takers)
+  in
+
+  Times.record ~budgetf ~n_domains ~init ~work ()
+  |> Times.to_thruput_metrics ~n:n_msgs ~singular:"message" ~config
+
+let run_suite ~budgetf =
+  run_one_domain ~budgetf ()
+  @ (Util.cross [ 1; 2 ] [ 1; 2 ]
+    |> List.concat_map @@ fun (n_adders, n_takers) ->
+       run_one ~budgetf ~n_adders ~n_takers ())
diff --git a/bench/bench_relaxed_queue.ml b/bench/bench_relaxed_queue.ml
new file mode 100644
index 00000000..e94f13b1
--- /dev/null
+++ b/bench/bench_relaxed_queue.ml
@@ -0,0 +1,95 @@
+open Multicore_bench
+module Queue = Saturn.Relaxed_queue
+module Spin = Queue.Spin
+module Not_lockfree = Queue.Not_lockfree
+module CAS_interface = Queue.Not_lockfree.CAS_interface
+
+let run_one ~budgetf ~n_adders ~n_takers ?(n_msgs = 50 * Util.iter_factor)
+    ?(api = `Spin) () =
+  let n_domains = n_adders + n_takers in
+
+  let t = Queue.create ~size_exponent:10 () in
+
+  let n_msgs_to_take = Atomic.make 0 |> Multicore_magic.copy_as_padded in
+  let n_msgs_to_add = Atomic.make 0 |> Multicore_magic.copy_as_padded in
+
+  let init _ =
+    assert (Not_lockfree.pop t == None);
+    Atomic.set n_msgs_to_take n_msgs;
+    Atomic.set n_msgs_to_add n_msgs
+  in
+  let work i () =
+    if i < n_adders then
+      let rec work () =
+        let n = Util.alloc n_msgs_to_add in
+        if n <> 0 then begin
+          match api with
+          | `Spin ->
+              for i = 1 to n do
+                Spin.push t i
+              done;
+              work ()
+          | `Not_lockfree ->
+              let rec loop n =
+                if 0 < n then loop (n - Bool.to_int (Not_lockfree.push t i))
+                else work ()
+              in
+              loop n
+          | `CAS_interface ->
+              let rec loop n =
+                if 0 < n then loop (n - Bool.to_int (CAS_interface.push t i))
+                else work ()
+              in
+              loop n
+        end
+      in
+      work ()
+    else
+      let rec work () =
+        let n = Util.alloc n_msgs_to_take in
+        if n <> 0 then
+          match api with
+          | `Spin ->
+              for _ = 1 to n do
+                Spin.pop t |> ignore
+              done;
+              work ()
+          | `Not_lockfree ->
+              let rec loop n =
+                if 0 < n then
+                  loop (n - Bool.to_int (Option.is_some (Not_lockfree.pop t)))
+                else work ()
+              in
+              loop n
+          | `CAS_interface ->
+              let rec loop n =
+                if 0 < n then
+                  loop (n - Bool.to_int (Option.is_some (CAS_interface.pop t)))
+                else work ()
+              in
+              loop n
+      in
+      work ()
+  in
+
+  let config =
+    let plural role n =
+      Printf.sprintf "%d %s%s" n role (if n = 1 then "" else "s")
+    in
+    Printf.sprintf "%s, %s (%s)" (plural "adder" n_adders)
+      (plural "taker" n_takers)
+      (match api with
+      | `Spin -> "spin"
+      | `Not_lockfree -> "not lf"
+      | `CAS_interface -> "cas")
+  in
+
+  Times.record ~budgetf ~n_domains ~init ~work ()
+  |> Times.to_thruput_metrics ~n:n_msgs ~singular:"message" ~config
+
+let run_suite ~budgetf =
+  Util.cross
+    [ `Spin; `Not_lockfree; `CAS_interface ]
+    (Util.cross [ 1; 2 ] [ 1; 2 ])
+  |> List.concat_map @@ fun (api, (n_adders, n_takers)) ->
+     run_one ~budgetf ~n_adders ~n_takers ~api ()
diff --git a/bench/bench_size.ml b/bench/bench_size.ml
new file mode 100644
index 00000000..9e2eaed9
--- /dev/null
+++ b/bench/bench_size.ml
@@ -0,0 +1,38 @@
+open Multicore_bench
+module Size = Saturn_lockfree.Size
+
+let run_one ~budgetf ~n_domains ?(n_ops = 250 * n_domains * Util.iter_factor) ()
+    =
+  let t = Size.create () in
+
+  let n_ops_todo = Atomic.make 0 |> Multicore_magic.copy_as_padded in
+
+  let init _ = Atomic.set n_ops_todo n_ops in
+  let work _ () =
+    let rec work () =
+      let n = Util.alloc n_ops_todo in
+      if n <> 0 then
+        let rec loop n =
+          if 0 < n then begin
+            let incr = Size.new_once t Size.incr in
+            Size.update_once t incr;
+            let decr = Size.new_once t Size.decr in
+            Size.update_once t decr;
+            loop (n - 2)
+          end
+          else work ()
+        in
+        loop n
+    in
+    work ()
+  in
+
+  let config =
+    Printf.sprintf "%d worker%s" n_domains (if n_domains = 1 then "" else "s")
+  in
+  Times.record ~budgetf ~n_domains ~init ~work ()
+  |> Times.to_thruput_metrics ~n:n_ops ~config ~singular:"operation"
+
+let run_suite ~budgetf =
+  [ 1; 2; 4 ]
+  |> List.concat_map @@ fun n_domains -> run_one ~n_domains ~budgetf ()
diff --git a/bench/bench_skiplist.ml b/bench/bench_skiplist.ml
index 2b420570..21013fad 100644
--- a/bench/bench_skiplist.ml
+++ b/bench/bench_skiplist.ml
@@ -1,57 +1,70 @@
-open Saturn
-
-let workload num_elems num_threads add remove =
-  let sl = Skiplist.create ~compare:Int.compare () in
-  let elems = Array.init num_elems (fun _ -> Random.int 10000) in
-  let push () =
-    Domain.spawn (fun () ->
-        let start_time = Unix.gettimeofday () in
-        for i = 0 to (num_elems - 1) / num_threads do
-          Domain.cpu_relax ();
-          let prob = Random.float 1.0 in
-          if prob < add then Skiplist.try_add sl (Random.int 10000) () |> ignore
-          else if prob >= add && prob < add +. remove then
-            Skiplist.try_remove sl (Random.int 10000) |> ignore
-          else Skiplist.mem sl elems.(i) |> ignore
-        done;
-        start_time)
+open Multicore_bench
+module Skiplist = Saturn.Skiplist
+
+let run_one ~budgetf ~n_domains ?(n_ops = 20 * Util.iter_factor)
+    ?(n_keys = 10000) ~percent_mem ?(percent_add = (100 - percent_mem + 1) / 2)
+    ?(prepopulate = true) () =
+  let percent_rem = 100 - (percent_mem + percent_add) in
+
+  let limit_mem = percent_mem in
+  let limit_add = percent_mem + percent_add in
+
+  assert (0 <= limit_mem && limit_mem <= 100);
+  assert (limit_mem <= limit_add && limit_add <= 100);
+
+  let t = Skiplist.create ~compare:Int.compare () in
+  if prepopulate then
+    for _ = 1 to n_keys do
+      let value = Random.bits () in
+      let key = value mod n_keys in
+      Skiplist.try_add t key value |> ignore
+    done;
+
+  let n_ops = (100 + percent_mem) * n_ops / 100 in
+  let n_ops = n_ops * n_domains in
+
+  let n_ops_todo = Atomic.make 0 |> Multicore_magic.copy_as_padded in
+
+  let init _ =
+    Atomic.set n_ops_todo n_ops;
+    Random.State.make_self_init ()
   in
-  let threads = List.init num_threads (fun _ -> push ()) in
-  let start_time_threads =
-    List.map (fun domain -> Domain.join domain) threads
+  let work _ state =
+    let rec work () =
+      let n = Util.alloc n_ops_todo in
+      if n <> 0 then
+        let rec loop n =
+          if 0 < n then
+            let value = Random.State.bits state in
+            let op = (value asr 20) mod 100 in
+            let key = value mod n_keys in
+            if op < limit_mem then begin
+              Skiplist.mem t key |> ignore;
+              loop (n - 1)
+            end
+            else if op < limit_add then begin
+              Skiplist.try_add t key value |> ignore;
+              loop (n - 1)
+            end
+            else begin
+              Skiplist.try_remove t key |> ignore;
+              loop (n - 1)
+            end
+          else work ()
+        in
+        loop n
+    in
+    work ()
   in
-  let end_time = Unix.gettimeofday () in
-  let time_diff = end_time -. List.nth start_time_threads 0 in
-  time_diff
-
-(* A write heavy workload with threads with 50% adds and 50% removes. *)
-let write_heavy_workload num_elems num_threads =
-  workload num_elems num_threads 0.5 0.5
-
-(* A regular workload with 90% reads, 9% adds and 1% removes. *)
-let read_heavy_workload num_elems num_threads =
-  workload num_elems num_threads 0.09 0.01
-
-let moderate_heavy_workload num_elems num_threads =
-  workload num_elems num_threads 0.2 0.1
-
-let balanced_heavy_workload num_elems num_threads =
-  workload num_elems num_threads 0.3 0.2
-
-let bench ~workload_type ~num_elems ~num_threads () =
-  let workload =
-    if workload_type = "read_heavy" then read_heavy_workload
-    else if workload_type = "moderate_heavy" then moderate_heavy_workload
-    else if workload_type = "balanced_heavy" then balanced_heavy_workload
-    else write_heavy_workload
+
+  let config =
+    Printf.sprintf "%d workers, %d%% mem %d%% add %d%% rem" n_domains
+      percent_mem percent_add percent_rem
   in
-  let results = ref [] in
-  for i = 1 to 10 do
-    let time = workload num_elems num_threads in
-    if i > 1 then results := time :: !results
-  done;
-  let results = List.sort Float.compare !results in
-  let median_time = List.nth results 4 in
-  let median_throughput = Float.of_int num_elems /. median_time in
-  Benchmark_result.create_generic ~median_time ~median_throughput
-    ("atomic_skiplist_" ^ workload_type)
+  Times.record ~budgetf ~n_domains ~init ~work ()
+  |> Times.to_thruput_metrics ~n:n_ops ~singular:"operation" ~config
+
+let run_suite ~budgetf =
+  Util.cross [ 10; 50; 90 ] [ 1; 2; 4 ]
+  |> List.concat_map @@ fun (percent_mem, n_domains) ->
+     run_one ~budgetf ~n_domains ~percent_mem ()
diff --git a/bench/bench_spsc_queue.ml b/bench/bench_spsc_queue.ml
index f82ddcf2..035d7454 100644
--- a/bench/bench_spsc_queue.ml
+++ b/bench/bench_spsc_queue.ml
@@ -1,37 +1,37 @@
-module Spsc_queue = Saturn.Single_prod_single_cons_queue
+open Multicore_bench
+module Queue = Saturn.Single_prod_single_cons_queue
 
-let item_count = 2_000_000
+let run_one ~budgetf ?(size_exponent = 3) ?(n_msgs = 80 * Util.iter_factor) () =
+  let t = Queue.create ~size_exponent in
 
-let rec try_until_success f =
-  try f () with Spsc_queue.Full -> try_until_success f
-
-let run () =
-  let queue = Spsc_queue.create ~size_exponent:3 in
-  let pusher =
-    Domain.spawn (fun () ->
-        let start_time = Unix.gettimeofday () in
-        for i = 1 to item_count do
-          try_until_success (fun () -> Spsc_queue.push queue i)
-        done;
-        start_time)
-  in
-  for _ = 1 to item_count do
-    while Option.is_none (Spsc_queue.pop_opt queue) do
-      ()
+  let before () =
+    while Queue.size t <> 0 do
+      Queue.pop t |> ignore
+    done;
+    let n = Random.int ((1 lsl size_exponent) + 1) in
+    for i = 1 to n do
+      Queue.push t i
     done
-  done;
-  let end_time = Unix.gettimeofday () in
-  let start_time = Domain.join pusher in
-  let time_diff = end_time -. start_time in
-  time_diff
+  in
+  let init _ = () in
+  let work i () =
+    if i = 0 then
+      let rec loop n =
+        if 0 < n then loop (n - Bool.to_int (Queue.try_push t n))
+      in
+      loop n_msgs
+    else
+      let rec loop n =
+        if 0 < n then
+          match Queue.pop_opt t with Some _ -> loop (n - 1) | None -> loop n
+      in
+      loop n_msgs
+  in
+
+  let config = Printf.sprintf "2 workers, capacity %d" (1 lsl size_exponent) in
+  Times.record ~budgetf ~n_domains:2 ~before ~init ~work ()
+  |> Times.to_thruput_metrics ~n:n_msgs ~singular:"message" ~config
 
-let bench () =
-  let results = ref [] in
-  for i = 1 to 10 do
-    let time = run () in
-    if i > 1 then results := time :: !results
-  done;
-  let results = List.sort Float.compare !results in
-  let median_time = List.nth results 4 in
-  let median_throughput = Float.of_int item_count /. median_time in
-  Benchmark_result.create_generic ~median_time ~median_throughput "spsc-queue"
+let run_suite ~budgetf =
+  [ 0; 3; 6; 9; 12; 15 ]
+  |> List.concat_map @@ fun size_exponent -> run_one ~budgetf ~size_exponent ()
diff --git a/bench/bench_spsc_queue.mli b/bench/bench_spsc_queue.mli
deleted file mode 100644
index fa7ab819..00000000
--- a/bench/bench_spsc_queue.mli
+++ /dev/null
@@ -1 +0,0 @@
-val bench : unit -> Benchmark_result.t
diff --git a/bench/bench_stack.ml b/bench/bench_stack.ml
new file mode 100644
index 00000000..499c3842
--- /dev/null
+++ b/bench/bench_stack.ml
@@ -0,0 +1,72 @@
+open Multicore_bench
+module Stack = Saturn_lockfree.Stack
+
+let run_one_domain ~budgetf ?(n_msgs = 50 * Util.iter_factor) () =
+  let t = Stack.create () in
+
+  let op push = if push then Stack.push t 101 else Stack.pop_opt t |> ignore in
+
+  let init _ =
+    assert (Stack.is_empty t);
+    Util.generate_push_and_pop_sequence n_msgs
+  in
+  let work _ bits = Util.Bits.iter op bits in
+
+  Times.record ~budgetf ~n_domains:1 ~init ~work ()
+  |> Times.to_thruput_metrics ~n:n_msgs ~singular:"message" ~config:"one domain"
+
+let run_one ~budgetf ?(n_adders = 2) ?(n_takers = 2)
+    ?(n_msgs = 50 * Util.iter_factor) () =
+  let n_domains = n_adders + n_takers in
+
+  let t = Stack.create () in
+
+  let n_msgs_to_take = Atomic.make 0 |> Multicore_magic.copy_as_padded in
+  let n_msgs_to_add = Atomic.make 0 |> Multicore_magic.copy_as_padded in
+
+  let init _ =
+    assert (Stack.is_empty t);
+    Atomic.set n_msgs_to_take n_msgs;
+    Atomic.set n_msgs_to_add n_msgs
+  in
+  let work i () =
+    if i < n_adders then
+      let rec work () =
+        let n = Util.alloc n_msgs_to_add in
+        if 0 < n then begin
+          for i = 1 to n do
+            Stack.push t i
+          done;
+          work ()
+        end
+      in
+      work ()
+    else
+      let rec work () =
+        let n = Util.alloc n_msgs_to_take in
+        if n <> 0 then begin
+          for _ = 1 to n do
+            while Option.is_none (Stack.pop_opt t) do
+              Domain.cpu_relax ()
+            done
+          done;
+          work ()
+        end
+      in
+      work ()
+  in
+
+  let config =
+    let format role n =
+      Printf.sprintf "%d %s%s" n role (if n = 1 then "" else "s")
+    in
+    Printf.sprintf "%s, %s" (format "adder" n_adders) (format "taker" n_takers)
+  in
+  Times.record ~budgetf ~n_domains ~init ~work ()
+  |> Times.to_thruput_metrics ~n:n_msgs ~singular:"message" ~config
+
+let run_suite ~budgetf =
+  run_one_domain ~budgetf ()
+  @ (Util.cross [ 1; 2 ] [ 1; 2 ]
+    |> List.concat_map @@ fun (n_adders, n_takers) ->
+       run_one ~budgetf ~n_adders ~n_takers ())
diff --git a/bench/bench_stdlib_queue.ml b/bench/bench_stdlib_queue.ml
new file mode 100644
index 00000000..b1c0175d
--- /dev/null
+++ b/bench/bench_stdlib_queue.ml
@@ -0,0 +1,18 @@
+open Multicore_bench
+module Queue = Stdlib.Queue
+
+let run_one_domain ~budgetf ?(n_msgs = 50 * Util.iter_factor) () =
+  let t = Queue.create () in
+
+  let op push = if push then Queue.push 101 t else Queue.take_opt t |> ignore in
+
+  let init _ =
+    assert (Queue.is_empty t);
+    Util.generate_push_and_pop_sequence n_msgs
+  in
+  let work _ bits = Util.Bits.iter op bits in
+
+  Times.record ~budgetf ~n_domains:1 ~init ~work ()
+  |> Times.to_thruput_metrics ~n:n_msgs ~singular:"message" ~config:"one domain"
+
+let run_suite ~budgetf = run_one_domain ~budgetf ()
diff --git a/bench/bench_stdlib_stack.ml b/bench/bench_stdlib_stack.ml
new file mode 100644
index 00000000..1a27b1b2
--- /dev/null
+++ b/bench/bench_stdlib_stack.ml
@@ -0,0 +1,18 @@
+open Multicore_bench
+module Stack = Stdlib.Stack
+
+let run_one_domain ~budgetf ?(n_msgs = 50 * Util.iter_factor) () =
+  let t = Stack.create () in
+
+  let op push = if push then Stack.push 101 t else Stack.pop_opt t |> ignore in
+
+  let init _ =
+    assert (Stack.is_empty t);
+    Util.generate_push_and_pop_sequence n_msgs
+  in
+  let work _ bits = Util.Bits.iter op bits in
+
+  Times.record ~budgetf ~n_domains:1 ~init ~work ()
+  |> Times.to_thruput_metrics ~n:n_msgs ~singular:"message" ~config:"one domain"
+
+let run_suite ~budgetf = run_one_domain ~budgetf ()
diff --git a/bench/bench_ws_deque.ml b/bench/bench_ws_deque.ml
new file mode 100644
index 00000000..331c4faf
--- /dev/null
+++ b/bench/bench_ws_deque.ml
@@ -0,0 +1,84 @@
+open Multicore_bench
+module Ws_deque = Saturn_lockfree.Work_stealing_deque.M
+
+let run_one ~budgetf ?(n_domains = 1) () =
+  let spawns =
+    Array.init n_domains @@ fun _ -> ref 0 |> Multicore_magic.copy_as_padded
+  in
+  let deques = Array.init n_domains @@ fun _ -> Ws_deque.create () in
+  let exit = ref false |> Multicore_magic.copy_as_padded in
+
+  let next i =
+    let i = i + 1 in
+    if i = n_domains then 0 else i
+  in
+
+  let rec try_own own =
+    match Ws_deque.pop (Array.unsafe_get deques own) with
+    | work -> work
+    | exception Exit -> try_steal own (next own)
+  and try_steal own other =
+    if other = own then raise_notrace Exit
+    else
+      match Ws_deque.steal (Array.unsafe_get deques other) with
+      | work -> work
+      | exception Exit -> try_steal own (next other)
+  in
+  let rec run own =
+    match try_own own with
+    | work ->
+        work own;
+        run own
+    | exception Exit -> if not !exit then run own
+  in
+
+  let spawn own work =
+    incr (Array.unsafe_get spawns own);
+    let promise = ref (Obj.magic exit) in
+    Ws_deque.push (Array.unsafe_get deques own) (fun own -> promise := work own);
+    promise
+  in
+  let rec await own promise =
+    let x = !promise in
+    if x == Obj.magic exit then begin
+      begin
+        match try_own own with exception Exit -> () | work -> work own
+      end;
+      await own promise
+    end
+    else x
+  in
+
+  let rec fib n worker =
+    if n < 2 then n
+    else
+      let n2 = spawn worker (fib (n - 2)) in
+      let n1 = fib (n - 1) worker in
+      await worker n2 + n1
+  in
+
+  let rec bits n = if n <= 1 then 0 else 1 + bits (n lsr 1) in
+
+  let init own =
+    Array.unsafe_get spawns own := 0;
+    if own = 0 then begin
+      exit := false;
+      let n = 27 + bits n_domains in
+      spawn own (fun own ->
+          fib n own |> ignore;
+          exit := true)
+      |> ignore
+    end
+  in
+  let work own () = run own in
+
+  let config =
+    Printf.sprintf "%d worker%s" n_domains (if n_domains = 1 then "" else "s")
+  in
+  let times = Times.record ~budgetf ~n_domains ~init ~work () in
+  let n = Array.fold_left (fun n c -> n + !c) 0 spawns in
+  Times.to_thruput_metrics ~n ~singular:"spawn" ~config times
+
+let run_suite ~budgetf =
+  [ 1; 2; 4; 8 ]
+  |> List.concat_map @@ fun n_domains -> run_one ~budgetf ~n_domains ()
diff --git a/bench/benchmark_result.ml b/bench/benchmark_result.ml
deleted file mode 100644
index d3e5f5a2..00000000
--- a/bench/benchmark_result.ml
+++ /dev/null
@@ -1,52 +0,0 @@
-module Metric = struct
-  type t = {
-    name : string;
-    value : [ `Text of string | `Numeric of float ];
-    units : string;
-    description : string;
-  }
-
-  let to_json { name; value; units; description } =
-    let value_str =
-      match value with
-      | `Text text -> Printf.sprintf {|"%s"|} text
-      | `Numeric number -> Printf.sprintf {|%f|} number
-    in
-    Printf.sprintf
-      {| {"name":"%s", "value":%s, "units":"%s", "description":"%s"} |} name
-      value_str units description
-end
-
-type t = { name : string; metrics : Metric.t list }
-
-let to_json { name; metrics } =
-  let metrics = List.map Metric.to_json metrics |> String.concat ", " in
-  Printf.sprintf {| {"name": "%s", "metrics": [%s]} |} name metrics
-
-let create_generic ?median_time ?median_throughput name =
-  let time =
-    Option.map
-      (fun median_time : Metric.t ->
-        {
-          name = "time";
-          value = `Numeric median_time;
-          units = "s";
-          description = "median time result";
-        })
-      median_time
-  in
-  let throughput =
-    Option.map
-      (fun median_throughput : Metric.t ->
-        {
-          name = "throughput";
-          value = `Numeric median_throughput;
-          units = "item/s";
-          description = "median throughput result";
-        })
-      median_throughput
-  in
-  let metrics = [ time; throughput ] |> List.filter_map (fun v -> v) in
-  if metrics = [] then
-    failwith "Benchmark_result.create: require at least one metric";
-  ({ name; metrics } : t)
diff --git a/bench/benchmark_result.mli b/bench/benchmark_result.mli
deleted file mode 100644
index 82df289a..00000000
--- a/bench/benchmark_result.mli
+++ /dev/null
@@ -1,15 +0,0 @@
-module Metric : sig
-  type t = {
-    name : String.t;
-    value : [ `Text of string | `Numeric of float ];
-    units : String.t;
-    description : String.t;
-  }
-end
-
-type t = { name : String.t; metrics : Metric.t list }
-
-val to_json : t -> string
-
-val create_generic :
-  ?median_time:float -> ?median_throughput:float -> string -> t
diff --git a/bench/dune b/bench/dune
index 3e5cb1b2..91d4ac0f 100644
--- a/bench/dune
+++ b/bench/dune
@@ -1,3 +1,4 @@
-(executables
- (names main mpmc_queue_cmd)
- (libraries saturn unix yojson))
+(test
+ (package saturn)
+ (name main)
+ (libraries saturn multicore-bench multicore-magic))
diff --git a/bench/main.ml b/bench/main.ml
index 7f694502..0520b33a 100644
--- a/bench/main.ml
+++ b/bench/main.ml
@@ -1,32 +1,14 @@
-let benchmark_list =
+let benchmarks =
   [
-    Bench_spsc_queue.bench;
-    Mpmc_queue.bench ~takers:4 ~pushers:4;
-    Mpmc_queue.bench ~takers:1 ~pushers:8;
-    Mpmc_queue.bench ~takers:8 ~pushers:1;
-    Mpmc_queue.bench ~use_cas:true ~takers:4 ~pushers:4;
-    Mpmc_queue.bench ~use_cas:true ~takers:1 ~pushers:8;
-    Mpmc_queue.bench ~use_cas:true ~takers:8 ~pushers:1;
-    Bench_skiplist.bench ~workload_type:"read_heavy" ~num_elems:2000000
-      ~num_threads:2;
-    Bench_skiplist.bench ~workload_type:"moderate_heavy" ~num_elems:2000000
-      ~num_threads:2;
+    ("Saturn Relaxed_queue", Bench_relaxed_queue.run_suite);
+    ("Saturn_lockfree Queue", Bench_queue.run_suite);
+    ("Saturn_lockfree Single_prod_single_cons_queue", Bench_spsc_queue.run_suite);
+    ("Saturn_lockfree Size", Bench_size.run_suite);
+    ("Saturn_lockfree Skiplist", Bench_skiplist.run_suite);
+    ("Saturn_lockfree Stack", Bench_stack.run_suite);
+    ("Saturn_lockfree Work_stealing_deque", Bench_ws_deque.run_suite);
+    ("Stdlib Queue", Bench_stdlib_queue.run_suite);
+    ("Stdlib Stack", Bench_stdlib_stack.run_suite);
   ]
 
-let () =
-  let results =
-    (* todo: should assert no stranded domains between tests. *)
-    List.map (fun f -> f ()) benchmark_list
-    |> List.map Benchmark_result.to_json
-    |> String.concat ", "
-  in
-  let output =
-    Printf.sprintf {|{"results": [%s]}|} results
-    (* Cannot use Yojson rewriters as of today none works on OCaml 5.1.0.
-       This at least verifies that the manually crafted JSON is well-formed.
-
-       If the type grow, we could switch to running ppx manually on 5.0.0 and
-       pasting in its output. *)
-    |> Yojson.Basic.prettify
-  in
-  Printf.printf "%s" output
+let () = Multicore_bench.Cmd.run ~benchmarks ()
diff --git a/bench/mpmc_queue.ml b/bench/mpmc_queue.ml
deleted file mode 100644
index 1300145a..00000000
--- a/bench/mpmc_queue.ml
+++ /dev/null
@@ -1,99 +0,0 @@
-open Saturn.Relaxed_queue
-
-let num_of_elements = ref 500_000
-let num_of_pushers = ref 4
-let num_of_takers = ref 4
-let num_of_iterations = ref 10
-let use_cas_intf = ref false
-let pop = ref Not_lockfree.pop
-let push = ref Not_lockfree.push
-
-let taker queue num_of_elements () =
-  let i = ref 0 in
-  while !i < num_of_elements do
-    if Option.is_some (!pop queue) then i := !i + 1
-  done
-
-let pusher queue num_of_elements () =
-  let i = ref 0 in
-  while !i < num_of_elements do
-    if !push queue !i then i := !i + 1
-  done
-
-let create_output ~time_median ~throughput_median ~throughput_stddev =
-  let time =
-    ({
-       name = "time";
-       value = `Numeric time_median;
-       units = "s";
-       description = "median time";
-     }
-      : Benchmark_result.Metric.t)
-  in
-  let throughput =
-    ({
-       name = "throughput";
-       value = `Numeric throughput_median;
-       units = "item/s";
-       description = "median throughput";
-     }
-      : Benchmark_result.Metric.t)
-  in
-  let throughput_stddev =
-    ({
-       name = "throughput-stddev";
-       value = `Numeric throughput_stddev;
-       units = "item/s";
-       description = "stddev throughput";
-     }
-      : Benchmark_result.Metric.t)
-  in
-  let metrics = [ time; throughput; throughput_stddev ] in
-  let name =
-    Printf.sprintf "mpmc-queue-pushers:%d,takers:%d,use-cas:%b" !num_of_pushers
-      !num_of_takers !use_cas_intf
-  in
-  ({ name; metrics } : Benchmark_result.t)
-
-let run_bench () =
-  if !use_cas_intf then (
-    push := Saturn.Relaxed_queue.Not_lockfree.CAS_interface.push;
-    pop := Saturn.Relaxed_queue.Not_lockfree.CAS_interface.pop);
-  let queue = create ~size_exponent:10 () in
-  let orchestrator =
-    Orchestrator.init
-      ~total_domains:(!num_of_takers + !num_of_pushers)
-      ~rounds:!num_of_iterations
-  in
-  (* define function to start domains *)
-  let start_n_domains n f =
-    assert (!num_of_elements mod n == 0);
-    let items_per_pusher = !num_of_elements / n in
-    List.init n (fun _ ->
-        Domain.spawn (fun () ->
-            Orchestrator.worker orchestrator (f queue items_per_pusher)))
-  in
-  (* start domains *)
-  let domains =
-    let takers = start_n_domains !num_of_takers taker in
-    let pushers = start_n_domains !num_of_pushers pusher in
-    Sys.opaque_identity (pushers @ takers)
-  in
-  (* run test *)
-  let times = Orchestrator.run orchestrator in
-  List.iter Domain.join domains;
-  let time_median = Stats.median times in
-  let throughputs =
-    List.map (fun time -> Int.to_float !num_of_elements /. time) times
-  in
-  let throughput_median = Stats.median throughputs in
-  let throughput_stddev = Stats.stddev throughputs in
-  create_output ~time_median ~throughput_median ~throughput_stddev
-
-let bench ?takers ?pushers ?use_cas ?iterations ?elements () =
-  num_of_takers := Option.value takers ~default:!num_of_takers;
-  num_of_pushers := Option.value pushers ~default:!num_of_pushers;
-  use_cas_intf := Option.value use_cas ~default:!use_cas_intf;
-  num_of_iterations := Option.value iterations ~default:!num_of_iterations;
-  num_of_elements := Option.value elements ~default:!num_of_elements;
-  run_bench ()
diff --git a/bench/mpmc_queue.mli b/bench/mpmc_queue.mli
deleted file mode 100644
index 0cce0278..00000000
--- a/bench/mpmc_queue.mli
+++ /dev/null
@@ -1,8 +0,0 @@
-val bench :
-  ?takers:int ->
-  ?pushers:int ->
-  ?use_cas:bool ->
-  ?iterations:int ->
-  ?elements:int ->
-  unit ->
-  Benchmark_result.t
diff --git a/bench/mpmc_queue_cmd.ml b/bench/mpmc_queue_cmd.ml
deleted file mode 100644
index abf19c1b..00000000
--- a/bench/mpmc_queue_cmd.ml
+++ /dev/null
@@ -1,25 +0,0 @@
-let elements = ref 100_000
-let pushers = ref 4
-let takers = ref 4
-let iterations = ref 10
-let use_cas = ref false
-
-let speclist =
-  [
-    ("-items", Arg.Set_int elements, "number of items to insert and remove");
-    ("-pushers", Arg.Set_int pushers, "number of domains pushing items");
-    ("-takers", Arg.Set_int takers, "number of domains taking times");
-    ("-iterations", Arg.Set_int iterations, "run the benchmark this many times");
-    ("-use-cas", Arg.Set use_cas, "use CAS instead of FAD");
-  ]
-
-let _f () =
-  Arg.parse speclist
-    (fun _ -> ())
-    "mpmc_queue.exe [-items INT] [-pushers INT] [-takers INT] [-iterations \
-     INT] [-use-cas]";
-  let result =
-    Mpmc_queue.bench ~takers:!takers ~pushers:!pushers ~use_cas:!use_cas
-      ~iterations:!iterations ~elements:!elements ()
-  in
-  Benchmark_result.to_json result |> Yojson.Basic.prettify |> print_string
diff --git a/bench/orchestrator.ml b/bench/orchestrator.ml
deleted file mode 100644
index 41459861..00000000
--- a/bench/orchestrator.ml
+++ /dev/null
@@ -1,43 +0,0 @@
-type t = {
-  ready : int Atomic.t;
-  total_domains : int;
-  round : int Atomic.t;
-  rounds : int;
-}
-
-let init ~total_domains ~rounds =
-  { ready = Atomic.make 0; total_domains; round = Atomic.make 0; rounds }
-
-let wait_until_all_ready ?(round = 0) { ready; total_domains; _ } =
-  while Atomic.get ready < total_domains * (round + 1) do
-    ()
-  done
-
-let worker ({ ready; round; rounds; _ } as t) f =
-  Atomic.incr ready;
-  wait_until_all_ready t;
-  (* all domains are up at this point *)
-  for i = 1 to rounds do
-    (* wait for signal to start work *)
-    while Atomic.get round < i do
-      ()
-    done;
-    f ();
-    (* signal that we're done *)
-    Atomic.incr ready
-  done
-
-let run ?(drop_first = true) ({ round; rounds; _ } as t) =
-  wait_until_all_ready t;
-  (* all domains are up, can start benchmarks *)
-  let results = ref [] in
-  for i = 1 to rounds do
-    let start_time = Unix.gettimeofday () in
-    Atomic.incr round;
-    wait_until_all_ready ~round:i t;
-    let end_time = Unix.gettimeofday () in
-
-    let diff = end_time -. start_time in
-    if drop_first && i == 1 then () else results := diff :: !results
-  done;
-  !results
diff --git a/bench/orchestrator.mli b/bench/orchestrator.mli
deleted file mode 100644
index 074f57b5..00000000
--- a/bench/orchestrator.mli
+++ /dev/null
@@ -1,37 +0,0 @@
-(** Helper library that ensures all workers have started before any
-  starts making progress on the benchmark. *)
-
-type t
-(** An orchestrator is similar to a counter that ensures each domain
-    has started and complete each round simultanously. All domains
-    wait for the other before beginning the next round. *)
-
-val init : total_domains:int -> rounds:int -> t
-(** [init ~total_domains:nd ~rounds:nr] create an orchestrator that
-    will run [nr] rounds for a test that uses exactly [nd] worker
-    domains *)
-
-val worker : t -> (unit -> unit) -> unit
-(** [worker t f] builds the function to pass to [Domain.spawn] while
-    using the orchestrator [t]. Doing [Domain.spawn (fun () -> worker
-    t f)] is similar to [Domain.spawn f] except that the orchestrator
-    is used to synchronize all domains progress.
- *)
-
-val run : ?drop_first:bool -> t -> float List.t
-(** [run t] is launching the benchmark by enabling domains to progress. Benchmarks code should have the following structure :
-
-{[
-   (* Initialize the orchestrator, with [nd] the number of domains we want. *)
-   let orchestrator = init ~total_domain:nd ~round:100 in
-   (* Spawn domains with [worker] *)
-   let domains =
-         List.init nd (fun _ ->
-               Domain.spawn (fun () ->
-                      worker orchestrator (fun () -> some_function ()))) in
-   (* Run the benchmarks by freeing domains round by round. *)
-   let times = run orchestrator in
-   ...
-]}
-
-*)
diff --git a/bench/run_all.sh b/bench/run_all.sh
deleted file mode 100755
index 9c89283b..00000000
--- a/bench/run_all.sh
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/bin/bash
-set -x
-
-date=$(date)
-
-echo "$date" > benchmarks_output.txt
-
-with_cas=("" "-use-cas")
-rw_balance=("-takers 4 -pushers 4" "-takers 1 pushers 8" "-takers 8 pushers 1")
-path="./../_build/default/bench/mpmc_queue.exe "
-
-for i in "${with_cas[@]}" 
-do
-  for j in "${rw_balance[@]}" 
-  do
-	  cmd="$path $j $i"
-    output=$($cmd)
-
-    echo "$cmd" >> benchmarks_output.txt
-    echo "$output" >> benchmarks_output.txt
-  done 
-done
\ No newline at end of file
diff --git a/bench/stats.ml b/bench/stats.ml
deleted file mode 100644
index 3412b399..00000000
--- a/bench/stats.ml
+++ /dev/null
@@ -1,36 +0,0 @@
-let median data =
-  let data = List.sort Float.compare data in
-  let len = List.length data in
-  if len mod 2 == 1 then List.nth data (List.length data / 2)
-  else
-    let a = List.nth data ((len / 2) - 1) in
-    let b = List.nth data (len / 2) in
-    (a +. b) /. 2.
-
-let mean data =
-  let sum = List.fold_left (fun curr_sum b -> curr_sum +. b) 0. data in
-  let n = Int.to_float (List.length data) in
-  sum /. n
-
-let stddev data =
-  let mean = mean data in
-  let sum =
-    List.fold_left
-      (fun curr_sum datapoint ->
-        let squared_diff = Float.pow (datapoint -. mean) 2. in
-        curr_sum +. squared_diff)
-      0. data
-  in
-  let n = Int.to_float (List.length data) in
-  Float.sqrt (sum /. n)
-
-let cmp ?(epsilon = 0.01) a b = Float.abs (a -. b) < epsilon
-
-let sanity_checks () =
-  assert (cmp (mean [ 1.; 5. ]) 3.);
-  assert (cmp (mean [ 1.; 3.; 7. ]) 3.6666);
-  assert (cmp (stddev [ 1.; 5. ]) 2.);
-  assert (cmp (stddev [ 1.; 3.; 7. ]) 2.4944)
-;;
-
-sanity_checks ()
diff --git a/bench/stats.mli b/bench/stats.mli
deleted file mode 100644
index acd900a5..00000000
--- a/bench/stats.mli
+++ /dev/null
@@ -1,3 +0,0 @@
-val mean : float List.t -> float
-val stddev : float List.t -> float
-val median : float List.t -> float
diff --git a/dune-project b/dune-project
index c4f875e7..31aff107 100644
--- a/dune-project
+++ b/dune-project
@@ -15,6 +15,7 @@
   (domain_shims (and (>= 0.1.0) :with-test))
   (saturn_lockfree (= :version))
   (multicore-magic (and (>= 2.1.0) :with-test))
+  (multicore-bench (and (>= 0.1.0) :with-test))
   (alcotest (and (>= 1.7.0) :with-test))
   (qcheck (and (>= 0.21.3) :with-test))
   (qcheck-stm (and (>= 0.3) :with-test))
diff --git a/saturn.opam b/saturn.opam
index 84408978..d3268a71 100644
--- a/saturn.opam
+++ b/saturn.opam
@@ -14,6 +14,7 @@ depends: [
   "domain_shims" {>= "0.1.0" & with-test}
   "saturn_lockfree" {= version}
   "multicore-magic" {>= "2.1.0" & with-test}
+  "multicore-bench" {>= "0.1.0" & with-test}
   "alcotest" {>= "1.7.0" & with-test}
   "qcheck" {>= "0.21.3" & with-test}
   "qcheck-stm" {>= "0.3" & with-test}