code wiki / _hdl_build / _f64_gate_authored.nx
`_f64_gate_authored.nx` source

↩ module page · 104 lines · 3531 B
1// _f64_gate_authored.nx -- ME0 gate: nx_f64 family vs hardware-IEEE oracle.
2//
3// Re-runnable evidence gate (evidence-driven-live-grading law):
4//   1217 KAT vectors generated by _f64_oracle_gen.py from THIS machine's
5//   IEEE 754 hardware doubles -> _f64_kat_vectors.nx.  Every nx_f64 op must
6//   reproduce the oracle bit pattern EXACTLY (no ULP tolerance: binary64
7//   add/sub/mul/div/sqrt/cvt are correctly-rounded operations, so the only
8//   passing grade is bit-identical).
9//
10// Verdict markers (judge output, never $?):
11//   F64-BAD i=<n> op=<k> a=<hex> b=<hex> exp=<hex> got=<hex>   per miss
12//   F64-KAT total=<n> ok=<n> bad=<n>
13//   F64-GATE verdict=GREEN|RED
14// Exit code = capped bad count (visible in nx_sov_build_run's run-exit).
15
16import "nx_syscalls.nx"
17import "nx_f64.nx"
18import "nx_f64_div.nx"
19import "nx_f64_sqrt.nx"
20import "nx_f64_cvt.nx"
21import "_f64_kat_vectors.nx"
22
23func f6g_puts(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
24
25func f6g_putn(v: i64) -> i64 {
26    let bb: *u8 = sys_mmap(28)
27    var m: i64 = v
28    if m < 0 { m = 0 - m; sys_write(1, "-" as *u8, 1) }
29    let t: *u8 = sys_mmap(28)
30    var k: i64 = 0
31    if m == 0 { t[0] = 48; k = 1 }
32    while m > 0 { t[k] = 48 + (m % 10); m = m / 10; k = k + 1 }
33    var i: i64 = 0
34    while i < k { bb[i] = t[k-1-i]; i = i + 1 }
35    sys_write(1, bb, k)
36    return 0
37}
38
39// 16-nibble hex print, sign-bit safe (no negation; mask nibbles directly).
40func f6g_puthex(v: i64) -> i64 {
41    let bb: *u8 = sys_mmap(20)
42    var i: i64 = 0
43    while i < 16 {
44        let nib: i64 = (v >> ((15 - i) * 4)) & 15
45        if nib < 10 { bb[i] = 48 + nib } else { bb[i] = 55 + nib }   // 0-9, A-F
46        i = i + 1
47    }
48    sys_write(1, bb, 16)
49    return 0
50}
51
52func main() -> i64 {
53    let ops: *i64 = sys_mmap(8 * 1400) as *i64
54    let av:  *i64 = sys_mmap(8 * 1400) as *i64
55    let bv:  *i64 = sys_mmap(8 * 1400) as *i64
56    let ev:  *i64 = sys_mmap(8 * 1400) as *i64
57    let n: i64 = f64_kat_fill_all(ops, av, bv, ev)
58
59    var ok: i64 = 0
60    var bad: i64 = 0
61    var i: i64 = 0
62    while i < n {
63        let op: i64 = ops[i]
64        let a: i64 = av[i]
65        let b: i64 = bv[i]
66        var got: i64 = -1
67        if op == 1 { got = nx_f64_add(a, b) }
68        if op == 2 { got = nx_f64_sub(a, b) }
69        if op == 3 { got = nx_f64_mul(a, b) }
70        if op == 4 { got = nx_f64_div(a, b) }
71        if op == 5 { got = nx_f64_sqrt(a) }
72        if op == 6 { got = nx_f64_eq(a, b) }
73        if op == 7 { got = nx_f64_lt(a, b) }
74        if op == 8 { got = nx_i64_to_f64(a) }
75        if op == 9 { got = nx_f64_to_f32(a) }
76        if got == ev[i] {
77            ok = ok + 1
78        } else {
79            bad = bad + 1
80            if bad <= 40 {
81                f6g_puts("F64-BAD i=" as *u8); f6g_putn(i)
82                f6g_puts(" op=" as *u8); f6g_putn(op)
83                f6g_puts(" a=" as *u8); f6g_puthex(a)
84                f6g_puts(" b=" as *u8); f6g_puthex(b)
85                f6g_puts(" exp=" as *u8); f6g_puthex(ev[i])
86                f6g_puts(" got=" as *u8); f6g_puthex(got)
87                f6g_puts("\n" as *u8)
88            }
89        }
90        i = i + 1
91    }
92
93    f6g_puts("F64-KAT total=" as *u8); f6g_putn(n)
94    f6g_puts(" ok=" as *u8); f6g_putn(ok)
95    f6g_puts(" bad=" as *u8); f6g_putn(bad)
96    f6g_puts("\n" as *u8)
97    if bad == 0 {
98        f6g_puts("F64-GATE verdict=GREEN\n" as *u8)
99        return 0
100    }
101    f6g_puts("F64-GATE verdict=RED\n" as *u8)
102    if bad > 100 { return 100 }
103    return bad
104}
_f64_gate_authored.nx source

`_f64_gate_authored.nx` source
