nx_deltaclass_lib.nx source

1// nx_deltaclass_lib.nx -- WHY a headline ratio moved: SCOPE vs EXECUTION, decomposed EXACTLY. 2// 3// THE DEBT THIS EATS: the ecomat headline went 500 -> 418 permil over two weeks and READ AS DECAY. 4// It was not decay. Delivery rose 34 -> 51 levels (+250 permil at a FIXED bar) while the bar itself 5// rose 68 -> 122 (-332 permil of pure requirement growth). Net -82. Nobody could tell those apart 6// without deriving it by hand, so a marathon had no defined start and no defined end. 7// 8// THE DECOMPOSITION IS EXACT, not a heuristic. For ratio = cur/bar: 9// exec_effect = permil(cur1,bar0) - permil(cur0,bar0) <- what DELIVERY did, bar held FIXED 10// scope_effect = permil(cur1,bar1) - permil(cur1,bar0) <- what the REQUIREMENT move did 11// total = permil(cur1,bar1) - permil(cur0,bar0) 12// residual = total - exec - scope <- integer truncation, EMITTED not hidden 13// Both effects are computed INDEPENDENTLY and the residual is PRINTED rather than derived away, so 14// truncation stays visible. Deriving one term from the other would force residual==0 by construction 15// and hide the very rounding the integer-truncation law says goes silent. 16// 17// TWO ORTHOGONAL AXES, deliberately NOT collapsed into one label: a sample can raise the bar AND 18// deliver in the same window, and flattening that into a single enum is exactly how real progress 19// gets misread as thrashing. 20// 21// license_tier: ORIGINAL No hw writes (Rule 26). 22import "nx_syscalls.nx" 23 24const DC_PERMIL: i64 = 1000 25 26// scope axis -- what the BAR (the requirement) did 27const DCS_FLAT: i64 = 0 28const DCS_ADMIT: i64 = 1 29const DCS_RAISE: i64 = 2 30const DCS_LOWER: i64 = 3 31 32// execution axis -- what the NUMERATOR (delivery) did 33const DCE_FLAT: i64 = 0 34const DCE_GAIN: i64 = 1 35const DCE_LOSS: i64 = 2 36 37// marathon verdict -- THE START/END CRITERION 38const DCV_CONVERGING: i64 = 0 39const DCV_SCOPE_BOUND: i64 = 1 40const DCV_DIVERGING: i64 = 2 41const DCV_STALLED: i64 = 3 42const DCV_THRASH: i64 = 4 43// A LOSS is not a STALL. Lumping them together tells the operator "nothing moved" while ground is 44// being given up -- the worst direction for a status word to be wrong. Found by running the CLI on 45// the live ledger: a 52->51 window reported STALLED. 46const DCV_REGRESSION: i64 = 5 47 48// -1 sentinel = evidence absent. NEVER a silent 0: an UNMEASURED gap must not read as a CLOSED one. 49func dc_unmeasured() -> i64 { return 0 - 1 } 50 51func dc_abs(v: i64) -> i64 { if v < 0 { return 0 - v } return v } 52 53func dc_permil(cur: i64, bar: i64) -> i64 { 54 if bar <= 0 { return dc_unmeasured() } 55 if cur < 0 { return dc_unmeasured() } 56 return cur * DC_PERMIL / bar 57} 58 59// The bar moved -> requirements changed. ADMIT (new territory scoped in) is distinguished from 60// RAISE (same territory, higher target) because they demand OPPOSITE responses: admit is a 61// deliberate widening, raise is a standard tightening. 62func dc_scope_class(bar0: i64, bar1: i64, dom0: i64, dom1: i64) -> i64 { 63 if bar1 < bar0 { return DCS_LOWER } 64 if bar1 > bar0 { 65 if dom1 > dom0 { return DCS_ADMIT } 66 return DCS_RAISE 67 } 68 return DCS_FLAT 69} 70 71func dc_exec_class(cur0: i64, cur1: i64) -> i64 { 72 if cur1 > cur0 { return DCE_GAIN } 73 if cur1 < cur0 { return DCE_LOSS } 74 return DCE_FLAT 75} 76 77// what the ratio would have done had the BAR NOT MOVED 78func dc_exec_effect(cur0: i64, cur1: i64, bar0: i64) -> i64 { 79 let a: i64 = dc_permil(cur1, bar0) 80 let b: i64 = dc_permil(cur0, bar0) 81 if a == dc_unmeasured() { return dc_unmeasured() } 82 if b == dc_unmeasured() { return dc_unmeasured() } 83 return a - b 84} 85 86// what the BAR MOVE alone did, holding delivery at its NEW value 87func dc_scope_effect(cur1: i64, bar0: i64, bar1: i64) -> i64 { 88 let a: i64 = dc_permil(cur1, bar1) 89 let b: i64 = dc_permil(cur1, bar0) 90 if a == dc_unmeasured() { return dc_unmeasured() } 91 if b == dc_unmeasured() { return dc_unmeasured() } 92 return a - b 93} 94 95func dc_total(cur0: i64, bar0: i64, cur1: i64, bar1: i64) -> i64 { 96 let a: i64 = dc_permil(cur1, bar1) 97 let b: i64 = dc_permil(cur0, bar0) 98 if a == dc_unmeasured() { return dc_unmeasured() } 99 if b == dc_unmeasured() { return dc_unmeasured() } 100 return a - b 101} 102 103// the truncation artifact, MADE VISIBLE. Bounded small; a large residual means the inputs lied. 104func dc_residual(cur0: i64, bar0: i64, cur1: i64, bar1: i64) -> i64 { 105 let t: i64 = dc_total(cur0, bar0, cur1, bar1) 106 let e: i64 = dc_exec_effect(cur0, cur1, bar0) 107 let s: i64 = dc_scope_effect(cur1, bar0, bar1) 108 if t == dc_unmeasured() { return dc_unmeasured() } 109 if e == dc_unmeasured() { return dc_unmeasured() } 110 if s == dc_unmeasured() { return dc_unmeasured() } 111 return t - e - s 112} 113 114// levels still owed. Clamped at 0: delivery above bar is a bar that needs raising, not a negative gap. 115func dc_gap(cur: i64, bar: i64) -> i64 { 116 if bar < cur { return 0 } 117 return bar - cur 118} 119 120// THE NUMBER THAT ENDS THE ARGUMENT: is the bar growing faster than we close it? 121// If yes there is no ETA at any effort level -- the remedy is a scope decision, not more hours. 122func dc_diverging(cur0: i64, bar0: i64, cur1: i64, bar1: i64) -> i64 { 123 let db: i64 = bar1 - bar0 124 let dc: i64 = cur1 - cur0 125 if db <= 0 { return 0 } 126 if db > dc { return 1 } 127 return 0 128} 129 130// windows remaining at the OBSERVED net rate; unmeasured when there is no finite answer. 131// Ceiling division so a partial window counts as a whole one -- never round an ETA down. 132func dc_eta(cur0: i64, bar0: i64, cur1: i64, bar1: i64) -> i64 { 133 if bar1 <= 0 { return dc_unmeasured() } 134 if dc_diverging(cur0, bar0, cur1, bar1) == 1 { return dc_unmeasured() } 135 let net: i64 = (cur1 - cur0) - (bar1 - bar0) 136 if net <= 0 { return dc_unmeasured() } 137 let g: i64 = dc_gap(cur1, bar1) 138 if g == 0 { return 0 } 139 return (g + net - 1) / net 140} 141 142// moved==1 means the window contained real movement that netted out (a cycle), not a flat line. 143// Without that flag a stalled run and a thrashing run are indistinguishable at the endpoints. 144func dc_verdict(cur0: i64, bar0: i64, cur1: i64, bar1: i64, moved: i64) -> i64 { 145 if bar0 <= 0 { return dc_unmeasured() } 146 if bar1 <= 0 { return dc_unmeasured() } 147 if dc_diverging(cur0, bar0, cur1, bar1) == 1 { return DCV_DIVERGING } 148 if bar1 != bar0 { 149 let e: i64 = dc_exec_effect(cur0, cur1, bar0) 150 let s: i64 = dc_scope_effect(cur1, bar0, bar1) 151 if dc_abs(s) > dc_abs(e) { return DCV_SCOPE_BOUND } 152 } 153 if cur1 > cur0 { return DCV_CONVERGING } 154 if cur1 == cur0 { 155 if moved == 1 { return DCV_THRASH } 156 return DCV_STALLED 157 } 158 return DCV_REGRESSION 159} 160 161// ============ DM7 (devmgmt rung): dc_adopt_delta -- THE ADOPTION-DELTA EMITTER ============ 162// A LEVEL CANNOT EXPRESS A TRAJECTORY. One drift census says "162 stale"; two say "and it is 163// shrinking". This is the SECOND READER OF AN OLD LOG -- it composes census rows nx_artifactdrift 164// already appended to knowledge/status/artifactdrift.log and adds NO new collector and NO new load 165// on the array, which is the whole point of the rung: the cheapest new timescale is a new reader. 166// 167// TWO THINGS IT REFUSES TO DO, both measured hazards rather than hypotheticals: 168// 169// 1. COUNT A GATE'S TEST CENSUS AS REAL MOVEMENT. The log interleaves production sweeps with gate 170// fixture sweeps -- there is a real row reading `distinct=6` between two reading `distinct=963`. 171// The producer stamps `reg=<registry>` precisely so the two are mechanically separable, so a row 172// is PRODUCTION only when its reg= names the registry the caller asked about. Rows written before 173// that field existed carry NO reg=, and they are UNKNOWN-PROVENANCE: their own bucket, never 174// folded into either side. Guessing their provenance is how a fixture becomes a trend. 175// 176// 2. PRESENT A FOSSIL-DERIVED NUMBER AS MOVEMENT. A BEHIND row is measured against the last build 177// ANYBODY ran, so a stale reference can invert the sign of the very delta a promote campaign 178// would act on. The producer already qualifies each BEHIND row REF-FRESH / REF-FOSSIL / 179// REF-UNKNOWN and publishes `considerable` = UNDECLARED and REF-FRESH together. The promotable 180// delta is therefore the delta of `considerable`, and when either row predates those fields it 181// is emitted as UNMEASURED -- an axis that cannot see must abstain, never acquit. 182// 183// EVERY PARTITION IS PRINTED WITH ITS SUM, at BOTH levels and on BOTH the level and the delta: a 184// partition is a claim, and a delta of a partition is a claim about a claim. 185const DCA_UNMEASURED: i64 = 0 - 1 186const DCA_MAXROWS: i64 = 4096 // parsed census rows retained; overflow REFUSES loudly 187const DCA_FIELDS: i64 = 16 // fields captured per row (index consts below) 188const DCA_F_EPOCH: i64 = 0 189const DCA_F_DISTINCT: i64 = 1 190const DCA_F_IDENTICAL: i64 = 2 191const DCA_F_STALE: i64 = 3 192const DCA_F_BEHIND: i64 = 4 193const DCA_F_AHEAD: i64 = 5 194const DCA_F_RESIZED: i64 = 6 195const DCA_F_NOBUILD: i64 = 7 196const DCA_F_NOSERVED: i64 = 8 197const DCA_F_STAGEDPTR: i64 = 9 198const DCA_F_CONSIDERABLE: i64 = 10 199const DCA_F_REFFRESH: i64 = 11 200const DCA_F_REFFOSSIL: i64 = 12 201const DCA_F_UNDECLARED: i64 = 13 202const DCA_F_INFLIGHT: i64 = 14 203const DCA_CH_NL: i64 = 10 // ASCII newline 204const DCA_CH_SP: i64 = 32 // ASCII space 205const DCA_CH_0: i64 = 48 // ASCII '0' 206const DCA_CH_9: i64 = 57 // ASCII '9' 207const DCA_VCLASS: i64 = 32 // distinct nx_catalog VERDICT classes retained 208const DCA_VCELL: i64 = 64 // one verdict-class name cell 209 210func dca_len(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n } 211func dca_cat(d: *u8, o: i64, s: *u8) -> i64 { var i: i64 = 0; var p: i64 = o; while s[i] != (0 as u8) { d[p] = s[i]; p = p + 1; i = i + 1 } return p } 212func dca_catn(d: *u8, o: i64, v: i64) -> i64 { 213 let t: *u8 = sys_mmap(28) 214 var p: i64 = o 215 var m: i64 = v 216 if m < 0 { d[p] = 45 as u8; p = p + 1; m = 0 - m } 217 var k: i64 = 0 218 if m == 0 { t[0] = DCA_CH_0 as u8; k = 1 } 219 while m > 0 { t[k] = (DCA_CH_0 + (m % 10)) as u8; m = m / 10; k = k + 1 } 220 var i: i64 = 0 221 while i < k { d[p] = t[k-1-i]; p = p + 1; i = i + 1 } 222 return p 223} 224func dca_at(q: *u8, i: i64, e: i64, lit: *u8) -> i64 { 225 let ll: i64 = dca_len(lit) 226 if i + ll > e { return 0 } 227 var k: i64 = 0 228 var ok: i64 = 1 229 while k < ll { if q[i+k] != lit[k] { ok = 0; k = ll } else { k = k + 1 } } 230 return ok 231} 232// Read `key=<int>` from ONE line only. Anchored at a token boundary (line start or a space) so that 233// `own_undeclared=` can never be read as `undeclared=` -- a suffix match here would silently report a 234// different column under the right name, which is the confident-wrong-answer class this file exists 235// to stop. Returns DCA_UNMEASURED when the key is absent: never 0, because an absent field and a 236// measured zero demand opposite conclusions. 237func dca_field(q: *u8, ls: i64, le: i64, key: *u8) -> i64 { 238 let kl: i64 = dca_len(key) 239 var i: i64 = ls 240 var res: i64 = DCA_UNMEASURED 241 var go: i64 = 1 242 while go == 1 { 243 if i + kl > le { go = 0 } else { 244 var bound: i64 = 0 245 if i == ls { bound = 1 } else { if (q[i-1] as i64) == DCA_CH_SP { bound = 1 } } 246 if bound == 1 { 247 if dca_at(q, i, le, key) == 1 { 248 var j: i64 = i + kl 249 var v: i64 = 0 250 var any: i64 = 0 251 var g2: i64 = 1 252 while g2 == 1 { 253 if j >= le { g2 = 0 } else { 254 let c: i64 = q[j] as i64 255 if c < DCA_CH_0 { g2 = 0 } else { 256 if c > DCA_CH_9 { g2 = 0 } else { v = v * 10 + (c - DCA_CH_0); any = 1; j = j + 1 } 257 } 258 } 259 } 260 if any == 1 { res = v } 261 go = 0 262 } else { i = i + 1 } 263 } else { i = i + 1 } 264 } 265 } 266 return res 267} 268// PRODUCTION iff `reg=` is present AND names the registry the caller asked about. 269// 1 = PRODUCTION 0 = OTHER-REGISTRY (a gate fixture) -1 = UNKNOWN-PROVENANCE (no reg= at all) 270func dca_provenance(q: *u8, ls: i64, le: i64, reg: *u8) -> i64 { 271 let k: *u8 = " reg=" as *u8 272 let kl: i64 = dca_len(k) 273 var i: i64 = ls 274 var found: i64 = 0 - 1 275 var go: i64 = 1 276 while go == 1 { 277 if i + kl > le { go = 0 } else { 278 if dca_at(q, i, le, k) == 1 { 279 var j: i64 = i + kl 280 var m: i64 = 0 281 let rl: i64 = dca_len(reg) 282 var eq: i64 = 1 283 while m < rl { if j + m >= le { eq = 0; m = rl } else { if q[j+m] != reg[m] { eq = 0; m = rl } else { m = m + 1 } } } 284 if eq == 1 { if j + rl < le { if (q[j+rl] as i64) != DCA_CH_SP { eq = 0 } } } 285 if eq == 1 { found = 1 } else { found = 0 } 286 go = 0 287 } else { i = i + 1 } 288 } 289 } 290 return found 291} 292func dca_sums(f: *i64) -> i64 { 293 if f[DCA_F_DISTINCT] < 0 { return 0 } 294 if f[DCA_F_IDENTICAL] + f[DCA_F_STALE] + f[DCA_F_NOBUILD] + f[DCA_F_NOSERVED] + f[DCA_F_STAGEDPTR] != f[DCA_F_DISTINCT] { return 0 } 295 if f[DCA_F_BEHIND] + f[DCA_F_AHEAD] + f[DCA_F_RESIZED] != f[DCA_F_STALE] { return 0 } 296 return 1 297} 298func dca_drow(d: *u8, p: i64, name: *u8, a: i64, b: i64) -> i64 { 299 var o: i64 = dca_cat(d, p, "DELTA " as *u8) 300 o = dca_cat(d, o, name) 301 o = dca_cat(d, o, " prev=" as *u8); o = dca_catn(d, o, a) 302 o = dca_cat(d, o, " cur=" as *u8); o = dca_catn(d, o, b) 303 o = dca_cat(d, o, " d=" as *u8) 304 if a < 0 { o = dca_cat(d, o, "UNMEASURED" as *u8) } else { if b < 0 { o = dca_cat(d, o, "UNMEASURED" as *u8) } else { o = dca_catn(d, o, b - a) } } 305 d[o] = DCA_CH_NL as u8 306 return o + 1 307} 308// cx[0]=prod_rows cx[1]=rows_total cx[2]=refuse-code (0 ok) 309// returns report bytes, -1 log unreadable, -2 fewer than two PRODUCTION rows, -3 row table capped. 310func dc_adopt_delta(logp: *u8, reg: *u8, catp: *u8, d: *u8, cx: *i64) -> i64 { 311 cx[0] = 0 312 cx[1] = 0 313 cx[2] = 0 314 let nlen: *i64 = sys_mmap(16) as *i64 315 let q: *u8 = sys_map_file(logp, nlen) 316 if (q as i64) == 0 { return 0 - 1 } 317 let n: i64 = nlen[0] 318 let rows: *i64 = sys_mmap(8 * DCA_MAXROWS * DCA_FIELDS) as *i64 319 var nprod: i64 = 0 320 var ntot: i64 = 0 321 var nfix: i64 = 0 322 var nunk: i64 = 0 323 var nbad: i64 = 0 324 var capped: i64 = 0 325 var i: i64 = 0 326 while i < n { 327 var le: i64 = i 328 var s2: i64 = 1 329 while s2 == 1 { if le >= n { s2 = 0 } else { if (q[le] as i64) == DCA_CH_NL { s2 = 0 } else { le = le + 1 } } } 330 if le > i { 331 let ep: i64 = dca_field(q, i, le, "epoch=" as *u8) 332 if ep >= 0 { 333 ntot = ntot + 1 334 let pv: i64 = dca_provenance(q, i, le, reg) 335 if pv == 0 { nfix = nfix + 1 } 336 if pv < 0 { nunk = nunk + 1 } 337 if pv == 1 { 338 if nprod >= DCA_MAXROWS { capped = 1 } else { 339 let b: i64 = nprod * DCA_FIELDS 340 rows[b + DCA_F_EPOCH] = ep 341 rows[b + DCA_F_DISTINCT] = dca_field(q, i, le, "distinct=" as *u8) 342 rows[b + DCA_F_IDENTICAL] = dca_field(q, i, le, "identical=" as *u8) 343 rows[b + DCA_F_STALE] = dca_field(q, i, le, "stale=" as *u8) 344 rows[b + DCA_F_BEHIND] = dca_field(q, i, le, "behind=" as *u8) 345 rows[b + DCA_F_AHEAD] = dca_field(q, i, le, "ahead=" as *u8) 346 rows[b + DCA_F_RESIZED] = dca_field(q, i, le, "resized=" as *u8) 347 rows[b + DCA_F_NOBUILD] = dca_field(q, i, le, "nobuild=" as *u8) 348 rows[b + DCA_F_NOSERVED] = dca_field(q, i, le, "noserved=" as *u8) 349 rows[b + DCA_F_STAGEDPTR] = dca_field(q, i, le, "stagedptr=" as *u8) 350 rows[b + DCA_F_CONSIDERABLE] = dca_field(q, i, le, "considerable=" as *u8) 351 rows[b + DCA_F_REFFRESH] = dca_field(q, i, le, "ref_fresh=" as *u8) 352 rows[b + DCA_F_REFFOSSIL] = dca_field(q, i, le, "ref_fossil=" as *u8) 353 rows[b + DCA_F_UNDECLARED] = dca_field(q, i, le, "own_undeclared=" as *u8) 354 rows[b + DCA_F_INFLIGHT] = dca_field(q, i, le, "own_inflight=" as *u8) 355 if dca_sums(((rows as i64) + b * 8) as *i64) == 0 { nbad = nbad + 1 } 356 nprod = nprod + 1 357 } 358 } 359 } 360 } 361 i = le + 1 362 } 363 cx[0] = nprod 364 cx[1] = ntot 365 if capped == 1 { cx[2] = 3; return 0 - 3 } 366 if nprod < 2 { cx[2] = 2; return 0 - 2 } 367 let a: *i64 = ((rows as i64) + (nprod - 2) * DCA_FIELDS * 8) as *i64 368 let b2: *i64 = ((rows as i64) + (nprod - 1) * DCA_FIELDS * 8) as *i64 369 var p: i64 = 0 370 p = dca_cat(d, p, "# NX-ADOPT-DELTA v=1 tool=nx_deltaclass averb=adoptdelta\n" as *u8) 371 p = dca_cat(d, p, "# LOG " as *u8); p = dca_cat(d, p, logp) 372 p = dca_cat(d, p, " REGISTRY " as *u8); p = dca_cat(d, p, reg) 373 p = dca_cat(d, p, " log_bytes=" as *u8); p = dca_catn(d, p, n) 374 d[p] = DCA_CH_NL as u8; p = p + 1 375 // the provenance partition IS the guard against grading a fixture, so it is printed first 376 p = dca_cat(d, p, "# PROVENANCE rows=" as *u8); p = dca_catn(d, p, ntot) 377 p = dca_cat(d, p, " production=" as *u8); p = dca_catn(d, p, nprod) 378 p = dca_cat(d, p, " other_registry=" as *u8); p = dca_catn(d, p, nfix) 379 p = dca_cat(d, p, " unknown_provenance=" as *u8); p = dca_catn(d, p, nunk) 380 p = dca_cat(d, p, " sum=" as *u8); p = dca_catn(d, p, nprod + nfix + nunk) 381 p = dca_cat(d, p, " sum_ok=" as *u8) 382 if nprod + nfix + nunk == ntot { p = dca_catn(d, p, 1) } else { p = dca_catn(d, p, 0) } 383 d[p] = DCA_CH_NL as u8; p = p + 1 384 p = dca_cat(d, p, "# BEATS prev_epoch=" as *u8); p = dca_catn(d, p, a[DCA_F_EPOCH]) 385 p = dca_cat(d, p, " cur_epoch=" as *u8); p = dca_catn(d, p, b2[DCA_F_EPOCH]) 386 p = dca_cat(d, p, " span_s=" as *u8); p = dca_catn(d, p, b2[DCA_F_EPOCH] - a[DCA_F_EPOCH]) 387 p = dca_cat(d, p, " malformed_production_rows=" as *u8); p = dca_catn(d, p, nbad) 388 p = dca_cat(d, p, " prev_row_partition_ok=" as *u8); p = dca_catn(d, p, dca_sums(a)) 389 p = dca_cat(d, p, " cur_row_partition_ok=" as *u8); p = dca_catn(d, p, dca_sums(b2)) 390 d[p] = DCA_CH_NL as u8; p = p + 1 391 p = dca_drow(d, p, "distinct" as *u8, a[DCA_F_DISTINCT], b2[DCA_F_DISTINCT]) 392 p = dca_drow(d, p, "identical" as *u8, a[DCA_F_IDENTICAL], b2[DCA_F_IDENTICAL]) 393 p = dca_drow(d, p, "stale" as *u8, a[DCA_F_STALE], b2[DCA_F_STALE]) 394 p = dca_drow(d, p, "behind" as *u8, a[DCA_F_BEHIND], b2[DCA_F_BEHIND]) 395 p = dca_drow(d, p, "ahead" as *u8, a[DCA_F_AHEAD], b2[DCA_F_AHEAD]) 396 p = dca_drow(d, p, "resized" as *u8, a[DCA_F_RESIZED], b2[DCA_F_RESIZED]) 397 p = dca_drow(d, p, "nobuild" as *u8, a[DCA_F_NOBUILD], b2[DCA_F_NOBUILD]) 398 p = dca_drow(d, p, "noserved" as *u8, a[DCA_F_NOSERVED], b2[DCA_F_NOSERVED]) 399 p = dca_drow(d, p, "stagedptr" as *u8, a[DCA_F_STAGEDPTR], b2[DCA_F_STAGEDPTR]) 400 p = dca_drow(d, p, "own_undeclared" as *u8, a[DCA_F_UNDECLARED], b2[DCA_F_UNDECLARED]) 401 p = dca_drow(d, p, "own_inflight" as *u8, a[DCA_F_INFLIGHT], b2[DCA_F_INFLIGHT]) 402 p = dca_drow(d, p, "ref_fossil" as *u8, a[DCA_F_REFFOSSIL], b2[DCA_F_REFFOSSIL]) 403 // THE DELTA OF A PARTITION IS ITSELF A PARTITION -- and if it did not reconcile, one of the two 404 // rows was read with a different column set and every number above would be quietly wrong. 405 let dd: i64 = b2[DCA_F_DISTINCT] - a[DCA_F_DISTINCT] 406 let dp: i64 = (b2[DCA_F_IDENTICAL] - a[DCA_F_IDENTICAL]) + (b2[DCA_F_STALE] - a[DCA_F_STALE]) + (b2[DCA_F_NOBUILD] - a[DCA_F_NOBUILD]) + (b2[DCA_F_NOSERVED] - a[DCA_F_NOSERVED]) + (b2[DCA_F_STAGEDPTR] - a[DCA_F_STAGEDPTR]) 407 let ds: i64 = b2[DCA_F_STALE] - a[DCA_F_STALE] 408 let dsp: i64 = (b2[DCA_F_BEHIND] - a[DCA_F_BEHIND]) + (b2[DCA_F_AHEAD] - a[DCA_F_AHEAD]) + (b2[DCA_F_RESIZED] - a[DCA_F_RESIZED]) 409 p = dca_cat(d, p, "# DELTA-PARTITION d_distinct=" as *u8); p = dca_catn(d, p, dd) 410 p = dca_cat(d, p, " d_classes_sum=" as *u8); p = dca_catn(d, p, dp) 411 p = dca_cat(d, p, " delta_sum_ok=" as *u8) 412 if dd == dp { p = dca_catn(d, p, 1) } else { p = dca_catn(d, p, 0) } 413 p = dca_cat(d, p, " d_stale=" as *u8); p = dca_catn(d, p, ds) 414 p = dca_cat(d, p, " d_stale_sub_sum=" as *u8); p = dca_catn(d, p, dsp) 415 p = dca_cat(d, p, " stale_sub_sum_ok=" as *u8) 416 if ds == dsp { p = dca_catn(d, p, 1) } else { p = dca_catn(d, p, 0) } 417 d[p] = DCA_CH_NL as u8; p = p + 1 418 // PROMOTABLE: `considerable` already means UNDECLARED and REF-FRESH together, so a REF-FOSSIL row 419 // is excluded BY CONSTRUCTION rather than counted and apologised for afterwards. If either beat 420 // predates the field, the axis says UNMEASURED -- a promote campaign sized off a fossil-derived 421 // number points at exactly the action that destroys capability. 422 p = dca_cat(d, p, "# PROMOTABLE prev=" as *u8); p = dca_catn(d, p, a[DCA_F_CONSIDERABLE]) 423 p = dca_cat(d, p, " cur=" as *u8); p = dca_catn(d, p, b2[DCA_F_CONSIDERABLE]) 424 p = dca_cat(d, p, " d=" as *u8) 425 var promo_ok: i64 = 1 426 if a[DCA_F_CONSIDERABLE] < 0 { promo_ok = 0 } 427 if b2[DCA_F_CONSIDERABLE] < 0 { promo_ok = 0 } 428 if promo_ok == 1 { p = dca_catn(d, p, b2[DCA_F_CONSIDERABLE] - a[DCA_F_CONSIDERABLE]) } else { p = dca_cat(d, p, "UNMEASURED" as *u8) } 429 p = dca_cat(d, p, " fossil_excluded_by_construction=" as *u8); p = dca_catn(d, p, promo_ok) 430 p = dca_cat(d, p, " cur_ref_fossil=" as *u8); p = dca_catn(d, p, b2[DCA_F_REFFOSSIL]) 431 d[p] = DCA_CH_NL as u8; p = p + 1 432 // second census, composed not re-run 433 p = dca_cat(d, p, "# CATALOG " as *u8) 434 var have_cat: i64 = 0 435 if dca_len(catp) > 0 { if dca_at(catp, 0, dca_len(catp), "-" as *u8) == 0 { have_cat = 1 } } 436 if have_cat == 0 { p = dca_cat(d, p, "UNMEASURED input=<nx_catalog capture path> (an axis that cannot see abstains; it does not report an empty census)" as *u8) } else { 437 let clen: *i64 = sys_mmap(16) as *i64 438 let cq: *u8 = sys_map_file(catp, clen) 439 if (cq as i64) == 0 { p = dca_cat(d, p, "UNREADABLE path=" as *u8); p = dca_cat(d, p, catp) } else { 440 let cn: i64 = clen[0] 441 let voff: *i64 = sys_mmap(8 * DCA_VCLASS) as *i64 442 let vlen: *i64 = sys_mmap(8 * DCA_VCLASS) as *i64 443 let vcnt: *i64 = sys_mmap(8 * DCA_VCLASS) as *i64 444 var nv: i64 = 0 445 var names: i64 = 0 446 var vcap: i64 = 0 447 var j: i64 = 0 448 while j < cn { 449 var je: i64 = j 450 var s3: i64 = 1 451 while s3 == 1 { if je >= cn { s3 = 0 } else { if (cq[je] as i64) == DCA_CH_NL { s3 = 0 } else { je = je + 1 } } } 452 var k: i64 = j 453 var hit: i64 = 0 - 1 454 while k < je { if dca_at(cq, k, je, "VERDICT " as *u8) == 1 { hit = k; k = je } else { k = k + 1 } } 455 if hit >= 0 { 456 // separate cursor + explicit flag: a loop that exits by clobbering its own cursor 457 // destroys the span it was computing, and it has been written wrong here before. 458 var vs: i64 = hit + dca_len("VERDICT " as *u8) 459 var gsp: i64 = 1 460 while gsp == 1 { if vs >= je { gsp = 0 } else { if (cq[vs] as i64) == DCA_CH_SP { vs = vs + 1 } else { gsp = 0 } } } 461 var ve: i64 = vs 462 var gve: i64 = 1 463 while gve == 1 { if ve >= je { gve = 0 } else { if (cq[ve] as i64) == DCA_CH_SP { gve = 0 } else { ve = ve + 1 } } } 464 var found: i64 = 0 - 1 465 var t: i64 = 0 466 while t < nv { 467 if vlen[t] == ve - vs { 468 var m: i64 = 0 469 var eq: i64 = 1 470 while m < ve - vs { if cq[voff[t]+m] != cq[vs+m] { eq = 0; m = ve - vs } else { m = m + 1 } } 471 if eq == 1 { found = t; t = nv } 472 } 473 t = t + 1 474 } 475 if found < 0 { 476 if nv >= DCA_VCLASS { vcap = 1 } else { voff[nv] = vs; vlen[nv] = ve - vs; vcnt[nv] = 1; nv = nv + 1 } 477 } else { vcnt[found] = vcnt[found] + 1 } 478 names = names + 1 479 } 480 j = je + 1 481 } 482 p = dca_cat(d, p, "path=" as *u8); p = dca_cat(d, p, catp) 483 p = dca_cat(d, p, " names=" as *u8); p = dca_catn(d, p, names) 484 p = dca_cat(d, p, " classes=" as *u8); p = dca_catn(d, p, nv) 485 p = dca_cat(d, p, " class_table_capped=" as *u8); p = dca_catn(d, p, vcap) 486 d[p] = DCA_CH_NL as u8; p = p + 1 487 var t2: i64 = 0 488 var csum: i64 = 0 489 while t2 < nv { 490 p = dca_cat(d, p, "CATALOG-CLASS " as *u8) 491 var m2: i64 = 0 492 while m2 < vlen[t2] { d[p] = cq[voff[t2]+m2]; p = p + 1; m2 = m2 + 1 } 493 p = dca_cat(d, p, " n=" as *u8); p = dca_catn(d, p, vcnt[t2]) 494 d[p] = DCA_CH_NL as u8; p = p + 1 495 csum = csum + vcnt[t2] 496 t2 = t2 + 1 497 } 498 p = dca_cat(d, p, "# CATALOG-PARTITION classes_sum=" as *u8); p = dca_catn(d, p, csum) 499 p = dca_cat(d, p, " names=" as *u8); p = dca_catn(d, p, names) 500 p = dca_cat(d, p, " sum_ok=" as *u8) 501 if csum == names { p = dca_catn(d, p, 1) } else { p = dca_catn(d, p, 0) } 502 } 503 } 504 d[p] = DCA_CH_NL as u8; p = p + 1 505 p = dca_cat(d, p, "ADOPTDELTA production_rows=" as *u8); p = dca_catn(d, p, nprod) 506 p = dca_cat(d, p, " d_distinct=" as *u8); p = dca_catn(d, p, dd) 507 p = dca_cat(d, p, " d_stale=" as *u8); p = dca_catn(d, p, ds) 508 p = dca_cat(d, p, " sum_ok=" as *u8) 509 var allok: i64 = 1 510 if dd != dp { allok = 0 } 511 if ds != dsp { allok = 0 } 512 if dca_sums(a) == 0 { allok = 0 } 513 if dca_sums(b2) == 0 { allok = 0 } 514 if nprod + nfix + nunk != ntot { allok = 0 } 515 p = dca_catn(d, p, allok) 516 d[p] = DCA_CH_NL as u8; p = p + 1 517 return p 518}