Feat: remove the need for &mut self in GpuBox and GpuBuffer

Author: RDambrosio016

crates/cust/CHANGELOG.md

@@ -8,3 +8,5 @@ Notable changes to this project will be documented in this file.
 at some point, but now we reconsidered that it may be the wrong choice.
 - Renamed `DBox` -> `DeviceBox`.
 - Fixed some doctests that were using old APIs.
+- Remove `GpuBox::as_device_ptr_mut` and `GpuBuffer::as_device_ptr_mut`.
+- Change `GpuBox::as_device_ptr` and `GpuBuffer::as_device_ptr` to take `&self` instead of `&mut self`.

crates/cust/src/memory/mod.rs

@@ -94,20 +94,13 @@ use core::num::*;
 /// A trait describing a generic buffer that can be accessed from the GPU. This could be either a [`UnifiedBuffer`]
 /// or a regular [`DeviceBuffer`].
 pub trait GpuBuffer<T: DeviceCopy>: private::Sealed {
-    /// Obtains a device pointer to this buffer, not requiring `&mut self`. This means
-    /// the buffer must be used only for immutable reads, and must not be written to.
-    unsafe fn as_device_ptr(&self) -> DevicePointer<T>;
-    fn as_device_ptr_mut(&mut self) -> DevicePointer<T>;
+    fn as_device_ptr(&self) -> DevicePointer<T>;
     fn len(&self) -> usize;
 }
 
 impl<T: DeviceCopy> GpuBuffer<T> for DeviceBuffer<T> {
-    unsafe fn as_device_ptr(&self) -> DevicePointer<T> {
-        DevicePointer::wrap((**self).as_ptr() as *mut _)
-    }
-
-    fn as_device_ptr_mut(&mut self) -> DevicePointer<T> {
-        (**self).as_device_ptr()
+    fn as_device_ptr(&self) -> DevicePointer<T> {
+        unsafe { DevicePointer::wrap((**self).as_ptr() as *mut _) }
     }
 
     fn len(&self) -> usize {
@@ -116,12 +109,7 @@ impl<T: DeviceCopy> GpuBuffer<T> for DeviceBuffer<T> {
 }
 
 impl<T: DeviceCopy> GpuBuffer<T> for UnifiedBuffer<T> {
-    unsafe fn as_device_ptr(&self) -> DevicePointer<T> {
-        DevicePointer::wrap(self.as_ptr() as *mut _)
-    }
-
-    fn as_device_ptr_mut(&mut self) -> DevicePointer<T> {
-        // SAFETY: unified pointers can be dereferenced from the gpu.
+    fn as_device_ptr(&self) -> DevicePointer<T> {
         unsafe { DevicePointer::wrap(self.as_ptr() as *mut _) }
     }
 
@@ -133,29 +121,17 @@ impl<T: DeviceCopy> GpuBuffer<T> for UnifiedBuffer<T> {
 /// A trait describing a generic pointer that can be accessed from the GPU. This could be either a [`UnifiedBox`]
 /// or a regular [`DeviceBox`].
 pub trait GpuBox<T: DeviceCopy>: private::Sealed {
-    /// Obtains a device pointer to this value, not requiring `&mut self`. This means
-    /// the value must be used only for immutable reads, and must not be written to.
-    unsafe fn as_device_ptr(&self) -> DevicePointer<T>;
-    fn as_device_ptr_mut(&mut self) -> DevicePointer<T>;
+    fn as_device_ptr(&self) -> DevicePointer<T>;
 }
 
 impl<T: DeviceCopy> GpuBox<T> for DeviceBox<T> {
-    unsafe fn as_device_ptr(&self) -> DevicePointer<T> {
+    fn as_device_ptr(&self) -> DevicePointer<T> {
         self.ptr
     }
-
-    fn as_device_ptr_mut(&mut self) -> DevicePointer<T> {
-        DeviceBox::as_device_ptr(self)
-    }
 }
 
 impl<T: DeviceCopy> GpuBox<T> for UnifiedBox<T> {
-    unsafe fn as_device_ptr(&self) -> DevicePointer<T> {
-        DevicePointer::wrap(self.ptr.as_raw() as *mut _)
-    }
-
-    fn as_device_ptr_mut(&mut self) -> DevicePointer<T> {
-        // SAFETY: unified pointers can be dereferenced from the gpu.
+    fn as_device_ptr(&self) -> DevicePointer<T> {
         unsafe { DevicePointer::wrap(self.ptr.as_raw() as *mut _) }
     }
 }

crates/optix/src/denoiser.rs

@@ -374,7 +374,7 @@ impl Denoiser {
         let raw_params = parameters.to_raw();
 
         let mut out = input_image.to_raw();
-        out.data = out_buffer.as_device_ptr_mut().as_raw_mut() as u64;
+        out.data = out_buffer.as_device_ptr().as_raw_mut() as u64;
 
         let layer = sys::OptixDenoiserLayer {
             input: input_image.to_raw(),
@@ -427,11 +427,11 @@ impl DenoiserParams<'_> {
             denoiseAlpha: self.denoise_alpha as u32,
             hdrIntensity: self
                 .hdr_intensity
-                .map(|x| unsafe { x.as_device_ptr().as_raw() as u64 })
+                .map(|x| x.as_device_ptr().as_raw() as u64)
                 .unwrap_or_default(),
             hdrAverageColor: self
                 .hdr_average_color
-                .map(|x| unsafe { x.as_device_ptr().as_raw() as u64 })
+                .map(|x| x.as_device_ptr().as_raw() as u64)
                 .unwrap_or_default(),
             blendFactor: self.blend_factor,
         }

examples/cuda/cpu/path_tracer/src/cuda/data.rs

@@ -1,7 +1,7 @@
 use crate::common::Camera;
 use cust::{
     error::CudaResult,
-    memory::{DBuffer, DeviceCopy, UnifiedBuffer},
+    memory::{DeviceBuffer, DeviceCopy, UnifiedBuffer},
     util::SliceExt,
     vek::{num_traits::Zero, Vec2, Vec3},
 };
@@ -15,13 +15,13 @@ use super::SEED;
 /// You could put these in the CUDA renderer but we separate them out for code readability.
 pub struct CudaRendererBuffers {
     /// The buffer of accumulated colors, every sample/render call adds its color to this buffer.
-    pub accumulated_buffer: DBuffer<Vec3<f32>>,
+    pub accumulated_buffer: DeviceBuffer<Vec3<f32>>,
     /// The scaled buffer of colors, this is just the accumulated colors divided by sample count.
-    pub scaled_buffer: DBuffer<Vec3<f32>>,
+    pub scaled_buffer: DeviceBuffer<Vec3<f32>>,
     /// The final image buffer after denoising and postprocessing.
-    pub out_buffer: DBuffer<Vec3<u8>>,
+    pub out_buffer: DeviceBuffer<Vec3<u8>>,
     /// The scaled buffer but denoised. In the future we will use the same buffer for this.
-    pub denoised_buffer: DBuffer<Vec3<f32>>,
+    pub denoised_buffer: DeviceBuffer<Vec3<f32>>,
 
     /// The viewport used by the render kernel to emit rays.
     pub viewport: Viewport,
@@ -75,7 +75,7 @@ impl CudaRendererBuffers {
     /// Reset the renderer's view, in the buffer's case this means clearing accumulated buffers from previous samples.
     /// As well as changing the viewport.
     pub fn update_camera(&mut self, new_camera: &Camera) -> CudaResult<()> {
-        self.accumulated_buffer = unsafe { DBuffer::zeroed(self.accumulated_buffer.len())? };
+        self.accumulated_buffer = unsafe { DeviceBuffer::zeroed(self.accumulated_buffer.len())? };
         new_camera.as_viewport(&mut self.viewport);
         Ok(())
     }
@@ -104,7 +104,9 @@ impl CudaRendererBuffers {
     }
 
     // could also use the convenience method on optix::denoiser::Image for this
-    fn image_buffer<T: DeviceCopy + Zero>(dimensions: Vec2<usize>) -> CudaResult<DBuffer<Vec3<T>>> {
-        unsafe { DBuffer::zeroed(dimensions.product()) }
+    fn image_buffer<T: DeviceCopy + Zero>(
+        dimensions: Vec2<usize>,
+    ) -> CudaResult<DeviceBuffer<Vec3<T>>> {
+        unsafe { DeviceBuffer::zeroed(dimensions.product()) }
     }
 }

examples/optix/denoiser/src/main.rs

@@ -1,4 +1,4 @@
-use cust::memory::DBuffer;
+use cust::memory::DeviceBuffer;
 use cust::prelude::{Stream, StreamFlags};
 use cust::util::SliceExt;
 use cust::vek::{Clamp, Vec3};
@@ -63,7 +63,7 @@ fn main() -> Result<(), Box<dyn Error>> {
 
     // Currently zeroed is unsafe, but in the future we will probably expose a safe way to do it
     // using bytemuck
-    let mut out_buf = unsafe { DBuffer::<Vec3<f32>>::zeroed((width * height) as usize)? };
+    let mut out_buf = unsafe { DeviceBuffer::<Vec3<f32>>::zeroed((width * height) as usize)? };
 
     // make an image to tell OptiX about how our image buffer is represented
     let input_image = Image::new(&in_buf, ImageFormat::Float3, width, height);