hi-cuda: apply cargo fmt to unblock the fmt·test CI gate

crates/hi-cuda/src/gpu.rs

@@ -3440,15 +3440,13 @@ mod native {
             // (Q6_K ~0.66 vs f16 2 bytes/param) and wins outright. So in the hybrid plan
             // (which is chosen precisely when we're not VRAM-starved) skip the f16 cache
             // for the head and let the dp4a GEMV below handle it.
-            let cache_output_head = is_output_head
-                && !self.cache_layer_f16
-                && {
-                    let f16_bytes = weight_elements.saturating_mul(std::mem::size_of::<u16>());
-                    self.dequant_f16_cache.borrow().contains_key(matrix_name)
-                        || crate::runtime::free_memory_bytes()
-                            .map(|free| f16_bytes.saturating_mul(2) <= free)
-                            .unwrap_or(true)
-                };
+            let cache_output_head = is_output_head && !self.cache_layer_f16 && {
+                let f16_bytes = weight_elements.saturating_mul(std::mem::size_of::<u16>());
+                self.dequant_f16_cache.borrow().contains_key(matrix_name)
+                    || crate::runtime::free_memory_bytes()
+                        .map(|free| f16_bytes.saturating_mul(2) <= free)
+                        .unwrap_or(true)
+            };
             // Fused Q6_K GEMV (M=1 decode): read Q6_K directly instead of dequantizing the
             // whole matrix to f32 every token — the per-op dequant is ~12x slower for Q6_K
             // models kept quantized (f16 doesn't fit). Also handles the Q6_K output head in
@@ -7268,8 +7266,7 @@ mod native {
             if token_ids.is_empty() {
                 bail!("append_tokens_logits requires at least one token");
             }
-            if self.config.recurrent_ssm_tensor_layout || !self.supports_batched_text_generation()
-            {
+            if self.config.recurrent_ssm_tensor_layout || !self.supports_batched_text_generation() {
                 bail!("append_tokens_logits requires a text decoder layout");
             }
             let dims = self.qwen_dims()?;
@@ -22858,6 +22855,21 @@ mod non_native {
             )
         }
 
+        #[allow(clippy::too_many_arguments)]
+        pub fn speculative_greedy_next_tokens_paged_with_page_table(
+            &self,
+            _sequence: &[u32],
+            _page_size: usize,
+            _page_table: &[usize],
+            _physical_page_count: usize,
+            _ngram: usize,
+            _max_draft: usize,
+        ) -> Result<Vec<u32>> {
+            bail!(
+                "hi-cuda was built without native-cuda support; GPU Qwen paged generation is unavailable"
+            )
+        }
+
         #[allow(clippy::too_many_arguments)]
         pub fn decode_sampled_next_tokens_batch_paged_with_page_tables(
             &self,

crates/hi-cuda/src/lib.rs

@@ -4733,7 +4733,10 @@ fn process_continuous_decode_chunk(
             .max_tokens
             .saturating_sub(active[idx].generated_tokens.len());
         let draft_cap = max_draft.min(remaining.saturating_sub(1));
-        let extended = active[idx].context_len().saturating_add(draft_cap).saturating_add(1);
+        let extended = active[idx]
+            .context_len()
+            .saturating_add(draft_cap)
+            .saturating_add(1);
         let page_table = match active[idx].page_table_for_token_count(extended, state.kv_page_size)
         {
             Ok(pt) => pt,
@@ -4759,9 +4762,10 @@ fn process_continuous_decode_chunk(
                 stats
                     .decode_tokens
                     .fetch_add(usize_to_u64(tokens.len()), Ordering::Relaxed);
-                stats
-                    .decode_micros
-                    .fetch_add(usize_to_u64(elapsed.as_micros() as usize), Ordering::Relaxed);
+                stats.decode_micros.fetch_add(
+                    usize_to_u64(elapsed.as_micros() as usize),
+                    Ordering::Relaxed,
+                );
                 for token in tokens {
                     if retire[idx].is_some() {
                         break;
@@ -11861,13 +11865,20 @@ mod tests {
 
         // Every emitted token is the model's greedy token, so speculative decode must
         // reproduce plain greedy exactly, regardless of what the n-gram proposer guesses.
-        for input in [vec![0u32], vec![1, 0, 1, 0, 1], vec![0, 1, 2, 0, 1, 2, 0, 1]] {
+        for input in [
+            vec![0u32],
+            vec![1, 0, 1, 0, 1],
+            vec![0, 1, 2, 0, 1, 2, 0, 1],
+        ] {
             let max = 12usize;
             let greedy = model.generate_greedy_tokens(&input, max, None).unwrap();
             let spec = model
                 .generate_greedy_speculative_ngram(&input, max, None, 2, 4)
                 .unwrap();
-            assert_eq!(spec.tokens, greedy, "speculative output diverged from greedy");
+            assert_eq!(
+                spec.tokens, greedy,
+                "speculative output diverged from greedy"
+            );
             // One forward pass yields at least one token, never more tokens than passes*(draft+1).
             assert!(spec.forward_passes >= 1);
             assert!(spec.forward_passes <= spec.tokens.len().max(1));