nx_galx_models.nx source
↩ module page · 112 lines · 5521 B
1// nx_galx_models.nx -- SOVEREIGN "who is who" index for recordings. The cam archive is foldered by person
2// (/mnt/nas_logging/<model>/<file>.ts), so each recording's parent-directory name IS the identity. This
3// scans knowledge/status/galx_vid_paths.tsv, extracts every recording's model (parent folder), counts per
4// model, and writes knowledge/status/galx_models.tsv = "<model>\t<count>" sorted by count DESC. The daemon
5// serves this as /api/models and filters recordings by &model=<name>. NishiLang only. license_tier: ORIGINAL
6import "nx_syscalls.nx"
7import "nx_itoa_lib.nx" // shared MSB-first emitter (zero-alloc)
8const K_MAGIC_1024: i64 = 1024
9
10const MAXM: i64 = 40000 // max distinct models
11const NAMEBUF: i64 = 4194304 // bytes for unique model names
12
13func mo_p(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
14// MIGRATED to the shared emitter (debt 1785563586). The old body mmapped a scratch buffer
15// per call and never freed it. At PAGE granularity that is 4096B leaked PER CALL -- the
16// defect that took 28.5GB of a 36GB host in nx_ts_lumadiff (2MB input, ~3.66M calls).
17// nxi_* is MSB-first, allocates NOTHING, and emits identical bytes including the sign.
18func mo_n(v: i64) -> i64 { nxi_out(v); return 0 }
19// compare model name at nb+off (len) with line bytes at buf+ps (plen); equal?
20func mo_eq(nb: *u8, off: i64, len: i64, buf: *u8, ps: i64, plen: i64) -> i64 {
21 if len != plen { return 0 }
22 var i: i64 = 0
23 while i < len { if nb[off+i] != buf[ps+i] { return 0 } i = i + 1 }
24 return 1
25}
26func mo_sift(idx: *i64, key: *i64, root0: i64, n: i64) -> i64 {
27 var root: i64 = root0; var go: i64 = 1
28 while go == 1 { let c: i64 = 2*root+1; if c >= n { go = 0 } else { var s: i64 = root; if key[idx[s]] < key[idx[c]] { s = c } if c+1 < n { if key[idx[s]] < key[idx[c+1]] { s = c+1 } } if s == root { go = 0 } else { let t: i64=idx[root]; idx[root]=idx[s]; idx[s]=t; root = s } } }
29 return 0
30}
31func mo_heapsort(idx: *i64, key: *i64, n: i64) -> i64 {
32 if n < 2 { return 0 }
33 var st: i64 = n/2 - 1
34 while st >= 0 { mo_sift(idx, key, st, n); st = st - 1 }
35 var e: i64 = n - 1
36 while e > 0 { let t: i64=idx[0]; idx[0]=idx[e]; idx[e]=t; mo_sift(idx, key, 0, e); e = e - 1 }
37 return 0
38}
39
40func main() -> i64 {
41 let szp: *i64 = sys_mmap(16) as *i64
42 let buf: *u8 = sys_read_file("knowledge/status/galx_vid_paths.tsv" as *u8, szp)
43 let sz: i64 = szp[0]
44 if (buf as i64) == 0 { mo_p("MODELS FAIL: no vid index\n" as *u8); sys_exit(1); return 1 }
45 let nb: *u8 = sys_mmap(NAMEBUF) // unique model name bytes
46 var nbo: i64 = 0
47 let moff: *i64 = sys_mmap(8 * MAXM) as *i64
48 let mlen: *i64 = sys_mmap(8 * MAXM) as *i64
49 let mcnt: *i64 = sys_mmap(8 * MAXM) as *i64
50 var nm: i64 = 0
51 var ls: i64 = 0
52 var i: i64 = 0
53 while i <= sz {
54 var nl: i64 = 0
55 if i == sz { nl = 1 } else { if buf[i] == (10 as u8) { nl = 1 } }
56 if nl == 1 {
57 if i - ls > 3 {
58 // parent folder = bytes between the 2nd-last and last '/'
59 var last: i64 = 0 - 1
60 var prev: i64 = 0 - 1
61 var p: i64 = ls
62 while p < i { if buf[p] == (47 as u8) { prev = last; last = p } p = p + 1 }
63 if prev >= 0 { if last > prev {
64 let ps: i64 = prev + 1
65 let plen: i64 = last - ps
66 if plen > 0 {
67 // find existing
68 var found: i64 = 0 - 1
69 var m: i64 = 0
70 while m < nm { if mo_eq(nb, moff[m], mlen[m], buf, ps, plen) == 1 { found = m; m = nm } else { m = m + 1 } }
71 if found >= 0 { mcnt[found] = mcnt[found] + 1 } else {
72 if nm < MAXM { if nbo + plen < NAMEBUF {
73 var c: i64 = 0
74 while c < plen { nb[nbo+c] = buf[ps+c]; c = c + 1 }
75 moff[nm] = nbo; mlen[nm] = plen; mcnt[nm] = 1; nbo = nbo + plen; nm = nm + 1
76 } }
77 }
78 }
79 } }
80 }
81 ls = i + 1
82 }
83 i = i + 1
84 }
85 // sort models by count DESC
86 let idx: *i64 = sys_mmap(8 * MAXM) as *i64
87 var j: i64 = 0; while j < nm { idx[j] = j; j = j + 1 }
88 mo_heapsort(idx, mcnt, nm) // ascending; emit reversed for desc
89 let fd: i64 = sys_openat_wr("knowledge/status/galx_models.tsv" as *u8, 0x1a4)
90 if fd < 0 { mo_p("MODELS FAIL: cannot write\n" as *u8); sys_exit(1); return 1 }
91 let line: *u8 = sys_mmap(K_MAGIC_1024)
92 var r: i64 = nm - 1
93 while r >= 0 {
94 let mi: i64 = idx[r]
95 var lo: i64 = 0
96 var c: i64 = 0
97 while c < mlen[mi] { line[lo] = nb[moff[mi]+c]; lo = lo + 1; c = c + 1 }
98 line[lo] = 9 as u8; lo = lo + 1
99 var cnt: i64 = mcnt[mi]
100 let tmp: *u8 = sys_mmap(28); var tk: i64 = 0
101 if cnt == 0 { tmp[0]=48; tk=1 }
102 while cnt > 0 { tmp[tk] = (48 + (cnt % 10)) as u8; cnt = cnt / 10; tk = tk + 1 }
103 var z: i64 = 0; while z < tk { line[lo] = tmp[tk-1-z]; lo = lo + 1; z = z + 1 }
104 line[lo] = 10 as u8; lo = lo + 1
105 sys_write(fd, line, lo)
106 r = r - 1
107 }
108 sys_close(fd)
109 mo_p("MODELS OK distinct=" as *u8); mo_n(nm); mo_p(" -> knowledge/status/galx_models.tsv\n" as *u8)
110 sys_exit(0)
111 return 0
112}