nx_perf_rehearsal_candidate_t179.nx source
↩ module page · 212 lines · 12073 B
1// nx_perf_rehearsal.nx -- THE MISSING FEEDBACK EDGE (operator 2026-06-23: "our analytics becomes a
2// feedback loop of s class exceed improving like the nishi conductor would do with the nishi orchestra").
3// The rehearsal loop EXISTS but is CORRECTNESS-ONLY: nx_conductor_notes names the weakest section from
4// RED gate arcs (examiner_arcs.log); nx_woodshed drills a module until it builds clean. A capability that
5// is GREEN-BUT-SLOW (passes gates, LOSES the race on latency) is INVISIBLE to the teacher. This is the
6// adapter that feeds PERFORMANCE/RACE analytics (nx_apm_sweep latency, nx_diora_leaderboard BEHIND) INTO
7// the conductor's weakest-section call -- so the team drills what LOSES RACES, not just what is broken.
8// COMPOSES the conductor-notes idiom (extended gate-red -> perf-behind); does NOT duplicate it. No new
9// monitor/census. Routes a BEHIND to a sectional drill (the trainer); an EXCEED bumps readiness.
10// license_tier: ORIGINAL
11import "nx_syscalls.nx"
12import "nx_itoa_lib.nx" // shared MSB-first emitter (zero-alloc)
13const PR_MAGIC_1105: i64 = 1105
14
15const PR_LOG: *u8 = "knowledge/status/perf_rehearsal.log"
16
17func pr_p(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
18// MIGRATED to the shared emitter (debt 1785563586). The old body mmapped a scratch buffer
19// per call and never freed it. At PAGE granularity that is 4096B leaked PER CALL -- the
20// defect that took 28.5GB of a 36GB host in nx_ts_lumadiff (2MB input, ~3.66M calls).
21// nxi_* is MSB-first, allocates NOTHING, and emits identical bytes including the sign.
22func pr_n(v: i64) -> i64 { nxi_out(v); return 0 }
23func pr_cat(dst: *u8, off: i64, s: *u8) -> i64 { var i: i64=0; while s[i]!=(0 as u8){dst[off+i]=s[i];i=i+1} return off+i }
24func pr_catn(dst: *u8, off: i64, v: i64) -> i64 { var m: i64=v; var o: i64=off; if m<0{dst[o]=45 as u8;o=o+1;m=0-m} let t: *u8=sys_mmap(24); 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+i]=t[k-1-i];i=i+1} return o+k }
25
26// THE FEEDBACK EDGE: given an analytics result for a delivery capability (nishi vs incumbent metric,
27// lower_better=1 for latency), decide DRILL (we LOSE -> the conductor's weakest section) or EXCEED.
28// Emits the conductor-notes-style record to PR_LOG + stdout. Returns 1 if BEHIND (drill called), else 0.
29func pr_note(cap: *u8, nishi: i64, incumbent: i64, lower_better: i64, lfd: i64) -> i64 {
30 var behind: i64 = 0
31 if lower_better == 1 { if nishi > incumbent { behind = 1 } } else { if nishi < incumbent { behind = 1 } }
32 let buf: *u8 = sys_mmap(512); var o: i64 = 0
33 o = pr_cat(buf, o, "PERF-REHEARSAL cap=" as *u8); o = pr_cat(buf, o, cap)
34 o = pr_cat(buf, o, " nishi=" as *u8); o = pr_catn(buf, o, nishi)
35 o = pr_cat(buf, o, " incumbent=" as *u8); o = pr_catn(buf, o, incumbent)
36 if behind == 1 { o = pr_cat(buf, o, " verdict=DRILL-CALLED (slow=loses-race -> weakest section -> woodshed/optimize)\n" as *u8) }
37 else { o = pr_cat(buf, o, " verdict=EXCEED-READY (wins the race -> readiness++)\n" as *u8) }
38 sys_write(1, buf, o)
39 if lfd >= 0 { sys_write(lfd, buf, o) }
40 return behind
41}
42
43
44import "nx_benchmark_release_candidate_t179.nx"
45import "nx_mcp_route.nx"
46import "nx_sha256.nx"
47
48// Schema v1 uses integer nanoseconds; numeric source spans are checked because
49// the general parser's cached integer may overflow. Missing is separate from bad.
50func pr_uint(v:*NxValue,bad:*i64)->i64 {
51 if v==(0 as *NxValue) { return 0-1 }
52 if v.kind!=NX_VAL_INT || v.str_len<=0 { *bad=1; return 0 }
53 if v.str_len>1 { if v.str_ptr[0]==(48 as u8) { *bad=1; return 0 } }
54 var n:i64=0; var i:i64=0
55 while i<v.str_len {
56 let d:i64=(v.str_ptr[i] as i64)-48
57 if d<0 || d>9 { *bad=1; return 0 }
58 if n>(BM_I64_MAX-d)/10 { *bad=1; return 0 }
59 n=n*10+d; i=i+1
60 }
61 return n
62}
63func pr_num(v:*NxValue,key:*u8,bad:*i64)->i64 { return pr_uint(mr_member(v,key,bad),bad) }
64func pr_text(v:*NxValue,bad:*i64)->i64 {
65 if v==(0 as *NxValue) { return 0 }
66 if v.kind!=NX_VAL_STRING || v.str_len<=0 { *bad=1; return 0 }
67 var i:i64=0
68 while i<v.str_len { let c:i64=v.str_ptr[i] as i64; if c<33 || c>126 || c==92 { *bad=1; return 0 }; i=i+1 }
69 return 1
70}
71func pr_same(a:*NxValue,b:*NxValue,bad:*i64)->i64 {
72 if pr_text(a,bad)==0 || pr_text(b,bad)==0 { return BM_RELEASE_UNKNOWN }
73 if a.str_len!=b.str_len { return BM_RELEASE_FAIL }
74 var i:i64=0; while i<a.str_len { if a.str_ptr[i]!=b.str_ptr[i] { return BM_RELEASE_FAIL }; i=i+1 }
75 return BM_RELEASE_PASS
76}
77func pr_hex(p:*u8,n:i64)->i64 {
78 if n!=64 { return 0 }
79 var i:i64=0
80 while i<n { let c:i64=p[i] as i64; if c<48 || c>102 { return 0 }; if c>57 && c<97 { return 0 }; i=i+1 }
81 return 1
82}
83func pr_digest_value(v:*NxValue,bad:*i64)->i64 {
84 if v==(0 as *NxValue) { return BM_RELEASE_UNKNOWN }
85 if v.kind!=NX_VAL_STRING { *bad=1; return BM_RELEASE_INVALID }
86 if pr_hex(v.str_ptr,v.str_len)==0 { *bad=1; return BM_RELEASE_INVALID }
87 return BM_RELEASE_PASS
88}
89func pr_hash_field(v:*NxValue,key:*u8,expected:*u8,bad:*i64)->i64 {
90 let t:*NxValue=mr_member(v,key,bad)
91 if t==(0 as *NxValue) { return BM_RELEASE_UNKNOWN }
92 if t.kind!=NX_VAL_STRING { *bad=1; return BM_RELEASE_INVALID }
93 if pr_hex(t.str_ptr,t.str_len)==0 { *bad=1; return BM_RELEASE_INVALID }
94 if mr_equal(t.str_ptr,t.str_len,expected)==0 { return BM_RELEASE_FAIL }
95 return BM_RELEASE_PASS
96}
97func pr_fact(v:*NxValue,key:*u8,bad:*i64)->i64 {
98 let n:i64=pr_num(v,key,bad)
99 if n<0 { return BM_RELEASE_UNKNOWN }
100 return bm_release_fact(n)
101}
102func pr_validate(r:*NxValue,p:*NxValue,candidate:*u8,incumbent:*u8,now:i64)->i64 {
103 var bad:i64=0
104 if pr_num(r,"schema_version",&bad)!=1 || pr_num(p,"schema_version",&bad)!=1 { return BM_RELEASE_INVALID }
105 let age:i64=pr_num(p,"max_age_s",&bad)
106 let min_trials:i64=pr_num(p,"min_paired_trials",&bad)
107 let min_duration:i64=pr_num(p,"min_trial_duration_ns",&bad)
108 var allow:i64=pr_num(p,"allow_quality_tradeoff",&bad)
109 if allow<0 { allow=0 }
110 if age<=0 || min_trials<=0 || min_duration<=0 || allow>1 || bad!=0 { return BM_RELEASE_INVALID }
111 var verdict:i64=pr_hash_field(r,"candidate_sha256",candidate,&bad)
112 verdict=bm_release_merge(verdict,pr_hash_field(r,"incumbent_sha256",incumbent,&bad))
113 // The caller-pinned policy names the actual required scenario and device.
114 let ps:*NxValue=mr_member(p,"scene_sha256",&bad)
115 let pd:*NxValue=mr_member(p,"device_sha256",&bad)
116 if pr_digest_value(ps,&bad)!=BM_RELEASE_PASS || pr_digest_value(pd,&bad)!=BM_RELEASE_PASS { return BM_RELEASE_INVALID }
117 verdict=bm_release_merge(verdict,pr_same(ps,mr_member(r,"candidate_scene_sha256",&bad),&bad))
118 verdict=bm_release_merge(verdict,pr_same(ps,mr_member(r,"incumbent_scene_sha256",&bad),&bad))
119 verdict=bm_release_merge(verdict,pr_same(pd,mr_member(r,"candidate_device_sha256",&bad),&bad))
120 verdict=bm_release_merge(verdict,pr_same(pd,mr_member(r,"incumbent_device_sha256",&bad),&bad))
121 let cr:*NxValue=mr_member(r,"candidate_run_id",&bad)
122 let ir:*NxValue=mr_member(r,"incumbent_run_id",&bad)
123 let same:i64=pr_same(cr,ir,&bad)
124 if same==BM_RELEASE_PASS { return BM_RELEASE_INVALID }
125 if same==BM_RELEASE_UNKNOWN { verdict=bm_release_merge(verdict,same) }
126 verdict=bm_release_merge(verdict,pr_fact(r,"contention_verified",&bad))
127 verdict=bm_release_merge(verdict,pr_fact(r,"functional_verified",&bad))
128 verdict=bm_release_merge(verdict,pr_fact(r,"raw_trace_verified",&bad))
129 verdict=bm_release_merge(verdict,pr_fact(r,"visual_verified",&bad))
130 verdict=bm_release_merge(verdict,pr_digest_value(mr_member(r,"raw_trace_sha256",&bad),&bad))
131 verdict=bm_release_merge(verdict,pr_digest_value(mr_member(r,"visual_evidence_sha256",&bad),&bad))
132 let observed:i64=pr_num(r,"observed_at_s",&bad)
133 if observed<0 { verdict=bm_release_merge(verdict,BM_RELEASE_UNKNOWN) } else { verdict=bm_release_merge(verdict,bm_release_freshness(now,observed,age)) }
134 let trials:i64=pr_num(r,"paired_trials",&bad)
135 let duration:i64=pr_num(r,"minimum_trial_duration_ns",&bad)
136 if trials<0 || duration<0 { verdict=bm_release_merge(verdict,BM_RELEASE_UNKNOWN) } else { verdict=bm_release_merge(verdict,bm_release_trials(trials,min_trials,duration,min_duration)) }
137 let quality:i64=pr_num(r,"visual_quality",&bad)
138 var approval:i64=pr_num(r,"tradeoff_approved",&bad)
139 if quality<0 { verdict=bm_release_merge(verdict,BM_RELEASE_UNKNOWN) } else {
140 if approval<0 { approval=0 }
141 verdict=bm_release_merge(verdict,bm_release_quality(quality,allow,approval))
142 if quality==2 && allow==1 {
143 let pa:*NxValue=mr_member(p,"approved_tradeoff_sha256",&bad)
144 let ra:*NxValue=mr_member(r,"approved_tradeoff_sha256",&bad)
145 verdict=bm_release_merge(verdict,pr_digest_value(pa,&bad))
146 verdict=bm_release_merge(verdict,pr_digest_value(ra,&bad))
147 verdict=bm_release_merge(verdict,pr_same(pa,ra,&bad))
148 }
149 }
150 let metrics:*NxValue=mr_member(r,"metrics",&bad)
151 let policy:*NxValue=mr_member(p,"metrics",&bad)
152 if policy==(0 as *NxValue) { return BM_RELEASE_INVALID }
153 if policy.kind!=NX_VAL_OBJECT || policy.n_items<=0 { return BM_RELEASE_INVALID }
154 if metrics==(0 as *NxValue) { verdict=bm_release_merge(verdict,BM_RELEASE_UNKNOWN) } else {
155 if metrics.kind!=NX_VAL_OBJECT { return BM_RELEASE_INVALID }
156 }
157 var i:i64=0
158 while i<policy.n_items {
159 // Raw policy key copied solely to use the existing duplicate-aware member API.
160 let key:*u8=sys_mmap(policy.key_lens_ptr[i]+1)
161 var j:i64=0; while j<policy.key_lens_ptr[i] { key[j]=policy.keys_ptr[i][j]; j=j+1 }; key[j]=0 as u8
162 let rule:*NxValue=mr_member(policy,key,&bad)
163 var row:*NxValue=0 as *NxValue
164 if metrics!=(0 as *NxValue) { row=mr_member(metrics,key,&bad) }
165 let absolute:i64=pr_num(rule,"absolute_budget_ns",&bad)
166 let relative:i64=pr_num(rule,"relative_budget_permil",&bad)
167 if absolute<=0 || relative<=0 { bad=1 }
168 if row==(0 as *NxValue) { verdict=bm_release_merge(verdict,BM_RELEASE_UNKNOWN) } else {
169 let measured:i64=pr_num(row,"measured",&bad)
170 let c:i64=pr_num(row,"candidate_ns",&bad)
171 let b:i64=pr_num(row,"incumbent_ns",&bad)
172 let cu:i64=pr_num(row,"candidate_uncertainty_ns",&bad)
173 let bu:i64=pr_num(row,"incumbent_uncertainty_ns",&bad)
174 if measured<0 || c<0 || b<0 || cu<0 || bu<0 { verdict=bm_release_merge(verdict,BM_RELEASE_UNKNOWN) } else { verdict=bm_release_merge(verdict,bm_release_metric(measured,c,b,cu,bu,absolute,relative)) }
175 }
176 sys_munmap(key,policy.key_lens_ptr[i]+1)
177 i=i+1
178 }
179 if bad!=0 { return BM_RELEASE_INVALID }
180 return verdict
181}
182func pr_load(path:*u8,expected:*u8)->*NxValue {
183 var n:i64=0
184 let data:*u8=sys_read_file(path,&n)
185 if data==(0 as *u8) || n<=0 { return 0 as *NxValue }
186 let digest:*u8=sys_mmap(32)
187 if sha256_digest_checked_native(data,n,digest)!=0 { return 0 as *NxValue }
188 let alphabet:*u8="0123456789abcdef"
189 var i:i64=0
190 while i<32 {
191 let b:i64=digest[i] as i64
192 if expected[i*2]!=alphabet[b/16] || expected[i*2+1]!=alphabet[b%16] { return 0 as *NxValue }
193 i=i+1
194 }
195 sys_munmap(digest,32)
196 var status:i64=0
197 let v:*NxValue=nx_value_parse_json(data,n,&status)
198 if status!=NX_VAL_PARSE_OK { return 0 as *NxValue }
199 return v
200}
201func main(argc:i64,argv:*i64)->i64 {
202 if argc!=8 { pr_p("usage: nx_perf_rehearsal validate-release receipt.json receipt_sha256 policy.json policy_sha256 candidate_sha256 incumbent_sha256\n"); return 4 }
203 if mr_equal(argv[1] as *u8,mr_len(argv[1] as *u8),"validate-release")==0 { return 4 }
204 if pr_hex(argv[3] as *u8,mr_len(argv[3] as *u8))==0 || pr_hex(argv[5] as *u8,mr_len(argv[5] as *u8))==0 || pr_hex(argv[6] as *u8,mr_len(argv[6] as *u8))==0 || pr_hex(argv[7] as *u8,mr_len(argv[7] as *u8))==0 { return 4 }
205 let r:*NxValue=pr_load(argv[2] as *u8,argv[3] as *u8)
206 let p:*NxValue=pr_load(argv[4] as *u8,argv[5] as *u8)
207 if r==(0 as *NxValue) || p==(0 as *NxValue) { pr_p("{\"status\":\"INVALID\",\"reason\":\"receipt_or_policy_hash_or_parse\"}\n"); return 4 }
208 let result:i64=pr_validate(r,p,argv[6] as *u8,argv[7] as *u8,sys_now_realtime_sec())
209 pr_p("{\"schema_version\":1,\"verdict_code\":"); pr_n(result); pr_p(",\"scope\":\"pinned_receipt_contract_not_independent_measurement\"}\n")
210 if result==BM_RELEASE_PASS { return 0 }
211 return result
212}