[SYCL] Merge host and device context to impl context.

Move to library.

Signed-off-by: Voronov, Alexey <[email protected]>
Signed-off-by: Vladimir Lazarev <[email protected]>

Author: alexeyvoronov-intel

sycl/CMakeLists.txt

@@ -74,6 +74,7 @@ set(OPENCL_INCLUDE "${OpenCL_INCLUDE_DIRS}")
 add_library("${SYCLLibrary}" SHARED
   "${includeRootPath}/CL/sycl.hpp"
   "${sourceRootPath}/detail/common.cpp"
+  "${sourceRootPath}/detail/context_impl.cpp"
   "${sourceRootPath}/detail/device_info.cpp"
   "${sourceRootPath}/detail/event_impl.cpp"
   "${sourceRootPath}/detail/force_device.cpp"

sycl/include/CL/sycl/context.hpp

@@ -8,27 +8,26 @@
 //===----------------------------------------------------------------------===//
 
 #pragma once
-#include <CL/sycl/detail/context_host.hpp>
-#include <CL/sycl/detail/context_opencl.hpp>
-#include <CL/sycl/device.hpp>
-#include <CL/sycl/platform.hpp>
+#include <CL/sycl/detail/common.hpp>
+#include <CL/sycl/detail/context_impl.hpp>
+#include <CL/sycl/exception.hpp>
+#include <CL/sycl/info/info_desc.hpp>
 #include <CL/sycl/stl.hpp>
 #include <memory>
-#include <utility>
 // 4.6.2 Context class
 
 namespace cl {
 namespace sycl {
+// Forward declarations
+class device;
+class platform;
 class context {
 public:
-  explicit context(const async_handler &asyncHandler = {})
-      : context(default_selector().select_device(), asyncHandler) {}
+  explicit context(const async_handler &asyncHandler = {});
 
-  context(const device &dev, async_handler asyncHandler = {})
-      : context(vector_class<device>(1, dev), asyncHandler) {}
+  context(const device &dev, async_handler asyncHandler = {});
 
-  context(const platform &plt, async_handler asyncHandler = {})
-      : context(plt.get_devices(), asyncHandler) {}
+  context(const platform &plt, async_handler asyncHandler = {});
 
   context(const vector_class<device> &deviceList,
           async_handler asyncHandler = {});
@@ -37,9 +36,7 @@ class context {
 
   template <info::context param>
   typename info::param_traits<info::context, param>::return_type
-  get_info() const {
-    return impl->get_info<param>();
-  }
+  get_info() const;
 
   context(const context &rhs) = default;
 
@@ -49,17 +46,17 @@ class context {
 
   context &operator=(context &&rhs) = default;
 
-  bool operator==(const context &rhs) const { return impl == rhs.impl; }
+  bool operator==(const context &rhs) const;
 
-  bool operator!=(const context &rhs) const { return !(*this == rhs); }
+  bool operator!=(const context &rhs) const;
 
-  cl_context get() const { return impl->get(); }
+  cl_context get() const;
 
-  bool is_host() const { return impl->is_host(); }
+  bool is_host() const;
 
-  platform get_platform() const { return impl->get_platform(); }
+  platform get_platform() const;
 
-  vector_class<device> get_devices() const { return impl->get_devices(); }
+  vector_class<device> get_devices() const;
 
 private:
   std::shared_ptr<detail::context_impl> impl;

sycl/include/CL/sycl/detail/context_host.hpp

@@ -1,4 +1,4 @@
-//==---------------- context.hpp - SYCL context ----------------------------==//
+//==---------------- context_impl.hpp - SYCL context -----------*- C++-*---==//
 //
 // The LLVM Compiler Infrastructure
 //
@@ -13,71 +13,48 @@
 #include <CL/sycl/info/info_desc.hpp>
 #include <CL/sycl/platform.hpp>
 #include <CL/sycl/stl.hpp>
+
+#include <memory>
 // 4.6.2 Context class
 
 namespace cl {
 namespace sycl {
 // Forward declaration
-class platform;
 class device;
 namespace detail {
-template <info::context param> struct get_context_info_cl {
-  using RetType =
-      typename info::param_traits<info::context, param>::return_type;
-
-  static RetType _(cl_context ctx) {
-    RetType Result = 0;
-    // TODO catch an exception and put it to list of asynchronous exceptions
-    CHECK_OCL_CODE(clGetContextInfo(ctx, cl_context_info(param), sizeof(Result),
-                                    &Result, nullptr));
-    return Result;
-  }
-};
-
 class context_impl {
 public:
-  context_impl(async_handler asyncHandler) : m_AsyncHandler(asyncHandler) {}
+  context_impl(const device &Device, async_handler AsyncHandler);
 
-  template <info::context param>
-  inline typename info::param_traits<info::context, param>::return_type
-  get_info() const;
+  context_impl(const vector_class<cl::sycl::device> Devices,
+               async_handler AsyncHandler);
+
+  context_impl(cl_context ClContext, async_handler AsyncHandler);
+
+  ~context_impl();
 
-  const async_handler& get_async_handler() const { return m_AsyncHandler; }
+  cl_context get() const;
 
-  virtual cl_context get() const = 0;
+  bool is_host() const;
 
-  virtual bool is_host() const = 0;
+  platform get_platform() const;
 
-  virtual platform get_platform() const = 0;
+  vector_class<device> get_devices() const;
 
-  virtual vector_class<device> get_devices() const = 0;
+  const async_handler &get_async_handler() const;
 
-  virtual ~context_impl() = default;
+  template <info::context param>
+  typename info::param_traits<info::context, param>::return_type
+  get_info() const;
 
 private:
   async_handler m_AsyncHandler;
+  vector_class<device> m_Devices;
+  cl_context m_ClContext;
+  platform m_Platform;
+  bool m_OpenCLInterop;
+  bool m_HostContext;
 };
-template <>
-inline typename info::param_traits<info::context,
-                                   info::context::reference_count>::return_type
-context_impl::get_info<info::context::reference_count>() const {
-  if (is_host()) {
-    return 0;
-  }
-  return get_context_info_cl<info::context::reference_count>::_(this->get());
-}
-template <>
-inline typename info::param_traits<info::context,
-                                   info::context::platform>::return_type
-context_impl::get_info<info::context::platform>() const {
-  return get_platform();
-}
-template <>
-inline typename info::param_traits<info::context,
-                                   info::context::devices>::return_type
-context_impl::get_info<info::context::devices>() const {
-  return get_devices();
-}
 
 } // namespace detail
 } // namespace sycl

sycl/include/CL/sycl/detail/context_impl.hpp

@@ -0,0 +1,33 @@
+//==---------------- context_info.hpp - SYCL context -----------*- C++ -*---==//
+//
+// 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/detail/common.hpp>
+#include <CL/sycl/info/info_desc.hpp>
+
+namespace cl {
+namespace sycl {
+namespace detail {
+
+template <info::context param> struct get_context_info_cl {
+  using RetType =
+      typename info::param_traits<info::context, param>::return_type;
+
+  static RetType _(cl_context ctx) {
+    RetType Result = 0;
+    // TODO catch an exception and put it to list of asynchronous exceptions
+    CHECK_OCL_CODE(clGetContextInfo(ctx, cl_context_info(param), sizeof(Result),
+                                    &Result, nullptr));
+    return Result;
+  }
+};
+
+} // namespace detail
+} // namespace sycl
+} // namespace cl

sycl/include/CL/sycl/detail/context_info.hpp

@@ -9,6 +9,7 @@
 
 #pragma once
 
+#include <CL/sycl/detail/common.hpp>
 #include <CL/sycl/info/info_desc.hpp>
 
 namespace cl {

sycl/include/CL/sycl/detail/context_opencl.hpp

@@ -11,6 +11,7 @@
 
 #include <CL/sycl/detail/common.hpp>
 #include <CL/sycl/detail/queue_impl.hpp>
+#include <CL/sycl/device_selector.hpp>
 #include <CL/sycl/info/info_desc.hpp>
 #include <CL/sycl/property_list.hpp>