coop/rose-ash
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

JIT: Phase 2 (LRU eviction) + Phase 3 (manual reset)
Some checks failed
Test, Build, and Deploy / test-build-deploy (push) Failing after 46s
Details

Browse Source 
sx_types.ml:
  - Add l_uid field on lambda (unique identity for cache tracking)
  - Add lambda_uid_counter + next_lambda_uid () minted on construction
  - Add jit_budget (default 5000) and jit_evicted_count counter
  - Add jit_cache_queue : (int * value) Queue.t — FIFO of compiled lambdas
  - jit_cache_size () helper for stats

sx_vm.ml:
  - On successful JIT compile, push (uid, Lambda l) onto jit_cache_queue
  - While queue length exceeds jit_budget, pop head (oldest entry) and
    clear that lambda's l_compiled slot — evicted entries fall through
    to cek_call_or_suspend on next call (correct, just slower)
  - Guard JIT trigger by !jit_budget > 0 (budget=0 disables JIT entirely)

sx_primitives.ml:
  Phase 2:
    - jit-set-budget! N — change cache budget at runtime
    - jit-stats includes budget, cache-size, evicted
  Phase 3:
    - jit-reset-cache! — clear all compiled VmClosures (hot paths re-JIT
      on next threshold crossing)
    - jit-reset-counters! also resets evicted counter

run_tests.ml:
  - Update test-fixture lambda construction to include l_uid

Effect: cache size bounded regardless of input pattern. The HS test harness
compiles ~3000 distinct one-shot lambdas, but tiered compilation (Phase 1)
keeps most below threshold so they never enter the cache. Steady-state count
stays in single digits for typical workloads. When a misbehaving caller
saturates the cache (eval-hs in a tight loop, REPL-style host), LRU
eviction caps memory at jit_budget compiled closures × ~1KB each.

Verification: 4771 passed, 1111 failed in run_tests — identical to
pre-Phase-2 baseline. No regressions.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
giles
2026-05-11 22:22:37 +00:00
parent 29ef89d473
commit 1f466186f9
4 changed files with 64 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
hosts/ocaml/lib/sx_primitives.ml
View File

@@ -3146,17 +3146,34 @@ let () =
register "jit-stats" (fun _args ->
let d = Hashtbl.create 8 in
Hashtbl.replace d "threshold" (Number (float_of_int !Sx_types.jit_threshold));
Hashtbl.replace d "budget" (Number (float_of_int !Sx_types.jit_budget));
Hashtbl.replace d "cache-size" (Number (float_of_int (Sx_types.jit_cache_size ())));
Hashtbl.replace d "compiled" (Number (float_of_int !Sx_types.jit_compiled_count));
Hashtbl.replace d "compile-failed" (Number (float_of_int !Sx_types.jit_skipped_count));
Hashtbl.replace d "below-threshold" (Number (float_of_int !Sx_types.jit_threshold_skipped_count));
Hashtbl.replace d "evicted" (Number (float_of_int !Sx_types.jit_evicted_count));
Dict d);
register "jit-set-threshold!" (fun args ->
match args with
| [Number n] -> Sx_types.jit_threshold := int_of_float n; Nil
| [Integer n] -> Sx_types.jit_threshold := n; Nil
| _ -> raise (Eval_error "jit-set-threshold!: (n) where n is integer"));
register "jit-set-budget!" (fun args ->
match args with
| [Number n] -> Sx_types.jit_budget := int_of_float n; Nil
| [Integer n] -> Sx_types.jit_budget := n; Nil
| _ -> raise (Eval_error "jit-set-budget!: (n) where n is integer"));
register "jit-reset-cache!" (fun _args ->
(* Phase 3 manual cache reset — clear all compiled VmClosures.
Hot paths will re-JIT on next call (after re-hitting threshold). *)
Queue.iter (fun (_, v) ->
match v with Lambda l -> l.l_compiled <- None | _ -> ()
) Sx_types.jit_cache_queue;
Queue.clear Sx_types.jit_cache_queue;
Nil);
register "jit-reset-counters!" (fun _args ->
Sx_types.jit_compiled_count := 0;
Sx_types.jit_skipped_count := 0;
Sx_types.jit_threshold_skipped_count := 0;
Sx_types.jit_evicted_count := 0;
Nil)