WIP: address closed-resource review feedback

Author: Andy-Jost

cuda_core/cuda/core/_memory/_ipc.pyx

@@ -16,7 +16,6 @@ from cuda.core._resource_handles cimport (
     deviceptr_import_ipc,
     get_last_error,
     as_cu,
-    as_intptr,
     as_py,
 )
 
@@ -111,7 +110,7 @@ cdef class IPCBufferDescriptor:
 
 
 cdef inline int IPCAllocationHandle_check_open(IPCAllocationHandle self) except -1:
-    if not self._h_fd or as_intptr(self._h_fd) < 0:
+    if self._h_fd.get() == NULL:
         raise RuntimeError("IPCAllocationHandle has been closed")
     return 0
 
@@ -138,10 +137,10 @@ cdef class IPCAllocationHandle:
     @property
     def is_closed(self) -> bool:
         """Whether this allocation handle has been closed."""
-        return self._h_fd.get() == NULL or as_intptr(self._h_fd) < 0
+        return self._h_fd.get() == NULL
 
     def __int__(self) -> int:
-        if not self._h_fd or as_intptr(self._h_fd) < 0:
+        if self._h_fd.get() == NULL:
             raise ValueError(
                 f"Cannot convert IPCAllocationHandle to int: the handle (id={id(self)}) is closed."
             )

cuda_core/cuda/core/_memory/_memory_pool.pyi

@@ -40,9 +40,13 @@ class _MemPoolAttributes:
 class _MemPool(MemoryResource):
     def __init__(self) -> None: ...
     def close(self) -> None:
-        """
-        Close the memory resource and destroy the associated memory pool
-        if owned.
+        """Release this object's reference to the memory pool.
+
+        New allocations and operations requiring this object's pool handle are
+        rejected afterward. For owned pools, release of the underlying pool's
+        resources is deferred until all outstanding allocations are freed and
+        pending free operations complete. :meth:`deallocate` remains available
+        after :meth:`close` so existing allocations can still be released.
         """
     @property
     def is_closed(self) -> bool:

cuda_core/cuda/core/_memory/_memory_pool.pyx

@@ -127,9 +127,13 @@ cdef class _MemPool(MemoryResource):
         self._attributes = None
 
     def close(self) -> None:
-        """
-        Close the memory resource and destroy the associated memory pool
-        if owned.
+        """Release this object's reference to the memory pool.
+
+        New allocations and operations requiring this object's pool handle are
+        rejected afterward. For owned pools, release of the underlying pool's
+        resources is deferred until all outstanding allocations are freed and
+        pending free operations complete. :meth:`deallocate` remains available
+        after :meth:`close` so existing allocations can still be released.
         """
         _MP_close(self)
 

cuda_core/cuda/core/_stream.pyi

@@ -70,6 +70,11 @@ class Stream:
         Releases the stream handle. For owned streams, this destroys the
         underlying CUDA stream. For borrowed streams, this releases the
         reference and allows the Python owner to be GC'd.
+
+        .. warning::
+            Do not close :obj:`LEGACY_DEFAULT_STREAM` or
+            :obj:`PER_THREAD_DEFAULT_STREAM`. They are shared module-level
+            objects, so closing one invalidates it for the rest of the process.
         """
     @property
     def is_closed(self) -> bool:

cuda_core/cuda/core/_stream.pyx

@@ -200,9 +200,12 @@ cdef class Stream:
         Releases the stream handle. For owned streams, this destroys the
         underlying CUDA stream. For borrowed streams, this releases the
         reference and allows the Python owner to be GC'd.
+
+        .. warning::
+            Do not close :obj:`LEGACY_DEFAULT_STREAM` or
+            :obj:`PER_THREAD_DEFAULT_STREAM`. They are shared module-level
+            objects, so closing one invalidates it for the rest of the process.
         """
-        if self._h_stream and Stream_is_default_token(self):
-            return
         self._h_stream.reset()
 
     @property

cuda_core/cuda/core/graph/_adjacency_set_proxy.pyx

@@ -61,9 +61,9 @@ class AdjacencySetProxy(MutableSet[GraphNode]):
         (<_AdjacencySetCore>self._core).check_owner_mutable()
         if not isinstance(value, GraphNode):
             return
-        (<_AdjacencySetCore>self._core).check_mutation(value)
         if value not in self:
             return
+        (<_AdjacencySetCore>self._core).check_mutation(value)
         (<_AdjacencySetCore>self._core).remove_edge(<GraphNode>value)
 
     # --- override for bulk efficiency ---

cuda_core/tests/graph/test_graph_definition_mutation.py

@@ -389,6 +389,22 @@ def test_add_wrong_type(init_cuda):
         node.succ.add(42)
 
 
+@pytest.mark.agent_authored(model="gpt-5.6")
+def test_discard_absent_invalid_value_is_noop(init_cuda):
+    graph = GraphDefinition()
+    owner = graph.empty()
+    neighbor = graph.empty()
+    destroyed = graph.empty()
+    owner.succ.add(neighbor)
+    destroyed.destroy()
+
+    foreign = GraphDefinition().empty()
+    for value in ("not a node", destroyed, foreign, graph._entry):
+        owner.succ.discard(value)
+
+    assert owner.succ == {neighbor}
+
+
 def test_cross_graph_edge(init_cuda):
     """Adding an edge to a node from a different graph raises ValueError."""
     g1 = GraphDefinition()

cuda_core/tests/test_stream.py

@@ -112,18 +112,24 @@ def test_per_thread_default_stream():
 
 
 @pytest.mark.agent_authored(model="gpt-5.6")
-@pytest.mark.parametrize("stream", [LEGACY_DEFAULT_STREAM, PER_THREAD_DEFAULT_STREAM])
-def test_default_stream_close_is_noop(stream, init_cuda):
-    """Closing a process-wide default-stream token must not invalidate it."""
+@pytest.mark.parametrize(
+    ("handle", "singleton"),
+    [
+        (driver.CU_STREAM_LEGACY, LEGACY_DEFAULT_STREAM),
+        (driver.CU_STREAM_PER_THREAD, PER_THREAD_DEFAULT_STREAM),
+    ],
+)
+def test_borrowed_default_stream_token_can_close(handle, singleton, init_cuda):
     Device().set_current()
-    handle = int(stream.handle)
+    stream = Stream.from_handle(int(handle))
+
+    assert stream is not singleton
+    assert not stream.is_closed
 
-    stream.close()
     stream.close()
 
-    assert not stream.is_closed
-    assert int(stream.handle) == handle
-    assert Stream_accept(stream) is stream
+    assert stream.is_closed
+    assert not singleton.is_closed
 
 
 @pytest.mark.agent_authored(model="gpt-5.6")