Add CUDA Event

Author: LutzCle

src/event.rs

@@ -0,0 +1,85 @@
+use crate::cuda_sys::cuda::{
+    cuEventCreate, cuEventDestroy_v2, cuEventElapsedTime, cuEventQuery, cuEventRecord,
+    cuEventSynchronize, CUevent,
+};
+use crate::error::{CudaResult, DropResult, ToResult};
+use crate::stream::Stream;
+
+use std::mem;
+use std::ptr;
+
+bitflags! {
+    pub struct EventFlags: u32 {
+        const DEFAULT = 0x0;
+        const BLOCKING_SYNC = 0x1;
+        const DISABLE_TIMING = 0x2;
+        const INTERPROCESS = 0x4;
+    }
+}
+
+#[derive(Debug)]
+pub struct Event(CUevent);
+
+impl Event {
+    pub fn new(flags: EventFlags) -> CudaResult<Self> {
+        unsafe {
+            let mut event: CUevent = mem::zeroed();
+            cuEventCreate(&mut event, flags.bits()).to_result()?;
+            Ok(Event(event))
+        }
+    }
+
+    pub fn record(&self, stream: Stream) -> CudaResult<&Self> {
+        unsafe {
+            cuEventRecord(self.0, stream.get_inner()).to_result()?;
+            Ok(self)
+        }
+    }
+
+    pub fn query(&self) -> CudaResult<&Self> {
+        unsafe {
+            cuEventQuery(self.0).to_result()?;
+            Ok(self)
+        }
+    }
+
+    pub fn synchronize(&self) -> CudaResult<&Self> {
+        unsafe {
+            cuEventSynchronize(self.0).to_result()?;
+            Ok(self)
+        }
+    }
+
+    pub fn elapsed_time(&self, start: &Self) -> CudaResult<f32> {
+        unsafe {
+            let mut millis: f32 = 0.0;
+            cuEventElapsedTime(&mut millis, start.0, self.0).to_result()?;
+            Ok(millis)
+        }
+    }
+
+    pub fn drop(mut event: Event) -> DropResult<Event> {
+        if event.0.is_null() {
+            return Ok(());
+        }
+
+        unsafe {
+            let inner = mem::replace(&mut event.0, ptr::null_mut());
+            match cuEventDestroy_v2(inner).to_result() {
+                Ok(()) => {
+                    mem::forget(event);
+                    Ok(())
+                }
+                Err(e) => Err((e, Event(inner))),
+            }
+        }
+    }
+}
+
+impl Drop for Event {
+    fn drop(&mut self) {
+        unsafe { cuEventDestroy_v2(self.0) }
+            .to_result()
+            .expect("Failed to destroy CUDA event");
+    }
+}

src/lib.rs

@@ -164,6 +164,7 @@ pub use rustacuda_derive::*;
 pub mod context;
 pub mod device;
 pub mod error;
+pub mod event;
 pub mod function;
 pub mod memory;
 pub mod module;

src/stream.rs

@@ -244,6 +244,10 @@ impl Stream {
         .to_result()
     }
 
+    pub(crate) fn get_inner(&self) -> CUstream {
+        self.inner
+    }
+
     /// Destroy a `Stream`, returning an error.
     ///
     /// Destroying a stream can return errors from previous asynchronous work. This function