From 8acd798d8e71ccfc169bc295cc2dc14d5968c30c Mon Sep 17 00:00:00 2001
From: Alexander Droste <alexander.droste@protonmail.com>
Date: Fri, 23 Oct 2026 12:18:15 +0100
Subject: [PATCH] perf(cuda): reuse pinned buffer completion events

Use each pinned buffer owner event for inflight reclamation instead of allocating another completion event per transfer. Preserve the source-retention and failure-recovery guarantees of the parent change.

Original-commit: ff5e49b1f0
Signed-off-by: Alexander Droste <alexander.droste@protonmail.com>
---
 vortex-cuda/src/pinned.rs | 39 +++++++++++++++++----------------------
 1 file changed, 17 insertions(+), 22 deletions(-)

diff --git a/vortex-cuda/src/pinned.rs b/vortex-cuda/src/pinned.rs
index 56e04346c24..3ef8362d136 100644
--- a/vortex-cuda/src/pinned.rs
+++ b/vortex-cuda/src/pinned.rs
@@ -173,7 +173,6 @@ impl std::fmt::Debug for PinnedByteBufferPool {
 }
 
 struct InflightPinnedBuffer {
-    event: CudaEvent,
     buffer: PinnedByteBuffer,
 }
 
@@ -259,7 +258,7 @@ impl PinnedByteBufferPool {
             .map_err(|e| vortex_err!("Failed to bind CUDA context: {e}"))?;
         let mut idx = 0usize;
         while idx < inflight.len() {
-            if !inflight[idx].event.is_complete() {
+            if !inflight[idx].buffer.event.is_complete() {
                 idx += 1;
                 continue;
             }
@@ -404,29 +403,25 @@ impl PooledPinnedBuffer {
         stream: &VortexCudaStream,
         completion: Result<(), result::DriverError>,
     ) -> VortexResult<()> {
-        let event = match completion.and_then(|()| stream.record_event(None)) {
-            Ok(event) => event,
-            Err(error) => {
-                // A failed record can leave an old event behind after DMA was already submitted.
-                // Fence the actual stream before recycling, independently of event tracking.
-                if let Err(sync_error) = stream.synchronize() {
-                    // Completion is unknown: leaking is safer than freeing an active DMA source.
-                    let _leaked = ManuallyDrop::new(
-                        self.inner.take().vortex_expect("buffer already consumed"),
-                    );
-                    return Err(vortex_err!(
-                        "H2D transfer fence failed: {error}; stream synchronization failed: {sync_error}"
-                    ));
-                }
-                return Err(vortex_err!("H2D transfer fence failed: {error}"));
+        if let Err(error) = completion {
+            // A failed record can leave an old event behind after DMA was already submitted.
+            // Fence the actual stream before recycling, independently of event tracking.
+            if let Err(sync_error) = stream.synchronize() {
+                // Completion is unknown: leaking is safer than freeing an active DMA source.
+                let _leaked =
+                    ManuallyDrop::new(self.inner.take().vortex_expect("buffer already consumed"));
+                return Err(vortex_err!(
+                    "H2D transfer fence failed: {error}; stream synchronization failed: {sync_error}"
+                ));
             }
-        };
+            return Err(vortex_err!("H2D transfer fence failed: {error}"));
+        }
 
         let inner = self.inner.take().vortex_expect("buffer already consumed");
-        self.pool.inflight.lock().push(InflightPinnedBuffer {
-            event,
-            buffer: inner,
-        });
+        self.pool
+            .inflight
+            .lock()
+            .push(InflightPinnedBuffer { buffer: inner });
         Ok(())
     }
 }