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

↩ module page · 237 lines · 8754 B
1// nx_quad_companion_compose_test.nx -- 4-modality concurrent integration.
2//
3// Closes the parallel-companion north star: FOUR actors of DIFFERENT
4// modalities running interleaved through one scheduler + message bus +
5// multiplexer.
6//
7//   NARRATOR  (LLM,         priority 80) -- nx_actor_role_llm
8//   NPC       (LLM,         priority 60) -- nx_actor_role_llm
9//   AUDIO_QC  (audio grader, priority 50) -- nx_actor_role_audio_grader
10//   GAME_LOGIC (tictactoe,   priority 70) -- nx_actor_role_game_logic
11//
12// Replaces the image grader from the original quad attempt with the
13// lighter-deps game-logic actor per [[feedback-nxc2-module-const-ceiling]]
14// guidance.  Each actor calls a DIFFERENT other-agent / sibling-arc
15// primitive:
16//
17//   LLM    -> nx_embedding_lookup + nx_blas_matmul + nx_sample_categorical
18//   AUDIO  -> nx_audio_scene_grade  (5-axis Q14 verdict)
19//   GAME   -> nx_ttt_pick + nx_ttt_try_apply + nx_ttt_evaluate
20//
21// Proves the substrate handles arbitrary heterogeneous modalities
22// through one uniform actor + message + multiplexer pipeline.
23
24import "nx_syscalls.nx"
25import "nx_tier.nx"
26import "nx_tensor.nx"
27import "nx_actor.nx"
28import "nx_message.nx"
29import "nx_stream_multiplexer.nx"
30import "nx_actor_role_llm.nx"
31import "nx_actor_role_audio_grader.nx"
32import "nx_actor_role_game_logic.nx"
33
34func _fill_q10(t: *NxTensor, base: i64, stride: i64) -> i64 {
  let p: *i64 = t.storage as *i64
  var i: nx_int = 0
  while i < t.numel {
      p[i] = base + (i as i64) * stride
      i = i + 1
  }
  return 0
42}
43
44func main() -> i64 {
  let now: nx_size = 1000000
46
  // ===== Stage 1: LLM weights (shared by NARRATOR + NPC) =====
  let shape_buf: *u8 = sys_mmap(16)
  let shape: *i64 = shape_buf as *i64
  shape[0] = 4
  shape[1] = 4
  let err_buf: *u8 = sys_mmap(8)
  let err_p: *i64 = err_buf as *i64
  let embed_table: *NxTensor = nx_t_alloc(NX_DT_I64, shape, 2, err_p)
  if err_p[0] != NX_T_OK { return 1 }
  _fill_q10(embed_table, 100, 5)
57
  let shape2_buf: *u8 = sys_mmap(16)
  let shape2: *i64 = shape2_buf as *i64
  shape2[0] = 4
  shape2[1] = 4
  let out_proj: *NxTensor = nx_t_alloc(NX_DT_I64, shape2, 2, err_p)
  _fill_q10(out_proj, 40, 3)
64
  // ===== Stage 2: audio inputs =====
  let bins_buf: *u8 = sys_mmap(64)
  let bins: *i64 = bins_buf as *i64
  var b: nx_int = 0
  while b < 8 {
      bins[b] = 5000 + ((b * 600) as i64)
      b = b + 1
  }
  let rms_buf: *u8 = sys_mmap(128)
  let rms: *i64 = rms_buf as *i64
  var f: nx_int = 0
  while f < 16 {
      rms[f] = 2200 + ((f * 180) as i64)
      f = f + 1
  }
80
  // ===== Stage 3: shared substrate =====
  let sched: *NxActorScheduler = nx_ac_sched_new(8, 1000000, 24, now)
  let bus: *NxMessageBus = nx_ms_bus_new(8, 32, 32)
  let mux: *NxStreamMultiplexer = nx_sm_new(64, 50000)
85
  let NARR: nx_int = 9001
  let NPC:  nx_int = 9002
  let AUD:  nx_int = 9003
  let GAME: nx_int = 9004
  let LIS:  nx_int = 9099
91
  nx_ac_spawn(sched, NARR, 1, 80, 0, now)
  nx_ac_spawn(sched, NPC,  1, 60, 0, now)
  nx_ac_spawn(sched, AUD,  4, 50, 0, now)
  nx_ac_spawn(sched, GAME, 5, 70, 0, now)
  nx_ac_spawn(sched, LIS,  5, 30, 0, now)
97
  nx_ms_register(bus, NARR)
  nx_ms_register(bus, NPC)
  nx_ms_register(bus, AUD)
  nx_ms_register(bus, GAME)
  nx_ms_register(bus, LIS)
  nx_ms_subscribe(bus, LIS, NX_MS_KIND_LLM_TOKEN)
  nx_ms_subscribe(bus, LIS, NX_MS_KIND_AUDIO_FRAME)
  nx_ms_subscribe(bus, LIS, NX_MS_KIND_GAME_ACTION)
106
  // ===== Stage 4: actor contexts =====
  let narr_ctx: *NxLlmActorCtx = nx_lr_actor_new(embed_table, out_proj, 1, 4, 4, 1024, 2, 7)
  let npc_ctx:  *NxLlmActorCtx = nx_lr_actor_new(embed_table, out_proj, 2, 4, 4, 1024, 2, 13)
  let aud_ctx:  *NxAudioGraderCtx = nx_ag_actor_new(bins, 8, rms, 16, 4)
  let game_ctx: *NxGameLogicCtx = nx_gl_actor_new(NX_TTT_X, NX_TTT_AI_PERFECT, NX_TTT_AI_PERFECT, 19)
  if (narr_ctx as i64) == 0 { return 2 }
  if (npc_ctx as i64) == 0 { return 3 }
  if (aud_ctx as i64) == 0 { return 4 }
  if (game_ctx as i64) == 0 { return 5 }
116
  // ===== Stage 5: pick_next initial = NARRATOR (priority 80) =====
  let first: *NxActor = nx_ac_pick_next(sched)
  if first.actor_id != NARR { return 6 }
120
  // ===== Stage 6: drive each actor to completion =====
  //   NARR + NPC: 5 phases each
  //   AUD: 3 phases
  //   GAME: up to 9 plies (1 step per ply, terminates when game ends)
  var tick: nx_size = now + 100
  var i: nx_int = 0
  while i < 5 {
      nx_lr_actor_step(narr_ctx, sched, bus, NARR, tick)
      tick = tick + 50
      i = i + 1
  }
  var j: nx_int = 0
  while j < 5 {
      nx_lr_actor_step(npc_ctx, sched, bus, NPC, tick)
      tick = tick + 50
      j = j + 1
  }
  var p: nx_int = 0
  while p < 3 {
      nx_ag_actor_step(aud_ctx, sched, bus, AUD, tick)
      tick = tick + 50
      p = p + 1
  }
  // Game: step until COMPLETED (PERFECT vs PERFECT -> DRAW in 9 plies)
  var game_steps: nx_int = 0
  var game_verdict: nx_int = NX_GL_V_STEPPED
  while game_verdict == NX_GL_V_STEPPED {
      game_verdict = nx_gl_actor_step(game_ctx, sched, bus, GAME, tick)
      tick = tick + 50
      game_steps = game_steps + 1
      if game_steps > 12 { return 7 }
  }
153
  // ===== Stage 7: all four actors COMPLETED =====
  let na: *NxActor = nx_ac_find(sched, NARR)
  let nb: *NxActor = nx_ac_find(sched, NPC)
  let nc: *NxActor = nx_ac_find(sched, AUD)
  let nd: *NxActor = nx_ac_find(sched, GAME)
  if na.state != NX_AC_STATE_COMPLETED { return 8 }
  if nb.state != NX_AC_STATE_COMPLETED { return 9 }
  if nc.state != NX_AC_STATE_COMPLETED { return 10 }
  if nd.state != NX_AC_STATE_COMPLETED { return 11 }
163
  // ===== Stage 8: game theory invariant -- PERFECT vs PERFECT must DRAW =====
  if nx_gl_actor_outcome(game_ctx) != NX_TTT_DRAW { return 12 }
  if nx_gl_actor_plies(game_ctx) != 9 { return 13 }
167
  // ===== Stage 9: LISTENER mailbox totals =====
  //   2 LLM_TOKEN (narr + npc) + 1 AUDIO_FRAME + 9 GAME_ACTION = 12
  if nx_ms_pending(bus, LIS) != 12 { return 14 }
171
  // ===== Stage 10: verdicts =====
  let narr_tok: nx_int = nx_lr_actor_token(narr_ctx)
  let npc_tok: nx_int = nx_lr_actor_token(npc_ctx)
  if narr_tok < 0 { return 15 }
  if narr_tok >= 4 { return 16 }
  if npc_tok < 0 { return 17 }
  if npc_tok >= 4 { return 18 }
  if nx_ag_actor_score_q14(aud_ctx) <= 0 { return 19 }
180
  // ===== Stage 11: drain LISTENER in FIFO order =====
  //   First 2 messages = LLM_TOKEN (narr, npc); then AUDIO_FRAME; then 9 GAME_ACTION
  let m1: *NxMessage = nx_ms_receive(bus, LIS)
  if m1.kind != NX_MS_KIND_LLM_TOKEN { return 20 }
  if m1.sender_actor_id != NARR { return 21 }
186
  let m2: *NxMessage = nx_ms_receive(bus, LIS)
  if m2.kind != NX_MS_KIND_LLM_TOKEN { return 22 }
  if m2.sender_actor_id != NPC { return 23 }
190
  let m3: *NxMessage = nx_ms_receive(bus, LIS)
  if m3.kind != NX_MS_KIND_AUDIO_FRAME { return 24 }
193
  // Remaining 9 are GAME_ACTION
  var ga_count: nx_int = 0
  while ga_count < 9 {
      let mg: *NxMessage = nx_ms_receive(bus, LIS)
      if mg.kind != NX_MS_KIND_GAME_ACTION { return 30 + ga_count }
      if mg.sender_actor_id != GAME { return 50 + ga_count }
      ga_count = ga_count + 1
  }
202
  // ===== Stage 12: multiplexer priority ordering =====
  //   Push one of each class; drain.  Priorities:
  //     LLM_TEXT     = 80
  //     GAME_ACTION  = 90 (game actions are highest non-system)
  //     AUDIO_TTS    = 70
  nx_sm_push(mux, NARR, NX_SM_CLASS_LLM_TEXT, 1, 8, narr_tok as nx_size, tick)
  nx_sm_push(mux, AUD, NX_SM_CLASS_AUDIO_TTS, 2, 8, nx_ag_actor_score_q14(aud_ctx) as nx_size, tick)
  nx_sm_push(mux, GAME, NX_SM_CLASS_GAME_ACTION, 3, 8, 0xCAFE, tick)
  if nx_sm_pending_count(mux) != 3 { return 70 }
212
  let oc_buf: *u8 = sys_mmap(24)
  let oc: *i64 = oc_buf as *i64
  let os: *i64 = (oc_buf + 8) as *i64
  let oid: *i64 = (oc_buf + 16) as *i64
217
  // First drained = GAME_ACTION (priority 90)
  nx_sm_next(mux, oc, os, oid, tick + 100)
  if oc[0] != (NX_SM_CLASS_GAME_ACTION as i64) { return 71 }
221
  // Second = LLM_TEXT (priority 80)
  nx_sm_next(mux, oc, os, oid, tick + 200)
  if oc[0] != (NX_SM_CLASS_LLM_TEXT as i64) { return 72 }
225
  // Third = AUDIO_TTS (priority 70)
  nx_sm_next(mux, oc, os, oid, tick + 300)
  if oc[0] != (NX_SM_CLASS_AUDIO_TTS as i64) { return 73 }
229
  if nx_sm_pending_count(mux) != 0 { return 74 }
231
  // ===== Stage 13: scheduler stats =====
  if nx_ac_actor_count(sched) != 5 { return 75 }   // NARR+NPC+AUD+GAME+LIS
  if nx_ac_total_runtime_us(sched) <= 0 { return 76 }
235
  return 0
237}
nx_quad_companion_compose_test.nx source

`nx_quad_companion_compose_test.nx` source
