[SYCL] do not test zero level backend with other backends

Author: dklochkov-emb

sycl/include/sycl/backend.hpp

@@ -350,9 +350,18 @@ make_queue(const typename backend_traits<Backend>::template input_type<queue>
            const context &TargetContext, const async_handler Handler = {}) {
   auto KeepOwnership =
       Backend == backend::ext_oneapi_cuda || Backend == backend::ext_oneapi_hip;
-  return detail::make_queue(detail::ur::cast<ur_native_handle_t>(BackendObject),
+      if constexpr (Backend == backend::ext_oneapi_level_zero)
+      {
+        return detail::make_queue(detail::ur::cast<ur_native_handle_t>(std::get<ze_command_queue_handle_t>(BackendObject.NativeHandle)),
                             false, TargetContext, nullptr, KeepOwnership, {},
                             Handler, Backend);
+      }
+      if constexpr (Backend != backend::ext_oneapi_level_zero)
+      {
+        return detail::make_queue(detail::ur::cast<ur_native_handle_t>(BackendObject),
+                                  false, TargetContext, nullptr, KeepOwnership, {},
+                                  Handler, Backend);
+      }
 }
 
 template <backend Backend>
@@ -361,8 +370,16 @@ std::enable_if_t<detail::InteropFeatureSupportMap<Backend>::MakeEvent == true,
 make_event(const typename backend_traits<Backend>::template input_type<event>
                &BackendObject,
            const context &TargetContext) {
-  return detail::make_event(detail::ur::cast<ur_native_handle_t>(BackendObject),
+           if constexpr (Backend == backend::ext_oneapi_level_zero)
+           {
+              return detail::make_event(detail::ur::cast<ur_native_handle_t>(BackendObject.NativeHandle),
                             TargetContext, Backend);
+           }
+           if constexpr (Backend != backend::ext_oneapi_level_zero)
+           {
+              return detail::make_event(detail::ur::cast<ur_native_handle_t>(BackendObject),
+                              TargetContext, Backend);
+           }
 }
 
 template <backend Backend>

sycl/test-e2e/Basic/interop/Interop_level_zero_backend.cpp

@@ -0,0 +1,85 @@
+// RUN: %if any-device-is-level_zero %{ %{build} -isystem %sycl_include -DBUILD_FOR_L0 -o %t-l0.out %}
+
+#include <sycl/backend.hpp>
+#include <sycl/detail/core.hpp>
+#include <sycl/properties/all_properties.hpp>
+#include <sycl/usm.hpp>
+using namespace sycl;
+
+constexpr auto BACKEND = backend::ext_oneapi_level_zero;
+using nativeDevice = ze_device_handle_t;
+using nativeQueue = ze_command_queue_handle_t;
+using nativeEvent = ze_event_handle_t;
+
+constexpr int N = 100;
+constexpr int VAL = 3;
+
+int main() {
+
+  assert(static_cast<bool>(
+      std::is_same_v<backend_traits<BACKEND>::return_type<device>,
+                     nativeDevice>));
+  assert(static_cast<bool>(
+      std::is_same_v<backend_traits<BACKEND>::return_type<queue>,
+                     nativeQueue>));
+  assert(static_cast<bool>(
+      std::is_same_v<backend_traits<BACKEND>::return_type<event>,
+                     nativeEvent>));
+
+  device Device;
+  backend_traits<BACKEND>::return_type<device> NativeDevice =
+      get_native<BACKEND>(Device);
+  // Create sycl device with a native device.
+  auto InteropDevice = make_device<BACKEND>(NativeDevice);
+
+  context Context(InteropDevice);
+
+  // Create sycl queue with device created from a native device.
+  queue Queue(InteropDevice, {sycl::property::queue::in_order()});
+  backend_traits<BACKEND>::return_type<queue> NativeQueue =
+      get_native<BACKEND>(Queue);
+  backend_traits<BACKEND>::input_type<queue> InputType(NativeQueue, Device);
+  
+  auto InteropQueue = make_queue<BACKEND>(InputType, Context);
+
+  auto A = (int *)malloc_device(N * sizeof(int), InteropQueue);
+  std::vector<int> vec(N, 0);
+
+  auto Event = Queue.submit([&](handler &h) {
+    h.parallel_for<class kern1>(range<1>(N),
+                                [=](id<1> item) { A[item] = VAL; });
+  });
+
+  backend_traits<BACKEND>::return_type<event> NativeEvent =
+      get_native<BACKEND>(Event);
+  backend_traits<BACKEND>::input_type<event> EventInputType;
+  EventInputType.NativeHandle = NativeEvent;
+  // Create sycl event with a native event.
+  event InteropEvent = make_event<BACKEND>(EventInputType, Context);
+
+  // depends_on sycl event created from a native event.
+  auto Event2 = InteropQueue.submit([&](handler &h) {
+    h.depends_on(InteropEvent);
+    h.parallel_for<class kern2>(range<1>(N), [=](id<1> item) { A[item]++; });
+  });
+
+  auto Event3 = InteropQueue.memcpy(&vec[0], A, N * sizeof(int), Event2);
+  Event3.wait();
+
+  if constexpr (BACKEND == backend::ext_oneapi_hip) {
+    try {
+      backend_traits<BACKEND>::return_type<context> NativeContext =
+            get_native<BACKEND>(Context);
+    } catch (sycl::exception &e) {
+      assert(e.code() == sycl::errc::feature_not_supported);
+    }
+  }
+
+  free(A, InteropQueue);
+
+  for (const auto &val : vec) {
+    assert(val == VAL + 1);
+  }
+
+  return 0;
+}

sycl/test-e2e/Basic/interop/interop_all_backends.cpp

@@ -1,8 +1,5 @@
-// XFAIL: any-device-is-opencl, any-device-is-cuda, any-device-is-level_zero
-// XFAIL-TRACKER: https://github.com/intel/llvm/issues/15819
 // RUN: %if any-device-is-opencl %{ %{build} -o %t-opencl.out %}
-// RUN: %if any-device-is-level_zero %{ %{build} -DBUILD_FOR_L0 -o %t-l0.out %}
-// RUN: %if any-device-is-cuda %{ %{build} -DBUILD_FOR_CUDA -o %t-cuda.out %}
+// RUN: %if any-device-is-cuda %{ %{build} -isystem %sycl_include -DBUILD_FOR_CUDA -o %t-cuda.out %}
 // RUN: %if any-device-is-hip %{ %{build} -DBUILD_FOR_HIP -o %t-hip.out %}
 
 #include <sycl/backend.hpp>
@@ -12,6 +9,7 @@
 using namespace sycl;
 
 #ifdef BUILD_FOR_CUDA
+#include <sycl/ext/oneapi/experimental/backend/cuda.hpp>
 constexpr auto BACKEND = backend::ext_oneapi_cuda;
 using nativeDevice = CUdevice;
 using nativeQueue = CUstream;
@@ -22,11 +20,6 @@ constexpr auto BACKEND = backend::ext_oneapi_hip;
 using nativeDevice = device;
 using nativeQueue = ihipStream_t;
 using nativeEvent = ihipEvent_t;
-#elif defined(BUILD_FOR_L0)
-constexpr auto BACKEND = backend::ext_oneapi_level_zero;
-using nativeDevice = ze_device_handle_t;
-using nativeQueue = ze_command_queue_handle_t;
-using nativeEvent = ze_event_handle_t;
 #else
 constexpr auto BACKEND = backend::opencl;
 using nativeDevice = cl_device_id;