code wiki / _hdl_build / nx_parallel_ingest_test.nx
nx_parallel_ingest_test.nx source
↩ module page · 61 lines · 2849 B
1// nx_parallel_ingest_test.nx -- ingest 256 capability results in PARALLEL with a bounded
2// pool, prove it matches the sequential answer (correct), and show the resource bound: at
3// most K workers live at once, a compact 256-byte bank, parent RAM flat. Speedup measured.
4
5import "nx_parallel_ingest.nx"
6
7func pi_puts(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
8func pi_num(v: i64) -> i64 {
9 let bb: *u8 = sys_mmap(28); var m: i64 = v; if m < 0 { m = 0 - m }
10 let t: *u8 = sys_mmap(28); var k: i64 = 0
11 if m == 0 { t[0] = 48; k = 1 }
12 while m > 0 { t[k] = 48 + (m % 10); m = m / 10; k = k + 1 }
13 var i: i64 = 0; while i < k { bb[i] = t[k - 1 - i]; i = i + 1 }
14 sys_write(1, bb, k); return 0
15}
16
17func pi_main(r: *i64) -> i64 {
18 pi_puts("=== PARALLEL INGEST: 256 capability results, bounded pool, process-isolated, compact bank ===\n" as *u8)
19 let N: i64 = 256
20 let K: i64 = 8
21 let bank: *u8 = par_mmap_shared(N) // shared 256-byte result bank
22 var i: i64 = 0
23 while i < N { bank[i] = 255 as u8; i = i + 1 } // 255 = not-yet-ingested sentinel
24
25 let t0: i64 = sys_now_us()
26 par_ingest(N, K, bank) // ingest in parallel, K workers max
27 let t1: i64 = sys_now_us()
28
29 // SEQUENTIAL reference (correctness oracle) + timing
30 let seq: *u8 = sys_mmap(N)
31 let s0: i64 = sys_now_us()
32 i = 0
33 while i < N { seq[i] = par_work(i) as u8; i = i + 1 }
34 let s1: i64 = sys_now_us()
35
36 // verify every item ingested + matches sequential
37 var ingested: i64 = 0
38 var mismatch: i64 = 0
39 i = 0
40 while i < N {
41 if bank[i] != (255 as u8) { ingested = ingested + 1 }
42 if bank[i] != seq[i] { mismatch = mismatch + 1 }
43 i = i + 1
44 }
45 pi_puts(" ingested " as *u8); pi_num(ingested); pi_puts("/" as *u8); pi_num(N)
46 pi_puts(" items with at most " as *u8); pi_num(K); pi_puts(" concurrent workers; mismatches vs sequential=" as *u8); pi_num(mismatch); pi_puts("\n" as *u8)
47 pi_puts(" parallel " as *u8); pi_num((t1 - t0) / 1000); pi_puts(" ms vs sequential " as *u8); pi_num((s1 - s0) / 1000); pi_puts(" ms\n" as *u8)
48 pi_puts(" resource bound: parent holds K=" as *u8); pi_num(K); pi_puts(" pids + a " as *u8); pi_num(N); pi_puts("-byte bank; each worker's RAM is reclaimed on exit -> flat as n grows.\n" as *u8)
49 pi_puts("----------------------------------------------------------------\n" as *u8)
50 pi_puts(" ingest thousands of exceeds with a handful of cores + a few KB: K*worker-RAM + n*record, both bounded.\n" as *u8)
51 r[0] = 0; if ingested == N { if mismatch == 0 { r[0] = 1 } }
52 return 1
53}
54
55func main() -> i64 {
56 let r: *i64 = sys_mmap(8 * 4) as *i64
57 pi_main(r)
58 var ec: i64 = 0; if r[0] != 1 { ec = 1 }
59 sys_exit(ec)
60 return ec
61}