giles
adc8467c78
Some checks failed
Test, Build, and Deploy / test-build-deploy (push) Failing after 58s
`table-2` wraps a 2-arg (input, output) relation. On a ground input walk, looks up the (string-encoded) cache key; on miss, runs the relation, drains the answer stream, extracts walk*-output values from each subst, stores them, and replays. On hit, replays the cached values directly — no recomputation. Cache lifetime: a single global mk-tab-cache (mutated via set!). mk-tab-clear! resets between independent queries. Canonical demo: tabled fib(25) = 75025 in ~5 seconds; the same naive fib-o times out at 60s. Memoization collapses the exponential redundant recomputation in the binary recursion. Limitations (deferred to future SLG work): cyclic recursive calls with the same ground key still diverge — naive memoization populates the cache only AFTER computation completes, so a recursive call inside its own computation can't see the in-progress entry. The brief's "tabled patho on cyclic graphs" use case requires producer/consumer scheduling and is left for a future iteration. 12 new tests, fib(0..20) + ground-term predicate + cache-replay verification. 638/638 cumulative.
92 lines
2.8 KiB
Plaintext
92 lines
2.8 KiB
Plaintext
;; lib/minikanren/tabling.sx — Phase 7 piece A: naive memoization.
|
|
;;
|
|
;; A `table-2` wrapper for 2-arg relations (input, output). Caches by
|
|
;; ground input (walked at call time). On hit, replays the cached output
|
|
;; values; on miss, runs the relation, collects all output values from
|
|
;; the answer stream, stores, then replays.
|
|
;;
|
|
;; Limitations of naive memoization (vs proper SLG / producer-consumer
|
|
;; tabling):
|
|
;; - Each call must terminate before its result enters the cache —
|
|
;; so cyclic recursive calls with the SAME ground input would still
|
|
;; diverge (not addressed here).
|
|
;; - Caching by full ground walk only; partially-ground args fall
|
|
;; through to the underlying relation.
|
|
;;
|
|
;; Despite the limitations, naive memoization is enough for the
|
|
;; canonical demo: Fibonacci goes from exponential to linear because
|
|
;; each fib(k) result is computed at most once.
|
|
;;
|
|
;; Cache lifetime: a single global mk-tab-cache. Use `(mk-tab-clear!)`
|
|
;; between independent queries.
|
|
|
|
(define mk-tab-cache {})
|
|
|
|
(define mk-tab-clear! (fn () (set! mk-tab-cache {})))
|
|
|
|
(define
|
|
mk-tab-lookup
|
|
(fn
|
|
(key)
|
|
(cond
|
|
((has-key? mk-tab-cache key) (get mk-tab-cache key))
|
|
(:else :miss))))
|
|
|
|
(define
|
|
mk-tab-store!
|
|
(fn (key vals) (set! mk-tab-cache (assoc mk-tab-cache key vals))))
|
|
|
|
(define
|
|
mk-tab-ground-term?
|
|
(fn
|
|
(t)
|
|
(cond
|
|
((is-var? t) false)
|
|
((mk-cons-cell? t)
|
|
(and
|
|
(mk-tab-ground-term? (mk-cons-head t))
|
|
(mk-tab-ground-term? (mk-cons-tail t))))
|
|
((mk-list-pair? t) (every? mk-tab-ground-term? t))
|
|
(:else true))))
|
|
|
|
(define
|
|
mk-tab-replay-vals
|
|
(fn
|
|
(vals output s)
|
|
(cond
|
|
((empty? vals) mzero)
|
|
(:else
|
|
(let
|
|
((sp (mk-unify output (first vals) s)))
|
|
(let
|
|
((this-stream (cond ((= sp nil) mzero) (:else (unit sp)))))
|
|
(mk-mplus this-stream (mk-tab-replay-vals (rest vals) output s))))))))
|
|
|
|
(define
|
|
table-2
|
|
(fn
|
|
(name rel-fn)
|
|
(fn
|
|
(input output)
|
|
(fn
|
|
(s)
|
|
(let
|
|
((winput (mk-walk* input s)))
|
|
(cond
|
|
((mk-tab-ground-term? winput)
|
|
(let
|
|
((key (str name "@" winput)))
|
|
(let
|
|
((cached (mk-tab-lookup key)))
|
|
(cond
|
|
((= cached :miss)
|
|
(let
|
|
((all-substs (stream-take -1 ((rel-fn input output) s))))
|
|
(let
|
|
((vals (map (fn (s2) (mk-walk* output s2)) all-substs)))
|
|
(begin
|
|
(mk-tab-store! key vals)
|
|
(mk-tab-replay-vals vals output s)))))
|
|
(:else (mk-tab-replay-vals cached output s))))))
|
|
(:else ((rel-fn input output) s))))))))
|