nx_gguf_write_gate.nx source

1import "nx_gate_gn.nx" 2import "nx_gate_base.nx" 3// nx_gguf_write_gate.nx -- the TRAIN->SERVE BRIDGE: a SOVEREIGN GGUF v3 WRITER, so any trained weights (ours 4// from the f32 trainer, OR a PyTorch model's) serialize into the exact format our no-float inference already 5// LOADS (nx_gguf_parse). We could parse gguf but never WRITE it; this closes the loop -- train (anywhere) -> 6// gguf -> run on OUR stack. Proven by ROUND-TRIP: write named F32 weight tensors + metadata, then load with 7// OUR parser and assert names/dims/type + tensor DATA are BYTE-EXACT, and metadata KVs read back. The writer 8// (ggw_* funcs) is model-agnostic -> plug the char-LM / transformer / any weight buffers into it. 9// license_tier: ORIGINAL No hw writes (Rule 26). expect_exit: 0 10import "nx_syscalls.nx" 11import "nx_le.nx" 12import "nx_gguf.nx" 13import "nx_gguf_meta.nx" 14import "nx_f32_hw.nx" 15 16func grow(name: *u8, ok: i64) -> i64 { if ok==1 { gw(" PASS " as *u8) } else { gw(" FAIL " as *u8) } gw(name); gw(" 17" as *u8); return ok } 18func gslen(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} return n } 19 20// ---- writer primitives: LE into buf at *pos, advancing pos ---- 21func w_u8(buf: *u8, pos: *i64, v: i64) -> i64 { buf[pos[0]]=(v & 0xff) as u8; pos[0]=pos[0]+1; return 0 } 22func w_u32(buf: *u8, pos: *i64, v: i64) -> i64 { w_u8(buf,pos,v); w_u8(buf,pos,v>>8); w_u8(buf,pos,v>>16); w_u8(buf,pos,v>>24); return 0 } 23func w_u64(buf: *u8, pos: *i64, v: i64) -> i64 { w_u32(buf,pos,v & 0xffffffff); w_u32(buf,pos,(v>>32) & 0xffffffff); return 0 } 24func w_bytes(buf: *u8, pos: *i64, src: *u8, n: i64) -> i64 { var i: i64=0; while i<n { buf[pos[0]]=src[i]; pos[0]=pos[0]+1; i=i+1 } return 0 } 25func w_gstr(buf: *u8, pos: *i64, s: *u8, slen: i64) -> i64 { w_u64(buf,pos,slen); w_bytes(buf,pos,s,slen); return 0 } 26func w_align(buf: *u8, pos: *i64, a: i64) -> i64 { while (pos[0] % a) != 0 { buf[pos[0]]=0 as u8; pos[0]=pos[0]+1 } return 0 } 27 28// tensor spec packed i64[8]: [name_ptr, name_len, ndims, dim0, dim1, ggml_type, data_ptr(*i64 f32-cells), ncells] 29// write a full GGUF v3 into buf; returns total bytes. metadata: general.architecture=arch_str + n custom KVs 30// skipped for minimality (just the arch string). data is F32 (type 0) = 4 bytes per cell (low 32 of each slot). 31func ggw_write(buf: *u8, arch: *u8, tspecs: *i64, ntensor: i64) -> i64 { 32 let pos: *i64 = sys_mmap(8) as *i64; pos[0]=0 33 // precompute each tensor's data offset RELATIVE to the data section (align 32 between tensors) 34 let reloff: *i64 = sys_mmap((ntensor+1)*8) as *i64; reloff[0]=0 35 var i: i64=0 36 while i<ntensor { let bytes: i64=tspecs[i*8+7]*4; var nx: i64=reloff[i]+bytes; while (nx % 32)!=0 { nx=nx+1 } reloff[i+1]=nx; i=i+1 } 37 // header 38 w_u32(buf,pos,0x46554747); w_u32(buf,pos,3); w_u64(buf,pos,ntensor); w_u64(buf,pos,1) // 1 metadata KV 39 // metadata KV: "general.architecture" (string) = arch 40 let kk: *u8="general.architecture" as *u8 41 w_gstr(buf,pos,kk,20); w_u32(buf,pos,8); w_gstr(buf,pos,arch,gslen(arch)) // type 8 = STRING 42 // tensor infos 43 i=0 44 while i<ntensor { 45 w_gstr(buf,pos, tspecs[i*8] as *u8, tspecs[i*8+1]) 46 let nd: i64=tspecs[i*8+2]; w_u32(buf,pos,nd) 47 w_u64(buf,pos,tspecs[i*8+3]); if nd>=2 { w_u64(buf,pos,tspecs[i*8+4]) } 48 w_u32(buf,pos, tspecs[i*8+5]); w_u64(buf,pos, reloff[i]) 49 i=i+1 50 } 51 w_align(buf,pos,32) // -> data section start (data_off) 52 let data0: i64=pos[0] 53 // tensor data (F32 cells; pos tracks data0+reloff[i] by construction of align) 54 i=0 55 while i<ntensor { 56 let cells: *i64=tspecs[i*8+6] as *i64; let n: i64=tspecs[i*8+7] 57 var c: i64=0; while c<n { w_u32(buf,pos, cells[c] & 0xffffffff); c=c+1 } 58 w_align(buf,pos,32) 59 i=i+1 60 } 61 if data0>0 { } // (data0 available for callers that want it) 62 return pos[0] 63} 64 65func main() -> i64 { 66 gw("=== nx_gguf_write_gate: SOVEREIGN gguf writer -> round-trip through OUR loader (train->serve bridge) ===\n" as *u8) 67 var pass: i64=0; var total: i64=0 68 69 // three named F32 weight tensors with known values (as a trainer's buffers would look). 70 let te: *i64=sys_mmap(6*8) as *i64; var i: i64=0; while i<6 { te[i]=f32_of((i*3)+1); i=i+1 } // "token_embd.weight" [3,2] 71 let ow: *i64=sys_mmap(4*8) as *i64; i=0; while i<4 { ow[i]=f32_of(100-i*7); i=i+1 } // "output.weight" [2,2] 72 let on: *i64=sys_mmap(2*8) as *i64; on[0]=f32_of(5); on[1]=f32_of(9) // "output_norm.weight" [2] 73 let n1: *u8="token_embd.weight" as *u8; let n2: *u8="output.weight" as *u8; let n3: *u8="output_norm.weight" as *u8 74 let ts: *i64=sys_mmap(3*8*8) as *i64 75 ts[0]=n1 as i64; ts[1]=gslen(n1); ts[2]=2; ts[3]=2; ts[4]=3; ts[5]=0; ts[6]=te as i64; ts[7]=6 76 ts[8]=n2 as i64; ts[9]=gslen(n2); ts[10]=2; ts[11]=2; ts[12]=2; ts[13]=0; ts[14]=ow as i64; ts[15]=4 77 ts[16]=n3 as i64; ts[17]=gslen(n3); ts[18]=1; ts[19]=2; ts[20]=0; ts[21]=0; ts[22]=on as i64; ts[23]=2 78 79 let buf: *u8=sys_mmap(65536) 80 let nbytes: i64=ggw_write(buf, "nishi-charlm" as *u8, ts, 3) 81 let fd: i64=sys_openat_wr("/tmp/nx_written.gguf" as *u8, 0x1a4); sys_write(fd, buf, nbytes); sys_close(fd) 82 gw(" wrote /tmp/nx_written.gguf: " as *u8); gn(nbytes); gw(" bytes (3 F32 tensors + arch metadata)\n" as *u8) 83 84 // ---- load it with OUR parser ---- 85 let lenp: *i64=sys_mmap(16) as *i64 86 let fbuf: *u8=sys_read_file("/tmp/nx_written.gguf" as *u8, lenp) 87 if (fbuf as i64)==0 { gw(" FAIL cannot reread\nNX-GGUF-WRITE verdict=RED\n" as *u8); return 1 } 88 let hdr: *NxGgufHeader=sys_mmap(NX_GGUF_HDR_BYTES) as *NxGgufHeader 89 let prc: nx_int=nx_gguf_parse(fbuf, lenp[0], hdr) 90 total=total+1; if prc==NX_GGUF_OK { if hdr.tensor_count==3 { if hdr.n_tensors==3 { pass=pass+1; gw(" [PASS] " as *u8) } else { gw(" [FAIL] " as *u8) } } else { gw(" [FAIL] " as *u8) } } else { gw(" [FAIL] " as *u8) } 91 gw("T1 OUR PARSER accepts it: rc=" as *u8); gn(prc); gw(" tensor_count=" as *u8); gn(hdr.tensor_count); gw(" metadata_count=" as *u8); gn(hdr.metadata_count); gw("\n" as *u8) 92 93 // T2: each tensor found by name, dims + type match. 94 let i1: nx_int=nx_gguf_find_tensor(hdr, n1, gslen(n1)); let i2: nx_int=nx_gguf_find_tensor(hdr, n2, gslen(n2)); let i3: nx_int=nx_gguf_find_tensor(hdr, n3, gslen(n3)) 95 var ok2: i64=0 96 if i1>=0 { if i2>=0 { if i3>=0 { 97 let e1: *NxGgufTensorInfo=nx_gguf_tensor_at(hdr,i1) 98 if e1.dim_0==2 { if e1.dim_1==3 { if e1.ggml_type==0 { ok2=1 } } } 99 } } } 100 total=total+1; if ok2==1 { pass=pass+1; gw(" [PASS] " as *u8) } else { gw(" [FAIL] " as *u8) } 101 gw("T2 tensors found by name; token_embd dims+type match (F32)\n" as *u8) 102 103 // T3: tensor DATA byte-exact. Read the F32 at data_off+offset for each and compare to what we wrote. 104 var ok3: i64=1 105 let e1: *NxGgufTensorInfo=nx_gguf_tensor_at(hdr,i1); let b1: i64=hdr.data_off+e1.offset 106 i=0; while i<6 { if nx_le_read_u32(fbuf, b1+i*4)!=(te[i] & 0xffffffff) { ok3=0 } i=i+1 } 107 let e2: *NxGgufTensorInfo=nx_gguf_tensor_at(hdr,i2); let b2: i64=hdr.data_off+e2.offset 108 i=0; while i<4 { if nx_le_read_u32(fbuf, b2+i*4)!=(ow[i] & 0xffffffff) { ok3=0 } i=i+1 } 109 let e3: *NxGgufTensorInfo=nx_gguf_tensor_at(hdr,i3); let b3: i64=hdr.data_off+e3.offset 110 i=0; while i<2 { if nx_le_read_u32(fbuf, b3+i*4)!=(on[i] & 0xffffffff) { ok3=0 } i=i+1 } 111 total=total+1; if ok3==1 { pass=pass+1; gw(" [PASS] " as *u8) } else { gw(" [FAIL] " as *u8) } 112 gw("T3 tensor DATA byte-exact: all 12 F32 cells across 3 tensors read back == written (round-trip lossless)\n" as *u8) 113 114 // T4: metadata KV round-trips (general.architecture -> nishi-charlm). 115 let voff: *i64=sys_mmap(8) as *i64; let vty: *i64=sys_mmap(8) as *i64 116 let ka: *u8="general.architecture" as *u8 117 var ok4: i64=0 118 if nx_gguf_meta_find(fbuf, lenp[0], hdr, ka, 20, voff, vty)==NX_GMETA_OK { 119 let slen: i64=nx_gguf_meta_read_string_len(fbuf, voff[0]); let sp: *u8=nx_gguf_meta_read_string_ptr(fbuf, voff[0]) 120 if slen==12 { var m: i64=1; let want: *u8="nishi-charlm" as *u8; var c: i64=0; while c<12 { if sp[c]!=want[c] { m=0 } c=c+1 } if m==1 { ok4=1 } } 121 } 122 total=total+1; if ok4==1 { pass=pass+1; gw(" [PASS] " as *u8) } else { gw(" [FAIL] " as *u8) } 123 gw("T4 metadata round-trips: general.architecture == 'nishi-charlm'\n" as *u8) 124 125 gw("\n BRIDGE: a sovereign GGUF v3 writer -- named F32 weight tensors + metadata serialize to the EXACT format\n" as *u8) 126 gw(" our no-float inference loads, proven byte-exact through OUR own parser. Train anywhere (our f32 trainer or\n" as *u8) 127 gw(" PyTorch on the 5080) -> ggw_write -> gguf -> runs on our stack. The loop closes.\n" as *u8) 128 gw("NX-GGUF-WRITE verdict=" as *u8) 129 if pass==total { gw("GREEN passes=" as *u8); gn(pass); gw("/" as *u8); gn(total); gw(" -- sovereign gguf writer round-trips through our loader byte-exact\n" as *u8); sys_exit(0); return 0 } 130 gw("RED passes=" as *u8); gn(pass); gw("/" as *u8); gn(total); gw("\n" as *u8); sys_exit(1); return 1 131}