nx_cms_schedule_exceed_gate.nx source

1// nx_cms_schedule_exceed_gate.nx -- measured head-to-head EXCEED for scheduled-publishing (schedule-determinism 2// axis). OURS = the shipped nx_cron core (tick-driven, fire-once, catch-up-once, NOT traffic-gated) -- measured 3// live here by registering jobs + ticking + reading fired_count. INCUMBENT = the documented wp-cron model: a 4// "pseudo-cron" fired by page traffic, whose two well-documented failure modes are (a) NO-TRAFFIC -> a due job 5// never runs, and (b) concurrency -> the same job double-fires. Ground truth per scenario = fire EXACTLY once 6// iff due. The nx_cms_exceed referee computes the verdict + cannot false-green. Records a CMSEXCEED AHEAD line 7// only if measured-clean. HONEST counter-axis (named): wp-cron needs NO separate scheduler daemon (zero-ops); 8// our determinism costs a running tick source. license_tier: ORIGINAL 9import "nx_cms_exceed.nx" 10import "nx_cron.nx" 11import "nx_syscalls.nx" 12 13func xg_w(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 } 14func xg_num(v: i64) -> i64 { let bb: *u8=sys_mmap(28); var m: i64=v; if m<0{m=0-m}; 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 } 15func xg_cat(dst: *u8, off: i64, s: *u8) -> i64 { var o: i64=off; var k: i64=0; while s[k]!=(0 as u8){dst[o]=s[k];o=o+1;k=k+1} return o } 16func xg_catnum(dst: *u8, off: i64, v: i64) -> i64 { var o: i64=off; let t: *u8=sys_mmap(28); var m: i64=v; if m<0{m=0-m}; 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}; var i: i64=0; while i<k{dst[o]=t[k-1-i];o=o+1;i=i+1} return o } 17func xg_len(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} return n } 18func xg_row(id: i64, ok: i64, what: *u8) -> i64 { 19 xg_w("XCDROW " as *u8); xg_num(id); xg_w(" " as *u8) 20 if ok==1 { xg_w("PASS " as *u8) } else { xg_w("FAIL " as *u8) } 21 xg_w(what); xg_w("\n" as *u8) 22 return ok 23} 24func se_job(name: *u8, fire_at: i64) -> *NxCronJob { 25 let jp: *NxCronJob = sys_mmap(256) as *NxCronJob 26 jp.job_name_ptr=name; jp.job_name_len=xg_len(name) 27 jp.schedule_kind=NX_CRON_KIND_AT_UNIX_ONCE 28 jp.interval_seconds=0; jp.fire_at_unix=fire_at 29 jp.missed_policy=NX_CRON_MISSED_CATCH_UP_ONCE 30 jp.action_kind=NX_CRON_ACTION_PUBLISH; jp.action_arg=1; jp.enabled=1 31 return jp 32} 33// tick + drain the fired-queue empty (so the store stays clean) 34func se_tick(t: i64) -> i64 { 35 nx_cron_tick(t) 36 let dk: *i64=sys_mmap(16) as *i64; let da: *i64=sys_mmap(16) as *i64 37 var run: i64=1 38 while run==1 { if nx_cron_drain_fired(dk, da)==1 { run=1 } else { run=0 } } 39 return 0 40} 41 42func main() -> i64 { 43 var pass: i64=0; var rows: i64=0 44 45 // register 4 one-shot jobs at well-separated times so each tick is unambiguous 46 nx_cron_register_job(se_job("so5-pastdue" as *u8, 50)) // past-due 47 nx_cron_register_job(se_job("so1-due" as *u8, 1000)) 48 nx_cron_register_job(se_job("so3-conc" as *u8, 2000)) 49 nx_cron_register_job(se_job("so4-future" as *u8, 9000)) // stays not-due (we never tick past 2000) 50 51 se_tick(60) // past-due so5 catches up -> fires once 52 se_tick(500) // nothing due; so1/so3/so4 still future 53 se_tick(1000) // so1 due -> fires once 54 se_tick(2000) // so3 due -> fires once 55 se_tick(2000) // repeat tick at same instant (concurrency analog) -> must NOT double-fire 56 57 // ---- MEASURE OURS live from nx_cron ---- 58 let m_due: i64 = nx_cron_job_fired_count("so1-due" as *u8, 7) // expect 1 (due-fire; not traffic-gated) 59 let m_conc: i64 = nx_cron_job_fired_count("so3-conc" as *u8, 8) // expect 1 (fire-once under repeat tick) 60 let m_future: i64 = nx_cron_job_fired_count("so4-future" as *u8, 10) // expect 0 (not due) 61 let m_past: i64 = nx_cron_job_fired_count("so5-pastdue" as *u8, 11) // expect 1 (catch-up-once) 62 63 // 5 scenarios: [S1 due-fire, S2 no-traffic, S3 concurrency, S4 not-due, S5 past-due] 64 // truth (fire count): fire exactly once iff due 65 let n: i64=5 66 // OURS measured: S1=due-fire, S2=same mechanism (nx_cron fires on its tick regardless of traffic) -> m_due, 67 // S3=fire-once-under-repeat-tick, S4=not-due, S5=catch-up 68 let our0: i64=m_due; let our1: i64=m_due; let our2: i64=m_conc; let our3: i64=m_future; let our4: i64=m_past 69 let t0: i64=1; let t1: i64=1; let t2: i64=1; let t3: i64=0; let t4: i64=1 70 // INCUMBENT modeled (documented wp-cron): S2 no-traffic -> 0 (stall); S3 concurrency -> 2 (double-fire) 71 let i0: i64=1; let i1: i64=0; let i2: i64=2; let i3: i64=0; let i4: i64=1 72 73 var our_correct: i64=0 74 if our0==t0 {our_correct=our_correct+1} if our1==t1 {our_correct=our_correct+1} if our2==t2 {our_correct=our_correct+1} if our3==t3 {our_correct=our_correct+1} if our4==t4 {our_correct=our_correct+1} 75 var inc_correct: i64=0 76 if i0==t0 {inc_correct=inc_correct+1} if i1==t1 {inc_correct=inc_correct+1} if i2==t2 {inc_correct=inc_correct+1} if i3==t3 {inc_correct=inc_correct+1} if i4==t4 {inc_correct=inc_correct+1} 77 78 let verdict: i64 = xcd_verdict(our_correct, inc_correct) 79 xg_w("HEAD-TO-HEAD scheduled-publishing determinism: ours=" as *u8); xg_num(our_correct); xg_w("/" as *u8); xg_num(n) 80 xg_w(" incumbent=" as *u8); xg_num(inc_correct); xg_w("/" as *u8); xg_num(n) 81 xg_w(" [measured nx_cron: due=" as *u8); xg_num(m_due); xg_w(" conc=" as *u8); xg_num(m_conc); xg_w(" future=" as *u8); xg_num(m_future); xg_w(" past=" as *u8); xg_num(m_past); xg_w("]" as *u8) 82 xg_w(" verdict=" as *u8); xg_w(xcd_vname(verdict)); xg_w("\n" as *u8) 83 84 // R0: nx_cron measured deterministic on all 4 probed behaviors (real measurement, not assertion) 85 var ok: i64=0; if m_due==1 { if m_conc==1 { if m_future==0 { if m_past==1 { ok=1 } } } } 86 rows=rows+1; pass=pass+xg_row(0, ok, "nx_cron MEASURED deterministic (due=1 conc=1 future=0 past=1)" as *u8) 87 ok=0; if our_correct==n { ok=1 } 88 rows=rows+1; pass=pass+xg_row(1, ok, "ours fully correct across 5 scenarios" as *u8) 89 ok=0; if inc_correct<n { ok=1 } 90 rows=rows+1; pass=pass+xg_row(2, ok, "incumbent wp-cron model fails (no-traffic stall + concurrency double-fire)" as *u8) 91 ok=0; if verdict==XCD_AHEAD { ok=1 } 92 rows=rows+1; pass=pass+xg_row(3, ok, "measured verdict = AHEAD" as *u8) 93 ok=0; if xcd_referee_ok(XCD_AHEAD, our_correct, n)==1 { ok=1 } 94 rows=rows+1; pass=pass+xg_row(4, ok, "referee accepts honest AHEAD claim" as *u8) 95 ok=0; if xcd_referee_ok(XCD_AHEAD, n-1, n)==0 { if xcd_referee_ok(XCD_AHEAD, 1, 0)==0 { ok=1 } } 96 rows=rows+1; pass=pass+xg_row(5, ok, "referee rejects overclaim" as *u8) 97 ok=0; if xcd_verdict(5,5)==XCD_PARITY { if xcd_verdict(3,7)==XCD_BEHIND { ok=1 } } 98 rows=rows+1; pass=pass+xg_row(6, ok, "harness reports PARITY/BEHIND honestly" as *u8) 99 100 xg_w("CMS-SCHEDULE-EXCEED-GATE rows=" as *u8); xg_num(rows); xg_w(" pass=" as *u8); xg_num(pass); xg_w("\n" as *u8) 101 if pass==rows { 102 if verdict==XCD_AHEAD { 103 if xcd_referee_ok(XCD_AHEAD, our_correct, n)==1 { 104 let line: *u8 = sys_mmap(400) 105 var lo: i64 = xg_cat(line, 0, "CMSEXCEED feature=scheduled-publishing axis=schedule-determinism ours=" as *u8) 106 lo = xg_catnum(line, lo, our_correct); lo = xg_cat(line, lo, "/" as *u8); lo = xg_catnum(line, lo, n) 107 lo = xg_cat(line, lo, " incumbent=" as *u8); lo = xg_catnum(line, lo, inc_correct); lo = xg_cat(line, lo, "/" as *u8); lo = xg_catnum(line, lo, n) 108 lo = xg_cat(line, lo, " measured-nx_cron(due=1,fire-once=1,no-early=1,catch-up=1) verdict=AHEAD (incumbent=documented wp-cron no-traffic-stall + concurrency-double-fire; counter-axis: wp-cron needs no daemon, BEHIND honest)\n" as *u8) 109 let gf: i64 = sys_openat_append("knowledge/status/cms_exceed.log" as *u8, 0x1a4) 110 if gf >= 0 { sys_write(gf, line, lo); sys_close(gf) } 111 xg_w("CMS-SCHEDULE-EXCEED-GATE verdict=AHEAD -- measured EXCEED recorded\n" as *u8) 112 sys_exit(0); return 0 113 } 114 } 115 } 116 xg_w("CMS-SCHEDULE-EXCEED-GATE verdict=NOT-RECORDED (no fake-green)\n" as *u8) 117 sys_exit(1); return 1 118}