Cleanup hostdevice_vector and add more APIs

cpp/src/io/orc/reader_impl_preprocess.cu

@@ -180,12 +180,11 @@ rmm::device_buffer decompress_stripe_data(
   rmm::cuda_stream_view stream)
 {
   // Parse the columns' compressed info
-  cudf::detail::hostdevice_vector<gpu::CompressedStreamInfo> compinfo(
-    0, stream_info.size(), stream);
-  for (auto const& info : stream_info) {
-    compinfo.push_back(gpu::CompressedStreamInfo(
-      static_cast<uint8_t const*>(stripe_data[info.stripe_idx].data()) + info.dst_pos,
-      info.length));
+  cudf::detail::hostdevice_vector<gpu::CompressedStreamInfo> compinfo(stream_info.size(), stream);
+  for (std::size_t idx = 0; idx < stream_info.size(); ++idx) {
+    auto const& info = stream_info[idx];
+    compinfo[idx]    = gpu::CompressedStreamInfo(
+      static_cast<uint8_t const*>(stripe_data[info.stripe_idx].data()) + info.dst_pos, info.length);
   }
   compinfo.host_to_device_async(stream);
 

cpp/src/io/parquet/reader_impl_chunking.cu

@@ -1392,7 +1392,7 @@ void reader::impl::setup_next_subpass(bool uses_custom_row_bounds)
   // copy the appropriate subset of pages from each column and store the mapping back to the source
   // (pass) pages
   else {
-    subpass.page_buf = cudf::detail::hostdevice_vector<PageInfo>(total_pages, total_pages, _stream);
+    subpass.page_buf       = cudf::detail::hostdevice_vector<PageInfo>(total_pages, _stream);
     subpass.page_src_index = rmm::device_uvector<size_t>(total_pages, _stream);
     auto iter              = thrust::make_counting_iterator(0);
     rmm::device_uvector<size_t> dst_offsets(num_columns + 1, _stream);

cpp/src/io/parquet/reader_impl_preprocess.cu

@@ -514,8 +514,7 @@ cudf::detail::hostdevice_vector<PageInfo> sort_pages(device_span<PageInfo const>
                              page_keys.end(),
                              sort_indices.begin(),
                              thrust::less<int>());
-  auto pass_pages =
-    cudf::detail::hostdevice_vector<PageInfo>(unsorted_pages.size(), unsorted_pages.size(), stream);
+  auto pass_pages = cudf::detail::hostdevice_vector<PageInfo>(unsorted_pages.size(), stream);
   thrust::transform(
     rmm::exec_policy_nosync(stream),
     sort_indices.begin(),

cpp/src/io/utilities/hostdevice_vector.hpp

@@ -26,13 +26,9 @@
 #include <cudf/utilities/span.hpp>
 
 #include <rmm/cuda_stream_view.hpp>
-#include <rmm/device_buffer.hpp>
+#include <rmm/device_uvector.hpp>
 #include <rmm/mr/host/host_memory_resource.hpp>
 
-#include <thrust/host_vector.h>
-
-#include <variant>
-
 namespace cudf::detail {
 
 /**
@@ -52,31 +48,12 @@ class hostdevice_vector {
   hostdevice_vector() : hostdevice_vector(0, cudf::get_default_stream()) {}
 
   explicit hostdevice_vector(size_t size, rmm::cuda_stream_view stream)
-    : hostdevice_vector(size, size, stream)
-  {
-  }
-
-  explicit hostdevice_vector(size_t initial_size, size_t max_size, rmm::cuda_stream_view stream)
-    : h_data({cudf::io::get_host_memory_resource(), stream}), d_data(0, stream)
-  {
-    CUDF_EXPECTS(initial_size <= max_size, "initial_size cannot be larger than max_size");
-
-    h_data.reserve(max_size);
-    h_data.resize(initial_size);
-
-    current_size = initial_size;
-    d_data.resize(max_size, stream);
-  }
-
-  void push_back(T const& data)
+    : h_data{size, rmm_host_allocator<T>{cudf::io::get_host_memory_resource(), stream}},
+      d_data{size, stream}
   {
-    CUDF_EXPECTS(size() < capacity(),
-                 "Cannot insert data into hostdevice_vector because capacity has been exceeded.");
-    h_data[current_size++] = data;
   }
 
-  [[nodiscard]] size_t capacity() const noexcept { return d_data.size(); }
-  [[nodiscard]] size_t size() const noexcept { return current_size; }
+  [[nodiscard]] size_t size() const noexcept { return h_data.size(); }
   [[nodiscard]] size_t size_bytes() const noexcept { return sizeof(T) * size(); }
   [[nodiscard]] bool empty() const noexcept { return size() == 0; }
 
@@ -92,6 +69,12 @@ class hostdevice_vector {
   [[nodiscard]] T* end() { return host_ptr(size()); }
   [[nodiscard]] T const* end() const { return host_ptr(size()); }
 
+  [[nodiscard]] T& front() { return h_data.front(); }
+  [[nodiscard]] T const& front() const { return front(); }
+
+  [[nodiscard]] T& back() { return h_data.back(); }
+  [[nodiscard]] T const& back() const { return back(); }
+
   [[nodiscard]] T* device_ptr(size_t offset = 0) { return d_data.data() + offset; }
   [[nodiscard]] T const* device_ptr(size_t offset = 0) const { return d_data.data() + offset; }
 
@@ -175,7 +158,6 @@ class hostdevice_vector {
 
  private:
   cudf::detail::rmm_host_vector<T> h_data;
-  size_t current_size = 0;
   rmm::device_uvector<T> d_data;
 };