code wiki / _hdl_build / nx_relay_loadprobe.nx
nx_relay_loadprobe.nx source
↩ module page · 155 lines · 8447 B
1// nx_relay_loadprobe.nx -- SOVEREIGN, on-demand performance probe of the relay's UDP media plane (operator
2// 2026-07-06: "performance to state of the art FIRST"). No third-party tooling (no iperf/netem). Two UDP
3// members join a bench room; A blasts paced media frames, B receives the relay fan-out. BOTH ends share
4// THIS process's monotonic clock -> arrival - embedded_send_us = EXACT one-way A->relay->B latency through
5// the real relay code. Target defaults to 127.0.0.1 (measures RELAY SOFTWARE throughput -- is our CODE the
6// bottleneck, independent of network); argv[1]="lan" targets the NAS 192.168.8.227 for a real-hop run
7// (needs LAN reachability -- WSL NAT may block; the WAN leg is task 25). Per rate tier: latency
8// min/avg/p50/p95/max, jitter, loss, throughput. FAILS LOUD if unreachable. license_tier: ORIGINAL
9import "nx_syscalls.nx"
10import "nx_dgram_media.nx"
11const LP_MAGIC_8471: i64 = 8471
12const LP_MAGIC_4096: i64 = 4096
13const LP_MAGIC_2048: i64 = 2048
14const LP_MAGIC_65536: i64 = 65536
15const LP_MAGIC_1000000: i64 = 1000000
16const LP_MAGIC_250000: i64 = 250000
17
18const LP_MEDIA: i64 = 0x4D
19const LP_FRAME: i64 = 1100
20const LP_MAXN: i64 = 2048
21
22func lw(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
23func ln(v: i64) -> i64 {
24 let b: *u8=sys_mmap(28); var m: i64=v; if m<0{sys_write(1,"-" as *u8,1);m=0-m}
25 let t: *u8=sys_mmap(28); var k: i64=0; if m==0{t[0]=48 as u8;k=1} while m>0{t[k]=(48+(m%10)) as u8;m=m/10;k=k+1}
26 var i: i64=0; while i<k{b[i]=t[k-1-i];i=i+1} sys_write(1,b,k); return 0 }
27func lms(us: i64) -> i64 { ln(us/1000); lw("." as *u8); let f: i64=(us%1000)/100; ln(f); lw("ms" as *u8); return 0 }
28func lp_rd8(b: *u8) -> i64 { // NB: nx_cc x86 blanks .s on IMMEDIATE shifts >31 -> use a VARIABLE-shift loop
29 var v: i64 = 0; var i: i64 = 0
30 while i < 8 { v = v | ((b[i] & 0xff) << (i * 8)); i = i + 1 }
31 return v }
32func lp_naddr(a: *u8, lan: i64) -> i64 {
33 a[0]=2 as u8; a[1]=0 as u8
34 a[2]=((LP_MAGIC_8471>>8)&0xff) as u8; a[3]=(LP_MAGIC_8471&0xff) as u8
35 if lan==1 { a[4]=192 as u8; a[5]=168 as u8; a[6]=8 as u8; a[7]=227 as u8 }
36 else { a[4]=127 as u8; a[5]=0 as u8; a[6]=0 as u8; a[7]=1 as u8 }
37 var i: i64=8; while i<16 { a[i]=0 as u8; i=i+1 }
38 return 0 }
39func lp_tmo(fd: i64, sec: i64, usec: i64) -> i64 {
40 let tv: *i64 = sys_mmap(16) as *i64; tv[0]=sec; tv[1]=usec
41 sys_setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, tv as *u8, 16); return 0 }
42
43func lp_join(fd: i64, naddr: *u8, id: *u8) -> i64 {
44 let pk: *u8 = sys_mmap(LP_MAGIC_4096); let rx: *u8 = sys_mmap(LP_MAGIC_2048); let info: *i64 = sys_mmap(8*12) as *i64
45 if dgm_pack_frame(0x4A, id, 0, "bench" as *u8, 5, pk, LP_MAGIC_4096) != 1 { return 0 }
46 let pl: i64 = (pk[0]&0xff) + ((pk[1]&0xff)<<8)
47 sys_sendto(fd, ((pk as i64)+2) as *u8, pl, 0, naddr, 16)
48 lp_tmo(fd, 2, 0)
49 let fl: *i64 = sys_mmap(16) as *i64; fl[0]=16; let src: *u8 = sys_mmap(16)
50 let r: i64 = sys_recvfrom(fd, rx, LP_MAGIC_2048, 0, src, fl)
51 if r <= 0 { return 0 }
52 if dgm_parse_pkt(rx, r, info) != 0 { return 0 }
53 if info[0] != 0x4B { return 0 }
54 return 1 }
55
56// record one received datagram. st = [recvd, prev_arr, jit, jcnt, interval]. flat (no deep nesting).
57func lp_record(rxm: *u8, fout: *u8, info: *i64, buf: *u8, r: i64, N: i64, seen: *u8, lat: *i64, st: *i64) -> i64 {
58 let rr: i64 = dgm_rx_add(rxm, buf, r, fout, LP_MAGIC_65536, info)
59 if rr <= 0 { return 0 }
60 let sq: i64 = info[1]
61 if sq < 0 { return 0 }
62 if sq >= N { return 0 }
63 if seen[sq] != 0 { return 0 }
64 seen[sq] = 1 as u8
65 let arr: i64 = sys_now_us()
66 lat[st[0]] = arr - lp_rd8(fout)
67 st[0] = st[0] + 1
68 if st[1] >= 0 { var dd: i64 = (arr - st[1]) - st[4]; if dd < 0 { dd = 0 - dd } st[2] = st[2] + dd; st[3] = st[3] + 1 }
69 st[1] = arr
70 return 0 }
71
72func lp_tier(fda: i64, fdb: i64, naddr: *u8, ida: *u8, rate: i64, secs: i64) -> i64 {
73 let interval: i64 = LP_MAGIC_1000000 / rate
74 var N: i64 = rate * secs; if N > LP_MAXN { N = LP_MAXN }
75 let payload: *u8 = sys_mmap(LP_FRAME)
76 var pf: i64=0; while pf<LP_FRAME { payload[pf]=((pf*7)&0xff) as u8; pf=pf+1 }
77 let pk: *u8 = sys_mmap(LP_MAGIC_4096); let rbuf: *u8 = sys_mmap(LP_MAGIC_2048)
78 let rxm: *u8 = sys_mmap(DGM_RX_REGION); dgm_rx_init(rxm)
79 let fout: *u8 = sys_mmap(LP_MAGIC_65536); let info: *i64 = sys_mmap(8*12) as *i64
80 let src: *u8 = sys_mmap(16); let fl: *i64 = sys_mmap(16) as *i64
81 let lat: *i64 = sys_mmap(8 * LP_MAXN) as *i64
82 let seen: *u8 = sys_mmap(LP_MAXN)
83 var sj: i64=0; while sj<N { seen[sj]=0 as u8; sj=sj+1 }
84 let st: *i64 = sys_mmap(8 * 6) as *i64
85 st[0]=0; st[1]=0-1; st[2]=0; st[3]=0; st[4]=interval
86
87 let start: i64 = sys_now_us()
88 var i: i64 = 0
89 while i < N {
90 let ts: i64 = sys_now_us()
91 var s8: i64 = 0; while s8 < 8 { payload[s8] = ((ts >> (s8*8)) & 0xff) as u8; s8 = s8 + 1 }
92 if dgm_pack_frame(LP_MEDIA, ida, i, payload, LP_FRAME, pk, LP_MAGIC_4096) == 1 {
93 let pl: i64 = (pk[0]&0xff)+((pk[1]&0xff)<<8); sys_sendto(fda, ((pk as i64)+2) as *u8, pl, 0, naddr, 16)
94 }
95 // NON-BLOCKING drain (MSG_DONTWAIT=0x40): no 1ms timeout floor -> pacing + throughput measured true
96 var d: i64 = 0
97 while d < 16 {
98 fl[0]=16
99 let r: i64 = sys_recvfrom(fdb, rbuf, LP_MAGIC_2048, 0x40, src, fl)
100 if r <= 0 { d = 16 } else { lp_record(rxm, fout, info, rbuf, r, N, seen, lat, st); d = d + 1 }
101 }
102 let target: i64 = start + (i+1) * interval
103 let now2: i64 = sys_now_us()
104 if now2 < target { let rem: i64 = (target - now2) / 1000; if rem > 0 { sys_sleep_ms(rem) } }
105 i = i + 1
106 }
107 lp_tmo(fdb, 0, LP_MAGIC_250000)
108 var empt: i64 = 0
109 while empt < 3 {
110 fl[0]=16
111 let r: i64 = sys_recvfrom(fdb, rbuf, LP_MAGIC_2048, 0, src, fl)
112 if r <= 0 { empt = empt + 1 } else { empt = 0; lp_record(rxm, fout, info, rbuf, r, N, seen, lat, st) }
113 }
114 let elapsed: i64 = sys_now_us() - start
115 let recvd: i64 = st[0]
116 var a: i64 = 1
117 while a < recvd {
118 let key: i64 = lat[a]; var b2: i64 = a - 1
119 while b2 >= 0 { if lat[b2] > key { lat[b2+1] = lat[b2]; b2 = b2 - 1 } else { b2 = 0 - 1 } }
120 lat[b2+1] = key; a = a + 1
121 }
122 var mn: i64=0; var mx: i64=0; var avg: i64=0; var p50: i64=0; var p95: i64=0
123 if recvd > 0 {
124 mn = lat[0]; mx = lat[recvd-1]
125 var s: i64=0; var q: i64=0; while q<recvd { s=s+lat[q]; q=q+1 }
126 avg = s / recvd; p50 = lat[recvd/2]; p95 = lat[(recvd*95)/100]
127 }
128 let loss: i64 = N - recvd
129 var lossperm: i64 = 0; if N>0 { lossperm = loss*1000/N }
130 var javg: i64 = 0; if st[3]>0 { javg = st[2]/st[3] }
131 var kbps: i64 = 0; if elapsed>0 { kbps = (recvd * LP_FRAME * 8) * 1000 / elapsed }
132
133 lw(" " as *u8); ln(rate); lw("fps x" as *u8); ln(secs); lw("s sent=" as *u8); ln(N); lw(" recv=" as *u8); ln(recvd)
134 lw(" loss=" as *u8); ln(lossperm); lw("permille lat avg=" as *u8); lms(avg); lw(" p50=" as *u8); lms(p50); lw(" p95=" as *u8); lms(p95); lw(" max=" as *u8); lms(mx)
135 lw(" jitter=" as *u8); lms(javg); lw(" thru=" as *u8); ln(kbps); lw("kbps\n" as *u8)
136 return loss }
137
138func main(argc: i64, argv: *i64) -> i64 {
139 var lan: i64 = 0
140 if argc > 1 { let a1: *u8 = (argv[1]) as *u8; if a1[0]==(108 as u8) { lan = 1 } } // 'l' -> lan
141 lw("=== nx_relay_loadprobe: relay UDP plane, sovereign, target=" as *u8)
142 if lan==1 { lw("192.168.8.227 (LAN hop)\n" as *u8) } else { lw("127.0.0.1 (SOFTWARE throughput, no net delay)\n" as *u8) }
143 let fda: i64 = sys_socket(AF_INET, SOCK_DGRAM, 0)
144 let fdb: i64 = sys_socket(AF_INET, SOCK_DGRAM, 0)
145 if fda < 0 { lw("FATAL socket\n" as *u8); return 1 }
146 if fdb < 0 { lw("FATAL socket\n" as *u8); return 1 }
147 let naddr: *u8 = sys_mmap(16); lp_naddr(naddr, lan)
148 if lp_join(fda, naddr, "BENCHA01" as *u8) != 1 { lw("FATAL: A JOIN got no ACK -> UDP plane UNREACHABLE (relay down, port blocked, or WSL-NAT). No numbers is NOT good.\n" as *u8); return 1 }
149 if lp_join(fdb, naddr, "BENCHB02" as *u8) != 1 { lw("FATAL: B JOIN got no ACK\n" as *u8); return 1 }
150 lw(" both members joined. measuring...\n" as *u8)
151 lp_tier(fda, fdb, naddr, "BENCHA01" as *u8, 30, 2)
152 lp_tier(fda, fdb, naddr, "BENCHA01" as *u8, 120, 2)
153 lp_tier(fda, fdb, naddr, "BENCHA01" as *u8, 480, 2)
154 lw("LOADPROBE done.\n" as *u8)
155 return 0 }