[SYCL][USM] Add ordered queue extension

Signed-off-by: Dounia <[email protected]>

Author: dkhaldi

sycl/include/CL/sycl.hpp

@@ -32,6 +32,7 @@
 #include <CL/sycl/pointers.hpp>
 #include <CL/sycl/program.hpp>
 #include <CL/sycl/queue.hpp>
+#include <CL/sycl/ordered_queue.hpp>
 #include <CL/sycl/range.hpp>
 #include <CL/sycl/sampler.hpp>
 #include <CL/sycl/stream.hpp>

sycl/include/CL/sycl/detail/queue_impl.hpp

@@ -24,19 +24,23 @@ namespace detail {
 // Set max number of queues supported by FPGA RT.
 const size_t MaxNumQueues = 256;
 
+enum QueueOrder { Ordered, OOO };
+
 class queue_impl {
 public:
   queue_impl(const device &SyclDevice, async_handler AsyncHandler,
-             const property_list &PropList)
-      : queue_impl(SyclDevice, context(SyclDevice), AsyncHandler, PropList) {};
+             QueueOrder Order, const property_list &PropList)
+      : queue_impl(SyclDevice, context(SyclDevice), AsyncHandler, Order,
+                   PropList){};
 
   queue_impl(const device &SyclDevice, const context &Context,
-             async_handler AsyncHandler, const property_list &PropList)
+             async_handler AsyncHandler, QueueOrder Order,
+             const property_list &PropList)
       : m_Device(SyclDevice), m_Context(Context), m_AsyncHandler(AsyncHandler),
         m_PropList(PropList), m_HostQueue(m_Device.is_host()) {
     m_OpenCLInterop = !m_HostQueue;
     if (!m_HostQueue) {
-      m_CommandQueue = createQueue();
+      m_CommandQueue = createQueue(Order);
     }
   }
 
@@ -51,8 +55,8 @@ class queue_impl {
     // TODO catch an exception and put it to list of asynchronous exceptions
     PI_CALL(RT::piQueueGetInfo(m_CommandQueue, PI_QUEUE_INFO_DEVICE,
                                sizeof(Device), &Device, nullptr));
-    m_Device = createSyclObjFromImpl<device>(
-        std::make_shared<device_impl_pi>(Device));
+    m_Device =
+        createSyclObjFromImpl<device>(std::make_shared<device_impl_pi>(Device));
 
     // TODO catch an exception and put it to list of asynchronous exceptions
     PI_CALL(RT::piQueueRetain(m_CommandQueue));
@@ -127,32 +131,31 @@ class queue_impl {
     m_Exceptions.Clear();
   }
 
-  RT::PiQueue createQueue() {
+  RT::PiQueue createQueue(QueueOrder Order) {
     RT::PiQueueProperties CreationFlags = 0;
 
-    if (m_SupportOOO) {
+    if (Order == QueueOrder::OOO) {
       CreationFlags = PI_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE;
     }
-
     if (m_PropList.has_property<property::queue::enable_profiling>()) {
       CreationFlags |= PI_QUEUE_PROFILING_ENABLE;
     }
-
     RT::PiQueue Queue;
     RT::PiContext Context = detail::getSyclObjImpl(m_Context)->getHandleRef();
     RT::PiDevice Device = detail::getSyclObjImpl(m_Device)->getHandleRef();
-    RT::PiResult Error = PI_CALL_RESULT(RT::piQueueCreate(Context, Device,
-        CreationFlags, &Queue));
+    RT::PiResult Error = PI_CALL_RESULT(
+        RT::piQueueCreate(Context, Device, CreationFlags, &Queue));
 
     // If creating out-of-order queue failed and this property is not
     // supported (for example, on FPGA), it will return
     // CL_INVALID_QUEUE_PROPERTIES and will try to create in-order queue.
     if (m_SupportOOO && Error == PI_INVALID_QUEUE_PROPERTIES) {
       m_SupportOOO = false;
-      Queue = createQueue();
+      Queue = createQueue(QueueOrder::Ordered);
     } else {
       PI_CHECK(Error);
     }
+
     return Queue;
   }
 
@@ -162,7 +165,7 @@ class queue_impl {
     // possibility of two kernels to share data with each other we shall
     // create a queue for every kernel enqueued.
     if (m_Queues.size() < MaxNumQueues) {
-      m_Queues.push_back(createQueue());
+      m_Queues.push_back(createQueue(QueueOrder::Ordered));
       return m_Queues.back();
     }
 
@@ -196,8 +199,8 @@ class queue_impl {
     return m_PropList.get_property<propertyT>();
   }
 
-  event memset(void* Ptr, int Value, size_t Count);
-  event memcpy(void* Dest, const void* Src, size_t Count);
+  event memset(void *Ptr, int Value, size_t Count);
+  event memcpy(void *Dest, const void *Src, size_t Count);
   event mem_advise(const void *Ptr, size_t Length, int Advice);
 
 private:

sycl/include/CL/sycl/detail/stream_impl.hpp

@@ -13,6 +13,7 @@
 #include <CL/sycl/detail/array.hpp>
 #include <CL/sycl/device_selector.hpp>
 #include <CL/sycl/queue.hpp>
+#include <CL/sycl/ordered_queue.hpp>
 
 namespace cl {
 namespace sycl {

sycl/include/CL/sycl/info/info_desc.hpp

@@ -172,12 +172,17 @@ enum class execution_capability : unsigned int {
   exec_native_kernel
 };
 
-// A.4 Queue information desctiptors
+// A.4 Queue information descriptors
 enum class queue : cl_command_queue_info {
   context = CL_QUEUE_CONTEXT,
   device = CL_QUEUE_DEVICE,
   reference_count = CL_QUEUE_REFERENCE_COUNT
 };
+enum class ordered_queue : cl_command_queue_info {
+  context = CL_QUEUE_CONTEXT,
+  device = CL_QUEUE_DEVICE,
+  reference_count = CL_QUEUE_REFERENCE_COUNT
+};
 
 // A.5 Kernel information desctiptors
 enum class kernel : cl_kernel_info {

sycl/include/CL/sycl/ordered_queue.hpp

@@ -0,0 +1,131 @@
+//==----------------- ordered queue.hpp - SYCL queue -----------------------==//
+//
+// 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/detail/queue_impl.hpp>
+#include <CL/sycl/device_selector.hpp>
+#include <CL/sycl/exception_list.hpp>
+#include <CL/sycl/info/info_desc.hpp>
+#include <CL/sycl/property_list.hpp>
+
+#include <memory>
+#include <utility>
+
+namespace cl {
+namespace sycl {
+
+// Forward declaration
+class context;
+class device;
+class ordered_queue {
+public:
+  explicit ordered_queue(const property_list &propList = {})
+      : ordered_queue(default_selector(), async_handler{}, propList) {}
+
+  ordered_queue(const async_handler &asyncHandler, const property_list &propList = {})
+      : ordered_queue(default_selector(), asyncHandler, propList) {}
+
+  ordered_queue(const device_selector &deviceSelector,
+        const property_list &propList = {})
+      : ordered_queue(deviceSelector.select_device(), async_handler{}, propList) {}
+
+  ordered_queue(const device_selector &deviceSelector,
+        const async_handler &asyncHandler, const property_list &propList = {})
+      : ordered_queue(deviceSelector.select_device(), asyncHandler, propList) {}
+
+  ordered_queue(const device &syclDevice, const property_list &propList = {})
+      : ordered_queue(syclDevice, async_handler{}, propList) {}
+
+  ordered_queue(const device &syclDevice, const async_handler &asyncHandler,
+        const property_list &propList = {});
+
+  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(const context &syclContext, const device_selector &deviceSelector,
+        const async_handler &asyncHandler, const property_list &propList = {});
+
+  ordered_queue(cl_command_queue cl_Queue, const context &syclContext,
+        const async_handler &asyncHandler = {});
+
+  ordered_queue(const ordered_queue &rhs) = default;
+
+  ordered_queue(ordered_queue &&rhs) = default;
+
+  ordered_queue &operator=(const ordered_queue &rhs) = default;
+
+  ordered_queue &operator=(ordered_queue &&rhs) = default;
+
+  bool operator==(const ordered_queue &rhs) const { return impl == rhs.impl; }
+
+  bool operator!=(const ordered_queue &rhs) const { return !(*this == rhs); }
+
+  cl_command_queue get() const { return impl->get(); }
+
+  context get_context() const { return impl->get_context(); }
+
+  device get_device() const { return impl->get_device(); }
+
+  bool is_host() const { return impl->is_host(); }
+
+  template <info::ordered_queue param>
+  typename info::param_traits<info::ordered_queue, param>::return_type
+  get_info() const {
+    return impl->get_info<param>();
+  }
+
+  template <typename T> event submit(T cgf) { return impl->submit(cgf, impl); }
+
+  template <typename T> event submit(T cgf, ordered_queue &secondaryQueue) {
+    return impl->submit(cgf, impl, secondaryQueue.impl);
+  }
+
+  void wait() { impl->wait(); }
+
+  void wait_and_throw() { impl->wait_and_throw(); }
+
+  void throw_asynchronous() { impl->throw_asynchronous(); }
+
+  template <typename propertyT> bool has_property() const {
+    return impl->has_property<propertyT>();
+  }
+
+  template <typename propertyT> propertyT get_property() const {
+    return impl->get_property<propertyT>();
+  }
+
+  event memset(void* ptr, int value, size_t count) {
+    return impl->memset(ptr, value, count);
+  }
+
+  event memcpy(void* dest, const void* src, size_t count) {
+    return impl->memcpy(dest, src, count);
+  }
+
+private:
+  std::shared_ptr<detail::queue_impl> impl;
+  template <class Obj>
+  friend decltype(Obj::impl) detail::getSyclObjImpl(const Obj &SyclObject);
+};
+
+} // namespace sycl
+} // namespace cl
+
+namespace std {
+template <> struct hash<cl::sycl::ordered_queue> {
+  size_t operator()(const cl::sycl::ordered_queue &q) const {
+    return std::hash<std::shared_ptr<cl::sycl::detail::queue_impl>>()(
+        cl::sycl::detail::getSyclObjImpl(q));
+  }
+};
+} // namespace std

sycl/source/CMakeLists.txt

@@ -52,6 +52,7 @@ add_library(sycl SHARED
   "kernel.cpp"
   "platform.cpp"
   "queue.cpp"
+  "ordered_queue.cpp"
   "sampler.cpp"
   "stream.cpp"
   "spirv_ops.cpp"

sycl/source/detail/scheduler/scheduler.cpp

@@ -145,8 +145,8 @@ EventImplPtr Scheduler::addHostAccessor(Requirement *Req) {
 
 Scheduler::Scheduler() {
   sycl::device HostDevice;
-  DefaultHostQueue = QueueImplPtr(
-      new queue_impl(HostDevice, /*AsyncHandler=*/{}, /*PropList=*/{}));
+  DefaultHostQueue = QueueImplPtr(new queue_impl(
+      HostDevice, /*AsyncHandler=*/{}, QueueOrder::Ordered, /*PropList=*/{}));
 }
 
 } // namespace detail

sycl/source/ordered_queue.cpp

@@ -0,0 +1,57 @@
+//==-------------- ordered_queue.cpp ---------------------------------------==//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include <CL/sycl/exception_list.hpp>
+#include <CL/sycl/ordered_queue.hpp>
+
+#include <algorithm>
+
+namespace cl {
+namespace sycl {
+ordered_queue::ordered_queue(const context &syclContext,
+                             const device_selector &deviceSelector,
+                             const async_handler &asyncHandler,
+                             const property_list &propList) {
+
+  const vector_class<device> Devs = syclContext.get_devices();
+
+  auto Comp = [&deviceSelector](const device &d1, const device &d2) {
+    return deviceSelector(d1) < deviceSelector(d2);
+  };
+
+  const device &syclDevice = *std::max_element(Devs.begin(), Devs.end(), Comp);
+  impl = std::make_shared<detail::queue_impl>(
+      syclDevice, syclContext, asyncHandler,
+      cl::sycl::detail::QueueOrder::Ordered, propList);
+}
+
+ordered_queue::ordered_queue(const device &syclDevice,
+                             const async_handler &asyncHandler,
+                             const property_list &propList) {
+  impl = std::make_shared<detail::queue_impl>(
+      syclDevice, asyncHandler, cl::sycl::detail::QueueOrder::Ordered,
+      propList);
+}
+
+ordered_queue::ordered_queue(cl_command_queue clQueue,
+                             const context &syclContext,
+                             const async_handler &asyncHandler) {
+  cl_command_queue_properties reportedProps;
+  RT::PiQueue m_CommandQueue = detail::pi::cast<detail::RT::PiQueue>(clQueue);
+  PI_CALL(RT::piQueueGetInfo(m_CommandQueue, PI_QUEUE_INFO_DEVICE,
+                             sizeof(reportedProps), &reportedProps, nullptr));
+  if (reportedProps & CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE)
+    throw runtime_error(
+        "Failed to build a sycl ordered queue from a cl OOO queue.");
+
+  impl =
+      std::make_shared<detail::queue_impl>(clQueue, syclContext, asyncHandler);
+}
+
+} // namespace sycl
+} // namespace cl

sycl/source/queue.cpp

@@ -23,14 +23,15 @@ queue::queue(const context &syclContext, const device_selector &deviceSelector,
   };
 
   const device &syclDevice = *std::max_element(Devs.begin(), Devs.end(), Comp);
-  impl = std::make_shared<detail::queue_impl>(syclDevice, syclContext,
-                                              asyncHandler, propList);
+  impl = std::make_shared<detail::queue_impl>(
+      syclDevice, syclContext, asyncHandler, cl::sycl::detail::QueueOrder::OOO,
+      propList);
 }
 
 queue::queue(const device &syclDevice, const async_handler &asyncHandler,
              const property_list &propList) {
-  impl =
-      std::make_shared<detail::queue_impl>(syclDevice, asyncHandler, propList);
+  impl = std::make_shared<detail::queue_impl>(
+      syclDevice, asyncHandler, cl::sycl::detail::QueueOrder::OOO, propList);
 }
 
 queue::queue(cl_command_queue clQueue, const context &syclContext,