span: One-dimensional Non-owning View

#include <raft/core/span.hpp>

using element_type = T

using value_type = typename std::remove_cv<T>::type

using size_type = std::size_t

using difference_type = std::ptrdiff_t

using pointer = T*

using const_pointer = T const*

using reference = T&

using const_reference = T const&

using iterator = pointer

using const_iterator = const_pointer

using reverse_iterator = cuda::std::reverse_iterator<iterator>

using const_reverse_iterator = cuda::std::reverse_iterator<const_iterator>

constexpr span() noexcept = default

Default constructor that constructs a span with size 0 and nullptr.

inline constexpr span(pointer ptr, size_type count) noexcept

Constructs a span that is a view over the range [first, first + count);.

inline constexpr span(pointer first, pointer last) noexcept

Constructs a span that is a view over the range [first, last)

template<std::size_t N>
inline constexpr span(element_type (&arr)[N]) noexcept

Constructs a span that is a view over the array arr.

template<class U, std::size_t OtherExtent, class = typename std::enable_if<detail::is_allowed_element_type_conversion_t<U, T>::value && detail::is_allowed_extent_conversion_t<OtherExtent, Extent>::value>>
inline constexpr span(const span<U, is_device, OtherExtent> &other) noexcept

Initialize a span class from another one who’s underlying type is convertible to element_type.

constexpr span(span const &other) noexcept = default

constexpr span(span &&other) noexcept = default

span &=default operator= (span const &other) noexcept

span &=default operator= (span &&other) noexcept

inline iterator begin() const noexcept

inline iterator end() const noexcept

inline const_iterator cbegin() const noexcept

inline const_iterator cend() const noexcept

inline _RAFT_HOST_DEVICE constexpr auto rbegin () const noexcept -> reverse_iterator

inline _RAFT_HOST_DEVICE constexpr auto rend () const noexcept -> reverse_iterator

inline _RAFT_HOST_DEVICE constexpr auto crbegin () const noexcept -> const_reverse_iterator

inline _RAFT_HOST_DEVICE constexpr auto crend () const noexcept -> const_reverse_iterator

inline reference front() const

inline reference back() const

template<typename Index>
inline reference operator[](Index _idx) const

inline pointer data() const noexcept

inline size_type size() const noexcept

inline size_type size_bytes() const noexcept

inline auto empty() const noexcept

template<std::size_t Count>
inline span<element_type, is_device, Count> first() const

inline span<element_type, is_device, dynamic_extent> first(std::size_t _count) const

template<std::size_t Count>
inline span<element_type, is_device, Count> last() const

inline span<element_type, is_device, dynamic_extent> last(std::size_t _count) const

template<std::size_t Offset, std::size_t Count = dynamic_extent>
inline span<element_type, is_device, detail::extent_value_t<Extent, Offset, Count>::value> subspan() const

If Count is std::dynamic_extent, r.size() == this->size() - Offset; Otherwise r.size() == Count.

inline span<element_type, is_device, dynamic_extent> subspan(size_type _offset, size_type _count = dynamic_extent) const

template<class T, std::size_t X, class U, std::size_t Y, bool is_device>
bool operator==(span<T, is_device, X> l, span<U, is_device, Y> r)

template<class T, std::size_t X, class U, std::size_t Y, bool is_device>
auto operator!=(span<T, is_device, X> l, span<U, is_device, Y> r)

template<class T, std::size_t X, class U, std::size_t Y, bool is_device>
auto operator<(span<T, is_device, X> l, span<U, is_device, Y> r)

template<class T, std::size_t X, class U, std::size_t Y, bool is_device>
auto operator<=(span<T, is_device, X> l, span<U, is_device, Y> r)

template<class T, std::size_t X, class U, std::size_t Y, bool is_device>
auto operator>(span<T, is_device, X> l, span<U, is_device, Y> r)

template<class T, std::size_t X, class U, std::size_t Y, bool is_device>
auto operator>=(span<T, is_device, X> l, span<U, is_device, Y> r)

template<class T, bool is_device, std::size_t E>
span<const std::byte, is_device, detail::extent_as_bytes_value_t<T, E>::value> as_bytes(span<T, is_device, E> s) noexcept

Converts a span into a view of its underlying bytes.

template<class T, bool is_device, std::size_t E>
span<std::byte, is_device, detail::extent_as_bytes_value_t<T, E>::value> as_writable_bytes(span<T, is_device, E> s) noexcept

Converts a span into a mutable view of its underlying bytes.

template<typename T, bool is_device, std::size_t Extent = dynamic_extent>
class span

#include <span.hpp>

The span class defined in ISO C++20. Iterator is defined as plain pointer and most of the methods have bound check on debug build.

rmm::device_uvector<float> uvec(10, rmm::cuda_stream_default);
auto view = device_span<float>{uvec.data(), uvec.size()};

#include <raft/core/device_span.hpp>

template<typename T, size_t extent = cuda::std::dynamic_extent>
using device_span = span<T, true, extent>

A span class for device pointer.

#include <raft/core/host_span.hpp>

template<typename T, size_t extent = cuda::std::dynamic_extent>
using host_span = span<T, false, extent>

A span class for host pointer.