Update Dask RF to use the new distributed algo

cpp/include/cuml/ensemble/randomforest_mg_utils.hpp

@@ -0,0 +1,41 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <raft/core/comms.hpp>
+#include <raft/core/handle.hpp>
+#include <raft/core/resource/comms.hpp>
+#include <raft/core/resource/cuda_stream.hpp>
+#include <raft/util/cudart_utils.hpp>
+
+#include <cstddef>
+
+namespace ML::detail {
+
+inline void cuml_rf_allreduce_validation_status(const raft::handle_t& handle,
+                                                const int* local_status,
+                                                int* global_status)
+{
+  auto const& comm    = raft::resource::get_comms(handle);
+  cudaStream_t stream = raft::resource::get_cuda_stream(handle);
+  comm.allreduce(local_status, global_status, 1, raft::comms::op_t::MAX, stream);
+  RAFT_EXPECTS(comm.sync_stream(stream) == raft::comms::status_t::SUCCESS,
+               "Input validation status all-reduce failed");
+}
+
+inline void cuml_rf_allreduce_oob_stats(const raft::handle_t& handle,
+                                        const double* local_stats,
+                                        double* global_stats,
+                                        std::size_t count)
+{
+  auto const& comm    = raft::resource::get_comms(handle);
+  cudaStream_t stream = raft::resource::get_cuda_stream(handle);
+  comm.allreduce(local_stats, global_stats, count, raft::comms::op_t::SUM, stream);
+  RAFT_EXPECTS(comm.sync_stream(stream) == raft::comms::status_t::SUCCESS,
+               "OOB statistics all-reduce failed");
+}
+
+}  // namespace ML::detail

cpp/src/randomforest/randomforest.cuh

@@ -330,10 +330,12 @@ class RandomForest {
     // Distributed tree builders issue collectives independently, so train them serially until
     // the forest-level scheduler can impose a global collective order across concurrent trees.
     if (distributed) { n_streams = 1; }
-    ASSERT(static_cast<std::size_t>(n_streams) <= handle.get_stream_pool_size(),
-           "effective RF n_streams (=%d) should be <= raft::handle_t.n_streams (=%lu)",
-           n_streams,
-           handle.get_stream_pool_size());
+    auto stream_pool_size = handle.get_stream_pool_size();
+    if (static_cast<std::size_t>(n_streams) > stream_pool_size) {
+      CUML_LOG_WARN("Resizing n_streams to fit the available stream pool size (%lu)",
+                    stream_pool_size);
+      n_streams = ML::narrow_cast<int>(stream_pool_size);
+    }
 
     auto quantile_result = DT::computeQuantiles(handle,
                                                 input,