nx_optimize_suite_test.nx source

1// nx_optimize_suite_test.nx -- the Nishi TEAM optimizing a SUITE autonomously 2// (the mechanism for grinding benchmarks). For each kernel the loop: SEARCHES for 3// a cheaper equivalent (e-graph superopt), MEASURES the cost gain, VERIFIES the 4// candidate still evaluates equal (1:1), and the crew GOVERNS the swap -- absorbing 5// real wins, correctly leaving already-optimal kernels alone. No hand-optimizing: 6// the loop builds + optimizes. This is point-and-deliver in miniature. 7// 8// Suite: mul x K for K in {3,4,8,16,32}. K=2^k strength-reduces (mul->shl, cost 9// 3->1, ABSORBED); K=3 has no cheaper equivalent (cost stays 3, DEFERRED -- the 10// loop honestly banks no false win). Known answer: "absorbed=4 deferred=1 gain=8". 11 12import "nx_superopt.nx" // e-graph search + nx_superopt_eval_emit 13import "nx_crew_council.nx" // governance 14 15// optimize one kernel (mul x K): returns the cost gain (before-after); writes the 16// council verdict to vd_out[0]. Verifies the cheaper form still computes x*K. 17func opt_one(K: i64, nodes: *NxENode, classes: *NxEClass, g: *NxEGraph, 18 cand_out: *NxEmitNode, env: *i64, val: *i64, a: *CrewAction, why: *i64, vd_out: *i64) -> i64 { 19 if nx_eqsat_init(g, nodes, 256, classes, 256) != NX_EQSAT_OK { return 0 - 1 } 20 let x: i64 = nx_eqsat_add_var(g, 0) 21 let ck: i64 = nx_eqsat_add_const(g, K) 22 let cls: i64 = nx_eqsat_add_binary(g, NX_EQ_OP_MUL, x, ck) 23 let before: i64 = nx_eqsat_class_cost(g, cls) 24 nx_eqsat_saturate(g, 16) 25 if nx_eqsat_recompute_best(g) != NX_EQSAT_OK { return 0 - 1 } 26 let after: i64 = nx_eqsat_best_cost(g, cls) 27 let cnt: *i64 = sys_mmap(8) as *i64 28 cnt[0] = 0 29 let root: i64 = nx_eqsat_emit(g, cls, cand_out, 64, cnt) 30 if root < 0 { return 0 - 1 } 31 32 // VERIFY equivalent: the emitted candidate evaluates == x*K over a battery. 33 var equiv: i64 = 1 34 var xv: i64 = 0 - 64 35 while xv <= 64 { 36 env[0] = xv 37 if nx_superopt_eval_emit(cand_out, cnt[0], root, env, val) != (xv * K) { equiv = 0 } 38 xv = xv + 1 39 } 40 var cheaper: i64 = 0 41 if after < before { cheaper = 1 } 42 43 cc_set(a, "superopt kernel" as *u8, equiv, 1, cheaper, 1, 1) // verifies=equiv, worth=cheaper 44 let vd: i64 = cc_council(a, why) 45 vd_out[0] = vd 46 if vd == CC_ACT { return before - after } 47 return 0 48} 49 50func main() -> i64 { 51 let nodes: *NxENode = sys_mmap(256 * 128) as *NxENode 52 let classes: *NxEClass = sys_mmap(256 * 64) as *NxEClass 53 let g: *NxEGraph = sys_mmap(256) as *NxEGraph 54 let cand_out: *NxEmitNode = sys_mmap(64 * 40) as *NxEmitNode 55 let env: *i64 = sys_mmap(8 * 8) as *i64 56 let val: *i64 = sys_mmap(64 * 8) as *i64 57 let a: *CrewAction = sys_mmap(64) as *CrewAction 58 let why: *i64 = sys_mmap(8) as *i64 59 let vd: *i64 = sys_mmap(8) as *i64 60 61 cc_puts("================================================================\n" as *u8) 62 cc_puts(" NISHI TEAM optimizing a suite -- search -> measure -> verify ->\n" as *u8) 63 cc_puts(" govern -> bank. (the benchmark-grinding loop, autonomous)\n" as *u8) 64 cc_puts("================================================================\n" as *u8) 65 66 let ks: *i64 = sys_mmap(8 * 5) as *i64 67 ks[0] = 3; ks[1] = 4; ks[2] = 8; ks[3] = 16; ks[4] = 32 68 var absorbed: i64 = 0 69 var deferred: i64 = 0 70 var gain: i64 = 0 71 72 var i: i64 = 0 73 while i < 5 { 74 let g1: i64 = opt_one(ks[i], nodes, classes, g, cand_out, env, val, a, why, vd) 75 if g1 < 0 { sys_exit(40); return 40 } 76 cc_puts(" mul x " as *u8) 77 let kb: *u8 = sys_mmap(4); var kk: i64 = ks[i]; var kn: i64 = 0 78 if kk == 0 { kb[0] = 48; kn = 1 } 79 let kt: *u8 = sys_mmap(4); var ktn: i64 = 0 80 while kk > 0 { kt[ktn] = 48 + (kk % 10); kk = kk / 10; ktn = ktn + 1 } 81 var z: i64 = 0; while z < ktn { kb[z] = kt[ktn - 1 - z]; z = z + 1 } 82 if ktn == 0 { ktn = kn } 83 sys_write(1, kb, ktn) 84 if vd[0] == CC_ACT { cc_puts(" -> OPTIMIZED (cost -" as *u8); let gb: *u8 = sys_mmap(2); gb[0] = 48 + g1; sys_write(1, gb, 1); cc_puts(", absorbed)\n" as *u8); absorbed = absorbed + 1; gain = gain + g1 } 85 if vd[0] != CC_ACT { cc_puts(" -> already optimal (no cheaper equivalent, deferred)\n" as *u8); deferred = deferred + 1 } 86 i = i + 1 87 } 88 89 cc_puts("----------------------------------------------------------------\n" as *u8) 90 cc_puts(" suite: absorbed=" as *u8); let ab: *u8 = sys_mmap(2); ab[0] = 48 + absorbed; sys_write(1, ab, 1) 91 cc_puts(" deferred=" as *u8); let df: *u8 = sys_mmap(2); df[0] = 48 + deferred; sys_write(1, df, 1) 92 cc_puts(" gain=" as *u8); let gn: *u8 = sys_mmap(2); gn[0] = 48 + gain; sys_write(1, gn, 1) 93 cc_puts("\n the loop optimized the suite itself -- searched, proved equivalent,\n" as *u8) 94 cc_puts(" governed, banked the wins; left the optimal kernel alone. no human.\n" as *u8) 95 cc_puts("----------------------------------------------------------------\n" as *u8) 96 97 if absorbed != 4 { sys_exit(1); return 1 } 98 if deferred != 1 { sys_exit(2); return 2 } 99 if gain != 8 { sys_exit(3); return 3 } 100 sys_exit(0); return 0 101}