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

↩ module page · 282 lines · 10274 B
1// nx_backlog_gen.nx -- X-Q-001 (w9, Q-arc): THE QUEUE FEEDS ITSELF.  v2:
2// walks knowledge/registry/census_set.tsv (path \t rung per row) so ONE
3// organ serves every census.  Each census file (contract: status \t
4// feature \t union \t evidence) contributes GEN-<rung>-<feature> queue
5// rows for ABSENT|TOY entries, IDEMPOTENT per file (substring probe
6// "\nGEN-<rung>-<feature>\t" against a fresh queue read).  Rows append in
7// ONE write each (no torn rows vs concurrent beats); trailing-newline
8// guarded.  Per-file evidence: CENSUS file=<path> rung=<rung> features=N
9// verdict=GREEN; total: BACKLOGGEN files= generated= skipped= verdict=.
10// A missing census file logs RED for that row and the roster continues
11// (fail-loud, no livelock); total verdict RED if any file failed.
12// license_tier: ORIGINAL
13import "nx_syscalls.nx"
14const BG_MAGIC_65535: i64 = 65535
15const BG_MAGIC_1000000: i64 = 1000000
16const BG_MAGIC_8192: i64 = 8192
17const BG_MAGIC_65536: i64 = 65536
18const BG_MAGIC_2048: i64 = 2048
19const BG_MAGIC_8191: i64 = 8191
20
21const BG_SET:   *u8 = "knowledge/registry/census_set.tsv"
22const BG_QUEUE: *u8 = "knowledge/registry/assignment_queue.tsv"
23const BG_LOG:   *u8 = "knowledge/status/backlog_gen.log"
24const BG_MODE:  i64 = 420
25// dedup reads the WHOLE queue into qbuf; a too-small buffer silently truncates the read so rows
26// appended past the boundary become invisible to the idempotency probe -> DUPLICATES every re-run.
27// (latent: triggered 2026-06-14 when the queue crossed 256KB.) Size generously + GUARD on truncation
28// (fail loud, never silently duplicate). Raise BG_QCAP if the guard ever fires.
29const BG_QCAP:  i64 = 8388608
30
31func bg_w(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
36}
37
38func bg_wn(fd: i64, n: i64) -> i64 {
  if n == 0 { sys_write(fd, "0" as *u8, 1); return 0 }
  var m: i64 = n
  let d: *u8 = sys_mmap(24)
  var k: i64 = 0
  while m > 0 { d[k] = (0x30 + (m % 10)) as u8; m = m / 10; k = k + 1 }
  var i: i64 = k - 1
  while i >= 0 { let o: *u8 = sys_mmap(1); o[0] = d[i]; sys_write(fd, o, 1); i = i - 1 }
  return 0
47}
48
49func bg_read_all(path: *u8, buf: *u8, cap: i64) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return 0 - 1 }
  var n: i64 = 0
  var r: i64 = 1
  while r > 0 {
      let dst: *u8 = ((buf as i64) + n) as *u8
      r = sys_read(fd, dst, cap - n)
      if r > 0 { n = n + r }
  }
  sys_close(fd)
  return n
61}
62
63func bg_app(buf: *u8, off: i64, s: *u8) -> i64 {
  var o: i64 = off
  var i: i64 = 0
  while s[i] != 0 as u8 { buf[o] = s[i]; o = o + 1; i = i + 1 }
  return o
68}
69
70func bg_appc(buf: *u8, off: i64, c: i64) -> i64 {
  buf[off] = c as u8
  return off + 1
73}
74
75func bg_appr(buf: *u8, off: i64, src: *u8, a: i64, b: i64) -> i64 {
  var o: i64 = off
  var i: i64 = a
  while i < b { buf[o] = src[i]; o = o + 1; i = i + 1 }
  return o
80}
81
82func bg_has(hay: *u8, hn: i64, nd: *u8, na: i64, nb: i64) -> i64 {
  let nn: i64 = nb - na
  if nn < 1 { return 0 }
  var i: i64 = 0
  while i + nn <= hn {
      var j: i64 = 0
      var ok: i64 = 1
      while j < nn {
          if hay[i + j] != nd[na + j] { ok = 0; j = nn } else { j = j + 1 }
      }
      if ok == 1 { return 1 }
      i = i + 1
  }
  return 0
96}
97
98func bg_find(buf: *u8, from: i64, lim: i64, c: i64) -> i64 {
  var i: i64 = from
  var done: i64 = 0
  while done == 0 {
      if i >= lim { done = 1 } else {
          if buf[i] == (c as u8) { done = 1 } else { i = i + 1 }
      }
  }
  return i
107}
108
109func bg_status_pfx(cbuf: *u8, ls: i64, le: i64) -> i64 {
  if le - ls > 7 {
      if cbuf[ls] == (65 as u8) {
          if cbuf[ls + 1] == (66 as u8) {
              if cbuf[ls + 6] == (9 as u8) { return ls + 7 }
          }
      }
  }
  if le - ls > 4 {
      if cbuf[ls] == (84 as u8) {
          if cbuf[ls + 1] == (79 as u8) {
              if cbuf[ls + 3] == (9 as u8) { return ls + 4 }
          }
      }
  }
  return 0 - 1
125}
126
127// process one census: returns gen*1000000 + skip, or -1 on read failure.
128func bg_gen_one(cpath: *u8, rung: *u8, cbuf: *u8, qbuf: *u8, row: *u8, lfd: i64) -> i64 {
  let cn: i64 = bg_read_all(cpath, cbuf, BG_MAGIC_65535)
  if cn < 1 { return 0 - 1 }
  let qn: i64 = bg_read_all(BG_QUEUE, qbuf, BG_QCAP - 1)
  if qn < 1 { return 0 - 1 }
  // truncation guard: a partial queue read blinds the dedup probe -> silent duplicates. Fail loud.
  if qn >= BG_QCAP - 1 {
      if lfd >= 0 { bg_w(lfd, "BACKLOGGEN queue-exceeds-dedup-buffer raise-BG_QCAP verdict=RED\n" as *u8) }
      bg_w(1, "BACKLOGGEN queue-exceeds-dedup-buffer raise-BG_QCAP verdict=RED\n" as *u8)
      return 0 - 1
  }
  let qfd: i64 = sys_openat_append(BG_QUEUE, BG_MODE)
  if qfd < 0 { return 0 - 1 }
  if qbuf[qn - 1] != (10 as u8) {
      let nl: *u8 = sys_mmap(1)
      nl[0] = 10 as u8
      sys_write(qfd, nl, 1)
  }
  var scanned: i64 = 0
  var gen: i64 = 0
  var skip: i64 = 0
  var ls: i64 = 0
  while ls < cn {
      let le: i64 = bg_find(cbuf, ls, cn, 10)
      if le > ls {
          if cbuf[ls] != (35 as u8) {
              scanned = scanned + 1
              let fs: i64 = bg_status_pfx(cbuf, ls, le)
              if fs >= 0 {
                  let fe: i64 = bg_find(cbuf, fs, le, 9)
                  var po: i64 = 0
                  po = bg_appc(row, po, 10)
                  po = bg_app(row, po, "GEN-" as *u8)
                  po = bg_app(row, po, rung)
                  po = bg_appc(row, po, 45)
                  po = bg_appr(row, po, cbuf, fs, fe)
                  po = bg_appc(row, po, 9)
                  if bg_has(qbuf, qn, row, 0, po) == 1 {
                      skip = skip + 1
                  } else {
                      po = bg_app(row, po, rung)
                      po = bg_appc(row, po, 9)
                      po = bg_app(row, po, "5" as *u8)
                      po = bg_appc(row, po, 9)
                      po = bg_app(row, po, "M" as *u8)
                      po = bg_appc(row, po, 9)
                      po = bg_app(row, po, "Builder" as *u8)
                      po = bg_appc(row, po, 9)
                      po = bg_app(row, po, "TODO" as *u8)
                      po = bg_appc(row, po, 9)
                      po = bg_app(row, po, "-" as *u8)
                      po = bg_appc(row, po, 9)
                      po = bg_app(row, po, "gen-" as *u8)
                      po = bg_appr(row, po, cbuf, fs, fe)
                      po = bg_app(row, po, "-gate" as *u8)
                      po = bg_appc(row, po, 9)
                      po = bg_app(row, po, "capability from census: " as *u8)
                      po = bg_appr(row, po, cbuf, fs, fe)
                      po = bg_app(row, po, " -- generated by nx_backlog_gen" as *u8)
                      po = bg_appc(row, po, 10)
                      let rp: *u8 = ((row as i64) + 1) as *u8
                      sys_write(qfd, rp, po - 1)
                      gen = gen + 1
                  }
              }
          }
      }
      ls = le + 1
  }
  sys_close(qfd)
  if lfd >= 0 {
      bg_w(lfd, "CENSUS file=" as *u8)
      bg_w(lfd, cpath)
      bg_w(lfd, " rung=" as *u8)
      bg_w(lfd, rung)
      bg_w(lfd, " features=" as *u8)
      bg_wn(lfd, scanned)
      bg_w(lfd, " generated=" as *u8)
      bg_wn(lfd, gen)
      bg_w(lfd, " verdict=GREEN\n" as *u8)
  }
  return gen * BG_MAGIC_1000000 + skip
210}
211
212func main() -> i64 {
  let setbuf: *u8 = sys_mmap(BG_MAGIC_8192)
  let cbuf: *u8 = sys_mmap(BG_MAGIC_65536)
  let qbuf: *u8 = sys_mmap(BG_QCAP)
  let row:  *u8 = sys_mmap(BG_MAGIC_2048)
  let pbuf: *u8 = sys_mmap(512)
  let rbuf: *u8 = sys_mmap(64)
  let sn: i64 = bg_read_all(BG_SET, setbuf, BG_MAGIC_8191)
  if sn < 1 { bg_w(1, "BACKLOGGEN census-set-missing verdict=RED\n" as *u8); sys_exit(1) }
  let lfd: i64 = sys_openat_append(BG_LOG, BG_MODE)
  var files: i64 = 0
  var totg: i64 = 0
  var tots: i64 = 0
  var allok: i64 = 1
  var ls: i64 = 0
  while ls < sn {
      let le: i64 = bg_find(setbuf, ls, sn, 10)
      if le > ls {
          if setbuf[ls] != (35 as u8) {
              let tb: i64 = bg_find(setbuf, ls, le, 9)
              if tb < le {
                  var i: i64 = ls
                  var o: i64 = 0
                  while i < tb { pbuf[o] = setbuf[i]; o = o + 1; i = i + 1 }
                  pbuf[o] = 0 as u8
                  i = tb + 1
                  o = 0
                  while i < le { rbuf[o] = setbuf[i]; o = o + 1; i = i + 1 }
                  rbuf[o] = 0 as u8
                  files = files + 1
                  let res: i64 = bg_gen_one(pbuf, rbuf, cbuf, qbuf, row, lfd)
                  if res < 0 {
                      allok = 0
                      if lfd >= 0 {
                          bg_w(lfd, "CENSUS file=" as *u8)
                          bg_w(lfd, pbuf)
                          bg_w(lfd, " verdict=RED\n" as *u8)
                      }
                      bg_w(1, "CENSUS-RED file=" as *u8)
                      bg_w(1, pbuf)
                      bg_w(1, "\n" as *u8)
                  } else {
                      totg = totg + res / BG_MAGIC_1000000
                      tots = tots + res % BG_MAGIC_1000000
                  }
              }
          }
      }
      ls = le + 1
  }
  if lfd >= 0 {
      bg_w(lfd, "BACKLOGGEN files=" as *u8)
      bg_wn(lfd, files)
      bg_w(lfd, " generated=" as *u8)
      bg_wn(lfd, totg)
      bg_w(lfd, " skipped=" as *u8)
      bg_wn(lfd, tots)
      if allok == 1 { bg_w(lfd, " verdict=GREEN\n" as *u8) } else { bg_w(lfd, " verdict=RED\n" as *u8) }
      sys_close(lfd)
  }
  bg_w(1, "BACKLOGGEN files=" as *u8)
  bg_wn(1, files)
  bg_w(1, " generated=" as *u8)
  bg_wn(1, totg)
  bg_w(1, " skipped=" as *u8)
  bg_wn(1, tots)
  if allok == 1 { bg_w(1, " verdict=GREEN\n" as *u8) } else { bg_w(1, " verdict=RED\n" as *u8) }
  if allok != 1 { sys_exit(1) }
  sys_exit(0)
  return 0
282}
nx_backlog_gen.nx source

`nx_backlog_gen.nx` source
