bench: 21'b — closure-pair + HOF/poly fixtures, 47-metric baseline
Two new throughput fixtures targeting blind spots in the 21'a
corpus:
- bench_closure_chain exercises the build_pair_drop_fn codegen
path (the 18c.4 doubled-braces trigger). Each iteration of
run_loop allocates a {thunk, env} closure pair via the
let-rec-name-as-value escape route. Sizes 10k / 100k / 500k.
rc/bump = 4.14x — materially worse than the 2.91x / 2.59x of
the linear/tree fixtures, exposing that closure work pays the
RC alloc tax twice (pair + env-struct).
- bench_hof_pipeline exercises poly-ADT instantiation and
indirect dispatch via fold_with_fn over List<a>. Sizes 100k /
1M / 3M elements. Ratios essentially match bench_list_sum,
confirming the 13b static-template-plus-ctor-inline design
has zero measurable overhead at this scale.
Baseline file extends from 31 to 47 metrics. The two new fixtures
build clean under all three allocators; the rc-arm build exercises
the per-type drop fn for the closure-pair, providing a tripwire
for any future 18c.4-class IR malformedness.
JOURNAL records both surprises (4.14x closure tax, ~zero HOF/poly
overhead) and explicitly notes the dispersion observation on
explicit_at_rc.p99 — three captures today (357.5 / 294.6 / 251.5)
confirm wide run-to-run variance on that fixture. Methodology
upgrade (n>=10 captures or tighter fixture) deferred to 21'c.
bench/run.sh fixtures array updated. bench/check.py needed no
changes — its parser handles the wider table by metric name.
This commit is contained in:
@@ -0,0 +1 @@
|
||||
{"defs":[{"body":{"args":[{"args":[{"args":[{"name":"seed","t":"var"}],"fn":{"name":"f","t":"var"},"t":"app"}],"fn":{"name":"f","t":"var"},"t":"app"}],"fn":{"name":"f","t":"var"},"t":"app"},"doc":"Higher-order: apply f three times to seed.","kind":"fn","name":"apply_thrice","params":["f","seed"],"type":{"effects":[],"k":"fn","params":[{"effects":[],"k":"fn","params":[{"k":"con","name":"Int"}],"ret":{"k":"con","name":"Int"}},{"k":"con","name":"Int"}],"ret":{"k":"con","name":"Int"}}},{"body":{"cond":{"args":[{"name":"i","t":"var"},{"lit":{"kind":"int","value":0},"t":"lit"}],"fn":{"name":"<","t":"var"},"t":"app"},"else":{"body":{"name":"i","t":"var"},"in":{"body":{"args":[{"args":[{"name":"i","t":"var"},{"lit":{"kind":"int","value":1},"t":"lit"}],"fn":{"name":"-","t":"var"},"t":"app"},{"args":[{"name":"acc","t":"var"},{"name":"r","t":"var"}],"fn":{"name":"+","t":"var"},"t":"app"}],"fn":{"name":"run_loop","t":"var"},"t":"app","tail":true},"name":"r","t":"let","value":{"args":[{"name":"helper","t":"var"},{"name":"i","t":"var"}],"fn":{"name":"apply_thrice","t":"var"},"t":"app"}},"name":"helper","params":["x"],"t":"letrec","type":{"effects":[],"k":"fn","params":[{"k":"con","name":"Int"}],"ret":{"k":"con","name":"Int"}}},"t":"if","then":{"name":"acc","t":"var"}},"doc":"For each i in [n-1, n-2, ..., 0], build a closure capturing i, pass to apply_thrice, accumulate. Tail-recursive on i and acc.","kind":"fn","name":"run_loop","params":["i","acc"],"type":{"effects":[],"k":"fn","params":[{"k":"con","name":"Int"},{"k":"con","name":"Int"}],"ret":{"k":"con","name":"Int"}}},{"body":{"args":[{"args":[{"name":"n","t":"var"},{"lit":{"kind":"int","value":1},"t":"lit"}],"fn":{"name":"-","t":"var"},"t":"app"},{"lit":{"kind":"int","value":0},"t":"lit"}],"fn":{"name":"run_loop","t":"var"},"t":"app"},"doc":"Drive run_loop from i=n-1 down to 0.","kind":"fn","name":"run","params":["n"],"type":{"effects":[],"k":"fn","params":[{"k":"con","name":"Int"}],"ret":{"k":"con","name":"Int"}}},{"body":{"lhs":{"args":[{"args":[{"lit":{"kind":"int","value":10000},"t":"lit"}],"fn":{"name":"run","t":"var"},"t":"app"}],"op":"io/print_int","t":"do"},"rhs":{"lhs":{"args":[{"args":[{"lit":{"kind":"int","value":100000},"t":"lit"}],"fn":{"name":"run","t":"var"},"t":"app"}],"op":"io/print_int","t":"do"},"rhs":{"args":[{"args":[{"lit":{"kind":"int","value":500000},"t":"lit"}],"fn":{"name":"run","t":"var"},"t":"app"}],"op":"io/print_int","t":"do"},"t":"seq"},"t":"seq"},"kind":"fn","name":"main","params":[],"type":{"effects":["IO"],"k":"fn","params":[],"ret":{"k":"con","name":"Unit"}}}],"imports":[],"name":"bench_closure_chain","schema":"ailang/v0"}
|
||||
@@ -0,0 +1,68 @@
|
||||
; Bench fixture: closure-pair allocation under load.
|
||||
;
|
||||
; Each iteration of `run_loop` introduces a fresh `let-rec helper`
|
||||
; whose body captures the outer fn-param `i`. The let-rec name is
|
||||
; passed as a value to `apply_thrice`, which forces eta-Lam wrapping
|
||||
; (the 16b.5 / 8b ABI shape) — codegen allocates a `{ thunk, env }`
|
||||
; closure pair where `env` holds the captured `i`. Under
|
||||
; --alloc=rc the allocation goes through `ailang_rc_alloc` and the
|
||||
; per-type drop fn `build_pair_drop_fn` is generated for the
|
||||
; closure-pair type. (The 18c.4 doubled-braces bug lived in exactly
|
||||
; this drop fn; this fixture is the canonical exerciser.)
|
||||
;
|
||||
; The helper body is (body i) — it ignores its parameter and
|
||||
; returns the capture. apply_thrice(helper, x) therefore evaluates
|
||||
; to i regardless of x. Each run_loop iteration thus contributes
|
||||
; `i` to the accumulator. Total = sum 0..n-1 = n*(n-1)/2.
|
||||
;
|
||||
; Sizes (Implicit-mode RC leaks the closure pairs by design — the
|
||||
; gc/bump arms are the meaningful allocator comparison, the rc arm
|
||||
; reports alloc-tax-only):
|
||||
; n = 10_000 -> 49_995_000 (1k closure-pair allocs)
|
||||
; n = 100_000 -> 4_999_950_000 (100k allocs)
|
||||
; n = 500_000 -> 124_999_750_000 (500k allocs)
|
||||
|
||||
(module bench_closure_chain
|
||||
|
||||
(fn apply_thrice
|
||||
(doc "Higher-order: apply f three times to seed.")
|
||||
(type
|
||||
(fn-type
|
||||
(params (fn-type (params (con Int)) (ret (con Int)))
|
||||
(con Int))
|
||||
(ret (con Int))))
|
||||
(params f seed)
|
||||
(body
|
||||
(app f (app f (app f seed)))))
|
||||
|
||||
(fn run_loop
|
||||
(doc "For each i in [n-1, n-2, ..., 0], build a closure capturing i, pass to apply_thrice, accumulate. Tail-recursive on i and acc.")
|
||||
(type
|
||||
(fn-type
|
||||
(params (con Int) (con Int))
|
||||
(ret (con Int))))
|
||||
(params i acc)
|
||||
(body
|
||||
(if (app < i 0)
|
||||
acc
|
||||
(let-rec helper
|
||||
(params x)
|
||||
(type (fn-type (params (con Int)) (ret (con Int))))
|
||||
(body i)
|
||||
(in
|
||||
(let r (app apply_thrice helper i)
|
||||
(tail-app run_loop (app - i 1) (app + acc r))))))))
|
||||
|
||||
(fn run
|
||||
(doc "Drive run_loop from i=n-1 down to 0.")
|
||||
(type (fn-type (params (con Int)) (ret (con Int))))
|
||||
(params n)
|
||||
(body (app run_loop (app - n 1) 0)))
|
||||
|
||||
(fn main
|
||||
(type (fn-type (params) (ret (con Unit)) (effects IO)))
|
||||
(params)
|
||||
(body
|
||||
(seq (do io/print_int (app run 10000))
|
||||
(seq (do io/print_int (app run 100000))
|
||||
(do io/print_int (app run 500000)))))))
|
||||
@@ -0,0 +1 @@
|
||||
{"defs":[{"ctors":[{"fields":[],"name":"Nil"},{"fields":[{"k":"var","name":"a"},{"args":[{"k":"var","name":"a"}],"k":"con","name":"List"}],"name":"Cons"}],"doc":"Polymorphic singly-linked list. Same shape as list_map_poly's List, replicated here so the bench fixture is self-contained.","kind":"type","name":"List","vars":["a"]},{"body":{"cond":{"args":[{"name":"n","t":"var"},{"lit":{"kind":"int","value":0},"t":"lit"}],"fn":{"name":"==","t":"var"},"t":"app"},"else":{"args":[{"args":[{"name":"n","t":"var"},{"lit":{"kind":"int","value":1},"t":"lit"}],"fn":{"name":"-","t":"var"},"t":"app"},{"args":[{"args":[{"name":"n","t":"var"},{"lit":{"kind":"int","value":1},"t":"lit"}],"fn":{"name":"-","t":"var"},"t":"app"},{"name":"acc","t":"var"}],"ctor":"Cons","t":"ctor","type":"List"}],"fn":{"name":"build_n","t":"var"},"t":"app","tail":true},"t":"if","then":{"name":"acc","t":"var"}},"doc":"Build [0, 1, ..., n-1] :: List Int. Tail-recursive accumulator form.","kind":"fn","name":"build_n","params":["n","acc"],"type":{"effects":[],"k":"fn","params":[{"k":"con","name":"Int"},{"args":[{"k":"con","name":"Int"}],"k":"con","name":"List"}],"ret":{"args":[{"k":"con","name":"Int"}],"k":"con","name":"List"}}},{"body":{"args":[{"name":"x","t":"var"},{"lit":{"kind":"int","value":1},"t":"lit"}],"fn":{"name":"+","t":"var"},"t":"app"},"doc":"Add 1 to an Int. Used as the HOF argument to fold_with_fn.","kind":"fn","name":"inc","params":["x"],"type":{"effects":[],"k":"fn","params":[{"k":"con","name":"Int"}],"ret":{"k":"con","name":"Int"}}},{"body":{"arms":[{"body":{"name":"acc","t":"var"},"pat":{"ctor":"Nil","fields":[],"p":"ctor"}},{"body":{"args":[{"name":"f","t":"var"},{"name":"t","t":"var"},{"args":[{"name":"acc","t":"var"},{"args":[{"name":"h","t":"var"}],"fn":{"name":"f","t":"var"},"t":"app"}],"fn":{"name":"+","t":"var"},"t":"app"}],"fn":{"name":"fold_with_fn","t":"var"},"t":"app","tail":true},"pat":{"ctor":"Cons","fields":[{"name":"h","p":"var"},{"name":"t","p":"var"}],"p":"ctor"}}],"scrutinee":{"name":"xs","t":"var"},"t":"match"},"doc":"Polymorphic foldl-with-mapping. Apply f:(a)->Int to every element of xs, sum into acc. Tail-recursive on (xs, acc); the f arg is forwarded unchanged.","kind":"fn","name":"fold_with_fn","params":["f","xs","acc"],"type":{"body":{"effects":[],"k":"fn","params":[{"effects":[],"k":"fn","params":[{"k":"var","name":"a"}],"ret":{"k":"con","name":"Int"}},{"args":[{"k":"var","name":"a"}],"k":"con","name":"List"},{"k":"con","name":"Int"}],"ret":{"k":"con","name":"Int"}},"k":"forall","vars":["a"]}},{"body":{"args":[{"args":[{"name":"inc","t":"var"},{"args":[{"name":"n","t":"var"},{"args":[],"ctor":"Nil","t":"ctor","type":"List"}],"fn":{"name":"build_n","t":"var"},"t":"app"},{"lit":{"kind":"int","value":0},"t":"lit"}],"fn":{"name":"fold_with_fn","t":"var"},"t":"app"}],"op":"io/print_int","t":"do"},"doc":"Build [0..n-1], fold with inc, print sum of (inc x).","kind":"fn","name":"run_one","params":["n"],"type":{"effects":["IO"],"k":"fn","params":[{"k":"con","name":"Int"}],"ret":{"k":"con","name":"Unit"}}},{"body":{"lhs":{"args":[{"lit":{"kind":"int","value":100000},"t":"lit"}],"fn":{"name":"run_one","t":"var"},"t":"app"},"rhs":{"lhs":{"args":[{"lit":{"kind":"int","value":1000000},"t":"lit"}],"fn":{"name":"run_one","t":"var"},"t":"app"},"rhs":{"args":[{"lit":{"kind":"int","value":3000000},"t":"lit"}],"fn":{"name":"run_one","t":"var"},"t":"app"},"t":"seq"},"t":"seq"},"kind":"fn","name":"main","params":[],"type":{"effects":["IO"],"k":"fn","params":[],"ret":{"k":"con","name":"Unit"}}}],"imports":[],"name":"bench_hof_pipeline","schema":"ailang/v0"}
|
||||
@@ -0,0 +1,87 @@
|
||||
; Bench fixture: HOF + polymorphic ADT pipeline.
|
||||
;
|
||||
; Builds a polymorphic List<Int> of length n, then folds it with a
|
||||
; higher-order function `inc` to compute the sum of incremented
|
||||
; elements. Distinct from bench_list_sum:
|
||||
; 1. Uses `(data List (vars a) ...)` — polymorphic ADT, exercises
|
||||
; the 13b/14a polymorphism-at-runtime path. The Cons cell
|
||||
; layout is the same width as bench_list_sum's IntList ICons,
|
||||
; but the type-arg substitution is the additional code path.
|
||||
; 2. The traversal is via `fold_with_fn` — an HOF taking
|
||||
; `(fn-type (params a) (ret (con Int)))` as its first param.
|
||||
; Each step calls `(app f h)` — an indirect call through the
|
||||
; fn-arg. This is the only fixture that exercises tight-loop
|
||||
; indirect dispatch.
|
||||
;
|
||||
; Build phase is alloc-heavy (n Cons cells); fold phase is
|
||||
; dispatch-heavy (n indirect calls). Per-iteration cost should be
|
||||
; visibly higher than bench_list_sum's direct sum.
|
||||
;
|
||||
; Result for size n (using inc(x) = x+1):
|
||||
; sum (inc 0) + (inc 1) + ... + (inc (n-1)) = sum 1..n = n*(n+1)/2
|
||||
;
|
||||
; Sizes:
|
||||
; 100_000 -> 5_000_050_000
|
||||
; 1_000_000 -> 500_000_500_000
|
||||
; 3_000_000 -> 4_500_001_500_000
|
||||
|
||||
(module bench_hof_pipeline
|
||||
|
||||
(data List (vars a)
|
||||
(doc "Polymorphic singly-linked list. Same shape as list_map_poly's List, replicated here so the bench fixture is self-contained.")
|
||||
(ctor Nil)
|
||||
(ctor Cons a (con List a)))
|
||||
|
||||
(fn build_n
|
||||
(doc "Build [0, 1, ..., n-1] :: List Int. Tail-recursive accumulator form.")
|
||||
(type
|
||||
(fn-type
|
||||
(params (con Int) (con List (con Int)))
|
||||
(ret (con List (con Int)))))
|
||||
(params n acc)
|
||||
(body
|
||||
(if (app == n 0)
|
||||
acc
|
||||
(tail-app build_n
|
||||
(app - n 1)
|
||||
(term-ctor List Cons (app - n 1) acc)))))
|
||||
|
||||
(fn inc
|
||||
(doc "Add 1 to an Int. Used as the HOF argument to fold_with_fn.")
|
||||
(type (fn-type (params (con Int)) (ret (con Int))))
|
||||
(params x)
|
||||
(body (app + x 1)))
|
||||
|
||||
(fn fold_with_fn
|
||||
(doc "Polymorphic foldl-with-mapping. Apply f:(a)->Int to every element of xs, sum into acc. Tail-recursive on (xs, acc); the f arg is forwarded unchanged.")
|
||||
(type
|
||||
(forall (vars a)
|
||||
(fn-type
|
||||
(params (fn-type (params a) (ret (con Int)))
|
||||
(con List a)
|
||||
(con Int))
|
||||
(ret (con Int)))))
|
||||
(params f xs acc)
|
||||
(body
|
||||
(match xs
|
||||
(case (pat-ctor Nil) acc)
|
||||
(case (pat-ctor Cons h t)
|
||||
(tail-app fold_with_fn f t (app + acc (app f h)))))))
|
||||
|
||||
(fn run_one
|
||||
(doc "Build [0..n-1], fold with inc, print sum of (inc x).")
|
||||
(type (fn-type (params (con Int)) (ret (con Unit)) (effects IO)))
|
||||
(params n)
|
||||
(body
|
||||
(do io/print_int
|
||||
(app fold_with_fn inc
|
||||
(app build_n n (term-ctor List Nil))
|
||||
0))))
|
||||
|
||||
(fn main
|
||||
(type (fn-type (params) (ret (con Unit)) (effects IO)))
|
||||
(params)
|
||||
(body
|
||||
(seq (app run_one 100000)
|
||||
(seq (app run_one 1000000)
|
||||
(app run_one 3000000))))))
|
||||
Reference in New Issue
Block a user