nx_q8_st_bw.nx source
↩ module page · 65 lines · 2349 B
1// nx_q8_st_bw.nx -- SINGLE-THREAD sovereign Q8 matmul bandwidth, to split the
2// 2.7x gap vs gcc-in-WSL2 (25.5 GB/s @16thr) into per-thread (kernel/memory)
3// vs scaling (pool). gcc SINGLE-thread Q8 matmul in WSL2 = 2892 MB/s. If
4// sovereign single-thread ~= 2892 -> the gap is THREADING SCALING (fix pool).
5// If << 2892 -> per-thread kernel/memory. Cold 220MB sweep via the ST path.
6import "nx_syscalls.nx"
7import "nx_tier.nx"
8import "nx_le.nx"
9import "nx_f32.nx"
10import "nx_f32_cvt.nx"
11import "nx_thread_pool.nx"
12import "nx_f32_lazy_weight.nx"
13import "nx_fmt.nx"
14
15const MK: i64 = 896
16const NG: i64 = 4864
17const Q8B: i64 = 34
18const NB: i64 = 48 // 48 * 4.63MB = 222MB cold
19
20func sb_nl() -> i64 { fmt_puts("\n" as *u8); return 0 }
21func sb_lcg(s: i64) -> i64 { var v: i64 = s * 1103515245 + 12345; v = v & 2147483647; return v }
22func sb_weight(seed: i64) -> *NxF32LazyWeight {
23 let bpr: i64 = (MK / 32) * Q8B
24 let w: *u8 = sys_mmap(NG * bpr)
25 var s: i64 = seed
26 var r: i64 = 0
27 while r < NG {
28 var b: i64 = 0
29 while b < MK / 32 {
30 let off: i64 = r * bpr + b * Q8B
31 w[off + 1] = 0x2C as u8
32 var q: i64 = 0
33 while q < 32 { s = sb_lcg(s); w[off + 2 + q] = ((s % 17) - 8) as u8; q = q + 1 }
34 b = b + 1
35 }
36 r = r + 1
37 }
38 return nx_f32_lazy_weight_new_q8_0(w, 0, NG, MK)
39}
40
41func main() -> i64 {
42 let A: *i64 = sys_mmap(MK * 8) as *i64
43 var s: i64 = 4242
44 var i: i64 = 0
45 while i < MK { s = sb_lcg(s); A[i] = nx_i32_to_f32((s % 9) - 4); i = i + 1 }
46 let C: *i64 = sys_mmap(NG * 8) as *i64
47 nx_lw_shared_pool()
48
49 let bufs: *i64 = sys_mmap(NB * 8) as *i64
50 var b0: i64 = 0
51 while b0 < NB { bufs[b0] = sb_weight(700 + b0 * 13) as i64; b0 = b0 + 1 }
52
53 // SINGLE-THREAD cold sweep via _lw_q8_0_matmul_st (no pool).
54 let t0: i64 = sys_now_us()
55 var r0: i64 = 0
56 while r0 < NB { _lw_q8_0_matmul_st(bufs[r0] as *NxF32LazyWeight, A, C, 1, MK, NG); r0 = r0 + 1 }
57 let usc: i64 = sys_now_us() - t0
58 var u: i64 = usc
59 if u < 1 { u = 1 }
60 let bytes: i64 = NG * (MK / 32) * Q8B * NB
61 fmt_puts("SOVEREIGN-ST Q8 matmul COLD MBps="); fmt_putn(bytes / u)
62 fmt_puts(" (gcc-WSL2 single-thread = 2892; if ~equal, gap = pool scaling)"); sb_nl()
63 fmt_puts("Q8_ST_BW DONE"); sb_nl()
64 return 0
65}