Remove the copy-based IPC event test, which is less efficient than the latch-based test.

Author: Andy-Jost

cuda_core/tests/memory_ipc/test_event_ipc.py

@@ -13,105 +13,17 @@
 
 ENABLE_LOGGING = False  # Set True for test debugging and development
 CHILD_TIMEOUT_SEC = 20
-NBYTES = 1024*1024*1024
-POOL_SIZE = NBYTES
-NCOPIES = 500
+NBYTES = 64
 
-class TestIpcEvent:
-    """Check the basic usage of IPC-enabled events."""
-
-    def test_main(self, ipc_device):
-        log = TimestampedLogger(prefix="parent: ", enabled=ENABLE_LOGGING)
-        device = ipc_device
-        stream1 = device.create_stream()
-        mr_options = DeviceMemoryResourceOptions(max_size=POOL_SIZE, ipc_enabled=True)
-        mr = DeviceMemoryResource(device, options=mr_options)
-
-        # Start the child process.
-        q_out, q_in = [mp.Queue() for _ in range(2)]
-        process = mp.Process(target=self.child_main, args=(log, q_out, q_in))
-        process.start()
-
-        # Prepare scratch buffers.
-        target = make_scratch_buffer(device, 0, NBYTES)
-        ones = make_scratch_buffer(device, 1, NBYTES)
-        twos = make_scratch_buffer(device, 2, NBYTES)
-
-        # Allocate the buffer and send it to the child.
-        buffer = mr.allocate(NBYTES, stream=stream1)
-        log("sending buffer")
-        q_out.put(buffer)
-
-        e_copy_start, e_copy_end = [device.create_event({"enable_timing": True}) for _ in range(2)]
-
-        # Stream 1:
-        stream1.record(e_copy_start)
-        log("begin enqueuing copies on stream1")
-        for i in range(NCOPIES):
-            buffer.copy_from(ones, stream=stream1)
-            if i % 100 == 0:
-                log(f"{i:>3}/{NCOPIES}")
-        stream1.record(e_copy_end)
-        log("done enqueuing copies")
-
-        ipc_event_options = EventOptions(ipc_enabled=True)
-        e = stream1.record(options=ipc_event_options)
-        log(f"recorded event ({hex(e.handle)})")
-        q_out.put(e)
-        log("sent event")
-
-        # Wait on the child.
-        log("waiting for copies")
-        e_copy_end.sync()
-        parent_done_copying_timestamp = time.time_ns()
-        log("done copying")
-        process.join()
-        assert process.exitcode == 0
-        log("done")
-
-        # Finish up.
-        target.copy_from(buffer, stream=stream1)
-        stream1.sync()
-        assert compare_equal_buffers(target, twos)
-        elapsed_ms = e_copy_end - e_copy_start
-        log(f"Elapsed time for {NCOPIES} copies: {int(elapsed_ms)} ms")
-
-        # Make sure the child finished enqueuing its work before the copies finished;
-        # otherwise the test has no meaning. If this trips, adjust NCOPIES and/or
-        # NBYTES.
-        child_done_enqueuing_timestamp = q_in.get(timeout=CHILD_TIMEOUT_SEC)
-        assert child_done_enqueuing_timestamp < parent_done_copying_timestamp
-
-
-    def child_main(self, log, q_in, q_out):
-        log.prefix = " child: "
-        log("ready")
-        device = Device()
-        device.set_current()
-        stream2 = device.create_stream()
-        twos = make_scratch_buffer(device, 2, NBYTES)
-        buffer = q_in.get(timeout=CHILD_TIMEOUT_SEC)
-        log("got buffer")
-        e = q_in.get(timeout=CHILD_TIMEOUT_SEC)
-        log(f"got event ({hex(e.handle)})")
-        stream2.wait(e)
-        log("enqueuing copy on stream2")
-        buffer.copy_from(twos, stream=stream2)
-        q_out.put(time.time_ns())  # Time when enqueuing finished
-        log("waiting")
-        stream2.sync()
-        log("done")
-
-class TestIpcEventWithLatch:
+class TestEventIpc:
     """Check the basic usage of IPC-enabled events with a latch kernel."""
 
     @skipif_need_cuda_headers  # libcu++
-    def test_main(self, ipc_device):
+    def test_main(self, ipc_device, ipc_memory_resource):
         log = TimestampedLogger(prefix="parent: ", enabled=ENABLE_LOGGING)
         device = ipc_device
+        mr = ipc_memory_resource
         stream1 = device.create_stream()
-        mr_options = DeviceMemoryResourceOptions(max_size=POOL_SIZE, ipc_enabled=True)
-        mr = DeviceMemoryResource(device, options=mr_options)
 
         # Start the child process.
         q_out, q_in = [mp.Queue() for _ in range(2)]