use std::sync::Arc;
use cudarc::driver::sys as cu;
use cudarc::driver::{CudaFunction, CudaStream, LaunchConfig, PushKernelArg};
use super::GpuPeerError;
use super::layout::{HDR_ACTIVE_GEN_OFF, HDR_EXITS_OFF, HDR_STOP_OFF};
use super::region::PeerRegion;
pub struct Poller {
stream: Arc<CudaStream>,
func: CudaFunction,
launches: u32,
quantum_ns: u64,
idle_exit_ns: u64,
vram_base: u64,
vram_block_bytes: u32,
vram_blocks: u32,
blocks_per_lane: u32,
paused: bool,
}
impl Poller {
#[expect(
clippy::too_many_arguments,
reason = "internal constructor mirroring the kernel's parameter list; a config struct would restate GpuPeerConfig"
)]
pub fn new(
stream: Arc<CudaStream>,
func: CudaFunction,
quantum_ns: u64,
idle_exit_ns: u64,
vram_base: u64,
vram_block_bytes: u32,
vram_blocks: u32,
blocks_per_lane: u32,
) -> Self {
Self {
stream,
func,
launches: 0,
quantum_ns,
idle_exit_ns,
vram_base,
vram_block_bytes,
vram_blocks,
blocks_per_lane: blocks_per_lane.max(1),
paused: false,
}
}
fn completed_launches(&self, region: &PeerRegion) -> u32 {
let blocks = region.geometry().lanes.max(1) * self.blocks_per_lane.max(1);
region.load_u32(HDR_EXITS_OFF) / blocks
}
pub fn ensure_running(&mut self, region: &PeerRegion) -> Result<(), GpuPeerError> {
if self.paused {
return Ok(()); }
if self.completed_launches(region) < self.launches {
return Ok(()); }
let generation = self.launches.wrapping_add(1);
self.launches = generation;
region.store_u32(HDR_ACTIVE_GEN_OFF, generation);
region.release_fence();
let g = region.geometry();
let dev_base = region.dev_base();
let lanes = g.lanes;
let slot_bytes = g.slot_bytes;
let slots_per_lane = g.slots_per_lane;
let quantum = self.quantum_ns;
let idle = self.idle_exit_ns;
let mut b = self.stream.launch_builder(&self.func);
b.arg(&dev_base);
b.arg(&lanes);
b.arg(&slot_bytes);
b.arg(&slots_per_lane);
b.arg(&quantum);
b.arg(&idle);
b.arg(&generation);
b.arg(&self.vram_base);
b.arg(&self.vram_block_bytes);
b.arg(&self.vram_blocks);
b.arg(&self.blocks_per_lane);
unsafe {
b.launch(LaunchConfig {
grid_dim: (lanes * self.blocks_per_lane, 1, 1),
block_dim: (256, 1, 1),
shared_mem_bytes: 0,
})
}
.map_err(|e| GpuPeerError::Driver(format!("poller launch: {e:?}")))?;
let _rc: cu::CUresult = unsafe { cu::cuStreamQuery(self.stream.cu_stream()) };
Ok(())
}
pub fn pause(&mut self, region: &PeerRegion) -> Result<(), GpuPeerError> {
if self.paused {
return Ok(());
}
region.store_u32(HDR_STOP_OFF, 1);
region.release_fence();
self.stream
.synchronize()
.map_err(|e| GpuPeerError::Driver(format!("poller pause sync: {e:?}")))?;
region.store_u32(HDR_STOP_OFF, 0);
region.release_fence();
self.paused = true;
Ok(())
}
pub fn resume(&mut self) {
self.paused = false;
}
#[inline]
pub fn is_paused(&self) -> bool {
self.paused
}
pub fn shutdown(&mut self, region: &PeerRegion) {
region.store_u32(HDR_STOP_OFF, 1);
region.release_fence();
self.stream.synchronize().ok();
}
}