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