code wiki / _hdl_build / nx_race_sov_worker.nx
nx_race_sov_worker.nx source
↩ module page · 184 lines · 6629 B
1// nx_race_sov_worker.nx -- the SOVEREIGN LANE of the IM6 beat-sqlite race.
2// Does the exact same logical storage work the competitor lane does, and
3// self-times ONLY the storage-engine work (parse excluded on both lanes):
4// write <prefix>: bulk-load the unique census records -> one committed
5// segment (fsync'd, indexed) -> SOVW us= count=
6// read <prefix>: keyed lookup of every record via the binary-search
7// index path, verifying each is found -> SOVR us= count=
8// The orchestrator (nx_infomgmt_race) compares these numbers against the
9// sqlite lane's self-timed numbers. license_tier: ORIGINAL
10
11import "nx_syscalls.nx"
12import "nx_itoa_lib.nx" // shared MSB-first emitter (zero-alloc)
13import "nx_canon_cid.nx"
14import "nx_seg_store.nx"
15const K_MAGIC_1000000000: i64 = 1000000000
16const K_MAGIC_2048: i64 = 2048
17const K_MAGIC_1024: i64 = 1024
18
19func rw_p(s: *u8) -> i64 {
20 var n: i64 = 0
21 while s[n] != (0 as u8) { n = n + 1 }
22 sys_write(1, s, n)
23 return 0
24}
25
26// MIGRATED to the shared emitter (debt 1785563586). The old body mmapped a scratch buffer
27// per call and never freed it. At PAGE granularity that is 4096B leaked PER CALL -- the
28// defect that took 28.5GB of a 36GB host in nx_ts_lumadiff (2MB input, ~3.66M calls).
29// nxi_* is MSB-first, allocates NOTHING, and emits identical bytes including the sign.
30func rw_pn(v: i64) -> i64 { nxi_out(v); return 0 }
31
32func rw_starts(b: *u8, off: i64, lim: i64, s: *u8) -> i64 {
33 var i: i64 = 0
34 while s[i] != (0 as u8) {
35 if off + i >= lim { return 0 - 1 }
36 if b[off + i] != s[i] { return 0 - 1 }
37 i = i + 1
38 }
39 return i
40}
41
42func rw_streq(a: *u8, b: *u8) -> i64 {
43 var i: i64 = 0
44 while 1 == 1 {
45 if a[i] != b[i] { return 0 }
46 if a[i] == (0 as u8) { return 1 }
47 i = i + 1
48 }
49 return 0
50}
51
52// parse census into parallel arrays of (storekey ptr, canonical-enc ptr, enc len);
53// in-file duplicates collapsed; returns unique count. OUTSIDE the timer.
54func rw_parse(kout: *i64, eout: *i64, lout: *i64) -> i64 {
55 let szp: *i64 = sys_mmap(16) as *i64
56 let b: *u8 = ss_readall("knowledge/status/elder_census.log" as *u8, szp)
57 let sz: i64 = szp[0]
58 if sz <= 0 { return 0 - 1 }
59 let keys: *i64 = sys_mmap(8 * 4) as *i64
60 let vals: *i64 = sys_mmap(8 * 4) as *i64
61 keys[0] = "kind" as *u8 as i64
62 keys[1] = "name" as *u8 as i64
63 keys[2] = "class" as *u8 as i64
64 vals[0] = "elder-service" as *u8 as i64
65 var cnt: i64 = 0
66 var i: i64 = 0
67 while i < sz {
68 var e: i64 = i
69 while e < sz {
70 if b[e] == (10 as u8) { e = e + K_MAGIC_1000000000 } else { e = e + 1 }
71 }
72 var lend: i64 = e
73 if e >= K_MAGIC_1000000000 { lend = e - K_MAGIC_1000000000 }
74 let m: i64 = rw_starts(b, i, lend, "CENSUS-SVC name=" as *u8)
75 if m > 0 {
76 var p: i64 = i + m
77 let name: *u8 = sys_mmap(160)
78 var t: i64 = 0
79 var go2: i64 = 1
80 while go2 == 1 {
81 if p >= lend { go2 = 0 }
82 if go2 == 1 {
83 if b[p] == (32 as u8) { p = p + 1; go2 = 0 } else {
84 if t < 150 { name[t] = b[p]; t = t + 1 }
85 p = p + 1
86 }
87 }
88 }
89 name[t] = 0 as u8
90 let m2: i64 = rw_starts(b, p, lend, "class=" as *u8)
91 let cls: *u8 = sys_mmap(64)
92 var c: i64 = 0
93 if m2 > 0 {
94 var p2: i64 = p + m2
95 while p2 < lend {
96 if c < 60 { cls[c] = b[p2]; c = c + 1 }
97 p2 = p2 + 1
98 }
99 }
100 cls[c] = 0 as u8
101 if t > 0 { if c > 0 {
102 var dup: i64 = 0
103 var si: i64 = 0
104 while si < cnt {
105 if dup == 0 {
106 let sk: *u8 = kout[si] as *u8
107 // stored key = "svc:" + name; compare past the 4-byte prefix
108 if rw_streq((sk as i64 + 4) as *u8, name) == 1 { dup = 1 }
109 }
110 si = si + 1
111 }
112 if dup == 0 { if cnt < 1000 {
113 vals[1] = name as i64
114 vals[2] = cls as i64
115 let enc: *u8 = sys_mmap(K_MAGIC_2048)
116 let el: i64 = canon_encode(keys, vals, 3, enc)
117 let kbuf: *u8 = sys_mmap(192)
118 var ko: i64 = 0
119 ko = ss_cat(kbuf, ko, "svc:" as *u8)
120 ko = ss_cat(kbuf, ko, name)
121 kbuf[ko] = 0 as u8
122 kout[cnt] = kbuf as i64
123 eout[cnt] = enc as i64
124 lout[cnt] = el
125 cnt = cnt + 1
126 } }
127 } }
128 }
129 i = lend + 1
130 }
131 return cnt
132}
133
134func main(argc: i64, argv: *i64) -> i64 {
135 if argc < 3 {
136 rw_p("usage: nx_race_sov_worker <write|read> <store-prefix>\n" as *u8)
137 return 2
138 }
139 let mode: *u8 = argv[1] as *u8
140 let prefix: *u8 = argv[2] as *u8
141 let kout: *i64 = sys_mmap(8 * K_MAGIC_1024) as *i64
142 let eout: *i64 = sys_mmap(8 * K_MAGIC_1024) as *i64
143 let lout: *i64 = sys_mmap(8 * K_MAGIC_1024) as *i64
144 let n: i64 = rw_parse(kout, eout, lout)
145 if n <= 0 { rw_p("SOV parse FAILED\n" as *u8); return 1 }
146
147 if rw_streq(mode, "write" as *u8) == 1 {
148 let t0: i64 = sys_now_us()
149 let w: *i64 = ss_begin()
150 var i: i64 = 0
151 while i < n {
152 ss_add(w, 1, kout[i] as *u8, eout[i] as *u8, lout[i])
153 i = i + 1
154 }
155 if ss_commit(prefix, w, 1) != 0 { rw_p("SOV commit FAILED\n" as *u8); return 1 }
156 let t1: i64 = sys_now_us()
157 rw_p("SOVW us=" as *u8)
158 rw_pn(t1 - t0)
159 rw_p(" count=" as *u8)
160 rw_pn(n)
161 rw_p("\n" as *u8)
162 return 0
163 }
164 // open-store handle INSIDE the timer (the sqlite lane times its connect
165 // too -- open once, then in-memory binary-search lookups, zero per-call IO)
166 let pp: *i64 = sys_mmap(16) as *i64
167 let ll: *i64 = sys_mmap(16) as *i64
168 let t0: i64 = sys_now_us()
169 let h: *i64 = ss_open(prefix)
170 var got: i64 = 0
171 var i: i64 = 0
172 while i < n {
173 let g: i64 = ss_hget(h, kout[i] as *u8, pp, ll)
174 if g == 1 { got = got + 1 }
175 i = i + 1
176 }
177 let t1: i64 = sys_now_us()
178 rw_p("SOVR us=" as *u8)
179 rw_pn(t1 - t0)
180 rw_p(" count=" as *u8)
181 rw_pn(got)
182 rw_p("\n" as *u8)
183 return 0
184}