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

↩ module page · 163 lines · 7301 B
1// nx_comprehensiveness.nx -- the FEATURE-COMPLETENESS gauge for the competitive map.  Operator: "we truly
2// wont have an s class exceed till we ... synthesize into a FEATURE-COMPLETE comprehensive competitive map."
3// So completeness is MEASURED: comprehensiveness = (capabilities WE have charted in comp_matrix) / (published
4// total per system, from incumbent_scale.tsv).  Tells us the HONEST distance to feature-complete + the harvest
5// backlog (functions still to find).  Emits -> knowledge/status/comprehensiveness.log.
6//
7// module: nishi-core.analyst.comprehensiveness
8// depends: nishi-core.sys.syscalls
9// capability: COMPETITIVE_MAP_COMPLETENESS_GAUGE
10// license_tier: ORIGINAL
11import "nx_syscalls.nx"
12import "nx_itoa_lib.nx"   // shared MSB-first emitter (zero-alloc)
13const CO_MAGIC_262144: i64 = 262144
14const CO_MAGIC_65536: i64 = 65536
15
16const CO_MATRIX: *u8 = "knowledge/registry/comp_matrix.tsv"
17const CO_SCALE:  *u8 = "knowledge/registry/incumbent_scale.tsv"
18const CO_OUT:    *u8 = "knowledge/status/comprehensiveness.log"
19
20func co_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 }
21// MIGRATED to the shared emitter (debt 1785563586). The old body mmapped a scratch buffer
22// per call and never freed it. At PAGE granularity that is 4096B leaked PER CALL -- the
23// defect that took 28.5GB of a 36GB host in nx_ts_lumadiff (2MB input, ~3.66M calls).
24// nxi_* is MSB-first, allocates NOTHING, and emits identical bytes including the sign.
25func co_wn(fd: i64, v: i64) -> i64 { nxi_fd(fd, v); return 0 }
26func co_len(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} return n }
27
28func co_read(path: *u8, buf: *u8, cap: i64) -> i64 {
29    let fd: i64 = sys_openat_rd(path)
30    if fd < 0 { return 0 }
31    var n: i64 = 0
32    var r: i64 = sys_read(fd, buf, cap - 1)
33    while r > 0 { n = n + r; if n >= cap - 1 { r = 0 } else { r = sys_read(fd, buf + n, cap - 1 - n) } }
34    sys_close(fd)
35    return n
36}
37
38func co_field(buf: *u8, ls: i64, le: i64, f: i64, dst: *u8, cap: i64) -> i64 {
39    var col: i64 = 0
40    var p: i64 = ls
41    var k: i64 = 0
42    while p < le {
43        if buf[p] == (9 as u8) { if col == f { dst[k] = 0 as u8; return k } col = col + 1; if col == f { k = 0 } }
44        else { if col == f { if k < cap - 1 { dst[k] = buf[p]; k = k + 1 } } }
45        p = p + 1
46    }
47    dst[k] = 0 as u8
48    return k
49}
50
51func co_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*10+(s[i]-48) } } i=i+1 } return v }
52
53// count comp_matrix charted features = (non-# lines) - 1 header.
54func co_charted(buf: *u8, n: i64) -> i64 {
55    var cnt: i64 = 0
56    var ls: i64 = 0
57    var i: i64 = 0
58    while i <= n {
59        var eol: i64 = 0
60        if i == n { eol = 1 } else { if buf[i] == (10 as u8) { eol = 1 } }
61        if eol == 1 {
62            if i > ls { if buf[ls] != (35 as u8) { cnt = cnt + 1 } }
63            ls = i + 1
64        }
65        i = i + 1
66    }
67    if cnt > 0 { return cnt - 1 }
68    return 0
69}
70
71func co_lc(dst: *u8, src: *u8) -> i64 { var i: i64=0; while src[i]!=(0 as u8){ var c: i64=src[i] as i64; if c>=65 { if c<=90 { c=c+32 } } dst[i]=c as u8; i=i+1 } dst[i]=0 as u8; return i }
72
73// count harvested entries in knowledge/registry/system_surface_<lower>.tsv (0 if not yet harvested).
74func co_count_surface(system: *u8) -> i64 {
75    let path: *u8 = sys_mmap(256)
76    var o: i64 = 0
77    let pre: *u8 = "knowledge/registry/system_surface_" as *u8
78    var k: i64 = 0
79    while pre[k] != (0 as u8) { path[o] = pre[k]; o = o + 1; k = k + 1 }
80    let lc: *u8 = sys_mmap(64)
81    co_lc(lc, system)
82    k = 0; while lc[k] != (0 as u8) { path[o] = lc[k]; o = o + 1; k = k + 1 }
83    let suf: *u8 = ".tsv" as *u8
84    k = 0; while suf[k] != (0 as u8) { path[o] = suf[k]; o = o + 1; k = k + 1 }
85    path[o] = 0 as u8
86    let buf: *u8 = sys_mmap(CO_MAGIC_262144)
87    let n: i64 = co_read(path, buf, CO_MAGIC_262144)
88    if n <= 0 { return 0 }
89    var cnt: i64 = 0
90    var ls: i64 = 0
91    var i: i64 = 0
92    while i <= n {
93        var eol: i64 = 0
94        if i == n { eol = 1 } else { if buf[i] == (10 as u8) { eol = 1 } }
95        if eol == 1 { if i > ls { if buf[ls] != (35 as u8) { cnt = cnt + 1 } } ls = i + 1 }
96        i = i + 1
97    }
98    return cnt
99}
100
101func main(fd_main: i64) -> i64 {
102    let mbuf: *u8 = sys_mmap(CO_MAGIC_262144)
103    let mn: i64 = co_read(CO_MATRIX, mbuf, CO_MAGIC_262144)
104    let charted: i64 = co_charted(mbuf, mn)
105
106    let sbuf: *u8 = sys_mmap(CO_MAGIC_65536)
107    let sn: i64 = co_read(CO_SCALE, sbuf, CO_MAGIC_65536)
108    if sn <= 0 { co_w(1, "COMPREHENSIVENESS verdict=RED reason=no-scale\n" as *u8); sys_exit(11); return 11 }
109
110    let sys: *u8 = sys_mmap(64)
111    let tot: *u8 = sys_mmap(32)
112
113    var p2: i64 = 0
114    while p2 < 2 {
115        var fd: i64 = 1
116        if p2 == 1 { fd = sys_openat_wr(CO_OUT, 0x1a4) }
117        if fd >= 0 {
118            co_w(fd, "== COMPETITIVE-MAP COMPLETENESS (charted=" as *u8); co_wn(fd, charted)
119            co_w(fd, " canonical capabilities) ==\n" as *u8)
120            var big_total: i64 = 0
121            var ls: i64 = 0
122            var i: i64 = 0
123            while i <= sn {
124                var eol: i64 = 0
125                if i == sn { eol = 1 } else { if sbuf[i] == (10 as u8) { eol = 1 } }
126                if eol == 1 {
127                    if i > ls { if sbuf[ls] != (35 as u8) {
128                        co_field(sbuf, ls, i, 0, sys, 64)
129                        if co_len(sys) > 0 {
130                            co_field(sbuf, ls, i, 1, tot, 32)
131                            let total: i64 = co_atoi(tot)
132                            if total > big_total { big_total = total }
133                            var charted_sys: i64 = co_count_surface(sys)
134                            var harvested: i64 = 1
135                            if charted_sys == 0 { charted_sys = charted; harvested = 0 }
136                            var permil: i64 = 0
137                            if total > 0 { permil = charted_sys * 1000 / total }
138                            var remain: i64 = total - charted_sys
139                            if remain < 0 { remain = 0 }
140                            co_w(fd, "  " as *u8); co_w(fd, sys)
141                            co_w(fd, ": published=" as *u8); co_wn(fd, total)
142                            co_w(fd, " charted=" as *u8); co_wn(fd, charted_sys)
143                            co_w(fd, " comprehensiveness_permil=" as *u8); co_wn(fd, permil)
144                            co_w(fd, " to_harvest=" as *u8); co_wn(fd, remain)
145                            if harvested == 1 { co_w(fd, " [HARVESTED]\n" as *u8) } else { co_w(fd, " [sample-only]\n" as *u8) }
146                        }
147                    } }
148                    ls = i + 1
149                }
150                i = i + 1
151            }
152            var head_permil: i64 = 0
153            if big_total > 0 { head_permil = charted * 1000 / big_total }
154            co_w(fd, "VERDICT: SAMPLE-ONLY -- " as *u8); co_wn(fd, head_permil)
155            co_w(fd, " permil comprehensive vs the largest vendor (Wolfram " as *u8); co_wn(fd, big_total)
156            co_w(fd, "); S-class-exceed knowledge requires harvesting+synthesizing the rest.\n" as *u8)
157            if p2 == 1 { sys_close(fd) }
158        }
159        p2 = p2 + 1
160    }
161    sys_exit(0)
162    return 0
163}
nx_comprehensiveness.nx source

`nx_comprehensiveness.nx` source
