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

1// nx_pipeline_fetch_test.nx -- proves the operator's live-fetch architecture law with measured numbers:
2// from ONE IP the team CANNOT fan out like Claude, but PIPELINE (process) parallelism hides the CPU stages
3// under the unavoidable polite fetch pacing, so the team reaches the irreducible polite floor. Exit 0 iff:
4//   (1) the pipeline strictly beats the naive team barrier (process-parallelism pays off),
5//   (2) the pipeline is POLITE-OPTIMAL (CPU fully hidden -> wall within one tail of the floor),
6//   (3) the pipeline never undercuts the polite floor (we DON'T cheat the host -- politeness preserved).
7import "nx_pipeline_fetch.nx"
8import "nx_syscalls.nx"
9
10func tp(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
11func tn(v: i64) -> i64 { let bb: *u8=sys_mmap(28); var m: i64=v; if m<0{m=0-m;sys_write(1,"-" as *u8,1)}; 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 }
12
13func main() -> i64 {
14    tp("=== TEAM LIVE-FETCH POLICY: process-parallel pipeline from ONE IP (operator's law) ===\n" as *u8)
15    // realistic ms: polite single-IP pace 800ms/host (don't get bot-blocked); extract 120ms; catalog 60ms;
16    // a real network round-trip (no pacing) ~ 250ms. 30 sources.
17    let n: i64 = 30
18    let pace: i64 = 800; let extract: i64 = 120; let catalog: i64 = 60; let net: i64 = 250
19
20    let claude: i64 = pf_claude_barrier(net, extract, catalog)        // needs n IPs the team lacks
21    let team_b: i64 = pf_team_barrier(n, pace, extract, catalog)      // the WRONG team policy
22    let team_p: i64 = pf_team_pipeline(n, pace, extract, catalog)     // the RIGHT team policy
23    let floor:  i64 = pf_polite_floor(n, pace)
24    let saving: i64 = pf_pipeline_saving(n, pace, extract, catalog)
25
26    tp(" n=" as *u8); tn(n); tp(" sources, one IP, polite pace=" as *u8); tn(pace); tp("ms\n" as *u8)
27    tp(" CLAUDE (many IPs, fan-out-all-per-step): " as *u8); tn(claude); tp("ms  -- fast, but needs " as *u8); tn(n); tp(" IPs/agents the team lacks\n" as *u8)
28    tp(" TEAM naive BARRIER  (one IP):            " as *u8); tn(team_b); tp("ms  -- the trap (n x everything serial)\n" as *u8)
29    tp(" TEAM PIPELINE (process-parallel, one IP):" as *u8); tn(team_p); tp("ms  -- CPU hidden under the polite pacing\n" as *u8)
30    tp(" irreducible POLITE FLOOR (n paced fetches): " as *u8); tn(floor); tp("ms\n" as *u8)
31    tp(" pipeline SAVES over naive barrier:        " as *u8); tn(saving); tp("ms (the value of process-parallelism)\n" as *u8)
32
33    let r0: i64 = 0; let r1: i64 = pf_is_polite_optimal(n, pace, extract, catalog)
34    var r0v: i64 = 0; if team_p < team_b { r0v = 1 }                  // (1) pipeline beats naive barrier
35    var r2v: i64 = 0; if team_p >= floor { r2v = 1 }                  // (3) never undercuts the polite floor (stays polite)
36    tp("----\n checks: beats-naive-barrier=" as *u8); tn(r0v); tp("  polite-optimal=" as *u8); tn(r1); tp("  stays-polite(>=floor)=" as *u8); tn(r2v); tp("\n" as *u8)
37    if r0v == 1 { if r1 == 1 { if r2v == 1 {
38        tp(" PROVEN: the team can't out-IP Claude, but PIPELINE process-parallelism reaches the polite floor --\n" as *u8)
39        tp(" it hides all CPU under the one-IP pacing, the best achievable without more IPs. This IS the team's win.\n" as *u8)
40        sys_exit(0); return 0
41    } } }
42    tp(" FAIL\n" as *u8); sys_exit(1); return 1
43}
nx_pipeline_fetch_test.nx source

`nx_pipeline_fetch_test.nx` source
