`layout_stride_relaxed`#

Defined in the <cuda/mdspan> header.

layout_stride_relaxed is a LayoutMappingPolicy which provides a layout mapping where the strides are user-defined and can be negative or zero.

Unlike cuda::std::layout_stride, this layout allows:

Negative strides for reverse iteration.
Zero strides for broadcasting.
A base offset to accommodate negative strides.
Compile-time stride values for static arrays.

Note

This layout is NOT always unique, exhaustive, or strided in the C++ standard sense.

Synopsis#

namespace cuda {

// Tag value for dynamic stride (analogous to dynamic_extent)
inline constexpr ptrdiff_t dynamic_stride = /* implementation-defined */;

// Strides class template
template <class OffsetType, ptrdiff_t... Strides>
class strides;

// Alias for all-dynamic strides
template <class OffsetType, size_t Rank>
using dstrides = strides<OffsetType, /* Rank dynamic_stride values */>;

// Alias for steps (synonym for dstrides)
template <size_t Rank, class OffsetType = ptrdiff_t>
using steps = dstrides<OffsetType, Rank>;

// Layout policy
struct layout_stride_relaxed {
    template <class Extents,
              class Stride = dstrides<make_signed_t<typename Extents::index_type>,
                                      Extents::rank()>,
              class OffsetType = ptrdiff_t>
    class mapping;
};

} // namespace cuda

`strides`#

Class template to describe the strides of a multi-dimensional array layout. Similar to extents, but for strides. Supports both static (compile-time known) and dynamic (runtime) stride values.

// Strides class template
template <class OffsetType, ptrdiff_t... Strides>
class strides;

// Alias for all-dynamic strides
template <class OffsetType, size_t Rank>
using dstrides = strides<OffsetType, /* Rank dynamic_stride values */>;

// Alias for steps (synonym for dstrides)
template <size_t Rank, class OffsetType = ptrdiff_t>
using steps = dstrides<OffsetType, Rank>;

Template Parameters

OffsetType: A signed integer type for stride values (supports negative strides) or an integer-constant-like type.
Strides...: The stride values, where dynamic_stride indicates a runtime value.
Rank: The number of dimensions.

Member Types	Definition
`offset_type`	`OffsetType`
`size_type`	`cuda::std::make_unsigned_t<offset_type>`
`rank_type`	`cuda::std::size_t`

Static Member Functions	Description
`rank()`	Returns the number of dimensions.
`rank_dynamic()`	Returns the number of dynamic strides.
`static_stride(rank_type r)`	Returns the static stride at dimension `r`, or `dynamic_stride` if dynamic.

Member Functions	Description
`stride(rank_type r)`	Returns the stride at dimension `r`.

Non-member Functions	Description
`operator==`	`true` if ranks are equal and all extent and stride values compare equal; `false` otherwise.
`operator!=`	`false` if ranks are equal and all extent and stride values compare equal; `true` otherwise.

Constructors

// (1) default constructor
constexpr strides() noexcept = default;

// (2) constructor from values
template <class... OtherIndexTypes>
constexpr explicit strides(OtherIndexTypes... values) noexcept;

// (3) constructor from span
template <class OtherIndexType, size_t Size>
constexpr explicit(/*see below*/) strides(cuda::std::span<OtherIndexType, Size> strs) noexcept;

// (4) constructor from array
template <class OtherIndexType, size_t Size>
constexpr explicit(/*see below*/) strides(const cuda::std::array<OtherIndexType, Size>& strs) noexcept;

// (5) constructor from strides
template <class OtherIndexType, ptrdiff_t... OtherStrides>
constexpr explicit(/*see below*/) strides(const strides<OtherIndexType, OtherStrides...>& other) noexcept;

(1) Default constructor. Value-initializes all dynamic strides to zero.
(2) Initializes the strides with the provided values.
- Constraints:
  - sizeof...(OtherIndexTypes) equals rank() or rank_dynamic().
  - OtherIndexTypes... is convertible and nothrow constructible to offset_type.
- Preconditions:
  - Each value is representable as offset_type.
(3), (4) Initializes the strides from span or array values.
- Constraints:
  - Size equals rank_dynamic() (implicit) or Size equals rank() and Size != rank_dynamic() (explicit).
  - OtherIndexType is convertible and nothrow constructible to offset_type.
- Preconditions:
  - Each value is representable as offset_type.
(5) Initializes the strides from another strides object.
- The constructor is explicit if any static stride in Strides... corresponds to a dynamic_stride in OtherStrides....
- Constraints:
  - sizeof...(OtherStrides) equals sizeof...(Strides).
  - For each dimension, either stride is dynamic_stride, or both strides are equal.
- Preconditions:
  - Static strides must match their compile-time values.
  - Each dynamic stride value is representable as offset_type.