1 // -*- C++ -*- 2 //===----------------------------------------------------------------------===// 3 // 4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5 // See https://llvm.org/LICENSE.txt for license information. 6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7 // 8 // Kokkos v. 4.0 9 // Copyright (2022) National Technology & Engineering 10 // Solutions of Sandia, LLC (NTESS). 11 // 12 // Under the terms of Contract DE-NA0003525 with NTESS, 13 // the U.S. Government retains certain rights in this software. 14 // 15 //===---------------------------------------------------------------------===// 16 17 #ifndef _LIBCPP___MDSPAN_LAYOUT_LEFT_H 18 #define _LIBCPP___MDSPAN_LAYOUT_LEFT_H 19 20 #include <__assert> 21 #include <__config> 22 #include <__fwd/mdspan.h> 23 #include <__mdspan/extents.h> 24 #include <__type_traits/common_type.h> 25 #include <__type_traits/is_constructible.h> 26 #include <__type_traits/is_convertible.h> 27 #include <__type_traits/is_nothrow_constructible.h> 28 #include <__utility/integer_sequence.h> 29 #include <array> 30 31 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 32 # pragma GCC system_header 33 #endif 34 35 _LIBCPP_PUSH_MACROS 36 #include <__undef_macros> 37 38 _LIBCPP_BEGIN_NAMESPACE_STD 39 40 #if _LIBCPP_STD_VER >= 23 41 42 template <class _Extents> 43 class layout_left::mapping { 44 public: 45 static_assert(__mdspan_detail::__is_extents<_Extents>::value, 46 "layout_left::mapping template argument must be a specialization of extents."); 47 48 using extents_type = _Extents; 49 using index_type = typename extents_type::index_type; 50 using size_type = typename extents_type::size_type; 51 using rank_type = typename extents_type::rank_type; 52 using layout_type = layout_left; 53 54 private: 55 _LIBCPP_HIDE_FROM_ABI static constexpr bool __required_span_size_is_representable(const extents_type& __ext) { 56 if constexpr (extents_type::rank() == 0) 57 return true; 58 59 index_type __prod = __ext.extent(0); 60 for (rank_type __r = 1; __r < extents_type::rank(); __r++) { 61 bool __overflowed = __builtin_mul_overflow(__prod, __ext.extent(__r), &__prod); 62 if (__overflowed) 63 return false; 64 } 65 return true; 66 } 67 68 static_assert(extents_type::rank_dynamic() > 0 || __required_span_size_is_representable(extents_type()), 69 "layout_left::mapping product of static extents must be representable as index_type."); 70 71 public: 72 // [mdspan.layout.left.cons], constructors 73 _LIBCPP_HIDE_FROM_ABI constexpr mapping() noexcept = default; 74 _LIBCPP_HIDE_FROM_ABI constexpr mapping(const mapping&) noexcept = default; 75 _LIBCPP_HIDE_FROM_ABI constexpr mapping(const extents_type& __ext) noexcept : __extents_(__ext) { 76 // not catching this could lead to out-of-bounds access later when used inside mdspan 77 // mapping<dextents<char, 2>> map(dextents<char, 2>(40,40)); map(10, 3) == -126 78 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS( 79 __required_span_size_is_representable(__ext), 80 "layout_left::mapping extents ctor: product of extents must be representable as index_type."); 81 } 82 83 template <class _OtherExtents> 84 requires(is_constructible_v<extents_type, _OtherExtents>) 85 _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_OtherExtents, extents_type>) 86 mapping(const mapping<_OtherExtents>& __other) noexcept 87 : __extents_(__other.extents()) { 88 // not catching this could lead to out-of-bounds access later when used inside mdspan 89 // mapping<dextents<char, 2>> map(mapping<dextents<int, 2>>(dextents<int, 2>(40,40))); map(10, 3) == -126 90 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS( 91 __mdspan_detail::__is_representable_as<index_type>(__other.required_span_size()), 92 "layout_left::mapping converting ctor: other.required_span_size() must be representable as index_type."); 93 } 94 95 template <class _OtherExtents> 96 requires(is_constructible_v<extents_type, _OtherExtents> && _OtherExtents::rank() <= 1) 97 _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_OtherExtents, extents_type>) 98 mapping(const layout_right::mapping<_OtherExtents>& __other) noexcept 99 : __extents_(__other.extents()) { 100 // not catching this could lead to out-of-bounds access later when used inside mdspan 101 // Note: since this is constraint to rank 1, extents itself would catch the invalid conversion first 102 // and thus this assertion should never be triggered, but keeping it here for consistency 103 // layout_left::mapping<dextents<char, 1>> map( 104 // layout_right::mapping<dextents<unsigned, 1>>(dextents<unsigned, 1>(200))); map.extents().extent(0) == 105 // -56 106 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS( 107 __mdspan_detail::__is_representable_as<index_type>(__other.required_span_size()), 108 "layout_left::mapping converting ctor: other.required_span_size() must be representable as index_type."); 109 } 110 111 template <class _OtherExtents> 112 requires(is_constructible_v<extents_type, _OtherExtents>) 113 _LIBCPP_HIDE_FROM_ABI constexpr explicit(extents_type::rank() > 0) 114 mapping(const layout_stride::mapping<_OtherExtents>& __other) noexcept 115 : __extents_(__other.extents()) { 116 if constexpr (extents_type::rank() > 0) { 117 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS( 118 ([&]() { 119 using _CommonType = common_type_t<typename extents_type::index_type, typename _OtherExtents::index_type>; 120 for (rank_type __r = 0; __r < extents_type::rank(); __r++) 121 if (static_cast<_CommonType>(stride(__r)) != static_cast<_CommonType>(__other.stride(__r))) 122 return false; 123 return true; 124 }()), 125 "layout_left::mapping from layout_stride ctor: strides are not compatible with layout_left."); 126 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS( 127 __mdspan_detail::__is_representable_as<index_type>(__other.required_span_size()), 128 "layout_left::mapping from layout_stride ctor: other.required_span_size() must be representable as " 129 "index_type."); 130 } 131 } 132 133 _LIBCPP_HIDE_FROM_ABI constexpr mapping& operator=(const mapping&) noexcept = default; 134 135 // [mdspan.layout.left.obs], observers 136 _LIBCPP_HIDE_FROM_ABI constexpr const extents_type& extents() const noexcept { return __extents_; } 137 138 _LIBCPP_HIDE_FROM_ABI constexpr index_type required_span_size() const noexcept { 139 index_type __size = 1; 140 for (size_t __r = 0; __r < extents_type::rank(); __r++) 141 __size *= __extents_.extent(__r); 142 return __size; 143 } 144 145 template <class... _Indices> 146 requires((sizeof...(_Indices) == extents_type::rank()) && (is_convertible_v<_Indices, index_type> && ...) && 147 (is_nothrow_constructible_v<index_type, _Indices> && ...)) 148 _LIBCPP_HIDE_FROM_ABI constexpr index_type operator()(_Indices... __idx) const noexcept { 149 // Mappings are generally meant to be used for accessing allocations and are meant to guarantee to never 150 // return a value exceeding required_span_size(), which is used to know how large an allocation one needs 151 // Thus, this is a canonical point in multi-dimensional data structures to make invalid element access checks 152 // However, mdspan does check this on its own, so for now we avoid double checking in hardened mode 153 _LIBCPP_ASSERT_UNCATEGORIZED(__mdspan_detail::__is_multidimensional_index_in(__extents_, __idx...), 154 "layout_left::mapping: out of bounds indexing"); 155 array<index_type, extents_type::rank()> __idx_a{static_cast<index_type>(__idx)...}; 156 return [&]<size_t... _Pos>(index_sequence<_Pos...>) { 157 index_type __res = 0; 158 ((__res = __idx_a[extents_type::rank() - 1 - _Pos] + __extents_.extent(extents_type::rank() - 1 - _Pos) * __res), 159 ...); 160 return __res; 161 }(make_index_sequence<sizeof...(_Indices)>()); 162 } 163 164 _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_unique() noexcept { return true; } 165 _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_exhaustive() noexcept { return true; } 166 _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_strided() noexcept { return true; } 167 168 _LIBCPP_HIDE_FROM_ABI static constexpr bool is_unique() noexcept { return true; } 169 _LIBCPP_HIDE_FROM_ABI static constexpr bool is_exhaustive() noexcept { return true; } 170 _LIBCPP_HIDE_FROM_ABI static constexpr bool is_strided() noexcept { return true; } 171 172 _LIBCPP_HIDE_FROM_ABI constexpr index_type stride(rank_type __r) const noexcept 173 requires(extents_type::rank() > 0) 174 { 175 // While it would be caught by extents itself too, using a too large __r 176 // is functionally an out of bounds access on the stored information needed to compute strides 177 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS( 178 __r < extents_type::rank(), "layout_left::mapping::stride(): invalid rank index"); 179 index_type __s = 1; 180 for (rank_type __i = 0; __i < __r; __i++) 181 __s *= __extents_.extent(__i); 182 return __s; 183 } 184 185 template <class _OtherExtents> 186 requires(_OtherExtents::rank() == extents_type::rank()) 187 _LIBCPP_HIDE_FROM_ABI friend constexpr bool 188 operator==(const mapping& __lhs, const mapping<_OtherExtents>& __rhs) noexcept { 189 return __lhs.extents() == __rhs.extents(); 190 } 191 192 private: 193 _LIBCPP_NO_UNIQUE_ADDRESS extents_type __extents_{}; 194 }; 195 196 #endif // _LIBCPP_STD_VER >= 23 197 198 _LIBCPP_END_NAMESPACE_STD 199 200 _LIBCPP_POP_MACROS 201 202 #endif // _LIBCPP___MDSPAN_LAYOUT_LEFT_H 203