Implemented DPCTLQueue_SubmitBarrier, DPCTLQueue_SubmitBarrierForEvents

Author: oleksandr-pavlyk

dpctl-capi/include/dpctl_sycl_queue_interface.h

@@ -343,4 +343,32 @@ bool DPCTLQueue_IsInOrder(__dpctl_keep const DPCTLSyclQueueRef QRef);
 DPCTL_API
 size_t DPCTLQueue_Hash(__dpctl_keep const DPCTLSyclQueueRef QRef);
 
+/*!
+ * @brief C-API wraper for ``sycl::queue::submit_barrier()``.
+ *
+ * @param    QRef    An opaque pointer to the ``sycl::queue``.
+ * @return   An opaque pointer to the ``sycl::event`` returned by the
+ *           ``sycl::queue::submit_barrier()`` function.
+ */
+DPCTL_API
+DPCTLSyclEventRef
+DPCTLQueue_SubmitBarrier(__dpctl_keep const DPCTLSyclQueueRef QRef);
+
+/*!
+ * @brief C-API wraper for ``sycl::queue::submit_barrier(event_vector)``.
+ *
+ * @param    QRef    An opaque pointer to the ``sycl::queue``.
+ * @param    DepEvents     List of dependent DPCTLSyclEventRef objects (events)
+ *                         for the barrier. We call ``sycl::handler.depends_on``
+ *                         for each of the provided events.
+ * @param    NDepEvents    Size of the DepEvents list.
+ * @return   An opaque pointer to the ``sycl::event`` returned by the
+ *           ``sycl::queue::submit_barrier()`` function.
+ */
+DPCTL_API
+DPCTLSyclEventRef DPCTLQueue_SubmitBarrierForEvents(
+    __dpctl_keep const DPCTLSyclQueueRef QRef,
+    __dpctl_keep const DPCTLSyclEventRef *DepEvents,
+    size_t NDepEvents);
+
 DPCTL_C_EXTERN_C_END

dpctl-capi/source/dpctl_sycl_queue_interface.cpp

@@ -533,3 +533,44 @@ size_t DPCTLQueue_Hash(__dpctl_keep const DPCTLSyclQueueRef QRef)
         return 0;
     }
 }
+
+__dpctl_give DPCTLSyclEventRef DPCTLQueue_SubmitBarrierForEvents(
+    __dpctl_keep const DPCTLSyclQueueRef QRef,
+    __dpctl_keep const DPCTLSyclEventRef *DepEvents,
+    size_t NDepEvents)
+{
+    auto Q = unwrap(QRef);
+    event e;
+    if (Q) {
+        try {
+            e = Q->submit([&](handler &cgh) {
+                // Depend on any event that was specified by the caller.
+                if (NDepEvents)
+                    for (auto i = 0ul; i < NDepEvents; ++i)
+                        cgh.depends_on(*unwrap(DepEvents[i]));
+
+                cgh.barrier();
+            });
+        } catch (runtime_error &re) {
+            // \todo fix error handling
+            std::cerr << re.what() << '\n';
+            return nullptr;
+        } catch (std::runtime_error &sre) {
+            std::cerr << sre.what() << '\n';
+            return nullptr;
+        }
+
+        return wrap(new event(e));
+    }
+    else {
+        // todo: log error
+        std::cerr << "Argument QRef is null" << '\n';
+        return nullptr;
+    }
+}
+
+__dpctl_give DPCTLSyclEventRef
+DPCTLQueue_SubmitBarrier(__dpctl_keep const DPCTLSyclQueueRef QRef)
+{
+    return DPCTLQueue_SubmitBarrierForEvents(QRef, nullptr, 0);
+}

dpctl-capi/tests/test_sycl_queue_submit.cpp

@@ -356,4 +356,56 @@ TEST_F(TestQueueSubmitNDRange, ChkSubmitNDRangeDouble)
     EXPECT_TRUE(worked);
 }
 
+struct TestQueueSubmitBarrier : public ::testing::Test
+{
+    DPCTLSyclQueueRef QRef = nullptr;
+
+    TestQueueSubmitBarrier()
+    {
+        DPCTLSyclDeviceSelectorRef DSRef = nullptr;
+        DPCTLSyclDeviceRef DRef = nullptr;
+
+        EXPECT_NO_FATAL_FAILURE(DSRef = DPCTLDefaultSelector_Create());
+        EXPECT_NO_FATAL_FAILURE(DRef = DPCTLDevice_CreateFromSelector(DSRef));
+        EXPECT_NO_FATAL_FAILURE(QRef = DPCTLQueue_CreateForDevice(
+                                    DRef, nullptr, DPCTL_DEFAULT_PROPERTY));
+        EXPECT_NO_FATAL_FAILURE(DPCTLDevice_Delete(DRef));
+        EXPECT_NO_FATAL_FAILURE(DPCTLDeviceSelector_Delete(DSRef));
+    }
+    ~TestQueueSubmitBarrier()
+    {
+        EXPECT_NO_FATAL_FAILURE(DPCTLQueue_Delete(QRef));
+    }
+};
+
+TEST_F(TestQueueSubmitBarrier, ChkSubmitBarrier)
+{
+    DPCTLSyclEventRef ERef = nullptr;
+
+    ASSERT_TRUE(QRef != nullptr);
+    EXPECT_NO_FATAL_FAILURE(ERef = DPCTLQueue_SubmitBarrier(QRef));
+    ASSERT_TRUE(ERef != nullptr);
+    EXPECT_NO_FATAL_FAILURE(DPCTLEvent_Wait(ERef));
+    EXPECT_NO_FATAL_FAILURE(DPCTLEvent_Delete(ERef));
+}
+
+TEST_F(TestQueueSubmitBarrier, ChkSubmitBarrierWithEvents)
+{
+    DPCTLSyclEventRef ERef = nullptr;
+    DPCTLSyclEventRef DepsERefs[2] = {nullptr, nullptr};
+
+    EXPECT_NO_FATAL_FAILURE(DepsERefs[0] = DPCTLEvent_Create());
+    EXPECT_NO_FATAL_FAILURE(DepsERefs[1] = DPCTLEvent_Create());
+
+    ASSERT_TRUE(QRef != nullptr);
+    EXPECT_NO_FATAL_FAILURE(
+        ERef = DPCTLQueue_SubmitBarrierForEvents(QRef, DepsERefs, 2));
+
+    ASSERT_TRUE(ERef != nullptr);
+    EXPECT_NO_FATAL_FAILURE(DPCTLEvent_Wait(ERef));
+    EXPECT_NO_FATAL_FAILURE(DPCTLEvent_Delete(ERef));
+    EXPECT_NO_FATAL_FAILURE(DPCTLEvent_Delete(DepsERefs[0]));
+    EXPECT_NO_FATAL_FAILURE(DPCTLEvent_Delete(DepsERefs[1]));
+}
+
 #endif