use crate::error::{BarracudaError, Result};
use std::collections::HashMap;
use std::ops::Deref;
use std::sync::atomic::{AtomicU32, AtomicUsize, Ordering};
use std::sync::{Arc, Mutex, RwLock, Weak};
pub struct PooledBuffer {
buffer: Option<wgpu::Buffer>,
pool: Weak<BufferPoolInner>,
bucket: usize,
}
impl PooledBuffer {
pub(crate) fn new(buffer: wgpu::Buffer, pool: Weak<BufferPoolInner>, bucket: usize) -> Self {
Self {
buffer: Some(buffer),
pool,
bucket,
}
}
#[must_use]
#[expect(
clippy::expect_used,
reason = "Option::Some invariant: buffer is taken only by into_buffer/Drop, which consume self"
)]
pub fn buffer(&self) -> &wgpu::Buffer {
self.buffer
.as_ref()
.expect("PooledBuffer::buffer after into_buffer (unreachable by ownership)")
}
#[must_use]
pub fn size(&self) -> u64 {
self.buffer().size()
}
#[must_use]
#[expect(
clippy::expect_used,
reason = "into_buffer consumes self; Option::None here means double-call (unreachable)"
)]
pub fn into_buffer(mut self) -> wgpu::Buffer {
self.buffer
.take()
.expect("PooledBuffer::into_buffer called twice (unreachable by ownership)")
}
}
impl Deref for PooledBuffer {
type Target = wgpu::Buffer;
#[expect(
clippy::expect_used,
reason = "Deref requires &T; buffer is Some until into_buffer/Drop consume self"
)]
fn deref(&self) -> &Self::Target {
self.buffer
.as_ref()
.expect("PooledBuffer::deref after into_buffer (unreachable by ownership)")
}
}
impl Drop for PooledBuffer {
fn drop(&mut self) {
if let Some(buffer) = self.buffer.take()
&& let Some(pool) = self.pool.upgrade()
{
pool.defer_return(buffer, self.bucket);
}
}
}
pub(crate) struct BufferPoolInner {
pub pools: RwLock<HashMap<usize, Vec<wgpu::Buffer>>>,
pub device: wgpu::Device,
poll_lock: Arc<Mutex<()>>,
active_encoders: Arc<AtomicU32>,
pub allocations: AtomicUsize,
pub reuses: AtomicUsize,
pub solver_buffers: RwLock<HashMap<String, SolverBufferSet>>,
pending: Mutex<Vec<(wgpu::Buffer, usize)>>,
}
impl BufferPoolInner {
fn return_buffer(&self, buffer: wgpu::Buffer, bucket: usize) {
self.pools
.write()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.entry(bucket)
.or_default()
.push(buffer);
self.reuses.fetch_add(1, Ordering::Relaxed);
}
fn defer_return(&self, buffer: wgpu::Buffer, bucket: usize) {
self.pending
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.push((buffer, bucket));
}
}
#[derive(Debug, Clone)]
pub struct BufferDescriptor {
pub size: u64,
pub usage: wgpu::BufferUsages,
pub label: Option<String>,
}
impl BufferDescriptor {
#[must_use]
pub fn new(size: u64) -> Self {
Self {
size,
usage: wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_SRC
| wgpu::BufferUsages::COPY_DST,
label: None,
}
}
#[must_use]
pub fn f64_array(count: usize) -> Self {
Self::new((count * std::mem::size_of::<f64>()) as u64)
}
#[must_use]
pub fn f32_array(count: usize) -> Self {
Self::new((count * std::mem::size_of::<f32>()) as u64)
}
#[must_use]
pub fn with_label(mut self, label: impl Into<String>) -> Self {
self.label = Some(label.into());
self
}
#[must_use]
pub fn with_usage(mut self, usage: wgpu::BufferUsages) -> Self {
self.usage = usage;
self
}
}
#[derive(Debug)]
pub struct SolverBufferSet {
solver_id: String,
buffers: HashMap<String, Arc<wgpu::Buffer>>,
}
impl SolverBufferSet {
#[must_use]
pub fn get(&self, name: &str) -> Option<&wgpu::Buffer> {
self.buffers.get(name).map(std::convert::AsRef::as_ref)
}
#[must_use]
pub fn get_arc(&self, name: &str) -> Option<Arc<wgpu::Buffer>> {
self.buffers.get(name).cloned()
}
#[must_use]
pub fn solver_id(&self) -> &str {
&self.solver_id
}
pub fn buffer_names(&self) -> impl Iterator<Item = &str> {
self.buffers.keys().map(std::string::String::as_str)
}
#[must_use]
pub fn len(&self) -> usize {
self.buffers.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.buffers.is_empty()
}
}
pub struct BufferPool {
inner: Arc<BufferPoolInner>,
}
impl BufferPool {
pub fn new(
device: wgpu::Device,
poll_lock: Arc<Mutex<()>>,
active_encoders: Arc<AtomicU32>,
) -> Self {
Self {
inner: Arc::new(BufferPoolInner {
pools: RwLock::new(HashMap::new()),
device,
poll_lock,
active_encoders,
allocations: AtomicUsize::new(0),
reuses: AtomicUsize::new(0),
solver_buffers: RwLock::new(HashMap::new()),
pending: Mutex::new(Vec::new()),
}),
}
}
#[must_use]
pub fn new_standalone(device: wgpu::Device) -> Self {
Self::new(
device,
Arc::new(Mutex::new(())),
Arc::new(AtomicU32::new(0)),
)
}
fn bucket_size(size: usize) -> usize {
let min_size = 256;
let size = size.max(min_size);
size.next_power_of_two()
}
pub fn drain_pending(&self) {
let pending_count = self
.inner
.pending
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.len();
if pending_count == 0 {
return;
}
if self.inner.active_encoders.load(Ordering::Acquire) > 0 {
return;
}
let _guard = match self.inner.poll_lock.try_lock() {
Ok(g) => g,
Err(std::sync::TryLockError::WouldBlock) => return,
Err(std::sync::TryLockError::Poisoned(e)) => e.into_inner(),
};
let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
let _ = self.inner.device.poll(wgpu::PollType::Poll);
}));
let drained: Vec<(wgpu::Buffer, usize)> = {
let mut pending = self
.inner
.pending
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
std::mem::take(&mut *pending)
};
for (buffer, bucket) in drained {
self.inner.return_buffer(buffer, bucket);
}
}
#[must_use]
pub fn acquire_pooled(&self, size_bytes: usize) -> PooledBuffer {
self.drain_pending();
let bucket = Self::bucket_size(size_bytes);
let buffer = self
.inner
.pools
.write()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.get_mut(&bucket)
.and_then(std::vec::Vec::pop)
.unwrap_or_else(|| self.allocate_new(bucket));
PooledBuffer::new(buffer, Arc::downgrade(&self.inner), bucket)
}
#[must_use]
pub fn acquire(&self, size_bytes: usize) -> wgpu::Buffer {
self.drain_pending();
let bucket = Self::bucket_size(size_bytes);
let recycled = self
.inner
.pools
.write()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.get_mut(&bucket)
.and_then(std::vec::Vec::pop);
if let Some(buf) = recycled {
self.inner.reuses.fetch_add(1, Ordering::Relaxed);
return buf;
}
self.allocate_new(bucket)
}
fn allocate_new(&self, bucket: usize) -> wgpu::Buffer {
self.inner.allocations.fetch_add(1, Ordering::Relaxed);
self.inner.active_encoders.fetch_add(1, Ordering::Acquire);
let buf = self.inner.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Pooled Buffer"),
size: bucket as u64,
usage: wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_SRC
| wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
self.inner.active_encoders.fetch_sub(1, Ordering::Release);
buf
}
pub fn release(&self, buffer: wgpu::Buffer) {
let bucket = Self::bucket_size(buffer.size() as usize);
self.inner
.pools
.write()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.entry(bucket)
.or_default()
.push(buffer);
}
#[must_use]
pub fn stats(&self) -> (usize, usize) {
(
self.inner.allocations.load(Ordering::Relaxed),
self.inner.reuses.load(Ordering::Relaxed),
)
}
pub fn pin_solver_buffers(
&self,
solver_id: &str,
buffers: &[(&str, BufferDescriptor)],
) -> Result<SolverBufferSet> {
let mut solver_buffers = self
.inner
.solver_buffers
.write()
.unwrap_or_else(std::sync::PoisonError::into_inner);
if solver_buffers.contains_key(solver_id) {
return Err(BarracudaError::InvalidInput {
message: format!(
"Solver '{solver_id}' already has pinned buffers. Call release_solver_buffers() first."
),
});
}
let mut buffer_map = HashMap::new();
for (name, desc) in buffers {
let label = desc
.label
.clone()
.unwrap_or_else(|| format!("{solver_id}:{name}"));
let buffer = self.inner.device.create_buffer(&wgpu::BufferDescriptor {
label: Some(&label),
size: desc.size,
usage: desc.usage,
mapped_at_creation: false,
});
self.inner.allocations.fetch_add(1, Ordering::Relaxed);
buffer_map.insert(name.to_string(), Arc::new(buffer));
}
let buffer_set = SolverBufferSet {
solver_id: solver_id.to_string(),
buffers: buffer_map.clone(),
};
solver_buffers.insert(solver_id.to_string(), buffer_set);
Ok(SolverBufferSet {
solver_id: solver_id.to_string(),
buffers: buffer_map,
})
}
#[must_use]
pub fn release_solver_buffers(&self, solver_id: &str) -> bool {
let mut solver_buffers = self
.inner
.solver_buffers
.write()
.unwrap_or_else(std::sync::PoisonError::into_inner);
solver_buffers.remove(solver_id).is_some()
}
#[must_use]
pub fn get_solver_buffers(&self, solver_id: &str) -> Option<SolverBufferSet> {
let solver_buffers = self
.inner
.solver_buffers
.read()
.unwrap_or_else(std::sync::PoisonError::into_inner);
solver_buffers.get(solver_id).map(|set| SolverBufferSet {
solver_id: set.solver_id.clone(),
buffers: set.buffers.clone(),
})
}
#[must_use]
pub fn has_solver_buffers(&self, solver_id: &str) -> bool {
let solver_buffers = self
.inner
.solver_buffers
.read()
.unwrap_or_else(std::sync::PoisonError::into_inner);
solver_buffers.contains_key(solver_id)
}
#[must_use]
pub fn solver_ids(&self) -> Vec<String> {
let solver_buffers = self
.inner
.solver_buffers
.read()
.unwrap_or_else(std::sync::PoisonError::into_inner);
solver_buffers.keys().cloned().collect()
}
}