1use crate::context::GpuContext;
7use crate::error::{GpuError, GpuResult};
8use bytemuck::{Pod, Zeroable};
9use std::marker::PhantomData;
10use std::sync::Arc;
11use tracing::{debug, trace};
12use wgpu::{
13 Buffer, BufferAsyncError, BufferDescriptor, BufferUsages, COPY_BUFFER_ALIGNMENT, MapMode,
14};
15
16#[derive(Debug, Clone, Copy, PartialEq, Eq)]
25pub enum BufferElementType {
26 F32,
28 F16,
30 U8,
32 U16,
34 U32,
36 I32,
38}
39
40impl BufferElementType {
41 pub fn byte_size(self) -> usize {
43 match self {
44 Self::F32 | Self::I32 | Self::U32 => 4,
45 Self::F16 | Self::U16 => 2,
46 Self::U8 => 1,
47 }
48 }
49
50 pub fn wgsl_type(self) -> &'static str {
55 match self {
56 Self::F32 => "f32",
57 Self::F16 => "f16",
58 Self::U32 => "u32",
59 Self::I32 => "i32",
60 Self::U8 => "u32", Self::U16 => "u32", }
63 }
64}
65
66pub fn f16_to_f32_slice(data: &[half::f16]) -> Vec<f32> {
75 data.iter().map(|h| f32::from(*h)).collect()
76}
77
78pub fn f32_to_f16_slice(data: &[f32]) -> Vec<half::f16> {
84 data.iter().map(|f| half::f16::from_f32(*f)).collect()
85}
86
87pub fn from_f16_slice_widening(
100 context: &GpuContext,
101 data: &[half::f16],
102) -> GpuResult<GpuBuffer<f32>> {
103 let f32_data = f16_to_f32_slice(data);
104 GpuBuffer::<f32>::from_data(
105 context,
106 &f32_data,
107 BufferUsages::STORAGE | BufferUsages::COPY_SRC | BufferUsages::COPY_DST,
108 )
109}
110
111pub fn from_f16_slice_native(context: &GpuContext, data: &[half::f16]) -> GpuResult<GpuBuffer<u8>> {
121 let bytes: &[u8] = bytemuck::cast_slice(data);
122 GpuBuffer::<u8>::from_data(
123 context,
124 bytes,
125 BufferUsages::STORAGE | BufferUsages::COPY_SRC | BufferUsages::COPY_DST,
126 )
127}
128
129pub fn read_f16_from_f32_buffer(buf: &GpuBuffer<f32>) -> GpuResult<Vec<half::f16>> {
138 let f32_vals = buf.read_blocking()?;
139 Ok(f32_to_f16_slice(&f32_vals))
140}
141
142pub struct GpuBuffer<T: Pod> {
147 buffer: Arc<Buffer>,
149 context: GpuContext,
151 len: usize,
153 usage: BufferUsages,
155 _phantom: PhantomData<T>,
157}
158
159impl<T: Pod> GpuBuffer<T> {
160 pub fn new(context: &GpuContext, len: usize, usage: BufferUsages) -> GpuResult<Self> {
166 let size = Self::calculate_size(len)?;
167
168 trace!("Creating GPU buffer: {} elements, {} bytes", len, size);
169
170 let buffer = context.device().create_buffer(&BufferDescriptor {
171 label: Some("GpuBuffer"),
172 size,
173 usage,
174 mapped_at_creation: false,
175 });
176
177 Ok(Self {
178 buffer: Arc::new(buffer),
179 context: context.clone(),
180 len,
181 usage,
182 _phantom: PhantomData,
183 })
184 }
185
186 pub fn from_data(context: &GpuContext, data: &[T], usage: BufferUsages) -> GpuResult<Self> {
192 let mut buffer = Self::new(context, data.len(), usage | BufferUsages::COPY_DST)?;
193 buffer.write(data)?;
194 Ok(buffer)
195 }
196
197 pub fn staging(context: &GpuContext, len: usize) -> GpuResult<Self> {
203 Self::new(
204 context,
205 len,
206 BufferUsages::MAP_READ | BufferUsages::COPY_DST,
207 )
208 }
209
210 fn calculate_size(len: usize) -> GpuResult<u64> {
212 let element_size = std::mem::size_of::<T>();
213 let size = len
214 .checked_mul(element_size)
215 .ok_or_else(|| GpuError::invalid_buffer("Buffer size overflow"))?;
216
217 let aligned_size = ((size as u64 + COPY_BUFFER_ALIGNMENT - 1) / COPY_BUFFER_ALIGNMENT)
219 * COPY_BUFFER_ALIGNMENT;
220
221 Ok(aligned_size)
222 }
223
224 pub fn write(&mut self, data: &[T]) -> GpuResult<()> {
231 if data.len() != self.len {
232 return Err(GpuError::invalid_buffer(format!(
233 "Data size mismatch: expected {}, got {}",
234 self.len,
235 data.len()
236 )));
237 }
238
239 if !self.usage.contains(BufferUsages::COPY_DST) {
240 return Err(GpuError::invalid_buffer(
241 "Buffer not writable (missing COPY_DST usage)",
242 ));
243 }
244
245 let bytes = bytemuck::cast_slice(data);
246 self.context.queue().write_buffer(&self.buffer, 0, bytes);
247
248 debug!("Wrote {} bytes to GPU buffer", bytes.len());
249 Ok(())
250 }
251
252 pub async fn read(&self) -> GpuResult<Vec<T>> {
258 if !self.usage.contains(BufferUsages::MAP_READ) {
259 return Err(GpuError::invalid_buffer(
260 "Buffer not readable (missing MAP_READ usage)",
261 ));
262 }
263
264 let buffer_slice = self.buffer.slice(..);
265
266 let (tx, rx) = futures::channel::oneshot::channel();
268 buffer_slice.map_async(MapMode::Read, move |result| {
269 let _ = tx.send(result);
270 });
271
272 self.context.poll(true);
274
275 rx.await
277 .map_err(|_| GpuError::buffer_mapping("Channel closed"))?
278 .map_err(|e| GpuError::buffer_mapping(Self::map_error_to_string(e)))?;
279
280 let data = buffer_slice
282 .get_mapped_range()
283 .map_err(|e| GpuError::buffer_mapping(e.to_string()))?;
284 let mut result: Vec<T> = bytemuck::cast_slice(&data).to_vec();
285
286 result.truncate(self.len);
294
295 drop(data);
297 self.buffer.unmap();
298
299 debug!("Read {} elements from GPU buffer", result.len());
300 Ok(result)
301 }
302
303 pub async fn read_async(&self) -> GpuResult<Vec<T>> {
320 self.read().await
321 }
322
323 pub fn read_blocking(&self) -> GpuResult<Vec<T>> {
329 pollster::block_on(self.read())
330 }
331
332 pub fn copy_from(&mut self, source: &GpuBuffer<T>) -> GpuResult<()> {
338 if self.len != source.len {
339 return Err(GpuError::invalid_buffer(format!(
340 "Buffer size mismatch: {} != {}",
341 self.len, source.len
342 )));
343 }
344
345 if !source.usage.contains(BufferUsages::COPY_SRC) {
346 return Err(GpuError::invalid_buffer(
347 "Source buffer not copyable (missing COPY_SRC usage)",
348 ));
349 }
350
351 if !self.usage.contains(BufferUsages::COPY_DST) {
352 return Err(GpuError::invalid_buffer(
353 "Destination buffer not copyable (missing COPY_DST usage)",
354 ));
355 }
356
357 let mut encoder =
358 self.context
359 .device()
360 .create_command_encoder(&wgpu::CommandEncoderDescriptor {
361 label: Some("Buffer Copy"),
362 });
363
364 let size = Self::calculate_size(self.len)?;
365 encoder.copy_buffer_to_buffer(&source.buffer, 0, &self.buffer, 0, size);
366
367 self.context.check_device_lost()?;
368 self.context.queue().submit(Some(encoder.finish()));
369
370 debug!("Copied {} elements between GPU buffers", self.len);
371 Ok(())
372 }
373
374 pub fn len(&self) -> usize {
376 self.len
377 }
378
379 pub fn is_empty(&self) -> bool {
381 self.len == 0
382 }
383
384 pub fn size_bytes(&self) -> u64 {
386 Self::calculate_size(self.len).unwrap_or(0)
387 }
388
389 pub fn buffer(&self) -> &Buffer {
391 &self.buffer
392 }
393
394 pub fn usage(&self) -> BufferUsages {
396 self.usage
397 }
398
399 fn map_error_to_string(error: BufferAsyncError) -> String {
401 error.to_string()
402 }
403}
404
405impl<T: Pod> Clone for GpuBuffer<T> {
406 fn clone(&self) -> Self {
407 Self {
408 buffer: Arc::clone(&self.buffer),
409 context: self.context.clone(),
410 len: self.len,
411 usage: self.usage,
412 _phantom: PhantomData,
413 }
414 }
415}
416
417impl<T: Pod> std::fmt::Debug for GpuBuffer<T> {
418 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
419 f.debug_struct("GpuBuffer")
420 .field("len", &self.len)
421 .field("size_bytes", &self.size_bytes())
422 .field("usage", &self.usage)
423 .field("type", &std::any::type_name::<T>())
424 .finish()
425 }
426}
427
428pub struct GpuRasterBuffer<T: Pod> {
433 bands: Vec<GpuBuffer<T>>,
435 width: u32,
437 height: u32,
439}
440
441impl<T: Pod + Zeroable> GpuRasterBuffer<T> {
442 pub fn new(
448 context: &GpuContext,
449 width: u32,
450 height: u32,
451 num_bands: usize,
452 usage: BufferUsages,
453 ) -> GpuResult<Self> {
454 let pixels_per_band = (width as usize)
455 .checked_mul(height as usize)
456 .ok_or_else(|| GpuError::invalid_buffer("Raster size overflow"))?;
457
458 let bands = (0..num_bands)
459 .map(|_| GpuBuffer::new(context, pixels_per_band, usage))
460 .collect::<GpuResult<Vec<_>>>()?;
461
462 debug!(
463 "Created GPU raster buffer: {}x{} with {} bands",
464 width, height, num_bands
465 );
466
467 Ok(Self {
468 bands,
469 width,
470 height,
471 })
472 }
473
474 pub fn from_bands(
480 context: &GpuContext,
481 width: u32,
482 height: u32,
483 bands_data: &[Vec<T>],
484 usage: BufferUsages,
485 ) -> GpuResult<Self> {
486 let expected_size = (width as usize) * (height as usize);
487
488 for (i, band) in bands_data.iter().enumerate() {
489 if band.len() != expected_size {
490 return Err(GpuError::invalid_buffer(format!(
491 "Band {} size mismatch: expected {}, got {}",
492 i,
493 expected_size,
494 band.len()
495 )));
496 }
497 }
498
499 let bands = bands_data
500 .iter()
501 .map(|data| GpuBuffer::from_data(context, data, usage))
502 .collect::<GpuResult<Vec<_>>>()?;
503
504 Ok(Self {
505 bands,
506 width,
507 height,
508 })
509 }
510
511 pub fn band(&self, index: usize) -> Option<&GpuBuffer<T>> {
513 self.bands.get(index)
514 }
515
516 pub fn band_mut(&mut self, index: usize) -> Option<&mut GpuBuffer<T>> {
518 self.bands.get_mut(index)
519 }
520
521 pub fn bands(&self) -> &[GpuBuffer<T>] {
523 &self.bands
524 }
525
526 pub fn num_bands(&self) -> usize {
528 self.bands.len()
529 }
530
531 pub fn dimensions(&self) -> (u32, u32) {
533 (self.width, self.height)
534 }
535
536 pub fn width(&self) -> u32 {
538 self.width
539 }
540
541 pub fn height(&self) -> u32 {
543 self.height
544 }
545
546 pub async fn read_all_bands(&self) -> GpuResult<Vec<Vec<T>>> {
552 let mut results = Vec::with_capacity(self.bands.len());
553
554 for band in &self.bands {
555 results.push(band.read().await?);
556 }
557
558 Ok(results)
559 }
560
561 pub fn read_all_bands_blocking(&self) -> GpuResult<Vec<Vec<T>>> {
567 pollster::block_on(self.read_all_bands())
568 }
569}
570
571impl<T: Pod> std::fmt::Debug for GpuRasterBuffer<T> {
572 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
573 f.debug_struct("GpuRasterBuffer")
574 .field("width", &self.width)
575 .field("height", &self.height)
576 .field("num_bands", &self.num_bands())
577 .field("type", &std::any::type_name::<T>())
578 .finish()
579 }
580}
581
582#[cfg(test)]
583#[allow(clippy::panic)]
584mod tests {
585 use super::*;
586
587 #[tokio::test]
588 async fn test_gpu_buffer_creation() {
589 if let Ok(context) = GpuContext::new().await {
590 let buffer: GpuBuffer<f32> = GpuBuffer::new(&context, 1024, BufferUsages::STORAGE)
591 .unwrap_or_else(|e| {
592 panic!("Failed to create buffer: {}", e);
593 });
594
595 assert_eq!(buffer.len(), 1024);
596 assert!(!buffer.is_empty());
597 }
598 }
599
600 #[tokio::test]
605 async fn test_gpu_buffer_write_read() {
606 if let Ok(context) = GpuContext::new().await {
607 let data: Vec<f32> = (0..100).map(|i| i as f32).collect();
608
609 let buffer = GpuBuffer::from_data(
610 &context,
611 &data,
612 BufferUsages::STORAGE | BufferUsages::COPY_SRC | BufferUsages::COPY_DST,
613 )
614 .unwrap_or_else(|e| {
615 panic!("Failed to create buffer: {}", e);
616 });
617
618 let mut staging = GpuBuffer::staging(&context, 100).unwrap_or_else(|e| {
620 panic!("Failed to create staging buffer: {}", e);
621 });
622
623 staging.copy_from(&buffer).unwrap_or_else(|e| {
624 panic!("Failed to copy buffer: {}", e);
625 });
626
627 let result = staging.read().await.unwrap_or_else(|e| {
628 panic!("Failed to read buffer: {}", e);
629 });
630
631 assert_eq!(result.len(), data.len());
632 for (a, b) in result.iter().zip(data.iter()) {
633 assert!((a - b).abs() < 1e-6);
634 }
635 }
636 }
637
638 #[tokio::test]
639 async fn test_read_truncates_u8_padding() {
640 if let Ok(context) = GpuContext::new().await {
648 let staging: GpuBuffer<u8> = GpuBuffer::staging(&context, 5).unwrap_or_else(|e| {
649 panic!("Failed to create staging buffer: {}", e);
650 });
651 let padded: [u8; 8] = [1, 2, 3, 4, 5, 0xAA, 0xBB, 0xCC];
652 context.queue().write_buffer(&staging.buffer, 0, &padded);
653
654 let result = staging
655 .read()
656 .await
657 .unwrap_or_else(|e| panic!("Failed to read buffer: {}", e));
658
659 assert_eq!(result.len(), 5, "read() must not return padding");
660 assert_eq!(result, vec![1, 2, 3, 4, 5]);
661 }
662 }
663
664 #[tokio::test]
665 async fn test_read_truncates_u16_padding() {
666 if let Ok(context) = GpuContext::new().await {
670 let staging: GpuBuffer<u16> = GpuBuffer::staging(&context, 3).unwrap_or_else(|e| {
671 panic!("Failed to create staging buffer: {}", e);
672 });
673 let padded: [u16; 4] = [100, 200, 300, 0xFFFF];
674 context
675 .queue()
676 .write_buffer(&staging.buffer, 0, bytemuck::cast_slice(&padded));
677
678 let result = staging
679 .read()
680 .await
681 .unwrap_or_else(|e| panic!("Failed to read buffer: {}", e));
682
683 assert_eq!(result.len(), 3, "read() must not return padding");
684 assert_eq!(result, vec![100, 200, 300]);
685 }
686 }
687
688 #[tokio::test]
689 async fn test_gpu_raster_buffer() {
690 if let Ok(context) = GpuContext::new().await {
691 let width = 64;
692 let height = 64;
693 let num_bands = 3;
694
695 let raster: GpuRasterBuffer<f32> =
696 GpuRasterBuffer::new(&context, width, height, num_bands, BufferUsages::STORAGE)
697 .unwrap_or_else(|e| {
698 panic!("Failed to create raster buffer: {}", e);
699 });
700
701 assert_eq!(raster.width(), width);
702 assert_eq!(raster.height(), height);
703 assert_eq!(raster.num_bands(), num_bands);
704 }
705 }
706}