style: format Rust workspace

crates/xserv-kernels/tests/ops_test.rs

@@ -2,7 +2,9 @@ use half::bf16;
 use xserv_kernels::*;
 use xserv_tensor::{Device, Tensor};
 
-fn init() { xserv_cuda::device::set_device(0).unwrap(); }
+fn init() {
+    xserv_cuda::device::set_device(0).unwrap();
+}
 
 // --- CPU reference implementations ---
 
@@ -37,10 +39,12 @@ fn cpu_layernorm(x: &[f32], gamma: &[f32], beta: &[f32], eps: f32, hidden: usize
 
 fn cpu_gelu(x: &[f32]) -> Vec<f32> {
     let sqrt_2_over_pi = 0.7978845608f32;
-    x.iter().map(|&v| {
-        let inner = sqrt_2_over_pi * (v + 0.044715 * v * v * v);
-        0.5 * v * (1.0 + inner.tanh())
-    }).collect()
+    x.iter()
+        .map(|&v| {
+            let inner = sqrt_2_over_pi * (v + 0.044715 * v * v * v);
+            0.5 * v * (1.0 + inner.tanh())
+        })
+        .collect()
 }
 
 fn cpu_silu(x: &[f32]) -> Vec<f32> {
@@ -88,8 +92,13 @@ fn check_close(result: &[f32], expected: &[f32], atol: f32, name: &str) {
     let mut max_err = 0.0f32;
     for (i, (r, e)) in result.iter().zip(expected).enumerate() {
         let err = (r - e).abs();
-        if err > max_err { max_err = err; }
-        assert!(err <= atol, "{name}: mismatch at [{i}]: got {r}, expected {e}, err {err}");
+        if err > max_err {
+            max_err = err;
+        }
+        assert!(
+            err <= atol,
+            "{name}: mismatch at [{i}]: got {r}, expected {e}, err {err}"
+        );
     }
     println!("{name}: max_err = {max_err:.6e}");
 }
@@ -208,13 +217,18 @@ fn test_softmax_sum_to_one() {
     init();
     let rows = 4;
     let cols = 2048;
-    let data: Vec<f32> = (0..rows * cols).map(|i| ((i % 31) as f32 - 15.0) * 0.5).collect();
+    let data: Vec<f32> = (0..rows * cols)
+        .map(|i| ((i % 31) as f32 - 15.0) * 0.5)
+        .collect();
     let x = Tensor::from_slice(&data, &[rows, cols]).to_device(Device::Cuda(0));
     let out = softmax(&x).to_device(Device::Cpu);
     let result = out.as_slice::<f32>();
     for r in 0..rows {
         let row_sum: f32 = result[r * cols..(r + 1) * cols].iter().sum();
-        assert!((row_sum - 1.0).abs() < 1e-5, "softmax row {r} sum = {row_sum}");
+        assert!(
+            (row_sum - 1.0).abs() < 1e-5,
+            "softmax row {r} sum = {row_sum}"
+        );
     }
 }
 
@@ -247,8 +261,10 @@ fn test_embedding_f32() {
         for i in 0..hidden {
             let expected = table_data[tid as usize * hidden + i];
             let got = result[seq_idx * hidden + i];
-            assert!((got - expected).abs() < 1e-6,
-                "embedding mismatch at [{seq_idx},{i}]: got {got}, expected {expected}");
+            assert!(
+                (got - expected).abs() < 1e-6,
+                "embedding mismatch at [{seq_idx},{i}]: got {got}, expected {expected}"
+            );
         }
     }
 }
@@ -270,8 +286,8 @@ fn test_rope_f32() {
     let mut expected = x_data.clone();
     cpu_rope(&mut expected, &positions, num_heads, head_dim, theta);
 
-    let x = Tensor::from_slice(&x_data, &[num_tokens, num_heads, head_dim])
-        .to_device(Device::Cuda(0));
+    let x =
+        Tensor::from_slice(&x_data, &[num_tokens, num_heads, head_dim]).to_device(Device::Cuda(0));
     let cache = RopeCache::new(64, head_dim, theta);
     rope_inplace(&x, &cache, &positions);
 
@@ -292,8 +308,8 @@ fn test_rope_position_0_identity() {
         .map(|i| (i as f32 + 1.0) * 0.1)
         .collect();
 
-    let x = Tensor::from_slice(&x_data, &[num_tokens, num_heads, head_dim])
-        .to_device(Device::Cuda(0));
+    let x =
+        Tensor::from_slice(&x_data, &[num_tokens, num_heads, head_dim]).to_device(Device::Cuda(0));
     let cache = RopeCache::new(64, head_dim, 10000.0);
     rope_inplace(&x, &cache, &positions);