[SYCL] Use forward declarations in ordered_queue (#1098)

This patch is a part of effort to decouple SYCL Runtime library
interface from its actual implementation. The goal is to improve
SYCL ABI/API compatibility between different versions of library.

ordered_queue class was refactored to use queue_impl class as forward
declaration in headers. All calls to impl were moved to the library. Also,
std::shared_ptr was replaced with shared_ptr_class.

Signed-off-by: Alexander Batashev <[email protected]>

Author: Alexander Batashev

sycl/include/CL/sycl/ordered_queue.hpp

@@ -9,7 +9,6 @@
 #pragma once
 
 #include <CL/sycl/detail/common.hpp>
-#include <CL/sycl/detail/queue_impl.hpp>
 #include <CL/sycl/device_selector.hpp>
 #include <CL/sycl/exception_list.hpp>
 #include <CL/sycl/info/info_desc.hpp>
@@ -33,8 +32,12 @@ namespace sycl {
 // Forward declaration
 class context;
 class device;
+namespace detail {
+class queue_impl;
+}
 
 class __SYCL_DEPRECATED__ ordered_queue {
+
 public:
   explicit ordered_queue(const property_list &propList = {})
       : ordered_queue(default_selector(), async_handler{}, propList) {}
@@ -60,10 +63,7 @@ class __SYCL_DEPRECATED__ ordered_queue {
 
   ordered_queue(const context &syclContext,
                 const device_selector &deviceSelector,
-                const property_list &propList = {})
-      : ordered_queue(syclContext, deviceSelector,
-                      detail::getSyclObjImpl(syclContext)->get_async_handler(),
-                      propList) {}
+                const property_list &propList = {});
 
   ordered_queue(const context &syclContext,
                 const device_selector &deviceSelector,
@@ -85,47 +85,36 @@ class __SYCL_DEPRECATED__ ordered_queue {
 
   bool operator!=(const ordered_queue &rhs) const { return !(*this == rhs); }
 
-  cl_command_queue get() const { return impl->get(); }
+  cl_command_queue get() const;
 
-  context get_context() const { return impl->get_context(); }
+  context get_context() const;
 
-  device get_device() const { return impl->get_device(); }
+  device get_device() const;
 
-  bool is_host() const { return impl->is_host(); }
+  bool is_host() const;
 
-  template <info::ordered_queue param>
-  typename info::param_traits<info::ordered_queue, param>::return_type
-  get_info() const {
-    return impl->get_info<param>();
-  }
+  template <info::queue param>
+  typename info::param_traits<info::queue, param>::return_type get_info() const;
 
-  template <typename T> event submit(T cgf) { return impl->submit(cgf, impl); }
+  template <typename T> event submit(T cgf) { return submit_impl(cgf); }
 
   template <typename T> event submit(T cgf, ordered_queue &secondaryQueue) {
-    return impl->submit(cgf, impl, secondaryQueue.impl);
+    return submit_impl(cgf, secondaryQueue);
   }
 
-  void wait() { impl->wait(); }
+  void wait();
 
-  void wait_and_throw() { impl->wait_and_throw(); }
+  void wait_and_throw();
 
-  void throw_asynchronous() { impl->throw_asynchronous(); }
+  void throw_asynchronous();
 
-  template <typename propertyT> bool has_property() const {
-    return impl->has_property<propertyT>();
-  }
+  template <typename propertyT> bool has_property() const;
 
-  template <typename propertyT> propertyT get_property() const {
-    return impl->get_property<propertyT>();
-  }
+  template <typename propertyT> propertyT get_property() const;
 
-  event memset(void *ptr, int value, size_t count) {
-    return impl->memset(impl, ptr, value, count);
-  }
+  event memset(void *ptr, int value, size_t count);
 
-  event memcpy(void *dest, const void *src, size_t count) {
-    return impl->memcpy(impl, dest, src, count);
-  }
+  event memcpy(void *dest, const void *src, size_t count);
 
   event prefetch(const void *Ptr, size_t Count) {
     return submit([=](handler &cgh) { cgh.prefetch(Ptr, Count); });
@@ -175,9 +164,13 @@ class __SYCL_DEPRECATED__ ordered_queue {
   }
 
 private:
-  std::shared_ptr<detail::queue_impl> impl;
+  shared_ptr_class<detail::queue_impl> impl;
   template <class Obj>
   friend decltype(Obj::impl) detail::getSyclObjImpl(const Obj &SyclObject);
+
+  event submit_impl(function_class<void(handler &)> CGH);
+  event submit_impl(function_class<void(handler &)> CGH,
+                    ordered_queue &secondQueue);
 };
 
 #undef __SYCL_DEPRECATED__

sycl/source/ordered_queue.cpp

@@ -6,13 +6,20 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include <CL/sycl/detail/queue_impl.hpp>
 #include <CL/sycl/exception_list.hpp>
 #include <CL/sycl/ordered_queue.hpp>
 
 #include <algorithm>
 
 __SYCL_INLINE namespace cl {
 namespace sycl {
+ordered_queue::ordered_queue(const context &syclContext,
+                             const device_selector &deviceSelector,
+                             const property_list &propList)
+    : ordered_queue(syclContext, deviceSelector,
+                    detail::getSyclObjImpl(syclContext)->get_async_handler(),
+                    propList) {}
 ordered_queue::ordered_queue(const context &syclContext,
                              const device_selector &deviceSelector,
                              const async_handler &asyncHandler,
@@ -54,5 +61,61 @@ ordered_queue::ordered_queue(cl_command_queue clQueue,
       m_CommandQueue, detail::getSyclObjImpl(syclContext), asyncHandler);
 }
 
+cl_command_queue ordered_queue::get() const { return impl->get(); }
+
+context ordered_queue::get_context() const { return impl->get_context(); }
+
+device ordered_queue::get_device() const { return impl->get_device(); }
+
+bool ordered_queue::is_host() const { return impl->is_host(); }
+
+void ordered_queue::wait() { impl->wait(); }
+
+void ordered_queue::wait_and_throw() { impl->wait_and_throw(); }
+
+void ordered_queue::throw_asynchronous() { impl->throw_asynchronous(); }
+
+event ordered_queue::memset(void *ptr, int value, size_t count) {
+  return impl->memset(impl, ptr, value, count);
+}
+
+event ordered_queue::memcpy(void *dest, const void *src, size_t count) {
+  return impl->memcpy(impl, dest, src, count);
+}
+
+event ordered_queue::submit_impl(function_class<void(handler &)> CGH) {
+  return impl->submit(CGH, impl);
+}
+
+event ordered_queue::submit_impl(function_class<void(handler &)> CGH,
+                                 ordered_queue &secondQueue) {
+  return impl->submit(CGH, impl, secondQueue.impl);
+}
+
+template <info::queue param>
+typename info::param_traits<info::queue, param>::return_type
+ordered_queue::get_info() const {
+  return impl->get_info<param>();
+}
+
+#define PARAM_TRAITS_SPEC(param_type, param, ret_type)                         \
+  template ret_type ordered_queue::get_info<info::param_type::param>() const;
+
+#include <CL/sycl/info/queue_traits.def>
+
+#undef PARAM_TRAITS_SPEC
+
+template <typename propertyT> bool ordered_queue::has_property() const {
+  return impl->has_property<propertyT>();
+}
+
+template <typename propertyT> propertyT ordered_queue::get_property() const {
+  return impl->get_property<propertyT>();
+}
+
+template bool
+ordered_queue::has_property<property::queue::enable_profiling>() const;
+template property::queue::enable_profiling
+ordered_queue::get_property<property::queue::enable_profiling>() const;
 } // namespace sycl
 } // namespace cl