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:
@@ -192,6 +192,22 @@ void heartbeat_service(void);
|
||||
*/
|
||||
uint64_t heartbeat_read_counter(void);
|
||||
|
||||
/* ---- The one adaptive heartbeat paces itself (StarForth v4; Captain Bob, 2026-11-17: "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"; docs/v4.0.0/plans/2026-11-17-one-adaptive-heartbeat.md). Given a load source -- the Stadium's resident
|
||||
* heat, on v4 -- every serviced tick samples it into the heartbeat's own rolling window; every
|
||||
* HEARTBEAT_PACE_EVERY samples its own slope provider (v4's inference arithmetic) runs on that window, and Loop
|
||||
* #7's rule sets the period: not stable, 20% faster; stable, 25% slower; within a quarter to four times the base.
|
||||
* The source is only read. With none (v3's path) nothing of this runs and the period is left to its setter. */
|
||||
#ifndef HEARTBEAT_PACE_EVERY
|
||||
#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);
|
||||
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);
|
||||
|
||||
/**
|
||||
* Get current TIME-TICKS (monotonic heartbeat count).
|
||||
*/
|
||||
|
||||
@@ -393,6 +393,10 @@ int stadium_quota_slot_for_vm(VMUuid vm_id);
|
||||
*/
|
||||
uint64_t stadium_resident_sum(VMUuid vm_id);
|
||||
|
||||
/* The heat of every patron on the floor, summed over the whole Stadium: the one output the adaptive heartbeat paces
|
||||
* by (kernel/src/heartbeat.c, heartbeat_pace_from; Captain Bob, 2026-11-17). Read only. */
|
||||
uint64_t stadium_resident_heat_total(void);
|
||||
|
||||
/*
|
||||
* stadium_conserved - Boolean analogue of vm_physics_conserved(), for the
|
||||
* Stadium per-VM quota invariant rather than fleet-wide execution heat
|
||||
|
||||
@@ -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
@@ -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 */
|
||||
|
||||
@@ -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);
|
||||
|
||||
|
||||
@@ -19,7 +19,11 @@ CC ?= cc
|
||||
CFLAGS := -std=c99 -Wall -Wextra -Werror -O2 -g -I$(HERE) -I$(ROOT)/kernel/include \
|
||||
-I$(ROOT)/kernel/include/starkernel -I$(ROOT)/v3/include
|
||||
|
||||
TESTS := test_gpt test_usb_config test_sk_v4_stop test_sk_v4_slots test_sk_v4_mint test_sk_v4_identity test_heartbeat_export test_ssm_jacquard test_physics_l2 test_stadium_node test_stadium_ops test_stadium_words
|
||||
TESTS := test_heartbeat test_gpt test_usb_config test_sk_v4_stop test_sk_v4_slots test_sk_v4_mint test_sk_v4_identity test_heartbeat_export test_ssm_jacquard test_physics_l2 test_stadium_node test_stadium_ops test_stadium_words
|
||||
# the one adaptive heartbeat paces itself (plan 2026-11-17-one-adaptive-heartbeat): heartbeat.c, its Q48.16, and the
|
||||
# v4 inference arithmetic its slope provider runs
|
||||
SRC_test_heartbeat := $(ROOT)/kernel/src/heartbeat.c $(ROOT)/kernel/src/math/q48_16.c $(ROOT)/v4/system/inference.c
|
||||
EXTRA_test_heartbeat := -D__STARKERNEL__ -DSTARFORTH_V4=1 -DARCH_AMD64 -I$(ROOT)/v4/include
|
||||
SRC_test_stadium_ops := $(ROOT)/kernel/src/vm/stadium_ops.c $(ROOT)/kernel/src/vm/stadium.c $(ROOT)/kernel/src/vm/session.c $(ROOT)/kernel/src/capsule/vm_uuid.c
|
||||
EXTRA_test_stadium_ops := -D__STARKERNEL__
|
||||
SRC_test_stadium_words := $(ROOT)/kernel/src/vm/stadium_words.c $(ROOT)/kernel/src/vm/stadium.c $(ROOT)/kernel/src/vm/session.c $(ROOT)/kernel/src/capsule/vm_uuid.c
|
||||
|
||||
@@ -0,0 +1,103 @@
|
||||
/* SPDX-License-Identifier: LicenseRef-Starship-1.0
|
||||
* Copyright (c) 2023-2026 Robert A. James
|
||||
*/
|
||||
/* test_heartbeat.c -- the one adaptive heartbeat paces itself (docs/v4.0.0/plans/2026-11-17-one-adaptive-
|
||||
* heartbeat.md; Captain Bob, 2026-11-17: "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").
|
||||
*
|
||||
* heartbeat.c with the v4 inference arithmetic, and a load source the test controls in place of the Stadium's
|
||||
* resident heat. Checked:
|
||||
* - with no load source (v3's path, and the boot before v4 starts it), the period is never touched by itself;
|
||||
* - with one, each serviced tick samples the load into the heartbeat's own window;
|
||||
* - every HEARTBEAT_INFERENCE_FREQUENCY samples its slope provider runs on that window, and Loop #7's rule sets
|
||||
* the period: not stable, 20% faster; stable (the variance within 5% of the last run's), 25% slower;
|
||||
* - always within a quarter to four times the 10 ms base;
|
||||
* - the load source is only read: nothing else is called.
|
||||
*/
|
||||
#include "harness.h"
|
||||
#include "starkernel/timer.h"
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
/* what heartbeat.c needs of the rest of the kernel, here */
|
||||
static uint64_t counter;
|
||||
uint64_t heartbeat_read_counter(void) { return counter += 1000u; }
|
||||
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)
|
||||
{
|
||||
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;
|
||||
}
|
||||
|
||||
#define BASE 10000000ULL
|
||||
|
||||
static void ticks(unsigned n)
|
||||
{
|
||||
unsigned i;
|
||||
for (i = 0; i < n; i++) { heartbeat_tick(); heartbeat_service(); }
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
printf("test_heartbeat\n");
|
||||
heartbeat_init(100000u, 100u);
|
||||
|
||||
/* no load source: v3's path -- the heartbeat does not pace itself */
|
||||
ticks(3000);
|
||||
CHECK(heartbeat_next_period_ns() == BASE, "no load source: the period stays at the base (%llu)",
|
||||
(unsigned long long)heartbeat_next_period_ns());
|
||||
CHECK(heartbeat_pace_samples() == 0, "and nothing is sampled");
|
||||
|
||||
/* the load source: sampled every serviced tick */
|
||||
load_mode = 1; loads_read = 0;
|
||||
heartbeat_pace_from(load);
|
||||
ticks(10);
|
||||
CHECK(heartbeat_pace_samples() == 10 && loads_read == 10, "each serviced tick samples the load once (%llu, %llu read)",
|
||||
(unsigned long long)heartbeat_pace_samples(), (unsigned long long)loads_read);
|
||||
|
||||
/* the first inference: no variance before it -- not stable: 20% faster */
|
||||
ticks(HEARTBEAT_PACE_EVERY - 10u);
|
||||
CHECK(heartbeat_pace_runs() == 1, "the slope provider ran after %u samples", HEARTBEAT_PACE_EVERY);
|
||||
CHECK(heartbeat_next_period_ns() == BASE * 80u / 100u, "not stable: the period 20%% shorter (%llu)",
|
||||
(unsigned long long)heartbeat_next_period_ns());
|
||||
|
||||
/* the same spread again: its variance within 5% of the last run's -- stable: 25% slower */
|
||||
ticks(HEARTBEAT_PACE_EVERY);
|
||||
CHECK(heartbeat_pace_runs() == 2, "it ran again");
|
||||
CHECK(heartbeat_next_period_ns() == BASE * 80u / 100u * 125u / 100u, "stable: 25%% longer, back to %llu",
|
||||
(unsigned long long)heartbeat_next_period_ns());
|
||||
|
||||
/* the same spread for many runs: stable each time -- slower, held at four times the base */
|
||||
ticks(HEARTBEAT_PACE_EVERY * 20u);
|
||||
CHECK(heartbeat_next_period_ns() == BASE * 4u, "stable run after run: slower, held at four times the base (%llu)",
|
||||
(unsigned long long)heartbeat_next_period_ns());
|
||||
|
||||
/* a spread that doubles each run (its variance four times the last): never stable -- faster each run, until a
|
||||
* quarter of the base */
|
||||
load_mode = 2;
|
||||
ticks(HEARTBEAT_PACE_EVERY * 20u);
|
||||
CHECK(heartbeat_next_period_ns() == BASE / 4u, "never stable: faster each run, held at a quarter of the base (%llu)",
|
||||
(unsigned long long)heartbeat_next_period_ns());
|
||||
|
||||
/* a constant load: steady -- slower each run? its variance is 0, and v3's rule (ported to the bit) calls a
|
||||
* variance of 0 never stabilized, so it stays fast: recorded as the rule is */
|
||||
load_mode = 0; load_value = 500u;
|
||||
ticks(HEARTBEAT_PACE_EVERY * 20u);
|
||||
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());
|
||||
|
||||
/* stopped: no source, no pacing */
|
||||
heartbeat_pace_from(0);
|
||||
{
|
||||
uint64_t p = heartbeat_next_period_ns(), s = heartbeat_pace_samples();
|
||||
ticks(3000);
|
||||
CHECK(heartbeat_next_period_ns() == p && heartbeat_pace_samples() == s, "the source taken away: pacing stops");
|
||||
}
|
||||
return DONE();
|
||||
}
|
||||
@@ -55,5 +55,15 @@ int main(void)
|
||||
CHECK(session_is_pinned(key), "and pinned");
|
||||
CHECK(stadium_conserved(key), "conservation holds: resident heat and reservoir sum to 1.0");
|
||||
CHECK(stadium_birth_node(key, "Hera") == 0 && session_find(key) == s, "born twice is born once");
|
||||
|
||||
/* the one output the heartbeat paces by (Captain Bob, 2026-11-17: resident heat): the heat on the floor,
|
||||
* summed over the Stadium -- every patron's, whoever's quota -- and nothing changed by reading it */
|
||||
{
|
||||
uint64_t total = stadium_resident_heat_total();
|
||||
CHECK(total == stadium_resident_sum(key), "resident heat over the Stadium: the one node's resident sum (%llu)",
|
||||
(unsigned long long)total);
|
||||
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");
|
||||
}
|
||||
return DONE();
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user