nx_nofloat_qwen_stack_gate.nx source
↩ module page · 83 lines · 5368 B
1// nx_nofloat_qwen_stack_gate.nx -- STACK real Qwen layers (lazy per-layer load), deterministic no-float.
2// Loops the canonical full layer over consecutive real blocks blk.0..blk.{N-1}; N=24 is just the parameter.
3// ALL logic from the canonical library nx_nofloat_llm.nx (DRY -- no copy-paste debt). expect_exit: 0 ORIGINAL
4import "nx_syscalls.nx"
5import "nx_tier.nx"
6import "nx_le.nx"
7import "nx_tensor.nx"
8import "nx_gguf.nx"
9import "nx_gguf_load.nx"
10import "nx_nofloat_llm.nx"
11import "nx_gate_verdict.nx"
12
13func sk_puts(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
14func sk_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
16func main() -> i64 {
17 sk_puts("STACK real Qwen layers (lazy per-layer load) via the canonical nx_nofloat_llm library, no-float\n\n" as *u8)
18 let path: *u8 = "/home/elderwesto/nx_stage/nx_real_model.gguf\x00" as *u8
19 let len_out: *i64 = sys_mmap(8) as *i64
20 len_out[0]=0
21 let buf: *u8 = sys_read_file(path, len_out)
22
23 let T: i64=2
24 let ne: i64=896
25 let qd: i64=896
26 let kvd: i64=128
27 let fd: i64=4864
28 let N: i64=3
29 let cfgA: *i64 = sys_mmap(8*8) as *i64
30 cfgA[0]=T; cfgA[1]=ne; cfgA[2]=14; cfgA[3]=2; cfgA[4]=64; cfgA[5]=qd; cfgA[6]=kvd; cfgA[7]=8192
31 let cfgF: *i64 = sys_mmap(4*8) as *i64
32 cfgF[0]=T; cfgF[1]=ne; cfgF[2]=fd
33
34 var changed: i64=0
35 var detmis: i64=0
36 var overflow: i64=0
37 var ran: i64=0
38 let out0: *i64 = sys_mmap(T*ne*8) as *i64
39 let out1: *i64 = sys_mmap(T*ne*8) as *i64
40 if buf != (0 as *u8) { if len_out[0] > 1000 {
41 let hdr: *NxGgufHeader = sys_mmap(NX_GGUF_HDR_BYTES) as *NxGgufHeader
42 if nx_gguf_parse(buf, len_out[0], hdr) == NX_GGUF_OK {
43 let wb: *i64 = sys_mmap(12*8) as *i64
44 wb[0]=sys_mmap(ne*8) as i64; wb[1]=sys_mmap(qd*ne*8) as i64; wb[2]=sys_mmap(kvd*ne*8) as i64; wb[3]=sys_mmap(kvd*ne*8) as i64; wb[4]=sys_mmap(ne*qd*8) as i64
45 wb[5]=sys_mmap(ne*8) as i64; wb[6]=sys_mmap(ne*fd*8) as i64; wb[7]=sys_mmap(ne*fd*8) as i64; wb[8]=sys_mmap(fd*ne*8) as i64
46 wb[9]=sys_mmap(qd*8) as i64; wb[10]=sys_mmap(kvd*8) as i64; wb[11]=sys_mmap(kvd*8) as i64
47 let sb: *i64 = sys_mmap(14*8) as *i64
48 sb[0]=sys_mmap(T*ne*8) as i64; sb[1]=sys_mmap(T*qd*8) as i64; sb[2]=sys_mmap(T*kvd*8) as i64; sb[3]=sys_mmap(T*kvd*8) as i64; sb[4]=sys_mmap(T*qd*8) as i64
49 sb[5]=sys_mmap(T*8) as i64; sb[6]=sys_mmap(T*8) as i64; sb[7]=sys_mmap(T*ne*8) as i64; sb[8]=sys_mmap(T*fd*8) as i64; sb[9]=sys_mmap(T*fd*8) as i64
50 sb[10]=sys_mmap(T*fd*8) as i64; sb[11]=sys_mmap(T*ne*8) as i64; sb[12]=sys_mmap(T*ne*8) as i64; sb[13]=sys_mmap(T*ne*8) as i64
51 let nm: *u8 = sys_mmap(64)
52 let freqs: *i64 = sys_mmap(32*8) as *i64
53 rope_freqs(freqs, 64)
54 let x: *i64 = sys_mmap(T*ne*8) as *i64
55 var i: i64=0; while i<T*ne { x[i]=(((i*5+ (i/ne)*7) % 23) - 11) * 5000; i=i+1 }
56 run_stack(buf, hdr, x, out0, wb, sb, nm, freqs, cfgA, cfgF, N, 0)
57 run_stack(buf, hdr, x, out1, wb, sb, nm, freqs, cfgA, cfgF, N, 1)
58 ran=1
59 let BOUND: i64=1099511627776
60 i=0; while i<T*ne { if out0[i]!=x[i] { changed=changed+1 } if out0[i]!=out1[i] { detmis=detmis+1 } var a: i64=out0[i]; if a<0 { a=0-a } if a>=BOUND { overflow=overflow+1 } i=i+1 }
61 }
62 } }
63
64 sk_puts(" stacked N="); sk_num(N); sk_puts(" real layers (via lib) cells changed="); sk_num(changed); sk_puts(" / "); sk_num(T*ne); sk_puts(" det mism (fwd vs rev)="); sk_num(detmis); sk_puts(" overflow="); sk_num(overflow); sk_puts("\n\n");
65
66 var pass: i64=0
67 var ttl: i64=0
68 ttl=ttl+1; sk_puts(" T1 stacked N real layers via the lib's run_stack (lazy per-layer load): "); if ran==1 { pass=pass+1; sk_puts("PASS\n") } else { sk_puts("FAIL\n") }
69 ttl=ttl+1; sk_puts(" T2 the stack ran end-to-end on real consecutive blocks (output transformed): "); if changed>=ne { pass=pass+1; sk_puts("PASS\n") } else { sk_puts("FAIL\n") }
70 ttl=ttl+1; sk_puts(" T3 DETERMINISTIC at depth on real weights (0 mism fwd vs rev): "); if ran==1 { if detmis==0 { pass=pass+1; sk_puts("PASS\n") } else { sk_puts("FAIL\n") } } else { sk_puts("FAIL\n") }
71 ttl=ttl+1; sk_puts(" T4 numerically STABLE through the stack (no overflow): "); if ran==1 { if overflow==0 { pass=pass+1; sk_puts("PASS\n") } else { sk_puts("FAIL\n") } } else { sk_puts("FAIL\n") }
72
73 sk_puts("NX-NOFLOAT-QWEN-STACK-GATE passed "); sk_num(pass); sk_puts("/"); sk_num(ttl)
74 // MIGRATED onto nx_gate_verdict by nx_gate_dry_apply (D001, minimal form): every check
75 // row above is untouched, so the PASS/FAIL vector cannot change; only the hand-rolled
76 // verdict emission is replaced by the ONE shared base class. Proven by nx_gate_migrate verify.
77 let ctr__dry: *i64 = gv_ctr()
78 ctr__dry[0] = pass
79 ctr__dry[1] = ttl
80 let rc__dry: i64 = gv_verdict("NOFLOAT-QWEN-STACK-GATE" as *u8, ctr__dry, "real Qwen layers stack via the canonical lib -- no copy-paste debt; N=24 is just the parameter)" as *u8)
81 sys_exit(rc__dry)
82 return rc__dry
83}