Skip to content

Commit e66d3a1

Browse files
joy2myselfjoy2myself
committed
[libc++] <experimental/simd> Add unary operators for class simd
1 parent e55dee3 commit e66d3a1

File tree

4 files changed

+251
-1
lines changed

4 files changed

+251
-1
lines changed

‎libcxx/include/experimental/__simd/scalar.h

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -67,6 +67,16 @@ struct __simd_operations<_Tp, simd_abi::__scalar> {
6767
static _LIBCPP_HIDE_FROM_ABI void __store(_SimdStorage __s, _Up* __mem) noexcept {
6868
*__mem = static_cast<_Up>(__s.__data);
6969
}
70+
71+
static void __increment(_SimdStorage& __s) noexcept { ++__s.__data; }
72+
73+
static void __decrement(_SimdStorage& __s) noexcept { --__s.__data; }
74+
75+
static _MaskStorage __negate(_SimdStorage __s) noexcept { return {!__s.__data}; }
76+
77+
static _SimdStorage __bitwise_not(_SimdStorage __s) noexcept { return {static_cast<_Tp>(~__s.__data)}; }
78+
79+
static _SimdStorage __unary_minus(_SimdStorage __s) noexcept { return {static_cast<_Tp>(-__s.__data)}; }
7080
};
7181

7282
template <class _Tp>

‎libcxx/include/experimental/__simd/simd.h

Lines changed: 44 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -25,15 +25,29 @@
2525
_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
2626
inline namespace parallelism_v2 {
2727

28+
template <class _Simd, class _Impl, bool>
29+
class __simd_int_operators {};
30+
31+
template <class _Simd, class _Impl>
32+
class __simd_int_operators<_Simd, _Impl, true> {
33+
public:
34+
// unary operators for integral _Tp
35+
_LIBCPP_HIDE_FROM_ABI _Simd operator~() const noexcept {
36+
return static_cast<_Simd>(_Impl::__bitwise_not((*static_cast<const _Simd*>(this)).__s_));
37+
}
38+
};
39+
2840
// class template simd [simd.class]
2941
// TODO: implement simd class
3042
template <class _Tp, class _Abi>
31-
class simd {
43+
class simd : public __simd_int_operators<simd<_Tp, _Abi>, __simd_operations<_Tp, _Abi>, is_integral_v<_Tp>> {
3244
using _Impl = __simd_operations<_Tp, _Abi>;
3345
using _Storage = typename _Impl::_SimdStorage;
3446

3547
_Storage __s_;
3648

49+
friend class __simd_int_operators<simd, _Impl, true>;
50+
3751
public:
3852
using value_type = _Tp;
3953
using reference = __simd_reference<_Tp, _Storage, value_type>;
@@ -88,6 +102,35 @@ class simd {
88102
// scalar access [simd.subscr]
89103
_LIBCPP_HIDE_FROM_ABI reference operator[](size_t __i) noexcept { return reference(__s_, __i); }
90104
_LIBCPP_HIDE_FROM_ABI value_type operator[](size_t __i) const noexcept { return __s_.__get(__i); }
105+
106+
// simd unary operators
107+
_LIBCPP_HIDE_FROM_ABI simd& operator++() noexcept {
108+
_Impl::__increment(__s_);
109+
return *this;
110+
}
111+
112+
_LIBCPP_HIDE_FROM_ABI simd operator++(int) noexcept {
113+
simd __r = *this;
114+
_Impl::__increment(__s_);
115+
return __r;
116+
}
117+
118+
_LIBCPP_HIDE_FROM_ABI simd& operator--() noexcept {
119+
_Impl::__decrement(__s_);
120+
return *this;
121+
}
122+
123+
_LIBCPP_HIDE_FROM_ABI simd operator--(int) noexcept {
124+
simd __r = *this;
125+
_Impl::__decrement(__s_);
126+
return __r;
127+
}
128+
129+
_LIBCPP_HIDE_FROM_ABI mask_type operator!() const noexcept { return static_cast<mask_type>(_Impl::__negate(__s_)); }
130+
131+
_LIBCPP_HIDE_FROM_ABI simd operator+() const noexcept { return *this; }
132+
133+
_LIBCPP_HIDE_FROM_ABI simd operator-() const noexcept { return static_cast<simd>(_Impl::__unary_minus(__s_)); }
91134
};
92135

93136
template <class _Tp, class _Abi>

‎libcxx/include/experimental/__simd/vec_ext.h

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -86,6 +86,16 @@ struct __simd_operations<_Tp, simd_abi::__vec_ext<_Np>> {
8686
for (size_t __i = 0; __i < _Np; __i++)
8787
__mem[__i] = static_cast<_Up>(__s.__data[__i]);
8888
}
89+
90+
static void __increment(_SimdStorage& __s) noexcept { __s.__data = __s.__data + 1; }
91+
92+
static void __decrement(_SimdStorage& __s) noexcept { __s.__data = __s.__data - 1; }
93+
94+
static _MaskStorage __negate(_SimdStorage __s) noexcept { return {!__s.__data}; }
95+
96+
static _SimdStorage __bitwise_not(_SimdStorage __s) noexcept { return {~__s.__data}; }
97+
98+
static _SimdStorage __unary_minus(_SimdStorage __s) noexcept { return {-__s.__data}; }
8999
};
90100

91101
template <class _Tp, int _Np>

‎libcxx/test/std/experimental/simd/simd.class/simd_unary.pass.cpp

Lines changed: 187 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,187 @@
1+
//===----------------------------------------------------------------------===//
2+
//
3+
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4+
// See https://llvm.org/LICENSE.txt for license information.
5+
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6+
//
7+
//===----------------------------------------------------------------------===//
8+
9+
// UNSUPPORTED: c++03, c++11, c++14
10+
11+
// FIXME: Fatal error with following targets (remove XFAIL when fixed):
12+
// Pass-by-value arguments with alignment greater than register width are not supported.
13+
// XFAIL: target=powerpc{{.*}}-ibm-aix7.2.5.7
14+
15+
// <experimental/simd>
16+
//
17+
// [simd.class]
18+
// simd& operator++() noexcept;
19+
// simd operator++(int) noexcept;
20+
// simd& operator--() noexcept;
21+
// simd operator--(int) noexcept;
22+
// mask_type operator!() const noexcept;
23+
// simd operator~() const noexcept;
24+
// simd operator+() const noexcept;
25+
// simd operator-() const noexcept;
26+
27+
#include "../test_utils.h"
28+
#include <experimental/simd>
29+
30+
namespace ex = std::experimental::parallelism_v2;
31+
32+
template <class T, std::size_t>
33+
struct CheckSimdPrefixIncrementOperator {
34+
template <class SimdAbi>
35+
void operator()() {
36+
constexpr std::size_t array_size = ex::simd_size_v<T, SimdAbi>;
37+
ex::simd<T, SimdAbi> origin_simd([](T i) { return i; });
38+
static_assert(noexcept(++origin_simd));
39+
std::array<T, array_size> expected_return_value, expected_value;
40+
for (size_t i = 0; i < array_size; ++i) {
41+
expected_return_value[i] = static_cast<T>(i) + 1;
42+
expected_value[i] = static_cast<T>(i) + 1;
43+
}
44+
assert_simd_values_equal<array_size>(++origin_simd, expected_return_value);
45+
assert_simd_values_equal<array_size>(origin_simd, expected_value);
46+
}
47+
};
48+
49+
template <class T, std::size_t>
50+
struct CheckSimdPostfixIncrementOperator {
51+
template <class SimdAbi>
52+
void operator()() {
53+
constexpr std::size_t array_size = ex::simd_size_v<T, SimdAbi>;
54+
ex::simd<T, SimdAbi> origin_simd([](T i) { return i; });
55+
static_assert(noexcept(origin_simd++));
56+
std::array<T, array_size> expected_return_value, expected_value;
57+
for (size_t i = 0; i < array_size; ++i) {
58+
expected_return_value[i] = static_cast<T>(i);
59+
expected_value[i] = static_cast<T>(i) + 1;
60+
}
61+
assert_simd_values_equal<array_size>(origin_simd++, expected_return_value);
62+
assert_simd_values_equal<array_size>(origin_simd, expected_value);
63+
}
64+
};
65+
66+
template <class T, std::size_t>
67+
struct CheckSimdPrefixDecrementOperator {
68+
template <class SimdAbi>
69+
void operator()() {
70+
constexpr std::size_t array_size = ex::simd_size_v<T, SimdAbi>;
71+
ex::simd<T, SimdAbi> origin_simd([](T i) { return i; });
72+
static_assert(noexcept(--origin_simd));
73+
std::array<T, array_size> expected_return_value, expected_value;
74+
for (size_t i = 0; i < array_size; ++i) {
75+
expected_return_value[i] = static_cast<T>(i) - 1;
76+
expected_value[i] = static_cast<T>(i) - 1;
77+
}
78+
assert_simd_values_equal<array_size>(--origin_simd, expected_return_value);
79+
assert_simd_values_equal<array_size>(origin_simd, expected_value);
80+
}
81+
};
82+
83+
template <class T, std::size_t>
84+
struct CheckSimdPostfixDecrementOperator {
85+
template <class SimdAbi>
86+
void operator()() {
87+
constexpr std::size_t array_size = ex::simd_size_v<T, SimdAbi>;
88+
ex::simd<T, SimdAbi> origin_simd([](T i) { return i; });
89+
static_assert(noexcept(origin_simd--));
90+
std::array<T, array_size> expected_return_value, expected_value;
91+
for (size_t i = 0; i < array_size; ++i) {
92+
expected_return_value[i] = static_cast<T>(i);
93+
expected_value[i] = static_cast<T>(i) - 1;
94+
}
95+
assert_simd_values_equal<array_size>(origin_simd--, expected_return_value);
96+
assert_simd_values_equal<array_size>(origin_simd, expected_value);
97+
}
98+
};
99+
100+
template <class T, std::size_t>
101+
struct CheckSimdNegationOperator {
102+
template <class SimdAbi>
103+
void operator()() {
104+
constexpr std::size_t array_size = ex::simd_size_v<T, SimdAbi>;
105+
ex::simd<T, SimdAbi> origin_simd([](T i) { return i; });
106+
static_assert(noexcept(!origin_simd));
107+
std::array<bool, array_size> expected_value;
108+
for (size_t i = 0; i < array_size; ++i)
109+
expected_value[i] = static_cast<bool>(!static_cast<T>(i));
110+
assert_simd_mask_values_equal<array_size>(!origin_simd, expected_value);
111+
}
112+
};
113+
114+
template <class T, std::size_t>
115+
struct CheckSimdBitwiseNotOperator {
116+
template <class SimdAbi>
117+
void operator()() {
118+
constexpr std::size_t array_size = ex::simd_size_v<T, SimdAbi>;
119+
ex::simd<T, SimdAbi> origin_simd([](T i) { return i; });
120+
static_assert(noexcept(~origin_simd));
121+
std::array<T, array_size> expected_value;
122+
for (size_t i = 0; i < array_size; ++i)
123+
expected_value[i] = ~static_cast<T>(i);
124+
assert_simd_values_equal<array_size>(~origin_simd, expected_value);
125+
}
126+
};
127+
128+
template <class T, std::size_t>
129+
struct CheckSimdPositiveSignOperator {
130+
template <class SimdAbi>
131+
void operator()() {
132+
constexpr std::size_t array_size = ex::simd_size_v<T, SimdAbi>;
133+
ex::simd<T, SimdAbi> origin_simd([](T i) { return i; });
134+
static_assert(noexcept(+origin_simd));
135+
std::array<T, array_size> expected_value;
136+
for (size_t i = 0; i < array_size; ++i)
137+
expected_value[i] = +static_cast<T>(i);
138+
assert_simd_values_equal<array_size>(+origin_simd, expected_value);
139+
}
140+
};
141+
142+
template <class T, std::size_t>
143+
struct CheckSimdNegativeSignOperator {
144+
template <class SimdAbi>
145+
void operator()() {
146+
constexpr std::size_t array_size = ex::simd_size_v<T, SimdAbi>;
147+
ex::simd<T, SimdAbi> origin_simd([](T i) { return i; });
148+
static_assert(noexcept(-origin_simd));
149+
std::array<T, array_size> expected_value;
150+
for (size_t i = 0; i < array_size; ++i)
151+
expected_value[i] = -static_cast<T>(i);
152+
assert_simd_values_equal<array_size>(-origin_simd, expected_value);
153+
}
154+
};
155+
156+
template <class T, class SimdAbi = ex::simd_abi::compatible<T>, class = void>
157+
struct has_bitwise_not_op : std::false_type {};
158+
159+
template <class T, class SimdAbi>
160+
struct has_bitwise_not_op<T, SimdAbi, std::void_t<decltype(~std::declval<ex::simd<T, SimdAbi>>())>> : std::true_type {};
161+
162+
template <class T, std::size_t>
163+
struct CheckSimdBitwiseNotTraits {
164+
template <class SimdAbi>
165+
void operator()() {
166+
// This function shall not participate in overload resolution unless
167+
// T is an integral type.
168+
if constexpr (std::is_integral_v<T>)
169+
static_assert(has_bitwise_not_op<T, SimdAbi>::value);
170+
// T is not an integral type.
171+
else
172+
static_assert(!has_bitwise_not_op<T, SimdAbi>::value);
173+
}
174+
};
175+
176+
int main(int, char**) {
177+
test_all_simd_abi<CheckSimdPrefixIncrementOperator>();
178+
test_all_simd_abi<CheckSimdPostfixIncrementOperator>();
179+
test_all_simd_abi<CheckSimdPrefixDecrementOperator>();
180+
test_all_simd_abi<CheckSimdPostfixDecrementOperator>();
181+
test_all_simd_abi<CheckSimdNegationOperator>();
182+
types::for_each(types::integer_types(), TestAllSimdAbiFunctor<CheckSimdBitwiseNotOperator>());
183+
test_all_simd_abi<CheckSimdPositiveSignOperator>();
184+
test_all_simd_abi<CheckSimdNegativeSignOperator>();
185+
test_all_simd_abi<CheckSimdBitwiseNotTraits>();
186+
return 0;
187+
}

0 commit comments

Comments
 (0)