refactor: rename native() to cu() for extracting raw CUDA handles

Shorter name that clearly indicates the return type is a CU* driver handle.
Updates all definitions, declarations, cimports, and call sites across
15 files.

Author: Andy-Jost

cuda_core/cuda/core/_cpp/DESIGN.md

@@ -73,7 +73,7 @@ Handles can be accessed in three ways via overloaded helper functions:
 
 | Function | Returns | Use Case | Notes
 |----------|---------|----------|-------|
-| `native(h)` | Raw CUDA type (e.g., `CUstream`) | Passing to CUDA APIs | An attribute of `cuda.bindings.cydriver` |
+| `cu(h)` | Raw CUDA type (e.g., `CUstream`) | Passing to CUDA APIs | An attribute of `cuda.bindings.cydriver` |
 | `intptr(h)` | `intptr_t` | Python interop, foreign code | |
 | `py(h)` | Python wrapper object | Returning to Python callers | An attribute of `cure.bindings.driver`
 
@@ -85,7 +85,7 @@ Example usage from Cython:
 
 ```cython
 # Get raw handle for CUDA API calls
-cdef CUstream raw_stream = native(h_stream)  # cuda.bindings.cydriver.CUstream
+cdef CUstream raw_stream = cu(h_stream)  # cuda.bindings.cydriver.CUstream
 
 # Get as integer for other use cases
 return hash(intptr(h_stream))
@@ -250,7 +250,7 @@ Related functions:
 from cuda.core._resource_handles cimport (
     StreamHandle,
     create_stream_handle,
-    native,
+    cu,
     intptr,
     get_last_error,
     _init_handles_table,
@@ -264,7 +264,7 @@ if not h_stream:
     HANDLE_RETURN(get_last_error())
 
 # Use in CUDA API
-cuStreamSynchronize(native(h_stream))
+cuStreamSynchronize(cu(h_stream))
 
 # Return to Python
 return py(h_stream)
@@ -279,7 +279,7 @@ The resource handle design:
 3. **Uses capsules** to solve two distinct problems:
    - Sharing C++ code across Cython modules without duplicate statics.
    - Resolving CUDA driver symbols dynamically through cuda-bindings.
-4. **Provides overloaded accessors** (`native`, `intptr`, `py`) since handles cannot
+4. **Provides overloaded accessors** (`cu`, `intptr`, `py`) since handles cannot
    have attributes without unnecessary Python object wrappers.
 
 This architecture ensures CUDA resources are managed correctly regardless of Python

cuda_core/cuda/core/_cpp/resource_handles.cpp

@@ -587,15 +587,15 @@ DevicePtrHandle deviceptr_alloc_from_pool(size_t size, MemoryPoolHandle h_pool,
     }
     GILReleaseGuard gil;
     CUdeviceptr ptr;
-    if (CUDA_SUCCESS != (err = p_cuMemAllocFromPoolAsync(&ptr, size, *h_pool, native(h_stream)))) {
+    if (CUDA_SUCCESS != (err = p_cuMemAllocFromPoolAsync(&ptr, size, *h_pool, cu(h_stream)))) {
         return {};
     }
 
     auto box = std::shared_ptr<DevicePtrBox>(
         new DevicePtrBox{ptr, h_stream},
         [h_pool](DevicePtrBox* b) {
             GILReleaseGuard gil;
-            p_cuMemFreeAsync(b->resource, native(b->h_stream));
+            p_cuMemFreeAsync(b->resource, cu(b->h_stream));
             delete b;
         }
     );
@@ -609,15 +609,15 @@ DevicePtrHandle deviceptr_alloc_async(size_t size, StreamHandle h_stream) {
     }
     GILReleaseGuard gil;
     CUdeviceptr ptr;
-    if (CUDA_SUCCESS != (err = p_cuMemAllocAsync(&ptr, size, native(h_stream)))) {
+    if (CUDA_SUCCESS != (err = p_cuMemAllocAsync(&ptr, size, cu(h_stream)))) {
         return {};
     }
 
     auto box = std::shared_ptr<DevicePtrBox>(
         new DevicePtrBox{ptr, h_stream},
         [](DevicePtrBox* b) {
             GILReleaseGuard gil;
-            p_cuMemFreeAsync(b->resource, native(b->h_stream));
+            p_cuMemFreeAsync(b->resource, cu(b->h_stream));
             delete b;
         }
     );
@@ -791,7 +791,7 @@ DevicePtrHandle deviceptr_import_ipc(MemoryPoolHandle h_pool, const void* export
                         ipc_ptr_cache.erase(it);
                     }
                 }
-                p_cuMemFreeAsync(b->resource, native(b->h_stream));
+                p_cuMemFreeAsync(b->resource, cu(b->h_stream));
                 delete b;
             }
         );
@@ -810,7 +810,7 @@ DevicePtrHandle deviceptr_import_ipc(MemoryPoolHandle h_pool, const void* export
             new DevicePtrBox{ptr, h_stream},
             [h_pool](DevicePtrBox* b) {
                 GILReleaseGuard gil;
-                p_cuMemFreeAsync(b->resource, native(b->h_stream));
+                p_cuMemFreeAsync(b->resource, cu(b->h_stream));
                 delete b;
             }
         );

cuda_core/cuda/core/_cpp/resource_handles.hpp

@@ -185,47 +185,47 @@ void set_deallocation_stream(const DevicePtrHandle& h, StreamHandle h_stream);
 // Overloaded helper functions to extract raw resources from handles
 // ============================================================================
 
-// native() - extract the raw CUDA handle
-inline CUcontext native(const ContextHandle& h) noexcept {
+// cu() - extract the raw CUDA handle
+inline CUcontext cu(const ContextHandle& h) noexcept {
     return h ? *h : nullptr;
 }
 
-inline CUstream native(const StreamHandle& h) noexcept {
+inline CUstream cu(const StreamHandle& h) noexcept {
     return h ? *h : nullptr;
 }
 
-inline CUevent native(const EventHandle& h) noexcept {
+inline CUevent cu(const EventHandle& h) noexcept {
     return h ? *h : nullptr;
 }
 
-inline CUmemoryPool native(const MemoryPoolHandle& h) noexcept {
+inline CUmemoryPool cu(const MemoryPoolHandle& h) noexcept {
     return h ? *h : nullptr;
 }
 
-inline CUdeviceptr native(const DevicePtrHandle& h) noexcept {
+inline CUdeviceptr cu(const DevicePtrHandle& h) noexcept {
     return h ? *h : 0;
 }
 
 // intptr() - extract handle as intptr_t for Python interop
 // Using signed intptr_t per C standard convention and issue #1342
 inline std::intptr_t intptr(const ContextHandle& h) noexcept {
-    return reinterpret_cast<std::intptr_t>(h ? *h : nullptr);
+    return reinterpret_cast<std::intptr_t>(cu(h));
 }
 
 inline std::intptr_t intptr(const StreamHandle& h) noexcept {
-    return reinterpret_cast<std::intptr_t>(h ? *h : nullptr);
+    return reinterpret_cast<std::intptr_t>(cu(h));
 }
 
 inline std::intptr_t intptr(const EventHandle& h) noexcept {
-    return reinterpret_cast<std::intptr_t>(h ? *h : nullptr);
+    return reinterpret_cast<std::intptr_t>(cu(h));
 }
 
 inline std::intptr_t intptr(const MemoryPoolHandle& h) noexcept {
-    return reinterpret_cast<std::intptr_t>(h ? *h : nullptr);
+    return reinterpret_cast<std::intptr_t>(cu(h));
 }
 
 inline std::intptr_t intptr(const DevicePtrHandle& h) noexcept {
-    return h ? static_cast<std::intptr_t>(*h) : 0;
+    return static_cast<std::intptr_t>(cu(h));
 }
 
 // py() - convert handle to Python driver wrapper object (returns new reference)

cuda_core/cuda/core/_device.pyx

@@ -20,7 +20,7 @@ from cuda.core._resource_handles cimport (
     _init_handles_table,
     create_context_handle_ref,
     get_primary_context,
-    native,
+    cu,
 )
 
 _init_handles_table()
@@ -1242,7 +1242,7 @@ class Device:
                     f" id={ctx._device_id}, which is different from the target id={self._device_id}"
                 )
             # prev_ctx is the previous context
-            curr_ctx = native(ctx._h_context)
+            curr_ctx = cu(ctx._h_context)
             prev_ctx = NULL
             with nogil:
                 HANDLE_RETURN(cydriver.cuCtxPopCurrent(&prev_ctx))
@@ -1257,7 +1257,7 @@ class Device:
             if h_context.get() == NULL:
                 raise ValueError("Cannot set NULL context as current")
             with nogil:
-                HANDLE_RETURN(cydriver.cuCtxSetCurrent(native(h_context)))
+                HANDLE_RETURN(cydriver.cuCtxSetCurrent(cu(h_context)))
             self._has_inited = True
             self._context = Context._from_handle(Context, h_context, self._device_id)  # Store owning context
 

cuda_core/cuda/core/_event.pyx

@@ -15,7 +15,7 @@ from cuda.core._resource_handles cimport (
     create_event_handle,
     create_event_handle_ipc,
     intptr,
-    native,
+    cu,
     py,
 )
 
@@ -148,7 +148,7 @@ cdef class Event:
         # return self - other (in milliseconds)
         cdef float timing
         with nogil:
-            err = cydriver.cuEventElapsedTime(&timing, native((<Event>other)._h_event), native(self._h_event))
+            err = cydriver.cuEventElapsedTime(&timing, cu((<Event>other)._h_event), cu(self._h_event))
         if err == 0:
             return timing
         else:
@@ -191,7 +191,7 @@ cdef class Event:
             raise RuntimeError("Event is not IPC-enabled")
         cdef cydriver.CUipcEventHandle data
         with nogil:
-            HANDLE_RETURN(cydriver.cuIpcGetEventHandle(&data, native(self._h_event)))
+            HANDLE_RETURN(cydriver.cuIpcGetEventHandle(&data, cu(self._h_event)))
         cdef bytes data_b = cpython.PyBytes_FromStringAndSize(<char*>(data.reserved), sizeof(data.reserved))
         self._ipc_descriptor = IPCEventDescriptor._init(data_b, self._busy_waited)
         return self._ipc_descriptor
@@ -241,13 +241,13 @@ cdef class Event:
 
         """
         with nogil:
-            HANDLE_RETURN(cydriver.cuEventSynchronize(native(self._h_event)))
+            HANDLE_RETURN(cydriver.cuEventSynchronize(cu(self._h_event)))
 
     @property
     def is_done(self) -> bool:
         """Return True if all captured works have been completed, otherwise False."""
         with nogil:
-            result = cydriver.cuEventQuery(native(self._h_event))
+            result = cydriver.cuEventQuery(cu(self._h_event))
         if result == cydriver.CUresult.CUDA_SUCCESS:
             return True
         if result == cydriver.CUresult.CUDA_ERROR_NOT_READY:

cuda_core/cuda/core/_launcher.pyx

@@ -8,7 +8,7 @@ from cuda.bindings cimport cydriver
 
 from cuda.core._launch_config cimport LaunchConfig
 from cuda.core._kernel_arg_handler cimport ParamHolder
-from cuda.core._resource_handles cimport native
+from cuda.core._resource_handles cimport cu
 from cuda.core._stream cimport Stream_accept, Stream
 from cuda.core._utils.cuda_utils cimport (
     check_or_create_options,
@@ -88,7 +88,7 @@ def launch(stream: Stream | GraphBuilder | IsStreamT, config: LaunchConfig, kern
     # rich.
     if _use_ex:
         drv_cfg = conf._to_native_launch_config()
-        drv_cfg.hStream = native(s._h_stream)
+        drv_cfg.hStream = cu(s._h_stream)
         if conf.cooperative_launch:
             _check_cooperative_launch(kernel, conf, s)
         with nogil:
@@ -100,7 +100,7 @@ def launch(stream: Stream | GraphBuilder | IsStreamT, config: LaunchConfig, kern
                 func_handle,
                 conf.grid[0], conf.grid[1], conf.grid[2],
                 conf.block[0], conf.block[1], conf.block[2],
-                conf.shmem_size, native(s._h_stream), args_ptr, NULL
+                conf.shmem_size, cu(s._h_stream), args_ptr, NULL
             )
         )
 

cuda_core/cuda/core/_memory/_buffer.pyx

@@ -19,7 +19,7 @@ from cuda.core._resource_handles cimport (
     _init_handles_table,
     deviceptr_create_with_owner,
     intptr,
-    native,
+    cu,
     set_deallocation_stream,
 )
 
@@ -187,7 +187,7 @@ cdef class Buffer:
             )
         with nogil:
             HANDLE_RETURN(cydriver.cuMemcpyAsync(
-                native(dst._h_ptr), native(self._h_ptr), src_size, native(s._h_stream)))
+                cu(dst._h_ptr), cu(self._h_ptr), src_size, cu(s._h_stream)))
         return dst
 
     def copy_from(self, src: Buffer, *, stream: Stream | GraphBuilder):
@@ -212,7 +212,7 @@ cdef class Buffer:
             )
         with nogil:
             HANDLE_RETURN(cydriver.cuMemcpyAsync(
-                native(self._h_ptr), native(src._h_ptr), dst_size, native(s._h_stream)))
+                cu(self._h_ptr), cu(src._h_ptr), dst_size, cu(s._h_stream)))
 
     def fill(self, value: int | BufferProtocol, *, stream: Stream | GraphBuilder):
         """Fill this buffer with a repeating byte pattern.
@@ -369,7 +369,7 @@ cdef class Buffer:
 cdef inline void _init_mem_attrs(Buffer self):
     """Initialize memory attributes by querying the pointer."""
     if not self._mem_attrs_inited:
-        _query_memory_attrs(self._mem_attrs, native(self._h_ptr))
+        _query_memory_attrs(self._mem_attrs, cu(self._h_ptr))
         self._mem_attrs_inited = True
 
 
@@ -524,8 +524,8 @@ cdef inline void Buffer_close(Buffer self, object stream):
 
 
 cdef inline int Buffer_fill_uint8(Buffer self, uint8_t value, StreamHandle h_stream) except? -1:
-    cdef cydriver.CUdeviceptr ptr = native(self._h_ptr)
-    cdef cydriver.CUstream s = native(h_stream)
+    cdef cydriver.CUdeviceptr ptr = cu(self._h_ptr)
+    cdef cydriver.CUstream s = cu(h_stream)
     with nogil:
         HANDLE_RETURN(cydriver.cuMemsetD8Async(ptr, value, self._size, s))
     return 0
@@ -535,8 +535,8 @@ cdef inline int Buffer_fill_from_ptr(
     Buffer self, const char* ptr, size_t width, StreamHandle h_stream
 ) except? -1:
     cdef size_t buffer_size = self._size
-    cdef cydriver.CUdeviceptr dst = native(self._h_ptr)
-    cdef cydriver.CUstream s = native(h_stream)
+    cdef cydriver.CUdeviceptr dst = cu(self._h_ptr)
+    cdef cydriver.CUstream s = cu(h_stream)
 
     if width == 1:
         with nogil:

cuda_core/cuda/core/_memory/_device_memory_resource.pyx

@@ -20,7 +20,7 @@ import platform  # no-cython-lint
 import uuid
 
 from cuda.core._utils.cuda_utils import check_multiprocessing_start_method
-from cuda.core._resource_handles cimport native
+from cuda.core._resource_handles cimport cu
 
 if TYPE_CHECKING:
     from .._device import Device
@@ -255,7 +255,7 @@ cpdef DMR_mempool_get_access(DeviceMemoryResource dmr, int device_id):
     location.id = dev_id
 
     with nogil:
-        HANDLE_RETURN(cydriver.cuMemPoolGetAccess(&flags, native(dmr._h_pool), &location))
+        HANDLE_RETURN(cydriver.cuMemPoolGetAccess(&flags, cu(dmr._h_pool), &location))
 
     if flags == cydriver.CUmemAccess_flags.CU_MEM_ACCESS_FLAGS_PROT_READWRITE:
         return "rw"

cuda_core/cuda/core/_memory/_graph_memory_resource.pyx

@@ -12,7 +12,7 @@ from cuda.core._resource_handles cimport (
     DevicePtrHandle,
     _init_handles_table,
     deviceptr_alloc_async,
-    native,
+    cu,
 )
 
 _init_handles_table()
@@ -194,7 +194,7 @@ cdef inline int check_capturing(cydriver.CUstream s) except?-1 nogil:
 
 
 cdef inline Buffer GMR_allocate(cyGraphMemoryResource self, size_t size, Stream stream):
-    cdef cydriver.CUstream s = native(stream._h_stream)
+    cdef cydriver.CUstream s = cu(stream._h_stream)
     cdef DevicePtrHandle h_ptr
     with nogil:
         check_capturing(s)
@@ -205,7 +205,7 @@ cdef inline Buffer GMR_allocate(cyGraphMemoryResource self, size_t size, Stream
 
 
 cdef inline void GMR_deallocate(intptr_t ptr, size_t size, Stream stream) noexcept:
-    cdef cydriver.CUstream s = native(stream._h_stream)
+    cdef cydriver.CUstream s = cu(stream._h_stream)
     cdef cydriver.CUdeviceptr devptr = <cydriver.CUdeviceptr>ptr
     with nogil:
         HANDLE_RETURN(cydriver.cuMemFreeAsync(devptr, s))

cuda_core/cuda/core/_memory/_ipc.pyx

@@ -14,7 +14,7 @@ from cuda.core._resource_handles cimport (
     create_mempool_handle_ipc,
     deviceptr_import_ipc,
     get_last_error,
-    native,
+    cu,
 )
 
 _init_handles_table()
@@ -164,7 +164,7 @@ cdef IPCBufferDescriptor Buffer_get_ipc_descriptor(Buffer self):
     cdef cydriver.CUmemPoolPtrExportData data
     with nogil:
         HANDLE_RETURN(
-            cydriver.cuMemPoolExportPointer(&data, native(self._h_ptr))
+            cydriver.cuMemPoolExportPointer(&data, cu(self._h_ptr))
         )
     cdef bytes data_b = cpython.PyBytes_FromStringAndSize(
         <char*>(data.reserved), sizeof(data.reserved)
@@ -250,7 +250,7 @@ cdef IPCAllocationHandle MP_export_mempool(_MemPool self):
     cdef int fd
     with nogil:
         HANDLE_RETURN(cydriver.cuMemPoolExportToShareableHandle(
-            &fd, native(self._h_pool), IPC_HANDLE_TYPE, 0)
+            &fd, cu(self._h_pool), IPC_HANDLE_TYPE, 0)
         )
     try:
         return IPCAllocationHandle._init(fd, uuid.uuid4())