cuda.core: rename Event.uses_blocking_sync to is_blocking_sync (#1945)

Adopt the is_-prefix convention used everywhere else (is_ipc_enabled,
is_timing_enabled, is_nonblocking) and eliminate the lone uses_- form.
Keep the _sync suffix so the name disambiguates from Stream's separate
"blocking" concept and stays close to the underlying CU_EVENT_BLOCKING_SYNC
driver flag.

EventOptions.blocking_sync is unchanged.

Made-with: Cursor

Author: Andy-Jost

cuda_core/cuda/core/_cpp/resource_handles.cpp

@@ -354,7 +354,7 @@ namespace {
 struct EventBox {
     CUevent resource;
     bool timing_enabled;
-    bool uses_blocking_sync;
+    bool is_blocking_sync;
     bool ipc_enabled;
     int device_id;
     ContextHandle h_context;
@@ -372,8 +372,8 @@ bool get_event_timing_enabled(const EventHandle& h) noexcept {
     return h ? get_box(h)->timing_enabled : false;
 }
 
-bool get_event_uses_blocking_sync(const EventHandle& h) noexcept {
-    return h ? get_box(h)->uses_blocking_sync : false;
+bool get_event_is_blocking_sync(const EventHandle& h) noexcept {
+    return h ? get_box(h)->is_blocking_sync : false;
 }
 
 bool get_event_ipc_enabled(const EventHandle& h) noexcept {
@@ -392,7 +392,7 @@ ContextHandle get_event_context(const EventHandle& h) noexcept {
 static HandleRegistry<CUevent, EventHandle> event_registry;
 
 EventHandle create_event_handle(const ContextHandle& h_ctx, unsigned int flags,
-                                bool timing_enabled, bool uses_blocking_sync,
+                                bool timing_enabled, bool is_blocking_sync,
                                 bool ipc_enabled, int device_id) {
     GILReleaseGuard gil;
     CUevent event;
@@ -401,7 +401,7 @@ EventHandle create_event_handle(const ContextHandle& h_ctx, unsigned int flags,
     }
 
     auto box = std::shared_ptr<const EventBox>(
-        new EventBox{event, timing_enabled, uses_blocking_sync, ipc_enabled, device_id, h_ctx},
+        new EventBox{event, timing_enabled, is_blocking_sync, ipc_enabled, device_id, h_ctx},
         [h_ctx](const EventBox* b) {
             event_registry.unregister_handle(b->resource);
             GILReleaseGuard gil;
@@ -427,15 +427,15 @@ EventHandle create_event_handle_ref(CUevent event) {
 }
 
 EventHandle create_event_handle_ipc(const CUipcEventHandle& ipc_handle,
-                                    bool uses_blocking_sync) {
+                                    bool is_blocking_sync) {
     GILReleaseGuard gil;
     CUevent event;
     if (CUDA_SUCCESS != (err = p_cuIpcOpenEventHandle(&event, ipc_handle))) {
         return {};
     }
 
     auto box = std::shared_ptr<const EventBox>(
-        new EventBox{event, false, uses_blocking_sync, true, -1, {}},
+        new EventBox{event, false, is_blocking_sync, true, -1, {}},
         [](const EventBox* b) {
             event_registry.unregister_handle(b->resource);
             GILReleaseGuard gil;

cuda_core/cuda/core/_cpp/resource_handles.hpp

@@ -211,7 +211,7 @@ StreamHandle get_per_thread_stream();
 // When the last reference is released, cuEventDestroy is called automatically.
 // Returns empty handle on error (caller must check).
 EventHandle create_event_handle(const ContextHandle& h_ctx, unsigned int flags,
-                                bool timing_enabled, bool uses_blocking_sync,
+                                bool timing_enabled, bool is_blocking_sync,
                                 bool ipc_enabled, int device_id);
 
 // Create an owning event handle without context dependency.
@@ -225,7 +225,7 @@ EventHandle create_event_handle_noctx(unsigned int flags);
 // When the last reference is released, cuEventDestroy is called automatically.
 // Returns empty handle on error (caller must check).
 EventHandle create_event_handle_ipc(const CUipcEventHandle& ipc_handle,
-                                    bool uses_blocking_sync);
+                                    bool is_blocking_sync);
 
 // Create a non-owning event handle (references existing event).
 // Use for events that are managed by the CUDA graph or another owner.
@@ -235,7 +235,7 @@ EventHandle create_event_handle_ref(CUevent event);
 
 // Event metadata accessors (read from EventBox via pointer arithmetic)
 bool get_event_timing_enabled(const EventHandle& h) noexcept;
-bool get_event_uses_blocking_sync(const EventHandle& h) noexcept;
+bool get_event_is_blocking_sync(const EventHandle& h) noexcept;
 bool get_event_ipc_enabled(const EventHandle& h) noexcept;
 int get_event_device_id(const EventHandle& h) noexcept;
 ContextHandle get_event_context(const EventHandle& h) noexcept;

cuda_core/cuda/core/_event.pyx

@@ -14,7 +14,7 @@ from cuda.core._resource_handles cimport (
     create_event_handle,
     create_event_handle_ipc,
     get_event_timing_enabled,
-    get_event_uses_blocking_sync,
+    get_event_is_blocking_sync,
     get_event_ipc_enabled,
     get_event_device_id,
     get_event_context,
@@ -101,15 +101,15 @@ cdef class Event:
         cdef EventOptions opts = check_or_create_options(EventOptions, options, "Event options")
         cdef unsigned int flags = 0x0
         cdef bint timing_enabled = True
-        cdef bint uses_blocking_sync = False
+        cdef bint is_blocking_sync = False
         cdef bint ipc_enabled = False
         self._ipc_descriptor = None
         if not opts.timing_enabled:
             flags |= cydriver.CUevent_flags.CU_EVENT_DISABLE_TIMING
             timing_enabled = False
         if opts.blocking_sync:
             flags |= cydriver.CUevent_flags.CU_EVENT_BLOCKING_SYNC
-            uses_blocking_sync = True
+            is_blocking_sync = True
         if opts.ipc_enabled:
             if is_free:
                 raise TypeError(
@@ -120,7 +120,7 @@ cdef class Event:
             if timing_enabled:
                 raise TypeError("IPC-enabled events cannot use timing.")
         cdef EventHandle h_event = create_event_handle(
-            h_context, flags, timing_enabled, uses_blocking_sync, ipc_enabled, device_id)
+            h_context, flags, timing_enabled, is_blocking_sync, ipc_enabled, device_id)
         if not h_event:
             raise RuntimeError("Failed to create CUDA event")
         self._h_event = h_event
@@ -208,7 +208,7 @@ cdef class Event:
         with nogil:
             HANDLE_RETURN(cydriver.cuIpcGetEventHandle(&data, as_cu(self._h_event)))
         cdef bytes data_b = cpython.PyBytes_FromStringAndSize(<char*>(data.reserved), sizeof(data.reserved))
-        self._ipc_descriptor = IPCEventDescriptor._init(data_b, get_event_uses_blocking_sync(self._h_event))
+        self._ipc_descriptor = IPCEventDescriptor._init(data_b, get_event_is_blocking_sync(self._h_event))
         return self._ipc_descriptor
 
     @classmethod
@@ -217,7 +217,7 @@ cdef class Event:
         cdef cydriver.CUipcEventHandle data
         memcpy(data.reserved, <const void*><const char*>(ipc_descriptor._reserved), sizeof(data.reserved))
         cdef Event self = Event.__new__(cls)
-        cdef EventHandle h_event = create_event_handle_ipc(data, ipc_descriptor._uses_blocking_sync)
+        cdef EventHandle h_event = create_event_handle_ipc(data, ipc_descriptor._is_blocking_sync)
         if not h_event:
             raise RuntimeError("Failed to open IPC event handle")
         self._h_event = h_event
@@ -235,11 +235,11 @@ cdef class Event:
         return get_event_timing_enabled(self._h_event)
 
     @property
-    def uses_blocking_sync(self) -> bool:
+    def is_blocking_sync(self) -> bool:
         """Return True if the event uses blocking synchronization (the CPU
         thread blocks on :meth:`sync` instead of busy-waiting), otherwise False.
         """
-        return get_event_uses_blocking_sync(self._h_event)
+        return get_event_is_blocking_sync(self._h_event)
 
     def sync(self):
         """Synchronize until the event completes.
@@ -305,24 +305,24 @@ cdef class IPCEventDescriptor:
 
     cdef:
         bytes _reserved
-        bint _uses_blocking_sync
+        bint _is_blocking_sync
 
     def __init__(self, *arg, **kwargs):
         raise RuntimeError("IPCEventDescriptor objects cannot be instantiated directly. Please use Event APIs.")
 
     @staticmethod
-    def _init(reserved: bytes, uses_blocking_sync: cython.bint):
+    def _init(reserved: bytes, is_blocking_sync: cython.bint):
         cdef IPCEventDescriptor self = IPCEventDescriptor.__new__(IPCEventDescriptor)
         self._reserved = reserved
-        self._uses_blocking_sync = uses_blocking_sync
+        self._is_blocking_sync = is_blocking_sync
         return self
 
     def __eq__(self, IPCEventDescriptor rhs):
-        # No need to check self._uses_blocking_sync.
+        # No need to check self._is_blocking_sync.
         return self._reserved == rhs._reserved
 
     def __reduce__(self):
-        return IPCEventDescriptor._init, (self._reserved, self._uses_blocking_sync)
+        return IPCEventDescriptor._init, (self._reserved, self._is_blocking_sync)
 
 
 def _reduce_event(event):

cuda_core/cuda/core/_resource_handles.pxd

@@ -121,16 +121,16 @@ cdef StreamHandle get_per_thread_stream() except+ nogil
 # Event handles
 cdef EventHandle create_event_handle(
     const ContextHandle& h_ctx, unsigned int flags,
-    bint timing_enabled, bint uses_blocking_sync,
+    bint timing_enabled, bint is_blocking_sync,
     bint ipc_enabled, int device_id) except+ nogil
 cdef EventHandle create_event_handle_noctx(unsigned int flags) except+ nogil
 cdef EventHandle create_event_handle_ref(cydriver.CUevent event) except+ nogil
 cdef EventHandle create_event_handle_ipc(
-    const cydriver.CUipcEventHandle& ipc_handle, bint uses_blocking_sync) except+ nogil
+    const cydriver.CUipcEventHandle& ipc_handle, bint is_blocking_sync) except+ nogil
 
 # Event metadata getters
 cdef bint get_event_timing_enabled(const EventHandle& h) noexcept nogil
-cdef bint get_event_uses_blocking_sync(const EventHandle& h) noexcept nogil
+cdef bint get_event_is_blocking_sync(const EventHandle& h) noexcept nogil
 cdef bint get_event_ipc_enabled(const EventHandle& h) noexcept nogil
 cdef int get_event_device_id(const EventHandle& h) noexcept nogil
 cdef ContextHandle get_event_context(const EventHandle& h) noexcept nogil

cuda_core/cuda/core/_resource_handles.pyx

@@ -72,19 +72,19 @@ cdef extern from "_cpp/resource_handles.hpp" namespace "cuda_core":
     # Event handles (note: _create_event_handle* are internal due to C++ overloading)
     EventHandle create_event_handle "cuda_core::create_event_handle" (
         const ContextHandle& h_ctx, unsigned int flags,
-        bint timing_enabled, bint uses_blocking_sync,
+        bint timing_enabled, bint is_blocking_sync,
         bint ipc_enabled, int device_id) except+ nogil
     EventHandle create_event_handle_noctx "cuda_core::create_event_handle_noctx" (
         unsigned int flags) except+ nogil
     EventHandle create_event_handle_ref "cuda_core::create_event_handle_ref" (
         cydriver.CUevent event) except+ nogil
     EventHandle create_event_handle_ipc "cuda_core::create_event_handle_ipc" (
-        const cydriver.CUipcEventHandle& ipc_handle, bint uses_blocking_sync) except+ nogil
+        const cydriver.CUipcEventHandle& ipc_handle, bint is_blocking_sync) except+ nogil
 
     # Event metadata getters
     bint get_event_timing_enabled "cuda_core::get_event_timing_enabled" (
         const EventHandle& h) noexcept nogil
-    bint get_event_uses_blocking_sync "cuda_core::get_event_uses_blocking_sync" (
+    bint get_event_is_blocking_sync "cuda_core::get_event_is_blocking_sync" (
         const EventHandle& h) noexcept nogil
     bint get_event_ipc_enabled "cuda_core::get_event_ipc_enabled" (
         const EventHandle& h) noexcept nogil

cuda_core/docs/source/release/1.0.0-notes.rst

@@ -47,7 +47,7 @@ Breaking changes
   - ``LaunchConfig.cooperative_launch`` -> :attr:`LaunchConfig.is_cooperative`
     (also renames the constructor keyword argument).
   - ``Event.is_timing_disabled`` -> :attr:`Event.is_timing_enabled`.
-  - ``Event.is_sync_busy_waited`` -> :attr:`Event.uses_blocking_sync`.
+  - ``Event.is_sync_busy_waited`` -> :attr:`Event.is_blocking_sync`.
   - ``EventOptions.enable_timing`` -> ``EventOptions.timing_enabled``
     and ``EventOptions.busy_waited_sync`` -> ``EventOptions.blocking_sync``.
 

cuda_core/tests/graph/test_graph_definition_lifetime.py

@@ -211,7 +211,7 @@ def test_event_record_node_preserves_metadata(init_cuda):
 
     reconstructed = node.event
     assert reconstructed.is_timing_enabled is True
-    assert reconstructed.uses_blocking_sync is True
+    assert reconstructed.is_blocking_sync is True
     assert reconstructed.is_ipc_enabled is False
     assert reconstructed.device is not None
 
@@ -226,7 +226,7 @@ def test_event_wait_node_preserves_metadata(init_cuda):
 
     reconstructed = node.event
     assert reconstructed.is_timing_enabled is False
-    assert reconstructed.uses_blocking_sync is False
+    assert reconstructed.is_blocking_sync is False
     assert reconstructed.device is not None
 
 
@@ -243,7 +243,7 @@ def test_event_metadata_survives_gc(init_cuda):
 
     retrieved = node.event
     assert retrieved.is_timing_enabled is True
-    assert retrieved.uses_blocking_sync is True
+    assert retrieved.is_blocking_sync is True
     assert retrieved.is_done is True
 
 

cuda_core/tests/memory_ipc/test_event_ipc.py

@@ -157,7 +157,7 @@ def test_main(self, ipc_device, blocking_sync, use_options_cls, use_option_kw):
         assert props[0] == e.ipc_descriptor
         assert props[1] == e.is_ipc_enabled
         assert props[2] == e.is_timing_enabled
-        assert props[3] == e.uses_blocking_sync
+        assert props[3] == e.is_blocking_sync
         assert props[4] is None
         assert props[5] is None
 
@@ -176,7 +176,7 @@ def child_main(self, q_in, q_out):
             e.ipc_descriptor,
             e.is_ipc_enabled,
             e.is_timing_enabled,
-            e.uses_blocking_sync,
+            e.is_blocking_sync,
             e.device,
             e.context,
         )

cuda_core/tests/test_event.py

@@ -48,16 +48,16 @@ def test_timing_success(init_cuda):
     assert elapsed_time_ms > 10
 
 
-def test_uses_blocking_sync(init_cuda):
+def test_is_blocking_sync(init_cuda):
     options = EventOptions(timing_enabled=False, blocking_sync=True)
     stream = Device().create_stream()
     event = stream.record(options=options)
-    assert event.uses_blocking_sync is True
+    assert event.is_blocking_sync is True
 
     options = EventOptions(timing_enabled=False)
     stream = Device().create_stream()
     event = stream.record(options=options)
-    assert event.uses_blocking_sync is False
+    assert event.is_blocking_sync is False
 
 
 def test_sync(init_cuda):