[CTS] Use C++ 17 features

Petr Vesely · veselypeta · commit 28987ad63f27 · 2023-02-24T14:24:00.000Z
diff --git a/include/ur.py b/include/ur.py
@@ -562,15 +562,17 @@ def __str__(self):
 ###############################################################################
 ## @brief Query queue info
 class ur_queue_info_v(IntEnum):
-    CONTEXT = 0                                     ## Queue context info
-    DEVICE = 1                                      ## Queue device info
-    DEVICE_DEFAULT = 2                              ## Queue device default info
-    PROPERTIES = 3                                  ## Queue properties info
+    CONTEXT = 0                                     ## ::ur_queue_handle_t: context associated with this queue.
+    DEVICE = 1                                      ## ::ur_device_handle_t: device associated with this queue.
+    DEVICE_DEFAULT = 2                              ## ::ur_queue_handle_t: the current default queue of the underlying
+                                                    ## device.
+    PROPERTIES = 3                                  ## ::ur_queue_flags_t: the properties associated with
+                                                    ## ::UR_QUEUE_PROPERTIES_FLAGS.
     REFERENCE_COUNT = 4                             ## [uint32_t] Reference count of the queue object.
                                                     ## The reference count returned should be considered immediately stale. 
                                                     ## It is unsuitable for general use in applications. This feature is
                                                     ## provided for identifying memory leaks.
-    SIZE = 5                                        ## Queue size info
+    SIZE = 5                                        ## uint32_t: The size of the queue
 
 class ur_queue_info_t(c_int):
     def __str__(self):
diff --git a/include/ur_api.h b/include/ur_api.h
@@ -2331,15 +2331,17 @@ urTearDown(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Query queue info
 typedef enum ur_queue_info_t {
-    UR_QUEUE_INFO_CONTEXT = 0,         ///< Queue context info
-    UR_QUEUE_INFO_DEVICE = 1,          ///< Queue device info
-    UR_QUEUE_INFO_DEVICE_DEFAULT = 2,  ///< Queue device default info
-    UR_QUEUE_INFO_PROPERTIES = 3,      ///< Queue properties info
+    UR_QUEUE_INFO_CONTEXT = 0,         ///< ::ur_queue_handle_t: context associated with this queue.
+    UR_QUEUE_INFO_DEVICE = 1,          ///< ::ur_device_handle_t: device associated with this queue.
+    UR_QUEUE_INFO_DEVICE_DEFAULT = 2,  ///< ::ur_queue_handle_t: the current default queue of the underlying
+                                       ///< device.
+    UR_QUEUE_INFO_PROPERTIES = 3,      ///< ::ur_queue_flags_t: the properties associated with
+                                       ///< ::UR_QUEUE_PROPERTIES_FLAGS.
     UR_QUEUE_INFO_REFERENCE_COUNT = 4, ///< [uint32_t] Reference count of the queue object.
                                        ///< The reference count returned should be considered immediately stale.
                                        ///< It is unsuitable for general use in applications. This feature is
                                        ///< provided for identifying memory leaks.
-    UR_QUEUE_INFO_SIZE = 5,            ///< Queue size info
+    UR_QUEUE_INFO_SIZE = 5,            ///< uint32_t: The size of the queue
     /// @cond
     UR_QUEUE_INFO_FORCE_UINT32 = 0x7fffffff
     /// @endcond
diff --git a/test/conformance/context/urContextRelease.cpp b/test/conformance/context/urContextRelease.cpp
@@ -9,15 +9,15 @@ UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urContextReleaseTest);
 TEST_P(urContextReleaseTest, Success) {
     ASSERT_SUCCESS(urContextRetain(context));
 
-    const auto prevRefCount = uur::urContextGetReferenceCount(context);
-    ASSERT_TRUE(prevRefCount.second);
+    const auto prevRefCount = uur::GetObjectReferenceCount(context);
+    ASSERT_TRUE(prevRefCount.has_value());
 
     ASSERT_SUCCESS(urContextRelease(context));
 
-    const auto refCount = uur::urContextGetReferenceCount(context);
-    ASSERT_TRUE(refCount.second);
+    const auto refCount = uur::GetObjectReferenceCount(context);
+    ASSERT_TRUE(refCount.has_value());
 
-    ASSERT_GT(prevRefCount.first, refCount.first);
+    ASSERT_GT(prevRefCount.value(), refCount.value());
 }
 
 TEST_P(urContextReleaseTest, InvalidNullHandleContext) {
diff --git a/test/conformance/context/urContextRetain.cpp b/test/conformance/context/urContextRetain.cpp
@@ -7,15 +7,15 @@ using urContextRetainTest = uur::urContextTest;
 UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urContextRetainTest);
 
 TEST_P(urContextRetainTest, Success) {
-    const auto prevRefCount = uur::urContextGetReferenceCount(context);
-    ASSERT_TRUE(prevRefCount.second);
+    const auto prevRefCount = uur::GetObjectReferenceCount(context);
+    ASSERT_TRUE(prevRefCount.has_value());
 
     ASSERT_SUCCESS(urContextRetain(context));
 
-    const auto refCount = uur::urContextGetReferenceCount(context);
-    ASSERT_TRUE(refCount.second);
+    const auto refCount = uur::GetObjectReferenceCount(context);
+    ASSERT_TRUE(refCount.has_value());
 
-    ASSERT_LT(prevRefCount.first, refCount.first);
+    ASSERT_LT(prevRefCount.value(), refCount.value());
 
     EXPECT_SUCCESS(urContextRelease(context));
 }
diff --git a/test/conformance/device/urDeviceRelease.cpp b/test/conformance/device/urDeviceRelease.cpp
@@ -8,15 +8,15 @@ TEST_F(urDeviceReleaseTest, Success) {
     for (auto device : devices) {
         ASSERT_SUCCESS(urDeviceRetain(device));
 
-        const auto prevRefCount = uur::urDeviceGetReferenceCount(device);
-        ASSERT_TRUE(prevRefCount.second);
+        const auto prevRefCount = uur::GetObjectReferenceCount(device);
+        ASSERT_TRUE(prevRefCount.has_value());
 
         EXPECT_SUCCESS(urDeviceRelease(device));
 
-        const auto refCount = uur::urDeviceGetReferenceCount(device);
-        ASSERT_TRUE(refCount.second);
+        const auto refCount = uur::GetObjectReferenceCount(device);
+        ASSERT_TRUE(refCount.has_value());
 
-        ASSERT_GT(prevRefCount.first, refCount.first);
+        ASSERT_GT(prevRefCount.value(), refCount.value());
     }
 }
 
diff --git a/test/conformance/device/urDeviceRetain.cpp b/test/conformance/device/urDeviceRetain.cpp
@@ -7,15 +7,15 @@ using urDeviceRetainTest = uur::urAllDevicesTest;
 
 TEST_F(urDeviceRetainTest, Success) {
     for (auto device : devices) {
-        const auto prevRefCount = uur::urDeviceGetReferenceCount(device);
-        ASSERT_TRUE(prevRefCount.second);
+        const auto prevRefCount = uur::GetObjectReferenceCount(device);
+        ASSERT_TRUE(prevRefCount.has_value());
 
         ASSERT_SUCCESS(urDeviceRetain(device));
 
-        const auto refCount = uur::urDeviceGetReferenceCount(device);
-        ASSERT_TRUE(refCount.second);
+        const auto refCount = uur::GetObjectReferenceCount(device);
+        ASSERT_TRUE(refCount.has_value());
 
-        ASSERT_LT(prevRefCount.first, refCount.first);
+        ASSERT_LT(prevRefCount.value(), refCount.value());
 
         EXPECT_SUCCESS(urDeviceRelease(device));
     }
diff --git a/test/conformance/event/urEventRelease.cpp b/test/conformance/event/urEventRelease.cpp
@@ -10,15 +10,15 @@ UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urEventReleaseTest);
 TEST_P(urEventReleaseTest, Success) {
     ASSERT_SUCCESS(urEventRetain(event));
 
-    const auto prevRefCount = uur::urEventGetReferenceCount(event);
-    ASSERT_TRUE(prevRefCount.second);
+    const auto prevRefCount = uur::GetObjectReferenceCount(event);
+    ASSERT_TRUE(prevRefCount.has_value());
 
     ASSERT_SUCCESS(urEventRelease(event));
 
-    const auto refCount = uur::urEventGetReferenceCount(event);
-    ASSERT_TRUE(refCount.second);
+    const auto refCount = uur::GetObjectReferenceCount(event);
+    ASSERT_TRUE(refCount.has_value());
 
-    ASSERT_GT(prevRefCount.first, refCount.first);
+    ASSERT_GT(prevRefCount.value(), refCount.value());
 }
 
 TEST_P(urEventReleaseTest, InvalidNullHandle) {
diff --git a/test/conformance/event/urEventRetain.cpp b/test/conformance/event/urEventRetain.cpp
@@ -7,15 +7,15 @@ using urEventRetainTest = uur::event::urEventTest;
 UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urEventRetainTest);
 
 TEST_P(urEventRetainTest, Success) {
-    const auto prevRefCount = uur::urEventGetReferenceCount(event);
-    ASSERT_TRUE(prevRefCount.second);
+    const auto prevRefCount = uur::GetObjectReferenceCount(event);
+    ASSERT_TRUE(prevRefCount.has_value());
 
     ASSERT_SUCCESS(urEventRetain(event));
 
-    const auto refCount = uur::urEventGetReferenceCount(event);
-    ASSERT_TRUE(refCount.second);
+    const auto refCount = uur::GetObjectReferenceCount(event);
+    ASSERT_TRUE(refCount.has_value());
 
-    ASSERT_LT(prevRefCount.first, refCount.first);
+    ASSERT_LT(prevRefCount.value(), refCount.value());
 
     ASSERT_SUCCESS(urEventRelease(event));
 }
diff --git a/test/conformance/queue/urQueueRelease.cpp b/test/conformance/queue/urQueueRelease.cpp
@@ -8,15 +8,15 @@ UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urQueueReleaseTest);
 TEST_P(urQueueReleaseTest, Success) {
     ASSERT_SUCCESS(urQueueRetain(queue));
 
-    const auto prevRefCount = uur::urQueueGetReferenceCount(queue);
-    ASSERT_TRUE(prevRefCount.second);
+    const auto prevRefCount = uur::GetObjectReferenceCount(queue);
+    ASSERT_TRUE(prevRefCount.has_value());
 
     ASSERT_SUCCESS(urQueueRelease(queue));
 
-    const auto refCount = uur::urQueueGetReferenceCount(queue);
-    ASSERT_TRUE(refCount.second);
+    const auto refCount = uur::GetObjectReferenceCount(queue);
+    ASSERT_TRUE(refCount.has_value());
 
-    ASSERT_GT(prevRefCount.first, refCount.first);
+    ASSERT_GT(prevRefCount.value(), refCount.value());
 }
 
 TEST_P(urQueueReleaseTest, InvalidNullHandleQueue) {
diff --git a/test/conformance/queue/urQueueRetain.cpp b/test/conformance/queue/urQueueRetain.cpp
@@ -6,15 +6,15 @@ using urQueueRetainTest = uur::urQueueTest;
 UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urQueueRetainTest);
 
 TEST_P(urQueueRetainTest, Success) {
-    const auto prevRefCount = uur::urQueueGetReferenceCount(queue);
-    ASSERT_TRUE(prevRefCount.second);
+    const auto prevRefCount = uur::GetObjectReferenceCount(queue);
+    ASSERT_TRUE(prevRefCount.has_value());
 
     ASSERT_SUCCESS(urQueueRetain(queue));
 
-    const auto refCount = uur::urQueueGetReferenceCount(queue);
-    ASSERT_TRUE(refCount.second);
+    const auto refCount = uur::GetObjectReferenceCount(queue);
+    ASSERT_TRUE(refCount.has_value());
 
-    ASSERT_LT(prevRefCount.first, refCount.first);
+    ASSERT_LT(prevRefCount.value(), refCount.value());
 
     EXPECT_SUCCESS(urQueueRelease(queue));
 }
diff --git a/test/conformance/testing/uur/utils.h b/test/conformance/testing/uur/utils.h
@@ -4,6 +4,7 @@
 #ifndef UR_CONFORMANCE_INCLUDE_UTILS_H_INCLUDED
 #define UR_CONFORMANCE_INCLUDE_UTILS_H_INCLUDED
 
+#include <optional>
 #include <string>
 #include <uur/environment.h>
 
@@ -47,44 +48,84 @@ inline std::string GetPlatformAndDeviceName(ur_device_handle_t device) {
     return GetPlatformName(GetPlatform()) + "__" + GetDeviceName(device);
 }
 
-inline std::pair<uint32_t, bool>
-urContextGetReferenceCount(ur_context_handle_t context) {
-    uint32_t refCount = 0;
-    if (urContextGetInfo(context, UR_CONTEXT_INFO_REFERENCE_COUNT,
-                         sizeof(uint32_t), &refCount, nullptr)) {
-        return {0, false};
+template <class T, class ObjectTy, class InfoTy, class Callable>
+std::optional<T> GetInfo(ObjectTy object, InfoTy info, Callable cb) {
+    size_t infoSize = 0;
+    if (cb(object, info, 0, nullptr, &infoSize)) {
+        return std::nullopt;
     }
-    return {refCount, true};
-}
-
-inline std::pair<uint32_t, bool>
-urDeviceGetReferenceCount(ur_device_handle_t device) {
-    uint32_t refCount = 0;
-    if (urDeviceGetInfo(device, UR_DEVICE_INFO_REFERENCE_COUNT,
-                        sizeof(uint32_t), &refCount, 0)) {
-        return {0, false};
+    if (infoSize == 0 || infoSize != sizeof(T)) {
+        return std::nullopt;
     }
-    return {refCount, true};
-}
-
-inline std::pair<uint32_t, bool>
-urEventGetReferenceCount(ur_event_handle_t event) {
-    int32_t refCount = 0;
-    if (urEventGetInfo(event, UR_EVENT_INFO_REFERENCE_COUNT, sizeof(uint32_t),
-                       &refCount, 0)) {
-        return {0, false};
+    T queryValue{};
+    if (cb(object, info, sizeof(T), &queryValue, nullptr)) {
+        return std::nullopt;
     }
-    return {refCount, true};
+    return queryValue;
 }
 
-inline std::pair<uint32_t, bool>
-urQueueGetReferenceCount(ur_queue_handle_t queue) {
-    uint32_t refCount = 0;
-    if (urQueueGetInfo(queue, UR_QUEUE_INFO_REFERENCE_COUNT, sizeof(uint32_t),
-                       &refCount, nullptr)) {
-        return {0, false};
+template <class T>
+auto GetContextInfo = [](ur_context_handle_t context, ur_context_info_t info) {
+    return GetInfo<T>(context, info, urContextGetInfo);
+};
+
+template <class T>
+auto GetDeviceInfo = [](ur_device_handle_t device, ur_device_info_t info) {
+    return GetInfo<T>(device, info, urDeviceGetInfo);
+};
+
+template <class T>
+auto GetEventInfo = [](ur_event_handle_t event, ur_event_info_t info) {
+    return GetInfo<T>(event, info, urEventGetInfo);
+};
+
+template <class T>
+auto GetQueueInfo = [](ur_queue_handle_t queue, ur_queue_info_t info) {
+    return GetInfo<T>(queue, info, urQueueGetInfo);
+};
+
+template <class T>
+auto GetSamplerInfo = [](ur_sampler_handle_t sampler, ur_sampler_info_t info) {
+    return GetInfo<T>(sampler, info, urSamplerGetInfo);
+};
+
+template <class T>
+auto GetKernelInfo = [](ur_kernel_handle_t kernel, ur_kernel_info_t info) {
+    return GetInfo<T>(kernel, info, urKernelGetInfo);
+};
+
+template <class T>
+auto GetProgramInfo = [](ur_program_handle_t program, ur_program_info_t info) {
+    return GetInfo<T>(program, info, urProgramGetInfo);
+};
+
+template <class T>
+std::optional<uint32_t> GetObjectReferenceCount(T object) {
+    if constexpr (std::is_same_v<T, ur_context_handle_t>) {
+        return GetContextInfo<uint32_t>(object,
+                                        UR_CONTEXT_INFO_REFERENCE_COUNT);
+    }
+    if constexpr (std::is_same_v<T, ur_device_handle_t>) {
+        return GetDeviceInfo<uint32_t>(object, UR_DEVICE_INFO_REFERENCE_COUNT);
+    }
+    if constexpr (std::is_same_v<T, ur_event_handle_t>) {
+        return GetEventInfo<uint32_t>(object, UR_EVENT_INFO_REFERENCE_COUNT);
+    }
+    if constexpr (std::is_same_v<T, ur_queue_handle_t>) {
+        return GetQueueInfo<uint32_t>(object, UR_QUEUE_INFO_REFERENCE_COUNT);
+    }
+    if constexpr (std::is_same_v<T, ur_sampler_handle_t>) {
+        return GetSamplerInfo<uint32_t>(object,
+                                        UR_SAMPLER_INFO_REFERENCE_COUNT);
+    }
+    if constexpr (std::is_same_v<T, ur_kernel_handle_t>) {
+        return GetKernelInfo<uint32_t>(object, UR_KERNEL_INFO_REFERENCE_COUNT);
+    }
+    if constexpr (std::is_same_v<T, ur_program_handle_t>) {
+        return GetProgramInfo<uint32_t>(object,
+                                        UR_PROGRAM_INFO_REFERENCE_COUNT);
     }
-    return {refCount, true};
+    return std::nullopt;
 }
 
 } // namespace uur
