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

↩ module page · 231 lines · 10997 B
1// nx_bite_sweep.nx -- run the non-vacuity proof across every declared gate of a domain (closes seq1366).
2//
3// nx_gate_bite answers "can THIS gate fail?" for one gate. This is the orchestration around it: walk a
4// domain's .gates, take each row's declared SUBJECT (field 3), and require every gate to kill a mutant.
5// Single responsibility kept separate on purpose (rule 9) -- measuring one gate and driving a fleet are
6// different jobs, and folding them into one organ is how a measurement tool grows a scheduler.
7//
8// ★NO SILENT CAPS. A row with no declared subject is reported as NO-SUBJECT and counted against the
9// domain, never skipped quietly. That distinction is the whole point: a gate we did not test and a gate
10// that cannot fail must not look the same in the output, or the sweep becomes the very thing it audits.
11//
12// ★WHY THE SUBJECT IS DECLARED, NOT DERIVED: the obvious convention (nx_X_gate.elf -> runtime/nx_X.nx) is
13// wrong often enough to matter -- nx_raci_gate's subject is runtime/_hdl_build/nx_raci.nx. A guessed path
14// that fails to open produces "no mutant killed", which reads identically to a vacuous gate. Guessing here
15// would manufacture false accusations against working gates.
16//
17// usage: nx_bite_sweep <domain> [max_sites]   (CWD = nxc2 root)
18// exit 0 = every declared gate BITES · 1 = at least one vacuous or untestable · 2 = usage/no gates
19// license_tier: ORIGINAL
20import "nx_syscalls.nx"
21import "nx_artifact_root.nx"
22const BS_MAGIC_65536: i64 = 65536
23const BS_MAGIC_65535: i64 = 65535
24
25const BS_MAXROW: i64 = 2048
26
27func w(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
28func wn(v: i64) -> i64 { let t: *u8=sys_mmap(28); var m: i64=v; 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} let b: *u8=sys_mmap(28); var i: i64=0; while i<k{b[i]=t[k-1-i];i=i+1} sys_write(1,b,k); return 0 }
29func wf(fd: i64, s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(fd,s,n); return 0 }
30func wnf(fd: i64, v: i64) -> i64 { let t: *u8=sys_mmap(28); var m: i64=v; 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} let b: *u8=sys_mmap(28); var i: i64=0; while i<k{b[i]=t[k-1-i];i=i+1} sys_write(fd,b,k); return 0 }
31
32func bs_read(path: *u8, buf: *u8, cap: i64) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return 0 - 1 }
  var tot: i64 = 0
  var go: i64 = 1
  while go == 1 {
      let n: i64 = sys_read(fd, ((buf as i64)+tot) as *u8, cap - tot)
      if n <= 0 { go = 0 } else { tot = tot + n; if tot >= cap { go = 0 } }
  }
  sys_close(fd)
  return tot
43}
44
45// copy field `want` (0-based, '|' separated) of buf[s..e) into out; returns its length (0 if absent)
46func bs_field(buf: *u8, s: i64, e: i64, want: i64, out: *u8, cap: i64) -> i64 {
  var f: i64 = 0
  var i: i64 = s
  var fs: i64 = s
  while i <= e {
      var cut: i64 = 0
      if i == e { cut = 1 } else { if buf[i] == (124 as u8) { cut = 1 } }
      if cut == 1 {
          if f == want {
              var n: i64 = i - fs
              if n >= cap { n = cap - 1 }
              var k: i64 = 0
              while k < n { out[k] = buf[fs+k]; k = k + 1 }
              out[n] = 0 as u8
              return n
          }
          f = f + 1
          fs = i + 1
      }
      i = i + 1
  }
  out[0] = 0 as u8
  return 0
69}
70
71// gate TARGET name from an elf path: strip directory, strip a trailing ".elf"
72func bs_target(elf: *u8, out: *u8) -> i64 {
  var n: i64 = 0
  while elf[n] != (0 as u8) { n = n + 1 }
  var s: i64 = 0
  var i: i64 = 0
  while i < n { if elf[i] == (47 as u8) { s = i + 1 } i = i + 1 }
  var e: i64 = n
  if n >= 4 { if elf[n-4] == (46 as u8) { e = n - 4 } }
  var o: i64 = 0
  var k: i64 = s
  while k < e { out[o] = elf[k]; o = o + 1; k = k + 1 }
  out[o] = 0 as u8
  return o
85}
86
87// fork nx_gate_bite <target> <subject> <sites>; return its exit code (0 = BITES)
88func bs_run(bite: *u8, target: *u8, subject: *u8, sites: *u8, outpath: *u8) -> i64 {
  let pid: i64 = sys_fork()
  if pid == 0 {
      let ofd: i64 = sys_openat_wr(outpath, 0x1a4)
      if ofd >= 0 { sys_dup3(ofd, 1, 0); sys_dup3(ofd, 2, 0) }
      let argv: *i64 = sys_mmap(48) as *i64
      argv[0] = bite as i64
      argv[1] = target as i64
      argv[2] = subject as i64
      argv[3] = sites as i64
      argv[4] = 0
      let envp: *i64 = sys_mmap(16) as *i64
      envp[0] = 0
      sys_execve(bite, argv, envp)
      sys_exit(127)
  }
  let stp: *i64 = sys_mmap(16) as *i64
  sys_wait4(pid, stp, 0)
  let sig: i64 = stp[0] & 0x7f
  if sig != 0 { return 128 + sig }
  return (stp[0] >> 8) & 0xff
109}
110
111func main(argc: i64, argv: *i64) -> i64 {
  if argc < 2 { w("usage: nx_bite_sweep <domain> [max_sites]\n" as *u8); sys_exit(2); return 2 }
  let domain: *u8 = argv[1] as *u8
  let sites: *u8 = "4\x00" as *u8
  var sitesp: *u8 = sites
  if argc > 2 { sitesp = argv[2] as *u8 }
117
  w("=== nx_bite_sweep -- every declared gate must be proven able to FAIL ===\n" as *u8)
  w("  domain=" as *u8); w(domain); w("  max_sites_per_gate=" as *u8); w(sitesp); w("\n" as *u8)
120
  let gp: *u8 = sys_mmap(256)
  var o: i64 = 0
  let pre: *u8 = "knowledge/compare/"
  var q: i64 = 0
  while pre[q] != (0 as u8) { gp[o] = pre[q]; o = o + 1; q = q + 1 }
  q = 0
  while domain[q] != (0 as u8) { gp[o] = domain[q]; o = o + 1; q = q + 1 }
  let sfx: *u8 = ".gates"
  q = 0
  while sfx[q] != (0 as u8) { gp[o] = sfx[q]; o = o + 1; q = q + 1 }
  gp[o] = 0 as u8
132
  let gbuf: *u8 = sys_mmap(BS_MAGIC_65536)
  let gn: i64 = bs_read(gp, gbuf, BS_MAGIC_65535)
  if gn <= 0 { w("  NO GATES FILE for this domain\n" as *u8); sys_exit(2); return 2 }
136
  // Resolve the bite organ itself through the shared root table -- it is `_offc/` on a dev tree and flat
  // at the serving root after a promote, exactly like every other artifact.
  let bite: *u8 = sys_mmap(512)
  if ar_resolve("_offc/nx_gate_bite.elf" as *u8, bite) == 0 {
      w("  CANNOT RESOLVE nx_gate_bite.elf -- build/promote it first\n" as *u8); sys_exit(2); return 2
  }
143
  let elf: *u8 = sys_mmap(512)
  let subj: *u8 = sys_mmap(512)
  let tgt: *u8 = sys_mmap(512)
  let outp: *u8 = "knowledge/status/bite_sweep_run.out\x00" as *u8
  var declared: i64 = 0
  var bites: i64 = 0
  var vacuous: i64 = 0
  var nosubj: i64 = 0
152
  var ls: i64 = 0
  var p: i64 = 0
  while p <= gn {
      var eol: i64 = 0
      if p == gn { eol = 1 } else { if gbuf[p] == (10 as u8) { eol = 1 } }
      if eol == 1 {
          if p > ls { if gbuf[ls] != (35 as u8) {
              let el: i64 = bs_field(gbuf, ls, p, 0, elf, 512)
              if el > 0 {
                  declared = declared + 1
                  let sl: i64 = bs_field(gbuf, ls, p, 3, subj, 512)
                  bs_target(elf, tgt)
                  w("  " as *u8); w(tgt); w(": " as *u8)
                  if sl <= 0 {
                      nosubj = nosubj + 1
                      w("NO-SUBJECT (row declares no source to mutate -- counted, not skipped)\n" as *u8)
                  } else {
                      // Name the three non-BITES outcomes separately. They demand different work:
                      // INCONCLUSIVE = widen the site budget or pick better mutation targets;
                      // UNCONTROLLED = fix the gate's baseline first, nothing is attributable until then;
                      // RESTORE-FAILED = stop everything, the corpus may be damaged.
                      let rc: i64 = bs_run(bite, tgt, subj, sitesp, outp)
                      if rc == 0 { bites = bites + 1; w("BITES" as *u8) } else {
                          vacuous = vacuous + 1
                          if rc == 1 { w("INCONCLUSIVE (no kill in budget -- not proof of vacuity)" as *u8) } else {
                              if rc == 2 { w("UNCONTROLLED (gate not green at baseline)" as *u8) } else {
                                  if rc == 3 { w("RESTORE-FAILED (CORPUS AT RISK)" as *u8) } else {
                                      // rc 4 = the row NAMES a subject we cannot open. Distinct from the
                                      // sl<=0 branch above (no field at all) and emphatically distinct from
                                      // UNCONTROLLED: the gate is not accused, the CONFIG is. Counted as
                                      // no_subject so the tally points at the .gates file, not the fleet.
                                      if rc == 4 { vacuous = vacuous - 1; nosubj = nosubj + 1
                                          w("SUBJECT-UNREADABLE (.gates 4th field names a file that cannot be opened -- CONFIG fault, gate NOT implicated)" as *u8)
                                      } else { w("ERROR (exit " as *u8); wn(rc); w(")" as *u8) }
                                  }
                              }
                          }
                      }
                      w("  subject=" as *u8); w(subj); w("\n" as *u8)
                  }
              }
          } }
          ls = p + 1
      }
      p = p + 1
  }
199
  w("  declared=" as *u8); wn(declared); w(" bites=" as *u8); wn(bites)
  w(" not_proven=" as *u8); wn(vacuous); w(" no_subject=" as *u8); wn(nosubj); w("\n" as *u8)
202
  let lp: *u8 = sys_mmap(256)
  o = 0
  let lpre: *u8 = "knowledge/status/bite_sweep_"
  q = 0
  while lpre[q] != (0 as u8) { lp[o] = lpre[q]; o = o + 1; q = q + 1 }
  q = 0
  while domain[q] != (0 as u8) { lp[o] = domain[q]; o = o + 1; q = q + 1 }
  let lsfx: *u8 = ".log"
  q = 0
  while lsfx[q] != (0 as u8) { lp[o] = lsfx[q]; o = o + 1; q = q + 1 }
  lp[o] = 0 as u8
  let lfd: i64 = sys_openat_wr(lp, 0x1a4)
  if lfd >= 0 {
      wf(lfd, "NX-BITE-SWEEP domain=" as *u8); wf(lfd, domain)
      wf(lfd, " declared=" as *u8); wnf(lfd, declared)
      wf(lfd, " bites=" as *u8); wnf(lfd, bites)
      wf(lfd, " not_proven=" as *u8); wnf(lfd, vacuous)
      wf(lfd, " no_subject=" as *u8); wnf(lfd, nosubj)
      wf(lfd, " epoch=" as *u8); wnf(lfd, sys_now_realtime_sec())
      wf(lfd, "\n" as *u8)
      if declared > 0 { if bites == declared { wf(lfd, "VERDICT=GREEN every declared gate proven able to fail\n" as *u8) } else { wf(lfd, "VERDICT=RED a declared gate is not proven able to fail (inconclusive, uncontrolled, or no declared subject)\n" as *u8) } } else { wf(lfd, "VERDICT=RED no declared gates\n" as *u8) }
      sys_close(lfd)
  }
226
  if declared > 0 { if bites == declared { w("VERDICT: verdict=GREEN (every declared gate BITES)\n" as *u8); sys_exit(0); return 0 } }
  w("VERDICT: verdict=RED (a declared gate is NOT PROVEN ABLE TO FAIL -- inconclusive, uncontrolled, or no declared subject; none of these is a proof of vacuity)\n" as *u8)
  sys_exit(1)
  return 1
231}
nx_bite_sweep.nx source

`nx_bite_sweep.nx` source
