test(cuda.core): rename PDL overlap tests to emphasize same-stream

Both direct and graph-capture paths are same-stream; update names and docs accordingly.

Author: lijinf2

cuda_core/tests/graph/test_graph_builder.py

@@ -776,11 +776,7 @@ def _assert_programmatic_dependency_edge(graph_definition):
 
 @skipif_need_cuda_headers
 @requires_module(np, "2.2.5", reason="need numpy 2.2.5+ (numpy GH #28632)")
-def test_pdl_primary_secondary_overlap_graph_capture(init_cuda):
-    """Primary + secondary PDL via GraphBuilder stream capture can overlap on Hopper+.
-
-    Same kernels / overlap protocol as test_pdl_primary_secondary_overlap_same_stream,
-    but launches are captured into a CUDA graph (see CUDA Programming Guide,
-    Programmatic Dependent Launch). Overlap is opportunistic → miss is xfail.
+def test_pdl_same_stream_primary_secondary_overlap_via_graph(init_cuda):
+    """Same-stream PDL overlap via GraphBuilder stream capture on Hopper+.
     """
     run_pdl_overlap_check(Device(), via_graph=True)

cuda_core/tests/helpers/pdl_kernels.py

@@ -53,15 +53,16 @@ def compile_pdl_overlap_kernels(device):
 
 
 def run_pdl_overlap_check(device, *, via_graph: bool = False):
-    """Run the shared primary/secondary PDL overlap protocol.
+    """Run the shared same-stream primary/secondary PDL overlap protocol.
 
-    Asserts no overlap without ``programmatic_stream_serialization``, then retries
-    a few times with it enabled. Overlap is opportunistic → miss is xfail.
+    Both paths launch primary then secondary on one stream. Asserts no overlap
+    without ``programmatic_stream_serialization``, then retries a few times with
+    it enabled. Overlap is opportunistic → miss is xfail.
 
     Args:
         device: Current CUDA device (compute capability >= 9.0 required).
-        via_graph: If True, capture launches into a CUDA graph and launch the
-            graph; otherwise launch kernels directly on the stream.
+        via_graph: If True, stream-capture the same-stream launches into a CUDA
+            graph and launch that graph; otherwise launch kernels directly.
     """
     if device.compute_capability < (9, 0):
         pytest.skip("Programmatic Dependent Launch requires compute capability >= 9.0")
@@ -97,7 +98,7 @@ def _run(secondary_launch_cfg: LaunchConfig) -> int:
             stream.sync()
         return int(overlapped[0])
 
-    path = "graph-capture" if via_graph else "same-stream"
+    path = "same-stream (graph)" if via_graph else "same-stream"
     assert _run(secondary_serial_cfg) == 0, (
         f"Expected no overlap when programmatic_stream_serialization is False ({path})"
     )

cuda_core/tests/test_launcher.py

@@ -205,13 +205,13 @@ def test_to_native_launch_config_pdl():
 
 @skipif_need_cuda_headers
 @requires_module(np, "2.2.5", reason="need numpy 2.2.5+ (numpy GH #28632)")
-def test_pdl_primary_secondary_overlap_same_stream(init_cuda):
-    """Primary + secondary PDL launch on one stream can overlap on Hopper+.
+def test_pdl_same_stream_primary_secondary_overlap(init_cuda):
+    """Same-stream primary + secondary PDL launch can overlap on Hopper+.
 
     Secondary is launched with ``programmatic_stream_serialization=True``. After
     the primary triggers completion, it spins until it observes a flag written by
     the secondary's independent preamble — proving both grids were resident at
-    once. Without PDL, the secondary cannot start until the primary exits.
+    once. Without PDL, same-stream kernels stay serialized.
 
     Note concurrency is opportunistic, so a missing overlap execution is reported as
     an expected failure.