From 80c6fe3c0513784c9d29d9bdd2b4f6d9e77fdbf0 Mon Sep 17 00:00:00 2001 From: Andrei Elovikov Date: Fri, 28 Mar 2025 13:15:17 -0700 Subject: [PATCH 1/5] [NFC][SYCL] Add few `vec` tests to document current behavior These will be updated as I upload PRs to implement recent specification changes. --- sycl/test/basic_tests/vectors/assign.cpp | 76 ++++++++++ .../basic_tests/vectors/cxx_conversions.cpp | 130 ++++++++++++++++++ 2 files changed, 206 insertions(+) create mode 100644 sycl/test/basic_tests/vectors/assign.cpp create mode 100644 sycl/test/basic_tests/vectors/cxx_conversions.cpp diff --git a/sycl/test/basic_tests/vectors/assign.cpp b/sycl/test/basic_tests/vectors/assign.cpp new file mode 100644 index 0000000000000..dea275b587b16 --- /dev/null +++ b/sycl/test/basic_tests/vectors/assign.cpp @@ -0,0 +1,76 @@ +// RUN: %clangxx -fsycl -fsyntax-only %s -fpreview-breaking-changes +// RUN: %clangxx -fsycl -fsyntax-only %s + +#include + +using sycl::half; +using sycl::vec; +using sw_half_1 = decltype(std::declval>().swizzle<1>()); +using sw_half_2 = decltype(std::declval>().swizzle<1, 2>()); + +using sw_float_1 = decltype(std::declval>().swizzle<1>()); +using sw_float_2 = decltype(std::declval>().swizzle<1, 2>()); + +using sw_double_1 = decltype(std::declval>().swizzle<1>()); +using sw_double_2 = decltype(std::declval>().swizzle<1, 2>()); + +// clang-format off + +// NOTE: Empty space is for the future markup using NOT_IN_PREVIEW/PREVIEW_ONLY +// macros. + +static_assert( std::is_assignable_v, half>); +static_assert( std::is_assignable_v, float>); +static_assert( std::is_assignable_v, double>); +static_assert( std::is_assignable_v, vec>); +static_assert( std::is_assignable_v, vec>); +static_assert( std::is_assignable_v, vec>); +static_assert( std::is_assignable_v, sw_half_1>); +static_assert( std::is_assignable_v, sw_float_1>); +static_assert( std::is_assignable_v, sw_double_1>); +static_assert( !std::is_assignable_v, sw_half_2>); +static_assert( !std::is_assignable_v, sw_float_2>); +static_assert( !std::is_assignable_v, sw_double_2>); + +static_assert( std::is_assignable_v, half>); +static_assert( std::is_assignable_v, float>); +static_assert( std::is_assignable_v, double>); +static_assert( std::is_assignable_v, vec>); +static_assert( !std::is_assignable_v, vec>); +static_assert( !std::is_assignable_v, vec>); +static_assert( std::is_assignable_v, sw_half_1>); +static_assert( std::is_assignable_v, sw_float_1>); +static_assert( std::is_assignable_v, sw_double_1>); +static_assert( std::is_assignable_v, sw_half_2>); +static_assert( !std::is_assignable_v, sw_float_2>); +static_assert( !std::is_assignable_v, sw_double_2>); + +static_assert( std::is_assignable_v, half>); +static_assert( std::is_assignable_v, float>); +static_assert( std::is_assignable_v, double>); +static_assert( std::is_assignable_v, vec>); +static_assert( std::is_assignable_v, vec>); +static_assert( std::is_assignable_v, vec>); +static_assert( std::is_assignable_v, sw_half_1>); +static_assert( std::is_assignable_v, sw_float_1>); +static_assert( std::is_assignable_v, sw_double_1>); +static_assert( !std::is_assignable_v, sw_half_2>); +static_assert( !std::is_assignable_v, sw_float_2>); +static_assert( !std::is_assignable_v, sw_double_2>); + +static_assert( std::is_assignable_v, half>); +static_assert( std::is_assignable_v, float>); +static_assert( std::is_assignable_v, double>); +#if __SYCL_DEVICE_ONLY__ +static_assert( std::is_assignable_v, vec>); +#else +static_assert( !std::is_assignable_v, vec>); +#endif +static_assert( std::is_assignable_v, vec>); +static_assert( std::is_assignable_v, vec>); +static_assert( std::is_assignable_v, sw_half_1>); +static_assert( std::is_assignable_v, sw_float_1>); +static_assert( std::is_assignable_v, sw_double_1>); +static_assert( !std::is_assignable_v, sw_half_2>); +static_assert( std::is_assignable_v, sw_float_2>); +static_assert( !std::is_assignable_v, sw_double_2>); diff --git a/sycl/test/basic_tests/vectors/cxx_conversions.cpp b/sycl/test/basic_tests/vectors/cxx_conversions.cpp new file mode 100644 index 0000000000000..512f729d48c25 --- /dev/null +++ b/sycl/test/basic_tests/vectors/cxx_conversions.cpp @@ -0,0 +1,130 @@ +// RUN: %clangxx -fsycl -fsyntax-only %s -fpreview-breaking-changes +// RUN: %clangxx -fsycl -fsyntax-only %s + +#include + +template +struct is_explicitly_convertible_to_impl : std::false_type {}; + +template +struct is_explicitly_convertible_to_impl< + From, To, std::void_t(std::declval()))>> + : std::true_type {}; + +template +struct is_explicitly_convertible_to + : is_explicitly_convertible_to_impl {}; + +template +inline constexpr bool is_explicitly_convertible_to_v = + is_explicitly_convertible_to::value; + +using sycl::half; +using sycl::vec; + +void f_half_v1(vec); +void f_half_v4(vec); +void f_float_v1(vec); +void f_float_v4(vec); + +using sw_half_1 = decltype(std::declval>().swizzle<1>()); +using sw_half_2 = decltype(std::declval>().swizzle<1, 2>()); + +using sw_float_1 = decltype(std::declval>().swizzle<1>()); +using sw_float_2 = decltype(std::declval>().swizzle<1, 2>()); + +using sw_double_1 = decltype(std::declval>().swizzle<1>()); +using sw_double_2 = decltype(std::declval>().swizzle<1, 2>()); + +// clang-format off + +// NOTE: Empty space is for the future markup using NOT_IN_PREVIEW/PREVIEW_ONLY +// macros. + +static_assert( std::is_invocable_v); +static_assert( std::is_invocable_v); +static_assert( std::is_invocable_v); +static_assert( std::is_invocable_v); +static_assert( std::is_invocable_v); +static_assert( std::is_invocable_v); +static_assert( std::is_invocable_v>); +static_assert( std::is_invocable_v>); +static_assert( std::is_invocable_v>); + +static_assert( std::is_invocable_v); +static_assert( std::is_invocable_v); +static_assert( std::is_invocable_v); +static_assert( std::is_invocable_v); +static_assert( std::is_invocable_v); +static_assert( std::is_invocable_v); +static_assert( std::is_invocable_v>); +static_assert( std::is_invocable_v>); +static_assert( std::is_invocable_v>); + +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); + +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); + +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); + +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); + +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); +static_assert( !is_explicitly_convertible_to_v>); +static_assert( !is_explicitly_convertible_to_v>); +static_assert( !is_explicitly_convertible_to_v>); +static_assert( !is_explicitly_convertible_to_v>); +static_assert( !is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); +static_assert( !is_explicitly_convertible_to_v>); +static_assert( !is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); + +static_assert( is_explicitly_convertible_to_v, half>); +#if __SYCL_DEVICE_ONLY__ +static_assert( is_explicitly_convertible_to_v, float>); +static_assert( is_explicitly_convertible_to_v, double>); +#else +static_assert( !is_explicitly_convertible_to_v, float>); +static_assert( !is_explicitly_convertible_to_v, double>); +#endif + +static_assert( is_explicitly_convertible_to_v, half>); +static_assert( is_explicitly_convertible_to_v, float>); +static_assert( is_explicitly_convertible_to_v, double>); From a0979dfa1e4d514d8d60916a2fb7e5a9e9e525e7 Mon Sep 17 00:00:00 2001 From: Andrei Elovikov Date: Wed, 12 Feb 2025 15:30:25 -0800 Subject: [PATCH 2/5] [SYCL] Fix vec constructors Implements https://github.com/KhronosGroup/SYCL-Docs/pull/668. Note that the "test" added here is less of a documentation of "intent" but rather the documentation of the effect of the change. Also, the idea behind specification changes was to keep all "reasonable" code in the wild compiling and several changes are needed together to make that happen. Until all of them land, keep the new code out of `-fpreview-breaking-changes` mode. --- .../detail/type_traits/vec_marray_traits.hpp | 12 ++++ sycl/include/sycl/vector.hpp | 55 ++++++++++++++----- sycl/test/basic_tests/vectors/assign.cpp | 24 +++++--- .../basic_tests/vectors/cxx_conversions.cpp | 26 +++++---- 4 files changed, 85 insertions(+), 32 deletions(-) diff --git a/sycl/include/sycl/detail/type_traits/vec_marray_traits.hpp b/sycl/include/sycl/detail/type_traits/vec_marray_traits.hpp index 6ce39bf6a072a..191264c2ad4b7 100644 --- a/sycl/include/sycl/detail/type_traits/vec_marray_traits.hpp +++ b/sycl/include/sycl/detail/type_traits/vec_marray_traits.hpp @@ -13,6 +13,18 @@ #include +#ifndef __SYCL_USE_PREVIEW_VEC_IMPL +#if defined(__INTEL_PREVIEW_BREAKING_CHANGES) +// Several specification changes need to be implemented together to keep CTS +// passing. We'll switch to `1` once they all land. +// `__SYCL_USE_PLAIN_ARRAY_AS_VEC_STORAGE` needs to be changed to use this +// `__SYCL_USE_PREVIEW_VEC_IMPL` at that time as well. +#define __SYCL_USE_PREVIEW_VEC_IMPL 0 +#else +#define __SYCL_USE_PREVIEW_VEC_IMPL 0 +#endif +#endif + namespace sycl { inline namespace _V1 { template class __SYCL_EBO vec; diff --git a/sycl/include/sycl/vector.hpp b/sycl/include/sycl/vector.hpp index a10a7445602f4..81dec0293614b 100644 --- a/sycl/include/sycl/vector.hpp +++ b/sycl/include/sycl/vector.hpp @@ -137,19 +137,11 @@ inline constexpr bool is_fundamental_or_half_or_bfloat16 = std::is_fundamental_v || std::is_same_v, half> || std::is_same_v, ext::oneapi::bfloat16>; -// Proposed SYCL specification changes have sycl::vec having different ctors -// available based on the number of elements. Without C++20's concepts we'll -// have to use partial specialization to represent that. This is a helper to do -// that. An alternative could be to have different specializations of the -// `sycl::vec` itself but then we'd need to outline all the common interfaces to -// re-use them. -// -// Note: the functional changes haven't been implemented yet, we've split -// vec_base in advance as a way to make changes easier to review/verify. -// -// Another note: `vector_t` is going to be removed, so corresponding ctor was -// kept inside `sycl::vec` to have all `vector_t` functionality in a single -// place. +// Per SYCL specification sycl::vec has different ctors available based on the +// number of elements. Without C++20's concepts we'd have to use partial +// specialization to represent that. This is a helper to do that. An alternative +// could be to have different specializations of the `sycl::vec` itself but then +// we'd need to outline all the common interfaces to re-use them. template class vec_base { // https://registry.khronos.org/SYCL/specs/sycl-2020/html/sycl-2020.html#memory-layout-and-alignment // It is required by the SPEC to align vec with vec. @@ -271,6 +263,43 @@ template class vec_base { : vec_base{VecArgArrayCreator::Create(args...), std::make_index_sequence()} {} }; + +#if __SYCL_USE_PREVIEW_VEC_IMPL +template class vec_base { + using DataType = std::conditional_t< +#if __SYCL_USE_PLAIN_ARRAY_AS_VEC_STORAGE + true, +#else + sizeof(std::array) == sizeof(DataT[1]) && + alignof(std::array) == alignof(DataT[1]), +#endif + DataT[1], std::array>; + +protected: + static constexpr int alignment = (std::min)((size_t)64, sizeof(DataType)); + alignas(alignment) DataType m_Data{}; + +public: + constexpr vec_base() = default; + constexpr vec_base(const vec_base &) = default; + constexpr vec_base(vec_base &&) = default; + constexpr vec_base &operator=(const vec_base &) = default; + constexpr vec_base &operator=(vec_base &&) = default; + + // Not `explicit` on purpose, differs from NumElements > 1. + constexpr vec_base(const DataT &arg) : m_Data{{arg}} {} + + // FIXME: Temporary workaround because swizzle's `operator DataT` is a + // template. + template >, + typename = std::enable_if_t, + typename = std::enable_if< + std::is_convertible_v>> + constexpr vec_base(const Swizzle &other) + : vec_base(static_cast(other)) {} +}; +#endif } // namespace detail ///////////////////////// class sycl::vec ///////////////////////// diff --git a/sycl/test/basic_tests/vectors/assign.cpp b/sycl/test/basic_tests/vectors/assign.cpp index dea275b587b16..2085298ead4c3 100644 --- a/sycl/test/basic_tests/vectors/assign.cpp +++ b/sycl/test/basic_tests/vectors/assign.cpp @@ -1,4 +1,5 @@ -// RUN: %clangxx -fsycl -fsyntax-only %s -fpreview-breaking-changes +// TODO: Remove `__SYCL_USE_PREVIEW_VEC_IMPL` once it's auto-set. +// RUN: %clangxx -fsycl -fsyntax-only %s -fpreview-breaking-changes -D__SYCL_USE_PREVIEW_VEC_IMPL=1 // RUN: %clangxx -fsycl -fsyntax-only %s #include @@ -14,17 +15,20 @@ using sw_float_2 = decltype(std::declval>().swizzle<1, 2>()); using sw_double_1 = decltype(std::declval>().swizzle<1>()); using sw_double_2 = decltype(std::declval>().swizzle<1, 2>()); -// clang-format off +#if __INTEL_PREVIEW_BREAKING_CHANGES +#define NOT_IN_PREVIEW ! +#else +#define NOT_IN_PREVIEW +#endif -// NOTE: Empty space is for the future markup using NOT_IN_PREVIEW/PREVIEW_ONLY -// macros. +// clang-format off static_assert( std::is_assignable_v, half>); -static_assert( std::is_assignable_v, float>); -static_assert( std::is_assignable_v, double>); +static_assert(NOT_IN_PREVIEW std::is_assignable_v, float>); +static_assert(NOT_IN_PREVIEW std::is_assignable_v, double>); static_assert( std::is_assignable_v, vec>); -static_assert( std::is_assignable_v, vec>); -static_assert( std::is_assignable_v, vec>); +static_assert(NOT_IN_PREVIEW std::is_assignable_v, vec>); +static_assert(NOT_IN_PREVIEW std::is_assignable_v, vec>); static_assert( std::is_assignable_v, sw_half_1>); static_assert( std::is_assignable_v, sw_float_1>); static_assert( std::is_assignable_v, sw_double_1>); @@ -48,7 +52,11 @@ static_assert( !std::is_assignable_v, sw_double_2>); static_assert( std::is_assignable_v, half>); static_assert( std::is_assignable_v, float>); static_assert( std::is_assignable_v, double>); +#if __SYCL_DEVICE_ONLY__ static_assert( std::is_assignable_v, vec>); +#else +static_assert(NOT_IN_PREVIEW std::is_assignable_v, vec>); +#endif static_assert( std::is_assignable_v, vec>); static_assert( std::is_assignable_v, vec>); static_assert( std::is_assignable_v, sw_half_1>); diff --git a/sycl/test/basic_tests/vectors/cxx_conversions.cpp b/sycl/test/basic_tests/vectors/cxx_conversions.cpp index 512f729d48c25..a78422fdaafdd 100644 --- a/sycl/test/basic_tests/vectors/cxx_conversions.cpp +++ b/sycl/test/basic_tests/vectors/cxx_conversions.cpp @@ -1,4 +1,5 @@ -// RUN: %clangxx -fsycl -fsyntax-only %s -fpreview-breaking-changes +// TODO: Remove `__SYCL_USE_PREVIEW_VEC_IMPL` once it's auto-set. +// RUN: %clangxx -fsycl -fsyntax-only %s -fpreview-breaking-changes -D__SYCL_USE_PREVIEW_VEC_IMPL=1 // RUN: %clangxx -fsycl -fsyntax-only %s #include @@ -36,30 +37,33 @@ using sw_float_2 = decltype(std::declval>().swizzle<1, 2>()); using sw_double_1 = decltype(std::declval>().swizzle<1>()); using sw_double_2 = decltype(std::declval>().swizzle<1, 2>()); -// clang-format off +#if __INTEL_PREVIEW_BREAKING_CHANGES +#define NOT_IN_PREVIEW ! +#else +#define NOT_IN_PREVIEW +#endif -// NOTE: Empty space is for the future markup using NOT_IN_PREVIEW/PREVIEW_ONLY -// macros. +// clang-format off static_assert( std::is_invocable_v); -static_assert( std::is_invocable_v); -static_assert( std::is_invocable_v); +static_assert(NOT_IN_PREVIEW std::is_invocable_v); +static_assert(NOT_IN_PREVIEW std::is_invocable_v); static_assert( std::is_invocable_v); static_assert( std::is_invocable_v); static_assert( std::is_invocable_v); static_assert( std::is_invocable_v>); -static_assert( std::is_invocable_v>); -static_assert( std::is_invocable_v>); +static_assert(NOT_IN_PREVIEW std::is_invocable_v>); +static_assert(NOT_IN_PREVIEW std::is_invocable_v>); -static_assert( std::is_invocable_v); +static_assert(NOT_IN_PREVIEW std::is_invocable_v); static_assert( std::is_invocable_v); static_assert( std::is_invocable_v); static_assert( std::is_invocable_v); static_assert( std::is_invocable_v); static_assert( std::is_invocable_v); -static_assert( std::is_invocable_v>); +static_assert(NOT_IN_PREVIEW std::is_invocable_v>); static_assert( std::is_invocable_v>); -static_assert( std::is_invocable_v>); +static_assert(NOT_IN_PREVIEW std::is_invocable_v>); static_assert( !std::is_invocable_v); static_assert( !std::is_invocable_v); From cb22962b92afe38876e1e95e1cd131bf09fa26a7 Mon Sep 17 00:00:00 2001 From: Andrei Elovikov Date: Mon, 31 Mar 2025 10:25:05 -0700 Subject: [PATCH 3/5] Let's settle on "future" macros here --- sycl/test/basic_tests/vectors/assign.cpp | 101 ++++++----- .../basic_tests/vectors/cxx_conversions.cpp | 170 +++++++++--------- 2 files changed, 139 insertions(+), 132 deletions(-) diff --git a/sycl/test/basic_tests/vectors/assign.cpp b/sycl/test/basic_tests/vectors/assign.cpp index dea275b587b16..ca8f185d7a296 100644 --- a/sycl/test/basic_tests/vectors/assign.cpp +++ b/sycl/test/basic_tests/vectors/assign.cpp @@ -19,58 +19,61 @@ using sw_double_2 = decltype(std::declval>().swizzle<1, 2>()); // NOTE: Empty space is for the future markup using NOT_IN_PREVIEW/PREVIEW_ONLY // macros. -static_assert( std::is_assignable_v, half>); -static_assert( std::is_assignable_v, float>); -static_assert( std::is_assignable_v, double>); -static_assert( std::is_assignable_v, vec>); -static_assert( std::is_assignable_v, vec>); -static_assert( std::is_assignable_v, vec>); -static_assert( std::is_assignable_v, sw_half_1>); -static_assert( std::is_assignable_v, sw_float_1>); -static_assert( std::is_assignable_v, sw_double_1>); -static_assert( !std::is_assignable_v, sw_half_2>); -static_assert( !std::is_assignable_v, sw_float_2>); -static_assert( !std::is_assignable_v, sw_double_2>); +// IN_PREVIEW_ONLY condition<> +// EXCEPT_IN_PREVIEW condition<> -static_assert( std::is_assignable_v, half>); -static_assert( std::is_assignable_v, float>); -static_assert( std::is_assignable_v, double>); -static_assert( std::is_assignable_v, vec>); -static_assert( !std::is_assignable_v, vec>); -static_assert( !std::is_assignable_v, vec>); -static_assert( std::is_assignable_v, sw_half_1>); -static_assert( std::is_assignable_v, sw_float_1>); -static_assert( std::is_assignable_v, sw_double_1>); -static_assert( std::is_assignable_v, sw_half_2>); -static_assert( !std::is_assignable_v, sw_float_2>); -static_assert( !std::is_assignable_v, sw_double_2>); +static_assert( std::is_assignable_v, half>); +static_assert( std::is_assignable_v, float>); +static_assert( std::is_assignable_v, double>); +static_assert( std::is_assignable_v, vec>); +static_assert( std::is_assignable_v, vec>); +static_assert( std::is_assignable_v, vec>); +static_assert( std::is_assignable_v, sw_half_1>); +static_assert( std::is_assignable_v, sw_float_1>); +static_assert( std::is_assignable_v, sw_double_1>); +static_assert( !std::is_assignable_v, sw_half_2>); +static_assert( !std::is_assignable_v, sw_float_2>); +static_assert( !std::is_assignable_v, sw_double_2>); -static_assert( std::is_assignable_v, half>); -static_assert( std::is_assignable_v, float>); -static_assert( std::is_assignable_v, double>); -static_assert( std::is_assignable_v, vec>); -static_assert( std::is_assignable_v, vec>); -static_assert( std::is_assignable_v, vec>); -static_assert( std::is_assignable_v, sw_half_1>); -static_assert( std::is_assignable_v, sw_float_1>); -static_assert( std::is_assignable_v, sw_double_1>); -static_assert( !std::is_assignable_v, sw_half_2>); -static_assert( !std::is_assignable_v, sw_float_2>); -static_assert( !std::is_assignable_v, sw_double_2>); +static_assert( std::is_assignable_v, half>); +static_assert( std::is_assignable_v, float>); +static_assert( std::is_assignable_v, double>); +static_assert( std::is_assignable_v, vec>); +static_assert( !std::is_assignable_v, vec>); +static_assert( !std::is_assignable_v, vec>); +static_assert( std::is_assignable_v, sw_half_1>); +static_assert( std::is_assignable_v, sw_float_1>); +static_assert( std::is_assignable_v, sw_double_1>); +static_assert( std::is_assignable_v, sw_half_2>); +static_assert( !std::is_assignable_v, sw_float_2>); +static_assert( !std::is_assignable_v, sw_double_2>); -static_assert( std::is_assignable_v, half>); -static_assert( std::is_assignable_v, float>); -static_assert( std::is_assignable_v, double>); +static_assert( std::is_assignable_v, half>); +static_assert( std::is_assignable_v, float>); +static_assert( std::is_assignable_v, double>); +static_assert( std::is_assignable_v, vec>); +static_assert( std::is_assignable_v, vec>); +static_assert( std::is_assignable_v, vec>); +static_assert( std::is_assignable_v, sw_half_1>); +static_assert( std::is_assignable_v, sw_float_1>); +static_assert( std::is_assignable_v, sw_double_1>); +static_assert( !std::is_assignable_v, sw_half_2>); +static_assert( !std::is_assignable_v, sw_float_2>); +static_assert( !std::is_assignable_v, sw_double_2>); + +static_assert( std::is_assignable_v, half>); +static_assert( std::is_assignable_v, float>); +static_assert( std::is_assignable_v, double>); #if __SYCL_DEVICE_ONLY__ -static_assert( std::is_assignable_v, vec>); +static_assert( std::is_assignable_v, vec>); #else -static_assert( !std::is_assignable_v, vec>); +static_assert( !std::is_assignable_v, vec>); #endif -static_assert( std::is_assignable_v, vec>); -static_assert( std::is_assignable_v, vec>); -static_assert( std::is_assignable_v, sw_half_1>); -static_assert( std::is_assignable_v, sw_float_1>); -static_assert( std::is_assignable_v, sw_double_1>); -static_assert( !std::is_assignable_v, sw_half_2>); -static_assert( std::is_assignable_v, sw_float_2>); -static_assert( !std::is_assignable_v, sw_double_2>); +static_assert( std::is_assignable_v, vec>); +static_assert( std::is_assignable_v, vec>); +static_assert( std::is_assignable_v, sw_half_1>); +static_assert( std::is_assignable_v, sw_float_1>); +static_assert( std::is_assignable_v, sw_double_1>); +static_assert( !std::is_assignable_v, sw_half_2>); +static_assert( std::is_assignable_v, sw_float_2>); +static_assert( !std::is_assignable_v, sw_double_2>); diff --git a/sycl/test/basic_tests/vectors/cxx_conversions.cpp b/sycl/test/basic_tests/vectors/cxx_conversions.cpp index 512f729d48c25..fb337c0e09e56 100644 --- a/sycl/test/basic_tests/vectors/cxx_conversions.cpp +++ b/sycl/test/basic_tests/vectors/cxx_conversions.cpp @@ -41,90 +41,94 @@ using sw_double_2 = decltype(std::declval>().swizzle<1, 2>()); // NOTE: Empty space is for the future markup using NOT_IN_PREVIEW/PREVIEW_ONLY // macros. -static_assert( std::is_invocable_v); -static_assert( std::is_invocable_v); -static_assert( std::is_invocable_v); -static_assert( std::is_invocable_v); -static_assert( std::is_invocable_v); -static_assert( std::is_invocable_v); -static_assert( std::is_invocable_v>); -static_assert( std::is_invocable_v>); -static_assert( std::is_invocable_v>); - -static_assert( std::is_invocable_v); -static_assert( std::is_invocable_v); -static_assert( std::is_invocable_v); -static_assert( std::is_invocable_v); -static_assert( std::is_invocable_v); -static_assert( std::is_invocable_v); -static_assert( std::is_invocable_v>); -static_assert( std::is_invocable_v>); -static_assert( std::is_invocable_v>); - -static_assert( !std::is_invocable_v); -static_assert( !std::is_invocable_v); -static_assert( !std::is_invocable_v); -static_assert( !std::is_invocable_v); -static_assert( !std::is_invocable_v); -static_assert( !std::is_invocable_v); -static_assert( !std::is_invocable_v); -static_assert( !std::is_invocable_v); -static_assert( !std::is_invocable_v); -static_assert( !std::is_invocable_v); -static_assert( !std::is_invocable_v); - -static_assert( !std::is_invocable_v); -static_assert( !std::is_invocable_v); -static_assert( !std::is_invocable_v); -static_assert( !std::is_invocable_v); -static_assert( !std::is_invocable_v); -static_assert( !std::is_invocable_v); -static_assert( !std::is_invocable_v); -static_assert( !std::is_invocable_v); -static_assert( !std::is_invocable_v); -static_assert( !std::is_invocable_v); -static_assert( !std::is_invocable_v); - -static_assert( is_explicitly_convertible_to_v>); -static_assert( is_explicitly_convertible_to_v>); -static_assert( is_explicitly_convertible_to_v>); -static_assert( is_explicitly_convertible_to_v>); -static_assert( is_explicitly_convertible_to_v>); -static_assert( is_explicitly_convertible_to_v>); - -static_assert( is_explicitly_convertible_to_v>); -static_assert( is_explicitly_convertible_to_v>); -static_assert( is_explicitly_convertible_to_v>); -static_assert( is_explicitly_convertible_to_v>); -static_assert( is_explicitly_convertible_to_v>); -static_assert( is_explicitly_convertible_to_v>); - -static_assert( is_explicitly_convertible_to_v>); -static_assert( is_explicitly_convertible_to_v>); -static_assert( is_explicitly_convertible_to_v>); -static_assert( is_explicitly_convertible_to_v>); -static_assert( is_explicitly_convertible_to_v>); -static_assert( is_explicitly_convertible_to_v>); -static_assert( !is_explicitly_convertible_to_v>); -static_assert( !is_explicitly_convertible_to_v>); -static_assert( !is_explicitly_convertible_to_v>); -static_assert( !is_explicitly_convertible_to_v>); -static_assert( !is_explicitly_convertible_to_v>); -static_assert( is_explicitly_convertible_to_v>); -static_assert( !is_explicitly_convertible_to_v>); -static_assert( !is_explicitly_convertible_to_v>); -static_assert( is_explicitly_convertible_to_v>); -static_assert( is_explicitly_convertible_to_v>); - -static_assert( is_explicitly_convertible_to_v, half>); + +// IN_PREVIEW_ONLY condition<> +// EXCEPT_IN_PREVIEW condition<> + +static_assert( std::is_invocable_v); +static_assert( std::is_invocable_v); +static_assert( std::is_invocable_v); +static_assert( std::is_invocable_v); +static_assert( std::is_invocable_v); +static_assert( std::is_invocable_v); +static_assert( std::is_invocable_v>); +static_assert( std::is_invocable_v>); +static_assert( std::is_invocable_v>); + +static_assert( std::is_invocable_v); +static_assert( std::is_invocable_v); +static_assert( std::is_invocable_v); +static_assert( std::is_invocable_v); +static_assert( std::is_invocable_v); +static_assert( std::is_invocable_v); +static_assert( std::is_invocable_v>); +static_assert( std::is_invocable_v>); +static_assert( std::is_invocable_v>); + +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); + +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); +static_assert( !std::is_invocable_v); + +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); + +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); + +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); +static_assert( !is_explicitly_convertible_to_v>); +static_assert( !is_explicitly_convertible_to_v>); +static_assert( !is_explicitly_convertible_to_v>); +static_assert( !is_explicitly_convertible_to_v>); +static_assert( !is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); +static_assert( !is_explicitly_convertible_to_v>); +static_assert( !is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); +static_assert( is_explicitly_convertible_to_v>); + +static_assert( is_explicitly_convertible_to_v, half>); #if __SYCL_DEVICE_ONLY__ -static_assert( is_explicitly_convertible_to_v, float>); -static_assert( is_explicitly_convertible_to_v, double>); +static_assert( is_explicitly_convertible_to_v, float>); +static_assert( is_explicitly_convertible_to_v, double>); #else -static_assert( !is_explicitly_convertible_to_v, float>); -static_assert( !is_explicitly_convertible_to_v, double>); +static_assert( !is_explicitly_convertible_to_v, float>); +static_assert( !is_explicitly_convertible_to_v, double>); #endif -static_assert( is_explicitly_convertible_to_v, half>); -static_assert( is_explicitly_convertible_to_v, float>); -static_assert( is_explicitly_convertible_to_v, double>); +static_assert( is_explicitly_convertible_to_v, half>); +static_assert( is_explicitly_convertible_to_v, float>); +static_assert( is_explicitly_convertible_to_v, double>); From d16dd21569491bfa61d6b6df674fa44467f77121 Mon Sep 17 00:00:00 2001 From: Andrei Elovikov Date: Mon, 31 Mar 2025 11:11:42 -0700 Subject: [PATCH 4/5] Rename `__SYCL_USE_PREVIEW_VEC_IMPL`->`__SYCL_USE_LIBSYCL8_VEC_IMPL` --- .../include/sycl/detail/type_traits/vec_marray_traits.hpp | 8 ++++---- sycl/include/sycl/vector.hpp | 2 +- sycl/test/basic_tests/vectors/assign.cpp | 4 ++-- sycl/test/basic_tests/vectors/cxx_conversions.cpp | 4 ++-- 4 files changed, 9 insertions(+), 9 deletions(-) diff --git a/sycl/include/sycl/detail/type_traits/vec_marray_traits.hpp b/sycl/include/sycl/detail/type_traits/vec_marray_traits.hpp index 191264c2ad4b7..64b7a9f5d750c 100644 --- a/sycl/include/sycl/detail/type_traits/vec_marray_traits.hpp +++ b/sycl/include/sycl/detail/type_traits/vec_marray_traits.hpp @@ -13,15 +13,15 @@ #include -#ifndef __SYCL_USE_PREVIEW_VEC_IMPL +#ifndef __SYCL_USE_LIBSYCL8_VEC_IMPL #if defined(__INTEL_PREVIEW_BREAKING_CHANGES) // Several specification changes need to be implemented together to keep CTS // passing. We'll switch to `1` once they all land. // `__SYCL_USE_PLAIN_ARRAY_AS_VEC_STORAGE` needs to be changed to use this -// `__SYCL_USE_PREVIEW_VEC_IMPL` at that time as well. -#define __SYCL_USE_PREVIEW_VEC_IMPL 0 +// `__SYCL_USE_LIBSYCL8_VEC_IMPL` at that time as well. +#define __SYCL_USE_LIBSYCL8_VEC_IMPL 1 #else -#define __SYCL_USE_PREVIEW_VEC_IMPL 0 +#define __SYCL_USE_LIBSYCL8_VEC_IMPL 1 #endif #endif diff --git a/sycl/include/sycl/vector.hpp b/sycl/include/sycl/vector.hpp index 81dec0293614b..06458a38e3d90 100644 --- a/sycl/include/sycl/vector.hpp +++ b/sycl/include/sycl/vector.hpp @@ -264,7 +264,7 @@ template class vec_base { std::make_index_sequence()} {} }; -#if __SYCL_USE_PREVIEW_VEC_IMPL +#if !__SYCL_USE_LIBSYCL8_VEC_IMPL template class vec_base { using DataType = std::conditional_t< #if __SYCL_USE_PLAIN_ARRAY_AS_VEC_STORAGE diff --git a/sycl/test/basic_tests/vectors/assign.cpp b/sycl/test/basic_tests/vectors/assign.cpp index 5a7d27684916e..67ed92971d022 100644 --- a/sycl/test/basic_tests/vectors/assign.cpp +++ b/sycl/test/basic_tests/vectors/assign.cpp @@ -1,5 +1,5 @@ -// TODO: Remove `__SYCL_USE_PREVIEW_VEC_IMPL` once it's auto-set. -// RUN: %clangxx -fsycl -fsyntax-only %s -fpreview-breaking-changes -D__SYCL_USE_PREVIEW_VEC_IMPL=1 +// TODO: Remove `__SYCL_USE_LIBSYCL8_VEC_IMPL` once it's auto-set. +// RUN: %clangxx -fsycl -fsyntax-only %s -fpreview-breaking-changes -D__SYCL_USE_LIBSYCL8_VEC_IMPL=0 // RUN: %clangxx -fsycl -fsyntax-only %s #include diff --git a/sycl/test/basic_tests/vectors/cxx_conversions.cpp b/sycl/test/basic_tests/vectors/cxx_conversions.cpp index 84f26ec96284d..4466533945668 100644 --- a/sycl/test/basic_tests/vectors/cxx_conversions.cpp +++ b/sycl/test/basic_tests/vectors/cxx_conversions.cpp @@ -1,5 +1,5 @@ -// TODO: Remove `__SYCL_USE_PREVIEW_VEC_IMPL` once it's auto-set. -// RUN: %clangxx -fsycl -fsyntax-only %s -fpreview-breaking-changes -D__SYCL_USE_PREVIEW_VEC_IMPL=1 +// TODO: Remove `__SYCL_USE_LIBSYCL8_VEC_IMPL` once it's auto-set. +// RUN: %clangxx -fsycl -fsyntax-only %s -fpreview-breaking-changes -D__SYCL_USE_LIBSYCL8_VEC_IMPL=0 // RUN: %clangxx -fsycl -fsyntax-only %s #include From 79e0e15a23bf719267df8b84b4fcdcfea9e90ec8 Mon Sep 17 00:00:00 2001 From: Andrei Elovikov Date: Tue, 1 Apr 2025 09:25:51 -0700 Subject: [PATCH 5/5] Update comment --- sycl/include/sycl/detail/type_traits/vec_marray_traits.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sycl/include/sycl/detail/type_traits/vec_marray_traits.hpp b/sycl/include/sycl/detail/type_traits/vec_marray_traits.hpp index 64b7a9f5d750c..7196a7ca4f868 100644 --- a/sycl/include/sycl/detail/type_traits/vec_marray_traits.hpp +++ b/sycl/include/sycl/detail/type_traits/vec_marray_traits.hpp @@ -16,7 +16,7 @@ #ifndef __SYCL_USE_LIBSYCL8_VEC_IMPL #if defined(__INTEL_PREVIEW_BREAKING_CHANGES) // Several specification changes need to be implemented together to keep CTS -// passing. We'll switch to `1` once they all land. +// passing. We'll switch to `0` once they all land. // `__SYCL_USE_PLAIN_ARRAY_AS_VEC_STORAGE` needs to be changed to use this // `__SYCL_USE_LIBSYCL8_VEC_IMPL` at that time as well. #define __SYCL_USE_LIBSYCL8_VEC_IMPL 1