code wiki / (root) / nx_unread_sensor.nx
`nx_unread_sensor.nx` source

↩ module page · 256 lines · 11394 B
1// nx_unread_sensor.nx -- WHICH STATUS ARTIFACTS DOES NOTHING NAME.
2//
3// usage: nx_unread_sensor [statusdir]        default knowledge/status/
4// exit:  0 GREEN (single-namer count at or below its ratchet) | 1 RED (it rose) | 3 UNPROVEN
5//
6// See nx_unread_sensor_lib.nx for why this exists and for the blind spots it declares. In short: this
7// estate rediscovered "a sensor nothing reads" four times in one day, and owned no instrument that could
8// have found the fifth. Every number below is a FLOOR on readers, so a row here is a QUESTION.
9//
10// IT REFUSES TO RUN ON A SATURATED BOX. Composing ct_admit_now costs one small /proc read and no fork,
11// and the alternative is a corpus-wide scan that becomes the load it was built to explain --
12// A DIAGNOSTIC THAT CANNOT REFUSE TO RUN IS A LOAD GENERATOR WITH GOOD INTENTIONS.
13//
14// THE RATCHET SELF-BASELINES ON FIRST SIGHT, so shipping it cannot turn every build red on day one, and
15// it is written ONLY on a fall or a first run: a ratchet that rewrites its baseline on a RISE launders
16// itself green and is worse than no ratchet at all.
17// license_tier: ORIGINAL   expect_exit: 0   Read-only. No hw writes (Rule 26).
18import "nx_syscalls.nx"
19import "nx_gatekit_lib.nx"
20import "nx_ctxtop_lib.nx"
21import "nx_unread_sensor_lib.nx"
22
23const UR_MAXART: i64 = 512
24const UR_STRIDE: i64 = 96
25const UR_NAMES_BYTES: i64 = 49152          // UR_MAXART * UR_STRIDE
26const UR_I64_BYTES: i64 = 4096             // UR_MAXART * 8
27const UR_FILECAP: i64 = 262144
28const UR_PATHCAP: i64 = 1024
29const UR_CORPUS_STRIDE: i64 = 256
30const UR_DIRBUF: i64 = 65536
31const UR_DIRENT_NAME_OFF: i64 = 19
32const UR_BASELINE: *u8 = "knowledge/status/unread_sensor.baseline"
33const UR_BASELINE_NAME: *u8 = "unread_sensor.baseline"
34const UR_MODE_644: i64 = 420
35const UR_EXIT_GREEN: i64 = 0
36const UR_EXIT_RED: i64 = 1
37const UR_EXIT_UNPROVEN: i64 = 3
38const UR_NEEDLE: *u8 = "knowledge/status/"
39const UR_NEEDLE_LEN: i64 = 17
40
41func ur_puts(s: *u8) -> i64 { sys_write(1, s, us_len(s)); return 0 }
42func ur_num(v: i64) -> i64 {
  let b: *u8 = sys_mmap(32)
  var o: i64 = gk_catn(b, 0, v)
  sys_write(1, b, o)
  sys_munmap(b, 32)
  return 0
48}
49
50func main(argc: i64, argv: *i64) -> i64 {
  var sdir: *u8 = "knowledge/status/" as *u8
  if argc >= 2 { sdir = argv[1] as *u8 }
53
  // ---- ADMISSION FIRST, before a single corpus byte is read ----
  if ct_admit_now() != 1 {
      ur_puts("REFUSED-BUSY the box is saturated and this census reads the whole source corpus.\n" as *u8)
      ur_puts("Nothing was scanned, so nothing is claimed. Re-run when load clears.\n" as *u8)
      ur_puts("verdict=UNPROVEN\n" as *u8)
      return UR_EXIT_UNPROVEN
  }
61
  // ---- 1. enumerate the status artifacts ----
  let names: *u8 = sys_mmap(UR_NAMES_BYTES)
  let refs: *i64 = sys_mmap(UR_I64_BYTES) as *i64
  let lastsrc: *i64 = sys_mmap(UR_I64_BYTES) as *i64
  var nart: i64 = 0
  var art_full: i64 = 0
  let dfd: i64 = sys_openat_rd(sdir)
  if dfd < 0 {
      ur_puts("STATUSDIR-UNREADABLE " as *u8); ur_puts(sdir); ur_puts("\n" as *u8)
      ur_puts("verdict=UNPROVEN\n" as *u8)
      return UR_EXIT_UNPROVEN
  }
  let db: *u8 = sys_mmap(UR_DIRBUF)
  var go: i64 = 1
  while go == 1 {
      let nr: i64 = sys_getdents64(dfd, db, UR_DIRBUF)
      if nr <= 0 { go = 0 }
      if nr > 0 {
          var pos: i64 = 0
          while pos < nr {
              let rec: *u8 = ((db as i64) + pos) as *u8
              let rl: i64 = (rec[16] as i64) | ((rec[17] as i64) << 8)
              if rl <= 0 { pos = nr }
              if rl > 0 {
                  let nm: *u8 = ((rec as i64) + UR_DIRENT_NAME_OFF) as *u8
                  // '.' and '..' fail the name test on their own: a bare dot run is not an artifact.
                  if us_isnamechar(nm[0] as i64) == 1 {
                      if nm[0] != (US_DOT as u8) {
                          if nart < UR_MAXART {
                              let dst: *u8 = ((names as i64) + nart * UR_STRIDE) as *u8
                              var k: i64 = 0
                              while nm[k] != (0 as u8) { if k < UR_STRIDE - 1 { dst[k] = nm[k] } k = k + 1 }
                              dst[k] = 0 as u8
                              refs[nart] = 0
                              lastsrc[nart] = 0 - 1
                              nart = nart + 1
                          }
                          if nart >= UR_MAXART { art_full = 1 }
                      }
                  }
                  pos = pos + rl
              }
          }
      }
  }
  sys_munmap(db, UR_DIRBUF)
  sys_close(dfd)
109
  // ---- 2. ONE pass over the .nx corpus, counting DISTINCT namers per artifact ----
  let maxlen: *i64 = sys_mmap(64) as *i64
  let ncorp: i64 = gk_corpus_count(maxlen)
  if ncorp <= 0 {
      ur_puts("CORPUS-UNREADABLE the source tree could not be enumerated, so absence cannot be proven.\n" as *u8)
      ur_puts("verdict=UNPROVEN\n" as *u8)
      return UR_EXIT_UNPROVEN
  }
  let paths: *u8 = sys_mmap(ncorp * UR_CORPUS_STRIDE + UR_CORPUS_STRIDE)
  let got: i64 = gk_corpus_scan(paths, UR_CORPUS_STRIDE, ncorp + 1)
  let fbuf: *u8 = sys_mmap(UR_FILECAP)
  let tok: *u8 = sys_mmap(US_NAMECAP)
  var scanned: i64 = 0
  var truncated: i64 = 0
  var unreadable: i64 = 0
  var si: i64 = 0
  while si < got {
      let p: *u8 = ((paths as i64) + si * UR_CORPUS_STRIDE) as *u8
      // THE READ IS SIZED FROM THE FILE, NOT FROM A CAP. The first cut used a 256 KB buffer and 8 of
      // 19,391 sources overflowed it, turning a whole-corpus census into a partial one and making every
      // absence UNPROVEN. The fix for a cap you hit is to MEASURE THE INPUT, never to pick a bigger
      // number: sys_read_file lseeks to END, sizes its own buffer, and cannot short-read.
      let flen: *i64 = sys_mmap(64) as *i64
      let fb: *u8 = sys_read_file(p, flen)
      if fb == (0 as *u8) { unreadable = unreadable + 1 }
      if fb != (0 as *u8) {
          let tot: i64 = flen[0]
          let fbuf: *u8 = fb
          scanned = scanned + 1
          var at: i64 = 0
          var fgo: i64 = 1
          while fgo == 1 {
              let h: i64 = us_find_from(fbuf, tot, at, UR_NEEDLE)
              if h < 0 { fgo = 0 }
              if h >= 0 {
                  let tl: i64 = us_name_at(fbuf, tot, h + UR_NEEDLE_LEN, tok, US_NAMECAP)
                  if tl > 0 {
                      let ix: i64 = us_tbl_find(names, UR_STRIDE, nart, tok)
                      if ix >= 0 {
                          // count each SOURCE once per artifact: a file that names the same artifact
                          // five times is one namer, and counting mentions would flatter every row.
                          if lastsrc[ix] != si { refs[ix] = refs[ix] + 1; lastsrc[ix] = si }
                      }
                  }
                  at = h + UR_NEEDLE_LEN
              }
          }
          sys_munmap(fb, tot + 16)
      }
      sys_munmap(flen as *u8, 64)
      si = si + 1
  }
162
  // ---- 3. classify, print the worklist, reconcile the partition ----
  var c_none: i64 = 0
  var c_single: i64 = 0
  var c_several: i64 = 0
  var c_shard: i64 = 0
  var c_self: i64 = 0
  ur_puts("=== NX-UNREAD-SENSOR: status artifacts nothing else names ===\n" as *u8)
  var ai: i64 = 0
  while ai < nart {
      let nm: *u8 = ((names as i64) + ai * UR_STRIDE) as *u8
      var cls: i64 = us_classify(nm, refs[ai])
      if us_is_self(nm, UR_BASELINE_NAME) == 1 { cls = US_CLASS_SEVERAL; c_self = 1 }
      if cls == US_CLASS_NONE { c_none = c_none + 1 }
      if cls == US_CLASS_SINGLE { c_single = c_single + 1 }
      if cls == US_CLASS_SEVERAL { c_several = c_several + 1 }
      if cls == US_CLASS_SHARD { c_shard = c_shard + 1 }
      if cls != US_CLASS_SEVERAL { if cls != US_CLASS_SHARD {
          ur_puts("  " as *u8); ur_puts(us_class_name(cls))
          ur_puts(" namers=" as *u8); ur_num(refs[ai])
          ur_puts("  " as *u8); ur_puts(nm)
          ur_puts("\n" as *u8)
      } }
      ai = ai + 1
  }
  let csum: i64 = c_none + c_single + c_several + c_shard
  ur_puts("artifacts=" as *u8); ur_num(nart)
  ur_puts(" no_literal_reference=" as *u8); ur_num(c_none)
  ur_puts(" single_namer=" as *u8); ur_num(c_single)
  ur_puts(" named_by_several=" as *u8); ur_num(c_several)
  ur_puts(" store_family=" as *u8); ur_num(c_shard)
  ur_puts(" self_bookkeeping_excluded=" as *u8); ur_num(c_self)
  ur_puts(" sum=" as *u8); ur_num(csum)
  ur_puts("\n" as *u8)
  ur_puts("corpus_declared=" as *u8); ur_num(ncorp)
  ur_puts(" scanned=" as *u8); ur_num(scanned)
  ur_puts(" unreadable=" as *u8); ur_num(unreadable)
  ur_puts(" truncated_at_cap=" as *u8); ur_num(truncated)
  ur_puts(" corpus_complete=" as *u8)
  var complete: i64 = 1
  if unreadable > 0 { complete = 0 }
  if art_full == 1 { complete = 0 }
  if scanned != got { complete = 0 }
  ur_num(complete)
  ur_puts("\n" as *u8)
  if art_full == 1 { ur_puts("ARTIFACT-TABLE-FULL the counts above are a FLOOR, not a total\n" as *u8) }
  if complete == 0 { ur_puts("COVERAGE-PARTIAL at least one source was unreadable or read only to its cap, so a NO-LITERAL-REFERENCE row is UNPROVEN rather than absent\n" as *u8) }
209
  // ---- 4. the ratchet ----
  let bb: *u8 = sys_mmap(64)
  let bfd: i64 = sys_openat_rd(UR_BASELINE)
  var base: i64 = 0 - 1
  if bfd >= 0 {
      let bn: i64 = sys_read(bfd, bb, 63)
      sys_close(bfd)
      if bn > 0 {
          bb[bn] = 0 as u8
          var v: i64 = 0
          var bi: i64 = 0
          var any: i64 = 0
          while bi < bn {
              let c: i64 = bb[bi] as i64
              if c >= US_D0 { if c <= US_D9 { v = v * 10 + (c - US_D0); any = 1 } }
              bi = bi + 1
          }
          if any == 1 { base = v }
      }
  }
  var rc: i64 = UR_EXIT_GREEN
  // A ratchet may only be rewritten on a FALL or on a first sight. Rewriting it on a RISE is how a
  // detector launders itself green, and it is the one mutation that makes the whole thing decorative.
  var write_base: i64 = 0
  if base < 0 { write_base = 1 }
  if base >= 0 { if c_single < base { write_base = 1 } }
  if base >= 0 { if c_single > base { rc = UR_EXIT_RED } }
  if complete == 0 { rc = UR_EXIT_UNPROVEN }
  if write_base == 1 {
      let wfd: i64 = sys_openat_wr(UR_BASELINE, UR_MODE_644)
      if wfd >= 0 {
          let ob: *u8 = sys_mmap(64)
          var oo: i64 = gk_catn(ob, 0, c_single)
          ob[oo] = 10 as u8
          sys_write(wfd, ob, oo + 1)
          sys_close(wfd)
      }
  }
  ur_puts("ratchet baseline=" as *u8); ur_num(base)
  ur_puts(" current=" as *u8); ur_num(c_single)
  ur_puts(" rewritten=" as *u8); ur_num(write_base)
  ur_puts("\n" as *u8)
  if rc == UR_EXIT_GREEN { ur_puts("verdict=GREEN\n" as *u8) }
  if rc == UR_EXIT_RED { ur_puts("verdict=RED the single-namer count ROSE above its baseline -- a new sensor was shipped with nothing reading it\n" as *u8) }
  if rc == UR_EXIT_UNPROVEN { ur_puts("verdict=UNPROVEN coverage was partial, so the count is a floor and the ratchet is not judged\n" as *u8) }
  return rc
256}
nx_unread_sensor.nx source

`nx_unread_sensor.nx` source
