nx_autoopt_library_test.nx source

1// nx_autoopt_library_test.nx -- the team builds its OWN optimization library, autonomously. 2// No hand-authored answers: it sweeps a family of kernels it chose (x*C, C=2..13), 3// and for EACH the GENERATOR (superopt) authors the shortest program, the ENGINEER 4// (execution) verifies it 1:1 on held-out inputs, and the verified-optimal machine code is 5// BANKED into a persistent library. The team also KNOWS its own coverage: a kernel it can't 6// reach within its search depth is recorded as a GAP (self-knowledge, not a failure), which 7// is exactly the signal for self-directed escalation. Who wrote the answers? The team did. 8// Gate: every kernel it CLAIMS to have solved is verified by execution -> exit 0. 9 10import "nx_superopt_emit.nx" // GENERATOR: so_find + se_emit_full 11import "nx_mulchain.nx" // ESCALATION generator: mulchain_find (deeper, faster) 12import "nx_engineer_crash.nx" // ENGINEER: eng_link + eng_run (verify by execution) 13 14func al_puts(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 } 15func al_num(v: i64) -> i64 { 16 let b: *u8 = sys_mmap(28); var m: i64 = v; if m < 0 { m = 0 - m } 17 let t: *u8 = sys_mmap(28); var k: i64 = 0 18 if m == 0 { t[0] = 48; k = 1 } 19 while m > 0 { t[k] = 48 + (m % 10); m = m / 10; k = k + 1 } 20 if v < 0 { al_puts("-" as *u8) } 21 var i: i64 = 0; while i < k { b[i] = t[k - 1 - i]; i = i + 1 } 22 sys_write(1, b, k); return 0 23} 24func tally(r: *i64, n: i64) -> i64 { var ec: i64 = 0; var i: i64 = 0; while i < n { if r[i] != 1 { if ec == 0 { ec = i + 1 } } i = i + 1 } return ec } 25func al_write(path: *u8, buf: *u8, len: i64) -> i64 { let fd: i64 = sys_openat_wr(path, 0x1a4); if fd < 0 { return 0 - 1 } sys_write(fd, buf, len); sys_close(fd); return 0 } 26 27// solve+verify ONE kernel x*C. res: 0=L 1=insns 2=verified 3=reachable 28func opt_one(c: i64, res: *i64) -> i64 { 29 let op: *i64 = sys_mmap(8 * 8) as *i64 30 let a: *i64 = sys_mmap(8 * 8) as *i64 31 let b: *i64 = sys_mmap(8 * 8) as *i64 32 let ex: *i64 = sys_mmap(8 * 32) as *i64 33 let ey: *i64 = sys_mmap(8 * 32) as *i64 34 let dd: *i64 = sys_mmap(8 * 16) as *i64 35 let buf: *u8 = sys_mmap(8192) 36 let icnt: *i64 = sys_mmap(8) as *i64 37 var k: i64 = 0 38 while k < 24 { ex[k] = k * 37 - 400; ey[k] = ex[k] * c; k = k + 1 } 39 dd[0]=5; dd[1]=0-8; dd[2]=123; dd[3]=0-456; dd[4]=77; dd[5]=0-1; dd[6]=1000; dd[7]=0-1000 40 var ref: i64 = 0 41 k = 0; while k < 8 { ref = ref + dd[k] * c; k = k + 1 } 42 ref = ref & 255 43 44 var L: i64 = so_find(ex, ey, 24, op, a, b, 3) 45 res[4] = 0 46 if L == 0 { L = mulchain_find(c, 8, op, a, b); res[4] = 1 } // ESCALATE: get unstuck, not just flag 47 res[0] = L 48 res[3] = 0; if L > 0 { res[3] = 1 } 49 if L == 0 { res[1] = 0; res[2] = 0; return 0 } // still unreachable even after escalation 50 let blen: i64 = se_emit_full(op, a, b, L, dd, 8, buf, icnt) 51 res[1] = icnt[0] 52 al_write("/tmp/al.s" as *u8, buf, blen) 53 if eng_link("/tmp/al.s" as *u8, "/tmp/al.elf" as *u8) != 0 { res[2] = 0; return 0 } 54 let rc: i64 = eng_run("/tmp/al.elf" as *u8, 0 as *u8) 55 res[2] = 0; if rc == ref { res[2] = 1 } 56 return 0 57} 58 59// the autonomous sweep: fills mat[k*4..] for each kernel, and r[k] = verdict (a claimed 60// solve must verify; a gap is acceptable). 61func autorun(lo: i64, hi: i64, mat: *i64, r: *i64) -> i64 { 62 var c: i64 = lo 63 var k: i64 = 0 64 let res: *i64 = sys_mmap(8 * 8) as *i64 65 while c <= hi { 66 opt_one(c, res) 67 mat[k * 5 + 0] = c 68 mat[k * 5 + 1] = res[0] // ops 69 mat[k * 5 + 2] = res[1] // insns 70 mat[k * 5 + 3] = res[2] // verified 71 mat[k * 5 + 4] = res[4] // escalated to chain search? 72 r[k] = 1 73 if res[3] == 1 { if res[2] == 0 { r[k] = 0 } } // claimed reachable but failed verify = bug 74 c = c + 1 75 k = k + 1 76 } 77 return k 78} 79 80// report the banked library + the gaps -- in its own frame (mat/nk fresh args), so the 81// fat-main register-pressure miscompile cannot corrupt the gate that follows. 82func report(mat: *i64, nk: i64) -> i64 { 83 var banked: i64 = 0 84 var gaps: i64 = 0 85 var escs: i64 = 0 86 var totins: i64 = 0 87 var k: i64 = 0 88 while k < nk { 89 let c: i64 = mat[k * 5 + 0] 90 let L: i64 = mat[k * 5 + 1] 91 let ins: i64 = mat[k * 5 + 2] 92 let ver: i64 = mat[k * 5 + 3] 93 let esc: i64 = mat[k * 5 + 4] 94 al_puts(" x*" as *u8); al_num(c) 95 if L == 0 { 96 al_puts(" : GAP (unreachable even after escalation)\n" as *u8); gaps = gaps + 1 97 } else { 98 al_puts(" : " as *u8); al_num(L); al_puts(" ops -> " as *u8); al_num(ins); al_puts(" x86 insns verified=" as *u8) 99 if ver == 1 { al_puts("YES (banked" as *u8); banked = banked + 1; totins = totins + ins; if esc == 1 { al_puts(", via ESCALATION" as *u8); escs = escs + 1 } al_puts(")\n" as *u8) } else { al_puts("NO\n" as *u8) } 100 } 101 k = k + 1 102 } 103 al_puts("----------------------------------------------------------------\n" as *u8) 104 al_puts(" autonomous: banked " as *u8); al_num(banked); al_puts(" verified-optimal kernels (" as *u8); al_num(totins) 105 al_puts(" total insns), " as *u8); al_num(escs); al_puts(" gaps the team CLOSED by escalating its own search, " as *u8); al_num(gaps); al_puts(" left. No hand-authored answers.\n" as *u8) 106 return 0 107} 108 109func main() -> i64 { 110 al_puts("=== AUTONOMOUS optimization-library build (self-closing gaps): author -> verify -> bank -> ESCALATE ===\n" as *u8) 111 let mat: *i64 = sys_mmap(8 * 5 * 32) as *i64 112 let r: *i64 = sys_mmap(8 * 32) as *i64 113 let nk: i64 = autorun(2, 13, mat, r) 114 report(mat, nk) 115 let ec: i64 = tally(r, nk) 116 sys_exit(ec) 117 return ec 118}