nx_lang_h2h.nx source
↩ module page · 659 lines · 32169 B
1// nx_lang_h2h.nx -- THE HEAD-TO-HEAD COMPILER BENCHMARK, SOVEREIGN AND RECEIPTED (2026-09-01).
2// Operator: "nishi lang to get to sota and best of breed and to meet and exceed gcc and rust ... independently
3// verified with evidence documented and our /compare properly storing and making the evidence reproducible".
4// This retires bench/nx_lang_h2h.sh -- shell that built, timed, parsed and judged, the forbidden shape. It builds
5// every arm from source, runs each arm N times, requires every arm to print the SAME checksum, and writes ONE
6// receipt (<out>, the <dom>.bench data class) carrying: host, CPU and kernel; every toolchain's version; every
7// source and binary sha256; min and median microseconds; the checksum; the exact repro command; and a verdict
8// derived by nx_bench_receipt_lib -- the SAME classifier the /compare page and the gate run. Nothing is judged
9// here: an arm whose toolchain is absent is UNMEASURABLE (declared), never dropped; an arm whose checksum
10// differs is VOID (its time is never ranked); a build or run failure names its exit code.
11// The child runner is deliberately NOT tr_run_capture: that primitive merges stderr into the capture (a compiler
12// warning would land inside an emitted .s) and fixes envp to PATH alone (the rustup shim needs HOME, go needs a
13// writable GOCACHE). Same fork/pipe/drain shape, stdout only, envp from the conf -- a different contract, named.
14// usage: nx_lang_h2h <conf> conf keys (line-anchored, nx_lineconf_lib, a missing required key REFUSES):
15// dom= title= workload= home= runs= workdir= srcdir= ref= out= nxcc= nxasm= nxsrc= [gcc=] [clang=] [rustc=] [go=]
16// exit: 0 VALID . 1 VOID (an arm disagrees on the checksum) . 2 usage or conf refusal . 3 UNMEASURABLE (the
17// reference arm or the NishiLang arm could not be measured -- no ratio exists)
18// license_tier: ORIGINAL No hw writes (Rule 26).
19import "nx_syscalls.nx"
20import "nx_lineconf_lib.nx"
21import "nx_sha256.nx"
22import "nx_bench_receipt_lib.nx"
23
24const H2_PATH: i64 = 1024
25const H2_CAP_OUT: i64 = 1048576 // one captured child stdout: a whole emitted .s measured 135 KB, this holds 7x and ANNOUNCES a brim
26const H2_CAP_PROC: i64 = 262144 // /proc/cpuinfo on a 16-way host measured about 20 KB; a brim is announced, never silent
27const H2_CAP_RECEIPT: i64 = 65536
28const H2_ARGV_SLOTS: i64 = 16
29const H2_ENV_SLOTS: i64 = 8
30const H2_WORD: i64 = 8
31const H2_HEX: i64 = 72
32const H2_VER: i64 = 512
33const H2_NOTE: i64 = 512
34const H2_RUNS_MIN: i64 = 3
35const H2_RUNS_MAX: i64 = 64
36const H2_ARMS_FIXED: i64 = 5
37const H2_ARM_NX: i64 = 4
38const H2_MODE_MAX: i64 = 12
39const H2_FLAG_MAX: i64 = 16
40const H2_MODE_KEY: *u8 = "nxmode_"
41const H2_MODE_KEY_LEN: i64 = 7
42const H2_MODE_RWX: i64 = 493
43const H2_MODE_RW: i64 = 420
44const H2_EXIT_VALID: i64 = 0
45const H2_EXIT_VOID: i64 = 1
46const H2_EXIT_USAGE: i64 = 2
47const H2_EXIT_UNMEASURABLE: i64 = 3
48const H2_SHA_BYTES: i64 = 32
49const H2_CHILD_FD_MAX: i64 = 256
50const H2_EINTR: i64 = 0 - 4
51const H2_EINTR_MAX: i64 = 4096
52const H2_ERR_PIPE: i64 = 0 - 2
53const H2_ERR_FORK: i64 = 0 - 3
54const H2_ERR_WAIT: i64 = 0 - 4
55const H2_ERR_WRITE: i64 = 0 - 7
56const H2_ERR_BRIM: i64 = 0 - 8
57const H2_ERR_EMPTY: i64 = 0 - 9
58const H2_EXEC_FAIL: i64 = 127
59const H2_NL: i64 = 10
60const H2_SP: i64 = 32
61const H2_ZERO: i64 = 48
62const H2_NINE: i64 = 57
63const H2_MINUS: i64 = 45
64const H2_COLON: i64 = 58
65const H2_SLASH: i64 = 47
66const H2_PIPE: i64 = 124
67const H2_KEY_ELAPSED: *u8 = "elapsed_us="
68const H2_KEY_CHECKSUM: *u8 = "checksum="
69const H2_DEVNULL: *u8 = "/dev/null"
70const H2_ENV_PATH: *u8 = "PATH=/usr/bin:/bin:/usr/local/bin"
71const H2_ENV_GOTOOLCHAIN: *u8 = "GOTOOLCHAIN=local"
72const H2_PROC_CPUINFO: *u8 = "/proc/cpuinfo"
73const H2_PROC_HOSTNAME: *u8 = "/proc/sys/kernel/hostname"
74const H2_PROC_OSRELEASE: *u8 = "/proc/sys/kernel/osrelease"
75const H2_WRITER: *u8 = "nx_lang_h2h"
76
77func h2_puts(s: *u8) -> i64 { sys_write(1, s, br_slen(s)); return 0 }
78func h2_putn(v: i64) -> i64 { let t: *u8 = sys_mmap(32); let n: i64 = br_catn(t, 0, v); sys_write(1, t, n); return 0 }
79// first offset of needle in buf[0..n), or -1
80func h2_find(buf: *u8, n: i64, needle: *u8) -> i64 {
81 let m: i64 = br_slen(needle)
82 if m == 0 { return 0 - 1 }
83 var i: i64 = 0
84 while i + m <= n {
85 var j: i64 = 0
86 var ok: i64 = 1
87 while j < m { if buf[i + j] != needle[j] { ok = 0; j = m } else { j = j + 1 } }
88 if ok == 1 { return i }
89 i = i + 1
90 }
91 return 0 - 1
92}
93// the number at buf[at..n): optional minus then digits; found[0]=1 when at least one digit was read
94func h2_num_at(buf: *u8, n: i64, at: i64, found: *i64) -> i64 {
95 var i: i64 = at
96 var neg: i64 = 0
97 found[0] = 0
98 if i < n { if (buf[i] as i64) == H2_MINUS { neg = 1; i = i + 1 } }
99 var v: i64 = 0
100 while i < n {
101 let c: i64 = buf[i] as i64
102 if c < H2_ZERO { break }
103 if c > H2_NINE { break }
104 v = v * 10 + (c - H2_ZERO)
105 found[0] = 1
106 i = i + 1
107 }
108 if neg == 1 { return 0 - v }
109 return v
110}
111// the value after key in buf; found[0] reports whether the key and a number were both there
112func h2_num_after(buf: *u8, n: i64, key: *u8, found: *i64) -> i64 {
113 let at: i64 = h2_find(buf, n, key)
114 if at < 0 { found[0] = 0; return 0 }
115 return h2_num_at(buf, n, at + br_slen(key), found)
116}
117// first line of src[0..n) into dst (cap incl NUL); pipes are replaced by a space so the line can sit in a receipt field
118func h2_first_line(src: *u8, n: i64, dst: *u8, cap: i64) -> i64 {
119 var i: i64 = 0
120 var o: i64 = 0
121 while i < n {
122 let c: i64 = src[i] as i64
123 if c == H2_NL { break }
124 if c == 13 { break }
125 if o < cap - 1 { if c == H2_PIPE { dst[o] = H2_SP as u8 } else { dst[o] = c as u8 } o = o + 1 }
126 i = i + 1
127 }
128 dst[o] = 0 as u8
129 return o
130}
131func h2_hexdigit(v: i64) -> i64 { if v < 10 { return H2_ZERO + v } return 97 + (v - 10) }
132func h2_hex(dst: *u8, off: i64, bytes: *u8, nb: i64) -> i64 {
133 var o: i64 = off
134 var i: i64 = 0
135 while i < nb {
136 let b: i64 = bytes[i] as i64
137 dst[o] = h2_hexdigit(b / 16) as u8
138 dst[o + 1] = h2_hexdigit(b % 16) as u8
139 o = o + 2
140 i = i + 1
141 }
142 dst[o] = 0 as u8
143 return o
144}
145// open + read loop: /proc files report no size, so sys_read_file cannot size them
146func h2_read_small(path: *u8, buf: *u8, cap: i64) -> i64 {
147 let fd: i64 = sys_openat_rd(path)
148 if fd < 0 { return 0 - 1 }
149 var tot: i64 = 0
150 var go: i64 = 1
151 while go == 1 {
152 if tot >= cap { go = 0 } else {
153 let r: i64 = sys_read(fd, ((buf as i64) + tot) as *u8, cap - tot)
154 if r > 0 { tot = tot + r } else { go = 0 }
155 }
156 }
157 sys_close(fd)
158 if tot < cap { buf[tot] = 0 as u8 }
159 return tot
160}
161// sha256 of a whole file as hex; returns the byte count, or -1 when unreadable
162func h2_file_sha(path: *u8, hexout: *u8) -> i64 {
163 let ln: *i64 = sys_mmap(H2_WORD * 2) as *i64
164 let b: *u8 = sys_read_file(path, ln)
165 if (b as i64) == 0 { hexout[0] = 45 as u8; hexout[1] = 0 as u8; return 0 - 1 }
166 let n: i64 = ln[0]
167 let dg: *u8 = sys_mmap(H2_SHA_BYTES + 8)
168 sha256_digest(b, n, dg)
169 h2_hex(hexout, 0, dg, H2_SHA_BYTES)
170 sys_free_file(b, n)
171 return n
172}
173// the value after "<key>\t: " on the first line of buf that starts with key; 0 when absent
174func h2_proc_value(buf: *u8, n: i64, key: *u8, dst: *u8, cap: i64) -> i64 {
175 let kl: i64 = br_slen(key)
176 var i: i64 = 0
177 while i < n {
178 var bol: i64 = 0
179 if i == 0 { bol = 1 } else { if (buf[i - 1] as i64) == H2_NL { bol = 1 } }
180 if bol == 1 { if i + kl < n {
181 var same: i64 = 1
182 var k: i64 = 0
183 while k < kl { if buf[i + k] != key[k] { same = 0; k = kl } else { k = k + 1 } }
184 if same == 1 {
185 var p: i64 = i + kl
186 while p < n { if (buf[p] as i64) == H2_COLON { break } if (buf[p] as i64) == H2_NL { break } p = p + 1 }
187 if p < n { if (buf[p] as i64) == H2_COLON {
188 p = p + 1
189 while p < n { if (buf[p] as i64) == H2_SP { p = p + 1 } else { break } }
190 var e: i64 = p
191 while e < n { if (buf[e] as i64) == H2_NL { break } e = e + 1 }
192 var o: i64 = 0
193 var q: i64 = p
194 while q < e { if o < cap - 1 { if (buf[q] as i64) == H2_PIPE { dst[o] = H2_SP as u8 } else { dst[o] = buf[q] } o = o + 1 } q = q + 1 }
195 dst[o] = 0 as u8
196 return o
197 } }
198 }
199 } }
200 i = i + 1
201 }
202 dst[0] = 0 as u8
203 return 0
204}
205func h2_count_lines_starting(buf: *u8, n: i64, pfx: *u8) -> i64 {
206 let pl: i64 = br_slen(pfx)
207 var c: i64 = 0
208 var i: i64 = 0
209 while i < n {
210 var bol: i64 = 0
211 if i == 0 { bol = 1 } else { if (buf[i - 1] as i64) == H2_NL { bol = 1 } }
212 if bol == 1 { if i + pl <= n {
213 var same: i64 = 1
214 var k: i64 = 0
215 while k < pl { if buf[i + k] != pfx[k] { same = 0; k = pl } else { k = k + 1 } }
216 if same == 1 { c = c + 1 }
217 } }
218 i = i + 1
219 }
220 return c
221}
222// fork + exec with stdout captured into out (cap bytes), stderr to /dev/null, envp from the caller.
223// Returns the child's exit code, or a negative harness sentinel; outlen[0] = captured bytes.
224func h2_run(path: *u8, argv: *i64, envp: *i64, out: *u8, cap: i64, outlen: *i64) -> i64 {
225 outlen[0] = 0
226 let fds: *i64 = sys_mmap(16) as *i64
227 if sys_pipe2(fds, 0) != 0 { return H2_ERR_PIPE }
228 let packed: i64 = fds[0]
229 let rfd: i64 = packed & 0xFFFFFFFF
230 let wfd: i64 = (packed >> 32) & 0xFFFFFFFF
231 let pid: i64 = sys_fork()
232 if pid < 0 { sys_close(rfd); sys_close(wfd); return H2_ERR_FORK }
233 if pid == 0 {
234 sys_dup3(wfd, 1, 0)
235 let dn: i64 = sys_openat_wr(H2_DEVNULL, H2_MODE_RW)
236 if dn >= 0 { sys_dup3(dn, 2, 0) }
237 sys_close(rfd)
238 sys_close(wfd)
239 var fdc: i64 = 3
240 while fdc < H2_CHILD_FD_MAX { sys_close(fdc); fdc = fdc + 1 }
241 sys_execve_clean(path, argv, envp)
242 sys_exit(H2_EXEC_FAIL)
243 return 0
244 }
245 sys_close(wfd)
246 var total: i64 = 0
247 var run: i64 = 1
248 var eintr: i64 = 0
249 while run == 1 {
250 if total >= cap { run = 0 } else {
251 let r: i64 = sys_read(rfd, ((out as i64) + total) as *u8, cap - total)
252 if r > 0 { total = total + r } else {
253 if r == 0 { run = 0 } else {
254 if r == H2_EINTR { if eintr > H2_EINTR_MAX { run = 0 } else { eintr = eintr + 1 } } else { run = 0 }
255 }
256 }
257 }
258 }
259 sys_close(rfd)
260 outlen[0] = total
261 let stp: *i64 = sys_mmap(16) as *i64
262 let w: i64 = sys_wait4(pid, stp, 0)
263 if w < 0 { return H2_ERR_WAIT }
264 return wait_exit_code(stp[0])
265}
266// insertion sort, ascending, in place
267func h2_sort(a: *i64, n: i64) -> i64 {
268 var i: i64 = 1
269 while i < n {
270 let v: i64 = a[i]
271 var j: i64 = i - 1
272 var go: i64 = 1
273 while go == 1 {
274 if j < 0 { go = 0 } else { if a[j] > v { a[j + 1] = a[j]; j = j - 1 } else { go = 0 } }
275 }
276 a[j + 1] = v
277 i = i + 1
278 }
279 return 0
280}
281// tmp + fsync-free rename: the reader never sees a half-written receipt
282func h2_write_atomic(path: *u8, buf: *u8, n: i64) -> i64 {
283 let tmp: *u8 = sys_mmap(H2_PATH)
284 var o: i64 = br_cat(tmp, 0, path)
285 o = br_cat(tmp, o, ".new" as *u8)
286 let fd: i64 = sys_openat_wr(tmp, H2_MODE_RW)
287 if fd < 0 { return 0 - 1 }
288 var off: i64 = 0
289 while off < n { let r: i64 = sys_write(fd, (buf as i64 + off) as *u8, n - off); if r <= 0 { sys_close(fd); return 0 - 2 } off = off + r }
290 sys_close(fd)
291 if sys_renameat(tmp, path) != 0 { return 0 - 3 }
292 return 0
293}
294// ---- THE ARMS. Structural facts about the compilers under test; their PATHS come from the conf. ----
295func h2_arm_name(i: i64) -> *u8 {
296 if i == 0 { return "c-gcc-O2" as *u8 }
297 if i == 1 { return "c-clang-O2" as *u8 }
298 if i == 2 { return "rust-O-checked" as *u8 }
299 if i == 3 { return "go-build" as *u8 }
300 return "nishilang-default" as *u8
301}
302func h2_arm_key(i: i64) -> *u8 {
303 if i == 0 { return "gcc" as *u8 }
304 if i == 1 { return "clang" as *u8 }
305 if i == 2 { return "rustc" as *u8 }
306 if i == 3 { return "go" as *u8 }
307 return "nxcc" as *u8
308}
309func h2_arm_tool(i: i64) -> *u8 {
310 if i == 0 { return "gcc -O2 (bounds unchecked by the language)" as *u8 }
311 if i == 1 { return "clang -O2 (bounds unchecked by the language)" as *u8 }
312 if i == 2 { return "rustc -O (indexing with [] keeps the bounds checks in play)" as *u8 }
313 if i == 3 { return "go build (bounds checked by the language)" as *u8 }
314 return "nx_cc_sovereign + nxasm_x86_main (default build, typed-array bounds checks LIVE)" as *u8
315}
316func h2_arm_srcfile(i: i64) -> *u8 {
317 if i == 0 { return "perf.c" as *u8 }
318 if i == 1 { return "perf.c" as *u8 }
319 if i == 2 { return "perf.rs" as *u8 }
320 return "perf.go" as *u8
321}
322// build one arm into bin; 0 = built
323func h2_build(i: i64, tool: *u8, src: *u8, bin: *u8, nxasm: *u8, envp: *i64, out: *u8, cap: i64) -> i64 {
324 let av: *i64 = sys_mmap(H2_ARGV_SLOTS * H2_WORD) as *i64
325 let ol: *i64 = sys_mmap(16) as *i64
326 if i == H2_ARM_NX {
327 av[0] = tool as i64; av[1] = src as i64; av[2] = 0
328 let rc: i64 = h2_run(tool, av, envp, out, cap, ol)
329 if rc != 0 { return rc }
330 if ol[0] <= 0 { return H2_ERR_EMPTY }
331 if ol[0] >= cap { return H2_ERR_BRIM }
332 let spath: *u8 = sys_mmap(H2_PATH)
333 var o: i64 = br_cat(spath, 0, bin)
334 o = br_cat(spath, o, ".s" as *u8)
335 if h2_write_atomic(spath, out, ol[0]) != 0 { return H2_ERR_WRITE }
336 av[0] = nxasm as i64; av[1] = spath as i64; av[2] = bin as i64; av[3] = 0
337 let rc2: i64 = h2_run(nxasm, av, envp, out, cap, ol)
338 if rc2 != 0 { return rc2 }
339 sys_fchmodat(bin, H2_MODE_RWX)
340 return 0
341 }
342 av[0] = tool as i64
343 if i == 3 {
344 av[1] = ("build" as *u8) as i64; av[2] = ("-o" as *u8) as i64; av[3] = bin as i64; av[4] = src as i64; av[5] = 0
345 } else {
346 if i == 2 { av[1] = ("-O" as *u8) as i64 } else { av[1] = ("-O2" as *u8) as i64 }
347 av[2] = ("-o" as *u8) as i64; av[3] = bin as i64; av[4] = src as i64; av[5] = 0
348 }
349 return h2_run(tool, av, envp, out, cap, ol)
350}
351// NishiLang under a declared MODE: the compiler receives the mode's flag tokens BEFORE the source
352// (the driver binds flags in any position since 2026-08-25, and the mode bundle itself is expanded
353// by the driver from knowledge/lang_modes.conf -- this organ passes `--mode=<name>` through verbatim,
354// so the receipt measures exactly the bundle the conf declares and never a private copy of it).
355func h2_build_nx_mode(tool: *u8, mode: *u8, src: *u8, bin: *u8, nxasm: *u8, envp: *i64, out: *u8, cap: i64) -> i64 {
356 let av: *i64 = sys_mmap(H2_ARGV_SLOTS * H2_WORD) as *i64
357 let ol: *i64 = sys_mmap(16) as *i64
358 let mflag: *u8 = sys_mmap(H2_VER)
359 var mo: i64 = br_cat(mflag, 0, "--mode=" as *u8); br_cat(mflag, mo, mode)
360 av[0] = tool as i64; av[1] = mflag as i64; av[2] = src as i64; av[3] = 0
361 let rc: i64 = h2_run(tool, av, envp, out, cap, ol)
362 if rc != 0 { return rc }
363 if ol[0] <= 0 { return H2_ERR_EMPTY }
364 if ol[0] >= cap { return H2_ERR_BRIM }
365 let spath: *u8 = sys_mmap(H2_PATH)
366 var o: i64 = br_cat(spath, 0, bin)
367 o = br_cat(spath, o, ".s" as *u8)
368 if h2_write_atomic(spath, out, ol[0]) != 0 { return H2_ERR_WRITE }
369 av[0] = nxasm as i64; av[1] = spath as i64; av[2] = bin as i64; av[3] = 0
370 let rc2: i64 = h2_run(nxasm, av, envp, out, cap, ol)
371 if rc2 != 0 { return rc2 }
372 sys_fchmodat(bin, H2_MODE_RWX)
373 return 0
374}
375// the toolchain's own version line (go says `go version`, everyone else --version)
376func h2_version(i: i64, tool: *u8, envp: *i64, out: *u8, cap: i64, dst: *u8, dcap: i64) -> i64 {
377 let av: *i64 = sys_mmap(H2_ARGV_SLOTS * H2_WORD) as *i64
378 let ol: *i64 = sys_mmap(16) as *i64
379 av[0] = tool as i64
380 if i == 3 { av[1] = ("version" as *u8) as i64 } else { av[1] = ("--version" as *u8) as i64 }
381 av[2] = 0
382 let rc: i64 = h2_run(tool, av, envp, out, cap, ol)
383 if rc != 0 { br_cat(dst, 0, "version query failed" as *u8); return rc }
384 h2_first_line(out, ol[0], dst, dcap)
385 return 0
386}
387func h2_refuse(key: *u8, conf: *u8) -> i64 {
388 h2_puts("NX-LANG-H2H REFUSED: required conf key " as *u8); h2_puts(key); h2_puts("= is absent from " as *u8); h2_puts(conf)
389 h2_puts(" -- a benchmark with a guessed toolchain path or workload is not reproducible; declare it\n" as *u8)
390 sys_exit(H2_EXIT_USAGE)
391 return H2_EXIT_USAGE
392}
393func h2_conf_str(cb: *u8, cn: i64, key: *u8, conf: *u8) -> *u8 {
394 let v: *u8 = sys_mmap(H2_PATH)
395 if lcf_str(cb, cn, key, v, H2_PATH) < 0 { h2_refuse(key, conf) }
396 return v
397}
398
399func main(argc: i64, argv: *i64) -> i64 {
400 if argc < 2 {
401 h2_puts("usage: nx_lang_h2h <conf> (keys: dom title workload home runs workdir srcdir ref out nxcc nxasm nxsrc [gcc clang rustc go])\n" as *u8)
402 sys_exit(H2_EXIT_USAGE); return H2_EXIT_USAGE
403 }
404 let conf: *u8 = argv[1] as *u8
405 let cl: *i64 = sys_mmap(H2_WORD * 2) as *i64
406 let cb: *u8 = sys_read_file(conf, cl)
407 if (cb as i64) == 0 { h2_puts("NX-LANG-H2H REFUSED: conf unreadable: " as *u8); h2_puts(conf); h2_puts("\n" as *u8); sys_exit(H2_EXIT_USAGE); return H2_EXIT_USAGE }
408 let cn: i64 = cl[0]
409 let dom: *u8 = h2_conf_str(cb, cn, "dom" as *u8, conf)
410 let title: *u8 = h2_conf_str(cb, cn, "title" as *u8, conf)
411 let workload: *u8 = h2_conf_str(cb, cn, "workload" as *u8, conf)
412 let home: *u8 = h2_conf_str(cb, cn, "home" as *u8, conf)
413 let workdir: *u8 = h2_conf_str(cb, cn, "workdir" as *u8, conf)
414 let srcdir: *u8 = h2_conf_str(cb, cn, "srcdir" as *u8, conf)
415 let ref: *u8 = h2_conf_str(cb, cn, "ref" as *u8, conf)
416 let outp: *u8 = h2_conf_str(cb, cn, "out" as *u8, conf)
417 let nxcc: *u8 = h2_conf_str(cb, cn, "nxcc" as *u8, conf)
418 let nxasm: *u8 = h2_conf_str(cb, cn, "nxasm" as *u8, conf)
419 let nxsrc: *u8 = h2_conf_str(cb, cn, "nxsrc" as *u8, conf)
420 let runs: i64 = lcf_int(cb, cn, "runs" as *u8)
421 if runs == LCF_MISS { h2_refuse("runs" as *u8, conf) }
422 if runs < H2_RUNS_MIN { h2_puts("NX-LANG-H2H REFUSED: runs below the floor of 3 -- a median needs a population\n" as *u8); sys_exit(H2_EXIT_USAGE); return H2_EXIT_USAGE }
423 if runs > H2_RUNS_MAX { h2_puts("NX-LANG-H2H REFUSED: runs above 64 -- raise H2_RUNS_MAX deliberately, never silently\n" as *u8); sys_exit(H2_EXIT_USAGE); return H2_EXIT_USAGE }
424
425 sys_mkdir(workdir, H2_MODE_RWX)
426 let gocache: *u8 = sys_mmap(H2_PATH)
427 var go1: i64 = br_cat(gocache, 0, workdir); go1 = br_cat(gocache, go1, "/gocache" as *u8)
428 sys_mkdir(gocache, H2_MODE_RWX)
429 let envp: *i64 = sys_mmap(H2_ENV_SLOTS * H2_WORD) as *i64
430 let envhome: *u8 = sys_mmap(H2_PATH)
431 var eh: i64 = br_cat(envhome, 0, "HOME=" as *u8); eh = br_cat(envhome, eh, home)
432 let envgo: *u8 = sys_mmap(H2_PATH)
433 var eg: i64 = br_cat(envgo, 0, "GOCACHE=" as *u8); eg = br_cat(envgo, eg, gocache)
434 envp[0] = H2_ENV_PATH as i64; envp[1] = envhome as i64; envp[2] = envgo as i64; envp[3] = H2_ENV_GOTOOLCHAIN as i64; envp[4] = 0
435
436 // ---- host facts, read from the kernel, never typed ----
437 let pb: *u8 = sys_mmap(H2_CAP_PROC)
438 let hostn: *u8 = sys_mmap(H2_VER)
439 var hn: i64 = h2_read_small(H2_PROC_HOSTNAME, pb, H2_CAP_PROC)
440 if hn < 0 { hn = 0 }
441 h2_first_line(pb, hn, hostn, H2_VER)
442 let osrel: *u8 = sys_mmap(H2_VER)
443 var rn: i64 = h2_read_small(H2_PROC_OSRELEASE, pb, H2_CAP_PROC)
444 if rn < 0 { rn = 0 }
445 h2_first_line(pb, rn, osrel, H2_VER)
446 var cn2: i64 = h2_read_small(H2_PROC_CPUINFO, pb, H2_CAP_PROC)
447 if cn2 < 0 { cn2 = 0 }
448 var cpubrim: i64 = 0
449 if cn2 >= H2_CAP_PROC { cpubrim = 1 }
450 let model: *u8 = sys_mmap(H2_VER)
451 h2_proc_value(pb, cn2, "model name" as *u8, model, H2_VER)
452 let nproc: i64 = h2_count_lines_starting(pb, cn2, "processor" as *u8)
453 let hoststr: *u8 = sys_mmap(H2_PATH)
454 var ho: i64 = br_cat(hoststr, 0, hostn)
455 ho = br_put(hoststr, ho, H2_PIPE); ho = br_cat(hoststr, ho, model)
456 ho = br_put(hoststr, ho, H2_PIPE); ho = br_cat(hoststr, ho, "Linux " as *u8); ho = br_cat(hoststr, ho, osrel)
457 ho = br_put(hoststr, ho, H2_PIPE); ho = br_cat(hoststr, ho, "nproc=" as *u8); ho = br_catn(hoststr, ho, nproc)
458 if cpubrim == 1 { ho = br_cat(hoststr, ho, " (cpuinfo read hit its reserve: nproc is a FLOOR)" as *u8) }
459
460 // ---- the receipt header ----
461 let hdr: *i64 = sys_mmap(BR_H_N * H2_WORD) as *i64
462 let arms: *i64 = sys_mmap(BR_MAXARMS * BR_STRIDE * H2_WORD) as *i64
463 br_init(hdr, arms)
464 hdr[BR_H_TITLE] = title as i64
465 hdr[BR_H_WORKLOAD] = workload as i64
466 hdr[BR_H_HOST] = hoststr as i64
467 hdr[BR_H_RUNS] = runs
468 hdr[BR_H_REF] = ref as i64
469 hdr[BR_H_ASOF] = sys_now_realtime_sec()
470 hdr[BR_H_WRITER] = H2_WRITER as i64
471 let cwd: *u8 = sys_mmap(H2_PATH)
472 if sys_getcwd(cwd, H2_PATH) <= 0 { cwd[0] = 46 as u8; cwd[1] = 0 as u8 }
473 let repro: *u8 = sys_mmap(H2_PATH * 2)
474 var rp: i64 = br_cat(repro, 0, "cd " as *u8); rp = br_cat(repro, rp, cwd)
475 rp = br_cat(repro, rp, " && " as *u8); rp = br_cat(repro, rp, argv[0] as *u8); rp = br_put(repro, rp, H2_SP); rp = br_cat(repro, rp, conf)
476 hdr[BR_H_REPRO] = repro as i64
477
478 // ---- the arms ----
479 let out: *u8 = sys_mmap(H2_CAP_OUT)
480 let ol: *i64 = sys_mmap(16) as *i64
481 let found: *i64 = sys_mmap(16) as *i64
482 let times: *i64 = sys_mmap(H2_RUNS_MAX * H2_WORD) as *i64
483 // ---- the mode arms, declared in the conf as nxmode_<name>=<intent words> ----
484 let modes: *i64 = sys_mmap(H2_MODE_MAX * H2_WORD) as *i64
485 var nmodes: i64 = 0
486 var cp: i64 = 0
487 while cp < cn {
488 var ce: i64 = cp
489 while ce < cn { if cb[ce] == (10 as u8) { break } ce = ce + 1 }
490 var same: i64 = 1
491 var kk: i64 = 0
492 while kk < H2_MODE_KEY_LEN { if cp + kk >= ce { same = 0; kk = H2_MODE_KEY_LEN } else { if cb[cp + kk] != H2_MODE_KEY[kk] { same = 0; kk = H2_MODE_KEY_LEN } else { kk = kk + 1 } } }
493 if same == 1 { if nmodes < H2_MODE_MAX {
494 let nm: *u8 = sys_mmap(H2_VER)
495 var q: i64 = cp + H2_MODE_KEY_LEN
496 var w: i64 = 0
497 while q < ce { if cb[q] == (61 as u8) { break } if w < H2_VER - 1 { nm[w] = cb[q]; w = w + 1 } q = q + 1 }
498 nm[w] = 0 as u8
499 if w > 0 { modes[nmodes] = nm as i64; nmodes = nmodes + 1 }
500 } }
501 cp = ce + 1
502 }
503 let H2_ARMS: i64 = H2_ARMS_FIXED + nmodes
504 var i: i64 = 0
505 while i < H2_ARMS {
506 let b: i64 = i * BR_STRIDE
507 var mode_name: *u8 = 0 as *u8
508 if i >= H2_ARMS_FIXED { mode_name = modes[i - H2_ARMS_FIXED] as *u8 }
509 if i < H2_ARMS_FIXED { arms[b + BR_A_NAME] = h2_arm_name(i) as i64 } else {
510 let an: *u8 = sys_mmap(H2_VER)
511 var ao: i64 = br_cat(an, 0, "nishilang-" as *u8); br_cat(an, ao, mode_name)
512 arms[b + BR_A_NAME] = an as i64
513 }
514 if i < H2_ARMS_FIXED { arms[b + BR_A_TOOL] = h2_arm_tool(i) as i64 } else {
515 let at: *u8 = sys_mmap(H2_VER)
516 var to: i64 = br_cat(at, 0, "nx_cc_sovereign --mode=" as *u8); to = br_cat(at, to, mode_name); br_cat(at, to, " + nxasm_x86_main (the mode bundle from knowledge/lang_modes.conf)" as *u8)
517 arms[b + BR_A_TOOL] = at as i64
518 }
519 let ver: *u8 = sys_mmap(H2_VER); ver[0] = 45 as u8; ver[1] = 0 as u8
520 arms[b + BR_A_VER] = ver as i64
521 let note: *u8 = sys_mmap(H2_NOTE); note[0] = 0 as u8
522 arms[b + BR_A_NOTE] = note as i64
523 let srcsha: *u8 = sys_mmap(H2_HEX); srcsha[0] = 45 as u8; srcsha[1] = 0 as u8
524 let binsha: *u8 = sys_mmap(H2_HEX); binsha[0] = 45 as u8; binsha[1] = 0 as u8
525 arms[b + BR_A_SRCSHA] = srcsha as i64
526 arms[b + BR_A_BINSHA] = binsha as i64
527 arms[b + BR_A_STATUS] = BR_ST_UNMEASURABLE
528 let src: *u8 = sys_mmap(H2_PATH)
529 if i >= H2_ARM_NX { br_cat(src, 0, nxsrc) } else {
530 var so: i64 = br_cat(src, 0, srcdir); so = br_put(src, so, H2_SLASH); br_cat(src, so, h2_arm_srcfile(i))
531 }
532 arms[b + BR_A_SRC] = src as i64
533 let tool: *u8 = sys_mmap(H2_PATH)
534 var have: i64 = 0
535 if i >= H2_ARM_NX { have = lcf_str(cb, cn, "nxcc" as *u8, tool, H2_PATH) } else { have = lcf_str(cb, cn, h2_arm_key(i), tool, H2_PATH) }
536 var proceed: i64 = 1
537 if h2_file_sha(src, srcsha) < 0 {
538 arms[b + BR_A_STATUS] = BR_ST_BUILDFAIL
539 var n0: i64 = br_cat(note, 0, "arm source unreadable: " as *u8); br_cat(note, n0, src)
540 proceed = 0
541 }
542 if proceed == 1 { if have < 0 {
543 arms[b + BR_A_STATUS] = BR_ST_UNMEASURABLE
544 var n1: i64 = br_cat(note, 0, "toolchain key " as *u8); if i >= H2_ARM_NX { n1 = br_cat(note, n1, "nxcc" as *u8) } else { n1 = br_cat(note, n1, h2_arm_key(i)) } n1 = br_cat(note, n1, "= not declared in " as *u8); n1 = br_cat(note, n1, conf); br_cat(note, n1, " on this host -- an absence, not a loss" as *u8)
545 proceed = 0
546 } }
547 if proceed == 1 {
548 let tfd: i64 = sys_openat_rd(tool)
549 if tfd < 0 {
550 arms[b + BR_A_STATUS] = BR_ST_UNMEASURABLE
551 var n2: i64 = br_cat(note, 0, "declared toolchain path is not readable on this host: " as *u8); br_cat(note, n2, tool)
552 proceed = 0
553 } else { sys_close(tfd) }
554 }
555 if proceed == 1 {
556 let bin: *u8 = sys_mmap(H2_PATH)
557 var bo: i64 = br_cat(bin, 0, workdir); bo = br_cat(bin, bo, "/perf_" as *u8); br_cat(bin, bo, arms[b + BR_A_NAME] as *u8)
558 var rc: i64 = 0
559 if i >= H2_ARMS_FIXED { rc = h2_build_nx_mode(tool, mode_name, src, bin, nxasm, envp, out, H2_CAP_OUT) } else { rc = h2_build(i, tool, src, bin, nxasm, envp, out, H2_CAP_OUT) }
560 if rc != 0 {
561 arms[b + BR_A_STATUS] = BR_ST_BUILDFAIL
562 var n3: i64 = br_cat(note, 0, "build exit=" as *u8); n3 = br_catn(note, n3, rc); br_cat(note, n3, " (127 = the toolchain could not be executed; -8 = the emitted assembly overran the capture reserve; -9 = the compiler emitted nothing)" as *u8)
563 } else {
564 var bb: i64 = h2_file_sha(bin, binsha)
565 if bb < 0 { bb = 0 }
566 arms[b + BR_A_BINBYTES] = bb
567 if i >= H2_ARM_NX {
568 let ccsha: *u8 = sys_mmap(H2_HEX)
569 let ccb: i64 = h2_file_sha(tool, ccsha)
570 let assha: *u8 = sys_mmap(H2_HEX)
571 let asb: i64 = h2_file_sha(nxasm, assha)
572 var vo: i64 = br_cat(ver, 0, "nx_cc_sovereign sha256=" as *u8); vo = br_cat(ver, vo, ccsha); vo = br_cat(ver, vo, " bytes=" as *u8); vo = br_catn(ver, vo, ccb)
573 vo = br_cat(ver, vo, "; nxasm_x86_main sha256=" as *u8); vo = br_cat(ver, vo, assha); vo = br_cat(ver, vo, " bytes=" as *u8); br_catn(ver, vo, asb)
574 } else {
575 h2_version(i, tool, envp, out, H2_CAP_OUT, ver, H2_VER)
576 }
577 // ---- the runs ----
578 let rav: *i64 = sys_mmap(H2_ARGV_SLOTS * H2_WORD) as *i64
579 var r: i64 = 0
580 var okruns: i64 = 0
581 var chk0: i64 = 0
582 var failed: i64 = 0
583 while r < runs {
584 if failed == 0 {
585 rav[0] = bin as i64; rav[1] = 0
586 let rrc: i64 = h2_run(bin, rav, envp, out, H2_CAP_OUT, ol)
587 if rrc != 0 {
588 failed = 1
589 var n4: i64 = br_cat(note, 0, "run " as *u8); n4 = br_catn(note, n4, r); n4 = br_cat(note, n4, " exit=" as *u8); br_catn(note, n4, rrc)
590 } else {
591 let el: i64 = h2_num_after(out, ol[0], H2_KEY_ELAPSED, found)
592 let f1: i64 = found[0]
593 let ck: i64 = h2_num_after(out, ol[0], H2_KEY_CHECKSUM, found)
594 let f2: i64 = found[0]
595 if f1 == 0 { failed = 1 }
596 if f2 == 0 { failed = 1 }
597 if failed == 1 {
598 var n5: i64 = br_cat(note, 0, "run " as *u8); n5 = br_catn(note, n5, r); br_cat(note, n5, " printed no elapsed_us= or no checksum=" as *u8)
599 } else {
600 if okruns == 0 { chk0 = ck } else { if ck != chk0 {
601 failed = 1
602 var n6: i64 = br_cat(note, 0, "checksum unstable across runs: " as *u8); n6 = br_catn(note, n6, chk0); n6 = br_cat(note, n6, " then " as *u8); br_catn(note, n6, ck)
603 } }
604 if failed == 0 { times[okruns] = el; okruns = okruns + 1 }
605 }
606 }
607 }
608 r = r + 1
609 }
610 if failed == 1 { arms[b + BR_A_STATUS] = BR_ST_RUNFAIL } else {
611 h2_sort(times, okruns)
612 arms[b + BR_A_RUNS] = okruns
613 arms[b + BR_A_MIN] = times[0]
614 arms[b + BR_A_MED] = times[okruns / 2]
615 arms[b + BR_A_CHK] = chk0
616 arms[b + BR_A_STATUS] = BR_ST_VALID
617 br_cat(note, 0, "min and median of the in-process elapsed_us each arm prints; the loop is timed, not process startup" as *u8)
618 }
619 }
620 }
621 h2_puts(" arm " as *u8); h2_puts(arms[b + BR_A_NAME] as *u8); h2_puts(": " as *u8); h2_puts(br_status_name(arms[b + BR_A_STATUS]))
622 if arms[b + BR_A_STATUS] == BR_ST_VALID { h2_puts(" min_us=" as *u8); h2_putn(arms[b + BR_A_MIN]); h2_puts(" median_us=" as *u8); h2_putn(arms[b + BR_A_MED]); h2_puts(" checksum=" as *u8); h2_putn(arms[b + BR_A_CHK]) }
623 else { h2_puts(" " as *u8); h2_puts(note) }
624 h2_puts("\n" as *u8)
625 i = i + 1
626 }
627
628 // ---- ONE verdict, the lib's ----
629 let verdict: i64 = br_verdict(hdr, arms, H2_ARMS)
630 let rbuf: *u8 = sys_mmap(H2_CAP_RECEIPT)
631 let rn2: i64 = br_write(rbuf, H2_CAP_RECEIPT, dom, hdr, arms, H2_ARMS, verdict)
632 let wr: i64 = h2_write_atomic(outp, rbuf, rn2)
633 sys_write(1, rbuf, rn2)
634 var c_valid: i64 = 0; var c_void: i64 = 0; var c_unm: i64 = 0; var c_bf: i64 = 0; var c_rf: i64 = 0
635 var nx_valid: i64 = 0
636 var k: i64 = 0
637 while k < H2_ARMS {
638 let st: i64 = arms[k * BR_STRIDE + BR_A_STATUS]
639 if st == BR_ST_VALID { c_valid = c_valid + 1; if k >= H2_ARM_NX { nx_valid = 1 } }
640 if st == BR_ST_VOID { c_void = c_void + 1 }
641 if st == BR_ST_UNMEASURABLE { c_unm = c_unm + 1 }
642 if st == BR_ST_BUILDFAIL { c_bf = c_bf + 1 }
643 if st == BR_ST_RUNFAIL { c_rf = c_rf + 1 }
644 k = k + 1
645 }
646 h2_puts("NX-LANG-H2H dom=" as *u8); h2_puts(dom)
647 h2_puts(" arms=" as *u8); h2_putn(H2_ARMS)
648 h2_puts(" valid=" as *u8); h2_putn(c_valid); h2_puts(" void=" as *u8); h2_putn(c_void); h2_puts(" unmeasurable=" as *u8); h2_putn(c_unm)
649 h2_puts(" buildfail=" as *u8); h2_putn(c_bf); h2_puts(" runfail=" as *u8); h2_putn(c_rf)
650 h2_puts(" sum=" as *u8); h2_putn(c_valid + c_void + c_unm + c_bf + c_rf)
651 h2_puts(" out=" as *u8); h2_puts(outp); h2_puts(" bytes=" as *u8); h2_putn(rn2); h2_puts(" write_rc=" as *u8); h2_putn(wr)
652 h2_puts(" verdict=" as *u8); h2_puts(br_verdict_name(verdict)); h2_puts("\n" as *u8)
653 if wr != 0 { sys_exit(H2_EXIT_USAGE); return H2_EXIT_USAGE }
654 if verdict == BR_V_VOID { sys_exit(H2_EXIT_VOID); return H2_EXIT_VOID }
655 if verdict != BR_V_VALID { sys_exit(H2_EXIT_UNMEASURABLE); return H2_EXIT_UNMEASURABLE }
656 if nx_valid == 0 { sys_exit(H2_EXIT_UNMEASURABLE); return H2_EXIT_UNMEASURABLE }
657 sys_exit(H2_EXIT_VALID)
658 return H2_EXIT_VALID
659}