fix: 12 bug fixes from comprehensive review — 51 tok/s verified on RTX 5090

P0 fixes (blocking usability):
- FIX-01: thread-local cuBLAS handle (was creating/destroying per matmul)
- FIX-16: EOS token no longer leaks into API responses
- FIX-17: max_seq_len configurable via --max-seq-len (default 2048, was hardcoded 256)
- FIX-18: max_tokens clamped to available seq space, prompt overflow returns 400

P1 fixes (bugs & performance):
- FIX-07: CachingAllocator wired into all hot paths (to_device, embedding, rope, concat)
- FIX-08: CudaDeviceProp buffer increased to 32KB for CUDA 12.9 safety
- FIX-09: tokenizer byte_fallback graceful degradation (was panic)
- FIX-19: causal mask uses -INFINITY instead of -1e9 (BF16 supports inf)
- FIX-20: LayerNorm rewritten to numerically stable two-pass algorithm
- FIX-21: min block size guard (32 threads) for LayerNorm/RMSNorm launches

P2 fixes (improvements):
- FIX-22: Option<GpuKVCache> + take() eliminates dummy KV cache allocations
- FIX-23: RoPE cache no longer artificially capped at 8192 positions

Verified on dash5 (RTX 5090): 51 tok/s batch=1, 74 tok/s 2-concurrent, 1.7-3.3x HF transformers.

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

crates/xserv-kernels/src/embedding.rs

@@ -26,7 +26,7 @@ pub fn embedding(table: &Tensor, token_ids: &[u32]) -> Tensor {
             num_tokens * std::mem::size_of::<u32>(),
         )
     };
-    let mut ids_gpu = GpuBuffer::alloc(ids_bytes.len()).expect("alloc token_ids");
+    let mut ids_gpu = xserv_cuda::allocator::cached_alloc(ids_bytes.len()).expect("alloc token_ids");
     ids_gpu.copy_from_host(ids_bytes).unwrap();
 
     let out = Tensor::empty(&[num_tokens, hidden_size], table.dtype(), table.device());

crates/xserv-kernels/src/gemm.rs

@@ -1,3 +1,4 @@
+use std::cell::RefCell;
 use std::ffi::c_void;
 use xserv_cuda::error::{self, Result};
 use xserv_tensor::{DType, Device, Tensor};
@@ -82,6 +83,23 @@ impl Drop for CublasContext {
     }
 }
 
+thread_local! {
+    static CUBLAS_CTX: RefCell<CublasContext> = RefCell::new(
+        CublasContext::new().expect("failed to create thread-local cuBLAS handle")
+    );
+}
+
+/// Borrow the thread-local cuBLAS handle for the duration of a closure.
+fn with_cublas<F, R>(f: F) -> R
+where
+    F: FnOnce(CublasHandle) -> R,
+{
+    CUBLAS_CTX.with(|cell| {
+        let ctx = cell.borrow();
+        f(ctx.handle)
+    })
+}
+
 /// Matrix multiplication: C = A @ B
 /// A: [M, K], B: [K, N], C: [M, N]
 /// All tensors must be contiguous and on the same GPU.
@@ -143,7 +161,6 @@ pub fn matmul(a: &Tensor, b: &Tensor, backend: GemmBackend) -> Tensor {
                 // cuBLAS uses column-major, but we have row-major tensors.
                 // Trick: compute C^T = B^T @ A^T, which gives us C in row-major.
                 // cuBLAS sees our row-major data as column-major transposed.
-                let ctx = CublasContext::new().unwrap();
                 let alpha = 1.0f32;
                 let beta = 0.0f32;
 
@@ -153,12 +170,12 @@ pub fn matmul(a: &Tensor, b: &Tensor, backend: GemmBackend) -> Tensor {
                     _ => panic!("unsupported dtype for cuBLAS GEMM"),
                 };
 
-                unsafe {
-                    cublasSetStream_v2(ctx.handle, null_stream);
+                with_cublas(|handle| unsafe {
+                    cublasSetStream_v2(handle, null_stream);
                     // Row-major trick: swap A/B and transpose flags
                     // C(row-major) = A @ B  <=>  C^T(col-major) = B^T @ A^T
                     error::check(cublasGemmEx(
-                        ctx.handle,
+                        handle,
                         CUBLAS_OP_N, CUBLAS_OP_N,
                         n as i32, m as i32, k as i32,
                         &alpha as *const f32 as *const c_void,
@@ -169,7 +186,7 @@ pub fn matmul(a: &Tensor, b: &Tensor, backend: GemmBackend) -> Tensor {
                         CUBLAS_COMPUTE_32F,
                         -1, // default algo
                     )).expect("cuBLAS GEMM failed");
-                }
+                });
             }
         }
     }
@@ -221,12 +238,11 @@ pub fn batched_matmul(a: &Tensor, b: &Tensor) -> Tensor {
     let stride_b = (k * n) as i64;
     let stride_c = (m * n) as i64;
 
-    let ctx = CublasContext::new().unwrap();
-    unsafe {
-        cublasSetStream_v2(ctx.handle, std::ptr::null_mut());
+    with_cublas(|handle| unsafe {
+        cublasSetStream_v2(handle, std::ptr::null_mut());
         // Row-major trick: C = A @ B ⟺ C^T = B^T @ A^T (col-major)
         error::check(cublasGemmStridedBatchedEx(
-            ctx.handle,
+            handle,
             CUBLAS_OP_N, CUBLAS_OP_N,
             n as i32, m as i32, k as i32,
             &alpha as *const f32 as *const c_void,
@@ -238,6 +254,6 @@ pub fn batched_matmul(a: &Tensor, b: &Tensor) -> Tensor {
             CUBLAS_COMPUTE_32F,
             -1,
         )).expect("cuBLAS batched GEMM failed");
-    }
+    });
     c
 }

crates/xserv-kernels/src/rope.rs

@@ -58,7 +58,7 @@ pub fn rope_inplace(x: &Tensor, cache: &RopeCache, positions: &[u32]) {
             num_tokens * std::mem::size_of::<u32>(),
         )
     };
-    let mut pos_gpu = GpuBuffer::alloc(pos_bytes.len()).expect("alloc positions");
+    let mut pos_gpu = xserv_cuda::allocator::cached_alloc(pos_bytes.len()).expect("alloc positions");
     pos_gpu.copy_from_host(pos_bytes).unwrap();
 
     unsafe {