use super::WgpuDevice;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, Mutex};
pub struct AsyncSubmitter {
device: Arc<WgpuDevice>,
pending: Mutex<Vec<wgpu::CommandBuffer>>,
submission_index: AtomicU64,
completed_index: AtomicU64,
}
impl AsyncSubmitter {
#[must_use]
pub fn new(device: Arc<WgpuDevice>) -> Self {
Self {
device,
pending: Mutex::new(Vec::with_capacity(16)),
submission_index: AtomicU64::new(0),
completed_index: AtomicU64::new(0),
}
}
pub fn queue(&self, command_buffer: wgpu::CommandBuffer) {
let mut pending = self
.pending
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
pending.push(command_buffer);
}
pub fn queue_operation<F>(&self, f: F)
where
F: FnOnce(&mut wgpu::CommandEncoder),
{
let mut encoder =
self.device
.device()
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("AsyncSubmitter encoder"),
});
f(&mut encoder);
self.queue(encoder.finish());
}
pub fn submit_all(&self) -> u64 {
let mut pending = self
.pending
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
if pending.is_empty() {
return self.submission_index.load(Ordering::SeqCst);
}
let index = self.submission_index.fetch_add(1, Ordering::SeqCst) + 1;
let buffers: Vec<_> = pending.drain(..).collect();
let lock = self.device.gpu_lock_arc();
let _guard = lock
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
self.device.brief_encoder_wait();
self.device.queue().submit(buffers);
let completed = Arc::new(AtomicU64::new(0));
let completed_clone = completed;
let idx = index;
self.device.queue().on_submitted_work_done(move || {
completed_clone.store(idx, Ordering::SeqCst);
});
index
}
pub fn submit_immediate(&self, command_buffer: wgpu::CommandBuffer) -> u64 {
let index = self.submission_index.fetch_add(1, Ordering::SeqCst) + 1;
let lock = self.device.gpu_lock_arc();
let _guard = lock
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
self.device.brief_encoder_wait();
self.device.queue().submit(Some(command_buffer));
index
}
pub fn current_index(&self) -> u64 {
self.submission_index.load(Ordering::SeqCst)
}
pub fn is_complete(&self, index: u64) -> bool {
self.device.poll_nonblocking();
self.completed_index.load(Ordering::SeqCst) >= index
}
pub fn wait_for(&self, index: u64) {
if self.completed_index.load(Ordering::SeqCst) >= index {
return;
}
let _ = self.device.poll_safe();
}
pub fn wait_all(&self) {
let current = self.submission_index.load(Ordering::SeqCst);
self.wait_for(current);
}
pub fn pending_count(&self) -> usize {
self.pending
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.len()
}
pub fn clear_pending(&self) {
self.pending
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.clear();
}
}
pub struct AsyncReadback {
device: Arc<WgpuDevice>,
staging_buffer: wgpu::Buffer,
size_bytes: u64,
receiver: std::sync::mpsc::Receiver<Result<(), wgpu::BufferAsyncError>>,
}
impl AsyncReadback {
#[must_use]
pub fn new(device: &WgpuDevice, source: &wgpu::Buffer, size_bytes: u64) -> Self {
Self::with_device(Arc::new(device.clone()), source, size_bytes)
}
#[must_use]
pub fn with_device(device: Arc<WgpuDevice>, source: &wgpu::Buffer, size_bytes: u64) -> Self {
let (staging_buffer, commands) = {
device.encoding_guard();
let staging = device.device().create_buffer(&wgpu::BufferDescriptor {
label: Some("AsyncReadback staging"),
size: size_bytes,
usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let mut encoder =
device
.device()
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("AsyncReadback copy"),
});
encoder.copy_buffer_to_buffer(source, 0, &staging, 0, size_bytes);
let cmds = encoder.finish();
device.encoding_complete();
(staging, cmds)
};
{
let lock = device.gpu_lock_arc();
let _guard = lock
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
device.brief_encoder_wait();
device.queue().submit(Some(commands));
}
let (sender, receiver) =
std::sync::mpsc::sync_channel::<std::result::Result<(), wgpu::BufferAsyncError>>(1);
{
device.encoding_guard();
staging_buffer
.slice(..)
.map_async(wgpu::MapMode::Read, move |result| {
sender.send(result).ok();
});
device.encoding_complete();
}
Self {
device,
staging_buffer,
size_bytes,
receiver,
}
}
#[must_use]
pub fn poll(&self) -> bool {
self.device.poll_nonblocking();
self.receiver.try_recv().is_ok()
}
async fn poll_until_ready(&self) -> crate::error::Result<()> {
use crate::error::BarracudaError;
loop {
let poll_ok = !self.device.is_lost();
if poll_ok {
self.device.poll_nonblocking();
}
if !poll_ok {
return Err(BarracudaError::device_lost(
"GPU device lost during async poll",
));
}
match self.receiver.try_recv() {
Ok(result) => {
return result.map_err(|e| BarracudaError::gpu(format!("buffer map: {e:?}")));
}
Err(std::sync::mpsc::TryRecvError::Empty) => {
tokio::task::yield_now().await;
}
Err(std::sync::mpsc::TryRecvError::Disconnected) => {
return Err(BarracudaError::gpu("readback cancelled — sender dropped"));
}
}
}
}
pub async fn read_f32(self) -> crate::error::Result<Vec<f32>> {
self.poll_until_ready().await?;
let data = self.staging_buffer.slice(..).get_mapped_range();
let result: Vec<f32> = bytemuck::cast_slice(&data).to_vec();
drop(data);
self.staging_buffer.unmap();
Ok(result)
}
pub async fn read_f64(self) -> crate::error::Result<Vec<f64>> {
self.poll_until_ready().await?;
let data = self.staging_buffer.slice(..).get_mapped_range();
let result: Vec<f64> = bytemuck::cast_slice(&data).to_vec();
drop(data);
self.staging_buffer.unmap();
Ok(result)
}
pub async fn read_u32(self) -> crate::error::Result<Vec<u32>> {
self.poll_until_ready().await?;
let data = self.staging_buffer.slice(..).get_mapped_range();
let result: Vec<u32> = bytemuck::cast_slice(&data).to_vec();
drop(data);
self.staging_buffer.unmap();
Ok(result)
}
pub async fn read_bytes(self) -> crate::error::Result<bytes::Bytes> {
self.poll_until_ready().await?;
let data = self.staging_buffer.slice(..).get_mapped_range();
let result = bytes::Bytes::copy_from_slice(&data);
drop(data);
self.staging_buffer.unmap();
Ok(result)
}
pub fn read_f32_blocking(self) -> crate::error::Result<Vec<f32>> {
use crate::error::BarracudaError;
self.device
.poll_safe()
.map_err(|_| BarracudaError::device_lost("GPU device lost during blocking poll"))?;
self.receiver
.recv()
.map_err(|_| BarracudaError::gpu("readback cancelled — sender dropped"))?
.map_err(|e| BarracudaError::gpu(format!("buffer map: {e:?}")))?;
let data = self.staging_buffer.slice(..).get_mapped_range();
let result = bytemuck::cast_slice::<u8, f32>(&data).to_vec();
drop(data);
self.staging_buffer.unmap();
Ok(result)
}
pub fn read_f64_blocking(self) -> crate::error::Result<Vec<f64>> {
use crate::error::BarracudaError;
self.device
.poll_safe()
.map_err(|_| BarracudaError::device_lost("GPU device lost during blocking poll"))?;
self.receiver
.recv()
.map_err(|_| BarracudaError::gpu("readback cancelled — sender dropped"))?
.map_err(|e| BarracudaError::gpu(format!("buffer map: {e:?}")))?;
let data = self.staging_buffer.slice(..).get_mapped_range();
let result = bytemuck::cast_slice::<u8, f64>(&data).to_vec();
drop(data);
self.staging_buffer.unmap();
Ok(result)
}
#[must_use]
pub fn size_bytes(&self) -> u64 {
self.size_bytes
}
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn test_submitter_creation() {
let Some(wgpu_device) = crate::device::test_pool::get_test_device_if_gpu_available().await
else {
return;
};
let submitter = AsyncSubmitter::new(Arc::clone(&wgpu_device));
assert_eq!(submitter.pending_count(), 0);
assert_eq!(submitter.current_index(), 0);
}
#[test]
fn test_submission_index_increment() {
let index = AtomicU64::new(0);
assert_eq!(index.fetch_add(1, Ordering::SeqCst) + 1, 1);
assert_eq!(index.fetch_add(1, Ordering::SeqCst) + 1, 2);
}
#[tokio::test]
async fn test_submitter_queue_and_submit() {
let Some(wgpu_device) = crate::device::test_pool::get_test_device_if_gpu_available().await
else {
return;
};
let submitter = AsyncSubmitter::new(Arc::clone(&wgpu_device));
submitter.queue_operation(|encoder| {
let _ = encoder; });
assert_eq!(submitter.pending_count(), 1);
submitter.queue_operation(|encoder| {
let _ = encoder;
});
assert_eq!(submitter.pending_count(), 2);
let idx = submitter.submit_all();
assert_eq!(idx, 1);
assert_eq!(submitter.pending_count(), 0);
}
#[tokio::test]
async fn test_submitter_multiple_submissions() {
let Some(wgpu_device) = crate::device::test_pool::get_test_device_if_gpu_available().await
else {
return;
};
let submitter = AsyncSubmitter::new(Arc::clone(&wgpu_device));
submitter.queue_operation(|_| {});
let idx1 = submitter.submit_all();
submitter.queue_operation(|_| {});
let idx2 = submitter.submit_all();
assert_eq!(idx1, 1);
assert_eq!(idx2, 2);
assert_eq!(submitter.current_index(), 2);
}
#[tokio::test]
async fn test_submitter_empty_submit() {
let Some(wgpu_device) = crate::device::test_pool::get_test_device_if_gpu_available().await
else {
return;
};
let submitter = AsyncSubmitter::new(Arc::clone(&wgpu_device));
let idx = submitter.submit_all();
assert_eq!(idx, 0, "empty submit should not increment index");
}
#[tokio::test]
async fn test_readback_creation_and_f32_roundtrip() {
use wgpu::util::DeviceExt;
let Some(wgpu_device) = crate::device::test_pool::get_test_device_if_gpu_available().await
else {
return;
};
let data: Vec<f32> = vec![1.0, 2.0, 3.0, 4.0];
wgpu_device.encoding_guard();
let buffer = wgpu_device
.device()
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("test_readback_src"),
contents: bytemuck::cast_slice(&data),
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
});
wgpu_device.encoding_complete();
let readback = AsyncReadback::new(&wgpu_device, &buffer, buffer.size());
assert_eq!(readback.size_bytes(), buffer.size());
match readback.read_f32().await {
Ok(result) => assert_eq!(result, data),
Err(e) if e.is_retriable() => return,
Err(e) => panic!("readback failed: {e}"),
}
}
#[tokio::test]
async fn test_readback_bytes_roundtrip() {
use wgpu::util::DeviceExt;
let Some(wgpu_device) = crate::device::test_pool::get_test_device_if_gpu_available().await
else {
return;
};
let data: Vec<f32> = vec![42.0, 99.0];
wgpu_device.encoding_guard();
let buffer = wgpu_device
.device()
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("test_readback_bytes"),
contents: bytemuck::cast_slice(&data),
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
});
wgpu_device.encoding_complete();
let readback = AsyncReadback::new(&wgpu_device, &buffer, buffer.size());
match readback.read_bytes().await {
Ok(result) => assert_eq!(result.len(), std::mem::size_of::<f32>() * 2),
Err(e) if e.is_retriable() => return,
Err(e) => panic!("readback failed: {e}"),
}
}
}