nx_uxf_store_bench.nx source
↩ module page · 133 lines · 7045 B
1// nx_uxf_store_bench.nx -- UXF arc R3: MEASURED exceed vs SQLite, on the sovereign seg_store.
2//
3// Honest framing (Rule: no-overclaim; sqlite3 is NOT installed here so a live 1:1 run is not
4// possible): the NISHI side is REALLY MEASURED with the native monotonic clock INSIDE the organ
5// (sys_clock_now_us -- honoring monitor-the-system-not-the-person); SQLite is a BY-DESIGN named
6// reference (its costs stated, NOT fabricated numbers) -- the same discipline nx_ws_exceed_gate
7// used for git. Exceed claim = the measured Nishi numbers + the STRUCTURAL properties SQLite
8// pays by-design and the append-only content-addressed store does not.
9//
10// Workload: N put records into one segment via the real write path (ss_add -> ss_build_keys ->
11// ss_writefile+fsync), then M point-gets via binary search over the sorted NXK1 index (zero-copy
12// read of the index bytes). All timed natively. No hardware writes (Rule 26).
13// expect_exit: 0 license_tier: ORIGINAL
14import "nx_syscalls.nx"
15import "nx_seg_store.nx"
16const K_MAGIC_4194304: i64 = 4194304
17const K_MAGIC_7919: i64 = 7919
18const K_MAGIC_1000000: i64 = 1000000
19
20const BN: i64 = 20000 // records written
21const BM: i64 = 20000 // point-gets timed
22
23func b_puts(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
24func b_putn(v: i64) -> i64 { let bb: *u8 = sys_mmap(28); var m: i64 = v; if m < 0 { m = 0 - m; sys_write(1, "-" as *u8, 1) } let t: *u8 = sys_mmap(28); var k: i64 = 0; if m == 0 { t[0] = 48 as u8; k = 1 } while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 } var i: i64 = 0; while i < k { bb[i] = t[k - 1 - i]; i = i + 1 } sys_write(1, bb, k); return 0 }
25
26// fixed-width key "k" + 8-digit zero-padded i (fixed width => byte-lex order == numeric order)
27func b_key(i: i64, dst: *u8) -> i64 {
28 dst[0] = 107 as u8 // 'k'
29 var v: i64 = i
30 var p: i64 = 8
31 while p >= 1 { dst[p] = (48 + (v % 10)) as u8; v = v / 10; p = p - 1 }
32 dst[9] = 0 as u8
33 return 9
34}
35
36// binary search the NXK1 index for key(kl); on hit out[0]=voff,out[1]=vlen, returns entry idx; else -1.
37// NXK1 | u32be m | m x u32be rel-off (from base=8+4m) | entries: u8 kind|u32be klen|key|u32be voff|u32be vlen
38func b_get(idx: *u8, key: *u8, kl: i64, out: *i64) -> i64 {
39 let m: i64 = ss_r32(idx, 4)
40 let base: i64 = 8 + 4 * m
41 var lo: i64 = 0
42 var hi: i64 = m - 1
43 while lo <= hi {
44 let mid: i64 = (lo + hi) / 2
45 let rel: i64 = ss_r32(idx, 8 + 4 * mid)
46 let eoff: i64 = base + rel
47 let eklen: i64 = ss_r32(idx, eoff + 1)
48 let ekoff: i64 = eoff + 5
49 let cmp: i64 = ss_kcmp(((idx as i64) + ekoff) as *u8, eklen, key, kl)
50 if cmp == 0 {
51 out[0] = ss_r32(idx, ekoff + eklen)
52 out[1] = ss_r32(idx, ekoff + eklen + 4)
53 return mid
54 }
55 if cmp < 0 { lo = mid + 1 } else { hi = mid - 1 }
56 }
57 return 0 - 1
58}
59
60func main() -> i64 {
61 b_puts("R3 STORE BENCH -- sovereign seg_store, native-clock timed (vs SQLite by-design)\n" as *u8)
62
63 let val: *u8 = sys_mmap(16)
64 var z: i64 = 0
65 while z < 16 { val[z] = 0xAB as u8; z = z + 1 }
66 let key: *u8 = sys_mmap(16)
67
68 // ---- WRITE PATH (timed) ----
69 let t0: i64 = sys_clock_now_us()
70 let w: *i64 = ss_begin()
71 var addfail: i64 = 0
72 var i: i64 = 0
73 while i < BN {
74 b_key(i, key)
75 if ss_add(w, 1, key, val, 16) != 0 { addfail = 1 }
76 i = i + 1
77 }
78 let t1: i64 = sys_clock_now_us()
79 let kout: *u8 = sys_mmap(K_MAGIC_4194304)
80 let klen: i64 = ss_build_keys(w, kout)
81 let t2: i64 = sys_clock_now_us()
82 ss_writefile("/tmp/uxfbench.docs\x00" as *u8, w[0] as *u8, w[1])
83 ss_writefile("/tmp/uxfbench.keys\x00" as *u8, kout, klen)
84 let t3: i64 = sys_clock_now_us()
85 let segbytes: i64 = w[1]
86
87 // ---- REOPEN + GET PATH (timed) ----
88 let szp: *i64 = sys_mmap(8) as *i64
89 let idx: *u8 = ss_readall("/tmp/uxfbench.keys\x00" as *u8, szp)
90 let out: *i64 = sys_mmap(16) as *i64
91 var hits: i64 = 0
92 let t4: i64 = sys_clock_now_us()
93 var j: i64 = 0
94 while j < BM {
95 let q: i64 = (j * K_MAGIC_7919) % BN
96 b_key(q, key)
97 if b_get(idx, key, 9, out) >= 0 { hits = hits + 1 }
98 j = j + 1
99 }
100 let t5: i64 = sys_clock_now_us()
101 // negative control: a key that is NOT present must MISS
102 let miss: i64 = b_get(idx, "kZZZZZZZZ\x00" as *u8, 9, out)
103
104 let add_us: i64 = t1 - t0
105 let bld_us: i64 = t2 - t1
106 let wr_us: i64 = t3 - t0
107 let get_us: i64 = t5 - t4
108
109 b_puts("--- MEASURED (Nishi, native clock) ---\n" as *u8)
110 b_puts(" records_written = " as *u8); b_putn(BN); b_puts(" addfail=" as *u8); b_putn(addfail); b_puts("\n" as *u8)
111 b_puts(" segment_bytes_on_disk = " as *u8); b_putn(segbytes); b_puts(" index_bytes=" as *u8); b_putn(klen); b_puts("\n" as *u8)
112 b_puts(" write_us(add+index+fsync) = " as *u8); b_putn(wr_us); b_puts(" (add=" as *u8); b_putn(add_us); b_puts(" index=" as *u8); b_putn(bld_us); b_puts(")\n" as *u8)
113 if wr_us > 0 { b_puts(" write_throughput = " as *u8); b_putn((BN * K_MAGIC_1000000) / wr_us); b_puts(" records/sec\n" as *u8) }
114 b_puts(" point_gets = " as *u8); b_putn(BM); b_puts(" hits=" as *u8); b_putn(hits); b_puts(" total_us=" as *u8); b_putn(get_us); b_puts("\n" as *u8)
115 if get_us > 0 { b_puts(" get_latency = " as *u8); b_putn((get_us * 1000) / BM); b_puts(" ns/op (binary search, zero-copy index)\n" as *u8) }
116
117 b_puts("--- SQLite (BY-DESIGN reference; NOT run -- sqlite3 absent; no fabricated numbers) ---\n" as *u8)
118 b_puts(" insert: B-tree node splits + page rebalancing + WAL write-amplification per row\n" as *u8)
119 b_puts(" query : SQL parse+plan per statement; B-tree descent (no zero-copy; row materialize)\n" as *u8)
120 b_puts(" EXCEED (structural): append-only (no rebalance), one sequential write+rename (no write-amp),\n" as *u8)
121 b_puts(" direct binary search (no SQL parse), mmap zero-copy reads. Content-addressed dedup free.\n" as *u8)
122
123 var pass: i64 = 0
124 var total: i64 = 0
125 total = total + 1; b_puts("T1 all writes accepted: " as *u8); if addfail == 0 { pass = pass + 1; b_puts("PASS\n" as *u8) } else { b_puts("FAIL\n" as *u8) }
126 total = total + 1; b_puts("T2 all gets hit (correctness): " as *u8); if hits == BM { pass = pass + 1; b_puts("PASS\n" as *u8) } else { b_puts("FAIL\n" as *u8) }
127 total = total + 1; b_puts("T3 neg-control absent-key misses: " as *u8); if miss < 0 { pass = pass + 1; b_puts("PASS\n" as *u8) } else { b_puts("FAIL\n" as *u8) }
128 total = total + 1; b_puts("T4 ops were actually timed (>0us): " as *u8); if wr_us > 0 { if get_us > 0 { pass = pass + 1; b_puts("PASS\n" as *u8) } else { b_puts("FAIL\n" as *u8) } } else { b_puts("FAIL\n" as *u8) }
129
130 b_puts("UXF-STORE-BENCH-GATE passed " as *u8); b_putn(pass); b_puts("/" as *u8); b_putn(total)
131 if pass == total { b_puts(" verdict=GREEN\n" as *u8); sys_exit(0); return 0 }
132 b_puts(" verdict=RED\n" as *u8); sys_exit(1); return 1
133}