nx_nofloat_qwen_stack_gate.nx source
↩ module page · 85 lines · 5455 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"
12import "nx_stage_path.nx"
13
14func 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 }
15func 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 }
16
17func main() -> i64 {
18 sk_puts("STACK real Qwen layers (lazy per-layer load) via the canonical nx_nofloat_llm library, no-float\n\n" as *u8)
19 let path: *u8 = sp_path("nx_real_model.gguf" as *u8, sys_mmap(SP_PATH_MAX))
20 sp_skip_unless("NOFLOAT-QWEN-STACK-GATE" as *u8, path)
21 let len_out: *i64 = sys_mmap(8) as *i64
22 len_out[0]=0
23 let buf: *u8 = sys_read_file(path, len_out)
24
25 let T: i64=2
26 let ne: i64=896
27 let qd: i64=896
28 let kvd: i64=128
29 let fd: i64=4864
30 let N: i64=3
31 let cfgA: *i64 = sys_mmap(8*8) as *i64
32 cfgA[0]=T; cfgA[1]=ne; cfgA[2]=14; cfgA[3]=2; cfgA[4]=64; cfgA[5]=qd; cfgA[6]=kvd; cfgA[7]=8192
33 let cfgF: *i64 = sys_mmap(4*8) as *i64
34 cfgF[0]=T; cfgF[1]=ne; cfgF[2]=fd
35
36 var changed: i64=0
37 var detmis: i64=0
38 var overflow: i64=0
39 var ran: i64=0
40 let out0: *i64 = sys_mmap(T*ne*8) as *i64
41 let out1: *i64 = sys_mmap(T*ne*8) as *i64
42 if buf != (0 as *u8) { if len_out[0] > 1000 {
43 let hdr: *NxGgufHeader = sys_mmap(NX_GGUF_HDR_BYTES) as *NxGgufHeader
44 if nx_gguf_parse(buf, len_out[0], hdr) == NX_GGUF_OK {
45 let wb: *i64 = sys_mmap(12*8) as *i64
46 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
47 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
48 wb[9]=sys_mmap(qd*8) as i64; wb[10]=sys_mmap(kvd*8) as i64; wb[11]=sys_mmap(kvd*8) as i64
49 let sb: *i64 = sys_mmap(14*8) as *i64
50 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
51 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
52 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
53 let nm: *u8 = sys_mmap(64)
54 let freqs: *i64 = sys_mmap(32*8) as *i64
55 rope_freqs(freqs, 64)
56 let x: *i64 = sys_mmap(T*ne*8) as *i64
57 var i: i64=0; while i<T*ne { x[i]=(((i*5+ (i/ne)*7) % 23) - 11) * 5000; i=i+1 }
58 run_stack(buf, hdr, x, out0, wb, sb, nm, freqs, cfgA, cfgF, N, 0)
59 run_stack(buf, hdr, x, out1, wb, sb, nm, freqs, cfgA, cfgF, N, 1)
60 ran=1
61 let BOUND: i64=1099511627776
62 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 }
63 }
64 } }
65
66 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");
67
68 var pass: i64=0
69 var ttl: i64=0
70 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") }
71 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") }
72 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") }
73 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") }
74
75 sk_puts("NX-NOFLOAT-QWEN-STACK-GATE passed "); sk_num(pass); sk_puts("/"); sk_num(ttl)
76 // MIGRATED onto nx_gate_verdict by nx_gate_dry_apply (D001, minimal form): every check
77 // row above is untouched, so the PASS/FAIL vector cannot change; only the hand-rolled
78 // verdict emission is replaced by the ONE shared base class. Proven by nx_gate_migrate verify.
79 let ctr__dry: *i64 = gv_ctr()
80 ctr__dry[0] = pass
81 ctr__dry[1] = ttl
82 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)
83 sys_exit(rc__dry)
84 return rc__dry
85}