feat(v4, kernel): ONE adaptive heartbeat -- it paces itself on the Stadium's resident heat; every VM ticks on it, in lockstep

Captain Bob, 2026-11-17: "The adaptive heartbeat is its own thing ... It has its own independent RWOT and slope
provider. Only one output from the entire stadium is used as a load measurement for heart rate pacing. ... ONE
AS IN THE NUMBER 1 heartbeat (the adaptive one) runs the entire system." Ruled one at a time: the kernel's
heartbeat; resident heat its one input; held in POST; the Stadium charged as before today
(docs/v4.0.0/plans/2026-11-17-one-adaptive-heartbeat.md, its first version kept as superseded).

- kernel/src/heartbeat.c, timer.h: heartbeat_pace_from(load) -- its own window of samples, its own slope
  provider (v4's inference arithmetic) every HEARTBEAT_PACE_EVERY samples, Loop #7 setting its own period
  (not stable 20% faster, stable 25% slower, 1/4..4x the 10 ms base). No source (v3's path): nothing runs.
- kernel/src/vm/stadium.c: stadium_resident_heat_total(), read only -- the one output it paces by.
- v4/system/mesh.c, mesh.h: the owner's clock read at every fabric step; each tick delivered, one by one, to
  every node present -- its heartbeat cycle run, active, idle or blocked alike. The tick by execution, the
  nodes' own Loop #7 and the heartrate callback are gone.
- kernel/src/v4/sk_v4.c: the clock gives the heartbeat's bottom half its turn; 0 until POST has ended.
- Tests first, each seen to fail (does not build): kernel/tests/test_heartbeat.c (11 checks),
  test_stadium_node.c (16), test_mesh_boot.c's lockstep checks. Seven Phase 7 checks that assumed the tick by
  execution now drive the test's heartbeat (ruled). POST 990/990 with v3's heat cases as written;
  mesh-boot 103, -on 112, -noop 100, san-mesh-boot 103, every v4 program at both widths, every kernel host
  test: 0 failures. The full `sanitize` target not run (it outlasts the foreground limit).

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-17 20:55:14 +00:00
parent 4a5c9bfd42
commit 00be537503
12 changed files with 462 additions and 88 deletions
+42
View File
@@ -37,6 +37,9 @@
#include "starkernel/timer.h"
#include "starkernel/capsule_vm_switch_signal.h" /* FABRIC-3.md §XXVIII Stage 3 */
#if STARFORTH_V4
#include "v4/inference.h" /* the heartbeat's own slope provider: v4's inference arithmetic */
#endif
#if defined(ARCH_AMD64)
#define HEARTBEAT_HAS_VARIANCE 1
@@ -63,6 +66,42 @@ static volatile int g_pending_valid;
* rate even if it forwarded an unclamped value. */
static volatile uint64_t g_adaptive_period_ns = HEARTBEAT_BASE_PERIOD_NS;
/* The heartbeat's own pacing (timer.h, heartbeat_pace_from): its load source, its own rolling window of samples,
* and its own slope provider's state. Mainline only (heartbeat_service), as the rest of the bottom half. */
static heartbeat_load_fn g_pace_load;
static uint64_t g_pace_window[HEARTBEAT_PACE_WINDOW];
static uint64_t g_pace_samples, g_pace_runs;
#if STARFORTH_V4
static uint64_t g_pace_trajectory[HEARTBEAT_PACE_WINDOW];
static v4_inference_out g_pace_inference;
#endif
void heartbeat_pace_from(heartbeat_load_fn load) { g_pace_load = load; }
uint64_t heartbeat_pace_samples(void) { return g_pace_samples; }
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();
g_pace_samples++;
#if STARFORTH_V4
if (g_pace_samples % HEARTBEAT_PACE_EVERY == 0) {
uint64_t n = g_pace_samples < HEARTBEAT_PACE_WINDOW ? g_pace_samples : HEARTBEAT_PACE_WINDOW, i, cur, next;
for (i = 0; i < n; i++) /* oldest first */
g_pace_trajectory[i] = g_pace_window[(g_pace_samples - n + i) % HEARTBEAT_PACE_WINDOW];
v4_inference_run(g_pace_trajectory, n, 0, 0, &g_pace_inference);
g_pace_runs++;
/* Loop #7, v3's rule: stable, 25% slower; else 20% faster -- heartbeat_set_adaptive_period_ns clamps it
* to a quarter to four times the base */
cur = g_adaptive_period_ns;
next = g_pace_inference.early_exited ? (cur * 125u) / 100u : (cur * 80u) / 100u;
heartbeat_set_adaptive_period_ns(next);
}
#endif
}
#if HEARTBEAT_HAS_VARIANCE
/**
@@ -156,6 +195,8 @@ void heartbeat_init(uint64_t tsc_hz, uint64_t tick_hz)
g_pending_valid = 0;
g_adaptive_period_ns = HEARTBEAT_BASE_PERIOD_NS;
g_pace_samples = 0;
g_pace_runs = 0;
}
void heartbeat_tick(void)
@@ -189,6 +230,7 @@ void heartbeat_service(void)
TimeTrustState *s = &g_heartbeat;
s->total_samples++;
pace_sample(); /* the heartbeat's own RWOT, when it paces itself */
if (s->total_samples == 1) {
s->last_tsc = now;
+17 -3
View File
@@ -89,8 +89,18 @@ static void *sk_v4_alloc(void *self, unsigned long bytes)
return p;
}
static void sk_v4_release(void *self, void *p) { (void)self; kfree(p); }
/* Loop #7 on Hera: the kernel's heartbeat re-armed at the period her inference sets, as v3's Hera does */
static void sk_v4_heartrate(void *self, uint64_t ns) { (void)self; heartbeat_set_adaptive_period_ns(ns); }
/* THE ONE ADAPTIVE HEARTBEAT (Captain Bob, 2026-11-17; plan 2026-11-17-one-adaptive-heartbeat): the kernel's
* heartbeat, which paces itself on the Stadium's resident heat (heartbeat.c). Every node's tick is its tick --
* held, 0, until POST has ended (as v3's boot runs POST before its timer starts), then the heartbeat's ticks since.
* 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;
static uint64_t sk_v4_clock(void *self)
{
(void)self;
heartbeat_service();
return sk_v4_heart_live ? heartbeat_ticks() - sk_v4_heart_base : 0u;
}
static void sk_v4_charge_one(void *ctx, v4_cell id, v4_uheat_t calls)
{
(void)ctx;
@@ -345,7 +355,8 @@ void sk_v4_boot(void (*chain)(void), const BootDisk *boot_disk)
sk_v4_mesh.forgot = sk_v4_forgot;
sk_v4_mesh.physics = sk_v4_physics;
sk_v4_mesh.alloc = sk_v4_alloc; sk_v4_mesh.release = sk_v4_release;
sk_v4_mesh.heartrate = sk_v4_heartrate;
sk_v4_mesh.clock = sk_v4_clock;
heartbeat_pace_from(stadium_resident_heat_total); /* 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;
@@ -357,6 +368,9 @@ void sk_v4_boot(void (*chain)(void), const BootDisk *boot_disk)
sk_v4_dump(0, 0u);
sk_v4_stop(); /* #177: halts, not a 100% spin */
}
/* POST has ended: from here every node ticks on the heartbeat */
sk_v4_heart_base = heartbeat_ticks();
sk_v4_heart_live = 1;
if (chain) {
/* the blocks are other blocks now: what the node has in its two
* buffers is POST's, and is let go */
+11
View File
@@ -821,6 +821,17 @@ uint64_t stadium_resident_sum(VMUuid vm_id) {
return sum;
}
/* The one output the adaptive heartbeat paces by (Captain Bob, 2026-11-17: "Only one output from the entire stadium
* is used as a load measurement for heart rate pacing" -- resident heat): the heat of every patron on the floor,
* summed over the whole Stadium, whoever's quota. Read only. */
uint64_t stadium_resident_heat_total(void) {
uint64_t sum = 0;
size_t i;
for (i = 0; i < stadium_ncells; i++)
if (bitmap_get(i)) sum += stadium_cell_array[i].header.heat;
return sum;
}
void stadium_consumed_record(VMUuid vm_id, uint64_t amount) {
int slot = quota_slot_for_vm(vm_id);