Add DPCTLEvent_GetWaitList func

Author: vlad-perevezentsev

dpctl-capi/include/dpctl_sycl_event_interface.h

@@ -31,6 +31,8 @@
 #include "dpctl_data_types.h"
 #include "dpctl_sycl_enum_types.h"
 #include "dpctl_sycl_types.h"
+#include "dpctl_sycl_event_manager.h"
+
 
 DPCTL_C_EXTERN_C_BEGIN
 
@@ -91,4 +93,15 @@ DPCTLEvent_Copy(__dpctl_keep const DPCTLSyclEventRef ERef);
 DPCTL_API
 DPCTLSyclBackendType DPCTLEvent_GetBackend(__dpctl_keep DPCTLSyclEventRef ERef);
 
+/*!
+ * @brief  Return the vector of events that this event waits for
+ *
+ * @param    ERef           Opaque pointer to a ``sycl::event``
+ * @return   A DPCTLEventVectorRef of DPCTLSyclEventRef objects
+ * @ingroup EventInterface
+ */
+DPCTL_API
+__dpctl_give DPCTLEventVectorRef
+DPCTLEvent_GetWaitList(__dpctl_keep DPCTLSyclEventRef ERef);
+
 DPCTL_C_EXTERN_C_END

dpctl-capi/include/dpctl_sycl_event_manager.h

@@ -0,0 +1,49 @@
+//===-- dpctl_sycl_event_manager.h - Helpers for sycl::event -*-C++-*- =//
+//
+//                      Data Parallel Control (dpctl)
+//
+// Copyright 2020-2021 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This header declares helper functions to work with  sycl::event objects.
+///
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "Support/DllExport.h"
+#include "Support/ExternC.h"
+#include "Support/MemOwnershipAttrs.h"
+#include "dpctl_sycl_types.h"
+#include "dpctl_vector.h"
+
+DPCTL_C_EXTERN_C_BEGIN
+
+/*! \addtogroup EventManager Event class helper functions
+ * Helper functions for ``sycl::event`` objects that do not directly map to
+ * any ``sycl::event`` member function.
+ * @{
+ */
+
+// Declares a set of types abd functions to deal with vectors of
+// DPCTLSyclEventRef. Refer dpctl_vector_macros.h
+
+DPCTL_DECLARE_VECTOR(Event)
+
+/*! @} */
+
+DPCTL_C_EXTERN_C_END

dpctl-capi/source/dpctl_sycl_event_interface.cpp

@@ -35,6 +35,8 @@ namespace
 {
 // Create wrappers for C Binding types (see CBindingWrapping.h)
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(event, DPCTLSyclEventRef)
+DEFINE_SIMPLE_CONVERSION_FUNCTIONS(vector_class<DPCTLSyclEventRef>,
+                                   DPCTLEventVectorRef)
 } /* end of anonymous namespace */
 
 __dpctl_give DPCTLSyclEventRef DPCTLEvent_Create()
@@ -91,3 +93,39 @@ DPCTLSyclBackendType DPCTLEvent_GetBackend(__dpctl_keep DPCTLSyclEventRef ERef)
     }
     return BTy;
 }
+
+__dpctl_give DPCTLEventVectorRef
+DPCTLEvent_GetWaitList(__dpctl_keep DPCTLSyclEventRef ERef)
+{
+    auto E = unwrap(ERef);
+    if (!E) {
+        std::cerr << "Cannot get wait list as input is a nullptr\n";
+        return nullptr;
+    }
+    vector_class<DPCTLSyclEventRef> *EventsVectorPtr = nullptr;
+    try {
+        EventsVectorPtr = new vector_class<DPCTLSyclEventRef>();
+    } catch (std::bad_alloc const &ba) {
+        // \todo log error
+        std::cerr << ba.what() << '\n';
+        return nullptr;
+    }
+    try {
+        auto Events = E->get_wait_list();
+        EventsVectorPtr->reserve(Events.size());
+        for (const auto &Ev : Events) {
+            EventsVectorPtr->emplace_back(wrap(new event(Ev)));
+        }
+        return wrap(EventsVectorPtr);
+    } catch (std::bad_alloc const &ba) {
+        delete EventsVectorPtr;
+        // \todo log error
+        std::cerr << ba.what() << '\n';
+        return nullptr;
+    } catch (const runtime_error &re) {
+        delete EventsVectorPtr;
+        // \todo log error
+        std::cerr << re.what() << '\n';
+        return nullptr;
+    }
+}

dpctl-capi/source/dpctl_sycl_event_manager.cpp

@@ -0,0 +1,44 @@
+//=== dpctl_sycl_event_manager.cpp - Implements helpers for sycl::event //
+//
+//                      Data Parallel Control (dpctl)
+//
+// Copyright 2020-2021 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file implements the functions declared in
+/// dpctl_sycl_event_manager.h.
+///
+//===----------------------------------------------------------------------===//
+
+#include "dpctl_sycl_event_manager.h"
+#include "../helper/include/dpctl_utils_helper.h"
+#include "Support/CBindingWrapping.h"
+#include "dpctl_sycl_event_interface.h"
+#include <CL/sycl.hpp>
+
+
+using namespace cl::sycl;
+
+namespace
+{
+DEFINE_SIMPLE_CONVERSION_FUNCTIONS(event, DPCTLSyclEventRef);
+}
+
+#undef EL
+#define EL Event
+#include "dpctl_vector_templ.cpp"
+#undef EL

dpctl-capi/tests/test_sycl_event_interface.cpp

@@ -26,14 +26,18 @@
 
 #include "Support/CBindingWrapping.h"
 #include "dpctl_sycl_event_interface.h"
+#include "dpctl_sycl_types.h"
 #include <CL/sycl.hpp>
 #include <gtest/gtest.h>
+#include <typeinfo>
 
 using namespace cl::sycl;
 
 namespace
 {
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(event, DPCTLSyclEventRef)
+DEFINE_SIMPLE_CONVERSION_FUNCTIONS(vector_class<DPCTLSyclEventRef>,
+                                   DPCTLEventVectorRef)
 } // namespace
 
 struct TestDPCTLSyclEventInterface : public ::testing::Test
@@ -100,3 +104,12 @@ TEST_F(TestDPCTLSyclEventInterface, CheckGetBackend_Invalid)
     EXPECT_NO_FATAL_FAILURE(Bty = DPCTLEvent_GetBackend(E));
     EXPECT_TRUE(Bty == DPCTL_UNKNOWN_BACKEND);
 }
+
+TEST_F(TestDPCTLSyclEventInterface, CheckGetWaitList)
+{
+    DPCTLEventVectorRef EVRef = nullptr;
+    EXPECT_NO_FATAL_FAILURE(EVRef = DPCTLEvent_GetWaitList(ERef));
+    ASSERT_TRUE(EVRef);
+    EXPECT_NO_FATAL_FAILURE(DPCTLEventVector_Clear(EVRef));
+    EXPECT_NO_FATAL_FAILURE(DPCTLEventVector_Delete(EVRef));
+}