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

↩ module page · 244 lines · 11309 B
1// nx_emu_testbed.nx -- THE EMU TEST-MATRIX organ: which common laptop configs can the Nishi emu
2// boot VIRTUALLY on THIS machine, right now, within its resources.
3//
4// module: nishi-core.genealogy.emu_testbed
5// capability: CORE_COMPUTE (the safe S-class test bench: boot all-the-way-up + flash-a-BIOS in a
6//   disposable VM, never the host -- the never-brick law made concrete; see CLAUDE.md #26)
7//
8// THE MODEL (operator 2026-06-16): the emu exists so we can test the brickable boot chain
9// (CMOS->POST->BIOS/UEFI flash->bootloader->NishiOS->spore germination) on models of the most
10// common laptops -- VIRTUALLY, sized to whatever host the spore lands on. This organ:
11//   * PROBES the real host LIVE: MemAvailable (/proc/meminfo) + core count (/proc/cpuinfo),
12//     via sys_read_file (a read-until-EOF loop, so /proc's size-0 files read fine);
13//   * reads the laptop profiles (DATA) and computes, per profile, whether it FITS virtually here
14//     (guest RAM <= EMU_RAM_BUDGET_PCT% of host avail, vCPU <= host cores, arch emulatable);
15//   * enforces NEVER-BRICK: every profile's brickable test must run in the emu sandbox
16//     (test_mode=emu); a host-mode profile is a violation -> RED.
17// The FIT list = the spore's build/test matrix on this machine. DYNAMIC/LIVING: run it on an 8GB
18// box and fewer fit; on a 128GB workstation, all do.  Sovereign: imports only nx_syscalls.
19// license_tier: ORIGINAL
20
21import "nx_syscalls.nx"
22const LP_MAGIC_1024: i64 = 1024
23
24const LP_FILE: *u8  = "knowledge/registry/laptop_profiles.tsv"
25const TB_MEMINFO: *u8 = "/proc/meminfo"
26const TB_CPUINFO: *u8 = "/proc/cpuinfo"
27const EMU_RAM_BUDGET_PCT: i64 = 80   // a guest may use at most 80% of the host's available RAM
28
29func tb_puts(s: *u8) -> i64 { var n: i64 = 0; while s[n] != 0 as u8 { n = n + 1 } sys_write(1, s, n); return 0 }
30func tb_putn(v: i64) -> i64 {
  if v == 0 { sys_write(1, "0" as *u8, 1); return 0 }
  var m: i64 = v
  if m < 0 { sys_write(1, "-" as *u8, 1); m = 0 - m }
  let d: *u8 = sys_mmap(24); var k: i64 = 0
  while m > 0 { d[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
  var j: i64 = k - 1
  while j >= 0 { sys_write(1, ((d as i64)+j) as *u8, 1); j = j - 1 }
  return 0
39}
40func tb_strlen(s: *u8) -> i64 { var i: i64 = 0; while s[i] != 0 as u8 { i = i + 1 } return i }
41func tb_streq(a: *u8, b: *u8) -> i64 {
  var i: i64 = 0
  while a[i] != 0 as u8 { if a[i] != b[i] { return 0 } i = i + 1 }
  if b[i] != 0 as u8 { return 0 }
  return 1
46}
47func tb_atoi(s: *u8) -> i64 {
  var i: i64 = 0; var v: i64 = 0
  while s[i] != 0 as u8 {
      if s[i] >= 48 as u8 { if s[i] <= 57 as u8 { v = v * 10 + (s[i] as i64 - 48) } }
      i = i + 1
  }
  return v
54}
55
56// TAB field f (0-based) of line[ls,le) copied into a FRESH NUL-term mmap; returns ptr.
57func tb_field_dup(b: *u8, ls: i64, le: i64, f: i64) -> *u8 {
  var cur: i64 = 0
  var i: i64 = ls
  while cur < f {
      if i >= le { let e: *u8 = sys_mmap(2); e[0] = 0 as u8; return e }
      if b[i] == 9 as u8 { cur = cur + 1 }
      i = i + 1
  }
  let out: *u8 = sys_mmap(256)
  var o: i64 = 0
  while i < le {
      if b[i] == 9 as u8 { i = le } else { if o < 255 { out[o] = b[i]; o = o + 1 } i = i + 1 }
  }
  out[o] = 0 as u8
  return out
72}
73
74// does `key` (NUL-term) match buf at position pos (within [0,n))? 1/0.
75func tb_match_at(buf: *u8, pos: i64, n: i64, key: *u8) -> i64 {
  var j: i64 = 0
  while key[j] != 0 as u8 {
      if (pos + j) >= n { return 0 }
      if buf[pos + j] != key[j] { return 0 }
      j = j + 1
  }
  return 1
83}
84
85// find `key` in buf[0,n), then parse the first run of digits AFTER it. -1 if not found.
86func tb_find_int_after(buf: *u8, n: i64, key: *u8) -> i64 {
  let kl: i64 = tb_strlen(key)
  var i: i64 = 0
  while i < n {
      if tb_match_at(buf, i, n, key) == 1 {
          var p: i64 = i + kl
          var v: i64 = 0; var seen: i64 = 0; var go: i64 = 1
          while go == 1 {
              if p >= n { go = 0 }
              else {
                  let c: u8 = buf[p]
                  if c >= 48 as u8 {
                      if c <= 57 as u8 { v = v * 10 + (c as i64 - 48); seen = 1; p = p + 1 }
                      else { if seen == 1 { go = 0 } else { p = p + 1 } }
                  } else { if seen == 1 { go = 0 } else { p = p + 1 } }
              }
          }
          if seen == 1 { return v }
          return 0 - 1
      }
      i = i + 1
  }
  return 0 - 1
109}
110
111// count lines whose start matches `key` (e.g. "processor" in /proc/cpuinfo).
112func tb_count_line_prefix(buf: *u8, n: i64, key: *u8) -> i64 {
  var cnt: i64 = 0; var atline: i64 = 1; var i: i64 = 0
  while i < n {
      if atline == 1 { if tb_match_at(buf, i, n, key) == 1 { cnt = cnt + 1 } }
      if buf[i] == 10 as u8 { atline = 1 } else { atline = 0 }
      i = i + 1
  }
  return cnt
120}
121
122func tb_arch_covered(arch: *u8) -> i64 {
  if tb_streq(arch, "x86_64" as *u8) == 1 { return 1 }
  if tb_streq(arch, "aarch64" as *u8) == 1 { return 1 }
  if tb_streq(arch, "riscv64" as *u8) == 1 { return 1 }
  return 0
127}
128
129// PROBE the host + analyze the profiles file into outs. Returns 0 ok, <0 on probe/read failure.
130//   outs[0]=nprofiles outs[1]=host_avail_mb outs[2]=host_cores outs[3]=budget_mb
131//   outs[4]=fit outs[5]=too_big(resource) outs[6]=arch_uncovered outs[7]=host_mode(never-brick viol)
132func tb_analyze(pfile: *u8, outs: *i64) -> i64 {
  let mlen: *i64 = sys_mmap(16) as *i64; mlen[0] = 0
  let mbuf: *u8 = sys_read_file(TB_MEMINFO, mlen)
  if (mbuf as i64) == 0 { return 0 - 1 }
  let avail_kb: i64 = tb_find_int_after(mbuf, mlen[0], "MemAvailable:" as *u8)
  if avail_kb < 0 { return 0 - 2 }
  let avail_mb: i64 = avail_kb / LP_MAGIC_1024
139
  let clen: *i64 = sys_mmap(16) as *i64; clen[0] = 0
  let cbuf: *u8 = sys_read_file(TB_CPUINFO, clen)
  if (cbuf as i64) == 0 { return 0 - 3 }
  let cores: i64 = tb_count_line_prefix(cbuf, clen[0], "processor" as *u8)
144
  let budget_mb: i64 = avail_mb * EMU_RAM_BUDGET_PCT / 100
146
  let plen: *i64 = sys_mmap(16) as *i64; plen[0] = 0
  let pbuf: *u8 = sys_read_file(pfile, plen)
  if (pbuf as i64) == 0 { return 0 - 4 }
  let pn: i64 = plen[0]
151
  var nprof: i64 = 0; var nfit: i64 = 0; var ntoobig: i64 = 0; var nuncov: i64 = 0; var nhost: i64 = 0
  var ls: i64 = 0; var i: i64 = 0
  while i <= pn {
      var atend: i64 = 0
      if i == pn { atend = 1 }
      if i < pn { if pbuf[i] == 10 as u8 { atend = 1 } }
      if atend == 1 {
          if i > ls { if pbuf[ls] != 35 as u8 {
              nprof = nprof + 1
              let arch: *u8 = tb_field_dup(pbuf, ls, i, 1)
              let ram: i64 = tb_atoi(tb_field_dup(pbuf, ls, i, 2))
              let vcpu: i64 = tb_atoi(tb_field_dup(pbuf, ls, i, 3))
              let tmode: *u8 = tb_field_dup(pbuf, ls, i, 7)
              let covered: i64 = tb_arch_covered(arch)
              if covered == 0 { nuncov = nuncov + 1 }
              if tb_streq(tmode, "emu" as *u8) == 0 { nhost = nhost + 1 }
              var ram_ok: i64 = 0; if ram <= budget_mb { ram_ok = 1 }
              var cpu_ok: i64 = 0; if vcpu <= cores { cpu_ok = 1 }
              if ram_ok == 1 { if cpu_ok == 1 { if covered == 1 { nfit = nfit + 1 } } }
              if ram_ok == 0 { ntoobig = ntoobig + 1 } else { if cpu_ok == 0 { ntoobig = ntoobig + 1 } }
          } }
          ls = i + 1
      }
      i = i + 1
  }
  outs[0] = nprof; outs[1] = avail_mb; outs[2] = cores; outs[3] = budget_mb
  outs[4] = nfit; outs[5] = ntoobig; outs[6] = nuncov; outs[7] = nhost
  return 0
180}
181
182// print each profile's verdict using the already-probed budget_mb + cores (no re-probe).
183func tb_print_profiles(pfile: *u8, budget_mb: i64, cores: i64) -> i64 {
  let plen: *i64 = sys_mmap(16) as *i64; plen[0] = 0
  let pbuf: *u8 = sys_read_file(pfile, plen)
  if (pbuf as i64) == 0 { return 0 - 1 }
  let pn: i64 = plen[0]
  var ls: i64 = 0; var i: i64 = 0
  while i <= pn {
      var atend: i64 = 0
      if i == pn { atend = 1 }
      if i < pn { if pbuf[i] == 10 as u8 { atend = 1 } }
      if atend == 1 {
          if i > ls { if pbuf[ls] != 35 as u8 {
              let id: *u8 = tb_field_dup(pbuf, ls, i, 0)
              let arch: *u8 = tb_field_dup(pbuf, ls, i, 1)
              let ram: i64 = tb_atoi(tb_field_dup(pbuf, ls, i, 2))
              let vcpu: i64 = tb_atoi(tb_field_dup(pbuf, ls, i, 3))
              let fw: *u8 = tb_field_dup(pbuf, ls, i, 5)
              let tmode: *u8 = tb_field_dup(pbuf, ls, i, 7)
              let covered: i64 = tb_arch_covered(arch)
              var ram_ok: i64 = 0; if ram <= budget_mb { ram_ok = 1 }
              var cpu_ok: i64 = 0; if vcpu <= cores { cpu_ok = 1 }
              tb_puts("    ")
              if tb_streq(tmode, "emu" as *u8) == 0 { tb_puts("[NEVER-BRICK!host] ") }
              else { if covered == 0 { tb_puts("[UNCOVERED-arch ] ") }
              else { if ram_ok == 0 { tb_puts("[TOO-BIG: RAM   ] ") }
              else { if cpu_ok == 0 { tb_puts("[TOO-BIG: vCPU  ] ") }
              else { tb_puts("[FITS-VIRTUALLY ] ") } } } }
              tb_puts(id); tb_puts("  "); tb_puts(arch); tb_puts("  ")
              tb_putn(ram); tb_puts("MB/"); tb_putn(vcpu); tb_puts("vcpu  ")
              tb_puts(fw); tb_puts("  sandbox="); tb_puts(tmode); tb_puts("\n")
          } }
          ls = i + 1
      }
      i = i + 1
  }
  return 0
219}
220
221func main() -> i64 {
  tb_puts("=== NISHI EMU TESTBED -- which common laptops boot virtually on THIS machine ===\n")
  let outs: *i64 = sys_mmap(256) as *i64
  let rc: i64 = tb_analyze(LP_FILE, outs)
  if rc != 0 {
      tb_puts("FATAL: probe/read failed rc="); tb_putn(rc); tb_puts(" (need /proc/meminfo + /proc/cpuinfo + "); tb_puts(LP_FILE); tb_puts(")\n")
      sys_exit(1); return 1
  }
  tb_puts("  HOST (live probe): avail_RAM="); tb_putn(outs[1]); tb_puts("MB  cores="); tb_putn(outs[2])
  tb_puts("  guest_RAM_budget("); tb_putn(EMU_RAM_BUDGET_PCT); tb_puts("%)="); tb_putn(outs[3]); tb_puts("MB\n")
  tb_print_profiles(LP_FILE, outs[3], outs[2])
  tb_puts("  CENSUS: profiles="); tb_putn(outs[0])
  tb_puts(" fit_virtually_here="); tb_putn(outs[4])
  tb_puts(" too_big(resource)="); tb_putn(outs[5])
  tb_puts(" arch_uncovered="); tb_putn(outs[6])
  tb_puts(" never_brick_violations(host-mode)="); tb_putn(outs[7]); tb_puts("\n")
  if outs[7] > 0 { tb_puts("  VERDICT: NEVER-BRICK VIOLATION -- a profile tests brickable ops on HOST not the emu sandbox\n"); sys_exit(1); return 1 }
  if outs[0] == 0 { tb_puts("  VERDICT: no laptop profiles in the matrix\n"); sys_exit(1); return 1 }
  if outs[4] == 0 { tb_puts("  VERDICT: NO profile fits virtually here -- this machine lacks the RAM/cores; spore must target a bigger host\n"); sys_exit(1); return 1 }
  tb_puts("  VERDICT: "); tb_putn(outs[4]); tb_puts(" of "); tb_putn(outs[0])
  tb_puts(" common laptop configs are testable virtually on this machine (all brickable tests emu-sandboxed); ")
  if outs[5] > 0 { tb_putn(outs[5]); tb_puts(" need a bigger host = the matrix worklist\n") } else { tb_puts("full matrix fits\n") }
  sys_exit(0); return 0
244}
nx_emu_testbed.nx source

`nx_emu_testbed.nx` source
