Apply CUDA event RAII wrapper to cuDF whenever possible

cpp/CMakeLists.txt

@@ -659,6 +659,7 @@ add_library(
   src/unary/nan_ops.cu
   src/unary/null_ops.cu
   src/utilities/cuda.cpp
+  src/utilities/cuda_event.cpp
   src/utilities/cuda_memcpy.cu
   src/utilities/default_stream.cpp
   src/utilities/host_memory.cpp

cpp/include/cudf/utilities/cuda_event.hpp

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2019-2024, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cudf/utilities/export.hpp>
+
+#include <cuda_runtime_api.h>
+
+namespace CUDF_EXPORT cudf {
+
+namespace detail {
+/**
+ * @brief RAII struct to wrap a cuda event and ensure its proper destruction.
+ */
+struct cuda_event {
+  cuda_event();
+  virtual ~cuda_event();
+
+  // Moveable but not copyable.
+  cuda_event(const cuda_event&)            = delete;
+  cuda_event& operator=(const cuda_event&) = delete;
+
+  cuda_event(cuda_event&&)            = default;
+  cuda_event& operator=(cuda_event&&) = default;
+
+  operator cudaEvent_t() const;
+
+ private:
+  cudaEvent_t e_;
+};
+}  // namespace detail
+
+}  // namespace CUDF_EXPORT cudf

cpp/src/interop/to_arrow_device.cu

@@ -30,6 +30,7 @@
 #include <cudf/strings/strings_column_view.hpp>
 #include <cudf/table/table_view.hpp>
 #include <cudf/types.hpp>
+#include <cudf/utilities/cuda_event.hpp>
 #include <cudf/utilities/memory_resource.hpp>
 #include <cudf/utilities/traits.hpp>
 #include <cudf/utilities/type_dispatcher.hpp>
@@ -559,13 +560,12 @@ int dispatch_to_arrow_device_view::operator()<cudf::dictionary32>(ArrowArray* ou
 
 struct ArrowDeviceArrayPrivateData {
   ArrowArray parent;
-  cudaEvent_t sync_event;
+  cudf::detail::cuda_event sync_event;
 };
 
 void ArrowDeviceArrayRelease(ArrowArray* array)
 {
   auto private_data = reinterpret_cast<ArrowDeviceArrayPrivateData*>(array->private_data);
-  RMM_ASSERT_CUDA_SUCCESS(cudaEventDestroy(private_data->sync_event));
   ArrowArrayRelease(&private_data->parent);
   delete private_data;
   array->release = nullptr;
@@ -578,7 +578,6 @@ unique_device_array_t create_device_array(nanoarrow::UniqueArray&& out,
     ArrowArrayFinishBuilding(out.get(), NANOARROW_VALIDATION_LEVEL_MINIMAL, nullptr));
 
   auto private_data = std::make_unique<detail::ArrowDeviceArrayPrivateData>();
-  CUDF_CUDA_TRY(cudaEventCreate(&private_data->sync_event));
   CUDF_CUDA_TRY(cudaEventRecord(private_data->sync_event, stream.value()));
 
   ArrowArrayMove(out.get(), &private_data->parent);

cpp/src/io/text/bgzip_data_chunk_source.cu

@@ -24,6 +24,7 @@
 #include <cudf/io/config_utils.hpp>
 #include <cudf/io/text/data_chunk_source_factories.hpp>
 #include <cudf/io/text/detail/bgzip_utils.hpp>
+#include <cudf/utilities/cuda_event.hpp>
 #include <cudf/utilities/default_stream.hpp>
 #include <cudf/utilities/error.hpp>
 
@@ -84,7 +85,7 @@ class bgzip_data_chunk_reader : public data_chunk_reader {
     static constexpr std::size_t default_offset_alloc =
       1 << 16;  // 64k offset allocation, resized on demand
 
-    cudaEvent_t event;
+    cudf::detail::cuda_event event;
     cudf::detail::host_vector<char> h_compressed_blocks;
     cudf::detail::host_vector<std::size_t> h_compressed_offsets;
     cudf::detail::host_vector<std::size_t> h_decompressed_offsets;
@@ -115,7 +116,6 @@ class bgzip_data_chunk_reader : public data_chunk_reader {
         d_decompressed_spans(0, init_stream),
         d_decompression_results(0, init_stream)
     {
-      CUDF_CUDA_TRY(cudaEventCreate(&event));
       h_compressed_blocks.reserve(default_buffer_alloc);
       h_compressed_offsets.reserve(default_offset_alloc);
       h_compressed_offsets.push_back(0);

cpp/src/io/text/data_chunk_source_factories.cpp

@@ -21,6 +21,7 @@
 #include <cudf/detail/utilities/host_vector.hpp>
 #include <cudf/detail/utilities/vector_factories.hpp>
 #include <cudf/io/text/data_chunk_source_factories.hpp>
+#include <cudf/utilities/cuda_event.hpp>
 
 #include <rmm/device_buffer.hpp>
 
@@ -33,15 +34,12 @@ namespace cudf::io::text {
 namespace {
 
 struct host_ticket {
-  cudaEvent_t event{};  // tracks the completion of the last device-to-host copy.
+  cudf::detail::cuda_event event;  // tracks the completion of the last device-to-host copy.
   cudf::detail::host_vector<char> buffer;
 
   host_ticket() : buffer{cudf::detail::make_pinned_vector_sync<char>(0, cudf::get_default_stream())}
   {
-    cudaEventCreate(&event);
   }
-
-  ~host_ticket() { cudaEventDestroy(event); }
 };
 
 /**

cpp/src/io/text/multibyte_split.cu

@@ -32,6 +32,7 @@
 #include <cudf/scalar/scalar.hpp>
 #include <cudf/strings/detail/strings_column_factories.cuh>
 #include <cudf/strings/detail/utilities.hpp>
+#include <cudf/utilities/cuda_event.hpp>
 #include <cudf/utilities/default_stream.hpp>
 #include <cudf/utilities/memory_resource.hpp>
 #include <cudf/utilities/span.hpp>
@@ -383,8 +384,7 @@ std::unique_ptr<cudf::column> multibyte_split(cudf::io::text::data_chunk_source
 
     auto streams = cudf::detail::fork_streams(stream, concurrency);
 
-    cudaEvent_t last_launch_event;
-    CUDF_CUDA_TRY(cudaEventCreate(&last_launch_event));
+    cudf::detail::cuda_event last_launch_event;
 
     auto& read_stream      = streams[0];
     auto& scan_stream      = streams[1];
@@ -499,8 +499,6 @@ std::unique_ptr<cudf::column> multibyte_split(cudf::io::text::data_chunk_source
       chunk = std::move(next_chunk);
     }
 
-    CUDF_CUDA_TRY(cudaEventDestroy(last_launch_event));
-
     cudf::detail::join_streams(streams, stream);
 
     auto chars          = char_storage.gather(stream, mr);

cpp/src/utilities/cuda_event.cpp

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2019-2024, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <cudf/utilities/cuda_event.hpp>
+#include <cudf/utilities/error.hpp>
+
+#include <rmm/detail/error.hpp>
+
+namespace cudf::detail {
+
+cuda_event::cuda_event() { CUDF_CUDA_TRY(cudaEventCreateWithFlags(&e_, cudaEventDisableTiming)); }
+
+cuda_event::~cuda_event() { RMM_ASSERT_CUDA_SUCCESS(cudaEventDestroy(e_)); }
+
+cuda_event::operator cudaEvent_t() const { return e_; }
+
+}  // namespace cudf::detail

cpp/src/utilities/stream_pool.cpp

@@ -16,6 +16,7 @@
 
 #include <cudf/detail/utilities/logger.hpp>
 #include <cudf/detail/utilities/stream_pool.hpp>
+#include <cudf/utilities/cuda_event.hpp>
 #include <cudf/utilities/default_stream.hpp>
 #include <cudf/utilities/error.hpp>
 
@@ -125,26 +126,6 @@ rmm::cuda_device_id get_current_cuda_device()
   return rmm::cuda_device_id{device_id};
 }
 
-/**
- * @brief RAII struct to wrap a cuda event and ensure its proper destruction.
- */
-struct cuda_event {
-  cuda_event() { CUDF_CUDA_TRY(cudaEventCreateWithFlags(&e_, cudaEventDisableTiming)); }
-  virtual ~cuda_event() { CUDF_ASSERT_CUDA_SUCCESS(cudaEventDestroy(e_)); }
-
-  // Moveable but not copyable.
-  cuda_event(const cuda_event&)            = delete;
-  cuda_event& operator=(const cuda_event&) = delete;
-
-  cuda_event(cuda_event&&)            = default;
-  cuda_event& operator=(cuda_event&&) = default;
-
-  operator cudaEvent_t() { return e_; }
-
- private:
-  cudaEvent_t e_;
-};
-
 /**
  * @brief Returns a cudaEvent_t for the current thread.
  *