Struct HotReloadManager 

pub struct HotReloadManager {
    config: HotReloadConfig,
    kernels: RwLock<HashMap<KernelId, KernelCodeSource>>,
    fallbacks: RwLock<HashMap<KernelId, KernelCodeSource>>,
    active_requests: RwLock<HashMap<KernelId, HotReloadRequest>>,
    version_counter: AtomicU64,
    stats: HotReloadStats,
}

Manager for kernel hot reload operations.

Provides seamless kernel code updates without stopping the system:

1. Drain pending messages from kernel input queue
2. Checkpoint kernel state (if preserving state)
3. Compile/validate new kernel code
4. Swap old kernel with new kernel
5. Restore state to new kernel
6. Resume processing

Example

use ringkernel_core::multi_gpu::{HotReloadManager, HotReloadConfig, KernelCodeSource};

let manager = HotReloadManager::new(HotReloadConfig::default());

// Register a reloadable kernel
manager.register_kernel(&kernel_id, current_code);

// Request hot reload with new PTX
let new_code = KernelCodeSource::from_ptx(new_ptx, "my_kernel");
let request = manager.request_reload(&kernel_id, new_code).await?;

// Execute the reload
let result = manager.execute_reload(request, &mut kernel).await?;
println!("Reload completed in {:?}", result.total_duration);

Fields

config: HotReloadConfig

Configuration.

kernels: RwLock<HashMap<KernelId, KernelCodeSource>>

Registered kernels and their current code.

fallbacks: RwLock<HashMap<KernelId, KernelCodeSource>>

Fallback code for registered kernels.

active_requests: RwLock<HashMap<KernelId, HotReloadRequest>>

Active reload requests.

version_counter: AtomicU64

Version counter for code versions.

stats: HotReloadStats

Statistics.

Implementations

impl HotReloadManager

pub fn new(config: HotReloadConfig) -> Arc<Self>

Create a new hot reload manager.

pub fn with_defaults() -> Arc<Self>

Create with default configuration.

pub fn is_enabled(&self) -> bool

Check if hot reload is enabled.

pub fn register_kernel(&self, kernel_id: &KernelId, code: KernelCodeSource)

Register a kernel for hot reload.

pub fn unregister_kernel(&self, kernel_id: &KernelId)

Unregister a kernel from hot reload.

pub fn get_current_version(&self, kernel_id: &KernelId) -> Option<u64>

Get current code version for a kernel.

pub fn get_current_code(&self, kernel_id: &KernelId) -> Option<KernelCodeSource>

Get current code for a kernel.

pub fn request_reload( &self, kernel_id: &KernelId, new_code: KernelCodeSource, ) -> Result<HotReloadRequest>

Request a hot reload for a kernel.

pub fn execute_reload<K: CheckpointableKernel>( &self, request: &mut HotReloadRequest, kernel: &K, ) -> Result<HotReloadResult>

Execute a hot reload operation.

This performs the full reload sequence:

1. Drain pending messages
2. Checkpoint state (if enabled)
3. Validate new code
4. Swap kernels
5. Restore state (if enabled)

pub fn rollback(&self, kernel_id: &KernelId) -> Result<()>

Rollback to previous kernel version.

fn validate_code(&self, code: &KernelCodeSource) -> Result<()>

Validate kernel code before swap.

pub fn stats(&self) -> HotReloadStatsSnapshot

Get statistics snapshot.

pub fn list_kernels(&self) -> Vec<KernelId>

List all registered kernels.

pub fn is_registered(&self, kernel_id: &KernelId) -> bool

Check if a kernel is registered.

pub fn is_reload_in_progress(&self, kernel_id: &KernelId) -> bool

Check if a reload is in progress for a kernel.

pub fn config(&self) -> &HotReloadConfig

Get the configuration.