style: format Rust workspace

crates/xserv-model/src/bin/xserv-cli.rs

@@ -1,6 +1,6 @@
 use std::io::{self, Write};
 use std::path::PathBuf;
-use xserv_model::{loader, KVCache, ModelConfig, PagedKVCache, BLOCK_SIZE};
+use xserv_model::{BLOCK_SIZE, KVCache, ModelConfig, PagedKVCache, loader};
 use xserv_tensor::{DType, Device};
 use xserv_tokenizer::Tokenizer;
 
@@ -21,14 +21,21 @@ fn main() {
 
     xserv_cuda::device::set_device(0).unwrap();
     let info = xserv_cuda::device::device_info(0).unwrap();
-    eprintln!("GPU: {} ({} MB free)", info.name, info.free_memory / 1024 / 1024);
+    eprintln!(
+        "GPU: {} ({} MB free)",
+        info.name,
+        info.free_memory / 1024 / 1024
+    );
 
     let config = ModelConfig::from_file(&model_dir.join("config.json"));
     let model_type = config.model_type.as_deref().unwrap_or("unknown");
     eprintln!(
         "Model: {model_type}, layers={}, hidden={}, heads={}/{} kv, vocab={}",
-        config.num_layers(), config.hidden(), config.num_heads(),
-        config.num_kv_heads(), config.vocab_size
+        config.num_layers(),
+        config.hidden(),
+        config.num_heads(),
+        config.num_kv_heads(),
+        config.vocab_size
     );
 
     eprintln!("Loading weights...");
@@ -37,7 +44,11 @@ fn main() {
 
     let is_qwen3 = model_type.contains("qwen");
     let is_gpt_oss = model_type.contains("gpt_oss");
-    let dtype = if is_qwen3 || is_gpt_oss { DType::BF16 } else { DType::F32 };
+    let dtype = if is_qwen3 || is_gpt_oss {
+        DType::BF16
+    } else {
+        DType::F32
+    };
 
     // Build model
     enum Model {
@@ -60,10 +71,16 @@ fn main() {
         print!("xserv> ");
         io::stdout().flush().unwrap();
         let mut input = String::new();
-        if io::stdin().read_line(&mut input).unwrap() == 0 { break; }
+        if io::stdin().read_line(&mut input).unwrap() == 0 {
+            break;
+        }
         let input = input.trim();
-        if input.is_empty() { continue; }
-        if input == "quit" || input == "exit" { break; }
+        if input.is_empty() {
+            continue;
+        }
+        if input == "quit" || input == "exit" {
+            break;
+        }
 
         let token_ids = tokenizer.encode(input);
 
@@ -73,12 +90,21 @@ fn main() {
             let max_blocks_per_seq = (max_seq + BLOCK_SIZE - 1) / BLOCK_SIZE;
             let total_blocks = max_blocks_per_seq + 64;
             let mut paged_cache = PagedKVCache::new(
-                &config, total_blocks, 0, 4, max_blocks_per_seq, DType::BF16, 0,
+                &config,
+                total_blocks,
+                0,
+                4,
+                max_blocks_per_seq,
+                DType::BF16,
+                0,
             );
             let slot = 0;
             paged_cache.register_sequence(slot).expect("register slot");
 
-            let model = match &model { Model::GptOss(m) => m, _ => unreachable!() };
+            let model = match &model {
+                Model::GptOss(m) => m,
+                _ => unreachable!(),
+            };
             let logits = model.forward_prefill_paged(&token_ids, slot, &mut paged_cache);
             let mut next = sample_greedy_last(&logits);
 
@@ -90,20 +116,28 @@ fn main() {
                 print!("{text}");
                 io::stdout().flush().unwrap();
 
-                if tokenizer.eos_token_id() == Some(next) { break; }
+                if tokenizer.eos_token_id() == Some(next) {
+                    break;
+                }
 
                 let pos = paged_cache.seq_len(slot);
-                let logits = model.forward_decode_paged(
-                    &[next], &[pos], &[slot], &mut paged_cache,
-                );
+                let logits = model.forward_decode_paged(&[next], &[pos], &[slot], &mut paged_cache);
                 next = sample_greedy_last(&logits);
             }
             println!();
             paged_cache.free_sequence(slot);
         } else {
-            let kv_heads = if is_qwen3 { config.num_kv_heads() } else { config.num_heads() };
+            let kv_heads = if is_qwen3 {
+                config.num_kv_heads()
+            } else {
+                config.num_heads()
+            };
             let mut cache = KVCache::new(
-                config.num_layers(), kv_heads, config.head_dim(), dtype, Device::Cuda(0),
+                config.num_layers(),
+                kv_heads,
+                config.head_dim(),
+                dtype,
+                Device::Cuda(0),
             );
 
             let logits = match &model {
@@ -125,7 +159,9 @@ fn main() {
                 print!("{text}");
                 io::stdout().flush().unwrap();
 
-                if tokenizer.eos_token_id() == Some(next) { break; }
+                if tokenizer.eos_token_id() == Some(next) {
+                    break;
+                }
 
                 let logits = match &model {
                     Model::GPT2(m) => m.forward_with_cache(&[next], &mut cache),
@@ -151,7 +187,9 @@ fn sample_greedy_last(logits: &xserv_tensor::Tensor) -> u32 {
     let seq_len = logits.shape()[0];
     let data = logits_cpu.as_slice::<bf16>();
     let last = &data[(seq_len - 1) * vocab_size..seq_len * vocab_size];
-    last.iter().enumerate()
+    last.iter()
+        .enumerate()
         .max_by(|a, b| a.1.to_f32().partial_cmp(&b.1.to_f32()).unwrap())
-        .map(|(i, _)| i as u32).unwrap()
+        .map(|(i, _)| i as u32)
+        .unwrap()
 }