code wiki / (root) / nx_actor_role_llm_v2_real_test.nx
`nx_actor_role_llm_v2_real_test.nx` source

↩ module page · 262 lines · 11195 B
1// nx_actor_role_llm_v2_real_test.nx -- REAL end-to-end smoke driving the
2// v2 LLM actor through actual transformer forward.
3//
4// Where nx_actor_role_llm_v2_test.nx is wiring-only, THIS smoke builds
5// a real 12-tensor synthetic Llama GGUF (n_layers=1, hidden=2, head=2,
6// vocab=4, ffn=4, all-zero F32 weights), a real BPE vocab, and drives
7// the v2 actor adapter through INIT -> RUN -> EMIT.  RUN actually
8// invokes nx_llm_generate_one_v2 which executes:
9//
10//   tokenize prompt -> nx_embedding_lookup -> RoPE + RMSNorm +
11//   multi-head attention + SwiGLU FFN + output norm + output proj
12//   + temperature + top_k + nx_sample_categorical -> token id
13//
14// Per the operator constraint: "real testing of real world capabilities
15// bits up".  No constructor-rejection-only paper proof; this exercises
16// the entire other-agent runner stack through the actor system.
17//
18// Composes [[feedback-real-playtest-loop-not-just-logs]] +
19// [[feedback-four-pillar-code-hygiene-untracked-imports]] (additive
20// fix landed; preventative scanner shipped; this is the demonstration
21// of the now-safe end-to-end path).
22
23import "nx_syscalls.nx"
24import "nx_tier.nx"
25import "nx_le.nx"
26import "nx_tensor.nx"
27import "nx_bpe.nx"
28import "nx_model_spec.nx"
29import "nx_prng.nx"
30import "nx_gguf.nx"
31import "nx_gguf_load.nx"
32import "nx_llm_run_v2.nx"
33import "nx_actor.nx"
34import "nx_message.nx"
35import "nx_actor_role_llm_v2.nx"
36
37// ===== GGUF fixture builders (same shape as v2 runner test) =====
38
39func _write_ti(buf: *u8, off: i64,
             name: *u8, name_len: i64,
             n_dims: i64, dim_0: i64, dim_1: i64,
             ggml_type: i64, data_offset: i64) -> i64 {
  nx_le_write_u64(buf, off, name_len)
  var o: i64 = off + 8
  var i: i64 = 0
  while i < name_len { buf[o + i] = name[i]; i = i + 1 }
  o = o + name_len
  nx_le_write_u32(buf, o, n_dims); o = o + 4
  nx_le_write_u64(buf, o, dim_0);  o = o + 8
  if n_dims >= 2 { nx_le_write_u64(buf, o, dim_1); o = o + 8 }
  nx_le_write_u32(buf, o, ggml_type); o = o + 4
  nx_le_write_u64(buf, o, data_offset); o = o + 8
  return o
54}
55
56func _mk_blk_name(suffix: *u8, suffix_len: nx_int, out: *u8) -> nx_int {
  out[0]=0x62; out[1]=0x6c; out[2]=0x6b; out[3]=0x2e
  out[4]=0x30; out[5]=0x2e
  var i: nx_int = 0
  while i < suffix_len { out[6 + i] = suffix[i]; i = i + 1 }
  return 6 + suffix_len
62}
63
64func main() -> i64 {
  let now: nx_size = 1000000
66
  // ===== Stage 1: build synthetic GGUF byte buffer =====
  let buf: *u8 = sys_mmap(4096)
  buf[0]=0x47; buf[1]=0x47; buf[2]=0x55; buf[3]=0x46
  buf[4]=3
  nx_le_write_u64(buf, 8, 12)
  nx_le_write_u64(buf, 16, 0)
73
  let n_te: *u8 = sys_mmap(17)
  n_te[0]=0x74; n_te[1]=0x6f; n_te[2]=0x6b; n_te[3]=0x65
  n_te[4]=0x6e; n_te[5]=0x5f; n_te[6]=0x65; n_te[7]=0x6d
  n_te[8]=0x62; n_te[9]=0x64; n_te[10]=0x2e; n_te[11]=0x77
  n_te[12]=0x65; n_te[13]=0x69; n_te[14]=0x67; n_te[15]=0x68
  n_te[16]=0x74
80
  let n_on: *u8 = sys_mmap(18)
  n_on[0]=0x6f; n_on[1]=0x75; n_on[2]=0x74; n_on[3]=0x70
  n_on[4]=0x75; n_on[5]=0x74; n_on[6]=0x5f; n_on[7]=0x6e
  n_on[8]=0x6f; n_on[9]=0x72; n_on[10]=0x6d; n_on[11]=0x2e
  n_on[12]=0x77; n_on[13]=0x65; n_on[14]=0x69; n_on[15]=0x67
  n_on[16]=0x68; n_on[17]=0x74
87
  let n_ow: *u8 = sys_mmap(13)
  n_ow[0]=0x6f; n_ow[1]=0x75; n_ow[2]=0x74; n_ow[3]=0x70
  n_ow[4]=0x75; n_ow[5]=0x74; n_ow[6]=0x2e; n_ow[7]=0x77
  n_ow[8]=0x65; n_ow[9]=0x69; n_ow[10]=0x67; n_ow[11]=0x68
  n_ow[12]=0x74
93
  let s_an: *u8 = sys_mmap(16)
  s_an[0]=0x61; s_an[1]=0x74; s_an[2]=0x74; s_an[3]=0x6e
  s_an[4]=0x5f; s_an[5]=0x6e; s_an[6]=0x6f; s_an[7]=0x72
  s_an[8]=0x6d; s_an[9]=0x2e; s_an[10]=0x77; s_an[11]=0x65
  s_an[12]=0x69; s_an[13]=0x67; s_an[14]=0x68; s_an[15]=0x74
99
  let s_q: *u8 = sys_mmap(13)
  s_q[0]=0x61; s_q[1]=0x74; s_q[2]=0x74; s_q[3]=0x6e
  s_q[4]=0x5f; s_q[5]=0x71; s_q[6]=0x2e; s_q[7]=0x77
  s_q[8]=0x65; s_q[9]=0x69; s_q[10]=0x67; s_q[11]=0x68; s_q[12]=0x74
104
  let s_k: *u8 = sys_mmap(13)
  s_k[0]=0x61; s_k[1]=0x74; s_k[2]=0x74; s_k[3]=0x6e
  s_k[4]=0x5f; s_k[5]=0x6b; s_k[6]=0x2e; s_k[7]=0x77
  s_k[8]=0x65; s_k[9]=0x69; s_k[10]=0x67; s_k[11]=0x68; s_k[12]=0x74
109
  let s_v: *u8 = sys_mmap(13)
  s_v[0]=0x61; s_v[1]=0x74; s_v[2]=0x74; s_v[3]=0x6e
  s_v[4]=0x5f; s_v[5]=0x76; s_v[6]=0x2e; s_v[7]=0x77
  s_v[8]=0x65; s_v[9]=0x69; s_v[10]=0x67; s_v[11]=0x68; s_v[12]=0x74
114
  let s_o: *u8 = sys_mmap(18)
  s_o[0]=0x61; s_o[1]=0x74; s_o[2]=0x74; s_o[3]=0x6e
  s_o[4]=0x5f; s_o[5]=0x6f; s_o[6]=0x75; s_o[7]=0x74
  s_o[8]=0x70; s_o[9]=0x75; s_o[10]=0x74; s_o[11]=0x2e
  s_o[12]=0x77; s_o[13]=0x65; s_o[14]=0x69; s_o[15]=0x67
  s_o[16]=0x68; s_o[17]=0x74
121
  let s_fn: *u8 = sys_mmap(15)
  s_fn[0]=0x66; s_fn[1]=0x66; s_fn[2]=0x6e; s_fn[3]=0x5f
  s_fn[4]=0x6e; s_fn[5]=0x6f; s_fn[6]=0x72; s_fn[7]=0x6d
  s_fn[8]=0x2e; s_fn[9]=0x77; s_fn[10]=0x65; s_fn[11]=0x69
  s_fn[12]=0x67; s_fn[13]=0x68; s_fn[14]=0x74
127
  let s_fg: *u8 = sys_mmap(15)
  s_fg[0]=0x66; s_fg[1]=0x66; s_fg[2]=0x6e; s_fg[3]=0x5f
  s_fg[4]=0x67; s_fg[5]=0x61; s_fg[6]=0x74; s_fg[7]=0x65
  s_fg[8]=0x2e; s_fg[9]=0x77; s_fg[10]=0x65; s_fg[11]=0x69
  s_fg[12]=0x67; s_fg[13]=0x68; s_fg[14]=0x74
133
  let s_fu: *u8 = sys_mmap(13)
  s_fu[0]=0x66; s_fu[1]=0x66; s_fu[2]=0x6e; s_fu[3]=0x5f
  s_fu[4]=0x75; s_fu[5]=0x70; s_fu[6]=0x2e; s_fu[7]=0x77
  s_fu[8]=0x65; s_fu[9]=0x69; s_fu[10]=0x67; s_fu[11]=0x68; s_fu[12]=0x74
138
  let s_fd: *u8 = sys_mmap(15)
  s_fd[0]=0x66; s_fd[1]=0x66; s_fd[2]=0x6e; s_fd[3]=0x5f
  s_fd[4]=0x64; s_fd[5]=0x6f; s_fd[6]=0x77; s_fd[7]=0x6e
  s_fd[8]=0x2e; s_fd[9]=0x77; s_fd[10]=0x65; s_fd[11]=0x69
  s_fd[12]=0x67; s_fd[13]=0x68; s_fd[14]=0x74
144
  let n_an: *u8 = sys_mmap(32); let l_an: nx_int = _mk_blk_name(s_an, 16, n_an)
  let n_q:  *u8 = sys_mmap(32); let l_q:  nx_int = _mk_blk_name(s_q,  13, n_q)
  let n_k:  *u8 = sys_mmap(32); let l_k:  nx_int = _mk_blk_name(s_k,  13, n_k)
  let n_v:  *u8 = sys_mmap(32); let l_v:  nx_int = _mk_blk_name(s_v,  13, n_v)
  let n_o:  *u8 = sys_mmap(32); let l_o:  nx_int = _mk_blk_name(s_o,  18, n_o)
  let n_fn: *u8 = sys_mmap(32); let l_fn: nx_int = _mk_blk_name(s_fn, 15, n_fn)
  let n_fg: *u8 = sys_mmap(32); let l_fg: nx_int = _mk_blk_name(s_fg, 15, n_fg)
  let n_fu: *u8 = sys_mmap(32); let l_fu: nx_int = _mk_blk_name(s_fu, 13, n_fu)
  let n_fd: *u8 = sys_mmap(32); let l_fd: nx_int = _mk_blk_name(s_fd, 15, n_fd)
154
  var p: i64 = 24
  p = _write_ti(buf, p, n_te, 17, 2, 4, 2, NX_GGML_TYPE_F32, 0)
  p = _write_ti(buf, p, n_on, 18, 1, 2, 1, NX_GGML_TYPE_F32, 32)
  p = _write_ti(buf, p, n_ow, 13, 2, 2, 4, NX_GGML_TYPE_F32, 40)
  p = _write_ti(buf, p, n_an, l_an, 1, 2, 1, NX_GGML_TYPE_F32, 72)
  p = _write_ti(buf, p, n_q,  l_q,  2, 2, 2, NX_GGML_TYPE_F32, 80)
  p = _write_ti(buf, p, n_k,  l_k,  2, 2, 2, NX_GGML_TYPE_F32, 96)
  p = _write_ti(buf, p, n_v,  l_v,  2, 2, 2, NX_GGML_TYPE_F32, 112)
  p = _write_ti(buf, p, n_o,  l_o,  2, 2, 2, NX_GGML_TYPE_F32, 128)
  p = _write_ti(buf, p, n_fn, l_fn, 1, 2, 1, NX_GGML_TYPE_F32, 144)
  p = _write_ti(buf, p, n_fg, l_fg, 2, 2, 4, NX_GGML_TYPE_F32, 152)
  p = _write_ti(buf, p, n_fu, l_fu, 2, 2, 4, NX_GGML_TYPE_F32, 184)
  p = _write_ti(buf, p, n_fd, l_fd, 2, 4, 2, NX_GGML_TYPE_F32, 216)
168
  let data_off: i64 = (p + 31) / 32 * 32
  var zi: nx_int = 0
  while zi < 248 { buf[data_off + zi] = 0; zi = zi + 1 }
172
  // ===== Stage 2: parse GGUF =====
  let hdr: *NxGgufHeader = sys_mmap(NX_GGUF_HDR_BYTES) as *NxGgufHeader
  if nx_gguf_parse(buf, 4096, hdr) != NX_GGUF_OK { return 1 }
  if hdr.n_tensors != 12 { return 2 }
177
  // ===== Stage 3: model spec =====
  let spec: *NxModelSpec = nx_model_spec_new()
  spec.n_layers    = 1
  spec.hidden_dim  = 2
  spec.n_heads     = 1
  spec.head_dim    = 2
  spec.n_kv_heads  = 1
  spec.ffn_dim     = 4
  spec.vocab_size  = 4
  spec.max_seq_len = 8
  if nx_model_spec_validate(spec) != NX_MS_OK { return 3 }
189
  // ===== Stage 4: BPE vocab (4 single-byte tokens) =====
  let bpe: *NxBpeVocab = nx_bpe_vocab_new(256, 16, 8)
  let ba: *u8 = sys_mmap(1); ba[0] = 0x61
  let bb: *u8 = sys_mmap(1); bb[0] = 0x62
  let bc: *u8 = sys_mmap(1); bc[0] = 0x63
  let bd: *u8 = sys_mmap(1); bd[0] = 0x64
  nx_bpe_add_token(bpe, ba, 1)
  nx_bpe_add_token(bpe, bb, 1)
  nx_bpe_add_token(bpe, bc, 1)
  nx_bpe_add_token(bpe, bd, 1)
200
  // ===== Stage 5: prompt + prng =====
  let prompt: *u8 = sys_mmap(1); prompt[0] = 0x61
  let prng: *i64 = sys_mmap(8) as *i64
  nx_prng_init(prng, 0xcafebabe)
205
  // ===== Stage 6: build v2 LLM actor adapter =====
  let ctx: *NxLlmV2ActorCtx = nx_lv_actor_new(
      spec, buf, hdr, bpe, prompt, 1,
      1024, 4, prng, 10000, 724)
  if (ctx as i64) == 0 { return 4 }
  if ctx.current_phase != NX_LV_PHASE_INIT { return 5 }
212
  // ===== Stage 7: substrate scheduler + bus + listener =====
  let sched: *NxActorScheduler = nx_ac_sched_new(4, 1000000, 8, now)
  nx_ac_spawn(sched, 4001, 1, 80, 0, now)
  let bus: *NxMessageBus = nx_ms_bus_new(4, 8, 8)
  nx_ms_register(bus, 4001)
  nx_ms_register(bus, 4002)
  nx_ms_subscribe(bus, 4002, NX_MS_KIND_LLM_TOKEN)
  nx_ms_subscribe(bus, 4002, NX_MS_KIND_ERROR_REPORT)
221
  // ===== Stage 8: drive actor INIT -> RUN -> EMIT -> DONE =====
  if nx_lv_actor_step(ctx, sched, bus, 4001, now + 100) != NX_LV_V_STEPPED { return 6 }
  if ctx.current_phase != NX_LV_PHASE_RUN { return 7 }
225
  // RUN actually executes the full transformer forward through the
  // other-agent runner.  With all-zero weights the logits are uniform
  // so the sampler returns a token in [0, vocab_size).
  let v_run: nx_int = nx_lv_actor_step(ctx, sched, bus, 4001, now + 200)
  if ctx.current_phase != NX_LV_PHASE_EMIT { return 8 }
  if v_run != NX_LV_V_STEPPED { return 9 }
  // Real runner returned a non-negative token
  if ctx.runner_result < 0 { return 10 }
  if ctx.runner_result >= 4 { return 11 }
  if ctx.runner_verdict != NX_LR2_OK { return 12 }
236
  // EMIT pushes LLM_TOKEN (not ERROR_REPORT) because runner_result >= 0
  let v_emit: nx_int = nx_lv_actor_step(ctx, sched, bus, 4001, now + 300)
  if v_emit != NX_LV_V_COMPLETED { return 13 }
  if ctx.current_phase != NX_LV_PHASE_DONE { return 14 }
  if nx_lv_actor_is_done(ctx) != 1 { return 15 }
242
  // ===== Stage 9: listener received LLM_TOKEN with the real token =====
  if nx_ms_pending(bus, 4002) != 1 { return 16 }
  let m: *NxMessage = nx_ms_receive(bus, 4002)
  if m.kind != NX_MS_KIND_LLM_TOKEN { return 17 }
  if m.sender_actor_id != 4001 { return 18 }
  let recv_token: nx_int = m.payload_handle as nx_int
  if recv_token != ctx.runner_result { return 19 }
  if recv_token < 0 { return 20 }
  if recv_token >= 4 { return 21 }
252
  // ===== Stage 10: scheduler marks COMPLETED (not FAILED) =====
  let a: *NxActor = nx_ac_find(sched, 4001)
  if a.state != NX_AC_STATE_COMPLETED { return 22 }
256
  // ===== Stage 11: accessors return the real values =====
  if nx_lv_actor_token(ctx) != ctx.runner_result { return 23 }
  if nx_lv_actor_runner_verdict(ctx) != NX_LR2_OK { return 24 }
260
  return 0
262}
nx_actor_role_llm_v2_real_test.nx source

`nx_actor_role_llm_v2_real_test.nx` source
