simon/jolt
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Chez Phase 1 (increment 3j): assemble the clojure.core prelude, -e-capable jolt-chez

Browse source 
Emit every non-macro clojure.core form through the live analyzer -> Chez emit
pipeline as a def-var! prelude (prelude mode, tier dependency order), load it
before a user expression, and you get an -e-capable jolt-chez: analysis on Janet,
execution on Chez. driver/emit-core-prelude assembles it (each form behind a
silent load guard so the Phase-2 multimethod forms don't break the rest);
bin/jolt-chez is the -e CLI, caching the prelude on disk keyed by source hash.

run-corpus-prelude.janet is the full parity gate this opens, the prelude-backed
sibling of run-corpus-chez. First baseline: 1220/2497 evaluated cases pass, 0 new
divergences (10 allowlisted: dynamic vars, class names, eval-order — deferred
Phase 2). The rest is the punch-list: ~360 emit-fail (real host interop, out of
the analyzer subset) and ~900 runtime crashes, mostly core fns calling
host-coupled seed natives with no Chez shim yet (str/format/vec, transients).
Follow-ups jolt-t6cr/kl2l/q3w8/9ls5.

Two shims landed to get the prelude to load and run. atoms.ss: atom/deref/swap!/
reset! (+ the compare/vals kernel) — needed at load time for
global-hierarchy = (atom (make-hierarchy)). predicates.ss: the type predicates +
name/namespace/boolean the overlay assumes are seed natives, matching the seed's
strict semantics. post-prelude.ss re-asserts char?/atom? after the prelude: the
overlay implements those by reading :jolt/type, which is false for Chez-native
chars/atoms, so its def-var! would clobber the correct native versions.

Per-case Scheme files are PID-unique so a foreground -e never reads a half-written
file while the gate runs.
This commit is contained in:
Yogthos 2026-06-17 20:50:42 -04:00
parent 37c433bd4a
commit 0c9c7931fe
10 changed files with 512 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

42
test/chez/README.md
View file

@ -88,6 +88,48 @@ Janet PEG). Prior incs: inc 3h `.method` → `:host-call` (`jolt-host-call` for
`letfn` → `letrec*`, `declare`/def-no-init → reserved var cell. The probe has a
regression floor (355) — every non-macro core form must keep emitting.
## Phase 1 — the assembled prelude: -e-capable jolt-chez (inc 3j, jolt-9ziu)
Once the whole non-macro clojure.core emits (inc 3i), the milestone is to ASSEMBLE
it: `driver/emit-core-prelude` emits every non-macro core form across the
dependency-ordered tiers as a `def-var!` (prelude mode), concatenated into a
Scheme prelude. `bin/jolt-chez -e EXPR` loads `rt.ss` + that prelude + a
post-prelude override, emits the user expression in prelude mode, and runs it on
Chez — an `-e`-capable jolt-chez (analysis on Janet, execution on Chez). The
prelude is cached on disk keyed by a fingerprint of the core sources + the RT.
`run-corpus-prelude.janet` is the full parity gate this opens (the prelude-backed
sibling of `run-corpus-chez.janet`): it assembles the prelude once, then runs every
corpus case with all of core present, bucketing the result —
JOLT_CHEZ_PRELUDE_CORPUS=1 janet test/chez/run-corpus-prelude.janet
JOLT_CORPUS_LIMIT=200 … (every-Nth stride, fast)
First parity baseline (inc 3j): **1220/2497** evaluated cases pass, 0 NEW
divergences (10 allowlisted: dynamic vars `*ns*`/`*clojure-version*`/`*unchecked-math*`,
class names, eval-order, with-open — all deferred Phase-2 / dynamic-var gaps).
The remaining buckets are the punch-list the next increments chase: ~360 emit-fail
(genuine host interop — qualified Java/Janet refs, runtime `defmacro`/`eval`, out of
the analyzer's subset) and ~900 runtime crashes, dominated by core fns calling
host-coupled seed natives with no Chez shim yet (`str`/`format`/`vec`/transients —
inc 3k/3l, jolt-t6cr/jolt-kl2l), plus smaller buckets (`##Inf`/`##NaN` literals →
unbound `inf`/`nan`, seq-prim transducer arities — inc 3m jolt-q3w8; multimethod
dispatch — Phase 2 jolt-9ls5).
Two host shims landed with the prelude. `host/chez/atoms.ss`: atom/deref/swap!/
reset! (+ compare-and-set!/swap-vals!/reset-vals!) — host-coupled mutable cells the
overlay assumes are native; needed at the prelude's LOAD time
(`global-hierarchy = (atom (make-hierarchy))`). `host/chez/predicates.ss`: the type
predicates + `name`/`namespace`/`boolean` the overlay assumes are seed natives
(`nil?`/`number?`/`string?`/`map?`/`vector?`/`set?`/`seq?`/`coll?`/`fn?`/…), matching
the seed's strict semantics. `host/chez/post-prelude.ss` re-asserts `char?`/`atom?`
AFTER the prelude — the overlay implements those two by reading a value's
`:jolt/type` key (a Janet-host assumption that's false for Chez-native chars/atoms),
and its `def-var!` would otherwise clobber the correct native shims.
The 8 print-method/print-dup `defmulti`/`defmethod` forms (50-io) can't LOAD yet
(no multimethod runtime on Chez — Phase 2); a silent load guard in the assembled
prelude lets the rest load and turns them into lazy gaps.
Prior, inc 3b (seq tier + dynamic IFn, jolt-5pso): 595/595 compiled, 0 divergences,
2060/2655 out of subset. The seq tier brought up a list/lazy-seq type with
first/rest/next/seq/cons/list, map/filter/reduce/into/remove,

45
test/chez/emit-test.janet
View file

@ -353,6 +353,51 @@
(string/find "frequencies" (scm 1)))
(string/format "%p" scm)))
# 3n) atoms (jolt-9ziu): atom/deref/swap!/reset! are host-coupled (stay in the
# Janet seed, no overlay def-var!), so the Chez host needs an RT shim
# (host/chez/atoms.ss). They lower to var-deref in prelude mode. The hierarchy
# machinery (global-hierarchy = (atom (make-hierarchy))) needs `atom` at the
# prelude's LOAD time, so this is a load blocker, not just a lazy gap. swap!
# invokes its fn through jolt-invoke; compare-and-set!/swap-vals!/reset-vals!
# are overlay fns that compose the native kernel.
(each src ["(deref (atom 42))"
"@(atom 99)"
"(let [a (atom 0)] (reset! a 7) (deref a))"
"(let [a (atom 0)] (swap! a inc) (swap! a inc) (deref a))"
"(let [a (atom 10)] (swap! a + 5) (deref a))"
"(let [a (atom 1)] (reset! a 2) [(deref a) @a])"
"(let [a (atom 0)] (compare-and-set! a 0 5) (deref a))"
"(let [a (atom 0)] (compare-and-set! a 9 5) (deref a))"]
(let [[code out err] (run-prelude src) want (cli-oracle src)]
(ok (string "atom: " src) (and (= code 0) (= out want))
(string "chez=" out " janet=" want " | " err))))
# 3o) type predicates + name/namespace (jolt-9ziu): seed natives the overlay
# assumes; the Chez host shims them (host/chez/predicates.ss) and def-var!s them
# into clojure.core, so they resolve in prelude mode. Semantics match the seed
# (core_types.janet): map?/vector?/set? strict over the persistent records,
# seq? only for real sequences, coll? the union. Parity vs the CLI oracle.
(each src ["(nil? nil)" "(nil? 0)"
"(number? 3)" "(number? :a)" "(string? \"x\")" "(string? 1)"
"(integer? 3)" "(integer? 3.5)"
"(symbol? 'x)" "(keyword? :x)" "(keyword? 'x)"
"(map? {:a 1})" "(map? [1 2])"
"(vector? [1 2])" "(vector? '(1 2))"
"(set? #{1 2})" "(set? [1])"
# NB: (seq? (seq [1 2])) is true on Chez (Clojure-correct — a seq IS a
# seq) but the seed oracle returns false (non-canonical), so it's not a
# like-for-like cli-oracle comparison; the corpus encodes the canonical
# value, where Chez agrees. Test seq? on the unambiguous cases here.
"(seq? [1 2])" "(seq? '(1 2))"
"(coll? [1])" "(coll? {:a 1})" "(coll? 3)"
"(fn? inc)" "(fn? 3)"
"(boolean nil)" "(boolean 5)"
"(name :foo)" "(name 'bar)" "(name \"baz\")"
"(namespace :a/b)" "(namespace :x)"]
(let [[code out err] (run-prelude src) want (cli-oracle src)]
(ok (string "pred: " src) (and (= code 0) (= out want))
(string "chez=" out " janet=" want " | " err))))
# 4) perf signal: emitted fib(30) in-Scheme timing (excludes Chez startup), to
# track against the spike ceiling (hand-Scheme fib ~5ms). Informational — the
# jolt-truthy? wrapper (~3x) and flonum modeling are known Phase-4 levers.

134
test/chez/run-corpus-prelude.janet Normal file
View file

@ -0,0 +1,134 @@
# Phase 1 (jolt-cf1q.2, inc 3j) — FULL parity against the -e-capable jolt-chez.
#
# run-corpus-chez.janet measures parity for the SUBSET the back end can compile
# without any clojure.core present (most cases are "out of subset" because they
# call core fns). This runner closes that gap: it assembles the ENTIRE non-macro
# clojure.core as a Scheme prelude (driver/emit-core-prelude — def-var! forms in
# tier dependency order), loads it before each case, and emits the case in
# prelude mode so every core ref resolves via var-deref. That is exactly the
# -e-capable jolt-chez the milestone calls for, measured in-process (one ctx,
# prelude assembled once) rather than via a spawned binary per case.
#
# With all of core available, "out of subset" collapses to genuine emit failures
# (host interop / unsupported IR). The new signal is RUNTIME parity: a case that
# emits but crashes (a missing/blank runtime prim — a lazy gap) or returns a
# wrong value (a divergence). The report buckets these so the gaps form a
# punch-list for the next increments.
# JOLT_CHEZ_PRELUDE_CORPUS=1 janet test/chez/run-corpus-prelude.janet
# JOLT_CORPUS_LIMIT=200 … (every-Nth stride, fast)
(import ../../host/chez/driver :as d)
(unless (os/getenv "JOLT_CHEZ_PRELUDE_CORPUS")
(print "skip: set JOLT_CHEZ_PRELUDE_CORPUS=1 to run the prelude parity gate")
(os/exit 0))
(unless (d/chez-available?)
(print "skip: chez not on PATH")
(os/exit 0))
(def corpus (parse (slurp "test/chez/corpus.edn")))
(def cases
(if-let [n (os/getenv "JOLT_CORPUS_LIMIT")]
(let [stride (max 1 (math/floor (/ (length corpus) (scan-number n))))]
(seq [i :range [0 (length corpus) stride]] (in corpus i)))
corpus))
# Known divergences: cases that emit + run on Chez but yield a non-canonical
# value because of a gap beyond this increment. The gate fails only on a NEW
# (un-allowlisted) divergence — a real Chez correctness regression. Each here is
# a deferred Phase-2 / dynamic-var / eval-order gap, NOT a wrong shim:
# - class names ((class x), .getName) — no Chez class system yet (Phase 2)
# - *ns* / *clojure-version* / *unchecked-math* — dynamic vars not bound on Chez
# - eval-order probes — assert left-to-right side-effect order via host state
# the emitted Scheme doesn't yet reproduce
# - close on throw — with-open/finally resource close semantics
(def known-divergences
{"class name evaluates to canonical string" true
"dispatch-only class name" true
"inside class" true
"values evaluate in source order" true
"keys evaluate before their values, pairwise" true
"source order with a nil value (phm form)" true
"close on throw" true
"ns-name of *ns*" true
"*clojure-version* major" true
"*unchecked-math*" true})
(def ctx (d/make-ctx))
# Assemble the prelude once and write it to a file the per-case programs `load`.
(def t0 (os/clock))
(def [prelude-scm emitted total] (d/emit-core-prelude ctx))
(def prelude-path (string "/tmp/jolt-chez-prelude-" (os/getpid) ".ss"))
(spit prelude-path prelude-scm)
(printf "prelude: %d/%d non-macro core forms emitted (%.1fs, %d bytes) -> %s"
emitted total (- (os/clock) t0) (length prelude-scm) prelude-path)
(flush)
(var pass 0)
(def emit-errs @[]) # user form can't emit (host interop / unsupported IR)
(def crashes @[]) # emitted, chez exited non-zero (lazy runtime gap or bug)
(def diverged @[]) # emitted + ran, NEW wrong value (fails the gate)
(def known-hit @[]) # emitted + ran, allowlisted wrong value (tolerated)
(def crash-keys @{}) # grouped crash reason -> count
(def emit-keys @{}) # grouped emit-failure reason -> count
(defn- bucket [tbl k] (put tbl k (+ 1 (or (get tbl k) 0))))
(defn- crash-reason [err]
(def e (string err))
(if-let [i (string/find "Exception" e)]
(string/slice e i (min (length e) (+ i 70)))
(string/slice e 0 (min 60 (length e)))))
(defn- emit-reason [msg]
(def m (string msg))
(cond
(string/find "out of subset" m) (let [i (string/find "`" m)]
(if i (string "core fn: " (string/slice m (inc i) (or (string/find "`" m (inc i)) (length m)))) "out-of-subset"))
(string/find "host" m) "host-interop"
(string/find "unhandled op" m) (string/slice m (max 0 (- (length m) 28)))
(string/slice m 0 (min 48 (length m)))))
(def t1 (os/clock))
(each row cases
(def {:expected e :actual a :label l} row)
(if (= e :throws)
nil # :throws error-semantics aren't modeled here; skip (counted out of run)
(let [src (string "(= " e " " a ")")
res (d/eval-e-with-prelude ctx src prelude-path)]
(cond
(= (get res 0) :emit-err)
(let [k (emit-reason (get res 1))] (bucket emit-keys k) (array/push emit-errs [l k]))
(not= (get res 0) 0)
(let [k (crash-reason (get res 2))] (bucket crash-keys k) (array/push crashes [l k]))
(= (get res 1) "true") (++ pass)
(known-divergences l) (array/push known-hit l)
(array/push diverged [l (string "got " (get res 1))])))))
(def n-eval (+ pass (length emit-errs) (length crashes) (length diverged) (length known-hit)))
(printf "\nPrelude parity: %d/%d evaluated cases pass (%.1fs)" pass n-eval (- (os/clock) t1))
(printf " emit-fail (out of subset): %d runtime crash: %d NEW divergence: %d known divergence: %d"
(length emit-errs) (length crashes) (length diverged) (length known-hit))
(defn- report [title tbl]
(when (> (length tbl) 0)
(printf "\n%s:" title)
(each k (sort-by (fn [k] (- (get tbl k))) (keys tbl))
(printf " %4d x %s" (get tbl k) k))))
(report "emit-failure reasons" emit-keys)
(report "runtime-crash reasons" crash-keys)
(when (> (length diverged) 0)
(printf "\nNEW divergences (emit+ran, wrong value) — gate FAILS:")
(each [l m] (slice diverged 0 (min 30 (length diverged)))
(printf " [%s] %s" l m)))
(when (> (length known-hit) 0)
(printf "\n%d known (allowlisted) divergences tolerated." (length known-hit)))
(flush)
# Regression floor (inc 3j baseline): raise as runtime gaps close, like the probe
# reach-floor and the suite baseline. The gate fails if parity drops below it, or
# on any NEW (un-allowlisted) divergence — a real Chez correctness regression.
# Full-corpus baseline at inc 3j: 1220/2497. Strided runs scale the floor down.
(def base-floor (scan-number (or (os/getenv "JOLT_CHEZ_PRELUDE_FLOOR") "1220")))
(def floor (if (os/getenv "JOLT_CORPUS_LIMIT") 0 base-floor))
(when (or (> (length diverged) 0) (< pass floor))
(printf "REGRESSION: pass %d < floor %d or %d new divergence(s)" pass floor (length diverged)))
(os/exit (if (or (> (length diverged) 0) (< pass floor)) 1 0))