Function DoPropertyDistributedQuantile

tests/cpp/common/test_quantile.cc:412–455

namespace {
void DoPropertyDistributedQuantile(ContainerCase const& c) {
  Context ctx;
  auto const world = collective::GetWorldSize();
  auto ft = FeatureTypes(c);
  auto rank = collective::GetRank();
  auto full_m = RandomDataGenerator{c.rows * static_cast<std::size_t>(world), c.cols, c.sparsity}
                    .Seed(c.seed)
                    .Lower(.0f)
                    .Upper(1.0f)
                    .Type(ft)
                    .MaxCategory(13)
                    .GenerateDMatrix();
  if (c.weights == WeightKind::kRow) {
    full_m->Info().weights_.HostVector() =
        GenerateWeights(c.rows * static_cast<std::size_t>(world), c.seed + 4096);
  }
  std::vector<std::int32_t> ridxs(c.rows);
  auto row_begin = static_cast<std::size_t>(rank) * c.rows;
  std::iota(ridxs.begin(), ridxs.end(), static_cast<std::int32_t>(row_begin));
  std::shared_ptr<DMatrix> m{full_m->Slice(Span<std::int32_t const>{ridxs.data(), ridxs.size()})};

  std::vector<bst_idx_t> column_size(c.cols, c.rows);
  std::vector<float> hessian(c.rows, 1.0f);
  auto hess = Span<float const>{hessian};
  HostSketchContainer row_sketch(&ctx, c.max_bin, m->Info().feature_types.ConstHostSpan(),
                                 column_size, false);
  for (auto const& page : m->GetBatches<SparsePage>(&ctx)) {
    row_sketch.PushRowPage(page, m->Info(), hess);
  }
  auto row_cuts = row_sketch.MakeCuts(&ctx, m->Info());

  HostSketchContainer sorted_sketch(&ctx, c.max_bin, m->Info().feature_types.ConstHostSpan(),
                                    column_size, false);
  for (auto const& page : m->GetBatches<SortedCSCPage>(&ctx)) {
    sorted_sketch.PushColPage(page, m->Info(), hess);
  }
  auto sorted_cuts = sorted_sketch.MakeCuts(&ctx, m->Info());

  collective::Finalize();
  CHECK_EQ(collective::GetWorldSize(), 1);
  auto columns = CollectWeightedColumns(full_m.get());
  ValidateContainerCuts(c, row_cuts, full_m.get(), columns);
  ValidateContainerCuts(c, sorted_cuts, full_m.get(), columns);
}

void DoSameOnAllWorkersDistributedQuantile(ContainerCase const& c) {
  Context ctx;