bd9e542c78
A ^Record param hint was applied only at the final re-emit (reinfer-def), not during the inter-procedural fixpoint. So a hinted param with no callers stayed :any while inference ran, and a field read off it (e.g. (:origin ^Ray r)) never told a non-inlined callee that its arg is a Vec3 — the callee's params stayed unproven and its field reads kept the dynamic guard. Seed declared hints as a param-type floor in the fixpoint: phint-seed (passes/ types) resolves an arity's :phints to positional record types via the record-shapes registry, and infer-unit! initializes each fn's fresh param slots from them instead of nil. A fixed declared type can't poison the least-fixpoint the way an early-iteration :any would, and a hinted param now propagates its (and its field reads') types to its callees during inference. Scope: this closes the hinted-propagation gap. It does NOT help the ray tracer, which uses zero ^-hinted params (only hinted fields) — its remaining type gap is unhinted record-param inference on recursive/non-inlined hot fns, and per the jolt-15jq A/B it's allocation-bound regardless (jolt-8flj). Tracked on the bead. Co-authored-by: Yogthos <yogthos@gmail.com>
77 lines
3.8 KiB
Text
77 lines
3.8 KiB
Text
# Declared record param hints propagate THROUGH the whole-program fixpoint
|
|
# (jolt-3ko). A ^Record param's field reads type to the field's record type, and
|
|
# when such a field-read value is passed to a SHARED helper (no hints, inferred
|
|
# from call sites), the helper's params must pick up that record type so its own
|
|
# field reads bare-index. Before the fix, ^-hints were applied only at the final
|
|
# re-emit (reinfer-def), not during the fixpoint, so a hinted param with no
|
|
# callers stayed :any during inference and never propagated to its callees —
|
|
# exactly why the ray tracer's vec ops (called with (:origin ray) etc.) stayed
|
|
# unproven even under whole-program optimization.
|
|
(import ../../src/jolt/api :as api)
|
|
(import ../../src/jolt/backend :as backend)
|
|
(import ../../src/jolt/types :as types)
|
|
|
|
(print "phint propagation through the fixpoint (jolt-3ko)...")
|
|
|
|
(def dir (string (or (os/getenv "TMPDIR") "/tmp") "/jolt-phint-prop"))
|
|
(os/mkdir dir)
|
|
(spit (string dir "/pp.clj")
|
|
(string
|
|
"(ns pp)\n"
|
|
"(defrecord Vec3 [r g b])\n"
|
|
"(defrecord Ray [^Vec3 origin ^Vec3 direction])\n"
|
|
# shared ops, NO hints — must be inferred from the call sites below. A
|
|
# `loop` makes them inline-INELIGIBLE so they stay real calls (a small fn
|
|
# would be spliced into the caller, where the caller's hint already proves
|
|
# it); the point here is propagation to a separate callee's PARAMS.
|
|
"(defn dot [a b]\n"
|
|
" (loop [i 0 s 0.0]\n"
|
|
" (if (< i 1) (recur (inc i) (+ (+ (* (:r a) (:r b)) (* (:g a) (:g b))) (* (:b a) (:b b)))) s)))\n"
|
|
"(defn add [a b]\n"
|
|
" (loop [i 0 s nil]\n"
|
|
" (if (< i 1) (recur (inc i) (->Vec3 (+ (:r a) (:r b)) (+ (:g a) (:g b)) (+ (:b a) (:b b)))) s)))\n"
|
|
# callers pass field-read Vec3s from a ^Ray param into the shared ops
|
|
"(defn use-dot [^Ray r] (dot (:origin r) (:direction r)))\n"
|
|
"(defn use-add [^Ray r] (add (:origin r) (:direction r)))\n"))
|
|
|
|
(os/setenv "JOLT_DIRECT_LINK" "1")
|
|
(os/setenv "JOLT_WHOLE_PROGRAM" "1")
|
|
(os/setenv "JOLT_PATH" dir)
|
|
(def ctx (api/init {:compile? true}))
|
|
(api/eval-string ctx "(require '[pp])")
|
|
(def report (backend/infer-program! ctx))
|
|
|
|
(def pns (types/ctx-find-ns ctx "jolt.passes"))
|
|
(def reinfer (types/var-get (types/ns-find pns "reinfer-def")))
|
|
(def ppns (types/ctx-find-ns ctx "pp"))
|
|
(defn ptmap-for [fname params]
|
|
(def pts (get report (string "pp/" fname)))
|
|
(def m @{}) (when pts (var i 0) (each p params (put m p (get pts i)) (++ i))) m)
|
|
(defn guards [fname params]
|
|
(def cell (get (ppns :mappings) fname))
|
|
(length (string/find-all ":jolt/type"
|
|
(string/format "%p" (backend/emit-ir ctx (reinfer (get cell :infer-ir) (ptmap-for fname params)))))))
|
|
|
|
(var fails 0)
|
|
(defn check [label got expected]
|
|
(if (= got expected) (print " ok " label)
|
|
(do (++ fails) (printf " FAIL %s: want %p got %p" label expected got))))
|
|
|
|
# the shared ops' params get the Vec3 record type from the field-read call args,
|
|
# so all their field reads bare-index (no :jolt/type guard)
|
|
(check "dot params typed Vec3 -> reads bare" (guards "dot" ["a" "b"]) 0)
|
|
(check "add params typed Vec3 -> reads bare" (guards "add" ["a" "b"]) 0)
|
|
# the hinted callers were already fine (re-emit applies the phint)
|
|
(check "use-dot hinted reads bare" (guards "use-dot" ["r"]) 0)
|
|
|
|
# the report shows the shared ops' params as a Vec3 struct (has :shape / :type)
|
|
(def dot-a (get (get report "pp/dot") 0))
|
|
(check "dot param a is a struct type" (truthy? (and dot-a (or (get dot-a :shape) (get dot-a :struct)))) true)
|
|
|
|
# correctness: results are unchanged
|
|
(check "dot computes" (api/eval-string ctx "(pp/dot (pp/->Vec3 1 2 3) (pp/->Vec3 4 5 6))") 32)
|
|
(check "use-dot computes"
|
|
(api/eval-string ctx "(pp/use-dot (pp/->Ray (pp/->Vec3 1 2 3) (pp/->Vec3 4 5 6)))") 32)
|
|
|
|
(if (> fails 0) (do (printf "phint-propagation: %d FAILED" fails) (os/exit 1))
|
|
(print "phint propagation (jolt-3ko) passed!"))
|