Replace stream with res where possible

achirkin · achirkin · commit ee94b00ceb36 · 2026-08-06T17:36:06.000+02:00
diff --git a/cpp/include/raft/core/bitset.cuh b/cpp/include/raft/core/bitset.cuh
@@ -148,15 +148,14 @@ void bitset_repeat(raft::resources const& handle,
                    index_t repeat_times)
 {
   if (src_bit_len == 0 || repeat_times == 0) return;
-  auto stream = resource::get_cuda_stream(handle);
 
   constexpr index_t bits_per_element = sizeof(bitset_t) * 8;
   const index_t total_bits           = src_bit_len * repeat_times;
   const index_t output_size          = (total_bits + bits_per_element - 1) / bits_per_element;
 
   int threadsPerBlock = 128;
   int blocksPerGrid   = (output_size + threadsPerBlock - 1) / threadsPerBlock;
-  raft::launch_kernel(stream, blocksPerGrid, threadsPerBlock)(
+  raft::launch_kernel(handle, blocksPerGrid, threadsPerBlock)(
     bitset_repeat_kernel, d_src, d_output, src_bit_len, repeat_times);
 
   return;
diff --git a/cpp/include/raft/linalg/detail/transpose.cuh b/cpp/include/raft/linalg/detail/transpose.cuh
@@ -89,7 +89,6 @@ void transpose_half(raft::resources const& handle,
                     const IndexType stride_out = 1)
 {
   if (n_cols == 0 || n_rows == 0) return;
-  auto stream = resource::get_cuda_stream(handle);
 
   int dev_id, sm_count;
 
@@ -118,7 +117,7 @@ void transpose_half(raft::resources const& handle,
   dim3 grids(adjusted_grid_x, adjusted_grid_y);
 
   if (stride_in > 1 || stride_out > 1) {
-    raft::launch_kernel(stream, grids, blocks)(
+    raft::launch_kernel(handle, grids, blocks)(
       transpose_half_kernel<IndexType, block_dim_x, block_dim_y>,
       n_rows,
       n_cols,
@@ -127,7 +126,7 @@ void transpose_half(raft::resources const& handle,
       stride_in,
       stride_out);
   } else {
-    raft::launch_kernel(stream, grids, blocks)(
+    raft::launch_kernel(handle, grids, blocks)(
       transpose_half_kernel<IndexType, block_dim_x, block_dim_y>,
       n_rows,
       n_cols,
diff --git a/cpp/include/raft/matrix/detail/shift.cuh b/cpp/include/raft/matrix/detail/shift.cuh
@@ -139,20 +139,19 @@ void shift_dispatch(raft::resources const& handle,
   size_t n_rows = in_out.extent(0);
   size_t n_cols = in_out.extent(1);
   size_t TPB    = 256;
-  auto stream   = raft::resource::get_cuda_stream(handle);
 
   if (shift_type == ShiftType::COL) {
     size_t num_blocks = static_cast<size_t>((n_rows + TPB) / TPB);
     if (shift_direction == ShiftDirection::TOWARDS_BEGINNING) {
-      raft::launch_kernel(stream, num_blocks, TPB)(
+      raft::launch_kernel(handle, num_blocks, TPB)(
         col_shift_towards_beginning<ValueT, fill_value, fill_type>,
         in_out.data_handle(),
         n_rows,
         n_cols,
         k,
         value);
     } else {  // ShiftDirection::TOWARDS_END
-      raft::launch_kernel(stream, num_blocks, TPB)(
+      raft::launch_kernel(handle, num_blocks, TPB)(
         col_shift_towards_end<ValueT, fill_value, fill_type>,
         in_out.data_handle(),
         n_rows,
@@ -163,15 +162,15 @@ void shift_dispatch(raft::resources const& handle,
   } else {  // ShiftType::ROW
     size_t num_blocks = static_cast<size_t>((n_cols + TPB) / TPB);
     if (shift_direction == ShiftDirection::TOWARDS_BEGINNING) {
-      raft::launch_kernel(stream, num_blocks, TPB)(
+      raft::launch_kernel(handle, num_blocks, TPB)(
         row_shift_towards_beginning<ValueT, fill_value, fill_type>,
         in_out.data_handle(),
         n_rows,
         n_cols,
         k,
         value);
     } else {  // ShiftDirection::TOWARDS_END
-      raft::launch_kernel(stream, num_blocks, TPB)(
+      raft::launch_kernel(handle, num_blocks, TPB)(
         row_shift_towards_end<ValueT, fill_value, fill_type>,
         in_out.data_handle(),
         n_rows,
diff --git a/cpp/include/raft/random/detail/multi_variable_gaussian.cuh b/cpp/include/raft/random/detail/multi_variable_gaussian.cuh
@@ -222,7 +222,7 @@ class multi_variable_gaussian_impl {
       // upper part (0) being filled with 0.0
       dim3 block(32, 32);
       dim3 grid(raft::ceildiv(dim, (int)block.x), raft::ceildiv(dim, (int)block.y));
-      raft::launch_kernel(cudaStream, grid, block)(fill_uplo<T>, dim, UPPER, (T)0.0, P);
+      raft::launch_kernel(handle, grid, block)(fill_uplo<T>, dim, UPPER, (T)0.0, P);
 
       // P is lower triangular chol decomp mtrx
       raft::linalg::gemm(
@@ -233,7 +233,7 @@ class multi_variable_gaussian_impl {
       dim3 grid(raft::ceildiv(dim, (int)block.x));
       RAFT_CUDA_TRY(cudaMemsetAsync(info, 0, sizeof(int), cudaStream));
       grid.x = raft::ceildiv(dim * dim, (int)block.x);
-      raft::launch_kernel(cudaStream, grid, block)(combined_dot_product<T>, dim, dim, eig, P, info);
+      raft::launch_kernel(handle, grid, block)(combined_dot_product<T>, dim, dim, eig, P, info);
 
       // checking if any eigen vals were negative
       raft::update_host(&info_h, info, 1, cudaStream);
diff --git a/cpp/include/raft/sparse/convert/detail/adj_to_csr.cuh b/cpp/include/raft/sparse/convert/detail/adj_to_csr.cuh
@@ -157,7 +157,7 @@ void adj_to_csr(raft::resources const& handle,
   dim3 block(adj_to_csr_tpb, 1);
   dim3 grid(blocks_per_row, grid_rows);
 
-  raft::launch_kernel(stream, grid, block)(
+  raft::launch_kernel(handle, grid, block)(
     adj_to_csr_kernel<index_t>, adj, row_ind, num_rows, num_cols, tmp, out_col_ind);
 }
 
diff --git a/cpp/include/raft/sparse/convert/detail/bitmap_to_csr.cuh b/cpp/include/raft/sparse/convert/detail/bitmap_to_csr.cuh
@@ -106,7 +106,6 @@ void calc_nnz_by_rows(raft::resources const& handle,
     sub_nnz_size     = num_rows * ((num_cols + bits_per_sub_col - 1) / bits_per_sub_col);
     return;
   }
-  auto stream        = resource::get_cuda_stream(handle);
   const size_t total = num_rows * num_cols;
   const size_t bitmap_num =
     (total + index_t(sizeof(bitmap_t) * 8) - 1) / index_t(sizeof(bitmap_t) * 8);
@@ -117,7 +116,7 @@ void calc_nnz_by_rows(raft::resources const& handle,
 
   auto block = bitmap_to_csr_tpb;
 
-  raft::launch_kernel(stream, grid, block)(calc_nnz_by_rows_kernel<bitmap_t, index_t, nnz_t>,
+  raft::launch_kernel(handle, grid, block)(calc_nnz_by_rows_kernel<bitmap_t, index_t, nnz_t>,
                                            bitmap,
                                            num_rows,
                                            num_cols,
@@ -249,14 +248,13 @@ void fill_indices_by_rows(raft::resources const& handle,
                           index_t bits_per_sub_col,
                           size_t sub_nnz_size)
 {
-  auto stream  = resource::get_cuda_stream(handle);
   auto block_x = num_rows;
   auto block_y = sub_nnz_size / num_rows;
   dim3 grid(block_x, block_y, 1);
 
   auto block = bitmap_to_csr_tpb;
 
-  raft::launch_kernel(stream, grid, block)(
+  raft::launch_kernel(handle, grid, block)(
     fill_indices_by_rows_kernel<bitmap_t, index_t, nnz_t, check_nnz>,
     bitmap,
     indptr,
diff --git a/cpp/include/raft/sparse/convert/detail/bitset_to_csr.cuh b/cpp/include/raft/sparse/convert/detail/bitset_to_csr.cuh
@@ -65,11 +65,10 @@ void gpu_repeat_csr(raft::resources const& handle,
 {
   if (nnz == 0) return;
 
-  auto stream            = resource::get_cuda_stream(handle);
   index_t repeat_csr_tpb = 256;
   index_t grid           = (nnz + repeat_csr_tpb - 1) / (repeat_csr_tpb);
 
-  raft::launch_kernel(stream, grid, repeat_csr_tpb)(repeat_csr_kernel,
+  raft::launch_kernel(handle, grid, repeat_csr_tpb)(repeat_csr_kernel,
                                                     d_indptr,
                                                     d_indices,
                                                     d_repeated_indptr,
diff --git a/cpp/include/raft/sparse/linalg/detail/laplacian.cuh b/cpp/include/raft/sparse/linalg/detail/laplacian.cuh
@@ -105,8 +105,7 @@ auto compute_graph_laplacian(
   auto result_structure                         = result.structure_view();
   auto static constexpr const threads_per_block = 256;
   auto blocks = std::min(int((dim + threads_per_block - 1) / threads_per_block), 65535);
-  auto stream = resource::get_cuda_stream(res);
-  raft::launch_kernel(stream, blocks, threads_per_block)(
+  raft::launch_kernel(res, blocks, threads_per_block)(
     detail::compute_graph_laplacian_kernel<std::remove_const_t<ElementType>,
                                            std::remove_const_t<IndptrType>,
                                            std::remove_const_t<IndicesType>>,
diff --git a/cpp/include/raft/sparse/linalg/detail/symmetrize.cuh b/cpp/include/raft/sparse/linalg/detail/symmetrize.cuh
@@ -208,7 +208,7 @@ void coo_symmetrize(raft::resources const& handle,
     handle, raft::make_device_vector_view(out_cols, out_nnz), static_cast<IdxT>(0));
   raft::matrix::fill(handle, raft::make_device_vector_view(out_vals, out_nnz), static_cast<T>(0.0));
 
-  raft::launch_kernel(stream, grid, blk)(coo_symmetrize_kernel<TPB_X, T, Lambda, IdxT, nnz_t>,
+  raft::launch_kernel(handle, grid, blk)(coo_symmetrize_kernel<TPB_X, T, Lambda, IdxT, nnz_t>,
                                          in_row_ind.data(),
                                          in_rows,
                                          in_cols,
diff --git a/cpp/include/raft/sparse/linalg/detail/utils.cuh b/cpp/include/raft/sparse/linalg/detail/utils.cuh
@@ -97,8 +97,6 @@ void faster_dot_on_csr(raft::resources const& handle,
 {
   if (nnz == 0 || n_rows == 0) return;
 
-  auto stream = resource::get_cuda_stream(handle);
-
   constexpr value_idx MAX_ROW_PER_ITER = 500;
   int dev_id, sm_count, blocks_per_sm;
 
@@ -115,7 +113,7 @@ void faster_dot_on_csr(raft::resources const& handle,
       (std::min(value_idx(blocks_per_sm * sm_count * 16), nnz) + block_x - 1) / block_x;
     dim3 blocks(block_x, block_y, 1);
 
-    raft::launch_kernel(stream, blocks, tpb, smem_size)(
+    raft::launch_kernel(handle, blocks, tpb, smem_size)(
       faster_dot_on_csr_kernel<value_idx, value_t, dot_t>,
       dot,
       indptr,
@@ -135,7 +133,7 @@ void faster_dot_on_csr(raft::resources const& handle,
       (std::min(value_idx(blocks_per_sm * sm_count * 16), nnz) + block_x - 1) / block_x;
     dim3 blocks(block_x, block_y, 1);
 
-    raft::launch_kernel(stream, blocks, tpb, smem_size)(
+    raft::launch_kernel(handle, blocks, tpb, smem_size)(
       faster_dot_on_csr_kernel<value_idx, value_t, dot_t>,
       dot,
       indptr,
@@ -154,7 +152,7 @@ void faster_dot_on_csr(raft::resources const& handle,
       (std::min(value_idx(blocks_per_sm * sm_count * 16), nnz) + block_x - 1) / block_x;
     dim3 blocks(block_x, block_y, 1);
 
-    raft::launch_kernel(stream, blocks, tpb, smem_size)(
+    raft::launch_kernel(handle, blocks, tpb, smem_size)(
       faster_dot_on_csr_kernel<value_idx, value_t, dot_t>,
       dot,
       indptr,
@@ -173,7 +171,7 @@ void faster_dot_on_csr(raft::resources const& handle,
       (std::min(value_idx(blocks_per_sm * sm_count * 16), nnz) + block_x - 1) / block_x;
     dim3 blocks(block_x, block_y, 1);
 
-    raft::launch_kernel(stream, blocks, tpb, smem_size)(
+    raft::launch_kernel(handle, blocks, tpb, smem_size)(
       faster_dot_on_csr_kernel<value_idx, value_t, dot_t>,
       dot,
       indptr,
diff --git a/cpp/include/raft/sparse/op/detail/reduce.cuh b/cpp/include/raft/sparse/op/detail/reduce.cuh
@@ -144,7 +144,7 @@ void max_duplicates(raft::resources const& handle,
   out.allocate(size, m, n, true, stream);
 
   // perform reduce
-  raft::launch_kernel(stream, raft::ceildiv(nnz, (nnz_t)256), 256)(
+  raft::launch_kernel(handle, raft::ceildiv(nnz, (nnz_t)256), 256)(
     max_duplicates_kernel<value_idx, value_t>,
     rows,
     cols,
diff --git a/cpp/include/raft/sparse/solver/detail/lanczos.cuh b/cpp/include/raft/sparse/solver/detail/lanczos.cuh
@@ -159,15 +159,15 @@ void lanczos_solve_ritz(
 
   int blockSize = 256;
   int numBlocks = (ncv + blockSize - 1) / blockSize;
-  raft::launch_kernel(stream, blockSize, numBlocks)(kernel_triangular_populate<ValueTypeT>,
+  raft::launch_kernel(handle, blockSize, numBlocks)(kernel_triangular_populate<ValueTypeT>,
                                                     triangular_matrix.data_handle(),
                                                     beta.data_handle(),
                                                     ncv);
 
   if (beta_k) {
     int threadsPerBlock = 256;
     int blocksPerGrid   = (k + threadsPerBlock - 1) / threadsPerBlock;
-    raft::launch_kernel(stream, blocksPerGrid, threadsPerBlock)(
+    raft::launch_kernel(handle, blocksPerGrid, threadsPerBlock)(
       kernel_triangular_beta_k<ValueTypeT>,
       triangular_matrix.data_handle(),
       beta_k.value().data_handle(),
@@ -378,7 +378,7 @@ void lanczos_aux(raft::resources const& handle,
     auto uu_i = raft::make_device_scalar_view(uu.data_handle() + uu.stride(1) * i);  // uu(0, i)
     raft::linalg::add(handle, make_const_mdspan(alpha_i), make_const_mdspan(uu_i), alpha_i);
 
-    raft::launch_kernel(stream, 1, 1)(
+    raft::launch_kernel(handle, 1, 1)(
       kernel_clamp_down<ValueTypeT>, alpha_i.data_handle(), static_cast<ValueTypeT>(1e-9));
 
     auto output = raft::make_device_vector_view<ValueTypeT, uint32_t>(
@@ -390,10 +390,10 @@ void lanczos_aux(raft::resources const& handle,
     int blockSize = 256;
     int numBlocks = (n + blockSize - 1) / blockSize;
 
-    raft::launch_kernel(stream, numBlocks, blockSize)(
+    raft::launch_kernel(handle, numBlocks, blockSize)(
       kernel_clamp_down_vector<ValueTypeT>, u.data_handle(), static_cast<ValueTypeT>(1e-7), n);
 
-    raft::launch_kernel(stream, 1, 1)(kernel_clamp_down<ValueTypeT>,
+    raft::launch_kernel(handle, 1, 1)(kernel_clamp_down<ValueTypeT>,
                                       beta.data_handle() + beta.stride(1) * i,
                                       static_cast<ValueTypeT>(1e-6));
 
@@ -402,7 +402,7 @@ void lanczos_aux(raft::resources const& handle,
     int threadsPerBlock = 256;
     int blocksPerGrid   = (n + threadsPerBlock - 1) / threadsPerBlock;
 
-    raft::launch_kernel(stream, blocksPerGrid, threadsPerBlock)(kernel_normalize<ValueTypeT>,
+    raft::launch_kernel(handle, blocksPerGrid, threadsPerBlock)(kernel_normalize<ValueTypeT>,
                                                                 u.data_handle(),
                                                                 beta.data_handle(),
                                                                 i,
diff --git a/cpp/include/raft/sparse/solver/detail/svds_sign_correction.cuh b/cpp/include/raft/sparse/solver/detail/svds_sign_correction.cuh
@@ -140,16 +140,14 @@ void svd_sign_correction(
   int m = U ? static_cast<int>(U->extent(0)) : 0;
   int n = Vt ? static_cast<int>(Vt->extent(1)) : 0;
 
-  auto stream = raft::resource::get_cuda_stream(handle);
-
   // threads_per_block must be a power of 2 for the tree reduction in the kernel
   constexpr int threads_per_block = 256;
   int smem_size                   = threads_per_block * (sizeof(ValueTypeT) + sizeof(int));
 
   ValueTypeT* U_ptr  = U ? U->data_handle() : nullptr;
   ValueTypeT* Vt_ptr = Vt ? Vt->data_handle() : nullptr;
 
-  raft::launch_kernel(stream, k, threads_per_block, smem_size)(
+  raft::launch_kernel(handle, k, threads_per_block, smem_size)(
     svd_sign_correction_kernel, U_ptr, Vt_ptr, m, n, k);
 }
 
diff --git a/cpp/include/raft/spectral/detail/matrix_wrappers.hpp b/cpp/include/raft/spectral/detail/matrix_wrappers.hpp
@@ -385,7 +385,7 @@ struct laplacian_matrix_t : sparse_matrix_t<index_type, value_type, nnz_type> {
     dim3 gridDim{std::min<unsigned int>((n + BLOCK_SIZE - 1) / BLOCK_SIZE, 65535), 1, 1};
 
     dim3 blockDim{BLOCK_SIZE, 1, 1};
-    raft::launch_kernel(stream, gridDim, blockDim)(
+    raft::launch_kernel(handle, gridDim, blockDim)(
       diagmv<index_type, value_type>, n, alpha, diagonal_.raw(), x, y);
 
     // Apply adjacency matrix
diff --git a/cpp/include/raft/stats/detail/batched/silhouette_score.cuh b/cpp/include/raft/stats/detail/batched/silhouette_score.cuh
@@ -214,7 +214,7 @@ value_t silhouette_score(
   dim3 block_size(std::min(n_rows, 32), std::min(n_labels, 32));
   dim3 grid_size(raft::ceildiv(n_rows, (value_idx)block_size.x),
                  raft::ceildiv(n_labels, (label_idx)block_size.y));
-  raft::launch_kernel(stream, grid_size, block_size)(
+  raft::launch_kernel(handle, grid_size, block_size)(
     detail::fill_b_kernel, b_ptr, y, n_rows, n_labels, cluster_counts.data());
 
   resource::wait_stream_pool_on_stream(handle);
diff --git a/cpp/include/raft/stats/detail/trustworthiness_score.cuh b/cpp/include/raft/stats/detail/trustworthiness_score.cuh
@@ -181,21 +181,20 @@ double trustworthiness_score(const raft::resources& h,
 
     int work     = curBatchSize * n;
     int n_blocks = raft::ceildiv(work, N_THREADS);
-    raft::launch_kernel(stream, n_blocks, N_THREADS)(
+    raft::launch_kernel(h, n_blocks, N_THREADS)(
       build_lookup_table, lookup_table.data(), X_ind.data(), n, work);
 
     RAFT_CUDA_TRY(cudaMemsetAsync(t_dbuf.data(), 0, sizeof(double), stream));
 
     work     = curBatchSize * (n_neighbors + 1);
     n_blocks = raft::ceildiv(work, N_THREADS);
-    raft::launch_kernel(stream, n_blocks, N_THREADS)(
-      compute_rank,
-      t_dbuf.data(),
-      lookup_table.data(),
-      &emb_ind.data()[(n - toDo) * (n_neighbors + 1)],
-      n,
-      n_neighbors + 1,
-      work);
+    raft::launch_kernel(h, n_blocks, N_THREADS)(compute_rank,
+                                                t_dbuf.data(),
+                                                lookup_table.data(),
+                                                &emb_ind.data()[(n - toDo) * (n_neighbors + 1)],
+                                                n,
+                                                n_neighbors + 1,
+                                                work);
 
     t += t_dbuf.value(stream);
 
diff --git a/cpp/tests/linalg/axpy.cu b/cpp/tests/linalg/axpy.cu
@@ -80,7 +80,7 @@ class AxpyTest : public ::testing::TestWithParam<AxpyInputs<T>> {
     int threads = 64;
     int blocks  = raft::ceildiv<int>(params.len, threads);
 
-    raft::launch_kernel(stream, blocks, threads)(
+    raft::launch_kernel(handle, blocks, threads)(
       naiveAxpy<T>, params.len, params.alpha, x.data(), refy.data(), params.incx, params.incy);
 
     auto host_alpha_view = make_host_scalar_view<const T>(&params.alpha);
diff --git a/cpp/tests/linalg/dot.cu b/cpp/tests/linalg/dot.cu
@@ -64,7 +64,7 @@ class DotTest : public ::testing::TestWithParam<DotInputs<T>> {
     uniform(handle, r, y.data(), y_len, T(-1.0), T(1.0));
 
     rmm::device_scalar<T> ref(0, resource::get_cuda_stream(handle));
-    raft::launch_kernel(stream, 256, 256)(
+    raft::launch_kernel(handle, 256, 256)(
       naiveDot<T>, params.len, x.data(), params.incx, y.data(), params.incy, ref.data());
     raft::update_host(&ref_output, ref.data(), 1, stream);
 
diff --git a/cpp/tests/linalg/gemv.cu b/cpp/tests/linalg/gemv.cu
@@ -99,7 +99,7 @@ class GemvTest : public ::testing::TestWithParam<GemvInputs<T>> {
     dim3 blocks(raft::ceildiv<int>(yElems, 256), 1, 1);
     dim3 threads(256, 1, 1);
 
-    raft::launch_kernel(stream, blocks, threads)(naiveGemv<T>,
+    raft::launch_kernel(handle, blocks, threads)(naiveGemv<T>,
                                                  refy.data(),
                                                  A.data(),
                                                  x.data(),
diff --git a/cpp/tests/linalg/mean_squared_error.cu b/cpp/tests/linalg/mean_squared_error.cu
@@ -76,7 +76,7 @@ class MeanSquaredErrorTest : public ::testing::TestWithParam<MeanSquaredErrorInp
                                             make_device_scalar_view<T>(output.data()),
                                             params.weight);
 
-    raft::launch_kernel(stream, 256, 256)(
+    raft::launch_kernel(handle, 256, 256)(
       naiveMeanSquaredError<T>, params.len, a.data(), b.data(), params.weight, refoutput.data());
     resource::sync_stream(handle);
   }
diff --git a/cpp/tests/random/multi_variable_gaussian.cu b/cpp/tests/random/multi_variable_gaussian.cu
diff --git a/cpp/tests/sparse/spmm.cu b/cpp/tests/sparse/spmm.cu
diff --git a/cpp/tests/stats/minmax.cu b/cpp/tests/stats/minmax.cu

Original file line number	Diff line number	Diff line change
`@@ -157,7 +157,7 @@ void adj_to_csr(raft::resources const& handle,`
`157`	`157`	`dim3 block(adj_to_csr_tpb, 1);`
`158`	`158`	`dim3 grid(blocks_per_row, grid_rows);`
`159`	`159`
`160`		`- raft::launch_kernel(stream, grid, block)(`
	`160`	`+ raft::launch_kernel(handle, grid, block)(`
`161`	`161`	`adj_to_csr_kernel<index_t>, adj, row_ind, num_rows, num_cols, tmp, out_col_ind);`
`162`	`162`	`}`
`163`	`163`