feat: removes the dependency of once_cell (vllm-project#633)

Signed-off-by: htiennv <[email protected]>

Author: htiennv

candle-binding/Cargo.lock

@@ -36,8 +36,7 @@ tracing = "0.1.37"
 libc = "0.2.147"
 rand = "0.8.5"
 # Performance optimization: parallel processing and lock-free initialization
-rayon = "1.8"       
-once_cell = "1.19"  # Used for lazy initialization of global state
+rayon = "1.8"
 parking_lot = "0.12"
 crossbeam-channel = "0.5"  # Efficient multi-channel select for scheduler wakeup
 
@@ -56,4 +55,4 @@ path = "../examples/candle-binding/qwen3_example.rs"
 
 # Note: Benchmark binaries are located in ../bench/scripts/rust/candle-binding/
 # They are not included in the library build to keep it self-contained.
-# To run benchmarks, use the workspace-level Cargo.toml or run them directly from the bench directory.
+# To run benchmarks, use the workspace-level Cargo.toml or run them directly from the bench directory.

candle-binding/Cargo.toml

@@ -4,10 +4,9 @@
 //! including double-free protection, LoRA-specific memory management, and
 //! path switching safety mechanisms.
 
-use once_cell::sync::Lazy;
 use std::collections::HashMap;
 use std::ffi::c_char;
-use std::sync::{Arc, Mutex, RwLock};
+use std::sync::{Arc, LazyLock, Mutex, RwLock};
 
 /// Memory allocation tracking for double-free protection
 #[derive(Debug, Clone)]
@@ -48,16 +47,16 @@ pub struct MemorySafetyResult {
     pub double_free_attempts: usize,
 }
 
-// Global memory tracker for dual-path safety using once_cell::Lazy
+// Global memory tracker for dual-path safety using LazyLock
 // These are lazily initialized mutable global state for runtime memory tracking
-static MEMORY_TRACKER: Lazy<Arc<RwLock<HashMap<usize, AllocationTracker>>>> =
-    Lazy::new(|| Arc::new(RwLock::new(HashMap::new())));
-static DOUBLE_FREE_PROTECTION: Lazy<Arc<Mutex<HashMap<usize, bool>>>> =
-    Lazy::new(|| Arc::new(Mutex::new(HashMap::new())));
-static LORA_MEMORY_POOL: Lazy<Arc<Mutex<LoRAMemoryPool>>> =
-    Lazy::new(|| Arc::new(Mutex::new(LoRAMemoryPool::new())));
-static PATH_SWITCH_GUARD: Lazy<Arc<RwLock<PathSwitchState>>> =
-    Lazy::new(|| Arc::new(RwLock::new(PathSwitchState::new())));
+static MEMORY_TRACKER: LazyLock<Arc<RwLock<HashMap<usize, AllocationTracker>>>> =
+    LazyLock::new(|| Arc::new(RwLock::new(HashMap::new())));
+static DOUBLE_FREE_PROTECTION: LazyLock<Arc<Mutex<HashMap<usize, bool>>>> =
+    LazyLock::new(|| Arc::new(Mutex::new(HashMap::new())));
+static LORA_MEMORY_POOL: LazyLock<Arc<Mutex<LoRAMemoryPool>>> =
+    LazyLock::new(|| Arc::new(Mutex::new(LoRAMemoryPool::new())));
+static PATH_SWITCH_GUARD: LazyLock<Arc<RwLock<PathSwitchState>>> =
+    LazyLock::new(|| Arc::new(RwLock::new(PathSwitchState::new())));
 
 /// LoRA-specific memory pool for high-performance allocations
 #[derive(Debug)]

candle-binding/src/ffi/memory_safety.rs

@@ -1,8 +1,7 @@
 //! Global State Manager
 
-use once_cell::sync::Lazy;
 use std::collections::HashMap;
-use std::sync::{Arc, Mutex, RwLock};
+use std::sync::{Arc, LazyLock, Mutex, RwLock};
 
 // Import all necessary types
 use crate::classifiers::lora::parallel_engine::ParallelLoRAEngine;
@@ -322,8 +321,8 @@ pub struct GlobalStateStats {
     pub system_state: SystemState,
 }
 
-// Global singleton instance using once_cell::Lazy
-static GLOBAL_STATE_MANAGER: Lazy<GlobalStateManager> = Lazy::new(GlobalStateManager::new);
+// Global singleton instance using LazyLock
+static GLOBAL_STATE_MANAGER: LazyLock<GlobalStateManager> = LazyLock::new(GlobalStateManager::new);
 
 /// Convenience functions for backward compatibility