Small cleanup to the proxy dmatrix.

- Remove the auto-dispatch for CUDA methods.

Author: trivialfis

src/c_api/c_api.cc

@@ -431,7 +431,7 @@ XGB_DLL int XGProxyDMatrixSetDataCudaArrayInterface(DMatrixHandle handle,
   CHECK(p_m);
   auto m = static_cast<xgboost::data::DMatrixProxy *>(p_m->get());
   CHECK(m) << "Current DMatrix type does not support set data.";
-  m->SetCUDAArray(c_interface_str);
+  m->SetCudaArray(c_interface_str);
   API_END();
 }
 
@@ -443,19 +443,19 @@ XGB_DLL int XGProxyDMatrixSetDataCudaColumnar(DMatrixHandle handle, char const *
   CHECK(p_m);
   auto m = static_cast<xgboost::data::DMatrixProxy *>(p_m->get());
   CHECK(m) << "Current DMatrix type does not support set data.";
-  m->SetCUDAArray(c_interface_str);
+  m->SetCudaColumnar(c_interface_str);
   API_END();
 }
 
-XGB_DLL int XGProxyDMatrixSetDataColumnar(DMatrixHandle handle, char const *c_interface_str) {
+XGB_DLL int XGProxyDMatrixSetDataColumnar(DMatrixHandle handle, char const *data) {
   API_BEGIN();
   CHECK_HANDLE();
-  xgboost_CHECK_C_ARG_PTR(c_interface_str);
+  xgboost_CHECK_C_ARG_PTR(data);
   auto p_m = static_cast<std::shared_ptr<xgboost::DMatrix> *>(handle);
   CHECK(p_m);
   auto m = static_cast<xgboost::data::DMatrixProxy *>(p_m->get());
   CHECK(m) << "Current DMatrix type does not support set data.";
-  m->SetColumnarData(c_interface_str);
+  m->SetColumnar(data);
   API_END();
 }
 
@@ -467,7 +467,7 @@ XGB_DLL int XGProxyDMatrixSetDataDense(DMatrixHandle handle, char const *c_inter
   CHECK(p_m);
   auto m = static_cast<xgboost::data::DMatrixProxy *>(p_m->get());
   CHECK(m) << "Current DMatrix type does not support set data.";
-  m->SetArrayData(c_interface_str);
+  m->SetArray(c_interface_str);
   API_END();
 }
 
@@ -482,7 +482,7 @@ XGB_DLL int XGProxyDMatrixSetDataCSR(DMatrixHandle handle, char const *indptr, c
   CHECK(p_m);
   auto m = static_cast<xgboost::data::DMatrixProxy *>(p_m->get());
   CHECK(m) << "Current DMatrix type does not support set data.";
-  m->SetCSRData(indptr, indices, data, ncol, true);
+  m->SetCsr(indptr, indices, data, ncol, true);
   API_END();
 }
 
@@ -1417,7 +1417,7 @@ XGB_DLL int XGBoosterPredictFromDense(BoosterHandle handle, char const *array_in
   auto proxy = dynamic_cast<data::DMatrixProxy *>(p_m.get());
   CHECK(proxy) << "Invalid input type for inplace predict.";
   xgboost_CHECK_C_ARG_PTR(array_interface);
-  proxy->SetArrayData(array_interface);
+  proxy->SetArray(array_interface);
   auto *learner = static_cast<xgboost::Learner *>(handle);
   InplacePredictImpl(p_m, c_json_config, learner, out_shape, out_dim, out_result);
   API_END();
@@ -1438,7 +1438,7 @@ XGB_DLL int XGBoosterPredictFromColumnar(BoosterHandle handle, char const *array
   auto proxy = dynamic_cast<data::DMatrixProxy *>(p_m.get());
   CHECK(proxy) << "Invalid input type for inplace predict.";
   xgboost_CHECK_C_ARG_PTR(array_interface);
-  proxy->SetColumnarData(array_interface);
+  proxy->SetColumnar(array_interface);
   auto *learner = static_cast<xgboost::Learner *>(handle);
   InplacePredictImpl(p_m, c_json_config, learner, out_shape, out_dim, out_result);
   API_END();
@@ -1460,7 +1460,7 @@ XGB_DLL int XGBoosterPredictFromCSR(BoosterHandle handle, char const *indptr, ch
   auto proxy = dynamic_cast<data::DMatrixProxy *>(p_m.get());
   CHECK(proxy) << "Invalid input type for inplace predict.";
   xgboost_CHECK_C_ARG_PTR(indptr);
-  proxy->SetCSRData(indptr, indices, data, cols, true);
+  proxy->SetCsr(indptr, indices, data, cols, true);
   auto *learner = static_cast<xgboost::Learner *>(handle);
   InplacePredictImpl(p_m, c_json_config, learner, out_shape, out_dim, out_result);
   API_END();

src/c_api/c_api.cu

@@ -150,7 +150,7 @@ int InplacePreidctCUDA(BoosterHandle handle, char const *c_array_interface,
   auto proxy = dynamic_cast<data::DMatrixProxy *>(p_m.get());
   CHECK(proxy) << "Invalid input type for inplace predict.";
 
-  proxy->SetCUDAArray(c_array_interface);
+  proxy->SetCudaArray(c_array_interface);
 
   auto config = Json::Load(StringView{c_json_config});
   auto *learner = static_cast<Learner *>(handle);

src/data/proxy_dmatrix.cc

@@ -1,5 +1,5 @@
 /**
- * Copyright 2021-2024, XGBoost Contributors
+ * Copyright 2021-2025, XGBoost Contributors
  */
 
 #include "proxy_dmatrix.h"
@@ -16,23 +16,23 @@
 #endif
 
 namespace xgboost::data {
-void DMatrixProxy::SetColumnarData(StringView interface_str) {
+void DMatrixProxy::SetColumnar(StringView interface_str) {
   std::shared_ptr<ColumnarAdapter> adapter{new ColumnarAdapter{interface_str}};
   this->batch_ = adapter;
   this->Info().num_col_ = adapter->NumColumns();
   this->Info().num_row_ = adapter->NumRows();
   this->ctx_.Init(Args{{"device", "cpu"}});
 }
 
-void DMatrixProxy::SetArrayData(StringView interface_str) {
+void DMatrixProxy::SetArray(StringView interface_str) {
   std::shared_ptr<ArrayAdapter> adapter{new ArrayAdapter{interface_str}};
   this->batch_ = adapter;
   this->Info().num_col_ = adapter->NumColumns();
   this->Info().num_row_ = adapter->NumRows();
   this->ctx_.Init(Args{{"device", "cpu"}});
 }
 
-void DMatrixProxy::SetCSRData(char const *c_indptr, char const *c_indices, char const *c_values,
+void DMatrixProxy::SetCsr(char const *c_indptr, char const *c_indices, char const *c_values,
                               bst_feature_t n_features, bool on_host) {
   CHECK(on_host) << "Not implemented on device.";
   std::shared_ptr<CSRArrayAdapter> adapter{new CSRArrayAdapter(
@@ -43,6 +43,11 @@ void DMatrixProxy::SetCSRData(char const *c_indptr, char const *c_indices, char
   this->ctx_.Init(Args{{"device", "cpu"}});
 }
 
+#if !defined(XGBOOST_USE_CUDA)
+void DMatrixProxy::SetCudaArray(StringView) { common::AssertGPUSupport(); }
+void DMatrixProxy::SetCudaColumnar(StringView) { common::AssertGPUSupport(); }
+#endif  // !defined(XGBOOST_USE_CUDA)
+
 namespace cuda_impl {
 std::shared_ptr<DMatrix> CreateDMatrixFromProxy(Context const *ctx,
                                                 std::shared_ptr<DMatrixProxy> proxy, float missing);

src/data/proxy_dmatrix.cu

@@ -7,8 +7,8 @@
 #include "proxy_dmatrix.h"
 
 namespace xgboost::data {
-void DMatrixProxy::FromCudaColumnar(StringView interface_str) {
-  auto adapter{std::make_shared<CudfAdapter>(interface_str)};
+void DMatrixProxy::SetCudaColumnar(StringView data) {
+  auto adapter{std::make_shared<CudfAdapter>(data)};
   this->batch_ = adapter;
   this->Info().num_col_ = adapter->NumColumns();
   this->Info().num_row_ = adapter->NumRows();
@@ -21,8 +21,8 @@ void DMatrixProxy::FromCudaColumnar(StringView interface_str) {
   ctx_ = ctx_.MakeCUDA(adapter->Device().ordinal);
 }
 
-void DMatrixProxy::FromCudaArray(StringView interface_str) {
-  auto adapter(std::make_shared<CupyAdapter>(StringView{interface_str}));
+void DMatrixProxy::SetCudaArray(StringView data) {
+  auto adapter(std::make_shared<CupyAdapter>(StringView{data}));
   this->batch_ = adapter;
   this->Info().num_col_ = adapter->NumColumns();
   this->Info().num_row_ = adapter->NumRows();

src/data/proxy_dmatrix.h

@@ -65,51 +65,39 @@ class DataIterProxy {
 };
 
 /**
- * @brief A proxy of DMatrix used by external iterator.
+ * @brief A proxy of DMatrix used by the external iterator.
  */
 class DMatrixProxy : public DMatrix {
   MetaInfo info_;
   std::any batch_;
   Context ctx_;
 
-#if defined(XGBOOST_USE_CUDA)
-  void FromCudaColumnar(StringView interface_str);
-  void FromCudaArray(StringView interface_str);
-#endif  // defined(XGBOOST_USE_CUDA)
-
  public:
   DeviceOrd Device() const { return ctx_.Device(); }
 
-  void SetCUDAArray(char const* c_interface) {
-    common::AssertGPUSupport();
-    CHECK(c_interface);
-#if defined(XGBOOST_USE_CUDA)
-    StringView interface_str{c_interface};
-    Json json_array_interface = Json::Load(interface_str);
-    if (IsA<Array>(json_array_interface)) {
-      this->FromCudaColumnar(interface_str);
-    } else {
-      this->FromCudaArray(interface_str);
-    }
-#endif  // defined(XGBOOST_USE_CUDA)
-  }
-
-  void SetColumnarData(StringView interface_str);
-
-  void SetArrayData(StringView interface_str);
-  void SetCSRData(char const* c_indptr, char const* c_indices, char const* c_values,
+  /**
+   * Device setters
+   */
+  void SetCudaColumnar(StringView data);
+  void SetCudaArray(StringView data);
+  /**
+   * Host setters
+   */
+  void SetColumnar(StringView data);
+  void SetArray(StringView data);
+  void SetCsr(char const* c_indptr, char const* c_indices, char const* c_values,
                   bst_feature_t n_features, bool on_host);
 
   MetaInfo& Info() override { return info_; }
   MetaInfo const& Info() const override { return info_; }
   Context const* Ctx() const override { return &ctx_; }
 
-  bool EllpackExists() const override { return false; }
-  bool GHistIndexExists() const override { return false; }
-  bool SparsePageExists() const override { return false; }
+  [[nodiscard]] bool EllpackExists() const override { return false; }
+  [[nodiscard]] bool GHistIndexExists() const override { return false; }
+  [[nodiscard]] bool SparsePageExists() const override { return false; }
 
   template <typename Page>
-  BatchSet<Page> NoBatch() {
+  static BatchSet<Page> NoBatch() {
     LOG(FATAL) << "Proxy DMatrix cannot return data batch.";
     return BatchSet<Page>(BatchIterator<Page>(nullptr));
   }

tests/cpp/data/test_proxy_dmatrix.cc

@@ -1,23 +1,26 @@
 /**
- * Copyright 2021-2023, XGBoost contributors
+ * Copyright 2021-2025, XGBoost contributors
  */
 #include <gtest/gtest.h>
 
-#include "../../../src/data/adapter.h"
+#include <cstddef>  // for size_t
+#include <vector>   // for vector
+
 #include "../../../src/data/proxy_dmatrix.h"
 #include "../helpers.h"
+#include "xgboost/host_device_vector.h"  // for HostDeviceVector
 
 namespace xgboost::data {
 TEST(ProxyDMatrix, HostData) {
   DMatrixProxy proxy;
-  size_t constexpr kRows = 100, kCols = 10;
+  std::size_t constexpr kRows = 100, kCols = 10;
   std::vector<HostDeviceVector<float>> label_storage(1);
 
   HostDeviceVector<float> storage;
   auto data =
       RandomDataGenerator(kRows, kCols, 0.5).Device(FstCU()).GenerateArrayInterface(&storage);
 
-  proxy.SetArrayData(data.c_str());
+  proxy.SetArray(data.c_str());
 
   auto n_samples = HostAdapterDispatch(&proxy, [](auto const &value) { return value.Size(); });
   ASSERT_EQ(n_samples, kRows);

tests/cpp/data/test_proxy_dmatrix.cu

@@ -1,15 +1,17 @@
 /**
- * Copyright 2020-2023 XGBoost contributors
+ * Copyright 2020-2025, XGBoost contributors
  */
 #include <gtest/gtest.h>
 #include <xgboost/host_device_vector.h>
 
-#include <any>  // for any_cast
-#include <memory>
+#include <any>     // for any_cast
+#include <memory>  // for shared_ptr
+#include <vector>  // for vector
 
 #include "../../../src/data/device_adapter.cuh"
 #include "../../../src/data/proxy_dmatrix.h"
 #include "../helpers.h"
+#include "xgboost/host_device_vector.h"  // for HostDeviceVector
 
 namespace xgboost::data {
 TEST(ProxyDMatrix, DeviceData) {
@@ -23,7 +25,7 @@ TEST(ProxyDMatrix, DeviceData) {
                     .GenerateColumnarArrayInterface(&label_storage);
 
   DMatrixProxy proxy;
-  proxy.SetCUDAArray(data.c_str());
+  proxy.SetCudaArray(data.c_str());
   proxy.SetInfo("label", labels.c_str());
 
   ASSERT_EQ(proxy.Adapter().type(), typeid(std::shared_ptr<CupyAdapter>));
@@ -35,7 +37,7 @@ TEST(ProxyDMatrix, DeviceData) {
   data = RandomDataGenerator(kRows, kCols, 0)
              .Device(FstCU())
              .GenerateColumnarArrayInterface(&columnar_storage);
-  proxy.SetCUDAArray(data.c_str());
+  proxy.SetCudaArray(data.c_str());
   ASSERT_EQ(proxy.Adapter().type(), typeid(std::shared_ptr<CudfAdapter>));
   ASSERT_EQ(std::any_cast<std::shared_ptr<CudfAdapter>>(proxy.Adapter())->NumRows(), kRows);
   ASSERT_EQ(std::any_cast<std::shared_ptr<CudfAdapter>>(proxy.Adapter())->NumColumns(), kCols);

tests/cpp/gbm/test_gblinear.cu

@@ -1,5 +1,5 @@
 /**
- * Copyright 2023, XGBoost Contributors
+ * Copyright 2023-2025, XGBoost Contributors
  */
 #include <gtest/gtest.h>
 #include <xgboost/global_config.h>  // for GlobalConfigThreadLocalStore

tests/cpp/gbm/test_gbtree.cc

@@ -1,5 +1,5 @@
 /**
- * Copyright 2019-2024, XGBoost contributors
+ * Copyright 2019-2025, XGBoost contributors
  */
 #include <gtest/gtest.h>
 #include <xgboost/context.h>
@@ -401,9 +401,9 @@ class Dart : public testing::TestWithParam<char const*> {
     HostDeviceVector<float>* inplace_predts;
     std::shared_ptr<data::DMatrixProxy> x{new data::DMatrixProxy{}};
     if (ctx.IsCUDA()) {
-      x->SetCUDAArray(array_str.c_str());
+      x->SetCudaArray(array_str.c_str());
     } else {
-      x->SetArrayData(array_str.c_str());
+      x->SetArray(array_str.c_str());
     }
     learner->InplacePredict(x, PredictionType::kValue, std::numeric_limits<float>::quiet_NaN(),
                             &inplace_predts, 0, 0);
@@ -628,7 +628,7 @@ TEST(GBTree, PredictRange) {
     HostDeviceVector<float> raw_storage;
     auto raw = RandomDataGenerator{n_samples, n_features, 0.5}.GenerateArrayInterface(&raw_storage);
     std::shared_ptr<data::DMatrixProxy> x{new data::DMatrixProxy{}};
-    x->SetArrayData(raw.data());
+    x->SetArray(raw.data());
 
     HostDeviceVector<float>* out_predt;
     learner->InplacePredict(x, PredictionType::kValue, std::numeric_limits<float>::quiet_NaN(),

tests/cpp/gbm/test_gbtree.cu

@@ -1,5 +1,5 @@
 /**
- * Copyright 2023, XGBoost contributors
+ * Copyright 2023-2025, XGBoost contributors
  */
 #include <xgboost/context.h>      // for Context
 #include <xgboost/learner.h>      // for Learner
@@ -8,7 +8,6 @@
 #include <limits>  // for numeric_limits
 #include <memory>  // for shared_ptr
 #include <string>  // for string
-#include <thread>  // for thread
 
 #include "../../../src/data/adapter.h"           // for ArrayAdapter
 #include "../../../src/data/device_adapter.cuh"  // for CupyAdapter
@@ -50,9 +49,9 @@ void TestInplaceFallback(Context const* ctx) {
   std::shared_ptr<DMatrix> p_m{new data::DMatrixProxy};
   auto proxy = std::dynamic_pointer_cast<data::DMatrixProxy>(p_m);
   if (data_ordinal.IsCPU()) {
-    proxy->SetArrayData(StringView{X});
+    proxy->SetArray(StringView{X});
   } else {
-    proxy->SetCUDAArray(X.c_str());
+    proxy->SetCudaArray(X.c_str());
   }
 
   HostDeviceVector<float>* out_predt{nullptr};