nx_evo_enc_r.nx source

1// nx_evo_enc_r.nx -- EVOLUTIONARY SYNTHESIS of the RV64 R-type encoder (eve "inside", 2// full encoder family). Target = asm_enc.enc_r (nxasm/asm_enc.nx:18-22): 3// (funct7<<25)|(rs2<<20)|(rs1<<15)|(funct3<<12)|(rd<<7)|opcode -- 6 fields. 4// The SEARCH derives the 6-field packing (which input -> which bit position) from 5// generated full-range examples + held-out, zero Claude composing it. Inputs passed as an 6// ARRAY (6 fields > 6 args). Genome = 6 terms (src,shift,mask); eval = OR of (in[src] & 7// mask) << shift. Masks restricted to field widths (<=7-bit) to keep the 6-field search 8// tractable. I author the MACHINE (substrate); the search derives the encoder. Champion 9// emitted as evo_enc_r(opcode,funct3,funct7,rd,rs1,rs2). license_tier: ORIGINAL 10import "nx_syscalls.nx" 11const EVO_MAGIC_2862933555777941757: i64 = 2862933555777941757 12const EVO_MAGIC_3037000493: i64 = 3037000493 13const EVO_MAGIC_999983: i64 = 999983 14const EVO_MAGIC_2654435761: i64 = 2654435761 15const EVO_MAGIC_12345: i64 = 12345 16const EVO_MAGIC_1000000000: i64 = 1000000000 17const EVO_MAGIC_8192: i64 = 8192 18 19const NIN: i64 = 6 20const NTERMS: i64 = 6 21const EVO_P: i64 = 512 22const EVO_G: i64 = 8000 23const EVO_T: i64 = 6 24const NTRAIN: i64 = 8 25const NHELD: i64 = 4 26 27func enr_rand(state: *i64) -> i64 { state[0] = state[0] * EVO_MAGIC_2862933555777941757 + EVO_MAGIC_3037000493; return (state[0] >> 17) & 0x3fffffff } 28func enr_shl(v: i64, sh: i64) -> i64 { 29 if sh == 0 { return v } 30 if sh == 1 { return v << 7 } 31 if sh == 2 { return v << 12 } 32 if sh == 3 { return v << 15 } 33 if sh == 4 { return v << 20 } 34 return v << 25 35} 36func enr_shval(sh: i64) -> i64 { if sh == 0 { return 0 } if sh == 1 { return 7 } if sh == 2 { return 12 } if sh == 3 { return 15 } if sh == 4 { return 20 } return 25 } 37func enr_and(v: i64, mk: i64) -> i64 { if mk == 0 { return v } if mk == 1 { return v & 0x1F } return v & 0x7F } 38func enr_mkval(mk: i64) -> i64 { if mk == 0 { return 0xFFFFFFFF } if mk == 1 { return 0x1F } return 0x7F } 39func enr_width(k: i64) -> i64 { if k == 0 { return 0x7F } if k == 1 { return 0x7 } if k == 2 { return 0x7F } if k == 3 { return 0x1F } if k == 4 { return 0x1F } return 0x1F } 40 41// the ORACLE = Claude's enc_r over the input array (in = [opcode,funct3,funct7,rd,rs1,rs2]). 42func enr_oracle(inarr: *i64, base: i64) -> i64 { 43 return (inarr[base+2] << 25) | (inarr[base+5] << 20) | (inarr[base+4] << 15) 44 | (inarr[base+1] << 12) | (inarr[base+3] << 7) | inarr[base+0] 45} 46 47func enr_eval(pop: *i64, pbase: i64, inarr: *i64, ibase: i64) -> i64 { 48 var acc: i64 = 0 49 var j: i64 = 0 50 while j < NTERMS { 51 let src: i64 = pop[pbase + j*3] 52 let sh: i64 = pop[pbase + j*3 + 1] 53 let mk: i64 = pop[pbase + j*3 + 2] 54 acc = acc | enr_shl(enr_and(inarr[ibase + src], mk), sh) 55 j = j + 1 56 } 57 return acc 58} 59 60func enr_hamming(a: i64, b: i64) -> i64 { 61 var c: i64 = 0; var i: i64 = 0; var x: i64 = a; var y: i64 = b 62 while i < 32 { if (x & 1) != (y & 1) { c = c + 1 } x = x >> 1; y = y >> 1; i = i + 1 } 63 return c 64} 65 66func enr_fit(pop: *i64, pbase: i64, ex_in: *i64, ex_out: *i64) -> i64 { 67 var err: i64 = 0; var e: i64 = 0 68 while e < NTRAIN { err = err + enr_hamming(enr_eval(pop, pbase, ex_in, e*NIN), ex_out[e]); e = e + 1 } 69 return err 70} 71 72func enr_randfill(pop: *i64, base: i64, state: *i64) -> i64 { 73 var j: i64 = 0 74 while j < NTERMS { 75 pop[base + j*3] = enr_rand(state) % 6 76 pop[base + j*3 + 1] = enr_rand(state) % 6 77 pop[base + j*3 + 2] = enr_rand(state) % 3 78 j = j + 1 79 } 80 return 0 81} 82 83func enr_tourney(fit: *i64, state: *i64) -> i64 { 84 var bi: i64 = enr_rand(state) % EVO_P; var bd: i64 = fit[bi]; var k: i64 = 1 85 while k < EVO_T { let i: i64 = enr_rand(state) % EVO_P; if fit[i] < bd { bd = fit[i]; bi = i } k = k + 1 } 86 return bi 87} 88 89func enr_cat(dst: *u8, off: i64, s: *u8) -> i64 { var i: i64 = 0; while s[i] != (0 as u8) { dst[off+i] = s[i]; i = i + 1 } return off + i } 90func enr_catn(dst: *u8, off: i64, v: i64) -> i64 { 91 var o: i64 = off 92 if v == 0 { dst[o] = 48 as u8; return o + 1 } 93 var m: i64 = v; let t: *u8 = sys_mmap(28); var k: i64 = 0 94 while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 } 95 var i: i64 = 0 96 while i < k { dst[o+i] = t[k-1-i]; i = i + 1 } 97 return o + k 98} 99func enr_p(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 } 100func enr_pn(v: i64) -> i64 { let b: *u8 = sys_mmap(32); let n: i64 = enr_catn(b, 0, v); sys_write(1, b, n); return 0 } 101func enr_srcname(dst: *u8, off: i64, src: i64) -> i64 { 102 if src == 0 { return enr_cat(dst, off, "opcode" as *u8) } 103 if src == 1 { return enr_cat(dst, off, "funct3" as *u8) } 104 if src == 2 { return enr_cat(dst, off, "funct7" as *u8) } 105 if src == 3 { return enr_cat(dst, off, "rd" as *u8) } 106 if src == 4 { return enr_cat(dst, off, "rs1" as *u8) } 107 return enr_cat(dst, off, "rs2" as *u8) 108} 109 110func main(argc: i64, argv: *i64) -> i64 { 111 var seed: i64 = 7 112 if argc >= 2 { 113 var s: i64 = 0; var i: i64 = 0; let a: *u8 = argv[1] as *u8 114 while a[i] != (0 as u8) { if a[i] >= (48 as u8) { if a[i] <= (57 as u8) { s = s*10 + ((a[i] as i64) - 48) } } i = i + 1 } 115 seed = s 116 } 117 // generate full-range examples deterministically (fixed example seed, distinct from search). 118 let NEX: i64 = NTRAIN + NHELD 119 let ex_in: *i64 = sys_mmap(NEX * NIN * 8) as *i64 120 let ex_out: *i64 = sys_mmap(NEX * 8) as *i64 121 let estate: *i64 = sys_mmap(8) as *i64; estate[0] = EVO_MAGIC_999983 122 var e: i64 = 0 123 while e < NEX { 124 var k: i64 = 0 125 while k < NIN { ex_in[e*NIN + k] = enr_rand(estate) & enr_width(k); k = k + 1 } 126 ex_out[e] = enr_oracle(ex_in, e*NIN) 127 e = e + 1 128 } 129 130 let state: *i64 = sys_mmap(8) as *i64; state[0] = seed * EVO_MAGIC_2654435761 + EVO_MAGIC_12345 131 let glen: i64 = NTERMS * 3 132 let pop: *i64 = sys_mmap(EVO_P * glen * 8) as *i64 133 let nxt: *i64 = sys_mmap(EVO_P * glen * 8) as *i64 134 let fit: *i64 = sys_mmap(EVO_P * 8) as *i64 135 let best: *i64 = sys_mmap(glen * 8) as *i64 136 137 var p: i64 = 0 138 while p < EVO_P { enr_randfill(pop, p * glen, state); p = p + 1 } 139 140 var best_err: i64 = EVO_MAGIC_1000000000; var best_gen: i64 = 0 - 1; var found: i64 = 0 141 var g: i64 = 0 142 while g < EVO_G { 143 var gbest: i64 = EVO_MAGIC_1000000000; var gbp: i64 = 0 144 p = 0 145 while p < EVO_P { let er: i64 = enr_fit(pop, p * glen, ex_in, ex_out); fit[p] = er; if er < gbest { gbest = er; gbp = p } p = p + 1 } 146 if gbest < best_err { best_err = gbest; var j: i64 = 0; while j < glen { best[j] = pop[gbp * glen + j]; j = j + 1 } best_gen = g } 147 if best_err == 0 { found = 1; g = EVO_G } else { 148 var j2: i64 = 0 149 while j2 < glen { nxt[j2] = best[j2]; j2 = j2 + 1 } 150 p = 1 151 while p < EVO_P { 152 let pa: i64 = enr_tourney(fit, state) * glen 153 let pb: i64 = enr_tourney(fit, state) * glen 154 let cut: i64 = (enr_rand(state) % (glen - 1)) + 1 155 var jj: i64 = 0 156 while jj < glen { if jj < cut { nxt[p*glen + jj] = pop[pa + jj] } else { nxt[p*glen + jj] = pop[pb + jj] } jj = jj + 1 } 157 let slot: i64 = enr_rand(state) % glen 158 let field: i64 = slot % 3 159 if field == 0 { nxt[p*glen + slot] = enr_rand(state) % 6 } 160 if field == 1 { nxt[p*glen + slot] = enr_rand(state) % 6 } 161 if field == 2 { nxt[p*glen + slot] = enr_rand(state) % 3 } 162 p = p + 1 163 } 164 var c: i64 = 0 165 while c < EVO_P * glen { pop[c] = nxt[c]; c = c + 1 } 166 g = g + 1 167 } 168 } 169 170 var held_ok: i64 = 0; var hi: i64 = 0 171 while hi < NHELD { let idx: i64 = NTRAIN + hi; if enr_eval(best, 0, ex_in, idx*NIN) == ex_out[idx] { held_ok = held_ok + 1 } hi = hi + 1 } 172 173 enr_p("ENCR train_err=" as *u8); enr_pn(best_err); enr_p(" gen=" as *u8); enr_pn(best_gen) 174 enr_p(" heldout=" as *u8); enr_pn(held_ok); enr_p("/" as *u8); enr_pn(NHELD) 175 if found == 1 { if held_ok == NHELD { enr_p(" GENERALIZES" as *u8) } else { enr_p(" OVERFIT" as *u8) } } else { enr_p(" NEAR" as *u8) } 176 enr_p(" terms=" as *u8) 177 var jg: i64 = 0 178 while jg < NTERMS { enr_p("(src" as *u8); enr_pn(best[jg*3]); enr_p(",<<" as *u8); enr_pn(enr_shval(best[jg*3+1])); enr_p(",&" as *u8); enr_pn(enr_mkval(best[jg*3+2])); enr_p(") " as *u8); jg = jg + 1 } 179 enr_p("\n" as *u8) 180 181 // ---- materialize the derived encoder ---- 182 let path: *u8 = sys_mmap(512); var po: i64 = 0 183 po = enr_cat(path, po, "runtime/_hdl_build/_evo_enc_r_champ.nx" as *u8); path[po] = 0 as u8 184 let buf: *u8 = sys_mmap(EVO_MAGIC_8192); var o: i64 = 0 185 o = enr_cat(buf, o, "// DISCOVERED BY nx_evo_enc_r (evolved RV64 R-type encoder; structure search-derived). license_tier: ORIGINAL\n" as *u8) 186 o = enr_cat(buf, o, "func evo_enc_r(opcode: i64, funct3: i64, funct7: i64, rd: i64, rs1: i64, rs2: i64) -> i64 {\n return " as *u8) 187 jg = 0 188 while jg < NTERMS { 189 if jg > 0 { o = enr_cat(buf, o, " | " as *u8) } 190 o = enr_cat(buf, o, "((" as *u8) 191 o = enr_srcname(buf, o, best[jg*3]) 192 o = enr_cat(buf, o, " & " as *u8); o = enr_catn(buf, o, enr_mkval(best[jg*3+2])) 193 o = enr_cat(buf, o, ") << " as *u8); o = enr_catn(buf, o, enr_shval(best[jg*3+1])) 194 o = enr_cat(buf, o, ")" as *u8) 195 jg = jg + 1 196 } 197 o = enr_cat(buf, o, "\n}\n" as *u8) 198 let fd: i64 = sys_openat_wr(path, 420) 199 if fd < 0 { enr_p("ENCR verdict=RED reason=champion-unwritable\n" as *u8); return 1 } 200 sys_write(fd, buf, o); sys_close(fd) 201 enr_p("ENCR champion written: runtime/_hdl_build/_evo_enc_r_champ.nx\n" as *u8) 202 return 0 203}