Rename and extract Context. (#8528)

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

tests/cpp/common/test_json.cc

@@ -590,7 +590,7 @@ TEST(Json, DISABLED_RoundTripExhaustive) {
     }
   };
   int64_t int32_max = static_cast<int64_t>(std::numeric_limits<uint32_t>::max());
-  GenericParameter ctx;
+  Context ctx;
   common::ParallelFor(int32_max, ctx.Threads(), [&](auto i) { test(static_cast<uint32_t>(i)); });
 }
 

tests/cpp/common/test_linalg.cc

@@ -2,7 +2,7 @@
  * Copyright 2021 by XGBoost Contributors
  */
 #include <gtest/gtest.h>
-#include <xgboost/generic_parameters.h>
+#include <xgboost/context.h>
 #include <xgboost/host_device_vector.h>
 #include <xgboost/linalg.h>
 
@@ -13,7 +13,7 @@
 namespace xgboost {
 namespace linalg {
 namespace {
-auto kCpuId = GenericParameter::kCpuId;
+auto kCpuId = Context::kCpuId;
 }
 
 auto MakeMatrixFromTest(HostDeviceVector<float> *storage, size_t n_rows, size_t n_cols) {

tests/cpp/common/test_linalg.cu

@@ -4,7 +4,7 @@
 #include <gtest/gtest.h>
 
 #include "../../../src/common/linalg_op.cuh"
-#include "xgboost/generic_parameters.h"
+#include "xgboost/context.h"
 #include "xgboost/linalg.h"
 
 namespace xgboost {
@@ -21,7 +21,7 @@ void TestElementWiseKernel() {
     ASSERT_FALSE(t.CContiguous());
     ElementWiseTransformDevice(t, [] __device__(size_t i, float) { return i; });
     // CPU view
-    t = l.View(GenericParameter::kCpuId).Slice(linalg::All(), 1, linalg::All());
+    t = l.View(Context::kCpuId).Slice(linalg::All(), 1, linalg::All());
     size_t k = 0;
     for (size_t i = 0; i < l.Shape(0); ++i) {
       for (size_t j = 0; j < l.Shape(2); ++j) {
@@ -41,7 +41,7 @@ void TestElementWiseKernel() {
     ElementWiseTransformDevice(t, [] XGBOOST_DEVICE(size_t i, float) { return i; });
     ASSERT_TRUE(t.CContiguous());
     // CPU view
-    t = l.View(GenericParameter::kCpuId);
+    t = l.View(Context::kCpuId);
 
     size_t ind = 0;
     for (size_t i = 0; i < l.Shape(0); ++i) {

tests/cpp/common/test_stats.cc

@@ -2,7 +2,7 @@
  * Copyright 2022 by XGBoost Contributors
  */
 #include <gtest/gtest.h>
-#include <xgboost/generic_parameters.h>
+#include <xgboost/context.h>
 
 #include "../../../src/common/stats.h"
 

tests/cpp/common/test_stats.cu

@@ -2,12 +2,13 @@
  * Copyright 2022 by XGBoost Contributors
  */
 #include <gtest/gtest.h>
+
 #include <utility>
 #include <vector>
 
 #include "../../../src/common/stats.cuh"
 #include "xgboost/base.h"
-#include "xgboost/generic_parameters.h"
+#include "xgboost/context.h"
 #include "xgboost/host_device_vector.h"
 #include "xgboost/linalg.h"
 

tests/cpp/data/test_array_interface.cc

@@ -20,7 +20,7 @@ TEST(ArrayInterface, Initialize) {
 
   HostDeviceVector<size_t> u64_storage(storage.Size());
   std::string u64_arr_str{ArrayInterfaceStr(linalg::TensorView<size_t const, 2>{
-      u64_storage.ConstHostSpan(), {kRows, kCols}, GenericParameter::kCpuId})};
+      u64_storage.ConstHostSpan(), {kRows, kCols}, Context::kCpuId})};
   std::copy(storage.ConstHostVector().cbegin(), storage.ConstHostVector().cend(),
             u64_storage.HostSpan().begin());
   auto u64_arr = ArrayInterface<2>{u64_arr_str};

tests/cpp/data/test_metainfo.cc

@@ -129,8 +129,8 @@ TEST(MetaInfo, SaveLoadBinary) {
     EXPECT_EQ(inforead.group_ptr_, info.group_ptr_);
     EXPECT_EQ(inforead.weights_.HostVector(), info.weights_.HostVector());
 
-    auto orig_margin = info.base_margin_.View(xgboost::GenericParameter::kCpuId);
-    auto read_margin = inforead.base_margin_.View(xgboost::GenericParameter::kCpuId);
+    auto orig_margin = info.base_margin_.View(xgboost::Context::kCpuId);
+    auto read_margin = inforead.base_margin_.View(xgboost::Context::kCpuId);
     EXPECT_TRUE(std::equal(orig_margin.Values().cbegin(), orig_margin.Values().cend(),
                            read_margin.Values().cbegin()));
 

tests/cpp/data/test_metainfo.cu

@@ -1,13 +1,13 @@
 /*! Copyright 2019-2021 by XGBoost Contributors */
 
 #include <gtest/gtest.h>
+#include <thrust/device_vector.h>
+#include <xgboost/context.h>
 #include <xgboost/data.h>
 #include <xgboost/json.h>
-#include <xgboost/generic_parameters.h>
-#include <thrust/device_vector.h>
-#include "test_array_interface.h"
-#include "../../../src/common/device_helpers.cuh"
 
+#include "../../../src/common/device_helpers.cuh"
+#include "test_array_interface.h"
 #include "test_metainfo.h"
 
 namespace xgboost {
@@ -65,7 +65,7 @@ TEST(MetaInfo, FromInterface) {
   }
 
   info.SetInfo(ctx, "base_margin", str.c_str());
-  auto const h_base_margin = info.base_margin_.View(GenericParameter::kCpuId);
+  auto const h_base_margin = info.base_margin_.View(Context::kCpuId);
   ASSERT_EQ(h_base_margin.Size(), d_data.size());
   for (size_t i = 0; i < d_data.size(); ++i) {
     ASSERT_EQ(h_base_margin(i), d_data[i]);

tests/cpp/data/test_simple_dmatrix.cc

@@ -256,7 +256,7 @@ TEST(SimpleDMatrix, Slice) {
   std::iota(upper.begin(), upper.end(), 1.0f);
 
   auto& margin = p_m->Info().base_margin_;
-  margin = decltype(p_m->Info().base_margin_){{kRows, kClasses}, GenericParameter::kCpuId};
+  margin = decltype(p_m->Info().base_margin_){{kRows, kClasses}, Context::kCpuId};
 
   std::array<int32_t, 3> ridxs {1, 3, 5};
   std::unique_ptr<DMatrix> out { p_m->Slice(ridxs) };
@@ -286,8 +286,8 @@ TEST(SimpleDMatrix, Slice) {
         ASSERT_EQ(p_m->Info().weights_.HostVector().at(ridx),
                   out->Info().weights_.HostVector().at(i));
 
-        auto out_margin = out->Info().base_margin_.View(GenericParameter::kCpuId);
-        auto in_margin = margin.View(GenericParameter::kCpuId);
+        auto out_margin = out->Info().base_margin_.View(Context::kCpuId);
+        auto in_margin = margin.View(Context::kCpuId);
         for (size_t j = 0; j < kClasses; ++j) {
           ASSERT_EQ(out_margin(i, j), in_margin(ridx, j));
         }
@@ -318,7 +318,7 @@ TEST(SimpleDMatrix, SliceCol) {
   std::iota(upper.begin(), upper.end(), 1.0f);
 
   auto& margin = p_m->Info().base_margin_;
-  margin = decltype(p_m->Info().base_margin_){{kRows, kClasses}, GenericParameter::kCpuId};
+  margin = decltype(p_m->Info().base_margin_){{kRows, kClasses}, Context::kCpuId};
 
   size_t constexpr kSlicCols {4};
   for (auto slice = 0; slice < 2; slice++) {
@@ -348,8 +348,8 @@ TEST(SimpleDMatrix, SliceCol) {
                     out->Info().labels_upper_bound_.HostVector().at(i));
           ASSERT_EQ(p_m->Info().weights_.HostVector().at(i), out->Info().weights_.HostVector().at(i));
 
-          auto out_margin = out->Info().base_margin_.View(GenericParameter::kCpuId);
-          auto in_margin = margin.View(GenericParameter::kCpuId);
+          auto out_margin = out->Info().base_margin_.View(Context::kCpuId);
+          auto in_margin = margin.View(Context::kCpuId);
           for (size_t j = 0; j < kClasses; ++j) {
             ASSERT_EQ(out_margin(i, j), in_margin(i, j));
           }

tests/cpp/gbm/test_gblinear.cc

@@ -7,11 +7,11 @@
 #include <sstream>
 
 #include "../helpers.h"
-#include "xgboost/json.h"
-#include "xgboost/logging.h"
+#include "xgboost/context.h"
 #include "xgboost/gbm.h"
-#include "xgboost/generic_parameters.h"
+#include "xgboost/json.h"
 #include "xgboost/learner.h"
+#include "xgboost/logging.h"
 
 namespace xgboost {
 namespace gbm {

tests/cpp/gbm/test_gbtree.cc

@@ -2,7 +2,7 @@
  * Copyright 2019-2022 XGBoost contributors
  */
 #include <gtest/gtest.h>
-#include <xgboost/generic_parameters.h>
+#include <xgboost/context.h>
 
 #include "../../../src/data/adapter.h"
 #include "../../../src/data/proxy_dmatrix.h"

tests/cpp/helpers.cc

@@ -532,7 +532,7 @@ std::unique_ptr<DMatrix> CreateSparsePageDMatrixWithRC(
   return dmat;
 }
 
-gbm::GBTreeModel CreateTestModel(LearnerModelParam const* param, GenericParameter const* ctx,
+gbm::GBTreeModel CreateTestModel(LearnerModelParam const* param, Context const* ctx,
                                  size_t n_classes) {
   gbm::GBTreeModel model(param, ctx);
 
@@ -549,13 +549,12 @@ gbm::GBTreeModel CreateTestModel(LearnerModelParam const* param, GenericParamete
   return model;
 }
 
-std::unique_ptr<GradientBooster> CreateTrainedGBM(
-    std::string name, Args kwargs, size_t kRows, size_t kCols,
-    LearnerModelParam const* learner_model_param,
-    GenericParameter const* generic_param) {
-  auto caches = std::make_shared< PredictionContainer >();;
-  std::unique_ptr<GradientBooster> gbm {
-    GradientBooster::Create(name, generic_param, learner_model_param)};
+std::unique_ptr<GradientBooster> CreateTrainedGBM(std::string name, Args kwargs, size_t kRows,
+                                                  size_t kCols,
+                                                  LearnerModelParam const* learner_model_param,
+                                                  Context const* ctx) {
+  auto caches = std::make_shared<PredictionContainer>();
+  std::unique_ptr<GradientBooster> gbm{GradientBooster::Create(name, ctx, learner_model_param)};
   gbm->Configure(kwargs);
   auto p_dmat = RandomDataGenerator(kRows, kCols, 0).GenerateDMatrix();
 

tests/cpp/helpers.h

@@ -8,7 +8,7 @@
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <xgboost/base.h>
-#include <xgboost/generic_parameters.h>
+#include <xgboost/context.h>
 #include <xgboost/json.h>
 
 #include <cstdio>
@@ -355,18 +355,17 @@ std::unique_ptr<DMatrix> CreateSparsePageDMatrixWithRC(
     size_t n_rows, size_t n_cols, size_t page_size, bool deterministic,
     const dmlc::TemporaryDirectory& tempdir = dmlc::TemporaryDirectory());
 
-gbm::GBTreeModel CreateTestModel(LearnerModelParam const* param, GenericParameter const* ctx,
+gbm::GBTreeModel CreateTestModel(LearnerModelParam const* param, Context const* ctx,
                                  size_t n_classes = 1);
 
-std::unique_ptr<GradientBooster> CreateTrainedGBM(
-    std::string name, Args kwargs, size_t kRows, size_t kCols,
-    LearnerModelParam const* learner_model_param,
-    GenericParameter const* generic_param);
+std::unique_ptr<GradientBooster> CreateTrainedGBM(std::string name, Args kwargs, size_t kRows,
+                                                  size_t kCols,
+                                                  LearnerModelParam const* learner_model_param,
+                                                  Context const* generic_param);
 
-inline GenericParameter CreateEmptyGenericParam(int gpu_id) {
-  xgboost::GenericParameter tparam;
-  std::vector<std::pair<std::string, std::string>> args {
-    {"gpu_id", std::to_string(gpu_id)}};
+inline Context CreateEmptyGenericParam(int gpu_id) {
+  xgboost::Context tparam;
+  std::vector<std::pair<std::string, std::string>> args{{"gpu_id", std::to_string(gpu_id)}};
   tparam.Init(args);
   return tparam;
 }

tests/cpp/linear/test_linear.cc

@@ -17,12 +17,12 @@ TEST(Linear, Shotgun) {
 
   auto p_fmat = xgboost::RandomDataGenerator(kRows, kCols, 0).GenerateDMatrix();
 
-  auto lparam = xgboost::CreateEmptyGenericParam(GPUIDX);
+  auto ctx = xgboost::CreateEmptyGenericParam(GPUIDX);
   LearnerModelParam mparam{MakeMP(kCols, .5, 1)};
 
   {
-    auto updater = std::unique_ptr<xgboost::LinearUpdater>(
-        xgboost::LinearUpdater::Create("shotgun", &lparam));
+    auto updater =
+        std::unique_ptr<xgboost::LinearUpdater>(xgboost::LinearUpdater::Create("shotgun", &ctx));
     updater->Configure({{"eta", "1."}});
     xgboost::HostDeviceVector<xgboost::GradientPair> gpair(
         p_fmat->Info().num_row_, xgboost::GradientPair(-5, 1.0));
@@ -31,11 +31,10 @@ TEST(Linear, Shotgun) {
     updater->Update(&gpair, p_fmat.get(), &model, gpair.Size());
 
     ASSERT_EQ(model.Bias()[0], 5.0f);
-
   }
   {
     auto updater = std::unique_ptr<xgboost::LinearUpdater>(
-        xgboost::LinearUpdater::Create("shotgun", &lparam));
+        xgboost::LinearUpdater::Create("shotgun", &ctx));
     EXPECT_ANY_THROW(updater->Configure({{"feature_selector", "random"}}));
   }
 }
@@ -50,11 +49,11 @@ TEST(Linear, coordinate) {
 
   auto p_fmat = xgboost::RandomDataGenerator(kRows, kCols, 0).GenerateDMatrix();
 
-  auto lparam = xgboost::CreateEmptyGenericParam(GPUIDX);
+  auto ctx = xgboost::CreateEmptyGenericParam(GPUIDX);
   LearnerModelParam mparam{MakeMP(kCols, .5, 1)};
 
   auto updater = std::unique_ptr<xgboost::LinearUpdater>(
-      xgboost::LinearUpdater::Create("coord_descent", &lparam));
+      xgboost::LinearUpdater::Create("coord_descent", &ctx));
   updater->Configure({{"eta", "1."}});
   xgboost::HostDeviceVector<xgboost::GradientPair> gpair(
       p_fmat->Info().num_row_, xgboost::GradientPair(-5, 1.0));

tests/cpp/metric/test_auc.cc

@@ -5,8 +5,8 @@ namespace xgboost {
 namespace metric {
 
 TEST(Metric, DeclareUnifiedTest(BinaryAUC)) {
-  auto tparam = xgboost::CreateEmptyGenericParam(GPUIDX);
-  std::unique_ptr<Metric> uni_ptr {Metric::Create("auc", &tparam)};
+  auto ctx = xgboost::CreateEmptyGenericParam(GPUIDX);
+  std::unique_ptr<Metric> uni_ptr {Metric::Create("auc", &ctx)};
   Metric * metric = uni_ptr.get();
   ASSERT_STREQ(metric->Name(), "auc");
 
@@ -49,9 +49,9 @@ TEST(Metric, DeclareUnifiedTest(BinaryAUC)) {
 }
 
 TEST(Metric, DeclareUnifiedTest(MultiClassAUC)) {
-  auto tparam = CreateEmptyGenericParam(GPUIDX);
+  auto ctx = CreateEmptyGenericParam(GPUIDX);
   std::unique_ptr<Metric> uni_ptr{
-      Metric::Create("auc", &tparam)};
+      Metric::Create("auc", &ctx)};
   auto metric = uni_ptr.get();
 
   // MultiClass
@@ -115,8 +115,8 @@ TEST(Metric, DeclareUnifiedTest(MultiClassAUC)) {
 }
 
 TEST(Metric, DeclareUnifiedTest(RankingAUC)) {
-  auto tparam = CreateEmptyGenericParam(GPUIDX);
-  std::unique_ptr<Metric> metric{Metric::Create("auc", &tparam)};
+  auto ctx = CreateEmptyGenericParam(GPUIDX);
+  std::unique_ptr<Metric> metric{Metric::Create("auc", &ctx)};
 
   // single group
   EXPECT_NEAR(GetMetricEval(metric.get(), {0.7f, 0.2f, 0.3f, 0.6f},
@@ -153,9 +153,9 @@ TEST(Metric, DeclareUnifiedTest(RankingAUC)) {
 }
 
 TEST(Metric, DeclareUnifiedTest(PRAUC)) {
-  auto tparam = xgboost::CreateEmptyGenericParam(GPUIDX);
+  auto ctx = xgboost::CreateEmptyGenericParam(GPUIDX);
 
-  xgboost::Metric *metric = xgboost::Metric::Create("aucpr", &tparam);
+  xgboost::Metric *metric = xgboost::Metric::Create("aucpr", &ctx);
   ASSERT_STREQ(metric->Name(), "aucpr");
   EXPECT_NEAR(GetMetricEval(metric, {0, 0, 1, 1}, {0, 0, 1, 1}), 1, 1e-10);
   EXPECT_NEAR(GetMetricEval(metric, {0.1f, 0.9f, 0.1f, 0.9f}, {0, 0, 1, 1}),
@@ -194,9 +194,9 @@ TEST(Metric, DeclareUnifiedTest(PRAUC)) {
 }
 
 TEST(Metric, DeclareUnifiedTest(MultiClassPRAUC)) {
-  auto tparam = xgboost::CreateEmptyGenericParam(GPUIDX);
+  auto ctx = xgboost::CreateEmptyGenericParam(GPUIDX);
 
-  std::unique_ptr<Metric> metric{Metric::Create("aucpr", &tparam)};
+  std::unique_ptr<Metric> metric{Metric::Create("aucpr", &ctx)};
 
   float auc = 0;
   std::vector<float> labels {1.0f, 0.0f, 2.0f};
@@ -223,9 +223,9 @@ TEST(Metric, DeclareUnifiedTest(MultiClassPRAUC)) {
 }
 
 TEST(Metric, DeclareUnifiedTest(RankingPRAUC)) {
-  auto tparam = xgboost::CreateEmptyGenericParam(GPUIDX);
+  auto ctx = xgboost::CreateEmptyGenericParam(GPUIDX);
 
-  std::unique_ptr<Metric> metric{Metric::Create("aucpr", &tparam)};
+  std::unique_ptr<Metric> metric{Metric::Create("aucpr", &ctx)};
 
   std::vector<float> labels {1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f};
   std::vector<uint32_t> groups {0, 2, 6};

tests/cpp/metric/test_elementwise_metric.cc

@@ -13,8 +13,8 @@
 namespace xgboost {
 namespace {
 inline void CheckDeterministicMetricElementWise(StringView name, int32_t device) {
-  auto lparam = CreateEmptyGenericParam(device);
-  std::unique_ptr<Metric> metric{Metric::Create(name.c_str(), &lparam)};
+  auto ctx = CreateEmptyGenericParam(device);
+  std::unique_ptr<Metric> metric{Metric::Create(name.c_str(), &ctx)};
 
   HostDeviceVector<float> predts;
   size_t n_samples = 2048;
@@ -48,8 +48,8 @@ namespace xgboost {
 namespace metric {
 
 TEST(Metric, DeclareUnifiedTest(RMSE)) {
-  auto lparam = xgboost::CreateEmptyGenericParam(GPUIDX);
-  xgboost::Metric * metric = xgboost::Metric::Create("rmse", &lparam);
+  auto ctx = xgboost::CreateEmptyGenericParam(GPUIDX);
+  xgboost::Metric * metric = xgboost::Metric::Create("rmse", &ctx);
   metric->Configure({});
   ASSERT_STREQ(metric->Name(), "rmse");
   EXPECT_NEAR(GetMetricEval(metric, {0, 1}, {0, 1}), 0, 1e-10);
@@ -73,8 +73,8 @@ TEST(Metric, DeclareUnifiedTest(RMSE)) {
 }
 
 TEST(Metric, DeclareUnifiedTest(RMSLE)) {
-  auto lparam = xgboost::CreateEmptyGenericParam(GPUIDX);
-  xgboost::Metric * metric = xgboost::Metric::Create("rmsle", &lparam);
+  auto ctx = xgboost::CreateEmptyGenericParam(GPUIDX);
+  xgboost::Metric * metric = xgboost::Metric::Create("rmsle", &ctx);
   metric->Configure({});
   ASSERT_STREQ(metric->Name(), "rmsle");
   EXPECT_NEAR(GetMetricEval(metric, {0, 1}, {0, 1}), 0, 1e-10);
@@ -98,8 +98,8 @@ TEST(Metric, DeclareUnifiedTest(RMSLE)) {
 }
 
 TEST(Metric, DeclareUnifiedTest(MAE)) {
-  auto lparam = xgboost::CreateEmptyGenericParam(GPUIDX);
-  xgboost::Metric * metric = xgboost::Metric::Create("mae", &lparam);
+  auto ctx = xgboost::CreateEmptyGenericParam(GPUIDX);
+  xgboost::Metric * metric = xgboost::Metric::Create("mae", &ctx);
   metric->Configure({});
   ASSERT_STREQ(metric->Name(), "mae");
   EXPECT_NEAR(GetMetricEval(metric, {0, 1}, {0, 1}), 0, 1e-10);
@@ -123,8 +123,8 @@ TEST(Metric, DeclareUnifiedTest(MAE)) {
 }
 
 TEST(Metric, DeclareUnifiedTest(MAPE)) {
-  auto lparam = xgboost::CreateEmptyGenericParam(GPUIDX);
-  xgboost::Metric * metric = xgboost::Metric::Create("mape", &lparam);
+  auto ctx = xgboost::CreateEmptyGenericParam(GPUIDX);
+  xgboost::Metric * metric = xgboost::Metric::Create("mape", &ctx);
   metric->Configure({});
   ASSERT_STREQ(metric->Name(), "mape");
   EXPECT_NEAR(GetMetricEval(metric, {150, 300}, {100, 200}), 0.5f, 1e-10);
@@ -148,8 +148,8 @@ TEST(Metric, DeclareUnifiedTest(MAPE)) {
 }
 
 TEST(Metric, DeclareUnifiedTest(MPHE)) {
-  auto lparam = xgboost::CreateEmptyGenericParam(GPUIDX);
-  std::unique_ptr<xgboost::Metric> metric{xgboost::Metric::Create("mphe", &lparam)};
+  auto ctx = xgboost::CreateEmptyGenericParam(GPUIDX);
+  std::unique_ptr<xgboost::Metric> metric{xgboost::Metric::Create("mphe", &ctx)};
   metric->Configure({});
   ASSERT_STREQ(metric->Name(), "mphe");
   EXPECT_NEAR(GetMetricEval(metric.get(), {0, 1}, {0, 1}), 0, 1e-10);
@@ -179,8 +179,8 @@ TEST(Metric, DeclareUnifiedTest(MPHE)) {
 }
 
 TEST(Metric, DeclareUnifiedTest(LogLoss)) {
-  auto lparam = xgboost::CreateEmptyGenericParam(GPUIDX);
-  xgboost::Metric * metric = xgboost::Metric::Create("logloss", &lparam);
+  auto ctx = xgboost::CreateEmptyGenericParam(GPUIDX);
+  xgboost::Metric * metric = xgboost::Metric::Create("logloss", &ctx);
   metric->Configure({});
   ASSERT_STREQ(metric->Name(), "logloss");
   EXPECT_NEAR(GetMetricEval(metric, {0, 1}, {0, 1}), 0, 1e-10);
@@ -208,8 +208,8 @@ TEST(Metric, DeclareUnifiedTest(LogLoss)) {
 }
 
 TEST(Metric, DeclareUnifiedTest(Error)) {
-  auto lparam = xgboost::CreateEmptyGenericParam(GPUIDX);
-  xgboost::Metric * metric = xgboost::Metric::Create("error", &lparam);
+  auto ctx = xgboost::CreateEmptyGenericParam(GPUIDX);
+  xgboost::Metric * metric = xgboost::Metric::Create("error", &ctx);
   metric->Configure({});
   ASSERT_STREQ(metric->Name(), "error");
   EXPECT_NEAR(GetMetricEval(metric, {0, 1}, {0, 1}), 0, 1e-10);
@@ -228,16 +228,16 @@ TEST(Metric, DeclareUnifiedTest(Error)) {
                             {  1,   2,   9,   8}),
               0.55f, 0.001f);
 
-  EXPECT_ANY_THROW(xgboost::Metric::Create("error@abc", &lparam));
+  EXPECT_ANY_THROW(xgboost::Metric::Create("error@abc", &ctx));
   delete metric;
 
-  metric = xgboost::Metric::Create("error@0.5f", &lparam);
+  metric = xgboost::Metric::Create("error@0.5f", &ctx);
   metric->Configure({});
   EXPECT_STREQ(metric->Name(), "error");
 
   delete metric;
 
-  metric = xgboost::Metric::Create("error@0.1", &lparam);
+  metric = xgboost::Metric::Create("error@0.1", &ctx);
   metric->Configure({});
   ASSERT_STREQ(metric->Name(), "error@0.1");
   EXPECT_STREQ(metric->Name(), "error@0.1");
@@ -262,8 +262,8 @@ TEST(Metric, DeclareUnifiedTest(Error)) {
 }
 
 TEST(Metric, DeclareUnifiedTest(PoissionNegLogLik)) {
-  auto lparam = xgboost::CreateEmptyGenericParam(GPUIDX);
-  xgboost::Metric * metric = xgboost::Metric::Create("poisson-nloglik", &lparam);
+  auto ctx = xgboost::CreateEmptyGenericParam(GPUIDX);
+  xgboost::Metric * metric = xgboost::Metric::Create("poisson-nloglik", &ctx);
   metric->Configure({});
   ASSERT_STREQ(metric->Name(), "poisson-nloglik");
   EXPECT_NEAR(GetMetricEval(metric, {0, 1}, {0, 1}), 0.5f, 1e-10);

tests/cpp/metric/test_metric.cc

@@ -4,16 +4,16 @@
 #include "../helpers.h"
 
 TEST(Metric, UnknownMetric) {
-  auto tparam = xgboost::CreateEmptyGenericParam(GPUIDX);
+  auto ctx = xgboost::CreateEmptyGenericParam(GPUIDX);
   xgboost::Metric * metric = nullptr;
-  EXPECT_ANY_THROW(metric = xgboost::Metric::Create("unknown_name", &tparam));
-  EXPECT_NO_THROW(metric = xgboost::Metric::Create("rmse", &tparam));
+  EXPECT_ANY_THROW(metric = xgboost::Metric::Create("unknown_name", &ctx));
+  EXPECT_NO_THROW(metric = xgboost::Metric::Create("rmse", &ctx));
   if (metric) {
     delete metric;
   }
   metric = nullptr;
-  EXPECT_ANY_THROW(metric = xgboost::Metric::Create("unknown_name@1", &tparam));
-  EXPECT_NO_THROW(metric = xgboost::Metric::Create("error@0.5f", &tparam));
+  EXPECT_ANY_THROW(metric = xgboost::Metric::Create("unknown_name@1", &ctx));
+  EXPECT_NO_THROW(metric = xgboost::Metric::Create("error@0.5f", &ctx));
   if (metric) {
     delete metric;
   }

tests/cpp/metric/test_multiclass_metric.cc

@@ -6,8 +6,8 @@
 
 namespace xgboost {
 inline void CheckDeterministicMetricMultiClass(StringView name, int32_t device) {
-  auto lparam = CreateEmptyGenericParam(device);
-  std::unique_ptr<Metric> metric{Metric::Create(name.c_str(), &lparam)};
+  auto ctx = CreateEmptyGenericParam(device);
+  std::unique_ptr<Metric> metric{Metric::Create(name.c_str(), &ctx)};
 
   HostDeviceVector<float> predts;
   MetaInfo info;
@@ -43,9 +43,9 @@ inline void CheckDeterministicMetricMultiClass(StringView name, int32_t device)
 }  // namespace xgboost
 
 inline void TestMultiClassError(int device) {
-  auto lparam = xgboost::CreateEmptyGenericParam(device);
-  lparam.gpu_id = device;
-  xgboost::Metric * metric = xgboost::Metric::Create("merror", &lparam);
+  auto ctx = xgboost::CreateEmptyGenericParam(device);
+  ctx.gpu_id = device;
+  xgboost::Metric * metric = xgboost::Metric::Create("merror", &ctx);
   metric->Configure({});
   ASSERT_STREQ(metric->Name(), "merror");
   EXPECT_ANY_THROW(GetMetricEval(metric, {0}, {0, 0}));
@@ -64,9 +64,9 @@ TEST(Metric, DeclareUnifiedTest(MultiClassError)) {
 }
 
 inline void TestMultiClassLogLoss(int device) {
-  auto lparam = xgboost::CreateEmptyGenericParam(device);
-  lparam.gpu_id = device;
-  xgboost::Metric * metric = xgboost::Metric::Create("mlogloss", &lparam);
+  auto ctx = xgboost::CreateEmptyGenericParam(device);
+  ctx.gpu_id = device;
+  xgboost::Metric * metric = xgboost::Metric::Create("mlogloss", &ctx);
   metric->Configure({});
   ASSERT_STREQ(metric->Name(), "mlogloss");
   EXPECT_ANY_THROW(GetMetricEval(metric, {0}, {0, 0}));

tests/cpp/metric/test_rank_metric.cc

@@ -5,9 +5,9 @@
 
 #if !defined(__CUDACC__)
 TEST(Metric, AMS) {
-  auto tparam = xgboost::CreateEmptyGenericParam(GPUIDX);
-  EXPECT_ANY_THROW(xgboost::Metric::Create("ams", &tparam));
-  xgboost::Metric * metric = xgboost::Metric::Create("ams@0.5f", &tparam);
+  auto ctx = xgboost::CreateEmptyGenericParam(GPUIDX);
+  EXPECT_ANY_THROW(xgboost::Metric::Create("ams", &ctx));
+  xgboost::Metric* metric = xgboost::Metric::Create("ams@0.5f", &ctx);
   ASSERT_STREQ(metric->Name(), "ams@0.5");
   EXPECT_NEAR(GetMetricEval(metric, {0, 1}, {0, 1}), 0.311f, 0.001f);
   EXPECT_NEAR(GetMetricEval(metric,
@@ -16,7 +16,7 @@ TEST(Metric, AMS) {
               0.29710f, 0.001f);
 
   delete metric;
-  metric = xgboost::Metric::Create("ams@0", &tparam);
+  metric = xgboost::Metric::Create("ams@0", &ctx);
   ASSERT_STREQ(metric->Name(), "ams@0");
   EXPECT_NEAR(GetMetricEval(metric, {0, 1}, {0, 1}), 0.311f, 0.001f);
 
@@ -28,8 +28,8 @@ TEST(Metric, DeclareUnifiedTest(Precision)) {
   // When the limit for precision is not given, it takes the limit at
   // std::numeric_limits<unsigned>::max(); hence all values are very small
   // NOTE(AbdealiJK): Maybe this should be fixed to be num_row by default.
-  auto tparam = xgboost::CreateEmptyGenericParam(GPUIDX);
-  xgboost::Metric * metric = xgboost::Metric::Create("pre", &tparam);
+  auto ctx = xgboost::CreateEmptyGenericParam(GPUIDX);
+  xgboost::Metric * metric = xgboost::Metric::Create("pre", &ctx);
   ASSERT_STREQ(metric->Name(), "pre");
   EXPECT_NEAR(GetMetricEval(metric, {0, 1}, {0, 1}), 0, 1e-7);
   EXPECT_NEAR(GetMetricEval(metric,
@@ -38,7 +38,7 @@ TEST(Metric, DeclareUnifiedTest(Precision)) {
               0, 1e-7);
 
   delete metric;
-  metric = xgboost::Metric::Create("pre@2", &tparam);
+  metric = xgboost::Metric::Create("pre@2", &ctx);
   ASSERT_STREQ(metric->Name(), "pre@2");
   EXPECT_NEAR(GetMetricEval(metric, {0, 1}, {0, 1}), 0.5f, 1e-7);
   EXPECT_NEAR(GetMetricEval(metric,
@@ -52,8 +52,8 @@ TEST(Metric, DeclareUnifiedTest(Precision)) {
 }
 
 TEST(Metric, DeclareUnifiedTest(NDCG)) {
-  auto tparam = xgboost::CreateEmptyGenericParam(GPUIDX);
-  xgboost::Metric * metric = xgboost::Metric::Create("ndcg", &tparam);
+  auto ctx = xgboost::CreateEmptyGenericParam(GPUIDX);
+  xgboost::Metric * metric = xgboost::Metric::Create("ndcg", &ctx);
   ASSERT_STREQ(metric->Name(), "ndcg");
   EXPECT_ANY_THROW(GetMetricEval(metric, {0, 1}, {}));
   EXPECT_NEAR(GetMetricEval(metric,
@@ -66,7 +66,7 @@ TEST(Metric, DeclareUnifiedTest(NDCG)) {
               0.6509f, 0.001f);
 
   delete metric;
-  metric = xgboost::Metric::Create("ndcg@2", &tparam);
+  metric = xgboost::Metric::Create("ndcg@2", &ctx);
   ASSERT_STREQ(metric->Name(), "ndcg@2");
   EXPECT_NEAR(GetMetricEval(metric, {0, 1}, {0, 1}), 1, 1e-10);
   EXPECT_NEAR(GetMetricEval(metric,
@@ -75,7 +75,7 @@ TEST(Metric, DeclareUnifiedTest(NDCG)) {
               0.3868f, 0.001f);
 
   delete metric;
-  metric = xgboost::Metric::Create("ndcg@-", &tparam);
+  metric = xgboost::Metric::Create("ndcg@-", &ctx);
   ASSERT_STREQ(metric->Name(), "ndcg-");
   EXPECT_NEAR(GetMetricEval(metric,
                             xgboost::HostDeviceVector<xgboost::bst_float>{},
@@ -86,7 +86,7 @@ TEST(Metric, DeclareUnifiedTest(NDCG)) {
                             {  0,   0,   1,   1}),
               0.6509f, 0.001f);
   delete metric;
-  metric = xgboost::Metric::Create("ndcg-", &tparam);
+  metric = xgboost::Metric::Create("ndcg-", &ctx);
   ASSERT_STREQ(metric->Name(), "ndcg-");
   EXPECT_NEAR(GetMetricEval(metric,
                             xgboost::HostDeviceVector<xgboost::bst_float>{},
@@ -98,7 +98,7 @@ TEST(Metric, DeclareUnifiedTest(NDCG)) {
               0.6509f, 0.001f);
 
   delete metric;
-  metric = xgboost::Metric::Create("ndcg@2-", &tparam);
+  metric = xgboost::Metric::Create("ndcg@2-", &ctx);
   ASSERT_STREQ(metric->Name(), "ndcg@2-");
   EXPECT_NEAR(GetMetricEval(metric, {0, 1}, {0, 1}), 1, 1e-10);
   EXPECT_NEAR(GetMetricEval(metric,
@@ -110,8 +110,8 @@ TEST(Metric, DeclareUnifiedTest(NDCG)) {
 }
 
 TEST(Metric, DeclareUnifiedTest(MAP)) {
-  auto tparam = xgboost::CreateEmptyGenericParam(GPUIDX);
-  xgboost::Metric * metric = xgboost::Metric::Create("map", &tparam);
+  auto ctx = xgboost::CreateEmptyGenericParam(GPUIDX);
+  xgboost::Metric * metric = xgboost::Metric::Create("map", &ctx);
   ASSERT_STREQ(metric->Name(), "map");
   EXPECT_NEAR(GetMetricEval(metric, {0, 1}, {0, 1}), 1, 1e-10);
   EXPECT_NEAR(GetMetricEval(metric,
@@ -131,21 +131,21 @@ TEST(Metric, DeclareUnifiedTest(MAP)) {
               0.8611f, 0.001f);
 
   delete metric;
-  metric = xgboost::Metric::Create("map@-", &tparam);
+  metric = xgboost::Metric::Create("map@-", &ctx);
   ASSERT_STREQ(metric->Name(), "map-");
   EXPECT_NEAR(GetMetricEval(metric,
                             xgboost::HostDeviceVector<xgboost::bst_float>{},
                             {}), 0, 1e-10);
 
   delete metric;
-  metric = xgboost::Metric::Create("map-", &tparam);
+  metric = xgboost::Metric::Create("map-", &ctx);
   ASSERT_STREQ(metric->Name(), "map-");
   EXPECT_NEAR(GetMetricEval(metric,
                             xgboost::HostDeviceVector<xgboost::bst_float>{},
                             {}), 0, 1e-10);
 
   delete metric;
-  metric = xgboost::Metric::Create("map@2", &tparam);
+  metric = xgboost::Metric::Create("map@2", &ctx);
   ASSERT_STREQ(metric->Name(), "map@2");
   EXPECT_NEAR(GetMetricEval(metric, {0, 1}, {0, 1}), 1, 1e-10);
   EXPECT_NEAR(GetMetricEval(metric,

tests/cpp/metric/test_survival_metric.cu

@@ -13,8 +13,8 @@ namespace xgboost {
 namespace common {
 namespace {
 inline void CheckDeterministicMetricElementWise(StringView name, int32_t device) {
-  auto lparam = CreateEmptyGenericParam(device);
-  std::unique_ptr<Metric> metric{Metric::Create(name.c_str(), &lparam)};
+  auto ctx = CreateEmptyGenericParam(device);
+  std::unique_ptr<Metric> metric{Metric::Create(name.c_str(), &ctx)};
   metric->Configure(Args{});
 
   HostDeviceVector<float> predts;
@@ -48,7 +48,7 @@ inline void CheckDeterministicMetricElementWise(StringView name, int32_t device)
 }  // anonymous namespace
 
 TEST(Metric, DeclareUnifiedTest(AFTNegLogLik)) {
-  auto lparam = xgboost::CreateEmptyGenericParam(GPUIDX);
+  auto ctx = xgboost::CreateEmptyGenericParam(GPUIDX);
 
   /**
    * Test aggregate output from the AFT metric over a small test data set.
@@ -69,7 +69,7 @@ TEST(Metric, DeclareUnifiedTest(AFTNegLogLik)) {
   };
   for (const auto& test_case : std::vector<TestCase>{ {"normal", 2.1508f}, {"logistic", 2.1804f},
                                                       {"extreme", 2.0706f} }) {
-    std::unique_ptr<Metric> metric(Metric::Create("aft-nloglik", &lparam));
+    std::unique_ptr<Metric> metric(Metric::Create("aft-nloglik", &ctx));
     metric->Configure({ {"aft_loss_distribution", test_case.dist_type},
                         {"aft_loss_distribution_scale", "1.0"} });
     EXPECT_NEAR(metric->Eval(preds, info), test_case.reference_value, 1e-4);
@@ -77,7 +77,7 @@ TEST(Metric, DeclareUnifiedTest(AFTNegLogLik)) {
 }
 
 TEST(Metric, DeclareUnifiedTest(IntervalRegressionAccuracy)) {
-  auto lparam = xgboost::CreateEmptyGenericParam(GPUIDX);
+  auto ctx = xgboost::CreateEmptyGenericParam(GPUIDX);
 
   MetaInfo info;
   info.num_row_ = 4;
@@ -86,7 +86,7 @@ TEST(Metric, DeclareUnifiedTest(IntervalRegressionAccuracy)) {
   info.weights_.HostVector() = std::vector<bst_float>();
   HostDeviceVector<bst_float> preds(4, std::log(60.0f));
 
-  std::unique_ptr<Metric> metric(Metric::Create("interval-regression-accuracy", &lparam));
+  std::unique_ptr<Metric> metric(Metric::Create("interval-regression-accuracy", &ctx));
   EXPECT_FLOAT_EQ(metric->Eval(preds, info), 0.75f);
   info.labels_lower_bound_.HostVector()[2] = 70.0f;
   EXPECT_FLOAT_EQ(metric->Eval(preds, info), 0.50f);
@@ -102,8 +102,8 @@ TEST(Metric, DeclareUnifiedTest(IntervalRegressionAccuracy)) {
 
 // Test configuration of AFT metric
 TEST(AFTNegLogLikMetric, DeclareUnifiedTest(Configuration)) {
-  auto lparam = xgboost::CreateEmptyGenericParam(GPUIDX);
-  std::unique_ptr<Metric> metric(Metric::Create("aft-nloglik", &lparam));
+  auto ctx = xgboost::CreateEmptyGenericParam(GPUIDX);
+  std::unique_ptr<Metric> metric(Metric::Create("aft-nloglik", &ctx));
   metric->Configure({{"aft_loss_distribution", "normal"}, {"aft_loss_distribution_scale", "10"}});
 
   // Configuration round-trip test

tests/cpp/objective/test_aft_obj.cc

@@ -16,8 +16,8 @@ namespace xgboost {
 namespace common {
 
 TEST(Objective, DeclareUnifiedTest(AFTObjConfiguration)) {
-  auto lparam = CreateEmptyGenericParam(GPUIDX);
-  std::unique_ptr<ObjFunction> objective(ObjFunction::Create("survival:aft", &lparam));
+  auto ctx = CreateEmptyGenericParam(GPUIDX);
+  std::unique_ptr<ObjFunction> objective(ObjFunction::Create("survival:aft", &ctx));
   objective->Configure({ {"aft_loss_distribution", "logistic"},
                           {"aft_loss_distribution_scale", "5"} });
 
@@ -77,8 +77,8 @@ static inline void CheckGPairOverGridPoints(
 }
 
 TEST(Objective, DeclareUnifiedTest(AFTObjGPairUncensoredLabels)) {
-  auto lparam = CreateEmptyGenericParam(GPUIDX);
-  std::unique_ptr<ObjFunction> obj(ObjFunction::Create("survival:aft", &lparam));
+  auto ctx = CreateEmptyGenericParam(GPUIDX);
+  std::unique_ptr<ObjFunction> obj(ObjFunction::Create("survival:aft", &ctx));
 
   CheckGPairOverGridPoints(obj.get(), 100.0f, 100.0f, "normal",
     { -3.9120f, -3.4013f, -2.8905f, -2.3798f, -1.8691f, -1.3583f, -0.8476f, -0.3368f, 0.1739f,
@@ -101,8 +101,8 @@ TEST(Objective, DeclareUnifiedTest(AFTObjGPairUncensoredLabels)) {
 }
 
 TEST(Objective, DeclareUnifiedTest(AFTObjGPairLeftCensoredLabels)) {
-  auto lparam = CreateEmptyGenericParam(GPUIDX);
-  std::unique_ptr<ObjFunction> obj(ObjFunction::Create("survival:aft", &lparam));
+  auto ctx = CreateEmptyGenericParam(GPUIDX);
+  std::unique_ptr<ObjFunction> obj(ObjFunction::Create("survival:aft", &ctx));
 
   CheckGPairOverGridPoints(obj.get(), 0.0f, 20.0f, "normal",
     { 0.0285f, 0.0832f, 0.1951f, 0.3804f, 0.6403f, 0.9643f, 1.3379f, 1.7475f, 2.1828f, 2.6361f,
@@ -122,8 +122,8 @@ TEST(Objective, DeclareUnifiedTest(AFTObjGPairLeftCensoredLabels)) {
 }
 
 TEST(Objective, DeclareUnifiedTest(AFTObjGPairRightCensoredLabels)) {
-  auto lparam = CreateEmptyGenericParam(GPUIDX);
-  std::unique_ptr<ObjFunction> obj(ObjFunction::Create("survival:aft", &lparam));
+  auto ctx = CreateEmptyGenericParam(GPUIDX);
+  std::unique_ptr<ObjFunction> obj(ObjFunction::Create("survival:aft", &ctx));
 
   CheckGPairOverGridPoints(obj.get(), 60.0f, std::numeric_limits<float>::infinity(), "normal",
     { -3.6583f, -3.1815f, -2.7135f, -2.2577f, -1.8190f, -1.4044f, -1.0239f, -0.6905f, -0.4190f,
@@ -146,8 +146,8 @@ TEST(Objective, DeclareUnifiedTest(AFTObjGPairRightCensoredLabels)) {
 }
 
 TEST(Objective, DeclareUnifiedTest(AFTObjGPairIntervalCensoredLabels)) {
-  auto lparam = CreateEmptyGenericParam(GPUIDX);
-  std::unique_ptr<ObjFunction> obj(ObjFunction::Create("survival:aft", &lparam));
+  auto ctx = CreateEmptyGenericParam(GPUIDX);
+  std::unique_ptr<ObjFunction> obj(ObjFunction::Create("survival:aft", &ctx));
 
   CheckGPairOverGridPoints(obj.get(), 16.0f, 200.0f, "normal",
     { -2.4435f, -1.9965f, -1.5691f, -1.1679f, -0.7990f, -0.4649f, -0.1596f, 0.1336f, 0.4370f,

tests/cpp/objective/test_hinge.cc

@@ -1,14 +1,14 @@
 // Copyright by Contributors
 #include <xgboost/objective.h>
-#include <xgboost/generic_parameters.h>
+#include <xgboost/context.h>
 #include <limits>
 
 #include "../helpers.h"
 
 TEST(Objective, DeclareUnifiedTest(HingeObj)) {
-  xgboost::GenericParameter tparam = xgboost::CreateEmptyGenericParam(GPUIDX);
+  xgboost::Context ctx = xgboost::CreateEmptyGenericParam(GPUIDX);
   std::unique_ptr<xgboost::ObjFunction> obj {
-    xgboost::ObjFunction::Create("binary:hinge", &tparam)
+    xgboost::ObjFunction::Create("binary:hinge", &ctx)
   };
 
   xgboost::bst_float eps = std::numeric_limits<xgboost::bst_float>::min();

tests/cpp/objective/test_multiclass_obj.cc

@@ -2,17 +2,17 @@
  * Copyright 2018-2019 XGBoost contributors
  */
 #include <xgboost/objective.h>
-#include <xgboost/generic_parameters.h>
+#include <xgboost/context.h>
 #include "../../src/common/common.h"
 #include "../helpers.h"
 
 namespace xgboost {
 
 TEST(Objective, DeclareUnifiedTest(SoftmaxMultiClassObjGPair)) {
-  GenericParameter lparam = CreateEmptyGenericParam(GPUIDX);
+  Context ctx = CreateEmptyGenericParam(GPUIDX);
   std::vector<std::pair<std::string, std::string>> args {{"num_class", "3"}};
   std::unique_ptr<ObjFunction> obj {
-    ObjFunction::Create("multi:softmax", &lparam)
+    ObjFunction::Create("multi:softmax", &ctx)
   };
 
   obj->Configure(args);
@@ -36,11 +36,11 @@ TEST(Objective, DeclareUnifiedTest(SoftmaxMultiClassObjGPair)) {
 }
 
 TEST(Objective, DeclareUnifiedTest(SoftmaxMultiClassBasic)) {
-  auto lparam = CreateEmptyGenericParam(GPUIDX);
+  auto ctx = CreateEmptyGenericParam(GPUIDX);
   std::vector<std::pair<std::string, std::string>> args{
-    std::pair<std::string, std::string>("num_class", "3")};
+      std::pair<std::string, std::string>("num_class", "3")};
 
-  std::unique_ptr<ObjFunction> obj { ObjFunction::Create("multi:softmax", &lparam) };
+  std::unique_ptr<ObjFunction> obj{ObjFunction::Create("multi:softmax", &ctx)};
   obj->Configure(args);
   CheckConfigReload(obj, "multi:softmax");
 
@@ -57,12 +57,12 @@ TEST(Objective, DeclareUnifiedTest(SoftmaxMultiClassBasic)) {
 }
 
 TEST(Objective, DeclareUnifiedTest(SoftprobMultiClassBasic)) {
-  GenericParameter lparam = CreateEmptyGenericParam(GPUIDX);
+  Context ctx = CreateEmptyGenericParam(GPUIDX);
   std::vector<std::pair<std::string, std::string>> args {
     std::pair<std::string, std::string>("num_class", "3")};
 
   std::unique_ptr<ObjFunction> obj {
-    ObjFunction::Create("multi:softprob", &lparam)
+    ObjFunction::Create("multi:softprob", &ctx)
   };
   obj->Configure(args);
   CheckConfigReload(obj, "multi:softprob");

tests/cpp/objective/test_objective.cc

@@ -1,13 +1,13 @@
 // Copyright by Contributors
 #include <gtest/gtest.h>
+#include <xgboost/context.h>
 #include <xgboost/objective.h>
-#include <xgboost/generic_parameters.h>
 
 #include "../helpers.h"
 
 TEST(Objective, UnknownFunction) {
   xgboost::ObjFunction* obj = nullptr;
-  xgboost::GenericParameter tparam;
+  xgboost::Context tparam;
   std::vector<std::pair<std::string, std::string>> args;
   tparam.UpdateAllowUnknown(args);
 
@@ -21,7 +21,7 @@ TEST(Objective, UnknownFunction) {
 namespace xgboost {
 TEST(Objective, PredTransform) {
   // Test that show PredTransform uses the same device with predictor.
-  xgboost::GenericParameter tparam;
+  xgboost::Context tparam;
   tparam.UpdateAllowUnknown(Args{{"gpu_id", "0"}});
   size_t n = 100;
 

tests/cpp/objective/test_ranking_obj.cc

@@ -1,18 +1,17 @@
 // Copyright by Contributors
-#include <xgboost/objective.h>
-#include <xgboost/generic_parameters.h>
-#include "../helpers.h"
+#include <xgboost/context.h>
 #include <xgboost/json.h>
+#include <xgboost/objective.h>
+
+#include "../helpers.h"
 
 namespace xgboost {
 
 TEST(Objective, DeclareUnifiedTest(PairwiseRankingGPair)) {
   std::vector<std::pair<std::string, std::string>> args;
-  xgboost::GenericParameter lparam = xgboost::CreateEmptyGenericParam(GPUIDX);
+  xgboost::Context ctx = xgboost::CreateEmptyGenericParam(GPUIDX);
 
-  std::unique_ptr<xgboost::ObjFunction> obj {
-    xgboost::ObjFunction::Create("rank:pairwise", &lparam)
-  };
+  std::unique_ptr<xgboost::ObjFunction> obj{xgboost::ObjFunction::Create("rank:pairwise", &ctx)};
   obj->Configure(args);
   CheckConfigReload(obj, "rank:pairwise");
 
@@ -37,12 +36,10 @@ TEST(Objective, DeclareUnifiedTest(PairwiseRankingGPair)) {
 }
 
 TEST(Objective, DeclareUnifiedTest(NDCG_JsonIO)) {
-  xgboost::GenericParameter tparam;
-  tparam.UpdateAllowUnknown(Args{});
+  xgboost::Context ctx;
+  ctx.UpdateAllowUnknown(Args{});
 
-  std::unique_ptr<xgboost::ObjFunction> obj {
-    xgboost::ObjFunction::Create("rank:ndcg", &tparam)
-  };
+  std::unique_ptr<xgboost::ObjFunction> obj{xgboost::ObjFunction::Create("rank:ndcg", &ctx)};
 
   obj->Configure(Args{});
   Json j_obj {Object()};
@@ -58,11 +55,9 @@ TEST(Objective, DeclareUnifiedTest(NDCG_JsonIO)) {
 
 TEST(Objective, DeclareUnifiedTest(PairwiseRankingGPairSameLabels)) {
   std::vector<std::pair<std::string, std::string>> args;
-  xgboost::GenericParameter lparam = xgboost::CreateEmptyGenericParam(GPUIDX);
+  xgboost::Context ctx = xgboost::CreateEmptyGenericParam(GPUIDX);
 
-  std::unique_ptr<ObjFunction> obj {
-    ObjFunction::Create("rank:pairwise", &lparam)
-  };
+  std::unique_ptr<ObjFunction> obj{ObjFunction::Create("rank:pairwise", &ctx)};
   obj->Configure(args);
   // No computation of gradient/hessian, as there is no diversity in labels
   CheckRankingObjFunction(obj,
@@ -78,11 +73,9 @@ TEST(Objective, DeclareUnifiedTest(PairwiseRankingGPairSameLabels)) {
 
 TEST(Objective, DeclareUnifiedTest(NDCGRankingGPair)) {
   std::vector<std::pair<std::string, std::string>> args;
-  xgboost::GenericParameter lparam = xgboost::CreateEmptyGenericParam(GPUIDX);
+  xgboost::Context ctx = xgboost::CreateEmptyGenericParam(GPUIDX);
 
-  std::unique_ptr<xgboost::ObjFunction> obj {
-    xgboost::ObjFunction::Create("rank:ndcg", &lparam)
-  };
+  std::unique_ptr<xgboost::ObjFunction> obj{xgboost::ObjFunction::Create("rank:ndcg", &ctx)};
   obj->Configure(args);
   CheckConfigReload(obj, "rank:ndcg");
 
@@ -107,11 +100,9 @@ TEST(Objective, DeclareUnifiedTest(NDCGRankingGPair)) {
 
 TEST(Objective, DeclareUnifiedTest(MAPRankingGPair)) {
   std::vector<std::pair<std::string, std::string>> args;
-  xgboost::GenericParameter lparam = xgboost::CreateEmptyGenericParam(GPUIDX);
+  xgboost::Context ctx = xgboost::CreateEmptyGenericParam(GPUIDX);
 
-  std::unique_ptr<xgboost::ObjFunction> obj {
-    xgboost::ObjFunction::Create("rank:map", &lparam)
-  };
+  std::unique_ptr<xgboost::ObjFunction> obj{xgboost::ObjFunction::Create("rank:map", &ctx)};
   obj->Configure(args);
   CheckConfigReload(obj, "rank:map");
 

tests/cpp/objective/test_regression_obj.cc

@@ -2,7 +2,7 @@
  * Copyright 2017-2022 XGBoost contributors
  */
 #include <gtest/gtest.h>
-#include <xgboost/generic_parameters.h>
+#include <xgboost/context.h>
 #include <xgboost/json.h>
 #include <xgboost/objective.h>
 
@@ -12,12 +12,10 @@
 namespace xgboost {
 
 TEST(Objective, DeclareUnifiedTest(LinearRegressionGPair)) {
-  GenericParameter tparam = CreateEmptyGenericParam(GPUIDX);
+  Context ctx = CreateEmptyGenericParam(GPUIDX);
   std::vector<std::pair<std::string, std::string>> args;
 
-  std::unique_ptr<ObjFunction> obj {
-    ObjFunction::Create("reg:squarederror", &tparam)
-  };
+  std::unique_ptr<ObjFunction> obj{ObjFunction::Create("reg:squarederror", &ctx)};
 
   obj->Configure(args);
   CheckObjFunction(obj,
@@ -36,10 +34,10 @@ TEST(Objective, DeclareUnifiedTest(LinearRegressionGPair)) {
 }
 
 TEST(Objective, DeclareUnifiedTest(SquaredLog)) {
-  GenericParameter tparam = CreateEmptyGenericParam(GPUIDX);
+  Context ctx = CreateEmptyGenericParam(GPUIDX);
   std::vector<std::pair<std::string, std::string>> args;
 
-  std::unique_ptr<ObjFunction> obj { ObjFunction::Create("reg:squaredlogerror", &tparam) };
+  std::unique_ptr<ObjFunction> obj{ObjFunction::Create("reg:squaredlogerror", &ctx)};
   obj->Configure(args);
   CheckConfigReload(obj, "reg:squaredlogerror");
 
@@ -59,10 +57,10 @@ TEST(Objective, DeclareUnifiedTest(SquaredLog)) {
 }
 
 TEST(Objective, DeclareUnifiedTest(PseudoHuber)) {
-  GenericParameter tparam = CreateEmptyGenericParam(GPUIDX);
+  Context ctx = CreateEmptyGenericParam(GPUIDX);
   Args args;
 
-  std::unique_ptr<ObjFunction> obj{ObjFunction::Create("reg:pseudohubererror", &tparam)};
+  std::unique_ptr<ObjFunction> obj{ObjFunction::Create("reg:pseudohubererror", &ctx)};
   obj->Configure(args);
   CheckConfigReload(obj, "reg:pseudohubererror");
 
@@ -88,9 +86,9 @@ TEST(Objective, DeclareUnifiedTest(PseudoHuber)) {
 }
 
 TEST(Objective, DeclareUnifiedTest(LogisticRegressionGPair)) {
-  GenericParameter tparam = CreateEmptyGenericParam(GPUIDX);
+  Context ctx = CreateEmptyGenericParam(GPUIDX);
   std::vector<std::pair<std::string, std::string>> args;
-  std::unique_ptr<ObjFunction> obj { ObjFunction::Create("reg:logistic", &tparam) };
+  std::unique_ptr<ObjFunction> obj{ObjFunction::Create("reg:logistic", &ctx)};
 
   obj->Configure(args);
   CheckConfigReload(obj, "reg:logistic");
@@ -104,11 +102,9 @@ TEST(Objective, DeclareUnifiedTest(LogisticRegressionGPair)) {
 }
 
 TEST(Objective, DeclareUnifiedTest(LogisticRegressionBasic)) {
-  GenericParameter lparam = CreateEmptyGenericParam(GPUIDX);
+  Context ctx = CreateEmptyGenericParam(GPUIDX);
   std::vector<std::pair<std::string, std::string>> args;
-  std::unique_ptr<ObjFunction> obj {
-    ObjFunction::Create("reg:logistic", &lparam)
-  };
+  std::unique_ptr<ObjFunction> obj{ObjFunction::Create("reg:logistic", &ctx)};
 
   obj->Configure(args);
   CheckConfigReload(obj, "reg:logistic");
@@ -135,10 +131,10 @@ TEST(Objective, DeclareUnifiedTest(LogisticRegressionBasic)) {
 }
 
 TEST(Objective, DeclareUnifiedTest(LogisticRawGPair)) {
-  GenericParameter lparam = CreateEmptyGenericParam(GPUIDX);
+  Context ctx = CreateEmptyGenericParam(GPUIDX);
   std::vector<std::pair<std::string, std::string>> args;
   std::unique_ptr<ObjFunction>  obj {
-    ObjFunction::Create("binary:logitraw", &lparam)
+    ObjFunction::Create("binary:logitraw", &ctx)
   };
   obj->Configure(args);
 
@@ -151,10 +147,10 @@ TEST(Objective, DeclareUnifiedTest(LogisticRawGPair)) {
 }
 
 TEST(Objective, DeclareUnifiedTest(PoissonRegressionGPair)) {
-  GenericParameter lparam = CreateEmptyGenericParam(GPUIDX);
+  Context ctx = CreateEmptyGenericParam(GPUIDX);
   std::vector<std::pair<std::string, std::string>> args;
   std::unique_ptr<ObjFunction> obj {
-    ObjFunction::Create("count:poisson", &lparam)
+    ObjFunction::Create("count:poisson", &ctx)
   };
 
   args.emplace_back(std::make_pair("max_delta_step", "0.1f"));
@@ -175,10 +171,10 @@ TEST(Objective, DeclareUnifiedTest(PoissonRegressionGPair)) {
 }
 
 TEST(Objective, DeclareUnifiedTest(PoissonRegressionBasic)) {
-  GenericParameter lparam = CreateEmptyGenericParam(GPUIDX);
+  Context ctx = CreateEmptyGenericParam(GPUIDX);
   std::vector<std::pair<std::string, std::string>> args;
   std::unique_ptr<ObjFunction> obj {
-    ObjFunction::Create("count:poisson", &lparam)
+    ObjFunction::Create("count:poisson", &ctx)
   };
 
   obj->Configure(args);
@@ -204,10 +200,10 @@ TEST(Objective, DeclareUnifiedTest(PoissonRegressionBasic)) {
 }
 
 TEST(Objective, DeclareUnifiedTest(GammaRegressionGPair)) {
-  GenericParameter lparam = CreateEmptyGenericParam(GPUIDX);
+  Context ctx = CreateEmptyGenericParam(GPUIDX);
   std::vector<std::pair<std::string, std::string>> args;
   std::unique_ptr<ObjFunction> obj {
-    ObjFunction::Create("reg:gamma", &lparam)
+    ObjFunction::Create("reg:gamma", &ctx)
   };
 
   obj->Configure(args);
@@ -226,11 +222,9 @@ TEST(Objective, DeclareUnifiedTest(GammaRegressionGPair)) {
 }
 
 TEST(Objective, DeclareUnifiedTest(GammaRegressionBasic)) {
-  GenericParameter lparam = CreateEmptyGenericParam(GPUIDX);
+  Context ctx = CreateEmptyGenericParam(GPUIDX);
   std::vector<std::pair<std::string, std::string>> args;
-  std::unique_ptr<ObjFunction> obj {
-    ObjFunction::Create("reg:gamma", &lparam)
-  };
+  std::unique_ptr<ObjFunction> obj{ObjFunction::Create("reg:gamma", &ctx)};
 
   obj->Configure(args);
   CheckConfigReload(obj, "reg:gamma");
@@ -257,11 +251,9 @@ TEST(Objective, DeclareUnifiedTest(GammaRegressionBasic)) {
 }
 
 TEST(Objective, DeclareUnifiedTest(TweedieRegressionGPair)) {
-  GenericParameter lparam = CreateEmptyGenericParam(GPUIDX);
+  Context ctx = CreateEmptyGenericParam(GPUIDX);
   std::vector<std::pair<std::string, std::string>> args;
-  std::unique_ptr<ObjFunction> obj {
-    ObjFunction::Create("reg:tweedie", &lparam)
-  };
+  std::unique_ptr<ObjFunction> obj{ObjFunction::Create("reg:tweedie", &ctx)};
 
   args.emplace_back(std::make_pair("tweedie_variance_power", "1.1f"));
   obj->Configure(args);
@@ -283,10 +275,9 @@ TEST(Objective, DeclareUnifiedTest(TweedieRegressionGPair)) {
 
 #if defined(__CUDACC__)
 TEST(Objective, CPU_vs_CUDA) {
-  GenericParameter lparam = CreateEmptyGenericParam(GPUIDX);
+  Context ctx = CreateEmptyGenericParam(GPUIDX);
 
-  ObjFunction * obj =
-      ObjFunction::Create("reg:squarederror", &lparam);
+  ObjFunction* obj = ObjFunction::Create("reg:squarederror", &ctx);
   HostDeviceVector<GradientPair> cpu_out_preds;
   HostDeviceVector<GradientPair> cuda_out_preds;
 
@@ -309,12 +300,12 @@ TEST(Objective, CPU_vs_CUDA) {
 
   {
     // CPU
-    lparam.gpu_id = -1;
+    ctx.gpu_id = -1;
     obj->GetGradient(preds, info, 0, &cpu_out_preds);
   }
   {
     // CUDA
-    lparam.gpu_id = 0;
+    ctx.gpu_id = 0;
     obj->GetGradient(preds, info, 0, &cuda_out_preds);
   }
 
@@ -335,11 +326,9 @@ TEST(Objective, CPU_vs_CUDA) {
 #endif
 
 TEST(Objective, DeclareUnifiedTest(TweedieRegressionBasic)) {
-  GenericParameter lparam = CreateEmptyGenericParam(GPUIDX);
+  Context ctx = CreateEmptyGenericParam(GPUIDX);
   std::vector<std::pair<std::string, std::string>> args;
-  std::unique_ptr<ObjFunction> obj {
-    ObjFunction::Create("reg:tweedie", &lparam)
-  };
+  std::unique_ptr<ObjFunction> obj{ObjFunction::Create("reg:tweedie", &ctx)};
 
   obj->Configure(args);
   CheckConfigReload(obj, "reg:tweedie");
@@ -366,11 +355,9 @@ TEST(Objective, DeclareUnifiedTest(TweedieRegressionBasic)) {
 // CoxRegression not implemented in GPU code, no need for testing.
 #if !defined(__CUDACC__)
 TEST(Objective, CoxRegressionGPair) {
-  GenericParameter lparam = CreateEmptyGenericParam(GPUIDX);
+  Context ctx = CreateEmptyGenericParam(GPUIDX);
   std::vector<std::pair<std::string, std::string>> args;
-  std::unique_ptr<ObjFunction> obj {
-    ObjFunction::Create("survival:cox", &lparam)
-  };
+  std::unique_ptr<ObjFunction> obj{ObjFunction::Create("survival:cox", &ctx)};
 
   obj->Configure(args);
   CheckObjFunction(obj,

tests/cpp/plugin/test_example_objective.cc

@@ -6,8 +6,8 @@
 namespace xgboost {
 
 TEST(Plugin, ExampleObjective) {
-  xgboost::GenericParameter tparam = CreateEmptyGenericParam(GPUIDX);
-  auto * obj = xgboost::ObjFunction::Create("mylogistic", &tparam);
+  xgboost::Context ctx = CreateEmptyGenericParam(GPUIDX);
+  auto* obj = xgboost::ObjFunction::Create("mylogistic", &ctx);
   ASSERT_EQ(obj->DefaultEvalMetric(), std::string{"logloss"});
   delete obj;
 }

tests/cpp/plugin/test_regression_obj_oneapi.cc

@@ -3,13 +3,13 @@
  */
 #include <gtest/gtest.h>
 #include <xgboost/objective.h>
-#include <xgboost/generic_parameters.h>
+#include <xgboost/context.h>
 #include <xgboost/json.h>
 #include "../helpers.h"
 namespace xgboost {
 
 TEST(Plugin, LinearRegressionGPairOneAPI) {
-  GenericParameter tparam = CreateEmptyGenericParam(0);
+  Context tparam = CreateEmptyGenericParam(0);
   std::vector<std::pair<std::string, std::string>> args;
 
   std::unique_ptr<ObjFunction> obj {
@@ -33,7 +33,7 @@ TEST(Plugin, LinearRegressionGPairOneAPI) {
 }
 
 TEST(Plugin, SquaredLogOneAPI) {
-  GenericParameter tparam = CreateEmptyGenericParam(0);
+  Context tparam = CreateEmptyGenericParam(0);
   std::vector<std::pair<std::string, std::string>> args;
 
   std::unique_ptr<ObjFunction> obj { ObjFunction::Create("reg:squaredlogerror_oneapi", &tparam) };
@@ -56,7 +56,7 @@ TEST(Plugin, SquaredLogOneAPI) {
 }
 
 TEST(Plugin, LogisticRegressionGPairOneAPI) {
-  GenericParameter tparam = CreateEmptyGenericParam(0);
+  Context tparam = CreateEmptyGenericParam(0);
   std::vector<std::pair<std::string, std::string>> args;
   std::unique_ptr<ObjFunction> obj { ObjFunction::Create("reg:logistic_oneapi", &tparam) };
 
@@ -72,7 +72,7 @@ TEST(Plugin, LogisticRegressionGPairOneAPI) {
 }
 
 TEST(Plugin, LogisticRegressionBasicOneAPI) {
-  GenericParameter lparam = CreateEmptyGenericParam(0);
+  Context lparam = CreateEmptyGenericParam(0);
   std::vector<std::pair<std::string, std::string>> args;
   std::unique_ptr<ObjFunction> obj {
     ObjFunction::Create("reg:logistic_oneapi", &lparam)
@@ -103,7 +103,7 @@ TEST(Plugin, LogisticRegressionBasicOneAPI) {
 }
 
 TEST(Plugin, LogisticRawGPairOneAPI) {
-  GenericParameter lparam = CreateEmptyGenericParam(0);
+  Context lparam = CreateEmptyGenericParam(0);
   std::vector<std::pair<std::string, std::string>> args;
   std::unique_ptr<ObjFunction>  obj {
     ObjFunction::Create("binary:logitraw_oneapi", &lparam)
@@ -120,12 +120,12 @@ TEST(Plugin, LogisticRawGPairOneAPI) {
 }
 
 TEST(Plugin, CPUvsOneAPI) {
-  GenericParameter lparam = CreateEmptyGenericParam(0);
+  Context ctx = CreateEmptyGenericParam(0);
 
   ObjFunction * obj_cpu =
-      ObjFunction::Create("reg:squarederror", &lparam);
+      ObjFunction::Create("reg:squarederror", &ctx);
   ObjFunction * obj_oneapi =
-      ObjFunction::Create("reg:squarederror_oneapi", &lparam);
+      ObjFunction::Create("reg:squarederror_oneapi", &ctx);
   HostDeviceVector<GradientPair> cpu_out_preds;
   HostDeviceVector<GradientPair> oneapi_out_preds;
 
@@ -148,12 +148,12 @@ TEST(Plugin, CPUvsOneAPI) {
 
   {
     // CPU
-    lparam.gpu_id = -1;
+    ctx.gpu_id = -1;
     obj_cpu->GetGradient(preds, info, 0, &cpu_out_preds);
   }
   {
     // oneapi
-    lparam.gpu_id = 0;
+    ctx.gpu_id = 0;
     obj_oneapi->GetGradient(preds, info, 0, &oneapi_out_preds);
   }
 

tests/cpp/predictor/test_cpu_predictor.cc

@@ -23,7 +23,7 @@ TEST(CpuPredictor, Basic) {
 
   LearnerModelParam mparam{MakeMP(kCols, .0, 1)};
 
-  GenericParameter ctx;
+  Context ctx;
   ctx.UpdateAllowUnknown(Args{});
   gbm::GBTreeModel model = CreateTestModel(&mparam, &ctx);
 
@@ -103,7 +103,7 @@ TEST(CpuPredictor, ExternalMemory) {
 
   LearnerModelParam mparam{MakeMP(dmat->Info().num_col_, .0, 1)};
 
-  GenericParameter ctx;
+  Context ctx;
   ctx.UpdateAllowUnknown(Args{});
   gbm::GBTreeModel model = CreateTestModel(&mparam, &ctx);
 

tests/cpp/predictor/test_predictor.cc

@@ -5,8 +5,8 @@
 #include "test_predictor.h"
 
 #include <gtest/gtest.h>
+#include <xgboost/context.h>
 #include <xgboost/data.h>
-#include <xgboost/generic_parameters.h>
 #include <xgboost/host_device_vector.h>
 #include <xgboost/predictor.h>
 
@@ -26,7 +26,7 @@ TEST(Predictor, PredictionCache) {
   // Add a cache that is immediately expired.
   auto add_cache = [&]() {
     auto p_dmat = RandomDataGenerator(kRows, kCols, 0).GenerateDMatrix();
-    container.Cache(p_dmat, GenericParameter::kCpuId);
+    container.Cache(p_dmat, Context::kCpuId);
     m = p_dmat.get();
   };
 
@@ -216,7 +216,7 @@ void TestCategoricalPrediction(std::string name) {
   float left_weight = 1.3f;
   float right_weight = 1.7f;
 
-  GenericParameter ctx;
+  Context ctx;
   ctx.UpdateAllowUnknown(Args{});
   gbm::GBTreeModel model(&mparam, &ctx);
   GBTreeModelForTest(&model, split_ind, split_cat, left_weight, right_weight);
@@ -257,7 +257,7 @@ void TestCategoricalPredictLeaf(StringView name) {
   float left_weight = 1.3f;
   float right_weight = 1.7f;
 
-  GenericParameter ctx;
+  Context ctx;
   ctx.UpdateAllowUnknown(Args{});
 
   gbm::GBTreeModel model(&mparam, &ctx);

tests/cpp/predictor/test_predictor.h

@@ -19,7 +19,7 @@ void TestPredictionFromGradientIndex(std::string name, size_t rows, size_t cols,
       std::unique_ptr<Predictor>(Predictor::Create(name, &lparam));
   predictor->Configure({});
 
-  GenericParameter ctx;
+  Context ctx;
   ctx.UpdateAllowUnknown(Args{});
   gbm::GBTreeModel model = CreateTestModel(&mparam, &ctx, kClasses);
 

tests/cpp/test_learner.cc

@@ -363,7 +363,7 @@ TEST(Learner, ConstantSeed) {
   CHECK_NE(v_0, v_1);
 
   {
-    rng.seed(GenericParameter::kDefaultSeed);
+    rng.seed(Context::kDefaultSeed);
     std::uniform_real_distribution<float> dist;
     float v_2 = dist(rng);
     CHECK_EQ(v_0, v_2);

tests/cpp/tree/gpu_hist/test_row_partitioner.cu

@@ -2,17 +2,17 @@
  * Copyright 2019-2022 by XGBoost Contributors
  */
 #include <gtest/gtest.h>
-#include <algorithm>
-#include <vector>
-
 #include <thrust/device_vector.h>
 #include <thrust/host_vector.h>
 #include <thrust/sequence.h>
 
+#include <algorithm>
+#include <vector>
+
 #include "../../../../src/tree/gpu_hist/row_partitioner.cuh"
 #include "../../helpers.h"
 #include "xgboost/base.h"
-#include "xgboost/generic_parameters.h"
+#include "xgboost/context.h"
 #include "xgboost/task.h"
 #include "xgboost/tree_model.h"
 

tests/cpp/tree/test_approx.cc

@@ -12,7 +12,7 @@ namespace xgboost {
 namespace tree {
 TEST(Approx, Partitioner) {
   size_t n_samples = 1024, n_features = 1, base_rowid = 0;
-  GenericParameter ctx;
+  Context ctx;
   CommonRowPartitioner partitioner{&ctx, n_samples, base_rowid};
   ASSERT_EQ(partitioner.base_rowid, base_rowid);
   ASSERT_EQ(partitioner.Size(), 1);
@@ -69,7 +69,7 @@ TEST(Approx, Partitioner) {
 namespace {
 void TestLeafPartition(size_t n_samples) {
   size_t const n_features = 2, base_rowid = 0;
-  GenericParameter ctx;
+  Context ctx;
   common::RowSetCollection row_set;
   CommonRowPartitioner partitioner{&ctx, n_samples, base_rowid};
 

tests/cpp/tree/test_gpu_hist.cu

@@ -18,7 +18,7 @@
 #include "../filesystem.h"  // dmlc::TemporaryDirectory
 #include "../helpers.h"
 #include "../histogram_helpers.h"
-#include "xgboost/generic_parameters.h"
+#include "xgboost/context.h"
 #include "xgboost/json.h"
 
 namespace xgboost {
@@ -170,9 +170,9 @@ void TestHistogramIndexImpl() {
 
   // Build 2 matrices and build a histogram maker with that
 
-  GenericParameter generic_param(CreateEmptyGenericParam(0));
-  tree::GPUHistMaker hist_maker{&generic_param,ObjInfo{ObjInfo::kRegression}},
-      hist_maker_ext{&generic_param,ObjInfo{ObjInfo::kRegression}};
+  Context ctx(CreateEmptyGenericParam(0));
+  tree::GPUHistMaker hist_maker{&ctx, ObjInfo{ObjInfo::kRegression}},
+      hist_maker_ext{&ctx, ObjInfo{ObjInfo::kRegression}};
   std::unique_ptr<DMatrix> hist_maker_dmat(
     CreateSparsePageDMatrixWithRC(kNRows, kNCols, 0, true));
 
@@ -239,8 +239,8 @@ void UpdateTree(HostDeviceVector<GradientPair>* gpair, DMatrix* dmat,
       {"sampling_method", sampling_method},
   };
 
-  GenericParameter generic_param(CreateEmptyGenericParam(0));
-  tree::GPUHistMaker hist_maker{&generic_param,ObjInfo{ObjInfo::kRegression}};
+  Context ctx(CreateEmptyGenericParam(0));
+  tree::GPUHistMaker hist_maker{&ctx,ObjInfo{ObjInfo::kRegression}};
   hist_maker.Configure(args);
 
   std::vector<HostDeviceVector<bst_node_t>> position(1);
@@ -384,9 +384,9 @@ TEST(GpuHist, ExternalMemoryWithSampling) {
 }
 
 TEST(GpuHist, ConfigIO) {
-  GenericParameter generic_param(CreateEmptyGenericParam(0));
+  Context ctx(CreateEmptyGenericParam(0));
   std::unique_ptr<TreeUpdater> updater{
-      TreeUpdater::Create("grow_gpu_hist", &generic_param, ObjInfo{ObjInfo::kRegression})};
+      TreeUpdater::Create("grow_gpu_hist", &ctx, ObjInfo{ObjInfo::kRegression})};
   updater->Configure(Args{});
 
   Json j_updater { Object() };
@@ -404,7 +404,7 @@ TEST(GpuHist, ConfigIO) {
 }
 
 TEST(GpuHist, MaxDepth) {
-  GenericParameter generic_param(CreateEmptyGenericParam(0));
+  Context ctx(CreateEmptyGenericParam(0));
   size_t constexpr kRows = 16;
   size_t constexpr kCols = 4;
   auto p_mat = RandomDataGenerator{kRows, kCols, 0}.GenerateDMatrix();

tests/cpp/tree/test_prediction_cache.cc

@@ -63,12 +63,12 @@ class TestPredictionCache : public ::testing::Test {
   void RunTest(std::string updater_name) {
     {
       omp_set_num_threads(1);
-      GenericParameter ctx;
+      Context ctx;
       ctx.InitAllowUnknown(Args{{"nthread", "8"}});
       if (updater_name == "grow_gpu_hist") {
         ctx.gpu_id = 0;
       } else {
-        ctx.gpu_id = GenericParameter::kCpuId;
+        ctx.gpu_id = Context::kCpuId;
       }
 
       std::unique_ptr<TreeUpdater> updater{
@@ -82,7 +82,7 @@ class TestPredictionCache : public ::testing::Test {
       HostDeviceVector<float> out_prediction_cached;
       out_prediction_cached.SetDevice(ctx.gpu_id);
       out_prediction_cached.Resize(n_samples_);
-      auto cache = linalg::VectorView<float>{ctx.gpu_id == GenericParameter::kCpuId
+      auto cache = linalg::VectorView<float>{ctx.gpu_id == Context::kCpuId
                                                  ? out_prediction_cached.HostSpan()
                                                  : out_prediction_cached.DeviceSpan(),
                                              {out_prediction_cached.Size()},

tests/cpp/tree/test_prune.cc

@@ -31,7 +31,7 @@ TEST(Updater, Prune) {
   std::shared_ptr<DMatrix> p_dmat {
     RandomDataGenerator{32, 10, 0}.GenerateDMatrix() };
 
-  auto lparam = CreateEmptyGenericParam(GPUIDX);
+  auto ctx = CreateEmptyGenericParam(GPUIDX);
 
   // prepare tree
   RegTree tree = RegTree();
@@ -39,7 +39,7 @@ TEST(Updater, Prune) {
   std::vector<RegTree*> trees {&tree};
   // prepare pruner
   std::unique_ptr<TreeUpdater> pruner(
-      TreeUpdater::Create("prune", &lparam, ObjInfo{ObjInfo::kRegression}));
+      TreeUpdater::Create("prune", &ctx, ObjInfo{ObjInfo::kRegression}));
   pruner->Configure(cfg);
 
   // loss_chg < min_split_loss;

tests/cpp/tree/test_quantile_hist.cc

@@ -20,7 +20,7 @@ namespace xgboost {
 namespace tree {
 TEST(QuantileHist, Partitioner) {
   size_t n_samples = 1024, n_features = 1, base_rowid = 0;
-  GenericParameter ctx;
+  Context ctx;
   ctx.InitAllowUnknown(Args{});
 
   CommonRowPartitioner partitioner{&ctx, n_samples, base_rowid};

tests/cpp/tree/test_refresh.cc

@@ -29,11 +29,11 @@ TEST(Updater, Refresh) {
       {"reg_lambda", "1"}};
 
   RegTree tree = RegTree();
-  auto lparam = CreateEmptyGenericParam(GPUIDX);
+  auto ctx = CreateEmptyGenericParam(GPUIDX);
   tree.param.UpdateAllowUnknown(cfg);
-  std::vector<RegTree*> trees {&tree};
+  std::vector<RegTree*> trees{&tree};
   std::unique_ptr<TreeUpdater> refresher(
-      TreeUpdater::Create("refresh", &lparam, ObjInfo{ObjInfo::kRegression}));
+      TreeUpdater::Create("refresh", &ctx, ObjInfo{ObjInfo::kRegression}));
 
   tree.ExpandNode(0, 2, 0.2f, false, 0.0, 0.2f, 0.8f, 0.0f, 0.0f,
                   /*left_sum=*/0.0f, /*right_sum=*/0.0f);

tests/cpp/tree/test_tree_stat.cc

@@ -67,8 +67,8 @@ class UpdaterEtaTest : public ::testing::Test {
   }
 
   void RunTest(std::string updater) {
-    GenericParameter ctx(updater == "grow_gpu_hist" ? CreateEmptyGenericParam(0)
-                                                    : CreateEmptyGenericParam(Context::kCpuId));
+    Context ctx(updater == "grow_gpu_hist" ? CreateEmptyGenericParam(0)
+                                           : CreateEmptyGenericParam(Context::kCpuId));
     float eta = 0.4;
     auto up_0 = std::unique_ptr<TreeUpdater>{
         TreeUpdater::Create(updater, &ctx, ObjInfo{ObjInfo::kClassification})};
@@ -140,9 +140,8 @@ class TestMinSplitLoss : public ::testing::Test {
               // test gamma
               {"gamma", std::to_string(gamma)}};
 
-    std::cout << "updater:" << updater << std::endl;
-    GenericParameter ctx(updater == "grow_gpu_hist" ? CreateEmptyGenericParam(0)
-                                                    : CreateEmptyGenericParam(Context::kCpuId));
+    Context ctx(updater == "grow_gpu_hist" ? CreateEmptyGenericParam(0)
+                                           : CreateEmptyGenericParam(Context::kCpuId));
     std::cout << ctx.gpu_id << std::endl;
     auto up = std::unique_ptr<TreeUpdater>{
         TreeUpdater::Create(updater, &ctx, ObjInfo{ObjInfo::kRegression})};