Implement olGetEventInfo(Size)

Author: callumfare

offload/liboffload/API/Event.td

@@ -29,3 +29,51 @@ def : Function {
     ];
     let returns = [];
 }
+
+def : Enum {
+  let name = "ol_event_info_t";
+  let desc = "Supported event info.";
+  let is_typed = 1;
+  let etors = [
+    TaggedEtor<"QUEUE", "ol_queue_handle_t", "The handle of the queue associated with the device.">
+  ];
+}
+
+def : Function {
+  let name = "olGetEventInfo";
+  let desc = "Queries the given property of the event.";
+  let details = [
+    "`olGetEventInfoSize` can be used to query the storage size "
+    "required for the given query."
+  ];
+  let params = [
+    Param<"ol_event_handle_t", "Event", "handle of the event", PARAM_IN>,
+    Param<"ol_event_info_t", "PropName", "type of the info to retrieve", PARAM_IN>,
+    Param<"size_t", "PropSize", "the number of bytes pointed to by PropValue.", PARAM_IN>,
+    TypeTaggedParam<"void*", "PropValue", "array of bytes holding the info. "
+      "If PropSize is not equal to or greater to the real number of bytes needed to return the info "
+      "then the OL_ERRC_INVALID_SIZE error is returned and PropValue is not used.", PARAM_OUT,
+      TypeInfo<"PropName" , "PropSize">>
+  ];
+  let returns = [
+    Return<"OL_ERRC_INVALID_SIZE", [
+      "`PropSize == 0`",
+      "If `PropSize` is less than the real number of bytes needed to return the info."
+    ]>,
+    Return<"OL_ERRC_INVALID_EVENT">
+  ];
+}
+
+def : Function {
+  let name = "olGetEventInfoSize";
+  let desc = "Returns the storage size of the given event query.";
+  let details = [];
+  let params = [
+    Param<"ol_event_handle_t", "Event", "handle of the event", PARAM_IN>,
+    Param<"ol_event_info_t", "PropName", "type of the info to query", PARAM_IN>,
+    Param<"size_t*", "PropSizeRet", "pointer to the number of bytes required to store the query", PARAM_OUT>
+  ];
+  let returns = [
+    Return<"OL_ERRC_INVALID_EVENT">
+  ];
+}

offload/liboffload/src/OffloadImpl.cpp

@@ -409,6 +409,34 @@ Error olDestroyEvent_impl(ol_event_handle_t Event) {
   return olDestroy(Event);
 }
 
+Error olGetEventInfoImplDetail(ol_event_handle_t Event,
+                               ol_event_info_t PropName, size_t PropSize,
+                               void *PropValue, size_t *PropSizeRet) {
+  ReturnHelper ReturnValue(PropSize, PropValue, PropSizeRet);
+
+  switch (PropName) {
+  case OL_EVENT_INFO_QUEUE:
+    return ReturnValue(Event->Queue);
+  default:
+    return createOffloadError(ErrorCode::INVALID_ENUMERATION,
+                              "olGetEventInfo enum '%i' is invalid", PropName);
+  }
+
+  return Error::success();
+}
+
+Error olGetEventInfo_impl(ol_event_handle_t Event, ol_event_info_t PropName,
+                          size_t PropSize, void *PropValue) {
+
+  return olGetEventInfoImplDetail(Event, PropName, PropSize, PropValue,
+                                  nullptr);
+}
+
+Error olGetEventInfoSize_impl(ol_event_handle_t Event, ol_event_info_t PropName,
+                              size_t *PropSizeRet) {
+  return olGetEventInfoImplDetail(Event, PropName, 0, nullptr, PropSizeRet);
+}
+
 ol_event_handle_t makeEvent(ol_queue_handle_t Queue) {
   auto EventImpl = std::make_unique<ol_event_impl_t>(nullptr, Queue);
   if (auto Res = Queue->Device->Device->createEvent(&EventImpl->EventInfo)) {

offload/unittests/OffloadAPI/CMakeLists.txt

@@ -10,7 +10,9 @@ add_offload_unittest("device"
 
 add_offload_unittest("event"
     event/olDestroyEvent.cpp
-    event/olWaitEvent.cpp)
+    event/olWaitEvent.cpp
+    event/olGetEventInfo.cpp
+    event/olGetEventInfoSize.cpp)
 
 add_offload_unittest("kernel"
     kernel/olGetKernel.cpp

offload/unittests/OffloadAPI/common/Fixtures.hpp

@@ -139,6 +139,31 @@ struct OffloadQueueTest : OffloadDeviceTest {
   ol_queue_handle_t Queue = nullptr;
 };
 
+struct OffloadEventTest : OffloadQueueTest {
+  void SetUp() override {
+    RETURN_ON_FATAL_FAILURE(OffloadQueueTest::SetUp());
+
+    // Get an event from a memcpy. We can still use it in olGetEventInfo etc
+    // after it has been waited on.
+    void *Alloc;
+    uint32_t Value = 42;
+    ASSERT_SUCCESS(
+        olMemAlloc(Device, OL_ALLOC_TYPE_DEVICE, sizeof(Value), &Alloc));
+    ASSERT_SUCCESS(
+        olMemcpy(Queue, Alloc, Device, &Value, Host, sizeof(Value), &Event));
+    ASSERT_SUCCESS(olWaitEvent(Event));
+    ASSERT_SUCCESS(olMemFree(Alloc));
+  }
+
+  void TearDown() override {
+    if (Event)
+      olDestroyEvent(Event);
+    RETURN_ON_FATAL_FAILURE(OffloadQueueTest::TearDown());
+  }
+
+  ol_event_handle_t Event = nullptr;
+};
+
 #define OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(FIXTURE)                      \
   INSTANTIATE_TEST_SUITE_P(                                                    \
       , FIXTURE, ::testing::ValuesIn(TestEnvironment::getDevices()),           \