nx_gpu_embed_gate.nx source
↩ module page · 231 lines · 9279 B
1// nx_gpu_embed_gate.nx -- E-ARC e4 (2026-07-15): the NISHILANG GPU-EMBED CLIENT, gated BIT-EXACT
2// vs the CPU path. This organ IS the #23 serve-integration contract rehearsed end-to-end: NishiLang
3// keeps tokenize (tk_bpe_encode) + dequant_row (embedding lookup); the resident-weight GPU server
4// (/home/elderwesto/nx_stage/nx_gpu.sock, gpu_embed_serve.c --serve, C=bootstrap oracle) runs the
5// 24-layer forward; embed protocol = send [pos:-(i+1) i64][x1: 896 i64] per token, reply = the
6// last-token pooled final-norm hidden state [896 i64] (the jina-recipe embedding, no LM head).
7// GATES:
8// T1/T2 BIT-EXACT two texts: GPU-socket embedding == nsv_embed (CPU i8) vector, 896/896
9// T3 DISTINCT the two texts' vectors differ (comparator sanity)
10// T4 NEG perturbing the last token's embedding row by +1 MUST break equality
11// Requires: coder GGUF staged + GPU server running persistent. The 2nd model read (~676MB) is the
12// price of file-scoped serve statics -- the real serve integration runs in-process and pays nothing.
13// license_tier: ORIGINAL No hw writes (Rule 26). expect_exit: 0
14import "nx_nofloat_serve_core.nx"
15import "nx_lib_std.nx"
16
17const GE_NE: i64 = 896
18
19func ge2_ws(s: *u8) -> i64 {
20 var n: i64 = 0
21 while s[n] != (0 as u8) { n = n + 1 }
22 sys_write(1, s, n)
23 return 0
24}
25
26func ge2_kv(label: *u8, v: i64) -> i64 {
27 ge2_ws(label)
28 ge2_ws("=" as *u8)
29 std_pdec(v)
30 ge2_ws(" " as *u8)
31 return 0
32}
33
34// connect to the GPU unix socket; ret fd or negative
35func ge2_connect() -> i64 {
36 let fd: i64 = sys_socket(1, 1, 0)
37 if fd < 0 { return 0 - 1 }
38 let sa: *u8 = sys_mmap(128) as *u8
39 sa[0] = 1 as u8
40 sa[1] = 0 as u8
41 let path: *u8 = "/home/elderwesto/nx_stage/nx_gpu.sock" as *u8
42 var i: i64 = 0
43 while path[i] != (0 as u8) { sa[2 + i] = path[i]; i = i + 1 }
44 let cr: i64 = sys_connect(fd, sa, 110)
45 if cr < 0 { sys_close(fd); return 0 - 2 }
46 return fd
47}
48
49func ge2_wall(fd: i64, buf: *u8, count: i64) -> i64 {
50 var off: i64 = 0
51 while off < count {
52 let q: *u8 = buf + off
53 let w: i64 = sys_write(fd, q, count - off)
54 if w <= 0 { return 0 - 1 }
55 off = off + w
56 }
57 return 0
58}
59
60func ge2_rall(fd: i64, buf: *u8, count: i64) -> i64 {
61 var off: i64 = 0
62 while off < count {
63 let q: *u8 = buf + off
64 let r: i64 = sys_read(fd, q, count - off)
65 if r <= 0 { return 0 - 1 }
66 off = off + r
67 }
68 return 0
69}
70
71func ge2_slen(s: *u8) -> i64 {
72 var n: i64 = 0
73 while s[n] != (0 as u8) { n = n + 1 }
74 return n
75}
76
77// embed text over the GPU socket: tokenize + per-token dequant_row + embed-mode request; the final
78// reply lands in gpuvec. perturb_last=1 adds +1 to the last token's x1[0] (the NEG control arm).
79// mp: *i64 = [buf, mfirst, nm_c, vfirst, vocab, te_base, te_ty] (the parsed model params).
80// ret ntok or negative.
81func ge2_gpu_embed(sock: i64, mp: *i64, text: *u8, tlen: i64, gpuvec: *i64, perturb_last: i64) -> i64 {
82 let tokp: *i64 = sys_mmap(4096 * 8) as *i64
83 let tokl: *i64 = sys_mmap(4096 * 8) as *i64
84 let ids: *i64 = sys_mmap(4096 * 8) as *i64
85 let buf: *u8 = mp[0] as *u8
86 let n: i64 = tk_bpe_encode(buf, mp[1], mp[2], mp[3], mp[4], text, tlen, tokp, tokl, ids)
87 if n < 1 { return 0 - 1 }
88 let x1: *i64 = sys_mmap(GE_NE * 8) as *i64
89 let tmp: *i64 = sys_mmap(65536) as *i64
90 let posb: *i64 = sys_mmap(8) as *i64
91 var i: i64 = 0
92 while i < n {
93 dequant_row(buf, mp[5], mp[6], ids[i], GE_NE, x1, tmp)
94 if perturb_last == 1 { if i == n - 1 { x1[0] = x1[0] + 1 } }
95 let negpos: i64 = 0 - (i + 1)
96 posb[0] = negpos
97 if ge2_wall(sock, posb as *u8, 8) != 0 { return 0 - 2 }
98 if ge2_wall(sock, x1 as *u8, GE_NE * 8) != 0 { return 0 - 2 }
99 if ge2_rall(sock, gpuvec as *u8, GE_NE * 8) != 0 { return 0 - 3 }
100 i = i + 1
101 }
102 return n
103}
104
105func ge2_mismatches(a: *i64, b: *i64) -> i64 {
106 var m: i64 = 0
107 var i: i64 = 0
108 while i < GE_NE { if a[i] != b[i] { m = m + 1 } i = i + 1 }
109 return m
110}
111
112func main() -> i64 {
113 ge2_ws("[gpu-embed-gate] NishiLang GPU client vs CPU nsv_embed, bit-exact bar\n" as *u8)
114 let mpath: *u8 = "/home/elderwesto/nx_stage/nx_coder_model.gguf\x00" as *u8
115 let ir: i64 = nsv_init(mpath)
116 if ir != 0 { ge2_kv("INIT-FAIL rc" as *u8, ir); ge2_ws("\n" as *u8); return 1 }
117 // own model view for the client half (file-scoped serve statics are not importable)
118 let len_out: *i64 = sys_mmap(8) as *i64
119 len_out[0] = 0
120 let buf: *u8 = sys_read_file(mpath, len_out)
121 if buf == (0 as *u8) { ge2_ws("RED model re-read\n" as *u8); return 1 }
122 let hdr: *NxGgufHeader = sys_mmap(NX_GGUF_HDR_BYTES) as *NxGgufHeader
123 if nx_gguf_parse(buf, len_out[0], hdr) != NX_GGUF_OK { ge2_ws("RED parse\n" as *u8); return 1 }
124 let voff: *i64 = sys_mmap(8) as *i64
125 let vty: *i64 = sys_mmap(8) as *i64
126 var mfirst: i64 = 0
127 var nm_c: i64 = 0
128 var vfirst: i64 = 0
129 var vocab: i64 = 0
130 let km: *u8 = "tokenizer.ggml.merges\x00" as *u8
131 let kt: *u8 = "tokenizer.ggml.tokens\x00" as *u8
132 if nx_gguf_meta_find(buf, len_out[0], hdr, km, ge2_slen(km), voff, vty) == NX_GMETA_OK {
133 nm_c = nx_gguf_meta_array_count(buf, voff[0])
134 mfirst = nx_gguf_meta_array_first_elt_off(buf, voff[0])
135 } else { ge2_ws("RED merges\n" as *u8); return 1 }
136 if nx_gguf_meta_find(buf, len_out[0], hdr, kt, ge2_slen(kt), voff, vty) == NX_GMETA_OK {
137 vocab = nx_gguf_meta_array_count(buf, voff[0])
138 vfirst = nx_gguf_meta_array_first_elt_off(buf, voff[0])
139 } else { ge2_ws("RED tokens\n" as *u8); return 1 }
140 let nt: *u8 = "token_embd.weight\x00" as *u8
141 let ie: nx_int = nx_gguf_find_tensor(hdr, nt, 17)
142 if ie < 0 { ge2_ws("RED embd tensor\n" as *u8); return 1 }
143 let te: *NxGgufTensorInfo = nx_gguf_tensor_at(hdr, ie)
144 let te_base: i64 = hdr.data_off + te.offset
145 let te_ty: i64 = te.ggml_type
146 let mp: *i64 = sys_mmap(8 * 8) as *i64
147 mp[0] = buf as i64
148 mp[1] = mfirst
149 mp[2] = nm_c
150 mp[3] = vfirst
151 mp[4] = vocab
152 mp[5] = te_base
153 mp[6] = te_ty
154 // connect
155 let sock: i64 = ge2_connect()
156 if sock < 0 { ge2_kv("RED socket rc" as *u8, sock); ge2_ws("(is gpu_embed_serve --serve up?)\n" as *u8); return 1 }
157 // T1
158 let t1: *u8 = "Find the most relevant code snippet given the following query:\nprint hello world in python" as *u8
159 let cpu1: *i64 = sys_mmap(GE_NE * 8) as *i64
160 let gpu1: *i64 = sys_mmap(GE_NE * 8) as *i64
161 var c0: i64 = sys_now_ms()
162 let cn1: i64 = nsv_embed(t1, ge2_slen(t1), 1, cpu1)
163 var c1: i64 = sys_now_ms()
164 var g0: i64 = sys_now_ms()
165 let gn1: i64 = ge2_gpu_embed(sock, mp, t1, ge2_slen(t1), gpu1, 0)
166 var g1: i64 = sys_now_ms()
167 let mm1: i64 = ge2_mismatches(cpu1, gpu1)
168 ge2_ws("[T1] " as *u8)
169 ge2_kv("cpu_ntok" as *u8, cn1)
170 ge2_kv("gpu_ntok" as *u8, gn1)
171 ge2_kv("mismatches" as *u8, mm1)
172 ge2_kv("cpu_ms" as *u8, c1 - c0)
173 ge2_kv("gpu_ms" as *u8, g1 - g0)
174 ge2_ws("\n" as *u8)
175 var gate1: i64 = 0
176 if cn1 > 0 { if gn1 == cn1 { if mm1 == 0 { gate1 = 1 } } }
177 // T2
178 let t2: *u8 = "Candidate code snippet:\nint arr[5] = {0, 0, 0, 0, 0};" as *u8
179 let cpu2: *i64 = sys_mmap(GE_NE * 8) as *i64
180 let gpu2: *i64 = sys_mmap(GE_NE * 8) as *i64
181 c0 = sys_now_ms()
182 let cn2: i64 = nsv_embed(t2, ge2_slen(t2), 1, cpu2)
183 c1 = sys_now_ms()
184 g0 = sys_now_ms()
185 let gn2: i64 = ge2_gpu_embed(sock, mp, t2, ge2_slen(t2), gpu2, 0)
186 g1 = sys_now_ms()
187 let mm2: i64 = ge2_mismatches(cpu2, gpu2)
188 ge2_ws("[T2] " as *u8)
189 ge2_kv("cpu_ntok" as *u8, cn2)
190 ge2_kv("gpu_ntok" as *u8, gn2)
191 ge2_kv("mismatches" as *u8, mm2)
192 ge2_kv("cpu_ms" as *u8, c1 - c0)
193 ge2_kv("gpu_ms" as *u8, g1 - g0)
194 ge2_ws("\n" as *u8)
195 var gate2: i64 = 0
196 if cn2 > 0 { if gn2 == cn2 { if mm2 == 0 { gate2 = 1 } } }
197 // T3 distinct texts -> distinct vectors
198 let dd: i64 = ge2_mismatches(gpu1, gpu2)
199 var gate3: i64 = 0
200 if dd > 0 { gate3 = 1 }
201 ge2_ws("[T3] " as *u8)
202 ge2_kv("t1_vs_t2_diffs" as *u8, dd)
203 ge2_ws("\n" as *u8)
204 // T4 NEG: perturbed last-token row must break equality
205 let t3: *u8 = "hi there" as *u8
206 let cpu3: *i64 = sys_mmap(GE_NE * 8) as *i64
207 let gpu3: *i64 = sys_mmap(GE_NE * 8) as *i64
208 let cn3: i64 = nsv_embed(t3, ge2_slen(t3), 1, cpu3)
209 let gn3: i64 = ge2_gpu_embed(sock, mp, t3, ge2_slen(t3), gpu3, 1)
210 let mm3: i64 = ge2_mismatches(cpu3, gpu3)
211 var gate4: i64 = 0
212 if cn3 > 0 { if gn3 == cn3 { if mm3 > 0 { gate4 = 1 } } }
213 ge2_ws("[T4 negctl] " as *u8)
214 ge2_kv("mismatches" as *u8, mm3)
215 ge2_kv("pass" as *u8, gate4)
216 ge2_ws("\n" as *u8)
217 sys_close(sock)
218 var green: i64 = 0
219 if gate1 == 1 { if gate2 == 1 { if gate3 == 1 { if gate4 == 1 { green = 1 } } } }
220 if green == 1 {
221 ge2_ws("VERDICT GREEN gpu-embed-client (NishiLang tokenize+dequant -> GPU socket forward == CPU nsv_embed BIT-EXACT on both texts + distinct + perturb-caught)\n" as *u8)
222 return 0
223 }
224 ge2_ws("VERDICT RED " as *u8)
225 ge2_kv("T1" as *u8, gate1)
226 ge2_kv("T2" as *u8, gate2)
227 ge2_kv("T3" as *u8, gate3)
228 ge2_kv("T4" as *u8, gate4)
229 ge2_ws("\n" as *u8)
230 return 1
231}