Debian Codegraph @

offload/unittests/OffloadAPI/device/olGetDeviceInfo.cpp

raw
1 //===------- Offload API tests - olGetDeviceInfo --------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "../common/Fixtures.hpp"
10 #include <OffloadAPI.h>
11 #include <gtest/gtest.h>
12
13 using olGetDeviceInfoTest = OffloadDeviceTest;
14 OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetDeviceInfoTest);
15
16 #define OL_DEVICE_INFO_TEST_SUCCESS_CHECK(TestName, PropType, PropName, Dev, \
17 Expr) \
18 TEST_P(olGetDeviceInfoTest, Test##Dev##TestName) { \
19 PropType Value; \
20 ASSERT_SUCCESS(olGetDeviceInfo(Dev, PropName, sizeof(Value), &Value)); \
21 Expr; \
22 }
23
24 #define OL_DEVICE_INFO_TEST_DEVICE_SUCCESS(TestName, PropType, PropName) \
25 OL_DEVICE_INFO_TEST_SUCCESS_CHECK(TestName, PropType, PropName, Device, {})
26
27 #define OL_DEVICE_INFO_TEST_HOST_SUCCESS(TestName, PropType, PropName) \
28 OL_DEVICE_INFO_TEST_SUCCESS_CHECK(TestName, PropType, PropName, Host, {})
29
30 #define OL_DEVICE_INFO_TEST_SUCCESS(TestName, PropType, PropName) \
31 OL_DEVICE_INFO_TEST_DEVICE_SUCCESS(TestName, PropType, PropName) \
32 OL_DEVICE_INFO_TEST_HOST_SUCCESS(TestName, PropType, PropName)
33
34 #define OL_DEVICE_INFO_TEST_DEVICE_VALUE_GT(TestName, PropType, PropName, \
35 LowBound) \
36 OL_DEVICE_INFO_TEST_SUCCESS_CHECK(TestName, PropType, PropName, Device, \
37 ASSERT_GT(Value, LowBound))
38
39 #define OL_DEVICE_INFO_TEST_HOST_VALUE_GT(TestName, PropType, PropName, \
40 LowBound) \
41 OL_DEVICE_INFO_TEST_SUCCESS_CHECK(TestName, PropType, PropName, Host, \
42 ASSERT_GT(Value, LowBound))
43
44 #define OL_DEVICE_INFO_TEST_VALUE_GT(TestName, PropType, PropName, LowBound) \
45 OL_DEVICE_INFO_TEST_DEVICE_VALUE_GT(TestName, PropType, PropName, LowBound) \
46 OL_DEVICE_INFO_TEST_HOST_VALUE_GT(TestName, PropType, PropName, LowBound)
47
48 TEST_P(olGetDeviceInfoTest, SuccessType) {
49 ol_device_type_t DeviceType;
50 ASSERT_SUCCESS(olGetDeviceInfo(Device, OL_DEVICE_INFO_TYPE,
51 sizeof(ol_device_type_t), &DeviceType));
52 }
53
54 TEST_P(olGetDeviceInfoTest, HostSuccessType) {
55 ol_device_type_t DeviceType;
56 ASSERT_SUCCESS(olGetDeviceInfo(Host, OL_DEVICE_INFO_TYPE,
57 sizeof(ol_device_type_t), &DeviceType));
58 ASSERT_EQ(DeviceType, OL_DEVICE_TYPE_HOST);
59 }
60
61 TEST_P(olGetDeviceInfoTest, SuccessPlatform) {
62 ol_platform_handle_t Platform = nullptr;
63 ASSERT_SUCCESS(olGetDeviceInfo(Device, OL_DEVICE_INFO_PLATFORM,
64 sizeof(ol_platform_handle_t), &Platform));
65 ASSERT_NE(Platform, nullptr);
66 }
67
68 TEST_P(olGetDeviceInfoTest, SuccessName) {
69 size_t Size = 0;
70 ASSERT_SUCCESS(olGetDeviceInfoSize(Device, OL_DEVICE_INFO_NAME, &Size));
71 ASSERT_GT(Size, 0ul);
72 std::vector<char> Name;
73 Name.resize(Size);
74 ASSERT_SUCCESS(
75 olGetDeviceInfo(Device, OL_DEVICE_INFO_NAME, Size, Name.data()));
76 ASSERT_EQ(std::strlen(Name.data()), Size - 1);
77 }
78
79 TEST_P(olGetDeviceInfoTest, HostName) {
80 size_t Size = 0;
81 ASSERT_SUCCESS(olGetDeviceInfoSize(Host, OL_DEVICE_INFO_NAME, &Size));
82 ASSERT_GT(Size, 0ul);
83 std::vector<char> Name;
84 Name.resize(Size);
85 ASSERT_SUCCESS(olGetDeviceInfo(Host, OL_DEVICE_INFO_NAME, Size, Name.data()));
86 ASSERT_EQ(std::strlen(Name.data()), Size - 1);
87 }
88
89 TEST_P(olGetDeviceInfoTest, SuccessProductName) {
90 size_t Size = 0;
91 ASSERT_SUCCESS(
92 olGetDeviceInfoSize(Device, OL_DEVICE_INFO_PRODUCT_NAME, &Size));
93 ASSERT_GT(Size, 0ul);
94 std::vector<char> Name;
95 Name.resize(Size);
96 ASSERT_SUCCESS(
97 olGetDeviceInfo(Device, OL_DEVICE_INFO_PRODUCT_NAME, Size, Name.data()));
98 ASSERT_EQ(std::strlen(Name.data()), Size - 1);
99 }
100
101 TEST_P(olGetDeviceInfoTest, SuccessUID) {
102 size_t Size = 0;
103 ASSERT_SUCCESS(olGetDeviceInfoSize(Device, OL_DEVICE_INFO_UID, &Size));
104 ASSERT_GT(Size, 0ul);
105 std::vector<char> UID;
106 UID.resize(Size);
107 ASSERT_SUCCESS(olGetDeviceInfo(Device, OL_DEVICE_INFO_UID, Size, UID.data()));
108 ASSERT_EQ(std::strlen(UID.data()), Size - 1);
109 }
110
111 TEST_P(olGetDeviceInfoTest, HostProductName) {
112 size_t Size = 0;
113 ASSERT_SUCCESS(olGetDeviceInfoSize(Host, OL_DEVICE_INFO_PRODUCT_NAME, &Size));
114 ASSERT_GT(Size, 0ul);
115 std::vector<char> Name;
116 Name.resize(Size);
117 ASSERT_SUCCESS(
118 olGetDeviceInfo(Host, OL_DEVICE_INFO_PRODUCT_NAME, Size, Name.data()));
119 ASSERT_EQ(std::strlen(Name.data()), Size - 1);
120 }
121
122 TEST_P(olGetDeviceInfoTest, HostUID) {
123 size_t Size = 0;
124 ASSERT_SUCCESS(olGetDeviceInfoSize(Host, OL_DEVICE_INFO_UID, &Size));
125 ASSERT_GT(Size, 0ul);
126 std::vector<char> UID;
127 UID.resize(Size);
128 ASSERT_SUCCESS(olGetDeviceInfo(Host, OL_DEVICE_INFO_UID, Size, UID.data()));
129 ASSERT_EQ(std::strlen(UID.data()), Size - 1);
130 }
131
132 TEST_P(olGetDeviceInfoTest, SuccessVendor) {
133 size_t Size = 0;
134 ASSERT_SUCCESS(olGetDeviceInfoSize(Device, OL_DEVICE_INFO_VENDOR, &Size));
135 ASSERT_GT(Size, 0ul);
136 std::vector<char> Vendor;
137 Vendor.resize(Size);
138 ASSERT_SUCCESS(
139 olGetDeviceInfo(Device, OL_DEVICE_INFO_VENDOR, Size, Vendor.data()));
140 ASSERT_EQ(std::strlen(Vendor.data()), Size - 1);
141 }
142
143 TEST_P(olGetDeviceInfoTest, SuccessDriverVersion) {
144 size_t Size = 0;
145 ASSERT_SUCCESS(
146 olGetDeviceInfoSize(Device, OL_DEVICE_INFO_DRIVER_VERSION, &Size));
147 ASSERT_GT(Size, 0ul);
148 std::vector<char> DriverVersion;
149 DriverVersion.resize(Size);
150 ASSERT_SUCCESS(olGetDeviceInfo(Device, OL_DEVICE_INFO_DRIVER_VERSION, Size,
151 DriverVersion.data()));
152 ASSERT_EQ(std::strlen(DriverVersion.data()), Size - 1);
153 }
154
155 OL_DEVICE_INFO_TEST_VALUE_GT(MaxWorkGroupSize, uint32_t,
156 OL_DEVICE_INFO_MAX_WORK_GROUP_SIZE, 0);
157
158 TEST_P(olGetDeviceInfoTest, SuccessMaxWorkGroupSizePerDimension) {
159 ol_dimensions_t Value{0, 0, 0};
160 ASSERT_SUCCESS(
161 olGetDeviceInfo(Device, OL_DEVICE_INFO_MAX_WORK_GROUP_SIZE_PER_DIMENSION,
162 sizeof(Value), &Value));
163 ASSERT_GT(Value.x, 0u);
164 ASSERT_GT(Value.y, 0u);
165 ASSERT_GT(Value.z, 0u);
166 }
167
168 OL_DEVICE_INFO_TEST_VALUE_GT(MaxWorkSize, uint32_t,
169 OL_DEVICE_INFO_MAX_WORK_SIZE, 0);
170
171 TEST_P(olGetDeviceInfoTest, SuccessMaxWorkSizePerDimension) {
172 ol_dimensions_t Value{0, 0, 0};
173 ASSERT_SUCCESS(olGetDeviceInfo(Device,
174 OL_DEVICE_INFO_MAX_WORK_SIZE_PER_DIMENSION,
175 sizeof(Value), &Value));
176 ASSERT_GT(Value.x, 0u);
177 ASSERT_GT(Value.y, 0u);
178 ASSERT_GT(Value.z, 0u);
179 }
180
181 OL_DEVICE_INFO_TEST_DEVICE_VALUE_GT(VendorId, uint32_t,
182 OL_DEVICE_INFO_VENDOR_ID, 0);
183 OL_DEVICE_INFO_TEST_HOST_SUCCESS(VendorId, uint32_t, OL_DEVICE_INFO_VENDOR_ID);
184 OL_DEVICE_INFO_TEST_VALUE_GT(NumComputeUnits, uint32_t,
185 OL_DEVICE_INFO_NUM_COMPUTE_UNITS, 0);
186 OL_DEVICE_INFO_TEST_VALUE_GT(SingleFPConfig, ol_device_fp_capability_flags_t,
187 OL_DEVICE_INFO_SINGLE_FP_CONFIG, 0);
188 OL_DEVICE_INFO_TEST_SUCCESS(HalfFPConfig, ol_device_fp_capability_flags_t,
189 OL_DEVICE_INFO_HALF_FP_CONFIG);
190 OL_DEVICE_INFO_TEST_VALUE_GT(DoubleFPConfig, ol_device_fp_capability_flags_t,
191 OL_DEVICE_INFO_DOUBLE_FP_CONFIG, 0);
192 OL_DEVICE_INFO_TEST_VALUE_GT(NativeVectorWidthChar, uint32_t,
193 OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_CHAR, 0);
194 OL_DEVICE_INFO_TEST_VALUE_GT(NativeVectorWidthShort, uint32_t,
195 OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_SHORT, 0);
196 OL_DEVICE_INFO_TEST_VALUE_GT(NativeVectorWidthInt, uint32_t,
197 OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_INT, 0);
198 OL_DEVICE_INFO_TEST_VALUE_GT(NativeVectorWidthLong, uint32_t,
199 OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_LONG, 0);
200 OL_DEVICE_INFO_TEST_VALUE_GT(NativeVectorWidthFloat, uint32_t,
201 OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_FLOAT, 0);
202 OL_DEVICE_INFO_TEST_VALUE_GT(NativeVectorWidthDouble, uint32_t,
203 OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_DOUBLE, 0);
204 OL_DEVICE_INFO_TEST_SUCCESS(NativeVectorWidthHalf, uint32_t,
205 OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_HALF);
206 OL_DEVICE_INFO_TEST_VALUE_GT(MaxClockFrequency, uint32_t,
207 OL_DEVICE_INFO_MAX_CLOCK_FREQUENCY, 0);
208 OL_DEVICE_INFO_TEST_VALUE_GT(MemoryClockRate, uint32_t,
209 OL_DEVICE_INFO_MEMORY_CLOCK_RATE, 0);
210 OL_DEVICE_INFO_TEST_VALUE_GT(AddressBits, uint32_t, OL_DEVICE_INFO_ADDRESS_BITS,
211 0);
212 OL_DEVICE_INFO_TEST_DEVICE_VALUE_GT(MaxMemAllocSize, uint64_t,
213 OL_DEVICE_INFO_MAX_MEM_ALLOC_SIZE, 0);
214 OL_DEVICE_INFO_TEST_HOST_SUCCESS(MaxMemAllocSize, uint64_t,
215 OL_DEVICE_INFO_MAX_MEM_ALLOC_SIZE);
216 OL_DEVICE_INFO_TEST_DEVICE_VALUE_GT(GlobalMemSize, uint64_t,
217 OL_DEVICE_INFO_GLOBAL_MEM_SIZE, 0);
218 OL_DEVICE_INFO_TEST_HOST_SUCCESS(GlobalMemSize, uint64_t,
219 OL_DEVICE_INFO_GLOBAL_MEM_SIZE);
220 OL_DEVICE_INFO_TEST_DEVICE_VALUE_GT(SharedMemSize, uint64_t,
221 OL_DEVICE_INFO_WORK_GROUP_LOCAL_MEM_SIZE,
222 0);
223 OL_DEVICE_INFO_TEST_HOST_SUCCESS(SharedMemSize, uint64_t,
224 OL_DEVICE_INFO_WORK_GROUP_LOCAL_MEM_SIZE);
225
226 TEST_P(olGetDeviceInfoTest, InvalidNullHandleDevice) {
227 ol_device_type_t DeviceType;
228 ASSERT_ERROR(OL_ERRC_INVALID_NULL_HANDLE,
229 olGetDeviceInfo(nullptr, OL_DEVICE_INFO_TYPE,
230 sizeof(ol_device_type_t), &DeviceType));
231 }
232
233 TEST_P(olGetDeviceInfoTest, InvalidEnumerationInfoType) {
234 ol_device_type_t DeviceType;
235 ASSERT_ERROR(OL_ERRC_INVALID_ENUMERATION,
236 olGetDeviceInfo(Device, OL_DEVICE_INFO_FORCE_UINT32,
237 sizeof(ol_device_type_t), &DeviceType));
238 }
239
240 TEST_P(olGetDeviceInfoTest, InvalidSizePropSize) {
241 ol_device_type_t DeviceType;
242 ASSERT_ERROR(OL_ERRC_INVALID_SIZE,
243 olGetDeviceInfo(Device, OL_DEVICE_INFO_TYPE, 0, &DeviceType));
244 }
245
246 TEST_P(olGetDeviceInfoTest, InvalidSizePropSizeSmall) {
247 ol_device_type_t DeviceType;
248 ASSERT_ERROR(OL_ERRC_INVALID_SIZE,
249 olGetDeviceInfo(Device, OL_DEVICE_INFO_TYPE,
250 sizeof(DeviceType) - 1, &DeviceType));
251 }
252
253 TEST_P(olGetDeviceInfoTest, InvalidNullPointerPropValue) {
254 ol_device_type_t DeviceType;
255 ASSERT_ERROR(OL_ERRC_INVALID_NULL_POINTER,
256 olGetDeviceInfo(Device, OL_DEVICE_INFO_TYPE, sizeof(DeviceType),
257 nullptr));
258 }