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

1// nx_dominance_test.nx -- "to say our slow-ass generations are better because they use less VRAM is
2// bullshit" (operator). The multi-dimensional guard: compare across VRAM + speed + quality. A version
3// that wins VRAM but LOSES speed is a TRADEOFF, not better -- calling it an exceed is bullshit. Only a
4// version that saves VRAM WITHOUT losing speed or quality DOMINATES = a real exceed. Exit 0 if honest.
5// license_tier: ORIGINAL
6
7import "nx_benchmark.nx"
8import "nx_syscalls.nx"
9
10func dt_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 dt_num(v: i64) -> i64 { let bb: *u8 = sys_mmap(28); var m: i64=v; if m<0 {m=0-m}; 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 }
12func dt_d(v: i64) -> i64 { if v==BM_DOMINATES {dt_puts("DOMINATES(real exceed)" as *u8)} if v==BM_TRADEOFF {dt_puts("TRADEOFF(not better)" as *u8)} if v==BM_DOMINATED {dt_puts("DOMINATED" as *u8)} if v==BM_EQUAL {dt_puts("EQUAL" as *u8)} return 0 }
13
14func main() -> i64 {
15    dt_puts("=== MULTI-DIM: less VRAM but slower = TRADEOFF, not 'better' (no bullshit) ===\n" as *u8)
16    // dimensions: [VRAM_MB, speed_tok/s, quality]  direction: VRAM lower-better(0), speed/quality higher-better(1)
17    let hb: *i64 = sys_mmap(8*8) as *i64; hb[0]=0; hb[1]=1; hb[2]=1
18    let them: *i64 = sys_mmap(8*8) as *i64; them[0]=6800; them[1]=15; them[2]=92
19
20    // A: the BS claim -- saves VRAM but SLOW + slightly worse quality
21    let slow: *i64 = sys_mmap(8*8) as *i64; slow[0]=2800; slow[1]=5; slow[2]=90
22    let dA: i64 = bm_dominance(3, slow, them, hb)
23    dt_puts(" slow-but-less-VRAM (VRAM 2800<6800 but speed 5<15) -> " as *u8); dt_d(dA); dt_puts("  exceed-honest=" as *u8); dt_num(bm_exceed_honest(dA)); dt_puts("\n" as *u8)
24
25    // B: the REAL exceed -- saves VRAM, NOT slower, same quality
26    let good: *i64 = sys_mmap(8*8) as *i64; good[0]=2800; good[1]=15; good[2]=92
27    let dB: i64 = bm_dominance(3, good, them, hb)
28    dt_puts(" less-VRAM-AND-not-slower (2800<6800, speed 15=15, q 92=92) -> " as *u8); dt_d(dB); dt_puts("  exceed-honest=" as *u8); dt_num(bm_exceed_honest(dB)); dt_puts("\n" as *u8)
29
30    // C: worse everywhere
31    let bad: *i64 = sys_mmap(8*8) as *i64; bad[0]=6800; bad[1]=5; bad[2]=90
32    let dC: i64 = bm_dominance(3, bad, them, hb)
33    dt_puts(" worse-everywhere -> " as *u8); dt_d(dC); dt_puts("\n" as *u8)
34
35    let r: *i64 = sys_mmap(8*8) as *i64
36    r[0] = 0; if dA == BM_TRADEOFF { if bm_exceed_honest(dA) == 0 { r[0] = 1 } }   // slow+less-VRAM is NOT better
37    r[1] = 0; if dB == BM_DOMINATES { if bm_exceed_honest(dB) == 1 { r[1] = 1 } }  // less-VRAM-and-not-slower IS a real exceed
38    r[2] = 0; if dC == BM_DOMINATED { r[2] = 1 }                                   // worse everywhere
39    var pass: i64 = 0; var i: i64 = 0
40    while i < 3 { pass = pass + r[i]; i = i + 1 }
41    dt_puts("----\n passed " as *u8); dt_num(pass); dt_puts("/3\n" as *u8)
42    if pass == 3 { dt_puts(" NO BULLSHIT: winning VRAM while losing speed = TRADEOFF, not better. A real exceed must DOMINATE (less VRAM AND not slower AND not worse quality).\n" as *u8); sys_exit(0); return 0 }
43    dt_puts(" FAIL\n" as *u8); sys_exit(1); return 1
44}
nx_dominance_test.nx source

`nx_dominance_test.nx` source
