[BUG]: Buffer.from_handle does not respect custom MemoryResource deallocation

[stiepan]

Is this a duplicate?

• I confirmed there appear to be no duplicate issues for this bug and that I agree to the Code of Conduct

Type of Bug

Silent Failure

Component

cuda.core

Describe the bug

Custom MemoryResource.deallocate is not called when Buffer instances created with Buffer.from_handle(mr=mr : MemoryResource) are destroyed.

Up to (incl.) the most recent 0.5.* release, Buffer instances created from_handle with memory resource instance specified, took ownership of the resource. I.e. when the Buffer instance was destroyed, the MemoryResource got a corresponding deallocate call. This no longer seem to be a case with the cuda-core built from the top-of main branch.

How to Reproduce

from cuda.core import MemoryResource, Buffer
import numpy as np


class DummyResource(MemoryResource):
 def __init__(self):
 self.active_allocs = {}

 def allocate(self, size, stream=None, logger=None) -> Buffer:
 a = np.zeros(size, dtype=np.int8)
 ptr = a.ctypes.data
 self.active_allocs[ptr] = a
 return Buffer.from_handle(ptr=ptr, size=size, mr=self)

 def deallocate(self, ptr, size, stream=None):
 del self.active_allocs[ptr]

 @property
 def is_device_accessible(self) -> bool:
 return True

 @property
 def is_host_accessible(self) -> bool:
 return False

 @property
 def device_id(self) -> int:
 raise RuntimeError("the resource is not bound to any GPU")


resource = DummyResource()
buffer = resource.allocate(10)
assert int(buffer.handle) in resource.active_allocs
assert len(resource.active_allocs) == 1
del buffer
assert len(resource.active_allocs) == 0 # in cuda-core <=0.5.* this calls resource.deallocate, but not top-of-tree cuda-core

Expected behavior

Expected behaviour is to keep what cuda-core did so far - allow user specify custom deallcation via MemoryResource deallocate method. That ownership semantics established some usage pattern for custom memory resources built on top of cuda-core. Changing Buffer.from_handle to always act as non-owining wrapper can lead to hidden bugs/leaks in code that relies on the pattern.

Operating System

No response

nvidia-smi output

No response