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

1// nx_cost_oracle_test.nx -- judging speed on emulated time is biased; a counted invariant is fair.
2// Two programs A (3 insns) and B (5 insns). Wall-clock across 3 runs is noisy and FLIPS the winner
3// (A: [10,12,9], B: [8,15,11] -> run0 B faster, run2 A faster); instruction count is 3 vs 5 EVERY run.
4// The cost oracle REJECTS a wall-clock verdict and renders a stable verdict on instruction count.
5// Exit 0 on 7/7. license_tier: ORIGINAL
6
7import "nx_cost_oracle.nx"
8import "nx_syscalls.nx"
9
10func ct_puts(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
11func ct_num(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); 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 }
12
13func main() -> i64 {
14    ct_puts("=== COST ORACLE: deterministic measure, reject emulated time (anti-emulator bias) ===\n" as *u8)
15    let runs: i64 = 3
16    let a_wall: *i64 = sys_mmap(8*8) as *i64; a_wall[0]=10; a_wall[1]=12; a_wall[2]=9
17    let b_wall: *i64 = sys_mmap(8*8) as *i64; b_wall[0]=8;  b_wall[1]=15; b_wall[2]=11
18    let a_insn: *i64 = sys_mmap(8*8) as *i64; a_insn[0]=3; a_insn[1]=3; a_insn[2]=3
19    let b_insn: *i64 = sys_mmap(8*8) as *i64; b_insn[0]=5; b_insn[1]=5; b_insn[2]=5
20
21    let wall_repro: i64 = co_reproducible(a_wall, runs)
22    let insn_repro: i64 = co_reproducible(a_insn, runs)
23    let flips: i64 = co_wallclock_flips(a_wall, b_wall, runs)
24    let v_wall: i64 = co_fair_verdict(CO_WALLCLOCK, a_wall[0], b_wall[0], 1)   // -> REJECT
25    let v_insn: i64 = co_fair_verdict(CO_INSN, a_insn[0], b_insn[0], 1)        // -> A_FASTER (3<5)
26
27    ct_puts(" wall-clock reproducible=" as *u8); ct_num(wall_repro); ct_puts("  (would the verdict FLIP across runs? " as *u8); ct_num(flips); ct_puts(")\n" as *u8)
28    ct_puts(" instruction-count reproducible=" as *u8); ct_num(insn_repro); ct_puts("  A=3 B=5 every run\n" as *u8)
29    ct_puts(" verdict on WALL-CLOCK = " as *u8); ct_num(v_wall); ct_puts(" (-1=REJECT: refuse emulated time)\n" as *u8)
30    ct_puts(" verdict on INSN-COUNT = " as *u8); ct_num(v_insn); ct_puts(" (1=A faster, stable)\n" as *u8)
31
32    let r: *i64 = sys_mmap(8*8) as *i64
33    r[0] = 0; if co_metric_deterministic(CO_WALLCLOCK) == 0 { r[0] = 1 }   // wall-clock flagged non-deterministic
34    r[1] = 0; if co_metric_deterministic(CO_INSN) == 1 { r[1] = 1 }        // insn count is deterministic
35    r[2] = 0; if wall_repro == 0 { r[2] = 1 }                              // wall-clock NOT reproducible
36    r[3] = 0; if insn_repro == 1 { r[3] = 1 }                              // insn count reproducible
37    r[4] = 0; if flips == 1 { r[4] = 1 }                                   // wall-clock verdict would FLIP (bias proven)
38    r[5] = 0; if v_wall == CO_REJECT { r[5] = 1 }                          // oracle refuses to judge on time
39    r[6] = 0; if v_insn == CO_A_FASTER { r[6] = 1 }                        // stable verdict on the invariant
40    var pass: i64 = 0; var i: i64 = 0
41    while i < 7 { pass = pass + r[i]; i = i + 1 }
42    ct_puts("----\n passed " as *u8); ct_num(pass); ct_puts("/7\n" as *u8)
43    if pass == 7 { ct_puts(" ANTI-EMULATOR: speed is judged by a COUNTED INVARIANT (insns/toggles/bytes), never flaky time -- so the verdict is reproducible from the hardware up, not a roll of the emulator's dice.\n" as *u8); sys_exit(0); return 0 }
44    ct_puts(" FAIL\n" as *u8); sys_exit(1); return 1
45}
nx_cost_oracle_test.nx source

`nx_cost_oracle_test.nx` source
