nx_rv64_jit_w_gate.nx source

1// nx_rv64_jit_w_gate.nx -- GATE: the JIT now compiles *W (32-bit word) ops, so REAL `int` loops accelerate. Before this, 2// jit_compile lacked ADDIW/ADDW/SUBW/MULW/SLLIW/SRLIW/SRAIW -> real compiled int loops (i++ = addiw) NEVER JIT'd (the 3// realc gate showed 0 loops JIT'd). A *W-heavy loop (sum of i*i for i in 1..K using mulw/addw/addiw + a 32-bit branch) 4// now JITs: T1 result == the golden interpreter (correctness, incl. 32-bit sign-extension), T2 it actually compiled + 5// ran native, T3 measurably faster. Uses the sovereign assembler (which emits *W). expect_exit: 0 6import "nx_syscalls.nx" 7import "nx_rv64_asm.nx" 8import "nx_rv64_fast.nx" 9import "nx_rv64_jit.nx" 10import "nx_rv64_tier.nx" 11 12func g_puts(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 } 13func g_pn(v: i64) -> i64 { let b: *u8=sys_mmap(28); var x: i64=v; if x<0{b[0]=45;sys_write(1,b,1);x=0-x} 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 } 14func 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 } 15const MEMSZ: i64 = 4096 16 17func main() -> i64 { 18 g_puts("nx_rv64_jit_w_gate (the JIT compiles *W ops -> real int loops accelerate: correctness + it JITs + faster)\n" as *u8) 19 var pass: i64=0; var total: i64=0 20 let code: *u8=sys_mmap(4096) 21 let opk: *i64=sys_mmap(128*8) as *i64; let rd: *i64=sys_mmap(128*8) as *i64; let rs1: *i64=sys_mmap(128*8) as *i64; let rs2: *i64=sys_mmap(128*8) as *i64; let imm: *i64=sys_mmap(128*8) as *i64 22 23 // sum of i*i for i in 1..2000000, all 32-bit int (mulw + addw + addiw + blt). t0=sum(x5) t1=i(x6) t2=limit(x7). 24 let nb: i64=rvasm_assemble_str(" li t0, 0\n li t1, 1\n lui t2, 0x1e9\n addi t2, t2, -0x780\nsq:\n mulw t3, t1, t1\n addw t0, t0, t3\n addiw t1, t1, 1\n blt t1, t2, sq\n" as *u8, code, 4096) 25 if nb<0 { g_puts(" ASSEMBLE FAILED\n" as *u8); sys_exit(1); return 1 } 26 let nc: i64=fk_predecode(code, nb, opk, rd, rs1, rs2, imm) 27 28 // golden interpreter 29 let ri: *i64=sys_mmap(32*8) as *i64; let mi: *u8=sys_mmap(MEMSZ); var z: i64=0; while z<32 { ri[z]=0; z=z+1 } 30 let it0: i64=sys_now_us(); fk_run(opk, rd, rs1, rs2, imm, nc, ri, mi, MEMSZ, 200000000, (0 as i64) as *NxVirtioMmio); let it1: i64=sys_now_us() 31 // tiered/JIT 32 let rt: *i64=sys_mmap(32*8) as *i64; let mt: *u8=sys_mmap(MEMSZ); let stats: *i64=sys_mmap(64) as *i64; z=0; while z<32 { rt[z]=0; z=z+1 } 33 let tt0: i64=sys_now_us(); tier_run(opk, rd, rs1, rs2, imm, nc, rt, mt, MEMSZ, 200000000, (0 as i64) as *NxVirtioMmio, 5, stats); let tt1: i64=sys_now_us() 34 35 g_puts(" sum(i*i,1..1999999) mod 2^32 sext: interp t0="); g_pn(ri[5]); g_puts(" tiered t0="); g_pn(rt[5]); g_puts("\n" as *u8) 36 g_puts(" tiered stats: interpreted="); g_pn(stats[0]); g_puts(" loops-JIT'd="); g_pn(stats[1]); g_puts(" native-runs="); g_pn(stats[2]); g_puts("\n" as *u8) 37 g_puts(" time: interp="); g_pn(it1-it0); g_puts("us tiered="); g_pn(tt1-tt0); g_puts("us\n" as *u8) 38 39 var t1: i64=0; if rt[5]==ri[5] { t1=1 } 40 pass=pass+ck("T1: the *W loop on the tiered/JIT engine == the golden interpreter (correctness incl. 32-bit sign-ext)" as *u8, t1); total=total+1 41 var t2: i64=0; if stats[1]>=1 { if stats[2]>=1 { t2=1 } } 42 pass=pass+ck("T2: the *W loop actually JIT-COMPILED + ran native (before this, real int loops NEVER JIT'd -- 0)" as *u8, t2); total=total+1 43 var t3: i64=0; if (tt1-tt0) < (it1-it0) { t3=1 } 44 var sp: i64=0; if (tt1-tt0)>0 { sp=((it1-it0)*100)/(tt1-tt0) } 45 g_puts(" JIT speedup on the *W loop = "); g_pn(sp/100); g_puts("."); if sp%100<10 { g_puts("0" as *u8) } g_pn(sp%100); g_puts("x\n" as *u8) 46 pass=pass+ck("T3: the JIT'd *W loop is measurably faster than interpretation (real int code now accelerates)" as *u8, t3); total=total+1 47 48 var okall: i64=0; if pass==total { okall=1 } 49 g_puts("---- nx_rv64_jit_w_gate: passed "); g_pn(pass); g_puts(" / "); g_pn(total); g_puts(" ----\n" as *u8) 50 if okall==1 { 51 let logf: i64=sys_openat_append("knowledge/status/jit_w.log" as *u8, 420) 52 if logf>=0 { let z2: i64=sys_write(logf,"NXRV64JITW GREEN: the JIT compiles *W ops (ADDIW/ADDW/SUBW/MULW/SLLIW/SRLIW/SRAIW via EAX+MOVSXD) -- real int loops now JIT-accelerate (were 0), correct vs interp incl 32-bit sign-ext, measurably faster\n" as *u8,205); sys_close(logf) } 53 g_puts("verdict=GREEN (the JIT now compiles *W ops -> real int loops JIT-accelerate, correct vs the interpreter + faster; the JIT fires on real code now)\n" as *u8); sys_exit(0); return 0 54 } 55 g_puts("verdict=RED\n" as *u8); sys_exit(1); return 1 56}