ocaml/test/old/test_brass_cue.ml


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

(* Test cuing the massive brass/prod pill *)

open Nock_lib

let test_brass env =
  Printf.printf "🚀 Testing Brass/Prod Pill Cue\n\n";

  Eio.Switch.run @@ fun _sw ->
  let fs = Eio.Stdenv.fs env in

  (* Load brass pill *)
  Printf.printf "Loading prod.pill (169 MB - this may take a moment)...\n%!";
  let file_path = Eio.Path.(fs / "prod.pill") in

  let load_start = Unix.gettimeofday () in
  let pill_bytes = Eio.Path.load file_path |> Bytes.of_string in
  let load_time = Unix.gettimeofday () -. load_start in

  let size_mb = float_of_int (Bytes.length pill_bytes) /. 1024.0 /. 1024.0 in
  Printf.printf "✓ Loaded %.1f MB in %.2fs\n\n" size_mb load_time;

  (* Cue with progress *)
  Printf.printf "Starting cue (this is 20x bigger than solid pill!)...\n%!";

  let last_tick = ref (Unix.gettimeofday ()) in
  let start = Unix.gettimeofday () in

  let progress ~nouns ~bits ~depth ~max_depth =
    let now = Unix.gettimeofday () in
    if now -. !last_tick >= 1.0 then begin
      let mb = float_of_int bits /. 8.0 /. 1024.0 /. 1024.0 in
      let pct = (float_of_int bits /. 8.0) /. float_of_int (Bytes.length pill_bytes) *. 100.0 in
      let elapsed = now -. start in
      let throughput = mb /. elapsed in
      Printf.printf "  %.1fs | %.1f MB (%.1f%%) | %dk nouns | depth %d/%d | %.2f MB/s\n%!"
        elapsed mb pct (nouns / 1000) depth max_depth throughput;
      last_tick := now
    end
  in

  let pill = Serial.cue ~progress ~progress_interval:100_000 pill_bytes in
  let elapsed = Unix.gettimeofday () -. start in

  Printf.printf "\n✓ Cued in %.1fs!\n\n" elapsed;

  let throughput = size_mb /. elapsed in
  Printf.printf "Performance:\n";
  Printf.printf "  Size: %.1f MB\n" size_mb;
  Printf.printf "  Time: %.1fs\n" elapsed;
  Printf.printf "  Throughput: %.2f MB/s\n\n" throughput;

  (* Compare to solid pill *)
  let solid_time = 1.2 in
  let solid_size = 8.7 in
  let size_ratio = size_mb /. solid_size in
  let time_ratio = elapsed /. solid_time in

  Printf.printf "Comparison to solid pill:\n";
  Printf.printf "  Size ratio: %.1fx bigger\n" size_ratio;
  Printf.printf "  Time ratio: %.1fx slower\n" time_ratio;
  Printf.printf "  Scaling: %.1f%% linear\n" ((size_ratio /. time_ratio) *. 100.0);

  if time_ratio <= size_ratio *. 1.2 then
    Printf.printf "\n🎉 Excellent scaling! Performance is near-linear!\n"
  else
    Printf.printf "\n⚠️ Non-linear scaling detected\n";

  (* Check structure *)
  Printf.printf "\nExamining structure...\n";
  match pill with
  | Noun.Cell (tag, _events) ->
      begin match tag with
      | Noun.Atom a ->
          Printf.printf "  Tag: %s (hex: 0x%s)\n" (Z.to_string a) (Z.format "x" a);
          if Z.equal a (Z.of_string "1819044208") then
            Printf.printf "  ✓ Valid 'llip' tag\n"
      | _ -> Printf.printf "  Tag: cell\n"
      end
  | _ ->
      Printf.printf "  ✗ Not a cell\n"

let () =
  Printf.printf "\n";
  Printf.printf "═══════════════════════════════════════════════════════════\n";
  Printf.printf " Brass/Prod Pill Cue Test\n";
  Printf.printf "═══════════════════════════════════════════════════════════\n";
  Printf.printf "\n";

  Eio_main.run test_brass