---
libstdc++-v3/include/std/mdspan | 387 ++++++++++++++++++
libstdc++-v3/src/c++23/std.cc.in | 2 +-
.../mdspan/submdspan/submdspan.cc | 369 +++++++++++++++++
.../mdspan/submdspan/submdspan_mapping.cc | 136 ++++++
.../mdspan/submdspan/submdspan_neg.cc | 102 +++++
5 files changed, 995 insertions(+), 1 deletion(-)
create mode 100644
libstdc++-v3/testsuite/23_containers/mdspan/submdspan/submdspan.cc
create mode 100644
libstdc++-v3/testsuite/23_containers/mdspan/submdspan/submdspan_mapping.cc
create mode 100644
libstdc++-v3/testsuite/23_containers/mdspan/submdspan/submdspan_neg.cc
diff --git a/libstdc++-v3/include/std/mdspan
b/libstdc++-v3/include/std/mdspan
index 36e04f7e1b5..712826ea7e7 100644
--- a/libstdc++-v3/include/std/mdspan
+++ b/libstdc++-v3/include/std/mdspan
@@ -578,20 +578,30 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
return __r == 0 ? 1 : __exts.extent(0);
else if constexpr
(__all_dynamic(std::span(__sta_exts).first(__rank-1)))
return __extents_prod(__exts, 1, 0, __r);
else
{
size_t __sta_prod = __fwd_partial_prods<__sta_exts>[__r];
return __extents_prod(__exts, __sta_prod, 0, __r);
}
}
+ template<typename _IndexType, size_t _Nm>
+ consteval _IndexType
+ __fwd_prod(span<const _IndexType, _Nm> __values)
+ {
+ _IndexType __ret = 1;
+ for(auto __value : __values)
+ __ret *= __value;
+ return __ret;
+ }
+
// Preconditions: _r < _Extents::rank()
template<typename _Extents>
constexpr typename _Extents::index_type
__rev_prod(const _Extents& __exts, size_t __r) noexcept
{
constexpr size_t __rank = _Extents::rank();
constexpr auto& __sta_exts = __static_extents<_Extents>();
if constexpr (__rank == 1)
return 1;
else if constexpr (__rank == 2)
@@ -1027,20 +1037,374 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
constexpr auto __sub_rank = __subrank<_IndexType, _Slices...>();
auto __map = std::array<size_t, __sub_rank>{};
auto __is_int_like = std::array{convertible_to<_Slices,
_IndexType>...};
size_t __i = 0;
for (size_t __k = 0; __k < __rank; ++__k)
if (!__is_int_like[__k])
__map[__i++] = __k;
return __map;
}
+
+ template<typename _IndexType, typename _Slice>
+ constexpr _IndexType
+ __slice_begin(_Slice __slice)
+ {
Please consider implementing this as:
if constexpr (is_same_v<_Slice, _full_extent_t>)
return 0;
else if constexpr (__is_strided_slice<_Slice>)
return __slice.offset;
else
return __slice;
This should be lighter to check that using concept,
and you do not need to pass _IndexType.
+ if constexpr (convertible_to<_Slice, _IndexType>)
+ return __slice;
+ else if constexpr (__is_strided_slice<_Slice>)
+ return __slice.offset;
+ else
+ return 0; // full_extent
+ }
+
+ template<typename _Mapping, typename... _Slices>
+ constexpr size_t
+ __suboffset(const _Mapping& __mapping, const _Slices&... __slices)
+ {
+ using _IndexType = typename _Mapping::index_type;
+ auto __any_past_the_end = [&]<size_t...
_Is>(index_sequence<_Is...>)
+ {
+ auto __is_past_the_end = [](const auto& __slice, const auto&
__ext)
+ {
+ using _Slice = remove_cvref_t<decltype(__slice)>;
if constexpr (__ext.static_extent(
I will suggest expressing this as:
if constexpr (is_same_v<_Slice, __full_extent_t>)
return true; // we checked that before
else if constexpr (!_is_strided_slice<_Slice>)
return false;
else
// Compiler wii probably optimize if this two are constant.
return __slice.offset = __ext.extent(0);
+ if constexpr (is_convertible_v<_Slice, _IndexType>)
I do not think this is correct, we single indices to operators.
+ return false;
+ else if (same_as<_Slice, full_extent_t>
+ && __ext.static_extent(0) > 0
+ && __ext.static_extent(0) != dynamic_extent)
+ return false;
+ else
+ return __slice_begin<_IndexType>(__slice) == __ext.extent(0);
We seem to this for __full_extent, before the previous if is not constexpr.
+ };
+
+ const auto& __exts = __mapping.extents();
+ return ((__is_past_the_end(__slices...[_Is],
+ __extract_extent<_Is>(__exts))) ||
...);
+ };
+
+ if constexpr ((same_as<_Slices, full_extent_t> && ...))
+ return __offset(__mapping);
+
I think I would check empty mdspan separately here, so if
empty(__mapping.extents())
the return __mapping.required_span_size(), this will also simply
__any_past_the_end.
+ if constexpr (!((convertible_to<_Slices, _IndexType>) && ...))
+ if
(__any_past_the_end(make_index_sequence<sizeof...(__slices)>()))
+ return __mapping.required_span_size();
+ return __mapping(__slice_begin<_IndexType>(__slices)...);
Because we do not pass _IndexType to slice begin, use
static_cast<_IndexType> here.
+ }
+
+ enum class _LayoutSide
+ {
+ __left,
+ __right,
+ __unknown
+ };
+
+ template<typename _Mapping>
+ consteval _LayoutSide
+ __deduce_mapping_side()
+ {
+ if constexpr (__is_left_padded_mapping<_Mapping>
+ || __mapping_of<layout_left, _Mapping>)
+ return _LayoutSide::__left;
+ if constexpr (__is_right_padded_mapping<_Mapping>
+ || __mapping_of<layout_right, _Mapping>)
+ return _LayoutSide::__right;
+ else
+ return _LayoutSide::__unknown;
+ }
+
+ template<_LayoutSide _Side, size_t _Rank>
+ struct _StridesTrait
+ {
+ static constexpr const _LayoutSide _S_side = _Side;
+
+ static constexpr size_t
+ _S_idx(size_t __k) noexcept
+ {
+ if constexpr (_Side == _LayoutSide::__left)
+ return __k;
+ else
+ return _Rank - 1 - __k;
+ }
+
+ template<typename _Mapping>
+ static constexpr typename _Mapping::index_type
+ _S_extent(const _Mapping& __mapping, size_t __k)
+ {
+ if (__k == 0)
+ return __mapping.stride(_S_idx(1));
Nice trick of handling padded and not padded, but comment on it.
+ else
+ return __mapping.extents().extent(_S_idx(__k));
+ }
+
+ template<typename _IndexType, typename... _Slices>
+ static consteval auto
+ _S_inv_map()
+ {
+ static_assert(_Side != _LayoutSide::__unknown);
+ auto __impl = [&]<size_t... _Is>(index_sequence<_Is...>)
+ {
+ return __inv_map_rank<_IndexType,
_Slices...[_S_idx(_Is)]...>();
+ };
+ return __impl(make_index_sequence<_Rank>());
+ }
+ };
+
+ template<typename _SubExtents, typename _Mapping, typename... _Slices>
+ constexpr auto
+ __substrides_generic(const _Mapping& __mapping, const _Slices&...
__slices)
+ {
+ using _IndexType = typename _Mapping::index_type;
+ if constexpr (_SubExtents::rank() == 0)
+ return array<_IndexType, _SubExtents::rank()>{};
+ else
+ {
+ auto __stride = [&__mapping](size_t __k, auto __slice) ->
_IndexType
+ {
+ if constexpr (__is_strided_slice<decltype(__slice)>)
+ if (__slice.stride < __slice.extent)
+ return __mapping.stride(__k) * __slice.stride;
+ return __mapping.stride(__k);
+ };
+
+ auto __impl = [&]<size_t... _Is>(index_sequence<_Is...>)
+ {
+ constexpr auto __inv_map = __inv_map_rank<_IndexType,
_Slices...>();
+ return array<_IndexType, _SubExtents::rank()>{
+ __stride(__inv_map[_Is], __slices...[__inv_map[_Is]])...};
+ };
+ return __impl(make_index_sequence<_SubExtents::rank()>());
+ }
+ };
+
+ template<typename _SubExtents, typename _Mapping, typename... _Slices>
+ constexpr auto
+ __substrides_standardized(const _Mapping& __mapping,
+ const _Slices&... __slices)
+ {
+ using _IndexType = typename _Mapping::index_type;
+ using _Trait = _StridesTrait<__deduce_mapping_side<_Mapping>(),
+ _Mapping::extents_type::rank()>;
+ using _SubTrait = _StridesTrait<__deduce_mapping_side<_Mapping>(),
+ _SubExtents::rank()>;
+
+ constexpr size_t __sub_rank = _SubExtents::rank();
+
+ array<_IndexType, __sub_rank> __ret;
+ if constexpr (__sub_rank > 0)
+ {
+ constexpr auto __inv_map
+ = _Trait::template _S_inv_map<_IndexType, _Slices...>();
+ auto __loop = [&]<size_t... _Ks>(index_sequence<_Ks...>)
+ {
+ size_t __i0 = 0;
+ size_t __stride = 1;
+ auto __body = [&](size_t __k, auto __slice)
+ {
+ for (size_t __i = __i0; __i < __inv_map[__k]; ++__i)
+ __stride *= _Trait::_S_extent(__mapping, __i);
I wonder if for all standardized mappings, we should not add _M_strides
(public) function to access that. This would be useful.
+
+ size_t __krev = _SubTrait::_S_idx(__k);
+ if constexpr (__is_strided_slice<decltype(__slice)>)
+ __ret[__krev] = __stride * __slice.stride;
+ else
+ __ret[__krev] = __stride;
+
+ __i0 = __inv_map[__k];
+ };
+
+ ((__body(_Ks,
__slices...[_Trait::_S_idx(__inv_map[_Ks])])),...);
+ };
+ __loop(make_index_sequence<__sub_rank>());
+ }
+ return __ret;
+ }
+
+
+ template<typename _SubExtents, typename _Mapping, typename... _Slices>
+ constexpr auto
+ __substrides(const _Mapping& __mapping, const _Slices&... __slices)
+ {
+ if constexpr (__deduce_mapping_side<_Mapping>() ==
_LayoutSide::__unknown)
+ return __substrides_generic<_SubExtents>(__mapping, __slices...);
+ else
+ return __substrides_standardized<_SubExtents>(__mapping,
__slices...);
+ }
+
+ template<typename _Slice, typename _IndexType>
+ concept __is_unit_stride_slice =
(__is_strided_slice<_Slice>
+ && __detail::__integral_constant_like<typename
_Slice::stride_type>
Usig is_constant_wrapper instead of __integral_constant_like.
+ && _Slice::stride_type::value == 1)
+ || same_as<_Slice, full_extent_t>;
+
+ // _BlockSize - 1
+ // [full, ..., full, unit_slice , ...]
+ template<typename _IndexType, size_t _BlockSize, typename... _Slices>
I think this funciton would read much better if we do normal template
parameter recursion,
i.e. have typename _Slice, typename... _RemSlices, we should never search a
block
with one element.
+ consteval bool
+ __is_block()
+ {
+ if constexpr (_BlockSize == 0 || _BlockSize > sizeof...(_Slices))
+ return false;
+ else if constexpr (_BlockSize == 1)
+ return __is_unit_stride_slice<_Slices...[0], _IndexType>;
+ else if constexpr (same_as<_Slices...[0], full_extent_t>)
This will be much simpler.
+ {
+ auto __recurse = []<size_t... _Is>(index_sequence<_Is...>)
+ {
+ return __is_block<_IndexType, _BlockSize - 1,
+ _Slices...[_Is + 1]...>();
+ };
+ return __recurse(make_index_sequence<sizeof...(_Slices) -
1>());
+ }
+ else
+ return false;
+ }
+
+ // __u __u + _BlockSize - 1
+ // [*, full, ..., full, unit_slice, *]
+ template<typename _IndexType, size_t _Start, size_t _BlockSize,
+ typename... _Slices>
+ consteval size_t
+ __find_block()
Hmm, I think that this function could be implemented much easier by having:
bool full_map[sizeof...(Slices)]{ is_same_v<full_exent_t, Slices>....
};
Or even better having an array of classification of slices at the
begining of the functo
constexpr SliceKind kinds[sizeof...(Slices)]{ function to classify,
full_extent -> full, strided -> stride, unit };
And then pass it to classification functions. That will go over what could
be returned.
+ {
+ static_assert(_BlockSize != dynamic_extent,
+ "The implementation can't handle submdspans with rank ==
size_t(-1)");
+
+ if constexpr (sizeof...(_Slices) == 0)
+ return dynamic_extent;
+ else if constexpr (__is_block<_IndexType, _BlockSize,
_Slices...>())
+ return _Start;
+ else
+ {
+ auto __recurse = []<size_t... _Is>(index_sequence<_Is...>)
+ {
+ return __find_block<_IndexType, _Start + 1, _BlockSize,
+ _Slices...[_Is + 1]...>();
+ };
+ return __recurse(make_index_sequence<sizeof...(_Slices) -
1>());
+ }
+ }
+
+ template<typename _IndexType, size_t _SubRank, typename... _Slices>
+ static consteval bool
+ __is_compact_block()
+ {
+ if constexpr (_SubRank == 0)
+ return false;
+ else
+ return __find_block<_IndexType, 0, _SubRank, _Slices...>() == 0;
+ }
+
+ // __u
+ // [unit_slice, i, ..., k, full, ..., full, unit_slice, *]
+ template<typename _IndexType, size_t _SubRank, typename _Slice,
+ typename... _Slices>
+ static consteval size_t
+ __padded_block_begin_generic()
+ {
+ if constexpr (!__mdspan::__is_unit_stride_slice<_Slice,
_IndexType>)
+ return dynamic_extent;
+ else if constexpr (sizeof...(_Slices) == 0)
+ return dynamic_extent;
+ else
+ {
+ constexpr auto __u = __find_block<_IndexType, 0, _SubRank - 1,
+ _Slices...>();
+ if constexpr (__u != dynamic_extent)
+ return __u + 1;
+ else
+ return dynamic_extent;
+ }
+ }
+
+ template<_LayoutSide _Side, typename _IndexType, size_t _SubRank,
+ typename... _Slices>
+ static consteval size_t
+ __padded_block_begin()
+ {
+ if constexpr (_Side == _LayoutSide::__left)
+ return __padded_block_begin_generic<_IndexType, _SubRank,
+ _Slices...>();
+ }
+
+ template<_LayoutSide _Side>
+ struct _SubMdspanMapping;
+
+ template<>
+ struct _SubMdspanMapping<_LayoutSide::__left>
+ {
+ using _Layout = layout_left;
+ template<size_t _Pad> using _PaddedLayout =
layout_left_padded<_Pad>;
+
+ template<typename _Mapping, size_t _Us>
+ static consteval size_t
+ _S_pad()
+ {
+ using _Extents = typename _Mapping::extents_type;
+ constexpr auto __sta_exts = __static_extents<_Extents>(0, _Us);
+ if constexpr (!__all_static(__sta_exts))
+ return dynamic_extent;
+ else
+ return __fwd_prod(__sta_exts);
+ }
+
+ template<typename _IndexType, size_t _SubRank, typename... _Slices>
+ static consteval bool
+ _S_is_unpadded_submdspan()
+ { return __is_compact_block<_IndexType, _SubRank, _Slices...>();
}
+ };
+
+ template<typename _Mapping>
+ constexpr auto
+ __submdspan_mapping_impl(const _Mapping& __mapping)
+ { return submdspan_mapping_result{__mapping, 0}; }
+
+ template<typename _Mapping, typename... _Slices>
+ requires (sizeof...(_Slices) > 0)
+ constexpr auto
+ __submdspan_mapping_impl(const _Mapping& __mapping, _Slices...
__slices)
+ {
+ using _IndexType= typename _Mapping::index_type;
+ constexpr auto __side = __deduce_mapping_side<_Mapping>();
+ using _Trait = _SubMdspanMapping<__side>;
+
+ auto __offset = __suboffset(__mapping, __slices...);
The calls need to be qualified (and one above) and everywhere in general.
+ auto __sub_exts = submdspan_extents(__mapping.
We should call __mdspan::__subextents as we already canonicalized
slices.
+ using _SubExtents = decltype(__sub_exts);
+ constexpr auto __sub_rank = _SubExtents::rank();
+ if constexpr (_SubExtents::rank() == 0)
+ return submdspan_mapping_result{
+ typename _Trait::_Layout::mapping(__sub_exts), __offset};
+ else if constexpr (
+ _Trait::template _S_is_unpadded_submdspan<_IndexType,
__sub_rank,
+ _Slices...>())
+ return submdspan_mapping_result{
+ typename _Trait::_Layout::mapping(__sub_exts), __offset};
+ else if constexpr (
+ constexpr auto __u = __padded_block_begin<__side, _IndexType,
+ __sub_rank,
_Slices...>();
+ __u != dynamic_extent)
+ {
+ constexpr auto __pad = _Trait::template _S_pad<_Mapping,
__u>();
+ using _Layout = typename _Trait::template _PaddedLayout<__pad>;
+ return submdspan_mapping_result{
+ typename _Layout::mapping(__sub_exts, __mapping.stride(__u)),
+ __offset};
+ }
+ else
+ {
+ auto __sub_strides
+ = __substrides<_SubExtents>(__mapping, __slices...);
+ return submdspan_mapping_result{
+ layout_stride::mapping(__sub_exts, __sub_strides),
__offset};
+ }
+ }
#endif // __glibcxx_submdspan
}
template<typename _Extents>
class layout_left::mapping
{
public:
using extents_type = _Extents;
using index_type = typename extents_type::index_type;
using size_type = typename extents_type::size_type;
@@ -1168,20 +1532,28 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _OExtents>
constexpr explicit
mapping(const _OExtents& __oexts, __mdspan::__internal_ctor)
noexcept
: _M_extents(__oexts)
{
static_assert(__mdspan::__representable_size<_OExtents,
index_type>,
"The size of OtherExtents must be representable as
index_type");
__glibcxx_assert(__mdspan::__is_representable_extents(_M_extents));
}
+#if __glibcxx_submdspan
+ template<__mdspan::__valid_canonical_slice_type<index_type>...
_Slices>
+ requires (extents_type::rank() == sizeof...(_Slices))
+ friend constexpr auto
+ submdspan_mapping(const mapping& __mapping, _Slices... __slices)
+ { return __mdspan::__submdspan_mapping_impl(__mapping,
__slices...); }
+#endif // __glibcxx_submdspan
+
[[no_unique_address]] extents_type _M_extents{};
};
namespace __mdspan
{
template<typename _Extents, typename... _Indices>
constexpr typename _Extents::index_type
__linear_index_right(const _Extents& __exts, _Indices... __indices)
noexcept
{
@@ -2824,16 +3196,31 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
requires (sizeof...(_Extents) == sizeof...(_Slices))
constexpr auto
submdspan_canonicalize_slices(const extents<_IndexType, _Extents...>&
__exts,
_Slices... __raw_slices)
{
auto [...__slices]
= make_tuple(__mdspan::__slice_cast<_IndexType>(__raw_slices)...);
__mdspan::__assert_valid_slices(__exts, __slices...);
return make_tuple(__slices...);
}
+
+ template<typename _ElementType, typename _Extents, typename _Layout,
+ typename _Accessor, typename... _Slices>
+ requires (sizeof...(_Slices) == _Extents::rank())
+ constexpr auto
+ submdspan(
+ const mdspan<_ElementType, _Extents, _Layout, _Accessor>& __md,
+ _Slices... __raw_slices)
+ {
+ auto [...__slices] = submdspan_canonicalize_slices(__md.extents(),
+ __raw_slices...);
Again, we do not want to instantiate tuples, so _would do __impl lambda
trick here,
were we pass canonicalized slices as arguments.
+ auto __result = submdspan_mapping(__md.mapping(), __slices...);
+ return mdspan(__md.accessor().offset(__md.data_handle(),
__result.offset),
+ __result.mapping, typename
_Accessor::offset_policy(__md.accessor()));
+ }
#endif // __glibcxx_submdspan
_GLIBCXX_END_NAMESPACE_VERSION
}
#endif
#endif
diff --git a/libstdc++-v3/src/c++23/std.cc.in b/libstdc++-v3/src/c++23/
std.cc.in
index c2a9293b05a..2dac6a6d887 100644
--- a/libstdc++-v3/src/c++23/std.cc.in
+++ b/libstdc++-v3/src/c++23/std.cc.in
@@ -1878,22 +1878,22 @@ export namespace std
using std::layout_left_padded;
using std::layout_right_padded;
#endif
#if __glibcxx_submdspan
using std::strided_slice;
using std::full_extent_t;
using std::full_extent;
using std::submdspan_mapping_result;
using std::submdspan_canonicalize_slices;
using std::submdspan_extents;
+ using std::submdspan;
#endif
- // FIXME mdsubspan
}
#endif
// 20.2 <memory>
export namespace std
{
using std::align;
using std::allocator;
using std::allocator_arg;
using std::allocator_arg_t;
diff --git
a/libstdc++-v3/testsuite/23_containers/mdspan/submdspan/submdspan.cc
b/libstdc++-v3/testsuite/23_containers/mdspan/submdspan/submdspan.cc
new file mode 100644
index 00000000000..53e91407a9c
--- /dev/null
+++ b/libstdc++-v3/testsuite/23_containers/mdspan/submdspan/submdspan.cc
@@ -0,0 +1,369 @@
+// { dg-do run { target c++26 } }
+#include <mdspan>
+
+#include <iostream> // TODO remove
+#include <vector>
+#include <numeric>
+#include "../layout_traits.h"
+#include <testsuite_hooks.h>
+
+constexpr size_t dyn = std::dynamic_extent;
+constexpr auto all = std::full_extent;
+
+template<typename T>
+ constexpr bool is_strided_slice = false;
+
+template<typename O, typename E, typename S>
+ constexpr bool is_strided_slice<std::strided_slice<O, E, S>> = true;
+
+template<typename MDSpan>
+ constexpr void
+ fill(const MDSpan& md)
+ {
+ using IndexType = typename MDSpan::index_type;
+ auto exts = md.extents();
+ if constexpr (exts.rank() == 3)
+ for(IndexType i = 0; i < exts.extent(0); ++i)
+ for(IndexType j = 0; j < exts.extent(1); ++j)
+ for(IndexType k = 0; k < exts.extent(2); ++k)
+ md[i, j, k] = 100 * i + 10 * j + k;
+ }
+
+template<typename Int, size_t Rank>
+ class multi_index_generator
+ {
+ class EndIt
+ { };
+
+ class BeginIt
+ {
+ public:
+ constexpr
+ BeginIt(const std::array<Int, Rank>& shape)
+ : M_shape(shape)
+ { }
+
+ constexpr BeginIt&
+ operator++()
+ {
+ if constexpr (Rank > 0)
+ {
+ ++M_indices[Rank-1];
+ for(size_t i = Rank; i > 1; --i)
+ if (M_indices[i-1] == M_shape[i-1])
+ {
+ M_indices[i-1] = 0;
+ ++M_indices[i-2];
+ }
+ }
+ return *this;
+ }
+
+ constexpr auto
+ operator*()
+ { return M_indices; }
+
+ constexpr bool
+ operator==(EndIt)
+ {
+ if constexpr (Rank > 0)
+ return M_indices[0] == M_shape[0];
+ else
+ return true;
+ }
+
+ private:
+ std::array<Int, Rank> M_indices{};
+ std::array<Int, Rank> M_shape;
+ };
+
+ public:
+ constexpr
+ multi_index_generator(std::array<Int, Rank> shape)
+ : M_shape(shape)
+ { }
+
+ constexpr BeginIt
+ begin() const
+ { return BeginIt(M_shape); }
+
+ constexpr EndIt
+ end() const
+ { return EndIt{}; }
+
+ private:
+ std::array<Int, Rank> M_shape;
+ };
+
+constexpr bool
+test_multi_index()
+{
+ auto shape = std::array{3, 5, 7, 1};
+
+ std::vector<std::array<int, 4>> expected;
+ for (int i = 0; i < shape[0]; ++i)
+ for (int j = 0; j < shape[1]; ++j)
+ for (int k = 0; k <shape[2]; ++k)
+ for (int l = 0; l <shape[3]; ++l)
+ expected.push_back(std::array{i, j, k, l});
+
+ size_t i = 0;
+ for (auto actual : multi_index_generator(shape))
+ VERIFY(expected[i++] == actual);
+ return true;
+}
+
+static_assert(test_multi_index());
+
+struct
+collapse
+{ };
+
+template<typename... Slices>
+ consteval auto
+ inv_collapsed_index_map()
+ {
+ constexpr size_t rank = sizeof...(Slices);
+ auto is_collapsing = std::array{std::same_as<Slices, collapse>...};
+ constexpr auto collapsed_rank = ((!std::same_as<Slices, collapse>) +
... + 0);
+
+ std::array<size_t, collapsed_rank> ret;
+ if constexpr (collapsed_rank > 0)
+ for(size_t k = 0, i = 0; i < rank; ++i)
+ if (!is_collapsing[i])
+ ret[k++] = i;
+ return ret;
+ }
+
+static_assert(inv_collapsed_index_map<collapse, collapse, collapse>()
+ == std::array<size_t, 0>{});
+
+static_assert(inv_collapsed_index_map<collapse, decltype(all), collapse>()
+ == std::array<size_t, 1>{1});
+
+template<typename IndexType, typename Slice>
+ constexpr std::vector<IndexType>
+ make_selection(IndexType extent, const Slice& slice)
+ {
+ if constexpr (std::convertible_to<Slice, IndexType>)
+ return {static_cast<IndexType>(slice)};
+ else if constexpr (std::same_as<Slice, std::full_extent_t>)
+ {
+ auto ret = std::vector<IndexType>(static_cast<size_t>(extent));
+ std::ranges::iota(ret, 0);
+ return ret;
+ }
+ else if constexpr (is_strided_slice<Slice>)
+ {
+ auto ret = std::vector<IndexType>{};
+ size_t n = static_cast<size_t>(slice.extent);
+ for(size_t i = 0; i < n; i += slice.stride)
+ ret.push_back(slice.offset + i);
+ return ret;
+ }
+ else
+ {
+ auto [begin, end] = slice;
+ auto ret = std::vector<IndexType>(static_cast<size_t>(end -
begin));
+ std::ranges::iota(ret, begin);
+ return ret;
+ }
+ }
+
+template<typename Layout, size_t... I, typename... Slices>
+ constexpr bool
+ check_selection(std::index_sequence<I...>, auto md, Slices... slices)
+ {
+ auto exts = md.extents();
+ auto outer_shape = std::array{exts.extent(0), exts.extent(1),
exts.extent(2)};
+
+ constexpr auto full_index = inv_collapsed_index_map<Slices...>();
+ auto make_slice = [](size_t i, auto slice)
+ {
+ if constexpr (std::same_as<decltype(slice), collapse>)
+ return i;
+ else
+ return slice;
+ };
+
+ auto loop_body = [&]<size_t... J>(std::index_sequence<J...>, auto ijk,
+ auto... slices)
+ {
+ auto submd = submdspan(md, slices...[I]...);
+ auto selection = std::tuple{make_selection(exts.extent(I),
slices...[I])...};
+ auto inner_shape = std::array<size_t, full_index.size()>{
+ std::get<full_index[J]>(selection).size()...
+ };
+
+ for (auto ij : multi_index_generator(inner_shape))
+ {
+ ((ijk[full_index[J]] = get<full_index[J]>(selection)[ij[J]]),...);
+ VERIFY(submd[ij] == md[ijk]);
+ }
+ };
+
+ for (auto ijk : multi_index_generator(outer_shape))
+ loop_body(std::make_index_sequence<full_index.size()>(), ijk,
+ make_slice(ijk[I], slices...[I])...);
+ return true;
+ }
+
+template<typename Layout, typename...MD, typename... Slices>
+ constexpr bool
+ check_selection(std::mdspan<MD...> md, Slices... slices)
+ {
+ auto indices = std::make_index_sequence<sizeof...(slices)>();
+ return check_selection<Layout>(indices, md, slices...);
+ }
+
+template<typename Layout, typename IndexType, size_t... Extents,
+ typename... Slices>
+ constexpr bool
+ check_selection(std::extents<IndexType, Extents...>exts, Slices...
slices)
+ {
+ auto run = [&](auto m)
+ {
+ auto storage = std::vector<double>(m.required_span_size());
+ auto md = std::mdspan(storage.data(), m);
+ fill(md);
+ return check_selection<Layout>(md, slices...);
+ };
+
+ if constexpr (std::same_as<Layout, std::layout_stride>)
+ {
+ auto m = typename Layout::mapping(exts, std::array{15, 2, 50});
+ return run(m);
+ }
+ else
+ {
+ auto m = typename Layout::mapping(exts);
+ return run(m);
+ }
+ }
+
+template<typename Layout>
+ constexpr bool
+ test_scalar_selection(auto exts)
+ {
+ check_selection<Layout>(exts, collapse{}, collapse{}, collapse{});
+ return true;
+ }
+
+template<typename Layout>
+ constexpr bool
+ test_full_lines(auto exts)
+ {
+ check_selection<Layout>(exts, all, collapse{}, collapse{});
+ check_selection<Layout>(exts, collapse{}, all, collapse{});
+ check_selection<Layout>(exts, collapse{}, collapse{}, all);
+ return true;
+ }
+
+template<typename Layout>
+ constexpr bool
+ test_full_blocks(auto exts)
+ {
+ check_selection<Layout>(exts, all, all, collapse{});
+ check_selection<Layout>(exts, all, collapse{}, all);
+ check_selection<Layout>(exts, collapse{}, all, all);
+ return true;
+ }
+
+template<typename Layout>
+ constexpr bool
+ test_cubes(auto exts)
+ {
+ auto s0 = std::pair{0, 2};
+ auto s1 = std::pair{1, 4};
+ auto s2 = std::pair{3, 7};
+
+ check_selection<Layout>(exts, all, all, all);
+ check_selection<Layout>(exts, all, all, s2);
+ check_selection<Layout>(exts, s0, all, all);
+ check_selection<Layout>(exts, s0, all, s2);
+ check_selection<Layout>(exts, s0, s1, s2);
+ return true;
+ }
+
+template<typename Layout>
+ constexpr bool
+ test_strided_line_selection(auto exts)
+ {
+ auto check = [&](auto s)
+ {
+ check_selection<Layout>(exts, collapse{}, s, collapse{});
+ };
+
+ check(std::strided_slice(0, 2, 2));
+ check(std::strided_slice(0, 3, 2));
+ check(std::strided_slice(1, 3, 2));
+ check(std::strided_slice(1, std::cw<3>, std::cw<2>));
+ return true;
+ }
+
+template<typename Layout>
+ constexpr bool
+ test_strided_box_selection(auto exts)
+ {
+ auto s0 = std::strided_slice(0, 3, 2);
+ auto s1 = std::strided_slice(1, 4, 2);
+ auto s2 = std::strided_slice(0, 7, 3);
+
+ check_selection<Layout>(exts, s0, s1, s2);
+ return true;
+ }
+
+template<typename Layout>
+ constexpr bool
+ test_all_cheap()
+ {
+ constexpr auto dyn_exts = std::extents(3, 5, 7);
+ constexpr auto sta_exts = std::extents<int, 3, 5, 7>{};
+
+ test_scalar_selection<Layout>(dyn_exts);
+ test_scalar_selection<Layout>(sta_exts);
+ static_assert(test_scalar_selection<Layout>(dyn_exts));
+ static_assert(test_scalar_selection<Layout>(sta_exts));
+
+ test_full_lines<Layout>(dyn_exts);
+ test_full_lines<Layout>(sta_exts);
+ static_assert(test_full_lines<Layout>(dyn_exts));
+ static_assert(test_full_lines<Layout>(sta_exts));
+
+ test_strided_box_selection<Layout>(dyn_exts);
+ test_strided_box_selection<Layout>(sta_exts);
+ static_assert(test_strided_box_selection<Layout>(dyn_exts));
+ static_assert(test_strided_box_selection<Layout>(sta_exts));
+ return true;
+ }
+
+template<typename Layout>
+ constexpr bool
+ test_all_expensive()
+ {
+ auto run = [](auto exts)
+ {
+ test_full_blocks<Layout>(exts);
+ test_cubes<Layout>(exts);
+ };
+
+ run(std::extents(3, 5, 7));
+ run(std::extents<int, 3, 5, 7>{});
+ return true;
+ }
+
+template<typename Layout>
+ constexpr bool
+ test_all()
+ {
+ test_all_cheap<Layout>();
+ test_all_expensive<Layout>();
+ return true;
+ }
+
+int
+main()
+{
+ test_all<std::layout_left>();
+ return 0;
+}
diff --git
a/libstdc++-v3/testsuite/23_containers/mdspan/submdspan/submdspan_mapping.cc
b/libstdc++-v3/testsuite/23_containers/mdspan/submdspan/submdspan_mapping.cc
new file mode 100644
index 00000000000..a37d3cd588f
--- /dev/null
+++
b/libstdc++-v3/testsuite/23_containers/mdspan/submdspan/submdspan_mapping.cc
@@ -0,0 +1,136 @@
+// { dg-do run { target c++26 } }
+#include <mdspan>
+
+#include <iostream> // TODO remove
+#include "../layout_traits.h"
+#include <testsuite_hooks.h>
+
+constexpr size_t dyn = std::dynamic_extent;
+
+template<typename Mapping, typename... Slices>
+ constexpr auto
+ call_submdspan_mapping(const Mapping& m, std::tuple<Slices...> slices)
+ {
+ auto impl = [&]<size_t... I>(std::index_sequence<I...>)
+ { return submdspan_mapping(m, get<I>(slices)...); };
+ return impl(std::make_index_sequence<sizeof...(Slices)>());
+ }
+
+template<typename Layout>
+ constexpr bool
+ test_layout_unpadded_return_types()
+ {
+ constexpr auto padding_side =
DeducePaddingSide::from_typename<Layout>();
+ using Traits = LayoutTraits<padding_side>;
+
+ {
+ auto m0 = typename Layout::mapping(std::extents());
+ auto result = submdspan_mapping(m0);
+ using layout_type = typename decltype(result.mapping)::layout_type;
+ static_assert(std::same_as<layout_type, Layout>);
+ }
+
+ auto exts = Traits::make_extents(std::dims<5, int>(3, 5, 7, 11, 13));
+ auto m = typename Layout::mapping(exts);
+ auto all = std::full_extent;
+ auto s251 = std::strided_slice{2, 5, std::cw<1>};
+
+ {
+ auto slices = std::tuple{0, 0, 0, 0, 0};
+ auto result = call_submdspan_mapping(m, Traits::make_tuple(slices));
+ using layout_type = typename decltype(result.mapping)::layout_type;
+ static_assert(std::same_as<layout_type, Layout>);
+ }
+
+ {
+ auto slices = std::tuple{all, all, all, s251, 0};
+ auto result = call_submdspan_mapping(m, Traits::make_tuple(slices));
+ using layout_type = typename decltype(result.mapping)::layout_type;
+ static_assert(std::same_as<layout_type, Layout>);
+ }
+
+ {
+ auto s0 = std::strided_slice{1, 1, std::cw<1>};
+ auto slices = std::tuple{s0, all, all, s251, 0};
+ auto result = call_submdspan_mapping(m, Traits::make_tuple(slices));
+ using layout_type = typename decltype(result.mapping)::layout_type;
+ static_assert(is_same_padded<padding_side, layout_type>);
+ }
+
+ {
+ auto s0 = std::strided_slice{1, 2, std::cw<1>};
+ auto slices = std::tuple{s0, all, all, s251, 0};
+ auto result = call_submdspan_mapping(m, Traits::make_tuple(slices));
+ using layout_type = typename decltype(result.mapping)::layout_type;
+ static_assert(is_same_padded<padding_side, layout_type>);
+ }
+
+ {
+ auto s0 = std::strided_slice{1, 2, std::cw<1>};
+ auto slices = std::tuple{s0, 0, all, s251, 0};
+ auto result = call_submdspan_mapping(m, Traits::make_tuple(slices));
+ using layout_type = typename decltype(result.mapping)::layout_type;
+ static_assert(is_same_padded<padding_side, layout_type>);
+ }
+
+ {
+ auto s0 = std::strided_slice{1, 2, 1};
+ auto slices = std::tuple{s0, all, all, s251, 0};
+ auto result = call_submdspan_mapping(m, Traits::make_tuple(slices));
+ using layout_type = decltype(result.mapping)::layout_type;
+ static_assert(std::same_as<layout_type, std::layout_stride>);
+ }
+
+ {
+ auto slices = std::tuple{1, all, all, s251, 0};
+ auto result = call_submdspan_mapping(m, Traits::make_tuple(slices));
+ using layout_type = decltype(result.mapping)::layout_type;
+ static_assert(std::same_as<layout_type, std::layout_stride>);
+ }
+
+ {
+ auto s3 = std::strided_slice{2, std::cw<7>, std::cw<2>};
+ auto slices = std::tuple{all, all, all, s3, 0};
+ auto result = call_submdspan_mapping(m, Traits::make_tuple(slices));
+ using layout_type = decltype(result.mapping)::layout_type;
+ static_assert(std::same_as<layout_type, std::layout_stride>);
+ }
+ return true;
+ }
+
+template<typename Layout>
+ constexpr bool
+ test_layout_unpadded_padding_value()
+ {
+ using Traits =
LayoutTraits<DeducePaddingSide::from_typename<Layout>()>;
+ auto s0 = std::strided_slice{size_t(1), size_t(2),
std::cw<size_t(1)>};
+ auto s3 = std::strided_slice{size_t(2), size_t(5),
std::cw<size_t(1)>};
+ auto all = std::full_extent;
+
+ auto check = [&](auto exts, size_t expected)
+ {
+ auto m = typename Layout::mapping(Traits::make_extents(exts));
+ auto slices = std::tuple{s0, size_t(0), all, s3, size_t(0)};
+ auto result = call_submdspan_mapping(m, Traits::make_tuple(slices));
+ auto padding_value = decltype(result.mapping)::padding_value;
+ VERIFY(padding_value == expected);
+ };
+
+ check(std::extents(std::cw<3>, std::cw<5>, std::cw<7>, 11, 13), 3*5);
+ check(std::extents(std::cw<3>, std::cw<5>, 7, 11, 13), 3*5);
+ check(std::extents(std::cw<3>, 5, 7, 11, 13), dyn);
+ check(std::extents(3, 5, 7, 11, 13), dyn);
+ return true;
+ }
+
+int
+main()
+{
+ test_layout_unpadded_return_types<std::layout_left>();
+ static_assert(test_layout_unpadded_return_types<std::layout_left>());
+
+ test_layout_unpadded_padding_value<std::layout_left>();
+ static_assert(test_layout_unpadded_padding_value<std::layout_left>());
+ return 0;
+}
+
diff --git
a/libstdc++-v3/testsuite/23_containers/mdspan/submdspan/submdspan_neg.cc
b/libstdc++-v3/testsuite/23_containers/mdspan/submdspan/submdspan_neg.cc
new file mode 100644
index 00000000000..4f9aad81cb7
--- /dev/null
+++
b/libstdc++-v3/testsuite/23_containers/mdspan/submdspan/submdspan_neg.cc
@@ -0,0 +1,102 @@
+// { dg-do compile { target c++26 } }
+#include <mdspan>
+
+#include <vector>
+
+template<typename Layout, typename... Slices>
+ constexpr bool
+ check_slice_range(Slices... slices)
+ {
+ auto m = typename Layout::mapping<std::extents<int, 3, 5, 7>>{};
+ auto storage = std::vector<double>(m.required_span_size());
+ auto md = std::mdspan(storage.data(), m);
+
+ auto submd = submdspan(md, slices...); // { dg-error
"expansion of" }
+ (void) submd;
+ return true;
+ }
+
+template<typename Layout>
+ constexpr bool
+ test_int_under()
+ {
+ check_slice_range<Layout>(1, -1, 2); // { dg-error
"expansion of" }
+ return true;
+ }
+static_assert(test_int_under<std::layout_left>()); // { dg-error
"expansion of" }
+
+template<typename Layout>
+ constexpr bool
+ test_int_over()
+ {
+ check_slice_range<Layout>(1, 5, 2); // { dg-error
"expansion of" }
+ return true;
+ }
+static_assert(test_int_over<std::layout_left>()); // { dg-error
"expansion of" }
+
+template<typename Layout>
+ constexpr bool
+ test_tuple_under()
+ {
+ check_slice_range<Layout>(1, std::tuple{-1, 2}, 2); // { dg-error
"expansion of" }
+ return true;
+ }
+static_assert(test_tuple_under<std::layout_left>()); // { dg-error
"expansion of" }
+
+template<typename Layout>
+ constexpr bool
+ test_tuple_reversed()
+ {
+ check_slice_range<Layout>(1, std::tuple{3, 2}, 2); // { dg-error
"expansion of" }
+ return true;
+ }
+static_assert(test_tuple_reversed<std::layout_left>()); // { dg-error
"expansion of" }
+
+template<typename Layout>
+ constexpr bool
+ test_tuple_over()
+ {
+ check_slice_range<Layout>(1, std::tuple{0, 6}, 2); // { dg-error
"expansion of" }
+ return true;
+ }
+static_assert(test_tuple_over<std::layout_left>()); // { dg-error
"expansion of" }
+
+template<typename Layout>
+ constexpr bool
+ test_strided_slice_zero()
+ {
+ check_slice_range<Layout>(1, std::strided_slice{1, 1, 0}, 2); // {
dg-error "expansion of" }
+ return true;
+ }
+static_assert(test_strided_slice_zero<std::layout_left>()); // {
dg-error "expansion of" }
+
+template<typename Layout>
+ constexpr bool
+ test_strided_slice_offset_under()
+ {
+ check_slice_range<Layout>(1, std::strided_slice{-1, 1, 1}, 2); // {
dg-error "expansion of" }
+ return true;
+ }
+static_assert(test_strided_slice_offset_under<std::layout_left>()); //
{ dg-error "expansion of" }
+
+template<typename Layout>
+ constexpr bool
+ test_strided_slice_offset_over()
+ {
+ check_slice_range<Layout>(1, std::strided_slice{6, 0, 1}, 2); // {
dg-error "expansion of" }
+ return true;
+ }
+static_assert(test_strided_slice_offset_over<std::layout_left>()); // {
dg-error "expansion of" }
+
+template<typename Layout>
+ constexpr bool
+ test_strided_slice_extent_over()
+ {
+ check_slice_range<Layout>(1, std::strided_slice{1, 5, 1}, 2); // {
dg-error "expansion of" }
+ return true;
+ }
+static_assert(test_strided_slice_extent_over<std::layout_left>()); // {
dg-error "expansion of" }
+
+// { dg-prune-output "static assertion failed" }
+// { dg-prune-output "__glibcxx_assert_fail" }
+// { dg-prune-output "non-constant condition" }
--
2.51.2
