cuda.core: inline resource state validation

Centralize open and valid state checks so hot Cython call paths use one consistent implementation.

Author: Andy-Jost

cuda_core/cuda/core/_context.pxd

@@ -23,3 +23,9 @@ cdef class Context:
     cdef Context _from_green_ctx(type cls, GreenCtxHandle h_green_ctx, int device_id)
 
     cpdef close(self)
+
+
+cdef inline int Context_check_open(Context self) except -1:
+    if not self._h_context:
+        raise RuntimeError("Context has been closed")
+    return 0

cuda_core/cuda/core/_context.pyx

@@ -96,8 +96,7 @@ cdef class Context:
 
         Raises :class:`RuntimeError` if the context has been closed.
         """
-        if not self._h_context:
-            raise RuntimeError("Cannot query resources on a closed context")
+        Context_check_open(self)
         return DeviceResources._init_from_ctx(self._h_context, self._device_id)
 
     def create_stream(self, options: object = None) -> Stream:
@@ -116,8 +115,7 @@ cdef class Context:
         :obj:`~_stream.Stream`
             Newly created stream object.
         """
-        if not self._h_context:
-            raise RuntimeError("Cannot create a stream on a closed context")
+        Context_check_open(self)
         if not self.is_green:
             raise RuntimeError(
                 "Context.create_stream() is only supported on green contexts. "

cuda_core/cuda/core/_device.pyx

@@ -12,7 +12,7 @@ from libcpp.vector cimport vector
 
 import threading
 
-from cuda.core._context cimport Context
+from cuda.core._context cimport Context, Context_check_open
 from cuda.core._context import ContextOptions
 from cuda.core._device_resources cimport DeviceResources, SMResource, WorkqueueResource
 from cuda.core._event cimport Event as cyEvent
@@ -1278,8 +1278,7 @@ class Device:
         if ctx is not None:
             # TODO: revisit once Context is cythonized
             assert_type(ctx, Context)
-            if ctx.is_closed:
-                raise RuntimeError("Context has been closed")
+            Context_check_open(ctx)
             if ctx._device_id != self._device_id:
                 raise RuntimeError(
                     "the provided context was created on the device with"

cuda_core/cuda/core/_event.pxd

@@ -23,4 +23,7 @@ cdef class Event:
 
 
 cdef Event Event_accept(object arg)
-cdef int Event_check_open(Event self) except -1
+cdef inline int Event_check_open(Event self) except -1:
+    if not self._h_event:
+        raise RuntimeError("Event has been closed")
+    return 0

cuda_core/cuda/core/_event.pyx

@@ -342,13 +342,6 @@ cdef class Event:
         if h_ctx and dev_id >= 0:
             return Context._from_handle(Context, h_ctx, dev_id)
 
-
-cdef int Event_check_open(Event self) except -1:
-    if not self._h_event:
-        raise RuntimeError("Event has been closed")
-    return 0
-
-
 cdef Event Event_accept(object arg):
     if not isinstance(arg, Event):
         raise TypeError(f"Event expected, got {type(arg).__name__}")

cuda_core/cuda/core/_graphics.pyx

@@ -45,6 +45,12 @@ def _parse_register_flags(flags: str | Sequence[str] | None) -> int:
     return result
 
 
+cdef inline int GraphicsResource_check_open(GraphicsResource self) except -1:
+    if not self._handle:
+        raise RuntimeError("GraphicsResource has been closed")
+    return 0
+
+
 cdef class GraphicsResource:
     """RAII wrapper for a CUDA graphics resource (``CUgraphicsResource``).
 
@@ -251,8 +257,7 @@ cdef class GraphicsResource:
         """
         cdef cydriver.CUdeviceptr dev_ptr = 0
         cdef size_t size = 0
-        if not self._handle:
-            raise RuntimeError("GraphicsResource has been closed")
+        GraphicsResource_check_open(self)
         if self._get_mapped_buffer() is not None:
             raise RuntimeError("GraphicsResource is already mapped")
 
@@ -294,8 +299,7 @@ cdef class GraphicsResource:
         CUDAError
             If the unmapping fails.
         """
-        if not self._handle:
-            raise RuntimeError("GraphicsResource has been closed")
+        GraphicsResource_check_open(self)
         cdef object buf_obj = self._get_mapped_buffer()
         if buf_obj is None:
             raise RuntimeError("GraphicsResource is not mapped")

cuda_core/cuda/core/_kernel_arg_handler.pyx

@@ -17,6 +17,7 @@ from typing import Sequence, Any
 import numpy
 
 from cuda.core._memory import Buffer
+from cuda.core._memory._buffer cimport Buffer as cyBuffer, Buffer_check_open
 from cuda.core._tensor_map import TensorMapDescriptor as _TensorMapDescriptor_py
 from cuda.core._tensor_map cimport TensorMapDescriptor
 from cuda.core.graph._graph_definition cimport GraphCondition
@@ -282,8 +283,7 @@ cdef class ParamHolder:
         for i, arg in enumerate(kernel_args):
             arg_type = type(arg)
             if arg_type is Buffer:
-                if arg.is_closed:
-                    raise RuntimeError("Buffer has been closed")
+                Buffer_check_open(<cyBuffer>arg)
                 # we need the address of where the actual buffer address is stored
                 if type(arg.handle) is int:
                     # see note below on handling int arguments
@@ -329,8 +329,7 @@ cdef class ParamHolder:
                     continue
                 # If no exact types are found, fallback to slower `isinstance` check
                 elif isinstance(arg, Buffer):
-                    if arg.is_closed:
-                        raise RuntimeError("Buffer has been closed")
+                    Buffer_check_open(<cyBuffer>arg)
                     if isinstance(arg.handle, int):
                         prepare_arg[intptr_t](self.data, self.data_addresses, arg.handle, i)
                         continue

cuda_core/cuda/core/_linker.pyx

@@ -63,6 +63,13 @@ LinkerHandleT = Union["cuda.bindings.nvjitlink.nvJitLinkHandle", "cuda.bindings.
 # Principal class
 # =============================================================================
 
+
+cdef inline int Linker_check_open(Linker self) except -1:
+    if self.is_closed:
+        raise RuntimeError("Linker has been closed")
+    return 0
+
+
 cdef class Linker:
     """Represent a linking machinery to link one or more object codes into
     :class:`~cuda.core.ObjectCode`.
@@ -106,8 +113,7 @@ cdef class Linker:
             Ensure that input object codes were compiled with appropriate
             flags for linking (e.g., relocatable device code enabled).
         """
-        if self.is_closed:
-            raise RuntimeError("Linker has been closed")
+        Linker_check_open(self)
         return Linker_link(self, str(target_type))
 
     def get_error_log(self) -> str:
@@ -121,8 +127,7 @@ cdef class Linker:
         # After link(), the decoded log is cached here.
         if self._error_log is not None:
             return self._error_log
-        if self.is_closed:
-            raise RuntimeError("Linker has been closed")
+        Linker_check_open(self)
         cdef cynvjitlink.nvJitLinkHandle c_h
         cdef size_t c_log_size = 0
         cdef char* c_log_ptr
@@ -149,8 +154,7 @@ cdef class Linker:
         # After link(), the decoded log is cached here.
         if self._info_log is not None:
             return self._info_log
-        if self.is_closed:
-            raise RuntimeError("Linker has been closed")
+        Linker_check_open(self)
         cdef cynvjitlink.nvJitLinkHandle c_h
         cdef size_t c_log_size = 0
         cdef char* c_log_ptr

cuda_core/cuda/core/_memory/_buffer.pxd

@@ -50,4 +50,9 @@ cdef Buffer Buffer_from_deviceptr_handle(
 # prefetch_batch, discard_batch, discard_prefetch_batch). `single_hint`
 # names the per-buffer API to use instead when a bare Buffer is passed.
 cdef tuple Buffer_coerce_batch(object buffers, str what, str single_hint)
-cdef int Buffer_check_open(Buffer self) except -1
+
+
+cdef inline int Buffer_check_open(Buffer self) except -1:
+    if not self._h_ptr:
+        raise RuntimeError("Buffer has been closed")
+    return 0

cuda_core/cuda/core/_memory/_buffer.pyx

@@ -882,13 +882,6 @@ cdef tuple Buffer_coerce_batch(object buffers, str what, str single_hint):
         out.append(item)
     return tuple(out)
 
-
-cdef int Buffer_check_open(Buffer self) except -1:
-    if not self._h_ptr:
-        raise RuntimeError("Buffer has been closed")
-    return 0
-
-
 cdef inline void Buffer_set_deallocation_stream(Buffer self, object stream):
     """Validate and replace a live buffer's deallocation recipe."""
     Buffer_check_open(self)