Rename and extract Context. (#8528)

* Rename `GenericParameter` to `Context`.
* Rename header file to reflect the change.
* Rename all references.

src/tree/common_row_partitioner.h

@@ -11,8 +11,8 @@
 
 #include "../common/numeric.h"  // Iota
 #include "../common/partition_builder.h"
-#include "hist/expand_entry.h"           // CPUExpandEntry
-#include "xgboost/generic_parameters.h"  // Context
+#include "hist/expand_entry.h"  // CPUExpandEntry
+#include "xgboost/context.h"    // Context
 
 namespace xgboost {
 namespace tree {

src/tree/gpu_hist/row_partitioner.cuh

@@ -9,7 +9,7 @@
 
 #include "../../common/device_helpers.cuh"
 #include "xgboost/base.h"
-#include "xgboost/generic_parameters.h"
+#include "xgboost/context.h"
 #include "xgboost/task.h"
 #include "xgboost/tree_model.h"
 

src/tree/hist/evaluate_splits.h

@@ -5,19 +5,20 @@
 #define XGBOOST_TREE_HIST_EVALUATE_SPLITS_H_
 
 #include <algorithm>
+#include <limits>
 #include <memory>
 #include <numeric>
-#include <limits>
 #include <utility>
 #include <vector>
 
-#include "../param.h"
-#include "../constraints.h"
-#include "../split_evaluator.h"
 #include "../../common/categorical.h"
-#include "../../common/random.h"
 #include "../../common/hist_util.h"
+#include "../../common/random.h"
 #include "../../data/gradient_index.h"
+#include "../constraints.h"
+#include "../param.h"
+#include "../split_evaluator.h"
+#include "xgboost/context.h"
 
 namespace xgboost {
 namespace tree {
@@ -427,7 +428,7 @@ class HistEvaluator {
                          std::shared_ptr<common::ColumnSampler> sampler)
       : param_{param},
         column_sampler_{std::move(sampler)},
-        tree_evaluator_{param, static_cast<bst_feature_t>(info.num_col_), GenericParameter::kCpuId},
+        tree_evaluator_{param, static_cast<bst_feature_t>(info.num_col_), Context::kCpuId},
         n_threads_{n_threads} {
     interaction_constraints_.Configure(param, info.num_col_);
     column_sampler_->Init(info.num_col_, info.feature_weights.HostVector(), param_.colsample_bynode,
@@ -442,14 +443,14 @@ class HistEvaluator {
  * \param p_last_tree The last tree being updated by tree updater
  */
 template <typename Partitioner>
-void UpdatePredictionCacheImpl(GenericParameter const *ctx, RegTree const *p_last_tree,
+void UpdatePredictionCacheImpl(Context const *ctx, RegTree const *p_last_tree,
                                std::vector<Partitioner> const &partitioner,
                                linalg::VectorView<float> out_preds) {
   CHECK_GT(out_preds.Size(), 0U);
 
   CHECK(p_last_tree);
   auto const &tree = *p_last_tree;
-  CHECK_EQ(out_preds.DeviceIdx(), GenericParameter::kCpuId);
+  CHECK_EQ(out_preds.DeviceIdx(), Context::kCpuId);
   size_t n_nodes = p_last_tree->GetNodes().size();
   for (auto &part : partitioner) {
     CHECK_EQ(part.Size(), n_nodes);

src/tree/split_evaluator.h

@@ -10,17 +10,18 @@
 
 #include <dmlc/registry.h>
 #include <xgboost/base.h>
+
+#include <algorithm>
+#include <limits>
 #include <utility>
 #include <vector>
-#include <limits>
-#include <algorithm>
 
-#include "xgboost/tree_model.h"
-#include "xgboost/host_device_vector.h"
-#include "xgboost/generic_parameters.h"
-#include "../common/transform.h"
 #include "../common/math.h"
+#include "../common/transform.h"
 #include "param.h"
+#include "xgboost/context.h"
+#include "xgboost/host_device_vector.h"
+#include "xgboost/tree_model.h"
 
 namespace xgboost {
 namespace tree {
@@ -38,7 +39,7 @@ class TreeEvaluator {
  public:
   TreeEvaluator(TrainParam const& p, bst_feature_t n_features, int32_t device) {
     device_ = device;
-    if (device != GenericParameter::kCpuId) {
+    if (device != Context::kCpuId) {
       lower_bounds_.SetDevice(device);
       upper_bounds_.SetDevice(device);
       monotone_.SetDevice(device);
@@ -56,7 +57,7 @@ class TreeEvaluator {
       has_constraint_ = true;
     }
 
-    if (device_ != GenericParameter::kCpuId) {
+    if (device_ != Context::kCpuId) {
       // Pull to device early.
       lower_bounds_.ConstDeviceSpan();
       upper_bounds_.ConstDeviceSpan();
@@ -151,7 +152,7 @@ class TreeEvaluator {
  public:
   /* Get a view to the evaluator that can be passed down to device. */
   template <typename ParamT = TrainParam> auto GetEvaluator() const {
-    if (device_ != GenericParameter::kCpuId) {
+    if (device_ != Context::kCpuId) {
       auto constraints = monotone_.ConstDevicePointer();
       return SplitEvaluator<ParamT>{constraints, lower_bounds_.ConstDevicePointer(),
                                     upper_bounds_.ConstDevicePointer(), has_constraint_};

src/tree/tree_updater.cc

@@ -14,13 +14,12 @@ DMLC_REGISTRY_ENABLE(::xgboost::TreeUpdaterReg);
 
 namespace xgboost {
 
-TreeUpdater* TreeUpdater::Create(const std::string& name, GenericParameter const* tparam,
-                                 ObjInfo task) {
+TreeUpdater* TreeUpdater::Create(const std::string& name, Context const* ctx, ObjInfo task) {
   auto* e = ::dmlc::Registry< ::xgboost::TreeUpdaterReg>::Get()->Find(name);
   if (e == nullptr) {
     LOG(FATAL) << "Unknown tree updater " << name;
   }
-  auto p_updater = (e->body)(tparam, task);
+  auto p_updater = (e->body)(ctx, task);
   return p_updater;
 }
 

src/tree/updater_approx.cc

@@ -256,7 +256,7 @@ class GlobalApproxUpdater : public TreeUpdater {
   ObjInfo task_;
 
  public:
-  explicit GlobalApproxUpdater(GenericParameter const *ctx, ObjInfo task)
+  explicit GlobalApproxUpdater(Context const *ctx, ObjInfo task)
       : TreeUpdater(ctx), task_{task} {
     monitor_.Init(__func__);
   }
@@ -337,8 +337,6 @@ XGBOOST_REGISTER_TREE_UPDATER(GlobalHistMaker, "grow_histmaker")
     .describe(
         "Tree constructor that uses approximate histogram construction "
         "for each node.")
-    .set_body([](GenericParameter const *ctx, ObjInfo task) {
-      return new GlobalApproxUpdater(ctx, task);
-    });
+    .set_body([](Context const *ctx, ObjInfo task) { return new GlobalApproxUpdater(ctx, task); });
 }  // namespace tree
 }  // namespace xgboost

src/tree/updater_colmaker.cc

@@ -55,7 +55,7 @@ DMLC_REGISTER_PARAMETER(ColMakerTrainParam);
 /*! \brief column-wise update to construct a tree */
 class ColMaker: public TreeUpdater {
  public:
-  explicit ColMaker(GenericParameter const *ctx) : TreeUpdater(ctx) {}
+  explicit ColMaker(Context const *ctx) : TreeUpdater(ctx) {}
   void Configure(const Args &args) override {
     param_.UpdateAllowUnknown(args);
     colmaker_param_.UpdateAllowUnknown(args);
@@ -159,11 +159,11 @@ class ColMaker: public TreeUpdater {
     // constructor
     explicit Builder(const TrainParam &param, const ColMakerTrainParam &colmaker_train_param,
                      FeatureInteractionConstraintHost _interaction_constraints,
-                     GenericParameter const *ctx, const std::vector<float> &column_densities)
+                     Context const *ctx, const std::vector<float> &column_densities)
         : param_(param),
           colmaker_train_param_{colmaker_train_param},
           ctx_{ctx},
-          tree_evaluator_(param_, column_densities.size(), GenericParameter::kCpuId),
+          tree_evaluator_(param_, column_densities.size(), Context::kCpuId),
           interaction_constraints_{std::move(_interaction_constraints)},
           column_densities_(column_densities) {}
     // update one tree, growing
@@ -594,7 +594,7 @@ class ColMaker: public TreeUpdater {
     const TrainParam& param_;
     const ColMakerTrainParam& colmaker_train_param_;
     // number of omp thread used during training
-    GenericParameter const* ctx_;
+    Context const* ctx_;
     common::ColumnSampler column_sampler_;
     // Instance Data: current node position in the tree of each instance
     std::vector<int> position_;
@@ -612,9 +612,7 @@ class ColMaker: public TreeUpdater {
 };
 
 XGBOOST_REGISTER_TREE_UPDATER(ColMaker, "grow_colmaker")
-.describe("Grow tree with parallelization over columns.")
-.set_body([](GenericParameter const* ctx, ObjInfo) {
-    return new ColMaker(ctx);
-  });
+    .describe("Grow tree with parallelization over columns.")
+    .set_body([](Context const *ctx, ObjInfo) { return new ColMaker(ctx); });
 }  // namespace tree
 }  // namespace xgboost

src/tree/updater_gpu_hist.cu

@@ -4,41 +4,40 @@
 #include <thrust/copy.h>
 #include <thrust/reduce.h>
 #include <xgboost/tree_updater.h>
+
 #include <algorithm>
 #include <cmath>
-#include <memory>
 #include <limits>
+#include <memory>
 #include <utility>
 #include <vector>
 
-#include "xgboost/base.h"
-#include "xgboost/data.h"
-#include "xgboost/generic_parameters.h"
-#include "xgboost/host_device_vector.h"
-#include "xgboost/parameter.h"
-#include "xgboost/span.h"
-#include "xgboost/json.h"
-
 #include "../collective/device_communicator.cuh"
-#include "../common/io.h"
+#include "../common/bitfield.h"
+#include "../common/categorical.h"
 #include "../common/device_helpers.cuh"
 #include "../common/hist_util.h"
-#include "../common/bitfield.h"
+#include "../common/io.h"
 #include "../common/timer.h"
-#include "../common/categorical.h"
 #include "../data/ellpack_page.cuh"
-
-#include "param.h"
-#include "driver.h"
-#include "updater_gpu_common.cuh"
-#include "split_evaluator.h"
 #include "constraints.cuh"
-#include "gpu_hist/feature_groups.cuh"
-#include "gpu_hist/gradient_based_sampler.cuh"
-#include "gpu_hist/row_partitioner.cuh"
-#include "gpu_hist/histogram.cuh"
+#include "driver.h"
 #include "gpu_hist/evaluate_splits.cuh"
 #include "gpu_hist/expand_entry.cuh"
+#include "gpu_hist/feature_groups.cuh"
+#include "gpu_hist/gradient_based_sampler.cuh"
+#include "gpu_hist/histogram.cuh"
+#include "gpu_hist/row_partitioner.cuh"
+#include "param.h"
+#include "split_evaluator.h"
+#include "updater_gpu_common.cuh"
+#include "xgboost/base.h"
+#include "xgboost/context.h"
+#include "xgboost/data.h"
+#include "xgboost/host_device_vector.h"
+#include "xgboost/json.h"
+#include "xgboost/parameter.h"
+#include "xgboost/span.h"
 #include "xgboost/task.h"
 #include "xgboost/tree_model.h"
 
@@ -730,7 +729,7 @@ class GPUHistMaker : public TreeUpdater {
   using GradientSumT = GradientPairPrecise;
 
  public:
-  explicit GPUHistMaker(GenericParameter const* ctx, ObjInfo task)
+  explicit GPUHistMaker(Context const* ctx, ObjInfo task)
       : TreeUpdater(ctx), task_{task} {};
   void Configure(const Args& args) override {
     // Used in test to count how many configurations are performed
@@ -879,9 +878,7 @@ class GPUHistMaker : public TreeUpdater {
 #if !defined(GTEST_TEST)
 XGBOOST_REGISTER_TREE_UPDATER(GPUHistMaker, "grow_gpu_hist")
     .describe("Grow tree with GPU.")
-    .set_body([](GenericParameter const* tparam, ObjInfo task) {
-      return new GPUHistMaker(tparam, task);
-    });
+    .set_body([](Context const* ctx, ObjInfo task) { return new GPUHistMaker(ctx, task); });
 #endif  // !defined(GTEST_TEST)
 
 }  // namespace tree

src/tree/updater_prune.cc

@@ -20,7 +20,7 @@ DMLC_REGISTRY_FILE_TAG(updater_prune);
 /*! \brief pruner that prunes a tree after growing finishes */
 class TreePruner : public TreeUpdater {
  public:
-  explicit TreePruner(GenericParameter const* ctx, ObjInfo task) : TreeUpdater(ctx) {
+  explicit TreePruner(Context const* ctx, ObjInfo task) : TreeUpdater(ctx) {
     syncher_.reset(TreeUpdater::Create("sync", ctx_, task));
     pruner_monitor_.Init("TreePruner");
   }
@@ -110,6 +110,6 @@ class TreePruner : public TreeUpdater {
 
 XGBOOST_REGISTER_TREE_UPDATER(TreePruner, "prune")
     .describe("Pruner that prune the tree according to statistics.")
-    .set_body([](GenericParameter const* ctx, ObjInfo task) { return new TreePruner(ctx, task); });
+    .set_body([](Context const* ctx, ObjInfo task) { return new TreePruner(ctx, task); });
 }  // namespace tree
 }  // namespace xgboost

src/tree/updater_quantile_hist.cc

@@ -335,8 +335,6 @@ void QuantileHistMaker::Builder::InitData(DMatrix *fmat, const RegTree &tree,
 
 XGBOOST_REGISTER_TREE_UPDATER(QuantileHistMaker, "grow_quantile_histmaker")
     .describe("Grow tree using quantized histogram.")
-    .set_body([](GenericParameter const *ctx, ObjInfo task) {
-      return new QuantileHistMaker(ctx, task);
-    });
+    .set_body([](Context const *ctx, ObjInfo task) { return new QuantileHistMaker(ctx, task); });
 }  // namespace tree
 }  // namespace xgboost

src/tree/updater_quantile_hist.h

@@ -85,8 +85,7 @@ inline BatchParam HistBatch(TrainParam const& param) {
 /*! \brief construct a tree using quantized feature values */
 class QuantileHistMaker: public TreeUpdater {
  public:
-  explicit QuantileHistMaker(GenericParameter const* ctx, ObjInfo task)
-      : TreeUpdater(ctx), task_{task} {}
+  explicit QuantileHistMaker(Context const* ctx, ObjInfo task) : TreeUpdater(ctx), task_{task} {}
   void Configure(const Args& args) override;
 
   void Update(HostDeviceVector<GradientPair>* gpair, DMatrix* dmat,
@@ -120,7 +119,7 @@ class QuantileHistMaker: public TreeUpdater {
    public:
     // constructor
     explicit Builder(const size_t n_trees, const TrainParam& param, DMatrix const* fmat,
-                     ObjInfo task, GenericParameter const* ctx)
+                     ObjInfo task, Context const* ctx)
         : n_trees_(n_trees),
           param_(param),
           p_last_fmat_(fmat),

src/tree/updater_refresh.cc

@@ -24,7 +24,7 @@ DMLC_REGISTRY_FILE_TAG(updater_refresh);
 /*! \brief pruner that prunes a tree after growing finishs */
 class TreeRefresher : public TreeUpdater {
  public:
-  explicit TreeRefresher(GenericParameter const *ctx) : TreeUpdater(ctx) {}
+  explicit TreeRefresher(Context const *ctx) : TreeUpdater(ctx) {}
   void Configure(const Args &args) override { param_.UpdateAllowUnknown(args); }
   void LoadConfig(Json const& in) override {
     auto const& config = get<Object const>(in);
@@ -160,6 +160,6 @@ class TreeRefresher : public TreeUpdater {
 
 XGBOOST_REGISTER_TREE_UPDATER(TreeRefresher, "refresh")
     .describe("Refresher that refreshes the weight and statistics according to data.")
-    .set_body([](GenericParameter const *ctx, ObjInfo) { return new TreeRefresher(ctx); });
+    .set_body([](Context const *ctx, ObjInfo) { return new TreeRefresher(ctx); });
 }  // namespace tree
 }  // namespace xgboost

src/tree/updater_sync.cc

@@ -24,7 +24,7 @@ DMLC_REGISTRY_FILE_TAG(updater_sync);
  */
 class TreeSyncher : public TreeUpdater {
  public:
-  explicit TreeSyncher(GenericParameter const* tparam) : TreeUpdater(tparam) {}
+  explicit TreeSyncher(Context const* tparam) : TreeUpdater(tparam) {}
   void Configure(const Args&) override {}
 
   void LoadConfig(Json const&) override {}
@@ -56,6 +56,6 @@ class TreeSyncher : public TreeUpdater {
 
 XGBOOST_REGISTER_TREE_UPDATER(TreeSyncher, "sync")
     .describe("Syncher that synchronize the tree in all distributed nodes.")
-    .set_body([](GenericParameter const* tparam, ObjInfo) { return new TreeSyncher(tparam); });
+    .set_body([](Context const* ctx, ObjInfo) { return new TreeSyncher(ctx); });
 }  // namespace tree
 }  // namespace xgboost