use std::sync::Arc;
use cudarc::driver::sys as cu;
use cudarc::driver::{CudaContext, CudaStream};
use super::GpuPeerError;
pub struct VramPool {
base: u64,
block_bytes: u32,
blocks: u32,
free: Vec<u32>,
ctx: Arc<CudaContext>,
}
impl VramPool {
pub fn new(
ctx: &Arc<CudaContext>,
stream: &Arc<CudaStream>,
block_bytes: u32,
blocks: u32,
) -> Result<Self, GpuPeerError> {
let total = block_bytes as usize * blocks as usize;
let slice = stream
.alloc_zeros::<u8>(total)
.map_err(|e| GpuPeerError::Driver(format!("vram pool alloc: {e:?}")))?;
let base = slice.leak();
Ok(Self {
base,
block_bytes,
blocks,
free: (0..blocks).rev().collect(),
ctx: Arc::clone(ctx),
})
}
#[inline]
pub fn base(&self) -> u64 {
self.base
}
#[inline]
pub fn block_bytes(&self) -> u32 {
self.block_bytes
}
#[inline]
pub fn blocks(&self) -> u32 {
self.blocks
}
#[inline]
pub fn block_ptr(&self, idx: u32) -> u64 {
debug_assert!(idx < self.blocks);
self.base + idx as u64 * self.block_bytes as u64
}
#[inline]
pub fn free_blocks(&self) -> usize {
self.free.len()
}
pub fn alloc(&mut self) -> Option<u32> {
self.free.pop()
}
pub fn alloc_span(&mut self, need: u32) -> Option<u32> {
let first = span_start(&self.free, need)?;
self.free.retain(|&b| b < first || b >= first + need);
Some(first)
}
pub fn release(&mut self, block: u32) {
debug_assert!(block < self.blocks);
debug_assert!(!self.free.contains(&block), "double release of block {block}");
self.free.push(block);
}
}
fn span_start(free: &[u32], need: u32) -> Option<u32> {
if need == 0 || need as usize > free.len() {
return None;
}
let mut sorted = free.to_vec();
sorted.sort_unstable();
let need_us = need as usize;
let mut run_start = 0usize;
for i in 1..=sorted.len() {
let contiguous = i < sorted.len() && sorted[i] == sorted[i - 1] + 1;
if !contiguous {
if i - run_start >= need_us {
return Some(sorted[run_start]);
}
run_start = i;
}
}
None
}
impl Drop for VramPool {
fn drop(&mut self) {
if self.ctx.bind_to_thread().is_ok() {
let _rc: cu::CUresult = unsafe { cu::cuMemFree_v2(self.base) };
}
}
}
#[cfg(test)]
mod tests {
#[test]
fn free_list_indexing_is_lifo_and_complete() {
let blocks = 8u32;
let mut free: Vec<u32> = (0..blocks).rev().collect();
assert_eq!(free.pop(), Some(0));
assert_eq!(free.pop(), Some(1));
free.push(0);
assert_eq!(free.pop(), Some(0));
let mut seen: Vec<u32> = std::mem::take(&mut free);
seen.sort_unstable();
assert_eq!(seen, (2..blocks).collect::<Vec<_>>());
}
#[test]
fn span_start_ignores_free_list_order() {
let free = vec![9u32, 4, 6, 5, 7, 2, 0];
assert_eq!(super::span_start(&free, 4), Some(4));
assert_eq!(super::span_start(&free, 1), Some(0));
assert_eq!(super::span_start(&free, 2), Some(4));
assert_eq!(super::span_start(&free, 5), None);
assert_eq!(super::span_start(&free, 0), None);
assert_eq!(super::span_start(&[], 1), None);
}
}