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

↩ module page · 249 lines · 13068 B
1// nx_nofloat_qgap_probe.nx -- THE QUANTISATION-GAP INSTRUMENT (2026-09-17, search R0s): does the served W12A12 (i8)
2// route generate what the lossless i32 route generates? Same model file, same prompts, GREEDY decoding, so the only
3// variable left is the arithmetic. The oracle scores biology 408 and the sovereign i8 pass 352 with two different
4// samplers, so that gap cannot say whether quantisation is the cause; this can. Two processes because a 16 GB VM
5// holds one weight cache beside the running engine:
6//   nx_nofloat_qgap_probe run i32|i8|q8 <model.gguf> <queries.tsv> <nq> <max_new> <outdir>   -- one file per prompt
7//   nx_nofloat_qgap_probe compare <outdir> <nq> [ref_prefix] [arm]                                           -- the agreement, as values
8// It is an INSTRUMENT: the teeth assert that every prompt produced both arms and that the comparator can see a
9// planted difference; the gap itself is printed, never judged, so a large gap cannot be argued away by a threshold.
10import "nx_syscalls.nx"
11import "nx_nofloat_serve_core.nx"
12import "nx_gate_verdict.nx"
13
14const QG_OUT_CAP: i64 = 8192
15const QG_GP_SLOTS: i64 = 16
16const QG_META_SLOTS: i64 = 8
17const QG_MODE_I32: i64 = 0
18const QG_MODE_I8: i64 = 1
19const QG_MODE_Q8: i64 = 3    // search R0s: the resident block-native route (NSV_MODE_Q4K's slot tables over a Q8_0 gguf)
20const QG_PROMPT_CAP: i64 = 4096
21const QG_PATH_CAP: i64 = 512
22const QG_PERMIL: i64 = 1000
23const QG_SEED: i64 = 1
24const QG_FILE_MODE: i64 = 420
25const QG_DEC: i64 = 10
26const QG_ASCII_0: i64 = 48
27const QG_INSTR: *u8 = "Rewrite the following question as a focused web search query that names the underlying scientific concepts. Question: " as *u8
28
29func qg_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
30func qg_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 } d[p] = 0 as u8; return p }
31func qg_catn(d: *u8, o: i64, v0: i64) -> i64 {
  var p: i64 = o
  var v: i64 = v0
  if v < 0 { d[p] = 45 as u8; p = p + 1; v = 0 - v }
  if v == 0 { d[p] = 48 as u8; p = p + 1; d[p] = 0 as u8; return p }
  var pw: i64 = 1
  while v / pw >= QG_DEC { pw = pw * QG_DEC }
  while pw > 0 { d[p] = (QG_ASCII_0 + ((v / pw) % QG_DEC)) as u8; p = p + 1; pw = pw / QG_DEC }
  d[p] = 0 as u8
  return p
41}
42func qg_atoi(s: *u8) -> i64 { var v: i64 = 0; var i: i64 = 0; while s[i] != (0 as u8) { if s[i] >= (48 as u8) { if s[i] <= (57 as u8) { v = v * QG_DEC + ((s[i] - (48 as u8)) as i64) } } i = i + 1 } return v }
43func qg_streq(a: *u8, b: *u8) -> i64 { var i: i64 = 0; while a[i] == b[i] { if a[i] == (0 as u8) { return 1 } i = i + 1 } return 0 }
44func qg_putsn(b: *u8, n: i64) { if n > 0 { sys_write(1, b, n) } }
45// the idx-th line's second TAB field copied into out (cap-1 bytes at most); returns its length, -1 when absent
46func qg_query(buf: *u8, n: i64, idx: i64, out: *u8, cap: i64) -> i64 {
  var line: i64 = 0
  var i: i64 = 0
  while i < n {
      if line == idx {
          var j: i64 = i
          var go: i64 = 1
          while go == 1 { if j < n { if buf[j] == (9 as u8) { go = 0 } else { if buf[j] == (10 as u8) { go = 0 } else { j = j + 1 } } } else { go = 0 } }
          if j >= n { return 0 - 1 }
          if buf[j] != (9 as u8) { return 0 - 1 }
          j = j + 1
          var o: i64 = 0
          var go2: i64 = 1
          while go2 == 1 { if j < n { if buf[j] == (10 as u8) { go2 = 0 } else { if buf[j] == (13 as u8) { go2 = 0 } else { if o < cap - 1 { out[o] = buf[j]; o = o + 1 } j = j + 1 } } } else { go2 = 0 } }
          out[o] = 0 as u8
          return o
      }
      if buf[i] == (10 as u8) { line = line + 1 }
      i = i + 1
  }
  return 0 - 1
67}
68// <outdir>/q<idx>.<arm>.<ext>
69func qg_path(out: *u8, dir: *u8, idx: i64, arm: *u8, ext: *u8) -> i64 {
  var o: i64 = qg_cat(out, 0, dir)
  o = qg_cat(out, o, "/q" as *u8)
  o = qg_catn(out, o, idx)
  o = qg_cat(out, o, "." as *u8)
  o = qg_cat(out, o, arm)
  o = qg_cat(out, o, "." as *u8)
  o = qg_cat(out, o, ext)
  return o
78}
79func qg_write(path: *u8, buf: *u8, n: i64) -> i64 {
  let fd: i64 = sys_openat_wr(path, QG_FILE_MODE)
  if fd < 0 { return 0 - 1 }
  var w: i64 = 0
  if n > 0 { w = sys_write(fd, buf, n) }
  sys_close(fd)
  return w
86}
87
88func qg_run(argc: i64, argv: *i64, ctr: *i64) -> i64 {
  if argc < 8 { gv_puts("usage: nx_nofloat_qgap_probe run i32|i8|q8 <model.gguf> <queries.tsv> <nq> <max_new> <outdir>\n" as *u8); return 2 }
  let arm: *u8 = argv[2] as *u8
  let mpath: *u8 = argv[3] as *u8
  let qpath: *u8 = argv[4] as *u8
  let nq: i64 = qg_atoi(argv[5] as *u8)
  let maxnew: i64 = qg_atoi(argv[6] as *u8)
  let outdir: *u8 = argv[7] as *u8
  var mode: i64 = 0 - 1
  if qg_streq(arm, "i32" as *u8) == 1 { mode = QG_MODE_I32 }
  if qg_streq(arm, "i8" as *u8) == 1 { mode = QG_MODE_I8 }
  if qg_streq(arm, "q8" as *u8) == 1 { mode = QG_MODE_Q8 }
  gv_need("arm-is-i32-or-i8" as *u8, (mode >= 0) as i64, ctr)
  var ir: i64 = 0 - 1
  if mode == QG_MODE_I32 { ir = nsv_init_i32only(mpath) } else { if mode == QG_MODE_Q8 { ir = nsv_init_q4k(mpath) } else { ir = nsv_init_i8(mpath) } }
  gv_need("model-initialised" as *u8, (ir == 0) as i64, ctr)
  let qlen: *i64 = sys_mmap(16) as *i64
  let qbuf: *u8 = sys_read_file(qpath, qlen)
  gv_need("queries-readable" as *u8, (qlen[0] > 0) as i64, ctr)
  let qtext: *u8 = sys_mmap(QG_PROMPT_CAP)
  let prompt: *u8 = sys_mmap(QG_PROMPT_CAP + QG_PROMPT_CAP)
  let out: *u8 = sys_mmap(QG_OUT_CAP)
  let meta: *i64 = sys_mmap(QG_META_SLOTS * 8) as *i64
  let gp: *i64 = sys_mmap(QG_GP_SLOTS * 8) as *i64
  let pbuf: *u8 = sys_mmap(QG_PATH_CAP)
  let mbuf: *u8 = sys_mmap(QG_PATH_CAP)
  let kbuf: *u8 = sys_mmap(QG_PATH_CAP)
  var allok: i64 = 1
  var done: i64 = 0
  var i: i64 = 0
  while i < nq {
      let ql: i64 = qg_query(qbuf, qlen[0], i, qtext, QG_PROMPT_CAP)
      if ql > 0 {
          var pl: i64 = qg_cat(prompt, 0, QG_INSTR)
          pl = qg_cat(prompt, pl, qtext)
          gp[0] = prompt as i64; gp[1] = pl; gp[2] = maxnew; gp[3] = mode
          gp[4] = out as i64; gp[5] = QG_OUT_CAP; gp[6] = meta as i64
          gp[7] = 0; gp[8] = 0; gp[9] = 0; gp[10] = 0; gp[11] = QG_SEED; gp[12] = 1
          let n: i64 = nsv_generate(gp)
          if n <= 0 { allok = 0 }
          qg_path(pbuf, outdir, i, arm, "out" as *u8)
          qg_write(pbuf, out, n)
          var mo: i64 = qg_cat(mbuf, 0, "tokens=" as *u8)
          mo = qg_catn(mbuf, mo, meta[1])
          mo = qg_cat(mbuf, mo, " ms=" as *u8)
          mo = qg_catn(mbuf, mo, meta[2])
          mo = qg_cat(mbuf, mo, " prompt_tokens=" as *u8)
          mo = qg_catn(mbuf, mo, meta[0])
          mo = qg_cat(mbuf, mo, " bytes=" as *u8)
          mo = qg_catn(mbuf, mo, n)
          mo = qg_cat(mbuf, mo, "\n" as *u8)
          qg_path(pbuf, outdir, i, arm, "meta" as *u8)
          qg_write(pbuf, mbuf, mo)
          var ko: i64 = qg_cat(kbuf, 0, "q" as *u8); ko = qg_catn(kbuf, ko, i); ko = qg_cat(kbuf, ko, "_" as *u8); ko = qg_cat(kbuf, ko, arm); ko = qg_cat(kbuf, ko, "_ms" as *u8)
          gv_kv(kbuf, meta[2])
          ko = qg_cat(kbuf, 0, "q" as *u8); ko = qg_catn(kbuf, ko, i); ko = qg_cat(kbuf, ko, "_" as *u8); ko = qg_cat(kbuf, ko, arm); ko = qg_cat(kbuf, ko, "_tokens" as *u8)
          gv_kv(kbuf, meta[1])
          ko = qg_cat(kbuf, 0, "q" as *u8); ko = qg_catn(kbuf, ko, i); ko = qg_cat(kbuf, ko, "_" as *u8); ko = qg_cat(kbuf, ko, arm); ko = qg_cat(kbuf, ko, "_bytes" as *u8)
          gv_kv(kbuf, n)
          done = done + 1
      }
      i = i + 1
  }
  gv_kv("prompts_run" as *u8, done)
  gv_check("T1 every prompt generated on this arm (no error code, bytes written)" as *u8, allok, ctr)
  gv_check_eq("T2 the prompt count reached the request" as *u8, done, nq, ctr)
  let rc: i64 = gv_verdict("NOFLOAT-QGAP-RUN" as *u8, ctr, "one arm of the quantisation-gap instrument: greedy continuations written per prompt" as *u8)
  gv_exit(rc)   // the base-class exit: the pool workers die with the verdict
  return rc
157}
158
159func qg_common(a: *u8, an: i64, b: *u8, bn: i64) -> i64 {
  var n: i64 = an
  if bn < n { n = bn }
  var i: i64 = 0
  while i < n { if a[i] != b[i] { return i } i = i + 1 }
  return n
165}
166
167func qg_compare(argc: i64, argv: *i64, ctr: *i64) -> i64 {
  if argc < 4 { gv_puts("usage: nx_nofloat_qgap_probe compare <outdir> <nq> [ref_prefix] [arm]\n" as *u8); return 2 }
  let outdir: *u8 = argv[2] as *u8
  let nq: i64 = qg_atoi(argv[3] as *u8)
  // optional 4th arg: a REFERENCE PREFIX for the lossless arm (<prefix>q<i>.i32.out), so a host that cannot hold the
  // i32 cache compares its served route against continuations banked once on a host that could
  var hasref: i64 = 0
  var refpfx: *u8 = "" as *u8
  if argc >= 5 { hasref = 1; refpfx = argv[4] as *u8 }
  // optional 5th arg: the arm under test (default i8) -- the R0s block-native route compares as q8
  var carm: *u8 = "i8" as *u8
  if argc >= 6 { carm = argv[5] as *u8 }
  let pa: *u8 = sys_mmap(QG_PATH_CAP)
  let pb: *u8 = sys_mmap(QG_PATH_CAP)
  let la: *i64 = sys_mmap(16) as *i64
  let lb: *i64 = sys_mmap(16) as *i64
  let kbuf: *u8 = sys_mmap(QG_PATH_CAP)
  var both: i64 = 0
  var identical: i64 = 0
  var permil_sum: i64 = 0
  var first_div_sum: i64 = 0
  var i: i64 = 0
  while i < nq {
      if hasref == 1 { var ro: i64 = qg_cat(pa, 0, refpfx); ro = qg_cat(pa, ro, "q" as *u8); ro = qg_catn(pa, ro, i); qg_cat(pa, ro, ".i32.out" as *u8) } else { qg_path(pa, outdir, i, "i32" as *u8, "out" as *u8) }
      qg_path(pb, outdir, i, carm, "out" as *u8)
      let a: *u8 = sys_read_file(pa, la)
      let b: *u8 = sys_read_file(pb, lb)
      if la[0] > 0 { if lb[0] > 0 {
          both = both + 1
          let c: i64 = qg_common(a, la[0], b, lb[0])
          var longest: i64 = la[0]
          if lb[0] > longest { longest = lb[0] }
          var same: i64 = 0
          if la[0] == lb[0] { if c == la[0] { same = 1 } }
          identical = identical + same
          permil_sum = permil_sum + (c * QG_PERMIL) / longest
          first_div_sum = first_div_sum + c
          var ko: i64 = qg_cat(kbuf, 0, "q" as *u8); ko = qg_catn(kbuf, ko, i); ko = qg_cat(kbuf, ko, "_identical" as *u8)
          gv_kv(kbuf, same)
          ko = qg_cat(kbuf, 0, "q" as *u8); ko = qg_catn(kbuf, ko, i); ko = qg_cat(kbuf, ko, "_common_prefix_bytes" as *u8)
          gv_kv(kbuf, c)
          ko = qg_cat(kbuf, 0, "q" as *u8); ko = qg_catn(kbuf, ko, i); ko = qg_cat(kbuf, ko, "_i32_bytes" as *u8)
          gv_kv(kbuf, la[0])
          ko = qg_cat(kbuf, 0, "q" as *u8); ko = qg_catn(kbuf, ko, i); ko = qg_cat(kbuf, ko, "_" as *u8); ko = qg_cat(kbuf, ko, carm); ko = qg_cat(kbuf, ko, "_bytes" as *u8)
          gv_kv(kbuf, lb[0])
          gv_puts("  q" as *u8); gv_num(i); gv_puts(" i32: " as *u8); qg_putsn(a, la[0]); gv_puts("\n" as *u8)
          gv_puts("  q" as *u8); gv_num(i); gv_puts(" " as *u8); gv_puts(carm); gv_puts(":  " as *u8); qg_putsn(b, lb[0]); gv_puts("\n" as *u8)
      } }
      i = i + 1
  }
  gv_kv("prompts" as *u8, nq)
  gv_kv("both_arms_present" as *u8, both)
  gv_kv("identical_continuations" as *u8, identical)
  var mp: i64 = 0
  if both > 0 { mp = permil_sum / both }
  gv_kv("mean_common_prefix_permil" as *u8, mp)
  var mf: i64 = 0
  if both > 0 { mf = first_div_sum / both }
  gv_kv("mean_common_prefix_bytes" as *u8, mf)
  gv_check_eq("T1 both arms present for every prompt" as *u8, both, nq, ctr)
  // neg-control: the comparator sees a planted difference
  let x: *u8 = sys_mmap(64)
  let y: *u8 = sys_mmap(64)
  var k: i64 = 0
  while k < 32 { x[k] = (65 + (k % 26)) as u8; y[k] = x[k]; k = k + 1 }
  y[17] = 33 as u8
  gv_check_eq("neg-control-T2 a planted byte at offset 17 stops the common prefix at 17" as *u8, qg_common(x, 32, y, 32), 17, ctr)
  gv_check_eq("T2b identical buffers share their whole length" as *u8, qg_common(x, 32, x, 32), 32, ctr)
  let rc: i64 = gv_verdict("NOFLOAT-QGAP" as *u8, ctr, "the lossless i32 route vs the served i8 route on the same prompts, greedy: agreement printed as values, never judged by a threshold" as *u8)
  gv_exit(rc)
  return rc
238}
239
240func main(argc: i64, argv: *i64) -> i64 {
  let ctr: *i64 = gv_ctr()
  gv_head("=== nx_nofloat_qgap_probe: the lossless i32 route vs the served i8 route, greedy, same prompts ===" as *u8)
  if argc < 2 { gv_puts("usage: nx_nofloat_qgap_probe run i32|i8|q8 <model.gguf> <queries.tsv> <nq> <max_new> <outdir> | compare <outdir> <nq> [ref_prefix] [arm]\n" as *u8); return 2 }
  let verb: *u8 = argv[1] as *u8
  if qg_streq(verb, "run" as *u8) == 1 { return qg_run(argc, argv, ctr) }
  if qg_streq(verb, "compare" as *u8) == 1 { return qg_compare(argc, argv, ctr) }
  gv_puts("unknown verb (run | compare)\n" as *u8)
  return 2
249}
nx_nofloat_qgap_probe.nx source

`nx_nofloat_qgap_probe.nx` source
