Debian Codegraph @

level_zero/tools/test/unit_tests/sources/metrics/test_multidevice_metric_programmable.cpp

raw
1 /*
2 * Copyright (C) 2024-2026 Intel Corporation
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 */
7
8 #include "shared/test/common/test_macros/test.h"
9
10 #include "level_zero/core/source/device/device.h"
11 #include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
12 #include "level_zero/tools/source/metrics/metric.h"
13 #include "level_zero/tools/source/metrics/metric_multidevice_programmable.h"
14 #include "level_zero/tools/source/metrics/metric_multidevice_programmable.inl"
15 #include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_programmable.h"
16 #include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_source.h"
17
18 namespace L0 {
19 namespace ult {
20
21 class OaMultiDeviceMetricProgrammableFixture : public MultiDeviceFixture,
22 public ::testing::Test {
23 protected:
24 void SetUp() override;
25 void TearDown() override;
26 MockIAdapterGroup1x13 mockAdapterGroup{};
27
28 std::vector<Device *> subDevices = {};
29 Device *rootDevice = nullptr;
30 DebugManagerStateRestore restorer;
31 MockIConcurrentGroup1x13 mockConcurrentGroup{};
32 MockMetricSource mockMetricSource{};
33
34 void getMetricProgrammable(zet_metric_programmable_exp_handle_t &programmable);
35 void getMetricFromProgrammable(zet_metric_programmable_exp_handle_t programmable, zet_metric_handle_t &metricHandle);
36 void createMetricGroupFromMetric(zet_metric_handle_t metric, std::vector<zet_metric_group_handle_t> &metricGroupHandles);
37 };
38
39 void OaMultiDeviceMetricProgrammableFixture::TearDown() {
40 MultiDeviceFixture::tearDown();
41
42 auto &l0Device = *static_cast<Device *>(rootDevice);
43 auto &rootDeviceOaSourceImp = l0Device.getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
44 auto rootDeviceMetricEnumeration = static_cast<MetricEnumeration *>(&rootDeviceOaSourceImp.getMetricEnumeration());
45 rootDeviceMetricEnumeration->cleanupExtendedMetricInformation();
46
47 for (auto &subDevice : subDevices) {
48 auto &subDeviceRef = *static_cast<Device *>(subDevice);
49 auto &subDeviceOaSourceImp = subDeviceRef.getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
50 auto subDeviceMetricEnumeration = static_cast<MetricEnumeration *>(&subDeviceOaSourceImp.getMetricEnumeration());
51 subDeviceMetricEnumeration->cleanupExtendedMetricInformation();
52 }
53 }
54
55 void OaMultiDeviceMetricProgrammableFixture::getMetricProgrammable(zet_metric_programmable_exp_handle_t &programmable) {
56
57 uint32_t count = 0;
58 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, nullptr));
59 EXPECT_EQ(count, 1u);
60 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, &programmable));
61 }
62
63 void OaMultiDeviceMetricProgrammableFixture::getMetricFromProgrammable(zet_metric_programmable_exp_handle_t programmable, zet_metric_handle_t &metricHandle) {
64 const char *metricName = "MetricName";
65 const char *metricDesc = "MetricDesc";
66 uint32_t metricHandleCount = 0;
67 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 0, nullptr, metricName, metricDesc, &metricHandleCount, nullptr));
68 EXPECT_EQ(metricHandleCount, 1u);
69 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 0, nullptr, metricName, metricDesc, &metricHandleCount, &metricHandle));
70 EXPECT_NE(metricHandle, nullptr);
71 }
72
73 void OaMultiDeviceMetricProgrammableFixture::createMetricGroupFromMetric(zet_metric_handle_t metricHandle, std::vector<zet_metric_group_handle_t> &metricGroupHandles) {
74
75 metricGroupHandles.clear();
76 uint32_t metricGroupCount = 0;
77 EXPECT_EQ(ZE_RESULT_SUCCESS, zetDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
78 EXPECT_GT(metricGroupCount, 0u);
79 metricGroupHandles.resize(metricGroupCount);
80 EXPECT_EQ(ZE_RESULT_SUCCESS, zetDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data()));
81
82 for (auto &metricGroup : metricGroupHandles) {
83 EXPECT_NE(metricGroup, nullptr);
84 }
85 }
86
87 void OaMultiDeviceMetricProgrammableFixture::SetUp() {
88 debugManager.flags.EnableImplicitScaling.set(1);
89
90 MultiDeviceFixture::numRootDevices = 1;
91 MultiDeviceFixture::numSubDevices = 3;
92 MultiDeviceFixture::setUp();
93
94 mockAdapterGroup.mockParams.Version.MajorNumber = 1;
95 mockAdapterGroup.mockParams.Version.MinorNumber = 13;
96
97 rootDevice = driverHandle->devices[0];
98 auto &l0Device = *static_cast<Device *>(rootDevice);
99 auto &rootDeviceOaSourceImp = l0Device.getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
100 rootDeviceOaSourceImp.setInitializationState(ZE_RESULT_SUCCESS);
101 auto rootDeviceMetricEnumeration = static_cast<MetricEnumeration *>(&rootDeviceOaSourceImp.getMetricEnumeration());
102 rootDeviceMetricEnumeration->setInitializationState(ZE_RESULT_SUCCESS);
103 const uint32_t subDeviceCount = static_cast<uint32_t>(l0Device.subDevices.size());
104
105 for (uint32_t i = 0; i < subDeviceCount; i++) {
106 subDevices.push_back(l0Device.subDevices[i]);
107 auto deviceContext = new MetricDeviceContext(*l0Device.subDevices[i]);
108 auto oaMetricSource = static_cast<OaMetricSourceImp *>(&deviceContext->getMetricSource<OaMetricSourceImp>());
109 auto metricEnumeration = static_cast<MetricEnumeration *>(&oaMetricSource->getMetricEnumeration());
110 metricEnumeration->setAdapterGroup(&mockAdapterGroup);
111 oaMetricSource->setInitializationState(ZE_RESULT_SUCCESS);
112 metricEnumeration->setInitializationState(ZE_RESULT_SUCCESS);
113
114 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = static_cast<MetricsDiscovery::IConcurrentGroup_1_13 &>(mockConcurrentGroup);
115 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
116 static_cast<Device *>(l0Device.subDevices[i])->metricContext.reset(deviceContext);
117 }
118 }
119
120 using OaMultiDeviceMetricProgrammableTests = OaMultiDeviceMetricProgrammableFixture;
121
122 TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricProgrammableIsSupportedThenValidHandlesAreReturned) {
123 uint32_t count = 0;
124 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, nullptr));
125 EXPECT_EQ(count, 1u);
126 zet_metric_programmable_exp_handle_t programmable{};
127 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, &programmable));
128 zet_metric_programmable_exp_properties_t properties{};
129 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetPropertiesExp(programmable, &properties));
130 EXPECT_STREQ(properties.component, "GroupName");
131 EXPECT_STREQ(properties.description, "LongName");
132 EXPECT_STREQ(properties.name, "SymbolName");
133 EXPECT_EQ(properties.domain, 1u);
134 EXPECT_EQ(properties.tierNumber, 1u);
135 EXPECT_EQ(properties.samplingType, METRICS_SAMPLING_TYPE_TIME_EVENT_BASED);
136 }
137
138 TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricProgrammableThenCorrectParamerterInfoIsReturned) {
139 uint32_t count = 0;
140 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, nullptr));
141 EXPECT_EQ(count, 1u);
142 zet_metric_programmable_exp_handle_t programmable{};
143 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, &programmable));
144 ASSERT_NE(programmable, nullptr);
145 zet_metric_programmable_param_info_exp_t parameterInfo[4];
146 uint32_t parameterCount = 6;
147 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetParamInfoExp(programmable, &parameterCount, parameterInfo));
148 EXPECT_EQ(parameterCount, 4u);
149
150 EXPECT_EQ(parameterInfo[0].defaultValue.ui64, UINT64_MAX);
151 EXPECT_STREQ(parameterInfo[0].name, "mockParam1");
152 EXPECT_EQ(parameterInfo[0].type, ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_DISAGGREGATION);
153 EXPECT_EQ(parameterInfo[0].valueInfoCount, 1u);
154 EXPECT_EQ(parameterInfo[0].valueInfoType, ZET_VALUE_INFO_TYPE_EXP_UINT32);
155
156 EXPECT_EQ(parameterInfo[1].defaultValue.ui64, 0u);
157 EXPECT_STREQ(parameterInfo[1].name, "mockParam2");
158 EXPECT_EQ(parameterInfo[1].type, ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_LATENCY);
159 EXPECT_EQ(parameterInfo[1].valueInfoCount, 1u);
160 EXPECT_EQ(parameterInfo[1].valueInfoType, ZET_VALUE_INFO_TYPE_EXP_UINT64);
161
162 EXPECT_EQ(parameterInfo[2].defaultValue.ui64, 0u);
163 EXPECT_STREQ(parameterInfo[2].name, "mockParam3");
164 EXPECT_EQ(parameterInfo[2].type, ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_NORMALIZATION_UTILIZATION);
165 EXPECT_EQ(parameterInfo[2].valueInfoCount, 1u);
166 EXPECT_EQ(parameterInfo[2].valueInfoType, ZET_VALUE_INFO_TYPE_EXP_UINT64_RANGE);
167
168 EXPECT_EQ(parameterInfo[3].defaultValue.ui64, 0u);
169 EXPECT_STREQ(parameterInfo[3].name, "mockParam4");
170 EXPECT_EQ(parameterInfo[3].type, ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_NORMALIZATION_BYTES);
171 EXPECT_EQ(parameterInfo[3].valueInfoCount, 1u);
172 EXPECT_EQ(parameterInfo[3].valueInfoType, ZET_VALUE_INFO_TYPE_EXP_UINT64_RANGE);
173 }
174
175 TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricProgrammableThenCorrectParamerterValueInfoIsReturned) {
176 uint32_t count = 0;
177 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, nullptr));
178 EXPECT_EQ(count, 1u);
179 zet_metric_programmable_exp_handle_t programmable{};
180 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, &programmable));
181 ASSERT_NE(programmable, nullptr);
182 std::vector<zet_metric_programmable_param_info_exp_t> parameterInfo(4);
183 uint32_t parameterCount = 2;
184 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetParamInfoExp(programmable, &parameterCount, parameterInfo.data()));
185 uint32_t valueInfoCount = 2;
186 zet_metric_programmable_param_value_info_exp_t valueInfo{};
187
188 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetParamValueInfoExp(programmable, 0, &valueInfoCount, &valueInfo));
189 EXPECT_EQ(valueInfoCount, 1u);
190 EXPECT_EQ(valueInfo.valueInfo.ui32, 1u);
191 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetParamValueInfoExp(programmable, 1, &valueInfoCount, &valueInfo));
192 EXPECT_EQ(valueInfoCount, 1u);
193 EXPECT_EQ(valueInfo.valueInfo.ui64, 2u);
194 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetParamValueInfoExp(programmable, 2, &valueInfoCount, &valueInfo));
195 EXPECT_EQ(valueInfoCount, 1u);
196 EXPECT_EQ(valueInfo.valueInfo.ui64Range.ui64Min, 3u);
197 EXPECT_EQ(valueInfo.valueInfo.ui64Range.ui64Max, 4u);
198 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetParamValueInfoExp(programmable, 3, &valueInfoCount, &valueInfo));
199 EXPECT_EQ(valueInfoCount, 1u);
200 EXPECT_EQ(valueInfo.valueInfo.ui64Range.ui64Min, 5u);
201 EXPECT_EQ(valueInfo.valueInfo.ui64Range.ui64Max, 6u);
202 }
203
204 TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricProgrammableWhenCreateMetricIsCalledThenValidMetricHandleIsReturned) {
205 uint32_t count = 0;
206 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, nullptr));
207 EXPECT_EQ(count, 1u);
208 zet_metric_programmable_exp_handle_t programmable{};
209 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, &programmable));
210 const char *metricName = "MetricName";
211 const char *metricDesc = "MetricDesc";
212 uint32_t metricHandleCount = 0;
213 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 0, nullptr, metricName, metricDesc, &metricHandleCount, nullptr));
214 EXPECT_EQ(metricHandleCount, 1u);
215 zet_metric_handle_t metricHandle = nullptr;
216 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 0, nullptr, metricName, metricDesc, &metricHandleCount, &metricHandle));
217 EXPECT_NE(metricHandle, nullptr);
218 zet_metric_properties_t metricProperties{};
219 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGetProperties(metricHandle, &metricProperties));
220 EXPECT_STREQ(metricProperties.name, metricName);
221 EXPECT_STREQ(metricProperties.description, metricDesc);
222 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle));
223 }
224
225 TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricsWhenMetricGroupIsCreatedFromThemThenValidMetricGroupIsReturned) {
226 uint32_t count = 0;
227 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, nullptr));
228 EXPECT_EQ(count, 1u);
229 zet_metric_programmable_exp_handle_t programmable{};
230 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, &programmable));
231 const char *metricName = "MetricName";
232 const char *metricDesc = "MetricDesc";
233 uint32_t metricHandleCount = 0;
234 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 0, nullptr, metricName, metricDesc, &metricHandleCount, nullptr));
235 EXPECT_EQ(metricHandleCount, 1u);
236 zet_metric_handle_t metricHandle = nullptr;
237 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 0, nullptr, metricName, metricDesc, &metricHandleCount, &metricHandle));
238 EXPECT_NE(metricHandle, nullptr);
239 uint32_t metricGroupCount = 0;
240 EXPECT_EQ(ZE_RESULT_SUCCESS, zetDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
241 EXPECT_GT(metricGroupCount, 0u);
242 std::vector<zet_metric_group_handle_t> metricGroupHandles(metricGroupCount);
243 EXPECT_EQ(ZE_RESULT_SUCCESS, zetDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data()));
244 EXPECT_NE(metricGroupHandles[0], nullptr);
245 zet_metric_group_properties_t metricGroupProperties{};
246 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupGetProperties(metricGroupHandles[0], &metricGroupProperties));
247
248 for (uint32_t index = 0; index < metricGroupCount; index++) {
249 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroupHandles[index]));
250 }
251 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle));
252 }
253
254 TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricsWhenMetricGroupCreationFailsInOneOfTheSubDeviceThenErrorIsReturned) {
255 MockIMetricSet1x13::addMetricCallCount = 0;
256 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList.resize(3);
257 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[0] = MetricsDiscovery::CC_OK;
258 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[1] = MetricsDiscovery::CC_OK;
259 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[2] = MetricsDiscovery::CC_ERROR_GENERAL;
260
261 uint32_t count = 0;
262 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, nullptr));
263 EXPECT_EQ(count, 1u);
264 zet_metric_programmable_exp_handle_t programmable{};
265 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, &programmable));
266 const char *metricName = "MetricName";
267 const char *metricDesc = "MetricDesc";
268 uint32_t metricHandleCount = 0;
269 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 0, nullptr, metricName, metricDesc, &metricHandleCount, nullptr));
270 EXPECT_EQ(metricHandleCount, 1u);
271 zet_metric_handle_t metricHandle = nullptr;
272 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 0, nullptr, metricName, metricDesc, &metricHandleCount, &metricHandle));
273 EXPECT_NE(metricHandle, nullptr);
274 uint32_t metricGroupCount = 0;
275 EXPECT_EQ(ZE_RESULT_SUCCESS, zetDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
276 EXPECT_GT(metricGroupCount, 0u);
277 std::vector<zet_metric_group_handle_t> metricGroupHandles(metricGroupCount);
278 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data()));
279 EXPECT_EQ(metricGroupHandles[0], nullptr);
280
281 for (uint32_t index = 0; index < metricGroupCount; index++) {
282 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroupHandles[index]));
283 }
284 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle));
285
286 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList.resize(1);
287 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[0] = MetricsDiscovery::CC_OK;
288 MockIMetricSet1x13::addMetricCallCount = 0;
289 MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet);
290 }
291
292 TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricsWhenMetricGroupCreationReturnsDifferentGroupCountForDifferentSubDevicesThenErrorIsReturned) {
293
294 MockIMetricSet1x13::addMetricCallCount = 0;
295 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList.resize(7);
296 // 1st Group creation - OK
297 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[0] = MetricsDiscovery::CC_OK;
298 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[1] = MetricsDiscovery::CC_OK;
299
300 // 2nd Group creation - OK
301 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[2] = MetricsDiscovery::CC_OK;
302 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[3] = MetricsDiscovery::CC_OK;
303
304 // 3rd Group creation
305 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[4] = MetricsDiscovery::CC_OK;
306 // fail during adding 2nd metric
307 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[5] = MetricsDiscovery::CC_ERROR_GENERAL;
308 // New Metric group created here
309 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[6] = MetricsDiscovery::CC_OK;
310
311 uint32_t count = 0;
312 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, nullptr));
313 EXPECT_EQ(count, 1u);
314 zet_metric_programmable_exp_handle_t programmable{};
315 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, &programmable));
316 const char *metricName = "MetricName";
317 const char *metricDesc = "MetricDesc";
318 uint32_t metricHandleCount = 0;
319 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 0, nullptr, metricName, metricDesc, &metricHandleCount, nullptr));
320 EXPECT_EQ(metricHandleCount, 1u);
321 zet_metric_handle_t metricHandle[2] = {};
322 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 0, nullptr, metricName, metricDesc, &metricHandleCount, &metricHandle[0]));
323 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 0, nullptr, metricName, metricDesc, &metricHandleCount, &metricHandle[1]));
324 EXPECT_NE(metricHandle[0], nullptr);
325 EXPECT_NE(metricHandle[1], nullptr);
326 uint32_t metricGroupCount = 0;
327 EXPECT_EQ(ZE_RESULT_SUCCESS, zetDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 2, metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
328 EXPECT_GT(metricGroupCount, 0u);
329
330 std::vector<zet_metric_group_handle_t> metricGroupHandles(metricGroupCount);
331 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, zetDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 2, metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data()));
332 EXPECT_EQ(metricGroupHandles[0], nullptr);
333 EXPECT_EQ(metricGroupCount, 0u);
334
335 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle[0]));
336 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle[1]));
337
338 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList.resize(1);
339 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[0] = MetricsDiscovery::CC_OK;
340 MockIMetricSet1x13::addMetricCallCount = 0;
341 MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet);
342 }
343
344 TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricGroupThenMetricGetReturnsSuccess) {
345
346 zet_metric_programmable_exp_handle_t programmable{};
347 getMetricProgrammable(programmable);
348
349 zet_metric_handle_t metricHandle{};
350 getMetricFromProgrammable(programmable, metricHandle);
351
352 std::vector<zet_metric_group_handle_t> metricGroups{};
353 createMetricGroupFromMetric(metricHandle, metricGroups);
354 uint32_t count = 0;
355 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGet(metricGroups[0], &count, nullptr));
356 // Additional metrics added during close
357 EXPECT_EQ(count, 3u);
358 zet_metric_handle_t getMetric{};
359 count = 1;
360 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGet(metricGroups[0], &count, &getMetric));
361 EXPECT_NE(getMetric, nullptr);
362 for (auto &metricGroup : metricGroups) {
363 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroup));
364 }
365
366 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle));
367 }
368
369 TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricGroupWhenSubdevicesAddDifferentMetricCountsThenErrorIsObserved) {
370
371 MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet);
372 mockConcurrentGroup.mockMetricSet.mockMetricCountList.resize(4);
373 // First Subdevice metric count
374 mockConcurrentGroup.mockMetricSet.mockMetricCountList[0] = 1;
375 mockConcurrentGroup.mockMetricSet.mockMetricCountList[1] = 1;
376 // Second Subdevice metric count
377 mockConcurrentGroup.mockMetricSet.mockMetricCountList[2] = 3;
378 mockConcurrentGroup.mockMetricSet.mockMetricCountList[3] = 3;
379 mockConcurrentGroup.mockMetricSet.mockInformationCount = 0;
380
381 zet_metric_programmable_exp_handle_t programmable{};
382 getMetricProgrammable(programmable);
383 zet_metric_handle_t metricHandle{};
384 getMetricFromProgrammable(programmable, metricHandle);
385 std::vector<zet_metric_group_handle_t> metricGroupHandles{};
386
387 metricGroupHandles.clear();
388 uint32_t metricGroupCount = 0;
389 EXPECT_EQ(ZE_RESULT_SUCCESS, zetDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
390 EXPECT_GT(metricGroupCount, 0u);
391 metricGroupHandles.resize(metricGroupCount);
392 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, zetDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data()));
393 EXPECT_EQ(metricGroupCount, 0u);
394
395 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle));
396 MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet);
397 }
398
399 TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricGroupWhenMetricGroupCloseFailsForOneOfTheGroupThenErrorIsObserved) {
400
401 MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet);
402 mockConcurrentGroup.mockMetricSet.mockMetricCountList.resize(6);
403 // Group0: First Subdevice metric count
404 mockConcurrentGroup.mockMetricSet.mockMetricCountList[0] = 1;
405 // Group0: Second Subdevice metric count
406 mockConcurrentGroup.mockMetricSet.mockMetricCountList[1] = 1;
407 // Group0: Third Subdevice metric count
408 mockConcurrentGroup.mockMetricSet.mockMetricCountList[2] = 1;
409
410 // Group1: First Subdevice metric count
411 mockConcurrentGroup.mockMetricSet.mockMetricCountList[3] = 1;
412 // Group1: Second Subdevice metric count
413 mockConcurrentGroup.mockMetricSet.mockMetricCountList[4] = 1;
414 // Group1: Third Subdevice metric count
415 mockConcurrentGroup.mockMetricSet.mockMetricCountList[5] = 3;
416 mockConcurrentGroup.mockMetricSet.mockInformationCount = 0;
417
418 zet_metric_programmable_exp_handle_t programmable{};
419 getMetricProgrammable(programmable);
420 zet_metric_handle_t metricHandle{};
421 getMetricFromProgrammable(programmable, metricHandle);
422 std::vector<zet_metric_group_handle_t> metricGroupHandles{};
423
424 metricGroupHandles.clear();
425 uint32_t metricGroupCount = 0;
426 EXPECT_EQ(ZE_RESULT_SUCCESS, zetDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
427 EXPECT_GT(metricGroupCount, 0u);
428 metricGroupHandles.resize(metricGroupCount);
429 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, zetDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data()));
430 EXPECT_EQ(metricGroupCount, 0u);
431
432 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle));
433 MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet);
434 }
435
436 TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricGroupWhenCloseDoesNotAddNewMetricsThenMetricCountIsCorrect) {
437
438 mockConcurrentGroup.mockMetricSet.mockMetricCountList.resize(1);
439 mockConcurrentGroup.mockMetricSet.mockMetricCountList[0] = 1;
440 mockConcurrentGroup.mockMetricSet.mockInformationCount = 0;
441
442 zet_metric_programmable_exp_handle_t programmable{};
443 getMetricProgrammable(programmable);
444
445 zet_metric_handle_t metricHandle{};
446 getMetricFromProgrammable(programmable, metricHandle);
447
448 std::vector<zet_metric_group_handle_t> metricGroups{};
449 createMetricGroupFromMetric(metricHandle, metricGroups);
450 uint32_t count = 0;
451 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGet(metricGroups[0], &count, nullptr));
452
453 EXPECT_EQ(count, 1u);
454 zet_metric_handle_t getMetric{};
455 count = 1;
456 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGet(metricGroups[0], &count, &getMetric));
457 EXPECT_NE(getMetric, nullptr);
458 for (auto &metricGroup : metricGroups) {
459 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroup));
460 }
461
462 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle));
463 MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet);
464 }
465
466 TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricGroupThenAddAndRemoveMetricReturnsSuccess) {
467 zet_metric_programmable_exp_handle_t programmable{};
468 getMetricProgrammable(programmable);
469 zet_metric_handle_t metricHandle{};
470 getMetricFromProgrammable(programmable, metricHandle);
471 std::vector<zet_metric_group_handle_t> metricGroups{};
472 createMetricGroupFromMetric(metricHandle, metricGroups);
473
474 zet_metric_handle_t metricHandle1{};
475 getMetricFromProgrammable(programmable, metricHandle1);
476
477 size_t errorStringSize = 0;
478
479 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroups[0], metricHandle1, &errorStringSize, nullptr));
480 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupRemoveMetricExp(metricGroups[0], metricHandle1));
481 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupRemoveMetricExp(metricGroups[0], metricHandle1));
482 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupCloseExp(metricGroups[0]));
483
484 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroups[0], metricHandle1, &errorStringSize, nullptr));
485 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupRemoveMetricExp(metricGroups[0], metricHandle1));
486 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupCloseExp(metricGroups[0]));
487
488 for (uint32_t index = 0; index < static_cast<uint32_t>(metricGroups.size()); index++) {
489 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroups[index]));
490 }
491 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle));
492 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle1));
493 }
494
495 TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricGroupWhenAddMetricFailsForOneOfTheSubDevicesThenReturnFailure) {
496 zet_metric_programmable_exp_handle_t programmable{};
497 getMetricProgrammable(programmable);
498 zet_metric_handle_t metricHandle{};
499 getMetricFromProgrammable(programmable, metricHandle);
500 std::vector<zet_metric_group_handle_t> metricGroups{};
501 createMetricGroupFromMetric(metricHandle, metricGroups);
502
503 zet_metric_handle_t metricHandle1{};
504 getMetricFromProgrammable(programmable, metricHandle1);
505
506 size_t errorStringSize = 0;
507
508 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroups[0], metricHandle1, &errorStringSize, nullptr));
509 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupRemoveMetricExp(metricGroups[0], metricHandle1));
510 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupCloseExp(metricGroups[0]));
511
512 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroups[0], metricHandle1, &errorStringSize, nullptr));
513 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupRemoveMetricExp(metricGroups[0], metricHandle1));
514 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupCloseExp(metricGroups[0]));
515
516 for (uint32_t index = 0; index < static_cast<uint32_t>(metricGroups.size()); index++) {
517 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroups[index]));
518 }
519 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle));
520 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle1));
521 }
522
523 TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricGroupWhenAddAndRemoveMetricIsCalledWithIncorrectMetricThenReturnFailure) {
524 zet_metric_programmable_exp_handle_t programmable{};
525 getMetricProgrammable(programmable);
526 zet_metric_handle_t metricHandle{};
527 getMetricFromProgrammable(programmable, metricHandle);
528 std::vector<zet_metric_group_handle_t> metricGroups{};
529 createMetricGroupFromMetric(metricHandle, metricGroups);
530
531 zet_intel_metric_scope_properties_exp_t scopeProperties{};
532 scopeProperties.stype = ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP;
533 scopeProperties.pNext = nullptr;
534 MockMetricScope mockMetricScope(scopeProperties, false, 0);
535 std::vector<MetricScopeImp *> mockMetricScopes{&mockMetricScope};
536 MockMetric mockMetric(mockMetricSource, mockMetricScopes);
537
538 mockMetric.setMultiDevice(false);
539 mockMetric.setPredefined(false);
540
541 size_t errorStringSize = 0;
542
543 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetMetricGroupAddMetricExp(metricGroups[0], mockMetric.toHandle(), &errorStringSize, nullptr));
544 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetMetricGroupRemoveMetricExp(metricGroups[0], mockMetric.toHandle()));
545
546 mockMetric.setMultiDevice(true);
547 mockMetric.setPredefined(true);
548 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetMetricGroupAddMetricExp(metricGroups[0], mockMetric.toHandle(), &errorStringSize, nullptr));
549 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetMetricGroupRemoveMetricExp(metricGroups[0], mockMetric.toHandle()));
550
551 for (uint32_t index = 0; index < static_cast<uint32_t>(metricGroups.size()); index++) {
552 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroups[index]));
553 }
554 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle));
555 }
556
557 TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricGroupWhenAddMetricIsCalledAndOneSubDeviceFailsThenReturnFailure) {
558
559 uint32_t count = 0;
560 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, nullptr));
561 EXPECT_EQ(count, 1u);
562 zet_metric_programmable_exp_handle_t programmable{};
563 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, &programmable));
564 const char *metricName = "MetricName";
565 const char *metricDesc = "MetricDesc";
566 uint32_t metricHandleCount = 0;
567 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 0, nullptr, metricName, metricDesc, &metricHandleCount, nullptr));
568 EXPECT_EQ(metricHandleCount, 1u);
569 zet_metric_handle_t metricHandle[2] = {};
570 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 0, nullptr, metricName, metricDesc, &metricHandleCount, &metricHandle[0]));
571 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 0, nullptr, metricName, metricDesc, &metricHandleCount, &metricHandle[1]));
572 EXPECT_NE(metricHandle[0], nullptr);
573 EXPECT_NE(metricHandle[1], nullptr);
574 uint32_t metricGroupCount = 0;
575 EXPECT_EQ(ZE_RESULT_SUCCESS, zetDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
576 EXPECT_GT(metricGroupCount, 0u);
577 std::vector<zet_metric_group_handle_t> metricGroupHandles(metricGroupCount);
578 EXPECT_EQ(ZE_RESULT_SUCCESS, zetDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data()));
579 EXPECT_GT(metricGroupCount, 0u);
580
581 // Prepare AddMetric return status for failure
582 MockIMetricSet1x13::addMetricCallCount = 0;
583 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList.resize(3);
584 // 1st Group
585 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[0] = MetricsDiscovery::CC_OK;
586 // 2nd Group
587 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[1] = MetricsDiscovery::CC_OK;
588 // 3rd Group
589 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[2] = MetricsDiscovery::CC_ERROR_GENERAL;
590
591 size_t errorStringSize = 0;
592 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetMetricGroupAddMetricExp(metricGroupHandles[0], metricHandle[1], &errorStringSize, nullptr));
593
594 for (uint32_t index = 0; index < metricGroupCount; index++) {
595 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroupHandles[index]));
596 }
597
598 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle[0]));
599 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle[1]));
600
601 MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet);
602 }
603
604 TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricGroupWhenRemoveMetricIsCalledAndOneSubDeviceFailsThenReturnFailure) {
605
606 uint32_t count = 0;
607 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, nullptr));
608 EXPECT_EQ(count, 1u);
609 zet_metric_programmable_exp_handle_t programmable{};
610 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, &programmable));
611 const char *metricName = "MetricName";
612 const char *metricDesc = "MetricDesc";
613 uint32_t metricHandleCount = 0;
614 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 0, nullptr, metricName, metricDesc, &metricHandleCount, nullptr));
615 EXPECT_EQ(metricHandleCount, 1u);
616 zet_metric_handle_t metricHandle[2] = {};
617 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 0, nullptr, metricName, metricDesc, &metricHandleCount, &metricHandle[0]));
618 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 0, nullptr, metricName, metricDesc, &metricHandleCount, &metricHandle[1]));
619 EXPECT_NE(metricHandle[0], nullptr);
620 EXPECT_NE(metricHandle[1], nullptr);
621 uint32_t metricGroupCount = 0;
622 EXPECT_EQ(ZE_RESULT_SUCCESS, zetDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 2, metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
623 EXPECT_GT(metricGroupCount, 0u);
624 std::vector<zet_metric_group_handle_t> metricGroupHandles(metricGroupCount);
625 EXPECT_EQ(ZE_RESULT_SUCCESS, zetDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 2, metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data()));
626 EXPECT_GT(metricGroupCount, 0u);
627
628 MockIMetricSet1x13::removeMetricCallCount = 0;
629 mockConcurrentGroup.mockMetricSet.mockRemoveMetricReturnCodeList.resize(3);
630 // 1st Group
631 mockConcurrentGroup.mockMetricSet.mockRemoveMetricReturnCodeList[0] = MetricsDiscovery::CC_OK;
632 // 2nd Group
633 mockConcurrentGroup.mockMetricSet.mockRemoveMetricReturnCodeList[1] = MetricsDiscovery::CC_OK;
634 // 3rd Group
635 mockConcurrentGroup.mockMetricSet.mockRemoveMetricReturnCodeList[2] = MetricsDiscovery::CC_ERROR_GENERAL;
636
637 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, zetMetricGroupRemoveMetricExp(metricGroupHandles[0], metricHandle[1]));
638
639 for (uint32_t index = 0; index < metricGroupCount; index++) {
640 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroupHandles[index]));
641 }
642
643 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle[0]));
644 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle[1]));
645
646 MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet);
647 MockIMetricSet1x13::addMetricCallCount = 0;
648 }
649
650 TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricGroupWhenCloseIsCalledAndOneSubDeviceFailsThenReturnFailure) {
651
652 uint32_t count = 0;
653 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, nullptr));
654 EXPECT_EQ(count, 1u);
655 zet_metric_programmable_exp_handle_t programmable{};
656 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, &programmable));
657 const char *metricName = "MetricName";
658 const char *metricDesc = "MetricDesc";
659 uint32_t metricHandleCount = 0;
660 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 0, nullptr, metricName, metricDesc, &metricHandleCount, nullptr));
661 EXPECT_EQ(metricHandleCount, 1u);
662 zet_metric_handle_t metricHandle[2] = {};
663 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 0, nullptr, metricName, metricDesc, &metricHandleCount, &metricHandle[0]));
664 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 0, nullptr, metricName, metricDesc, &metricHandleCount, &metricHandle[1]));
665 EXPECT_NE(metricHandle[0], nullptr);
666 EXPECT_NE(metricHandle[1], nullptr);
667 uint32_t metricGroupCount = 0;
668 EXPECT_EQ(ZE_RESULT_SUCCESS, zetDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
669 EXPECT_GT(metricGroupCount, 0u);
670 std::vector<zet_metric_group_handle_t> metricGroupHandles(metricGroupCount);
671 EXPECT_EQ(ZE_RESULT_SUCCESS, zetDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data()));
672 EXPECT_GT(metricGroupCount, 0u);
673 size_t errorStringSize = 0;
674 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandles[0], metricHandle[1], &errorStringSize, nullptr));
675
676 MockIMetricSet1x13::closeCallCount = 0;
677 mockConcurrentGroup.mockMetricSet.mockCloseReturnCodeList.resize(3);
678 // 1st Group
679 mockConcurrentGroup.mockMetricSet.mockCloseReturnCodeList[0] = MetricsDiscovery::CC_OK;
680 // 2nd Group
681 mockConcurrentGroup.mockMetricSet.mockCloseReturnCodeList[1] = MetricsDiscovery::CC_ERROR_GENERAL;
682 // 3rd Group
683 mockConcurrentGroup.mockMetricSet.mockCloseReturnCodeList[2] = MetricsDiscovery::CC_OK;
684 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, zetMetricGroupCloseExp(metricGroupHandles[0]));
685
686 for (uint32_t index = 0; index < metricGroupCount; index++) {
687 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroupHandles[index]));
688 }
689
690 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle[0]));
691 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle[1]));
692
693 MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet);
694 }
695
696 TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricGroupWhenCreateIsCalledAndCloseForOneSubDeviceFailsThenReturnFailure) {
697
698 MockIMetricSet1x13::closeCallCount = 0;
699 mockConcurrentGroup.mockMetricSet.mockCloseReturnCodeList.resize(3);
700 // 1st Group
701 mockConcurrentGroup.mockMetricSet.mockCloseReturnCodeList[0] = MetricsDiscovery::CC_OK;
702 // 2nd Group
703 mockConcurrentGroup.mockMetricSet.mockCloseReturnCodeList[1] = MetricsDiscovery::CC_OK;
704 // 3rd Group
705 mockConcurrentGroup.mockMetricSet.mockCloseReturnCodeList[2] = MetricsDiscovery::CC_ERROR_GENERAL;
706
707 uint32_t count = 0;
708 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, nullptr));
709 EXPECT_EQ(count, 1u);
710 zet_metric_programmable_exp_handle_t programmable{};
711 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, &programmable));
712 const char *metricName = "MetricName";
713 const char *metricDesc = "MetricDesc";
714 uint32_t metricHandleCount = 0;
715 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 0, nullptr, metricName, metricDesc, &metricHandleCount, nullptr));
716 EXPECT_EQ(metricHandleCount, 1u);
717 zet_metric_handle_t metricHandle[2] = {};
718 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 0, nullptr, metricName, metricDesc, &metricHandleCount, &metricHandle[0]));
719 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 0, nullptr, metricName, metricDesc, &metricHandleCount, &metricHandle[1]));
720 EXPECT_NE(metricHandle[0], nullptr);
721 EXPECT_NE(metricHandle[1], nullptr);
722 uint32_t metricGroupCount = 0;
723 EXPECT_EQ(ZE_RESULT_SUCCESS, zetDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
724 EXPECT_GT(metricGroupCount, 0u);
725 std::vector<zet_metric_group_handle_t> metricGroupHandles(metricGroupCount);
726 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, zetDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data()));
727 EXPECT_EQ(metricGroupCount, 0u);
728
729 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle[0]));
730 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle[1]));
731
732 MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet);
733 }
734
735 TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricsWhenMetricIsDestroyedBeforeMetricGroupDestroyThenErrorInUseIsReturned) {
736 uint32_t count = 0;
737 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, nullptr));
738 EXPECT_EQ(count, 1u);
739 zet_metric_programmable_exp_handle_t programmable{};
740 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, &programmable));
741 const char *metricName = "MetricName";
742 const char *metricDesc = "MetricDesc";
743 uint32_t metricHandleCount = 0;
744 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 0, nullptr, metricName, metricDesc, &metricHandleCount, nullptr));
745 EXPECT_EQ(metricHandleCount, 1u);
746 zet_metric_handle_t metricHandle = nullptr;
747 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 0, nullptr, metricName, metricDesc, &metricHandleCount, &metricHandle));
748 EXPECT_NE(metricHandle, nullptr);
749 uint32_t metricGroupCount = 0;
750 EXPECT_EQ(ZE_RESULT_SUCCESS, zetDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
751 EXPECT_GT(metricGroupCount, 0u);
752 std::vector<zet_metric_group_handle_t> metricGroupHandles(metricGroupCount);
753 EXPECT_EQ(ZE_RESULT_SUCCESS, zetDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data()));
754 EXPECT_NE(metricGroupHandles[0], nullptr);
755 zet_metric_group_properties_t metricGroupProperties{};
756 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupGetProperties(metricGroupHandles[0], &metricGroupProperties));
757
758 EXPECT_EQ(ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE, zetMetricDestroyExp(metricHandle));
759
760 for (uint32_t index = 0; index < metricGroupCount; index++) {
761 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroupHandles[index]));
762 }
763
764 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle));
765 }
766
767 struct MockMetricProgrammable : public MetricProgrammable {
768
769 MockMetricSource metricSource{};
770 std::vector<MockMetric *> allocatedMetricObjects{};
771 std::vector<MetricScopeImp *> mockMetricScopes{};
772
773 ~MockMetricProgrammable() override {
774 for (auto &metric : allocatedMetricObjects) {
775 delete metric;
776 delete mockMetricScopes.back();
777 mockMetricScopes.pop_back();
778 }
779 allocatedMetricObjects.clear();
780 mockMetricScopes.clear();
781 }
782
783 ze_result_t createMetricReturnStatus = ZE_RESULT_SUCCESS;
784 uint32_t createMetricReturnHandleCount = 2;
785
786 ze_result_t getProperties(zet_metric_programmable_exp_properties_t *pProperties) override {
787 return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
788 }
789 ze_result_t getParamInfo(uint32_t *pParameterCount, zet_metric_programmable_param_info_exp_t *pParameterInfo) override {
790 return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
791 }
792 ze_result_t getParamValueInfo(uint32_t parameterOrdinal, uint32_t *pValueInfoCount,
793 zet_metric_programmable_param_value_info_exp_t *pValueInfo) override {
794 return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
795 }
796 ze_result_t createMetric(zet_metric_programmable_param_value_exp_t *pParameterValues,
797 uint32_t parameterCount, const char name[ZET_MAX_METRIC_NAME],
798 const char description[ZET_MAX_METRIC_DESCRIPTION],
799 uint32_t *pMetricHandleCount, zet_metric_handle_t *phMetricHandles) override {
800
801 if (*pMetricHandleCount == 0) {
802 *pMetricHandleCount = createMetricReturnHandleCount;
803 return createMetricReturnStatus;
804 }
805
806 *pMetricHandleCount = std::min(*pMetricHandleCount, createMetricReturnHandleCount);
807 prepareMetricObjects(*pMetricHandleCount);
808
809 for (uint32_t index = 0; index < *pMetricHandleCount; index++) {
810 *phMetricHandles++ = allocatedMetricObjects[index];
811 }
812
813 return createMetricReturnStatus;
814 }
815
816 void prepareMetricObjects(uint32_t metricHandleCount) {
817
818 zet_intel_metric_scope_properties_exp_t scopeProperties{};
819 scopeProperties.stype = ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP;
820 scopeProperties.pNext = nullptr;
821
822 bool additionalAllocationNecessary = metricHandleCount > static_cast<uint32_t>(allocatedMetricObjects.size());
823 if (additionalAllocationNecessary) {
824 uint32_t additionalAllocations = metricHandleCount - static_cast<uint32_t>(allocatedMetricObjects.size());
825 for (uint32_t index = 0; index < additionalAllocations; index++) {
826 auto mockMetricScope = new MockMetricScope(scopeProperties, false, 0);
827 mockMetricScopes.push_back(mockMetricScope);
828 auto mockMetric = new MockMetric(metricSource, mockMetricScopes);
829 mockMetric->destroyReturn = ZE_RESULT_SUCCESS;
830 allocatedMetricObjects.push_back(mockMetric);
831 }
832 }
833 }
834 };
835
836 TEST(HomogeneousMultiDeviceMetricProgrammableTest, givenSubDevicesReturnNonHomogenousMetricsWhenCreateMetricsIsCalledThenErrorIsReturned) {
837
838 MockMetricSource mockMetricSource{};
839 MockMetricProgrammable mockSubDeviceProgrammables[2];
840 std::vector<MetricProgrammable *> subDeviceProgrammables{};
841 subDeviceProgrammables.push_back(&mockSubDeviceProgrammables[0]);
842 subDeviceProgrammables.push_back(&mockSubDeviceProgrammables[1]);
843
844 MetricProgrammable *multiDeviceProgrammable = HomogeneousMultiDeviceMetricProgrammable::create(mockMetricSource, subDeviceProgrammables);
845 const char *name = "name";
846 const char *desc = "desc";
847 uint32_t metricHandleCount = 0;
848 mockSubDeviceProgrammables[0].createMetricReturnHandleCount = 2;
849 mockSubDeviceProgrammables[1].createMetricReturnHandleCount = 3;
850 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, multiDeviceProgrammable->createMetric(nullptr, 0, name, desc, &metricHandleCount, nullptr));
851
852 mockSubDeviceProgrammables[0].createMetricReturnHandleCount = 2;
853 mockSubDeviceProgrammables[1].createMetricReturnHandleCount = 3;
854 metricHandleCount = 4;
855 std::vector<zet_metric_handle_t> metricHandles(metricHandleCount);
856 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, multiDeviceProgrammable->createMetric(nullptr, 0, name, desc, &metricHandleCount, metricHandles.data()));
857
858 mockSubDeviceProgrammables[0].createMetricReturnHandleCount = 3;
859 mockSubDeviceProgrammables[0].prepareMetricObjects(3);
860 static_cast<MockMetric *>(mockSubDeviceProgrammables[0].allocatedMetricObjects[0])->destroyReturn = ZE_RESULT_SUCCESS;
861 mockSubDeviceProgrammables[1].createMetricReturnHandleCount = 3;
862 metricHandleCount = 4;
863 EXPECT_EQ(ZE_RESULT_SUCCESS, multiDeviceProgrammable->createMetric(nullptr, 0, name, desc, &metricHandleCount, metricHandles.data()));
864 EXPECT_EQ(metricHandleCount, 3u);
865
866 for (uint32_t index = 0; index < metricHandleCount; index++) {
867 zetMetricDestroyExp(metricHandles[index]);
868 }
869
870 delete multiDeviceProgrammable;
871 }
872
873 TEST(HomogeneousMultiDeviceMetricProgrammableTest, givenSubDevicesReturnErrorWhenCreateMetricsIsCalledThenErrorIsReturned) {
874
875 MockMetricSource mockMetricSource{};
876 MockMetricProgrammable mockSubDeviceProgrammables[2];
877 std::vector<MetricProgrammable *> subDeviceProgrammables{};
878 subDeviceProgrammables.push_back(&mockSubDeviceProgrammables[0]);
879 subDeviceProgrammables.push_back(&mockSubDeviceProgrammables[1]);
880
881 MetricProgrammable *multiDeviceProgrammable = HomogeneousMultiDeviceMetricProgrammable::create(mockMetricSource, subDeviceProgrammables);
882 const char *name = "name";
883 const char *desc = "desc";
884 uint32_t metricHandleCount = 0;
885 mockSubDeviceProgrammables[0].createMetricReturnHandleCount = 2;
886 mockSubDeviceProgrammables[1].createMetricReturnHandleCount = 3;
887 mockSubDeviceProgrammables[1].createMetricReturnStatus = ZE_RESULT_ERROR_INVALID_ARGUMENT;
888 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, multiDeviceProgrammable->createMetric(nullptr, 0, name, desc, &metricHandleCount, nullptr));
889
890 mockSubDeviceProgrammables[0].createMetricReturnHandleCount = 2;
891 mockSubDeviceProgrammables[1].createMetricReturnHandleCount = 3;
892 mockSubDeviceProgrammables[1].createMetricReturnStatus = ZE_RESULT_ERROR_INVALID_ARGUMENT;
893 metricHandleCount = 4;
894 std::vector<zet_metric_handle_t> metricHandles(metricHandleCount);
895 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, multiDeviceProgrammable->createMetric(nullptr, 0, name, desc, &metricHandleCount, metricHandles.data()));
896
897 delete multiDeviceProgrammable;
898 }
899
900 TEST(HomogeneousMultiDeviceMetricProgrammableTest, givenSubDevicesReturnZeroMetricWhenCreateMetricsIsCalledThenSuccessIsReturned) {
901
902 MockMetricSource mockMetricSource{};
903 MockMetricProgrammable mockSubDeviceProgrammables[2];
904 std::vector<MetricProgrammable *> subDeviceProgrammables{};
905 subDeviceProgrammables.push_back(&mockSubDeviceProgrammables[0]);
906 subDeviceProgrammables.push_back(&mockSubDeviceProgrammables[1]);
907
908 MetricProgrammable *multiDeviceProgrammable = HomogeneousMultiDeviceMetricProgrammable::create(mockMetricSource, subDeviceProgrammables);
909 const char *name = "name";
910 const char *desc = "desc";
911 uint32_t metricHandleCount = 0;
912 mockSubDeviceProgrammables[0].createMetricReturnHandleCount = 0;
913 mockSubDeviceProgrammables[1].createMetricReturnHandleCount = 0;
914 mockSubDeviceProgrammables[1].createMetricReturnStatus = ZE_RESULT_SUCCESS;
915 EXPECT_EQ(ZE_RESULT_SUCCESS, multiDeviceProgrammable->createMetric(nullptr, 0, name, desc, &metricHandleCount, nullptr));
916
917 mockSubDeviceProgrammables[0].createMetricReturnHandleCount = 0;
918 mockSubDeviceProgrammables[1].createMetricReturnHandleCount = 0;
919 mockSubDeviceProgrammables[1].createMetricReturnStatus = ZE_RESULT_SUCCESS;
920 metricHandleCount = 4;
921 std::vector<zet_metric_handle_t> metricHandles(metricHandleCount);
922 EXPECT_EQ(ZE_RESULT_SUCCESS, multiDeviceProgrammable->createMetric(nullptr, 0, name, desc, &metricHandleCount, metricHandles.data()));
923
924 delete multiDeviceProgrammable;
925 }
926
927 TEST(HomogeneousMultiDeviceMetricTest, givenMultiDeviceMetricWhenDestroyIsCalledThenUnsupportedFeatureIsReturned) {
928
929 MockMetricSource mockMetricSource{};
930 zet_intel_metric_scope_properties_exp_t scopeProperties{};
931 scopeProperties.stype = ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP;
932 scopeProperties.pNext = nullptr;
933 MockMetricScope mockMetricScope(scopeProperties, false, 0);
934 std::vector<MetricScopeImp *> mockMetricScopes{&mockMetricScope};
935 MockMetric mockMetric(mockMetricSource, mockMetricScopes);
936 std::vector<MetricImp *> mockMetrics{&mockMetric};
937 MultiDeviceMetricImp *multiDevMetric = static_cast<MultiDeviceMetricImp *>(
938 MultiDeviceMetricImp::create(mockMetricSource, mockMetrics, mockMetricScopes));
939 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, multiDevMetric->destroy());
940 delete multiDevMetric;
941 }
942
943 struct MultiDeviceCreatedMetricGroupManagerTest : public MultiDeviceFixture,
944
945 public ::testing::Test {
946 void SetUp() override {
947 MultiDeviceFixture::numRootDevices = 1;
948 MultiDeviceFixture::numSubDevices = 2;
949 MultiDeviceFixture::setUp();
950 rootDevice = driverHandle->devices[0];
951 rootDeviceMetricContext = &(static_cast<Device *>(rootDevice)->getMetricDeviceContext());
952 }
953
954 void TearDown() override {
955 MultiDeviceFixture::tearDown();
956 }
957
958 DebugManagerStateRestore restorer;
959 Device *rootDevice = nullptr;
960 MetricDeviceContext *rootDeviceMetricContext = nullptr;
961 };
962
963 struct DummyMetricGroup : public MockMetricGroup {
964 static DummyMetricGroup *create(MetricSource &metricSource,
965 std::vector<MetricGroupImp *> &subDeviceMetricGroups,
966 std::vector<MultiDeviceMetricImp *> &multiDeviceMetrics) {
967 return nullptr;
968 }
969 };
970
971 TEST_F(MultiDeviceCreatedMetricGroupManagerTest, givenMetricFromSubDeviceIsUsedWhenCreateMultipleFromHomogenousMetricsIsCalledThenErrorIsReturned) {
972
973 MockMetricSource mockMetricSource{};
974 zet_intel_metric_scope_properties_exp_t scopeProperties{};
975 scopeProperties.stype = ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP;
976 scopeProperties.pNext = nullptr;
977 MockMetricScope mockMetricScope(scopeProperties, false, 0);
978 std::vector<MetricScopeImp *> mockMetricScopes{&mockMetricScope};
979 MockMetric mockMetric(mockMetricSource, mockMetricScopes);
980 mockMetric.setMultiDevice(false);
981
982 uint32_t metricGroupFromMetricsCount = 0;
983 auto metricHandle = mockMetric.toHandle();
984 std::vector<zet_metric_group_handle_t> metricGroups{};
985 std::vector<zet_metric_handle_t> metrics(1);
986 metrics[0] = metricHandle;
987 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, MultiDeviceCreatedMetricGroupManager::createMultipleMetricGroupsFromMetrics<DummyMetricGroup>(
988 *rootDeviceMetricContext, mockMetricSource,
989 metrics, "name", "desc", &metricGroupFromMetricsCount, metricGroups));
990 EXPECT_EQ(metricGroupFromMetricsCount, 0u);
991 }
992
993 } // namespace ult
994 } // namespace L0