codekingpro/portable-devtools
114k
1// -*- C++ -*-2//===------------------------------- simd ---------------------------------===//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-exception7//8//===----------------------------------------------------------------------===//9#ifndef _LIBCUDACXX_EXPERIMENTAL_SIMD10#define _LIBCUDACXX_EXPERIMENTAL_SIMD11 12/*13 experimental/simd synopsis14 15namespace std::experimental {16 17inline namespace parallelism_v2 {18 19namespace simd_abi {20 21struct scalar {};22template <int N> struct fixed_size {};23template <typename T> inline constexpr int max_fixed_size = implementation-defined;24template <typename T> using compatible = implementation-defined;25template <typename T> using native = implementation-defined;26 27} // simd_abi28 29struct element_aligned_tag {};30struct vector_aligned_tag {};31template <size_t> struct overaligned_tag {};32inline constexpr element_aligned_tag element_aligned{};33inline constexpr vector_aligned_tag vector_aligned{};34template <size_t N> inline constexpr overaligned_tag<N> overaligned{};35 36// traits [simd.traits]37template <class T> struct is_abi_tag;38template <class T> inline constexpr bool is_abi_tag_v = is_abi_tag<T>::value;39 40template <class T> struct is_simd;41template <class T> inline constexpr bool is_simd_v = is_simd<T>::value;42 43template <class T> struct is_simd_mask;44template <class T> inline constexpr bool is_simd_mask_v = is_simd_mask<T>::value;45 46template <class T> struct is_simd_flag_type;47template <class T> inline constexpr bool is_simd_flag_type_v = is_simd_flag_type<T>::value;48 49template <class T, size_t N> struct abi_for_size { using type = see below; };50template <class T, size_t N> using abi_for_size_t = typename abi_for_size<T, N>::type;51 52template <class T, class Abi = simd_abi::compatible<T>> struct simd_size;53template <class T, class Abi = simd_abi::compatible<T>>54inline constexpr size_t simd_size_v = simd_size<T, Abi>::value;55 56template <class T, class U = typename T::value_type> struct memory_alignment;57template <class T, class U = typename T::value_type>58inline constexpr size_t memory_alignment_v = memory_alignment<T, U>::value;59 60// class template simd [simd.class]61template <class T, class Abi = simd_abi::compatible<T>> class simd;62template <class T> using native_simd = simd<T, simd_abi::native<T>>;63template <class T, int N> using fixed_size_simd = simd<T, simd_abi::fixed_size<N>>;64 65// class template simd_mask [simd.mask.class]66template <class T, class Abi = simd_abi::compatible<T>> class simd_mask;67template <class T> using native_simd_mask = simd_mask<T, simd_abi::native<T>>;68template <class T, int N> using fixed_size_simd_mask = simd_mask<T, simd_abi::fixed_size<N>>;69 70// casts [simd.casts]71template <class T, class U, class Abi> see below simd_cast(const simd<U, Abi>&);72template <class T, class U, class Abi> see below static_simd_cast(const simd<U, Abi>&);73 74template <class T, class Abi>75fixed_size_simd<T, simd_size_v<T, Abi>> to_fixed_size(const simd<T, Abi>&) noexcept;76template <class T, class Abi>77fixed_size_simd_mask<T, simd_size_v<T, Abi>> to_fixed_size(const simd_mask<T, Abi>&) noexcept;78template <class T, size_t N> native_simd<T> to_native(const fixed_size_simd<T, N>&) noexcept;79template <class T, size_t N>80native_simd_mask<T> to_native(const fixed_size_simd_mask<T, N>> &) noexcept;81template <class T, size_t N> simd<T> to_compatible(const fixed_size_simd<T, N>&) noexcept;82template <class T, size_t N> simd_mask<T> to_compatible(const fixed_size_simd_mask<T, N>&) noexcept;83 84template <size_t... Sizes, class T, class Abi>85tuple<simd<T, abi_for_size_t<Sizes>>...> split(const simd<T, Abi>&);86template <size_t... Sizes, class T, class Abi>87tuple<simd_mask<T, abi_for_size_t<Sizes>>...> split(const simd_mask<T, Abi>&);88template <class V, class Abi>89array<V, simd_size_v<typename V::value_type, Abi> / V::size()> split(90const simd<typename V::value_type, Abi>&);91template <class V, class Abi>92array<V, simd_size_v<typename V::value_type, Abi> / V::size()> split(93const simd_mask<typename V::value_type, Abi>&);94 95template <class T, class... Abis>96simd<T, abi_for_size_t<T, (simd_size_v<T, Abis> + ...)>> concat(const simd<T, Abis>&...);97template <class T, class... Abis>98simd_mask<T, abi_for_size_t<T, (simd_size_v<T, Abis> + ...)>> concat(const simd_mask<T, Abis>&...);99 100// reductions [simd.mask.reductions]101template <class T, class Abi> bool all_of(const simd_mask<T, Abi>&) noexcept;102template <class T, class Abi> bool any_of(const simd_mask<T, Abi>&) noexcept;103template <class T, class Abi> bool none_of(const simd_mask<T, Abi>&) noexcept;104template <class T, class Abi> bool some_of(const simd_mask<T, Abi>&) noexcept;105template <class T, class Abi> int popcount(const simd_mask<T, Abi>&) noexcept;106template <class T, class Abi> int find_first_set(const simd_mask<T, Abi>&);107template <class T, class Abi> int find_last_set(const simd_mask<T, Abi>&);108 109bool all_of(see below) noexcept;110bool any_of(see below) noexcept;111bool none_of(see below) noexcept;112bool some_of(see below) noexcept;113int popcount(see below) noexcept;114int find_first_set(see below) noexcept;115int find_last_set(see below) noexcept;116 117// masked assignment [simd.whereexpr]118template <class M, class T> class const_where_expression;119template <class M, class T> class where_expression;120 121// masked assignment [simd.mask.where]122template <class T> struct nodeduce { using type = T; }; // exposition only123 124template <class T> using nodeduce_t = typename nodeduce<T>::type; // exposition only125 126template <class T, class Abi>127where_expression<simd_mask<T, Abi>, simd<T, Abi>>128where(const typename simd<T, Abi>::mask_type&, simd<T, Abi>&) noexcept;129 130template <class T, class Abi>131const_where_expression<simd_mask<T, Abi>, const simd<T, Abi>>132where(const typename simd<T, Abi>::mask_type&, const simd<T, Abi>&) noexcept;133 134template <class T, class Abi>135where_expression<simd_mask<T, Abi>, simd_mask<T, Abi>>136where(const nodeduce_t<simd_mask<T, Abi>>&, simd_mask<T, Abi>&) noexcept;137 138template <class T, class Abi>139const_where_expression<simd_mask<T, Abi>, const simd_mask<T, Abi>>140where(const nodeduce_t<simd_mask<T, Abi>>&, const simd_mask<T, Abi>&) noexcept;141 142template <class T> where_expression<bool, T> where(see below k, T& d) noexcept;143 144template <class T>145const_where_expression<bool, const T> where(see below k, const T& d) noexcept;146 147// reductions [simd.reductions]148template <class T, class Abi, class BinaryOperation = std::plus<>>149T reduce(const simd<T, Abi>&, BinaryOperation = BinaryOperation());150 151template <class M, class V, class BinaryOperation>152typename V::value_type reduce(const const_where_expression<M, V>& x,153typename V::value_type neutral_element, BinaryOperation binary_op);154 155template <class M, class V>156typename V::value_type reduce(const const_where_expression<M, V>& x, plus<> binary_op = plus<>());157 158template <class M, class V>159typename V::value_type reduce(const const_where_expression<M, V>& x, multiplies<> binary_op);160 161template <class M, class V>162typename V::value_type reduce(const const_where_expression<M, V>& x, bit_and<> binary_op);163 164template <class M, class V>165typename V::value_type reduce(const const_where_expression<M, V>& x, bit_or<> binary_op);166 167template <class M, class V>168typename V::value_type reduce(const const_where_expression<M, V>& x, bit_xor<> binary_op);169 170template <class T, class Abi> T hmin(const simd<T, Abi>&);171template <class M, class V> T hmin(const const_where_expression<M, V>&);172template <class T, class Abi> T hmax(const simd<T, Abi>&);173template <class M, class V> T hmax(const const_where_expression<M, V>&);174 175// algorithms [simd.alg]176template <class T, class Abi> simd<T, Abi> min(const simd<T, Abi>&, const simd<T, Abi>&) noexcept;177 178template <class T, class Abi> simd<T, Abi> max(const simd<T, Abi>&, const simd<T, Abi>&) noexcept;179 180template <class T, class Abi>181std::pair<simd<T, Abi>, simd<T, Abi>> minmax(const simd<T, Abi>&, const simd<T, Abi>&) noexcept;182 183template <class T, class Abi>184simd<T, Abi> clamp(const simd<T, Abi>& v, const simd<T, Abi>& lo, const simd<T, Abi>& hi);185 186// [simd.whereexpr]187template <class M, class T>188class const_where_expression {189 const M& mask; // exposition only190 T& data; // exposition only191public:192 const_where_expression(const const_where_expression&) = delete;193 const_where_expression& operator=(const const_where_expression&) = delete;194 remove_const_t<T> operator-() const &&;195 template <class U, class Flags> void copy_to(U* mem, Flags f) const &&;196};197 198template <class M, class T>199class where_expression : public const_where_expression<M, T> {200public:201 where_expression(const where_expression&) = delete;202 where_expression& operator=(const where_expression&) = delete;203 template <class U> void operator=(U&& x);204 template <class U> void operator+=(U&& x);205 template <class U> void operator-=(U&& x);206 template <class U> void operator*=(U&& x);207 template <class U> void operator/=(U&& x);208 template <class U> void operator%=(U&& x);209 template <class U> void operator&=(U&& x);210 template <class U> void operator|=(U&& x);211 template <class U> void operator^=(U&& x);212 template <class U> void operator<<=(U&& x);213 template <class U> void operator>>=(U&& x);214 void operator++();215 void operator++(int);216 void operator--();217 void operator--(int);218 template <class U, class Flags> void copy_from(const U* mem, Flags);219};220 221// [simd.class]222template <class T, class Abi> class simd {223public:224 using value_type = T;225 using reference = see below;226 using mask_type = simd_mask<T, Abi>;227 228 using abi_type = Abi;229 static constexpr size_t size() noexcept;230 simd() = default;231 232 // implicit type conversion constructor233 template <class U> simd(const simd<U, simd_abi::fixed_size<size()>>&);234 235 // implicit broadcast constructor (see below for constraints)236 template <class U> simd(U&& value);237 238 // generator constructor (see below for constraints)239 template <class G> explicit simd(G&& gen);240 241 // load constructor242 template <class U, class Flags> simd(const U* mem, Flags f);243 244 // loads [simd.load]245 template <class U, class Flags> void copy_from(const U* mem, Flags f);246 247 // stores [simd.store]248 template <class U, class Flags> void copy_to(U* mem, Flags f) const;249 250 // scalar access [simd.subscr]251 reference operator[](size_t);252 value_type operator[](size_t) const;253 254 // unary operators [simd.unary]255 simd& operator++();256 simd operator++(int);257 simd& operator--();258 simd operator--(int);259 mask_type operator!() const;260 simd operator~() const; // see below261 simd operator+() const;262 simd operator-() const;263 264 // binary operators [simd.binary]265 friend simd operator+ (const simd&, const simd&);266 friend simd operator- (const simd&, const simd&);267 friend simd operator* (const simd&, const simd&);268 friend simd operator/ (const simd&, const simd&);269 friend simd operator% (const simd&, const simd&);270 friend simd operator& (const simd&, const simd&);271 friend simd operator| (const simd&, const simd&);272 friend simd operator^ (const simd&, const simd&);273 friend simd operator<<(const simd&, const simd&);274 friend simd operator>>(const simd&, const simd&);275 friend simd operator<<(const simd&, int);276 friend simd operator>>(const simd&, int);277 278 // compound assignment [simd.cassign]279 friend simd& operator+= (simd&, const simd&);280 friend simd& operator-= (simd&, const simd&);281 friend simd& operator*= (simd&, const simd&);282 friend simd& operator/= (simd&, const simd&);283 friend simd& operator%= (simd&, const simd&);284 285 friend simd& operator&= (simd&, const simd&);286 friend simd& operator|= (simd&, const simd&);287 friend simd& operator^= (simd&, const simd&);288 friend simd& operator<<=(simd&, const simd&);289 friend simd& operator>>=(simd&, const simd&);290 friend simd& operator<<=(simd&, int);291 friend simd& operator>>=(simd&, int);292 293 // compares [simd.comparison]294 friend mask_type operator==(const simd&, const simd&);295 friend mask_type operator!=(const simd&, const simd&);296 friend mask_type operator>=(const simd&, const simd&);297 friend mask_type operator<=(const simd&, const simd&);298 friend mask_type operator> (const simd&, const simd&);299 friend mask_type operator< (const simd&, const simd&);300};301 302// [simd.math]303template <class Abi> using scharv = simd<signed char, Abi>; // exposition only304template <class Abi> using shortv = simd<short, Abi>; // exposition only305template <class Abi> using intv = simd<int, Abi>; // exposition only306template <class Abi> using longv = simd<long int, Abi>; // exposition only307template <class Abi> using llongv = simd<long long int, Abi>; // exposition only308template <class Abi> using floatv = simd<float, Abi>; // exposition only309template <class Abi> using doublev = simd<double, Abi>; // exposition only310template <class Abi> using ldoublev = simd<long double, Abi>; // exposition only311template <class T, class V> using samesize = fixed_size_simd<T, V::size()>; // exposition only312 313template <class Abi> floatv<Abi> acos(floatv<Abi> x);314template <class Abi> doublev<Abi> acos(doublev<Abi> x);315template <class Abi> ldoublev<Abi> acos(ldoublev<Abi> x);316 317template <class Abi> floatv<Abi> asin(floatv<Abi> x);318template <class Abi> doublev<Abi> asin(doublev<Abi> x);319template <class Abi> ldoublev<Abi> asin(ldoublev<Abi> x);320 321template <class Abi> floatv<Abi> atan(floatv<Abi> x);322template <class Abi> doublev<Abi> atan(doublev<Abi> x);323template <class Abi> ldoublev<Abi> atan(ldoublev<Abi> x);324 325template <class Abi> floatv<Abi> atan2(floatv<Abi> y, floatv<Abi> x);326template <class Abi> doublev<Abi> atan2(doublev<Abi> y, doublev<Abi> x);327template <class Abi> ldoublev<Abi> atan2(ldoublev<Abi> y, ldoublev<Abi> x);328 329template <class Abi> floatv<Abi> cos(floatv<Abi> x);330template <class Abi> doublev<Abi> cos(doublev<Abi> x);331template <class Abi> ldoublev<Abi> cos(ldoublev<Abi> x);332 333template <class Abi> floatv<Abi> sin(floatv<Abi> x);334template <class Abi> doublev<Abi> sin(doublev<Abi> x);335template <class Abi> ldoublev<Abi> sin(ldoublev<Abi> x);336 337template <class Abi> floatv<Abi> tan(floatv<Abi> x);338template <class Abi> doublev<Abi> tan(doublev<Abi> x);339template <class Abi> ldoublev<Abi> tan(ldoublev<Abi> x);340 341template <class Abi> floatv<Abi> acosh(floatv<Abi> x);342template <class Abi> doublev<Abi> acosh(doublev<Abi> x);343template <class Abi> ldoublev<Abi> acosh(ldoublev<Abi> x);344 345template <class Abi> floatv<Abi> asinh(floatv<Abi> x);346template <class Abi> doublev<Abi> asinh(doublev<Abi> x);347template <class Abi> ldoublev<Abi> asinh(ldoublev<Abi> x);348 349template <class Abi> floatv<Abi> atanh(floatv<Abi> x);350template <class Abi> doublev<Abi> atanh(doublev<Abi> x);351template <class Abi> ldoublev<Abi> atanh(ldoublev<Abi> x);352 353template <class Abi> floatv<Abi> cosh(floatv<Abi> x);354template <class Abi> doublev<Abi> cosh(doublev<Abi> x);355template <class Abi> ldoublev<Abi> cosh(ldoublev<Abi> x);356 357template <class Abi> floatv<Abi> sinh(floatv<Abi> x);358template <class Abi> doublev<Abi> sinh(doublev<Abi> x);359template <class Abi> ldoublev<Abi> sinh(ldoublev<Abi> x);360 361template <class Abi> floatv<Abi> tanh(floatv<Abi> x);362template <class Abi> doublev<Abi> tanh(doublev<Abi> x);363template <class Abi> ldoublev<Abi> tanh(ldoublev<Abi> x);364 365template <class Abi> floatv<Abi> exp(floatv<Abi> x);366template <class Abi> doublev<Abi> exp(doublev<Abi> x);367template <class Abi> ldoublev<Abi> exp(ldoublev<Abi> x);368 369template <class Abi> floatv<Abi> exp2(floatv<Abi> x);370template <class Abi> doublev<Abi> exp2(doublev<Abi> x);371template <class Abi> ldoublev<Abi> exp2(ldoublev<Abi> x);372 373template <class Abi> floatv<Abi> expm1(floatv<Abi> x);374template <class Abi> doublev<Abi> expm1(doublev<Abi> x);375template <class Abi> ldoublev<Abi> expm1(ldoublev<Abi> x);376 377template <class Abi> floatv<Abi> frexp(floatv<Abi> value, samesize<int, floatv<Abi>>* exp);378template <class Abi> doublev<Abi> frexp(doublev<Abi> value, samesize<int, doublev<Abi>>* exp);379template <class Abi> ldoublev<Abi> frexp(ldoublev<Abi> value, samesize<int, ldoublev<Abi>>* exp);380 381template <class Abi> samesize<int, floatv<Abi>> ilogb(floatv<Abi> x);382template <class Abi> samesize<int, doublev<Abi>> ilogb(doublev<Abi> x);383template <class Abi> samesize<int, ldoublev<Abi>> ilogb(ldoublev<Abi> x);384 385template <class Abi> floatv<Abi> ldexp(floatv<Abi> x, samesize<int, floatv<Abi>> exp);386template <class Abi> doublev<Abi> ldexp(doublev<Abi> x, samesize<int, doublev<Abi>> exp);387template <class Abi> ldoublev<Abi> ldexp(ldoublev<Abi> x, samesize<int, ldoublev<Abi>> exp);388 389template <class Abi> floatv<Abi> log(floatv<Abi> x);390template <class Abi> doublev<Abi> log(doublev<Abi> x);391template <class Abi> ldoublev<Abi> log(ldoublev<Abi> x);392 393template <class Abi> floatv<Abi> log10(floatv<Abi> x);394template <class Abi> doublev<Abi> log10(doublev<Abi> x);395template <class Abi> ldoublev<Abi> log10(ldoublev<Abi> x);396 397template <class Abi> floatv<Abi> log1p(floatv<Abi> x);398template <class Abi> doublev<Abi> log1p(doublev<Abi> x);399template <class Abi> ldoublev<Abi> log1p(ldoublev<Abi> x);400 401template <class Abi> floatv<Abi> log2(floatv<Abi> x);402template <class Abi> doublev<Abi> log2(doublev<Abi> x);403template <class Abi> ldoublev<Abi> log2(ldoublev<Abi> x);404 405template <class Abi> floatv<Abi> logb(floatv<Abi> x);406template <class Abi> doublev<Abi> logb(doublev<Abi> x);407template <class Abi> ldoublev<Abi> logb(ldoublev<Abi> x);408 409template <class Abi> floatv<Abi> modf(floatv<Abi> value, floatv<Abi>* iptr);410template <class Abi> doublev<Abi> modf(doublev<Abi> value, doublev<Abi>* iptr);411template <class Abi> ldoublev<Abi> modf(ldoublev<Abi> value, ldoublev<Abi>* iptr);412 413template <class Abi> floatv<Abi> scalbn(floatv<Abi> x, samesize<int, floatv<Abi>> n);414template <class Abi> doublev<Abi> scalbn(doublev<Abi> x, samesize<int, doublev<Abi>> n);415template <class Abi> ldoublev<Abi> scalbn(ldoublev<Abi> x, samesize<int, ldoublev<Abi>> n);416template <class Abi> floatv<Abi> scalbln(floatv<Abi> x, samesize<long int, floatv<Abi>> n);417template <class Abi> doublev<Abi> scalbln(doublev<Abi> x, samesize<long int, doublev<Abi>> n);418template <class Abi> ldoublev<Abi> scalbln(ldoublev<Abi> x, samesize<long int, ldoublev<Abi>> n);419 420template <class Abi> floatv<Abi> cbrt(floatv<Abi> x);421template <class Abi> doublev<Abi> cbrt(doublev<Abi> x);422template <class Abi> ldoublev<Abi> cbrt(ldoublev<Abi> x);423 424template <class Abi> scharv<Abi> abs(scharv<Abi> j);425template <class Abi> shortv<Abi> abs(shortv<Abi> j);426template <class Abi> intv<Abi> abs(intv<Abi> j);427template <class Abi> longv<Abi> abs(longv<Abi> j);428template <class Abi> llongv<Abi> abs(llongv<Abi> j);429template <class Abi> floatv<Abi> abs(floatv<Abi> j);430template <class Abi> doublev<Abi> abs(doublev<Abi> j);431template <class Abi> ldoublev<Abi> abs(ldoublev<Abi> j);432 433template <class Abi> floatv<Abi> hypot(floatv<Abi> x, floatv<Abi> y);434template <class Abi> doublev<Abi> hypot(doublev<Abi> x, doublev<Abi> y);435template <class Abi> ldoublev<Abi> hypot(doublev<Abi> x, doublev<Abi> y);436template <class Abi> floatv<Abi> hypot(floatv<Abi> x, floatv<Abi> y, floatv<Abi> z);437template <class Abi> doublev<Abi> hypot(doublev<Abi> x, doublev<Abi> y, doublev<Abi> z);438template <class Abi> ldoublev<Abi> hypot(ldoublev<Abi> x, ldoublev<Abi> y, ldoublev<Abi> z);439 440template <class Abi> floatv<Abi> pow(floatv<Abi> x, floatv<Abi> y);441template <class Abi> doublev<Abi> pow(doublev<Abi> x, doublev<Abi> y);442template <class Abi> ldoublev<Abi> pow(ldoublev<Abi> x, ldoublev<Abi> y);443 444template <class Abi> floatv<Abi> sqrt(floatv<Abi> x);445template <class Abi> doublev<Abi> sqrt(doublev<Abi> x);446template <class Abi> ldoublev<Abi> sqrt(ldoublev<Abi> x);447 448template <class Abi> floatv<Abi> erf(floatv<Abi> x);449template <class Abi> doublev<Abi> erf(doublev<Abi> x);450template <class Abi> ldoublev<Abi> erf(ldoublev<Abi> x);451template <class Abi> floatv<Abi> erfc(floatv<Abi> x);452template <class Abi> doublev<Abi> erfc(doublev<Abi> x);453template <class Abi> ldoublev<Abi> erfc(ldoublev<Abi> x);454 455template <class Abi> floatv<Abi> lgamma(floatv<Abi> x);456template <class Abi> doublev<Abi> lgamma(doublev<Abi> x);457template <class Abi> ldoublev<Abi> lgamma(ldoublev<Abi> x);458 459template <class Abi> floatv<Abi> tgamma(floatv<Abi> x);460template <class Abi> doublev<Abi> tgamma(doublev<Abi> x);461template <class Abi> ldoublev<Abi> tgamma(ldoublev<Abi> x);462 463template <class Abi> floatv<Abi> ceil(floatv<Abi> x);464template <class Abi> doublev<Abi> ceil(doublev<Abi> x);465template <class Abi> ldoublev<Abi> ceil(ldoublev<Abi> x);466 467template <class Abi> floatv<Abi> floor(floatv<Abi> x);468template <class Abi> doublev<Abi> floor(doublev<Abi> x);469template <class Abi> ldoublev<Abi> floor(ldoublev<Abi> x);470 471template <class Abi> floatv<Abi> nearbyint(floatv<Abi> x);472template <class Abi> doublev<Abi> nearbyint(doublev<Abi> x);473template <class Abi> ldoublev<Abi> nearbyint(ldoublev<Abi> x);474 475template <class Abi> floatv<Abi> rint(floatv<Abi> x);476template <class Abi> doublev<Abi> rint(doublev<Abi> x);477template <class Abi> ldoublev<Abi> rint(ldoublev<Abi> x);478 479template <class Abi> samesize<long int, floatv<Abi>> lrint(floatv<Abi> x);480template <class Abi> samesize<long int, doublev<Abi>> lrint(doublev<Abi> x);481template <class Abi> samesize<long int, ldoublev<Abi>> lrint(ldoublev<Abi> x);482template <class Abi> samesize<long long int, floatv<Abi>> llrint(floatv<Abi> x);483template <class Abi> samesize<long long int, doublev<Abi>> llrint(doublev<Abi> x);484template <class Abi> samesize<long long int, ldoublev<Abi>> llrint(ldoublev<Abi> x);485 486template <class Abi> floatv<Abi> round(floatv<Abi> x);487template <class Abi> doublev<Abi> round(doublev<Abi> x);488template <class Abi> ldoublev<Abi> round(ldoublev<Abi> x);489template <class Abi> samesize<long int, floatv<Abi>> lround(floatv<Abi> x);490template <class Abi> samesize<long int, doublev<Abi>> lround(doublev<Abi> x);491template <class Abi> samesize<long int, ldoublev<Abi>> lround(ldoublev<Abi> x);492template <class Abi> samesize<long long int, floatv<Abi>> llround(floatv<Abi> x);493template <class Abi> samesize<long long int, doublev<Abi>> llround(doublev<Abi> x);494template <class Abi> samesize<long long int, ldoublev<Abi>> llround(ldoublev<Abi> x);495 496template <class Abi> floatv<Abi> trunc(floatv<Abi> x);497template <class Abi> doublev<Abi> trunc(doublev<Abi> x);498template <class Abi> ldoublev<Abi> trunc(ldoublev<Abi> x);499 500template <class Abi> floatv<Abi> fmod(floatv<Abi> x, floatv<Abi> y);501template <class Abi> doublev<Abi> fmod(doublev<Abi> x, doublev<Abi> y);502template <class Abi> ldoublev<Abi> fmod(ldoublev<Abi> x, ldoublev<Abi> y);503 504template <class Abi> floatv<Abi> remainder(floatv<Abi> x, floatv<Abi> y);505template <class Abi> doublev<Abi> remainder(doublev<Abi> x, doublev<Abi> y);506template <class Abi> ldoublev<Abi> remainder(ldoublev<Abi> x, ldoublev<Abi> y);507 508template <class Abi> floatv<Abi> remquo(floatv<Abi> x, floatv<Abi> y, samesize<int, floatv<Abi>>* quo);509template <class Abi> doublev<Abi> remquo(doublev<Abi> x, doublev<Abi> y, samesize<int, doublev<Abi>>* quo);510template <class Abi> ldoublev<Abi> remquo(ldoublev<Abi> x, ldoublev<Abi> y, samesize<int, ldoublev<Abi>>* quo);511 512template <class Abi> floatv<Abi> copysign(floatv<Abi> x, floatv<Abi> y);513template <class Abi> doublev<Abi> copysign(doublev<Abi> x, doublev<Abi> y);514template <class Abi> ldoublev<Abi> copysign(ldoublev<Abi> x, ldoublev<Abi> y);515 516template <class Abi> doublev<Abi> nan(const char* tagp);517template <class Abi> floatv<Abi> nanf(const char* tagp);518template <class Abi> ldoublev<Abi> nanl(const char* tagp);519 520template <class Abi> floatv<Abi> nextafter(floatv<Abi> x, floatv<Abi> y);521template <class Abi> doublev<Abi> nextafter(doublev<Abi> x, doublev<Abi> y);522template <class Abi> ldoublev<Abi> nextafter(ldoublev<Abi> x, ldoublev<Abi> y);523 524template <class Abi> floatv<Abi> nexttoward(floatv<Abi> x, ldoublev<Abi> y);525template <class Abi> doublev<Abi> nexttoward(doublev<Abi> x, ldoublev<Abi> y);526template <class Abi> ldoublev<Abi> nexttoward(ldoublev<Abi> x, ldoublev<Abi> y);527 528template <class Abi> floatv<Abi> fdim(floatv<Abi> x, floatv<Abi> y);529template <class Abi> doublev<Abi> fdim(doublev<Abi> x, doublev<Abi> y);530template <class Abi> ldoublev<Abi> fdim(ldoublev<Abi> x, ldoublev<Abi> y);531 532template <class Abi> floatv<Abi> fmax(floatv<Abi> x, floatv<Abi> y);533template <class Abi> doublev<Abi> fmax(doublev<Abi> x, doublev<Abi> y);534template <class Abi> ldoublev<Abi> fmax(ldoublev<Abi> x, ldoublev<Abi> y);535 536template <class Abi> floatv<Abi> fmin(floatv<Abi> x, floatv<Abi> y);537template <class Abi> doublev<Abi> fmin(doublev<Abi> x, doublev<Abi> y);538template <class Abi> ldoublev<Abi> fmin(ldoublev<Abi> x, ldoublev<Abi> y);539 540template <class Abi> floatv<Abi> fma(floatv<Abi> x, floatv<Abi> y, floatv<Abi> z);541template <class Abi> doublev<Abi> fma(doublev<Abi> x, doublev<Abi> y, doublev<Abi> z);542template <class Abi> ldoublev<Abi> fma(ldoublev<Abi> x, ldoublev<Abi> y, ldoublev<Abi> z);543 544template <class Abi> samesize<int, floatv<Abi>> fpclassify(floatv<Abi> x);545template <class Abi> samesize<int, doublev<Abi>> fpclassify(doublev<Abi> x);546template <class Abi> samesize<int, ldoublev<Abi>> fpclassify(ldoublev<Abi> x);547 548template <class Abi> simd_mask<float, Abi> isfinite(floatv<Abi> x);549template <class Abi> simd_mask<double, Abi> isfinite(doublev<Abi> x);550template <class Abi> simd_mask<long double, Abi> isfinite(ldoublev<Abi> x);551 552template <class Abi> simd_mask<float, Abi> isinf(floatv<Abi> x);553template <class Abi> simd_mask<double, Abi> isinf(doublev<Abi> x);554template <class Abi> simd_mask<long double, Abi> isinf(ldoublev<Abi> x);555 556template <class Abi> simd_mask<float, Abi> isnan(floatv<Abi> x);557template <class Abi> simd_mask<double, Abi> isnan(doublev<Abi> x);558template <class Abi> simd_mask<long double, Abi> isnan(ldoublev<Abi> x);559 560template <class Abi> simd_mask<float, Abi> isnormal(floatv<Abi> x);561template <class Abi> simd_mask<double, Abi> isnormal(doublev<Abi> x);562template <class Abi> simd_mask<long double, Abi> isnormal(ldoublev<Abi> x);563 564template <class Abi> simd_mask<float, Abi> signbit(floatv<Abi> x);565template <class Abi> simd_mask<double, Abi> signbit(doublev<Abi> x);566template <class Abi> simd_mask<long double, Abi> signbit(ldoublev<Abi> x);567 568template <class Abi> simd_mask<float, Abi> isgreater(floatv<Abi> x, floatv<Abi> y);569template <class Abi> simd_mask<double, Abi> isgreater(doublev<Abi> x, doublev<Abi> y);570template <class Abi> simd_mask<long double, Abi> isgreater(ldoublev<Abi> x, ldoublev<Abi> y);571 572template <class Abi> simd_mask<float, Abi> isgreaterequal(floatv<Abi> x, floatv<Abi> y);573template <class Abi> simd_mask<double, Abi> isgreaterequal(doublev<Abi> x, doublev<Abi> y);574template <class Abi> simd_mask<long double, Abi> isgreaterequal(ldoublev<Abi> x, ldoublev<Abi> y);575 576template <class Abi> simd_mask<float, Abi> isless(floatv<Abi> x, floatv<Abi> y);577template <class Abi> simd_mask<double, Abi> isless(doublev<Abi> x, doublev<Abi> y);578template <class Abi> simd_mask<long double, Abi> isless(ldoublev<Abi> x, ldoublev<Abi> y);579 580template <class Abi> simd_mask<float, Abi> islessequal(floatv<Abi> x, floatv<Abi> y);581template <class Abi> simd_mask<double, Abi> islessequal(doublev<Abi> x, doublev<Abi> y);582template <class Abi> simd_mask<long double, Abi> islessequal(ldoublev<Abi> x, ldoublev<Abi> y);583 584template <class Abi> simd_mask<float, Abi> islessgreater(floatv<Abi> x, floatv<Abi> y);585template <class Abi> simd_mask<double, Abi> islessgreater(doublev<Abi> x, doublev<Abi> y);586template <class Abi> simd_mask<long double, Abi> islessgreater(ldoublev<Abi> x, ldoublev<Abi> y);587 588template <class Abi> simd_mask<float, Abi> isunordered(floatv<Abi> x, floatv<Abi> y);589template <class Abi> simd_mask<double, Abi> isunordered(doublev<Abi> x, doublev<Abi> y);590template <class Abi> simd_mask<long double, Abi> isunordered(ldoublev<Abi> x, ldoublev<Abi> y);591 592template <class V> struct simd_div_t { V quot, rem; };593template <class Abi> simd_div_t<scharv<Abi>> div(scharv<Abi> numer, scharv<Abi> denom);594template <class Abi> simd_div_t<shortv<Abi>> div(shortv<Abi> numer, shortv<Abi> denom);595template <class Abi> simd_div_t<intv<Abi>> div(intv<Abi> numer, intv<Abi> denom);596template <class Abi> simd_div_t<longv<Abi>> div(longv<Abi> numer, longv<Abi> denom);597template <class Abi> simd_div_t<llongv<Abi>> div(llongv<Abi> numer, llongv<Abi> denom);598 599// [simd.mask.class]600template <class T, class Abi>601class simd_mask {602public:603 using value_type = bool;604 using reference = see below;605 using simd_type = simd<T, Abi>;606 using abi_type = Abi;607 static constexpr size_t size() noexcept;608 simd_mask() = default;609 610 // broadcast constructor611 explicit simd_mask(value_type) noexcept;612 613 // implicit type conversion constructor614 template <class U> simd_mask(const simd_mask<U, simd_abi::fixed_size<size()>>&) noexcept;615 616 // load constructor617 template <class Flags> simd_mask(const value_type* mem, Flags);618 619 // loads [simd.mask.copy]620 template <class Flags> void copy_from(const value_type* mem, Flags);621 template <class Flags> void copy_to(value_type* mem, Flags) const;622 623 // scalar access [simd.mask.subscr]624 reference operator[](size_t);625 value_type operator[](size_t) const;626 627 // unary operators [simd.mask.unary]628 simd_mask operator!() const noexcept;629 630 // simd_mask binary operators [simd.mask.binary]631 friend simd_mask operator&&(const simd_mask&, const simd_mask&) noexcept;632 friend simd_mask operator||(const simd_mask&, const simd_mask&) noexcept;633 friend simd_mask operator& (const simd_mask&, const simd_mask&) noexcept;634 friend simd_mask operator| (const simd_mask&, const simd_mask&) noexcept;635 friend simd_mask operator^ (const simd_mask&, const simd_mask&) noexcept;636 637 // simd_mask compound assignment [simd.mask.cassign]638 friend simd_mask& operator&=(simd_mask&, const simd_mask&) noexcept;639 friend simd_mask& operator|=(simd_mask&, const simd_mask&) noexcept;640 friend simd_mask& operator^=(simd_mask&, const simd_mask&) noexcept;641 642 // simd_mask compares [simd.mask.comparison]643 friend simd_mask operator==(const simd_mask&, const simd_mask&) noexcept;644 friend simd_mask operator!=(const simd_mask&, const simd_mask&) noexcept;645};646 647} // parallelism_v2648} // std::experimental649 650*/651 652#include <experimental/__config>653#include <algorithm>654#include <array>655#include <cstddef>656#include <functional>657 658#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)659# pragma GCC system_header660#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)661# pragma clang system_header662#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)663# pragma system_header664#endif // no system header665 666_LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD667 668#if _LIBCUDACXX_STD_VER >= 17669 670enum class _StorageKind {671 _Scalar,672 _Array,673 _VecExt,674};675 676template <_StorageKind __kind, int _Np>677struct __simd_abi {};678 679template <class _Tp, class _Abi>680class __simd_storage {};681 682template <class _Tp, int __num_element>683class __simd_storage<_Tp, __simd_abi<_StorageKind::_Array, __num_element>> {684 std::array<_Tp, __num_element> __storage_;685 686 template <class, class>687 friend struct simd;688 689 template <class, class>690 friend struct simd_mask;691 692public:693 _Tp __get(size_t __index) const noexcept { return __storage_[__index]; };694 void __set(size_t __index, _Tp __val) noexcept {695 __storage_[__index] = __val;696 }697};698 699template <class _Tp>700class __simd_storage<_Tp, __simd_abi<_StorageKind::_Scalar, 1>> {701 _Tp __storage_;702 703 template <class, class>704 friend struct simd;705 706 template <class, class>707 friend struct simd_mask;708 709public:710 _Tp __get(size_t __index) const noexcept { return (&__storage_)[__index]; };711 void __set(size_t __index, _Tp __val) noexcept {712 (&__storage_)[__index] = __val;713 }714};715 716#ifndef _LIBCUDACXX_HAS_NO_VECTOR_EXTENSION717 718constexpr size_t __floor_pow_of_2(size_t __val) {719 return ((__val - 1) & __val) == 0 ? __val720 : __floor_pow_of_2((__val - 1) & __val);721}722 723constexpr size_t __ceil_pow_of_2(size_t __val) {724 return __val == 1 ? 1 : __floor_pow_of_2(__val - 1) << 1;725}726 727template <class _Tp, size_t __bytes>728struct __vec_ext_traits {729#if !defined(_LIBCUDACXX_COMPILER_CLANG)730 typedef _Tp type __attribute__((vector_size(__ceil_pow_of_2(__bytes))));731#endif732};733 734#if defined(_LIBCUDACXX_COMPILER_CLANG)735#define _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, _NUM_ELEMENT) \736 template <> \737 struct __vec_ext_traits<_TYPE, sizeof(_TYPE) * _NUM_ELEMENT> { \738 using type = \739 _TYPE __attribute__((vector_size(sizeof(_TYPE) * _NUM_ELEMENT))); \740 }741 742#define _LIBCUDACXX_SPECIALIZE_VEC_EXT_32(_TYPE) \743 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 1); \744 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 2); \745 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 3); \746 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 4); \747 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 5); \748 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 6); \749 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 7); \750 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 8); \751 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 9); \752 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 10); \753 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 11); \754 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 12); \755 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 13); \756 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 14); \757 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 15); \758 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 16); \759 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 17); \760 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 18); \761 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 19); \762 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 20); \763 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 21); \764 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 22); \765 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 23); \766 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 24); \767 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 25); \768 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 26); \769 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 27); \770 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 28); \771 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 29); \772 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 30); \773 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 31); \774 _LIBCUDACXX_SPECIALIZE_VEC_EXT(_TYPE, 32);775 776_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(char);777_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(char16_t);778_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(char32_t);779_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(wchar_t);780_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(signed char);781_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(signed short);782_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(signed int);783_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(signed long);784_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(signed long long);785_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(unsigned char);786_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(unsigned short);787_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(unsigned int);788_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(unsigned long);789_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(unsigned long long);790_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(float);791_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(double);792_LIBCUDACXX_SPECIALIZE_VEC_EXT_32(long double);793 794#undef _LIBCUDACXX_SPECIALIZE_VEC_EXT_32795#undef _LIBCUDACXX_SPECIALIZE_VEC_EXT796#endif797 798template <class _Tp, int __num_element>799class __simd_storage<_Tp, __simd_abi<_StorageKind::_VecExt, __num_element>> {800 using _StorageType =801 typename __vec_ext_traits<_Tp, sizeof(_Tp) * __num_element>::type;802 803 _StorageType __storage_;804 805 template <class, class>806 friend struct simd;807 808 template <class, class>809 friend struct simd_mask;810 811public:812 _Tp __get(size_t __index) const noexcept { return __storage_[__index]; };813 void __set(size_t __index, _Tp __val) noexcept {814 __storage_[__index] = __val;815 }816};817 818#endif // _LIBCUDACXX_HAS_NO_VECTOR_EXTENSION819 820template <class _Vp, class _Tp, class _Abi>821class __simd_reference {822 static_assert(std::is_same<_Vp, _Tp>::value, "");823 824 template <class, class>825 friend struct simd;826 827 template <class, class>828 friend struct simd_mask;829 830 __simd_storage<_Tp, _Abi>* __ptr_;831 size_t __index_;832 833 __simd_reference(__simd_storage<_Tp, _Abi>* __ptr, size_t __index)834 : __ptr_(__ptr), __index_(__index) {}835 836 __simd_reference(const __simd_reference&) = default;837 838public:839 __simd_reference() = delete;840 __simd_reference& operator=(const __simd_reference&) = delete;841 842 operator _Vp() const { return __ptr_->__get(__index_); }843 844 __simd_reference operator=(_Vp __value) && {845 __ptr_->__set(__index_, __value);846 return *this;847 }848 849 __simd_reference operator++() && {850 return std::move(*this) = __ptr_->__get(__index_) + 1;851 }852 853 _Vp operator++(int) && {854 auto __val = __ptr_->__get(__index_);855 __ptr_->__set(__index_, __val + 1);856 return __val;857 }858 859 __simd_reference operator--() && {860 return std::move(*this) = __ptr_->__get(__index_) - 1;861 }862 863 _Vp operator--(int) && {864 auto __val = __ptr_->__get(__index_);865 __ptr_->__set(__index_, __val - 1);866 return __val;867 }868 869 __simd_reference operator+=(_Vp __value) && {870 return std::move(*this) = __ptr_->__get(__index_) + __value;871 }872 873 __simd_reference operator-=(_Vp __value) && {874 return std::move(*this) = __ptr_->__get(__index_) - __value;875 }876 877 __simd_reference operator*=(_Vp __value) && {878 return std::move(*this) = __ptr_->__get(__index_) * __value;879 }880 881 __simd_reference operator/=(_Vp __value) && {882 return std::move(*this) = __ptr_->__get(__index_) / __value;883 }884 885 __simd_reference operator%=(_Vp __value) && {886 return std::move(*this) = __ptr_->__get(__index_) % __value;887 }888 889 __simd_reference operator>>=(_Vp __value) && {890 return std::move(*this) = __ptr_->__get(__index_) >> __value;891 }892 893 __simd_reference operator<<=(_Vp __value) && {894 return std::move(*this) = __ptr_->__get(__index_) << __value;895 }896 897 __simd_reference operator&=(_Vp __value) && {898 return std::move(*this) = __ptr_->__get(__index_) & __value;899 }900 901 __simd_reference operator|=(_Vp __value) && {902 return std::move(*this) = __ptr_->__get(__index_) | __value;903 }904 905 __simd_reference operator^=(_Vp __value) && {906 return std::move(*this) = __ptr_->__get(__index_) ^ __value;907 }908};909 910template <class _To, class _From>911constexpr decltype(_To{std::declval<_From>()}, true)912__is_non_narrowing_convertible_impl(_From) {913 return true;914}915 916template <class _To>917constexpr bool __is_non_narrowing_convertible_impl(...) {918 return false;919}920 921template <class _From, class _To>922constexpr typename std::enable_if<std::is_arithmetic<_To>::value &&923 std::is_arithmetic<_From>::value,924 bool>::type925__is_non_narrowing_arithmetic_convertible() {926 return __is_non_narrowing_convertible_impl<_To>(_From{});927}928 929template <class _From, class _To>930constexpr typename std::enable_if<!(std::is_arithmetic<_To>::value &&931 std::is_arithmetic<_From>::value),932 bool>::type933__is_non_narrowing_arithmetic_convertible() {934 return false;935}936 937template <class _Tp>938constexpr _Tp __variadic_sum() {939 return _Tp{};940}941 942template <class _Tp, class _Up, class... _Args>943constexpr _Tp __variadic_sum(_Up __first, _Args... __rest) {944 return static_cast<_Tp>(__first) + __variadic_sum<_Tp>(__rest...);945}946 947template <class _Tp>948struct __nodeduce {949 using type = _Tp;950};951 952template <class _Tp>953constexpr bool __vectorizable() {954 return std::is_arithmetic<_Tp>::value && !std::is_const<_Tp>::value &&955 !std::is_volatile<_Tp>::value && !std::is_same<_Tp, bool>::value;956}957 958_LIBCUDACXX_END_NAMESPACE_EXPERIMENTAL_SIMD959_LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD_ABI960 961using scalar = __simd_abi<_StorageKind::_Scalar, 1>;962 963template <int _Np>964using fixed_size = __simd_abi<_StorageKind::_Array, _Np>;965 966template <class _Tp>967_LIBCUDACXX_INLINE_VAR constexpr size_t max_fixed_size = 32;968 969template <class _Tp>970using compatible = fixed_size<16 / sizeof(_Tp)>;971 972#ifndef _LIBCUDACXX_HAS_NO_VECTOR_EXTENSION973template <class _Tp>974using native = __simd_abi<_StorageKind::_VecExt,975 _LIBCUDACXX_NATIVE_SIMD_WIDTH_IN_BYTES / sizeof(_Tp)>;976#else977template <class _Tp>978using native =979 fixed_size<_Tp, _LIBCUDACXX_NATIVE_SIMD_WIDTH_IN_BYTES / sizeof(_Tp)>;980#endif // _LIBCUDACXX_HAS_NO_VECTOR_EXTENSION981 982_LIBCUDACXX_END_NAMESPACE_EXPERIMENTAL_SIMD_ABI983_LIBCUDACXX_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD984 985template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>986class simd;987template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>988class simd_mask;989 990struct element_aligned_tag {};991struct vector_aligned_tag {};992template <size_t>993struct overaligned_tag {};994_LIBCUDACXX_INLINE_VAR constexpr element_aligned_tag element_aligned{};995_LIBCUDACXX_INLINE_VAR constexpr vector_aligned_tag vector_aligned{};996template <size_t _Np>997_LIBCUDACXX_INLINE_VAR constexpr overaligned_tag<_Np> overaligned{};998 999// traits [simd.traits]1000template <class _Tp>1001struct is_abi_tag : std::integral_constant<bool, false> {};1002 1003template <_StorageKind __kind, int _Np>1004struct is_abi_tag<__simd_abi<__kind, _Np>>1005 : std::integral_constant<bool, true> {};1006 1007template <class _Tp>1008struct is_simd : std::integral_constant<bool, false> {};1009 1010template <class _Tp, class _Abi>1011struct is_simd<simd<_Tp, _Abi>> : std::integral_constant<bool, true> {};1012 1013template <class _Tp>1014struct is_simd_mask : std::integral_constant<bool, false> {};1015 1016template <class _Tp, class _Abi>1017struct is_simd_mask<simd_mask<_Tp, _Abi>> : std::integral_constant<bool, true> {1018};1019 1020template <class _Tp>1021struct is_simd_flag_type : std::integral_constant<bool, false> {};1022 1023template <>1024struct is_simd_flag_type<element_aligned_tag>1025 : std::integral_constant<bool, true> {};1026 1027template <>1028struct is_simd_flag_type<vector_aligned_tag>1029 : std::integral_constant<bool, true> {};1030 1031template <size_t _Align>1032struct is_simd_flag_type<overaligned_tag<_Align>>1033 : std::integral_constant<bool, true> {};1034 1035template <class _Tp>1036_LIBCUDACXX_INLINE_VAR constexpr bool is_abi_tag_v = is_abi_tag<_Tp>::value;1037template <class _Tp>1038_LIBCUDACXX_INLINE_VAR constexpr bool is_simd_v = is_simd<_Tp>::value;1039template <class _Tp>1040_LIBCUDACXX_INLINE_VAR constexpr bool is_simd_mask_v = is_simd_mask<_Tp>::value;1041template <class _Tp>1042_LIBCUDACXX_INLINE_VAR constexpr bool is_simd_flag_type_v =1043 is_simd_flag_type<_Tp>::value;1044template <class _Tp, size_t _Np>1045struct abi_for_size {1046 using type = simd_abi::fixed_size<_Np>;1047};1048template <class _Tp, size_t _Np>1049using abi_for_size_t = typename abi_for_size<_Tp, _Np>::type;1050 1051template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>1052struct simd_size;1053 1054template <class _Tp, _StorageKind __kind, int _Np>1055struct simd_size<_Tp, __simd_abi<__kind, _Np>>1056 : std::integral_constant<size_t, _Np> {1057 static_assert(1058 std::is_arithmetic<_Tp>::value &&1059 !std::is_same<typename std::remove_const<_Tp>::type, bool>::value,1060 "Element type should be vectorizable");1061};1062 1063// TODO: implement it.1064template <class _Tp, class _Up = typename _Tp::value_type>1065struct memory_alignment;1066 1067template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>1068_LIBCUDACXX_INLINE_VAR constexpr size_t simd_size_v = simd_size<_Tp, _Abi>::value;1069 1070template <class _Tp, class _Up = typename _Tp::value_type>1071_LIBCUDACXX_INLINE_VAR constexpr size_t memory_alignment_v =1072 memory_alignment<_Tp, _Up>::value;1073 1074// class template simd [simd.class]1075template <class _Tp>1076using native_simd = simd<_Tp, simd_abi::native<_Tp>>;1077template <class _Tp, int _Np>1078using fixed_size_simd = simd<_Tp, simd_abi::fixed_size<_Np>>;1079 1080// class template simd_mask [simd.mask.class]1081template <class _Tp>1082using native_simd_mask = simd_mask<_Tp, simd_abi::native<_Tp>>;1083 1084template <class _Tp, int _Np>1085using fixed_size_simd_mask = simd_mask<_Tp, simd_abi::fixed_size<_Np>>;1086 1087// casts [simd.casts]1088template <class _Tp>1089struct __static_simd_cast_traits {1090 template <class _Up, class _Abi>1091 static simd<_Tp, _Abi> __apply(const simd<_Up, _Abi>& __v);1092};1093 1094template <class _Tp, class _NewAbi>1095struct __static_simd_cast_traits<simd<_Tp, _NewAbi>> {1096 template <class _Up, class _Abi>1097 static typename std::enable_if<simd<_Up, _Abi>::size() ==1098 simd<_Tp, _NewAbi>::size(),1099 simd<_Tp, _NewAbi>>::type1100 __apply(const simd<_Up, _Abi>& __v);1101};1102 1103template <class _Tp>1104struct __simd_cast_traits {1105 template <class _Up, class _Abi>1106 static typename std::enable_if<1107 __is_non_narrowing_arithmetic_convertible<_Up, _Tp>(),1108 simd<_Tp, _Abi>>::type1109 __apply(const simd<_Up, _Abi>& __v);1110};1111 1112template <class _Tp, class _NewAbi>1113struct __simd_cast_traits<simd<_Tp, _NewAbi>> {1114 template <class _Up, class _Abi>1115 static typename std::enable_if<1116 __is_non_narrowing_arithmetic_convertible<_Up, _Tp>() &&1117 simd<_Up, _Abi>::size() == simd<_Tp, _NewAbi>::size(),1118 simd<_Tp, _NewAbi>>::type1119 __apply(const simd<_Up, _Abi>& __v);1120};1121 1122template <class _Tp, class _Up, class _Abi>1123auto simd_cast(const simd<_Up, _Abi>& __v)1124 -> decltype(__simd_cast_traits<_Tp>::__apply(__v)) {1125 return __simd_cast_traits<_Tp>::__apply(__v);1126}1127 1128template <class _Tp, class _Up, class _Abi>1129auto static_simd_cast(const simd<_Up, _Abi>& __v)1130 -> decltype(__static_simd_cast_traits<_Tp>::__apply(__v)) {1131 return __static_simd_cast_traits<_Tp>::__apply(__v);1132}1133 1134template <class _Tp, class _Abi>1135fixed_size_simd<_Tp, simd_size<_Tp, _Abi>::value>1136to_fixed_size(const simd<_Tp, _Abi>&) noexcept;1137 1138template <class _Tp, class _Abi>1139fixed_size_simd_mask<_Tp, simd_size<_Tp, _Abi>::value>1140to_fixed_size(const simd_mask<_Tp, _Abi>&) noexcept;1141 1142template <class _Tp, size_t _Np>1143native_simd<_Tp> to_native(const fixed_size_simd<_Tp, _Np>&) noexcept;1144 1145template <class _Tp, size_t _Np>1146native_simd_mask<_Tp> to_native(const fixed_size_simd_mask<_Tp, _Np>&) noexcept;1147 1148template <class _Tp, size_t _Np>1149simd<_Tp> to_compatible(const fixed_size_simd<_Tp, _Np>&) noexcept;1150 1151template <class _Tp, size_t _Np>1152simd_mask<_Tp> to_compatible(const fixed_size_simd_mask<_Tp, _Np>&) noexcept;1153 1154template <size_t... __sizes, class _Tp, class _Abi>1155tuple<simd<_Tp, abi_for_size_t<_Tp, __sizes>>...> split(const simd<_Tp, _Abi>&);1156 1157template <size_t... __sizes, class _Tp, class _Abi>1158tuple<simd_mask<_Tp, abi_for_size_t<_Tp, __sizes>>...>1159split(const simd_mask<_Tp, _Abi>&);1160 1161template <class _SimdType, class _Abi>1162array<_SimdType, simd_size<typename _SimdType::value_type, _Abi>::value /1163 _SimdType::size()>1164split(const simd<typename _SimdType::value_type, _Abi>&);1165 1166template <class _SimdType, class _Abi>1167array<_SimdType, simd_size<typename _SimdType::value_type, _Abi>::value /1168 _SimdType::size()>1169split(const simd_mask<typename _SimdType::value_type, _Abi>&);1170 1171template <class _Tp, class... _Abis>1172simd<_Tp, abi_for_size_t<_Tp, __variadic_sum(simd_size<_Tp, _Abis>::value...)>>1173concat(const simd<_Tp, _Abis>&...);1174 1175template <class _Tp, class... _Abis>1176simd_mask<_Tp,1177 abi_for_size_t<_Tp, __variadic_sum(simd_size<_Tp, _Abis>::value...)>>1178concat(const simd_mask<_Tp, _Abis>&...);1179 1180// reductions [simd.mask.reductions]1181template <class _Tp, class _Abi>1182bool all_of(const simd_mask<_Tp, _Abi>&) noexcept;1183template <class _Tp, class _Abi>1184bool any_of(const simd_mask<_Tp, _Abi>&) noexcept;1185template <class _Tp, class _Abi>1186bool none_of(const simd_mask<_Tp, _Abi>&) noexcept;1187template <class _Tp, class _Abi>1188bool some_of(const simd_mask<_Tp, _Abi>&) noexcept;1189template <class _Tp, class _Abi>1190int popcount(const simd_mask<_Tp, _Abi>&) noexcept;1191template <class _Tp, class _Abi>1192int find_first_set(const simd_mask<_Tp, _Abi>&);1193template <class _Tp, class _Abi>1194int find_last_set(const simd_mask<_Tp, _Abi>&);1195bool all_of(bool) noexcept;1196bool any_of(bool) noexcept;1197bool none_of(bool) noexcept;1198bool some_of(bool) noexcept;1199int popcount(bool) noexcept;1200int find_first_set(bool) noexcept;