Misc test fixes/thread-unsafe markers

Author: seberg

cuda_core/tests/graph/test_graph_node_update.py

@@ -14,7 +14,7 @@
 import pytest
 from helpers.graph_kernels import compile_common_kernels
 
-from cuda.core import LaunchConfig, LegacyPinnedMemoryResource
+from cuda.core import Device, LaunchConfig, LegacyPinnedMemoryResource
 from cuda.core._utils._weak_handles import weak_handle
 from cuda.core._utils.cuda_utils import CUDAError, driver, handle_return
 from cuda.core._utils.version import driver_version
@@ -619,7 +619,10 @@ def assert_exec_uses(graph, expected):
 def definition_update_case(request, init_cuda):
     if driver_version() < (12, 2, 0):
         pytest.skip("individual graph node updates require CUDA 12.2+")
-    return request.param(init_cuda)
+    factory = request.param
+    # pytest-run-parallel shares this fixture object across workers. Build the
+    # case at call time on Device() so each worker gets its own graph/node.
+    return lambda: factory(Device())
 
 
 @pytest.mark.agent_authored(model="gpt-5.6")
@@ -745,7 +748,7 @@ def test_memcpy_update_between_host_and_device(init_cuda, device_operand):
 def test_definition_node_update_changes_future_instantiations(
     definition_update_case,
 ):
-    case = definition_update_case
+    case = definition_update_case()
     assert case.original != case.replacement
     old_graph = case.graph_def.instantiate()
 
@@ -762,7 +765,7 @@ def test_definition_node_update_changes_future_instantiations(
 def test_destroyed_definition_node_rejects_update(
     definition_update_case,
 ):
-    case = definition_update_case
+    case = definition_update_case()
     case.node.destroy()
 
     assert not case.node.is_valid
@@ -777,7 +780,7 @@ def test_destroyed_definition_node_rejects_update(
 def test_failed_definition_node_update_preserves_state(
     definition_update_case,
 ):
-    case = definition_update_case
+    case = definition_update_case()
 
     assert case.invalid_update is not None
     assert case.invalid_exception is not None
@@ -793,17 +796,18 @@ def test_failed_definition_node_update_preserves_state(
 def test_definition_node_update_rejects_wrong_type(
     definition_update_case,
 ):
-    if definition_update_case.invalid_argument_update is None:
+    case = definition_update_case()
+    if case.invalid_argument_update is None:
         pytest.skip("update method has no typed positional argument")
     with pytest.raises(TypeError):
-        definition_update_case.invalid_argument_update()
+        case.invalid_argument_update()
 
 
 @pytest.mark.agent_authored(model="gpt-5.6")
 def test_executable_node_update_changes_existing_exec(
     definition_update_case,
 ):
-    case = definition_update_case
+    case = definition_update_case()
     graph = case.graph_def.instantiate()
 
     _update_executable_case(graph, case)
@@ -974,6 +978,7 @@ def test_rejected_executable_update_rolls_back_owners(init_cuda):
     assert ctypes.c_int.from_address(int(active.handle)).value == 1
 
 
+@pytest.mark.thread_unsafe(reason="deferred cleanup on main thread which would wait")
 @pytest.mark.agent_authored(model="gpt-5.6")
 def test_whole_update_replaces_executable_attachment_accumulator(init_cuda):
     if driver_version() < (12, 2, 0):
@@ -1132,6 +1137,7 @@ def second():
     _wait_until(lambda: first_weak() is None and second_weak() is None)
 
 
+@pytest.mark.thread_unsafe(reason="deferred cleanup on main thread which would wait")
 @pytest.mark.agent_authored(model="claude-opus-5")
 def test_child_graph_update_transfers_source_owners_to_executable(init_cuda):
     if driver_version() < (12, 2, 0):

cuda_core/tests/memory/test_copy_batch.py

@@ -212,6 +212,7 @@ def test_batch_matches_sequential_d2d(self, copy_batch_device, device_bufs, copy
 class TestCopyBatchStreamSemantics:
     """Where the batch sits in stream order, and what it cannot be part of."""
 
+    @pytest.mark.thread_unsafe(reason="shared copy_stream and buffers must not interleave")
     @pytest.mark.agent_authored(model="Claude Opus 5")
     def test_ordered_between_prior_and_later_stream_work(self, device_bufs, copy_stream):
         """The batch must observe prior stream work and precede later work.

cuda_core/tests/memory/test_copy_single_options.py

@@ -369,7 +369,7 @@ def test_options_copy_from_data_correct(single_copy_device, single_copy_stream,
 
 
 @pytest.mark.agent_authored(model="Claude Sonnet 4.6")
-def test_options_copy_to_rejected_under_graph_capture(single_copy_stream, pinned_mr):
+def test_options_copy_to_rejected_under_graph_capture(single_copy_device, pinned_mr):
     """copy_to with options raises TypeError when the stream is capturing,
     matching copy_batch. Use GraphNode.memcpy to build attributed copies
     into a graph instead; options=None keeps working under capture as it
@@ -378,57 +378,63 @@ def test_options_copy_to_rejected_under_graph_capture(single_copy_stream, pinned
     src = pinned_mr.allocate(SIZE)
     dst = pinned_mr.allocate(SIZE)
     opts = CopyOptions(src_access_order=MemcpySrcAccessOrder.ANY)
+    stream = single_copy_device.create_stream()
 
-    gb = single_copy_stream.create_graph_builder().begin_building()
+    gb = stream.create_graph_builder().begin_building()
     try:
         with pytest.raises(TypeError, match="graph capture"):
             src.copy_to(dst, stream=gb, options=opts)
     finally:
         gb.end_building()
         gb.close()
+        stream.close()
 
     src.close()
     dst.close()
 
 
 @pytest.mark.agent_authored(model="Claude Sonnet 4.6")
-def test_options_copy_from_rejected_under_graph_capture(single_copy_stream, pinned_mr):
+def test_options_copy_from_rejected_under_graph_capture(single_copy_device, pinned_mr):
     """Same as the copy_to variant, exercising copy_from instead."""
     src = pinned_mr.allocate(SIZE)
     dst = pinned_mr.allocate(SIZE)
     opts = CopyOptions(src_access_order=MemcpySrcAccessOrder.STREAM)
+    stream = single_copy_device.create_stream()
 
-    gb = single_copy_stream.create_graph_builder().begin_building()
+    gb = stream.create_graph_builder().begin_building()
     try:
         with pytest.raises(TypeError, match="graph capture"):
             dst.copy_from(src, stream=gb, options=opts)
     finally:
         gb.end_building()
         gb.close()
+        stream.close()
 
     src.close()
     dst.close()
 
 
 @pytest.mark.agent_authored(model="Claude Sonnet 4.6")
-def test_options_none_copy_to_still_works_under_graph_capture(single_copy_stream, pinned_mr):
+def test_options_none_copy_to_still_works_under_graph_capture(single_copy_device, pinned_mr):
     """options=None never touches the attributes path, so copy_to keeps
     working under graph capture exactly as it did before options existed.
     """
     src = pinned_mr.allocate(SIZE)
     set_buffer(src, 0xBB)
     dst = pinned_mr.allocate(SIZE)
+    stream = single_copy_device.create_stream()
 
-    gb = single_copy_stream.create_graph_builder().begin_building()
+    gb = stream.create_graph_builder().begin_building()
     src.copy_to(dst, stream=gb)
     graph = gb.end_building().complete()
-    graph.launch(single_copy_stream)
-    single_copy_stream.sync()
+    graph.launch(stream)
+    stream.sync()
 
     assert compare_equal_buffers(src, dst)
 
     src.close()
     dst.close()
+    stream.close()
 
 
 @pytest.mark.agent_authored(model="Claude Sonnet 5")

cuda_core/tests/test_object_protocols.py

@@ -751,30 +751,31 @@ def sample_object_b(request):
 
 
 @pytest.mark.agent_authored(model="gpt-5.6")
-@pytest.mark.parametrize("fixture_name", CLOSEABLE_TYPES)
-def test_closeable_object_state_and_safe_inspection(fixture_name, request):
+@pytest.mark.thread_unsafe(reason="closes a fixture object shared between threads")
+@pytest.mark.parametrize("sample_object", CLOSEABLE_TYPES, indirect=True)
+def test_closeable_object_state_and_safe_inspection(sample_object):
     """Closing is idempotent, updates named state, and leaves inspection safe."""
-    obj = request.getfixturevalue(fixture_name)
-    assert not obj.is_closed
+    assert not sample_object.is_closed
 
-    obj.close()
-    assert obj.is_closed
-    assert bool(obj) is True  # Preserve backward-compatible truthiness after close.
-    repr(obj)
-    if hasattr(obj, "handle"):
-        _ = obj.handle
+    sample_object.close()
+    assert sample_object.is_closed
+    assert bool(sample_object) is True  # Preserve backward-compatible truthiness after close.
+    repr(sample_object)
+    if hasattr(sample_object, "handle"):
+        _ = sample_object.handle
 
-    obj.close()
-    assert obj.is_closed
+    sample_object.close()
+    assert sample_object.is_closed
 
 
 @pytest.mark.agent_authored(model="gpt-5.6")
-def test_graph_object_validity_uses_named_state(sample_graphdef):
+def test_graph_object_validity_uses_named_state(init_cuda):
     """Graph objects remain truthy when their named validity becomes false."""
-    assert sample_graphdef.is_valid
-    assert sample_graphdef._entry.is_valid
+    graph_def = GraphDefinition()
+    assert graph_def.is_valid
+    assert graph_def._entry.is_valid
 
-    node = sample_graphdef.empty()
+    node = graph_def.empty()
     assert node.is_valid
     node.destroy()
     assert not node.is_valid