code wiki / _hdl_build / nx_evo_isa_sov.nx

nx_evo_isa_sov.nx

buildroot/runtime/_hdl_build/nx_evo_isa_sov.nx

9677 B172 linesdepth 5pulls 17 transitivereach 0 importersview sourcekind tooltopic evo
docsdependenciesstructsconstsfunctions

about

nx_evo_isa_sov.nx -- THE FULL LOOP, LIVE end-to-end. DERIVE a real RV64 program by live search (NO embedded sequence) for f(a,b)=a*b+a over the real ISA ops (ADD/SUB/MUL/AND/OR/SLT, semantics = rv64im_min_sim's ALU); verify it generalizes on a grid; then ENCODE the LIVE-derived best genome to machine code (rv_lui = the search-derived enc_u) + wrap (li a,b; sb result->UART; SiFive-finisher halt); LOAD into rv64im_min_sim (god); RUN; and VERIFY the captured UART byte == the search's OWN prediction es_eval(best,a,b) -- which simultaneously confirms the interpreter's semantics == the sim's ALU. Hardware->derive->hardware, live. license_tier: ORIGINAL

dependencies 10 imports · 0 importers

nx_syscalls.nx nx_itoa_lib.nx nishi_hdl_primitives.nx rv64im_min_decoder.nx rv64im_min_alu.nx rv64im_min_regfile.nx rv64im_min_csr.nx rv64im_min_clint.nx rv64im_min_uart.nx rv64im_min_sim.nx nx_evo_isa_sov.nx

imports: nx_syscalls.nxnx_itoa_lib.nxnishi_hdl_primitives.nxrv64im_min_decoder.nxrv64im_min_alu.nxrv64im_min_regfile.nxrv64im_min_csr.nxrv64im_min_clint.nxrv64im_min_uart.nxrv64im_min_sim.nx

imported by: nobody (leaf or entry point)

call flow from main pre-order; caps 40 nodes / depth 6 declared; ↻ = already shown

main sys_mmap es_setinstr es_rand es_fit es_pa es_pb es_eval es_op es_reg es_absv es_target es_tourney es_rand ↻ es_rand ↻ es_mut es_rand ↻ es_eval ↻ es_target ↻ es_p sys_write es_n nxi_out nxi_fd sys_mmap ↻ ccz_cat_num sys_write ↻ sys_munmap nx_rv64im_rf_init nx_rv64im_csr_init nx_clint_init nx_uart_init nx_rv64im_sim_init rv_w32 rv_addi rv_rtype rv_f7 rv_f3 rv_lui rv_store

structs

none

consts

19const EVO_MAGIC_2862933555777941757: i64 = 2862933555777941757
20const EVO_MAGIC_3037000493: i64 = 3037000493
21const EVO_MAGIC_4000000: i64 = 4000000
22const EVO_MAGIC_2654435761: i64 = 2654435761
23const EVO_MAGIC_12345: i64 = 12345
24const EVO_MAGIC_1000000000: i64 = 1000000000
26const NINSTR: i64 = 2
27const GLEN: i64 = 6
28const EVO_P: i64 = 256
29const EVO_G: i64 = 2000
30const EVO_T: i64 = 5
31const NTRAIN: i64 = 6
32const IR_MEM_BASE: i64 = 0x80000000
33const IR_MEM_SIZE: i64 = 4096
34const IR_TX_CAP: i64 = 256

functions

36func es_rand(s: *i64) -> i64 { s[0] = s[0] * EVO_MAGIC_2862933555777941757 + EVO_MAGIC_3037000493; return (s[0] >> 17) & 0x3fffffff }
called by 4: es_setinstres_tourneyes_mutmain
37func es_absv(x: i64) -> i64 { if x < 0 { return 0 - x } return x }
called by 1: es_fit
38func es_pa(i: i64) -> i64 { if i==0 {return 3} if i==1 {return 5} if i==2 {return 7} if i==3 {return 2} if i==4 {return 8} return 4 }
called by 1: es_fit
39func es_pb(i: i64) -> i64 { if i==0 {return 4} if i==1 {return 2} if i==2 {return 3} if i==3 {return 6} if i==4 {return 5} return 7 }
called by 1: es_fit
40func es_target(a: i64, b: i64) -> i64 { return a * b + a }
called by 2: es_fitmain
43func es_op(op: i64, x: i64, y: i64) -> i64
called by 1: es_eval
51func es_reg(idx: i64, a: i64, b: i64, r3: i64) -> i64 { if idx==0 {return 0} if idx==1 {return a} if idx==2 {return b} return r3 }
called by 1: es_eval
52func es_eval(gen: *i64, base: i64, a: i64, b: i64) -> i64
called by 2: es_fitmain calls 2: es_opes_reg
61func es_setinstr(gen: *i64, j: i64, state: *i64) -> i64 { gen[j*3] = es_rand(state) % 6; gen[j*3+1] = es_rand(state) % 4; gen[j*3+2] = es_rand(state) % 4; return 0 }
called by 1: main calls 1: es_rand
62func es_fit(pop: *i64, base: i64) -> i64
called by 1: main calls 5: es_paes_pbes_evales_absves_target
72func es_tourney(fit: *i64, state: *i64) -> i64 { var bi: i64 = es_rand(state) % EVO_P; var bd: i64 = fit[bi]; var k: i64 = 1; while k < EVO_T { let i: i64 = es_rand(state) % EVO_P; if fit[i] < bd { bd = fit[i]; bi = i } k = k + 1 } return bi }
called by 1: main calls 1: es_rand
73func es_mut(gen: *i64, base: i64, state: *i64) -> i64 { let j: i64 = es_rand(state) % NINSTR; let f: i64 = es_rand(state) % 3; if f == 0 { gen[base + j*3] = es_rand(state) % 6 } else { gen[base + j*3 + f] = es_rand(state) % 4 } return 0 }
called by 1: main calls 1: es_rand
75func rv_addi(rd: i64, rs1: i64, imm: i64) -> i64 { return ((imm & 0xFFF) << 20) | (rs1 << 15) | (rd << 7) | 0x13 }
called by 1: main
76func rv_lui(rd: i64, imm20: i64) -> i64 { return ((imm20 & 0xFFFFF) << 12) | (rd << 7) | 0x37 }
called by 1: main
77func rv_rtype(f7: i64, rs2: i64, rs1: i64, f3: i64, rd: i64) -> i64 { return (f7 << 25) | (rs2 << 20) | (rs1 << 15) | (f3 << 12) | (rd << 7) | 0x33 }
called by 1: main
78func rv_store(rs2: i64, rs1: i64, f3: i64) -> i64 { return (rs2 << 20) | (rs1 << 15) | (f3 << 12) | 0x23 }
called by 1: main
79func rv_f3(op: i64) -> i64 { if op==3 {return 7} if op==4 {return 6} if op==5 {return 2} return 0 }
called by 1: main
80func rv_f7(op: i64) -> i64 { if op==1 {return 0x20} if op==2 {return 1} return 0 }
called by 1: main
81func rv_w32(buf: *u8, off: i64, w: i64) -> i64 { buf[off] = (w & 0xff) as u8; buf[off+1] = ((w>>8)&0xff) as u8; buf[off+2] = ((w>>16)&0xff) as u8; buf[off+3] = ((w>>24)&0xff) as u8; return off + 4 }
called by 1: main
83func es_p(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
called by 1: main calls 1: sys_write
88func es_n(v: i64) -> i64 { nxi_out(v); return 0 }
called by 1: main calls 1: nxi_out
90func main() -> i64
calls 24: sys_mmapes_setinstres_fites_tourneyes_randes_mut+18