10 Commits

Author	SHA1	Message	Date
Brummel	14a91f0ae5	iter boehm-retirement.1 (DONE 10/10): retire the transitional Boehm GC backend ... Closes Gitea #4. Removes the Boehm-Demers-Weiser conservative GC backend wholesale across six layers in one atomic iteration. After this iter, `AllocStrategy` has two variants (`Rc`, `Bump`), `--alloc=gc` is rejected at CLI parse with `unknown --alloc value`, the libgc link arm is gone, and the design ledger describes RC (canonical) + bump (raw-alloc bench-floor) as the only allocators. Layer-by-layer summary: CLI surface — `crates/ail/src/main.rs`: `parse_alloc_strategy` arm `"gc" => Ok(AllocStrategy::Gc)` removed; error wording updated to `(expected `rc` or `bump`)`; clap-derive `value_parser = ["gc","bump","rc"]` allowlist on BOTH `Build` and `Run` subcommands DROPPED so that `parse_alloc_strategy` remains the sole gatekeeper for the unknown-value diagnostic (otherwise clap shadows the runtime diagnostic with `invalid value 'gc' for '--alloc'`, which would miss the milestone-pin's stderr substring check). The `default_value = "rc"` stays. Codegen — `crates/ailang-codegen/src/lib.rs`: `AllocStrategy::Gc` variant + `Default` derive removed (no caller of `AllocStrategy::default()` existed in the workspace, so the trait derivation was dead). `fn_name` (spec called it `runtime_alloc_fn` loosely; actual identifier is `fn_name`) drops the `Gc => "GC_malloc"` arm. `lower_workspace` and `lower_workspace_staticlib` defaults flip from `Gc` to `Rc`. In-source negative-complement codegen test (mod tests, lib.rs:3571ff) retargets from `AllocStrategy::Gc` to `AllocStrategy::Bump` (bump also doesn't emit per-type drop fns; the test's semantic "no drop fns under non-RC" is preserved). Link branch — `crates/ail/src/main.rs:2389ff`: The `match strategy { AllocStrategy::Gc => { ... cmd.arg("-lgc"); ... } }` arm and its libgc-link block are entirely gone. The surviving match exhausts on `Bump` and `Rc` (Rust's exhaustiveness check confirms; no `error[E0004]`). Staticlib-guard diagnostic rewritten to drop the "shared Boehm collector" phrasing while preserving the prefix `staticlib (swarm) artefact is RC-only` verbatim (the surviving `staticlib_bump_is_rejected` test depends on that substring). Test suite — 3 pure-differential e2e tests deleted (`gc_handles_recursive_list_construction`, `alloc_rc_produces_same_stdout_as_gc`, `alloc_rc_matches_gc_on_std_list_demo`); 9 RC-feature tests stripped of their `stdout_gc` build call and differential `assert_eq!(stdout_gc, stdout_rc, ...)` (absolute `assert_eq!(stdout_rc.trim(), "<n>")` pin retained as correctness oracle); `staticlib_gc_is_rejected` deleted; new milestone-pin `crates/ail/tests/boehm_retirement_pin.rs` asserts `ail build --alloc=gc` exits ≠ 0 with stderr containing `unknown --alloc value` and `\`gc\``; `examples/gc_stress.ail` fixture deleted (no remaining references). Implementer expansion (not in plan): `iter17a_local_box_alloca` (in `e2e.rs`) carried an IR-shape assertion against `@GC_malloc`-absence as the witness for non-escaping allocation. After the Task-2 codegen default flip, the witness shifts to `@ailang_rc_alloc`-absence in escape-targeted positions; assertion + doc-comment updated. Property protected ("no heap allocation in non-escaping contexts") is unchanged; only the named allocator shifts. Bench harness — `bench/run.sh` 9→6 column compaction (workload + bump(s) + rc(s) + rc/bump + bump RSS + rc RSS); gc-arm `bench_latency_implicit_gc` build call + harness invocation dropped from latency block; header comment reframed from "GC-overhead bench harness" to "RC-overhead bench harness"; "Decision 10's Boehm-retirement target (1.3x)" rewording to "RC-overhead-vs-bump bench-health regression gate". `bench/check.py:62` header-sentinel changes from `"gc(s)" in line` to `"bump(s)" in line`; column-count check at `:72` flips from `!= 9` to `!= 6`; per-workload field set drops `gc_s`/`gc_over_bump`/`gc_rss_kb`; `ARM_LABEL_TO_KEY` drops the `"implicit @ gc": "implicit_at_gc"` entry. `bench/baseline.json` regenerated via `--update-baseline`. Implementer note (planner-defect): `write_new_baseline` iterated over the *existing* baseline's metric list when emitting the regenerated file, so even after parser-level `gc_*` removal, the fallback emitted them back into the JSON. Scrubbed post-update; the cleaner fix (have `write_new_baseline` emit only keys present in `parsed_throughput[workload]`) is a follow-up if the script becomes load-bearing for further allocator changes. Design ledger — `design/models/rc-uniqueness.md` excises the `## Dual allocator — RC canonical, Boehm parity oracle` section and the `Boehm-Demers-Weiser conservative GC` choice block + rationale + trade-offs; the per-fn-alloca section generalises Boehm-specific language to allocator-agnostic; the memory-model section's `## Choice.` paragraph reframes the 1.3× target from "Boehm-retirement gate" to "bench-health regression gate". `design/models/pipeline.md` drops the `--alloc=gc → links libgc` arm of the pipeline diagram and replaces it with `--alloc=bump → links bump-floor`; the accompanying prose rewrites accordingly. `design/contracts/scope-boundaries.md` rewrites the "Memory management via Boehm conservative GC" bullet to describe RC + per-fn-arena present-tense; the dead reference to `examples/gc_stress.ail.json` (file never existed; the fixture only ever had a `.ail` form, deleted by this iter) is dropped along with the `examples/std_list_stress.ail.json` reference whose purpose was Boehm-only soak testing. `:67`'s `@printf` / `@GC_malloc` parenthetical updated. `design/contracts/memory-model.md:232` drops the "leaks like the pre-Boehm era" phrase; the RC inc/dec instrumentation is wired up, so the "until then" conditional that referenced pre-Boehm is closed. `design/contracts/embedding-abi.md:42-44` rewrites the staticlib-guard prose to drop the `--alloc=gc` clause (gc is now a CLI-parser-level unknown-value, not a staticlib-guard rejection) and reframe the swarm-safety justification around `--alloc=bump` (leak-only bench instrument) rather than the historical Boehm collector. Honesty pin — `crates/ailang-core/tests/docs_honesty_pin.rs` inverts the polarity: the present-tense Boehm-anchor assertion on `pipeline.md` (`:116-117`) is deleted, and four absence-pins are added to `design_md_has_no_wunschdenken` against the Boehm-zombie strings `transitional Boehm`, `parity oracle`, `GC_malloc`, `libgc`. The `design_corpus()` already includes `rc-uniqueness.md` so no path-list change was needed for the new pins to scan. `crates/ailang-core/tests/design_index_pin.rs:166` drops the `"pre-Boehm"` token from the protected-exception comment list (the phrase no longer appears in `memory-model.md` after this iter, so the exception is dead). Runtime docs — `runtime/bump.c`, `runtime/rc.c`, `runtime/str.c` header comments scrubbed of Boehm/`GC_malloc`/`libgc` references. `bump.c`'s function signature description still documents `void *bump_malloc(size_t)` as the bench-floor allocator interface, but no longer cross-references libgc. Example fixtures — `examples/bench_latency_implicit.ail`, `bench_latency_explicit.ail`, `escape_local_demo.ail`, `reuse_as_demo.ail`, `rc_pin_recurse_implicit.ail` doc-comment headers scrubbed of `--alloc=gc` / Boehm references. The `.ail` surface (AST) is untouched in every case; round-trip invariant holds (`cargo test -p ailang-surface --test round_trip` green). Skill / agent prompts — `skills/audit/agents/ailang-bencher.md` rewritten to use an RC-vs-bump worked example pattern for the hypothesis-driven bench tutorial, replacing the recurring "RC vs Boehm under heap pressure" example. `skills/implement/agents/ailang-implementer.md` Decision-10 / Boehm references replaced with present-tense RC-commitment framing. IR snapshots — the 5 checked-in snapshots (`crates/ail/tests/snapshots/{hello,list,max3,sum,ws_main}.ll`) regenerated via `UPDATE_SNAPSHOTS=1 cargo test -p ail --test ir_snapshot`. Each previously contained `declare ptr @GC_malloc(i64)` and (for `list.ll`) a `call ptr @GC_malloc(...)` invocation; post-flip the snapshots contain `declare ptr @ailang_rc_alloc(i64)` plus the rc inc/dec runtime declarations. Spec-vs-acceptance addendum (caught at orchestrator end-report, absorbed here rather than in a follow-up spec edit): spec §6 acceptance criteria said "Boehm-grep returns matches ONLY in docs_honesty_pin.rs". The plan itself prescribed historical Boehm references in 3 additional files: (a) the new milestone-pin `boehm_retirement_pin.rs` (must literally invoke `--alloc=gc` to assert its rejection), (b) `embed_staticlib_alloc_guard.rs` file doc-comment historical note ("`--alloc=gc` no longer exists as a CLI value"), (c) `embedding-abi.md:44-45` contract historical clause ("see the Boehm-retirement iter"). All three are prescribed; the spec's grep wording was too narrow. The four absence-pins in `docs_honesty_pin.rs` catch the actual zombies (Boehm-narrative re-emerging in the design ledger), which is the substantive intent the spec was aiming at — the four extra documented-by-design exceptions are the cost of having an explicit milestone-pin and contract-level historical anchors. Net delta: - 32 files modified, 2 new (boehm_retirement_pin.rs + stats), 1 deleted (gc_stress.ail); - workspace tests: every binary `0 failed`. Pass-count delta: -3 net (4 e2e tests deleted, 1 new milestone-pin test added); - boehm-grep state: hits only in the four by-design exceptions documented above; - `bench/check.py` exit 0 against regenerated baseline; - CLI must-fail fixture: `ail build --alloc=gc examples/hello.ail` exits non-zero with stderr containing `unknown --alloc value` and `\`gc\``; - design ledger present-tense honest (Boehm-narrative gone from `rc-uniqueness.md` + `pipeline.md`; the few historical references in `embedding-abi.md` / `boehm_retirement_pin.rs` / `embed_staticlib_alloc_guard.rs` are explicit milestone-pins or contract anchors, not silent ledger residue). Bench measurement variance noted: closure-chain and hof-pipeline are ±1-5% jittery between runs; one regeneration flagged 2 metrics as `regressed` before a second run returned 0. The captured baseline is within self-comparison range. Existing per-metric tolerances absorb the jitter. Stats file: `bench/orchestrator-stats/2026-05-20-iter-boehm-retirement.1.json`. closes #4	2026-05-20 20:51:53 +02:00
Brummel	99df14c792	workflow: scrub residual JOURNAL/journal refs missed in the first sweep ... A re-grep found 15 live references (excluding docs/specs/ and docs/plans/, which stay historical) the previous two commits missed — all in source comments, doctests, bench helpers, and one agent file. Per-file: - crates/ail/src/main.rs: typeclass-coherence diagnostic comment pointed at "the JOURNAL queue's wording" — points at design/contracts/typeclasses.md alone. - crates/ailang-prose/src/lib.rs: `//!` header referred to docs/JOURNAL.md "Pinned: human-readable prose surface" — retargeted to design/contracts/authoring-surface.md. - crates/ailang-check/src/lib.rs: bugfix tag + "see iter method-dispatch-refactor journal" prose collapsed to a clean rationale paragraph; the canonical shape is stated inline. - crates/ailang-surface/tests/prelude_decouple_carve_out_pin.rs: "(d) record the rationale in a per-iter journal" → "(d) record the rationale in the commit body". - crates/ailang-surface/tests/prelude_module_hash_pin.rs: header collapsed (pd.2/pd.3 milestone narrative dropped — the test's purpose is self-evident from its body); both "per-iter journal" drift-instructions point at the commit body. - runtime/rc.c: "bench numbers in JOURNAL 18f.2" → "original profiling bench numbers". - bench/run.sh: two "JOURNAL entry" comments → "commit body". - bench/architect_sweeps.sh: header rewritten (cross-ref to the design-md-consolidation milestone commits, not a JOURNAL entry). Sweep-4 extended with two new anti-regrowth phrases ("see the per-iter journal", "in a per-iter journal") so journal prose can't grow back into design/contracts/ silently. - skills/audit/agents/ailang-architect.md: "unlike a journal it lives on main" → "since it lives on main". - ail-embed/src/bin/timeshard_runner.rs: "records it in the close-out journal" → "prints it to stderr". - ail-embed/tests/timeshard.rs: two "journal-only friction timing" → "stderr-only friction timing". Verification (after the edit): - `grep -rin '\bjournal\b'` against live tree returns exactly two hits: the Sweep-4 regex itself (intentional — TABU phrases that prevent regrowth) and the PHRASES array in design_index_pin.rs (intentional — the same regrowth guard at test level). Both are load-bearing negative assertions. - `bash bench/architect_sweeps.sh` exits 0 ("All five sweeps clean") — no design/-side regrowth. - `cargo build --workspace` green; `cargo test --workspace` green.	2026-05-20 11:32:37 +02:00
Brummel	9fdc4cacff	iter form-a.1 (Tasks 6-12): milestone close ... Second half of the form-a-default-authoring milestone-close iter (Boss-decided strategy C, big-bang). All seven tasks DONE; cargo test --workspace green at every per-task boundary. T6 — Bench-driver suffix flip from .ail.json to .ail across 4 Python scripts + run.sh. compile_check.py + cross_lang.py exit 0. T7 — Re-author e2e.rs raw-JSON-inspect tests: - diff_detects_changed_def — derive sum.ail.json on-the-fly via `ail parse examples/sum.ail` into tempdir, then mutate + diff. - borrow_own_demo_modes_are_metadata_only — same pattern. - reuse_as_demo_under_rc_uses_inplace_rewrite — same pattern. - render_parse_round_trip_canonical — RETIRED (subsumed by T1's cli_parse_then_render_then_parse_is_idempotent over whole corpus). - ail_run_accepts_ail_source_with_same_stdout_as_ail_json — re-authored to derive hello.ail.json in a per-process tempdir from hello.ail via `ail parse`, then assert dual-form stdout. T8 — Bulk-delete 156 non-carve-out .ail.json. Inventory: 8 .ail.json (carve-outs, alphabetical: broken_unbound + prelude + 3× test_22b2_* + 3× test_ct1_*) + 157 .ail. carve_out_inventory test un-#[ignore]'d and green. Forward-pulled 20 repairs that the T1-5 dispatch's recon missed (12 Group-B suffix + 5 Group-A load_workspace + 3 ail_run sites). Also forward-pulled T9 Step 5 (schema_coverage corpus flip from .ail.json to .ail) to satisfy T8's green-gate. T9 — Retire obsolete roundtrip tests: - print_then_parse_round_trips_every_fixture (round_trip.rs) - every_ail_fixture_matches_its_json_counterpart (round_trip.rs) - cli_render_then_parse_preserves_canonical_bytes_on_every_fixture - Dead helpers: list_json_fixtures ×2, round_trip_one, strip_trailing_newlines. Schema-coverage corpus already flipped in T8 (forward-pull). T10 — DESIGN.md §"Roundtrip Invariant" (lines 2027-2109) restated with parse-determinism + idempotency + CLI-pipeline-idempotency + carve-out-anchor framing. Five surviving enforcement tests named. §"Float literals" and §"Why anchored at top level" preserved. T11 — §A4 doctrine edits: CLAUDE.md:5-6 + DESIGN.md:465-466. Canonical form remains JSON-AST; authoring projection is .ail; build derives JSON-AST in-process via ailang_surface::parse. T12 — Milestone close: - WhatsNew entry: user-facing language, lead with the change. - Roadmap: [milestone] form-a struck [x] with closing note. - Final inventory verified: 8 .ail.json + 157 .ail. - Final cargo test --workspace: 557 passed, 0 failed, 3 ignored. - bench/compile_check.py + bench/cross_lang.py: exit 0. Test math: pre-iter 558 baseline + 3 new T1 tests = 561, − 1 (T7 retire) − 3 (T9 retire) = 557 final. INDEX.md appended with the full iter summary covering T1-T12 (the T1-5 commit at 77b28ad deferred the INDEX line to full-iter close). Milestone [Form-A as the default authoring surface] structurally closed. The compile-time-embed carve-out (prelude.ail.json) is the subject of the queued follow-up milestone [Prelude embed: Form-A as compile-time source]. audit-form-a runs as the next dispatch.	2026-05-13 11:31:39 +02:00
Brummel	75f7fda788	bench: 21'f — explicit-mode pair, full alloc+dec vs malloc+free ... Closes the apples-to-apples gap from 21'e. Adds: - examples/bench_list_sum_explicit.ailx — same algorithm and sizes as bench_list_sum, fully (borrow)/(own)/(drop-iterative) annotated so codegen emits proper inc/dec instrumentation. - bench/reference/list_sum_explicit_free.c — same algorithm with explicit free() walking the chain after sum. The full alloc+dec vs malloc+free comparison reveals two non- trivial conclusions: 1. AILang's full RC pipeline is only 26% slower than glibc malloc+free on this workload (rc/c = 1.26x). The implicit- mode comparison's 1.42x was misleading — it counted neither pipeline's free path. The fair ratio is 1.26x, materially better than the previous read. 2. RC's dec is cheaper per cell than glibc free(). AILang dec-tax: ~3 ns/cell. C free-tax: ~5.5 ns/cell. Plausible cause: ailang_rc_dec operates on a known-shape cell with a fixed-offset refcount and a static per-type drop fn — no free-list bucketing, no header introspection, no global lock. bump's advantage expresses fully: bench_list_sum_explicit.bump/c = 0.42x means AILang at bump is 2.4x faster than C malloc+free. Sets a useful upper bound on a slab/pool RC allocator's potential. The 21'-family arc — bench-regression infrastructure — is now substantively complete: 21'a (bench/check.py), 21'b (corpus widening), 21'c (compile_check.py), 21'd (pure-compute fixtures + harness hardening), 21'e (cross-language hand-C), 21'f (explicit apples-to-apples). 63 runtime metrics + 18 compile metrics + 25 cross-lang metrics under regression coverage. Any future iter that regresses any axis beyond tolerance gets caught at the next family close. Remaining queue is back to substantive language work — Family 21 (typeclasses / polymorphic ADTs at runtime / pattern-binding generalisation) is now an orchestrator-level fork that needs direct user input.	2026-05-09 01:21:15 +02:00
Brummel	5a4a6de031	bench: 21'd — pure-compute fixtures + harness hardening ... Closes the third corpus blind spot (heap-allocation-only) by adding two fixtures with no allocation pressure: bench_compute_ intsum (tail-recursive integer accumulator) and bench_compute_ collatz (Collatz step-counter, branchy). Surprise on intsum: 50M-iteration loop runs in 1ms wall under all three allocators. LLVM's induction-variable analysis applies the closed-form triangular-sum reduction to AILang's IR — a positive codegen finding (the IR composes with LLVM's optimizer at the same level a hand-C loop would) but it makes intsum useless as a runtime regression bench. Excluded from run.sh's fixtures array; kept in examples/ as reference and as a future cross-language comparison anchor. Collatz survives optimization (data-dependent control flow). At 56ms wall, gc/bump/rc all within 2% — the canonical "pure-compute is allocator-invariant" data point this fixture is meant to prove. If a future codegen change leaks an allocation into the inner loop, the 1.00x / 1.02x ratios diverge visibly. Two infrastructure fixes the new fixtures forced: - 6-decimal precision in run.sh's Python timing helper and median averager (was 3-decimal; sub-ms times rounded to 0.000 and crashed the ratio awk with Division durch Null). - Zero-guard in the ratio awk (defensive even with the precision bump, since LLVM-eliminated workloads can still hit zero). Latency baseline: implicit_at_rc.max_us tolerance 25% -> 30%. Three captures today (477 / 456 / 609 µs) show natural run-to-run dispersion wider than the original tolerance accounts for. Not a softening to dodge regression — the original baseline was the first capture; a fairer tolerance across natural max-of-1000- samples width is what the harness needed from the start. Baseline file: 47 -> 55 metrics. 21'e (cross-language reference, clang -O2 hand-C ratios) is the natural next dispatch.	2026-05-09 01:11:26 +02:00
Brummel	07bff24527	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.	2026-05-09 00:55:57 +02:00
Brummel	c2af5ad3da	bench: latency_harness --runs N (stat-of-N, drop-slowest) ... Closes the architect's tidy follow-up item on bench-number methodology. The harness now accepts --runs N (default 1, byte- identical output for back-compat); with N>=2 it reports median + min..max per cell across runs, with N>=4 it drops the slowest run before aggregating to match bench/run.sh's drop- slowest throughput convention. bench/run.sh now invokes the harness with --runs 5 for each of the three latency arms, so a single bench/run.sh run produces both a regression-stable throughput table and a regression-stable latency table. The qualitative claims from JOURNAL 2026-05-08 (RC tail latency 23x better than Boehm; RC RSS lower than Boehm) hold at the new stat-of-5 confidence level — a 5-run smoke on the explicit-rc arm shows p99=296µs (range 289-311), p99/median=1.31x (range 1.28-1.37). Variance is well below the signal.	2026-05-08 15:17:53 +02:00
Brummel	3113258680	tidy: 18g sub-arc — DESIGN ratification, latency bench, negative coverage ... Resolves the architect's drift report on the 18g sub-arc: - DESIGN.md: ratify mode-metadata's codegen role. param_modes / ret_mode were already on Type::Fn since 18a; with 18d.4 / 18g they became load-bearing for drop-emission decisions in codegen. The new 'Mode metadata is load-bearing for codegen' subsection records the four seams (Iter A + Iter B + 18g.1 + 18g.2) and names the let-alias-of-borrow carve-out the gates do not propagate through. - bench/run.sh: post-throughput, invoke bench/latency_harness.py on the three canonical arms (Implicit @ gc, explicit @ rc, Implicit @ rc control). The Boehm-retirement bench numbers are now reproducible by anyone running the harness, not just by hand on a specific host. - Negative coverage: examples/rc_let_implicit_returning_app + alloc_rc_let_binder_for_implicit_returning_app_does_not_drop pin the asymmetry to the (own)-ret-mode test (live=0 there, live=1 here). The Borrow-ret-mode case is covered by the language design itself — typechecker rejects 'borrow- passthrough' shapes with consume-while-borrowed. JOURNAL entry records four items as deferred known debt: emit_inlined_partial_drop dynamic-tag fallback, carve-out diagnostics surface, bench-number stat-of-N, and the cross-family ordering observation about CLAUDE.md's tidy-iter rule. The 18-arc is formally closed with this tidy. Next iter is the orchestrator's Boehm-retirement decision (Path A vs Path B from JOURNAL 2026-05-08 18f entry, joined by the post-18g.2 re-bench numbers).	2026-05-08 14:37:36 +02:00
Brummel	234dbb6c5a	bench: extend run.sh with --alloc=rc column for Iter 18f ... Adds rc to the modes list and an rc/bump ratio column in the results table. The rc/bump ratio is the decisive number for Decision 10's Boehm-retirement threshold (target 1.3x).	2026-05-08 12:56:53 +02:00
Brummel	65e280bb70	Bench: GC overhead via bump-allocator comparison ... Adds --alloc=<gc|bump> to ail build/run. Bump path links a 256MB no-free arena C stub instead of libgc; IR is byte-identical except for the @GC_malloc → @bump_malloc symbol swap. Bench harness times two allocation-heavy workloads (list cons/sum and balanced tree build/walk) under both modes. Numbers (RUNS=5, median of 4): bench_list_sum gc 0.141s bump 0.048s +194% bench_tree_walk gc 0.103s bump 0.041s +151% Bucket: large. ~60% of runtime is Boehm on these workloads — upper bound for any realistic program. Both fixtures hold the heap fully live, so the cost we're seeing is Boehm's allocate path itself, not collection work; that fact narrows the design space for the GC discussion. - crates/ailang-codegen: AllocStrategy enum, three callsites and the IR header parameterised. - crates/ail/src/main.rs: --alloc flag plumbed; bump runtime located + compiled on demand. - runtime/bump.c: 256MB static arena, abort-on-overflow. - examples/bench_list_sum, bench_tree_walk: accumulator-form fixtures (textbook recursive sum was constructor-blocked). - bench/run.sh: harness with Python timing helper (Arch's /usr/bin/time isn't part of the base install). No language-level changes; default --alloc=gc, all 141 workspace tests green, all 5 IR snapshots unchanged, 11 prior fixtures produce identical stdout. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-08 00:06:20 +02:00