[PATCH v3 4/4] libstdc++: Implement layout_right_padded.
Luc Grosheintz
luc.grosheintz@gmail.com
Fri Sep 26 12:22:22 GMT 2025
On 9/26/25 9:45 AM, Tomasz Kaminski wrote:
> On Tue, Sep 23, 2025 at 3:41 PM Luc Grosheintz <luc.grosheintz@gmail.com>
> wrote:
>
>> This commit adds the right padded layout as described in N5014, with
>> LWG4372 (dynamic padding value) and LWG4314 (move in operator()).
>>
>> libstdc++-v3/ChangeLog:
>>
>> * include/std/mdspan (_RightPaddedIndices): New class.
>> (layout_right_padded): New class.
>> * src/c++23/std.cc.in (layout_right_padded): Add.
>> * testsuite/23_containers/mdspan/layouts/ctors.cc: Update
>> test for right padded layout.
>> * testsuite/23_containers/mdspan/layouts/empty.cc: Ditto.
>> * testsuite/23_containers/mdspan/layouts/mapping.cc: Ditto.
>> * testsuite/23_containers/mdspan/layouts/padded.cc: Ditto.
>> * testsuite/23_containers/mdspan/layouts/padded_neg.cc: Ditto.
>> * testsuite/23_containers/mdspan/layouts/padded_traits.h: Ditto.
>>
>> Signed-off-by: Luc Grosheintz <luc.grosheintz@gmail.com>
>> ---
>>
> Suggestions here:
> * Add _PaddingStride::_M_equal for opearator== and use _M_stride to
> implement it
> * Fix spaces, and cast index_type as in layout_left
> * Suggestion for LWG issue for both
> * Explanation that we can use existing member names for internal classes,
> and suggestion
> to use it for _PaddingStorage.
>
> With that ready for v4
>
>
>> libstdc++-v3/include/std/mdspan | 263 ++++++++++++++++++
>> libstdc++-v3/src/c++23/std.cc.in | 5 +-
>> .../23_containers/mdspan/layouts/ctors.cc | 3 +-
>> .../23_containers/mdspan/layouts/empty.cc | 1 +
>> .../23_containers/mdspan/layouts/mapping.cc | 6 +-
>> .../23_containers/mdspan/layouts/padded.cc | 4 +
>> .../mdspan/layouts/padded_neg.cc | 28 ++
>> .../mdspan/layouts/padded_traits.h | 135 ++++++++-
>> 8 files changed, 437 insertions(+), 8 deletions(-)
>>
>> diff --git a/libstdc++-v3/include/std/mdspan
>> b/libstdc++-v3/include/std/mdspan
>> index 18782bf0a06..f61931ab8e6 100644
>> --- a/libstdc++-v3/include/std/mdspan
>> +++ b/libstdc++-v3/include/std/mdspan
>> @@ -954,6 +954,32 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
>> : mapping(__other.extents(), __mdspan::__internal_ctor{})
>> { __glibcxx_assert(*this == __other); }
>>
>> +#if __glibcxx_padded_layouts
>> + template<class _RightPaddedMapping>
>> + requires __mdspan::__is_right_padded_mapping<_RightPaddedMapping>
>> + && is_constructible_v<extents_type,
>> + typename
>> _RightPaddedMapping::extents_type>
>>
> Tabs instead of spaces, here and the rest of the file.
>
>> + constexpr
>> + explicit(!is_convertible_v<typename
>> _RightPaddedMapping::extents_type,
>> + extents_type>)
>>
> We should report bug against standard, because this constructor should be
> explicit,
> for Ranks > 1 and extent(0) or _S_padded_stride are dynamic, as we have
> precondition
> then. I think it should also be constrained, on what is now mandated, about
> satic_stride
> matching.
I see your point. (Let's discuss separately.)
> We should match stride_mismatch, the same way as static extent mismatch is
> handled here.
I'm sorry, I don't understand the immediately preceeding sentence.
One guess is I should apply the trick:
if constexpr (__rank > 1>
if constexpr ( /* static conds */)
static_assert(...);
else
__glibcxx_assert(...);
(but that's already the case, likely due to a different review
comment).
>
> Same for layot_left.
>
>
>> + mapping(const _RightPaddedMapping& __other) noexcept
>> + : mapping(__other.extents(), __mdspan::__internal_ctor{})
>> + {
>> + constexpr size_t __rank = extents_type::rank();
>> + constexpr size_t __ostride_sta = __mdspan::__get_static_stride<
>> + _RightPaddedMapping>();
>> +
>> + if constexpr (__rank > 1
>> + && extents_type::static_extent(__rank - 1) != dynamic_extent
>> + && __ostride_sta != dynamic_extent)
>> + static_assert(extents_type::static_extent(__rank - 1) ==
>> __ostride_sta);
>> +
>> + if constexpr (__rank > 1)
>> + __glibcxx_assert(__other.stride(__rank - 2)
>> + == __other.extents().extent(__rank - 1));
>> + }
>> +#endif
>> +
>> constexpr mapping&
>> operator=(const mapping&) noexcept = default;
>>
>> @@ -1350,6 +1376,37 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
>> return __res;
>> }
>>
>> + template<typename _Extents, typename _Stride, typename... _Indices>
>> + constexpr typename _Extents::index_type
>> + __linear_index_rightpad(const _Extents& __exts, _Stride __stride,
>> + _Indices... __indices)
>> + {
>> + // i[n-1] + stride*(i[n-2] + extents.extent(n-2])*...)
>> + using _IndexType = typename _Extents::index_type;
>> + _IndexType __res = 0;
>> + if constexpr (sizeof...(__indices) > 0)
>> + {
>> + _IndexType __mult = 1;
>> + array<_IndexType, sizeof...(__indices)>
>> __ind_arr{__indices...};
>> +
>> + auto __update_rest = [&, __pos = __exts.rank()-1](_IndexType)
>> mutable
>> + {
>> + --__pos;
>> + __res += __ind_arr[__pos] * __mult;
>> + __mult *= __exts.extent(__pos);
>> + };
>> +
>> + auto __update = [&](_IndexType, auto... __rest)
>> + {
>> + __res += __ind_arr[__exts.rank() - 1];
>> + __mult = __stride.extent(0);
>> + (__update_rest(__rest), ...);
>> + };
>> + __update(__indices...);
>> + }
>> + return __res;
>> + }
>> +
>> template<size_t _Rank>
>> struct _LeftPaddedLayoutTraits
>> {
>> @@ -1384,6 +1441,39 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
>> }
>> };
>>
>> + template<size_t _Rank>
>> + struct _RightPaddedLayoutTraits
>> + {
>> + using _LayoutSame = layout_right;
>> + using _LayoutOther = layout_left;
>> +
>> + constexpr static size_t _S_ext_idx = _Rank - 1;
>> + constexpr static size_t _S_stride_idx = _Rank - 2;
>> + constexpr static size_t _S_unpad_begin = 0;
>> + constexpr static size_t _S_unpad_end = _Rank - 1;
>> +
>> + template<typename _Mapping>
>> + constexpr static bool _S_is_same_padded_mapping =
>> + __is_right_padded_mapping<_Mapping>;
>> +
>> + template<typename _Mapping>
>> + constexpr static bool _S_is_other_padded_mapping =
>> + __is_left_padded_mapping<_Mapping>;
>> +
>> + template<typename _IndexType, size_t _StaticStride,
>> size_t..._Extents>
>> + constexpr static auto _S_make_padded_extent(
>> + extents<_IndexType, _StaticStride> __stride,
>> + const extents<_IndexType, _Extents...>& __exts)
>> + {
>> + auto __impl = [&]<size_t... _Is>(integer_sequence<size_t,
>> _Is...>)
>> + {
>> + return extents<_IndexType, (_Extents...[_Is])...,
>> _StaticStride>{
>> + __exts.extent(_Is)..., __stride.extent(0)};
>> + };
>> + return __impl(make_index_sequence<sizeof...(_Extents) - 1>());
>> + }
>> + };
>> +
>> template<size_t _PaddingValue, typename _Extents, typename
>> _LayoutTraits>
>> class _PaddedStorage
>> {
>> @@ -1834,6 +1924,179 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
>> __other.stride(1)));
>> }
>> };
>> +
>> + template<size_t _PaddingValue>
>> + template<typename _Extents>
>> + class layout_right_padded<_PaddingValue>::mapping {
>> + public:
>> + static constexpr size_t padding_value = _PaddingValue;
>> + using extents_type = _Extents;
>> + using index_type = typename extents_type::index_type;
>> + using size_type = typename extents_type::size_type;
>> + using rank_type = typename extents_type::rank_type;
>> + using layout_type = layout_right_padded<_PaddingValue>;
>> +
>> + private:
>> + static constexpr size_t _S_rank = extents_type::rank();
>> + using _RightPaddedStorage = __mdspan::_PaddedStorage<_PaddingValue,
>> + _Extents, __mdspan::_RightPaddedLayoutTraits<_S_rank>>;
>> + [[no_unique_address]] _RightPaddedStorage _M_storage;
>> +
>> + static constexpr size_t _S_static_stride =
>> + _RightPaddedStorage::_S_static_stride;
>> +
>> + consteval friend size_t
>> + __mdspan::__get_static_stride<mapping>();
>> +
>> + constexpr index_type
>> + _M_extent(size_t __r) const noexcept
>> + { return _M_storage._M_extents.extent(__r); }
>> +
>> + constexpr index_type
>> + _M_dynamic_padded_stride() const noexcept
>> + { return _M_storage._M_stride.extent(0); }
>> +
>> + public:
>> + constexpr
>> + mapping() noexcept
>> + { }
>> +
>> + constexpr
>> + mapping(const mapping&) noexcept = default;
>> +
>> + constexpr
>> + mapping(const extents_type& __exts)
>> + : _M_storage(__exts)
>> + { }
>> +
>> + template<__mdspan::__valid_index_type<index_type> _OIndexType>
>> + constexpr mapping(const extents_type& __exts, _OIndexType __opad)
>> + : _M_storage(__exts, std::move(__opad))
>>
> Cast to index_type here.
>
>> + { }
>> +
>> + template<typename _OExtents>
>> + requires is_constructible_v<extents_type, _OExtents>
>> + constexpr explicit(!is_convertible_v<_OExtents, extents_type>)
>> + mapping(const layout_right::mapping<_OExtents>& __other)
>> + : _M_storage(__other)
>> + { }
>> +
>> + template<typename _OExtents>
>> + requires is_constructible_v<_OExtents, extents_type>
>> + constexpr explicit(_OExtents::rank() > 0)
>> + mapping(const typename layout_stride::mapping<_OExtents>&
>> __other)
>> + : _M_storage(__other)
>> + { __glibcxx_assert(*this == __other); }
>> +
>> + template<typename _RightPaddedMapping>
>> + requires __mdspan::__is_right_padded_mapping<_RightPaddedMapping>
>> + && is_constructible_v<extents_type,
>> + typename
>> _RightPaddedMapping::extents_type>
>> + constexpr explicit(_S_rank > 1 && (padding_value !=
>> dynamic_extent
>> + || _RightPaddedMapping::padding_value == dynamic_extent))
>> + mapping(const _RightPaddedMapping& __other)
>> + : _M_storage(__other)
>> + { }
>> +
>> + template<typename _LeftPaddedMapping>
>> + requires (__mdspan::__is_left_padded_mapping<_LeftPaddedMapping>
>> + || __mdspan::__mapping_of<layout_left, _LeftPaddedMapping>)
>> + && (_S_rank <= 1)
>> + && is_constructible_v<extents_type,
>> + typename
>> _LeftPaddedMapping::extents_type>
>> + constexpr explicit(!is_convertible_v<
>> + typename _LeftPaddedMapping::extents_type, extents_type>)
>> + mapping(const _LeftPaddedMapping& __other) noexcept
>> + : _M_storage(__other)
>> + { }
>> +
>> + constexpr mapping& operator=(const mapping&) noexcept = default;
>> +
>> + constexpr const extents_type&
>> + extents() const noexcept { return _M_storage._M_extents; }
>> +
>> + constexpr array<index_type, _S_rank>
>> + strides() const noexcept
>> + {
>> + array<index_type, _S_rank> __ret;
>> + if constexpr (_S_rank > 0)
>> + __ret[_S_rank - 1] = 1;
>> + if constexpr (_S_rank > 1)
>> + __ret[_S_rank - 2] = _M_dynamic_padded_stride();
>> + if constexpr (_S_rank > 2)
>> + for(size_t __i = _S_rank - 2; __i > 0; --__i)
>> + __ret[__i - 1] = __ret[__i] * _M_extent(__i);
>> + return __ret;
>> + }
>> +
>> + constexpr index_type
>> + required_span_size() const noexcept
>> + { return _M_storage._M_required_span_size(); }
>>
> You can name the matching function in PaddedStorage as
> "required_span_size()"
> without the "_M_prefix". We use _M_prefix as the name is reserved for
> implementation,
> and people are not allowed to do:
> #define _M_required_span_size
> #include <mdspan>
> Or in other words, if they do, is on them.
>
> Similary if the name is used somewhere, like required_span_size, we can use
> it direclty.
> I think I would prefer using exactly the same name for function that we
> just forward to,
> but I will leave it up to you.
I feel that would be inconsistent. We use _IndexType a lot, even if
it's a type alias, also _S_rank isn't needed as often since "rank" is
safe and there's several other cases too, I think there should be
some similar cases in the helper for std::extents.
>
>
>> +
>> + // _GLIBCXX_RESOLVE_LIB_DEFECTS
>> + // 4314. Missing move in mdspan layout mapping::operator()
>> + template<__mdspan::__valid_index_type<index_type>... _Indices>
>> + requires (sizeof...(_Indices) == _S_rank)
>> + constexpr index_type
>> + operator()(_Indices... __indices) const noexcept
>> + {
>> + return __mdspan::__linear_index_rightpad(
>> + extents(), _M_storage._M_stride,
>> + static_cast<index_type>(std::move(__indices))...);
>> + }
>> +
>> + static constexpr bool
>> + is_always_exhaustive() noexcept
>> + { return _RightPaddedStorage::_M_is_always_exhaustive(); }
>> +
>> + constexpr bool
>> + is_exhaustive() noexcept
>> + { return _M_storage._M_is_exhaustive(); }
>> +
>> + static constexpr bool
>> + is_always_unique() noexcept { return true; }
>> +
>> + static constexpr bool
>> + is_always_strided() noexcept { return true; }
>> +
>> + static constexpr bool
>> + is_unique() noexcept { return true; }
>> +
>> + static constexpr bool
>> + is_strided() noexcept { return true; }
>> +
>> + constexpr index_type
>> + stride(rank_type __r) const noexcept
>> + {
>> + __glibcxx_assert(__r < _S_rank);
>> + if constexpr (_S_rank <= 1)
>> + return 1;
>> + else
>> + {
>> + if (__r == _S_rank - 1)
>> + return 1;
>> + else if (__r == _S_rank - 2)
>> + return _M_dynamic_padded_stride();
>> + else
>> + return static_cast<index_type>(
>> + static_cast<size_t>(_M_dynamic_padded_stride()) *
>> + static_cast<size_t>(__mdspan::__fwd_prod(
>> + extents(), __r + 1, _S_rank - 1)));
>> + }
>> + }
>> +
>> + template<typename _RightPaddedMapping>
>> + requires(__mdspan::__is_right_padded_mapping<_RightPaddedMapping>
>> + && _RightPaddedMapping::extents_type::rank() == _S_rank)
>> + friend constexpr bool
>> + operator==(const mapping& __self, const _RightPaddedMapping&
>> __other)
>> + noexcept
>> + {
>> + return __self.extents() == __other.extents()
>> + && (_S_rank < 2 || cmp_equal(__self.stride(_S_rank - 2),
>> + __other.stride(_S_rank - 2)));
>>
> + }
>>
> This could be just __self.extents() == __other.extents()
> && __self._M_stride == other._M_stride;
> I would add _M_equal method to _PaddingStride to handle this, and call it
> from here.
>
The slight catch is that it requires additional friendlyness
because
_M_storage._M_equal(__other._M_storage);
due to _M_storage being private. Instead I did:
_M_extents == _M_extents
&& (_S_rank < 2 || _M_stride.extent(0) == __other.stride(...));
the _S_rank < 2 check ensures that we end up with
true || ...
which I think we can trust the optimizer to eliminate for us.
>
>
>> + };
>> #endif
>>
>> template<typename _ElementType>
>> diff --git a/libstdc++-v3/src/c++23/std.cc.in b/libstdc++-v3/src/c++23/
>> std.cc.in
>> index f10bab59e2c..c1b4e4c88b7 100644
>> --- a/libstdc++-v3/src/c++23/std.cc.in
>> +++ b/libstdc++-v3/src/c++23/std.cc.in
>> @@ -1871,9 +1871,10 @@ export namespace std
>> using std::mdspan;
>> #if __glibcxx_padded_layouts
>> using std::layout_left_padded;
>> + using std::layout_right_padded;
>> #endif
>> - // FIXME layout_right_padded, strided_slice, submdspan_mapping_result,
>> - // full_extent_t, full_extent, submdspan_extents, mdsubspan
>> + // FIXME strided_slice, submdspan_mapping_result, full_extent_t,
>> full_extent,
>> + // submdspan_extents, mdsubspan
>> }
>> #endif
>>
>> diff --git a/libstdc++-v3/testsuite/23_containers/mdspan/layouts/ctors.cc
>> b/libstdc++-v3/testsuite/23_containers/mdspan/layouts/ctors.cc
>> index 891471467e1..73b161f5979 100644
>> --- a/libstdc++-v3/testsuite/23_containers/mdspan/layouts/ctors.cc
>> +++ b/libstdc++-v3/testsuite/23_containers/mdspan/layouts/ctors.cc
>> @@ -10,7 +10,7 @@ constexpr size_t dyn = std::dynamic_extent;
>> #if __glibcxx_padded_layouts
>> template<typename Layout>
>> constexpr bool
>> - is_padded_layout = is_left_padded<Layout>;
>> + is_padded_layout = is_left_padded<Layout> || is_right_padded<Layout>;
>> #else
>> template<typename>
>> constexpr bool
>> @@ -479,6 +479,7 @@ main()
>> test_all<std::layout_right>();
>> #ifdef __glibcxx_padded_layouts
>> test_padded_all<std::layout_left_padded>();
>> + test_padded_all<std::layout_right_padded>();
>> #endif
>>
>> from_left_or_right::test_all<std::layout_left, std::layout_right>();
>> diff --git a/libstdc++-v3/testsuite/23_containers/mdspan/layouts/empty.cc
>> b/libstdc++-v3/testsuite/23_containers/mdspan/layouts/empty.cc
>> index 236aca8bc2b..c5519afe34f 100644
>> --- a/libstdc++-v3/testsuite/23_containers/mdspan/layouts/empty.cc
>> +++ b/libstdc++-v3/testsuite/23_containers/mdspan/layouts/empty.cc
>> @@ -142,6 +142,7 @@ main()
>> static_assert(test_all<std::layout_stride>());
>> #ifdef __glibcxx_padded_layouts
>> static_assert(test_padded_all<std::layout_left_padded>());
>> + static_assert(test_padded_all<std::layout_right_padded>());
>> #endif
>> return 0;
>> }
>> diff --git
>> a/libstdc++-v3/testsuite/23_containers/mdspan/layouts/mapping.cc
>> b/libstdc++-v3/testsuite/23_containers/mdspan/layouts/mapping.cc
>> index 5bf6bf65d3a..57560a6aae7 100644
>> --- a/libstdc++-v3/testsuite/23_containers/mdspan/layouts/mapping.cc
>> +++ b/libstdc++-v3/testsuite/23_containers/mdspan/layouts/mapping.cc
>> @@ -374,7 +374,7 @@ template<>
>>
>> #if __glibcxx_padded_layouts
>> template<typename Layout>
>> - requires is_left_padded<Layout>
>> + requires is_left_padded<Layout> || is_right_padded<Layout>
>> struct TestStride2D<Layout>
>> {
>> static constexpr void
>> @@ -458,7 +458,7 @@ template<>
>>
>> #if __glibcxx_padded_layouts
>> template<typename Layout>
>> - requires is_left_padded<Layout>
>> + requires is_left_padded<Layout> || is_right_padded<Layout>
>> struct TestStride3D<Layout>
>> {
>> static constexpr void
>> @@ -702,6 +702,7 @@ main()
>> test_all<std::layout_stride>();
>> #ifdef __glibcxx_padded_layouts
>> test_padded_all<std::layout_left_padded>();
>> + test_padded_all<std::layout_right_padded>();
>> #endif
>>
>> test_has_op_eq<std::layout_right, std::layout_left, false>();
>> @@ -709,6 +710,7 @@ main()
>> test_has_op_eq<std::layout_left, std::layout_stride, true>();
>> #ifdef __glibcxx_padded_layouts
>> test_padded_has_op_eq<std::layout_left_padded>();
>> + test_padded_has_op_eq<std::layout_right_padded>();
>> #endif
>>
>> test_has_op_eq_peculiar();
>> diff --git a/libstdc++-v3/testsuite/23_containers/mdspan/layouts/padded.cc
>> b/libstdc++-v3/testsuite/23_containers/mdspan/layouts/padded.cc
>> index ea9a8ef3f4b..a607d1ddd02 100644
>> --- a/libstdc++-v3/testsuite/23_containers/mdspan/layouts/padded.cc
>> +++ b/libstdc++-v3/testsuite/23_containers/mdspan/layouts/padded.cc
>> @@ -670,6 +670,10 @@ main()
>> test_all<std::layout_left_padded>();
>> static_assert(test_all<std::layout_left_padded>());
>>
>> + test_all<std::layout_right_padded>();
>> + static_assert(test_all<std::layout_right_padded>());
>> +
>> test_from_pad_all<std::layout_left_padded>();
>> + test_from_pad_all<std::layout_right_padded>();
>> return 0;
>> }
>> diff --git
>> a/libstdc++-v3/testsuite/23_containers/mdspan/layouts/padded_neg.cc
>> b/libstdc++-v3/testsuite/23_containers/mdspan/layouts/padded_neg.cc
>> index 29f12aa4de2..d0ac31c2810 100644
>> --- a/libstdc++-v3/testsuite/23_containers/mdspan/layouts/padded_neg.cc
>> +++ b/libstdc++-v3/testsuite/23_containers/mdspan/layouts/padded_neg.cc
>> @@ -15,6 +15,7 @@ template<template<size_t> typename Layout>
>> return true;
>> }
>> static_assert(test_from_extens_representable_sta<std::layout_left_padded>());
>> // { dg-error "from here" }
>> +static_assert(test_from_extens_representable_sta<std::layout_right_padded>());
>> // { dg-error "from here" }
>>
>> template<template<size_t> typename Layout>
>> constexpr bool
>> @@ -28,6 +29,7 @@ template<template<size_t> typename Layout>
>> return true;
>> }
>> static_assert(test_from_extents_representable_padded_size<std::layout_left_padded>());
>> // { dg-error "expansion of" }
>> +static_assert(test_from_extents_representable_padded_size<std::layout_right_padded>());
>> // { dg-error "expansion of" }
>>
>> template<template<size_t> typename Layout>
>> constexpr bool
>> @@ -40,6 +42,7 @@ template<template<size_t> typename Layout>
>> return true;
>> }
>> static_assert(test_from_extents_representable_stride<std::layout_left_padded>());
>> // { dg-error "expansion of" }
>> +static_assert(test_from_extents_representable_stride<std::layout_right_padded>());
>> // { dg-error "expansion of" }
>>
>> template<template<size_t> typename Layout>
>> constexpr bool
>> @@ -51,6 +54,7 @@ template<template<size_t> typename Layout>
>> return true;
>> }
>> static_assert(test_from_pad_representable_stride<std::layout_left_padded>());
>> // { dg-error "expansion of" }
>> +static_assert(test_from_pad_representable_stride<std::layout_right_padded>());
>> // { dg-error "expansion of" }
>>
>> template<template<size_t> typename Layout>
>> constexpr bool
>> @@ -62,6 +66,7 @@ template<template<size_t> typename Layout>
>> return true;
>> }
>> static_assert(test_from_pad_representable_padded_size<std::layout_left_padded>());
>> // { dg-error "expansion of" }
>> +static_assert(test_from_pad_representable_padded_size<std::layout_right_padded>());
>> // { dg-error "expansion of" }
>>
>> template<template<size_t> typename Layout>
>> constexpr bool
>> @@ -76,6 +81,7 @@ template<template<size_t> typename Layout>
>> return true;
>> }
>> static_assert(test_from_left<std::layout_left_padded>()); // { dg-error
>> "required from here" }
>> +static_assert(test_from_left<std::layout_right_padded>()); // { dg-error
>> "required from here" }
>>
>> template<template<size_t> typename Layout>
>> constexpr bool
>> @@ -90,6 +96,7 @@ template<template<size_t> typename Layout>
>> return true;
>> }
>> static_assert(test_from_left_bad_runtime_stride<std::layout_left_padded>());
>> // { dg-error "expansion of" }
>> +static_assert(test_from_left_bad_runtime_stride<std::layout_right_padded>());
>> // { dg-error "expansion of" }
>>
>> template<template<size_t> typename Layout>
>> constexpr bool
>> @@ -103,6 +110,7 @@ template<template<size_t> typename Layout>
>> return true;
>> }
>> static_assert(test_from_left_representable_extents<std::layout_left_padded>());
>> // { dg-error "expansion of" }
>> +static_assert(test_from_left_representable_extents<std::layout_right_padded>());
>> // { dg-error "expansion of" }
>>
>> template<template<size_t> typename Layout, size_t PaddingValue>
>> constexpr bool
>> @@ -116,6 +124,8 @@ template<template<size_t> typename Layout, size_t
>> PaddingValue>
>> }
>> static_assert(test_pad_overflow<std::layout_left_padded, 1>()); // {
>> dg-error "expansion of" }
>> static_assert(test_pad_overflow<std::layout_left_padded, dyn>()); // {
>> dg-error "expansion of" }
>> +static_assert(test_pad_overflow<std::layout_right_padded, 1>()); // {
>> dg-error "expansion of" }
>> +static_assert(test_pad_overflow<std::layout_right_padded, dyn>()); // {
>> dg-error "expansion of" }
>>
>> template<template<size_t> typename Layout, size_t PaddingValue>
>> constexpr bool
>> @@ -128,6 +138,8 @@ template<template<size_t> typename Layout, size_t
>> PaddingValue>
>> }
>> static_assert(test_from_pad_negative<std::layout_left_padded, 1>()); //
>> { dg-error "expansion of" }
>> static_assert(test_from_pad_negative<std::layout_left_padded, dyn>()); //
>> { dg-error "expansion of" }
>> +static_assert(test_from_pad_negative<std::layout_right_padded, 1>());
>> // { dg-error "expansion of" }
>> +static_assert(test_from_pad_negative<std::layout_right_padded, dyn>());
>> // { dg-error "expansion of" }
>>
>> template<template<size_t> typename Layout, size_t Pad>
>> constexpr bool
>> @@ -142,6 +154,8 @@ template<template<size_t> typename Layout, size_t Pad>
>> }
>> static_assert(test_static_pad_same<std::layout_left_padded, 1>()); // {
>> dg-error "expansion of" }
>> static_assert(test_static_pad_same<std::layout_left_padded, 3>()); // {
>> dg-error "expansion of" }
>> +static_assert(test_static_pad_same<std::layout_right_padded, 1>()); // {
>> dg-error "expansion of" }
>> +static_assert(test_static_pad_same<std::layout_right_padded, 3>()); // {
>> dg-error "expansion of" }
>>
>> template<template<size_t> typename Layout>
>> constexpr bool
>> @@ -156,6 +170,7 @@ template<template<size_t> typename Layout>
>> return true;
>> }
>> static_assert(test_from_stride_wrong_stride0<std::layout_left_padded>());
>> // { dg-error "expansion of" }
>> +static_assert(test_from_stride_wrong_stride0<std::layout_right_padded>());
>> // { dg-error "expansion of" }
>>
>> template<template<size_t> typename Layout>
>> constexpr bool
>> @@ -170,6 +185,7 @@ template<template<size_t> typename Layout>
>> return true;
>> }
>> static_assert(test_from_stride_wrong_stride1<std::layout_left_padded>());
>> // { dg-error "expansion of" }
>> +static_assert(test_from_stride_wrong_stride1<std::layout_right_padded>());
>> // { dg-error "expansion of" }
>>
>> template<template<size_t> typename Layout>
>> constexpr bool
>> @@ -184,6 +200,7 @@ template<template<size_t> typename Layout>
>> return true;
>> }
>> static_assert(test_from_stride_wrong_stride2<std::layout_left_padded>());
>> +static_assert(test_from_stride_wrong_stride2<std::layout_right_padded>());
>>
>> template<template<size_t> typename Layout>
>> constexpr bool
>> @@ -200,6 +217,7 @@ template<template<size_t> typename Layout>
>> return true;
>> }
>> static_assert(test_from_stride_oversized<std::layout_left_padded>()); //
>> { dg-error "expansion of" }
>> +static_assert(test_from_stride_oversized<std::layout_right_padded>()); //
>> { dg-error "expansion of" }
>>
>> template<template<size_t> typename Layout>
>> constexpr bool
>> @@ -213,6 +231,7 @@ template<template<size_t> typename Layout>
>> return true;
>> }
>> static_assert(test_from_samepad_dyn<std::layout_left_padded>()); // {
>> dg-error "expansion of" }
>> +static_assert(test_from_samepad_dyn<std::layout_right_padded>()); // {
>> dg-error "expansion of" }
>>
>> template<template<size_t> typename Layout>
>> constexpr bool
>> @@ -226,6 +245,7 @@ template<template<size_t> typename Layout>
>> return true;
>> }
>> static_assert(test_from_samepad_sta<std::layout_left_padded>()); // {
>> dg-error "expansion of" }
>> +static_assert(test_from_samepad_sta<std::layout_right_padded>()); // {
>> dg-error "expansion of" }
>>
>> template<template<size_t> typename Layout>
>> constexpr bool
>> @@ -240,6 +260,7 @@ template<template<size_t> typename Layout>
>> return true;
>> }
>> static_assert(test_from_samepad_oversized<std::layout_left_padded>()); //
>> { dg-error "expansion of" }
>> +static_assert(test_from_samepad_oversized<std::layout_right_padded>());
>> // { dg-error "expansion of" }
>>
>> template<template<size_t> typename Layout, size_t RunId>
>> constexpr bool
>> @@ -278,6 +299,10 @@
>> static_assert(test_to_same_not_exhaustive<std::layout_left_padded, 0>());
>> // { d
>> static_assert(test_to_same_not_exhaustive<std::layout_left_padded, 1>());
>> // { dg-error "expansion of" }
>> static_assert(test_to_same_not_exhaustive<std::layout_left_padded, 2>());
>> // { dg-error "expansion of" }
>> static_assert(test_to_same_not_exhaustive<std::layout_left_padded, 3>());
>> // { dg-error "expansion of" }
>> +static_assert(test_to_same_not_exhaustive<std::layout_right_padded,
>> 0>()); // { dg-error "expansion of" }
>> +static_assert(test_to_same_not_exhaustive<std::layout_right_padded,
>> 1>()); // { dg-error "expansion of" }
>> +static_assert(test_to_same_not_exhaustive<std::layout_right_padded,
>> 2>()); // { dg-error "expansion of" }
>> +static_assert(test_to_same_not_exhaustive<std::layout_right_padded,
>> 3>()); // { dg-error "expansion of" }
>>
>> template<template<size_t> typename Layout>
>> constexpr bool
>> @@ -290,6 +315,7 @@ template<template<size_t> typename Layout>
>> return true;
>> }
>> static_assert(test_statically_bad_padding_value1<std::layout_left_padded>());
>> // { dg-error "required from" }
>> +static_assert(test_statically_bad_padding_value1<std::layout_right_padded>());
>> // { dg-error "required from" }
>>
>> template<template<size_t> typename Layout>
>> constexpr bool
>> @@ -301,6 +327,7 @@ template<template<size_t> typename Layout>
>> return true;
>> }
>> static_assert(test_statically_bad_padding_value2<std::layout_left_padded>());
>> // { dg-error "required from" }
>> +static_assert(test_statically_bad_padding_value2<std::layout_right_padded>());
>> // { dg-error "required from" }
>>
>> template<template<size_t> typename Layout>
>> constexpr bool
>> @@ -312,6 +339,7 @@ template<template<size_t> typename Layout>
>> return true;
>> }
>> static_assert(test_statically_oversized<std::layout_left_padded>()); // {
>> dg-error "from here" }
>> +static_assert(test_statically_oversized<std::layout_right_padded>()); //
>> { dg-error "from here" }
>>
>> // { dg-prune-output "padding_value must be representable as index_type" }
>> // { dg-prune-output "non-constant condition for static assertion" }
>> diff --git
>> a/libstdc++-v3/testsuite/23_containers/mdspan/layouts/padded_traits.h
>> b/libstdc++-v3/testsuite/23_containers/mdspan/layouts/padded_traits.h
>> index 1f0169d7c02..c267454f467 100644
>> --- a/libstdc++-v3/testsuite/23_containers/mdspan/layouts/padded_traits.h
>> +++ b/libstdc++-v3/testsuite/23_containers/mdspan/layouts/padded_traits.h
>> @@ -2,9 +2,86 @@
>> #define TEST_MDSPAN_PADDED_TRAITS_H
>>
>> #if __glibcxx_padded_layouts
>> +template<typename Rev, typename Fwd>
>> + struct reverse_impl;
>> +
>> +template<size_t... Ir, size_t I0, size_t... I>
>> + struct reverse_impl<std::integer_sequence<size_t, Ir...>,
>> + std::integer_sequence<size_t, I0, I...>>
>> + {
>> + using type = typename reverse_impl<std::index_sequence<I0, Ir...>,
>> + std::index_sequence<I...>>::type;
>> + };
>> +
>> +template<size_t... Ir>
>> + struct reverse_impl<std::integer_sequence<size_t, Ir...>,
>> + std::integer_sequence<size_t>>
>> + {
>> + using type = std::index_sequence<Ir...>;
>> + };
>> +
>> +template<typename I>
>> + struct reverse;
>> +
>> +template<size_t... Ir>
>> + struct reverse<std::index_sequence<Ir...>>
>> + {
>> + using type = typename reverse_impl<std::integer_sequence<size_t>,
>> + std::integer_sequence<size_t,
>> Ir...>>::type;
>> + };
>> +
>> +template<typename, typename>
>> + struct sequence_to_extents;
>> +
>> +template<typename IndexType, size_t... I>
>> + struct sequence_to_extents<IndexType, std::index_sequence<I...>>
>> + {
>> + using type = std::extents<IndexType, I...>;
>> + };
>> +
>> +template<typename IndexType, size_t... I>
>> + struct reverse<std::extents<IndexType, I...>>
>> + {
>> + using type = typename sequence_to_extents<
>> + IndexType,
>> + typename reverse<std::index_sequence<I...>>::type
>> + >::type;
>> + };
>> +
>> +template<typename Extents>
>> + constexpr auto
>> + dynamic_extents_array(const Extents& exts)
>> + {
>> + std::array<typename Extents::index_type, Extents::rank()> ret;
>> + for(size_t i = 0; i < Extents::rank(); ++i)
>> + ret[i] = exts.extent(i);
>> + return ret;
>> + }
>> +
>> +template<typename T, size_t N>
>> + constexpr std::array<T, N>
>> + reversed(const std::array<T, N>& fwd)
>> + {
>> + std::array<T, N> rev;
>> + for(size_t i = 0; i < N; ++i)
>> + rev[(N-1) - i] = fwd[i];
>> + return rev;
>> + }
>> +
>> +template<typename IndexType, size_t... I>
>> + constexpr auto
>> + reversed(const std::extents<IndexType, I...>& exts)
>> + {
>> + using rev_type = typename reverse<std::extents<IndexType,
>> I...>>::type;
>> + return rev_type(reversed(dynamic_extents_array(exts)));
>> + }
>> +
>> +static_assert(std::array{3, 2, 1} == reversed(std::array{1, 2, 3}));
>> +
>> enum class PaddingSide
>> {
>> - Left
>> + Left,
>> + Right
>> };
>>
>> template<typename Layout>
>> @@ -13,17 +90,33 @@ template<typename Layout>
>> template<size_t PaddingValue>
>> constexpr static bool
>> is_left_padded<std::layout_left_padded<PaddingValue>> = true;
>>
>> +template<typename Layout>
>> + constexpr static bool is_right_padded = false;
>> +
>> +template<size_t PaddingValue>
>> + constexpr static bool
>> is_right_padded<std::layout_right_padded<PaddingValue>> = true;
>> +
>> struct DeducePaddingSide
>> {
>> template<template<size_t> typename Layout>
>> constexpr static PaddingSide
>> from_template()
>> - { return PaddingSide::Left; }
>> + {
>> + if constexpr (std::same_as<Layout<0>, std::layout_left_padded<0>>)
>> + return PaddingSide::Left;
>> + else
>> + return PaddingSide::Right;
>> + }
>>
>> template<typename Layout>
>> constexpr static PaddingSide
>> from_typename()
>> - { return PaddingSide::Left; }
>> + {
>> + if constexpr (is_left_padded<Layout>)
>> + return PaddingSide::Left;
>> + else
>> + return PaddingSide::Right;
>> + }
>> };
>>
>> template<PaddingSide Side>
>> @@ -59,5 +152,41 @@ template<>
>> { return exts.extent(0); }
>> };
>>
>> +template<>
>> + struct LayoutTraits<PaddingSide::Right>
>> + {
>> + using layout_same = std::layout_right;
>> + using layout_other = std::layout_left;
>> +
>> + template<typename Extents>
>> + using extents_type = typename reverse<Extents>::type;
>> +
>> + template<typename Extents>
>> + constexpr static extents_type<Extents>
>> + make_extents(const Extents& exts)
>> + { return reversed(exts); }
>> +
>> + template<typename T, size_t N>
>> + constexpr static std::array<T, N>
>> + make_expected(const std::array<T, N>& expected)
>> + { return reversed(expected); }
>> +
>> + template<typename Mapping>
>> + constexpr static auto
>> + padded_stride(const Mapping& m)
>> + {
>> + auto rank = Mapping::extents_type::rank();
>> + return m.stride(rank - 2);
>> + }
>> +
>> + template<typename Extents>
>> + constexpr static auto
>> + padded_extent(const Extents& exts)
>> + {
>> + auto rank = Extents::rank();
>> + return exts.extent(rank - 1);
>> + }
>> + };
>> +
>> #endif
>> #endif
>> --
>> 2.50.1
>>
>>
>
More information about the Libstdc++
mailing list