Implement olGetQueueInfo(Size)

Author: callumfare

offload/liboffload/API/Queue.td

@@ -40,3 +40,51 @@ def : Function {
     ];
     let returns = [];
 }
+
+def : Enum {
+  let name = "ol_queue_info_t";
+  let desc = "Supported queue info.";
+  let is_typed = 1;
+  let etors = [
+    TaggedEtor<"DEVICE", "ol_device_handle_t", "The handle of the device associated with the queue.">
+  ];
+}
+
+def : Function {
+  let name = "olGetQueueInfo";
+  let desc = "Queries the given property of the queue.";
+  let details = [
+    "`olGetQueueInfoSize` can be used to query the storage size "
+    "required for the given query."
+  ];
+  let params = [
+    Param<"ol_queue_handle_t", "Queue", "handle of the queue", PARAM_IN>,
+    Param<"ol_queue_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 Size 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 pPlatformInfo 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_QUEUE">
+  ];
+}
+
+def : Function {
+  let name = "olGetQueueInfoSize";
+  let desc = "Returns the storage size of the given queue query.";
+  let details = [];
+  let params = [
+    Param<"ol_queue_handle_t", "Queue", "handle of the queue", PARAM_IN>,
+    Param<"ol_queue_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_QUEUE">
+  ];
+}

offload/liboffload/src/OffloadImpl.cpp

@@ -368,6 +368,33 @@ Error olWaitQueue_impl(ol_queue_handle_t Queue) {
   return Error::success();
 }
 
+Error olGetQueueInfoImplDetail(ol_queue_handle_t Queue,
+                               ol_queue_info_t PropName, size_t PropSize,
+                               void *PropValue, size_t *PropSizeRet) {
+  ReturnHelper ReturnValue(PropSize, PropValue, PropSizeRet);
+
+  switch (PropName) {
+  case OL_QUEUE_INFO_DEVICE:
+    return ReturnValue(Queue->Device);
+  default:
+    return createOffloadError(ErrorCode::INVALID_ENUMERATION,
+                              "olGetQueueInfo enum '%i' is invalid", PropName);
+  }
+
+  return Error::success();
+}
+
+Error olGetQueueInfo_impl(ol_queue_handle_t Queue, ol_queue_info_t PropName,
+                          size_t PropSize, void *PropValue) {
+  return olGetQueueInfoImplDetail(Queue, PropName, PropSize, PropValue,
+                                  nullptr);
+}
+
+Error olGetQueueInfoSize_impl(ol_queue_handle_t Queue, ol_queue_info_t PropName,
+                              size_t *PropSizeRet) {
+  return olGetQueueInfoImplDetail(Queue, PropName, 0, nullptr, PropSizeRet);
+}
+
 Error olWaitEvent_impl(ol_event_handle_t Event) {
   if (auto Res = Event->Queue->Device->Device->syncEvent(Event->EventInfo))
     return Res;

offload/unittests/OffloadAPI/CMakeLists.txt

@@ -32,4 +32,6 @@ add_offload_unittest("program"
 add_offload_unittest("queue"
     queue/olCreateQueue.cpp
     queue/olWaitQueue.cpp
-    queue/olDestroyQueue.cpp)
+    queue/olDestroyQueue.cpp
+    queue/olGetQueueInfo.cpp
+    queue/olGetQueueInfoSize.cpp)

offload/unittests/OffloadAPI/queue/olGetQueueInfo.cpp

@@ -0,0 +1,55 @@
+//===------- Offload API tests - olGetQueueInfo ---------------------------===//
+//
+// 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 <OffloadAPI.h>
+
+#include "../common/Fixtures.hpp"
+
+using olGetQueueInfoTest = OffloadQueueTest;
+OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetQueueInfoTest);
+
+TEST_P(olGetQueueInfoTest, SuccessDevice) {
+  ol_device_handle_t RetrievedDevice;
+  ASSERT_SUCCESS(olGetQueueInfo(Queue, OL_QUEUE_INFO_DEVICE,
+                                sizeof(ol_device_handle_t), &RetrievedDevice));
+  ASSERT_EQ(Device, RetrievedDevice);
+}
+
+TEST_P(olGetQueueInfoTest, InvalidNullHandle) {
+  ol_device_handle_t RetrievedDevice;
+  ASSERT_ERROR(OL_ERRC_INVALID_NULL_HANDLE,
+               olGetQueueInfo(nullptr, OL_QUEUE_INFO_DEVICE,
+                              sizeof(RetrievedDevice), &RetrievedDevice));
+}
+
+TEST_P(olGetQueueInfoTest, InvalidQueueInfoEnumeration) {
+  ol_device_handle_t RetrievedDevice;
+  ASSERT_ERROR(OL_ERRC_INVALID_ENUMERATION,
+               olGetQueueInfo(Queue, OL_QUEUE_INFO_FORCE_UINT32,
+                              sizeof(RetrievedDevice), &RetrievedDevice));
+}
+
+TEST_P(olGetQueueInfoTest, InvalidSizeZero) {
+  ol_device_handle_t RetrievedDevice;
+  ASSERT_ERROR(OL_ERRC_INVALID_SIZE, olGetQueueInfo(Queue, OL_QUEUE_INFO_DEVICE,
+                                                    0, &RetrievedDevice));
+}
+
+TEST_P(olGetQueueInfoTest, InvalidSizeSmall) {
+  ol_device_handle_t RetrievedDevice;
+  ASSERT_ERROR(OL_ERRC_INVALID_SIZE,
+               olGetQueueInfo(Queue, OL_QUEUE_INFO_DEVICE,
+                              sizeof(RetrievedDevice) - 1, &RetrievedDevice));
+}
+
+TEST_P(olGetQueueInfoTest, InvalidNullPointerPropValue) {
+  ol_device_handle_t RetrievedDevice;
+  ASSERT_ERROR(OL_ERRC_INVALID_NULL_POINTER,
+               olGetQueueInfo(Queue, OL_QUEUE_INFO_DEVICE,
+                              sizeof(RetrievedDevice), nullptr));
+}

offload/unittests/OffloadAPI/queue/olGetQueueInfoSize.cpp

@@ -0,0 +1,37 @@
+//===------- Offload API tests - olGetQueueInfoSize -----------------------===//
+//
+// 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 <OffloadAPI.h>
+
+#include "../common/Fixtures.hpp"
+
+using olGetQueueInfoSizeTest = OffloadQueueTest;
+OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetQueueInfoSizeTest);
+
+TEST_P(olGetQueueInfoSizeTest, SuccessDevice) {
+  size_t Size = 0;
+  ASSERT_SUCCESS(olGetQueueInfoSize(Queue, OL_QUEUE_INFO_DEVICE, &Size));
+  ASSERT_EQ(Size, sizeof(ol_device_handle_t));
+}
+
+TEST_P(olGetQueueInfoSizeTest, InvalidNullHandle) {
+  size_t Size = 0;
+  ASSERT_ERROR(OL_ERRC_INVALID_NULL_HANDLE,
+               olGetQueueInfoSize(nullptr, OL_QUEUE_INFO_DEVICE, &Size));
+}
+
+TEST_P(olGetQueueInfoSizeTest, InvalidQueueInfoEnumeration) {
+  size_t Size = 0;
+  ASSERT_ERROR(OL_ERRC_INVALID_ENUMERATION,
+               olGetQueueInfoSize(Queue, OL_QUEUE_INFO_FORCE_UINT32, &Size));
+}
+
+TEST_P(olGetQueueInfoSizeTest, InvalidNullPointer) {
+  ASSERT_ERROR(OL_ERRC_INVALID_NULL_POINTER,
+               olGetQueueInfoSize(Queue, OL_QUEUE_INFO_DEVICE, nullptr));
+}