<!-- GPT direction of 2026-09-16, copied verbatim from ~/Documents/Codex/2026-09-16/are-we-at-a-state-with/outputs/FLOOR_COMPETITIVE_BENCHMARK.md so it has a revision. docs/fcb-model.md is the model written against it; receipts/FCB-R0-OPEN.md the contract. -->
Stage-0.1 review update: Fable repaired the original metric semantics, counter domains, subject label, and post-deadline progress credit at commit
01031e6; independent C1–C9 and repository guards pass. The official battery remains on hold because a fresh transition can still begin after the armed deadline, physical counters run through cleanup, the official runner audits only the 2B half of a B/2B marginal, and closed-loop metric derivation is quadratic. The bounded repair is inFCB_STAGE01_CODEX_REVIEW_AND_FABLE_STAGE02_ASSIGNMENT.md.
The system under comparison is /home/travis/ProjectAmp2/computedriven: the no-std semantic floor/kernellet and ComputeDriven Locus Multiplexing. Super is an operating environment above this substrate and is not the benchmark target. Elixir is not the floor implementation; the measured floor and compiled home are Rust.
The objective is the R7 objective already written before its mechanism:
Optimize semantic progress per Locus, not occupancy of Carriers.
One unit of progress is one admitted, complete semantic transition. Migration, refusal, occupancy and CPU busy time are never progress.
Semantic enforcement floor: 6,384 bytes .text + 146 bytes net .rodata; full measured image including codec and harness: 9,078 bytes .text + .rodata, over 8 KiB by 886 bytes and under 16 KiB by 7,306 bytes. Per-live-Locus mutable state: 168 bytes. These are x86-64, rustc 1.75, size-optimized figures, not other-ISA claims.
Density 4, uniform demand: CLOCK-AGE(4,16) admitted 75,232 transitions, versus RR-FAIR 64,000, while using 23.7 versus 633.9 fabric bytes per admitted transition and 1,253.8 versus 5,805.0 instructions per admitted transition. Its oldest-ready age was bounded at 16 rounds and no Locus had zero progress. HOT-RESIDENT reached high apparent throughput while leaving 24 of 32 Loci at zero progress, demonstrating why throughput/utilization alone is insufficient.
Density 8, 7/8 skew: CLOCK-AGE admitted 30,595 transitions versus RR-FAIR 28,171, used 97.4 versus 632.8 fabric bytes per admitted transition, and cost 1,837.6 versus 5,795.8 instructions per admitted transition; oldest-ready age remained 16.
The compiled placement home used 8.8–18.9× fewer instructions per admitted transition than the Python reference home in the corrected R7.2.1C confirmation. That is an implementation replacement result, not an industry comparison.
Under the dedicated quiet-host profile, one settled move below capacity caused no measurable loss of admitted transitions within the prespecified ±0.1% bound. This establishes bounded no-cost under that condition, not a placement benefit.
No existing receipt establishes ComputeDriven superiority over Linux, Go, BEAM, Seastar, Akka or Orleans. The R7 prior-art section maps concepts; it is not a shootout.
| System | Native scheduling currency | Comparison question |
|---|---|---|
| ComputeDriven CLOCK-AGE / RR-FAIR | complete admitted semantic transitions | Does transition-denominated debt and explicit residency produce more fair semantic progress per physical cost? |
| Linux EEVDF | CPU-time lag and virtual deadlines | How do progress tails and physical cost compare when the OS may preempt inside a transition? |
| Go runtime | runnable goroutines over M/P, asynchronous safe-point preemption | How much progress, tail delay and memory does a one-Carrier Go schedule obtain? |
| Erlang/BEAM | reductions per process | How does work-count scheduling compare when reductions may suspend a process mid-operation? |
| Seastar | shard-per-core run-to-completion with a task quota | How does the closest production run-to-completion model compare on locality, stalls and fairness? |
Akka/Orleans are a second wave for actor-turn batching. They are useful after the five-way core experiment, not needed to start it.
Give every system the same deterministic demand trace and semantic state machine. A transition has the same input, state precondition, committed result and reference digest. Configure one execution carrier: one ComputeDriven floor, one Linux CPU, GOMAXPROCS=1, one BEAM scheduler and one Seastar shard. Let each native scheduler use its own preemption and residency model.
This answers which complete system produces the best outcomes. It also preserves the major semantic difference: ComputeDriven refuses over-long transitions at admission; other systems may interrupt work in progress.
Give every implementation the same hot-state capacity and explicit backing representation, then charge every state transfer. This isolates ComputeDriven's selection/residency policy from the advantage conventional runtimes get by leaving all entities memory-resident. Tier B must not be substituted for Tier A; both are necessary.
Reuse R7's deterministic generators and exact seeds:
UNIFORM at density 1, 4 and 8.
SKEW-7/8 at density 4 and 8.
WAITING with externally triggered re-readiness.
REFUSING-1/8, with the same invalid semantic transition and refusal classification.
A long-transition adversary at several declared lengths. ComputeDriven must refuse beyond its bound; preemptive systems may admit and interrupt. Report both behavior and cost.
Primary semantic outcomes:
completed/admitted transitions, total and per Locus;
Loci at zero progress;
oldest-ready age maximum;
ready-to-progress latency p50, p99 and p99.9;
durable LSR advances/s only when every system's durable mode is actually enabled.
Primary physical prices:
retired instructions per admitted transition;
fabric/state bytes moved per admitted transition;
migrations and context switches per 1,000 admitted;
refusal amplification;
peak and per-entity resident memory;
energy per admitted transition where RAPL is available and attributable.
Diagnostics, never the ranking objective: CPU/Carrier utilization, load, harness wall time and Little's-law consistency.
Publish a Pareto frontier rather than one synthetic score: semantic progress, worst-Locus delay, and physical cost. A system that wins throughput by starving one entity does not dominate.
Every system must produce the same final semantic state and per-Locus progress ledger for a fixed trace where scheduling cannot change offered demand.
Mutants that count migration, refusal or partial work as progress must fail.
A starvation control must be visible as zero-progress Loci and growing oldest-ready age even when CPU use or aggregate throughput looks favorable.
Arrival times must be recorded independently of service so coordinated omission cannot hide stalls.
Pin compiler/runtime versions, binaries, affinity, frequency policy, seeds, source and dirty patches.
Alternate system order within blocks and use the repository's fixed sentinel/reference gates.
Do not run an official competitive battery in the current desktop session. The standing ComputeDriven host profile requires a reboot, one terminal, no Codex/browser/VM/BEAM workload, fixed-reference baseline bands, RSD caps and bracketing sentinels. More importantly, R7.2.1B stage 0 explicitly permits semantic development smokes and forbids an official performance battery until review. The next implementation work is a Fable-authored, non-evidentiary adapter/harness design and correctness suite. Official measurements start only after the round authorizes them and the dedicated-host procedure is satisfied.
Linux EEVDF schedules eligible tasks using CPU-time lag and earliest virtual deadline; it can preempt for an earlier deadline: https://docs.kernel.org/scheduler/sched-eevdf.html
Go supports blocked, synchronous and asynchronous safe points and can pause user code with a signal: https://go.dev/src/runtime/preempt.go
Seastar exposes a per-reactor task quota, currently documented with a 0.5 ms default: https://docs.seastar.io/master/structseastar_1_1reactor__options.html
These establish model differences. They are not benchmark results.