nx_realweight_quant_gate.nx
buildroot/runtime/nx_realweight_quant_gate.nx
about
nx_realweight_quant_gate.nx -- AIM AT THE BAR: a REAL quantization-error number on REAL model weights.
Loads a BF16 weight slice from an actual safetensors model, runs the dominant op (matmul) two ways:
reference = full-precision Q16 weights; quantized = PER-CHANNEL INT8 weights (dequantized).
Measures the relative output error -- the real cost of INT8-quantizing real weights through a real
computation. NOT end-to-end model accuracy (that bar is bigger), but the first number that is REAL
(real weights, real op, measured) rather than synthetic. Reports it honestly whatever it is, and checks
per-channel vs per-tensor on the same real data. No hw writes (Rule 26). expect_exit: 0 tier: ORIGINAL
dependencies 3 imports · 0 importers
imports: nx_syscalls.nxnx_gate_verdict.nxnx_stage_path.nx
imported by: nobody (leaf or entry point)
call flow from main pre-order; caps 40 nodes / depth 6 declared; ↻ = already shown
structs
| none |
consts
| none |
functions
| 13 | func rw_puts(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 } |
| 14 | func rw_num(v: i64) -> i64 { let b: *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{b[i]=t[k-1-i];i=i+1} sys_write(1,b,k); return 0 } |
| 15 | func absq(x: i64) -> i64 { if x<0 { return 0-x } return x } called by 1: main |
| 16 | func rdiv(a: i64, b: i64) -> i64 { if a>=0 { return (a+(b>>1))/b } return 0 - (((0-a)+(b>>1))/b) } called by 1: main |
| 17 | func clampq(x: i64, lo: i64, hi: i64) -> i64 { if x<lo { return lo } if x>hi { return hi } return x } called by 1: main |
| 18 | func qmul(a: i64, b: i64) -> i64 { return (a*b) >> 16 } called by 1: main |
| 19 | func bf16_to_q16(bf: i64) -> i64 called by 1: main |
| 28 | func isqrt(v: i64) -> i64 { if v<=0 { return 0 } if v<4 { return 1 } var x: i64=v; var y: i64=(x+1)>>1; var go: i64=1; while go==1 { if y<x { x=y; y=(x+v/x)>>1 } else { go=0 } } return x } called by 1: main |
| 30 | func main() -> i64 |