`nx_swarm_tile.nx` source

↩ module page · 387 lines · 15585 B
1// nx_swarm_tile.nx -- SWARM FABRIC chunk EXECUTOR (SF-R3 real-artifact): a sovereign, embarrassingly-
2// parallel image generator. Each "chunk" = a horizontal BAND of a fixed-point Mandelbrot render; bands
3// are INDEPENDENT (no cross-tile state) = the exact workload class the operator named (3D render / Monte
4// Carlo / brute-force). The job engine (nx_swarm_job) stays GENERIC -- it leases opaque chunk ids; THIS
5// organ turns chunk id -> real pixels; a DRIVER wires place->lease->render->complete->assemble (rule 9).
6// Proves the north-star "generate an image by combining/parallelizing across the fabric" with REAL output
7// (was SIMULATED in the SF-R3 gate). When remote workers join, the SAME job engine dispatches the SAME
8// bands to them -- distribution is placement, already proven; this is the executor + assembler.
9//
10//   render   <W> <H> <ntiles> <tile_id> <outdir>          -- render band tile_id -> outdir/tile_<id>.raw (RGB)
11//   assemble <W> <H> <ntiles> <outdir> <out.ppm>          -- stitch bands in order -> a real P6 PPM image
12//   [gate]                                                -- self-gate: determinism + structure + coverage + size
13// Fully integer (Q16 fixed-point escape-time) -> bit-identical across any device (the sovereign EXCEED axis:
14// float raster is non-deterministic across hardware). outdir: bare name or under /tmp/. license_tier: ORIGINAL
15import "nx_swarm_lib.nx"
16const T_MAGIC_1048576: i64 = 1048576
17const T_MAGIC_65536: i64 = 65536
18
19const T_SCALE:   i64 = 65536      // Q16
20const T_MAXITER: i64 = 128
21const T_ESCAPE:  i64 = 262144     // 4 << 16  (|z|^2 > 4)
22// complex window (Q16): real [-2.5, 1.0], imag [-1.25, 1.25]
23const T_XMIN:    i64 = 0 - 163840 // -2.5 * 65536
24const T_XSPAN:   i64 = 229376     //  3.5 * 65536
25const T_YMIN:    i64 = 0 - 81920  // -1.25 * 65536
26const T_YSPAN:   i64 = 163840     //  2.5 * 65536
27
28func tl_puts(s: *u8) -> i64 { sys_write(1, s, fa_len(s)); return 0 }
29func tl_eq(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
34}
35
36// outdir guard: bare basename OR under /tmp/, no ".."
37func tl_dir_ok(p: *u8) -> i64 {
  let n: i64 = fa_len(p)
  if n < 1 { return 0 }
  var i: i64 = 0
  while i + 1 < n { if (p[i] as i64) == 46 { if (p[i+1] as i64) == 46 { return 0 } } i = i + 1 }
  var slash: i64 = 0
  i = 0
  while i < n { if (p[i] as i64) == 47 { slash = 1 } i = i + 1 }
  if slash == 0 { return 1 }
  if n < 4 { return 0 }
  if (p[0] as i64) != 47 { return 0 }
  if (p[1] as i64) != 116 { return 0 }
  if (p[2] as i64) != 109 { return 0 }
  if (p[3] as i64) != 112 { return 0 }
  if n == 4 { return 1 }
  if (p[4] as i64) != 47 { return 0 }
  return 1
54}
55
56// escape-time iteration count for c=(cre,cim) in Q16 fixed-point. Returns iters (0..T_MAXITER).
57func tl_iter(cre: i64, cim: i64) -> i64 {
  var zr: i64 = 0
  var zi: i64 = 0
  var it: i64 = 0
  var go: i64 = 1
  while go == 1 {
      if it >= T_MAXITER { go = 0 } else {
          let zr2: i64 = (zr * zr) / T_SCALE      // zr^2 in Q16
          let zi2: i64 = (zi * zi) / T_SCALE
          if zr2 + zi2 > T_ESCAPE { go = 0 } else {
              let nzr: i64 = zr2 - zi2 + cre        // zr' = zr^2 - zi^2 + cre
              let cross: i64 = (zr * zi) / T_SCALE
              let nzi: i64 = cross + cross + cim    // zi' = 2*zr*zi + cim
              zr = nzr
              zi = nzi
              it = it + 1
          }
      }
  }
  return it
77}
78
79// color for an iteration count -> rgb[0..2]. In-set (it==MAXITER) = black; else banded palette.
80func tl_color(it: i64, rgb: *u8) -> i64 {
  if it >= T_MAXITER {
      rgb[0] = 0 as u8; rgb[1] = 0 as u8; rgb[2] = 0 as u8
      return 0
  }
  rgb[0] = ((it * 8) % 256) as u8
  rgb[1] = ((it * 5) % 256) as u8
  rgb[2] = ((64 + it * 11) % 256) as u8
  return 0
89}
90
91// band row range for tile_id of ntiles over height H: [y0, y1).
92func tl_y0(H: i64, ntiles: i64, tid: i64) -> i64 { return tid * H / ntiles }
93func tl_y1(H: i64, ntiles: i64, tid: i64) -> i64 { return (tid + 1) * H / ntiles }
94
95// build "<dir>/tile_<id>.raw" into out.
96func tl_tile_path(dir: *u8, tid: i64, out: *u8) -> i64 {
  var o: i64 = 0
  o = fa_cat(out, o, dir)
  out[o] = 47 as u8; o = o + 1
  o = fa_cat(out, o, "tile_" as *u8)
  o = fa_catn(out, o, tid)
  o = fa_cat(out, o, ".raw" as *u8)
  out[o] = 0 as u8
  return o
105}
106
107func tl_write_all(fd: i64, buf: *u8, n: i64) -> i64 {
  var off: i64 = 0
  while off < n {
      let w: i64 = sys_write(fd, (buf as i64 + off) as *u8, n - off)
      if w <= 0 { return 0 - 1 }
      off = off + w
  }
  return 0
115}
116
117// render band tid -> outdir/tile_<tid>.raw (RGB rows for [y0,y1)). Returns bytes written or -1.
118func tl_render(W: i64, H: i64, ntiles: i64, tid: i64, outdir: *u8) -> i64 {
  let y0: i64 = tl_y0(H, ntiles, tid)
  let y1: i64 = tl_y1(H, ntiles, tid)
  let rows: i64 = y1 - y0
  if rows <= 0 { return 0 }
  let nbytes: i64 = rows * W * 3
  let buf: *u8 = sys_mmap(nbytes + 16)
  let rgb: *u8 = sys_mmap(8)
  var py: i64 = y0
  var bo: i64 = 0
  while py < y1 {
      let cim: i64 = T_YMIN + (py * T_YSPAN) / H
      var px: i64 = 0
      while px < W {
          let cre: i64 = T_XMIN + (px * T_XSPAN) / W
          let it: i64 = tl_iter(cre, cim)
          tl_color(it, rgb)
          buf[bo] = rgb[0]; buf[bo+1] = rgb[1]; buf[bo+2] = rgb[2]
          bo = bo + 3
          px = px + 1
      }
      py = py + 1
  }
  let path: *u8 = sys_mmap(512)
  tl_tile_path(outdir, tid, path)
  let fd: i64 = sys_openat_wr(path, 0x1a4)
  if fd < 0 { return 0 - 1 }
  let wr: i64 = tl_write_all(fd, buf, bo)
  sys_close(fd)
  if wr < 0 { return 0 - 1 }
  return bo
149}
150
151// assemble: write P6 PPM header + concat tile_0.raw..tile_{n-1}.raw -> outfile. Returns total bytes or -1.
152func tl_assemble(W: i64, H: i64, ntiles: i64, outdir: *u8, outfile: *u8) -> i64 {
  let fd: i64 = sys_openat_wr(outfile, 0x1a4)
  if fd < 0 { return 0 - 1 }
  // header "P6\n<W> <H>\n255\n"
  let hdr: *u8 = sys_mmap(64)
  var ho: i64 = 0
  ho = fa_cat(hdr, ho, "P6\n" as *u8)
  ho = fa_catn(hdr, ho, W)
  hdr[ho] = 32 as u8; ho = ho + 1
  ho = fa_catn(hdr, ho, H)
  hdr[ho] = 10 as u8; ho = ho + 1
  ho = fa_cat(hdr, ho, "255\n" as *u8)
  if tl_write_all(fd, hdr, ho) < 0 { sys_close(fd); return 0 - 1 }
  var total: i64 = ho
  let path: *u8 = sys_mmap(512)
  let rbuf: *u8 = sys_mmap(T_MAGIC_1048576)   // 1 MiB streaming
  var tid: i64 = 0
  var ok: i64 = 1
  while tid < ntiles {
      if ok == 1 {
          tl_tile_path(outdir, tid, path)
          let rfd: i64 = sys_openat_rd(path)
          if rfd < 0 { ok = 0 } else {
              var go: i64 = 1
              while go == 1 {
                  let r: i64 = sys_read(rfd, rbuf, T_MAGIC_1048576)
                  if r <= 0 { go = 0 } else {
                      if tl_write_all(fd, rbuf, r) < 0 { go = 0; ok = 0 }
                      total = total + r
                  }
              }
              sys_close(rfd)
          }
      }
      tid = tid + 1
  }
  sys_close(fd)
  if ok == 0 { return 0 - 1 }
  return total
191}
192
193// count distinct byte-triples in a file (bounded) -> a cheap "has structure" probe.
194func tl_distinct_colors(path: *u8, cap: i64) -> i64 {
  let buf: *u8 = sys_mmap(cap + 16)
  let n: i64 = sb_read(path, buf, cap)
  if n < 3 { return 0 }
  // sample: count how many pixels differ from pixel 0 (structure => >0)
  let r0: i64 = buf[0] as i64
  let g0: i64 = buf[1] as i64
  let b0: i64 = buf[2] as i64
  var diff: i64 = 0
  var i: i64 = 3
  while i + 2 < n {
      if (buf[i] as i64) != r0 { diff = diff + 1 } else { if (buf[i+1] as i64) != g0 { diff = diff + 1 } else { if (buf[i+2] as i64) != b0 { diff = diff + 1 } } }
      i = i + 3
  }
  return diff
209}
210
211func tl_filesize(path: *u8) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return 0 - 1 }
  var tot: i64 = 0
  let b: *u8 = sys_mmap(T_MAGIC_65536)
  var go: i64 = 1
  while go == 1 {
      let r: i64 = sys_read(fd, b, T_MAGIC_65536)
      if r <= 0 { go = 0 } else { tot = tot + r }
  }
  sys_close(fd)
  return tot
223}
224
225func tl_gate() -> i64 {
  var pass: i64 = 0
  var total: i64 = 0
  let now: i64 = sys_now_us()
  // fresh outdir under /tmp
  let dir: *u8 = sys_mmap(256)
  var od: i64 = 0
  od = fa_cat(dir, od, "/tmp/tile_" as *u8); od = fa_catn(dir, od, now); dir[od] = 0 as u8
  __syscall(258, AT_FDCWD, dir as i64, 0x1ff, 0, 0, 0)   // mkdirat 0777 (raw: SYS_MKDIRAT not in nx_syscalls)
234
  let W: i64 = 64
  let H: i64 = 48
  let NT: i64 = 4
238
  // T1 render all bands -> each writes rows*W*3 bytes; coverage sums to H
  total = total + 1
  var covered: i64 = 0
  var allok: i64 = 1
  var tid: i64 = 0
  while tid < NT {
      let got: i64 = tl_render(W, H, NT, tid, dir)
      let rows: i64 = tl_y1(H, NT, tid) - tl_y0(H, NT, tid)
      if got != rows * W * 3 { allok = 0 }
      covered = covered + rows
      tid = tid + 1
  }
  if allok == 1 { if covered == H { pass = pass + 1; tl_puts("T1 render+coverage OK\n" as *u8) } }
252
  // T2 assemble -> PPM size == header + W*H*3
  total = total + 1
  let ppm: *u8 = sys_mmap(256)
  var po: i64 = 0
  po = fa_cat(ppm, po, dir); ppm[po] = 47 as u8; po = po + 1
  po = fa_cat(ppm, po, "out.ppm" as *u8); ppm[po] = 0 as u8
  let asz: i64 = tl_assemble(W, H, NT, dir, ppm)
  let fsz: i64 = tl_filesize(ppm)
  // header len for 64x48: "P6\n64 48\n255\n" = 3+2+1+2+1+4 = 13
  let pixbytes: i64 = W * H * 3
  var t2: i64 = 0
  if asz == fsz { if fsz > pixbytes { if fsz < pixbytes + 32 { t2 = 1 } } }
  if t2 == 1 { pass = pass + 1; tl_puts("T2 assemble-size OK\n" as *u8) }
266
  // T3 STRUCTURE: the fractal is not a flat color (distinct pixels > 0, and a lot)
  total = total + 1
  let diff: i64 = tl_distinct_colors(ppm, pixbytes + 64)
  if diff > 100 { pass = pass + 1; tl_puts("T3 has-structure OK\n" as *u8) }
271
  // T4 DETERMINISM (the sovereign EXCEED axis): re-render a band -> byte-identical to the first
  total = total + 1
  let dir2: *u8 = sys_mmap(256)
  var o2: i64 = 0
  o2 = fa_cat(dir2, o2, "/tmp/tile2_" as *u8); o2 = fa_catn(dir2, o2, now); dir2[o2] = 0 as u8
  __syscall(258, AT_FDCWD, dir2 as i64, 0x1ff, 0, 0, 0)   // mkdirat 0777
  tl_render(W, H, NT, 1, dir2)
  let p1: *u8 = sys_mmap(512)
  let p2: *u8 = sys_mmap(512)
  tl_tile_path(dir, 1, p1)
  tl_tile_path(dir2, 1, p2)
  let b1: *u8 = sys_mmap(T_MAGIC_65536)
  let b2: *u8 = sys_mmap(T_MAGIC_65536)
  let n1: i64 = sb_read(p1, b1, T_MAGIC_65536)
  let n2: i64 = sb_read(p2, b2, T_MAGIC_65536)
  var iden: i64 = 0
  if n1 == n2 { if n1 > 0 {
      var k: i64 = 0
      var same: i64 = 1
      while k < n1 { if b1[k] != b2[k] { same = 0; k = n1 } else { k = k + 1 } }
      if same == 1 { iden = 1 }
  } }
  if iden == 1 { pass = pass + 1; tl_puts("T4 deterministic OK\n" as *u8) }
295
  // T5 the SET is present: some pixels are black (in-set, it==MAXITER) -> the render is a real Mandelbrot
  total = total + 1
  let buf: *u8 = sys_mmap(pixbytes + 128)
  let nn: i64 = sb_read(ppm, buf, pixbytes + 128)
  var black: i64 = 0
  var i: i64 = 13   // skip header
  while i + 2 < nn { if (buf[i] as i64) == 0 { if (buf[i+1] as i64) == 0 { if (buf[i+2] as i64) == 0 { black = black + 1 } } } i = i + 3 }
  if black > 20 { pass = pass + 1; tl_puts("T5 mandelbrot-set-present OK\n" as *u8) }
304
  let t: *u8 = sys_mmap(128)
  var to: i64 = 0
  to = fa_cat(t, to, "SWARMTILEGATE " as *u8)
  to = fa_catn(t, to, pass)
  to = fa_cat(t, to, "/" as *u8)
  to = fa_catn(t, to, total)
  if pass == total { to = fa_cat(t, to, " verdict=GREEN\n" as *u8) } else { to = fa_cat(t, to, " verdict=RED\n" as *u8) }
  sys_write(1, t, to)
  if pass == total { return 0 }
  return 1
315}
316
317// ASCII preview to stdout (no files) -- makes the sovereign render visible in a terminal/chat.
318func tl_preview(W: i64, H: i64) -> i64 {
  let ramp: *u8 = " .:-=+*o#@" as *u8   // 10 chars, low iter -> high iter; in-set = '@'
  let line: *u8 = sys_mmap(W + 2)
  var py: i64 = 0
  while py < H {
      let cim: i64 = T_YMIN + (py * T_YSPAN) / H
      var px: i64 = 0
      while px < W {
          let cre: i64 = T_XMIN + (px * T_XSPAN) / W
          let it: i64 = tl_iter(cre, cim)
          var idx: i64 = it * 9 / T_MAXITER
          if idx > 9 { idx = 9 }
          line[px] = ramp[idx]
          px = px + 1
      }
      line[W] = 10 as u8
      sys_write(1, line, W + 1)
      py = py + 1
  }
  return 0
338}
339
340func main(argc: i64, argv: *i64) -> i64 {
  if argc >= 2 {
      let verb: *u8 = argv[1] as *u8
      let vout: *i64 = sys_mmap(16) as *i64
      let pend: *i64 = sys_mmap(16) as *i64
      if tl_eq(verb, "preview" as *u8) == 1 {
          var W: i64 = 78
          var H: i64 = 30
          if argc >= 4 {
              sb_pint(argv[2] as *u8, fa_len(argv[2] as *u8), 0, vout, pend); W = vout[0]
              sb_pint(argv[3] as *u8, fa_len(argv[3] as *u8), 0, vout, pend); H = vout[0]
          }
          return tl_preview(W, H)
      }
      if tl_eq(verb, "render" as *u8) == 1 {
          if argc < 7 { tl_puts("usage: nx_swarm_tile render <W> <H> <ntiles> <tile_id> <outdir>\n" as *u8); return 2 }
          sb_pint(argv[2] as *u8, fa_len(argv[2] as *u8), 0, vout, pend); let W: i64 = vout[0]
          sb_pint(argv[3] as *u8, fa_len(argv[3] as *u8), 0, vout, pend); let H: i64 = vout[0]
          sb_pint(argv[4] as *u8, fa_len(argv[4] as *u8), 0, vout, pend); let NT: i64 = vout[0]
          sb_pint(argv[5] as *u8, fa_len(argv[5] as *u8), 0, vout, pend); let TID: i64 = vout[0]
          let dir: *u8 = argv[6] as *u8
          if tl_dir_ok(dir) == 0 { tl_puts("SWARMTILE render REFUSED (dir law)\n" as *u8); return 3 }
          let r: i64 = tl_render(W, H, NT, TID, dir)
          if r < 0 { tl_puts("SWARMTILE render IO-FAIL\n" as *u8); return 4 }
          let t: *u8 = sys_mmap(96)
          var o: i64 = fa_cat(t, 0, "SWARMTILE rendered tile=" as *u8)
          o = fa_catn(t, o, TID); o = fa_cat(t, o, " bytes=" as *u8); o = fa_catn(t, o, r); o = fa_cat(t, o, "\n" as *u8)
          sys_write(1, t, o)
          return 0
      }
      if tl_eq(verb, "assemble" as *u8) == 1 {
          if argc < 7 { tl_puts("usage: nx_swarm_tile assemble <W> <H> <ntiles> <outdir> <out.ppm>\n" as *u8); return 2 }
          sb_pint(argv[2] as *u8, fa_len(argv[2] as *u8), 0, vout, pend); let W: i64 = vout[0]
          sb_pint(argv[3] as *u8, fa_len(argv[3] as *u8), 0, vout, pend); let H: i64 = vout[0]
          sb_pint(argv[4] as *u8, fa_len(argv[4] as *u8), 0, vout, pend); let NT: i64 = vout[0]
          let dir: *u8 = argv[5] as *u8
          if tl_dir_ok(dir) == 0 { tl_puts("SWARMTILE assemble REFUSED (dir law)\n" as *u8); return 3 }
          let r: i64 = tl_assemble(W, H, NT, dir, argv[6] as *u8)
          if r < 0 { tl_puts("SWARMTILE assemble IO-FAIL\n" as *u8); return 4 }
          let t: *u8 = sys_mmap(96)
          var o: i64 = fa_cat(t, 0, "SWARMTILE assembled bytes=" as *u8)
          o = fa_catn(t, o, r); o = fa_cat(t, o, "\n" as *u8)
          sys_write(1, t, o)
          return 0
      }
  }
  return tl_gate()
387}
nx_swarm_tile.nx source

`nx_swarm_tile.nx` source
