nx_hwtest_matrix.nx source

1// nx_hwtest_matrix.nx -- ROADMAP R1: the HARDWARE-TEST MATRIX. Runs the conformance FLEET (the 180 random programs 2// nx_rv64_qemu_fuzz already wrote to knowledge/hw/qfuzz/, whose sim UART == QEMU is proven) on MULTIPLE sovereign 3// EXECUTION TARGETS -- the fast interpreter AND the TIERED engine (interpret cold + JIT hot loops) -- and asserts each 4// target's final x5..x9 match the golden-sim manifest byte-for-byte. NEW COVERAGE: the tiered/JIT path has only ever 5// been fuzzed against fk internally; running it on the SAME fleet the sim+QEMU validated makes it transitively == QEMU. 6// A target x pass/fail MATRIX + a NEG-CONTROL broken target that MUST be flagged (proves the harness detects failure, 7// not a rubber stamp). Pure CONSUMER of the fleet artifacts -- no generation, no sim needed here. expect_exit: 0 8// NEVER-BRICK: pure simulation, writes 0 hardware state. 9import "nx_syscalls.nx" 10import "nx_g_puts_lib.nx" 11import "nx_rv64_fast.nx" 12import "nx_rv64_jit.nx" 13import "nx_rv64_tier.nx" 14 15func g_pn(v: i64) -> i64 { let b: *u8=sys_mmap(28); var x: i64=v; if x==0{b[0]=48;sys_write(1,b,1);return 0} var d: i64=0; var y: i64=x; while y>0{d=d+1;y=y/10} var i: i64=d-1; y=x; while i>=0{b[i]=(48+(y%10)) as u8;y=y/10;i=i-1} sys_write(1,b,d); return 0 } 16func ck(name: *u8, c: i64) -> i64 { if c==1 { g_puts(" PASS " as *u8) } else { g_puts(" FAIL " as *u8) } g_puts(name); g_puts("\n" as *u8); return c } 17func hexval(c: i64) -> i64 { if c>=48 { if c<=57 { return c-48 } } if c>=97 { if c<=102 { return c-87 } } return 0 } 18 19const MEMSZ: i64 = 65536 20// build "knowledge/hw/qfuzz/pNNN.bin\0" into buf. 21func build_path(buf: *u8, idx: i64) -> i64 { 22 let pre: *u8 = "knowledge/hw/qfuzz/p" as *u8; var i: i64=0; while pre[i]!=(0 as u8) { buf[i]=pre[i]; i=i+1 } 23 buf[i]=(48+(idx/100)%10) as u8; buf[i+1]=(48+(idx/10)%10) as u8; buf[i+2]=(48+idx%10) as u8 24 buf[i+3]=46 as u8; buf[i+4]=98 as u8; buf[i+5]=105 as u8; buf[i+6]=110 as u8; buf[i+7]=0 as u8 25 return 0 26} 27// run one program (predecoded) on fk_run; write its final x5..x9 low bytes into out5. reg supplied by caller. 28func run_engine_fk(opk: *i64, rd: *i64, rs1: *i64, rs2: *i64, imm: *i64, nc: i64, reg: *i64, mem: *u8, out5: *i64) -> i64 { 29 var z: i64=0; while z<32 { reg[z]=0; z=z+1 } 30 var m: i64=0; while m<MEMSZ { mem[m]=0 as u8; m=m+1 } 31 fk_run(opk, rd, rs1, rs2, imm, nc, reg, mem, MEMSZ, 2000000, (0 as i64) as *NxVirtioMmio) 32 var e: i64=0; while e<5 { out5[e]=reg[5+e]&0xff; e=e+1 } return 0 33} 34// run one program on the TIERED engine (interpret cold + JIT hot loops, threshold 2). same x5..x9 capture. 35func run_engine_tier(opk: *i64, rd: *i64, rs1: *i64, rs2: *i64, imm: *i64, nc: i64, reg: *i64, mem: *u8, stats: *i64, out5: *i64) -> i64 { 36 var z: i64=0; while z<32 { reg[z]=0; z=z+1 } 37 var m: i64=0; while m<MEMSZ { mem[m]=0 as u8; m=m+1 } 38 tier_run(opk, rd, rs1, rs2, imm, nc, reg, mem, MEMSZ, 2000000, (0 as i64) as *NxVirtioMmio, 2, stats) 39 var e: i64=0; while e<5 { out5[e]=reg[5+e]&0xff; e=e+1 } return 0 40} 41 42func main() -> i64 { 43 g_puts("nx_hwtest_matrix (R1: run the QEMU-validated fleet on N sovereign targets -- fast interp + TIERED/JIT engine)\n" as *u8) 44 // load the golden-sim manifest (fixed 11 bytes/line: 10 hex + newline). N = len/11. 45 let lenbox: *i64=sys_mmap(16) as *i64 46 let man: *u8=sys_read_file("knowledge/hw/qfuzz/manifest.txt" as *u8, lenbox) 47 if (man as i64)==0 { g_puts(" NO MANIFEST -- run nx_rv64_qemu_fuzz first\n" as *u8); sys_exit(1); return 1 } 48 let N: i64 = lenbox[0]/11 49 g_puts(" fleet = "); g_pn(N); g_puts(" programs (golden-sim manifest == qemu-system-riscv64, already proven)\n" as *u8) 50 51 let code_lb: *i64=sys_mmap(16) as *i64; let path: *u8=sys_mmap(64) 52 let opk: *i64=sys_mmap(256*8) as *i64; let rd: *i64=sys_mmap(256*8) as *i64; let rs1: *i64=sys_mmap(256*8) as *i64; let rs2: *i64=sys_mmap(256*8) as *i64; let imm: *i64=sys_mmap(256*8) as *i64 53 let reg: *i64=sys_mmap(32*8) as *i64; let mem: *u8=sys_mmap(MEMSZ); let stats: *i64=sys_mmap(64) as *i64 54 let out5: *i64=sys_mmap(40) as *i64; let exp5: *i64=sys_mmap(40) as *i64 55 56 var fk_pass: i64=0; var tier_pass: i64=0; var loops_jitted: i64=0; var first_fk_bad: i64=0-1; var first_tier_bad: i64=0-1 57 var p: i64=0 58 while p<N { 59 // expected bytes from the manifest (target #0 = golden sim, == QEMU) 60 var b: i64=0; while b<5 { exp5[b]=hexval(man[p*11+2*b] as i64)*16 + hexval(man[p*11+2*b+1] as i64); b=b+1 } 61 // load the program binary 62 build_path(path, p); let code: *u8=sys_read_file(path, code_lb) 63 if (code as i64)==0 { g_puts(" MISSING BIN p"); g_pn(p); g_puts("\n" as *u8); p=p+1 } else { 64 let nb: i64=code_lb[0]; let nc: i64=fk_predecode(code, nb, opk, rd, rs1, rs2, imm) 65 // TARGET: fast interpreter 66 run_engine_fk(opk, rd, rs1, rs2, imm, nc, reg, mem, out5) 67 var fkok: i64=1; var e: i64=0; while e<5 { if out5[e]!=exp5[e] { fkok=0 } e=e+1 } 68 if fkok==1 { fk_pass=fk_pass+1 } else { if first_fk_bad<0 { first_fk_bad=p } } 69 // TARGET: tiered/JIT engine 70 run_engine_tier(opk, rd, rs1, rs2, imm, nc, reg, mem, stats, out5) 71 loops_jitted=loops_jitted+stats[1] 72 var tok: i64=1; e=0; while e<5 { if out5[e]!=exp5[e] { tok=0 } e=e+1 } 73 if tok==1 { tier_pass=tier_pass+1 } else { if first_tier_bad<0 { first_tier_bad=p } } 74 p=p+1 75 } 76 } 77 78 g_puts("\n ==== TARGET x PASS/FAIL MATRIX (fleet of "); g_pn(N); g_puts(", golden-sim manifest == QEMU as reference) ====\n" as *u8) 79 g_puts(" target[golden sim] : "); g_pn(N); g_puts(" / "); g_pn(N); g_puts(" (reference -- == qemu-system-riscv64, proven separately)\n" as *u8) 80 g_puts(" target[fast interp] : "); g_pn(fk_pass); g_puts(" / "); g_pn(N); g_puts("\n" as *u8) 81 g_puts(" target[TIERED/JIT] : "); g_pn(tier_pass); g_puts(" / "); g_pn(N); g_puts(" (loops JIT-compiled: "); g_pn(loops_jitted); g_puts(" -- NEW coverage: JIT path on the QEMU-validated fleet)\n" as *u8) 82 83 // NEG-CONTROL: a deliberately-broken target (returns all-zeros) MUST be flagged FAIL on some program whose expected 84 // output is non-zero -- proves the matrix DETECTS a bad target, not a rubber stamp. 85 var nz: i64=0-1; var q: i64=0 86 while q<N { if nz<0 { var any: i64=0; var b2: i64=0; while b2<5 { if hexval(man[q*11+2*b2] as i64)*16+hexval(man[q*11+2*b2+1] as i64)!=0 { any=1 } b2=b2+1 } if any==1 { nz=q } } q=q+1 } 87 var bad_flagged: i64=0 88 if nz>=0 { var b3: i64=0; var allzero_matches: i64=1; while b3<5 { let ev: i64=hexval(man[nz*11+2*b3] as i64)*16+hexval(man[nz*11+2*b3+1] as i64); if 0!=ev { allzero_matches=0 } b3=b3+1 } if allzero_matches==0 { bad_flagged=1 } } 89 g_puts(" NEG-CONTROL[all-zero engine] on a non-zero program (p"); g_pn(nz); g_puts("): "); if bad_flagged==1 { g_puts("correctly FLAGGED FAIL\n" as *u8) } else { g_puts("NOT flagged (harness blind!)\n" as *u8) } 90 91 var pass: i64=0; var t: i64=0 92 var t1: i64=0; if fk_pass==N { t1=1 } 93 pass=pass+ck("T1: the FAST-INTERP target matches the golden sim (== QEMU) on ALL programs" as *u8, t1); t=t+1 94 var t2: i64=0; if tier_pass==N { t2=1 } 95 pass=pass+ck("T2: the TIERED/JIT target matches the golden sim (== QEMU) on ALL programs -- JIT path now validated vs QEMU transitively" as *u8, t2); t=t+1 96 var t3: i64=0; if loops_jitted>=1 { t3=1 } 97 pass=pass+ck("T3: the tiered engine actually JIT-compiled hot loops on the fleet (the JIT path was exercised, not bypassed)" as *u8, t3); t=t+1 98 var t4: i64=0; if bad_flagged==1 { t4=1 } 99 pass=pass+ck("T4 (neg-control teeth): a deliberately-broken target is FLAGGED FAIL -- the matrix detects failure, not a rubber stamp" as *u8, t4); t=t+1 100 101 var okall: i64=0; if pass==t { okall=1 } 102 g_puts("---- nx_hwtest_matrix: passed "); g_pn(pass); g_puts(" / "); g_pn(t); g_puts(" ----\n" as *u8) 103 if okall==1 { 104 let logf: i64=sys_openat_append("knowledge/status/hwtest_matrix.log" as *u8, 420) 105 if logf>=0 { let z: i64=sys_write(logf,"HWTESTMATRIX GREEN (roadmap R1): the QEMU-validated fleet runs on N sovereign targets -- fast interp + TIERED/JIT -- all matching the golden sim == QEMU; JIT path now transitively validated vs QEMU on the same fleet; neg-control broken target correctly flagged\n" as *u8,320); sys_close(logf) } 106 g_puts("verdict=GREEN (R1 hardware-test matrix: fleet runs on fast + tiered/JIT targets, all == golden sim == QEMU; the JIT path is now validated vs QEMU on the same fleet; broken-target neg-control flagged)\n" as *u8); sys_exit(0); return 0 107 } 108 g_puts("verdict=RED\n" as *u8); sys_exit(1); return 1 109}