code wiki / _hdl_build / nx_self_tune.nx
nx_self_tune.nx source
↩ module page · 164 lines · 8910 B
1// nx_self_tune.nx -- LOCAL-ONLY DRIVER SELF-TUNE (X-DRV-F3).
2//
3// The privacy-preserving counterpart to the federated registry (X-DRV-F2): a NON-SHARING spore
4// improves its own drivers using the SAME emitter + measurement, but the learnings NEVER leave the
5// device -- no telemetry, no phone-home. It sweeps the candidate configs for each device on its
6// OWN emu, measures emu-steps, and keeps the fastest as its tuned local registry.
7//
8// nx_self_tune [candidates_path]
9// candidates : local_tune_candidates.tsv (deviceid <TAB> config_spec <TAB> config_bin)
10// -> knowledge/registry/driver_registry_tuned_local.tsv (deviceid -> best local config + steps)
11// -> knowledge/status/self_tune.log (SELFTUNE: per-device best, configs swept; NO shared writes)
12// Touches ONLY local files (emit/run/registry/log). Sovereign, no gcc/.sh. license_tier: ORIGINAL
13import "nx_syscalls.nx"
14const ST_MAGIC_65536: i64 = 65536
15
16const ST_EMIT: *u8 = "_offc/nx_drv_proto_emit.elf"
17const ST_SOV: *u8 = "_offc/nx_boot_run_sov.elf"
18const ST_OUT: *u8 = "knowledge/registry/driver_registry_tuned_local.tsv"
19const ST_LOG: *u8 = "knowledge/status/self_tune.log"
20const ST_MAXDEV: i64 = 32
21
22func st_p(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
23func st_fp(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 }
24func st_fn(fd: i64, v: i64) -> i64 { let bb: *u8=sys_mmap(28); var m: i64=v; if m<0{m=0-m}; let t: *u8=sys_mmap(28); var k: i64=0; if m==0{t[0]=48;k=1}; while m>0{t[k]=(48+(m%10)) as u8;m=m/10;k=k+1}; var i: i64=0; while i<k{bb[i]=t[k-1-i];i=i+1}; sys_write(fd,bb,k); return 0 }
25func st_n(v: i64) -> i64 { st_fn(1, v); return 0 }
26
27func st_run(prog: *u8, a1: *u8, outpath: *u8) -> i64 {
28 let pid: i64 = sys_fork()
29 if pid == 0 {
30 if outpath != (0 as *u8) { let ofd: i64 = sys_openat_wr(outpath, 0x1a4); if ofd >= 0 { sys_dup3(ofd, 1, 0); sys_dup3(ofd, 2, 0) } }
31 let argv: *i64 = sys_mmap(32) as *i64
32 argv[0] = prog as i64
33 var k: i64 = 1
34 if a1 != (0 as *u8) { argv[k] = a1 as i64; k = k + 1 }
35 argv[k] = 0
36 let envp: *i64 = sys_mmap(16) as *i64
37 envp[0] = "PATH=/usr/bin:/bin" as *u8 as i64; envp[1] = 0
38 sys_execve(prog, argv, envp)
39 sys_exit(127)
40 }
41 let st: *i64 = sys_mmap(16) as *i64
42 sys_wait4(pid, st, 0)
43 let sg: i64 = st[0] & 0x7f
44 if sg != 0 { return 128 + sg }
45 return (st[0] >> 8) & 0xff
46}
47
48func st_read(path: *u8, buf: *u8, cap: i64) -> i64 {
49 let fd: i64 = sys_openat_rd(path)
50 if fd < 0 { return 0 - 1 }
51 var n: i64 = 0
52 var go: i64 = 1
53 while go == 1 { let r: i64 = sys_read(fd, (buf as i64 + n) as *u8, cap - 1 - n); if r <= 0 { go = 0 } else { n = n + r } if n >= cap - 1 { go = 0 } }
54 sys_close(fd)
55 return n
56}
57
58func st_parse_steps(buf: *u8, n: i64) -> i64 {
59 var i: i64 = 0
60 while i + 6 <= n {
61 if buf[i]==(115 as u8) { if buf[i+1]==(116 as u8) { if buf[i+2]==(101 as u8) { if buf[i+3]==(112 as u8) { if buf[i+4]==(115 as u8) { if buf[i+5]==(61 as u8) {
62 var p: i64 = i + 6; var v: i64 = 0; var any: i64 = 0
63 while p < n { let c: i64 = buf[p] as i64; if c>=48 { if c<=57 { v=v*10+(c-48); any=1; p=p+1 } else { p=n } } else { p=n } }
64 if any == 1 { return v }
65 return 0 - 1
66 }}}}}}
67 i = i + 1
68 }
69 return 0 - 1
70}
71
72func st_field(buf: *u8, ls: i64, le: i64, idx: i64) -> i64 {
73 if idx == 0 { return ls }
74 var f: i64 = 0; var p: i64 = ls
75 while p < le { if buf[p] == (9 as u8) { f = f + 1; if f == idx { return p + 1 } } p = p + 1 }
76 return 0 - 1
77}
78func st_field_end(buf: *u8, s: i64, le: i64) -> i64 { var q: i64 = s; while q < le { if buf[q] == (9 as u8) { return q } q = q + 1 } return le }
79func st_parse_num(buf: *u8, p: i64, le: i64) -> i64 { var q: i64=p; var v: i64=0; var go: i64=1; while go==1 { if q>=le { go=0 } else { let c: i64=buf[q] as i64; if c>=48 { if c<=57 { v=v*10+(c-48); q=q+1 } else { go=0 } } else { go=0 } } } return v }
80func st_copy(buf: *u8, s: i64, e: i64, out: *u8) -> i64 { var c: i64=0; var q: i64=s; while q<e { out[c]=buf[q]; c=c+1; q=q+1 } out[c]=0 as u8; return c }
81
82func main(argc: i64, argv: *i64) -> i64 {
83 var cand_path: *u8 = "knowledge/registry/local_tune_candidates.tsv" as *u8
84 if argc >= 2 { cand_path = argv[1] as *u8 }
85
86 st_p("=== nx_self_tune: LOCAL-ONLY driver self-tune (sweep own configs, keep best, NO phone-home) ===\n" as *u8)
87 let cb: *u8 = sys_mmap(ST_MAGIC_65536)
88 let cn: i64 = st_read(cand_path, cb, ST_MAGIC_65536)
89 if cn <= 0 { st_p("SELFTUNE verdict=RED reason=no-candidates\n" as *u8); sys_exit(1); return 1 }
90
91 let dev_id: *i64 = sys_mmap(8 * ST_MAXDEV) as *i64
92 let dev_steps: *i64 = sys_mmap(8 * ST_MAXDEV) as *i64
93 let dev_cfg: *u8 = sys_mmap(ST_MAXDEV * 512)
94 var ndev: i64 = 0
95 var swept: i64 = 0
96
97 let spec: *u8 = sys_mmap(512)
98 let bin: *u8 = sys_mmap(512)
99 let serial: *u8 = sys_mmap(ST_MAGIC_65536)
100
101 var ls: i64 = 0
102 while ls < cn {
103 var le: i64 = ls
104 var sc: i64 = 1
105 while sc == 1 { if le >= cn { sc = 0 } else { if cb[le] == (10 as u8) { sc = 0 } else { le = le + 1 } } }
106 if cb[ls] != (35 as u8) { if le > ls {
107 let f0: i64 = st_field(cb, ls, le, 0)
108 let f1: i64 = st_field(cb, ls, le, 1)
109 let f2: i64 = st_field(cb, ls, le, 2)
110 if f0>=0 { if f1>=0 { if f2>=0 {
111 let did: i64 = st_parse_num(cb, f0, le)
112 st_copy(cb, f1, st_field_end(cb, f1, le), spec)
113 st_copy(cb, f2, st_field_end(cb, f2, le), bin)
114 // emit + run this config on the LOCAL emu, measure steps
115 if st_run(ST_EMIT, spec, "/tmp/_st_emit.out" as *u8) == 0 {
116 st_run(ST_SOV, bin, "/tmp/_st_serial.txt" as *u8)
117 let sn: i64 = st_read("/tmp/_st_serial.txt" as *u8, serial, ST_MAGIC_65536)
118 let steps: i64 = st_parse_steps(serial, sn)
119 if steps > 0 {
120 swept = swept + 1
121 st_p(" swept deviceid=" as *u8); st_n(did); st_p(" config=" as *u8); st_p(spec); st_p(" steps=" as *u8); st_n(steps); st_p("\n" as *u8)
122 var slot: i64 = 0 - 1
123 var di: i64 = 0
124 while di < ndev { if dev_id[di] == did { slot = di } di = di + 1 }
125 if slot < 0 { if ndev < ST_MAXDEV {
126 slot = ndev; dev_id[slot] = did; dev_steps[slot] = steps
127 var k: i64 = 0; while spec[k] != (0 as u8) { dev_cfg[slot*512 + k] = spec[k]; k = k + 1 } dev_cfg[slot*512 + k] = 0 as u8
128 ndev = ndev + 1
129 } } else {
130 if steps < dev_steps[slot] {
131 dev_steps[slot] = steps
132 var k2: i64 = 0; while spec[k2] != (0 as u8) { dev_cfg[slot*512 + k2] = spec[k2]; k2 = k2 + 1 } dev_cfg[slot*512 + k2] = 0 as u8
133 }
134 }
135 }
136 }
137 }}}
138 }}
139 ls = le + 1
140 }
141
142 // write the tuned LOCAL registry (stays on-device).
143 let ofd: i64 = sys_openat_wr(ST_OUT, 0x1a4)
144 if ofd >= 0 {
145 st_fp(ofd, "# driver_registry_tuned_local.tsv -- AUTHORED BY nx_self_tune (X-DRV-F3). The fastest\n" as *u8)
146 st_fp(ofd, "# config per device, measured on THIS node's own emu. LOCAL-ONLY -- never shared.\n" as *u8)
147 st_fp(ofd, "# columns: deviceid\ttuned_config_spec\tbest_steps\n" as *u8)
148 var di: i64 = 0
149 while di < ndev { st_fn(ofd, dev_id[di]); st_fp(ofd, "\t" as *u8); st_fp(ofd, (dev_cfg as i64 + di*512) as *u8); st_fp(ofd, "\t" as *u8); st_fn(ofd, dev_steps[di]); st_fp(ofd, "\n" as *u8); di = di + 1 }
150 sys_close(ofd)
151 }
152 let lf: i64 = sys_openat_append(ST_LOG, 0x1a4)
153 if lf >= 0 {
154 st_fp(lf, "SELFTUNE verdict=GREEN local-only=yes phone-home=none devices=" as *u8); st_fn(lf, ndev); st_fp(lf, " configs-swept=" as *u8); st_fn(lf, swept)
155 var di2: i64 = 0
156 while di2 < ndev { st_fp(lf, " tuned[dev" as *u8); st_fn(lf, dev_id[di2]); st_fp(lf, "]=steps" as *u8); st_fn(lf, dev_steps[di2]); di2 = di2 + 1 }
157 st_fp(lf, " epoch=" as *u8); st_fn(lf, sys_now_realtime_sec()); st_fp(lf, "\n" as *u8); sys_close(lf)
158 }
159 st_p("SELFTUNE summary devices=" as *u8); st_n(ndev); st_p(" configs-swept=" as *u8); st_n(swept); st_p(" (LOCAL-ONLY, no phone-home)\n" as *u8)
160 var di3: i64 = 0
161 while di3 < ndev { st_p(" TUNED deviceid=" as *u8); st_n(dev_id[di3]); st_p(" config=" as *u8); st_p((dev_cfg as i64 + di3*512) as *u8); st_p(" steps=" as *u8); st_n(dev_steps[di3]); st_p("\n" as *u8); di3 = di3 + 1 }
162 sys_exit(0)
163 return 0
164}