Hendrik/xgboost
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Cleanup warnings. (#5247)

Browse Source 
From clang-tidy-9 and gcc-7: Invalid case style, narrowing definition, wrong
initialization order, unused variables.
This commit is contained in:
Jiaming Yuan 2020-01-31 14:52:15 +08:00 committed by GitHub
parent adc795929a
commit fe8d72b50b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 260 additions and 262 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/xgboost/model.h
View File

@ -15,6 +15,7 @@ namespace xgboost {
class Json; class Json;
struct Model { struct Model {
virtual ~Model() = default;
/*! /*!
* \brief load the model from a json object * \brief load the model from a json object
* \param in json object where to load the model from * \param in json object where to load the model from
@ -28,6 +29,7 @@ struct Model {
}; };
struct Configurable { struct Configurable {
virtual ~Configurable() = default;
/*! /*!
* \brief Load configuration from JSON object * \brief Load configuration from JSON object
* \param in JSON object containing the configuration * \param in JSON object containing the configuration

4
src/c_api/c_api.cc
View File

@ -257,7 +257,7 @@ XGB_DLL int XGDMatrixCreateFromMat(const bst_float* data,
xgboost::bst_ulong ncol, bst_float missing, xgboost::bst_ulong ncol, bst_float missing,
DMatrixHandle* out) { DMatrixHandle* out) {
API_BEGIN(); API_BEGIN();
data::DenseAdapter adapter(data, nrow, nrow * ncol, ncol); data::DenseAdapter adapter(data, nrow, ncol);
*out = new std::shared_ptr<DMatrix>(DMatrix::Create(&adapter, missing, 1)); *out = new std::shared_ptr<DMatrix>(DMatrix::Create(&adapter, missing, 1));
API_END(); API_END();
} }
@ -268,7 +268,7 @@ XGB_DLL int XGDMatrixCreateFromMat_omp(const bst_float* data, // NOLINT
bst_float missing, DMatrixHandle* out, bst_float missing, DMatrixHandle* out,
int nthread) { int nthread) {
API_BEGIN(); API_BEGIN();
data::DenseAdapter adapter(data, nrow, nrow * ncol, ncol); data::DenseAdapter adapter(data, nrow, ncol);
*out = new std::shared_ptr<DMatrix>(DMatrix::Create(&adapter, missing, nthread)); *out = new std::shared_ptr<DMatrix>(DMatrix::Create(&adapter, missing, nthread));
API_END(); API_END();
} }

338
src/data/adapter.h
View File

@ -11,6 +11,9 @@
#include <utility> #include <utility>
#include <vector> #include <vector>
#include "xgboost/base.h"
#include "xgboost/data.h"
namespace xgboost { namespace xgboost {
namespace data { namespace data {
@ -76,17 +79,17 @@ namespace detail {
template <typename DType> template <typename DType>
class SingleBatchDataIter : dmlc::DataIter<DType> { class SingleBatchDataIter : dmlc::DataIter<DType> {
public: public:
void BeforeFirst() override { counter = 0; } void BeforeFirst() override { counter_ = 0; }
bool Next() override { bool Next() override {
if (counter == 0) { if (counter_ == 0) {
counter++; counter_++;
return true; return true;
} }
return false; return false;
} }
private: private:
int counter{0}; int counter_{0};
}; };
/** \brief Indicates this data source cannot contain meta-info such as labels, /** \brief Indicates this data source cannot contain meta-info such as labels,
@ -107,42 +110,42 @@ class CSRAdapterBatch : public detail::NoMetaInfo {
public: public:
Line(size_t row_idx, size_t size, const unsigned* feature_idx, Line(size_t row_idx, size_t size, const unsigned* feature_idx,
const float* values) const float* values)
: row_idx(row_idx), : row_idx_(row_idx),
size(size), size_(size),
feature_idx(feature_idx), feature_idx_(feature_idx),
values(values) {} values_(values) {}
size_t Size() const { return size; } size_t Size() const { return size_; }
COOTuple GetElement(size_t idx) const { COOTuple GetElement(size_t idx) const {
return COOTuple(row_idx, feature_idx[idx], values[idx]); return COOTuple{row_idx_, feature_idx_[idx], values_[idx]};
} }
private: private:
size_t row_idx; size_t row_idx_;
size_t size; size_t size_;
const unsigned* feature_idx; const unsigned* feature_idx_;
const float* values; const float* values_;
}; };
CSRAdapterBatch(const size_t* row_ptr, const unsigned* feature_idx, CSRAdapterBatch(const size_t* row_ptr, const unsigned* feature_idx,
const float* values, size_t num_rows, size_t num_elements, const float* values, size_t num_rows, size_t num_elements,
size_t num_features) size_t num_features)
: row_ptr(row_ptr), : row_ptr_(row_ptr),
feature_idx(feature_idx), feature_idx_(feature_idx),
values(values), values_(values),
num_rows(num_rows) {} num_rows_(num_rows) {}
const Line GetLine(size_t idx) const { const Line GetLine(size_t idx) const {
size_t begin_offset = row_ptr[idx]; size_t begin_offset = row_ptr_[idx];
size_t end_offset = row_ptr[idx + 1]; size_t end_offset = row_ptr_[idx + 1];
return Line(idx, end_offset - begin_offset, &feature_idx[begin_offset], return Line(idx, end_offset - begin_offset, &feature_idx_[begin_offset],
&values[begin_offset]); &values_[begin_offset]);
} }
size_t Size() const { return num_rows; } size_t Size() const { return num_rows_; }
private: private:
const size_t* row_ptr; const size_t* row_ptr_;
const unsigned* feature_idx; const unsigned* feature_idx_;
const float* values; const float* values_;
size_t num_rows; size_t num_rows_;
}; };
class CSRAdapter : public detail::SingleBatchDataIter<CSRAdapterBatch> { class CSRAdapter : public detail::SingleBatchDataIter<CSRAdapterBatch> {
@ -150,150 +153,146 @@ class CSRAdapter : public detail::SingleBatchDataIter<CSRAdapterBatch> {
CSRAdapter(const size_t* row_ptr, const unsigned* feature_idx, CSRAdapter(const size_t* row_ptr, const unsigned* feature_idx,
const float* values, size_t num_rows, size_t num_elements, const float* values, size_t num_rows, size_t num_elements,
size_t num_features) size_t num_features)
: batch(row_ptr, feature_idx, values, num_rows, num_elements, : batch_(row_ptr, feature_idx, values, num_rows, num_elements,
num_features), num_features),
num_rows(num_rows), num_rows_(num_rows),
num_columns(num_features) {} num_columns_(num_features) {}
const CSRAdapterBatch& Value() const override { return batch; } const CSRAdapterBatch& Value() const override { return batch_; }
size_t NumRows() const { return num_rows; } size_t NumRows() const { return num_rows_; }
size_t NumColumns() const { return num_columns; } size_t NumColumns() const { return num_columns_; }
private: private:
CSRAdapterBatch batch; CSRAdapterBatch batch_;
size_t num_rows; size_t num_rows_;
size_t num_columns; size_t num_columns_;
}; };
class DenseAdapterBatch : public detail::NoMetaInfo { class DenseAdapterBatch : public detail::NoMetaInfo {
public: public:
DenseAdapterBatch(const float* values, size_t num_rows, size_t num_elements, DenseAdapterBatch(const float* values, size_t num_rows, size_t num_features)
size_t num_features) : values_(values),
: num_features(num_features), num_rows_(num_rows),
num_rows(num_rows), num_features_(num_features) {}
num_elements(num_elements),
values(values) {}
private: private:
class Line { class Line {
public: public:
Line(const float* values, size_t size, size_t row_idx) Line(const float* values, size_t size, size_t row_idx)
: row_idx(row_idx), size(size), values(values) {} : row_idx_(row_idx), size_(size), values_(values) {}
size_t Size() const { return size; } size_t Size() const { return size_; }
COOTuple GetElement(size_t idx) const { COOTuple GetElement(size_t idx) const {
return COOTuple(row_idx, idx, values[idx]); return COOTuple{row_idx_, idx, values_[idx]};
} }
private: private:
size_t row_idx; size_t row_idx_;
size_t size; size_t size_;
const float* values; const float* values_;
}; };
public: public:
size_t Size() const { return num_rows; } size_t Size() const { return num_rows_; }
const Line GetLine(size_t idx) const { const Line GetLine(size_t idx) const {
return Line(values + idx * num_features, num_features, idx); return Line(values_ + idx * num_features_, num_features_, idx);
} }
private: private:
const float* values; const float* values_;
size_t num_elements; size_t num_rows_;
size_t num_rows; size_t num_features_;
size_t num_features;
}; };
class DenseAdapter : public detail::SingleBatchDataIter<DenseAdapterBatch> { class DenseAdapter : public detail::SingleBatchDataIter<DenseAdapterBatch> {
public: public:
DenseAdapter(const float* values, size_t num_rows, size_t num_elements, DenseAdapter(const float* values, size_t num_rows, size_t num_features)
size_t num_features) : batch_(values, num_rows, num_features),
: batch(values, num_rows, num_elements, num_features), num_rows_(num_rows),
num_rows(num_rows), num_columns_(num_features) {}
num_columns(num_features) {} const DenseAdapterBatch& Value() const override { return batch_; }
const DenseAdapterBatch& Value() const override { return batch; }
size_t NumRows() const { return num_rows; } size_t NumRows() const { return num_rows_; }
size_t NumColumns() const { return num_columns; } size_t NumColumns() const { return num_columns_; }
private: private:
DenseAdapterBatch batch; DenseAdapterBatch batch_;
size_t num_rows; size_t num_rows_;
size_t num_columns; size_t num_columns_;
}; };
class CSCAdapterBatch : public detail::NoMetaInfo { class CSCAdapterBatch : public detail::NoMetaInfo {
public: public:
CSCAdapterBatch(const size_t* col_ptr, const unsigned* row_idx, CSCAdapterBatch(const size_t* col_ptr, const unsigned* row_idx,
const float* values, size_t num_features) const float* values, size_t num_features)
: col_ptr(col_ptr), : col_ptr_(col_ptr),
row_idx(row_idx), row_idx_(row_idx),
values(values), values_(values),
num_features(num_features) {} num_features_(num_features) {}
private: private:
class Line { class Line {
public: public:
Line(size_t col_idx, size_t size, const unsigned* row_idx, Line(size_t col_idx, size_t size, const unsigned* row_idx,
const float* values) const float* values)
: col_idx(col_idx), size(size), row_idx(row_idx), values(values) {} : col_idx_(col_idx), size_(size), row_idx_(row_idx), values_(values) {}
size_t Size() const { return size; } size_t Size() const { return size_; }
COOTuple GetElement(size_t idx) const { COOTuple GetElement(size_t idx) const {
return COOTuple(row_idx[idx], col_idx, values[idx]); return COOTuple{row_idx_[idx], col_idx_, values_[idx]};
} }
private: private:
size_t col_idx; size_t col_idx_;
size_t size; size_t size_;
const unsigned* row_idx; const unsigned* row_idx_;
const float* values; const float* values_;
}; };
public: public:
size_t Size() const { return num_features; } size_t Size() const { return num_features_; }
const Line GetLine(size_t idx) const { const Line GetLine(size_t idx) const {
size_t begin_offset = col_ptr[idx]; size_t begin_offset = col_ptr_[idx];
size_t end_offset = col_ptr[idx + 1]; size_t end_offset = col_ptr_[idx + 1];
return Line(idx, end_offset - begin_offset, &row_idx[begin_offset], return Line(idx, end_offset - begin_offset, &row_idx_[begin_offset],
&values[begin_offset]); &values_[begin_offset]);
} }
private: private:
const size_t* col_ptr; const size_t* col_ptr_;
const unsigned* row_idx; const unsigned* row_idx_;
const float* values; const float* values_;
size_t num_features; size_t num_features_;
}; };
class CSCAdapter : public detail::SingleBatchDataIter<CSCAdapterBatch> { class CSCAdapter : public detail::SingleBatchDataIter<CSCAdapterBatch> {
public: public:
CSCAdapter(const size_t* col_ptr, const unsigned* row_idx, CSCAdapter(const size_t* col_ptr, const unsigned* row_idx,
const float* values, size_t num_features, size_t num_rows) const float* values, size_t num_features, size_t num_rows)
: batch(col_ptr, row_idx, values, num_features), : batch_(col_ptr, row_idx, values, num_features),
num_rows(num_rows), num_rows_(num_rows),
num_columns(num_features) {} num_columns_(num_features) {}
const CSCAdapterBatch& Value() const override { return batch; } const CSCAdapterBatch& Value() const override { return batch_; }
// JVM package sends 0 as unknown // JVM package sends 0 as unknown
size_t NumRows() const { size_t NumRows() const {
return num_rows == 0 ? kAdapterUnknownSize : num_rows; return num_rows_ == 0 ? kAdapterUnknownSize : num_rows_;
} }
size_t NumColumns() const { return num_columns; } size_t NumColumns() const { return num_columns_; }
private: private:
CSCAdapterBatch batch; CSCAdapterBatch batch_;
size_t num_rows; size_t num_rows_;
size_t num_columns; size_t num_columns_;
}; };
class DataTableAdapterBatch : public detail::NoMetaInfo { class DataTableAdapterBatch : public detail::NoMetaInfo {
public: public:
DataTableAdapterBatch(void** data, const char** feature_stypes, DataTableAdapterBatch(void** data, const char** feature_stypes,
size_t num_rows, size_t num_features) size_t num_rows, size_t num_features)
: data(data), : data_(data),
feature_stypes(feature_stypes), feature_stypes_(feature_stypes),
num_features(num_features), num_features_(num_features),
num_rows(num_rows) {} num_rows_(num_rows) {}
private: private:
enum class DTType : uint8_t { enum class DTType : uint8_t {
@ -370,31 +369,31 @@ class DataTableAdapterBatch : public detail::NoMetaInfo {
public: public:
Line(DTType type, size_t size, size_t column_idx, const void* column) Line(DTType type, size_t size, size_t column_idx, const void* column)
: type(type), size(size), column_idx(column_idx), column(column) {} : type_(type), size_(size), column_idx_(column_idx), column_(column) {}
size_t Size() const { return size; } size_t Size() const { return size_; }
COOTuple GetElement(size_t idx) const { COOTuple GetElement(size_t idx) const {
return COOTuple(idx, column_idx, DTGetValue(column, type, idx)); return COOTuple{idx, column_idx_, DTGetValue(column_, type_, idx)};
} }
private: private:
DTType type; DTType type_;
size_t size; size_t size_;
size_t column_idx; size_t column_idx_;
const void* column; const void* column_;
}; };
public: public:
size_t Size() const { return num_features; } size_t Size() const { return num_features_; }
const Line GetLine(size_t idx) const { const Line GetLine(size_t idx) const {
return Line(DTGetType(feature_stypes[idx]), num_rows, idx, data[idx]); return Line(DTGetType(feature_stypes_[idx]), num_rows_, idx, data_[idx]);
} }
private: private:
void** data; void** data_;
const char** feature_stypes; const char** feature_stypes_;
size_t num_features; size_t num_features_;
size_t num_rows; size_t num_rows_;
}; };
class DataTableAdapter class DataTableAdapter
@ -402,17 +401,17 @@ class DataTableAdapter
public: public:
DataTableAdapter(void** data, const char** feature_stypes, size_t num_rows, DataTableAdapter(void** data, const char** feature_stypes, size_t num_rows,
size_t num_features) size_t num_features)
: batch(data, feature_stypes, num_rows, num_features), : batch_(data, feature_stypes, num_rows, num_features),
num_rows(num_rows), num_rows_(num_rows),
num_columns(num_features) {} num_columns_(num_features) {}
const DataTableAdapterBatch& Value() const override { return batch; } const DataTableAdapterBatch& Value() const override { return batch_; }
size_t NumRows() const { return num_rows; } size_t NumRows() const { return num_rows_; }
size_t NumColumns() const { return num_columns; } size_t NumColumns() const { return num_columns_; }
private: private:
DataTableAdapterBatch batch; DataTableAdapterBatch batch_;
size_t num_rows; size_t num_rows_;
size_t num_columns; size_t num_columns_;
}; };
class FileAdapterBatch { class FileAdapterBatch {
@ -421,59 +420,59 @@ class FileAdapterBatch {
public: public:
Line(size_t row_idx, const uint32_t* feature_idx, const float* value, Line(size_t row_idx, const uint32_t* feature_idx, const float* value,
size_t size) size_t size)
: row_idx(row_idx), : row_idx_(row_idx),
feature_idx(feature_idx), feature_idx_(feature_idx),
value(value), value_(value),
size(size) {} size_(size) {}
size_t Size() { return size; } size_t Size() { return size_; }
COOTuple GetElement(size_t idx) { COOTuple GetElement(size_t idx) {
float fvalue = value == nullptr ? 1.0f : value[idx]; float fvalue = value_ == nullptr ? 1.0f : value_[idx];
return COOTuple(row_idx, feature_idx[idx], fvalue); return COOTuple{row_idx_, feature_idx_[idx], fvalue};
} }
private: private:
size_t row_idx; size_t row_idx_;
const uint32_t* feature_idx; const uint32_t* feature_idx_;
const float* value; const float* value_;
size_t size; size_t size_;
}; };
FileAdapterBatch(const dmlc::RowBlock<uint32_t>* block, size_t row_offset) FileAdapterBatch(const dmlc::RowBlock<uint32_t>* block, size_t row_offset)
: block(block), row_offset(row_offset) {} : block_(block), row_offset_(row_offset) {}
Line GetLine(size_t idx) const { Line GetLine(size_t idx) const {
auto begin = block->offset[idx]; auto begin = block_->offset[idx];
auto end = block->offset[idx + 1]; auto end = block_->offset[idx + 1];
return Line(idx + row_offset, &block->index[begin], &block->value[begin], return Line{idx + row_offset_, &block_->index[begin], &block_->value[begin],
end - begin); end - begin};
} }
const float* Labels() const { return block->label; } const float* Labels() const { return block_->label; }
const float* Weights() const { return block->weight; } const float* Weights() const { return block_->weight; }
const uint64_t* Qid() const { return block->qid; } const uint64_t* Qid() const { return block_->qid; }
const float* BaseMargin() const { return nullptr; } const float* BaseMargin() const { return nullptr; }
size_t Size() const { return block->size; } size_t Size() const { return block_->size; }
private: private:
const dmlc::RowBlock<uint32_t>* block; const dmlc::RowBlock<uint32_t>* block_;
size_t row_offset; size_t row_offset_;
}; };
/** \brief FileAdapter wraps dmlc::parser to read files and provide access in a /** \brief FileAdapter wraps dmlc::parser to read files and provide access in a
* common interface. */ * common interface. */
class FileAdapter : dmlc::DataIter<FileAdapterBatch> { class FileAdapter : dmlc::DataIter<FileAdapterBatch> {
public: public:
explicit FileAdapter(dmlc::Parser<uint32_t>* parser) : parser(parser) {} explicit FileAdapter(dmlc::Parser<uint32_t>* parser) : parser_(parser) {}
const FileAdapterBatch& Value() const override { return *batch.get(); } const FileAdapterBatch& Value() const override { return *batch_.get(); }
void BeforeFirst() override { void BeforeFirst() override {
batch.reset(); batch_.reset();
parser->BeforeFirst(); parser_->BeforeFirst();
row_offset = 0; row_offset_ = 0;
} }
bool Next() override { bool Next() override {
bool next = parser->Next(); bool next = parser_->Next();
batch.reset(new FileAdapterBatch(&parser->Value(), row_offset)); batch_.reset(new FileAdapterBatch(&parser_->Value(), row_offset_));
row_offset += parser->Value().size; row_offset_ += parser_->Value().size;
return next; return next;
} }
// Indicates a number of rows/columns must be inferred // Indicates a number of rows/columns must be inferred
@ -481,9 +480,9 @@ class FileAdapter : dmlc::DataIter<FileAdapterBatch> {
size_t NumColumns() const { return kAdapterUnknownSize; } size_t NumColumns() const { return kAdapterUnknownSize; }
private: private:
size_t row_offset{0}; size_t row_offset_{0};
std::unique_ptr<FileAdapterBatch> batch; std::unique_ptr<FileAdapterBatch> batch_;
dmlc::Parser<uint32_t>* parser; dmlc::Parser<uint32_t>* parser_;
}; };
class DMatrixSliceAdapterBatch { class DMatrixSliceAdapterBatch {
@ -510,16 +509,16 @@ class DMatrixSliceAdapterBatch {
class Line { class Line {
public: public:
Line(const SparsePage::Inst& inst, size_t row_idx) Line(const SparsePage::Inst& inst, size_t row_idx)
: inst(inst), row_idx(row_idx) {} : inst_(inst), row_idx_(row_idx) {}
size_t Size() { return inst.size(); } size_t Size() { return inst_.size(); }
COOTuple GetElement(size_t idx) { COOTuple GetElement(size_t idx) {
return COOTuple(row_idx, inst[idx].index, inst[idx].fvalue); return COOTuple{row_idx_, inst_[idx].index, inst_[idx].fvalue};
} }
private: private:
SparsePage::Inst inst; SparsePage::Inst inst_;
size_t row_idx; size_t row_idx_;
}; };
Line GetLine(size_t idx) const { return Line(batch[ridx_set[idx]], idx); } Line GetLine(size_t idx) const { return Line(batch[ridx_set[idx]], idx); }
const float* Labels() const { const float* Labels() const {
@ -559,17 +558,18 @@ class DMatrixSliceAdapter
: public detail::SingleBatchDataIter<DMatrixSliceAdapterBatch> { : public detail::SingleBatchDataIter<DMatrixSliceAdapterBatch> {
public: public:
DMatrixSliceAdapter(DMatrix* dmat, common::Span<const int> ridx_set) DMatrixSliceAdapter(DMatrix* dmat, common::Span<const int> ridx_set)
: dmat(dmat), : dmat_(dmat),
ridx_set(ridx_set), ridx_set_(ridx_set),
batch(*dmat->GetBatches<SparsePage>().begin(), dmat, ridx_set) {} batch_(*dmat_->GetBatches<SparsePage>().begin(), dmat_, ridx_set) {}
const DMatrixSliceAdapterBatch& Value() const override { return batch; } const DMatrixSliceAdapterBatch& Value() const override { return batch_; }
// Indicates a number of rows/columns must be inferred // Indicates a number of rows/columns must be inferred
size_t NumRows() const { return ridx_set.size(); } size_t NumRows() const { return ridx_set_.size(); }
size_t NumColumns() const { return dmat->Info().num_col_; } size_t NumColumns() const { return dmat_->Info().num_col_; }
DMatrix* dmat;
DMatrixSliceAdapterBatch batch; private:
bool before_first{true}; DMatrix* dmat_;
common::Span<const int> ridx_set; common::Span<const int> ridx_set_;
DMatrixSliceAdapterBatch batch_;
}; };
}; // namespace data }; // namespace data
} // namespace xgboost } // namespace xgboost

4
tests/cpp/common/test_hist_util.cc
View File

@ -46,7 +46,6 @@ TEST(ParallelGHistBuilder, Reset) {
hist_builder.Reset(nthreads, kNodes, space, target_hist); hist_builder.Reset(nthreads, kNodes, space, target_hist);
common::ParallelFor2d(space, nthreads, [&](size_t inode, common::Range1d r) { common::ParallelFor2d(space, nthreads, [&](size_t inode, common::Range1d r) {
const size_t itask = r.begin();
const size_t tid = omp_get_thread_num(); const size_t tid = omp_get_thread_num();
GHistRow hist = hist_builder.GetInitializedHist(tid, inode); GHistRow hist = hist_builder.GetInitializedHist(tid, inode);
@ -65,7 +64,6 @@ TEST(ParallelGHistBuilder, Reset) {
hist_builder.Reset(nthreads, kNodesExtended, space2, target_hist); hist_builder.Reset(nthreads, kNodesExtended, space2, target_hist);
common::ParallelFor2d(space2, nthreads, [&](size_t inode, common::Range1d r) { common::ParallelFor2d(space2, nthreads, [&](size_t inode, common::Range1d r) {
const size_t itask = r.begin();
const size_t tid = omp_get_thread_num(); const size_t tid = omp_get_thread_num();
GHistRow hist = hist_builder.GetInitializedHist(tid, inode); GHistRow hist = hist_builder.GetInitializedHist(tid, inode);
@ -80,7 +78,6 @@ TEST(ParallelGHistBuilder, Reset) {
TEST(ParallelGHistBuilder, ReduceHist) { TEST(ParallelGHistBuilder, ReduceHist) {
constexpr size_t kBins = 10; constexpr size_t kBins = 10;
constexpr size_t kNodes = 5; constexpr size_t kNodes = 5;
constexpr size_t kNodesExtended = 10;
constexpr size_t kTasksPerNode = 10; constexpr size_t kTasksPerNode = 10;
constexpr double kValue = 1.0; constexpr double kValue = 1.0;
const size_t nthreads = GetNThreads(); const size_t nthreads = GetNThreads();
@ -104,7 +101,6 @@ TEST(ParallelGHistBuilder, ReduceHist) {
// Simple analog of BuildHist function, works in parallel for both tree-nodes and data in node // Simple analog of BuildHist function, works in parallel for both tree-nodes and data in node
common::ParallelFor2d(space, nthreads, [&](size_t inode, common::Range1d r) { common::ParallelFor2d(space, nthreads, [&](size_t inode, common::Range1d r) {
const size_t itask = r.begin();
const size_t tid = omp_get_thread_num(); const size_t tid = omp_get_thread_num();
GHistRow hist = hist_builder.GetInitializedHist(tid, inode); GHistRow hist = hist_builder.GetInitializedHist(tid, inode);

165
tests/cpp/common/test_threading_utils.cc
View File

@ -1,82 +1,83 @@
#include <gtest/gtest.h> #include <cstddef>
#include <gtest/gtest.h>
#include "../../../src/common/column_matrix.h"
#include "../../../src/common/threading_utils.h" #include "../../../src/common/column_matrix.h"
#include "../../../src/common/threading_utils.h"
namespace xgboost {
namespace common { namespace xgboost {
namespace common {
TEST(CreateBlockedSpace2d, Test) {
constexpr size_t kDim1 = 5; TEST(CreateBlockedSpace2d, Test) {
constexpr size_t kDim2 = 3; constexpr size_t kDim1 = 5;
constexpr size_t kGrainSize = 1; constexpr size_t kDim2 = 3;
constexpr size_t kGrainSize = 1;
BlockedSpace2d space(kDim1, [&](size_t i) {
return kDim2; BlockedSpace2d space(kDim1, [&](size_t i) {
}, kGrainSize); return kDim2;
}, kGrainSize);
ASSERT_EQ(kDim1 * kDim2, space.Size());
ASSERT_EQ(kDim1 * kDim2, space.Size());
for (auto i = 0; i < kDim1; i++) {
for (auto j = 0; j < kDim2; j++) { for (size_t i = 0; i < kDim1; i++) {
ASSERT_EQ(space.GetFirstDimension(i*kDim2 + j), i); for (size_t j = 0; j < kDim2; j++) {
ASSERT_EQ(j, space.GetRange(i*kDim2 + j).begin()); ASSERT_EQ(space.GetFirstDimension(i*kDim2 + j), i);
ASSERT_EQ(j + kGrainSize, space.GetRange(i*kDim2 + j).end()); ASSERT_EQ(j, space.GetRange(i*kDim2 + j).begin());
} ASSERT_EQ(j + kGrainSize, space.GetRange(i*kDim2 + j).end());
} }
} }
}
TEST(ParallelFor2d, Test) {
constexpr size_t kDim1 = 100; TEST(ParallelFor2d, Test) {
constexpr size_t kDim2 = 15; constexpr size_t kDim1 = 100;
constexpr size_t kGrainSize = 2; constexpr size_t kDim2 = 15;
constexpr size_t kGrainSize = 2;
// working space is matrix of size (kDim1 x kDim2)
std::vector<int> matrix(kDim1 * kDim2, 0); // working space is matrix of size (kDim1 x kDim2)
BlockedSpace2d space(kDim1, [&](size_t i) { std::vector<int> matrix(kDim1 * kDim2, 0);
return kDim2; BlockedSpace2d space(kDim1, [&](size_t i) {
}, kGrainSize); return kDim2;
}, kGrainSize);
ParallelFor2d(space, 4, [&](size_t i, Range1d r) {
for (auto j = r.begin(); j < r.end(); ++j) { ParallelFor2d(space, 4, [&](size_t i, Range1d r) {
matrix[i*kDim2 + j] += 1; for (auto j = r.begin(); j < r.end(); ++j) {
} matrix[i*kDim2 + j] += 1;
}); }
});
for (auto i = 0; i < kDim1 * kDim2; i++) {
ASSERT_EQ(matrix[i], 1); for (size_t i = 0; i < kDim1 * kDim2; i++) {
} ASSERT_EQ(matrix[i], 1);
} }
}
TEST(ParallelFor2dNonUniform, Test) {
constexpr size_t kDim1 = 5; TEST(ParallelFor2dNonUniform, Test) {
constexpr size_t kGrainSize = 256; constexpr size_t kDim1 = 5;
constexpr size_t kGrainSize = 256;
// here are quite non-uniform distribution in space
// but ParallelFor2d should split them by blocks with max size = kGrainSize // here are quite non-uniform distribution in space
// and process in balanced manner (optimal performance) // but ParallelFor2d should split them by blocks with max size = kGrainSize
std::vector<size_t> dim2 { 1024, 500, 255, 5, 10000 }; // and process in balanced manner (optimal performance)
BlockedSpace2d space(kDim1, [&](size_t i) { std::vector<size_t> dim2 { 1024, 500, 255, 5, 10000 };
return dim2[i]; BlockedSpace2d space(kDim1, [&](size_t i) {
}, kGrainSize); return dim2[i];
}, kGrainSize);
std::vector<std::vector<int>> working_space(kDim1);
for (auto i = 0; i < kDim1; i++) { std::vector<std::vector<int>> working_space(kDim1);
working_space[i].resize(dim2[i], 0); for (size_t i = 0; i < kDim1; i++) {
} working_space[i].resize(dim2[i], 0);
}
ParallelFor2d(space, 4, [&](size_t i, Range1d r) {
for (auto j = r.begin(); j < r.end(); ++j) { ParallelFor2d(space, 4, [&](size_t i, Range1d r) {
working_space[i][j] += 1; for (auto j = r.begin(); j < r.end(); ++j) {
} working_space[i][j] += 1;
}); }
});
for (auto i = 0; i < kDim1; i++) {
for (auto j = 0; j < dim2[i]; j++) { for (size_t i = 0; i < kDim1; i++) {
ASSERT_EQ(working_space[i][j], 1); for (size_t j = 0; j < dim2[i]; j++) {
} ASSERT_EQ(working_space[i][j], 1);
} }
} }
}
} // namespace common
} // namespace xgboost } // namespace common
} // namespace xgboost

1
tests/cpp/data/test_adapter.cc
View File

@ -7,7 +7,6 @@
#include "../helpers.h" #include "../helpers.h"
using namespace xgboost; // NOLINT using namespace xgboost; // NOLINT
TEST(adapter, CSRAdapter) { TEST(adapter, CSRAdapter) {
int m = 3;
int n = 2; int n = 2;
std::vector<float> data = {1, 2, 3, 4, 5}; std::vector<float> data = {1, 2, 3, 4, 5};
std::vector<unsigned> feature_idx = {0, 1, 0, 1, 1}; std::vector<unsigned> feature_idx = {0, 1, 0, 1, 1};

4
tests/cpp/data/test_simple_dmatrix.cc
View File

@ -83,7 +83,7 @@ TEST(SimpleDMatrix, Empty) {
CHECK_EQ(batch.Size(), 0); CHECK_EQ(batch.Size(), 0);
} }
data::DenseAdapter dense_adapter(nullptr, 0, 0, 0); data::DenseAdapter dense_adapter(nullptr, 0, 0);
dmat = data::SimpleDMatrix(&dense_adapter, dmat = data::SimpleDMatrix(&dense_adapter,
std::numeric_limits<float>::quiet_NaN(), 1); std::numeric_limits<float>::quiet_NaN(), 1);
CHECK_EQ(dmat.Info().num_nonzero_, 0); CHECK_EQ(dmat.Info().num_nonzero_, 0);
@ -136,7 +136,7 @@ TEST(SimpleDMatrix, FromDense) {
int m = 3; int m = 3;
int n = 2; int n = 2;
std::vector<float> data = {1, 2, 3, 4, 5, 6}; std::vector<float> data = {1, 2, 3, 4, 5, 6};
data::DenseAdapter adapter(data.data(), m, m * n, n); data::DenseAdapter adapter(data.data(), m, n);
data::SimpleDMatrix dmat(&adapter, std::numeric_limits<float>::quiet_NaN(), data::SimpleDMatrix dmat(&adapter, std::numeric_limits<float>::quiet_NaN(),
-1); -1);
EXPECT_EQ(dmat.Info().num_col_, 2); EXPECT_EQ(dmat.Info().num_col_, 2);

4
tests/cpp/data/test_sparse_page_dmatrix.cc
View File

@ -106,7 +106,7 @@ TEST(SparsePageDMatrix, Empty) {
EXPECT_EQ(batch.Size(), 0); EXPECT_EQ(batch.Size(), 0);
} }
data::DenseAdapter dense_adapter(nullptr, 0, 0, 0); data::DenseAdapter dense_adapter(nullptr, 0, 0);
data::SparsePageDMatrix dmat2(&dense_adapter, data::SparsePageDMatrix dmat2(&dense_adapter,
std::numeric_limits<float>::quiet_NaN(), 1,tmp_file); std::numeric_limits<float>::quiet_NaN(), 1,tmp_file);
EXPECT_EQ(dmat2.Info().num_nonzero_, 0); EXPECT_EQ(dmat2.Info().num_nonzero_, 0);
@ -163,7 +163,7 @@ TEST(SparsePageDMatrix, FromDense) {
int m = 3; int m = 3;
int n = 2; int n = 2;
std::vector<float> data = {1, 2, 3, 4, 5, 6}; std::vector<float> data = {1, 2, 3, 4, 5, 6};
data::DenseAdapter adapter(data.data(), m, m * n, n); data::DenseAdapter adapter(data.data(), m, n);
data::SparsePageDMatrix dmat( data::SparsePageDMatrix dmat(
&adapter, std::numeric_limits<float>::quiet_NaN(), 1, tmp_file); &adapter, std::numeric_limits<float>::quiet_NaN(), 1, tmp_file);
EXPECT_EQ(dmat.Info().num_col_, 2); EXPECT_EQ(dmat.Info().num_col_, 2);