use std::sync::Arc;
use cudarc::driver::sys as cu;
use cudarc::driver::{CudaFunction, CudaStream, LaunchConfig, PushKernelArg};
use super::GpuPeerError;
use super::layout::{HDR_STOP_OFF, lane_exits_off, lane_gen_off};
use super::region::PeerRegion;
pub struct Poller {
streams: Vec<Arc<CudaStream>>,
func: CudaFunction,
launches: Vec<u32>,
quantum_ns: u64,
idle_exit_ns: u64,
vram_base: u64,
vram_block_bytes: u32,
vram_blocks: u32,
lane_teams: Vec<u32>,
barrier_deadline_ns: u64,
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(
streams: Vec<Arc<CudaStream>>,
func: CudaFunction,
quantum_ns: u64,
idle_exit_ns: u64,
vram_base: u64,
vram_block_bytes: u32,
vram_blocks: u32,
lane_teams: Vec<u32>,
barrier_deadline_ns: u64,
) -> Self {
Self {
streams,
func,
launches: Vec::new(),
quantum_ns,
idle_exit_ns,
vram_base,
vram_block_bytes,
vram_blocks,
lane_teams: lane_teams.into_iter().map(|team| team.max(1)).collect(),
barrier_deadline_ns: barrier_deadline_ns.max(1),
paused: false,
}
}
fn team_of(&self, lane: u32) -> Result<u32, GpuPeerError> {
self.lane_teams
.get(lane as usize)
.copied()
.ok_or(GpuPeerError::Unavailable("no team width recorded for the lane"))
}
fn completed_launches(&self, region: &PeerRegion, lane: u32, team: u32) -> u32 {
region.load_u32(lane_exits_off(lane)) / team.max(1)
}
pub fn ensure_running(
&mut self,
region: &PeerRegion,
lane: u32,
) -> Result<(), GpuPeerError> {
if self.paused {
return Ok(()); }
let lane_count = region.geometry().lanes.max(1);
if lane >= lane_count {
return Err(GpuPeerError::Unavailable("lane beyond the region geometry"));
}
if self.launches.len() < lane_count as usize {
self.launches.resize(lane_count as usize, 0);
}
let team = self.team_of(lane)?;
let launched = self.launches[lane as usize];
if self.completed_launches(region, lane, team) < launched {
return Ok(()); }
let generation = launched.wrapping_add(1);
region.store_u32(lane_gen_off(lane), 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 stream = match self.streams.get(lane as usize) {
Some(s) => Arc::clone(s),
None => return Err(GpuPeerError::Unavailable("no stream for lane")),
};
let mut b = 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);
let barrier_deadline = self.barrier_deadline_ns;
b.arg(&barrier_deadline);
b.arg(&team);
b.arg(&lane);
unsafe {
b.launch(LaunchConfig {
grid_dim: (team, 1, 1),
block_dim: (256, 1, 1),
shared_mem_bytes: 0,
})
}
.map_err(|e| GpuPeerError::Driver(format!("poller launch: {e:?}")))?;
self.launches[lane as usize] = generation;
let _rc: cu::CUresult = unsafe { cu::cuStreamQuery(stream.cu_stream()) };
Ok(())
}
pub fn ensure_running_all(&mut self, region: &PeerRegion) -> Result<(), GpuPeerError> {
for lane in 0..region.geometry().lanes.max(1) {
self.ensure_running(region, lane)?;
}
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();
for (lane, s) in self.streams.iter().enumerate() {
s.synchronize()
.map_err(|e| GpuPeerError::Driver(format!("poller pause sync lane {lane}: {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();
for (lane, s) in self.streams.iter().enumerate() {
if let Err(e) = s.synchronize() {
notice!("flynnel gpu_peer: lane {lane} shutdown sync failed: {e:?}");
}
}
}
}