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

↩ module page · 103 lines · 5567 B
1import "nx_gate_gn.nx"
2// nx_fabric_fec_gate.nx -- LIVE GATE for R3 (built-in resiliency: FEC vs ARQ over a lossy RTT link).
3// Proves proactive Reed-Solomon FEC (composing nx_room_fec) recovers losses with ~no round-trips, where
4// ARQ stalls an RTT per loss round -- on the SAME loss pattern -- with negative controls.
5//
6//   criteria:
7//     1  baseline(ARQ) p99 latency >= 3 * R3(FEC) p99      (FEC tail >= 3x lower = no RTT-per-loss stalls)
8//     2  R3 byte_exact == 1                                (EVERY reconstruction matches the original)
9//     3  baseline p99 >= 1 + RTT                           (ARQ really stalls >=1 RTT -- non-vacuous loss)
10//     4  R3 recovered_fec >= 90% of blocks                 (the common case is zero-retransmit recovery)
11//   negative controls:
12//     NC1 FEC with m=0 (no parity) -> bloat >= 3*R3        (the PARITY does the work, not the framing)
13//     NC2 loss=0 -> R3 p99 <= 2                            (the exceed is LOSS-driven, not a rigged speedup)
14//     NC3 byte_exact across R3 + NC1 + NC2                 (recovered data is always correct -- liar-kill)
15//
16// D001-MIGRATED 2026-08-01 (hand: the dry-apply emitter SKIPped this counter idiom): verdict now
17// inherits nx_gate_verdict (gv_ctr/gv_check/gv_verdict) so nx_gate_green can judge it; the durable
18// knowledge/status log frame is kept.
19// expect_exit: 0  license_tier: ORIGINAL
20import "nx_gate_verdict.nx"
21import "nx_fabric_fec.nx"
22
23func gp(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
24func fdn(fd: i64, v: i64) -> i64 {
25    let b: *u8 = sys_mmap(28); var m: i64 = v; if m < 0 { m = 0 - m }
26    let t: *u8 = sys_mmap(28); var k: i64 = 0
27    if m == 0 { t[0] = 48 as u8; k = 1 }
28    while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
29    var i: i64 = 0
30    while i < k { b[i] = t[k - 1 - i]; i = i + 1 }
31    sys_write(fd, b, k); return 0
32}
33func show(tag: *u8, m: *FecMetrics) -> i64 {
34    gp(tag); gp(": lat_p50=" as *u8); gn(m.lat_p50); gp(" lat_p99=" as *u8); gn(m.lat_p99)
35    gp(" recovered_fec=" as *u8); gn(m.recovered_fec); gp("/" as *u8); gn(m.blocks)
36    gp(" shards_sent=" as *u8); gn(m.shards_sent); gp(" byte_exact=" as *u8); gn(m.byte_exact); gp("\n" as *u8); return 0
37}
38
39func main() -> i64 {
40    let NB: i64 = 400
41    let k: i64 = 8
42    let m: i64 = 4                                            // parity shards
43    let S: i64 = 4
44    let RTT: i64 = 10
45    let P: i64 = 80                                           // 8% per-shard loss
46    let SEED: i64 = 12345
47
48    let ctr: *i64 = gv_ctr()
49    gv_head("nx_fabric_fec R3 gate -- proactive FEC vs ARQ over a lossy RTT link" as *u8)
50    gp("blocks=" as *u8); gn(NB); gp(" k=" as *u8); gn(k); gp(" m=" as *u8); gn(m); gp(" RTT=" as *u8); gn(RTT)
51    gp(" loss=" as *u8); gn(P); gp("/1000 (composes nx_room_fec GF(256) Reed-Solomon)\n" as *u8)
52
53    let r3:   *FecMetrics = sys_mmap(64) as *FecMetrics
54    let base: *FecMetrics = sys_mmap(64) as *FecMetrics
55    let nc1:  *FecMetrics = sys_mmap(64) as *FecMetrics
56    let nc2:  *FecMetrics = sys_mmap(64) as *FecMetrics
57
58    fec_run(FB_FEC, NB, k, m, S, RTT, P, SEED, r3)            // R3: k+m FEC
59    fec_run(FB_ARQ, NB, k, m, S, RTT, P, SEED, base)          // baseline: ARQ retransmit
60    fec_run(FB_FEC, NB, k, 0, S, RTT, P, SEED, nc1)           // NC1: FEC with NO parity
61    fec_run(FB_FEC, NB, k, m, S, RTT, 0, SEED, nc2)           // NC2: zero loss
62
63    show("R3       (FEC k+m)" as *u8, r3)
64    show("BASELINE (ARQ retransmit)" as *u8, base)
65    show("NC1      (FEC m=0, no parity)" as *u8, nc1)
66    show("NC2      (FEC, zero loss)" as *u8, nc2)
67
68    var c1: i64 = 0; if r3.lat_p99 >= 1 { if base.lat_p99 >= 3 * r3.lat_p99 { c1 = 1 } }
69    gv_check("1  baseline(ARQ) p99 >= 3 * R3(FEC) p99 (no RTT-per-loss stalls)" as *u8, c1, ctr)
70
71    var c2: i64 = 0; if r3.byte_exact == 1 { c2 = 1 }
72    gv_check("2  R3 byte_exact == 1 (every reconstruction matches the original)" as *u8, c2, ctr)
73
74    var c3: i64 = 0; if base.lat_p99 >= 1 + RTT { c3 = 1 }
75    gv_check("3  baseline p99 >= 1+RTT (ARQ really stalls -- non-vacuous loss)" as *u8, c3, ctr)
76
77    // cross-multiply, never divide: a truncated bar with >= banks a false PASS
78    var c4: i64 = 0; if r3.recovered_fec * 10 >= NB * 9 { c4 = 1 }
79    gv_check("4  R3 recovered_fec >= 90% (common case = zero-retransmit recovery)" as *u8, c4, ctr)
80
81    var cn1: i64 = 0; if r3.lat_p99 >= 1 { if nc1.lat_p99 >= 3 * r3.lat_p99 { cn1 = 1 } }
82    gv_check("NC1 no parity -> bloat >= 3*R3 (the PARITY does the work)" as *u8, cn1, ctr)
83
84    var cn2: i64 = 0; if nc2.lat_p99 <= 2 { cn2 = 1 }
85    gv_check("NC2 zero loss -> R3 p99 <= 2 (exceed is LOSS-driven, not rigged)" as *u8, cn2, ctr)
86
87    var cn3: i64 = 0
88    if r3.byte_exact == 1 { if nc1.byte_exact == 1 { if nc2.byte_exact == 1 { cn3 = 1 } } }
89    gv_check("NC3 byte_exact across R3+NC1+NC2 (recovered data always correct)" as *u8, cn3, ctr)
90
91    let rc: i64 = gv_verdict("FABRIC-FEC-GATE" as *u8, ctr, "fec zero-rtt recovery + byte-exact + NC1/2/3" as *u8)
92
93    let lfd: i64 = sys_openat_append("knowledge/status/fabric_nx_fabric_fec.log" as *u8, 0x1a4)
94    if lfd >= 0 {
95        sys_write(lfd, "R3-FABRIC-FEC organ=nx_fabric_fec checks=" as *u8, 41)
96        fdn(lfd, ctr[0]); sys_write(lfd, "/" as *u8, 1); fdn(lfd, ctr[1])
97        if rc == 0 { sys_write(lfd, " fec-zero-rtt-recovery+byte-exact+NC1/2/3 verdict=GREEN\n" as *u8, 56) }
98        if rc != 0 { sys_write(lfd, " verdict=RED\n" as *u8, 13) }
99        sys_close(lfd)
100    }
101    sys_exit(rc)
102    return 0
103}
nx_fabric_fec_gate.nx source

`nx_fabric_fec_gate.nx` source
