timshen updated this revision to Diff 128706.
timshen added a comment.
Add tests to boolean version of the horizontal operations.
https://reviews.llvm.org/D41756
Files:
libcxx/include/experimental/simd
libcxx/test/std/experimental/simd/simd.casts/to_compatible.pass.cpp
libcxx/test/std/experimental/simd/simd.casts/to_fixed_size.pass.cpp
libcxx/test/std/experimental/simd/simd.casts/to_native.pass.cpp
libcxx/test/std/experimental/simd/simd.horizontal/concat.pass.cpp
libcxx/test/std/experimental/simd/simd.horizontal/mask.pass.cpp
libcxx/test/std/experimental/simd/simd.horizontal/split.pass.cpp
Index: libcxx/test/std/experimental/simd/simd.horizontal/split.pass.cpp
===================================================================
--- libcxx/test/std/experimental/simd/simd.horizontal/split.pass.cpp
+++ libcxx/test/std/experimental/simd/simd.horizontal/split.pass.cpp
@@ -39,7 +39,7 @@
using namespace std::experimental::parallelism_v2;
-void test_split() {
+void test_split_simd() {
auto t = split<1, 2, 3>(fixed_size_simd<int, 6>([](int i) { return i; }));
static_assert(std::tuple_size<decltype(t)>::value == 3, "");
@@ -56,7 +56,24 @@
assert(std::get<2>(t)[2] == 5);
}
-void test_split_array() {
+void test_split_mask() {
+ auto t = split<1, 2, 3>(fixed_size_simd_mask<int, 6>(true));
+ static_assert(std::tuple_size<decltype(t)>::value == 3, "");
+
+ assert(std::get<0>(t).size() == 1);
+ assert(std::get<0>(t)[0]);
+
+ assert(std::get<1>(t).size() == 2);
+ assert(std::get<1>(t)[0]);
+ assert(std::get<1>(t)[1]);
+
+ assert(std::get<2>(t).size() == 3);
+ assert(std::get<2>(t)[0]);
+ assert(std::get<2>(t)[1]);
+ assert(std::get<2>(t)[2]);
+}
+
+void test_split_array_simd() {
{
auto arr = split_by<2>(fixed_size_simd<int, 6>([](int i) { return i; }));
static_assert(arr.size() == 2, "");
@@ -88,7 +105,38 @@
}
}
-void compile_split_propagate_abi() {
+void test_split_array_mask() {
+ {
+ auto arr = split_by<2>(fixed_size_simd_mask<int, 6>(true));
+ static_assert(arr.size() == 2, "");
+
+ assert(arr[0].size() == 3);
+ assert(arr[0][0]);
+ assert(arr[0][1]);
+ assert(arr[0][2]);
+
+ assert(arr[1].size() == 3);
+ assert(arr[1][0]);
+ assert(arr[1][1]);
+ assert(arr[1][2]);
+ }
+ {
+ auto arr = split<fixed_size_simd<int, 3>>(fixed_size_simd<int, 6>(true));
+ static_assert(arr.size() == 2, "");
+
+ assert(arr[0].size() == 3);
+ assert(arr[0][0]);
+ assert(arr[0][1]);
+ assert(arr[0][2]);
+
+ assert(arr[1].size() == 3);
+ assert(arr[1][0]);
+ assert(arr[1][1]);
+ assert(arr[1][2]);
+ }
+}
+
+void compile_split_simd_propagate_abi() {
using compatible_simd_half =
simd<int,
rebind_abi_t<int, simd<int>::size() / 2, simd_abi::compatible<int>>>;
@@ -119,7 +167,41 @@
"");
}
+void compile_split_simd_mask_propagate_abi() {
+ using compatible_simd_mask_half =
+ simd_mask<int, rebind_abi_t<int, simd_mask<int>::size() / 2,
+ simd_abi::compatible<int>>>;
+ using native_simd_mask_half =
+ simd_mask<int, rebind_abi_t<int, native_simd_mask<int>::size() / 2,
+ simd_abi::native<int>>>;
+
+ static_assert(std::is_same<decltype(split<simd_mask<int>::size() / 2,
+ simd_mask<int>::size() / 2>(
+ simd_mask<int>())),
+ std::tuple<compatible_simd_mask_half,
+ compatible_simd_mask_half>>::value,
+ "");
+
+ static_assert(
+ std::is_same<
+ decltype(split<native_simd_mask<int>::size() / 2,
+ native_simd_mask<int>::size() / 2>(
+ native_simd_mask<int>())),
+ std::tuple<native_simd_mask_half, native_simd_mask_half>>::value,
+ "");
+
+ static_assert(std::is_same<decltype(split_by<2>(simd_mask<int>())),
+ std::array<compatible_simd_mask_half, 2>>::value,
+ "");
+
+ static_assert(std::is_same<decltype(split_by<2>(native_simd_mask<int>())),
+ std::array<native_simd_mask_half, 2>>::value,
+ "");
+}
+
int main() {
- test_split();
- test_split_array();
+ test_split_simd();
+ test_split_mask();
+ test_split_array_simd();
+ test_split_array_mask();
}
Index: libcxx/test/std/experimental/simd/simd.horizontal/mask.pass.cpp
===================================================================
--- /dev/null
+++ libcxx/test/std/experimental/simd/simd.horizontal/mask.pass.cpp
@@ -0,0 +1,189 @@
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/simd>
+//
+// // reductions [simd.mask.reductions]
+// template <class T, class Abi> bool all_of(const simd_mask<T, Abi>&) noexcept;
+// template <class T, class Abi> bool any_of(const simd_mask<T, Abi>&) noexcept;
+// template <class T, class Abi> bool none_of(const simd_mask<T, Abi>&) noexcept;
+// template <class T, class Abi> bool some_of(const simd_mask<T, Abi>&) noexcept;
+// template <class T, class Abi> int popcount(const simd_mask<T, Abi>&) noexcept;
+// template <class T, class Abi> int find_first_set(const simd_mask<T, Abi>&);
+// template <class T, class Abi> int find_last_set(const simd_mask<T, Abi>&);
+//
+// bool all_of(see below ) noexcept;
+// bool any_of(see below ) noexcept;
+// bool none_of(see below ) noexcept;
+// bool some_of(see below ) noexcept;
+// int popcount(see below ) noexcept;
+// int find_first_set(see below ) noexcept;
+// int find_last_set(see below ) noexcept;
+
+#include <cassert>
+#include <cstdint>
+#include <experimental/simd>
+
+using namespace std::experimental::parallelism_v2;
+
+void test_all_of() {
+ {
+ bool expected[] = {false, false};
+ assert(
+ !all_of(fixed_size_simd_mask<int, 2>(expected, element_aligned_tag())));
+ }
+ {
+ bool expected[] = {true, false};
+ assert(
+ !all_of(fixed_size_simd_mask<int, 2>(expected, element_aligned_tag())));
+ }
+ {
+ bool expected[] = {true, true};
+ assert(
+ all_of(fixed_size_simd_mask<int, 2>(expected, element_aligned_tag())));
+ }
+}
+
+void test_any_of() {
+ {
+ bool expected[] = {false, false};
+ assert(
+ !any_of(fixed_size_simd_mask<int, 2>(expected, element_aligned_tag())));
+ }
+ {
+ bool expected[] = {true, false};
+ assert(
+ any_of(fixed_size_simd_mask<int, 2>(expected, element_aligned_tag())));
+ }
+ {
+ bool expected[] = {true, true};
+ assert(
+ any_of(fixed_size_simd_mask<int, 2>(expected, element_aligned_tag())));
+ }
+}
+
+void test_none_of() {
+ {
+ bool expected[] = {false, false};
+ assert(
+ none_of(fixed_size_simd_mask<int, 2>(expected, element_aligned_tag())));
+ }
+ {
+ bool expected[] = {true, false};
+ assert(!none_of(
+ fixed_size_simd_mask<int, 2>(expected, element_aligned_tag())));
+ }
+ {
+ bool expected[] = {true, true};
+ assert(!none_of(
+ fixed_size_simd_mask<int, 2>(expected, element_aligned_tag())));
+ }
+}
+
+void test_some_of() {
+ {
+ bool expected[] = {false, false};
+ assert(!some_of(
+ fixed_size_simd_mask<int, 2>(expected, element_aligned_tag())));
+ }
+ {
+ bool expected[] = {true, false};
+ assert(
+ some_of(fixed_size_simd_mask<int, 2>(expected, element_aligned_tag())));
+ }
+ {
+ bool expected[] = {true, true};
+ assert(!some_of(
+ fixed_size_simd_mask<int, 2>(expected, element_aligned_tag())));
+ }
+}
+
+void test_popcount() {
+ {
+ bool expected[] = {false, false};
+ assert(popcount(fixed_size_simd_mask<int, 2>(expected,
+ element_aligned_tag())) == 0);
+ }
+ {
+ bool expected[] = {true, false};
+ assert(popcount(fixed_size_simd_mask<int, 2>(expected,
+ element_aligned_tag())) == 1);
+ }
+ {
+ bool expected[] = {true, true};
+ assert(popcount(fixed_size_simd_mask<int, 2>(expected,
+ element_aligned_tag())) == 2);
+ }
+}
+
+void test_find_first_set() {
+ {
+ bool expected[] = {false, true, true};
+ assert(find_first_set(fixed_size_simd_mask<int, 3>(
+ expected, element_aligned_tag())) == 1);
+ }
+ {
+ bool expected[] = {true, false, true};
+ assert(find_first_set(fixed_size_simd_mask<int, 3>(
+ expected, element_aligned_tag())) == 0);
+ }
+ {
+ bool expected[] = {true, true, false};
+ assert(find_first_set(fixed_size_simd_mask<int, 3>(
+ expected, element_aligned_tag())) == 0);
+ }
+}
+
+void test_find_last_set() {
+ {
+ bool expected[] = {false, true, true};
+ assert(find_last_set(fixed_size_simd_mask<int, 3>(
+ expected, element_aligned_tag())) == 2);
+ }
+ {
+ bool expected[] = {true, false, true};
+ assert(find_last_set(fixed_size_simd_mask<int, 3>(
+ expected, element_aligned_tag())) == 2);
+ }
+ {
+ bool expected[] = {true, true, false};
+ assert(find_last_set(fixed_size_simd_mask<int, 3>(
+ expected, element_aligned_tag())) == 1);
+ }
+}
+
+void test_bool_functions() {
+ assert(all_of(true));
+ assert(!all_of(false));
+ assert(any_of(true));
+ assert(!any_of(false));
+ assert(!none_of(true));
+ assert(none_of(false));
+ assert(!some_of(true));
+ assert(!some_of(false));
+ assert(popcount(true) == 1);
+ assert(popcount(false) == 0);
+ assert(find_first_set(true) == 0);
+ assert(find_first_set(false) == 0);
+ assert(find_last_set(true) == 0);
+ assert(find_last_set(false) == 0);
+}
+
+int main() {
+ test_all_of();
+ test_any_of();
+ test_none_of();
+ test_some_of();
+ test_popcount();
+ test_find_first_set();
+ test_find_last_set();
+ test_bool_functions();
+}
Index: libcxx/test/std/experimental/simd/simd.horizontal/concat.pass.cpp
===================================================================
--- libcxx/test/std/experimental/simd/simd.horizontal/concat.pass.cpp
+++ libcxx/test/std/experimental/simd/simd.horizontal/concat.pass.cpp
@@ -33,7 +33,7 @@
using namespace std::experimental::parallelism_v2;
-void test_concat() {
+void test_concat_simd() {
auto v = concat(fixed_size_simd<int, 1>([](int i) { return i; }),
fixed_size_simd<int, 2>([](int i) { return i + 1; }),
fixed_size_simd<int, 3>([](int i) { return i + 3; }));
@@ -46,7 +46,20 @@
assert(v[5] == 5);
}
-void test_concat_array() {
+void test_concat_mask() {
+ auto v = concat(fixed_size_simd_mask<int, 1>(true),
+ fixed_size_simd_mask<int, 2>(true),
+ fixed_size_simd_mask<int, 3>(true));
+ static_assert(v.size() == 6, "");
+ assert(v[0]);
+ assert(v[1]);
+ assert(v[2]);
+ assert(v[3]);
+ assert(v[4]);
+ assert(v[5]);
+}
+
+void test_concat_array_simd() {
std::array<fixed_size_simd<int, 2>, 2> arr;
arr[0] = fixed_size_simd<int, 2>([](int) { return 0; });
arr[1] = fixed_size_simd<int, 2>([](int) { return 1; });
@@ -59,6 +72,19 @@
assert(v[3] == 1);
}
+void test_concat_array_mask() {
+ std::array<fixed_size_simd_mask<int, 2>, 2> arr;
+ arr[0] = fixed_size_simd_mask<int, 2>(true);
+ arr[1] = fixed_size_simd_mask<int, 2>(true);
+
+ auto v = concat(arr);
+ static_assert(v.size() == 4, "");
+ assert(v[0]);
+ assert(v[1]);
+ assert(v[2]);
+ assert(v[3]);
+}
+
void compile_split_propagate_abi() {
static_assert(std::is_same<typename decltype(
concat(simd<int>(), simd<int>()))::abi_type,
@@ -75,6 +101,8 @@
}
int main() {
- test_concat();
- test_concat_array();
+ test_concat_simd();
+ test_concat_mask();
+ test_concat_array_simd();
+ test_concat_array_mask();
}
Index: libcxx/test/std/experimental/simd/simd.casts/to_native.pass.cpp
===================================================================
--- libcxx/test/std/experimental/simd/simd.casts/to_native.pass.cpp
+++ libcxx/test/std/experimental/simd/simd.casts/to_native.pass.cpp
@@ -25,27 +25,47 @@
using namespace std::experimental::parallelism_v2;
void test_to_native() {
- auto v = to_native(
- fixed_size_simd<int, native_simd<int>::size()>([](int i) { return i; }));
- native_simd<int> w([](int i) { return i; });
+ {
+ auto v = to_native(fixed_size_simd<int, native_simd<int>::size()>(
+ [](int i) { return i; }));
+ native_simd<int> w([](int i) { return i; });
- static_assert(std::is_same<decltype(v), decltype(w)>::value, "");
+ static_assert(std::is_same<decltype(v), decltype(w)>::value, "");
- for (size_t i = 0; i < v.size(); i++) {
- assert(v[i] == w[i]);
+ for (size_t i = 0; i < v.size(); i++) {
+ assert(v[i] == w[i]);
+ }
+ }
+ {
+ auto v = to_native(
+ fixed_size_simd_mask<int, native_simd_mask<int>::size()>(true));
+ static_assert(std::is_same<native_simd_mask<int>, decltype(v)>::value, "");
+ assert(all_of(v));
}
}
void test_to_native_extension() {
- auto arr = split_by<32 / native_simd<int>::size()>(
- to_native(fixed_size_simd<int, 32>([](int i) { return i; })));
- static_assert(
- std::is_same<decltype(arr)::value_type, native_simd<int>>::value, "");
- int v = 0;
- for (size_t i = 0; i < arr.size(); i++) {
- for (size_t j = 0; j < arr[0].size(); j++) {
- assert(arr[i][j] == v);
- v++;
+ {
+ std::array<native_simd<int>, 2> arr = split_by<2>(
+ to_native(fixed_size_simd<int, native_simd<int>::size() * 2>(
+ [](int i) { return i; })));
+ static_assert(
+ std::is_same<decltype(arr)::value_type, native_simd<int>>::value, "");
+ int v = 0;
+ for (size_t i = 0; i < arr.size(); i++) {
+ for (size_t j = 0; j < arr[0].size(); j++) {
+ assert(arr[i][j] == v);
+ v++;
+ }
+ }
+ }
+ {
+ std::array<native_simd_mask<int>, 2> arr = split_by<2>(to_native(
+ fixed_size_simd_mask<int, native_simd_mask<int>::size() * 2>(true)));
+ for (size_t i = 0; i < arr.size(); i++) {
+ for (size_t j = 0; j < arr[0].size(); j++) {
+ assert(arr[i][j]);
+ }
}
}
}
Index: libcxx/test/std/experimental/simd/simd.casts/to_fixed_size.pass.cpp
===================================================================
--- libcxx/test/std/experimental/simd/simd.casts/to_fixed_size.pass.cpp
+++ libcxx/test/std/experimental/simd/simd.casts/to_fixed_size.pass.cpp
@@ -27,13 +27,23 @@
using namespace std::experimental::parallelism_v2;
void test_to_fixed_size() {
- auto v = to_fixed_size(native_simd<int>([](int i) { return i; }));
- static_assert(std::is_same<fixed_size_simd<int, native_simd<int>::size()>,
- decltype(v)>::value,
- "");
+ {
+ auto v = to_fixed_size(native_simd<int>([](int i) { return i; }));
+ static_assert(std::is_same<fixed_size_simd<int, native_simd<int>::size()>,
+ decltype(v)>::value,
+ "");
- for (size_t i = 0; i < v.size(); i++) {
- assert(v[i] == (int)i);
+ for (size_t i = 0; i < v.size(); i++) {
+ assert(v[i] == (int)i);
+ }
+ }
+ {
+ auto v = to_fixed_size(native_simd_mask<int>(true));
+ static_assert(
+ std::is_same<fixed_size_simd_mask<int, native_simd_mask<int>::size()>,
+ decltype(v)>::value,
+ "");
+ assert(all_of(v));
}
}
Index: libcxx/test/std/experimental/simd/simd.casts/to_compatible.pass.cpp
===================================================================
--- libcxx/test/std/experimental/simd/simd.casts/to_compatible.pass.cpp
+++ libcxx/test/std/experimental/simd/simd.casts/to_compatible.pass.cpp
@@ -25,26 +25,47 @@
using namespace std::experimental::parallelism_v2;
void test_to_compatible() {
- auto v = to_compatible(
- fixed_size_simd<int, simd<int>::size()>([](int i) { return i; }));
- simd<int> w([](int i) { return i; });
+ {
+ auto v = to_compatible(
+ fixed_size_simd<int, simd<int>::size()>([](int i) { return i; }));
+ simd<int> w([](int i) { return i; });
- static_assert(std::is_same<decltype(v), decltype(w)>::value, "");
+ static_assert(std::is_same<decltype(v), decltype(w)>::value, "");
- for (size_t i = 0; i < v.size(); i++) {
- assert(v[i] == w[i]);
+ for (size_t i = 0; i < v.size(); i++) {
+ assert(v[i] == w[i]);
+ }
+ }
+
+ {
+ auto v =
+ to_compatible(fixed_size_simd_mask<int, simd_mask<int>::size()>(true));
+ static_assert(std::is_same<simd_mask<int>, decltype(v)>::value, "");
+ assert(all_of(v));
}
}
void test_to_compatible_extension() {
- auto arr = split_by<32 / simd<int>::size()>(
- to_compatible(fixed_size_simd<int, 32>([](int i) { return i; })));
- static_assert(std::is_same<decltype(arr)::value_type, simd<int>>::value, "");
- int v = 0;
- for (size_t i = 0; i < arr.size(); i++) {
- for (size_t j = 0; j < arr[0].size(); j++) {
- assert(arr[i][j] == v);
- v++;
+ {
+ std::array<simd<int>, 2> arr = split_by<2>(to_compatible(
+ fixed_size_simd<int, simd<int>::size() * 2>([](int i) { return i; })));
+ static_assert(std::is_same<decltype(arr)::value_type, simd<int>>::value,
+ "");
+ int v = 0;
+ for (size_t i = 0; i < arr.size(); i++) {
+ for (size_t j = 0; j < arr[0].size(); j++) {
+ assert(arr[i][j] == v);
+ v++;
+ }
+ }
+ }
+ {
+ std::array<simd_mask<int>, 2> arr = split_by<2>(to_compatible(
+ fixed_size_simd_mask<int, simd_mask<int>::size() * 2>(true)));
+ for (size_t i = 0; i < arr.size(); i++) {
+ for (size_t j = 0; j < arr[0].size(); j++) {
+ assert(arr[i][j]);
+ }
}
}
}
Index: libcxx/include/experimental/simd
===================================================================
--- libcxx/include/experimental/simd
+++ libcxx/include/experimental/simd
@@ -1131,37 +1131,27 @@
return simd_cast<fixed_size_simd<_Tp, simd_size<_Tp, _Abi>::value>>(__v);
}
-template <class _Tp, class _Abi>
-fixed_size_simd_mask<_Tp, simd_size<_Tp, _Abi>::value>
-to_fixed_size(const simd_mask<_Tp, _Abi>&) noexcept;
-
// NOTE: As an extension, allow transforming to a native type with a size
// that's not native_simd<T>::size().
template <class _Tp, size_t _Np>
simd<_Tp, simd_abi::__native<_Tp, _Np>>
to_native(const fixed_size_simd<_Tp, _Np>& __v) noexcept {
return simd_cast<simd<_Tp, simd_abi::__native<_Tp, _Np>>>(__v);
}
-template <class _Tp, size_t _Np>
-native_simd_mask<_Tp> to_native(const fixed_size_simd_mask<_Tp, _Np>&) noexcept;
-
// NOTE: As an extension, allow transforming to a compatible type with a size
// that's not simd<T>::size().
template <class _Tp, size_t _Np>
simd<_Tp, simd_abi::__compatible<_Tp, _Np>>
to_compatible(const fixed_size_simd<_Tp, _Np>& __v) noexcept {
return simd_cast<simd<_Tp, simd_abi::__compatible<_Tp, _Np>>>(__v);
}
-template <class _Tp, size_t _Np>
-simd_mask<_Tp> to_compatible(const fixed_size_simd_mask<_Tp, _Np>&) noexcept;
-
-template <class _TupleType, class _Tp, size_t... __indicies>
+template <class _TupleType, class _Tp, size_t... __indices>
_TupleType __split_tuple_impl(_Tp** __buffers,
- std::index_sequence<__indicies...>) {
- return _TupleType(typename std::tuple_element<__indicies, _TupleType>::type(
- __buffers[__indicies], element_aligned_tag())...);
+ std::index_sequence<__indices...>) {
+ return _TupleType(typename std::tuple_element<__indices, _TupleType>::type(
+ __buffers[__indices], element_aligned_tag())...);
}
template <size_t... __sizes, class _Tp, class _Abi>
@@ -1187,10 +1177,6 @@
__buffers, std::make_index_sequence<sizeof...(__sizes)>());
}
-template <size_t... __sizes, class _Tp, class _Abi>
-tuple<simd_mask<_Tp, rebind_abi_t<_Tp, __sizes, _Abi>>...>
-split(const simd_mask<_Tp, _Abi>&);
-
// NOTE: P0820 extension
template <size_t __array_size, class _Tp, class _Abi>
typename std::enable_if<
@@ -1223,23 +1209,11 @@
_SimdType::size()>(__v);
}
-template <size_t __array_size, class _Tp, class _Abi>
-array<
- simd_mask<_Tp, rebind_abi_t<_Tp, simd_size<_Tp, _Abi>::value / __array_size,
- _Abi>>,
- __array_size>
-split_by(const simd_mask<_Tp, _Abi>& x);
-
-template <class _SimdType, class _Abi>
-array<_SimdType, simd_size<typename _SimdType::value_type, _Abi>::value /
- _SimdType::size()>
-split(const simd_mask<typename _SimdType::value_type, _Abi>&);
-
-template <class _TupleType, class _Tp, size_t... __indicies>
+template <class _TupleType, class _Tp, size_t... __indices>
void __concat_tuple_impl(_TupleType __vs, _Tp** __buffers,
- std::index_sequence<__indicies...>) {
- int __unused[] = {(std::get<__indicies>(__vs).copy_to(__buffers[__indicies],
- element_aligned_tag()),
+ std::index_sequence<__indices...>) {
+ int __unused[] = {(std::get<__indices>(__vs).copy_to(__buffers[__indices],
+ element_aligned_tag()),
0)...};
(void)__unused;
}
@@ -1278,15 +1252,157 @@
return __v;
}
+struct __simd_mask_friend {
+ template <class _Tp, class _Abi>
+ static fixed_size_simd_mask<_Tp, simd_size<_Tp, _Abi>::value>
+ __to_fixed_size(const simd_mask<_Tp, _Abi>& __m) noexcept {
+ return to_fixed_size(__m.__s_);
+ }
+
+ template <class _Tp, size_t _Np>
+ static simd_mask<_Tp, simd_abi::__native<_Tp, _Np>>
+ __to_native(const fixed_size_simd_mask<_Tp, _Np>& __m) noexcept {
+ return to_native(__m.__s_);
+ }
+
+ template <class _Tp, size_t _Np>
+ static simd_mask<_Tp, simd_abi::__compatible<_Tp, _Np>>
+ __to_compatible(const fixed_size_simd_mask<_Tp, _Np>& __m) noexcept {
+ return to_compatible(__m.__s_);
+ }
+
+ template <class _ResType, class _TupleType, size_t... __indices>
+ static _ResType __split_impl(const _TupleType& __t,
+ std::index_sequence<__indices...>) {
+ return _ResType(std::get<__indices>(__t)...);
+ }
+
+ template <size_t... __sizes, class _Tp, class _Abi>
+ static typename std::enable_if<
+ __variadic_sum<size_t>(__sizes...) == simd<_Tp, _Abi>::size(),
+ tuple<simd_mask<_Tp, rebind_abi_t<_Tp, __sizes, _Abi>>...>>::type
+ __split(const simd_mask<_Tp, _Abi>& __m) {
+ return __split_impl<
+ tuple<simd_mask<_Tp, rebind_abi_t<_Tp, __sizes, _Abi>>...>>(
+ split<__sizes...>(__m.__s_),
+ std::make_index_sequence<sizeof...(__sizes)>());
+ }
+
+ template <size_t __array_size, class _Tp, class _Abi>
+ static typename std::enable_if<
+ simd_size<_Tp, _Abi>::value % __array_size == 0,
+ array<simd_mask<_Tp, rebind_abi_t<
+ _Tp, simd_size<_Tp, _Abi>::value / __array_size,
+ _Abi>>,
+ __array_size>>::type
+ __split_by(const simd_mask<_Tp, _Abi>& __m) {
+ auto __arr = split_by<__array_size>(__m.__s_);
+ array<simd_mask<
+ _Tp, rebind_abi_t<_Tp, simd_size<_Tp, _Abi>::value / __array_size,
+ _Abi>>,
+ __array_size>
+ __ret;
+ for (size_t __i = 0; __i < __ret.size(); __i++) {
+ __ret[__i] = __arr[__i];
+ }
+ return __ret;
+ }
+
+ template <class _MaskType, class _Abi>
+ static typename std::enable_if<
+ is_simd_mask<_MaskType>::value &&
+ simd_size<typename _MaskType::value_type, _Abi>::value %
+ _MaskType::size() ==
+ 0,
+ array<_MaskType, simd_size<typename _MaskType::value_type, _Abi>::value /
+ _MaskType::size()>>::type
+ __split(const simd_mask<typename _MaskType::value_type, _Abi>& __m) {
+ return split<typename _MaskType::simd_type>(__m.__s_);
+ }
+
+ template <class _Tp, class... _Abis>
+ static simd_mask<
+ _Tp,
+ rebind_abi_t<_Tp, __variadic_sum<size_t>(simd_size<_Tp, _Abis>::value...),
+ _Abis...>>
+ __concat(const simd_mask<_Tp, _Abis>&... __ms) {
+ return concat(__ms.__s_...);
+ }
+
+ template <class _Tp, class _Abi, size_t _Np>
+ static simd_mask<_Tp,
+ rebind_abi_t<_Tp, _Np * simd_size<_Tp, _Abi>::value, _Abi>>
+ __concat(const std::array<simd_mask<_Tp, _Abi>, _Np>& __ms) {
+ std::array<decltype(__ms[0].__s_), _Np> __arr;
+ for (size_t __i = 0; __i < __ms.size(); __i++) {
+ __arr[__i] = __ms[__i].__s_;
+ }
+ return concat(__arr);
+ }
+};
+
+template <class _Tp, class _Abi>
+fixed_size_simd_mask<_Tp, simd_size<_Tp, _Abi>::value>
+to_fixed_size(const simd_mask<_Tp, _Abi>& __m) noexcept {
+ return __simd_mask_friend::__to_fixed_size(__m);
+}
+
+template <class _Tp, size_t _Np>
+simd_mask<_Tp, simd_abi::__native<_Tp, _Np>>
+to_native(const fixed_size_simd_mask<_Tp, _Np>& __m) noexcept {
+ return __simd_mask_friend::__to_native(__m);
+}
+
+template <class _Tp, size_t _Np>
+simd_mask<_Tp, simd_abi::__compatible<_Tp, _Np>>
+to_compatible(const fixed_size_simd_mask<_Tp, _Np>& __m) noexcept {
+ return __simd_mask_friend::__to_compatible(__m);
+}
+
+template <size_t... __sizes, class _Tp, class _Abi>
+typename std::enable_if<
+ __variadic_sum<size_t>(__sizes...) == simd<_Tp, _Abi>::size(),
+ tuple<simd_mask<_Tp, rebind_abi_t<_Tp, __sizes, _Abi>>...>>::type
+split(const simd_mask<_Tp, _Abi>& __m) {
+ return __simd_mask_friend::__split<__sizes...>(__m);
+}
+
+template <size_t __array_size, class _Tp, class _Abi>
+static typename std::enable_if<
+ simd_size<_Tp, _Abi>::value % __array_size == 0,
+ array<simd_mask<
+ _Tp, rebind_abi_t<_Tp, simd_size<_Tp, _Abi>::value / __array_size,
+ _Abi>>,
+ __array_size>>::type
+split_by(const simd_mask<_Tp, _Abi>& __m) {
+ return __simd_mask_friend::__split_by<__array_size>(__m);
+}
+
+template <class _MaskType, class _Abi>
+static typename std::enable_if<
+ is_simd_mask<_MaskType>::value &&
+ simd_size<typename _MaskType::value_type, _Abi>::value %
+ _MaskType::size() ==
+ 0,
+ array<_MaskType, simd_size<typename _MaskType::value_type, _Abi>::value /
+ _MaskType::size()>>::type
+split(const simd_mask<typename _MaskType::value_type, _Abi>& __m) {
+ return __simd_mask_friend::__split<_MaskType>(__m);
+}
+
template <class _Tp, class... _Abis>
simd_mask<_Tp, rebind_abi_t<
_Tp, __variadic_sum<size_t>(simd_size<_Tp, _Abis>::value...),
_Abis...>>
-concat(const simd_mask<_Tp, _Abis>&...);
+concat(const simd_mask<_Tp, _Abis>&... __ms) {
+ return __simd_mask_friend::__concat(__ms...);
+}
template <class _Tp, class _Abi, size_t _Np>
-simd_mask<_Tp, rebind_abi_t<_Tp, _Np, _Abi>>
-concat(const std::array<simd_mask<_Tp, _Abi>, _Np>&);
+simd_mask<_Tp, rebind_abi_t<_Tp, _Np * simd_size<_Tp, _Abi>::value, _Abi>>
+concat(const std::array<simd_mask<_Tp, _Abi>, _Np>& __ms) {
+ return __simd_mask_friend::__concat(__ms);
+}
// reductions [simd.mask.reductions]
template <class _Tp, class _Abi>
@@ -1297,25 +1413,62 @@
}
return __ret;
}
+
template <class _Tp, class _Abi>
-bool any_of(const simd_mask<_Tp, _Abi>&) noexcept;
+bool any_of(const simd_mask<_Tp, _Abi>& __m) noexcept {
+ bool __ret = false;
+ for (size_t __i = 0; __i < __m.size(); __i++) {
+ __ret |= __m[__i];
+ }
+ return __ret;
+}
+
template <class _Tp, class _Abi>
-bool none_of(const simd_mask<_Tp, _Abi>&) noexcept;
+bool none_of(const simd_mask<_Tp, _Abi>& __m) noexcept {
+ return !any_of(__m);
+}
+
template <class _Tp, class _Abi>
-bool some_of(const simd_mask<_Tp, _Abi>&) noexcept;
+bool some_of(const simd_mask<_Tp, _Abi>& __m) noexcept {
+ return !all_of(__m) && !none_of(__m);
+}
+
template <class _Tp, class _Abi>
-int popcount(const simd_mask<_Tp, _Abi>&) noexcept;
+int popcount(const simd_mask<_Tp, _Abi>& __m) noexcept {
+ int __ret = 0;
+ for (size_t __i = 0; __i < __m.size(); __i++) {
+ __ret += __m[__i];
+ }
+ return __ret;
+}
+
template <class _Tp, class _Abi>
-int find_first_set(const simd_mask<_Tp, _Abi>&);
+int find_first_set(const simd_mask<_Tp, _Abi>& __m) {
+ for (size_t __i = 0; __i < __m.size(); __i++) {
+ if (__m[__i]) {
+ return __i;
+ }
+ }
+ return __m.size();
+}
+
template <class _Tp, class _Abi>
-int find_last_set(const simd_mask<_Tp, _Abi>&);
-bool all_of(bool) noexcept;
-bool any_of(bool) noexcept;
-bool none_of(bool) noexcept;
-bool some_of(bool) noexcept;
-int popcount(bool) noexcept;
-int find_first_set(bool) noexcept;
-int find_last_set(bool) noexcept;
+int find_last_set(const simd_mask<_Tp, _Abi>& __m) {
+ for (int __i = __m.size() - 1; __i >= 0; __i--) {
+ if (__m[__i]) {
+ return __i;
+ }
+ }
+ return __m.size();
+}
+
+bool all_of(bool __v) noexcept { return __v; }
+bool any_of(bool __v) noexcept { return __v; }
+bool none_of(bool __v) noexcept { return !__v; }
+bool some_of(bool) noexcept { return false; }
+int popcount(bool __v) noexcept { return __v; }
+int find_first_set(bool) noexcept { return 0; }
+int find_last_set(bool) noexcept { return 0; }
// masked assignment [simd.whereexpr]
template <class _MaskType, class _Tp>
@@ -1530,27 +1683,27 @@
std::is_unsigned<_Tp>::value);
}
- template <class _Generator, size_t... __indicies>
+ template <class _Generator, size_t... __indices>
static constexpr decltype(
std::forward_as_tuple(std::declval<_Generator>()(
- std::integral_constant<size_t, __indicies>())...),
+ std::integral_constant<size_t, __indices>())...),
bool())
- __can_generate(std::index_sequence<__indicies...>) {
+ __can_generate(std::index_sequence<__indices...>) {
return !__variadic_sum<bool>(
!__can_broadcast<decltype(std::declval<_Generator>()(
- std::integral_constant<size_t, __indicies>()))>()...);
+ std::integral_constant<size_t, __indices>()))>()...);
}
template <class _Generator>
static bool __can_generate(...) {
return false;
}
- template <class _Generator, size_t... __indicies>
- void __generator_init(_Generator&& __g, std::index_sequence<__indicies...>) {
- int __unused[] = {((*this)[__indicies] =
- __g(std::integral_constant<size_t, __indicies>()),
- 0)...};
+ template <class _Generator, size_t... __indices>
+ void __generator_init(_Generator&& __g, std::index_sequence<__indices...>) {
+ int __unused[] = {
+ ((*this)[__indices] = __g(std::integral_constant<size_t, __indices>()),
+ 0)...};
(void)__unused;
}
@@ -1859,7 +2012,9 @@
simd<__element_type, _Abi> __s_;
- explicit simd_mask(const simd<__element_type, _Abi>& __mask) : __s_(__mask) {}
+ simd_mask(const simd<__element_type, _Abi>& __mask) : __s_(__mask) {}
+
+ friend struct __simd_mask_friend;
public:
using value_type = bool;
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
