nx_f32_llama_layer_lazy_load_test.nx source
↩ module page · 68 lines · 2666 B
1// nx_f32_llama_layer_lazy_load_test.nx -- smoke for the lazy-aware
2// per-layer binder. Uses the tiny fixture (F32 zero weights).
3// Verifies all 9 weight slots are populated; W_* are F32-tagged
4// NxF32LazyWeight (since the fixture has no Q4_K tensors).
5
6import "nx_syscalls.nx"
7import "nx_tier.nx"
8import "nx_gguf.nx"
9import "nx_gguf_fixture_tiny.nx"
10import "nx_gguf_load_f32.nx"
11import "nx_f32_lazy_weight.nx"
12import "nx_f32_llama_block_v4.nx"
13import "nx_f32_llama_layer_lazy_load.nx"
14
15func main() -> i64 {
16 var vi: nx_int = 0
17 while vi < NX_FLLL_N_VERDICTS {
18 if nx_flll_verdict_is_valid(vi) != 1 { return 5 + vi }
19 vi = vi + 1
20 }
21
22 let b: *NxGgufFixtureBundle = nx_gft_build_tiny_llama(42 as i64)
23 if nx_gft_is_built(b) != 1 { return 10 }
24
25 let layer: *NxF32LlamaLayerLazy = nx_f32_llama_layer_lazy_alloc()
26 let out_err: *i64 = sys_mmap(8) as *i64
27
28 let v: nx_int = nx_f32_llama_layer_lazy_load_from_gguf(
29 b.gguf_buf, b.hdr, 0, layer, out_err)
30 if v != NX_FLLL_OK { return 20 + v }
31
32 // All 9 slots populated.
33 if (layer.gamma_attn as i64) == 0 { return 40 }
34 if (layer.gamma_ffn as i64) == 0 { return 41 }
35 if (layer.W_q as i64) == 0 { return 42 }
36 if (layer.W_k as i64) == 0 { return 43 }
37 if (layer.W_v as i64) == 0 { return 44 }
38 if (layer.W_o as i64) == 0 { return 45 }
39 if (layer.W_gate as i64) == 0 { return 46 }
40 if (layer.W_up as i64) == 0 { return 47 }
41 if (layer.W_down as i64) == 0 { return 48 }
42
43 // All W_* tagged F32 (fixture has F32 source).
44 if layer.W_q.dtype_tag != NX_LW_DTYPE_F32 { return 50 }
45 if layer.W_k.dtype_tag != NX_LW_DTYPE_F32 { return 51 }
46 if layer.W_v.dtype_tag != NX_LW_DTYPE_F32 { return 52 }
47 if layer.W_o.dtype_tag != NX_LW_DTYPE_F32 { return 53 }
48 if layer.W_gate.dtype_tag != NX_LW_DTYPE_F32 { return 54 }
49 if layer.W_up.dtype_tag != NX_LW_DTYPE_F32 { return 55 }
50 if layer.W_down.dtype_tag != NX_LW_DTYPE_F32 { return 56 }
51
52 // Fixture weights are zero -> first value of each storage is 0.
53 if layer.gamma_attn[0] != 0 { return 60 }
54 if layer.W_q.storage[0] != 0 { return 61 }
55 if layer.W_down.storage[0] != 0 { return 62 }
56
57 // Bad-layer + missing-layer verdicts.
58 let layer2: *NxF32LlamaLayerLazy = nx_f32_llama_layer_lazy_alloc()
59 let vE: nx_int = nx_f32_llama_layer_lazy_load_from_gguf(
60 b.gguf_buf, b.hdr, -1, layer2, out_err)
61 if vE != NX_FLLL_ERR_BAD_LAYER { return 70 }
62
63 let vN: nx_int = nx_f32_llama_layer_lazy_load_from_gguf(
64 b.gguf_buf, b.hdr, 5, layer2, out_err)
65 if vN != NX_FLLL_ERR_NOT_FOUND { return 71 }
66
67 return 0
68}