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
88 lines
4.6 KiB
C
88 lines
4.6 KiB
C
/* SPDX-License-Identifier: LicenseRef-Starship-1.0
|
|
* Copyright (c) 2023-2026 Robert A. James
|
|
*/
|
|
/* test_stadium_node.c -- kernel/src/vm/stadium.c and session.c on the host (#189, plan
|
|
* 2026-11-13-engine-step4-phase1, Task 1): the Stadium keyed by a v4 node's number (Captain Bob,
|
|
* 2026-11-13: "A new node key"). A node's key is none of v3's (not Hera's all-zero, not "none"); the
|
|
* Stadium can be made with that key in its first quota; the node is born on cell 0, its session
|
|
* registered and pinned, its whole share in its reservoir -- as Hera is on v3's path, which keeps
|
|
* vm_uuid_hera() and stadium_birth_hera().
|
|
*
|
|
* What the sources call outside themselves is defined here.
|
|
*/
|
|
#include "harness.h"
|
|
#include "starkernel/vm/stadium.h"
|
|
#include "starkernel/session.h"
|
|
#include "starkernel/vm_uuid.h"
|
|
#include "starkernel/kmalloc.h"
|
|
#include "starkernel/q48_16.h"
|
|
#include <stdarg.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
|
|
void *kmalloc(size_t size) { return calloc(1, size); }
|
|
void kfree(void *ptr) { free(ptr); }
|
|
kmalloc_stats_t kmalloc_get_stats(void)
|
|
{
|
|
kmalloc_stats_t s;
|
|
memset(&s, 0, sizeof s);
|
|
s.free_bytes = 16u * 1024u * 1024u; /* a small heap: the Stadium takes its percentage of it */
|
|
return s;
|
|
}
|
|
void log_message(int level, const char *fmt, ...) { (void)level; (void)fmt; }
|
|
void sk_hal_panic(const char *message) { printf("PANIC: %s\n", message); exit(2); }
|
|
int blk_flush(uint32_t block_num) { (void)block_num; return 0; }
|
|
|
|
int main(void)
|
|
{
|
|
VMUuid key = stadium_node_key(10), other = stadium_node_key(11);
|
|
Session *s;
|
|
|
|
CHECK(!vm_uuid_is_hera(key) && !vm_uuid_is_none(key), "a node's key is neither Hera's (all-zero) nor none");
|
|
CHECK(!vm_uuid_equal(key, other), "two nodes, two keys");
|
|
CHECK(vm_uuid_equal(key, stadium_node_key(10)), "a node's key is the same each time");
|
|
|
|
CHECK(stadium_boot_init_for(key) == 0 && stadium_is_initialized(), "the Stadium is made with the node's key first");
|
|
CHECK(session_boot_init() == 0, "the sessions");
|
|
CHECK(stadium_quota_slot_for_vm(key) == 0, "the node holds the first quota");
|
|
CHECK(stadium_quota_slot_for_vm(vm_uuid_hera()) < 0, "and Hera's all-zero key none");
|
|
CHECK(stadium_reservoir_peek(key) == Q48_ONE, "its reservoir holds the whole share, 1.0");
|
|
|
|
CHECK(stadium_birth_node(key, "Hera") == 0, "the node is born");
|
|
s = session_find(key);
|
|
CHECK(s != 0 && s->stadium_cell == 0, "on cell 0, patron zero, its session registered");
|
|
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");
|
|
}
|
|
/* the same total, walked a slice at a time (2026-11-19, Captain Bob: "A slice each tick"): the heartbeat
|
|
* takes its one input from a walk of so many cells per tick, so no tick pays for the whole Stadium */
|
|
{
|
|
stadium_heat_walk w = { 0, 0 };
|
|
uint64_t total = stadium_resident_heat_total(), sample = 0;
|
|
size_t ncells = stadium_cell_count();
|
|
unsigned calls = 0;
|
|
int done = 0;
|
|
while (!done && calls < 10000000u) { done = stadium_heat_walk_step(&w, 7, &sample); calls++; }
|
|
CHECK(done && sample == total, "walked 7 cells at a time, a walk's sum is the resident heat (%llu, %llu)",
|
|
(unsigned long long)sample, (unsigned long long)total);
|
|
CHECK(calls == (ncells + 6u) / 7u, " and it is done after ceil(cells / 7) slices (%u, of %zu cells)", calls, ncells);
|
|
calls = 0; done = 0; sample = 0;
|
|
while (!done && calls < 10000000u) { done = stadium_heat_walk_step(&w, 7, &sample); calls++; }
|
|
CHECK(done && sample == total && calls == (ncells + 6u) / 7u, " then it starts again: the next walk the same");
|
|
CHECK(stadium_heat_walk_step(&w, 0, &sample) == 0, "a slice of no cells finishes nothing");
|
|
CHECK(stadium_conserved(key), " and walking changed nothing");
|
|
}
|
|
return DONE();
|
|
}
|