xgboost
span.h
Go to the documentation of this file.
1 
29 #ifndef XGBOOST_SPAN_H_
30 #define XGBOOST_SPAN_H_
31 
32 #include <xgboost/base.h>
33 
34 #include <cstddef> // size_t
35 #include <cstdio>
36 #include <iterator>
37 #include <limits> // numeric_limits
38 #include <type_traits>
39 #include <utility> // for move
40 #include <vector> // for vector
41 
42 #if defined(__CUDACC__)
43 #include <cuda_runtime.h>
44 #endif // defined(__CUDACC__)
45 
63 #if defined(_MSC_VER) && _MSC_VER < 1910
64 
65 #define __span_noexcept
66 
67 #pragma push_macro("constexpr")
68 #define constexpr /*constexpr*/
69 
70 #else
71 
72 #define __span_noexcept noexcept
73 
74 #endif // defined(_MSC_VER) && _MSC_VER < 1910
75 
76 namespace xgboost::common {
77 
78 #if defined(__CUDA_ARCH__)
79 // Usual logging facility is not available inside device code.
80 
81 #if defined(_MSC_VER)
82 
83 // Windows CUDA doesn't have __assert_fail.
84 #define CUDA_KERNEL_CHECK(cond) \
85  do { \
86  if (XGBOOST_EXPECT(!(cond), false)) { \
87  asm("trap;"); \
88  } \
89  } while (0)
90 
91 #else // defined(_MSC_VER)
92 
93 #define __ASSERT_STR_HELPER(x) #x
94 
95 #define CUDA_KERNEL_CHECK(cond) \
96  (XGBOOST_EXPECT((cond), true) \
97  ? static_cast<void>(0) \
98  : __assert_fail(__ASSERT_STR_HELPER((cond)), __FILE__, __LINE__, __PRETTY_FUNCTION__))
99 
100 #endif // defined(_MSC_VER)
101 
102 #define KERNEL_CHECK CUDA_KERNEL_CHECK
103 
104 #define SPAN_CHECK KERNEL_CHECK
105 
106 #else // ------------------------------ not CUDA ----------------------------
107 
108 #if defined(XGBOOST_STRICT_R_MODE) && XGBOOST_STRICT_R_MODE == 1
109 
110 #define KERNEL_CHECK(cond)
111 
112 #define SPAN_CHECK(cond) KERNEL_CHECK(cond)
113 
114 #else
115 
116 #if defined(__SYCL_DEVICE_ONLY__)
117 
118 // SYCL doesn't support termination
119 #define SYCL_KERNEL_CHECK(cond)
120 
121 #define KERNEL_CHECK(cond) SYCL_KERNEL_CHECK(cond)
122 
123 #else // defined(__SYCL_DEVICE_ONLY__)
124 #define KERNEL_CHECK(cond) (XGBOOST_EXPECT((cond), true) ? static_cast<void>(0) : std::terminate())
125 #endif // defined(__SYCL_DEVICE_ONLY__)
126 
127 #define SPAN_CHECK(cond) KERNEL_CHECK(cond)
128 
129 #endif // defined(XGBOOST_STRICT_R_MODE)
130 
131 #endif // __CUDA_ARCH__
132 
133 #define SPAN_LT(lhs, rhs) SPAN_CHECK((lhs) < (rhs))
134 
135 namespace detail {
142 using ptrdiff_t = typename std::conditional_t< // NOLINT
143  std::is_same_v<std::ptrdiff_t, std::int64_t>, std::ptrdiff_t, std::int64_t>;
144 } // namespace detail
145 
146 #if defined(_MSC_VER) && _MSC_VER < 1910
147 constexpr const std::size_t
148 dynamic_extent = std::numeric_limits<std::size_t>::max(); // NOLINT
149 #else
150 constexpr std::size_t dynamic_extent = std::numeric_limits<std::size_t>::max(); // NOLINT
151 #endif // defined(_MSC_VER) && _MSC_VER < 1910
152 
153 enum class byte : unsigned char {}; // NOLINT
154 
155 template <class ElementType, std::size_t Extent>
156 class Span;
157 
158 namespace detail {
159 
160 template <typename SpanType, bool IsConst>
162  using ElementType = typename SpanType::element_type;
163 
164  public:
165  using iterator_category = std::random_access_iterator_tag; // NOLINT
166  using value_type = typename SpanType::value_type; // NOLINT
168 
169  using reference = typename std::conditional< // NOLINT
170  IsConst, const ElementType, ElementType>::type&;
171  using pointer = typename std::add_pointer<reference>::type; // NOLINT
172 
173  constexpr SpanIterator() = default;
174 
176  const SpanType* _span,
177  typename SpanType::index_type _idx) __span_noexcept :
178  span_(_span), index_(_idx) {}
179 
181  template <bool B, typename std::enable_if_t<!B && IsConst>* = nullptr>
182  XGBOOST_DEVICE constexpr SpanIterator( // NOLINT
184  : SpanIterator(other_.span_, other_.index_) {}
185 
187  SPAN_CHECK(index_ < span_->size());
188  return *(span_->data() + index_);
189  }
191  return *(*this + n);
192  }
193 
195  SPAN_CHECK(index_ != span_->size());
196  return span_->data() + index_;
197  }
198 
200  SPAN_CHECK(index_ != span_->size());
201  index_++;
202  return *this;
203  }
204 
206  auto ret = *this;
207  ++(*this);
208  return ret;
209  }
210 
212  SPAN_CHECK(index_ != 0 && index_ <= span_->size());
213  index_--;
214  return *this;
215  }
216 
218  auto ret = *this;
219  --(*this);
220  return ret;
221  }
222 
224  auto ret = *this;
225  return ret += n;
226  }
227 
229  SPAN_CHECK((index_ + n) <= span_->size());
230  index_ += n;
231  return *this;
232  }
233 
235  SPAN_CHECK(span_ == rhs.span_);
236  return index_ - rhs.index_;
237  }
238 
240  auto ret = *this;
241  return ret -= n;
242  }
243 
245  return *this += -n;
246  }
247 
248  // friends
249  XGBOOST_DEVICE constexpr friend bool operator==(
251  return _lhs.span_ == _rhs.span_ && _lhs.index_ == _rhs.index_;
252  }
253 
254  XGBOOST_DEVICE constexpr friend bool operator!=(
256  return !(_lhs == _rhs);
257  }
258 
259  XGBOOST_DEVICE constexpr friend bool operator<(
261  return _lhs.index_ < _rhs.index_;
262  }
263 
264  XGBOOST_DEVICE constexpr friend bool operator<=(
266  return !(_rhs < _lhs);
267  }
268 
269  XGBOOST_DEVICE constexpr friend bool operator>(
271  return _rhs < _lhs;
272  }
273 
274  XGBOOST_DEVICE constexpr friend bool operator>=(
276  return !(_rhs > _lhs);
277  }
278 
279  protected:
280  const SpanType *span_ { nullptr };
281  typename SpanType::index_type index_ { 0 };
282 };
283 
284 
285 // It's tempting to use constexpr instead of structs to do the following meta
286 // programming. But remember that we are supporting MSVC 2013 here.
287 
295 template <std::size_t Extent, std::size_t Offset, std::size_t Count>
296 struct ExtentValue : public std::integral_constant<
297  std::size_t, Count != dynamic_extent ?
298  Count : (Extent != dynamic_extent ? Extent - Offset : Extent)> {};
299 
304 template <typename T, std::size_t Extent>
305 struct ExtentAsBytesValue : public std::integral_constant<
306  std::size_t,
307  Extent == dynamic_extent ?
308  Extent : sizeof(T) * Extent> {};
309 
310 template <std::size_t From, std::size_t To>
311 struct IsAllowedExtentConversion : public std::integral_constant<
312  bool, From == To || From == dynamic_extent || To == dynamic_extent> {};
313 
314 template <class From, class To>
316  : public std::integral_constant<bool, std::is_convertible_v<From (*)[], To (*)[]>> {}; // NOLINT
317 
318 template <class T>
319 struct IsSpanOracle : std::false_type {};
320 
321 template <class T, std::size_t Extent>
322 struct IsSpanOracle<Span<T, Extent>> : std::true_type {};
323 
324 template <class T>
325 struct IsSpan : public IsSpanOracle<typename std::remove_cv_t<T>> {};
326 
327 // Re-implement std algorithms here to adopt CUDA.
328 template <typename T>
329 struct Less {
330  XGBOOST_DEVICE constexpr bool operator()(const T& _x, const T& _y) const {
331  return _x < _y;
332  }
333 };
334 
335 template <typename T>
336 struct Greater {
337  XGBOOST_DEVICE constexpr bool operator()(const T& _x, const T& _y) const {
338  return _x > _y;
339  }
340 };
341 
342 template <class InputIt1, class InputIt2,
343  class Compare =
345 XGBOOST_DEVICE bool LexicographicalCompare(InputIt1 first1, InputIt1 last1,
346  InputIt2 first2, InputIt2 last2) {
347  Compare comp;
348  for (; first1 != last1 && first2 != last2; ++first1, ++first2) {
349  if (comp(*first1, *first2)) {
350  return true;
351  }
352  if (comp(*first2, *first1)) {
353  return false;
354  }
355  }
356  return first1 == last1 && first2 != last2;
357 }
358 
359 } // namespace detail
360 
361 
429 template <typename T,
430  std::size_t Extent = dynamic_extent>
431 class Span {
432  public:
433  using element_type = T; // NOLINT
434  using value_type = typename std::remove_cv<T>::type; // NOLINT
435  using index_type = std::size_t; // NOLINT
437  using pointer = T*; // NOLINT
438  using reference = T&; // NOLINT
439 
441  using const_iterator = const detail::SpanIterator<Span<T, Extent>, true>; // NOLINT
442  using reverse_iterator = std::reverse_iterator<iterator>; // NOLINT
443  using const_reverse_iterator = const std::reverse_iterator<const_iterator>; // NOLINT
444 
445  // constructors
446  constexpr Span() = default;
447 
449  size_(_count), data_(_ptr) {
450  SPAN_CHECK(!(Extent != dynamic_extent && _count != Extent));
451  SPAN_CHECK(_ptr || _count == 0);
452  }
453 
455  size_(_last - _first), data_(_first) {
456  SPAN_CHECK(data_ || size_ == 0);
457  }
458 
459  template <std::size_t N>
460  XGBOOST_DEVICE constexpr Span(element_type (&arr)[N]) // NOLINT
461  __span_noexcept : size_(N), data_(&arr[0]) {}
462 
463  template <class Container,
464  class = typename std::enable_if_t<
465  !std::is_const_v<element_type> && !detail::IsSpan<Container>::value &&
466  std::is_convertible_v<typename Container::pointer, pointer> &&
467  std::is_convertible_v<typename Container::pointer,
468  decltype(std::declval<Container>().data())>>>
469  Span(Container& _cont) // NOLINT
470  : size_(_cont.size()), data_(_cont.data()) {
471  static_assert(!detail::IsSpan<Container>::value, "Wrong constructor of Span is called.");
472  }
473 
474  template <class Container,
475  class = typename std::enable_if_t<
476  std::is_const_v<element_type> && !detail::IsSpan<Container>::value &&
477  std::is_convertible_v<typename Container::pointer, pointer> &&
478  std::is_convertible_v<typename Container::pointer,
479  decltype(std::declval<Container>().data())>>>
480  Span(const Container& _cont) // NOLINT
481  : size_(_cont.size()), data_(_cont.data()) {
482  static_assert(!detail::IsSpan<Container>::value, "Wrong constructor of Span is called.");
483  }
484 
485  template <class U, std::size_t OtherExtent,
486  class = typename std::enable_if_t<
489  XGBOOST_DEVICE constexpr Span(const Span<U, OtherExtent>& _other) // NOLINT
490  __span_noexcept : size_(_other.size()),
491  data_(_other.data()) {}
492 
493  constexpr Span(Span const& _other) noexcept(true) = default;
494  constexpr Span& operator=(Span const& _other) noexcept(true) = default;
495  constexpr Span(Span&& _other) noexcept(true) = default;
496  constexpr Span& operator=(Span&& _other) noexcept(true) = default;
497  ~Span() noexcept(true) = default;
498 
499  XGBOOST_DEVICE constexpr iterator begin() const __span_noexcept { // NOLINT
500  return {this, 0};
501  }
502 
503  XGBOOST_DEVICE constexpr iterator end() const __span_noexcept { // NOLINT
504  return {this, size()};
505  }
506 
507  XGBOOST_DEVICE constexpr const_iterator cbegin() const __span_noexcept { // NOLINT
508  return {this, 0};
509  }
510 
511  XGBOOST_DEVICE constexpr const_iterator cend() const __span_noexcept { // NOLINT
512  return {this, size()};
513  }
514 
515  constexpr reverse_iterator rbegin() const __span_noexcept { // NOLINT
516  return reverse_iterator{end()};
517  }
518 
519  constexpr reverse_iterator rend() const __span_noexcept { // NOLINT
520  return reverse_iterator{begin()};
521  }
522 
524  return const_reverse_iterator{cend()};
525  }
526 
528  return const_reverse_iterator{cbegin()};
529  }
530 
531  // element access
532 
533  XGBOOST_DEVICE reference front() const { // NOLINT
534  return (*this)[0];
535  }
536 
537  XGBOOST_DEVICE reference back() const { // NOLINT
538  return (*this)[size() - 1];
539  }
540 
542  SPAN_LT(_idx, size());
543  return data()[_idx];
544  }
545 
547  return this->operator[](_idx);
548  }
549 
550  XGBOOST_DEVICE constexpr pointer data() const __span_noexcept { // NOLINT
551  return data_;
552  }
553 
554  // Observers
555  XGBOOST_DEVICE constexpr index_type size() const __span_noexcept { // NOLINT
556  return size_;
557  }
558  XGBOOST_DEVICE constexpr index_type size_bytes() const __span_noexcept { // NOLINT
559  return size() * sizeof(T);
560  }
561 
562  XGBOOST_DEVICE constexpr bool empty() const __span_noexcept { // NOLINT
563  return size() == 0;
564  }
565 
566  // Subviews
567  template <std::size_t Count>
569  SPAN_CHECK(Count <= size());
570  return {data(), Count};
571  }
572 
574  std::size_t _count) const {
575  SPAN_CHECK(_count <= size());
576  return {data(), _count};
577  }
578 
579  template <std::size_t Count>
581  SPAN_CHECK(Count <= size());
582  return {data() + size() - Count, Count};
583  }
584 
586  std::size_t _count) const {
587  SPAN_CHECK(_count <= size());
588  return subspan(size() - _count, _count);
589  }
590 
595  template <std::size_t Offset,
596  std::size_t Count = dynamic_extent>
597  XGBOOST_DEVICE auto subspan() const -> // NOLINT
599  detail::ExtentValue<Extent, Offset, Count>::value> {
600  SPAN_CHECK((Count == dynamic_extent) ?
601  (Offset <= size()) : (Offset + Count <= size()));
602  return {data() + Offset, Count == dynamic_extent ? size() - Offset : Count};
603  }
604 
606  index_type _offset,
607  index_type _count = dynamic_extent) const {
608  SPAN_CHECK((_count == dynamic_extent) ?
609  (_offset <= size()) : (_offset + _count <= size()));
610  return {data() + _offset, _count ==
611  dynamic_extent ? size() - _offset : _count};
612  }
613 
614  private:
615  index_type size_ { 0 };
616  pointer data_ { nullptr };
617 };
618 
619 template <class T, std::size_t X, class U, std::size_t Y>
621  if (l.size() != r.size()) {
622  return false;
623  }
624  for (auto l_beg = l.cbegin(), r_beg = r.cbegin(); l_beg != l.cend();
625  ++l_beg, ++r_beg) {
626  if (*l_beg != *r_beg) {
627  return false;
628  }
629  }
630  return true;
631 }
632 
633 template <class T, std::size_t X, class U, std::size_t Y>
635  return !(l == r);
636 }
637 
638 template <class T, std::size_t X, class U, std::size_t Y>
640  return detail::LexicographicalCompare(l.begin(), l.end(),
641  r.begin(), r.end());
642 }
643 
644 template <class T, std::size_t X, class U, std::size_t Y>
646  return !(l > r);
647 }
648 
649 template <class T, std::size_t X, class U, std::size_t Y>
652  typename Span<T, X>::iterator, typename Span<U, Y>::iterator,
654  r.begin(), r.end());
655 }
656 
657 template <class T, std::size_t X, class U, std::size_t Y>
659  return !(l < r);
660 }
661 
662 template <class T, std::size_t E>
665  return {reinterpret_cast<const byte*>(s.data()), s.size_bytes()};
666 }
667 
668 template <class T, std::size_t E>
671  return {reinterpret_cast<byte*>(s.data()), s.size_bytes()};
672 }
673 
677 template <typename It>
678 class IterSpan {
679  public:
680  using value_type = typename std::iterator_traits<It>::value_type; // NOLINT
681  using index_type = std::size_t; // NOLINT
682  using iterator = It; // NOLINT
683 
684  private:
685  It it_;
686  index_type size_{0};
687 
688  public:
689  IterSpan() = default;
690  XGBOOST_DEVICE IterSpan(It it, index_type size) : it_{std::move(it)}, size_{size} {}
692  : it_{span.data()}, size_{span.size()} {}
693 
694  [[nodiscard]] XGBOOST_DEVICE index_type size() const noexcept { return size_; } // NOLINT
695  [[nodiscard]] XGBOOST_DEVICE decltype(auto) operator[](index_type i) const { return it_[i]; }
696  [[nodiscard]] XGBOOST_DEVICE decltype(auto) operator[](index_type i) { return it_[i]; }
697  [[nodiscard]] XGBOOST_DEVICE bool empty() const noexcept { return size() == 0; } // NOLINT
698  [[nodiscard]] XGBOOST_DEVICE It data() const noexcept { return it_; } // NOLINT
699  [[nodiscard]] XGBOOST_DEVICE IterSpan<It> subspan( // NOLINT
700  index_type _offset, index_type _count = dynamic_extent) const {
701  SPAN_CHECK((_count == dynamic_extent) ? (_offset <= size()) : (_offset + _count <= size()));
702  return {data() + _offset, _count == dynamic_extent ? size() - _offset : _count};
703  }
704  [[nodiscard]] XGBOOST_DEVICE constexpr iterator begin() const noexcept { // NOLINT
705  return it_;
706  }
707  [[nodiscard]] XGBOOST_DEVICE constexpr iterator end() const noexcept { // NOLINT
708  return it_ + size();
709  }
710 };
711 
712 template <typename T>
713 Span(std::vector<T> const&) -> Span<T const>;
714 
715 template <typename T>
716 Span(std::vector<T>&) -> Span<T>;
717 } // namespace xgboost::common
718 
719 
720 #if defined(_MSC_VER) &&_MSC_VER < 1910
721 #undef constexpr
722 #pragma pop_macro("constexpr")
723 #undef __span_noexcept
724 #endif // _MSC_VER < 1910
725 
726 #endif // XGBOOST_SPAN_H_
Defines configuration macros and basic types for xgboost.
#define XGBOOST_DEVICE
Tag function as usable by device.
Definition: base.h:64
A simple custom Span type that uses general iterator instead of pointer.
Definition: span.h:678
It iterator
Definition: span.h:682
constexpr XGBOOST_DEVICE iterator begin() const noexcept
Definition: span.h:704
std::size_t index_type
Definition: span.h:681
XGBOOST_DEVICE IterSpan(common::Span< It, dynamic_extent > span)
Definition: span.h:691
constexpr XGBOOST_DEVICE iterator end() const noexcept
Definition: span.h:707
XGBOOST_DEVICE IterSpan(It it, index_type size)
Definition: span.h:690
XGBOOST_DEVICE bool empty() const noexcept
Definition: span.h:697
XGBOOST_DEVICE IterSpan< It > subspan(index_type _offset, index_type _count=dynamic_extent) const
Definition: span.h:699
XGBOOST_DEVICE index_type size() const noexcept
Definition: span.h:694
XGBOOST_DEVICE It data() const noexcept
Definition: span.h:698
typename std::iterator_traits< It >::value_type value_type
Definition: span.h:680
span class implementation, based on ISO++20 span<T>. The interface should be the same.
Definition: span.h:431
T & reference
Definition: span.h:438
XGBOOST_DEVICE Span(pointer _first, pointer _last)
Definition: span.h:454
Span(const Container &_cont)
Definition: span.h:480
T * pointer
Definition: span.h:437
detail::ptrdiff_t difference_type
Definition: span.h:436
XGBOOST_DEVICE reference operator()(index_type _idx) const
Definition: span.h:546
XGBOOST_DEVICE reference front() const
Definition: span.h:533
constexpr XGBOOST_DEVICE const_iterator cbegin() const __span_noexcept
Definition: span.h:507
constexpr XGBOOST_DEVICE iterator begin() const __span_noexcept
Definition: span.h:499
constexpr XGBOOST_DEVICE pointer data() const __span_noexcept
Definition: span.h:550
std::size_t index_type
Definition: span.h:435
constexpr Span(Span const &_other) noexcept(true)=default
XGBOOST_DEVICE reference back() const
Definition: span.h:537
constexpr Span()=default
XGBOOST_DEVICE auto subspan() const -> Span< element_type, detail::ExtentValue< Extent, Offset, Count >::value >
Definition: span.h:597
constexpr XGBOOST_DEVICE index_type size() const __span_noexcept
Definition: span.h:555
XGBOOST_DEVICE Span< element_type, Count > last() const
Definition: span.h:580
Span(Container &_cont)
Definition: span.h:469
XGBOOST_DEVICE Span< element_type, Count > first() const
Definition: span.h:568
constexpr XGBOOST_DEVICE bool empty() const __span_noexcept
Definition: span.h:562
constexpr Span(Span &&_other) noexcept(true)=default
constexpr XGBOOST_DEVICE index_type size_bytes() const __span_noexcept
Definition: span.h:558
constexpr XGBOOST_DEVICE Span(element_type(&arr)[N]) __span_noexcept
Definition: span.h:460
constexpr reverse_iterator rbegin() const __span_noexcept
Definition: span.h:515
T element_type
Definition: span.h:433
constexpr Span & operator=(Span &&_other) noexcept(true)=default
const std::reverse_iterator< const_iterator > const_reverse_iterator
Definition: span.h:443
XGBOOST_DEVICE Span< element_type, dynamic_extent > first(std::size_t _count) const
Definition: span.h:573
~Span() noexcept(true)=default
constexpr XGBOOST_DEVICE const_reverse_iterator crbegin() const __span_noexcept
Definition: span.h:523
constexpr XGBOOST_DEVICE const_iterator cend() const __span_noexcept
Definition: span.h:511
constexpr Span & operator=(Span const &_other) noexcept(true)=default
constexpr XGBOOST_DEVICE const_reverse_iterator crend() const __span_noexcept
Definition: span.h:527
constexpr XGBOOST_DEVICE iterator end() const __span_noexcept
Definition: span.h:503
XGBOOST_DEVICE reference operator[](index_type _idx) const
Definition: span.h:541
constexpr reverse_iterator rend() const __span_noexcept
Definition: span.h:519
XGBOOST_DEVICE Span(pointer _ptr, index_type _count)
Definition: span.h:448
std::reverse_iterator< iterator > reverse_iterator
Definition: span.h:442
XGBOOST_DEVICE Span< element_type, dynamic_extent > subspan(index_type _offset, index_type _count=dynamic_extent) const
Definition: span.h:605
constexpr XGBOOST_DEVICE Span(const Span< U, OtherExtent > &_other) __span_noexcept
Definition: span.h:489
typename std::remove_cv< T >::type value_type
Definition: span.h:434
XGBOOST_DEVICE Span< element_type, dynamic_extent > last(std::size_t _count) const
Definition: span.h:585
XGBOOST_DEVICE pointer operator->() const
Definition: span.h:194
XGBOOST_DEVICE SpanIterator & operator--()
Definition: span.h:211
std::random_access_iterator_tag iterator_category
Definition: span.h:165
XGBOOST_DEVICE reference operator*() const
Definition: span.h:186
constexpr XGBOOST_DEVICE friend bool operator<(SpanIterator _lhs, SpanIterator _rhs) __span_noexcept
Definition: span.h:259
typename SpanType::value_type value_type
Definition: span.h:166
constexpr XGBOOST_DEVICE SpanIterator(const SpanType *_span, typename SpanType::index_type _idx) __span_noexcept
Definition: span.h:175
constexpr XGBOOST_DEVICE friend bool operator>(SpanIterator _lhs, SpanIterator _rhs) __span_noexcept
Definition: span.h:269
constexpr XGBOOST_DEVICE SpanIterator(const SpanIterator< SpanType, B > &other_) __span_noexcept
Definition: span.h:182
XGBOOST_DEVICE SpanIterator operator++(int)
Definition: span.h:205
constexpr XGBOOST_DEVICE friend bool operator==(SpanIterator _lhs, SpanIterator _rhs) __span_noexcept
Definition: span.h:249
XGBOOST_DEVICE SpanIterator & operator+=(difference_type n)
Definition: span.h:228
XGBOOST_DEVICE SpanIterator operator-(difference_type n) const
Definition: span.h:239
XGBOOST_DEVICE SpanIterator & operator-=(difference_type n)
Definition: span.h:244
detail::ptrdiff_t difference_type
Definition: span.h:167
typename std::conditional< IsConst, const ElementType, ElementType >::type & reference
Definition: span.h:170
XGBOOST_DEVICE reference operator[](difference_type n) const
Definition: span.h:190
typename std::add_pointer< reference >::type pointer
Definition: span.h:171
XGBOOST_DEVICE difference_type operator-(SpanIterator rhs) const
Definition: span.h:234
const SpanType * span_
Definition: span.h:280
constexpr XGBOOST_DEVICE friend bool operator>=(SpanIterator _lhs, SpanIterator _rhs) __span_noexcept
Definition: span.h:274
XGBOOST_DEVICE SpanIterator operator+(difference_type n) const
Definition: span.h:223
constexpr XGBOOST_DEVICE friend bool operator!=(SpanIterator _lhs, SpanIterator _rhs) __span_noexcept
Definition: span.h:254
constexpr XGBOOST_DEVICE friend bool operator<=(SpanIterator _lhs, SpanIterator _rhs) __span_noexcept
Definition: span.h:264
XGBOOST_DEVICE SpanIterator operator--(int)
Definition: span.h:217
SpanType::index_type index_
Definition: span.h:281
XGBOOST_DEVICE SpanIterator & operator++()
Definition: span.h:199
Definition: intrusive_ptr.h:207
XGBOOST_DEVICE bool LexicographicalCompare(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2)
Definition: span.h:345
typename std::conditional_t< std::is_same_v< std::ptrdiff_t, std::int64_t >, std::ptrdiff_t, std::int64_t > ptrdiff_t
Definition: span.h:143
Definition: span.h:76
constexpr XGBOOST_DEVICE bool operator>=(Span< T, X > l, Span< U, Y > r)
Definition: span.h:658
constexpr XGBOOST_DEVICE bool operator!=(Span< T, X > l, Span< U, Y > r)
Definition: span.h:634
constexpr std::size_t dynamic_extent
Definition: span.h:150
byte
Definition: span.h:153
XGBOOST_DEVICE auto as_writable_bytes(Span< T, E > s) __span_noexcept -> Span< byte, detail::ExtentAsBytesValue< T, E >::value >
Definition: span.h:669
XGBOOST_DEVICE bool operator==(Span< T, X > l, Span< U, Y > r)
Definition: span.h:620
XGBOOST_DEVICE auto as_bytes(Span< T, E > s) __span_noexcept -> Span< const byte, detail::ExtentAsBytesValue< T, E >::value >
Definition: span.h:663
constexpr XGBOOST_DEVICE bool operator>(Span< T, X > l, Span< U, Y > r)
Definition: span.h:650
Span(std::vector< T > const &) -> Span< T const >
constexpr XGBOOST_DEVICE bool operator<=(Span< T, X > l, Span< U, Y > r)
Definition: span.h:645
constexpr XGBOOST_DEVICE bool operator<(Span< T, X > l, Span< U, Y > r)
Definition: span.h:639
constexpr size_t Offset(S(&strides)[D], size_t n, Head head)
Definition: linalg.h:53
#define SPAN_LT(lhs, rhs)
Definition: span.h:133
#define __span_noexcept
span class based on ISO++20 span
Definition: span.h:72
#define SPAN_CHECK(cond)
Definition: span.h:127
Definition: span.h:336
constexpr XGBOOST_DEVICE bool operator()(const T &_x, const T &_y) const
Definition: span.h:337
Definition: span.h:325
Definition: span.h:329
constexpr XGBOOST_DEVICE bool operator()(const T &_x, const T &_y) const
Definition: span.h:330