nx_weblatbench.nx source
↩ module page · 233 lines · 10116 B
1// nx_weblatbench.nx -- STANDING LATENCY BENCH for the WEB serve (operator standing order 2026-08-12:
2// progress claims need a referee that is not the claimant -- until this organ existed, every /search
3// speed number was an ad-hoc probe chosen by the seat that wanted the number to look good).
4// Fixed 8-query set spanning every measured shape, driven through the LIVE serve over LOOPBACK
5// (127.0.0.1:18456 /api/search?scope=web -- the exact production stack; fetch pattern composed from
6// nx_web_relevance_bench). One pass per run, SEQUENTIAL (this bench must never itself hammer the box:
7// envelope = 8 queries/run, beat hourly, log ~200B/run).
8// PRE-DECLARED ACCEPT RULE (before the first run, 2026-08-12; RATCHET DOWN as rungs land, never up):
9// GREEN iff ok=8/8 fetches (HTTP 200 + JSON marker) AND the did-you-mean tooth fires AND
10// p50 <= 3000ms AND max <= 20000ms.
11// WHY these numbers: in-window queries measured 0.25-2.8s on 2026-08-12 (p50 3000 = that + margin);
12// max 20000 deliberately TOLERATES one reopen-lottery draw (measured 10.2-11.5s, debt 1786555686)
13// so the bench reports the tail without being permanently RED -- a detector that is always RED is
14// one everyone learns to ignore. When the incremental-refresh re-lands, ratchet max to 5000.
15// Output: per-query ms ALWAYS printed (a gate that reports only a boolean cannot say why), last line
16// verdict=GREEN|RED (positional anchor), exit code carries the verdict. Appends one row per run to
17// knowledge/status/weblatbench.log (append-only; the DISTRIBUTION over beats is the instrument --
18// a single run is still just a sample and must never be quoted as the population).
19// license_tier: ORIGINAL No hw writes (Rule 26).
20import "nx_syscalls.nx"
21import "nx_connect.nx"
22const LB_MAGIC_1000000: i64 = 1000000
23const LB_MAGIC_8192: i64 = 8192
24
25const LB_PORT: i64 = 18456
26const LB_OUTCAP: i64 = 1048576
27const LB_NQ: i64 = 8
28const LB_P50CAP: i64 = 3000
29const LB_MAXCAP: i64 = 20000
30
31func lb_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
32func lb_wnum(d: *u8, off: i64, v: i64) -> i64 {
33 var o: i64 = off
34 var m: i64 = v
35 if m < 0 { d[o] = 45 as u8; o = o + 1; m = 0 - m }
36 var pw: i64 = 1
37 while m / pw >= 10 { pw = pw * 10 }
38 while pw > 0 { d[o] = (48 + (m / pw) % 10) as u8; o = o + 1; pw = pw / 10 }
39 return o
40}
41func lb_cat(d: *u8, o: i64, s: *u8) -> i64 { var i: i64 = 0; while s[i] != (0 as u8) { d[o + i] = s[i]; i = i + 1 } return o + i }
42func lb_catb(d: *u8, o: i64, s: *u8, n: i64) -> i64 { var i: i64 = 0; while i < n { d[o + i] = s[i]; i = i + 1 } return o + n }
43func lb_hex(v: i64) -> i64 { if v < 10 { return 48 + v } return 55 + v }
44func lb_urlenc(src: *u8, slen: i64, dst: *u8) -> i64 {
45 var o: i64 = 0
46 var i: i64 = 0
47 while i < slen {
48 let c: i64 = src[i] as i64
49 var keep: i64 = 0
50 if c >= 48 { if c <= 57 { keep = 1 } }
51 if c >= 65 { if c <= 90 { keep = 1 } }
52 if c >= 97 { if c <= 122 { keep = 1 } }
53 if c == 45 { keep = 1 } if c == 46 { keep = 1 } if c == 95 { keep = 1 } if c == 126 { keep = 1 } if c == 58 { keep = 1 }
54 if keep == 1 { dst[o] = c as u8; o = o + 1 } else {
55 dst[o] = 37 as u8; o = o + 1
56 dst[o] = lb_hex((c >> 4) & 15) as u8; o = o + 1
57 dst[o] = lb_hex(c & 15) as u8; o = o + 1
58 }
59 i = i + 1
60 }
61 return o
62}
63func lb_contains(hay: *u8, hn: i64, ndl: *u8) -> i64 {
64 let nl: i64 = lb_slen(ndl)
65 if nl == 0 { return 0 }
66 var i: i64 = 0
67 while i + nl <= hn {
68 var m: i64 = 1
69 var j: i64 = 0
70 while j < nl { if hay[i + j] != ndl[j] { m = 0; j = nl } else { j = j + 1 } }
71 if m == 1 { return 1 }
72 i = i + 1
73 }
74 return 0
75}
76func lb_now_us() -> i64 {
77 let ts: *i64 = sys_mmap(16) as *i64
78 sys_clock_gettime_mono(ts as *u8)
79 let sec: i64 = ts[0]
80 let nsec: i64 = ts[1]
81 return sec * LB_MAGIC_1000000 + nsec / 1000
82}
83func lb_wall_epoch() -> i64 {
84 let ts: *i64 = sys_mmap(16) as *i64
85 __syscall(SYS_CLOCK_GETTIME, 0, ts, 0, 0, 0, 0)
86 return ts[0]
87}
88// fetch q through the live serve; returns body length read (0 = fetch failed); resp gets the raw bytes
89func lb_fetch(q: *u8, resp: *u8) -> i64 {
90 let ql: i64 = lb_slen(q)
91 let enc: *u8 = sys_mmap(ql * 3 + 16)
92 let el: i64 = lb_urlenc(q, ql, enc)
93 let req: *u8 = sys_mmap(el + 256)
94 var o: i64 = lb_cat(req, 0, "GET /api/search?scope=web&q=" as *u8)
95 o = lb_catb(req, o, enc, el)
96 o = lb_cat(req, o, "&page=0 HTTP/1.0\r\nHost: nishifamily.com\r\nConnection: close\r\n\r\n" as *u8)
97 let fd: i64 = sys_socket(2, 1, 0)
98 if fd < 0 { return 0 }
99 let sa: *u8 = sys_mmap(16)
100 sa[0] = 2 as u8; sa[1] = 0 as u8
101 sa[2] = ((LB_PORT / 256) & 255) as u8; sa[3] = (LB_PORT & 255) as u8
102 sa[4] = 127 as u8; sa[5] = 0 as u8; sa[6] = 0 as u8; sa[7] = 1 as u8
103 var z: i64 = 8
104 while z < 16 { sa[z] = 0 as u8; z = z + 1 }
105 if nx_connect_bounded(fd, sa, 16, NX_CONN_DEFAULT_MS) < 0 { sys_close(fd); return 0 }
106 var w: i64 = 0
107 while w < o { let x: i64 = sys_write(fd, ((req as i64) + w) as *u8, o - w); if x <= 0 { w = o } else { w = w + x } }
108 var tot: i64 = 0
109 var go: i64 = 1
110 while go == 1 {
111 if tot >= LB_OUTCAP { go = 0 } else {
112 let r: i64 = sys_read(fd, ((resp as i64) + tot) as *u8, LB_OUTCAP - tot)
113 if r <= 0 { go = 0 } else { tot = tot + r }
114 }
115 }
116 sys_close(fd)
117 return tot
118}
119
120func main() -> i64 {
121 let out: *u8 = sys_mmap(LB_MAGIC_8192)
122 var b: i64 = 0
123 b = lb_cat(out, b, "=== nx_weblatbench -- standing latency bench, live web serve loopback :18456 ===\n" as *u8)
124 let resp: *u8 = sys_mmap(LB_OUTCAP)
125 let ms: *i64 = sys_mmap(8 * LB_NQ) as *i64
126 let qs: *i64 = sys_mmap(8 * LB_NQ) as *i64
127 qs[0] = ("zzqxlatbenchabsent" as *u8) as i64
128 qs[1] = ("nishi" as *u8) as i64
129 qs[2] = ("quantum" as *u8) as i64
130 qs[3] = ("cryptocurrency" as *u8) as i64
131 qs[4] = ("climate change mitigation" as *u8) as i64
132 qs[5] = ("renewable energy storage" as *u8) as i64
133 qs[6] = ("quantum site:nsf.gov" as *u8) as i64
134 qs[7] = ("quantumm physxics" as *u8) as i64
135 var okn: i64 = 0
136 var dym: i64 = 0
137 var i: i64 = 0
138 while i < LB_NQ {
139 let t0: i64 = lb_now_us()
140 let n: i64 = lb_fetch(qs[i] as *u8, resp)
141 let t1: i64 = lb_now_us()
142 var m: i64 = (t1 - t0) / 1000
143 var ok: i64 = 0
144 if n > 0 { if lb_contains(resp, n, "\"v\":1" as *u8) == 1 { ok = 1 } }
145 if ok == 0 { m = 0 - 1 } else { okn = okn + 1 }
146 // STANDING TOOTH: the 2026-08-12 dss_correct first-char run bound must keep correcting.
147 // A bound that skips everything is indistinguishable from a fast fix until this fires.
148 if i == 7 { if ok == 1 { if lb_contains(resp, n, "did_you_mean" as *u8) == 1 { dym = 1 } } }
149 ms[i] = m
150 b = lb_cat(out, b, " q" as *u8)
151 b = lb_wnum(out, b, i)
152 b = lb_cat(out, b, " [" as *u8)
153 b = lb_cat(out, b, qs[i] as *u8)
154 b = lb_cat(out, b, "] ms=" as *u8)
155 b = lb_wnum(out, b, m)
156 b = lb_cat(out, b, "\n" as *u8)
157 i = i + 1
158 }
159 // sorted copy -> p50 (upper median of 8) + max; failed fetches (-1) sort low and cannot flatter
160 let sr: *i64 = sys_mmap(8 * LB_NQ) as *i64
161 i = 0
162 while i < LB_NQ { sr[i] = ms[i]; i = i + 1 }
163 var a: i64 = 1
164 while a < LB_NQ {
165 let kv: i64 = sr[a]
166 var j2: i64 = a - 1
167 var mv: i64 = 1
168 while mv == 1 {
169 if j2 >= 0 { if sr[j2] > kv { sr[j2 + 1] = sr[j2]; j2 = j2 - 1 } else { mv = 0 } } else { mv = 0 }
170 }
171 sr[j2 + 1] = kv
172 a = a + 1
173 }
174 let p50: i64 = sr[4]
175 let mx: i64 = sr[LB_NQ - 1]
176 var verdict: i64 = 1
177 if okn < LB_NQ { verdict = 0 }
178 if dym == 0 { verdict = 0 }
179 if p50 > LB_P50CAP { verdict = 0 }
180 if mx > LB_MAXCAP { verdict = 0 }
181 b = lb_cat(out, b, "ok=" as *u8)
182 b = lb_wnum(out, b, okn)
183 b = lb_cat(out, b, "/8 dym_tooth=" as *u8)
184 b = lb_wnum(out, b, dym)
185 b = lb_cat(out, b, " p50_ms=" as *u8)
186 b = lb_wnum(out, b, p50)
187 b = lb_cat(out, b, " max_ms=" as *u8)
188 b = lb_wnum(out, b, mx)
189 b = lb_cat(out, b, " caps: p50<=" as *u8)
190 b = lb_wnum(out, b, LB_P50CAP)
191 b = lb_cat(out, b, " max<=" as *u8)
192 b = lb_wnum(out, b, LB_MAXCAP)
193 b = lb_cat(out, b, "\n" as *u8)
194 // append ONE compact row to the published log (the distribution over beats is the instrument)
195 let row: *u8 = sys_mmap(512)
196 var ro: i64 = 0
197 ro = lb_cat(row, ro, "epoch=" as *u8)
198 ro = lb_wnum(row, ro, lb_wall_epoch())
199 ro = lb_cat(row, ro, " ms=" as *u8)
200 i = 0
201 while i < LB_NQ {
202 if i > 0 { ro = lb_cat(row, ro, "," as *u8) }
203 ro = lb_wnum(row, ro, ms[i])
204 i = i + 1
205 }
206 ro = lb_cat(row, ro, " ok=" as *u8)
207 ro = lb_wnum(row, ro, okn)
208 ro = lb_cat(row, ro, " dym=" as *u8)
209 ro = lb_wnum(row, ro, dym)
210 ro = lb_cat(row, ro, " p50=" as *u8)
211 ro = lb_wnum(row, ro, p50)
212 ro = lb_cat(row, ro, " max=" as *u8)
213 ro = lb_wnum(row, ro, mx)
214 ro = lb_cat(row, ro, " verdict=" as *u8)
215 if verdict == 1 { ro = lb_cat(row, ro, "GREEN" as *u8) } else { ro = lb_cat(row, ro, "RED" as *u8) }
216 row[ro] = 10 as u8
217 ro = ro + 1
218 let lfd: i64 = __syscall(SYS_OPENAT, AT_FDCWD, "knowledge/status/weblatbench.log" as *u8, O_WRONLY_CA, 420, 0, 0)
219 if lfd >= 0 {
220 var lw: i64 = 0
221 while lw < ro { let lx: i64 = sys_write(lfd, ((row as i64) + lw) as *u8, ro - lw); if lx <= 0 { lw = ro } else { lw = lw + lx } }
222 sys_close(lfd)
223 b = lb_cat(out, b, "log: appended to knowledge/status/weblatbench.log\n" as *u8)
224 } else {
225 b = lb_cat(out, b, "log: APPEND FAILED (fd err) -- run row printed above only\n" as *u8)
226 }
227 b = lb_cat(out, b, "verdict=" as *u8)
228 if verdict == 1 { b = lb_cat(out, b, "GREEN" as *u8) } else { b = lb_cat(out, b, "RED" as *u8) }
229 b = lb_cat(out, b, "\n" as *u8)
230 sys_write(1, out, b)
231 if verdict == 1 { return 0 }
232 return 1
233}