nx_linkqual_bench.nx source
↩ module page · 95 lines · 3442 B
1// nx_linkqual_bench.nx -- MEASURED hot-path performance of the link-quality
2// substrate on THIS hardware (1:1, no proxy: native x86_64 ELF, raw
3// syscalls, monotonic sys_now_us deltas). Reports ns/op + updates/sec for
4// each hot-path update so we can claim "as performant as the hardware
5// allows" with a real number, not an assertion. Honest method: a warmup
6// pass is discarded; inputs vary per-iteration so the work can't be folded.
7//
8// license_tier: ORIGINAL
9
10import "nx_linkqual.nx"
11const K_MAGIC_2000000: i64 = 2000000
12const K_MAGIC_100000: i64 = 100000
13
14func bdec(n: i64) -> i64 {
15 if n == 0 { sys_write(1, "0" as *u8, 1); return 0 }
16 var m: i64 = n
17 if m < 0 { sys_write(1, "-" as *u8, 1); m = 0 - m }
18 let d: *u8 = sys_mmap(24)
19 var k: i64 = 0
20 while m > 0 { d[k] = (0x30 + (m % 10)) as u8; m = m / 10; k = k + 1 }
21 var i: i64 = k - 1
22 while i >= 0 { let one: *u8 = sys_mmap(1); one[0] = d[i]; sys_write(1, one, 1); i = i - 1 }
23 return 0
24}
25
26// report: label, iterations N, elapsed microseconds -> ns/op + M ops/sec.
27func breport(label: *u8, label_len: i64, n: i64, us: i64) -> i64 {
28 sys_write(1, label, label_len)
29 let ns_op: i64 = (us * 1000) / n
30 sys_write(1, " ", 1); bdec(ns_op); sys_write(1, " ns/op, ", 8)
31 // ops/sec = n * 1e6 / us ; report in thousands to avoid overflow framing
32 var ops_k: i64 = 0
33 if us > 0 { ops_k = (n / us) * 1000 } // ~ (n/us)*1e6/1000 = (n/us)*1000 thousand-ops? compute Mops below
34 let mops: i64 = ops_k / 1000 // millions of ops/sec
35 bdec(mops); sys_write(1, " M ops/sec (", 12); bdec(us); sys_write(1, "us for ", 7); bdec(n); sys_write(1, ")\n", 2)
36 return 0
37}
38
39func main() -> i64 {
40 let N: i64 = K_MAGIC_2000000
41 let f: *LinkFlow = lq_flow_new()
42
43 // ---- warmup (discarded) ----
44 var w: i64 = 0
45 while w < K_MAGIC_100000 { lq_on_arrival(f, w, w + 10 + (w & 7)); w = w + 1 }
46
47 // ---- bench 1: lq_on_arrival (RFC3550 jitter hot path) ----
48 let g: *LinkFlow = lq_flow_new()
49 let t0: i64 = sys_now_us()
50 var i: i64 = 0
51 while i < N {
52 lq_on_arrival(g, i, i + 10 + (i & 15))
53 i = i + 1
54 }
55 let t1: i64 = sys_now_us()
56 breport("jitter update (lq_on_arrival): " as *u8, 31, N, t1 - t0)
57
58 // ---- bench 2: lq_record_latency (HDR quantile bucket) ----
59 let h: *LinkFlow = lq_flow_new()
60 let t2: i64 = sys_now_us()
61 i = 0
62 while i < N {
63 lq_record_latency(h, (i & 1023) + 1)
64 i = i + 1
65 }
66 let t3: i64 = sys_now_us()
67 breport("latency record (lq_record_latency):" as *u8, 35, N, t3 - t2)
68
69 // ---- bench 3: lq_on_rtt (RFC6298 smoothing) ----
70 let r: *LinkFlow = lq_flow_new()
71 let t4: i64 = sys_now_us()
72 i = 0
73 while i < N {
74 lq_on_rtt(r, 20 + (i & 63))
75 i = i + 1
76 }
77 let t5: i64 = sys_now_us()
78 breport("rtt update (lq_on_rtt): " as *u8, 31, N, t5 - t4)
79
80 // ---- bench 4: full per-packet (seq + arrival + record) ----
81 let p: *LinkFlow = lq_flow_new()
82 let t6: i64 = sys_now_us()
83 i = 0
84 while i < N {
85 lq_on_seq(p, i)
86 lq_on_arrival(p, i, i + 10 + (i & 15))
87 lq_record_latency(p, (i & 1023) + 1)
88 i = i + 1
89 }
90 let t7: i64 = sys_now_us()
91 breport("full per-packet (seq+arr+rec): " as *u8, 31, N, t7 - t6)
92
93 sys_write(1, "LINKQUAL BENCH DONE (measured 1:1 on this hardware, native x86_64, raw syscalls)\n", 80)
94 return 0
95}