[EM] Drop support for the device cache. (#11446)

Author: trivialfis

doc/tutorials/external_memory.rst

@@ -147,9 +147,8 @@ stages the cache on CPU memory by default. Users can change the backing storage
 specifying the ``on_host`` parameter in the :py:class:`~xgboost.DataIter`. However, using
 the disk is not recommended as it's likely to make the GPU slower than the CPU. The option
 is here for experimentation purposes only. In addition,
-:py:class:`~xgboost.ExtMemQuantileDMatrix` parameters ``max_num_device_pages``,
-``min_cache_page_bytes``, and ``max_quantile_batches`` can help control the data placement
-and memory usage.
+:py:class:`~xgboost.ExtMemQuantileDMatrix` parameters ``min_cache_page_bytes``, and
+``max_quantile_batches`` can help control the data placement and memory usage.
 
 Inputs to the :py:class:`~xgboost.ExtMemQuantileDMatrix` (through the iterator) must be on
 the GPU. Following is a snippet from :ref:`sphx_glr_python_examples_external_memory.py`:
@@ -194,9 +193,9 @@ memory. XGBoost relies on the asynchronous memory pool to reduce the overhead of
 fetching. In addition, the open source `NVIDIA Linux driver
 <https://developer.nvidia.com/blog/nvidia-transitions-fully-towards-open-source-gpu-kernel-modules/>`__
 is required for ``Heterogeneous memory management (HMM)`` support. Usually, users need not
-to change :py:class:`~xgboost.ExtMemQuantileDMatrix` parameters ``max_num_device_pages``
-and ``min_cache_page_bytes``, they are automatically configured based on the device and
-don't change model accuracy. However, the ``max_quantile_batches`` can be useful if
+to change :py:class:`~xgboost.ExtMemQuantileDMatrix` parameters like
+``min_cache_page_bytes``, they are automatically configured based on the device and don't
+change model accuracy. However, the ``max_quantile_batches`` can be useful if
 :py:class:`~xgboost.ExtMemQuantileDMatrix` is running out of device memory during
 construction, see :py:class:`~xgboost.QuantileDMatrix` and the following sections for more
 info. Currently, we focus on devices with ``NVLink-C2C`` support for GPU-based external

include/xgboost/data.h

@@ -538,19 +538,16 @@ struct ExtMemConfig {
   std::int64_t min_cache_page_bytes{0};
   // Missing value.
   float missing{std::numeric_limits<float>::quiet_NaN()};
-  // Maximum number of pages cached in device.
-  std::int64_t max_num_device_pages{0};
   // The number of CPU threads.
   std::int32_t n_threads{0};
 
   ExtMemConfig() = default;
   ExtMemConfig(std::string cache, bool on_host, std::int64_t min_cache, float missing,
-               std::int64_t max_num_d, std::int32_t n_threads)
+               std::int32_t n_threads)
       : cache{std::move(cache)},
         on_host{on_host},
         min_cache_page_bytes{min_cache},
         missing{missing},
-        max_num_device_pages{max_num_d},
         n_threads{n_threads} {}
 };
 

jvm-packages/xgboost4j-spark-gpu/src/main/java/ml/dmlc/xgboost4j/java/ExtMemQuantileDMatrix.java

@@ -30,7 +30,6 @@ public ExtMemQuantileDMatrix(Iterator<ColumnBatch> iter,
       int maxBin,
       DMatrix ref,
       int nthread,
-      int maxNumDevicePages,
       int maxQuantileBatches,
       int minCachePageBytes) throws XGBoostError {
     long[] out = new long[1];
@@ -39,8 +38,8 @@ public ExtMemQuantileDMatrix(Iterator<ColumnBatch> iter,
       refHandle = new long[1];
       refHandle[0] = ref.getHandle();
     }
-    String conf = this.getConfig(missing, maxBin, nthread, maxNumDevicePages,
-        maxQuantileBatches, minCachePageBytes);
+    String conf = this.getConfig(missing, maxBin, nthread,
+                                 maxQuantileBatches, minCachePageBytes);
     XGBoostJNI.checkCall(XGBoostJNI.XGExtMemQuantileDMatrixCreateFromCallback(
         iter, refHandle, conf, out));
     handle = out[0];
@@ -51,7 +50,7 @@ public ExtMemQuantileDMatrix(
       float missing,
       int maxBin,
       DMatrix ref) throws XGBoostError {
-    this(iter, missing, maxBin, ref, 0, -1, -1, -1);
+    this(iter, missing, maxBin, ref, 0, -1, -1);
   }
 
   public ExtMemQuantileDMatrix(
@@ -61,16 +60,13 @@ public ExtMemQuantileDMatrix(
     this(iter, missing, maxBin, null);
   }
 
-  private String getConfig(float missing, int maxBin, int nthread, int maxNumDevicePages,
-      int maxQuantileBatches, int minCachePageBytes) {
+  private String getConfig(float missing, int maxBin, int nthread,
+                           int maxQuantileBatches, int minCachePageBytes) {
     Map<String, Object> conf = new java.util.HashMap<>();
     conf.put("missing", missing);
     conf.put("max_bin", maxBin);
     conf.put("nthread", nthread);
 
-    if (maxNumDevicePages > 0) {
-      conf.put("max_num_device_pages", maxNumDevicePages);
-    }
     if (maxQuantileBatches > 0) {
       conf.put("max_quantile_batches", maxQuantileBatches);
     }

jvm-packages/xgboost4j-spark-gpu/src/main/scala/ml/dmlc/xgboost4j/scala/ExtMemQuantileDMatrix.scala

@@ -27,12 +27,11 @@ class ExtMemQuantileDMatrix private[scala](
            maxBin: Int,
            ref: Option[QuantileDMatrix],
            nthread: Int,
-           maxNumDevicePages: Int,
            maxQuantileBatches: Int,
            minCachePageBytes: Int) {
     this(new jExtMemQuantileDMatrix(iter.asJava, missing, maxBin,
       ref.map(_.jDMatrix).orNull,
-      nthread, maxNumDevicePages, maxQuantileBatches, minCachePageBytes))
+      nthread, maxQuantileBatches, minCachePageBytes))
   }
 
   def this(iter: Iterator[ColumnBatch], missing: Float, maxBin: Int) {

jvm-packages/xgboost4j-spark-gpu/src/main/scala/ml/dmlc/xgboost4j/scala/spark/GpuXGBoostPlugin.scala

@@ -134,7 +134,6 @@ class GpuXGBoostPlugin extends XGBoostPlugin {
 
     val maxQuantileBatches = estimator.getMaxQuantileBatches
     val minCachePageBytes = estimator.getMinCachePageBytes
-    val maxNumDevicePages = estimator.getMaxNumDevicePages
 
     /** build QuantileDMatrix on the executor side */
     def buildQuantileDMatrix(input: Iterator[Table],
@@ -143,7 +142,7 @@ class GpuXGBoostPlugin extends XGBoostPlugin {
       extMemPath match {
         case Some(_) =>
           val itr = new ExternalMemoryIterator(input, indices, extMemPath)
-          new ExtMemQuantileDMatrix(itr, missing, maxBin, ref, nthread, maxNumDevicePages,
+          new ExtMemQuantileDMatrix(itr, missing, maxBin, ref, nthread,
             maxQuantileBatches, minCachePageBytes)
 
         case None =>

jvm-packages/xgboost4j-spark/src/main/scala/ml/dmlc/xgboost4j/scala/spark/params/XGBoostParams.scala

@@ -188,11 +188,6 @@ private[spark] trait SparkParams[T <: Params] extends HasFeaturesCols with HasFe
 
   final def getUseExternalMemory: Boolean = $(useExternalMemory)
 
-  final val maxNumDevicePages = new IntParam(this, "maxNumDevicePages", "Maximum number of " +
-    "pages cached in device")
-
-  final def getMaxNumDevicePages: Int = $(maxNumDevicePages)
-
   final val maxQuantileBatches = new IntParam(this, "maxQuantileBatches", "Maximum quantile " +
     "batches")
 
@@ -207,7 +202,7 @@ private[spark] trait SparkParams[T <: Params] extends HasFeaturesCols with HasFe
     numEarlyStoppingRounds -> 0, forceRepartition -> false, missing -> Float.NaN,
     featuresCols -> Array.empty, customObj -> null, customEval -> null,
     featureNames -> Array.empty, featureTypes -> Array.empty, useExternalMemory -> false,
-    maxNumDevicePages -> -1, maxQuantileBatches -> -1, minCachePageBytes -> -1)
+    maxQuantileBatches -> -1, minCachePageBytes -> -1)
 
   addNonXGBoostParam(numWorkers, numRound, numEarlyStoppingRounds, inferBatchSize, featuresCol,
     labelCol, baseMarginCol, weightCol, predictionCol, leafPredictionCol, contribPredictionCol,
@@ -251,8 +246,6 @@ private[spark] trait SparkParams[T <: Params] extends HasFeaturesCols with HasFe
 
   def setUseExternalMemory(value: Boolean): T = set(useExternalMemory, value).asInstanceOf[T]
 
-  def setMaxNumDevicePages(value: Int): T = set(maxNumDevicePages, value).asInstanceOf[T]
-
   def setMaxQuantileBatches(value: Int): T = set(maxQuantileBatches, value).asInstanceOf[T]
 
   def setMinCachePageBytes(value: Int): T = set(minCachePageBytes, value).asInstanceOf[T]

python-package/xgboost/core.py

@@ -1820,7 +1820,6 @@ def __init__(  # pylint: disable=super-init-not-called
         max_bin: Optional[int] = None,
         ref: Optional[DMatrix] = None,
         enable_categorical: bool = False,
-        max_num_device_pages: Optional[int] = None,
         max_quantile_batches: Optional[int] = None,
     ) -> None:
         """
@@ -1829,15 +1828,6 @@ def __init__(  # pylint: disable=super-init-not-called
         data :
             A user-defined :py:class:`DataIter` for loading data.
 
-        max_num_device_pages :
-            For a GPU-based validation dataset, XGBoost can optionally cache some pages
-            in device memory instead of host memory to reduce data transfer. Each cached
-            page has size of `min_cache_page_bytes`. Set this to 0 if you don't want
-            pages to be cached in the device memory. This can be useful for preventing
-            OOM error where there are more than one validation datasets. The default
-            number of device-based page is 1. Lastly, XGBoost infers whether a dataset
-            is used for valdiation by checking whether ref is not None.
-
         max_quantile_batches :
             See :py:class:`QuantileDMatrix`.
 
@@ -1850,7 +1840,6 @@ def __init__(  # pylint: disable=super-init-not-called
             data,
             ref,
             enable_categorical=enable_categorical,
-            max_num_device_pages=max_num_device_pages,
             max_quantile_blocks=max_quantile_batches,
         )
         assert self.handle is not None
@@ -1861,7 +1850,6 @@ def _init(
         ref: Optional[DMatrix],
         *,
         enable_categorical: bool,
-        max_num_device_pages: Optional[int] = None,
         max_quantile_blocks: Optional[int] = None,
     ) -> None:
         args = make_jcargs(
@@ -1871,7 +1859,6 @@ def _init(
             on_host=it.on_host,
             max_bin=self.max_bin,
             min_cache_page_bytes=it.min_cache_page_bytes,
-            max_num_device_pages=max_num_device_pages,
             # It's called blocks internally due to block-based quantile sketching.
             max_quantile_blocks=max_quantile_blocks,
         )
@@ -2559,9 +2546,9 @@ def predict(
             prediction. Note the final column is the bias term.
 
         approx_contribs :
-            Approximate the contributions of each feature.  Used when ``pred_contribs`` or
-            ``pred_interactions`` is set to True.  Changing the default of this parameter
-            (False) is not recommended.
+            Approximate the contributions of each feature.  Used when ``pred_contribs``
+            or ``pred_interactions`` is set to True.  Changing the default of this
+            parameter (False) is not recommended.
 
         pred_interactions :
             When this is True the output will be a matrix of size (nsample,
@@ -2579,10 +2566,10 @@ def predict(
 
         training :
             Whether the prediction value is used for training.  This can effect `dart`
-            booster, which performs dropouts during training iterations but use all trees
-            for inference. If you want to obtain result with dropouts, set this parameter
-            to `True`.  Also, the parameter is set to true when obtaining prediction for
-            custom objective function.
+            booster, which performs dropouts during training iterations but use all
+            trees for inference. If you want to obtain result with dropouts, set this
+            parameter to `True`.  Also, the parameter is set to true when obtaining
+            prediction for custom objective function.
 
             .. versionadded:: 1.0.0
 
@@ -2595,8 +2582,8 @@ def predict(
             .. versionadded:: 1.4.0
 
         strict_shape :
-            When set to True, output shape is invariant to whether classification is used.
-            For both value and margin prediction, the output shape is (n_samples,
+            When set to True, output shape is invariant to whether classification is
+            used.  For both value and margin prediction, the output shape is (n_samples,
             n_groups), n_groups == 1 when multi-class is not used.  Default to False, in
             which case the output shape can be (n_samples, ) if multi-class is not used.
 
@@ -3116,8 +3103,8 @@ def get_fscore(self, fmap: PathLike = "") -> Dict[str, Union[float, List[float]]
 
         .. note:: Zero-importance features will not be included
 
-           Keep in mind that this function does not include zero-importance feature, i.e.
-           those features that have not been used in any split conditions.
+           Keep in mind that this function does not include zero-importance feature,
+           i.e.  those features that have not been used in any split conditions.
 
         Parameters
         ----------
@@ -3141,13 +3128,13 @@ def get_score(
 
         .. note::
 
-           For linear model, only "weight" is defined and it's the normalized coefficients
-           without bias.
+           For linear model, only "weight" is defined and it's the normalized
+           coefficients without bias.
 
         .. note:: Zero-importance features will not be included
 
-           Keep in mind that this function does not include zero-importance feature, i.e.
-           those features that have not been used in any split conditions.
+           Keep in mind that this function does not include zero-importance feature,
+           i.e.  those features that have not been used in any split conditions.
 
         Parameters
         ----------

src/c_api/c_api.cc

@@ -330,14 +330,12 @@ XGB_DLL int XGDMatrixCreateFromCallback(DataIterHandle iter, DMatrixHandle proxy
   xgboost_CHECK_C_ARG_PTR(reset);
   xgboost_CHECK_C_ARG_PTR(out);
 
-  auto config = ExtMemConfig{
-      cache, on_host, min_cache_page_bytes, missing, /*max_num_device_pages=*/0, n_threads};
+  auto config = ExtMemConfig{cache, on_host, min_cache_page_bytes, missing, n_threads};
   *out = new std::shared_ptr<xgboost::DMatrix>{
       xgboost::DMatrix::Create(iter, proxy, reset, next, config)};
   API_END();
 }
 
-
 namespace {
 std::shared_ptr<DMatrix> GetRefDMatrix(DataIterHandle ref) {
   std::shared_ptr<DMatrix> _ref{nullptr};
@@ -393,17 +391,14 @@ XGB_DLL int XGExtMemQuantileDMatrixCreateFromCallback(DataIterHandle iter, DMatr
   std::string cache = RequiredArg<String>(jconfig, "cache_prefix", __func__);
   auto min_cache_page_bytes = OptionalArg<Integer, std::int64_t>(jconfig, "min_cache_page_bytes",
                                                                  cuda_impl::AutoCachePageBytes());
-  auto max_num_device_pages = OptionalArg<Integer, std::int64_t>(jconfig, "max_num_device_pages",
-                                                                 cuda_impl::MaxNumDevicePages());
   auto max_quantile_blocks = OptionalArg<Integer, std::int64_t>(
       jconfig, "max_quantile_blocks", std::numeric_limits<std::int64_t>::max());
 
   xgboost_CHECK_C_ARG_PTR(next);
   xgboost_CHECK_C_ARG_PTR(reset);
   xgboost_CHECK_C_ARG_PTR(out);
 
-  auto config =
-      ExtMemConfig{cache, on_host, min_cache_page_bytes, missing, max_num_device_pages, n_threads};
+  auto config = ExtMemConfig{cache, on_host, min_cache_page_bytes, missing, n_threads};
   *out = new std::shared_ptr<xgboost::DMatrix>{xgboost::DMatrix::Create(
       iter, proxy, p_ref, reset, next, max_bin, max_quantile_blocks, config)};
   API_END();

src/data/batch_utils.h

@@ -39,8 +39,6 @@ void CheckParam(BatchParam const& init, BatchParam const& param);
 namespace xgboost::cuda_impl {
 // Indicator for XGBoost to not concatenate any page.
 constexpr std::int64_t MatchingPageBytes() { return 0; }
-// Maxmimum number of pages from the validation dataset to be cached in the device memory.
-constexpr std::int32_t MaxNumDevicePages() { return 1; }
 // Default size of the cached page
 constexpr double CachePageRatio() { return 0.125; }
 // Indicator for XGBoost to automatically concatenate pages.

src/data/data.cc

@@ -950,12 +950,8 @@ DMatrix* DMatrix::Load(const std::string& uri, bool silent, DataSplitMode data_s
     CHECK(data_split_mode != DataSplitMode::kCol)
         << "Column-wise data split is not supported for external memory.";
     data::FileIterator iter{fname, static_cast<uint32_t>(partid), static_cast<uint32_t>(npart)};
-    auto config = ExtMemConfig{cache_file,
-                               false,
-                               cuda_impl::MatchingPageBytes(),
-                               std::numeric_limits<float>::quiet_NaN(),
-                               cuda_impl::MaxNumDevicePages(),
-                               1};
+    auto config = ExtMemConfig{cache_file, false, cuda_impl::MatchingPageBytes(),
+                               std::numeric_limits<float>::quiet_NaN(), 1};
     dmat = new data::SparsePageDMatrix{&iter, iter.Proxy(), data::fileiter::Reset,
                                        data::fileiter::Next, config};
   }