[SYCL] Get rid of using deprecated API in SYCL RT and tests (#5022)

Pavel Samolysov · web-flow · commit d3ab1454812e · 2021-11-29T17:04:30.000+03:00
The sycl::backend_return_t type alias is used as return type for all
the (deprecated) SyclObj.get_native() functions instead of the
sycl::detail::interop one. Also all the invokes of the SyclObj.get_native()
methods in the unit tests are replaced with the sycl::get_native()
free function.

All the unit tests use the new INSTANTIATE_TEST_SUITE_P googletest
macro instead of the deprecated INSTANTIATE_TEST_CASE_P one.

Usages of the deprecated function interop_task  are replaced with
host_task in unit tests.
diff --git a/sycl/include/CL/sycl/context.hpp b/sycl/include/CL/sycl/context.hpp
@@ -217,12 +217,10 @@ class __SYCL_EXPORT context {
   /// Gets the native handle of the SYCL context.
   ///
   /// \return a native handle, the type of which defined by the backend.
-  template <backend BackendName>
+  template <backend Backend>
   __SYCL_DEPRECATED("Use SYCL 2020 sycl::get_native free function")
-  auto get_native() const ->
-      typename detail::interop<BackendName, context>::type {
-    return reinterpret_cast<
-        typename detail::interop<BackendName, context>::type>(getNative());
+  backend_return_t<Backend, context> get_native() const {
+    return reinterpret_cast<backend_return_t<Backend, context>>(getNative());
   }
 
 private:
diff --git a/sycl/include/CL/sycl/device.hpp b/sycl/include/CL/sycl/device.hpp
@@ -186,11 +186,14 @@ class __SYCL_EXPORT device {
   /// Gets the native handle of the SYCL device.
   ///
   /// \return a native handle, the type of which defined by the backend.
-  template <backend BackendName>
+  template <backend Backend>
   __SYCL_DEPRECATED("Use SYCL 2020 sycl::get_native free function")
-  auto get_native() const ->
-      typename detail::interop<BackendName, device>::type {
-    return (typename detail::interop<BackendName, device>::type)getNative();
+  backend_return_t<Backend, device> get_native() const {
+    // In CUDA CUdevice isn't an opaque pointer, unlike a lot of the others,
+    // but instead a 32-bit int (on all relevant systems). Different
+    // backends use the same function for this purpose so static_cast is
+    // needed in some cases but not others, so a C-style cast was chosen.
+    return (backend_return_t<Backend, device>)getNative();
   }
 
   /// Indicates if the SYCL device has the given feature.
diff --git a/sycl/include/CL/sycl/event.hpp b/sycl/include/CL/sycl/event.hpp
@@ -130,12 +130,10 @@ class __SYCL_EXPORT event {
   /// Gets the native handle of the SYCL event.
   ///
   /// \return a native handle, the type of which defined by the backend.
-  template <backend BackendName>
+  template <backend Backend>
   __SYCL_DEPRECATED("Use SYCL 2020 sycl::get_native free function")
-  auto get_native() const ->
-      typename detail::interop<BackendName, event>::type {
-    return reinterpret_cast<typename detail::interop<BackendName, event>::type>(
-        getNative());
+  backend_return_t<Backend, event> get_native() const {
+    return reinterpret_cast<backend_return_t<Backend, event>>(getNative());
   }
 
 private:
diff --git a/sycl/include/CL/sycl/kernel.hpp b/sycl/include/CL/sycl/kernel.hpp
@@ -202,17 +202,17 @@ class __SYCL_EXPORT kernel {
 
   template <backend Backend>
   __SYCL_DEPRECATED("Use SYCL 2020 sycl::get_native free function")
-  typename backend_traits<Backend>::template return_type<kernel> get_native()
-      const {
-    return detail::pi::cast<
-        typename backend_traits<Backend>::template return_type<kernel>>(
-        getNativeImpl());
+  backend_return_t<Backend, kernel> get_native() const {
+    return detail::pi::cast<backend_return_t<Backend, kernel>>(getNative());
   }
 
 private:
   /// Constructs a SYCL kernel object from a valid kernel_impl instance.
   kernel(std::shared_ptr<detail::kernel_impl> Impl);
 
+  pi_native_handle getNative() const;
+
+  __SYCL_DEPRECATED("Use getNative() member function")
   pi_native_handle getNativeImpl() const;
 
   std::shared_ptr<detail::kernel_impl> impl;
diff --git a/sycl/include/CL/sycl/kernel_bundle.hpp b/sycl/include/CL/sycl/kernel_bundle.hpp
@@ -312,7 +312,7 @@ class kernel_bundle : public detail::kernel_bundle_plain {
 
   template <backend Backend>
   __SYCL_DEPRECATED("Use SYCL 2020 sycl::get_native free function")
-  auto get_native() const -> backend_return_t<Backend, kernel_bundle<State>> {
+  backend_return_t<Backend, kernel_bundle<State>> get_native() const {
     return getNative<Backend>();
   }
 
diff --git a/sycl/include/CL/sycl/platform.hpp b/sycl/include/CL/sycl/platform.hpp
@@ -120,12 +120,10 @@ class __SYCL_EXPORT platform {
   /// Gets the native handle of the SYCL platform.
   ///
   /// \return a native handle, the type of which defined by the backend.
-  template <backend BackendName>
+  template <backend Backend>
   __SYCL_DEPRECATED("Use SYCL 2020 sycl::get_native free function")
-  auto get_native() const ->
-      typename detail::interop<BackendName, platform>::type {
-    return reinterpret_cast<
-        typename detail::interop<BackendName, platform>::type>(getNative());
+  backend_return_t<Backend, platform> get_native() const {
+    return reinterpret_cast<backend_return_t<Backend, platform>>(getNative());
   }
 
   /// Indicates if all of the SYCL devices on this platform have the
diff --git a/sycl/include/CL/sycl/program.hpp b/sycl/include/CL/sycl/program.hpp
@@ -367,12 +367,10 @@ class __SYCL_EXPORT __SYCL2020_DEPRECATED(
   /// Gets the native handle of the SYCL platform.
   ///
   /// \return a native handle, the type of which defined by the backend.
-  template <backend BackendName>
+  template <backend Backend>
   __SYCL_DEPRECATED("Use SYCL 2020 sycl::get_native free function")
-  auto get_native() const ->
-      typename detail::interop<BackendName, program>::type {
-    return reinterpret_cast<
-        typename detail::interop<BackendName, program>::type>(getNative());
+  backend_return_t<Backend, program> get_native() const {
+    return reinterpret_cast<backend_return_t<Backend, program>>(getNative());
   }
 
 private:
diff --git a/sycl/include/CL/sycl/queue.hpp b/sycl/include/CL/sycl/queue.hpp
@@ -1038,12 +1038,10 @@ class __SYCL_EXPORT queue {
   /// Gets the native handle of the SYCL queue.
   ///
   /// \return a native handle, the type of which defined by the backend.
-  template <backend BackendName>
+  template <backend Backend>
   __SYCL_DEPRECATED("Use SYCL 2020 sycl::get_native free function")
-  auto get_native() const ->
-      typename detail::interop<BackendName, queue>::type {
-    return reinterpret_cast<typename detail::interop<BackendName, queue>::type>(
-        getNative());
+  backend_return_t<Backend, queue> get_native() const {
+    return reinterpret_cast<backend_return_t<Backend, queue>>(getNative());
   }
 
 private:
diff --git a/sycl/source/kernel.cpp b/sycl/source/kernel.cpp
@@ -128,6 +128,8 @@ kernel::get_sub_group_info(
 
 kernel::kernel(std::shared_ptr<detail::kernel_impl> Impl) : impl(Impl) {}
 
+pi_native_handle kernel::getNative() const { return impl->getNative(); }
+
 pi_native_handle kernel::getNativeImpl() const { return impl->getNative(); }
 
 } // namespace sycl
diff --git a/sycl/test/abi/sycl_symbols_linux.dump b/sycl/test/abi/sycl_symbols_linux.dump
@@ -4214,6 +4214,7 @@ _ZNK2cl4sycl6kernel11get_backendEv
 _ZNK2cl4sycl6kernel11get_contextEv
 _ZNK2cl4sycl6kernel11get_programEv
 _ZNK2cl4sycl6kernel13getNativeImplEv
+_ZNK2cl4sycl6kernel9getNativeEv
 _ZNK2cl4sycl6kernel17get_kernel_bundleEv
 _ZNK2cl4sycl6kernel18get_sub_group_infoILNS0_4info16kernel_sub_groupE16650EEENS3_12param_traitsIS4_XT_EE11return_typeERKNS0_6deviceE
 _ZNK2cl4sycl6kernel18get_sub_group_infoILNS0_4info16kernel_sub_groupE4537EEENS3_12param_traitsIS4_XT_EE11return_typeERKNS0_6deviceE
diff --git a/sycl/test/abi/sycl_symbols_windows.dump b/sycl/test/abi/sycl_symbols_windows.dump
@@ -2095,6 +2095,7 @@
 ?getNativeContext@interop_handle@sycl@cl@@AEBA_KXZ
 ?getNativeDevice@interop_handle@sycl@cl@@AEBA_KXZ
 ?getNativeImpl@kernel@sycl@cl@@AEBA_KXZ
+?getNative@kernel@sycl@cl@@AEBA_KXZ
 ?getNativeMem@interop_handle@sycl@cl@@AEBA_KPEAVAccessorImplHost@detail@23@@Z
 ?getNativeQueue@interop_handle@sycl@cl@@AEBA_KXZ
 ?getOSMemSize@OSUtil@detail@sycl@cl@@SA_KXZ
diff --git a/sycl/unittests/assert/assert.cpp b/sycl/unittests/assert/assert.cpp
@@ -284,7 +284,7 @@ static pi_result redefinedKernelGetInfo(pi_kernel Kernel,
                                         size_t ParamValueSize, void *ParamValue,
                                         size_t *ParamValueSizeRet) {
   if (PI_KERNEL_INFO_CONTEXT == ParamName) {
-    cl_context Ctx = Context->get_native<sycl::backend::opencl>();
+    cl_context Ctx = sycl::get_native<sycl::backend::opencl>(*Context);
 
     if (ParamValue)
       memcpy(ParamValue, &Ctx, sizeof(Ctx));
@@ -357,7 +357,7 @@ static pi_result redefinedProgramGetInfo(pi_program P,
   if (PI_PROGRAM_INFO_DEVICES == ParamName) {
     EXPECT_EQ(ParamValueSize, 1 * sizeof(cl_device_id));
 
-    cl_device_id Dev = Device->get_native<sycl::backend::opencl>();
+    cl_device_id Dev = sycl::get_native<sycl::backend::opencl>(*Device);
 
     if (ParamValue)
       memcpy(ParamValue, &Dev, sizeof(Dev));
@@ -628,11 +628,11 @@ TEST(Assert, TestInteropKernelFromProgramNegative) {
 
   setupMockForInterop(Mock, Ctx, Dev);
 
-  sycl::program POrig{Ctx};
-  POrig.build_with_kernel_type<TestKernel>();
-  sycl::kernel KOrig = POrig.get_kernel<TestKernel>();
+  sycl::kernel_bundle Bundle =
+      sycl::get_kernel_bundle<sycl::bundle_state::executable>(Ctx);
+  sycl::kernel KOrig = Bundle.get_kernel(sycl::get_kernel_id<TestKernel>());
 
-  cl_kernel CLKernel = KOrig.get_native<sycl::backend::opencl>();
+  cl_kernel CLKernel = sycl::get_native<sycl::backend::opencl>(KOrig);
   sycl::kernel KInterop{CLKernel, Ctx};
 
   Queue.submit([&](sycl::handler &H) { H.single_task(KInterop); });
diff --git a/sycl/unittests/pi/EnqueueMemTest.cpp b/sycl/unittests/pi/EnqueueMemTest.cpp
@@ -105,7 +105,7 @@ class EnqueueMemTest : public testing::TestWithParam<detail::plugin> {
   }
 };
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     EnqueueMemTestImpl, EnqueueMemTest,
     testing::ValuesIn(pi::initializeAndRemoveInvalid()),
     [](const testing::TestParamInfo<EnqueueMemTest::ParamType> &info) {
diff --git a/sycl/unittests/pi/PlatformTest.cpp b/sycl/unittests/pi/PlatformTest.cpp
@@ -62,7 +62,7 @@ class PlatformTest : public testing::TestWithParam<detail::plugin> {
   }
 };
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     PlatformTestImpl, PlatformTest,
     testing::ValuesIn(pi::initializeAndRemoveInvalid()),
     [](const testing::TestParamInfo<PlatformTest::ParamType> &info) {
diff --git a/sycl/unittests/pi/cuda/test_interop_get_native.cpp b/sycl/unittests/pi/cuda/test_interop_get_native.cpp
@@ -62,8 +62,9 @@ TEST_P(CudaInteropGetNativeTests, interopTaskGetMem) {
   buffer<int, 1> syclBuffer(range<1>{1});
   syclQueue_->submit([&](handler &cgh) {
     auto syclAccessor = syclBuffer.get_access<access::mode::read>(cgh);
-    cgh.interop_task([=](interop_handler ih) {
-      CUdeviceptr cudaPtr = ih.get_mem<backend::ext_oneapi_cuda>(syclAccessor);
+    cgh.host_task([=](interop_handle ih) {
+      CUdeviceptr cudaPtr =
+          ih.get_native_mem<backend::ext_oneapi_cuda>(syclAccessor);
       CUdeviceptr cudaPtrBase;
       size_t cudaPtrSize = 0;
       CUcontext cudaContext =
@@ -80,8 +81,9 @@ TEST_P(CudaInteropGetNativeTests, interopTaskGetMem) {
 TEST_P(CudaInteropGetNativeTests, interopTaskGetQueue) {
   CUstream cudaStream = get_native<backend::ext_oneapi_cuda>(*syclQueue_);
   syclQueue_->submit([&](handler &cgh) {
-    cgh.interop_task([=](interop_handler ih) {
-      CUstream cudaInteropStream = ih.get_queue<backend::ext_oneapi_cuda>();
+    cgh.host_task([=](interop_handle ih) {
+      CUstream cudaInteropStream =
+          ih.get_native_queue<backend::ext_oneapi_cuda>();
       ASSERT_EQ(cudaInteropStream, cudaStream);
     });
   });
@@ -130,6 +132,6 @@ TEST_P(CudaInteropGetNativeTests, hostTaskGetNativeContext) {
   });
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     OnCudaPlatform, CudaInteropGetNativeTests,
     ::testing::ValuesIn(pi::getPlatformsWithName("CUDA BACKEND")));
diff --git a/sycl/unittests/pi/cuda/test_primary_context.cpp b/sycl/unittests/pi/cuda/test_primary_context.cpp
@@ -40,8 +40,8 @@ TEST_P(CudaPrimaryContextTests, piSingleContext) {
       deviceA_, async_handler{},
       {sycl::ext::oneapi::cuda::property::context::use_primary_context{}});
 
-  CUdevice CudaDevice = deviceA_.get_native<backend::ext_oneapi_cuda>();
-  CUcontext CudaContext = Context.get_native<backend::ext_oneapi_cuda>();
+  CUdevice CudaDevice = get_native<backend::ext_oneapi_cuda>(deviceA_);
+  CUcontext CudaContext = get_native<backend::ext_oneapi_cuda>(Context);
 
   CUcontext PrimaryCudaContext;
   cuDevicePrimaryCtxRetain(&PrimaryCudaContext, CudaDevice);
@@ -60,8 +60,8 @@ TEST_P(CudaPrimaryContextTests, piMultiContextSingleDevice) {
       deviceA_, async_handler{},
       {sycl::ext::oneapi::cuda::property::context::use_primary_context{}});
 
-  CUcontext CudaContextA = ContextA.get_native<backend::ext_oneapi_cuda>();
-  CUcontext CudaContextB = ContextB.get_native<backend::ext_oneapi_cuda>();
+  CUcontext CudaContextA = get_native<backend::ext_oneapi_cuda>(ContextA);
+  CUcontext CudaContextB = get_native<backend::ext_oneapi_cuda>(ContextB);
 
   ASSERT_EQ(CudaContextA, CudaContextB);
 }
@@ -70,8 +70,8 @@ TEST_P(CudaPrimaryContextTests, piMultiContextMultiDevice) {
   if (deviceA_ == deviceB_)
     return;
 
-  CUdevice CudaDeviceA = deviceA_.get_native<backend::ext_oneapi_cuda>();
-  CUdevice CudaDeviceB = deviceB_.get_native<backend::ext_oneapi_cuda>();
+  CUdevice CudaDeviceA = get_native<backend::ext_oneapi_cuda>(deviceA_);
+  CUdevice CudaDeviceB = get_native<backend::ext_oneapi_cuda>(deviceB_);
 
   ASSERT_NE(CudaDeviceA, CudaDeviceB);
 
@@ -83,8 +83,8 @@ TEST_P(CudaPrimaryContextTests, piMultiContextMultiDevice) {
       deviceB_, async_handler{},
       {sycl::ext::oneapi::cuda::property::context::use_primary_context{}});
 
-  CUcontext CudaContextA = ContextA.get_native<backend::ext_oneapi_cuda>();
-  CUcontext CudaContextB = ContextB.get_native<backend::ext_oneapi_cuda>();
+  CUcontext CudaContextA = get_native<backend::ext_oneapi_cuda>(ContextA);
+  CUcontext CudaContextB = get_native<backend::ext_oneapi_cuda>(ContextB);
 
   ASSERT_NE(CudaContextA, CudaContextB);
 }
diff --git a/sycl/unittests/pi/cuda/test_sampler_properties.cpp b/sycl/unittests/pi/cuda/test_sampler_properties.cpp
@@ -121,7 +121,7 @@ TEST_P(SamplerPropertiesTest, piCheckAddressingMode) {
   ASSERT_EQ(actualAddressMode, addressMode_);
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     SamplerPropertiesTestImpl, SamplerPropertiesTest,
     ::testing::Combine(
         ::testing::Values(PI_TRUE, PI_FALSE),

Original file line number	Diff line number	Diff line change
`@@ -312,7 +312,7 @@ class kernel_bundle : public detail::kernel_bundle_plain {`
`312`	`312`
`313`	`313`	`template <backend Backend>`
`314`	`314`	`__SYCL_DEPRECATED("Use SYCL 2020 sycl::get_native free function")`
`315`		`- auto get_native() const -> backend_return_t<Backend, kernel_bundle<State>> {`
	`315`	`+ backend_return_t<Backend, kernel_bundle<State>> get_native() const {`
`316`	`316`	`return getNative<Backend>();`
`317`	`317`	`}`
`318`	`318`