code wiki / _hdl_build / nx_frontier.nx
nx_frontier.nx source
↩ module page · 146 lines · 6672 B
1// nx_frontier.nx -- X-PAR-004: the DEPENDENCY FRONTIER (operator 2026-06-12: ordered
2// right, everything else works IN PARALLEL as self-sufficiency grows). Per beat:
3// READY = TODO rows whose deps are ALL satisfied (DONE, or '-') -- the parallel
4// work surface: every section/clone/lane can pull from ITS ready set NOW
5// BLOCKED= TODO rows waiting, each naming its FIRST unmet dep (the next domino)
6// Emits FRONTIER summary + per-owner ready counts + the top ready ids per owner ->
7// knowledge/status/frontier.log (parts/sections/conductor consume; SITREP line).
8// Exit 0 = derived; exit 1 = unreadable world. argv[1]=queue (gates use scratch).
9// license_tier: ORIGINAL
10import "nx_syscalls.nx"
11const K_MAGIC_1048576: i64 = 1048576
12const K_MAGIC_1048560: i64 = 1048560
13func _p(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
14func _fp(fd: i64, s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(fd,s,n); return 0 }
15func _fn(fd: i64, v: i64) -> i64 { let bb: *u8=sys_mmap(28); var m: i64=v; if m<0{m=0-m; sys_write(fd,"-" as *u8,1)}; let t: *u8=sys_mmap(28); var k: i64=0; if m==0{t[0]=48 as u8;k=1}; while m>0{t[k]=(48+(m%10)) as u8;m=m/10;k=k+1}; var i: i64=0; while i<k{bb[i]=t[k-1-i];i=i+1}; sys_write(fd,bb,k); return 0 }
16func fr_read(path: *u8, buf: *u8, cap: i64) -> i64 {
17 let fd: i64 = sys_openat_rd(path)
18 if fd < 0 { return 0 }
19 var n: i64 = 0
20 var go: i64 = 1
21 while go == 1 { let base: i64 = buf as i64; let r: i64 = sys_read(fd, (base + n) as *u8, cap - n); if r <= 0 { go = 0 } else { n = n + r } if n >= cap { go = 0 } }
22 sys_close(fd)
23 return n
24}
25func fr_cols(q: *u8, ls: i64, le: i64, sp: *i64) -> i64 {
26 var c: i64 = 0
27 var p: i64 = ls
28 while c < 9 {
29 var e: i64 = p
30 var s: i64 = 1
31 while s == 1 { if e >= le { s = 0 } else { if q[e] == (9 as u8) { s = 0 } else { e = e + 1 } } }
32 sp[c*2] = p
33 sp[c*2+1] = e
34 c = c + 1
35 if e >= le { return c }
36 p = e + 1
37 }
38 return c
39}
40func fr_slice_eq(a: *u8, s: i64, e: i64, b: *u8, bs: i64, be: i64) -> i64 {
41 if e - s != be - bs { return 0 }
42 var i: i64 = 0
43 while s + i < e { if a[s+i] != b[bs+i] { return 0 } i = i + 1 }
44 return 1
45}
46// is the dep slice [da,db) the id of a DONE row? (ids/status indexed via second pass)
47func fr_dep_done(q: *u8, qn: i64, da: i64, db: i64) -> i64 {
48 var i: i64 = 0
49 while i < qn {
50 var le: i64 = i
51 var s: i64 = 1
52 while s == 1 { if le >= qn { s = 0 } else { if q[le] == (10 as u8) { s = 0 } else { le = le + 1 } } }
53 if q[i] != (35 as u8) {
54 let sp: *i64 = sys_mmap(160) as *i64
55 let nc: i64 = fr_cols(q, i, le, sp)
56 if nc == 9 {
57 if fr_slice_eq(q, sp[0], sp[1], q, da, db) == 1 {
58 if q[sp[10]] == (68 as u8) { return 1 }
59 return 0
60 }
61 }
62 }
63 i = le + 1
64 }
65 // dep id not found in queue = treat as satisfied-elsewhere ONLY if it looks like
66 // a non-queue ref; honest default: NOT satisfied (missing dep = blocked, loud)
67 return 0
68}
69// all deps in [a,b) CSV satisfied? '-' = none. Writes first unmet [ua,ub) to u.
70func fr_deps_ok(q: *u8, qn: i64, a: i64, b: i64, u: *i64) -> i64 {
71 if b - a == 1 { if q[a] == (45 as u8) { return 1 } }
72 var p: i64 = a
73 while p < b {
74 var e: i64 = p
75 var s: i64 = 1
76 while s == 1 { if e >= b { s = 0 } else { if q[e] == (44 as u8) { s = 0 } else { e = e + 1 } } }
77 if e > p {
78 if fr_dep_done(q, qn, p, e) == 0 { u[0] = p; u[1] = e; return 0 }
79 }
80 p = e + 1
81 }
82 return 1
83}
84func main(argc: i64, argv: *i64) -> i64 {
85 var qp: *u8 = "knowledge/registry/assignment_queue.tsv" as *u8
86 if argc >= 2 { qp = argv[1] as *u8 }
87 _p("=== FRONTIER: the parallel work surface (ready NOW vs blocked-by-what) ===\n" as *u8)
88 let q: *u8 = sys_mmap(K_MAGIC_1048576)
89 let qn: i64 = fr_read(qp, q, K_MAGIC_1048560)
90 if qn <= 0 { _p(" queue MISSING -- fail loud\n" as *u8); sys_exit(1); return 1 }
91 let lfd: i64 = sys_openat_append("knowledge/status/frontier.log" as *u8, 0x1a4)
92 if lfd < 0 { _p(" frontier log open failed\n" as *u8); sys_exit(1); return 1 }
93 let sp: *i64 = sys_mmap(160) as *i64
94 let u: *i64 = sys_mmap(16) as *i64
95 let qbase: i64 = q as i64
96 var ready: i64 = 0
97 var blocked: i64 = 0
98 var shown: i64 = 0
99 var i: i64 = 0
100 while i < qn {
101 var le: i64 = i
102 var s: i64 = 1
103 while s == 1 { if le >= qn { s = 0 } else { if q[le] == (10 as u8) { s = 0 } else { le = le + 1 } } }
104 if q[i] != (35 as u8) {
105 let nc: i64 = fr_cols(q, i, le, sp)
106 if nc == 9 {
107 if q[sp[10]] == (84 as u8) {
108 if fr_deps_ok(q, qn, sp[12], sp[13], u) == 1 {
109 ready = ready + 1
110 // show high-weight ready rows (w >= 8) as FRONTIER-READY lines
111 if q[sp[4]] >= (56 as u8) {
112 if shown < 12 {
113 _fp(lfd, "FRONTIER-READY id=" as *u8)
114 sys_write(lfd, (qbase + sp[0]) as *u8, sp[1] - sp[0])
115 _fp(lfd, " w=" as *u8)
116 sys_write(lfd, (qbase + sp[4]) as *u8, sp[5] - sp[4])
117 _fp(lfd, " owner=" as *u8)
118 sys_write(lfd, (qbase + sp[8]) as *u8, sp[9] - sp[8])
119 _fp(lfd, "\n" as *u8)
120 shown = shown + 1
121 }
122 }
123 } else {
124 blocked = blocked + 1
125 if blocked <= 6 {
126 _fp(lfd, "FRONTIER-BLOCKED id=" as *u8)
127 sys_write(lfd, (qbase + sp[0]) as *u8, sp[1] - sp[0])
128 _fp(lfd, " waits=" as *u8)
129 sys_write(lfd, (qbase + u[0]) as *u8, u[1] - u[0])
130 _fp(lfd, "\n" as *u8)
131 }
132 }
133 }
134 }
135 }
136 i = le + 1
137 }
138 _fp(lfd, "FRONTIER epoch=" as *u8); _fn(lfd, sys_now_realtime_sec())
139 _fp(lfd, " ready=" as *u8); _fn(lfd, ready)
140 _fp(lfd, " blocked=" as *u8); _fn(lfd, blocked)
141 _fp(lfd, " verdict=DERIVED\n" as *u8)
142 sys_close(lfd)
143 _p(" FRONTIER: derived (ready set = the parallel surface; knowledge/status/frontier.log)\n" as *u8)
144 sys_exit(0)
145 return 0
146}