nx_gguf_load_f32_test.nx source
↩ module page · 89 lines · 3254 B
1// nx_gguf_load_f32_test.nx -- smoke for nx_gguf_load_f32.nx.
2//
3// Builds a minimal 1-tensor GGUF buffer with one F32 tensor of 4
4// known values (1.0, 2.0, 3.0, 4.0), parses it via nx_gguf_parse,
5// loads the tensor as f32, and verifies bit-exact bytes.
6
7import "nx_syscalls.nx"
8import "nx_tier.nx"
9import "nx_le.nx"
10import "nx_gguf.nx"
11import "nx_gguf_load.nx"
12import "nx_gguf_load_f32.nx"
13
14func main() -> i64 {
15 var vi: nx_int = 0
16 while vi < NX_GLF_N_VERDICTS {
17 if nx_glf_verdict_is_valid(vi) != 1 { return 5 + vi }
18 vi = vi + 1
19 }
20
21 // Build minimal GGUF: header (24) + 1 tensor info (~50) + data.
22 let buf: *u8 = sys_mmap(512)
23
24 // Header.
25 buf[0]=0x47; buf[1]=0x47; buf[2]=0x55; buf[3]=0x46
26 nx_le_write_u32(buf, 4, 3) // version
27 nx_le_write_u64(buf, 8, 1) // tensor_count = 1
28 nx_le_write_u64(buf, 16, 0) // metadata_count = 0
29
30 // Tensor info at offset 24.
31 // name = "test.weight" (11 bytes)
32 let name: *u8 = sys_mmap(11)
33 name[0]=0x74; name[1]=0x65; name[2]=0x73; name[3]=0x74
34 name[4]=0x2e; name[5]=0x77; name[6]=0x65; name[7]=0x69
35 name[8]=0x67; name[9]=0x68; name[10]=0x74
36
37 var p: i64 = 24
38 nx_le_write_u64(buf, p, 11) // name_len
39 p = p + 8
40 var ni: nx_int = 0
41 while ni < 11 { buf[p + ni] = name[ni]; ni = ni + 1 }
42 p = p + 11
43 nx_le_write_u32(buf, p, 1) // n_dims
44 p = p + 4
45 nx_le_write_u64(buf, p, 4) // dim_0 = 4 values
46 p = p + 8
47 nx_le_write_u32(buf, p, 0) // ggml_type = F32
48 p = p + 4
49 nx_le_write_u64(buf, p, 0) // tensor data offset within data section
50 p = p + 8
51
52 // Align data_off to 32-byte boundary.
53 let data_off: i64 = (p + 31) / 32 * 32
54
55 // Tensor data: 4 f32 values (1.0, 2.0, 3.0, 4.0).
56 nx_le_write_u32(buf, data_off + 0, 0x3F800000) // 1.0
57 nx_le_write_u32(buf, data_off + 4, 0x40000000) // 2.0
58 nx_le_write_u32(buf, data_off + 8, 0x40400000) // 3.0
59 nx_le_write_u32(buf, data_off + 12, 0x40800000) // 4.0
60
61 // Parse the GGUF.
62 let hdr: *NxGgufHeader = sys_mmap(NX_GGUF_HDR_BYTES) as *NxGgufHeader
63 let pv: nx_int = nx_gguf_parse(buf, 512, hdr)
64 if pv != NX_GGUF_OK { return 20 + pv }
65
66 // Load the tensor as f32.
67 let n_values_out: *i64 = sys_mmap(8) as *i64
68 let out_err: *i64 = sys_mmap(8) as *i64
69 let storage: *i64 = nx_gguf_load_tensor_to_f32(buf, hdr, name, 11,
70 n_values_out, out_err)
71 if out_err[0] != NX_GLF_OK { return 30 + (out_err[0] as nx_int) }
72 if storage == (0 as *i64) { return 40 }
73 if n_values_out[0] != 4 { return 50 }
74
75 // Verify bit-exact f32 bits.
76 if storage[0] != 0x3F800000 { return 60 }
77 if storage[1] != 0x40000000 { return 61 }
78 if storage[2] != 0x40400000 { return 62 }
79 if storage[3] != 0x40800000 { return 63 }
80
81 // Test ERR_NOT_FOUND.
82 let bad_name: *u8 = sys_mmap(8)
83 bad_name[0]=0x78; bad_name[1]=0x78; bad_name[2]=0x78
84 let _s2: *i64 = nx_gguf_load_tensor_to_f32(buf, hdr, bad_name, 3,
85 n_values_out, out_err)
86 if out_err[0] != NX_GLF_ERR_NOT_FOUND { return 70 }
87
88 return 0
89}