Skip to content

Commit f8c72fa

Browse files
author
Gang Y Chen
committed
[SYCL][ESIMD] - convert esimd operator to friend methodw
Signed-off-by: Gang Y Chen <[email protected]>
1 parent 237675b commit f8c72fa

File tree

4 files changed

+88
-35
lines changed

4 files changed

+88
-35
lines changed

‎sycl/include/CL/sycl/INTEL/esimd/esimd.hpp

Lines changed: 24 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -184,30 +184,26 @@ template <typename Ty, int N> class simd {
184184
// {/quote}
185185
// * if not different, then auto should not be used
186186
#define DEF_BINOP(BINOP, OPASSIGN) \
187-
auto operator BINOP(const simd &RHS) const { \
187+
ESIMD_INLINE friend auto operator BINOP(const simd &X, const simd &Y) { \
188188
using ComputeTy = compute_type_t<simd>; \
189-
auto V0 = convert<typename ComputeTy::vector_type>(data()); \
190-
auto V1 = convert<typename ComputeTy::vector_type>(RHS.data()); \
189+
auto V0 = convert<typename ComputeTy::vector_type>(X.data()); \
190+
auto V1 = convert<typename ComputeTy::vector_type>(Y.data()); \
191191
auto V2 = V0 BINOP V1; \
192192
return ComputeTy(V2); \
193193
} \
194-
simd &operator OPASSIGN(const simd &RHS) { \
194+
ESIMD_INLINE friend simd &operator OPASSIGN(simd &LHS, const simd &RHS) { \
195195
using ComputeTy = compute_type_t<simd>; \
196-
auto V0 = convert<typename ComputeTy::vector_type>(data()); \
196+
auto V0 = convert<typename ComputeTy::vector_type>(LHS.data()); \
197197
auto V1 = convert<typename ComputeTy::vector_type>(RHS.data()); \
198198
auto V2 = V0 BINOP V1; \
199-
write(convert<vector_type>(V2)); \
200-
return *this; \
199+
LHS.write(convert<vector_type>(V2)); \
200+
return LHS; \
201201
} \
202-
simd &operator OPASSIGN(const Ty &RHS) { return *this OPASSIGN simd(RHS); }
202+
ESIMD_INLINE friend simd &operator OPASSIGN(simd &LHS, const Ty &RHS) { \
203+
LHS OPASSIGN simd(RHS); \
204+
return LHS; \
205+
}
203206

204-
// TODO @keryell
205-
// {quote}
206-
// Nowadays hidden friends seem to be more fashionable for these kind of
207-
// operations. A nice side effect is that you have easily some scalar
208-
// broadcast either on LHS & RHS.
209-
// {/quote}
210-
// TODO @mattkretz +1, ditto for compares
211207
DEF_BINOP(+, +=)
212208
DEF_BINOP(-, -=)
213209
DEF_BINOP(*, *=)
@@ -222,8 +218,9 @@ template <typename Ty, int N> class simd {
222218
// the future revisions.
223219
//
224220
#define DEF_RELOP(RELOP) \
225-
simd<uint16_t, N> operator RELOP(const simd &RHS) const { \
226-
auto R = data() RELOP RHS.data(); \
221+
ESIMD_INLINE friend simd<uint16_t, N> operator RELOP(const simd &X, \
222+
const simd &Y) { \
223+
auto R = X.data() RELOP Y.data(); \
227224
mask_type_t<N> M(1); \
228225
return M & convert<mask_type_t<N>>(R); \
229226
}
@@ -238,16 +235,20 @@ template <typename Ty, int N> class simd {
238235
#undef DEF_RELOP
239236

240237
#define DEF_LOGIC_OP(LOGIC_OP, OPASSIGN) \
241-
simd operator LOGIC_OP(const simd &RHS) const { \
238+
ESIMD_INLINE friend simd operator LOGIC_OP(const simd &X, const simd &Y) { \
242239
static_assert(std::is_integral<Ty>(), "not integeral type"); \
243-
auto V2 = data() LOGIC_OP RHS.data(); \
240+
auto V2 = X.data() LOGIC_OP Y.data(); \
244241
return simd(V2); \
245242
} \
246-
simd &operator OPASSIGN(const simd &RHS) { \
243+
ESIMD_INLINE friend simd &operator OPASSIGN(simd &LHS, const simd &RHS) { \
247244
static_assert(std::is_integral<Ty>(), "not integeral type"); \
248-
auto V2 = data() LOGIC_OP RHS.data(); \
249-
write(convert<vector_type>(V2)); \
250-
return *this; \
245+
auto V2 = LHS.data() LOGIC_OP RHS.data(); \
246+
LHS.write(convert<vector_type>(V2)); \
247+
return LHS; \
248+
} \
249+
ESIMD_INLINE friend simd &operator OPASSIGN(simd &LHS, const Ty &RHS) { \
250+
LHS OPASSIGN simd(RHS); \
251+
return LHS; \
251252
}
252253

253254
DEF_LOGIC_OP(&, &=)

‎sycl/include/CL/sycl/INTEL/esimd/esimd_view.hpp

Lines changed: 51 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -180,13 +180,26 @@ template <typename BaseTy, typename RegionTy> class simd_view {
180180
}
181181

182182
#define DEF_BINOP(BINOP, OPASSIGN) \
183-
auto operator BINOP(const value_type &RHS) const { \
183+
ESIMD_INLINE friend auto operator BINOP(const simd_view &X, \
184+
const value_type &Y) { \
184185
using ComputeTy = compute_type_t<value_type>; \
185-
auto V0 = convert<typename ComputeTy::vector_type>(read().data()); \
186-
auto V1 = convert<typename ComputeTy::vector_type>(RHS.data()); \
186+
auto V0 = convert<typename ComputeTy::vector_type>(X.read().data()); \
187+
auto V1 = convert<typename ComputeTy::vector_type>(Y.data()); \
188+
auto V2 = V0 BINOP V1; \
189+
return ComputeTy(V2); \
190+
} \
191+
ESIMD_INLINE friend auto operator BINOP(const value_type &X, \
192+
const simd_view &Y) { \
193+
using ComputeTy = compute_type_t<value_type>; \
194+
auto V0 = convert<typename ComputeTy::vector_type>(X.data()); \
195+
auto V1 = convert<typename ComputeTy::vector_type>(Y.read().data()); \
187196
auto V2 = V0 BINOP V1; \
188197
return ComputeTy(V2); \
189198
} \
199+
ESIMD_INLINE friend auto operator BINOP(const simd_view &X, \
200+
const simd_view &Y) { \
201+
return (X BINOP Y.read()); \
202+
} \
190203
simd_view &operator OPASSIGN(const value_type &RHS) { \
191204
using ComputeTy = compute_type_t<value_type>; \
192205
auto V0 = convert<typename ComputeTy::vector_type>(read().data()); \
@@ -195,6 +208,9 @@ template <typename BaseTy, typename RegionTy> class simd_view {
195208
auto V3 = convert<vector_type>(V2); \
196209
write(V3); \
197210
return *this; \
211+
} \
212+
simd_view &operator OPASSIGN(const simd_view &RHS) { \
213+
return (*this OPASSIGN RHS.read()); \
198214
}
199215

200216
DEF_BINOP(+, +=)
@@ -205,10 +221,21 @@ template <typename BaseTy, typename RegionTy> class simd_view {
205221
#undef DEF_BINOP
206222

207223
#define DEF_RELOP(RELOP) \
208-
simd<uint16_t, length> operator RELOP(const simd_view &RHS) const { \
209-
auto R = read().data() RELOP RHS.read().data(); \
224+
ESIMD_INLINE friend simd<uint16_t, length> operator RELOP( \
225+
const simd_view &X, const value_type &Y) { \
226+
auto R = X.read().data() RELOP Y.data(); \
210227
mask_type_t<length> M(1); \
211228
return M & convert<mask_type_t<length>>(R); \
229+
} \
230+
ESIMD_INLINE friend simd<uint16_t, length> operator RELOP( \
231+
const value_type &X, const simd_view &Y) { \
232+
auto R = X.data() RELOP Y.read().data(); \
233+
mask_type_t<length> M(1); \
234+
return M & convert<mask_type_t<length>>(R); \
235+
} \
236+
ESIMD_INLINE friend simd<uint16_t, length> operator RELOP( \
237+
const simd_view &X, const simd_view &Y) { \
238+
return (X RELOP Y.read()); \
212239
}
213240

214241
DEF_RELOP(>)
@@ -221,19 +248,32 @@ template <typename BaseTy, typename RegionTy> class simd_view {
221248
#undef DEF_RELOP
222249

223250
#define DEF_LOGIC_OP(LOGIC_OP, OPASSIGN) \
224-
simd_view operator LOGIC_OP(const simd_view &RHS) const { \
251+
ESIMD_INLINE friend auto operator LOGIC_OP(const simd_view &X, \
252+
const value_type &Y) { \
225253
static_assert(std::is_integral<element_type>(), "not integral type"); \
226-
auto V2 = read().data() LOGIC_OP RHS.read().data(); \
227-
return simd_view(V2); \
254+
auto V2 = X.read().data() LOGIC_OP Y.data(); \
255+
return simd<element_type, length>(V2); \
228256
} \
229-
simd_view &operator OPASSIGN(const simd_view &RHS) { \
257+
ESIMD_INLINE friend auto operator LOGIC_OP(const value_type &X, \
258+
const simd_view &Y) { \
259+
static_assert(std::is_integral<element_type>(), "not integral type"); \
260+
auto V2 = X.data() LOGIC_OP Y.read().data(); \
261+
return simd<element_type, length>(V2); \
262+
} \
263+
ESIMD_INLINE friend auto operator LOGIC_OP(const simd_view &X, \
264+
const simd_view &Y) { \
265+
return (X LOGIC_OP Y.read()); \
266+
} \
267+
simd_view &operator OPASSIGN(const value_type &RHS) { \
230268
static_assert(std::is_integral<element_type>(), "not integeral type"); \
231-
auto V2 = read().data LOGIC_OP RHS.read().data(); \
269+
auto V2 = read().data() LOGIC_OP RHS.data(); \
232270
auto V3 = convert<vector_type>(V2); \
233271
write(V3); \
234272
return *this; \
273+
} \
274+
simd_view &operator OPASSIGN(const simd_view &RHS) { \
275+
return (*this OPASSIGN RHS.read()); \
235276
}
236-
237277
DEF_LOGIC_OP(&, &=)
238278
DEF_LOGIC_OP(|, |=)
239279
DEF_LOGIC_OP(^, ^=)

‎sycl/test/esimd/simd.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -63,7 +63,7 @@ bool test_simd_bin_ops() __attribute__((sycl_device)) {
6363
simd<int, 8> v0 = 1;
6464
simd<int, 8> v1 = 2;
6565
v0 += v1;
66-
v0 += 2;
66+
v0 = 2 - v0;
6767
v0 -= v1;
6868
v0 -= 2;
6969
v0 *= v1;

‎sycl/test/esimd/simd_view.cpp

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -48,3 +48,15 @@ bool test_simd_view_assign2() __attribute__((sycl_device)) {
4848
v0.select<8, 1>(0) = v1.select<8, 1>(0);
4949
return v0[0] == 1;
5050
}
51+
52+
bool test_simd_view_assign3() __attribute__((sycl_device)) {
53+
simd<int, 64> v0 = 0;
54+
simd<int, 64> v1 = 1;
55+
auto mask = (v0.select<16, 1>(0) > v1.select<16, 1>(0));
56+
auto mask2 = (v0 > v1);
57+
simd<ushort, 64> s = 0;
58+
auto g4 = s.format<ushort, 4, 16>();
59+
simd<ushort, 16> val = (g4.row(2) & mask);
60+
simd<ushort, 16> val1 = (g4.row(2) & mask2.format<ushort, 4, 16>().row(0));
61+
return val[0] == 0 && val1[0] == 0;
62+
}

0 commit comments

Comments
 (0)