feat(ci): add performance regression workflow

- Add benchmark.yml workflow for PR performance regression testing
- Fix benchmark compilation errors (add EnhancedMetricsCollector to SchedulerEngine::new calls)
- Format code with cargo fmt

Tasks 23-26: Phase 5 CI Performance Regression & Final Verification

Author: pplmx

.github/workflows/benchmark.yml

@@ -0,0 +1,37 @@
+name: Performance Regression
+
+on:
+  pull_request:
+    branches: [main]
+
+jobs:
+  benchmark:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install Rust
+        uses: dtolnay/rust-action@stable
+      - name: Cache cargo
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target/
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+      - name: Run Benchmarks (PR)
+        run: cargo bench -- --save-baseline pr
+      - name: Checkout Main
+        run: |
+          git fetch origin main
+          git checkout origin/main
+      - name: Run Benchmarks (Main)
+        run: cargo bench -- --save-baseline main
+      - name: Compare Results
+        run: cargo bench -- --baseline main --threshold 10
+      - name: Upload Results
+        if: always()
+        uses: actions/upload-artifact@v3
+        with:
+          name: benchmark-results
+          path: target/criterion/

crates/core/benches/optimization_benchmarks.rs

@@ -0,0 +1,172 @@
+use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
+use std::hint::black_box;
+use std::sync::Arc;
+use tokio::sync::mpsc;
+use vllm_core::engine::Engine;
+use vllm_core::metrics::EnhancedMetricsCollector;
+use vllm_core::scheduler::SchedulerEngine;
+use vllm_core::types::{AdaptiveDraftConfig, Request, SchedulerConfig};
+use vllm_testing::IncrementModel;
+
+/// Benchmark Sequence Packing vs FIFO
+fn bench_sequence_packing(c: &mut Criterion) {
+    let mut group = c.benchmark_group("sequence_packing");
+    let metrics = Arc::new(EnhancedMetricsCollector::new());
+
+    for batch_size in [4, 8, 16].iter() {
+        // FIFO baseline
+        group.bench_with_input(
+            BenchmarkId::new("fifo", batch_size),
+            batch_size,
+            |b, &batch_size| {
+                let config = SchedulerConfig {
+                    packing: vllm_core::types::SequencePackingConfig {
+                        enabled: false,
+                        ..Default::default()
+                    },
+                    ..Default::default()
+                };
+                let mut scheduler = SchedulerEngine::new(config, 1024, metrics.clone());
+
+                // Add requests with varying lengths
+                for i in 0..batch_size {
+                    let len = 100 + (i * 50); // 100, 150, 200, ...
+                    scheduler.add_request(Request::new(i as u64, vec![1; len], 10));
+                }
+
+                b.iter(|| {
+                    black_box(scheduler.build_batch());
+                });
+            },
+        );
+
+        // Packing optimized
+        group.bench_with_input(
+            BenchmarkId::new("packing", batch_size),
+            batch_size,
+            |b, &batch_size| {
+                let config = SchedulerConfig::default(); // packing enabled by default
+                let mut scheduler = SchedulerEngine::new(config, 1024, metrics.clone());
+
+                // Add requests with varying lengths
+                for i in 0..batch_size {
+                    let len = 100 + (i * 50);
+                    scheduler.add_request(Request::new(i as u64, vec![1; len], 10));
+                }
+
+                b.iter(|| {
+                    black_box(scheduler.build_batch());
+                });
+            },
+        );
+    }
+
+    group.finish();
+}
+
+/// Benchmark Adaptive Speculative Decoding
+fn bench_adaptive_speculative(c: &mut Criterion) {
+    let mut group = c.benchmark_group("adaptive_speculative");
+
+    // Fixed draft tokens
+    group.bench_function("fixed_draft", |b| {
+        let config = SchedulerConfig::default();
+        let mut engine = Engine::with_config(IncrementModel, IncrementModel, config, 4, 1024);
+
+        let (tx, _rx) = mpsc::channel(64);
+        engine.add_request(Request::new(1, vec![10, 20], 50), tx);
+
+        b.iter(|| {
+            black_box(engine.step_speculative().unwrap());
+        });
+    });
+
+    // Adaptive draft tokens
+    group.bench_function("adaptive_draft", |b| {
+        let config = SchedulerConfig::default();
+        let mut engine = Engine::with_config(IncrementModel, IncrementModel, config, 4, 1024);
+        engine.enable_adaptive_speculative(AdaptiveDraftConfig::default());
+
+        let (tx, _rx) = mpsc::channel(64);
+        engine.add_request(Request::new(1, vec![10, 20], 50), tx);
+
+        b.iter(|| {
+            black_box(engine.step_adaptive_speculative().unwrap());
+        });
+    });
+
+    group.finish();
+}
+
+/// Benchmark end-to-end throughput
+fn bench_throughput(c: &mut Criterion) {
+    let mut group = c.benchmark_group("throughput");
+    group.sample_size(10);
+
+    for num_requests in [10, 50, 100].iter() {
+        // Baseline: No optimizations
+        group.bench_with_input(
+            BenchmarkId::new("baseline", num_requests),
+            num_requests,
+            |b, &num_requests| {
+                let config = SchedulerConfig {
+                    packing: vllm_core::types::SequencePackingConfig {
+                        enabled: false,
+                        ..Default::default()
+                    },
+                    ..Default::default()
+                };
+                let mut engine =
+                    Engine::with_config(IncrementModel, IncrementModel, config, 4, 1024);
+
+                for i in 0..num_requests {
+                    let (tx, _rx) = mpsc::channel(64);
+                    engine.add_request(Request::new(i as u64, vec![10, 20], 20), tx);
+                }
+
+                b.iter(|| {
+                    let mut completed = 0;
+                    while completed < num_requests {
+                        let results = black_box(engine.step().unwrap());
+                        completed += results.len();
+                    }
+                });
+            },
+        );
+
+        // All optimizations enabled
+        group.bench_with_input(
+            BenchmarkId::new("optimized", num_requests),
+            num_requests,
+            |b, &num_requests| {
+                let config = SchedulerConfig::default();
+                let mut engine =
+                    Engine::with_config(IncrementModel, IncrementModel, config, 4, 1024);
+                engine.enable_adaptive_speculative(AdaptiveDraftConfig::default());
+
+                for i in 0..num_requests {
+                    let (tx, _rx) = mpsc::channel(64);
+                    engine.add_request(Request::new(i as u64, vec![10, 20], 20), tx);
+                }
+
+                b.iter(|| {
+                    let mut completed = 0;
+                    while completed < num_requests {
+                        let results = black_box(engine.step_adaptive_speculative().unwrap());
+                        completed += results.len();
+                    }
+                });
+            },
+        );
+    }
+
+    group.finish();
+}
+
+criterion_group!(
+    benches,
+    bench_sequence_packing,
+    bench_adaptive_speculative,
+    bench_throughput
+);
+criterion_main!(benches);

crates/core/benches/scheduler.rs

@@ -1,5 +1,7 @@
 use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
 use std::hint::black_box;
+use std::sync::Arc;
+use vllm_core::metrics::EnhancedMetricsCollector;
 use vllm_core::scheduler::SchedulerEngine;
 use vllm_core::types::{Request, SchedulerConfig};
 
@@ -17,18 +19,20 @@ fn scheduler_add_request(c: &mut Criterion) {
         max_batch_size: 256,
         ..Default::default()
     };
+    let metrics = Arc::new(EnhancedMetricsCollector::new());
 
     c.bench_function("scheduler_new", |b| {
         b.iter(|| {
-            let scheduler = SchedulerEngine::new(config.clone(), 1024);
+            let scheduler = SchedulerEngine::new(config.clone(), 1024, metrics.clone());
             black_box(scheduler)
         });
     });
 }
 
 fn scheduler_build_batch(c: &mut Criterion) {
     let config = SchedulerConfig::default();
-    let mut scheduler = SchedulerEngine::new(config, 1024);
+    let metrics = Arc::new(EnhancedMetricsCollector::new());
+    let mut scheduler = SchedulerEngine::new(config, 1024, metrics);
 
     for i in 0..100 {
         let tokens: Vec<u32> = (0..128).map(|j| (i * 100 + j) as u32).collect();

crates/core/benches/scheduler_benchmarks.rs

@@ -2,6 +2,7 @@ use criterion::{Criterion, criterion_group, criterion_main};
 use std::hint::black_box;
 use std::sync::Arc;
 use std::time::Instant;
+use vllm_core::metrics::EnhancedMetricsCollector;
 use vllm_core::scheduler::policy::{FcfsPolicy, SchedulingContext, SchedulingPolicy, SjfPolicy};
 use vllm_core::scheduler::{
     PhaseScheduler, PhaseSwitchPolicy, RequestQueue, SchedulerEngine, SchedulerState,
@@ -106,11 +107,12 @@ fn bench_scheduling_policies(c: &mut Criterion) {
 fn bench_batch_building(c: &mut Criterion) {
     let mut group = c.benchmark_group("batch_building");
     let config = SchedulerConfig::default();
+    let metrics = Arc::new(EnhancedMetricsCollector::new());
 
     group.bench_function("build_batch_10", |b| {
         b.iter_with_setup(
             || {
-                let mut engine = SchedulerEngine::new(config.clone(), 1024);
+                let mut engine = SchedulerEngine::new(config.clone(), 1024, metrics.clone());
                 for i in 0..10 {
                     engine.add_request(Request::new(i, vec![i as u32; 50], 100));
                 }
@@ -123,7 +125,7 @@ fn bench_batch_building(c: &mut Criterion) {
     group.bench_function("build_batch_100", |b| {
         b.iter_with_setup(
             || {
-                let mut engine = SchedulerEngine::new(config.clone(), 1024);
+                let mut engine = SchedulerEngine::new(config.clone(), 1024, metrics.clone());
                 for i in 0..100 {
                     engine.add_request(Request::new(i, vec![i as u32; 50], 100));
                 }

crates/core/src/circuit_breaker/breaker.rs

@@ -1,14 +1,14 @@
 // crates/core/src/circuit_breaker/breaker.rs
-use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicU64, Ordering};
 use std::time::{Duration, Instant};
 use tokio::sync::RwLock;
 
 /// Circuit breaker state
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum CircuitState {
-    Closed, // Normal operation
-    Open,   // Failing, reject calls
+    Closed,   // Normal operation
+    Open,     // Failing, reject calls
     HalfOpen, // Testing recovery
 }
 
@@ -161,7 +161,9 @@ mod tests {
         };
         let breaker = CircuitBreaker::new(config);
         for _ in 0..3 {
-            let _ = breaker.call(|| async { Err::<i32, TestError>(TestError("fail")) }).await;
+            let _ = breaker
+                .call(|| async { Err::<i32, TestError>(TestError("fail")) })
+                .await;
         }
         let result = breaker.call(|| async { Ok::<_, TestError>(42) }).await;
         assert!(matches!(result, Err(CircuitBreakerError::Open)));
@@ -176,7 +178,9 @@ mod tests {
         };
         let breaker = CircuitBreaker::new(config);
         // First failure opens the circuit
-        let _ = breaker.call(|| async { Err::<i32, TestError>(TestError("fail")) }).await;
+        let _ = breaker
+            .call(|| async { Err::<i32, TestError>(TestError("fail")) })
+            .await;
         // Wait for recovery timeout
         tokio::time::sleep(Duration::from_millis(100)).await;
         // The next call will transition to HalfOpen
@@ -198,8 +202,12 @@ mod tests {
         };
         let breaker = CircuitBreaker::new(config);
         // Two failures open the circuit
-        let _ = breaker.call(|| async { Err::<i32, TestError>(TestError("fail")) }).await;
-        let _ = breaker.call(|| async { Err::<i32, TestError>(TestError("fail")) }).await;
+        let _ = breaker
+            .call(|| async { Err::<i32, TestError>(TestError("fail")) })
+            .await;
+        let _ = breaker
+            .call(|| async { Err::<i32, TestError>(TestError("fail")) })
+            .await;
         // Wait for recovery
         tokio::time::sleep(Duration::from_millis(100)).await;
         // Check that we're in HalfOpen by making a call that succeeds

crates/core/src/circuit_breaker/mod.rs

@@ -3,6 +3,4 @@
 pub mod breaker;
 pub mod strategy;
 pub use breaker::{CircuitBreaker, CircuitBreakerConfig, CircuitBreakerError, CircuitState};
-pub use strategy::{
-    DegradeStrategy, FailFastStrategy, FallbackStrategy, RetryStrategy,
-};
+pub use strategy::{DegradeStrategy, FailFastStrategy, FallbackStrategy, RetryStrategy};

crates/core/src/circuit_breaker/strategy.rs

@@ -119,8 +119,7 @@ mod tests {
         let attempts = std::sync::atomic::AtomicUsize::new(0);
         let result = strategy
             .execute(|| async {
-                let count =
-                    attempts.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+                let count = attempts.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
                 if count < 2 {
                     Err::<i32, ()>(())
                 } else {