[Japabu]

Stacked on the affinity PR (#1116), which is stacked on #1111. Review only the last two commits: 8277dc466 (the key) and c9f88d36e (review r1), as rebased onto main 8122a4ef5 with no conflict in this PR. Host CI at the stack's top (8a1357642): 109 steps, all green, exit 0 (log). Before that rebase: 109 steps, all green, exit 0 (log).

Problem

CpuHandles::place ranked a spawn's candidates by (load, !sleeping, busy_siblings) and broke every remaining tie by the rotation. A spawn therefore woke a CPU in its deepest declared idle state as readily as one in C1. idle_near already weighs the published idle exit for a wake forward; spawn placement ignored it.

Behaviour

• The spawn key is now (load, !sleeping_unrung, busy_siblings, idle_exit).
  • Among free-core sleepers with equal queues, the shallowest one is woken.
  • A sleeper with a kick already on its way ranks as awake (Doorbell::sleeping_unrung, the test a wake forward uses). A kicked CPU keeps reading SLEEPING until its next pass and keeps its published exit until it wakes, and a spawn raises no published load, so without this a burst of spawns would all choose the one shallow sleeper.
  • The rotation breaks only ties between equal exits.
  • A free core still comes before a shallow sibling of a running CPU.
• This reverses Idle CPUs enter the deep states their firmware declares #1073's choice that a spawn reads no idle exit. That PR's rulings covered the wake-forward tiebreak, and I found no owner ruling on spawns. The basis for the change is the accepted scheduling model, under which placement weighs wake cost. Idle CPUs enter the deep states their firmware declares #1073's test a_spawn_lands_where_it_would_whatever_the_sleepers_exits is replaced by a_spawn_wakes_the_shallowest_free_core_sleeper.
• The simulator plans C1, so every exit there is 0 and its scenarios place as before.
• issues/the-scheduler-and-the-clocks-never-talk.md now says so, and idle_exit's doc names both readers.

Why it was shelved, and why it can land now

On the T14, an earlier head (161fc1e1c, on the base before affinity) had one boot refuse pingpong.pipe.same_cpu: "the_ponger_was_not_placed". That row staged its ponger by spawning until a thread happened to land on the CPU where the pinger sat parked. Under this rule, once that CPU idled deep, no spawn chose it. The rule was right and the bench's premise was false. With the affinity PR, the benches pin instead of staging, so a placement rule no longer decides whether a row can run.

Checks

Evidence: pr-1117/r2 at 100a3523; round 1 pr-1117/r1 at 3d29475d.

• Review r1 (e8e96821c): host CI at the top of the stack (1178599c4, sched: a woken partner follows its waker's LLC #1129) passed all 108 steps, exit 0. The new host test a_spawn_passes_over_a_rung_sleeper rings the shallowest sleeper and places again. The control (the key ranking plain SLEEPING) reds it and nothing else, exit 101, applied and reversed in the same run.

• Host CI and QEMU at this commit (28a55585c): cargo run -- --ci host passed all 106 steps, and the two affinity QEMU tests passed. Both exited 0, and both logs are in sched: a thread runs only on the CPUs its process's mask names #1116's evidence.

• Mutations at 28a55585c: dropping the exit from the key, and ranking the exit before busy_siblings. Each reds only a_spawn_wakes_the_shallowest_free_core_sleeper, with exit 101.

• Rebased onto 49559ddb2: host CI (108 steps) and the QEMU pair are green; see sched: a thread runs only on the CPUs its process's mask names #1116.

Metal A/B (base 0c7e62ca7, head 28a55585c, 4 boots per image per side per bench, evidence)

Every boot returned rc=0. A row resolves only when all 4 of one side's runs beat all 4 of the other's (p = 0.029).

The A/B measures the whole stack, so it does not isolate this commit. Spawn placement is what this commit changes.

The isolating reading is ab3's AMD arms without and with this commit, 3 boots each (pr-1111/r2): proc.posix_spawn_wait.std p50 535–545 µs without it against 410–467 µs with it, and .tiny 71–79 µs against 45–64 µs. Every boot with the commit beat every boot without it in both rows (p = 0.1 at 3 a side). Those arms predate the kick check above.

• AMD:
  • spawn_cost median: base 348–379 µs, head 277–307 µs, resolved (about −19%).
  • Also resolved: process.spawn_wait −21%, proc.posix_spawn_wait.std −21%, .tiny −15%.
• T14:
  • spawn_cost: base 281–305 µs, head 262–281 µs, not resolved (the sides overlap at 281).
  • Resolved: process.spawn_wait −6% and posix_spawn_wait.std −4%.
  • proc.spawn_wait.large read +13%, not resolved (p 0.057).
• The AMD's slow ipc and fs rows are not this commit's. In the 9-boot diagnostic, each row follows where its pair landed, in every arm. Without this commit 3 of 6 rows were split across the LLCs; with it, 4 of 6 (pr-1111/r2). Spawn placement has no LLC locality before this commit or after it.

Risks

• Whether spawns reach shallow CPUs often enough to pay is read from spawn_cost in the bundled A/B. A missing gain on one bench would not by itself reject the rule.
• On a machine with a single declared idle state every exit is equal, and nothing changes.

🤖 Generated with Claude Code

[Japabu]

Review r2 of #1117 at e8e96821c

Round-1 required finding: fixed. The spawn key is (load, !sleeping_unrung, busy_siblings, idle_exit) (kernel/pure/sched/cpu.rs:2860-2863 at the stack top):

• A rung sleeper now ranks as awake. A spawn raises no published load, but its adopt rings the target, so the next spawn in a burst skips that CPU.
• Doorbell::sleeping_unrung (kernel/pure/sched/mailbox.rs:527) reads both bits in one load. forward_target shares it, which removes a duplicated two-load test rather than adding one.
• a_spawn_passes_over_a_rung_sleeper states exactly that claim. Its control (r16/mut-1117-rung.log) reds only that test.
• The masks from sched: a thread runs only on the CPUs its process's mask names #1116 are still honoured: the scan filters on mask before keying.

The rung-but-unloaded case ranks ahead of a loaded awake CPU through load, which is the right order: an idle CPU being woken still beats a queue.

No blocker, no suggestion. LAND.