code wiki / _hdl_build / nx_evo_enc.nx
nx_evo_enc.nx source
↩ module page · 202 lines · 10127 B
1// nx_evo_enc.nx -- EVOLUTIONARY SYNTHESIS of a COMPILER-INTERNAL bit-packing encoder
2// ("the inside, like a compiler"). Target = the assembler's enc_u (RV64 U-type word,
3// nxasm/asm_enc.nx:39): ((imm20 & 0xFFFFF) << 12) | (rd << 7) | opcode. The SEARCH derives
4// the field-packing STRUCTURE -- which input field lands at which bit position under which
5// mask -- from (opcode,rd,imm20)->encoded-word examples + HELD-OUT, ZERO Claude composing
6// it. Genome = NTERMS terms, each (src, shift, mask); eval = OR of (in[src] & mask) << shift.
7// I author the MACHINE (Bar-C substrate); the SEARCH derives the encoder = the toolchain's
8// INSIDE, not a leaf organ. Champion emitted as a real evo_enc_u(opcode,rd,imm20), then
9// differentially-replaced vs the Claude asm_enc.enc_u. NishiLang has constant bit-operands,
10// so shift/mask are selected via constant-op helpers. license_tier: ORIGINAL
11import "nx_syscalls.nx"
12const EVO_MAGIC_2862933555777941757: i64 = 2862933555777941757
13const EVO_MAGIC_3037000493: i64 = 3037000493
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 NTERMS: i64 = 3
20const EVO_P: i64 = 256
21const EVO_G: i64 = 3000
22const EVO_T: i64 = 5
23const NTRAIN: i64 = 6
24const NHELD: i64 = 4
25
26func en_rand(state: *i64) -> i64 { state[0] = state[0] * EVO_MAGIC_2862933555777941757 + EVO_MAGIC_3037000493; return (state[0] >> 17) & 0x3fffffff }
27
28// constant-operand shift/mask selectors (the search picks an index; the OP is constant).
29func en_shl(v: i64, sh: i64) -> i64 {
30 if sh == 0 { return v }
31 if sh == 1 { return v << 7 }
32 if sh == 2 { return v << 12 }
33 if sh == 3 { return v << 15 }
34 if sh == 4 { return v << 20 }
35 return v << 25
36}
37func en_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 }
38func en_and(v: i64, mk: i64) -> i64 {
39 if mk == 0 { return v }
40 if mk == 1 { return v & 0x1F }
41 if mk == 2 { return v & 0x7F }
42 if mk == 3 { return v & 0xFFF }
43 return v & 0xFFFFF
44}
45func en_mkval(mk: i64) -> i64 { if mk == 0 { return 0xFFFFFFFF } if mk == 1 { return 0x1F } if mk == 2 { return 0x7F } if mk == 3 { return 0xFFF } return 0xFFFFF }
46
47// training (i<6) + held-out (i>=6) RV field triples (in-range) + the ORACLE = Claude's enc_u.
48func en_op(i: i64) -> i64 { if i == 0 { return 0x37 } if i == 1 { return 0x17 } if i == 2 { return 0x37 } if i == 3 { return 0x17 } if i == 4 { return 0x37 } if i == 5 { return 0x17 } if i == 6 { return 0x37 } if i == 7 { return 0x17 } if i == 8 { return 0x37 } return 0x17 }
49func en_rd(i: i64) -> i64 { if i == 0 { return 1 } if i == 1 { return 5 } if i == 2 { return 10 } if i == 3 { return 31 } if i == 4 { return 2 } if i == 5 { return 17 } if i == 6 { return 28 } if i == 7 { return 7 } if i == 8 { return 13 } return 20 }
50func en_imm(i: i64) -> i64 { if i == 0 { return 0x12345 } if i == 1 { return 0xABCDE } if i == 2 { return 0x00001 } if i == 3 { return 0xFFFFF } if i == 4 { return 0x80000 } if i == 5 { return 0x0F0F0 } if i == 6 { return 0x54321 } if i == 7 { return 0x13579 } if i == 8 { return 0x2468A } return 0xBEEF0 }
51func en_oracle(o: i64, r: i64, m: i64) -> i64 { return ((m & 0xFFFFF) << 12) | (r << 7) | o }
52
53func en_eval(pop: *i64, base: i64, in0: i64, in1: i64, in2: i64) -> i64 {
54 var acc: i64 = 0
55 var j: i64 = 0
56 while j < NTERMS {
57 let src: i64 = pop[base + j*3]
58 let sh: i64 = pop[base + j*3 + 1]
59 let mk: i64 = pop[base + j*3 + 2]
60 var v: i64 = 0
61 if src == 0 { v = in0 }
62 if src == 1 { v = in1 }
63 if src == 2 { v = in2 }
64 acc = acc | en_shl(en_and(v, mk), sh)
65 j = j + 1
66 }
67 return acc
68}
69
70func en_hamming(a: i64, b: i64) -> i64 {
71 var c: i64 = 0; var i: i64 = 0
72 var x: i64 = a; var y: i64 = b
73 while i < 32 { if (x & 1) != (y & 1) { c = c + 1 } x = x >> 1; y = y >> 1; i = i + 1 }
74 return c
75}
76
77func en_fit(pop: *i64, base: i64) -> i64 {
78 var err: i64 = 0; var i: i64 = 0
79 while i < NTRAIN {
80 let o: i64 = en_op(i); let r: i64 = en_rd(i); let m: i64 = en_imm(i)
81 err = err + en_hamming(en_eval(pop, base, o, r, m), en_oracle(o, r, m))
82 i = i + 1
83 }
84 return err
85}
86
87func en_randfill(pop: *i64, base: i64, state: *i64) -> i64 {
88 var j: i64 = 0
89 while j < NTERMS {
90 pop[base + j*3] = en_rand(state) % 3
91 pop[base + j*3 + 1] = en_rand(state) % 6
92 pop[base + j*3 + 2] = en_rand(state) % 5
93 j = j + 1
94 }
95 return 0
96}
97
98func en_tourney(fit: *i64, state: *i64) -> i64 {
99 var bi: i64 = en_rand(state) % EVO_P; var bd: i64 = fit[bi]; var k: i64 = 1
100 while k < EVO_T { let i: i64 = en_rand(state) % EVO_P; if fit[i] < bd { bd = fit[i]; bi = i } k = k + 1 }
101 return bi
102}
103
104func en_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 }
105func en_catn(dst: *u8, off: i64, v: i64) -> i64 {
106 var o: i64 = off
107 if v == 0 { dst[o] = 48 as u8; return o + 1 }
108 var m: i64 = v; let t: *u8 = sys_mmap(28); var k: i64 = 0
109 while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
110 var i: i64 = 0
111 while i < k { dst[o+i] = t[k-1-i]; i = i + 1 }
112 return o + k
113}
114func en_p(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
115func en_pn(v: i64) -> i64 { let b: *u8 = sys_mmap(32); let n: i64 = en_catn(b, 0, v); sys_write(1, b, n); return 0 }
116func en_srcname(dst: *u8, off: i64, src: i64) -> i64 {
117 if src == 0 { return en_cat(dst, off, "opcode" as *u8) }
118 if src == 1 { return en_cat(dst, off, "rd" as *u8) }
119 return en_cat(dst, off, "imm20" as *u8)
120}
121
122func main(argc: i64, argv: *i64) -> i64 {
123 var seed: i64 = 7
124 if argc >= 2 {
125 var s: i64 = 0; var i: i64 = 0; let a: *u8 = argv[1] as *u8
126 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 }
127 seed = s
128 }
129 let state: *i64 = sys_mmap(8) as *i64; state[0] = seed * EVO_MAGIC_2654435761 + EVO_MAGIC_12345
130 let glen: i64 = NTERMS * 3
131 let pop: *i64 = sys_mmap(EVO_P * glen * 8) as *i64
132 let nxt: *i64 = sys_mmap(EVO_P * glen * 8) as *i64
133 let fit: *i64 = sys_mmap(EVO_P * 8) as *i64
134 let best: *i64 = sys_mmap(glen * 8) as *i64
135
136 var p: i64 = 0
137 while p < EVO_P { en_randfill(pop, p * glen, state); p = p + 1 }
138
139 var best_err: i64 = EVO_MAGIC_1000000000; var best_gen: i64 = 0 - 1; var found: i64 = 0
140 var g: i64 = 0
141 while g < EVO_G {
142 var gbest: i64 = EVO_MAGIC_1000000000; var gbp: i64 = 0
143 p = 0
144 while p < EVO_P { let e: i64 = en_fit(pop, p * glen); fit[p] = e; if e < gbest { gbest = e; gbp = p } p = p + 1 }
145 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 }
146 if best_err == 0 { found = 1; g = EVO_G } else {
147 var j2: i64 = 0
148 while j2 < glen { nxt[j2] = best[j2]; j2 = j2 + 1 }
149 p = 1
150 while p < EVO_P {
151 let pa: i64 = en_tourney(fit, state) * glen
152 let pb: i64 = en_tourney(fit, state) * glen
153 let cut: i64 = (en_rand(state) % (glen - 1)) + 1
154 var jj: i64 = 0
155 while jj < glen { if jj < cut { nxt[p*glen + jj] = pop[pa + jj] } else { nxt[p*glen + jj] = pop[pb + jj] } jj = jj + 1 }
156 let slot: i64 = en_rand(state) % glen
157 let field: i64 = slot % 3
158 if field == 0 { nxt[p*glen + slot] = en_rand(state) % 3 }
159 if field == 1 { nxt[p*glen + slot] = en_rand(state) % 6 }
160 if field == 2 { nxt[p*glen + slot] = en_rand(state) % 5 }
161 p = p + 1
162 }
163 var c: i64 = 0
164 while c < EVO_P * glen { pop[c] = nxt[c]; c = c + 1 }
165 g = g + 1
166 }
167 }
168
169 var held_ok: i64 = 0; var hi: i64 = 0
170 while hi < NHELD { let idx: i64 = NTRAIN + hi; if en_eval(best, 0, en_op(idx), en_rd(idx), en_imm(idx)) == en_oracle(en_op(idx), en_rd(idx), en_imm(idx)) { held_ok = held_ok + 1 } hi = hi + 1 }
171
172 en_p("ENC train_err=" as *u8); en_pn(best_err); en_p(" gen=" as *u8); en_pn(best_gen)
173 en_p(" heldout=" as *u8); en_pn(held_ok); en_p("/" as *u8); en_pn(NHELD)
174 if found == 1 { if held_ok == NHELD { en_p(" GENERALIZES" as *u8) } else { en_p(" OVERFIT" as *u8) } } else { en_p(" NEAR" as *u8) }
175 en_p(" terms=" as *u8)
176 var jg: i64 = 0
177 while jg < NTERMS { en_p("(src" as *u8); en_pn(best[jg*3]); en_p(",<<" as *u8); en_pn(en_shval(best[jg*3+1])); en_p(",&" as *u8); en_pn(en_mkval(best[jg*3+2])); en_p(") " as *u8); jg = jg + 1 }
178 en_p("\n" as *u8)
179
180 // ---- materialize the derived encoder as a real evo_enc_u(opcode,rd,imm20) ----
181 let path: *u8 = sys_mmap(512); var po: i64 = 0
182 po = en_cat(path, po, "runtime/_hdl_build/_evo_enc_champ.nx" as *u8); path[po] = 0 as u8
183 let buf: *u8 = sys_mmap(EVO_MAGIC_8192); var o: i64 = 0
184 o = en_cat(buf, o, "// DISCOVERED BY nx_evo_enc (evolved RV64 U-type encoder from I/O examples; structure search-derived). license_tier: ORIGINAL\n" as *u8)
185 o = en_cat(buf, o, "func evo_enc_u(opcode: i64, rd: i64, imm20: i64) -> i64 {\n return " as *u8)
186 jg = 0
187 while jg < NTERMS {
188 if jg > 0 { o = en_cat(buf, o, " | " as *u8) }
189 o = en_cat(buf, o, "((" as *u8)
190 o = en_srcname(buf, o, best[jg*3])
191 o = en_cat(buf, o, " & " as *u8); o = en_catn(buf, o, en_mkval(best[jg*3+2]))
192 o = en_cat(buf, o, ") << " as *u8); o = en_catn(buf, o, en_shval(best[jg*3+1]))
193 o = en_cat(buf, o, ")" as *u8)
194 jg = jg + 1
195 }
196 o = en_cat(buf, o, "\n}\n" as *u8)
197 let fd: i64 = sys_openat_wr(path, 420)
198 if fd < 0 { en_p("ENC verdict=RED reason=champion-unwritable\n" as *u8); return 1 }
199 sys_write(fd, buf, o); sys_close(fd)
200 en_p("ENC champion written: runtime/_hdl_build/_evo_enc_champ.nx\n" as *u8)
201 return 0
202}