#![allow(clippy::missing_errors_doc)]
#![allow(clippy::missing_panics_doc)]
use crate::{error::GpuResult, GpuDevice, GpuError};
use std::collections::HashMap;
use std::sync::Mutex;
use wgpu::{util::DeviceExt, Buffer, BufferDescriptor, BufferUsages};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum BufferUsage {
Storage,
Uniform,
Vertex,
Index,
Staging,
Custom(BufferUsages),
}
impl BufferUsage {
pub fn to_wgpu_usage(self) -> BufferUsages {
match self {
BufferUsage::Storage => {
BufferUsages::STORAGE | BufferUsages::COPY_DST | BufferUsages::COPY_SRC
}
BufferUsage::Uniform => BufferUsages::UNIFORM | BufferUsages::COPY_DST,
BufferUsage::Vertex => BufferUsages::VERTEX | BufferUsages::COPY_DST,
BufferUsage::Index => BufferUsages::INDEX | BufferUsages::COPY_DST,
BufferUsage::Staging => {
BufferUsages::MAP_READ
| BufferUsages::MAP_WRITE
| BufferUsages::COPY_SRC
| BufferUsages::COPY_DST
}
BufferUsage::Custom(usage) => usage,
}
}
}
pub struct GpuBuffer {
buffer: Buffer,
size: u64,
usage: BufferUsage,
device: GpuDevice,
}
impl GpuBuffer {
pub fn new(device: GpuDevice, size: u64, usage: BufferUsage) -> GpuResult<Self> {
let buffer = device.device().create_buffer(&BufferDescriptor {
label: Some("Moirai GPU Buffer"),
size,
usage: usage.to_wgpu_usage(),
mapped_at_creation: false,
});
Ok(Self {
buffer,
size,
usage,
device,
})
}
pub fn with_data<T: bytemuck::Pod>(
device: GpuDevice,
data: &[T],
usage: BufferUsage,
) -> GpuResult<Self> {
let bytes = bytemuck::cast_slice(data);
let buffer = device
.device()
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Moirai GPU Buffer"),
contents: bytes,
usage: usage.to_wgpu_usage(),
});
Ok(Self {
buffer,
size: bytes.len() as u64,
usage,
device,
})
}
pub fn buffer(&self) -> &Buffer {
&self.buffer
}
pub fn size(&self) -> u64 {
self.size
}
pub fn usage(&self) -> BufferUsage {
self.usage
}
pub fn write<T: bytemuck::Pod>(&self, data: &[T], offset: u64) -> GpuResult<()> {
let bytes = bytemuck::cast_slice(data);
if offset + bytes.len() as u64 > self.size {
return Err(GpuError::ValidationError(
"Write would exceed buffer bounds".to_string(),
));
}
self.device
.queue()
.write_buffer(&self.buffer, offset, bytes);
Ok(())
}
pub async fn map_read(&self, offset: u64, size: Option<u64>) -> GpuResult<()> {
let map_size = size.unwrap_or(self.size - offset);
let buffer_slice = self.buffer.slice(offset..offset + map_size);
let (sender, receiver) = futures::channel::oneshot::channel();
buffer_slice.map_async(wgpu::MapMode::Read, move |result| {
let _ = sender.send(result);
});
self.device.device().poll(wgpu::Maintain::Wait);
receiver
.await
.map_err(|_| GpuError::BufferMappingFailed("Channel closed".to_string()))?
.map_err(GpuError::from)?;
Ok(())
}
pub async fn map_write(&self, offset: u64, size: Option<u64>) -> GpuResult<()> {
let map_size = size.unwrap_or(self.size - offset);
let buffer_slice = self.buffer.slice(offset..offset + map_size);
let (sender, receiver) = futures::channel::oneshot::channel();
buffer_slice.map_async(wgpu::MapMode::Write, move |result| {
let _ = sender.send(result);
});
self.device.device().poll(wgpu::Maintain::Wait);
receiver
.await
.map_err(|_| GpuError::BufferMappingFailed("Channel closed".to_string()))?
.map_err(GpuError::from)?;
Ok(())
}
pub fn copy_from(&self, src: &GpuBuffer, encoder: &mut wgpu::CommandEncoder) -> GpuResult<()> {
if self.size != src.size {
return Err(GpuError::ValidationError(
"Buffer sizes must match for copy".to_string(),
));
}
encoder.copy_buffer_to_buffer(&src.buffer, 0, &self.buffer, 0, self.size);
Ok(())
}
}
pub struct GpuBufferPool {
pools: Mutex<HashMap<(u64, BufferUsage), Vec<GpuBuffer>>>,
stats: Mutex<PoolStats>,
}
#[derive(Debug, Default)]
struct PoolStats {
total_allocated: u64,
total_reused: u64,
peak_memory_usage: u64,
current_memory_usage: u64,
}
impl GpuBufferPool {
pub fn new() -> Self {
Self {
pools: Mutex::new(HashMap::new()),
stats: Mutex::new(PoolStats::default()),
}
}
pub fn acquire(
&self,
device: GpuDevice,
size: u64,
usage: BufferUsage,
) -> GpuResult<GpuBuffer> {
let mut pools = self.pools.lock().unwrap();
let mut stats = self.stats.lock().unwrap();
let key = (size, usage);
if let Some(pool) = pools.get_mut(&key) {
if let Some(buffer) = pool.pop() {
stats.total_reused += 1;
return Ok(buffer);
}
}
let buffer = GpuBuffer::new(device, size, usage)?;
stats.total_allocated += 1;
stats.current_memory_usage += size;
stats.peak_memory_usage = stats.peak_memory_usage.max(stats.current_memory_usage);
Ok(buffer)
}
pub fn release(&self, buffer: GpuBuffer) {
let mut pools = self.pools.lock().unwrap();
let key = (buffer.size(), buffer.usage());
pools.entry(key).or_default().push(buffer);
}
pub fn stats(&self) -> (u64, u64, u64, u64) {
let stats = self.stats.lock().unwrap();
(
stats.total_allocated,
stats.total_reused,
stats.peak_memory_usage,
stats.current_memory_usage,
)
}
pub fn clear(&self) {
let mut pools = self.pools.lock().unwrap();
let mut stats = self.stats.lock().unwrap();
pools.clear();
stats.current_memory_usage = 0;
}
}
impl Default for GpuBufferPool {
fn default() -> Self {
Self::new()
}
}