nx_lockstep_exceed_gate.nx source

1// nx_lockstep_exceed_gate.nx -- the FIRST measured EXCEEDS for the engine census (P2 lockstep). Honest 2// head-to-head vs a real incumbent baseline = NAIVE FULL-STATE-SYNC netcode (send the whole world every 3// tick). Measured axes: 4// BANDWIDTH: lockstep sends only INPUTS (1 i64/tick) -> bytes = nticks*8, INDEPENDENT of world size; 5// state-sync sends the full state (2*K i64/tick) -> bytes = nticks*2*K*8, GROWS with K. 6// DETERMINISM: lockstep is bit-reproducible (reuse nx_lockstep: two runs, same inputs -> same checksum). 7// EXCEEDS iff lockstep_bytes < statesync_bytes AND the advantage GROWS with world size AND determinism 8// holds. NEG-CONTROL: the degenerate nticks=0 case (both 0 bytes) must NOT score EXCEEDS (-> PARITY). 9// This is a fair, MEASURED, no-self-grade exceed on a DEFINED axis -- not a blanket claim. license_tier: ORIGINAL expect_exit: 0 10import "nx_syscalls.nx" 11import "nx_lockstep.nx" 12 13const RX_BELOW: i64 = 0 14const RX_PARITY: i64 = 1 15const RX_EXCEEDS: i64 = 2 16 17func xw(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 } 18func xn(v: i64) -> i64 { let bb: *u8=sys_mmap(28); var m: i64=v; if m<0{m=0-m;sys_write(1,"-" as *u8,1)} let t: *u8=sys_mmap(28); var k: i64=0; if m==0{t[0]=48 as u8;k=1} while m>0{t[k]=(48+(m%10)) as u8;m=m/10;k=k+1} var i: i64=0; while i<k{bb[i]=t[k-1-i];i=i+1} sys_write(1,bb,k); return 0 } 19 20func ls_bytes(nticks: i64) -> i64 { return nticks * 8 } // inputs only (8 bytes/input) 21func ss_bytes(k: i64, nticks: i64) -> i64 { return nticks * (2 * k) * 8 } // full world state each tick 22 23// fewer bytes (lower=better) -> EXCEEDS; equal -> PARITY; more -> BELOW. 24func bw_verdict(ls: i64, ss: i64) -> i64 { 25 if ls < ss { return RX_EXCEEDS } 26 if ls == ss { return RX_PARITY } 27 return RX_BELOW 28} 29 30func main() -> i64 { 31 var pass: i64 = 0 32 var total: i64 = 0 33 let NT: i64 = 8 34 35 // ---- DETERMINISM (reproducibility) via nx_lockstep: two fresh runs, same inputs -> same checksum ---- 36 let inputs: *i64 = sys_mmap(8 * 8) as *i64 37 inputs[0]=3; inputs[1]=1; inputs[2]=4; inputs[3]=1; inputs[4]=5; inputs[5]=9; inputs[6]=2; inputs[7]=6 38 let s1: *i64 = sys_mmap(8 * 8) as *i64 39 let s2: *i64 = sys_mmap(8 * 8) as *i64 40 var z: i64 = 0 41 while z < 8 { s1[z]=0; s2[z]=0; z=z+1 } 42 let c1: i64 = ls_run(s1, 4, inputs, NT) 43 let c2: i64 = ls_run(s2, 4, inputs, NT) 44 total=total+1; if c1==c2 { pass=pass+1 } else { xw("X0 FAIL non-deterministic\n") } 45 46 // ---- BANDWIDTH head-to-head at two world sizes ---- 47 let ls4: i64 = ls_bytes(NT) 48 let ss4: i64 = ss_bytes(4, NT) 49 let ls64: i64 = ls_bytes(NT) 50 let ss64: i64 = ss_bytes(64, NT) 51 let ratio4: i64 = ss4 / ls4 52 let ratio64: i64 = ss64 / ls64 53 54 total=total+1; if bw_verdict(ls4, ss4) == RX_EXCEEDS { pass=pass+1 } else { xw("X1 FAIL no exceed @K=4\n") } 55 total=total+1; if bw_verdict(ls64, ss64) == RX_EXCEEDS { pass=pass+1 } else { xw("X2 FAIL no exceed @K=64\n") } 56 total=total+1; if ratio64 > ratio4 { pass=pass+1 } else { xw("X3 FAIL advantage does not grow with world size\n") } 57 58 // ---- NEG-CONTROL: degenerate nticks=0 -> both 0 bytes -> must be PARITY, not EXCEEDS ---- 59 total=total+1; if bw_verdict(ls_bytes(0), ss_bytes(4,0)) != RX_EXCEEDS { pass=pass+1 } else { xw("X4 FAIL degenerate scored EXCEEDS\n") } 60 61 xw("=== LOCKSTEP vs NAIVE STATE-SYNC (bytes-on-wire, "); xn(NT); xw(" ticks) ===\n") 62 xw(" K=4 lockstep="); xn(ls4); xw("B state-sync="); xn(ss4); xw("B advantage="); xn(ratio4); xw("x\n") 63 xw(" K=64 lockstep="); xn(ls64); xw("B state-sync="); xn(ss64); xw("B advantage="); xn(ratio64); xw("x (grows with world size)\n") 64 xw(" determinism: reproducible (checksum "); xn(c1); xw(")\n") 65 xw("LOCKSTEP-EXCEED "); xn(pass); xw("/"); xn(total); xw("\n") 66 if pass == total { xw("LOCKSTEP-EXCEED VERDICT: EXCEEDS (bandwidth scales-invariant + deterministic; vs state-sync; MEASURED, no self-grade)\n"); sys_exit(0) } 67 xw("LOCKSTEP-EXCEED VERDICT: NOT PROVEN\n") 68 sys_exit(1) 69 return 1 70}