Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

[SYCL] Re-implement swizzles from scratch #17817

Merged
merged 1 commit into from
Apr 4, 2025
Merged

[SYCL] Re-implement swizzles from scratch #17817

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
12 changes: 8 additions & 4 deletions sycl/include/sycl/detail/type_traits.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -24,10 +24,6 @@ template <class T> struct is_fixed_size_group : std::false_type {};

template <class T>
inline constexpr bool is_fixed_size_group_v = is_fixed_size_group<T>::value;

template <typename VecT, typename OperationLeftT, typename OperationRightT,
template <typename> class OperationCurrentT, int... Indexes>
class SwizzleOp;
} // namespace detail

template <int Dimensions> class group;
Expand Down Expand Up @@ -154,12 +150,20 @@ template <typename T, size_t N> struct get_elem_type_unqual<marray<T, N>> {
template <typename T, int N> struct get_elem_type_unqual<vec<T, N>> {
using type = T;
};
#if __SYCL_USE_LIBSYCL8_VEC_IMPL
template <typename VecT, typename OperationLeftT, typename OperationRightT,
template <typename> class OperationCurrentT, int... Indexes>
struct get_elem_type_unqual<SwizzleOp<VecT, OperationLeftT, OperationRightT,
OperationCurrentT, Indexes...>> {
using type = typename get_elem_type_unqual<std::remove_cv_t<VecT>>::type;
};
#else
template <bool IsConstVec, typename DataT, int VecSize, int... Indexes>
struct get_elem_type_unqual<detail::hide_swizzle_from_adl::Swizzle<
IsConstVec, DataT, VecSize, Indexes...>> {
using type = DataT;
};
#endif

template <typename ElementType, access::address_space Space,
access::decorated DecorateAddress>
Expand Down
29 changes: 29 additions & 0 deletions sycl/include/sycl/detail/type_traits/vec_marray_traits.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -32,22 +32,37 @@ template <typename DataT, int NumElements> class __SYCL_EBO vec;
template <typename DataT, std::size_t N> class marray;

namespace detail {
#if __SYCL_USE_LIBSYCL8_VEC_IMPL
template <typename VecT, typename OperationLeftT, typename OperationRightT,
template <typename> class OperationCurrentT, int... Indexes>
class SwizzleOp;
#else
namespace hide_swizzle_from_adl {
template <bool IsConstVec, typename DataT, int VecSize, int... Indexes>
class __SYCL_EBO Swizzle;
}
#endif

// Utility for converting a swizzle to a vector or preserve the type if it isn't
// a swizzle.
template <typename T> struct simplify_if_swizzle {
using type = T;
};

#if __SYCL_USE_LIBSYCL8_VEC_IMPL
template <typename VecT, typename OperationLeftT, typename OperationRightT,
template <typename> class OperationCurrentT, int... Indexes>
struct simplify_if_swizzle<SwizzleOp<VecT, OperationLeftT, OperationRightT,
OperationCurrentT, Indexes...>> {
using type = vec<typename VecT::element_type, sizeof...(Indexes)>;
};
#else
template <bool IsConstVec, typename DataT, int VecSize, int... Indexes>
struct simplify_if_swizzle<detail::hide_swizzle_from_adl::Swizzle<
IsConstVec, DataT, VecSize, Indexes...>> {
using type = vec<DataT, sizeof...(Indexes)>;
};
#endif

template <typename T>
using simplify_if_swizzle_t = typename simplify_if_swizzle<T>::type;
Expand Down Expand Up @@ -79,10 +94,17 @@ inline constexpr bool is_valid_type_for_ext_vector_v =
is_valid_type_for_ext_vector<T>::value;

template <typename> struct is_swizzle : std::false_type {};
#if __SYCL_USE_LIBSYCL8_VEC_IMPL
template <typename VecT, typename OperationLeftT, typename OperationRightT,
template <typename> class OperationCurrentT, int... Indexes>
struct is_swizzle<SwizzleOp<VecT, OperationLeftT, OperationRightT,
OperationCurrentT, Indexes...>> : std::true_type {};
#else
template <bool IsConstVec, typename DataT, int VecSize, int... Indexes>
struct is_swizzle<detail::hide_swizzle_from_adl::Swizzle<IsConstVec, DataT,
VecSize, Indexes...>>
: std::true_type {};
#endif
template <typename T> constexpr bool is_swizzle_v = is_swizzle<T>::value;

template <typename T>
Expand All @@ -108,11 +130,18 @@ struct num_elements<T __attribute__((ext_vector_type(N)))>
: std::integral_constant<std::size_t, N> {};
#endif
#endif
#if __SYCL_USE_LIBSYCL8_VEC_IMPL
template <typename VecT, typename OperationLeftT, typename OperationRightT,
template <typename> class OperationCurrentT, int... Indexes>
struct num_elements<SwizzleOp<VecT, OperationLeftT, OperationRightT,
OperationCurrentT, Indexes...>>
: std::integral_constant<std::size_t, sizeof...(Indexes)> {};
#else
template <bool IsConstVec, typename DataT, int VecSize, int... Indexes>
struct num_elements<detail::hide_swizzle_from_adl::Swizzle<IsConstVec, DataT,
VecSize, Indexes...>>
: std::integral_constant<std::size_t, sizeof...(Indexes)> {};
#endif

template <typename T>
inline constexpr std::size_t num_elements_v = num_elements<T>::value;
Expand Down
197 changes: 193 additions & 4 deletions sycl/include/sycl/detail/vector_arith.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -16,11 +16,7 @@

namespace sycl {
inline namespace _V1 {

template <typename DataT, int NumElem> class __SYCL_EBO vec;

namespace detail {

template <typename T> struct from_incomplete;
template <typename T>
struct from_incomplete<const T> : public from_incomplete<T> {};
Expand All @@ -31,6 +27,33 @@ struct from_incomplete<vec<DataT, NumElements>> {
static constexpr size_t size() { return NumElements; }
};

#if !__SYCL_USE_LIBSYCL8_VEC_IMPL
template <bool IsConstVec, typename DataT, int VecSize, int... Indexes>
struct from_incomplete<
hide_swizzle_from_adl::Swizzle<IsConstVec, DataT, VecSize, Indexes...>> {
using element_type = DataT;
static constexpr size_t size() { return sizeof...(Indexes); }

using vec_ty = std::conditional_t<IsConstVec, const vec<DataT, VecSize>,
vec<DataT, VecSize>>;
using result_vec_ty = vec<DataT, size()>;
static constexpr int vec_size = VecSize;
static constexpr bool is_over_const_vec = IsConstVec;
static constexpr bool has_repeating_indexes = []() constexpr {
int Idxs[] = {Indexes...};
for (std::size_t i = 1; i < sizeof...(Indexes); ++i) {
for (std::size_t j = 0; j < i; ++j)
if (Idxs[j] == Idxs[i])
// Repeating index
return true;
}

return false;
}();
static constexpr bool is_assignable = !IsConstVec && !has_repeating_indexes;
};
#endif

template <bool Cond, typename Mixin> struct ApplyIf {};
template <typename Mixin> struct ApplyIf<true, Mixin> : Mixin {};

Expand Down Expand Up @@ -477,6 +500,172 @@ template <typename Self> struct VecOperators {
OpAssign<ShiftRight>, IncDec> {};
};

#if !__SYCL_USE_LIBSYCL8_VEC_IMPL
template <typename Self> struct SwizzleOperators {
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Nit; The Self name is used all around to represent a shared-pointer to the implementation itself. Could we maybe call this SelfT to disambiguate?

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I think it's a bit late: https://github.com/search?q=repo%3Aintel%2Fllvm+Self+path%3Asycl%2Finclude%2Fsycl%2F&type=code. I also don't see an issue with that. IMO, Self is like this but just a bit different. shared-pointer impl or CRTP both satisfy that view.

Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

IMO, Self is like this but just a bit different. shared-pointer impl or CRTP both satisfy that view.

That's my point. The shared-pointer impl is like this but different, and I don't see a reflective type being as close. Even if you could make the argument that it is, it creates the ambiguity that I wanted to avoid. Alas, it's just a nit, so I won't fight. 😉

using element_type = typename from_incomplete<Self>::element_type;
using vec_ty = typename from_incomplete<Self>::result_vec_ty;
static constexpr int N = from_incomplete<Self>::size();

template <typename T>
static constexpr bool is_compatible_scalar =
std::is_convertible_v<T, typename from_incomplete<Self>::element_type> &&
!is_swizzle_v<T>;

// Can't use partial specialization on constexpr variables because it took too
// long for gcc to fix https://gcc.gnu.org/bugzilla/show_bug.cgi?id=71954 and
// we need to support older versions without the fix.
template <typename OtherSwizzle, typename = void>
struct is_compatible_swizzle_impl : std::false_type {};

template <typename OtherSwizzle>
struct is_compatible_swizzle_impl<
OtherSwizzle, std::enable_if_t<is_swizzle_v<OtherSwizzle>>>
: std::bool_constant<
std::is_same_v<typename from_incomplete<OtherSwizzle>::element_type,
typename from_incomplete<Self>::element_type> &&
from_incomplete<OtherSwizzle>::size() ==
from_incomplete<Self>::size()> {};

template <typename OtherSwizzle>
static constexpr bool is_compatible_swizzle =
is_compatible_swizzle_impl<OtherSwizzle>::value;

template <typename OtherSwizzle, typename = void>
struct is_compatible_swizzle_opposite_const_impl : std::false_type {};

template <typename OtherSwizzle>
struct is_compatible_swizzle_opposite_const_impl<
OtherSwizzle, std::enable_if_t<is_swizzle_v<OtherSwizzle>>>
: std::bool_constant<is_compatible_swizzle<OtherSwizzle> &&
from_incomplete<OtherSwizzle>::is_over_const_vec !=
from_incomplete<Self>::is_over_const_vec> {};

template <typename OtherSwizzle>
static constexpr bool is_compatible_swizzle_opposite_const =
is_compatible_swizzle_opposite_const_impl<OtherSwizzle>::value;

template <typename Op>
using result_t = std::conditional_t<
is_logical<Op>, vec<fixed_width_signed<sizeof(element_type)>, N>, vec_ty>;

// Uglier than possible due to
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85282.
template <typename Op, typename = void> struct OpMixin;

template <typename Op>
struct OpMixin<Op, std::enable_if_t<std::is_same_v<Op, IncDec>>>
: public IncDecImpl<const Self> {};

#define __SYCL_SWIZZLE_BINOP_MIXIN(OP, OPERATOR) \
template <typename Op> \
struct OpMixin<Op, std::enable_if_t<std::is_same_v<Op, OP>>> { \
friend result_t<OP> operator OPERATOR(const Self & lhs, \
const vec_ty & rhs) { \
return OP{}(vec_ty{lhs}, rhs); \
} \
friend result_t<OP> operator OPERATOR(const vec_ty & lhs, \
const Self & rhs) { \
return OP{}(lhs, vec_ty{rhs}); \
} \
template <typename T> \
friend std::enable_if_t<is_compatible_scalar<T>, result_t<OP>> \
operator OPERATOR(const Self & lhs, const T & rhs) { \
return OP{}(vec_ty{lhs}, vec_ty{rhs}); \
} \
template <typename T> \
friend std::enable_if_t<is_compatible_scalar<T>, result_t<OP>> \
operator OPERATOR(const T & lhs, const Self & rhs) { \
return OP{}(vec_ty{lhs}, vec_ty{rhs}); \
} \
template <typename OtherSwizzle> \
friend std::enable_if_t<is_compatible_swizzle<OtherSwizzle>, result_t<OP>> \
operator OPERATOR(const Self & lhs, const OtherSwizzle & rhs) { \
return OP{}(vec_ty{lhs}, vec_ty{rhs}); \
} \
template <typename OtherSwizzle> \
friend std::enable_if_t< \
is_compatible_swizzle_opposite_const<OtherSwizzle>, result_t<OP>> \
operator OPERATOR(const OtherSwizzle & lhs, const Self & rhs) { \
return OP{}(vec_ty{lhs}, vec_ty{rhs}); \
} \
};

#define __SYCL_SWIZZLE_OPASSIGN_MIXIN(OP, OPERATOR) \
template <typename Op> \
struct OpMixin<OpAssign<Op>, std::enable_if_t<std::is_same_v<Op, OP>>> { \
friend const Self &operator OPERATOR(const Self & lhs, \
const vec_ty & rhs) { \
lhs = OP{}(vec_ty{lhs}, rhs); \
return lhs; \
} \
template <typename T> \
friend std::enable_if_t<is_compatible_scalar<T>, const Self &> \
operator OPERATOR(const Self & lhs, const T & rhs) { \
lhs = OP{}(vec_ty{lhs}, vec_ty{rhs}); \
return lhs; \
} \
template <typename OtherSwizzle> \
friend std::enable_if_t<is_compatible_swizzle<OtherSwizzle>, const Self &> \
operator OPERATOR(const Self & lhs, const OtherSwizzle & rhs) { \
lhs = OP{}(vec_ty{lhs}, vec_ty{rhs}); \
return lhs; \
} \
};

#define __SYCL_SWIZZLE_UOP_MIXIN(OP, OPERATOR) \
template <typename Op> \
struct OpMixin<Op, std::enable_if_t<std::is_same_v<Op, OP>>> { \
friend result_t<OP> operator OPERATOR(const Self & v) { \
return OP{}(vec_ty{v}); \
} \
};

__SYCL_INSTANTIATE_OPERATORS(__SYCL_SWIZZLE_BINOP_MIXIN,
__SYCL_SWIZZLE_OPASSIGN_MIXIN,
__SYCL_SWIZZLE_UOP_MIXIN)

#undef __SYCL_SWIZZLE_UOP_MIXIN
#undef __SYCL_SWIZZLE_OPASSIGN_MIXIN
#undef __SYCL_SWIZZLE_BINOP_MIXIN

template <typename... Op>
struct __SYCL_EBO CombineImpl
: ApplyIf<is_op_available_for_type<Op, element_type>, OpMixin<Op>>... {};

template <typename _Self, typename = void>
struct CombinedImpl
: CombineImpl<std::plus<void>, std::minus<void>, std::multiplies<void>,
std::divides<void>, std::modulus<void>, std::bit_and<void>,
std::bit_or<void>, std::bit_xor<void>, std::equal_to<void>,
std::not_equal_to<void>, std::less<void>,
std::greater<void>, std::less_equal<void>,
std::greater_equal<void>, std::logical_and<void>,
std::logical_or<void>, ShiftLeft, ShiftRight,
std::negate<void>, std::logical_not<void>,
std::bit_not<void>, UnaryPlus> {};

template <typename _Self>
struct CombinedImpl<_Self,
std::enable_if_t<from_incomplete<_Self>::is_assignable>>
: CombineImpl<std::plus<void>, std::minus<void>, std::multiplies<void>,
std::divides<void>, std::modulus<void>, std::bit_and<void>,
std::bit_or<void>, std::bit_xor<void>, std::equal_to<void>,
std::not_equal_to<void>, std::less<void>,
std::greater<void>, std::less_equal<void>,
std::greater_equal<void>, std::logical_and<void>,
std::logical_or<void>, ShiftLeft, ShiftRight,
std::negate<void>, std::logical_not<void>,
std::bit_not<void>, UnaryPlus, OpAssign<std::plus<void>>,
OpAssign<std::minus<void>>, OpAssign<std::multiplies<void>>,
OpAssign<std::divides<void>>, OpAssign<std::modulus<void>>,
OpAssign<std::bit_and<void>>, OpAssign<std::bit_or<void>>,
OpAssign<std::bit_xor<void>>, OpAssign<ShiftLeft>,
OpAssign<ShiftRight>, IncDec> {};

using Combined = CombinedImpl<Self>;
};
#endif

#if __SYCL_USE_LIBSYCL8_VEC_IMPL
template <typename DataT, int NumElements>
class vec_arith : public VecOperators<vec<DataT, NumElements>>::Combined {};
Expand Down
Loading