Rename _mr to _memory_resource. Change pointer types from intptr_t to uintptr_t.

Author: Andy-Jost

cuda_core/cuda/core/experimental/_memory/_buffer.pxd

@@ -2,16 +2,16 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from libc.stdint cimport intptr_t
+from libc.stdint cimport uintptr_t
 
 from cuda.core.experimental._stream cimport Stream
 
 
 cdef class Buffer:
     cdef:
-        intptr_t       _ptr
+        uintptr_t      _ptr
         size_t         _size
-        MemoryResource _mr
+        MemoryResource _memory_resource
         object         _ptr_obj
         Stream         _alloc_stream
 

cuda_core/cuda/core/experimental/_memory/_buffer.pyx

@@ -4,7 +4,7 @@
 
 from __future__ import annotations
 
-from libc.stdint cimport intptr_t
+from libc.stdint cimport uintptr_t
 
 from cuda.core.experimental._memory._dmr cimport DeviceMemoryResource
 from cuda.core.experimental._memory._ipc cimport IPCBufferDescriptor
@@ -44,7 +44,7 @@ cdef class Buffer:
     def _clear(self):
         self._ptr = 0
         self._size = 0
-        self._mr = None
+        self._memory_resource = None
         self._ptr_obj = None
         self._alloc_stream = None
 
@@ -58,10 +58,10 @@ cdef class Buffer:
         stream: Stream | None = None
     ):
         cdef Buffer self = Buffer.__new__(cls)
-        self._ptr = <intptr_t>(int(ptr))
+        self._ptr = <uintptr_t>(int(ptr))
         self._ptr_obj = ptr
         self._size = size
-        self._mr = mr
+        self._memory_resource = mr
         self._alloc_stream = <Stream>(stream) if stream is not None else None
         return self
 
@@ -138,10 +138,10 @@ cdef class Buffer:
         cdef size_t src_size = self._size
 
         if dst is None:
-            if self._mr is None:
+            if self._memory_resource is None:
                 raise ValueError("a destination buffer must be provided (this "
                                  "buffer does not have a memory_resource)")
-            dst = self._mr.allocate(src_size, stream)
+            dst = self._memory_resource.allocate(src_size, stream)
 
         cdef size_t dst_size = dst._size
         if dst_size != src_size:
@@ -226,8 +226,8 @@ cdef class Buffer:
     @property
     def device_id(self) -> int:
         """Return the device ordinal of this buffer."""
-        if self._mr is not None:
-            return self._mr.device_id
+        if self._memory_resource is not None:
+            return self._memory_resource.device_id
         raise NotImplementedError("WIP: Currently this property only supports buffers with associated MemoryResource")
 
     @property
@@ -250,21 +250,21 @@ cdef class Buffer:
     @property
     def is_device_accessible(self) -> bool:
         """Return True if this buffer can be accessed by the GPU, otherwise False."""
-        if self._mr is not None:
-            return self._mr.is_device_accessible
+        if self._memory_resource is not None:
+            return self._memory_resource.is_device_accessible
         raise NotImplementedError("WIP: Currently this property only supports buffers with associated MemoryResource")
 
     @property
     def is_host_accessible(self) -> bool:
         """Return True if this buffer can be accessed by the CPU, otherwise False."""
-        if self._mr is not None:
-            return self._mr.is_host_accessible
+        if self._memory_resource is not None:
+            return self._memory_resource.is_host_accessible
         raise NotImplementedError("WIP: Currently this property only supports buffers with associated MemoryResource")
 
     @property
     def memory_resource(self) -> MemoryResource:
         """Return the memory resource associated with this buffer."""
-        return self._mr
+        return self._memory_resource
 
     @property
     def size(self) -> int:
@@ -276,7 +276,7 @@ cdef class Buffer:
 # ---------------------
 cdef Buffer_close(Buffer self, stream):
     cdef Stream s
-    if self._ptr and self._mr is not None:
+    if self._ptr and self._memory_resource is not None:
         if stream is None:
             if self._alloc_stream is not None:
                 s = self._alloc_stream
@@ -285,9 +285,9 @@ cdef Buffer_close(Buffer self, stream):
                 s = <Stream>(default_stream())
         else:
             s = <Stream>stream
-        self._mr.deallocate(self._ptr, self._size, s)
+        self._memory_resource.deallocate(self._ptr, self._size, s)
         self._ptr = 0
-        self._mr = None
+        self._memory_resource = None
         self._ptr_obj = None
         self._alloc_stream = None
 

cuda_core/cuda/core/experimental/_memory/_dmr.pyx

@@ -5,7 +5,7 @@
 from __future__ import annotations
 
 from libc.limits cimport ULLONG_MAX
-from libc.stdint cimport uintptr_t, intptr_t
+from libc.stdint cimport uintptr_t
 from libc.string cimport memset
 
 from cuda.bindings cimport cydriver
@@ -339,7 +339,7 @@ cdef class DeviceMemoryResource(MemoryResource):
             If the buffer is deallocated without an explicit stream, the allocation stream
             is used.
         """
-        DMR_deallocate(self, <intptr_t>ptr, size, <Stream>stream)
+        DMR_deallocate(self, <uintptr_t>ptr, size, <Stream>stream)
 
     @property
     def attributes(self) -> DeviceMemoryResourceAttributes:
@@ -466,16 +466,16 @@ cdef Buffer DMR_allocate(DeviceMemoryResource self, size_t size, Stream stream):
     with nogil:
         HANDLE_RETURN(cydriver.cuMemAllocFromPoolAsync(&devptr, size, self._handle, s))
     cdef Buffer buf = Buffer.__new__(Buffer)
-    buf._ptr = <intptr_t>(devptr)
+    buf._ptr = <uintptr_t>(devptr)
     buf._ptr_obj = None
     buf._size = size
-    buf._mr = self
+    buf._memory_resource = self
     buf._alloc_stream = stream
     return buf
 
 
 cdef void DMR_deallocate(
-    DeviceMemoryResource self, intptr_t ptr, size_t size, Stream stream
+    DeviceMemoryResource self, uintptr_t ptr, size_t size, Stream stream
 ) noexcept:
     cdef cydriver.CUstream s = stream._handle
     cdef cydriver.CUdeviceptr devptr = <cydriver.CUdeviceptr>ptr

cuda_core/cuda/core/experimental/_memory/_ipc.pyx

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 cimport cpython
-from libc.stdint cimport intptr_t
+from libc.stdint cimport uintptr_t
 from libc.string cimport memcpy
 
 from cuda.bindings cimport cydriver
@@ -142,7 +142,7 @@ multiprocessing.reduction.register(DeviceMemoryResource, _deep_reduce_device_mem
 # Buffer IPC Implementation
 # -------------------------
 cdef IPCBufferDescriptor Buffer_get_ipc_descriptor(Buffer self):
-    if not self._mr.is_ipc_enabled:
+    if not self.memory_resource.is_ipc_enabled:
         raise RuntimeError("Memory resource is not IPC-enabled")
     cdef cydriver.CUmemPoolPtrExportData data
     with nogil:
@@ -172,7 +172,7 @@ cdef Buffer Buffer_from_ipc_descriptor(
     cdef cydriver.CUdeviceptr ptr
     with nogil:
         HANDLE_RETURN(cydriver.cuMemPoolImportPointer(&ptr, mr._handle, &data))
-    return Buffer._init(<intptr_t>ptr, ipc_buffer.size, mr, stream)
+    return Buffer._init(<uintptr_t>ptr, ipc_buffer.size, mr, stream)
 
 
 # DeviceMemoryResource IPC Implementation
@@ -205,7 +205,7 @@ cdef DeviceMemoryResource DMR_from_allocation_handle(cls, device_id, alloc_handl
     cdef int handle = int(alloc_handle)
     with nogil:
         HANDLE_RETURN(cydriver.cuMemPoolImportFromShareableHandle(
-            &(self._handle), <void*><intptr_t>(handle), IPC_HANDLE_TYPE, 0)
+            &(self._handle), <void*><uintptr_t>(handle), IPC_HANDLE_TYPE, 0)
         )
 
     # Register it.