expose free/release/destroy functions

src/ffi/memory/device.rs

@@ -167,15 +167,18 @@ impl<T: Copy> DeviceBuffer<T> {
         &self.internal
     }
 
-    /// Get readonly reference to internal [`DevicePtr`].
+    /// Get mutable reference to internal [`DevicePtr`].
     #[inline(always)]
     pub fn as_mut_internal(&mut self) -> &mut DevicePtr {
         &mut self.internal
     }
-}
 
-impl<T: Copy> Drop for DeviceBuffer<T> {
-    fn drop(&mut self) {
+    /// Release the buffer memory.
+    ///
+    /// # Safety
+    ///
+    /// The buffer may not be used after this function is called, except for being dropped.
+    pub unsafe fn free(&mut self) {
         if self.internal.is_null() {
             return;
         }
@@ -191,6 +194,16 @@ impl<T: Copy> Drop for DeviceBuffer<T> {
     }
 }
 
+impl<T: Copy> Drop for DeviceBuffer<T> {
+    #[inline]
+    fn drop(&mut self) {
+        // SAFETY: This is safe since the buffer cannot be used after this.
+        unsafe {
+            self.free();
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/ffi/memory/device2d.rs

@@ -192,15 +192,18 @@ impl<T: Copy> DeviceBuffer2D<T> {
         &self.internal
     }
 
-    /// Get readonly reference to internal [`DevicePtr`].
+    /// Get mutable reference to internal [`DevicePtr`].
     #[inline(always)]
     pub fn as_mut_internal(&mut self) -> &mut DevicePtr {
         &mut self.internal
     }
-}
 
-impl<T: Copy> Drop for DeviceBuffer2D<T> {
-    fn drop(&mut self) {
+    /// Release the buffer memory.
+    ///
+    /// # Safety
+    ///
+    /// The buffer may not be used after this function is called, except for being dropped.
+    pub unsafe fn free(&mut self) {
         if self.internal.is_null() {
             return;
         }
@@ -216,6 +219,16 @@ impl<T: Copy> Drop for DeviceBuffer2D<T> {
     }
 }
 
+impl<T: Copy> Drop for DeviceBuffer2D<T> {
+    #[inline]
+    fn drop(&mut self) {
+        // SAFETY: This is safe since the buffer cannot be used after this.
+        unsafe {
+            self.free();
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/ffi/memory/host.rs

@@ -145,15 +145,18 @@ impl<T: Copy> HostBuffer<T> {
         &self.internal
     }
 
-    /// Get readonly reference to internal [`DevicePtr`].
+    /// Get mutable reference to internal [`DevicePtr`].
     #[inline(always)]
     pub fn as_mut_internal(&mut self) -> &mut DevicePtr {
         &mut self.internal
     }
-}
 
-impl<T: Copy> Drop for HostBuffer<T> {
-    fn drop(&mut self) {
+    /// Release the buffer memory.
+    ///
+    /// # Safety
+    ///
+    /// The buffer may not be used after this function is called, except for being dropped.
+    pub unsafe fn free(&mut self) {
         if self.internal.is_null() {
             return;
         }
@@ -169,6 +172,16 @@ impl<T: Copy> Drop for HostBuffer<T> {
     }
 }
 
+impl<T: Copy> Drop for HostBuffer<T> {
+    #[inline]
+    fn drop(&mut self) {
+        // SAFETY: This is safe since the buffer cannot be used after this.
+        unsafe {
+            self.free();
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/ffi/ptr.rs

@@ -74,7 +74,6 @@ impl DevicePtr {
     /// }
     ///
     /// impl Drop for Object {
-    ///
     ///     fn drop(&mut self) {
     ///         // SAFETY: This is safe because `self` and `self.internal`
     ///         // are not used beyond this unsafe block.
@@ -84,7 +83,6 @@ impl DevicePtr {
     ///         // Propertly deallocate the pointer here and do *NOT* use
     ///         // use `self` for anything!
     ///     }
-    ///
     /// }
     /// ```
     #[inline]

src/ffi/stream.rs

@@ -91,15 +91,18 @@ impl Stream {
         &self.internal
     }
 
-    /// Get readonly reference to internal [`DevicePtr`].
+    /// Get mutable reference to internal [`DevicePtr`].
     #[inline(always)]
     pub fn as_mut_internal(&mut self) -> &mut DevicePtr {
         &mut self.internal
     }
-}
 
-impl Drop for Stream {
-    fn drop(&mut self) {
+    /// Destroy stream.
+    ///
+    /// # Safety
+    ///
+    /// The object may not be used after this function is called, except for being dropped.
+    pub unsafe fn destroy(&mut self) {
         if self.internal.is_null() {
             return;
         }
@@ -125,6 +128,16 @@ impl Drop for Stream {
     }
 }
 
+impl Drop for Stream {
+    #[inline]
+    fn drop(&mut self) {
+        // SAFETY: This is safe since the object cannot be used after this.
+        unsafe {
+            self.destroy();
+        }
+    }
+}
+
 cpp! {{
     /// Holds the C++ code that makes up the native part required to get our CUDA callback to work
     /// over the FFI.

src/npp/ffi/context.rs

@@ -107,17 +107,36 @@ impl Context {
     pub(crate) fn as_ptr(&self) -> *const std::ffi::c_void {
         self.raw
     }
-}
 
-impl Drop for Context {
-    fn drop(&mut self) {
+    /// Delete the context.
+    ///
+    /// # Safety
+    ///
+    /// The context may not be used after this function is called, except for being dropped.
+    pub unsafe fn delete(&mut self) {
+        if self.raw.is_null() {
+            return;
+        }
+
         let raw = self.raw;
+        self.raw = std::ptr::null_mut();
+
         cpp!(unsafe [raw as "void*"] {
             delete ((NppStreamContext*) raw);
         });
     }
 }
 
+impl Drop for Context {
+    #[inline]
+    fn drop(&mut self) {
+        // SAFETY: This is safe since the buffer cannot be used after this.
+        unsafe {
+            self.delete();
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;