cythonize event

Author: leofang

cuda_core/cuda/core/experimental/_event.pyx

@@ -4,6 +4,11 @@
 
 from __future__ import annotations
 
+from libc.stdint cimport uintptr_t
+
+# TODO: how about cuda.bindings < 12.6.2?
+from cuda.bindings cimport cydriver
+
 from cuda.core.experimental._utils.cuda_utils cimport (
     _check_driver_error as raise_if_driver_error,
     check_or_create_options,
@@ -78,43 +83,46 @@ cdef class Event:
 
     """
     cdef:
-        object _handle
+        cydriver.CUevent _handle
         bint _timing_disabled
         bint _busy_waited
         int _device_id
         object _ctx_handle
 
+    def __cinit__(self):
+        self._handle = <cydriver.CUevent>(NULL)
+
     def __init__(self, *args, **kwargs):
         raise RuntimeError("Event objects cannot be instantiated directly. Please use Stream APIs (record).")
 
     @classmethod
     def _init(cls, device_id: int, ctx_handle: Context, options=None):
         cdef Event self = Event.__new__(cls)
         cdef EventOptions opts = check_or_create_options(EventOptions, options, "Event options")
-        flags = 0x0
+        cdef unsigned int flags = 0x0
         self._timing_disabled = False
         self._busy_waited = False
         if not opts.enable_timing:
-            flags |= driver.CUevent_flags.CU_EVENT_DISABLE_TIMING
+            flags |= cydriver.CUevent_flags.CU_EVENT_DISABLE_TIMING
             self._timing_disabled = True
         if opts.busy_waited_sync:
-            flags |= driver.CUevent_flags.CU_EVENT_BLOCKING_SYNC
+            flags |= cydriver.CUevent_flags.CU_EVENT_BLOCKING_SYNC
             self._busy_waited = True
         if opts.support_ipc:
             raise NotImplementedError("WIP: https://github.com/NVIDIA/cuda-python/issues/103")
-        err, self._handle = driver.cuEventCreate(flags)
-        raise_if_driver_error(err)
+        # TODO: use HANDLE_RETURN
+        err = cydriver.cuEventCreate(&self._handle, flags)
         self._device_id = device_id
         self._ctx_handle = ctx_handle
         return self
 
     cdef _shutdown_safe_close(self, is_shutting_down=sys.is_finalizing):
         if is_shutting_down and is_shutting_down():
             return
-        if self._handle is not None:
-            err, = driver.cuEventDestroy(self._handle)
-            self._handle = None
-            raise_if_driver_error(err)
+        if self._handle != NULL:
+            # TODO: use HANDLE_RETURN
+            err = cydriver.cuEventDestroy(self._handle)
+            self._handle = <cydriver.CUevent>(NULL)
 
     cpdef close(self):
         """Destroy the event."""
@@ -129,14 +137,14 @@ cdef class Event:
     def __rsub__(self, other):
         return NotImplemented
 
-    def __sub__(self, other):
+    def __sub__(self, other: Event):
         # return self - other (in milliseconds)
-        err, timing = driver.cuEventElapsedTime(other.handle, self._handle)
-        try:
-            raise_if_driver_error(err)
+        cdef float timing
+        err = cydriver.cuEventElapsedTime(&timing, other._handle, self._handle)
+        if err == 0:
             return timing
-        except CUDAError as e:
-            if err == driver.CUresult.CUDA_ERROR_INVALID_HANDLE:
+        else:
+            if err == cydriver.CUresult.CUDA_ERROR_INVALID_HANDLE:
                 if self.is_timing_disabled or other.is_timing_disabled:
                     explanation = (
                         "Both Events must be created with timing enabled in order to subtract them; "
@@ -147,15 +155,15 @@ cdef class Event:
                         "Both Events must be recorded before they can be subtracted; "
                         "use Stream.record() to record both events to a stream."
                     )
-            elif err == driver.CUresult.CUDA_ERROR_NOT_READY:
+            elif err == cydriver.CUresult.CUDA_ERROR_NOT_READY:
                 explanation = (
                     "One or both events have not completed; "
                     "use Event.sync(), Stream.sync(), or Device.sync() to wait for the events to complete "
                     "before subtracting them."
                 )
             else:
-                raise e
-            raise RuntimeError(explanation) from e
+                raise CUDAError(err)
+            raise RuntimeError(explanation)
 
     @property
     def is_timing_disabled(self) -> bool:
@@ -182,17 +190,18 @@ cdef class Event:
         has been completed.
 
         """
-        handle_return(driver.cuEventSynchronize(self._handle))
+        # TODO: use HANDLE_RETURN
+        err = cydriver.cuEventSynchronize(self._handle)
 
     @property
     def is_done(self) -> bool:
         """Return True if all captured works have been completed, otherwise False."""
-        result, = driver.cuEventQuery(self._handle)
-        if result == driver.CUresult.CUDA_SUCCESS:
+        result = cydriver.cuEventQuery(self._handle)
+        if result == cydriver.CUresult.CUDA_SUCCESS:
             return True
-        if result == driver.CUresult.CUDA_ERROR_NOT_READY:
+        if result == cydriver.CUresult.CUDA_ERROR_NOT_READY:
             return False
-        handle_return(result)
+        # TODO: use HANDLE_RETURN
 
     @property
     def handle(self) -> cuda.bindings.driver.CUevent:
@@ -203,7 +212,7 @@ cdef class Event:
             This handle is a Python object. To get the memory address of the underlying C
             handle, call ``int(Event.handle)``.
         """
-        return self._handle
+        return driver.CUevent(<uintptr_t>(self._handle))
 
     @property
     def device(self) -> Device:

cuda_core/cuda/core/experimental/_stream.pyx

@@ -122,7 +122,7 @@ cdef class Stream:
         object _device_id
         object _ctx_handle
 
-    def __cinit__(self, *args, **kwargs):
+    def __cinit__(self):
         self._handle = <cydriver.CUstream>(NULL)
 
     def __init__(self, *args, **kwargs):
@@ -235,7 +235,7 @@ cdef class Stream:
             This handle is a Python object. To get the memory address of the underlying C
             handle, call ``int(Stream.handle)``.
         """
-        return driver.CUstream(<uintptr_t><void*>(self._handle))
+        return driver.CUstream(<uintptr_t>(self._handle))
 
     @property
     def is_nonblocking(self) -> bool: