nx_team_tick.nx source

1// nx_team_tick.nx -- the team's AUTONOMY TICK: one self-contained beat of the whole self- 2// improvement loop, so it runs INDEPENDENTLY (wrap in a loop / cron) or on the operator's 3// TRIGGER (just run it). One tick exercises the full stack, bits-up, end to end: 4// GATE level -- synthesize a boolean circuit (majority) + verify EXACTLY (truth table) 5// MACHINE level -- synthesize+emit a multiply (x*C) + verify BY EXECUTION 6// RACE -- cost it vs the newest gcc, classify the standing 7// REPORT -- one honest line + TICK COMPLETE 8// Everything sovereign (the team's own generators/verifiers/racer); no human in the beat. 9 10import "nx_mulchain.nx" 11import "nx_superopt_emit.nx" 12import "nx_engineer_crash.nx" 13import "nx_gcc_race.nx" 14import "nx_boolsynth.nx" 15const K_MAGIC_8192: i64 = 8192 16 17func tk_puts(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 } 18func tk_num(v: i64) -> i64 { 19 let bb: *u8 = sys_mmap(28); var m: i64 = v; if m < 0 { m = 0 - m } 20 let t: *u8 = sys_mmap(28); var k: i64 = 0 21 if m == 0 { t[0] = 48; k = 1 } 22 while m > 0 { t[k] = 48 + (m % 10); m = m / 10; k = k + 1 } 23 if v < 0 { tk_puts("-" as *u8) } 24 var i: i64 = 0; while i < k { bb[i] = t[k - 1 - i]; i = i + 1 } 25 sys_write(1, bb, k); return 0 26} 27func tk_bwrite(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 } 28func tk_genc(c: i64, path: *u8) -> i64 { 29 let buf: *u8 = sys_mmap(128); var oi: i64 = 0 30 let pre: *u8 = "long f(long x){return x*" as *u8 31 var j: i64 = 0; while pre[j] != (0 as u8) { buf[oi] = pre[j]; oi = oi + 1; j = j + 1 } 32 let t: *u8 = sys_mmap(28); var m: i64 = c; var k: i64 = 0; if m == 0 { t[0]=48; k=1 } 33 while m > 0 { t[k] = 48 + (m % 10); m = m / 10; k = k + 1 } 34 var i: i64 = 0; while i < k { buf[oi] = t[k-1-i]; oi = oi + 1; i = i + 1 } 35 let post: *u8 = ";}\n" as *u8 36 j = 0; while post[j] != (0 as u8) { buf[oi] = post[j]; oi = oi + 1; j = j + 1 } 37 tk_bwrite(path, buf, oi); return 0 38} 39// evaluate a boolean circuit on the magic columns -> truth-table byte 40func tk_booleval(op: *i64, a: *i64, b: *i64, L: i64) -> i64 { 41 let sv: *i64 = sys_mmap(8 * (L + 6)) as *i64 42 sv[0] = BL_A; sv[1] = BL_B; sv[2] = BL_C 43 var t: i64 = 0 44 while t < L { sv[t+3] = bl_eval(op[t], sv[a[t]], sv[b[t]]); t = t + 1 } 45 return sv[L+2] & 255 46} 47 48// run ONE tick; out: 0=mc_verified 1=mc_cost 2=gcc_cost 3=gate_verified 4=gate_gates 5=verdict 49func tk_run(out: *i64) -> i64 { 50 // GATE LEVEL: synthesize + exactly verify a boolean circuit (majority) 51 let bop: *i64 = sys_mmap(8*12) as *i64; let ba: *i64 = sys_mmap(8*12) as *i64; let bb2: *i64 = sys_mmap(8*12) as *i64 52 let gL: i64 = bl_find(232, bop, ba, bb2, 6) 53 out[4] = gL 54 out[3] = 0; if gL > 0 { if tk_booleval(bop, ba, bb2, gL) == 232 { out[3] = 1 } } 55 // MACHINE LEVEL: synthesize + emit + verify by execution a multiply 56 let c: i64 = 45 57 let op: *i64 = sys_mmap(8*12) as *i64; let a: *i64 = sys_mmap(8*12) as *i64; let b: *i64 = sys_mmap(8*12) as *i64 58 let dd: *i64 = sys_mmap(8*16) as *i64; let buf: *u8 = sys_mmap(K_MAGIC_8192); let icnt: *i64 = sys_mmap(8) as *i64 59 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 60 var ref: i64 = 0; var kk: i64 = 0; while kk < 8 { ref = ref + dd[kk]*c; kk = kk+1 }; ref = ref & 255 61 let L: i64 = mulchain_find(c, 8, op, a, b) 62 let blen: i64 = se_emit_full(op, a, b, L, dd, 8, buf, icnt) 63 tk_bwrite("/tmp/tk.s" as *u8, buf, blen) 64 out[0] = 0 65 if eng_link("/tmp/tk.s" as *u8, "/tmp/tk.elf" as *u8) == 0 { if eng_run("/tmp/tk.elf" as *u8, 0 as *u8) == ref { out[0] = 1 } } 66 out[1] = gr_cost_obj("/tmp/tk.elf" as *u8, "/tmp/tk_t.txt" as *u8, "synth" as *u8) 67 tk_genc(c, "/tmp/tk.c" as *u8) 68 let gcc: *u8 = gr_newest_gcc() 69 gr_race_cv(gcc, "/tmp/tk.c" as *u8, "/tmp/tk.o" as *u8, "/tmp/tk_g.txt" as *u8, "f" as *u8) 70 out[2] = gr_cost_obj("/tmp/tk.o" as *u8, "/tmp/tk_gc.txt" as *u8, "f" as *u8) 71 out[5] = 0 72 if out[2] > 0 { if out[1] < out[2] { out[5] = 1 } if out[1] > out[2] { out[5] = 0 - 1 } } 73 return 0 74} 75 76func tk_main(r: *i64) -> i64 { 77 tk_puts("=== TEAM AUTONOMY TICK (trigger me, or loop me) -- one beat of the whole self-improvement loop ===\n" as *u8) 78 let out: *i64 = sys_mmap(8 * 8) as *i64 79 tk_run(out) 80 tk_puts(" GATE level : synthesized majority = " as *u8); tk_num(out[4]); tk_puts(" gates, exact-verified " as *u8); if out[3]==1 {tk_puts("OK\n" as *u8)} else {tk_puts("FAIL\n" as *u8)} 81 tk_puts(" MACHINE level: synthesized+emitted x*45, exec-verified " as *u8); if out[0]==1 {tk_puts("OK" as *u8)} else {tk_puts("FAIL" as *u8)} 82 tk_puts(" cost " as *u8); tk_num(out[1]); tk_puts(" vs gcc " as *u8); tk_num(out[2]); tk_puts(" -> " as *u8) 83 if out[5]==1 {tk_puts("EXCEED\n" as *u8)} else { if out[5]==0 {tk_puts("parity\n" as *u8)} else {tk_puts("behind\n" as *u8)} } 84 tk_puts("----------------------------------------------------------------\n" as *u8) 85 tk_puts(" TICK COMPLETE -- bits-up (gate + machine) synthesized + verified this beat, sovereign. trigger again to loop.\n" as *u8) 86 r[0] = 0; if out[3] == 1 { if out[0] == 1 { r[0] = 1 } } 87 return 1 88} 89 90func main() -> i64 { 91 let r: *i64 = sys_mmap(8 * 4) as *i64 92 tk_main(r) 93 var ec: i64 = 0; if r[0] != 1 { ec = 1 } 94 sys_exit(ec) 95 return ec 96}