heartbeat: the Stadium's resident heat, walked a slice each tick -- CI's aarch64 BIRTH stall

The heartbeat's one input walked all 335,544 Stadium cells every tick,
about 15 ms on aarch64 TCG, longer than a tick. At fast pacing it took
the CPU, and a birth missed the session's 300 s on CI. That was my
11-17 change.

Captain Bob ruled: sample less often, scaled by the cells, measured
first, as a slice each tick; the slope inference later.
- stadium_heat_walk_step() walks STADIUM_HEAT_SLICE_CELLS cells per
  tick (Kconfig, 5500, about 0.25 ms on aarch64 TCG).
- A completed walk is one sample.
- The heartbeat's load takes a sample only when a walk is done.

Test first: test_stadium_node (21 checks) and test_heartbeat (13). Both
failed to build before. All kernel host tests pass. Four aarch64 boots
in a row pass 18/18 each, BIRTH included.

The evidence is in logs/20261119-heat-slice.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017RzZgrf7V7Zk2iczBXDRbm
This commit is contained in:
Claude
2026-11-19 02:32:38 +00:00
parent 13fae6df30
commit 7975bab049
27 changed files with 1254 additions and 7 deletions
+2 -1
View File
@@ -494,6 +494,7 @@ $(eval $(call kconfig_int,STADIUM_CONTAINS_DEPTH_MAX,5))
$(eval $(call kconfig_int,STADIUM_CAPACITY_TICK,1000))
$(eval $(call kconfig_int,STADIUM_MEMORY_PERCENT,1))
$(eval $(call kconfig_int,STADIUM_WORD_HEAT_QUANTUM,2048))
$(eval $(call kconfig_int,STADIUM_HEAT_SLICE_CELLS,5500))
$(eval $(call kconfig_int,STADIUM_WORD_COOL_RATE_Q48,21845))
$(eval $(call kconfig_int,STADIUM_BLOCK_HEAT_QUANTUM,2048))
$(eval $(call kconfig_int,STADIUM_BLOCK_COOL_RATE_Q48,21845))
@@ -543,7 +544,7 @@ VM_FEATURE_FLAG_VARS := \
HEARTBEAT_SLOPE_VALIDATION_FREQUENCY SK_PARITY_DEBUG \
EMERGENCY_CONSOLE_ENABLED STADIUM_MAX_VM_COUNT \
STADIUM_CONTAINS_DEPTH_MAX STADIUM_CAPACITY_TICK \
STADIUM_MEMORY_PERCENT \
STADIUM_MEMORY_PERCENT STADIUM_HEAT_SLICE_CELLS \
SSM_ENTROPY_HIGH_THRESHOLD SSM_CV_HIGH_THRESHOLD \
SSM_TEMPORAL_DECAY_THRESHOLD SSM_TEMPORAL_DECAY_LOW_THRESHOLD \
SSM_HYSTERESIS_TICKS \
+3 -1
View File
@@ -203,7 +203,9 @@ uint64_t heartbeat_read_counter(void);
#define HEARTBEAT_PACE_EVERY 1000u /* samples between runs: Kconfig.heartbeat's inference frequency */
#endif
#define HEARTBEAT_PACE_WINDOW 1024u /* the heartbeat's own rolling window, in samples */
typedef uint64_t (*heartbeat_load_fn)(void);
/* The source does a slice of its work each call, and gives a sample (returns 1) when a whole one is done
* (2026-11-19: the Stadium walked a slice each tick); 0 otherwise. */
typedef int (*heartbeat_load_fn)(uint64_t *sample);
void heartbeat_pace_from(heartbeat_load_fn load); /* 0: no source, no pacing */
uint64_t heartbeat_pace_samples(void);
uint64_t heartbeat_pace_runs(void);
+11
View File
@@ -397,6 +397,17 @@ uint64_t stadium_resident_sum(VMUuid vm_id);
* by (kernel/src/heartbeat.c, heartbeat_pace_from; Captain Bob, 2026-11-17). Read only. */
uint64_t stadium_resident_heat_total(void);
/* The same total, walked a slice at a time (Captain Bob, 2026-11-19: "A slice each tick"). A whole walk of the
* Stadium is ~15 ms on aarch64 under TCG (335,544 cells, ~22,000 a millisecond), more than a heartbeat tick: the
* heartbeat that took it every tick starved the system (CI's aarch64 BIRTH stall). Each step walks the next `cells`
* cells into `w`; when the walk reaches the end it gives the sum in *sample, returns 1 and starts again; otherwise 0.
* A walk's sum is stadium_resident_heat_total() as it stood over the walk. Read only. */
typedef struct { size_t cursor; uint64_t acc; } stadium_heat_walk;
int stadium_heat_walk_step(stadium_heat_walk *w, size_t cells, uint64_t *sample);
#ifndef STADIUM_HEAT_SLICE_CELLS
#define STADIUM_HEAT_SLICE_CELLS 5500u /* Kconfig: ~0.25 ms on aarch64 TCG, a tenth of the fastest tick (2.5 ms) */
#endif
/*
* stadium_conserved - Boolean analogue of vm_physics_conserved(), for the
* Stadium per-VM quota invariant rather than fleet-wide execution heat
+3 -2
View File
@@ -83,8 +83,9 @@ uint64_t heartbeat_pace_runs(void) { return g_pace_runs; }
/* one sample of the load into the window; every HEARTBEAT_PACE_EVERY of them, the slope provider and Loop #7 */
static void pace_sample(void)
{
if (!g_pace_load) return;
g_pace_window[g_pace_samples % HEARTBEAT_PACE_WINDOW] = g_pace_load();
uint64_t v;
if (!g_pace_load || !g_pace_load(&v)) return; /* a slice each tick; a sample when a walk is done */
g_pace_window[g_pace_samples % HEARTBEAT_PACE_WINDOW] = v;
g_pace_samples++;
#if STARFORTH_V4
if (g_pace_samples % HEARTBEAT_PACE_EVERY == 0) {
+5 -1
View File
@@ -95,6 +95,10 @@ static void sk_v4_release(void *self, void *p) { (void)self; kfree(p); }
* Read by the mesh at every fabric step, which also gives the heartbeat's bottom half its turn during a line. */
static int sk_v4_heart_live;
static uint64_t sk_v4_heart_base;
/* The heartbeat's one input: the Stadium's resident heat, walked a slice each tick (2026-11-19). */
static stadium_heat_walk sk_v4_heat_walk;
static int sk_v4_heat(uint64_t *sample) { return stadium_heat_walk_step(&sk_v4_heat_walk, STADIUM_HEAT_SLICE_CELLS, sample); }
static uint64_t sk_v4_clock(void *self)
{
(void)self;
@@ -356,7 +360,7 @@ void sk_v4_boot(void (*chain)(void), const BootDisk *boot_disk)
sk_v4_mesh.physics = sk_v4_physics;
sk_v4_mesh.alloc = sk_v4_alloc; sk_v4_mesh.release = sk_v4_release;
sk_v4_mesh.clock = sk_v4_clock;
heartbeat_pace_from(stadium_resident_heat_total); /* the heartbeat's one input: the Stadium's resident heat */
heartbeat_pace_from(sk_v4_heat); /* the heartbeat's one input: the Stadium's resident heat */
sk_v4_mesh.out = sk_v4_out; sk_v4_mesh.key = sk_v4_key;
sk_v4_mesh.words = sk_v4_words; sk_v4_mesh.word_count = sizeof sk_v4_words / sizeof sk_v4_words[0];
sk_v4_mesh.serve = sk_v4_serve;
+13
View File
@@ -832,6 +832,19 @@ uint64_t stadium_resident_heat_total(void) {
return sum;
}
int stadium_heat_walk_step(stadium_heat_walk *w, size_t cells, uint64_t *sample) {
size_t k;
if (!w || !sample || cells == 0 || stadium_ncells == 0) return 0;
if (w->cursor >= stadium_ncells) { w->cursor = 0; w->acc = 0; }
for (k = 0; k < cells && w->cursor < stadium_ncells; k++, w->cursor++)
if (bitmap_get(w->cursor)) w->acc += stadium_cell_array[w->cursor].header.heat;
if (w->cursor < stadium_ncells) return 0;
*sample = w->acc;
w->cursor = 0;
w->acc = 0;
return 1;
}
void stadium_consumed_record(VMUuid vm_id, uint64_t amount) {
int slot = quota_slot_for_vm(vm_id);
+25 -2
View File
@@ -26,14 +26,24 @@ void sk_vm_switch_signal_tick(void) { }
static uint64_t load_value, loads_read;
static int load_mode; /* 0 constant; 1 alternating, the same spread; 2 a spread that doubles each run */
static uint64_t load(void)
static unsigned slices = 1; /* how many ticks a walk of the source takes (2026-11-19: a slice each tick) */
static uint64_t value(void)
{
loads_read++;
if (load_mode == 1) return (loads_read & 1u) ? 100u : 200u;
/* doubling for six runs, then back: v4's inference variance (v3's, ported to the bit) saturates beyond that */
if (load_mode == 2) return (loads_read & 1u) ? 100u : 100u + (100u << (heartbeat_pace_runs() % 6u));
return load_value;
}
/* the source: a slice each call; a walk done every `slices` calls gives a sample */
static unsigned slice_at;
static int load(uint64_t *sample)
{
if (++slice_at < slices) return 0;
slice_at = 0;
loads_read++;
*sample = value();
return 1;
}
#define BASE 10000000ULL
@@ -92,6 +102,19 @@ int main(void)
CHECK(heartbeat_next_period_ns() >= BASE / 4u && heartbeat_next_period_ns() <= BASE * 4u,
"a constant load: within the bounds (%llu)", (unsigned long long)heartbeat_next_period_ns());
/* a source whose walk takes three ticks (the Stadium walked a slice at a time): a sample every third tick,
* and the slope provider runs after HEARTBEAT_PACE_EVERY samples, not ticks */
heartbeat_pace_from(0); heartbeat_init(100000u, 100u);
load_mode = 1; loads_read = 0; slices = 3; slice_at = 0;
heartbeat_pace_from(load);
ticks(30);
CHECK(heartbeat_pace_samples() == 10 && loads_read == 10, "a walk of three slices: 30 ticks, 10 samples (%llu)",
(unsigned long long)heartbeat_pace_samples());
ticks(HEARTBEAT_PACE_EVERY * 3u - 30u);
CHECK(heartbeat_pace_runs() == 1, " and the slope provider runs after %u samples: %u ticks", HEARTBEAT_PACE_EVERY,
HEARTBEAT_PACE_EVERY * 3u);
slices = 1;
/* stopped: no source, no pacing */
heartbeat_pace_from(0);
{
+18
View File
@@ -65,5 +65,23 @@ int main(void)
CHECK(total + stadium_reservoir_peek(key) == Q48_ONE, "with its reservoir, the whole share: 1.0");
CHECK(stadium_resident_heat_total() == total && stadium_conserved(key), "read twice, the same; nothing changed");
}
/* the same total, walked a slice at a time (2026-11-19, Captain Bob: "A slice each tick"): the heartbeat
* takes its one input from a walk of so many cells per tick, so no tick pays for the whole Stadium */
{
stadium_heat_walk w = { 0, 0 };
uint64_t total = stadium_resident_heat_total(), sample = 0;
size_t ncells = stadium_cell_count();
unsigned calls = 0;
int done = 0;
while (!done && calls < 10000000u) { done = stadium_heat_walk_step(&w, 7, &sample); calls++; }
CHECK(done && sample == total, "walked 7 cells at a time, a walk's sum is the resident heat (%llu, %llu)",
(unsigned long long)sample, (unsigned long long)total);
CHECK(calls == (ncells + 6u) / 7u, " and it is done after ceil(cells / 7) slices (%u, of %zu cells)", calls, ncells);
calls = 0; done = 0; sample = 0;
while (!done && calls < 10000000u) { done = stadium_heat_walk_step(&w, 7, &sample); calls++; }
CHECK(done && sample == total && calls == (ncells + 6u) / 7u, " then it starts again: the next walk the same");
CHECK(stadium_heat_walk_step(&w, 0, &sample) == 0, "a slice of no cells finishes nothing");
CHECK(stadium_conserved(key), " and walking changed nothing");
}
return DONE();
}