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