feat: add transmute for views

src/driver/safe/core.rs

@@ -29,9 +29,9 @@
 /// # Safety
 /// 1. impl [Drop] to call all the corresponding resource cleanup methods
 /// 2. Doesn't impl clone, so you can't have multiple device pointers
 /// hanging around.
 /// 3. Any allocations enforce that self is an [Arc], meaning no allocation
 /// can outlive the [CudaDevice]
 #[derive(Debug)]
 pub struct CudaDevice {
     pub(crate) cu_device: sys::CUdevice,
@@ -703,6 +703,21 @@
             marker: PhantomData,
         })
     }
+
+    /// Reinterprets the slice of memory into a different type. `len` is the number
+    /// of elements of the new type `S` that are expected. If not enough bytes
+    /// are allocated in `self` for the view, then this returns `None`.
+    ///
+    /// # Safety
+    /// This is unsafe because not the memory for the view may not be a valid interpretation
+    /// for the type `S`.
+    pub unsafe fn transmute<S>(&self, len: usize) -> Option<CudaView<'_, S>> {
+        (len * std::mem::size_of::<S>() <= self.num_bytes()).then_some(CudaView {
+            ptr: self.ptr,
+            len,
+            marker: PhantomData,
+        })
+    }
 }
 
 /// A mutable sub-view into a [CudaSlice] created by [CudaSlice::try_slice_mut()] or [CudaSlice::slice_mut()].
@@ -871,6 +886,21 @@
         })
     }
 
+    /// Reinterprets the slice of memory into a different type. `len` is the number
+    /// of elements of the new type `S` that are expected. If not enough bytes
+    /// are allocated in `self` for the view, then this returns `None`.
+    ///
+    /// # Safety
+    /// This is unsafe because not the memory for the view may not be a valid interpretation
+    /// for the type `S`.
+    pub unsafe fn transmute<S>(&self, len: usize) -> Option<CudaView<'_, S>> {
+        (len * std::mem::size_of::<S>() <= self.num_bytes()).then_some(CudaView {
+            ptr: self.ptr,
+            len,
+            marker: PhantomData,
+        })
+    }
+
     /// Creates a [CudaViewMut] at the specified offset from the start of `self`.
     ///
     /// Panics if `range` and `0...self.len()` are not overlapping.
@@ -934,6 +964,21 @@
             },
         ))
     }
+
+    /// Reinterprets the slice of memory into a different type. `len` is the number
+    /// of elements of the new type `S` that are expected. If not enough bytes
+    /// are allocated in `self` for the view, then this returns `None`.
+    ///
+    /// # Safety
+    /// This is unsafe because not the memory for the view may not be a valid interpretation
+    /// for the type `S`.
+    pub unsafe fn transmute_mut<S>(&mut self, len: usize) -> Option<CudaViewMut<'_, S>> {
+        (len * std::mem::size_of::<S>() <= self.num_bytes()).then_some(CudaViewMut {
+            ptr: self.ptr,
+            len,
+            marker: PhantomData,
+        })
+    }
 }
 
 trait RangeHelper: RangeBounds<usize> {
@@ -993,5 +1038,19 @@
         assert!(unsafe { slice.transmute::<f32>(26) }.is_none());
         assert!(unsafe { slice.transmute_mut::<f32>(25) }.is_some());
         assert!(unsafe { slice.transmute_mut::<f32>(26) }.is_none());
+
+        {
+            let view = slice.slice(0..100);
+            assert!(unsafe { view.transmute::<f32>(25) }.is_some());
+            assert!(unsafe { view.transmute::<f32>(26) }.is_none());
+        }
+
+        {
+            let mut view_mut = slice.slice_mut(0..100);
+            assert!(unsafe { view_mut.transmute::<f32>(25) }.is_some());
+            assert!(unsafe { view_mut.transmute::<f32>(26) }.is_none());
+            assert!(unsafe { view_mut.transmute_mut::<f32>(25) }.is_some());
+            assert!(unsafe { view_mut.transmute_mut::<f32>(26) }.is_none());
+        }
     }
 }