code wiki / _hdl_build / _xperf003a_gate.nx
_xperf003a_gate.nx source
↩ module page · 227 lines · 9494 B
1// _xperf003a_gate.nx -- SOVEREIGN gate for rung X-PERF-003a (CLBG fannkuch-redux
2// throughput baseline, measure-before-optimize).
3//
4// (1) Runs the SOVEREIGN-compiled organ /tmp/nx_clbg_fannkuch.sov.elf (the runtime),
5// parses its (checksum,maxflips,sov_us). Asserts (checksum,maxflips)==golden for
6// N -> CORRECTNESS GREEN. sov_us came from nx_clock_monotonic_ns() bracketing the
7// sovereign permutation hot loop INSIDE that organ.
8// (2) Compiles the equivalent C ref with gcc -O2 (BENCHMARK LANE ONLY -- never the
9// runtime, like qemu=hardware-align / openssl=crypto-ref), runs it timed the SAME
10// way (CLOCK_MONOTONIC, same FK_REPEAT), parses ref_us.
11// (3) ratio_permil = ref_us*1000/sov_us. REPORTED, not asserted to win: sovereign
12// scalar codegen is expected to trail gcc, and that gap IS the X-PERF-003 target.
13// (4) Appends to knowledge/status/clbg_fannkuch.log:
14// CLBGFANNKUCH n=<N> sov_us=<..> ref_us=<..> ratio_permil=<..> checksum=<..> maxflips=<..> verdict=MEASURED
15//
16// PASS = correctness==golden AND an honest MEASURED ratio line is emitted.
17// spec: knowledge/specs/2026-06-13-clbg-fannkuch-throughput.md
18import "nx_syscalls.nx"
19
20const G_N: i64 = 10
21const G_GOLD_CHECKSUM: i64 = 73196
22const G_GOLD_MAXFLIPS: i64 = 38
23const G_MODE_RWX: i64 = 0x1a4 // 0644
24const G_BUFSZ: i64 = 4096
25
26func g_puts(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
27func g_fputs(fd: i64, s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(fd,s,n); return 0 }
28func g_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;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 }
29func g_fputn(fd: i64, v: i64) -> i64 { let bb: *u8=sys_mmap(28); var m: i64=v; if m<0{m=0-m;sys_write(fd,"-" as *u8,1)}; let t: *u8=sys_mmap(28); var k: i64=0; if m==0{t[0]=48;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(fd,bb,k); return 0 }
30
31// fork + redirect child stdout -> redir_out fd + execve; parent waits; returns
32// WEXITSTATUS or 128+signal (segfault != silent fake-success).
33func g_run(path: *u8, argv: *i64, envp: *i64, redir_out: i64) -> i64 {
34 let pid: i64 = sys_fork()
35 if pid == 0 {
36 if redir_out >= 0 { sys_dup3(redir_out, 1, 0) }
37 sys_execve(path, argv, envp)
38 sys_exit(127)
39 }
40 let st: *i64 = sys_mmap(16) as *i64
41 sys_wait4(pid, st, 0)
42 let sig: i64 = st[0] & 0x7f
43 if sig != 0 { return 128 + sig }
44 return (st[0] >> 8) & 0xff
45}
46
47// read whole file into buf (NUL-terminated); return byte count (0 if missing).
48func g_slurp(path: *u8, buf: *u8) -> i64 {
49 let fd: i64 = sys_openat_rd(path)
50 if fd < 0 { return 0 }
51 var total: i64 = 0
52 var n: i64 = sys_read(fd, (buf + total) as *u8, G_BUFSZ - 1 - total)
53 while n > 0 {
54 total = total + n
55 n = sys_read(fd, (buf + total) as *u8, G_BUFSZ - 1 - total)
56 }
57 sys_close(fd)
58 buf[total] = 0 as u8
59 return total
60}
61
62// returns 1 if buf[i..] begins with key (NUL-terminated); else 0.
63func g_match_at(buf: *u8, i: i64, key: *u8) -> i64 {
64 var j: i64 = 0
65 while key[j] != (0 as u8) {
66 if buf[i + j] != key[j] { return 0 }
67 j = j + 1
68 }
69 return 1
70}
71
72// find first occurrence of key in buf, then parse the decimal integer immediately
73// following it. Returns the parsed value, or notfound if key never appears.
74func g_parse_after(buf: *u8, blen: i64, key: *u8, notfound: i64) -> i64 {
75 var i: i64 = 0
76 var hit: i64 = 0 - 1
77 while i < blen {
78 if hit < 0 {
79 if g_match_at(buf, i, key) == 1 { hit = i }
80 }
81 i = i + 1
82 }
83 if hit < 0 { return notfound }
84 var p: i64 = hit
85 while key[p - hit] != (0 as u8) { p = p + 1 }
86 var neg: i64 = 0
87 if buf[p] == (45 as u8) { neg = 1; p = p + 1 }
88 var val: i64 = 0
89 var any: i64 = 0
90 var go: i64 = 1
91 while go == 1 {
92 let ch: i64 = buf[p] as i64
93 if ch < 48 { go = 0 }
94 if ch > 57 { go = 0 }
95 if go == 1 {
96 val = val * 10 + (ch - 48)
97 any = 1
98 p = p + 1
99 }
100 }
101 if any == 0 { return notfound }
102 if neg == 1 { return 0 - val }
103 return val
104}
105
106func main() -> i64 {
107 g_puts("=== X-PERF-003a gate (CLBG fannkuch-redux throughput baseline; SOVEREIGN runtime + gcc bench-ref) ===\n" as *u8)
108
109 let envp: *i64 = sys_mmap(8*4) as *i64
110 envp[0] = "PATH=/usr/bin:/bin" as *u8 as i64; envp[1] = 0
111
112 // -------- (1) run the SOVEREIGN organ, capture + parse its output --------
113 let sov_out: *u8 = "/tmp/_xperf003a_sov.txt" as *u8
114 let sov_bin: *u8 = "/tmp/nx_clbg_fannkuch.sov.elf" as *u8
115 let sfd: i64 = sys_openat_wr(sov_out, G_MODE_RWX)
116 let sargv: *i64 = sys_mmap(8*4) as *i64
117 sargv[0] = sov_bin as i64; sargv[1] = 0
118 let src: i64 = g_run(sov_bin, sargv, envp, sfd)
119 sys_close(sfd)
120
121 let sbuf: *u8 = sys_mmap(G_BUFSZ)
122 let slen: i64 = g_slurp(sov_out, sbuf)
123 g_puts(" sovereign organ stdout: " as *u8); g_puts(sbuf)
124
125 let checksum: i64 = g_parse_after(sbuf, slen, " checksum=" as *u8, 0 - 1)
126 let maxflips: i64 = g_parse_after(sbuf, slen, " maxflips=" as *u8, 0 - 1)
127 let sov_us: i64 = g_parse_after(sbuf, slen, " sov_us=" as *u8, 0 - 1)
128
129 var correct: i64 = 0
130 if checksum == G_GOLD_CHECKSUM {
131 if maxflips == G_GOLD_MAXFLIPS { correct = 1 }
132 }
133
134 g_puts(" CORRECTNESS: checksum=" as *u8); g_putn(checksum)
135 g_puts(" (gold " as *u8); g_putn(G_GOLD_CHECKSUM)
136 g_puts(") maxflips=" as *u8); g_putn(maxflips)
137 g_puts(" (gold " as *u8); g_putn(G_GOLD_MAXFLIPS)
138 g_puts(") -> " as *u8)
139 if correct == 1 { g_puts("GREEN\n" as *u8) } else { g_puts("RED\n" as *u8) }
140
141 if src != 0 {
142 g_puts("GATE verdict=RED reason=sovereign-run-nonzero rc=" as *u8); g_putn(src); g_puts("\n" as *u8)
143 sys_exit(1); return 1
144 }
145 if correct == 0 {
146 g_puts("GATE verdict=RED reason=correctness-mismatch-vs-golden\n" as *u8)
147 sys_exit(1); return 1
148 }
149 if sov_us <= 0 {
150 g_puts("GATE verdict=RED reason=sov_us-unparsed-or-zero\n" as *u8)
151 sys_exit(1); return 1
152 }
153
154 // -------- (2) compile + run the gcc C reference (BENCH LANE ONLY) --------
155 let ref_src: *u8 = "knowledge/specs/clbg_fannkuch_ref.c" as *u8
156 let ref_bin: *u8 = "/tmp/clbg_fannkuch_ref" as *u8
157 let gcc: *u8 = "/usr/bin/gcc" as *u8
158 let gargv: *i64 = sys_mmap(8*8) as *i64
159 gargv[0] = gcc as i64
160 gargv[1] = "-O2" as *u8 as i64
161 gargv[2] = "-o" as *u8 as i64
162 gargv[3] = ref_bin as i64
163 gargv[4] = ref_src as i64
164 gargv[5] = 0
165 let gcc_rc: i64 = g_run(gcc, gargv, envp, 0 - 1)
166 if gcc_rc != 0 {
167 g_puts("GATE verdict=RED reason=gcc-ref-compile-failed rc=" as *u8); g_putn(gcc_rc); g_puts("\n" as *u8)
168 sys_exit(1); return 1
169 }
170
171 let ref_out: *u8 = "/tmp/_xperf003a_ref.txt" as *u8
172 let rfd: i64 = sys_openat_wr(ref_out, G_MODE_RWX)
173 let rargv: *i64 = sys_mmap(8*4) as *i64
174 rargv[0] = ref_bin as i64; rargv[1] = 0
175 let ref_rc: i64 = g_run(ref_bin, rargv, envp, rfd)
176 sys_close(rfd)
177 if ref_rc != 0 {
178 g_puts("GATE verdict=RED reason=gcc-ref-run-nonzero rc=" as *u8); g_putn(ref_rc); g_puts("\n" as *u8)
179 sys_exit(1); return 1
180 }
181
182 let rbuf: *u8 = sys_mmap(G_BUFSZ)
183 let rlen: i64 = g_slurp(ref_out, rbuf)
184 g_puts(" gcc -O2 ref stdout: " as *u8); g_puts(rbuf)
185
186 let ref_us: i64 = g_parse_after(rbuf, rlen, " ref_us=" as *u8, 0 - 1)
187 if ref_us <= 0 {
188 g_puts("GATE verdict=RED reason=ref_us-unparsed-or-zero\n" as *u8)
189 sys_exit(1); return 1
190 }
191 // sanity: the C ref must compute the SAME golden (proves the two impls agree)
192 let ref_cs: i64 = g_parse_after(rbuf, rlen, " checksum=" as *u8, 0 - 1)
193 let ref_mf: i64 = g_parse_after(rbuf, rlen, " maxflips=" as *u8, 0 - 1)
194 var ref_ok: i64 = 0
195 if ref_cs == G_GOLD_CHECKSUM {
196 if ref_mf == G_GOLD_MAXFLIPS { ref_ok = 1 }
197 }
198 if ref_ok == 0 {
199 g_puts("GATE verdict=RED reason=gcc-ref-disagrees-with-golden\n" as *u8)
200 sys_exit(1); return 1
201 }
202
203 // -------- (3) ratio (REPORTED, not asserted to win) --------
204 let ratio_permil: i64 = ref_us * 1000 / sov_us
205
206 g_puts(" MEASURED sov_us=" as *u8); g_putn(sov_us)
207 g_puts(" ref_us=" as *u8); g_putn(ref_us)
208 g_puts(" ratio_permil=" as *u8); g_putn(ratio_permil)
209 g_puts(" (ref/sov; sovereign scalar codegen trails gcc -- that gap = X-PERF-003 target)\n" as *u8)
210
211 // -------- (4) write the MEASURED evidence line --------
212 let lfd: i64 = sys_openat_append("knowledge/status/clbg_fannkuch.log" as *u8, G_MODE_RWX)
213 if lfd >= 0 {
214 g_fputs(lfd, "CLBGFANNKUCH n=" as *u8); g_fputn(lfd, G_N)
215 g_fputs(lfd, " sov_us=" as *u8); g_fputn(lfd, sov_us)
216 g_fputs(lfd, " ref_us=" as *u8); g_fputn(lfd, ref_us)
217 g_fputs(lfd, " ratio_permil=" as *u8); g_fputn(lfd, ratio_permil)
218 g_fputs(lfd, " checksum=" as *u8); g_fputn(lfd, checksum)
219 g_fputs(lfd, " maxflips=" as *u8); g_fputn(lfd, maxflips)
220 g_fputs(lfd, " verdict=MEASURED\n" as *u8)
221 sys_close(lfd)
222 }
223
224 g_puts("GATE verdict=GREEN (correctness==golden; honest MEASURED ratio emitted)\n" as *u8)
225 sys_exit(0)
226 return 0
227}