phase 10: GPU add/mul kernels + BF16 precision analysis

Kernel additions:
- add_f32/bf16, mul_f32/bf16 CUDA kernels (element-wise, on GPU)
- Refactored activation.rs with dispatch_unary/dispatch_binary helpers
- Qwen3 and GPT-2 now use GPU add/mul instead of CPU round-trips

GPT-2 add_bias also moved to GPU (broadcast via tile + GPU add)

BF16 precision analysis (docs/benchmarks/phase10-qwen3.md):
- Root cause: separate attention kernels materialize BF16 intermediates
  (QK^T→BF16→scale→BF16→mask→BF16→softmax→BF16 vs HF's fused FP32 path)
- HF itself SDPA vs Eager also differs by ~0.125 logit
- xserv vs HF: ~1-2 logit systematic offset, but same top-1 in 84% cases
- Industry standard for BF16: top-5 overlap (we achieve 100%)
- Fix path: Flash Attention (Phase 14) to fuse attention in FP32

Performance: TTFT 138→119ms, TBT 144→137ms (GPU ops faster than CPU)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

crates/xserv-model/src/bin/dump-logits.rs

@@ -0,0 +1,44 @@
+use std::path::PathBuf;
+use xserv_model::{loader, KVCache, ModelConfig, Qwen3};
+use xserv_tensor::{DType, Device};
+use xserv_tokenizer::Tokenizer;
+use half::bf16;
+
+fn main() {
+    let args: Vec<String> = std::env::args().collect();
+    let model_dir = PathBuf::from(&args[1]);
+    let prompt = &args[2];
+
+    xserv_cuda::device::set_device(0).unwrap();
+    let config = ModelConfig::from_file(&model_dir.join("config.json"));
+    let weights = loader::load_model_dir(&model_dir, Device::Cuda(0));
+    let model = Qwen3::from_weights(config.clone(), weights);
+    let tokenizer = Tokenizer::from_file(&model_dir.join("tokenizer.json"));
+
+    let token_ids = tokenizer.encode(prompt);
+    eprintln!("Prompt: {prompt}");
+    eprintln!("Token IDs: {token_ids:?}");
+
+    let mut cache = KVCache::new(
+        config.num_layers(), config.num_kv_heads(), config.head_dim(),
+        DType::BF16, Device::Cuda(0),
+    );
+    let logits = model.forward_with_cache(&token_ids, &mut cache);
+    let logits_cpu = logits.to_device(Device::Cpu);
+    let data = logits_cpu.as_slice::<bf16>();
+    let vocab_size = logits.shape()[1];
+    let seq_len = logits.shape()[0];
+
+    // Print top-20 logits for the last position
+    let last_row = &data[(seq_len - 1) * vocab_size..seq_len * vocab_size];
+    let mut indexed: Vec<(usize, f32)> = last_row.iter().enumerate()
+        .map(|(i, v)| (i, v.to_f32()))
+        .collect();
+    indexed.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
+
+    println!("Top-20 logits (last position):");
+    for (rank, (id, val)) in indexed.iter().take(20).enumerate() {
+        let tok = tokenizer.decode(&[*id as u32]);
+        println!("  [{rank:>2}] id={id:>6} logit={val:>10.4} token={tok:?}");
+    }
+}

crates/xserv-model/src/gpt2.rs

@@ -247,27 +247,33 @@ fn matmul_2d(a: &Tensor, b: &Tensor) -> Tensor {
 }
 
 fn add_tensors(a: &Tensor, b: &Tensor) -> Tensor {
-    assert_eq!(a.shape(), b.shape());
-    assert_eq!(a.dtype(), DType::F32);
-    let a_cpu = a.to_device(Device::Cpu);
-    let b_cpu = b.to_device(Device::Cpu);
-    let a_data = a_cpu.as_slice::<f32>();
-    let b_data = b_cpu.as_slice::<f32>();
-    let sum: Vec<f32> = a_data.iter().zip(b_data).map(|(x, y)| x + y).collect();
-    Tensor::from_slice(&sum, a.shape()).to_device(a.device())
+    xserv_kernels::add(a, b)
 }
 
 fn add_bias(x: &Tensor, bias: &Tensor) -> Tensor {
+    // bias: [N], x: [S, N] — broadcast add via reshape
     assert_eq!(x.ndim(), 2);
     assert_eq!(bias.ndim(), 1);
-    assert_eq!(x.shape()[1], bias.shape()[0]);
-    let x_cpu = x.to_device(Device::Cpu);
-    let b_cpu = bias.to_device(Device::Cpu);
-    let x_data = x_cpu.as_slice::<f32>();
-    let b_data = b_cpu.as_slice::<f32>();
     let n = bias.shape()[0];
-    let result: Vec<f32> = x_data.iter().enumerate().map(|(i, &v)| v + b_data[i % n]).collect();
-    Tensor::from_slice(&result, x.shape()).to_device(x.device())
+    assert_eq!(x.shape()[1], n);
+    let rows = x.shape()[0];
+    // Broadcast: tile bias to [S, N] on CPU, then GPU add
+    let b_cpu = bias.to_device(Device::Cpu);
+    match x.dtype() {
+        DType::F32 => {
+            let bd = b_cpu.as_slice::<f32>();
+            let tiled: Vec<f32> = (0..rows).flat_map(|_| bd.iter().copied()).collect();
+            let b_full = Tensor::from_slice(&tiled, x.shape()).to_device(x.device());
+            xserv_kernels::add(x, &b_full)
+        }
+        DType::BF16 => {
+            let bd = b_cpu.as_slice::<half::bf16>();
+            let tiled: Vec<half::bf16> = (0..rows).flat_map(|_| bd.iter().copied()).collect();
+            let b_full = Tensor::from_slice(&tiled, x.shape()).to_device(x.device());
+            xserv_kernels::add(x, &b_full)
+        }
+        _ => panic!("unsupported dtype"),
+    }
 }
 
 fn split_qkv(qkv: &Tensor, num_heads: usize, head_dim: usize, seq_len: usize) -> (Tensor, Tensor, Tensor) {

crates/xserv-model/src/qwen3.rs

@@ -250,27 +250,11 @@ fn repeat_kv(x: &Tensor, n_rep: usize) -> Tensor {
 }
 
 fn add_any(a: &Tensor, b: &Tensor) -> Tensor {
-    assert_eq!(a.shape(), b.shape());
-    let a_cpu = a.to_device(Device::Cpu);
-    let b_cpu = b.to_device(Device::Cpu);
-    let ad = a_cpu.as_slice::<bf16>();
-    let bd = b_cpu.as_slice::<bf16>();
-    let r: Vec<bf16> = ad.iter().zip(bd)
-        .map(|(x, y)| bf16::from_f32(x.to_f32() + y.to_f32()))
-        .collect();
-    Tensor::from_slice(&r, a.shape()).to_device(a.device())
+    xserv_kernels::add(a, b)
 }
 
 fn mul_any(a: &Tensor, b: &Tensor) -> Tensor {
-    assert_eq!(a.shape(), b.shape());
-    let a_cpu = a.to_device(Device::Cpu);
-    let b_cpu = b.to_device(Device::Cpu);
-    let ad = a_cpu.as_slice::<bf16>();
-    let bd = b_cpu.as_slice::<bf16>();
-    let r: Vec<bf16> = ad.iter().zip(bd)
-        .map(|(x, y)| bf16::from_f32(x.to_f32() * y.to_f32()))
-        .collect();
-    Tensor::from_slice(&r, a.shape()).to_device(a.device())
+    xserv_kernels::mul(a, b)
 }
 
 pub fn sample_greedy(logits: &Tensor) -> u32 {