nx_bench_fannkuch.nx source
↩ module page · 87 lines · 3185 B
1// nx_bench_fannkuch.nx -- NishiLang twin of bench/xlang/fannkuch.c
2// (fannkuch-redux, Computer Language Benchmarks Game). First RACING BENCH
3// ingestion (docs/NX_RACING_BENCH_NORTHSTAR.md). n=10, published answer
4// checksum 73196 / maxflips 38; line 1 = checksum*100+maxflips (=7319638),
5// line 2 = us. Structurally identical flag-based control flow to the C twin
6// (NishiLang has no break) so the compared work is honest.
7// license_tier: ORIGINAL No hw writes (Rule 26).
8// (nx_syscalls_x86_64.nx import REMOVED 2026-07-31, debt 1785528831: this file already
9// gets the canonical syscall layer via nx_clock.nx -> syscalls.nx, so importing the raw-x86
10// module too put TWO syscall layers in one TU -- every wrapper twice, numbering picked by
11// definition ORDER, silently.)
12import "nx_clock.nx"
13
14func fk_emit_i64(fd: i64, n: i64) -> i64 {
15 let scratch: *u8 = sys_mmap(32)
16 var v: i64 = n
17 var neg: i64 = 0
18 if v < 0 { neg = 1; v = 0 - v }
19 var k: i64 = 0
20 if v == 0 { scratch[0] = 0x30 as u8; k = 1 }
21 while v > 0 { scratch[k] = (0x30 + (v - (v / 10) * 10)) as u8; v = v / 10; k = k + 1 }
22 let rev: *u8 = sys_mmap(48)
23 var ro: i64 = 0
24 if neg == 1 { rev[0] = 0x2D as u8; ro = 1 }
25 var j: i64 = 0
26 while j < k { rev[ro + j] = scratch[k - 1 - j]; j = j + 1 }
27 rev[ro + k] = 0x0A as u8
28 sys_write(fd, rev, ro + k + 1)
29 return 0
30}
31
32func main() -> i64 {
33 let n: i64 = 10
34 let perm: *i64 = sys_mmap(128) as *i64
35 let perm1: *i64 = sys_mmap(128) as *i64
36 let count: *i64 = sys_mmap(128) as *i64
37 var i: i64 = 0
38 while i < n { perm1[i] = i; i = i + 1 }
39 var maxflips: i64 = 0
40 var checksum: i64 = 0
41 var permcount: i64 = 0
42 var r: i64 = n
43 let start: i64 = nx_clock_monotonic_ns()
44 var done: i64 = 0
45 while done == 0 {
46 while r != 1 { count[r - 1] = r; r = r - 1 }
47 var ci: i64 = 0
48 while ci < n { perm[ci] = perm1[ci]; ci = ci + 1 }
49 var flips: i64 = 0
50 var k: i64 = perm[0]
51 while k != 0 {
52 var i2: i64 = 0
53 var j2: i64 = k
54 while i2 < j2 {
55 let t: i64 = perm[i2]
56 perm[i2] = perm[j2]
57 perm[j2] = t
58 i2 = i2 + 1
59 j2 = j2 - 1
60 }
61 flips = flips + 1
62 k = perm[0]
63 }
64 if flips > maxflips { maxflips = flips }
65 if permcount % 2 == 0 { checksum = checksum + flips }
66 if permcount % 2 != 0 { checksum = checksum - flips }
67 var stepped: i64 = 0
68 while stepped == 0 {
69 if r == n { done = 1; stepped = 1 }
70 if done == 0 {
71 let p0: i64 = perm1[0]
72 var i3: i64 = 0
73 while i3 < r { perm1[i3] = perm1[i3 + 1]; i3 = i3 + 1 }
74 perm1[r] = p0
75 count[r] = count[r] - 1
76 if count[r] > 0 { stepped = 1 }
77 if count[r] <= 0 { r = r + 1 }
78 }
79 }
80 permcount = permcount + 1
81 }
82 let end: i64 = nx_clock_monotonic_ns()
83 let us: i64 = (end - start) / 1000
84 fk_emit_i64(1, checksum * 100 + maxflips)
85 fk_emit_i64(1, us)
86 return 0
87}