code wiki / _hdl_build / nx_analyst_store_gate.nx
nx_analyst_store_gate.nx source
↩ module page · 130 lines · 6389 B
1// nx_analyst_store_gate.nx -- GATE proving the analytics run on REAL STORED DATA (round-trip through the
2// sovereign seg_store). Writes a known dataset (rows "size<TAB>age<TAB>price", price=5*size-2*age+noise) into
3// a FRESH per-run store, reads it back via ss_scan, extracts columns, and analyzes them -- the report must
4// (a) profile every stored column, (b) name size as the strongest ASSOCIATION with price. Also asserts field-parse
5// correctness + row-count round-trip. expect_exit: 0 license_tier: ORIGINAL
6import "nx_syscalls.nx"
7import "_hdl_build/nx_analyst_store.nx"
8import "nx_gate_verdict.nx"
9
10func sp(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
11func snn(v: i64) -> i64 { var m: i64=v; if m<0{sp("-" as *u8);m=0-m} let t:*u8=sys_mmap(24); 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} let o:*u8=sys_mmap(24); var i:i64=0; while i<k{o[i]=t[k-1-i];i=i+1} sys_write(1,o,k); return 0 }
12func shas(hay: *u8, n: i64, needle: *u8) -> i64 {
13 var nl: i64 = 0
14 while needle[nl] != (0 as u8) { nl = nl + 1 }
15 var i: i64 = 0
16 while i + nl <= n { var j: i64 = 0; var eq: i64 = 1; while j < nl { if hay[i+j] != needle[j] { eq = 0; break } j = j + 1 } if eq == 1 { return 1 } i = i + 1 }
17 return 0
18}
19func lcg(s: i64) -> i64 { return (s * 1103515245 + 12345) & 0x7fffffff }
20// append decimal v to buf at o; return new o
21func scatn(buf: *u8, o: i64, v: i64) -> i64 {
22 var oo: i64 = o
23 var m: i64 = v
24 if m < 0 { buf[oo] = 45 as u8; oo = oo + 1; m = 0 - m }
25 let t: *u8 = sys_mmap(24)
26 var k: i64 = 0
27 if m == 0 { t[0] = 48 as u8; k = 1 }
28 while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
29 var i: i64 = k - 1
30 while i >= 0 { buf[oo] = t[i]; oo = oo + 1; i = i - 1 }
31 return oo
32}
33
34func main() -> i64 {
35 sp("=== nx_analyst_store_gate (analytics on REAL stored data) ===\n" as *u8)
36 var pass: i64 = 0
37 var fail: i64 = 0
38
39 // T0 field-parse correctness (independent of the store)
40 let sample: *u8 = "125\t18\t-609" as *u8
41 var t0: i64 = 1
42 if asr_field_i64(sample, 11, 0) != 125 { t0 = 0 }
43 if asr_field_i64(sample, 11, 1) != 18 { t0 = 0 }
44 if asr_field_i64(sample, 11, 2) != (0 - 609) { t0 = 0 }
45 if t0 == 1 { pass = pass + 1 } else { fail = fail + 1; sp("T0 FAIL field parse\n" as *u8) }
46
47 // build a FRESH per-run store prefix: /tmp/anstore_<now_us>
48 let prefix: *u8 = sys_mmap(128)
49 var po: i64 = 0
50 let pfx: *u8 = "/tmp/anstore_" as *u8
51 while pfx[po] != (0 as u8) { prefix[po] = pfx[po]; po = po + 1 }
52 let now: i64 = sys_now_us()
53 po = scatn(prefix, po, now)
54 prefix[po] = 0 as u8
55
56 // write N rows under key "dsrow". N<=256: the seg_store scan hard-caps at 256 results/key (documented
57 // in asr_load_field) -- 250 proves a CLEAN full round-trip within the store contract; sharded-load for
58 // >256 is the named scale follow-on.
59 let n: i64 = 250
60 let w: *i64 = ss_begin()
61 let row: *u8 = sys_mmap(64)
62 var s: i64 = 11
63 var i: i64 = 0
64 while i < n {
65 s = lcg(s)
66 let size: i64 = 50 + (s % 150)
67 s = lcg(s)
68 let age: i64 = s % 40
69 s = lcg(s)
70 let price: i64 = 5 * size - 2 * age + (s % 20)
71 var ro: i64 = 0
72 ro = scatn(row, ro, size)
73 row[ro] = 9 as u8; ro = ro + 1
74 ro = scatn(row, ro, age)
75 row[ro] = 9 as u8; ro = ro + 1
76 ro = scatn(row, ro, price)
77 ss_add(w, 1, "dsrow" as *u8, row, ro)
78 i = i + 1
79 }
80 let cr: i64 = ss_commit(prefix, w, now)
81 sp("committed rc=" as *u8); snn(cr); sp(" prefix="); sp(prefix); sp("\n" as *u8)
82
83 // T1 row-count round-trip: load field 0 -> exactly n rows back
84 let col: *i64 = sys_mmap(8 * (n + 16)) as *i64
85 let got: i64 = asr_load_field(prefix, "dsrow" as *u8, 0, col, n + 8)
86 sp("rows read back=" as *u8); snn(got); sp("\n" as *u8)
87 if got == n { pass = pass + 1 } else { fail = fail + 1; sp("T1 FAIL row-count round-trip\n" as *u8) }
88
89 // T2 a stored value parsed correctly: first row's size is in [50,199]
90 var t2: i64 = 1
91 if col[0] < 50 { t2 = 0 }
92 if col[0] > 199 { t2 = 0 }
93 if t2 == 1 { pass = pass + 1 } else { fail = fail + 1; sp("T2 FAIL stored value range\n" as *u8) }
94
95 // T3 FULL analyze on stored data -> report names size as the key driver of price
96 let names: *i64 = sys_mmap(8 * 3) as *i64
97 names[0] = "size" as *u8 as i64
98 names[1] = "age" as *u8 as i64
99 names[2] = "price" as *u8 as i64
100 let out: *u8 = sys_mmap(16384)
101 let rw: i64 = asr_analyze_stored(prefix, "dsrow" as *u8, names, 3, 2, n + 8, out, 16384)
102 sp(out); sp("\n---\n" as *u8)
103 var t3: i64 = 1
104 if rw <= 0 { t3 = 0 }
105 if shas(out, rw, "DATASET ANALYSIS" as *u8) == 0 { t3 = 0 }
106 if shas(out, rw, "DATA PROFILE: size" as *u8) == 0 { t3 = 0 }
107 if shas(out, rw, "DATA PROFILE: price" as *u8) == 0 { t3 = 0 }
108 if shas(out, rw, "size has the strongest association" as *u8) == 0 { t3 = 0 }
109 if t3 == 1 { pass = pass + 1 } else { fail = fail + 1; sp("T3 FAIL analyze-stored\n" as *u8) }
110
111 sp("pass=" as *u8); snn(pass); sp(" fail=" as *u8); snn(fail); sp("\n" as *u8)
112 let log: *u8 = sys_mmap(128)
113 var lo: i64 = 0
114 let pre: *u8 = "ANALYSTSTORE authored=organ verdict=" as *u8
115 var pi: i64 = 0
116 while pre[pi] != (0 as u8) { log[lo] = pre[pi]; lo = lo + 1; pi = pi + 1 }
117 if fail == 0 { let g: *u8 = "GREEN\n" as *u8; var gi: i64 = 0; while g[gi] != (0 as u8) { log[lo] = g[gi]; lo = lo + 1; gi = gi + 1 } } else { let r: *u8 = "RED\n" as *u8; var ri: i64 = 0; while r[ri] != (0 as u8) { log[lo] = r[ri]; lo = lo + 1; ri = ri + 1 } }
118 let fd: i64 = sys_openat_wr("knowledge/status/analyst_store.log" as *u8, 0x1A4)
119 if fd >= 0 { sys_write(fd, log, lo); sys_close(fd) }
120
121 // MIGRATED onto nx_gate_verdict by nx_gate_dry_apply (D001, minimal form): every check
122 // row above is untouched, so the PASS/FAIL vector cannot change; only the hand-rolled
123 // verdict emission is replaced by the ONE shared base class. Proven by nx_gate_migrate verify.
124 let ctr__dry: *i64 = gv_ctr()
125 ctr__dry[0] = pass
126 ctr__dry[1] = pass + fail
127 let rc__dry: i64 = gv_verdict("ANALYST-STORE-GATE" as *u8, ctr__dry, "teeth unchanged; verdict emission migrated onto the shared base class" as *u8)
128 sys_exit(rc__dry)
129 return rc__dry
130}