nx_fabric_fec.nx source

1// nx_fabric_fec.nx -- R3 of the SkyHammer fabric exceed ladder: built-in RESILIENCY. 2// (knowledge/research/2026-06-23-skyhammer-fabric-sclass-exceed-benchmark.md, ladder R3.) 3// 4// SkyHammer sells "built-in resiliency" IN SILICON. On a LOSSY link with RTT the honest 5// software exceed is PROACTIVE FEC: a retransmit (ARQ) costs a full round-trip PER loss 6// round (= a stall), whereas Reed-Solomon parity already in flight RECONSTRUCTS the lost 7// shard with ZERO added round-trips. This rung MEASURES that vs ARQ on the SAME data-shard 8// loss pattern, and (NC3) PROVES every recovery is byte-exact -- not just "counted". 9// 10// FOUNDED ON (composes, does not reinvent -- rule #15): nx_room_fec.nx -- the proven 11// sovereign GF(256) systematic Reed-Solomon MDS erasure code (gf_init / fec_build_G / 12// fec_encode / fec_decode / fec_data_eq; its own gate recovers ALL C(7,3) patterns + 13// tamper-breaks). R3 adds only the lossy-link + ARQ-vs-FEC latency model. Importing it 14// transitively splices nx_syscalls (single import; no double-import). 15// 16// Integer-only, deterministic (LCG loss, reproducible). expect_exit: 0 license_tier: ORIGINAL 17import "nx_room_fec.nx" 18const FB_MAGIC_1103515245: i64 = 1103515245 19const FB_MAGIC_12345: i64 = 12345 20const FB_MAGIC_2654435761: i64 = 2654435761 21 22const FB_ARQ: i64 = 0 // baseline: data-only, retransmit lost shards (RTT per loss round) 23const FB_FEC: i64 = 1 // R3: k data + m parity; reconstruct <=m losses with no retransmit 24 25struct FecMetrics { 26 lat_p50: i64, // block-completion latency, 50th pct (units: 1 one-way + r*RTT) 27 lat_p99: i64, // block-completion latency tail (the stall metric) 28 shards_sent: i64, // total shards transmitted (bandwidth -- FEC's honest cost) 29 byte_exact: i64, // 1 iff EVERY FEC reconstruction matched the original (liar-kill) 30 recovered_fec:i64, // blocks delivered by FEC with NO retransmit (the zero-RTT win) 31 blocks: i64, 32} 33 34func fb_lcg(st: *i64) -> i64 { st[0] = (st[0] * FB_MAGIC_1103515245 + FB_MAGIC_12345) & 0x7fffffff; return st[0] } 35func fb_lost(st: *i64, p_permille: i64) -> i64 { if (fb_lcg(st) % 1000) < p_permille { return 1 } return 0 } 36 37// ARQ delivery of `count` shards: returns send rounds; adds transmitted shards into *sent. 38func fb_arq_rounds(st: *i64, count: i64, p_permille: i64, sent: *i64) -> i64 { 39 var remaining: i64 = count 40 var rounds: i64 = 0 41 while remaining > 0 { 42 rounds = rounds + 1 43 if rounds > 40 { break } // safety: pathological-loss cap 44 sent[0] = sent[0] + remaining 45 var lost: i64 = 0 46 var z: i64 = 0 47 while z < remaining { if fb_lost(st, p_permille) == 1 { lost = lost + 1 } z = z + 1 } 48 remaining = lost 49 } 50 return rounds 51} 52 53func fec_run(mode: i64, NBLOCKS: i64, k: i64, m: i64, S: i64, RTT: i64, p_permille: i64, base_seed: i64, mo: *FecMetrics) -> i64 { 54 let MAXLAT: i64 = 1 + 60 * RTT 55 let exp: *i64 = sys_mmap(8 * 512) as *i64 56 let log: *i64 = sys_mmap(8 * 256) as *i64 57 gf_init(exp, log) 58 let n: i64 = k + m 59 let G: *i64 = sys_mmap(8 * n * k) as *i64 60 fec_build_G(exp, log, G, k, m) // m=0 -> just the k identity rows (NC1 path) 61 let data: *i64 = sys_mmap(8 * k * S) as *i64 62 let shards: *i64 = sys_mmap(8 * n * S) as *i64 63 let erased: *i64 = sys_mmap(8 * n) as *i64 64 let out: *i64 = sys_mmap(8 * k * S) as *i64 65 let lathist: *i64 = sys_mmap(8 * MAXLAT) as *i64 66 let st: *i64 = sys_mmap(8) as *i64 67 let sent: *i64 = sys_mmap(8) as *i64 // shards-sent accumulator (passed by ptr) 68 sent[0] = 0 69 70 var byte_exact: i64 = 1 71 var recovered_fec: i64 = 0 72 var blk: i64 = 0 73 while blk < NBLOCKS { 74 var i: i64 = 0 75 while i < k { 76 var c: i64 = 0 77 while c < S { data[i*S+c] = (i*53 + c*29 + blk*7 + 17) & 255; c = c + 1 } 78 i = i + 1 79 } 80 st[0] = (base_seed + blk * FB_MAGIC_2654435761) & 0x7fffffff 81 var latency: i64 = 1 82 83 if mode == FB_FEC { 84 fec_encode(exp, log, G, data, shards, k, m, S) 85 sent[0] = sent[0] + n 86 var z: i64 = 0 87 while z < n { erased[z] = 0; z = z + 1 } 88 var lost: i64 = 0 89 z = 0 90 while z < n { if fb_lost(st, p_permille) == 1 { erased[z] = 1; lost = lost + 1 } z = z + 1 } 91 if lost <= m { 92 let rc: i64 = fec_decode(exp, log, G, shards, erased, out, k, m, S) 93 if rc == 0 { 94 if fec_data_eq(out, data, k, S) == 1 { recovered_fec = recovered_fec + 1 } else { byte_exact = 0 } 95 } else { byte_exact = 0 } // lost<=m MUST decode; otherwise the engine lied 96 latency = 1 // recovered from parity in flight -> NO round-trip 97 } else { 98 let rounds: i64 = fb_arq_rounds(st, k, p_permille, sent) // FEC insufficient -> ARQ fallback 99 latency = 1 + rounds * RTT 100 } 101 } else { 102 let rounds: i64 = fb_arq_rounds(st, k, p_permille, sent) 103 latency = 1 + (rounds - 1) * RTT // round 1 is the initial one-way, not an RTT 104 } 105 106 if latency >= MAXLAT { latency = MAXLAT - 1 } 107 lathist[latency] = lathist[latency] + 1 108 blk = blk + 1 109 } 110 111 let t50: i64 = (NBLOCKS * 50) / 100 112 let t99: i64 = (NBLOCKS * 99) / 100 113 var cum: i64 = 0 114 var p50: i64 = 0 115 var p99: i64 = 0 116 var g50: i64 = 0 117 var g99: i64 = 0 118 var hh: i64 = 0 119 while hh < MAXLAT { 120 cum = cum + lathist[hh] 121 if g50 == 0 { if cum > t50 { p50 = hh; g50 = 1 } } 122 if g99 == 0 { if cum > t99 { p99 = hh; g99 = 1 } } 123 if g99 == 1 { break } 124 hh = hh + 1 125 } 126 mo.lat_p50 = p50 127 mo.lat_p99 = p99 128 mo.shards_sent = sent[0] 129 mo.byte_exact = byte_exact 130 mo.recovered_fec = recovered_fec 131 mo.blocks = NBLOCKS 132 return 0 133} 134 135func main() -> i64 { return 0 }