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
127 lines
6.0 KiB
C
127 lines
6.0 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 unsigned slices = 1; /* how many ticks a walk of the source takes (2026-11-19: a slice each tick) */
|
|
static uint64_t value(void)
|
|
{
|
|
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
|
|
|
|
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());
|
|
|
|
/* 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);
|
|
{
|
|
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();
|
|
}
|