code wiki / _hdl_build / nx_layered_backlog_test.nx
`nx_layered_backlog_test.nx` source

1// nx_layered_backlog_test.nx -- prove "next moves" are deterministic + L8-up + parallel + no-skip.
2// A backlog with the foundation (L8..L5) done and work remaining at L4/L3/L0 must: pick L4 as the
3// frontier, return BOTH L4 items as the parallel batch, refuse to build L3 or the L0 output yet,
4// and -- once L4 completes -- advance the frontier to L3. Exit 0 if all hold. license_tier: ORIGINAL
5
6import "nx_layered_backlog.nx"
7import "nx_syscalls.nx"
8
9func bt_puts(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
10func bt_num(v: i64) -> i64 { let bb: *u8 = sys_mmap(28); var m: i64=v; if m<0 {m=0-m; sys_write(1,"-" as *u8,1)}; let t: *u8 = sys_mmap(28); var k: i64=0; if m==0 {t[0]=48;k=1}; while m>0 {t[k]=48+(m%10); m=m/10; k=k+1}; var i: i64=0; while i<k {bb[i]=t[k-1-i]; i=i+1}; sys_write(1, bb, k); return 0 }
11
12func main() -> i64 {
13    bt_puts("=== LAYERED BACKLOG: deterministic next moves, L8 up to L0 ===\n" as *u8)
14    // layer, done. foundation L8..L5 DONE; two TODO at L4 (parallel), one at L3, the output at L0.
15    let N: i64 = 9
16    let layer: *i64 = sys_mmap(8*16) as *i64
17    let done:  *i64 = sys_mmap(8*16) as *i64
18    layer[0]=8; done[0]=1     // machine-code: integer moments + perception kernel
19    layer[1]=7; done[1]=1     // kernels: qmatvec/qlayer
20    layer[2]=6; done[2]=1     // ALU
21    layer[3]=5; done[3]=1     // organs: Critic / Researcher / Librarian
22    layer[4]=4; done[4]=0     // TODO: perception-aware fidelity integration
23    layer[5]=4; done[5]=0     // TODO: imatrix K-quant (parallel with [4])
24    layer[6]=3; done[6]=0     // TODO: KIVI 2-bit KV (depends on L4 done)
25    layer[7]=0; done[7]=0     // the OUTPUT: lossless perceptual generation (depends on all)
26    layer[8]=8; done[8]=1     // another machine-code item, done
27
28    let out: *i64 = sys_mmap(8*16) as *i64
29    let f: i64 = bl_frontier(N, layer, done)
30    let cnt: i64 = bl_parallel_batch(N, layer, done, out)
31    bt_puts(" frontier layer = " as *u8); bt_num(f); bt_puts("  parallel next-moves = " as *u8); bt_num(cnt); bt_puts(" items:" as *u8)
32    var i: i64 = 0
33    while i < cnt { bt_puts(" i" as *u8); bt_num(out[i]); i = i + 1 }
34    bt_puts("\n" as *u8)
35
36    let r: *i64 = sys_mmap(8*8) as *i64
37    r[0] = 0; if f == 4 { r[0] = 1 }                                         // deepest unfinished layer
38    r[1] = 0; if cnt == 2 { r[1] = 1 }                                       // both L4 items, in parallel
39    r[2] = 0; if bl_buildable(N, layer, done, 6) == 0 { r[2] = 1 }           // L3 NOT buildable (no skip)
40    r[3] = 0; if bl_buildable(N, layer, done, 7) == 0 { r[3] = 1 }           // L0 output NOT buildable yet
41    // advance: finish L4 -> frontier moves up to L3
42    done[4] = 1; done[5] = 1
43    r[4] = 0; if bl_frontier(N, layer, done) == 3 { if bl_buildable(N, layer, done, 6) == 1 { r[4] = 1 } }
44    var pass: i64 = 0; var j: i64 = 0
45    while j < 5 { pass = pass + r[j]; j = j + 1 }
46    bt_puts("----\n passed " as *u8); bt_num(pass); bt_puts("/5\n" as *u8)
47    if pass == 5 { bt_puts(" DETERMINISTIC: next move = the parallel batch at the deepest unfinished layer; build L8->L0; no skipping; no randomness.\n" as *u8); sys_exit(0); return 0 }
48    bt_puts(" FAIL\n" as *u8); sys_exit(1); return 1
49}
nx_layered_backlog_test.nx source

`nx_layered_backlog_test.nx` source
