nx_seg_columnar_gate.nx source

1import "nx_gate_gn.nx" 2// nx_seg_columnar_gate.nx -- exceed-gate for CAP-SEG-COLUMNAR. Proves lossless compression on a column: RLE encodes 3// runs to fewer pairs and decodes back byte-exact; dictionary reduces a low-cardinality column to distinct values + 4// small ids and decodes back byte-exact. This is the analytic-scan win a row store can't give. 5// Sovereign: nx_syscalls + nx_seg_columnar. expect_exit: 0 6import "nx_syscalls.nx" 7import "nx_seg_columnar.nx" 8import "nx_gate_verdict.nx" 9 10func gp(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 } 11func geq(a: *i64, b: *i64, n: i64) -> i64 { var i: i64=0; while i<n { if a[i]!=b[i] { return 0 } i=i+1 } return 1 } 12 13func main(argc: i64, argv: *i64) -> i64 { 14 gp("=== nx_seg_columnar_gate (columnar RLE + dictionary compression, lossless) ===\n" as *u8) 15 var pass: i64=0; var fail: i64=0 16 17 // RLE column: 8 values with runs -> 3 (count,value) runs 18 let vals: *i64=sys_mmap(8*8) as *i64 19 vals[0]=5; vals[1]=5; vals[2]=5; vals[3]=5; vals[4]=3; vals[5]=3; vals[6]=3; vals[7]=9 20 let pairs: *i64=sys_mmap(8*16) as *i64 21 let np: i64 = col_rle_encode(vals, 8, pairs) 22 if np == 3 { pass=pass+1; gp(" T1 RLE encode 8 values -> 3 runs PASS\n" as *u8) } else { fail=fail+1; gp(" T1 FAIL np=" as *u8); gn(np); gp("\n" as *u8) } 23 24 let dec: *i64=sys_mmap(8*16) as *i64 25 let dn2: i64 = col_rle_decode(pairs, np, dec) 26 if dn2 == 8 { if geq(dec, vals, 8)==1 { pass=pass+1; gp(" T2 RLE decode -> 8 values byte-exact (lossless round-trip) PASS\n" as *u8) } else { fail=fail+1; gp(" T2 FAIL bytes\n" as *u8) } } else { fail=fail+1; gp(" T2 FAIL count\n" as *u8) } 27 28 if np*2 < 8 { pass=pass+1; gp(" T3 compressed: " as *u8); gn(np*2); gp(" ints < 8 raw PASS\n" as *u8) } else { fail=fail+1; gp(" T3 FAIL no compression\n" as *u8) } 29 30 // DICTIONARY column: 5 rows, 2 distinct 31 let dv: *i64=sys_mmap(8*8) as *i64 32 dv[0]=100; dv[1]=200; dv[2]=100; dv[3]=100; dv[4]=200 33 let dict: *i64=sys_mmap(8*8) as *i64; let ids: *i64=sys_mmap(8*8) as *i64 34 let card: i64 = col_dict_encode(dv, 5, dict, ids) 35 if card == 2 { pass=pass+1; gp(" T4 dict encode: cardinality 2 < 5 rows (low-card compressed) PASS\n" as *u8) } else { fail=fail+1; gp(" T4 FAIL card=" as *u8); gn(card); gp("\n" as *u8) } 36 37 let dd: *i64=sys_mmap(8*8) as *i64 38 col_dict_decode(dict, ids, 5, dd) 39 if geq(dd, dv, 5)==1 { pass=pass+1; gp(" T5 dict decode -> byte-exact (lossless round-trip) PASS\n" as *u8) } else { fail=fail+1; gp(" T5 FAIL\n" as *u8) } 40 41 gp("RESULT pass=" as *u8); gn(pass); gp(" fail=" as *u8); gn(fail) 42 // MIGRATED onto nx_gate_verdict by nx_gate_dry_apply (D001, minimal form): every check 43 // row above is untouched, so the PASS/FAIL vector cannot change; only the hand-rolled 44 // verdict emission is replaced by the ONE shared base class. Proven by nx_gate_migrate verify. 45 let ctr__dry: *i64 = gv_ctr() 46 ctr__dry[0] = pass 47 ctr__dry[1] = pass + fail 48 let rc__dry: i64 = gv_verdict("SEG-COLUMNAR-GATE" as *u8, ctr__dry, "columnar layout + lossless RLE/dict compression -- analytic-scan class)" as *u8) 49 sys_exit(rc__dry) 50 return rc__dry 51}