base.h

前往此文件文档。

 
#ifndef XGBOOST_BASE_H_
#define XGBOOST_BASE_H_
 
#include <dmlc/omp.h> // for omp_uint, omp_ulong
// 将 windefs 放在这里，以尽可能多地保护文件。
#include <xgboost/windefs.h>
 
#include <cstdint> // for int32_t, uint64_t, int16_t
#include <ostream> // for ostream
#include <string> // for string
#include <utility> // for pair
#include <vector> // for vector
 
#ifndef XGBOOST_STRICT_R_MODE
#define XGBOOST_STRICT_R_MODE 0
#endif // XGBOOST_STRICT_R_MODE
 
#ifndef XGBOOST_LOG_WITH_TIME
#define XGBOOST_LOG_WITH_TIME 1
#endif // XGBOOST_LOG_WITH_TIME
 
#ifndef XGBOOST_CUSTOMIZE_GLOBAL_PRNG
#define XGBOOST_CUSTOMIZE_GLOBAL_PRNG 0
#endif // XGBOOST_CUSTOMIZE_GLOBAL_PRNG
 
#if defined(__GNUC__) && ((__GNUC__ == 4 && __GNUC_MINOR__ >= 8) || __GNUC__ > 4)
#define XGBOOST_ALIGNAS(X) alignas(X)
#else
#define XGBOOST_ALIGNAS(X)
#endif // defined(__GNUC__) && ((__GNUC__ == 4 && __GNUC_MINOR__ >= 8) || __GNUC__ > 4)
 
#if defined(__GNUC__)
#define XGBOOST_EXPECT(cond, ret) __builtin_expect((cond), (ret))
#else
#define XGBOOST_EXPECT(cond, ret) (cond)
#endif // defined(__GNUC__)
 
#if defined (__CUDA__) || defined(__NVCC__)
#define XGBOOST_DEVICE __host__ __device__
#else
#define XGBOOST_DEVICE
#endif // defined (__CUDA__) || defined(__NVCC__)
 
#if defined(__CUDA__) || defined(__CUDACC__)
#define XGBOOST_HOST_DEV_INLINE XGBOOST_DEVICE __forceinline__
#define XGBOOST_DEV_INLINE __device__ __forceinline__
#else
#define XGBOOST_HOST_DEV_INLINE
#define XGBOOST_DEV_INLINE
#endif // defined(__CUDA__) || defined(__CUDACC__)
 
 
// restrict
#if defined(_MSC_VER)
#define XGBOOST_RESTRICT __restrict
#else
#define XGBOOST_RESTRICT __restrict__
#endif
 
// 这些检查用于 Makefile。
#if !defined(XGBOOST_MM_PREFETCH_PRESENT) && !defined(XGBOOST_BUILTIN_PREFETCH_PRESENT)
/* 软件预取默认逻辑 */
#if (defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_AMD64))) || defined(__INTEL_COMPILER)
// 为 Intel 编译器和 MSVC+x86 启用 _mm_prefetch
 #define XGBOOST_MM_PREFETCH_PRESENT
 #define XGBOOST_BUILTIN_PREFETCH_PRESENT
#elif defined(__GNUC__)
// 为 GCC 启用 __builtin_prefetch
#define XGBOOST_BUILTIN_PREFETCH_PRESENT
#endif // 守卫
 
#endif // !defined(XGBOOST_MM_PREFETCH_PRESENT) && !defined()
 
namespace xgboost {
using bst_uint = std::uint32_t; // NOLINT
using bst_ulong = std::uint64_t; // NOLINT
using bst_float = float; // NOLINT
using bst_cat_t = std::int32_t; // NOLINT
using bst_feature_t = std::uint32_t; // NOLINT
using bst_bin_t = std::int32_t; // NOLINT
using bst_idx_t = std::uint64_t; // NOLINT
using bst_node_t = std::int32_t; // NOLINT
using bst_group_t = std::uint32_t; // NOLINT
using bst_target_t = std::uint32_t; // NOLINT
using bst_layer_t = std::int32_t; // NOLINT
using bst_tree_t = std::int32_t; // NOLINT
using bst_d_ordinal_t = std::int16_t; // NOLINT
 
namespace detail {
template <typename T>
class GradientPairInternal {
 T grad_{0};
 T hess_{0};
 
 XGBOOST_DEVICE void SetGrad(T g) { grad_ = g; }
 XGBOOST_DEVICE void SetHess(T h) { hess_ = h; }
 
 public
 using ValueT = T;
 
 inline void Add(const ValueT& grad, const ValueT& hess) {
 grad_ += grad;
 hess_ += hess;
  }
 
 inline static void Reduce(GradientPairInternal<T>& a, const GradientPairInternal<T>& b) { // NOLINT(*)
 a += b;
  }
 
 GradientPairInternal() = default;
 
 XGBOOST_DEVICE GradientPairInternal(T grad, T hess) {
 SetGrad(grad);
 SetHess(hess);
  }
 
 // 如果是相同值类型，则为复制构造函数，标记为 default 以便可 trivially_copyable
 GradientPairInternal(GradientPairInternal const &g) = default;
 GradientPairInternal(GradientPairInternal &&g) = default;
 GradientPairInternal &operator=(GradientPairInternal const &that) = default;
 GradientPairInternal &operator=(GradientPairInternal &&that) = default;
 
 // 如果值类型不同，则为复制构造函数 - 使用 getter 和 setter 执行转换
 // perform conversion
 template <typename T2>
 XGBOOST_DEVICE explicit GradientPairInternal(const GradientPairInternal<T2> &g) {
 SetGrad(g.GetGrad());
 SetHess(g.GetHess());
  }
 
 XGBOOST_DEVICE T GetGrad() const { return grad_; }
 XGBOOST_DEVICE T GetHess() const { return hess_; }
 
 XGBOOST_DEVICE GradientPairInternal<T> &operator+=(
 const GradientPairInternal<T> &rhs) {
 grad_ += rhs.grad_;
 hess_ += rhs.hess_;
 return *this;
  }
 
 XGBOOST_DEVICE GradientPairInternal<T> operator+(
 const GradientPairInternal<T> &rhs) const {
 GradientPairInternal<T> g;
 g.grad_ = grad_ + rhs.grad_;
 g.hess_ = hess_ + rhs.hess_;
 return g;
  }
 
 XGBOOST_DEVICE GradientPairInternal<T> &operator-=(
 const GradientPairInternal<T> &rhs) {
 grad_ -= rhs.grad_;
 hess_ -= rhs.hess_;
 return *this;
  }
 
 XGBOOST_DEVICE GradientPairInternal<T> operator-(
 const GradientPairInternal<T> &rhs) const {
 GradientPairInternal<T> g;
 g.grad_ = grad_ - rhs.grad_;
 g.hess_ = hess_ - rhs.hess_;
 return g;
  }
 
 XGBOOST_DEVICE GradientPairInternal<T> &operator*=(float multiplier) {
 grad_ *= multiplier;
 hess_ *= multiplier;
 return *this;
  }
 
 XGBOOST_DEVICE GradientPairInternal<T> operator*(float multiplier) const {
 GradientPairInternal<T> g;
 g.grad_ = grad_ * multiplier;
 g.hess_ = hess_ * multiplier;
 return g;
  }
 
 XGBOOST_DEVICE GradientPairInternal<T> &operator/=(float divisor) {
 grad_ /= divisor;
 hess_ /= divisor;
 return *this;
  }
 
 XGBOOST_DEVICE GradientPairInternal<T> operator/(float divisor) const {
 GradientPairInternal<T> g;
 g.grad_ = grad_ / divisor;
 g.hess_ = hess_ / divisor;
 return g;
  }
 
 XGBOOST_DEVICE bool operator==(const GradientPairInternal<T> &rhs) const {
 return grad_ == rhs.grad_ && hess_ == rhs.hess_;
  }
 
 XGBOOST_DEVICE explicit GradientPairInternal(int value) {
 *this = GradientPairInternal<T>(static_cast<float>(value),
 static_cast<float>(value));
  }
 
 friend std::ostream &operator<<(std::ostream &os,
 const GradientPairInternal<T> &g) {
 os << g.GetGrad() << "/" << g.GetHess();
 return os;
  }
};
} // namespace detail
 
using GradientPair = detail::GradientPairInternal<float>;
using GradientPairPrecise = detail::GradientPairInternal<double>;
 
class GradientPairInt64 {
 using T = int64_t;
 T grad_ = 0;
 T hess_ = 0;
 
 public
 using ValueT = T;
 
 XGBOOST_DEVICE GradientPairInt64(T grad, T hess) : grad_(grad), hess_(hess) {}
 GradientPairInt64() = default;
 
 // 如果是相同值类型，则为复制构造函数，标记为 default 以便可 trivially_copyable
 GradientPairInt64(GradientPairInt64 const &g) = default;
 GradientPairInt64 &operator=(GradientPairInt64 const &g) = default;
 
 [[nodiscard]] XGBOOST_DEVICE T GetQuantisedGrad() const { return grad_; }
 [[nodiscard]] XGBOOST_DEVICE T GetQuantisedHess() const { return hess_; }
 
 XGBOOST_DEVICE GradientPairInt64 &operator+=(const GradientPairInt64 &rhs) {
 grad_ += rhs.grad_;
 hess_ += rhs.hess_;
 return *this;
  }
 
 XGBOOST_DEVICE GradientPairInt64 operator+(const GradientPairInt64 &rhs) const {
 GradientPairInt64 g;
 g.grad_ = grad_ + rhs.grad_;
 g.hess_ = hess_ + rhs.hess_;
 return g;
  }
 
 XGBOOST_DEVICE GradientPairInt64 &operator-=(const GradientPairInt64 &rhs) {
 grad_ -= rhs.grad_;
 hess_ -= rhs.hess_;
 return *this;
  }
 
 XGBOOST_DEVICE GradientPairInt64 operator-(const GradientPairInt64 &rhs) const {
 GradientPairInt64 g;
 g.grad_ = grad_ - rhs.grad_;
 g.hess_ = hess_ - rhs.hess_;
 return g;
  }
 
 XGBOOST_DEVICE bool operator==(const GradientPairInt64 &rhs) const {
 return grad_ == rhs.grad_ && hess_ == rhs.hess_;
  }
 friend std::ostream &operator<<(std::ostream &os, const GradientPairInt64 &g) {
 os << g.GetQuantisedGrad() << "/" << g.GetQuantisedHess();
 return os;
  }
};
 
using Args = std::vector<std::pair<std::string, std::string> >;
 
constexpr bst_float kRtEps = 1e-6f;
 
using omp_ulong = dmlc::omp_ulong; // NOLINT
using bst_omp_uint = dmlc::omp_uint; // NOLINT
using XGBoostVersionT = std::int32_t;
} // namespace xgboost
 
#endif // XGBOOST_BASE_H_