diff --git a/cpp/include/cudf/detail/groupby.hpp b/cpp/include/cudf/detail/groupby.hpp
index ce5fdb92bd1..36a76c7b6de 100644
--- a/cpp/include/cudf/detail/groupby.hpp
+++ b/cpp/include/cudf/detail/groupby.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019-2020, NVIDIA CORPORATION.
+ * Copyright (c) 2019-2021, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,6 +16,7 @@
 
 #include <cudf/groupby.hpp>
 #include <cudf/types.hpp>
+#include <cudf/utilities/span.hpp>
 
 #include <rmm/cuda_stream_view.hpp>
 
@@ -36,12 +37,12 @@ namespace hash {
  * @return true A hash-based groupby can be used
  * @return false A hash-based groupby cannot be used
  */
-bool can_use_hash_groupby(table_view const& keys, std::vector<aggregation_request> const& requests);
+bool can_use_hash_groupby(table_view const& keys, host_span<aggregation_request const> requests);
 
 // Hash-based groupby
 std::pair<std::unique_ptr<table>, std::vector<aggregation_result>> groupby(
   table_view const& keys,
-  std::vector<aggregation_request> const& requests,
+  host_span<aggregation_request const> requests,
   null_policy include_null_keys,
   rmm::cuda_stream_view stream,
   rmm::mr::device_memory_resource* mr);
diff --git a/cpp/include/cudf/groupby.hpp b/cpp/include/cudf/groupby.hpp
index 1dfacd53e0d..19f87873873 100644
--- a/cpp/include/cudf/groupby.hpp
+++ b/cpp/include/cudf/groupby.hpp
@@ -19,6 +19,7 @@
 #include <cudf/aggregation.hpp>
 #include <cudf/table/table_view.hpp>
 #include <cudf/types.hpp>
+#include <cudf/utilities/span.hpp>
 
 #include <rmm/cuda_stream_view.hpp>
 
@@ -163,7 +164,7 @@ class groupby {
    * specified in `requests`.
    */
   std::pair<std::unique_ptr<table>, std::vector<aggregation_result>> aggregate(
-    std::vector<aggregation_request> const& requests,
+    host_span<aggregation_request const> requests,
     rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
   /**
@@ -218,7 +219,7 @@ class groupby {
    * specified in `requests`.
    */
   std::pair<std::unique_ptr<table>, std::vector<aggregation_result>> scan(
-    std::vector<aggregation_request> const& requests,
+    host_span<aggregation_request const> requests,
     rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
   /**
@@ -277,18 +278,18 @@ class groupby {
    * aggregation requests.
    */
   std::pair<std::unique_ptr<table>, std::vector<aggregation_result>> dispatch_aggregation(
-    std::vector<aggregation_request> const& requests,
+    host_span<aggregation_request const> requests,
     rmm::cuda_stream_view stream,
     rmm::mr::device_memory_resource* mr);
 
   // Sort-based groupby
   std::pair<std::unique_ptr<table>, std::vector<aggregation_result>> sort_aggregate(
-    std::vector<aggregation_request> const& requests,
+    host_span<aggregation_request const> requests,
     rmm::cuda_stream_view stream,
     rmm::mr::device_memory_resource* mr);
 
   std::pair<std::unique_ptr<table>, std::vector<aggregation_result>> sort_scan(
-    std::vector<aggregation_request> const& requests,
+    host_span<aggregation_request const> requests,
     rmm::cuda_stream_view stream,
     rmm::mr::device_memory_resource* mr);
 };
diff --git a/cpp/src/groupby/common/utils.hpp b/cpp/src/groupby/common/utils.hpp
index 40bc96c6103..e8d5c60f81a 100644
--- a/cpp/src/groupby/common/utils.hpp
+++ b/cpp/src/groupby/common/utils.hpp
@@ -18,13 +18,14 @@
 
 #include <cudf/detail/aggregation/result_cache.hpp>
 #include <cudf/detail/groupby.hpp>
+#include <cudf/utilities/span.hpp>
 #include <vector>
 
 namespace cudf {
 namespace groupby {
 namespace detail {
 inline std::vector<aggregation_result> extract_results(
-  std::vector<aggregation_request> const& requests, cudf::detail::result_cache& cache)
+  host_span<aggregation_request const> requests, cudf::detail::result_cache& cache)
 {
   std::vector<aggregation_result> results(requests.size());
 
diff --git a/cpp/src/groupby/groupby.cu b/cpp/src/groupby/groupby.cu
index cdd8ceb0a6c..0312d17a37c 100644
--- a/cpp/src/groupby/groupby.cu
+++ b/cpp/src/groupby/groupby.cu
@@ -55,7 +55,7 @@ groupby::groupby(table_view const& keys,
 
 // Select hash vs. sort groupby implementation
 std::pair<std::unique_ptr<table>, std::vector<aggregation_result>> groupby::dispatch_aggregation(
-  std::vector<aggregation_request> const& requests,
+  host_span<aggregation_request const> requests,
   rmm::cuda_stream_view stream,
   rmm::mr::device_memory_resource* mr)
 {
@@ -79,7 +79,7 @@ groupby::~groupby() = default;
 
 namespace {
 /// Make an empty table with appropriate types for requested aggs
-auto empty_results(std::vector<aggregation_request> const& requests)
+auto empty_results(host_span<aggregation_request const> requests)
 {
   std::vector<aggregation_result> empty_results;
 
@@ -102,7 +102,7 @@ auto empty_results(std::vector<aggregation_request> const& requests)
 }
 
 /// Verifies the agg requested on the request's values is valid
-void verify_valid_requests(std::vector<aggregation_request> const& requests)
+void verify_valid_requests(host_span<aggregation_request const> requests)
 {
   CUDF_EXPECTS(
     std::all_of(
@@ -143,7 +143,7 @@ void verify_valid_requests(std::vector<aggregation_request> const& requests)
 
 // Compute aggregation requests
 std::pair<std::unique_ptr<table>, std::vector<aggregation_result>> groupby::aggregate(
-  std::vector<aggregation_request> const& requests, rmm::mr::device_memory_resource* mr)
+  host_span<aggregation_request const> requests, rmm::mr::device_memory_resource* mr)
 {
   CUDF_FUNC_RANGE();
   CUDF_EXPECTS(
@@ -161,7 +161,7 @@ std::pair<std::unique_ptr<table>, std::vector<aggregation_result>> groupby::aggr
 
 // Compute scan requests
 std::pair<std::unique_ptr<table>, std::vector<aggregation_result>> groupby::scan(
-  std::vector<aggregation_request> const& requests, rmm::mr::device_memory_resource* mr)
+  host_span<aggregation_request const> requests, rmm::mr::device_memory_resource* mr)
 {
   CUDF_FUNC_RANGE();
   CUDF_EXPECTS(
diff --git a/cpp/src/groupby/hash/groupby.cu b/cpp/src/groupby/hash/groupby.cu
index c54ecee9ccb..38aacbe59a7 100644
--- a/cpp/src/groupby/hash/groupby.cu
+++ b/cpp/src/groupby/hash/groupby.cu
@@ -110,7 +110,7 @@ class hash_compound_agg_finalizer final : public cudf::detail::aggregation_final
   data_type result_type;
   cudf::detail::result_cache* sparse_results;
   cudf::detail::result_cache* dense_results;
-  rmm::device_vector<size_type> const& gather_map;
+  device_span<size_type const> gather_map;
   size_type const map_size;
   Map const& map;
   bitmask_type const* __restrict__ row_bitmask;
@@ -122,7 +122,7 @@ class hash_compound_agg_finalizer final : public cudf::detail::aggregation_final
                               column_view col,
                               cudf::detail::result_cache* sparse_results,
                               cudf::detail::result_cache* dense_results,
-                              rmm::device_vector<size_type> const& gather_map,
+                              device_span<size_type const> gather_map,
                               size_type map_size,
                               Map const& map,
                               bitmask_type const* row_bitmask,
@@ -272,7 +272,7 @@ class hash_compound_agg_finalizer final : public cudf::detail::aggregation_final
 
 // flatten aggs to filter in single pass aggs
 std::tuple<table_view, std::vector<aggregation::Kind>, std::vector<size_t>>
-flatten_single_pass_aggs(std::vector<aggregation_request> const& requests)
+flatten_single_pass_aggs(host_span<aggregation_request const> requests)
 {
   std::vector<column_view> columns;
   std::vector<aggregation::Kind> agg_kinds;
@@ -311,10 +311,10 @@ flatten_single_pass_aggs(std::vector<aggregation_request> const& requests)
  */
 template <typename Map>
 void sparse_to_dense_results(table_view const& keys,
-                             std::vector<aggregation_request> const& requests,
+                             host_span<aggregation_request const> requests,
                              cudf::detail::result_cache* sparse_results,
                              cudf::detail::result_cache* dense_results,
-                             rmm::device_vector<size_type> const& gather_map,
+                             device_span<size_type const> gather_map,
                              size_type map_size,
                              Map const& map,
                              bool keys_have_nulls,
@@ -421,7 +421,7 @@ auto create_sparse_results_table(table_view const& flattened_values,
  */
 template <bool keys_have_nulls, typename Map>
 void compute_single_pass_aggs(table_view const& keys,
-                              std::vector<aggregation_request> const& requests,
+                              host_span<aggregation_request const> requests,
                               cudf::detail::result_cache* sparse_results,
                               Map& map,
                               null_policy include_null_keys,
@@ -469,10 +469,10 @@ void compute_single_pass_aggs(table_view const& keys,
  * `map`.
  */
 template <typename Map>
-std::pair<rmm::device_vector<size_type>, size_type> extract_populated_keys(
+std::pair<rmm::device_uvector<size_type>, size_type> extract_populated_keys(
   Map map, size_type num_keys, rmm::cuda_stream_view stream)
 {
-  rmm::device_vector<size_type> populated_keys(num_keys);
+  rmm::device_uvector<size_type> populated_keys(num_keys, stream);
 
   auto get_key = [] __device__(auto const& element) {
     size_type key, value;
@@ -520,7 +520,7 @@ std::pair<rmm::device_vector<size_type>, size_type> extract_populated_keys(
  */
 template <bool keys_have_nulls>
 std::unique_ptr<table> groupby_null_templated(table_view const& keys,
-                                              std::vector<aggregation_request> const& requests,
+                                              host_span<aggregation_request const> requests,
                                               cudf::detail::result_cache* cache,
                                               null_policy include_null_keys,
                                               rmm::cuda_stream_view stream,
@@ -539,9 +539,9 @@ std::unique_ptr<table> groupby_null_templated(table_view const& keys,
 
   // Extract the populated indices from the hash map and create a gather map.
   // Gathering using this map from sparse results will give dense results.
-  rmm::device_vector<size_type> gather_map;
-  size_type map_size;
-  std::tie(gather_map, map_size) = extract_populated_keys(*map, keys.num_rows(), stream);
+  auto map_and_size = extract_populated_keys(*map, keys.num_rows(), stream);
+  rmm::device_uvector<size_type> gather_map{std::move(map_and_size.first)};
+  size_type const map_size = map_and_size.second;
 
   // Compact all results from sparse_results and insert into cache
   sparse_to_dense_results(keys,
@@ -576,7 +576,7 @@ std::unique_ptr<table> groupby_null_templated(table_view const& keys,
  * @return true A hash-based groupby should be used
  * @return false A hash-based groupby should not be used
  */
-bool can_use_hash_groupby(table_view const& keys, std::vector<aggregation_request> const& requests)
+bool can_use_hash_groupby(table_view const& keys, host_span<aggregation_request const> requests)
 {
   return std::all_of(requests.begin(), requests.end(), [](aggregation_request const& r) {
     return std::all_of(r.aggregations.begin(), r.aggregations.end(), [](auto const& a) {
@@ -588,7 +588,7 @@ bool can_use_hash_groupby(table_view const& keys, std::vector<aggregation_reques
 // Hash-based groupby
 std::pair<std::unique_ptr<table>, std::vector<aggregation_result>> groupby(
   table_view const& keys,
-  std::vector<aggregation_request> const& requests,
+  host_span<aggregation_request const> requests,
   null_policy include_null_keys,
   rmm::cuda_stream_view stream,
   rmm::mr::device_memory_resource* mr)
diff --git a/cpp/src/groupby/sort/aggregate.cpp b/cpp/src/groupby/sort/aggregate.cpp
index b171b19413b..86e2837967e 100644
--- a/cpp/src/groupby/sort/aggregate.cpp
+++ b/cpp/src/groupby/sort/aggregate.cpp
@@ -385,7 +385,7 @@ void aggregrate_result_functor::operator()<aggregation::COLLECT_SET>(aggregation
 
 // Sort-based groupby
 std::pair<std::unique_ptr<table>, std::vector<aggregation_result>> groupby::sort_aggregate(
-  std::vector<aggregation_request> const& requests,
+  host_span<aggregation_request const> requests,
   rmm::cuda_stream_view stream,
   rmm::mr::device_memory_resource* mr)
 {
diff --git a/cpp/src/groupby/sort/group_nth_element.cu b/cpp/src/groupby/sort/group_nth_element.cu
index 5c8e8b790d4..e6c10aa1056 100644
--- a/cpp/src/groupby/sort/group_nth_element.cu
+++ b/cpp/src/groupby/sort/group_nth_element.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020, NVIDIA CORPORATION.
+ * Copyright (c) 2020-2021, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -69,7 +69,7 @@ std::unique_ptr<column> group_nth_element(column_view const &values,
     auto bitmask_iterator =
       thrust::make_transform_iterator(cudf::detail::make_validity_iterator(*values_view),
                                       [] __device__(auto b) { return static_cast<size_type>(b); });
-    rmm::device_vector<size_type> intra_group_index(values.size());
+    rmm::device_uvector<size_type> intra_group_index(values.size(), stream);
     // intra group index for valids only.
     thrust::exclusive_scan_by_key(rmm::exec_policy(stream),
                                   group_labels.begin(),
@@ -77,9 +77,9 @@ std::unique_ptr<column> group_nth_element(column_view const &values,
                                   bitmask_iterator,
                                   intra_group_index.begin());
     // group_size to recalculate n if n<0
-    rmm::device_vector<size_type> group_count = [&] {
+    rmm::device_uvector<size_type> group_count = [&] {
       if (n < 0) {
-        rmm::device_vector<size_type> group_count(num_groups);
+        rmm::device_uvector<size_type> group_count(num_groups, stream);
         thrust::reduce_by_key(rmm::exec_policy(stream),
                               group_labels.begin(),
                               group_labels.end(),
@@ -88,7 +88,7 @@ std::unique_ptr<column> group_nth_element(column_view const &values,
                               group_count.begin());
         return group_count;
       } else {
-        return rmm::device_vector<size_type>();
+        return rmm::device_uvector<size_type>(0, stream);
       }
     }();
     // gather the valid index == n
diff --git a/cpp/src/groupby/sort/group_quantiles.cu b/cpp/src/groupby/sort/group_quantiles.cu
index fcadb2e71fb..c9f9e3cad9e 100644
--- a/cpp/src/groupby/sort/group_quantiles.cu
+++ b/cpp/src/groupby/sort/group_quantiles.cu
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019-2020, NVIDIA CORPORATION.
+ * Copyright (c) 2019-2021, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -80,7 +80,7 @@ struct quantiles_functor {
     column_view const& group_sizes,
     cudf::device_span<size_type const> group_offsets,
     size_type const num_groups,
-    rmm::device_vector<double> const& quantile,
+    device_span<double const> quantile,
     interpolation interpolation,
     rmm::cuda_stream_view stream,
     rmm::mr::device_memory_resource* mr)
@@ -112,7 +112,7 @@ struct quantiles_functor {
                            *group_size_view,
                            *result_view,
                            group_offsets.data(),
-                           quantile.data().get(),
+                           quantile.data(),
                            static_cast<size_type>(quantile.size()),
                            interpolation});
     } else {
@@ -125,7 +125,7 @@ struct quantiles_functor {
                            *group_size_view,
                            *result_view,
                            group_offsets.data(),
-                           quantile.data().get(),
+                           quantile.data(),
                            static_cast<size_type>(quantile.size()),
                            interpolation});
     }
diff --git a/cpp/src/groupby/sort/scan.cpp b/cpp/src/groupby/sort/scan.cpp
index 63de4ea8684..3d7ccf18242 100644
--- a/cpp/src/groupby/sort/scan.cpp
+++ b/cpp/src/groupby/sort/scan.cpp
@@ -107,7 +107,7 @@ void scan_result_functor::operator()<aggregation::COUNT_ALL>(aggregation const&
 
 // Sort-based groupby
 std::pair<std::unique_ptr<table>, std::vector<aggregation_result>> groupby::sort_scan(
-  std::vector<aggregation_request> const& requests,
+  host_span<aggregation_request const> requests,
   rmm::cuda_stream_view stream,
   rmm::mr::device_memory_resource* mr)
 {