From 5c79bddbbb9972cf8ea8cb09e7859e26a5d86ee9 Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 13 Nov 2026 22:17:50 +0000 Subject: [PATCH] feat(v4): Phase 7 Task 3, first step -- each node's tick by execution, as v3 (#189) Captain Bob, 2026-11-13: "By execution, as v3". v3's kernel runs a VM's heartbeat cycle every 256 word executions (HEARTBEAT_CHECK_FREQUENCY, vm_core.c:912 and :1210), and its tick_count is the count of cycles. Task 2a had used the kernel's timer heartbeat as the decay clock: corrected. Each node counts its word calls; every 256th runs its heartbeat cycle at the call; the cycle's loops follow. The kernel no longer gives the mesh its timer. Test first: test_mesh_boot.c, 59 checks (67 with pipelining and the cache on). Not pushed (held to the end of Phase 7). Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_017RzZgrf7V7Zk2iczBXDRbm --- ...-engine-step4-phase7-the-loops-and-parity.md | 7 +++++++ kernel/src/v4/sk_v4.c | 2 -- v4/include/v4/mesh.h | 8 +++++--- v4/system/mesh.c | 17 +++++++++++++++-- v4/tests/test_mesh_boot.c | 14 ++++++++++++++ 5 files changed, 41 insertions(+), 7 deletions(-) diff --git a/docs/v4.0.0/plans/2026-11-13-engine-step4-phase7-the-loops-and-parity.md b/docs/v4.0.0/plans/2026-11-13-engine-step4-phase7-the-loops-and-parity.md index 3088a7b8..5592a7f9 100644 --- a/docs/v4.0.0/plans/2026-11-13-engine-step4-phase7-the-loops-and-parity.md +++ b/docs/v4.0.0/plans/2026-11-13-engine-step4-phase7-the-loops-and-parity.md @@ -119,6 +119,13 @@ Phase 4). (`hotwords_cache_promote`, `v3/src/physics_hotwords_cache.c`). v4 does the same. And v3 never calls `transition_metrics_record_prefetch_miss`: its misses are always 0, as v4's. ### Task 3: the per-tick loops (tuner, slope, background decay, L8, inference, snapshot) +- [x] **The tick, by execution** (Captain Bob, 2026-11-13: "By execution, as v3"). v3's kernel runs a VM's + heartbeat cycle every 256 word executions (`HEARTBEAT_CHECK_FREQUENCY`, `kernel/src/vm/vm_core.c:912` + and `:1210`), and its tick is the count of cycles; the timer heartbeat is not the VM's tick. Task 2a + had used the kernel's timer: corrected. Each node counts its word calls; every 256th runs its cycle + at the call. Test first (`test_mesh_boot.c`, 59 and 67 checks). +- [ ] The cycle's loops, in v3's order (`vm_heartbeat_run_cycle`): tick; inference every 1000 ticks; + background decay; the window's service; L8's update; the snapshot. ### Task 4: the words that read and set them (`FREEZE-WORD`, the inference words, ...), and their POST ### Task 5: the StarForth words (Phase 3's: `init.4th`, `starforth.4th`), and their POST ### Task 6: the ACL (Phase 4's: `ACL.4th`, the word card, the countdown), and its POST diff --git a/kernel/src/v4/sk_v4.c b/kernel/src/v4/sk_v4.c index 1ec1cb2f..0b25c6b3 100644 --- a/kernel/src/v4/sk_v4.c +++ b/kernel/src/v4/sk_v4.c @@ -78,7 +78,6 @@ static uint32_t sk_v4_charge_ids[V4_MESH_WORD_IDS]; static uint64_t sk_v4_charge_calls[V4_MESH_WORD_IDS]; static uint32_t sk_v4_charge_n; static v4_mesh_physics sk_v4_physics[SK_V4_PLACES]; /* each node's physics: its tick, decay slope, L8's gates (#189, Phase 7) */ -static uint64_t sk_v4_heartbeat_ticks(void) { return heartbeat_ticks(); } /* what decay is measured by, as v3's VM tick */ /* a word's transition counters, from the kernel's heap, zeroed (pipelining, when the build has it) */ static void *sk_v4_alloc(void *self, unsigned long bytes) { @@ -322,7 +321,6 @@ 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.ticks = sk_v4_heartbeat_ticks; sk_v4_mesh.alloc = sk_v4_alloc; sk_v4_mesh.release = sk_v4_release; 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]; diff --git a/v4/include/v4/mesh.h b/v4/include/v4/mesh.h index 0e7c5b88..9daa7ea6 100644 --- a/v4/include/v4/mesh.h +++ b/v4/include/v4/mesh.h @@ -100,8 +100,11 @@ typedef struct { #define V4_MESH_WINDOW 4096u /* v3's ROLLING_WINDOW_SIZE */ #define V4_MESH_WINDOW_WARM 1024u /* executions before the window is warm, as v3 */ #define V4_MESH_ADAPTIVE_CHECK 512u /* v3's ADAPTIVE_CHECK_FREQUENCY: executions between diversity checks */ +#define V4_MESH_CHECK_FREQUENCY 256u /* v3's HEARTBEAT_CHECK_FREQUENCY: word calls a heartbeat cycle */ typedef struct { - uint64_t tick; + uint64_t tick; /* the node's heartbeat cycles (v3's tick_count): by execution, as v3 */ + uint32_t check_counter; /* word calls since the last cycle */ + uint32_t cycle_every; /* V4_MESH_CHECK_FREQUENCY */ uint64_t decay_slope_q48; uint8_t l3_decay; /* L8's gate on Loop #3 */ uint8_t l2_window; /* L8's gate on Loop #2 */ @@ -156,7 +159,6 @@ struct v4_mesh { v4_mesh_account *accounts; unsigned char *is_word; v4_mesh_physics *physics; /* `capacity` of them: each node's (#189, Phase 7) */ - uint64_t (*ticks)(void); /* the heartbeat's tick count, read at each call (0: v4_mesh_set_tick's) */ /* memory for a word's transition counters, zeroed, and given back (pipelining; may be 0: none recorded) */ void *(*alloc)(void *self, unsigned long bytes); void (*release)(void *self, void *p); @@ -199,7 +201,7 @@ int v4_mesh_busy(const v4_mesh *ms); /* A word's record on the node in `place`, by its xt: 0 if that is not a word's xt. */ const v4_mesh_account *v4_mesh_account_at(const v4_mesh *ms, unsigned place, v4_cell xt); -/* The heartbeat's tick, for every node (v3's vm->heartbeat.tick_count): what decay is measured by. */ +/* Every node's tick set to `tick` (for tests: a node's tick is its own count of heartbeat cycles). */ void v4_mesh_set_tick(v4_mesh *ms, uint64_t tick); /* A word's state flags (V4_MESH_STATE_*), or 0 if xt is not a word's. */ diff --git a/v4/system/mesh.c b/v4/system/mesh.c index fd926f84..4a6c497a 100644 --- a/v4/system/mesh.c +++ b/v4/system/mesh.c @@ -340,6 +340,13 @@ static void pipeline(unsigned place, v4_mesh_physics *p, uint32_t id) } #endif +/* a node's heartbeat cycle (v3's vm_heartbeat_run_cycle): its tick; the per-tick loops follow (Task 3) */ +static void heartbeat_cycle(unsigned place, v4_mesh_physics *p) +{ + (void)place; + p->tick++; +} + /* at `call` (exec.h), on a word -- any other target, nothing -- in v3's order (physics_pre_execute, * V3-PARITY.md 2.1; Captain Bob, 2026-11-13: "Every call, as v3"): decay by the ticks since, heat +1, * the count the Stadium is charged by, the temperature, the rolling window */ @@ -354,7 +361,6 @@ static void on_call(void *ctx, v4_node *n, v4_cell target) a = &accounts_of(place)[id]; if (the->physics) { v4_mesh_physics *p = &the->physics[place]; - if (the->ticks) p->tick = the->ticks(); decay(a, p, p->tick - a->last_decay_tick); a->last_decay_tick = p->tick; a->heat++; @@ -370,6 +376,12 @@ static void on_call(void *ctx, v4_node *n, v4_cell target) if (p->l1_cache && a->heat > V4_MESH_HOT_HEAT && !hot_has(place, target)) promote(place, target); #endif p->prev_id = (uint32_t)id; + /* the heartbeat, by execution (v3: every HEARTBEAT_CHECK_FREQUENCY words its VM executes; + * Captain Bob, 2026-11-13: "By execution, as v3") */ + if (++p->check_counter >= p->cycle_every) { + p->check_counter = 0; + heartbeat_cycle(place, p); + } } a->calls++; a->since++; @@ -419,11 +431,12 @@ static void words_attach(unsigned place, v4_fabric_node *x) } if (the->physics) { /* the node's physics, as v3's VM starts */ v4_mesh_physics *p = &the->physics[place]; - uint64_t tick = p->tick; /* the heartbeat's, which goes on */ + uint64_t tick = 0; /* its own count of cycles, from none */ unsigned char *z = (unsigned char *)p; unsigned long i; for (i = 0; i < sizeof *p; i++) z[i] = 0; p->tick = tick; + p->cycle_every = V4_MESH_CHECK_FREQUENCY; p->decay_slope_q48 = V4_MESH_INITIAL_DECAY_SLOPE_Q48; p->l3_decay = 1; p->l2_window = 1; /* v3: "No config yet: recorded" */ diff --git a/v4/tests/test_mesh_boot.c b/v4/tests/test_mesh_boot.c index 6d44b7f1..73eb0997 100644 --- a/v4/tests/test_mesh_boot.c +++ b/v4/tests/test_mesh_boot.c @@ -225,8 +225,14 @@ int main(void) v4_mesh_physics *p = &ms.physics[0]; const v4_mesh_account *a; uint64_t total0; + uint32_t every = p->cycle_every; r = line(V4_MESH_HERA, ": P7 DUP * ; ' P7 .", &how); a = v4_mesh_account_at(&ms, 0, (v4_cell)strtol(r, 0, 10)); + /* the tick, by execution (Captain Bob, 2026-11-13: "By execution, as v3"): every 256 word calls a + * node's heartbeat cycle runs, and its tick is the count of them -- held still here, so decay's + * arithmetic is seen exactly, and seen moving below */ + CHECK(every == 256u, "a node's heartbeat cycle comes every 256 word calls, as v3's HEARTBEAT_CHECK_FREQUENCY"); + p->cycle_every = 0xFFFFFFFFu; v4_mesh_set_tick(&ms, 100); total0 = p->total_executions; r = line(V4_MESH_HERA, "2 P7 3 P7 4 P7 + + .", &how); @@ -256,6 +262,14 @@ int main(void) r = line(V4_MESH_HERA, "2 P7 .", &how); CHECK(a && a->heat == 1, "and with it on, 300 ticks take all six, then one: %lu", a ? (unsigned long)a->heat : 0ul); v4_mesh_set_tick(&ms, 0); + p->cycle_every = every; + { + uint64_t t0 = p->tick; + r = line(V4_MESH_HERA, ": LP7 300 0 DO 2 P7 DROP LOOP ; LP7", &how); + CHECK(p->tick >= t0 + 2, + "300 calls of P7, and the many the line's compiling makes: the tick moves, a cycle per 256 (%lu)", + (unsigned long)(p->tick - t0)); + } r = line(V4_MESH_HERA, "FORGET P7", &how); } r = line(V4_MESH_HERA, "3 SQ .", &how);