cuda.core: fix C++ teardown leak when buffer has no attached stream (#2001)

Issue: the C++ ``shared_ptr`` deleter for a buffer's device-pointer
handle invokes ``MemoryResource.deallocate`` via ``_mr_dealloc_callback``.
The handle's deallocation stream is set separately via
``set_deallocation_stream``; if it was never set (e.g. buffers minted via
``Buffer.from_handle(ptr, size, mr=mr)`` from DLPack import, IPC import,
or third-party adapters), the callback would pass ``stream=None`` to
``mr.deallocate``. After the strict-stream changes for #2001, the
stream-ordered MR overrides reject ``stream=None`` via ``Stream_accept``
and raise ``TypeError``. The ``noexcept`` callback catches the exception,
prints a warning to stderr, and returns -- silently **leaking** the
underlying CUDA allocation (and any associated IPC handles).

Fix: when ``h_stream`` is empty in ``_mr_dealloc_callback``, fall back
to ``default_stream()`` instead of ``None``. The C++ teardown path is
the unique legitimate "no-stream-context" caller (no Python frame from
which to obtain a stream), so this is the one place where an implicit
default-stream fallback is necessary; everywhere else the policy
remains "stream is required and must be passed explicitly".

Add ``test_mr_dealloc_callback_falls_back_to_default_stream`` covering
the regression: a strict stream-ordered mock MR is used to back a
``Buffer.from_handle`` (no attached stream), and the test asserts that
``deallocate`` is invoked with the default stream rather than failing
with ``TypeError`` and leaking.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: Andy-Jost

cuda_core/cuda/core/_memory/_buffer.pyx

@@ -49,11 +49,23 @@ cdef void _mr_dealloc_callback(
     size_t size,
     const StreamHandle& h_stream,
 ) noexcept:
-    """Called by the C++ deleter to deallocate via MemoryResource.deallocate."""
+    """Called by the C++ deleter to deallocate via MemoryResource.deallocate.
+
+    This is the C++ teardown path: there is no Python caller frame from
+    which to obtain a stream. If the device-pointer handle was created
+    without ``set_deallocation_stream`` being called (e.g. buffers minted
+    via ``Buffer.from_handle(ptr, size, mr=mr)`` from DLPack import,
+    third-party adapters, or other foreign sources), ``h_stream`` is
+    empty here. Stream-ordered MR ``deallocate`` overrides reject
+    ``stream=None`` (issue #2001), so without a fallback the destructor
+    would print a warning and leak the allocation. Fall back to the
+    legacy/per-thread default stream so the free still happens; this is
+    the unique exception to the "no implicit default-stream fallback"
+    policy because the teardown has no other source of truth.
+    """
+    cdef Stream stream
     try:
-        stream = None
-        if h_stream:
-            stream = Stream._from_handle(Stream, h_stream)
+        stream = Stream._from_handle(Stream, h_stream) if h_stream else default_stream()
         mr.deallocate(int(ptr), size, stream=stream)
     except Exception as exc:
         print(f"Warning: mr.deallocate() failed during Buffer destruction: {exc}",

cuda_core/tests/test_memory.py

@@ -521,6 +521,56 @@ def deallocate(self, ptr, size, *, stream=None):
     assert received["stream"].handle == stream.handle
 
 
+def test_mr_dealloc_callback_falls_back_to_default_stream():
+    """When a Buffer's device-pointer handle has no attached deallocation
+    stream (e.g. buffers minted via :meth:`Buffer.from_handle` from DLPack
+    import, IPC import, or third-party adapters), the C++ deleter callback
+    must fall back to the default stream rather than passing ``stream=None``
+    to ``mr.deallocate``. Stream-ordered MRs validate the stream and would
+    otherwise raise ``TypeError`` from inside the ``noexcept`` callback,
+    which only logs a warning and silently leaks the allocation. See
+    `#2001 <https://github.com/NVIDIA/cuda-python/issues/2001>`__.
+    """
+    import gc
+
+    from cuda.core._stream import Stream_accept, default_stream
+
+    device = Device()
+    device.set_current()
+    captured = {}
+
+    class StrictCapturingMR(MemoryResource):
+        # Models a stream-ordered MR: deallocate validates the stream
+        # the same way DeviceMemoryResource.deallocate does.
+        @property
+        def is_device_accessible(self):
+            return True
+
+        @property
+        def is_host_accessible(self):
+            return False
+
+        @property
+        def device_id(self):
+            return device.device_id
+
+        def allocate(self, size, *, stream):
+            raise NotImplementedError  # not used; we use from_handle below
+
+        def deallocate(self, ptr, size, *, stream):
+            captured["stream"] = Stream_accept(stream)
+
+    mr = StrictCapturingMR()
+    # Buffer.from_handle binds mr but does not attach a deallocation stream.
+    # ptr=1 is fine because StrictCapturingMR.deallocate does not free.
+    buf = Buffer.from_handle(1, 1024, mr=mr)
+    del buf
+    gc.collect()
+
+    assert "stream" in captured, "deallocate was not invoked (callback raised and leaked)"
+    assert captured["stream"].handle == default_stream().handle
+
+
 def test_memory_resource_and_owner_disallowed():
     with pytest.raises(ValueError, match="cannot be both specified together"):
         a = (ctypes.c_byte * 20)()