Skip to content

Commit e028ad5

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

File tree

6 files changed

+271
-5
lines changed

6 files changed

+271
-5
lines changed

‎libcxx/docs/Status/ParallelismProjects.csv

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -28,6 +28,7 @@ Section,Description,Dependencies,Assignee,Complete
2828
| `[parallel.simd.class] <https://wg21.link/N4808>`_, "`simd load constructor <https://github.com/llvm/llvm-project/pull/76610>`_", None, Yin Zhang, |Complete|
2929
| `[parallel.simd.class] <https://wg21.link/N4808>`_, "`simd subscript operators <https://github.com/llvm/llvm-project/pull/68960>`_", None, Yin Zhang, |Complete|
3030
| `[parallel.simd.class] <https://wg21.link/N4808>`_, "`simd copy functions <https://github.com/llvm/llvm-project/pull/78935>`_", None, Yin Zhang, |Complete|
31+
| `[parallel.simd.class] <https://wg21.link/N4808>`_, "`simd unary operators <https://github.com/llvm/llvm-project/pull/104764>`_", None, Yin Zhang, |Complete|
3132
| `[parallel.simd.class] <https://wg21.link/N4808>`_, "Class template simd implementation", None, Yin Zhang, |In Progress|
3233
| `[parallel.simd.nonmembers] <https://wg21.link/N4808>`_, "simd non-member operations", None, Yin Zhang, |In Progress|
3334
| `[parallel.simd.mask.class] <https://wg21.link/N4808>`_, "`Class template simd_mask declaration and alias <https://reviews.llvm.org/D144362>`_", [parallel.simd.abi], Yin Zhang, |Complete|

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

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -67,6 +67,20 @@ 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 _LIBCPP_HIDE_FROM_ABI void __increment(_SimdStorage& __s) noexcept { ++__s.__data; }
72+
73+
static _LIBCPP_HIDE_FROM_ABI void __decrement(_SimdStorage& __s) noexcept { --__s.__data; }
74+
75+
static _LIBCPP_HIDE_FROM_ABI _MaskStorage __negate(_SimdStorage __s) noexcept { return {!__s.__data}; }
76+
77+
static _LIBCPP_HIDE_FROM_ABI _SimdStorage __bitwise_not(_SimdStorage __s) noexcept {
78+
return {static_cast<_Tp>(~__s.__data)};
79+
}
80+
81+
static _LIBCPP_HIDE_FROM_ABI _SimdStorage __unary_minus(_SimdStorage __s) noexcept {
82+
return {static_cast<_Tp>(-__s.__data)};
83+
}
7084
};
7185

7286
template <class _Tp>

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

Lines changed: 51 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -10,6 +10,7 @@
1010
#ifndef _LIBCPP_EXPERIMENTAL___SIMD_SIMD_H
1111
#define _LIBCPP_EXPERIMENTAL___SIMD_SIMD_H
1212

13+
#include <__type_traits/is_integral.h>
1314
#include <__type_traits/is_same.h>
1415
#include <__type_traits/remove_cvref.h>
1516
#include <__utility/forward.h>
@@ -25,15 +26,29 @@
2526
_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
2627
inline namespace parallelism_v2 {
2728

29+
template <class _Simd, class _Impl, bool>
30+
class __simd_int_operators {};
31+
32+
template <class _Simd, class _Impl>
33+
class __simd_int_operators<_Simd, _Impl, true> {
34+
public:
35+
// unary operators for integral _Tp
36+
_LIBCPP_HIDE_FROM_ABI _Simd operator~() const noexcept {
37+
return _Simd(_Impl::__bitwise_not((*static_cast<const _Simd*>(this)).__s_), _Simd::__storage_tag);
38+
}
39+
};
40+
2841
// class template simd [simd.class]
2942
// TODO: implement simd class
3043
template <class _Tp, class _Abi>
31-
class simd {
44+
class simd : public __simd_int_operators<simd<_Tp, _Abi>, __simd_operations<_Tp, _Abi>, is_integral_v<_Tp>> {
3245
using _Impl = __simd_operations<_Tp, _Abi>;
3346
using _Storage = typename _Impl::_SimdStorage;
3447

3548
_Storage __s_;
3649

50+
friend class __simd_int_operators<simd, _Impl, true>;
51+
3752
public:
3853
using value_type = _Tp;
3954
using reference = __simd_reference<_Tp, _Storage, value_type>;
@@ -45,8 +60,10 @@ class simd {
4560
_LIBCPP_HIDE_FROM_ABI simd() noexcept = default;
4661

4762
// explicit conversion from and to implementation-defined types
48-
explicit _LIBCPP_HIDE_FROM_ABI operator _Storage() const;
49-
explicit _LIBCPP_HIDE_FROM_ABI simd(const _Storage& __s) : __s_(__s) {}
63+
struct __storage_tag_t {};
64+
static constexpr __storage_tag_t __storage_tag{};
65+
explicit _LIBCPP_HIDE_FROM_ABI operator _Storage() const { return __s_; }
66+
explicit _LIBCPP_HIDE_FROM_ABI simd(const _Storage& __s, __storage_tag_t) : __s_(__s) {}
5067

5168
// broadcast constructor
5269
template <class _Up, enable_if_t<__can_broadcast_v<value_type, __remove_cvref_t<_Up>>, int> = 0>
@@ -88,6 +105,37 @@ class simd {
88105
// scalar access [simd.subscr]
89106
_LIBCPP_HIDE_FROM_ABI reference operator[](size_t __i) noexcept { return reference(__s_, __i); }
90107
_LIBCPP_HIDE_FROM_ABI value_type operator[](size_t __i) const noexcept { return __s_.__get(__i); }
108+
109+
// simd unary operators
110+
_LIBCPP_HIDE_FROM_ABI simd& operator++() noexcept {
111+
_Impl::__increment(__s_);
112+
return *this;
113+
}
114+
115+
_LIBCPP_HIDE_FROM_ABI simd operator++(int) noexcept {
116+
simd __r = *this;
117+
_Impl::__increment(__s_);
118+
return __r;
119+
}
120+
121+
_LIBCPP_HIDE_FROM_ABI simd& operator--() noexcept {
122+
_Impl::__decrement(__s_);
123+
return *this;
124+
}
125+
126+
_LIBCPP_HIDE_FROM_ABI simd operator--(int) noexcept {
127+
simd __r = *this;
128+
_Impl::__decrement(__s_);
129+
return __r;
130+
}
131+
132+
_LIBCPP_HIDE_FROM_ABI mask_type operator!() const noexcept {
133+
return mask_type(_Impl::__negate(__s_), mask_type::__storage_tag);
134+
}
135+
136+
_LIBCPP_HIDE_FROM_ABI simd operator+() const noexcept { return *this; }
137+
138+
_LIBCPP_HIDE_FROM_ABI simd operator-() const noexcept { return simd(_Impl::__unary_minus(__s_), __storage_tag); }
91139
};
92140

93141
template <class _Tp, class _Abi>

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

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -42,8 +42,10 @@ class simd_mask {
4242
_LIBCPP_HIDE_FROM_ABI simd_mask() noexcept = default;
4343

4444
// explicit conversion from and to implementation-defined types
45-
explicit _LIBCPP_HIDE_FROM_ABI operator _Storage() const;
46-
explicit _LIBCPP_HIDE_FROM_ABI simd_mask(const _Storage& __s) : __s_(__s) {}
45+
struct __storage_tag_t {};
46+
static constexpr __storage_tag_t __storage_tag{};
47+
explicit _LIBCPP_HIDE_FROM_ABI operator _Storage() const { return __s_; }
48+
explicit _LIBCPP_HIDE_FROM_ABI simd_mask(const _Storage& __s, __storage_tag_t) : __s_(__s) {}
4749

4850
// broadcast constructor
4951
_LIBCPP_HIDE_FROM_ABI explicit simd_mask(value_type __v) noexcept : __s_(_Impl::__broadcast(__v)) {}

‎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 _LIBCPP_HIDE_FROM_ABI void __increment(_SimdStorage& __s) noexcept { __s.__data = __s.__data + 1; }
91+
92+
static _LIBCPP_HIDE_FROM_ABI void __decrement(_SimdStorage& __s) noexcept { __s.__data = __s.__data - 1; }
93+
94+
static _LIBCPP_HIDE_FROM_ABI _MaskStorage __negate(_SimdStorage __s) noexcept { return {!__s.__data}; }
95+
96+
static _LIBCPP_HIDE_FROM_ABI _SimdStorage __bitwise_not(_SimdStorage __s) noexcept { return {~__s.__data}; }
97+
98+
static _LIBCPP_HIDE_FROM_ABI _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: 191 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,191 @@
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+
// Older versions of clang may encounter a backend error (see 0295c2ad):
12+
// Pass-by-value arguments with alignment greater than register width are not supported.
13+
// XFAIL: target=powerpc{{.*}}-ibm-{{.*}} && (clang-17 || clang-18)
14+
15+
// FIXME: The following issue occurs on macOS 13.7 with Apple clang 15.0.0:
16+
// clang: error: unable to execute command: Illegal instruction: 4
17+
// XFAIL: target=x86_64-apple-macosx13.7
18+
19+
// <experimental/simd>
20+
//
21+
// [simd.class]
22+
// simd& operator++() noexcept;
23+
// simd operator++(int) noexcept;
24+
// simd& operator--() noexcept;
25+
// simd operator--(int) noexcept;
26+
// mask_type operator!() const noexcept;
27+
// simd operator~() const noexcept;
28+
// simd operator+() const noexcept;
29+
// simd operator-() const noexcept;
30+
31+
#include "../test_utils.h"
32+
#include <experimental/simd>
33+
34+
namespace ex = std::experimental::parallelism_v2;
35+
36+
template <class T, std::size_t>
37+
struct CheckSimdPrefixIncrementOperator {
38+
template <class SimdAbi>
39+
void operator()() {
40+
constexpr std::size_t array_size = ex::simd_size_v<T, SimdAbi>;
41+
ex::simd<T, SimdAbi> origin_simd([](T i) { return i; });
42+
static_assert(noexcept(++origin_simd));
43+
std::array<T, array_size> expected_return_value, expected_value;
44+
for (size_t i = 0; i < array_size; ++i) {
45+
expected_return_value[i] = static_cast<T>(i) + 1;
46+
expected_value[i] = static_cast<T>(i) + 1;
47+
}
48+
assert_simd_values_equal<array_size>(++origin_simd, expected_return_value);
49+
assert_simd_values_equal<array_size>(origin_simd, expected_value);
50+
}
51+
};
52+
53+
template <class T, std::size_t>
54+
struct CheckSimdPostfixIncrementOperator {
55+
template <class SimdAbi>
56+
void operator()() {
57+
constexpr std::size_t array_size = ex::simd_size_v<T, SimdAbi>;
58+
ex::simd<T, SimdAbi> origin_simd([](T i) { return i; });
59+
static_assert(noexcept(origin_simd++));
60+
std::array<T, array_size> expected_return_value, expected_value;
61+
for (size_t i = 0; i < array_size; ++i) {
62+
expected_return_value[i] = static_cast<T>(i);
63+
expected_value[i] = static_cast<T>(i) + 1;
64+
}
65+
assert_simd_values_equal<array_size>(origin_simd++, expected_return_value);
66+
assert_simd_values_equal<array_size>(origin_simd, expected_value);
67+
}
68+
};
69+
70+
template <class T, std::size_t>
71+
struct CheckSimdPrefixDecrementOperator {
72+
template <class SimdAbi>
73+
void operator()() {
74+
constexpr std::size_t array_size = ex::simd_size_v<T, SimdAbi>;
75+
ex::simd<T, SimdAbi> origin_simd([](T i) { return i; });
76+
static_assert(noexcept(--origin_simd));
77+
std::array<T, array_size> expected_return_value, expected_value;
78+
for (size_t i = 0; i < array_size; ++i) {
79+
expected_return_value[i] = static_cast<T>(i) - 1;
80+
expected_value[i] = static_cast<T>(i) - 1;
81+
}
82+
assert_simd_values_equal<array_size>(--origin_simd, expected_return_value);
83+
assert_simd_values_equal<array_size>(origin_simd, expected_value);
84+
}
85+
};
86+
87+
template <class T, std::size_t>
88+
struct CheckSimdPostfixDecrementOperator {
89+
template <class SimdAbi>
90+
void operator()() {
91+
constexpr std::size_t array_size = ex::simd_size_v<T, SimdAbi>;
92+
ex::simd<T, SimdAbi> origin_simd([](T i) { return i; });
93+
static_assert(noexcept(origin_simd--));
94+
std::array<T, array_size> expected_return_value, expected_value;
95+
for (size_t i = 0; i < array_size; ++i) {
96+
expected_return_value[i] = static_cast<T>(i);
97+
expected_value[i] = static_cast<T>(i) - 1;
98+
}
99+
assert_simd_values_equal<array_size>(origin_simd--, expected_return_value);
100+
assert_simd_values_equal<array_size>(origin_simd, expected_value);
101+
}
102+
};
103+
104+
template <class T, std::size_t>
105+
struct CheckSimdNegationOperator {
106+
template <class SimdAbi>
107+
void operator()() {
108+
constexpr std::size_t array_size = ex::simd_size_v<T, SimdAbi>;
109+
ex::simd<T, SimdAbi> origin_simd([](T i) { return i; });
110+
static_assert(noexcept(!origin_simd));
111+
std::array<bool, array_size> expected_value;
112+
for (size_t i = 0; i < array_size; ++i)
113+
expected_value[i] = !static_cast<bool>(i);
114+
assert_simd_mask_values_equal<array_size>(!origin_simd, expected_value);
115+
}
116+
};
117+
118+
template <class T, std::size_t>
119+
struct CheckSimdBitwiseNotOperator {
120+
template <class SimdAbi>
121+
void operator()() {
122+
constexpr std::size_t array_size = ex::simd_size_v<T, SimdAbi>;
123+
ex::simd<T, SimdAbi> origin_simd([](T i) { return i; });
124+
static_assert(noexcept(~origin_simd));
125+
std::array<T, array_size> expected_value;
126+
for (size_t i = 0; i < array_size; ++i)
127+
expected_value[i] = ~static_cast<T>(i);
128+
assert_simd_values_equal<array_size>(~origin_simd, expected_value);
129+
}
130+
};
131+
132+
template <class T, std::size_t>
133+
struct CheckSimdPositiveSignOperator {
134+
template <class SimdAbi>
135+
void operator()() {
136+
constexpr std::size_t array_size = ex::simd_size_v<T, SimdAbi>;
137+
ex::simd<T, SimdAbi> origin_simd([](T i) { return i; });
138+
static_assert(noexcept(+origin_simd));
139+
std::array<T, array_size> expected_value;
140+
for (size_t i = 0; i < array_size; ++i)
141+
expected_value[i] = +static_cast<T>(i);
142+
assert_simd_values_equal<array_size>(+origin_simd, expected_value);
143+
}
144+
};
145+
146+
template <class T, std::size_t>
147+
struct CheckSimdNegativeSignOperator {
148+
template <class SimdAbi>
149+
void operator()() {
150+
constexpr std::size_t array_size = ex::simd_size_v<T, SimdAbi>;
151+
ex::simd<T, SimdAbi> origin_simd([](T i) { return i; });
152+
static_assert(noexcept(-origin_simd));
153+
std::array<T, array_size> expected_value;
154+
for (size_t i = 0; i < array_size; ++i)
155+
expected_value[i] = -static_cast<T>(i);
156+
assert_simd_values_equal<array_size>(-origin_simd, expected_value);
157+
}
158+
};
159+
160+
template <class T, class SimdAbi = ex::simd_abi::compatible<T>, class = void>
161+
struct has_bitwise_not_op : std::false_type {};
162+
163+
template <class T, class SimdAbi>
164+
struct has_bitwise_not_op<T, SimdAbi, std::void_t<decltype(~std::declval<ex::simd<T, SimdAbi>>())>> : std::true_type {};
165+
166+
template <class T, std::size_t>
167+
struct CheckSimdBitwiseNotTraits {
168+
template <class SimdAbi>
169+
void operator()() {
170+
// This function shall not participate in overload resolution unless
171+
// T is an integral type.
172+
if constexpr (std::is_integral_v<T>)
173+
static_assert(has_bitwise_not_op<T, SimdAbi>::value);
174+
// T is not an integral type.
175+
else
176+
static_assert(!has_bitwise_not_op<T, SimdAbi>::value);
177+
}
178+
};
179+
180+
int main(int, char**) {
181+
test_all_simd_abi<CheckSimdPrefixIncrementOperator>();
182+
test_all_simd_abi<CheckSimdPostfixIncrementOperator>();
183+
test_all_simd_abi<CheckSimdPrefixDecrementOperator>();
184+
test_all_simd_abi<CheckSimdPostfixDecrementOperator>();
185+
test_all_simd_abi<CheckSimdNegationOperator>();
186+
types::for_each(types::integer_types(), TestAllSimdAbiFunctor<CheckSimdBitwiseNotOperator>());
187+
test_all_simd_abi<CheckSimdPositiveSignOperator>();
188+
test_all_simd_abi<CheckSimdNegativeSignOperator>();
189+
test_all_simd_abi<CheckSimdBitwiseNotTraits>();
190+
return 0;
191+
}

0 commit comments

Comments
 (0)