[SYCL][PI][CUDA] Implements get_native interoperability

sycl/include/CL/sycl.hpp

@@ -10,6 +10,8 @@
 
 #include <CL/sycl/accessor.hpp>
 #include <CL/sycl/atomic.hpp>
+#include <CL/sycl/backend.hpp>
+#include <CL/sycl/backend/opencl.hpp>
 #include <CL/sycl/buffer.hpp>
 #include <CL/sycl/builtins.hpp>
 #include <CL/sycl/context.hpp>

sycl/include/CL/sycl/backend.hpp

@@ -0,0 +1,34 @@
+//==---------------- backend.hpp - SYCL PI backends ------------------------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include <CL/sycl/accessor.hpp>
+#include <CL/sycl/backend_types.hpp>
+
+__SYCL_INLINE_NAMESPACE(cl) {
+namespace sycl {
+
+template <backend BackendName, class SyclObjectT>
+auto get_native(const SyclObjectT &Obj) ->
+    typename interop<BackendName, SyclObjectT>::type {
+  return Obj.template get_native<BackendName>();
+}
+
+// Native handle of an accessor should be accessed through interop_handler
+template <backend BackendName, typename DataT, int Dimensions,
+          access::mode AccessMode, access::target AccessTarget,
+          access::placeholder IsPlaceholder>
+auto get_native(const accessor<DataT, Dimensions, AccessMode, AccessTarget,
+                               IsPlaceholder> &Obj) ->
+    typename interop<BackendName, accessor<DataT, Dimensions, AccessMode,
+                                           AccessTarget, IsPlaceholder>>::type =
+    delete;
+
+} // namespace sycl
+} // __SYCL_INLINE_NAMESPACE(cl)

sycl/include/CL/sycl/backend/cuda.hpp

@@ -1,3 +1,4 @@
+
 //==---------------- cuda.hpp - SYCL CUDA backend --------------------------==//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
@@ -6,29 +7,45 @@
 //
 //===----------------------------------------------------------------------===//
 
+#pragma once
+
+#include <CL/sycl/accessor.hpp>
+#include <CL/sycl/backend_types.hpp>
+#include <CL/sycl/context.hpp>
 #include <CL/sycl/detail/defines.hpp>
+#include <CL/sycl/device.hpp>
+#include <CL/sycl/event.hpp>
+#include <CL/sycl/queue.hpp>
+
+typedef int CUdevice;
+typedef struct CUctx_st *CUcontext;
+typedef struct CUstream_st *CUstream;
+typedef struct CUevent_st *CUevent;
+
+// As defined in the CUDA 10.1 header file. This requires CUDA version > 3.2
+#if defined(_WIN64) || defined(__LP64__)
+typedef unsigned long long CUdeviceptr;
+#else
+typedef unsigned int CUdeviceptr;
+#endif
 
 __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {
-namespace backend {
-namespace cuda {
-
-// CUDA backend specific options
-// TODO: Use values that won't overlap with others
-
-// Mem Object info: Retrieve the raw CUDA pointer from a cl_mem
-#define PI_CUDA_RAW_POINTER (0xFF01)
-// Context creation: Use a primary CUDA context instead of a custom one by
-//                   providing a property value of PI_TRUE for the following
-//                   property ID.
-#define PI_CONTEXT_PROPERTIES_CUDA_PRIMARY (0xFF02)
-
-// PI Command Queue using Default stream
-#define PI_CUDA_USE_DEFAULT_STREAM (0xFF03)
-// PI Command queue will sync with default stream
-#define PI_CUDA_SYNC_WITH_DEFAULT (0xFF04)
-
-} // namespace cuda
-} // namespace backend
+
+template <> struct interop<backend::cuda, device> { using type = CUdevice; };
+
+template <> struct interop<backend::cuda, context> { using type = CUcontext; };
+
+template <> struct interop<backend::cuda, queue> { using type = CUstream; };
+
+template <> struct interop<backend::cuda, event> { using type = CUevent; };
+
+template <typename DataT, int Dimensions, access::mode AccessMode>
+struct interop<backend::cuda, accessor<DataT, Dimensions, AccessMode,
+                                       access::target::global_buffer,
+                                       access::placeholder::false_t>> {
+  using type = CUdeviceptr;
+};
+
 } // namespace sycl
 } // namespace cl

sycl/include/CL/sycl/backend/opencl.hpp

@@ -0,0 +1,31 @@
+
+//==---------------- opencl.hpp - SYCL OpenCL backend ----------------------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include <CL/cl.h>
+#include <CL/sycl/accessor.hpp>
+#include <CL/sycl/backend_types.hpp>
+
+__SYCL_INLINE_NAMESPACE(cl) {
+namespace sycl {
+
+template <> struct interop<backend::opencl, queue> {
+  using type = cl_command_queue;
+};
+
+template <typename DataT, int Dimensions, access::mode AccessMode>
+struct interop<backend::opencl, accessor<DataT, Dimensions, AccessMode,
+                                         access::target::global_buffer,
+                                         access::placeholder::false_t>> {
+  using type = cl_mem;
+};
+
+} // namespace sycl
+} // __SYCL_INLINE_NAMESPACE(cl)

sycl/include/CL/sycl/backend_types.hpp

@@ -0,0 +1,19 @@
+//==-------------- backend_types.hpp - SYCL backend types ------------------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+namespace cl {
+namespace sycl {
+
+enum class backend { host, opencl, cuda };
+
+template <backend name, typename SYCLObjectT> struct interop;
+
+} // namespace sycl
+} // namespace cl

sycl/include/CL/sycl/context.hpp

@@ -7,6 +7,8 @@
 //===----------------------------------------------------------------------===//
 
 #pragma once
+
+#include <CL/sycl/backend_types.hpp>
 #include <CL/sycl/detail/common.hpp>
 #include <CL/sycl/detail/export.hpp>
 #include <CL/sycl/exception_list.hpp>
@@ -135,10 +137,21 @@ class __SYCL_EXPORT context {
   /// \return a vector of valid SYCL device instances.
   vector_class<device> get_devices() const;
 
+  /// Gets the native handle of the SYCL context.
+  ///
+  /// \return a native handle, the type of which defined by the backend.
+  template <backend BackendName>
+  auto get_native() const -> typename interop<BackendName, context>::type {
+    return reinterpret_cast<typename interop<BackendName, context>::type>(
+        getNative());
+  }
+
 private:
   /// Constructs a SYCL context object from a valid context_impl instance.
   context(shared_ptr_class<detail::context_impl> Impl);
 
+  pi_native_handle getNative() const;
+
   shared_ptr_class<detail::context_impl> impl;
   template <class Obj>
   friend decltype(Obj::impl) detail::getSyclObjImpl(const Obj &SyclObject);

sycl/include/CL/sycl/detail/cg.hpp

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include <CL/sycl/backend_types.hpp>
 #include <CL/sycl/detail/accessor_impl.hpp>
 #include <CL/sycl/detail/common.hpp>
 #include <CL/sycl/detail/export.hpp>
@@ -29,6 +30,12 @@
 __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {
 
+// Forward declaration
+class queue;
+namespace detail {
+class queue_impl;
+} // namespace detail
+
 // Interoperability handler
 //
 class interop_handler {
@@ -37,26 +44,51 @@ class interop_handler {
             access::target AccTarget, access::placeholder isPlaceholder>
   friend class accessor;
 public:
+  using QueueImplPtr = std::shared_ptr<detail::queue_impl>;
   using ReqToMem = std::pair<detail::Requirement*, pi_mem>;
 
-  interop_handler(std::vector<ReqToMem> MemObjs, cl_command_queue PiQueue) :
-    MQueue(PiQueue), MMemObjs(MemObjs) {}
+  interop_handler(std::vector<ReqToMem> MemObjs, QueueImplPtr Queue)
+      : MQueue(std::move(Queue)), MMemObjs(std::move(MemObjs)) {}
 
-  cl_command_queue get_queue() const noexcept { return MQueue; };
+  template <backend BackendName = backend::opencl>
+  auto get_queue() const -> typename interop<BackendName, queue>::type {
+    return reinterpret_cast<typename interop<BackendName, queue>::type>(
+        GetNativeQueue());
+  }
 
-  template <typename DataT, int Dims, access::mode AccessMode,
-            access::target AccessTarget,
+  template <backend BackendName = backend::opencl, typename DataT, int Dims,
+            access::mode AccessMode, access::target AccessTarget,
             access::placeholder IsPlaceholder = access::placeholder::false_t>
-  cl_mem get_mem(accessor<DataT, Dims, AccessMode, AccessTarget,
-                          access::placeholder::false_t>
-                     Acc) const {
+  auto get_mem(accessor<DataT, Dims, AccessMode, AccessTarget,
+                        access::placeholder::false_t>
+                   Acc) const ->
+      typename interop<BackendName,
+                       accessor<DataT, Dims, AccessMode, AccessTarget,
+                                access::placeholder::false_t>>::type {
     detail::AccessorBaseHost *AccBase = (detail::AccessorBaseHost *)&Acc;
-    return getMemImpl(detail::getSyclObjImpl(*AccBase).get());
+    return getMemImpl<BackendName, DataT, Dims, AccessMode, AccessTarget,
+                      access::placeholder::false_t>(
+        detail::getSyclObjImpl(*AccBase).get());
   }
+
 private:
-  cl_command_queue MQueue;
+  QueueImplPtr MQueue;
   std::vector<ReqToMem> MMemObjs;
-  __SYCL_EXPORT cl_mem getMemImpl(detail::Requirement *Req) const;
+
+  template <backend BackendName, typename DataT, int Dims,
+            access::mode AccessMode, access::target AccessTarget,
+            access::placeholder IsPlaceholder>
+  __SYCL_EXPORT auto
+  getMemImpl(detail::Requirement *Req) const -> typename interop<
+      BackendName,
+      accessor<DataT, Dims, AccessMode, AccessTarget, IsPlaceholder>>::type {
+    return (typename interop<BackendName,
+                             accessor<DataT, Dims, AccessMode, AccessTarget,
+                                      IsPlaceholder>>::type)GetNativeMem(Req);
+  }
+
+  __SYCL_EXPORT pi_native_handle GetNativeMem(detail::Requirement *Req) const;
+  __SYCL_EXPORT pi_native_handle GetNativeQueue() const;
 };
 
 namespace detail {

sycl/include/CL/sycl/detail/cuda_definitions.hpp

@@ -0,0 +1,24 @@
+//==------------ cuda_definitions.hpp - SYCL CUDA backend ------------------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+// CUDA backend specific options
+// TODO: Use values that won't overlap with others
+
+// Mem Object info: Retrieve the raw CUDA pointer from a cl_mem
+#define PI_CUDA_RAW_POINTER (0xFF01)
+// Context creation: Use a primary CUDA context instead of a custom one by
+//                   providing a property value of PI_TRUE for the following
+//                   property ID.
+#define PI_CONTEXT_PROPERTIES_CUDA_PRIMARY (0xFF02)
+
+// PI Command Queue using Default stream
+#define PI_CUDA_USE_DEFAULT_STREAM (0xFF03)
+// PI Command queue will sync with default stream
+#define PI_CUDA_SYNC_WITH_DEFAULT (0xFF04)

sycl/include/CL/sycl/detail/pi.def

@@ -18,26 +18,31 @@
 _PI_API(piPlatformsGet)
 _PI_API(piPlatformGetInfo)
 // Device
-_PI_API(piextDeviceConvert)
 _PI_API(piDevicesGet)
 _PI_API(piDeviceGetInfo)
 _PI_API(piDevicePartition)
 _PI_API(piDeviceRetain)
 _PI_API(piDeviceRelease)
 _PI_API(piextDeviceSelectBinary)
 _PI_API(piextGetDeviceFunctionPointer)
+_PI_API(piextDeviceGetNativeHandle)
+_PI_API(piextDeviceCreateWithNativeHandle)
 // Context
 _PI_API(piContextCreate)
 _PI_API(piContextGetInfo)
 _PI_API(piContextRetain)
 _PI_API(piContextRelease)
 _PI_API(piextContextSetExtendedDeleter)
+_PI_API(piextContextGetNativeHandle)
+_PI_API(piextContextCreateWithNativeHandle)
 // Queue
 _PI_API(piQueueCreate)
 _PI_API(piQueueGetInfo)
 _PI_API(piQueueFinish)
 _PI_API(piQueueRetain)
 _PI_API(piQueueRelease)
+_PI_API(piextQueueGetNativeHandle)
+_PI_API(piextQueueCreateWithNativeHandle)
 // Memory
 _PI_API(piMemBufferCreate)
 _PI_API(piMemImageCreate)
@@ -46,8 +51,9 @@ _PI_API(piMemImageGetInfo)
 _PI_API(piMemRetain)
 _PI_API(piMemRelease)
 _PI_API(piMemBufferPartition)
+_PI_API(piextMemGetNativeHandle)
+_PI_API(piextMemCreateWithNativeHandle)
 // Program
-_PI_API(piextProgramConvert)
 _PI_API(piProgramCreate)
 _PI_API(piclProgramCreateWithSource)
 _PI_API(piclProgramCreateWithBinary)
@@ -59,6 +65,8 @@ _PI_API(piProgramGetBuildInfo)
 _PI_API(piProgramRetain)
 _PI_API(piProgramRelease)
 _PI_API(piextProgramSetSpecializationConstant)
+_PI_API(piextProgramGetNativeHandle)
+_PI_API(piextProgramCreateWithNativeHandle)
 // Kernel
 _PI_API(piKernelCreate)
 _PI_API(piKernelSetArg)
@@ -78,6 +86,8 @@ _PI_API(piEventSetCallback)
 _PI_API(piEventSetStatus)
 _PI_API(piEventRetain)
 _PI_API(piEventRelease)
+_PI_API(piextEventGetNativeHandle)
+_PI_API(piextEventCreateWithNativeHandle)
 // Sampler
 _PI_API(piSamplerCreate)
 _PI_API(piSamplerGetInfo)