code wiki / _hdl_build / nx_consolidate.nx
nx_consolidate.nx source
↩ module page · 181 lines · 8101 B
1// nx_consolidate.nx -- ATLAS-DRIVEN CONSOLIDATION ARCHITECT (operator 2026-07-20: "use the atlas
2// to consolidate and architect so we get object oriented without losing functionalities but always
3// growing"). Composes the atlas dup census (nx_dup_source_check output): for each cross-tree dup
4// basename it BYTE-COMPARES the two copies and proposes a DRY consolidation --
5// IDENTICAL -> SAFE-COLLAPSE to one canonical (functionality preserved BY CONSTRUCTION: same bytes;
6// the byte-equal proof IS the behaviour-preserving gate, rule 25 "never strip features")
7// DIVERGENT -> HAZARD: the copies differ, so collapsing WOULD change behaviour for one consumer
8// (the seq284 stale-nx_syscalls class) -> flagged for seat/PM resolution, NEVER auto-collapsed.
9// Output = the consolq- staging plane (a DERIVED VIEW re-seeded per run = idempotent + self-clearing:
10// when a dup is reconciled it drops off the next run). It never edits a source -- propose, prove, and
11// let a seat apply the gated collapse. Weight: DIVERGENT=CD_W_HAZARD (latent bug) > IDENTICAL.
12// argv: <dupcensus-capture> <consolq-prefix>
13// Report: NX-CONSOLIDATE pairs=N identical=N divergent=N missing=N + one PROPOSE line per pair.
14// exit 0 = ran (proposals are data). license_tier: ORIGINAL No hw writes (Rule 26).
15import "nx_seat_drive_lib.nx"
16import "nx_store_seed_lib.nx"
17import "nx_seg_store.nx"
18import "nx_deploy_lib.nx"
19import "nx_syscalls.nx"
20const CD_MAGIC_1024: i64 = 1024
21
22const CD_CAP: i64 = 1048576
23const CD_FILE_CAP: i64 = 2097152
24const CD_W_HAZARD: i64 = 8
25const CD_W_SAFE: i64 = 5
26
27// read a whole file into buf (cap); returns bytes or -1 if absent
28func cd_readf(path: *u8, buf: *u8, cap: i64) -> i64 {
29 let fd: i64 = sys_openat_rd(path)
30 if fd < 0 { return 0 - 1 }
31 var n: i64 = 0
32 var r: i64 = sys_read(fd, buf, cap - 1)
33 while r > 0 { n = n + r; if n >= cap - 1 { r = 0 } else { r = sys_read(fd, buf + n, cap - 1 - n) } }
34 sys_close(fd)
35 return n
36}
37
38// join tree + "/" + name into out (NUL-terminated)
39func cd_join(out: *u8, tree: *u8, ts: i64, te: i64, name: *u8, ns: i64, ne: i64) -> i64 {
40 var o: i64 = 0
41 var i: i64 = ts
42 while i < te { out[o] = tree[i]; o = o + 1; i = i + 1 }
43 out[o] = 47 as u8
44 o = o + 1
45 i = ns
46 while i < ne { out[o] = name[i]; o = o + 1; i = i + 1 }
47 out[o] = 0 as u8
48 return o
49}
50
51// find literal in buf[from..n); return index or -1
52func cd_find(buf: *u8, from: i64, n: i64, lit: *u8) -> i64 {
53 var ll: i64 = 0
54 while lit[ll] != (0 as u8) { ll = ll + 1 }
55 var p: i64 = from
56 while p + ll <= n {
57 var k: i64 = 0
58 var hit: i64 = 1
59 while k < ll { if buf[p + k] != lit[k] { hit = 0; k = ll } else { k = k + 1 } }
60 if hit == 1 { return p }
61 p = p + 1
62 }
63 return 0 - 1
64}
65
66func main(argc: i64, argv: *i64) -> i64 {
67 if argc < 3 { sd_w("usage: nx_consolidate <dupcensus-capture> <consolq-prefix>\n" as *u8); sys_exit(2); return 2 }
68 let capp: *u8 = argv[1] as *u8
69 let cqp: *u8 = argv[2] as *u8
70 let cb: *u8 = sys_mmap(CD_CAP)
71 let cn: i64 = dp_read(capp, cb, CD_CAP)
72 if cn <= 0 { sd_w("NX-CONSOLIDATE census unreadable\n" as *u8); sys_exit(2); return 2 }
73
74 let fa: *u8 = sys_mmap(CD_FILE_CAP)
75 let fb: *u8 = sys_mmap(CD_FILE_CAP)
76 let pa: *u8 = sys_mmap(CD_MAGIC_1024)
77 let pb2: *u8 = sys_mmap(CD_MAGIC_1024)
78 let outq: *u8 = sys_mmap(CD_CAP)
79 var qo: i64 = 0
80 var pairs: i64 = 0
81 var ident: i64 = 0
82 var diverg: i64 = 0
83 var missing: i64 = 0
84
85 var i: i64 = 0
86 while i < cn {
87 var le: i64 = i
88 var s1: i64 = 1
89 while s1 == 1 { if le >= cn { s1 = 0 } else { if cb[le] == (10 as u8) { s1 = 0 } else { le = le + 1 } } }
90 // a dup line contains "DUP basename: " and "present in both " ... " and " ... ")"
91 let dpos: i64 = cd_find(cb, i, le, "DUP basename: " as *u8)
92 if dpos >= 0 {
93 let ns: i64 = dpos + 14
94 var ne: i64 = ns
95 var s2: i64 = 1
96 while s2 == 1 { if ne >= le { s2 = 0 } else { if cb[ne] == (32 as u8) { s2 = 0 } else { ne = ne + 1 } } }
97 let bpos: i64 = cd_find(cb, ne, le, "present in both " as *u8)
98 if bpos >= 0 { if ne > ns {
99 let as1: i64 = bpos + 16
100 let andp: i64 = cd_find(cb, as1, le, " and " as *u8)
101 if andp >= 0 {
102 let ae: i64 = andp
103 let bs: i64 = andp + 5
104 var be: i64 = bs
105 var s3: i64 = 1
106 while s3 == 1 { if be >= le { s3 = 0 } else { if cb[be] == (41 as u8) { s3 = 0 } else { if cb[be] == (32 as u8) { s3 = 0 } else { be = be + 1 } } } }
107 pairs = pairs + 1
108 cd_join(pa, cb, as1, ae, cb, ns, ne)
109 cd_join(pb2, cb, bs, be, cb, ns, ne)
110 let na: i64 = cd_readf(pa, fa, CD_FILE_CAP)
111 let nb: i64 = cd_readf(pb2, fb, CD_FILE_CAP)
112 var verdict: *u8 = "IDENTICAL" as *u8
113 var w: i64 = CD_W_SAFE
114 if na < 0 { verdict = "MISSING" as *u8; w = CD_W_SAFE; missing = missing + 1 } else {
115 if nb < 0 { verdict = "MISSING" as *u8; w = CD_W_SAFE; missing = missing + 1 } else {
116 var same: i64 = 0
117 if na == nb {
118 same = 1
119 var k: i64 = 0
120 while k < na { if fa[k] != fb[k] { same = 0; k = na } else { k = k + 1 } }
121 }
122 if same == 1 { verdict = "IDENTICAL" as *u8; w = CD_W_SAFE; ident = ident + 1 } else { verdict = "DIVERGENT" as *u8; w = CD_W_HAZARD; diverg = diverg + 1 }
123 }
124 }
125 // proposal row (frontier-shaped): id, title, w, 0, owner, T, deps, lane, note
126 qo = sd_cat(outq, qo, "C" as *u8)
127 qo = sd_num(outq, qo, pairs)
128 qo = sd_cat(outq, qo, "\tconsolidate " as *u8)
129 var nc: i64 = ns
130 while nc < ne { outq[qo] = cb[nc]; qo = qo + 1; nc = nc + 1 }
131 qo = sd_cat(outq, qo, " [" as *u8)
132 qo = sd_cat(outq, qo, verdict)
133 qo = sd_cat(outq, qo, " bytesA=" as *u8)
134 qo = sd_num(outq, qo, na)
135 qo = sd_cat(outq, qo, " bytesB=" as *u8)
136 qo = sd_num(outq, qo, nb)
137 qo = sd_cat(outq, qo, "]\t" as *u8)
138 qo = sd_num(outq, qo, w)
139 qo = sd_cat(outq, qo, "\t0\tconsolidator\tT\t\tconsolidate\t" as *u8)
140 var ta: i64 = as1
141 while ta < ae { outq[qo] = cb[ta]; qo = qo + 1; ta = ta + 1 }
142 qo = sd_cat(outq, qo, "||" as *u8)
143 var tb: i64 = bs
144 while tb < be { outq[qo] = cb[tb]; qo = qo + 1; tb = tb + 1 }
145 qo = sd_cat(outq, qo, "\n" as *u8)
146 sd_w("PROPOSE " as *u8)
147 let nmb: *u8 = sys_mmap(256)
148 var nmo: i64 = 0
149 nc = ns
150 while nc < ne { nmb[nmo] = cb[nc]; nmo = nmo + 1; nc = nc + 1 }
151 nmb[nmo] = 0 as u8
152 sd_w(nmb)
153 sd_w(" " as *u8)
154 sd_w(verdict)
155 sd_w("\n" as *u8)
156 }
157 } }
158 }
159 i = le + 1
160 }
161 let seeded: i64 = sts_seed(cqp, outq, qo)
162 sd_w("NX-CONSOLIDATE pairs=" as *u8)
163 let nb2: *u8 = sys_mmap(64)
164 sd_num(nb2, 0, pairs)
165 sd_w(nb2)
166 sd_w(" identical=" as *u8)
167 sd_num(nb2, 0, ident)
168 sd_w(nb2)
169 sd_w(" divergent=" as *u8)
170 sd_num(nb2, 0, diverg)
171 sd_w(nb2)
172 sd_w(" missing=" as *u8)
173 sd_num(nb2, 0, missing)
174 sd_w(nb2)
175 sd_w(" seeded_rows=" as *u8)
176 sd_num(nb2, 0, seeded)
177 sd_w(nb2)
178 sd_w("\n" as *u8)
179 sys_exit(0)
180 return 0
181}