From d69a4c2ac50eddee27425a0a07b78bc84e194dfd Mon Sep 17 00:00:00 2001 From: ldrumm Date: Thu, 8 Feb 2024 23:21:16 +0000 Subject: [PATCH 1/8] Revert "[ESIMD][E2E] Enable few cases in atomic_update after gpu driver update" (#12669) Reverts intel/llvm#12639 This regressed atomic_update_acc_dg2_pvc_cmpxchg.cpp --- .../Inputs/atomic_update.hpp | 16 ++++++++++---- .../Inputs/atomic_update_slm.hpp | 22 ++++++++++++++++--- 2 files changed, 31 insertions(+), 7 deletions(-) diff --git a/sycl/test-e2e/ESIMD/unified_memory_api/Inputs/atomic_update.hpp b/sycl/test-e2e/ESIMD/unified_memory_api/Inputs/atomic_update.hpp index ef8646ae4892a..3da82ee8e15d1 100644 --- a/sycl/test-e2e/ESIMD/unified_memory_api/Inputs/atomic_update.hpp +++ b/sycl/test-e2e/ESIMD/unified_memory_api/Inputs/atomic_update.hpp @@ -715,10 +715,13 @@ bool test_int_types_and_sizes(queue q, const Config &cfg) { q, cfg); passed &= test_int_types<64, Op, UseMask, UseLSCFeatures, UseAcc, SignMask>( q, cfg); - passed &= test_int_types<12, Op, UseMask, UseLSCFeatures, UseAcc, SignMask>( - q, cfg); - passed &= test_int_types<33, Op, UseMask, UseLSCFeatures, UseAcc, SignMask>( - q, cfg); + // non power of two values are supported only in newer driver. + // TODO: Enable this when the new driver reaches test infrastructure + // (v27556). +#if 0 + passed &= test_int_types<12, Op, UseMask, UseLSCFeatures, UseAcc, SignMask>(q, cfg); + passed &= test_int_types<33, Op, UseMask, UseLSCFeatures, UseAcc, SignMask>(q, cfg); +#endif } return passed; @@ -739,8 +742,13 @@ bool test_fp_types_and_sizes(queue q, const Config &cfg) { passed &= test_fp_types<32, Op, UseMask, UseLSCFeatures, UseAcc>(q, cfg); passed &= test_fp_types<64, Op, UseMask, UseLSCFeatures, UseAcc>(q, cfg); + // non power of two values are supported only in newer driver. + // TODO: Enable this when the new driver reaches test infrastructure + // (v27556). +#if 0 passed &= test_fp_types<12, Op, UseMask, UseLSCFeatures, UseAcc>(q, cfg); passed &= test_fp_types<35, Op, UseMask, UseLSCFeatures, UseAcc>(q, cfg); +#endif } return passed; } diff --git a/sycl/test-e2e/ESIMD/unified_memory_api/Inputs/atomic_update_slm.hpp b/sycl/test-e2e/ESIMD/unified_memory_api/Inputs/atomic_update_slm.hpp index 6b69d99158cb6..92f000711e137 100644 --- a/sycl/test-e2e/ESIMD/unified_memory_api/Inputs/atomic_update_slm.hpp +++ b/sycl/test-e2e/ESIMD/unified_memory_api/Inputs/atomic_update_slm.hpp @@ -612,9 +612,14 @@ bool test_fp_types(queue q) { if constexpr (Features == TestFeatures::DG2 || Features == TestFeatures::PVC) { - if (q.get_device().has(sycl::aspect::atomic64) && - q.get_device().has(sycl::aspect::fp64)) { - passed &= run_test(q); + // TODO: fmin/fmax/fcmpxchg for double requires a newer GPU driver. + if constexpr (!std::is_same_v, ImplLSCFmax> && + !std::is_same_v, ImplLSCFmin> && + !std::is_same_v, ImplLSCFcmpwr>) { + if (q.get_device().has(sycl::aspect::atomic64) && + q.get_device().has(sycl::aspect::fp64)) { + passed &= run_test(q); + } } } return passed; @@ -628,6 +633,7 @@ bool test_int_types_and_sizes(queue q) { passed &= test_int_types<2, Op, UseMask, Features, UseAcc, SignMask>(q); passed &= test_int_types<4, Op, UseMask, Features, UseAcc, SignMask>(q); passed &= test_int_types<8, Op, UseMask, Features, UseAcc, SignMask>(q); + // TODO: N=16 and N=32 does not pass on Gen12 with mask due to older driver. if (UseMask && Features == TestFeatures::Generic && esimd_test::isGPUDriverGE(q, esimd_test::GPUDriverOS::LinuxAndWindows, "26918", "101.4953", false)) { @@ -639,8 +645,13 @@ bool test_int_types_and_sizes(queue q) { if constexpr (Features == TestFeatures::DG2 || Features == TestFeatures::PVC) { passed &= test_int_types<64, Op, UseMask, Features, UseAcc, SignMask>(q); + // non power of two values are supported only in newer driver. + // TODO: Enable this when the new driver reaches test infrastructure + // (v27556). +#if 0 passed &= test_int_types<12, Op, UseMask, Features, UseAcc, SignMask>(q); passed &= test_int_types<33, Op, UseMask, Features, UseAcc, SignMask>(q); +#endif } return passed; @@ -661,8 +672,13 @@ bool test_fp_types_and_sizes(queue q) { if constexpr (Features == TestFeatures::DG2 || Features == TestFeatures::PVC) { passed &= test_fp_types<64, Op, UseMask, Features, UseAcc>(q); + // non power of two values are supported only in newer driver. + // TODO: Enable this when the new driver reaches test infrastructure + // (v27556). +#if 0 passed &= test_fp_types<33, Op, UseMask, Features, UseAcc>(q); passed &= test_fp_types<65, Op, UseMask, Features, UseAcc>(q); +#endif } return passed; } From db04b1ee8e955d342e07ad2cc2a02dbd4317be93 Mon Sep 17 00:00:00 2001 From: aelovikov-intel Date: Thu, 8 Feb 2024 16:01:15 -0800 Subject: [PATCH 2/8] [NFC][SYCL] Move builtin tests sycl/test/basic_tests/{*builtins*.cpp,builtins/} (#12667) While at it, fix formatting and modernize include to SYCL 2020 (``). --- .../builtins_implicitly_convertible_args.cpp | 0 .../{ => builtins}/builtins_templates.cpp | 0 .../{ => builtins}/relational_builtins.cpp | 14 +++++++------- 3 files changed, 7 insertions(+), 7 deletions(-) rename sycl/test/basic_tests/{ => builtins}/builtins_implicitly_convertible_args.cpp (100%) rename sycl/test/basic_tests/{ => builtins}/builtins_templates.cpp (100%) rename sycl/test/basic_tests/{ => builtins}/relational_builtins.cpp (96%) diff --git a/sycl/test/basic_tests/builtins_implicitly_convertible_args.cpp b/sycl/test/basic_tests/builtins/builtins_implicitly_convertible_args.cpp similarity index 100% rename from sycl/test/basic_tests/builtins_implicitly_convertible_args.cpp rename to sycl/test/basic_tests/builtins/builtins_implicitly_convertible_args.cpp diff --git a/sycl/test/basic_tests/builtins_templates.cpp b/sycl/test/basic_tests/builtins/builtins_templates.cpp similarity index 100% rename from sycl/test/basic_tests/builtins_templates.cpp rename to sycl/test/basic_tests/builtins/builtins_templates.cpp diff --git a/sycl/test/basic_tests/relational_builtins.cpp b/sycl/test/basic_tests/builtins/relational_builtins.cpp similarity index 96% rename from sycl/test/basic_tests/relational_builtins.cpp rename to sycl/test/basic_tests/builtins/relational_builtins.cpp index ab9f3aa5c4326..eabd7e26c35cb 100644 --- a/sycl/test/basic_tests/relational_builtins.cpp +++ b/sycl/test/basic_tests/builtins/relational_builtins.cpp @@ -4,7 +4,7 @@ // NOTE: Compile the test fully to ensure the library exports the right host // symbols. -#include +#include // Some helper macros to verify return type of the builtins. To be used like // this @@ -19,15 +19,15 @@ template struct CheckHelper { template static auto call(F f) { return f(Args()...); } }; -#define CHECK(EXPECTED, FUNC, ...) \ +#define CHECK(EXPECTED, FUNC, ...) \ { \ auto ret = CheckHelper<__VA_ARGS__>::call( \ - [](auto... args) { return cl::sycl::FUNC(args...); }); \ - static_assert(std::is_same_v); \ + [](auto... args) { return sycl::FUNC(args...); }); \ + static_assert(std::is_same_v); \ } void foo() { - using namespace cl::sycl; + using namespace sycl; using boolm = marray; using int16v = vec; @@ -247,9 +247,9 @@ void foo() { } int main() { - cl::sycl::queue q; + sycl::queue q; foo(); // Verify host. - q.submit([&](cl::sycl::handler &cgh) { + q.submit([&](sycl::handler &cgh) { cgh.single_task([]() { foo(); // verify device }); From 6098a75b3092da2a9efc34b169b09e76e0336b4c Mon Sep 17 00:00:00 2001 From: Udit Agarwal <16324601+uditagarwal97@users.noreply.github.com> Date: Thu, 8 Feb 2024 23:40:51 -0800 Subject: [PATCH 3/8] [SYCL][E2E] Fix the test script after changing sycl-ls output (#12672) In PR#https://github.com/intel/llvm/pull/12596, we changed the output of sycl-ls to use 'fpga' instead of 'acc'. This has caused several tests to fail when fpga is available on the system. This PR fixes that. In retrospect, we should have enabled testing on FPGA in pre-commit testing as this bug could have been caught earlier. --- sycl/test-e2e/lit.cfg.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sycl/test-e2e/lit.cfg.py b/sycl/test-e2e/lit.cfg.py index a25f775edc9e1..ef44dc972797b 100644 --- a/sycl/test-e2e/lit.cfg.py +++ b/sycl/test-e2e/lit.cfg.py @@ -669,7 +669,7 @@ features.update(sg_size_features) be, dev = sycl_device.split(":") - features.add(dev.replace("acc", "accelerator")) + features.add(dev.replace("fpga", "accelerator")) # Use short names for LIT rules. features.add(be) From 1f37b5ed804123d9068d78a739f8451584fdafca Mon Sep 17 00:00:00 2001 From: aelovikov-intel Date: Fri, 9 Feb 2024 02:33:50 -0800 Subject: [PATCH 4/8] [SYCL] Fix SFINAE rules for integer builtins/bitselect (#12671) In case of vectors/swizzles of integer types only fixed width types are allowed per SYCL 2020 revision 8. Update the implementation to match that. --- sycl/include/sycl/builtins_preview.hpp | 9 +- sycl/include/sycl/builtins_utils_scalar.hpp | 11 ++ .../sycl/detail/builtins/helper_macros.hpp | 8 ++ .../detail/builtins/integer_functions.inc | 7 +- .../detail/builtins/relational_functions.inc | 10 +- sycl/source/builtins/host_helper_macros.hpp | 7 + sycl/source/builtins/integer_functions.cpp | 3 +- sycl/source/builtins/relational_functions.cpp | 3 +- .../builtins/builtin_unit_tests.cpp | 133 ++++++++++++++++++ 9 files changed, 181 insertions(+), 10 deletions(-) create mode 100644 sycl/test/basic_tests/builtins/builtin_unit_tests.cpp diff --git a/sycl/include/sycl/builtins_preview.hpp b/sycl/include/sycl/builtins_preview.hpp index dfc44e5848f91..91fd50d2ec4f2 100644 --- a/sycl/include/sycl/builtins_preview.hpp +++ b/sycl/include/sycl/builtins_preview.hpp @@ -137,7 +137,14 @@ auto builtin_marray_impl(FuncTy F, const Ts &...x) { marray Res; constexpr auto N = T::size(); for (size_t I = 0; I < N / 2; ++I) { - auto PartialRes = F(to_vec2(x, I * 2)...); + auto PartialRes = [&]() { + using elem_ty = get_elem_type_t; + if constexpr (std::is_integral_v) + return F(to_vec2(x, I * 2) + .template as, 2>>()...); + else + return F(to_vec2(x, I * 2)...); + }(); std::memcpy(&Res[I * 2], &PartialRes, sizeof(decltype(PartialRes))); } if (N % 2) diff --git a/sycl/include/sycl/builtins_utils_scalar.hpp b/sycl/include/sycl/builtins_utils_scalar.hpp index 62d86df045cdf..31f267892243b 100644 --- a/sycl/include/sycl/builtins_utils_scalar.hpp +++ b/sycl/include/sycl/builtins_utils_scalar.hpp @@ -128,6 +128,17 @@ template struct get_unsigned_int_by_size { template struct same_size_unsigned_int { using type = typename get_unsigned_int_by_size::type; }; +template +using same_size_unsigned_int_t = typename same_size_unsigned_int::type; + +template struct get_fixed_sized_int { + static_assert(std::is_integral_v); + using type = + std::conditional_t, same_size_signed_int_t, + same_size_unsigned_int_t>; +}; +template +using get_fixed_sized_int_t = typename get_fixed_sized_int::type; // Utility trait for getting an upsampled integer type. // NOTE: For upsampling we look for an integer of double the size of the diff --git a/sycl/include/sycl/detail/builtins/helper_macros.hpp b/sycl/include/sycl/detail/builtins/helper_macros.hpp index 49d4af8981d70..38014c4b62c8f 100644 --- a/sycl/include/sycl/detail/builtins/helper_macros.hpp +++ b/sycl/include/sycl/detail/builtins/helper_macros.hpp @@ -48,6 +48,11 @@ FOR_EACH4_A6(BASE_CASE, FIXED1, FIXED2, FIXED3, FIXED4, ARG1, ARG2, ARG3, \ ARG4, ARG5, ARG6) \ BASE_CASE(FIXED1, FIXED2, FIXED3, FIXED4, ARG7) +#define FOR_EACH4_A8(BASE_CASE, FIXED1, FIXED2, FIXED3, FIXED4, ARG1, ARG2, \ + ARG3, ARG4, ARG5, ARG6, ARG7, ARG8) \ + FOR_EACH4_A7(BASE_CASE, FIXED1, FIXED2, FIXED3, FIXED4, ARG1, ARG2, ARG3, \ + ARG4, ARG5, ARG6, ARG7) \ + BASE_CASE(FIXED1, FIXED2, FIXED3, FIXED4, ARG8) #define FOR_EACH4_A11(BASE_CASE, FIXED1, FIXED2, FIXED3, FIXED4, ARG1, ARG2, \ ARG3, ARG4, ARG5, ARG6, ARG7, ARG8, ARG9, ARG10, ARG11) \ FOR_EACH4_A7(BASE_CASE, FIXED1, FIXED2, FIXED3, FIXED4, ARG1, ARG2, ARG3, \ @@ -169,6 +174,9 @@ unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long // 11 types #define INTEGER_TYPES SIGNED_TYPES, UNSIGNED_TYPES +// 8 types +#define FIXED_WIDTH_INTEGER_TYPES \ + int8_t, int16_t, int32_t, int64_t, uint8_t, uint16_t, uint32_t, uint64_t #define DEVICE_IMPL_TEMPLATE_CUSTOM_DELEGATE( \ NUM_ARGS, NAME, ENABLER, DELEGATOR, NS, /*SCALAR_VEC_IMPL*/...) \ diff --git a/sycl/include/sycl/detail/builtins/integer_functions.inc b/sycl/include/sycl/detail/builtins/integer_functions.inc index dab0cee8a647a..44699765ff7fd 100644 --- a/sycl/include/sycl/detail/builtins/integer_functions.inc +++ b/sycl/include/sycl/detail/builtins/integer_functions.inc @@ -16,9 +16,10 @@ namespace detail { template struct integer_elem_type : std::bool_constant< - check_type_in_v, char, signed char, short, int, - long, long long, unsigned char, unsigned short, - unsigned int, unsigned long, unsigned long long>> {}; + (is_vec_or_swizzle_v && + check_type_in_v, FIXED_WIDTH_INTEGER_TYPES>) || + (!is_vec_or_swizzle_v && + check_type_in_v, INTEGER_TYPES>)> {}; template struct suint32_elem_type : std::bool_constant< diff --git a/sycl/include/sycl/detail/builtins/relational_functions.inc b/sycl/include/sycl/detail/builtins/relational_functions.inc index fb0b3f7682b0a..d63a7716aa9b7 100644 --- a/sycl/include/sycl/detail/builtins/relational_functions.inc +++ b/sycl/include/sycl/detail/builtins/relational_functions.inc @@ -15,10 +15,12 @@ inline namespace _V1 { namespace detail { template struct bitselect_elem_type - : std::bool_constant, float, double, half, char, signed char, short, - int, long, long long, unsigned char, unsigned short, unsigned int, - unsigned long, unsigned long long>> {}; + : std::bool_constant< + check_type_in_v, FP_TYPES> || + (is_vec_or_swizzle_v && + check_type_in_v, FIXED_WIDTH_INTEGER_TYPES>) || + (!is_vec_or_swizzle_v && + check_type_in_v, INTEGER_TYPES>)> {}; template struct rel_ret_traits diff --git a/sycl/source/builtins/host_helper_macros.hpp b/sycl/source/builtins/host_helper_macros.hpp index 484b0bc95fb8b..41aac2148db71 100644 --- a/sycl/source/builtins/host_helper_macros.hpp +++ b/sycl/source/builtins/host_helper_macros.hpp @@ -56,6 +56,9 @@ #define EXPORT_VEC(NUM_ARGS, NAME, TYPE, VL) \ EXPORT_VEC_NS(NUM_ARGS, NAME, sycl, TYPE, VL) +#define EXPORT_VEC_1_16_IMPL(NUM_ARGS, NAME, NS, TYPE) \ + FOR_VEC_1_16(EXPORT_VEC_NS, NUM_ARGS, NAME, NS, TYPE) + #define EXPORT_SCALAR_AND_VEC_1_16_IMPL(NUM_ARGS, NAME, NS, TYPE) \ EXPORT_SCALAR_NS(NUM_ARGS, NAME, NS, TYPE) \ FOR_VEC_1_16(EXPORT_VEC_NS, NUM_ARGS, NAME, NS, TYPE) @@ -69,8 +72,12 @@ #define EXPORT_SCALAR_AND_VEC_1_16_NS(NUM_ARGS, NAME, NS, ...) \ FOR_EACH3(EXPORT_SCALAR_AND_VEC_1_16_IMPL, NUM_ARGS, NAME, NS, __VA_ARGS__) +#define EXPORT_VEC_1_16_NS(NUM_ARGS, NAME, NS, ...) \ + FOR_EACH3(EXPORT_VEC_1_16_IMPL, NUM_ARGS, NAME, NS, __VA_ARGS__) #define EXPORT_SCALAR_AND_VEC_1_16(NUM_ARGS, NAME, ...) \ EXPORT_SCALAR_AND_VEC_1_16_NS(NUM_ARGS, NAME, sycl, __VA_ARGS__) +#define EXPORT_VEC_1_16(NUM_ARGS, NAME, ...) \ + EXPORT_VEC_1_16_NS(NUM_ARGS, NAME, sycl, __VA_ARGS__) #define EXPORT_SCALAR_AND_VEC_2_4(NUM_ARGS, NAME, ...) \ FOR_EACH2(EXPORT_SCALAR_AND_VEC_2_4_IMPL, NUM_ARGS, NAME, __VA_ARGS__) diff --git a/sycl/source/builtins/integer_functions.cpp b/sycl/source/builtins/integer_functions.cpp index 381d6f1fa0a10..cd92b2180df73 100644 --- a/sycl/source/builtins/integer_functions.cpp +++ b/sycl/source/builtins/integer_functions.cpp @@ -76,7 +76,8 @@ namespace sycl { inline namespace _V1 { #define BUILTIN_GENINT(NUM_ARGS, NAME, IMPL) \ HOST_IMPL(NAME, IMPL) \ - EXPORT_SCALAR_AND_VEC_1_16(NUM_ARGS, NAME, INTEGER_TYPES) + FOR_EACH2(EXPORT_SCALAR, NUM_ARGS, NAME, INTEGER_TYPES) \ + EXPORT_VEC_1_16(NUM_ARGS, NAME, FIXED_WIDTH_INTEGER_TYPES) #define BUILTIN_GENINT_SU(NUM_ARGS, NAME, IMPL) \ BUILTIN_GENINT(NUM_ARGS, NAME, IMPL) diff --git a/sycl/source/builtins/relational_functions.cpp b/sycl/source/builtins/relational_functions.cpp index b54c55e283e5e..b8b7795f6fb79 100644 --- a/sycl/source/builtins/relational_functions.cpp +++ b/sycl/source/builtins/relational_functions.cpp @@ -103,6 +103,7 @@ HOST_IMPL(bitselect, [](auto x, auto y, auto z) { assert((ures & std::numeric_limits::max()) == ures); return bit_cast(static_cast(ures)); }) -EXPORT_SCALAR_AND_VEC_1_16(THREE_ARGS, bitselect, INTEGER_TYPES, FP_TYPES) +FOR_EACH2(EXPORT_SCALAR, THREE_ARGS, bitselect, INTEGER_TYPES, FP_TYPES) +EXPORT_VEC_1_16(THREE_ARGS, bitselect, FIXED_WIDTH_INTEGER_TYPES, FP_TYPES) } // namespace _V1 } // namespace sycl diff --git a/sycl/test/basic_tests/builtins/builtin_unit_tests.cpp b/sycl/test/basic_tests/builtins/builtin_unit_tests.cpp new file mode 100644 index 0000000000000..d241a90568fc3 --- /dev/null +++ b/sycl/test/basic_tests/builtins/builtin_unit_tests.cpp @@ -0,0 +1,133 @@ +// RUN: %clangxx -fsycl -fpreview-breaking-changes -fsyntax-only %s -Xclang -verify +// REQUIRES: preview-breaking-changes-supported + +#include + +using namespace sycl; +using namespace sycl::detail; + +namespace builtin_same_shape_v_tests { +using swizzle1 = decltype(std::declval>().swizzle<0>()); +using swizzle2 = decltype(std::declval>().swizzle<0, 0>()); +using swizzle3 = decltype(std::declval>().swizzle<0, 0, 1>()); + +static_assert(builtin_same_shape_v); +static_assert(builtin_same_shape_v); +static_assert(builtin_same_shape_v>); +static_assert(builtin_same_shape_v, marray>); +static_assert(builtin_same_shape_v>); +static_assert(builtin_same_shape_v, vec>); +static_assert(builtin_same_shape_v, swizzle2>); + +static_assert(!builtin_same_shape_v>); +static_assert(!builtin_same_shape_v>); +static_assert(!builtin_same_shape_v, vec>); +static_assert(!builtin_same_shape_v); +static_assert(!builtin_same_shape_v, swizzle1>); +static_assert(!builtin_same_shape_v); +} // namespace builtin_same_shape_v_tests + +namespace builtin_marray_impl_tests { +// Integer functions/relational bitselect only accept fixed-width integer +// element types for vector/swizzle elements. Make sure that our marray->vec +// delegator can handle that. + +auto foo(char x) { return x; } +auto foo(signed char x) { return x; } +auto foo(unsigned char x) { return x; } +auto foo(vec x) { return x; } +auto foo(vec x) { return x; } + +auto test() { + marray x; + marray y; + marray z; + auto TestOne = [](auto x) { + std::ignore = builtin_marray_impl([](auto x) { return foo(x); }, x); + }; + TestOne(x); + TestOne(y); + TestOne(z); +} +} // namespace builtin_marray_impl_tests + +namespace builtin_enable_integer_tests { +using swizzle1 = decltype(std::declval>().swizzle<0>()); +using swizzle2 = decltype(std::declval>().swizzle<0, 0>()); +template void ignore() {} + +void test() { + // clang-format off + ignore, + builtin_enable_integer_t, + builtin_enable_integer_t>(); + // clang-format on + + ignore>, + builtin_enable_integer_t>>(); + + ignore>(); + ignore, vec>>(); + ignore, swizzle2>>(); + ignore>(); + + { + // Only one of char/signed char maps onto int8_t. The other type isn't a + // valid vector element type for integer builtins. + + static_assert(std::is_signed_v); + + // clang-format off + // expected-error-re@*:* {{no type named 'type' in 'sycl::detail::builtin_enable>'}} + // expected-note@+1 {{in instantiation of template type alias 'builtin_enable_integer_t' requested here}} + ignore>, builtin_enable_integer_t>>(); + // clang-format on + } + + // expected-error@*:* {{no type named 'type' in 'sycl::detail::builtin_enable'}} + // expected-note@+1 {{in instantiation of template type alias 'builtin_enable_integer_t' requested here}} + ignore>(); +} +} // namespace builtin_enable_integer_tests + +namespace builtin_enable_bitselect_tests { +// Essentially the same as builtin_enable_integer_t + FP types support. +using swizzle1 = decltype(std::declval>().swizzle<0>()); +using swizzle2 = decltype(std::declval>().swizzle<0, 0>()); +template void ignore() {} + +void test() { + // clang-format off + ignore, + builtin_enable_bitselect_t, + builtin_enable_bitselect_t, + builtin_enable_bitselect_t>(); + // clang-format on + + ignore>, + builtin_enable_bitselect_t>, + builtin_enable_bitselect_t>>(); + + ignore>(); + ignore, vec>>(); + ignore, swizzle2>>(); + ignore>(); + + { + // Only one of char/signed char maps onto int8_t. The other type isn't a + // valid vector element type for integer builtins. + + static_assert(std::is_signed_v); + + // clang-format off + // expected-error-re@*:* {{no type named 'type' in 'sycl::detail::builtin_enable>'}} + // expected-note@+1 {{in instantiation of template type alias 'builtin_enable_bitselect_t' requested here}} + ignore>, builtin_enable_bitselect_t>>(); + // clang-format on + } + + // expected-error@*:* {{no type named 'type' in 'sycl::detail::builtin_enable'}} + // expected-note@+1 {{in instantiation of template type alias 'builtin_enable_bitselect_t' requested here}} + ignore>(); +} +} // namespace builtin_enable_bitselect_tests From c200fe3b56d3eff068474abf65641a612abb117b Mon Sep 17 00:00:00 2001 From: Piotr Balcer Date: Fri, 9 Feb 2024 12:32:16 +0100 Subject: [PATCH 5/8] [UR][L0] Cleanup Queue at Release unconditionally and reset command list after failure (#12640) --- sycl/plugins/unified_runtime/CMakeLists.txt | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/sycl/plugins/unified_runtime/CMakeLists.txt b/sycl/plugins/unified_runtime/CMakeLists.txt index 2ea2b2f37622a..8703068f70698 100644 --- a/sycl/plugins/unified_runtime/CMakeLists.txt +++ b/sycl/plugins/unified_runtime/CMakeLists.txt @@ -57,13 +57,13 @@ if(SYCL_PI_UR_USE_FETCH_CONTENT) include(FetchContent) set(UNIFIED_RUNTIME_REPO "https://github.com/oneapi-src/unified-runtime.git") - # commit 9babc4d092a92c1036791d26ef328e5eeaf19803 - # Merge: 3be8f205 90498ec5 - # Author: aarongreig - # Date: Thu Feb 8 15:44:54 2024 +0000 - # Merge pull request #1321 from pbalcer/adapter-compute-constructor - # [L0] move adapter init into its constructor from urAdapterGet - set(UNIFIED_RUNTIME_TAG 9babc4d092a92c1036791d26ef328e5eeaf19803) + # commit 32e2533fef84f48a2cf2db292d40c7c8d321780d + # Merge: 9babc4d0 24066e4a + # Author: Piotr Balcer + # Date: Fri Feb 9 08:39:25 2024 +0100 + # Merge pull request #1300 from nrspruit/queue_release_cleanup + # [L0] Cleanup Queue at Release unconditionally and reset command list after failure + set(UNIFIED_RUNTIME_TAG 32e2533fef84f48a2cf2db292d40c7c8d321780d) if(SYCL_PI_UR_OVERRIDE_FETCH_CONTENT_REPO) set(UNIFIED_RUNTIME_REPO "${SYCL_PI_UR_OVERRIDE_FETCH_CONTENT_REPO}") From effbbabcd6e37be22b1c8682d7814dd1414b6a01 Mon Sep 17 00:00:00 2001 From: Victor Perez Date: Fri, 9 Feb 2024 13:25:03 +0100 Subject: [PATCH 6/8] [SYCL][Fusion] Avoid deadlock on events with no command group (#12621) `sycl::queue` shortcut functions, e.g., `sycl::queue::memcpy`, may not create a command group, so events coming from those will not have a command group attached. Avoid deadlock when going through event list in fusion mode. Signed-off-by: Victor Perez --- .../source/detail/scheduler/graph_builder.cpp | 1 + .../group_reduce_and_last_wg_detection.cpp | 1 - .../KernelFusion/queue-shortcut-functions.cpp | 99 +++++++++++++++++++ 3 files changed, 100 insertions(+), 1 deletion(-) create mode 100644 sycl/test-e2e/KernelFusion/queue-shortcut-functions.cpp diff --git a/sycl/source/detail/scheduler/graph_builder.cpp b/sycl/source/detail/scheduler/graph_builder.cpp index 104c38dcdd99b..5a26623ce4003 100644 --- a/sycl/source/detail/scheduler/graph_builder.cpp +++ b/sycl/source/detail/scheduler/graph_builder.cpp @@ -963,6 +963,7 @@ Scheduler::GraphBuildResult Scheduler::GraphBuilder::addCG( for (auto Ev = Events.begin(); Ev != Events.end();) { auto *EvDepCmd = static_cast((*Ev)->getCommand()); if (!EvDepCmd) { + ++Ev; continue; } // Handle event dependencies on any commands part of another active diff --git a/sycl/test-e2e/KernelFusion/Reduction/group_reduce_and_last_wg_detection.cpp b/sycl/test-e2e/KernelFusion/Reduction/group_reduce_and_last_wg_detection.cpp index 500847379d864..0868428cc2ef6 100644 --- a/sycl/test-e2e/KernelFusion/Reduction/group_reduce_and_last_wg_detection.cpp +++ b/sycl/test-e2e/KernelFusion/Reduction/group_reduce_and_last_wg_detection.cpp @@ -1,6 +1,5 @@ // RUN: %{build} -fsycl-embed-ir -o %t.out // RUN: %{run} %t.out -// UNSUPPORTED: hip || cuda // COM: When ran on HIP and CUDA, this algorithm launches 'memcpy' commands // leading to an infinite loop due to a bug in kernel fusion. diff --git a/sycl/test-e2e/KernelFusion/queue-shortcut-functions.cpp b/sycl/test-e2e/KernelFusion/queue-shortcut-functions.cpp new file mode 100644 index 0000000000000..7696c18adc7ed --- /dev/null +++ b/sycl/test-e2e/KernelFusion/queue-shortcut-functions.cpp @@ -0,0 +1,99 @@ +// RUN: %{build} -fsycl-embed-ir -o %t.out +// RUN: env SYCL_RT_WARNING_LEVEL=1 %{run} %t.out 2>&1 \ +// RUN: | FileCheck %s --implicit-check-not=ERROR + +// Test fusion with queue shortcut functions being involved. + +#include + +using namespace sycl; + +template class Kernel; + +template void test() { + static_assert(0 <= FusionStartPoint && FusionStartPoint < 3, + "Invalid fusion start point"); + + constexpr size_t size = 1024; + constexpr float value = 10; + queue q{ext::codeplay::experimental::property::queue::enable_fusion{}}; + std::array h; + h.fill(0); + auto *ptr0 = sycl::malloc_device(size, q); + auto *ptr1 = sycl::malloc_device(size, q); + + { + range<1> r{size}; + + ext::codeplay::experimental::fusion_wrapper fw{q}; + + if constexpr (FusionStartPoint == 0) { + fw.start_fusion(); + } + + // ptr0(x) = value + auto e0 = q.parallel_for>( + r, [=](sycl::id<1> i) { ptr0[i] = value; }); + // ptr1(x) = value / 2 + auto e1 = q.parallel_for>( + r, [=](sycl::id<1> i) { ptr1[i] = value / 2; }); + + if constexpr (FusionStartPoint == 1) { + fw.start_fusion(); + } + + // ptr0(x) = value / 2 if x < size / 2 else value + auto e2 = q.memcpy(ptr0, ptr1, sizeof(float) * size / 2, {e0, e1}); + + if constexpr (FusionStartPoint == 2) { + fw.start_fusion(); + } + + // ptr0(x) = value / 2 + 1 if x < size / 2 else value + 1 + auto e3 = q.parallel_for>( + r, e2, [=](sycl::id<1> i) { ptr0[i]++; }); + + fw.complete_fusion({ext::codeplay::experimental::property::no_barriers{}}); + + // Copyback + q.memcpy(h.data(), ptr0, sizeof(float) * size, e3).wait(); + } + + sycl::free(ptr0, q); + sycl::free(ptr1, q); + + assert(std::all_of(h.begin(), h.begin() + size / 2, + [=](float f) { return f == value / 2 + 1; }) && + "ERROR"); + assert(std::all_of(h.begin() + size / 2, h.end(), + [=](float f) { return f == value + 1; }) && + "ERROR"); +} + +int main() { + std::cerr << "FusionStartPoint = 0:\n"; + // COM: memcpy leads to a CG being created as it depends on CGs not producing + // a PI event (coming from the CGs to be fused), so not safe to bypass. Fusion + // should be cancelled as a dependency with an event to be fused is found. + + // CHECK: FusionStartPoint = 0: + // CHECK-NEXT: WARNING: Not fusing 'copy usm' command group. Can only fuse device kernel command groups. + // CHECK-NEXT: WARNING: Aborting fusion because synchronization with one of the kernels in the fusion list was requested + test<0>(); + + std::cerr << "FusionStartPoint = 1:\n"; + // COM: memcpy does not create CG, memory manager handles the operation + // instead. As no dependency with a CG to be fused is found, events are issued + // as usual and fusion takes place. + + // CHECK-NEXT: FusionStartPoint = 1: + // CHECK-NEXT: JIT DEBUG: Compiling new kernel, no suitable cached kernel found + test<1>(); + + std::cerr << "FusionStartPoint = 2:\n"; + // COM: Same as above. + + // CHECK-NEXT: FusionStartPoint = 2: + // CHECK-NEXT: JIT DEBUG: Compiling new kernel, no suitable cached kernel found + test<2>(); +} From f6425750bfe7c7ba98fa913dff5ae8a3cd2649b2 Mon Sep 17 00:00:00 2001 From: Maxime France-Pillois Date: Fri, 9 Feb 2024 14:38:16 +0000 Subject: [PATCH 7/8] [SYCL][Graph] Re-enable USM-based graph tests on gpu-intel-dg2 (#12677) The UR PR https://github.com/oneapi-src/unified-runtime/pull/1328 fixes the bug revealed by the post-commit CIs https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 These tests can therefore be re-enabled. --- sycl/plugins/unified_runtime/CMakeLists.txt | 14 +++++++------- .../Graph/Explicit/add_nodes_after_finalize.cpp | 4 ---- sycl/test-e2e/Graph/Explicit/basic_usm.cpp | 4 ---- sycl/test-e2e/Graph/Explicit/basic_usm_host.cpp | 4 ---- sycl/test-e2e/Graph/Explicit/basic_usm_mixed.cpp | 4 ---- sycl/test-e2e/Graph/Explicit/basic_usm_shared.cpp | 4 ---- sycl/test-e2e/Graph/Explicit/empty_node.cpp | 4 ---- sycl/test-e2e/Graph/Explicit/host_task.cpp | 4 ---- sycl/test-e2e/Graph/Explicit/host_task2.cpp | 4 ---- sycl/test-e2e/Graph/Explicit/host_task_last.cpp | 4 ---- .../Graph/Explicit/host_task_multiple_deps.cpp | 4 ---- sycl/test-e2e/Graph/Explicit/host_task_single.cpp | 4 ---- .../Graph/Explicit/host_task_successive.cpp | 4 ---- sycl/test-e2e/Graph/Explicit/memadvise.cpp | 5 +---- .../Graph/Explicit/multiple_exec_graphs.cpp | 4 ---- sycl/test-e2e/Graph/Explicit/prefetch.cpp | 5 +---- .../Graph/Explicit/queue_constructor_usm.cpp | 10 +++------- sycl/test-e2e/Graph/Explicit/queue_shortcuts.cpp | 4 ---- sycl/test-e2e/Graph/Explicit/repeated_exec.cpp | 4 ---- sycl/test-e2e/Graph/Explicit/sub_graph.cpp | 4 ---- .../Explicit/sub_graph_execute_without_parent.cpp | 4 ---- .../Explicit/sub_graph_multiple_submission.cpp | 4 ---- sycl/test-e2e/Graph/Explicit/sub_graph_nested.cpp | 4 ---- .../Graph/Explicit/sub_graph_two_parent_graphs.cpp | 4 ---- sycl/test-e2e/Graph/Explicit/usm_copy.cpp | 5 +---- sycl/test-e2e/Graph/Explicit/usm_fill.cpp | 4 ---- sycl/test-e2e/Graph/Explicit/usm_fill_shared.cpp | 4 ---- sycl/test-e2e/Graph/Explicit/usm_memset.cpp | 5 +---- .../RecordReplay/add_nodes_after_finalize.cpp | 5 +---- sycl/test-e2e/Graph/RecordReplay/after_use.cpp | 4 ---- .../Graph/RecordReplay/barrier_with_work.cpp | 4 ---- sycl/test-e2e/Graph/RecordReplay/basic_usm.cpp | 4 ---- .../test-e2e/Graph/RecordReplay/basic_usm_host.cpp | 4 ---- .../Graph/RecordReplay/basic_usm_mixed.cpp | 4 ---- .../Graph/RecordReplay/basic_usm_shared.cpp | 4 ---- sycl/test-e2e/Graph/RecordReplay/empty_node.cpp | 4 ---- sycl/test-e2e/Graph/RecordReplay/host_task.cpp | 4 ---- sycl/test-e2e/Graph/RecordReplay/host_task2.cpp | 4 ---- .../Graph/RecordReplay/host_task_in_order.cpp | 4 ---- .../test-e2e/Graph/RecordReplay/host_task_last.cpp | 4 ---- .../Graph/RecordReplay/host_task_multiple_deps.cpp | 4 ---- .../Graph/RecordReplay/host_task_single.cpp | 4 ---- .../Graph/RecordReplay/host_task_successive.cpp | 4 ---- sycl/test-e2e/Graph/RecordReplay/memadvise.cpp | 5 +---- .../Graph/RecordReplay/multiple_exec_graphs.cpp | 4 ---- sycl/test-e2e/Graph/RecordReplay/prefetch.cpp | 5 +---- .../Graph/RecordReplay/queue_constructor_usm.cpp | 10 +++------- .../Graph/RecordReplay/queue_shortcuts.cpp | 4 ---- sycl/test-e2e/Graph/RecordReplay/repeated_exec.cpp | 4 ---- sycl/test-e2e/Graph/RecordReplay/sub_graph.cpp | 4 ---- .../sub_graph_execute_without_parent.cpp | 4 ---- .../RecordReplay/sub_graph_multiple_submission.cpp | 4 ---- .../Graph/RecordReplay/sub_graph_nested.cpp | 4 ---- .../RecordReplay/sub_graph_two_parent_graphs.cpp | 4 ---- sycl/test-e2e/Graph/RecordReplay/usm_copy.cpp | 5 +---- sycl/test-e2e/Graph/RecordReplay/usm_fill.cpp | 4 ---- .../Graph/RecordReplay/usm_fill_shared.cpp | 4 ---- sycl/test-e2e/Graph/RecordReplay/usm_memset.cpp | 5 +---- sycl/test-e2e/Graph/empty_graph.cpp | 4 ---- 59 files changed, 22 insertions(+), 245 deletions(-) diff --git a/sycl/plugins/unified_runtime/CMakeLists.txt b/sycl/plugins/unified_runtime/CMakeLists.txt index 8703068f70698..5d17057597506 100644 --- a/sycl/plugins/unified_runtime/CMakeLists.txt +++ b/sycl/plugins/unified_runtime/CMakeLists.txt @@ -57,13 +57,13 @@ if(SYCL_PI_UR_USE_FETCH_CONTENT) include(FetchContent) set(UNIFIED_RUNTIME_REPO "https://github.com/oneapi-src/unified-runtime.git") - # commit 32e2533fef84f48a2cf2db292d40c7c8d321780d - # Merge: 9babc4d0 24066e4a - # Author: Piotr Balcer - # Date: Fri Feb 9 08:39:25 2024 +0100 - # Merge pull request #1300 from nrspruit/queue_release_cleanup - # [L0] Cleanup Queue at Release unconditionally and reset command list after failure - set(UNIFIED_RUNTIME_TAG 32e2533fef84f48a2cf2db292d40c7c8d321780d) + # commit 47102cb2b275472054803a9399b5b977ef210b23 + # Merge: 186bfb9d 2390664d + # Author: aarongreig + # Date: Fri Feb 9 12:21:47 2024 +0000 + # Merge pull request #1328 from Bensuo/maxime/events-reset-bugfix + # [EXP][CMDBUF] Reset events for multiple submissions (bugfix) + set(UNIFIED_RUNTIME_TAG 47102cb2b275472054803a9399b5b977ef210b23) if(SYCL_PI_UR_OVERRIDE_FETCH_CONTENT_REPO) set(UNIFIED_RUNTIME_REPO "${SYCL_PI_UR_OVERRIDE_FETCH_CONTENT_REPO}") diff --git a/sycl/test-e2e/Graph/Explicit/add_nodes_after_finalize.cpp b/sycl/test-e2e/Graph/Explicit/add_nodes_after_finalize.cpp index b39f3b4fc889b..cf17e3b6c3dba 100644 --- a/sycl/test-e2e/Graph/Explicit/add_nodes_after_finalize.cpp +++ b/sycl/test-e2e/Graph/Explicit/add_nodes_after_finalize.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_EXPLICIT diff --git a/sycl/test-e2e/Graph/Explicit/basic_usm.cpp b/sycl/test-e2e/Graph/Explicit/basic_usm.cpp index 00940dcd6d68c..6e76ec42c079e 100644 --- a/sycl/test-e2e/Graph/Explicit/basic_usm.cpp +++ b/sycl/test-e2e/Graph/Explicit/basic_usm.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable the tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_EXPLICIT diff --git a/sycl/test-e2e/Graph/Explicit/basic_usm_host.cpp b/sycl/test-e2e/Graph/Explicit/basic_usm_host.cpp index fd8fcec4b89d2..040ce8c30c38b 100644 --- a/sycl/test-e2e/Graph/Explicit/basic_usm_host.cpp +++ b/sycl/test-e2e/Graph/Explicit/basic_usm_host.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable the tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_EXPLICIT diff --git a/sycl/test-e2e/Graph/Explicit/basic_usm_mixed.cpp b/sycl/test-e2e/Graph/Explicit/basic_usm_mixed.cpp index 5855fc25ed4cc..bb12ff6006004 100644 --- a/sycl/test-e2e/Graph/Explicit/basic_usm_mixed.cpp +++ b/sycl/test-e2e/Graph/Explicit/basic_usm_mixed.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable the tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_EXPLICIT diff --git a/sycl/test-e2e/Graph/Explicit/basic_usm_shared.cpp b/sycl/test-e2e/Graph/Explicit/basic_usm_shared.cpp index 3be8febbe008e..f989a27a1ca39 100644 --- a/sycl/test-e2e/Graph/Explicit/basic_usm_shared.cpp +++ b/sycl/test-e2e/Graph/Explicit/basic_usm_shared.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable the tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_EXPLICIT diff --git a/sycl/test-e2e/Graph/Explicit/empty_node.cpp b/sycl/test-e2e/Graph/Explicit/empty_node.cpp index 301c53aa69795..7f7501175899c 100644 --- a/sycl/test-e2e/Graph/Explicit/empty_node.cpp +++ b/sycl/test-e2e/Graph/Explicit/empty_node.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_EXPLICIT diff --git a/sycl/test-e2e/Graph/Explicit/host_task.cpp b/sycl/test-e2e/Graph/Explicit/host_task.cpp index 62bcd167e484f..167219bf4b8ef 100644 --- a/sycl/test-e2e/Graph/Explicit/host_task.cpp +++ b/sycl/test-e2e/Graph/Explicit/host_task.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_EXPLICIT diff --git a/sycl/test-e2e/Graph/Explicit/host_task2.cpp b/sycl/test-e2e/Graph/Explicit/host_task2.cpp index 78be02a7bc991..f7d59f48aac09 100644 --- a/sycl/test-e2e/Graph/Explicit/host_task2.cpp +++ b/sycl/test-e2e/Graph/Explicit/host_task2.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_EXPLICIT diff --git a/sycl/test-e2e/Graph/Explicit/host_task_last.cpp b/sycl/test-e2e/Graph/Explicit/host_task_last.cpp index 26dcf148d6f7d..aed2916284cc1 100644 --- a/sycl/test-e2e/Graph/Explicit/host_task_last.cpp +++ b/sycl/test-e2e/Graph/Explicit/host_task_last.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_EXPLICIT diff --git a/sycl/test-e2e/Graph/Explicit/host_task_multiple_deps.cpp b/sycl/test-e2e/Graph/Explicit/host_task_multiple_deps.cpp index 32c7157d0958c..3d03b7f6013ad 100644 --- a/sycl/test-e2e/Graph/Explicit/host_task_multiple_deps.cpp +++ b/sycl/test-e2e/Graph/Explicit/host_task_multiple_deps.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_EXPLICIT diff --git a/sycl/test-e2e/Graph/Explicit/host_task_single.cpp b/sycl/test-e2e/Graph/Explicit/host_task_single.cpp index b2236b9a0d91b..6fc8744e04c18 100644 --- a/sycl/test-e2e/Graph/Explicit/host_task_single.cpp +++ b/sycl/test-e2e/Graph/Explicit/host_task_single.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_EXPLICIT diff --git a/sycl/test-e2e/Graph/Explicit/host_task_successive.cpp b/sycl/test-e2e/Graph/Explicit/host_task_successive.cpp index 2147d075715af..da26b8b182296 100644 --- a/sycl/test-e2e/Graph/Explicit/host_task_successive.cpp +++ b/sycl/test-e2e/Graph/Explicit/host_task_successive.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_EXPLICIT diff --git a/sycl/test-e2e/Graph/Explicit/memadvise.cpp b/sycl/test-e2e/Graph/Explicit/memadvise.cpp index 1a8313478ddb5..11e0d6296290f 100644 --- a/sycl/test-e2e/Graph/Explicit/memadvise.cpp +++ b/sycl/test-e2e/Graph/Explicit/memadvise.cpp @@ -2,10 +2,7 @@ // RUN: %if linux && (level_zero || cuda) %{ env SYCL_PI_TRACE=2 %{run} %t.out 2>&1 FileCheck %s %} %else %{ %{run} %t.out %} // Mem advise command not supported for OpenCL -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: opencl, gpu-intel-dg2 +// UNSUPPORTED: opencl // Since Mem advise is only a memory hint that doesn't // impact results but only performances, we verify diff --git a/sycl/test-e2e/Graph/Explicit/multiple_exec_graphs.cpp b/sycl/test-e2e/Graph/Explicit/multiple_exec_graphs.cpp index e9c76ad01113b..a83775b8ecb8a 100644 --- a/sycl/test-e2e/Graph/Explicit/multiple_exec_graphs.cpp +++ b/sycl/test-e2e/Graph/Explicit/multiple_exec_graphs.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_EXPLICIT diff --git a/sycl/test-e2e/Graph/Explicit/prefetch.cpp b/sycl/test-e2e/Graph/Explicit/prefetch.cpp index 4b670ebc89357..8e0e6e15c292d 100644 --- a/sycl/test-e2e/Graph/Explicit/prefetch.cpp +++ b/sycl/test-e2e/Graph/Explicit/prefetch.cpp @@ -2,10 +2,7 @@ // RUN: %if linux && (level_zero || cuda) %{ env SYCL_PI_TRACE=2 %{run} %t.out 2>&1 FileCheck %s %} %else %{ %{run} %t.out %} // prefetch command not supported for OpenCL -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: opencl, gpu-intel-dg2 +// UNSUPPORTED: opencl // Since Prefetch is only a memory hint that doesn't // impact results but only performances, we verify diff --git a/sycl/test-e2e/Graph/Explicit/queue_constructor_usm.cpp b/sycl/test-e2e/Graph/Explicit/queue_constructor_usm.cpp index 0760b5805e6d9..a62996ebffb3a 100644 --- a/sycl/test-e2e/Graph/Explicit/queue_constructor_usm.cpp +++ b/sycl/test-e2e/Graph/Explicit/queue_constructor_usm.cpp @@ -1,14 +1,10 @@ // RUN: %{build} -o %t.out // RUN: %{run} %t.out // Extra run to check for leaks in Level Zero using UR_L0_LEAKS_DEBUG -// RUN: %if level_zero %{env UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s %} +// RUN: %if level_zero %{env UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} +// Extra run to check for immediate-command-list in Level Zero +// RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// CHECK-NOT: LEAK -// -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable the tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_EXPLICIT diff --git a/sycl/test-e2e/Graph/Explicit/queue_shortcuts.cpp b/sycl/test-e2e/Graph/Explicit/queue_shortcuts.cpp index 85d3b106bc3cd..a2589cda54320 100644 --- a/sycl/test-e2e/Graph/Explicit/queue_shortcuts.cpp +++ b/sycl/test-e2e/Graph/Explicit/queue_shortcuts.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_EXPLICIT diff --git a/sycl/test-e2e/Graph/Explicit/repeated_exec.cpp b/sycl/test-e2e/Graph/Explicit/repeated_exec.cpp index 935f431b09332..8b1f6ba3d4455 100644 --- a/sycl/test-e2e/Graph/Explicit/repeated_exec.cpp +++ b/sycl/test-e2e/Graph/Explicit/repeated_exec.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_EXPLICIT diff --git a/sycl/test-e2e/Graph/Explicit/sub_graph.cpp b/sycl/test-e2e/Graph/Explicit/sub_graph.cpp index c60aa2f63e34f..830cc5a42a668 100644 --- a/sycl/test-e2e/Graph/Explicit/sub_graph.cpp +++ b/sycl/test-e2e/Graph/Explicit/sub_graph.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable the tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_EXPLICIT diff --git a/sycl/test-e2e/Graph/Explicit/sub_graph_execute_without_parent.cpp b/sycl/test-e2e/Graph/Explicit/sub_graph_execute_without_parent.cpp index 772c07599300f..bc3cb1c8f352d 100644 --- a/sycl/test-e2e/Graph/Explicit/sub_graph_execute_without_parent.cpp +++ b/sycl/test-e2e/Graph/Explicit/sub_graph_execute_without_parent.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_EXPLICIT diff --git a/sycl/test-e2e/Graph/Explicit/sub_graph_multiple_submission.cpp b/sycl/test-e2e/Graph/Explicit/sub_graph_multiple_submission.cpp index 17cdde9b87956..92add086ee20d 100644 --- a/sycl/test-e2e/Graph/Explicit/sub_graph_multiple_submission.cpp +++ b/sycl/test-e2e/Graph/Explicit/sub_graph_multiple_submission.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_EXPLICIT diff --git a/sycl/test-e2e/Graph/Explicit/sub_graph_nested.cpp b/sycl/test-e2e/Graph/Explicit/sub_graph_nested.cpp index 7fd72c79722d4..05ecfbd982a01 100644 --- a/sycl/test-e2e/Graph/Explicit/sub_graph_nested.cpp +++ b/sycl/test-e2e/Graph/Explicit/sub_graph_nested.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_EXPLICIT diff --git a/sycl/test-e2e/Graph/Explicit/sub_graph_two_parent_graphs.cpp b/sycl/test-e2e/Graph/Explicit/sub_graph_two_parent_graphs.cpp index d43e7e221e68c..8fa8e0c334de2 100644 --- a/sycl/test-e2e/Graph/Explicit/sub_graph_two_parent_graphs.cpp +++ b/sycl/test-e2e/Graph/Explicit/sub_graph_two_parent_graphs.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_EXPLICIT diff --git a/sycl/test-e2e/Graph/Explicit/usm_copy.cpp b/sycl/test-e2e/Graph/Explicit/usm_copy.cpp index 6b60911d4627e..323d3e35935ac 100644 --- a/sycl/test-e2e/Graph/Explicit/usm_copy.cpp +++ b/sycl/test-e2e/Graph/Explicit/usm_copy.cpp @@ -7,10 +7,7 @@ // // // USM copy command not supported for OpenCL -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: opencl, gpu-intel-dg2 +// UNSUPPORTED: opencl #define GRAPH_E2E_EXPLICIT diff --git a/sycl/test-e2e/Graph/Explicit/usm_fill.cpp b/sycl/test-e2e/Graph/Explicit/usm_fill.cpp index 966809cf5a8d3..86076768f5d32 100644 --- a/sycl/test-e2e/Graph/Explicit/usm_fill.cpp +++ b/sycl/test-e2e/Graph/Explicit/usm_fill.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_EXPLICIT diff --git a/sycl/test-e2e/Graph/Explicit/usm_fill_shared.cpp b/sycl/test-e2e/Graph/Explicit/usm_fill_shared.cpp index 53feb52cad798..e0100d42d7267 100644 --- a/sycl/test-e2e/Graph/Explicit/usm_fill_shared.cpp +++ b/sycl/test-e2e/Graph/Explicit/usm_fill_shared.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_EXPLICIT diff --git a/sycl/test-e2e/Graph/Explicit/usm_memset.cpp b/sycl/test-e2e/Graph/Explicit/usm_memset.cpp index 50821fd8d008b..e9bb9ebab0fa9 100644 --- a/sycl/test-e2e/Graph/Explicit/usm_memset.cpp +++ b/sycl/test-e2e/Graph/Explicit/usm_memset.cpp @@ -6,10 +6,7 @@ // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // // USM memset command not supported for OpenCL -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: opencl, gpu-intel-dg2 +// UNSUPPORTED: opencl #define GRAPH_E2E_EXPLICIT diff --git a/sycl/test-e2e/Graph/RecordReplay/add_nodes_after_finalize.cpp b/sycl/test-e2e/Graph/RecordReplay/add_nodes_after_finalize.cpp index c0729ebb3a015..ba81666277e44 100644 --- a/sycl/test-e2e/Graph/RecordReplay/add_nodes_after_finalize.cpp +++ b/sycl/test-e2e/Graph/RecordReplay/add_nodes_after_finalize.cpp @@ -7,10 +7,7 @@ // // // Temporarily disabled until failure is addressed. -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: windows, gpu-intel-dg2 +// UNSUPPORTED: windows #define GRAPH_E2E_RECORD_REPLAY diff --git a/sycl/test-e2e/Graph/RecordReplay/after_use.cpp b/sycl/test-e2e/Graph/RecordReplay/after_use.cpp index 4a87a09e0fbce..767ca8b425ab7 100644 --- a/sycl/test-e2e/Graph/RecordReplay/after_use.cpp +++ b/sycl/test-e2e/Graph/RecordReplay/after_use.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable the tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 // This test attempts recording a set of kernels after they have already been // executed once before. diff --git a/sycl/test-e2e/Graph/RecordReplay/barrier_with_work.cpp b/sycl/test-e2e/Graph/RecordReplay/barrier_with_work.cpp index 951a016994261..c12038ba46185 100644 --- a/sycl/test-e2e/Graph/RecordReplay/barrier_with_work.cpp +++ b/sycl/test-e2e/Graph/RecordReplay/barrier_with_work.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable the tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #include "../graph_common.hpp" diff --git a/sycl/test-e2e/Graph/RecordReplay/basic_usm.cpp b/sycl/test-e2e/Graph/RecordReplay/basic_usm.cpp index bcdfb702b78c7..ffddf70716250 100644 --- a/sycl/test-e2e/Graph/RecordReplay/basic_usm.cpp +++ b/sycl/test-e2e/Graph/RecordReplay/basic_usm.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable the tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_RECORD_REPLAY diff --git a/sycl/test-e2e/Graph/RecordReplay/basic_usm_host.cpp b/sycl/test-e2e/Graph/RecordReplay/basic_usm_host.cpp index b71fd0a690220..a90931934f0ce 100644 --- a/sycl/test-e2e/Graph/RecordReplay/basic_usm_host.cpp +++ b/sycl/test-e2e/Graph/RecordReplay/basic_usm_host.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable the tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_RECORD_REPLAY diff --git a/sycl/test-e2e/Graph/RecordReplay/basic_usm_mixed.cpp b/sycl/test-e2e/Graph/RecordReplay/basic_usm_mixed.cpp index 74bc18a7b3496..410850f5ff7a8 100644 --- a/sycl/test-e2e/Graph/RecordReplay/basic_usm_mixed.cpp +++ b/sycl/test-e2e/Graph/RecordReplay/basic_usm_mixed.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable the tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_RECORD_REPLAY diff --git a/sycl/test-e2e/Graph/RecordReplay/basic_usm_shared.cpp b/sycl/test-e2e/Graph/RecordReplay/basic_usm_shared.cpp index 51e4597354473..2f19c2706380b 100644 --- a/sycl/test-e2e/Graph/RecordReplay/basic_usm_shared.cpp +++ b/sycl/test-e2e/Graph/RecordReplay/basic_usm_shared.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable the tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_RECORD_REPLAY diff --git a/sycl/test-e2e/Graph/RecordReplay/empty_node.cpp b/sycl/test-e2e/Graph/RecordReplay/empty_node.cpp index 2155b226e2fc3..70128db712f78 100644 --- a/sycl/test-e2e/Graph/RecordReplay/empty_node.cpp +++ b/sycl/test-e2e/Graph/RecordReplay/empty_node.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_RECORD_REPLAY diff --git a/sycl/test-e2e/Graph/RecordReplay/host_task.cpp b/sycl/test-e2e/Graph/RecordReplay/host_task.cpp index 4f4d50fe3b3f3..582a3fb3f14ff 100644 --- a/sycl/test-e2e/Graph/RecordReplay/host_task.cpp +++ b/sycl/test-e2e/Graph/RecordReplay/host_task.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_RECORD_REPLAY diff --git a/sycl/test-e2e/Graph/RecordReplay/host_task2.cpp b/sycl/test-e2e/Graph/RecordReplay/host_task2.cpp index cd867eb4caadd..f947a13ffd63d 100644 --- a/sycl/test-e2e/Graph/RecordReplay/host_task2.cpp +++ b/sycl/test-e2e/Graph/RecordReplay/host_task2.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_RECORD_REPLAY diff --git a/sycl/test-e2e/Graph/RecordReplay/host_task_in_order.cpp b/sycl/test-e2e/Graph/RecordReplay/host_task_in_order.cpp index c3037c78d8eaf..e40fe3a0e963c 100644 --- a/sycl/test-e2e/Graph/RecordReplay/host_task_in_order.cpp +++ b/sycl/test-e2e/Graph/RecordReplay/host_task_in_order.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable the tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 // This test uses a host_task when adding a command_graph node to an // in-order queue. diff --git a/sycl/test-e2e/Graph/RecordReplay/host_task_last.cpp b/sycl/test-e2e/Graph/RecordReplay/host_task_last.cpp index 64d625197f089..c8dfa02c63ea7 100644 --- a/sycl/test-e2e/Graph/RecordReplay/host_task_last.cpp +++ b/sycl/test-e2e/Graph/RecordReplay/host_task_last.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_RECORD_REPLAY diff --git a/sycl/test-e2e/Graph/RecordReplay/host_task_multiple_deps.cpp b/sycl/test-e2e/Graph/RecordReplay/host_task_multiple_deps.cpp index a8ff9b53637cd..7e312df58d092 100644 --- a/sycl/test-e2e/Graph/RecordReplay/host_task_multiple_deps.cpp +++ b/sycl/test-e2e/Graph/RecordReplay/host_task_multiple_deps.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_RECORD_REPLAY diff --git a/sycl/test-e2e/Graph/RecordReplay/host_task_single.cpp b/sycl/test-e2e/Graph/RecordReplay/host_task_single.cpp index 4e2730592ef95..6d86cef96c862 100644 --- a/sycl/test-e2e/Graph/RecordReplay/host_task_single.cpp +++ b/sycl/test-e2e/Graph/RecordReplay/host_task_single.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_RECORD_REPLAY diff --git a/sycl/test-e2e/Graph/RecordReplay/host_task_successive.cpp b/sycl/test-e2e/Graph/RecordReplay/host_task_successive.cpp index e5570cb61a2d3..51da588ab9444 100644 --- a/sycl/test-e2e/Graph/RecordReplay/host_task_successive.cpp +++ b/sycl/test-e2e/Graph/RecordReplay/host_task_successive.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_RECORD_REPLAY diff --git a/sycl/test-e2e/Graph/RecordReplay/memadvise.cpp b/sycl/test-e2e/Graph/RecordReplay/memadvise.cpp index 1f7989f9a0361..a5b87f8143832 100644 --- a/sycl/test-e2e/Graph/RecordReplay/memadvise.cpp +++ b/sycl/test-e2e/Graph/RecordReplay/memadvise.cpp @@ -2,10 +2,7 @@ // RUN: %if linux && (level_zero || cuda) %{ env SYCL_PI_TRACE=2 %{run} %t.out 2>&1 FileCheck %s %} %else %{ %{run} %t.out %} // Mem advise command not supported for OpenCL -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: opencl, gpu-intel-dg2 +// UNSUPPORTED: opencl // Since Mem advise is only a memory hint that doesn't // impact results but only performances, we verify diff --git a/sycl/test-e2e/Graph/RecordReplay/multiple_exec_graphs.cpp b/sycl/test-e2e/Graph/RecordReplay/multiple_exec_graphs.cpp index 0709d25e225bd..67b5335de4383 100644 --- a/sycl/test-e2e/Graph/RecordReplay/multiple_exec_graphs.cpp +++ b/sycl/test-e2e/Graph/RecordReplay/multiple_exec_graphs.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_RECORD_REPLAY diff --git a/sycl/test-e2e/Graph/RecordReplay/prefetch.cpp b/sycl/test-e2e/Graph/RecordReplay/prefetch.cpp index a5a18c08c6b66..dca297f7772b3 100644 --- a/sycl/test-e2e/Graph/RecordReplay/prefetch.cpp +++ b/sycl/test-e2e/Graph/RecordReplay/prefetch.cpp @@ -2,10 +2,7 @@ // RUN: %if linux && (level_zero || cuda) %{ env SYCL_PI_TRACE=2 %{run} %t.out 2>&1 FileCheck %s %} %else %{ %{run} %t.out %} // prefetch command not supported for OpenCL -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: opencl, gpu-intel-dg2 +// UNSUPPORTED: opencl // Since Prefetch is only a memory hint that doesn't // impact results but only performances, we verify diff --git a/sycl/test-e2e/Graph/RecordReplay/queue_constructor_usm.cpp b/sycl/test-e2e/Graph/RecordReplay/queue_constructor_usm.cpp index a88e462461a04..75e7b007e404b 100644 --- a/sycl/test-e2e/Graph/RecordReplay/queue_constructor_usm.cpp +++ b/sycl/test-e2e/Graph/RecordReplay/queue_constructor_usm.cpp @@ -1,14 +1,10 @@ // RUN: %{build} -o %t.out // RUN: %{run} %t.out // Extra run to check for leaks in Level Zero using UR_L0_LEAKS_DEBUG -// RUN: %if level_zero %{env UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s %} +// RUN: %if level_zero %{env UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} +// Extra run to check for immediate-command-list in Level Zero +// RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// CHECK-NOT: LEAK -// -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable the tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_RECORD_REPLAY diff --git a/sycl/test-e2e/Graph/RecordReplay/queue_shortcuts.cpp b/sycl/test-e2e/Graph/RecordReplay/queue_shortcuts.cpp index d5e9520417a71..99a28bd745853 100644 --- a/sycl/test-e2e/Graph/RecordReplay/queue_shortcuts.cpp +++ b/sycl/test-e2e/Graph/RecordReplay/queue_shortcuts.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_RECORD_REPLAY diff --git a/sycl/test-e2e/Graph/RecordReplay/repeated_exec.cpp b/sycl/test-e2e/Graph/RecordReplay/repeated_exec.cpp index 9e2416541e091..badf7293f49cb 100644 --- a/sycl/test-e2e/Graph/RecordReplay/repeated_exec.cpp +++ b/sycl/test-e2e/Graph/RecordReplay/repeated_exec.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_RECORD_REPLAY diff --git a/sycl/test-e2e/Graph/RecordReplay/sub_graph.cpp b/sycl/test-e2e/Graph/RecordReplay/sub_graph.cpp index 37e29e16edf40..2096a7c7a21f7 100644 --- a/sycl/test-e2e/Graph/RecordReplay/sub_graph.cpp +++ b/sycl/test-e2e/Graph/RecordReplay/sub_graph.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable the tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_RECORD_REPLAY diff --git a/sycl/test-e2e/Graph/RecordReplay/sub_graph_execute_without_parent.cpp b/sycl/test-e2e/Graph/RecordReplay/sub_graph_execute_without_parent.cpp index b7442d24c6f1d..f1aeef51f1c31 100644 --- a/sycl/test-e2e/Graph/RecordReplay/sub_graph_execute_without_parent.cpp +++ b/sycl/test-e2e/Graph/RecordReplay/sub_graph_execute_without_parent.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_RECORD_REPLAY diff --git a/sycl/test-e2e/Graph/RecordReplay/sub_graph_multiple_submission.cpp b/sycl/test-e2e/Graph/RecordReplay/sub_graph_multiple_submission.cpp index 57b4c1cd3abdd..d26f99a34c290 100644 --- a/sycl/test-e2e/Graph/RecordReplay/sub_graph_multiple_submission.cpp +++ b/sycl/test-e2e/Graph/RecordReplay/sub_graph_multiple_submission.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_RECORD_REPLAY diff --git a/sycl/test-e2e/Graph/RecordReplay/sub_graph_nested.cpp b/sycl/test-e2e/Graph/RecordReplay/sub_graph_nested.cpp index e78794733dc42..f2b7ca35a77d7 100644 --- a/sycl/test-e2e/Graph/RecordReplay/sub_graph_nested.cpp +++ b/sycl/test-e2e/Graph/RecordReplay/sub_graph_nested.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_RECORD_REPLAY diff --git a/sycl/test-e2e/Graph/RecordReplay/sub_graph_two_parent_graphs.cpp b/sycl/test-e2e/Graph/RecordReplay/sub_graph_two_parent_graphs.cpp index 8c3c5f0980c55..a1d0373290cc6 100644 --- a/sycl/test-e2e/Graph/RecordReplay/sub_graph_two_parent_graphs.cpp +++ b/sycl/test-e2e/Graph/RecordReplay/sub_graph_two_parent_graphs.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_RECORD_REPLAY diff --git a/sycl/test-e2e/Graph/RecordReplay/usm_copy.cpp b/sycl/test-e2e/Graph/RecordReplay/usm_copy.cpp index 1fdf104310623..c9257bd730079 100644 --- a/sycl/test-e2e/Graph/RecordReplay/usm_copy.cpp +++ b/sycl/test-e2e/Graph/RecordReplay/usm_copy.cpp @@ -6,10 +6,7 @@ // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // // USM copy command not supported for OpenCL -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable the tests while investigating the bug. -// UNSUPPORTED: opencl, gpu-intel-dg2 +// UNSUPPORTED: opencl #define GRAPH_E2E_RECORD_REPLAY diff --git a/sycl/test-e2e/Graph/RecordReplay/usm_fill.cpp b/sycl/test-e2e/Graph/RecordReplay/usm_fill.cpp index 66a9589d9e242..8e89ecc693ed7 100644 --- a/sycl/test-e2e/Graph/RecordReplay/usm_fill.cpp +++ b/sycl/test-e2e/Graph/RecordReplay/usm_fill.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_RECORD_REPLAY diff --git a/sycl/test-e2e/Graph/RecordReplay/usm_fill_shared.cpp b/sycl/test-e2e/Graph/RecordReplay/usm_fill_shared.cpp index ed959ca5a400b..401cdc7aa430f 100644 --- a/sycl/test-e2e/Graph/RecordReplay/usm_fill_shared.cpp +++ b/sycl/test-e2e/Graph/RecordReplay/usm_fill_shared.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 #define GRAPH_E2E_RECORD_REPLAY diff --git a/sycl/test-e2e/Graph/RecordReplay/usm_memset.cpp b/sycl/test-e2e/Graph/RecordReplay/usm_memset.cpp index 86c533110f26b..137b3df19cf02 100644 --- a/sycl/test-e2e/Graph/RecordReplay/usm_memset.cpp +++ b/sycl/test-e2e/Graph/RecordReplay/usm_memset.cpp @@ -6,10 +6,7 @@ // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // USM memset command not supported for OpenCL -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: opencl, gpu-intel-dg2 +// UNSUPPORTED: opencl #define GRAPH_E2E_RECORD_REPLAY diff --git a/sycl/test-e2e/Graph/empty_graph.cpp b/sycl/test-e2e/Graph/empty_graph.cpp index c574d65e9357f..ff4984603d908 100644 --- a/sycl/test-e2e/Graph/empty_graph.cpp +++ b/sycl/test-e2e/Graph/empty_graph.cpp @@ -5,10 +5,6 @@ // Extra run to check for immediate-command-list in Level Zero // RUN: %if level_zero && linux %{env SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1 UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK %} // -// Post-commit test failed -// https://github.com/intel/llvm/actions/runs/7814201804/job/21315560479 -// Temporarily disable USM based tests while investigating the bug. -// UNSUPPORTED: gpu-intel-dg2 // Tests the ability to finalize and submit a command graph which doesn't // contain any nodes. From 73d34739bff5848cca075fbec415e06f67848efe Mon Sep 17 00:00:00 2001 From: Artur Gainullin Date: Fri, 9 Feb 2024 08:24:57 -0800 Subject: [PATCH 8/8] [SYCL] Choose image with inlined default values if default value is set explicitly (#12626) If -fsycl-add-default-spec-consts-image option is used then DPCPP generates a device image where default values of specialization constants are inlined (in addition to regular device image). Currently we always choose regular device image if somebody calls `set_specialization_constant ` API. This PR improves this behavior: if `set_specialization_constant` sets the value equal to default value then we can choose the device image where default values of specialization constants are inlined. --- sycl/include/sycl/kernel_bundle.hpp | 2 + sycl/source/detail/device_image_impl.hpp | 68 ++++++++++++---- .../SpecConstants/2020/image_selection.cpp | 80 +++++++++++++++++++ 3 files changed, 133 insertions(+), 17 deletions(-) diff --git a/sycl/include/sycl/kernel_bundle.hpp b/sycl/include/sycl/kernel_bundle.hpp index 5bff42bf37f39..91caddfec75df 100644 --- a/sycl/include/sycl/kernel_bundle.hpp +++ b/sycl/include/sycl/kernel_bundle.hpp @@ -205,6 +205,8 @@ class __SYCL_EXPORT kernel_bundle_plain { void get_specialization_constant_impl(const char *SpecName, void *Value) const noexcept; + // \returns a bool value which indicates if specialization constant was set to + // a value different from default value. bool is_specialization_constant_set(const char *SpecName) const noexcept; detail::KernelBundleImplPtr impl; diff --git a/sycl/source/detail/device_image_impl.hpp b/sycl/source/detail/device_image_impl.hpp index db74a314222f9..f21bf3ccd0185 100644 --- a/sycl/source/detail/device_image_impl.hpp +++ b/sycl/source/detail/device_image_impl.hpp @@ -50,6 +50,8 @@ class device_image_impl { unsigned int CompositeOffset = 0; unsigned int Size = 0; unsigned int BlobOffset = 0; + // Indicates if the specialization constant was set to a value which is + // different from the default value. bool IsSet = false; }; @@ -61,7 +63,8 @@ class device_image_impl { sycl::detail::pi::PiProgram Program) : MBinImage(BinImage), MContext(std::move(Context)), MDevices(std::move(Devices)), MState(State), MProgram(Program), - MKernelIDs(std::move(KernelIDs)) { + MKernelIDs(std::move(KernelIDs)), + MSpecConstsDefValBlob(getSpecConstsDefValBlob()) { updateSpecConstSymMap(); } @@ -74,6 +77,7 @@ class device_image_impl { : MBinImage(BinImage), MContext(std::move(Context)), MDevices(std::move(Devices)), MState(State), MProgram(Program), MKernelIDs(std::move(KernelIDs)), MSpecConstsBlob(SpecConstsBlob), + MSpecConstsDefValBlob(getSpecConstsDefValBlob()), MSpecConstSymMap(SpecConstMap) {} bool has_kernel(const kernel_id &KernelIDCand) const noexcept { @@ -152,6 +156,21 @@ class device_image_impl { std::vector &Descs = MSpecConstSymMap[std::string{SpecName}]; for (SpecConstDescT &Desc : Descs) { + // If there is a default value of the specialization constant and it is + // the same as the value which is being set then do nothing, runtime is + // going to handle this case just like if only the default value of the + // specialization constant was provided. + if (MSpecConstsDefValBlob.size() && + (std::memcmp(MSpecConstsDefValBlob.begin() + Desc.BlobOffset, + static_cast(Value) + Desc.CompositeOffset, + Desc.Size) == 0)) { + // Now we have default value, so reset to false. + Desc.IsSet = false; + continue; + } + + // Value of the specialization constant is set to a value which is + // different from the default value. Desc.IsSet = true; std::memcpy(MSpecConstsBlob.data() + Desc.BlobOffset, static_cast(Value) + Desc.CompositeOffset, @@ -161,19 +180,20 @@ class device_image_impl { void get_specialization_constant_raw_value(const char *SpecName, void *ValueRet) const noexcept { - assert(is_specialization_constant_set(SpecName)); + bool IsSet = is_specialization_constant_set(SpecName); // Lock the mutex to prevent when one thread in the middle of writing a // new value while another thread is reading the value to pass it to // JIT compiler. const std::lock_guard SpecConstLock(MSpecConstAccessMtx); - + assert(IsSet || MSpecConstsDefValBlob.size()); // operator[] can't be used here, since it's not marked as const const std::vector &Descs = MSpecConstSymMap.at(std::string{SpecName}); for (const SpecConstDescT &Desc : Descs) { - + auto Blob = + IsSet ? MSpecConstsBlob.data() : MSpecConstsDefValBlob.begin(); std::memcpy(static_cast(ValueRet) + Desc.CompositeOffset, - MSpecConstsBlob.data() + Desc.BlobOffset, Desc.Size); + Blob + Desc.BlobOffset, Desc.Size); } } @@ -293,16 +313,30 @@ class device_image_impl { } private: + // Get the specialization constant default value blob. + ByteArray getSpecConstsDefValBlob() const { + if (!MBinImage) + return ByteArray(nullptr, 0); + + // Get default values for specialization constants. + const RTDeviceBinaryImage::PropertyRange &SCDefValRange = + MBinImage->getSpecConstantsDefaultValues(); + if (!SCDefValRange.size()) + return ByteArray(nullptr, 0); + + ByteArray DefValDescriptors = + DeviceBinaryProperty(*SCDefValRange.begin()).asByteArray(); + // First 8 bytes are consumed by the size of the property. + DefValDescriptors.dropBytes(8); + return DefValDescriptors; + } + void updateSpecConstSymMap() { if (MBinImage) { const RTDeviceBinaryImage::PropertyRange &SCRange = MBinImage->getSpecConstants(); using SCItTy = RTDeviceBinaryImage::PropertyRange::ConstIterator; - // get default values for specialization constants - const RTDeviceBinaryImage::PropertyRange &SCDefValRange = - MBinImage->getSpecConstantsDefaultValues(); - // This variable is used to calculate spec constant value offset in a // flat byte array. unsigned BlobOffset = 0; @@ -341,16 +375,13 @@ class device_image_impl { } MSpecConstsBlob.resize(BlobOffset); - bool HasDefaultValues = SCDefValRange.begin() != SCDefValRange.end(); - - if (HasDefaultValues) { - ByteArray DefValDescriptors = - DeviceBinaryProperty(*SCDefValRange.begin()).asByteArray(); - assert(DefValDescriptors.size() - 8 == MSpecConstsBlob.size() && + if (MSpecConstsDefValBlob.size()) { + assert(MSpecConstsDefValBlob.size() == MSpecConstsBlob.size() && "Specialization constant default value blob do not have the " "expected size."); - std::uninitialized_copy(&DefValDescriptors[8], - &DefValDescriptors[8] + MSpecConstsBlob.size(), + std::uninitialized_copy(MSpecConstsDefValBlob.begin(), + MSpecConstsDefValBlob.begin() + + MSpecConstsBlob.size(), MSpecConstsBlob.data()); } } @@ -372,6 +403,9 @@ class device_image_impl { // Binary blob which can have values of all specialization constants in the // image std::vector MSpecConstsBlob; + // Binary blob which can have default values of all specialization constants + // in the image. + const ByteArray MSpecConstsDefValBlob; // Buffer containing binary blob which can have values of all specialization // constants in the image, it is using for storing non-native specialization // constants diff --git a/sycl/test-e2e/SpecConstants/2020/image_selection.cpp b/sycl/test-e2e/SpecConstants/2020/image_selection.cpp index ec3c65d2b1a5b..8d0d424d2fa8a 100644 --- a/sycl/test-e2e/SpecConstants/2020/image_selection.cpp +++ b/sycl/test-e2e/SpecConstants/2020/image_selection.cpp @@ -23,12 +23,33 @@ // RUN: env SYCL_PI_TRACE=-1 %{run} %t3.out | FileCheck --match-full-lines --check-prefix=CHECK-MIX %s // clang-format on +// Check the behaviour when -fsycl-add-default-spec-consts-image option is used +// and default value is explicitly set with the same value - we are supposed to +// choose images with inlined values in this case. + +// clang-format off +// RUN: %clangxx -fsycl-add-default-spec-consts-image -fsycl -fsycl-targets=spir64_gen -Xsycl-target-backend=spir64_gen %gpu_aot_target_opts %s -o %t3.out +// RUN: env SYCL_PI_TRACE=-1 %{run} %t3.out | FileCheck --match-full-lines --check-prefix=CHECK-DEFAULT-EXPLICIT-SET %s +// clang-format on + +// Check the behaviour when -fsycl-add-default-spec-consts-image option is used +// and value of specialization constant is changed to new value and then back to +// the default value - we are supposed to choose images with inlined values in +// this case. + +// clang-format off +// RUN: %clangxx -fsycl-add-default-spec-consts-image -fsycl -fsycl-targets=spir64_gen -Xsycl-target-backend=spir64_gen %gpu_aot_target_opts %s -o %t3.out +// RUN: env SYCL_PI_TRACE=-1 %{run} %t3.out | FileCheck --match-full-lines --check-prefix=CHECK-DEFAULT-BACK-TO-DEFAULT %s +// clang-format on + #include constexpr sycl::specialization_id int_id(3); class Kernel1; class Kernel2; +class Kernel3; +class Kernel4; int main() { sycl::queue Q; @@ -189,5 +210,64 @@ int main() { else std::cout << "Default value of specialization constant was used." << std::endl; + + // Test that if user calls set_specialization_constant with the value equal to + // default then we choose image with inlined default values of specialization + // constants. We are verifying that by checking the 4th parameter is set to + // zero. + // CHECK-DEFAULT-EXPLICIT-SET: Default value was explicitly set + // CHECK-DEFAULT-EXPLICIT-SET: ---> piextKernelSetArgMemObj( + // CHECK-DEFAULT-EXPLICIT-SET-NEXT: : {{.*}} + // CHECK-DEFAULT-EXPLICIT-SET-NEXT: : {{.*}} + // CHECK-DEFAULT-EXPLICIT-SET-NEXT: : {{.*}} + // CHECK-DEFAULT-EXPLICIT-SET-NEXT: : 0 + // CHECK-DEFAULT-EXPLICIT-SET-NEXT: ) ---> pi_result : PI_SUCCESS + // CHECK-DEFAULT-EXPLICIT-SET: Default value of specialization constant was used. + std::cout << "Default value was explicitly set" << std::endl; + Q.submit([&](sycl::handler &cgh) { + cgh.set_specialization_constant(3); + + cgh.single_task([=](sycl::kernel_handler h) { + auto SpecConst = h.get_specialization_constant(); + *Res = SpecConst == 3 ? 0 : 1; + }); + }).wait(); + + if (*Res) + std::cout << "New specialization constant value was set." << std::endl; + else + std::cout << "Default value of specialization constant was used." + << std::endl; + + // Test that if user sets new value of specialization constant and then + // changes it back to default value then we choose image with inlined default + // values of specialization constants. We are verifying that by checking the + // 4th parameter is set to zero. + // CHECK-DEFAULT-BACK-TO-DEFAULT: Changed to new value and then default value was explicitly set + // CHECK-DEFAULT-BACK-TO-DEFAULT: ---> piextKernelSetArgMemObj( + // CHECK-DEFAULT-BACK-TO-DEFAULT-NEXT: : {{.*}} + // CHECK-DEFAULT-BACK-TO-DEFAULT-NEXT: : {{.*}} + // CHECK-DEFAULT-BACK-TO-DEFAULT-NEXT: : {{.*}} + // CHECK-DEFAULT-BACK-TO-DEFAULT-NEXT: : 0 + // CHECK-DEFAULT-BACK-TO-DEFAULT-NEXT: ) ---> pi_result : PI_SUCCESS + // CHECK-DEFAULT-BACK-TO-DEFAULT: Default value of specialization constant was used. + std::cout << "Changed to new value and then default value was explicitly set" + << std::endl; + Q.submit([&](sycl::handler &cgh) { + cgh.set_specialization_constant(4); + cgh.set_specialization_constant(3); + + cgh.single_task([=](sycl::kernel_handler h) { + auto SpecConst = h.get_specialization_constant(); + *Res = SpecConst == 3 ? 0 : 1; + }); + }).wait(); + + if (*Res) + std::cout << "New specialization constant value was set." << std::endl; + else + std::cout << "Default value of specialization constant was used." + << std::endl; + return 0; }