Add --cache flag to benchmarks for LRU cache testing

Runners accept an optional ~cache parameter that wraps the backend
with Backend.cached. The main CLI exposes --cache N to set the
capacity. Names include "+cache" suffix when cache is active.

Co-Authored-By: Claude Opus 4.6 <[e-mail]>

bench/bench_irmin4.ml

···
     Measures write throughput and commit overhead. *)
 let scenario_commits ~name ~(backend : Hash.sha1 Backend.t)
     (conf : Bench_common.config) =
-  let store = Store.Git.create ~backend in
+  let store = Store.Git.create ~backend () in
   let paths =
     Array.init (conf.tree_add + 1) (Bench_common.path ~depth:conf.depth)
   in
···
     Populates a tree, then reads random entries. Measures read throughput. *)
 let scenario_reads ~name ~(backend : Hash.sha1 Backend.t)
     (conf : Bench_common.config) =
-  let store = Store.Git.create ~backend in
+  let store = Store.Git.create ~backend () in
   let paths =
     Array.init (conf.tree_add + 1) (Bench_common.path ~depth:conf.depth)
   in
···
     Measures overhead of small updates on a large tree. *)
 let scenario_incremental ~name ~(backend : Hash.sha1 Backend.t)
     (conf : Bench_common.config) =
-  let store = Store.Git.create ~backend in
+  let store = Store.Git.create ~backend () in
   let paths =
     Array.init (conf.tree_add + 1) (Bench_common.path ~depth:conf.depth)
   in
···
 let scenario_large_values ~name ~(backend : Hash.sha1 Backend.t)
     (conf : Bench_common.config) =
   let large_size = 10_000 in
-  let store = Store.Git.create ~backend in
+  let store = Store.Git.create ~backend () in
   let npaths = min conf.tree_add 200 in
   let paths =
     Array.init (npaths + 1) (Bench_common.path ~depth:conf.depth)
···
 
 (** {1 Backend runners} *)
 
-let run_all_memory conf =
-  let name = "Irmin4 (memory)" in
-  let mk () = Backend.Memory.create_sha1 () in
+let run_all_memory ?(cache = 0) conf =
+  let suffix = if cache > 0 then "+cache" else "" in
+  let name = "Irmini" ^ suffix ^ " (memory)" in
+  let mk () =
+    let b = Backend.Memory.create_sha1 () in
+    if cache > 0 then Backend.cached ~capacity:cache b else b
+  in
   [
     scenario_commits ~name ~backend:(mk ()) conf;
     scenario_reads ~name ~backend:(mk ()) conf;
···
     scenario_large_values ~name ~backend:(mk ()) conf;
   ]
 
-let run_all_disk ~sw ~env root conf =
-  let name = "Irmin4 (disk)" in
-  let mk () = Backend.Disk.create_sha1 ~sw root in
+let run_all_disk ?(cache = 0) ~sw ~env root conf =
+  let suffix = if cache > 0 then "+cache" else "" in
+  let name = "Irmini" ^ suffix ^ " (disk)" in
+  let mk () =
+    let b = Backend.Disk.create_sha1 ~sw root in
+    if cache > 0 then Backend.cached ~capacity:cache b else b
+  in
   let run_one f =
     let backend = mk () in
     Fun.protect ~finally:(fun () -> backend.close ()) (fun () -> f ~backend)

bench/bench_irmin4_lavyek.ml

···
     Each scenario gets a fresh Lavyek store in a separate subdirectory
     to avoid WAL replay issues between runs. *)
 
-let run_all ~sw ~env root (conf : Bench_common.config) =
-  let name = "Irmin4 (lavyek)" in
+let run_all ?(cache = 0) ~sw ~env root (conf : Bench_common.config) =
+  let suffix = if cache > 0 then "+cache" else "" in
+  let name = "Irmini" ^ suffix ^ " (lavyek)" in
   let n = ref 0 in
   let run_one f =
     incr n;
     let subdir = Eio.Path.(root / Printf.sprintf "scenario_%d" !n) in
-    let backend = Backend_lavyek.create ~sw subdir in
+    let b = Backend_lavyek.create ~sw subdir in
+    let backend =
+      if cache > 0 then Irmin.Backend.cached ~capacity:cache b else b
+    in
     Fun.protect
       ~finally:(fun () -> backend.Irmin.Backend.close ())
       (fun () -> f ~backend)

bench/bench_irmin4_main.ml

···
-(** Irmin4 benchmark runner.
+(** Irmini benchmark runner.
 
-    Benchmarks Irmin4 with memory, disk, and lavyek backends across
+    Benchmarks Irmini with memory, disk, and lavyek backends across
     multiple scenarios: commits, reads, incremental updates, large values.
+    Optionally runs with LRU cache enabled.
 
     Usage: bench_irmin4_main [--ncommits N] [--tree-add N] [--depth N]
                              [--nreads N] [--value-size N]
-                             [--skip-lavyek] [--skip-disk] *)
+                             [--skip-lavyek] [--skip-disk]
+                             [--cache N] *)
 
 let () =
   let ncommits = ref 100 in
···
   let value_size = ref 100 in
   let skip_lavyek = ref false in
   let skip_disk = ref false in
+  let cache = ref 0 in
   Arg.parse
     [
       ("--ncommits", Arg.Set_int ncommits, "Number of commits (default: 100)");
···
        "Size of values in bytes (default: 100)");
       ("--skip-lavyek", Arg.Set skip_lavyek, "Skip Lavyek backend benchmark");
       ("--skip-disk", Arg.Set skip_disk, "Skip disk backend benchmark");
+      ("--cache", Arg.Set_int cache,
+       "LRU cache capacity (default: 0 = no cache)");
     ]
     (fun _ -> ())
-    "bench_irmin4 - Irmin4 performance benchmarks";
+    "bench_irmin4 - Irmini performance benchmarks";
   let conf : Bench_common.config =
     {
       ncommits = !ncommits;
···
       value_size = !value_size;
     }
   in
+  let cache = !cache in
   Format.printf
     "Configuration: %d commits, %d adds/commit, depth %d, %d reads, \
-     %d-byte values@.@."
-    conf.ncommits conf.tree_add conf.depth conf.nreads conf.value_size;
+     %d-byte values%s@.@."
+    conf.ncommits conf.tree_add conf.depth conf.nreads conf.value_size
+    (if cache > 0 then Printf.sprintf ", cache=%d" cache else "");
   Eio_main.run @@ fun env ->
   let cwd = Eio.Stdenv.cwd env in
   let results = ref [] in
···
     in
     (try rm path with _ -> ())
   in
-  (* 1. Irmin4 memory *)
-  Format.printf "--- Irmin4 (memory) ---@.@.";
-  let rs = Bench_irmin4.run_all_memory conf in
-  List.iter (fun r -> Format.printf "%a@.@." Bench_common.pp_result r) rs;
-  results := rs @ !results;
-  (* 2. Irmin4 disk *)
+  let run name rs =
+    Format.printf "--- %s ---@.@." name;
+    List.iter (fun r -> Format.printf "%a@.@." Bench_common.pp_result r) rs;
+    results := rs @ !results
+  in
+  (* 1. Irmini memory *)
+  run "Irmini (memory)" (Bench_irmin4.run_all_memory ~cache conf);
+  (* 2. Irmini disk *)
   if not !skip_disk then begin
-    Format.printf "--- Irmin4 (disk) ---@.@.";
     Eio.Switch.run @@ fun sw ->
     let root = Eio.Path.(cwd / "_build/_bench_disk") in
     rm_rf root;
-    let rs = Bench_irmin4.run_all_disk ~sw ~env root conf in
-    List.iter (fun r -> Format.printf "%a@.@." Bench_common.pp_result r) rs;
-    results := rs @ !results
+    run "Irmini (disk)" (Bench_irmin4.run_all_disk ~cache ~sw ~env root conf)
   end;
-  (* 3. Irmin4 + Lavyek *)
+  (* 3. Irmini + Lavyek *)
   if not !skip_lavyek then begin
-    Format.printf "--- Irmin4 (lavyek) ---@.@.";
     Eio.Switch.run @@ fun sw ->
     let root = Eio.Path.(cwd / "_build/_bench_lavyek") in
     rm_rf root;
-    let rs = Bench_irmin4_lavyek.run_all ~sw ~env root conf in
-    List.iter (fun r -> Format.printf "%a@.@." Bench_common.pp_result r) rs;
-    results := rs @ !results
+    run "Irmini (lavyek)"
+      (Bench_irmin4_lavyek.run_all ~cache ~sw ~env root conf)
   end;
   (* Summary *)
   Bench_common.pp_comparison Format.std_formatter (List.rev !results)