On Tue, Jun 10, 2025 at 8:45 AM Luc Grosheintz <luc.groshei...@gmail.com> wrote:
> Same style error. > Will be included in my fixup commit. > > On 6/4/25 16:58, Luc Grosheintz wrote: > > Implements the remaining parts of layout_left and layout_right; and all > > of layout_stride. > > > > The implementation of layout_stride::mapping::is_exhaustive applies > > the following change to the standard: > > > > 4266. layout_stride::mapping should treat empty mappings as exhaustive > > > > https://cplusplus.github.io/LWG/issue4266 > > > > The preconditions for layout_stride(extents, strides) are not checked. > > > > libstdc++-v3/ChangeLog: > > > > * include/std/mdspan (layout_stride): New class. > > * src/c++23/std.cc.in: Add layout_stride. > > > > Signed-off-by: Luc Grosheintz <luc.groshei...@gmail.com> > > --- > > libstdc++-v3/include/std/mdspan | 249 ++++++++++++++++++++++++++++++- > > libstdc++-v3/src/c++23/std.cc.in | 3 +- > > 2 files changed, 250 insertions(+), 2 deletions(-) > > > > diff --git a/libstdc++-v3/include/std/mdspan > b/libstdc++-v3/include/std/mdspan > > index 8ab7a1a52fb..fe182c35a55 100644 > > --- a/libstdc++-v3/include/std/mdspan > > +++ b/libstdc++-v3/include/std/mdspan > > @@ -415,6 +415,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > > class mapping; > > }; > > > > + struct layout_stride > > + { > > + template<typename _Extents> > > + class mapping; > > + }; > > + > > namespace __mdspan > > { > > template<typename _Tp> > > @@ -508,7 +514,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > > > > template<typename _Mapping> > > concept __standardized_mapping = __mapping_of<layout_left, > _Mapping> > > - || __mapping_of<layout_right, > _Mapping>; > > + || __mapping_of<layout_right, > _Mapping> > > + || __mapping_of<layout_stride, > _Mapping>; > > > > // A tag type to create internal ctors. > > class __internal_ctor > > @@ -554,6 +561,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > > : mapping(__other.extents(), __mdspan::__internal_ctor{}) > > { } > > > > + template<typename _OExtents> > > + requires is_constructible_v<extents_type, _OExtents> > > + constexpr explicit(extents_type::rank() > 0) > > + mapping(const layout_stride::mapping<_OExtents>& __other) > > + : mapping(__other.extents(), __mdspan::__internal_ctor{}) > > + { __glibcxx_assert(*this == __other); } > > + > > constexpr mapping& > > operator=(const mapping&) noexcept = default; > > > > @@ -684,6 +698,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > > : mapping(__other.extents(), __mdspan::__internal_ctor{}) > > { } > > > > + template<class _OExtents> > > s/class/typename/ > > > + requires is_constructible_v<extents_type, _OExtents> > > + constexpr explicit(extents_type::rank() > 0) > > + mapping(const layout_stride::mapping<_OExtents>& __other) noexcept > > + : mapping(__other.extents(), __mdspan::__internal_ctor{}) > > + { __glibcxx_assert(*this == __other); } > > + > > constexpr mapping& > > operator=(const mapping&) noexcept = default; > > > > @@ -756,6 +777,232 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > > [[no_unique_address]] extents_type _M_extents{}; > > }; > > > > + namespace __mdspan > > + { > > + template<typename M> > > + concept __mapping_alike = requires > > + { > > + requires __is_extents<typename M::extents_type>; > > + { M::is_always_strided() } -> same_as<bool>; > > + { M::is_always_exhaustive() } -> same_as<bool>; > > + { M::is_always_unique() } -> same_as<bool>; > > + bool_constant<M::is_always_strided()>::value; > > + bool_constant<M::is_always_exhaustive()>::value; > > + bool_constant<M::is_always_unique()>::value; > > + }; > > + > > + template<typename _Mapping> > > + constexpr typename _Mapping::index_type > > + __offset(const _Mapping& __m) noexcept > > + { > > + using _IndexType = typename _Mapping::index_type; > > + constexpr auto __rank = _Mapping::extents_type::rank(); > > + > > + if constexpr (__standardized_mapping<_Mapping>) > > + return 0; > > + else if (__empty(__m.extents())) > > + return 0; > > + else > > + { > > + auto __impl = [&__m]<size_t... > _Counts>(index_sequence<_Counts...>) > > + { return __m(((void) _Counts, _IndexType(0))...); }; > > + return __impl(make_index_sequence<__rank>()); > > + } > > + } > > + > > + template<typename _Mapping, typename... _Indices> > > + constexpr typename _Mapping::index_type > > + __linear_index_strides(const _Mapping& __m, _Indices... __indices) > > + noexcept > > + { > > + using _IndexType = typename _Mapping::index_type; > > + _IndexType __res = 0; > > + if constexpr (sizeof...(__indices) > 0) > > + { > > + auto __update = [&, __pos = 0u](_IndexType __idx) mutable > > + { > > + __res += __idx * __m.stride(__pos++); > > + }; > > + (__update(__indices), ...); > > + } > > + return __res; > > + } > > + } > > + > > + template<typename _Extents> > > + class layout_stride::mapping > > + { > > + public: > > + 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_stride; > > + > > + static_assert(__mdspan::__representable_size<extents_type, > index_type>, > > + "The size of extents_type must be representable as index_type"); > > + > > + constexpr > > + mapping() noexcept > > + { > > + // The precondition is either statically asserted, or automatically > > + // satisfied because dynamic extents are zero-initialzied. > > + size_t __stride = 1; > > + for (size_t __i = extents_type::rank(); __i > 0; --__i) > > + { > > + _M_strides[__i - 1] = index_type(__stride); > > + __stride *= size_t(_M_extents.extent(__i - 1)); > > + } > > + } > > + > > + constexpr > > + mapping(const mapping&) noexcept = default; > > + > > + template<__mdspan::__valid_index_type<index_type> _OIndexType> > > + constexpr > > + mapping(const extents_type& __exts, > > + span<_OIndexType, extents_type::rank()> __strides) noexcept > > + : _M_extents(__exts) > > + { > > + for (size_t __i = 0; __i < extents_type::rank(); ++__i) > > + _M_strides[__i] = index_type(as_const(__strides[__i])); > > + } > > + > > + template<__mdspan::__valid_index_type<index_type> _OIndexType> > > + constexpr > > + mapping(const extents_type& __exts, > > + const array<_OIndexType, extents_type::rank()>& __strides) > > + noexcept > > + : mapping(__exts, > > + span<const _OIndexType, extents_type::rank()>(__strides)) > > + { } > > + > > + template<__mdspan::__mapping_alike _StridedMapping> > > + requires (is_constructible_v<extents_type, > > + typename > _StridedMapping::extents_type> > > + && _StridedMapping::is_always_unique() > > + && _StridedMapping::is_always_strided()) > > + constexpr explicit(!( > > + is_convertible_v<typename _StridedMapping::extents_type, > extents_type> > > + && __mdspan::__standardized_mapping<_StridedMapping>)) > > + mapping(const _StridedMapping& __other) noexcept > > + : _M_extents(__other.extents()) > > + { > > + using _OIndexType = _StridedMapping::index_type; > > + using _OExtents = _StridedMapping::extents_type; > > + > > + __glibcxx_assert(__mdspan::__offset(__other) == 0); > > + static_assert(__mdspan::__representable_size<_OExtents, > index_type>, > > + "The size of StridedMapping::extents_type must be > representable as" > > + " index_type"); > > + if constexpr (cmp_greater(numeric_limits<_OIndexType>::max(), > > + numeric_limits<index_type>::max())) > > + __glibcxx_assert(!cmp_less(numeric_limits<index_type>::max(), > > + __other.required_span_size()) > > + && "other.required_span_size() must be representable" > > + " as index_type"); > > + if constexpr (extents_type::rank() > 0) > > + for (size_t __i = 0; __i < extents_type::rank(); ++__i) > > + _M_strides[__i] = index_type(__other.stride(__i)); > > + } > > + > > + constexpr mapping& > > + operator=(const mapping&) noexcept = default; > > + > > + constexpr const extents_type& > > + extents() const noexcept { return _M_extents; } > > + > > + constexpr array<index_type, extents_type::rank()> > > + strides() const noexcept > > + { > > + array<index_type, extents_type::rank()> __ret; > > + for (size_t __i = 0; __i < extents_type::rank(); ++__i) > > + __ret[__i] = _M_strides[__i]; > > + return __ret; > > + } > > + > > + constexpr index_type > > + required_span_size() const noexcept > > + { > > + if (__mdspan::__empty(_M_extents)) > > + return 0; > > + > > + index_type __ret = 1; > > + for (size_t __i = 0; __i < extents_type::rank(); ++__i) > > + __ret += (_M_extents.extent(__i) - 1) * _M_strides[__i]; > > + return __ret; > > + } > > + > > + template<__mdspan::__valid_index_type<index_type>... _Indices> > > + requires (sizeof...(_Indices) == extents_type::rank()) > > + constexpr index_type > > + operator()(_Indices... __indices) const noexcept > > + { > > + return __mdspan::__linear_index_strides(*this, > > + static_cast<index_type>(__indices)...); > > + } > > + > > + static constexpr bool > > + is_always_unique() noexcept { return true; } > > + > > + // _GLIBCXX_RESOLVE_LIB_DEFECTS > > + // 4266. layout_stride::mapping should treat empty mappings as > exhaustive > > + static constexpr bool > > + is_always_exhaustive() noexcept > > + { > > + return (_Extents::rank() == 0) || __mdspan::__contains_zero( > > + __mdspan::__static_extents<extents_type>()); > > + } > > + > > + static constexpr bool > > + is_always_strided() noexcept { return true; } > > + > > + static constexpr bool > > + is_unique() noexcept { return true; } > > + > > + // _GLIBCXX_RESOLVE_LIB_DEFECTS > > + // 4266. layout_stride::mapping should treat empty mappings as > exhaustive > > + constexpr bool > > + is_exhaustive() const noexcept > > + { > > + if constexpr (!is_always_exhaustive()) > > + { > > + constexpr auto __rank = extents_type::rank(); > > + auto __size = __mdspan::__fwd_prod(_M_extents, __rank); > > + if(__size > 0) > > + return __size == required_span_size(); > > + } > > + return true; > > + } > > + > > + static constexpr bool > > + is_strided() noexcept { return true; } > > + > > + constexpr index_type > > + stride(rank_type __r) const noexcept { return _M_strides[__r]; } > > + > > + template<__mdspan::__mapping_alike _OMapping> > > + requires ((extents_type::rank() == _OMapping::extents_type::rank()) > > + && _OMapping::is_always_strided()) > > + friend constexpr bool > > + operator==(const mapping& __self, const _OMapping& __other) > noexcept > > + { > > + if (__self.extents() != __other.extents()) > > + return false; > > + if constexpr (extents_type::rank() > 0) > > + for (size_t __i = 0; __i < extents_type::rank(); ++__i) > > + if (!cmp_equal(__self.stride(__i), __other.stride(__i))) > > + return false; > > + return __mdspan::__offset(__other) == 0; > > + } > > + > > + private: > > + using _S_strides_t = typename __array_traits<index_type, > > + > extents_type::rank()>::_Type; > > + [[no_unique_address]] extents_type _M_extents; > > + [[no_unique_address]] _S_strides_t _M_strides; > > + }; > > + > > _GLIBCXX_END_NAMESPACE_VERSION > > } > > #endif > > diff --git a/libstdc++-v3/src/c++23/std.cc.in b/libstdc++-v3/src/c++23/ > std.cc.in > > index fe1407d71da..9a52a7e7728 100644 > > --- a/libstdc++-v3/src/c++23/std.cc.in > > +++ b/libstdc++-v3/src/c++23/std.cc.in > > @@ -1846,7 +1846,8 @@ export namespace std > > using std::extents; > > using std::layout_left; > > using std::layout_right; > > - // FIXME layout_*, default_accessor and mdspan > > + using std::layout_stride; > > + // FIXME layout_left_padded, layout_right_padded, default_accessor > and mdspan > > } > > #endif > > > >
