Files
LithosAnanke/kernel/tests/test_heartbeat.c
T
Claude 00be537503 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
2026-11-17 20:55:14 +00:00

104 lines
4.9 KiB
C

/* 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();
}