Debian Codegraph @

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

raw
1 /*
2 * Copyright (C) 2024-2025 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/test/unit_tests/sources/metrics/mock_metric_ip_sampling_source.h"
14 #include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_programmable.h"
15 #include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_source.h"
16
17 namespace L0 {
18 namespace ult {
19
20 class OaMetricProgrammableFixture : public DeviceFixture,
21 public ::testing::Test {
22 protected:
23 void SetUp() override;
24 void TearDown() override;
25 std::unique_ptr<MetricDeviceContext> deviceContext = nullptr;
26 OaMetricSourceImp *oaMetricSource = nullptr;
27 MetricEnumeration *metricEnumeration = nullptr;
28 MockIAdapterGroup1x13 mockAdapterGroup{};
29 void disableProgrammableMetricsSupport();
30 DebugManagerStateRestore restorer;
31 MockMetricScope *mockMetricScope = nullptr;
32 std::vector<MetricScopeImp *> mockMetricScopes{};
33 };
34
35 void OaMetricProgrammableFixture::TearDown() {
36 DeviceFixture::tearDown();
37 deviceContext.reset();
38 delete mockMetricScope;
39 mockMetricScope = nullptr;
40 mockMetricScopes.clear();
41 }
42
43 void OaMetricProgrammableFixture::SetUp() {
44 DeviceFixture::setUp();
45
46 mockAdapterGroup.mockParams.Version.MajorNumber = 1;
47 mockAdapterGroup.mockParams.Version.MinorNumber = 13;
48 deviceContext = std::make_unique<MetricDeviceContext>(*device);
49 deviceContext->setMetricsCollectionAllowed(true);
50 oaMetricSource = static_cast<OaMetricSourceImp *>(&deviceContext->getMetricSource<OaMetricSourceImp>());
51 metricEnumeration = static_cast<MetricEnumeration *>(&oaMetricSource->getMetricEnumeration());
52 metricEnumeration->setAdapterGroup(&mockAdapterGroup);
53
54 oaMetricSource->setInitializationState(ZE_RESULT_SUCCESS);
55 metricEnumeration->setInitializationState(ZE_RESULT_SUCCESS);
56 zet_intel_metric_scope_properties_exp_t scopeProperties{};
57 scopeProperties.stype = ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP;
58 scopeProperties.pNext = nullptr;
59 mockMetricScope = new MockMetricScope(scopeProperties, false, 0);
60 mockMetricScopes.push_back(mockMetricScope);
61 }
62
63 void OaMetricProgrammableFixture::disableProgrammableMetricsSupport() {
64
65 deviceContext.reset();
66 debugManager.flags.DisableProgrammableMetricsSupport.set(1);
67 mockAdapterGroup.mockParams.Version.MajorNumber = 1;
68 mockAdapterGroup.mockParams.Version.MinorNumber = 13;
69 deviceContext = std::make_unique<MetricDeviceContext>(*device);
70 oaMetricSource = static_cast<OaMetricSourceImp *>(&deviceContext->getMetricSource<OaMetricSourceImp>());
71 metricEnumeration = static_cast<MetricEnumeration *>(&oaMetricSource->getMetricEnumeration());
72 metricEnumeration->setAdapterGroup(&mockAdapterGroup);
73
74 oaMetricSource->setInitializationState(ZE_RESULT_SUCCESS);
75 metricEnumeration->setInitializationState(ZE_RESULT_SUCCESS);
76 }
77
78 using OaMetricProgrammableTests = OaMetricProgrammableFixture;
79
80 TEST_F(OaMetricProgrammableTests, givenMetricProgrammableIsSupportedThenValidHandlesAreReturned) {
81 MockIConcurrentGroup1x13 mockConcurrentGroup;
82 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
83 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
84 uint32_t count = 0;
85 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
86 EXPECT_EQ(count, 1u);
87
88 zet_metric_programmable_exp_handle_t programmable{};
89 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
90 zet_metric_programmable_exp_properties_t properties{};
91 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->getProperties(&properties));
92 EXPECT_STREQ(properties.component, "GroupName");
93 EXPECT_STREQ(properties.description, "LongName");
94 EXPECT_STREQ(properties.name, "SymbolName");
95 EXPECT_EQ(properties.domain, 1u);
96 EXPECT_EQ(properties.tierNumber, 1u);
97 EXPECT_EQ(properties.samplingType, METRICS_SAMPLING_TYPE_TIME_EVENT_BASED);
98 metricEnumeration->cleanupExtendedMetricInformation();
99 }
100
101 TEST_F(OaMetricProgrammableTests, givenMetricProgrammableIsSupportedAndMoreThanAvailableCountIsRequestedThenSuccessIsReturned) {
102 MockIConcurrentGroup1x13 mockConcurrentGroup;
103 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
104 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
105 uint32_t count = 0;
106 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
107 EXPECT_EQ(count, 1u);
108
109 zet_metric_programmable_exp_handle_t programmable{};
110 count += 1;
111 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
112 metricEnumeration->cleanupExtendedMetricInformation();
113 }
114
115 TEST_F(OaMetricProgrammableTests, givenEnableProgrammableMetricsSupportIsNotSetWhenMetricProgrammableGetIsCalledThenErrorIsReturned) {
116
117 uint32_t count = 0;
118 DebugManagerStateRestore restorer;
119 debugManager.flags.DisableProgrammableMetricsSupport.set(1);
120 auto deviceContextTest = std::make_unique<MetricDeviceContext>(*device);
121 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, deviceContextTest->metricProgrammableGet(&count, nullptr));
122 }
123
124 TEST_F(OaMetricProgrammableTests, givenEnumerationHasErroreWhenmetricProgrammableGetIsCalledThenErrorIsReturned) {
125 MockIConcurrentGroup1x13 mockConcurrentGroup;
126 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
127 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
128 metricEnumeration->setInitializationState(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE);
129 uint32_t count = 0;
130 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, oaMetricSource->metricProgrammableGet(&count, nullptr));
131 metricEnumeration->cleanupExtendedMetricInformation();
132 }
133
134 TEST_F(OaMetricProgrammableTests, givenConcurrentGroupVersionIsMetThenMetricProgrammableCountIsNonZero) {
135 MockIConcurrentGroup1x13 mockConcurrentGroup;
136 mockAdapterGroup.mockParams.Version.MajorNumber = 2;
137 mockAdapterGroup.mockParams.Version.MinorNumber = 0;
138 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
139 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
140 uint32_t count = 0;
141 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
142 EXPECT_GT(count, 0u);
143 metricEnumeration->cleanupExtendedMetricInformation();
144 }
145
146 TEST_F(OaMetricProgrammableTests, givenMetricEnumeratorIsNullThenMetricProgrammableCountIsZero) {
147 MockIConcurrentGroup1x13 mockConcurrentGroup;
148 mockConcurrentGroup.metricEnumeratorReturn = nullptr;
149 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
150 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
151 uint32_t count = 0;
152 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
153 EXPECT_EQ(count, 0u);
154 metricEnumeration->cleanupExtendedMetricInformation();
155 }
156
157 TEST_F(OaMetricProgrammableTests, givenMetricPrototypeCountIsZeroThenMetricProgrammableCountIsZero) {
158 MockIConcurrentGroup1x13 mockConcurrentGroup;
159 mockConcurrentGroup.metricEnumeratorReturn->getMetricPrototypeCountReturn = 0;
160 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
161 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
162 uint32_t count = 0;
163 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
164 EXPECT_EQ(count, 0u);
165 metricEnumeration->cleanupExtendedMetricInformation();
166 }
167
168 TEST_F(OaMetricProgrammableTests, givenMetricPrototypeParamsAreNullThenMetricProgrammableCountIsZero) {
169 MockIConcurrentGroup1x13 mockConcurrentGroup;
170 mockConcurrentGroup.metricEnumeratorReturn->metricProtoTypeReturn[0].getParamsReturn = nullptr;
171 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
172 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
173 uint32_t count = 0;
174 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
175 EXPECT_EQ(count, 0u);
176 metricEnumeration->cleanupExtendedMetricInformation();
177 }
178
179 TEST_F(OaMetricProgrammableTests, whenRetrievingConcurrentGroupFromAdapterGroupThenAllParametersAreCorrect) {
180
181 auto adapterGroupParams = metricEnumeration->getAdapterGroupParams(
182 static_cast<MetricsDiscovery::IAdapterGroup_1_13 *>(&mockAdapterGroup));
183 EXPECT_EQ(adapterGroupParams->Version.MajorNumber, 1u);
184 EXPECT_EQ(adapterGroupParams->Version.MinorNumber, 13u);
185 auto adapter = metricEnumeration->getAdapterFromAdapterGroup(
186 static_cast<MetricsDiscovery::IAdapterGroup_1_13 *>(&mockAdapterGroup), 0);
187 const auto adapterParams19 = metricEnumeration->getAdapterParams(adapter);
188 EXPECT_EQ(adapterParams19->BusNumber, 100u);
189 MetricsDiscovery::IMetricsDevice_1_13 *metricsDevice = nullptr;
190 metricEnumeration->openMetricsDeviceFromAdapter(adapter, &metricsDevice);
191 EXPECT_NE(metricsDevice, nullptr);
192 metricsDevice = nullptr;
193 metricEnumeration->openMetricsSubDeviceFromAdapter(adapter, 0, &metricsDevice);
194 EXPECT_NE(metricsDevice, nullptr);
195 auto concurrentGroup = metricEnumeration->getConcurrentGroupFromDevice(metricsDevice, 0);
196 EXPECT_NE(concurrentGroup, nullptr);
197 }
198
199 TEST_F(OaMetricProgrammableTests, givenMetricProgrammableIsSupportedWhenCachingForMulitpleConcurrentGroupsThenValidHandlesAreReturned) {
200 MockIConcurrentGroup1x13 mockConcurrentGroup;
201 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
202 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
203 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
204 uint32_t count = 0;
205 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
206 EXPECT_EQ(count, 2u);
207 zet_metric_programmable_exp_handle_t programmable[2] = {};
208 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, programmable));
209
210 for (uint32_t i = 0; i < 2u; i++) {
211 zet_metric_programmable_exp_properties_t properties{};
212 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable[i])->getProperties(&properties));
213 EXPECT_STREQ(properties.component, "GroupName");
214 EXPECT_STREQ(properties.description, "LongName");
215 EXPECT_STREQ(properties.name, "SymbolName");
216 EXPECT_EQ(properties.domain, 1u);
217 EXPECT_EQ(properties.tierNumber, 1u);
218 EXPECT_EQ(properties.samplingType, METRICS_SAMPLING_TYPE_TIME_EVENT_BASED);
219 }
220 metricEnumeration->cleanupExtendedMetricInformation();
221 }
222
223 TEST_F(OaMetricProgrammableTests, givenMetricsProgrammableSupportIsDisabledWhenmetricProgrammableGetIsCalledThenErrorIsReturned) {
224 disableProgrammableMetricsSupport();
225 MockIConcurrentGroup1x13 mockConcurrentGroup;
226 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
227 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
228 uint32_t count = 0;
229 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, deviceContext->metricProgrammableGet(&count, nullptr));
230 EXPECT_EQ(count, 0u);
231 metricEnumeration->cleanupExtendedMetricInformation();
232 }
233
234 TEST_F(OaMetricProgrammableTests, givenMetricsProgrammableSupportIsDisabledWhenRetrievingConcurrentGroupFromAdapterGroupThenAllParametersAreCorrect) {
235
236 disableProgrammableMetricsSupport();
237 auto adapterGroupParams = metricEnumeration->getAdapterGroupParams(
238 static_cast<MetricsDiscovery::IAdapterGroup_1_13 *>(&mockAdapterGroup));
239 EXPECT_EQ(adapterGroupParams->Version.MajorNumber, 1u);
240 EXPECT_EQ(adapterGroupParams->Version.MinorNumber, 13u);
241 auto adapter = metricEnumeration->getAdapterFromAdapterGroup(
242 static_cast<MetricsDiscovery::IAdapterGroup_1_13 *>(&mockAdapterGroup), 0);
243 const auto adapterParams19 = metricEnumeration->getAdapterParams(adapter);
244 EXPECT_EQ(adapterParams19->BusNumber, 100u);
245 MetricsDiscovery::IMetricsDevice_1_13 *metricsDevice = nullptr;
246 metricEnumeration->openMetricsDeviceFromAdapter(adapter, &metricsDevice);
247 EXPECT_NE(metricsDevice, nullptr);
248 metricsDevice = nullptr;
249 metricEnumeration->openMetricsSubDeviceFromAdapter(adapter, 0, &metricsDevice);
250 EXPECT_NE(metricsDevice, nullptr);
251 auto concurrentGroup = metricEnumeration->getConcurrentGroupFromDevice(metricsDevice, 0);
252 EXPECT_NE(concurrentGroup, nullptr);
253 }
254
255 TEST_F(OaMetricProgrammableTests, givenMetricProgrammableIsSupportedAndApiMaskIsIoStreamThenCorrectSamplingTypeIsSet) {
256 MockIConcurrentGroup1x13 mockConcurrentGroup;
257 mockConcurrentGroup.mockMetricEnumerator.metricProtoTypeReturn[0].mockParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM;
258 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
259 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
260 uint32_t count = 0;
261 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
262 EXPECT_EQ(count, 1u);
263 zet_metric_programmable_exp_handle_t programmable{};
264 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
265 zet_metric_programmable_exp_properties_t properties{};
266 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->getProperties(&properties));
267 EXPECT_EQ(properties.samplingType, ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED);
268 metricEnumeration->cleanupExtendedMetricInformation();
269 }
270
271 TEST_F(OaMetricProgrammableTests, givenMetricProgrammableIsSupportedAndApiMaskIsNotIoStreamThenCorrectSamplingTypeIsSet) {
272 MockIConcurrentGroup1x13 mockConcurrentGroup;
273 mockConcurrentGroup.mockMetricEnumerator.metricProtoTypeReturn[0].mockParams.ApiMask = MetricsDiscovery::API_TYPE_OCL | MetricsDiscovery::API_TYPE_OGL4_X;
274 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
275 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
276 uint32_t count = 0;
277 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
278 EXPECT_EQ(count, 1u);
279 zet_metric_programmable_exp_handle_t programmable{};
280 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
281 zet_metric_programmable_exp_properties_t properties{};
282 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->getProperties(&properties));
283 EXPECT_EQ(properties.samplingType, ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED);
284 metricEnumeration->cleanupExtendedMetricInformation();
285 }
286
287 TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableThenCorrectParamerterInfoIsReturned) {
288 MockIConcurrentGroup1x13 mockConcurrentGroup;
289 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
290 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
291 uint32_t count = 0;
292 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
293 EXPECT_EQ(count, 1u);
294 zet_metric_programmable_exp_handle_t programmable{};
295 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
296 zet_metric_programmable_param_info_exp_t parameterInfo[4];
297
298 uint32_t parameterCount = 6;
299 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->getParamInfo(&parameterCount, parameterInfo));
300 EXPECT_EQ(parameterCount, 4u);
301
302 EXPECT_EQ(parameterInfo[0].defaultValue.ui64, UINT64_MAX);
303 EXPECT_STREQ(parameterInfo[0].name, "mockParam1");
304 EXPECT_EQ(parameterInfo[0].type, ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_DISAGGREGATION);
305 EXPECT_EQ(parameterInfo[0].valueInfoCount, 1u);
306 EXPECT_EQ(parameterInfo[0].valueInfoType, ZET_VALUE_INFO_TYPE_EXP_UINT32);
307
308 EXPECT_EQ(parameterInfo[1].defaultValue.ui64, 0u);
309 EXPECT_STREQ(parameterInfo[1].name, "mockParam2");
310 EXPECT_EQ(parameterInfo[1].type, ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_LATENCY);
311 EXPECT_EQ(parameterInfo[1].valueInfoCount, 1u);
312 EXPECT_EQ(parameterInfo[1].valueInfoType, ZET_VALUE_INFO_TYPE_EXP_UINT64);
313
314 EXPECT_EQ(parameterInfo[2].defaultValue.ui64, 0u);
315 EXPECT_STREQ(parameterInfo[2].name, "mockParam3");
316 EXPECT_EQ(parameterInfo[2].type, ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_NORMALIZATION_UTILIZATION);
317 EXPECT_EQ(parameterInfo[2].valueInfoCount, 1u);
318 EXPECT_EQ(parameterInfo[2].valueInfoType, ZET_VALUE_INFO_TYPE_EXP_UINT64_RANGE);
319
320 EXPECT_EQ(parameterInfo[3].defaultValue.ui64, 0u);
321 EXPECT_STREQ(parameterInfo[3].name, "mockParam4");
322 EXPECT_EQ(parameterInfo[3].type, ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_NORMALIZATION_BYTES);
323 EXPECT_EQ(parameterInfo[3].valueInfoCount, 1u);
324 EXPECT_EQ(parameterInfo[3].valueInfoType, ZET_VALUE_INFO_TYPE_EXP_UINT64_RANGE);
325
326 metricEnumeration->cleanupExtendedMetricInformation();
327 }
328
329 TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableWhenQueryingParameterInfoWithZeroParameterCountThenReturnError) {
330 MockIConcurrentGroup1x13 mockConcurrentGroup;
331 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
332 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
333 uint32_t count = 0;
334 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
335 EXPECT_EQ(count, 1u);
336 zet_metric_programmable_exp_handle_t programmable{};
337 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
338 zet_metric_programmable_param_info_exp_t parameterInfo[4];
339 uint32_t parameterCount = 0;
340 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, MetricProgrammable::fromHandle(programmable)->getParamInfo(&parameterCount, parameterInfo));
341
342 metricEnumeration->cleanupExtendedMetricInformation();
343 }
344
345 TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableWithZeroParametersWhenQueryingParamInfoWithZeroParamCountThenReturnSuccess) {
346 MockIConcurrentGroup1x13 mockConcurrentGroup;
347 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
348 mockConcurrentGroup.mockMetricEnumerator.metricProtoTypeReturn[0].mockParams.OptionDescriptorCount = 0;
349 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
350 uint32_t count = 0;
351 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
352 EXPECT_EQ(count, 1u);
353 zet_metric_programmable_exp_handle_t programmable{};
354 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
355 zet_metric_programmable_param_info_exp_t parameterInfo[4];
356 uint32_t parameterCount = 0;
357 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->getParamInfo(&parameterCount, parameterInfo));
358
359 metricEnumeration->cleanupExtendedMetricInformation();
360 }
361
362 TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableWhenGetOptionDescriptorReturnsNullThenErrorIsReturned) {
363 MockIConcurrentGroup1x13 mockConcurrentGroup;
364 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
365 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
366 uint32_t count = 0;
367 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
368 EXPECT_EQ(count, 1u);
369 zet_metric_programmable_exp_handle_t programmable{};
370 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
371 zet_metric_programmable_param_info_exp_t parameterInfo[4];
372 uint32_t parameterCount = 6;
373 mockConcurrentGroup.metricEnumeratorReturn->metricProtoTypeReturn[0].mockOptionDescriptors.resize(0);
374 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, MetricProgrammable::fromHandle(programmable)->getParamInfo(&parameterCount, parameterInfo));
375
376 metricEnumeration->cleanupExtendedMetricInformation();
377 }
378
379 TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableWhenGetOptionDescriptorTypeIsUnsupportedThenErrorIsReturned) {
380 MockIConcurrentGroup1x13 mockConcurrentGroup;
381 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
382 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
383 uint32_t count = 0;
384 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
385 EXPECT_EQ(count, 1u);
386 zet_metric_programmable_exp_handle_t programmable{};
387 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
388 zet_metric_programmable_param_info_exp_t parameterInfo[4];
389 uint32_t parameterCount = 6;
390 mockConcurrentGroup.metricEnumeratorReturn->metricProtoTypeReturn[0].mockOptionDescriptors[0].Type = MetricsDiscovery::OPTION_DESCRIPTOR_TYPE_LAST;
391 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, MetricProgrammable::fromHandle(programmable)->getParamInfo(&parameterCount, parameterInfo));
392
393 metricEnumeration->cleanupExtendedMetricInformation();
394 }
395
396 TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableWhenGetOptionDescriptorValueTypeIsUnsupportedThenErrorIsReturned) {
397 MockIConcurrentGroup1x13 mockConcurrentGroup;
398 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
399 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
400 uint32_t count = 0;
401 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
402 EXPECT_EQ(count, 1u);
403 zet_metric_programmable_exp_handle_t programmable{};
404 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
405 zet_metric_programmable_param_info_exp_t parameterInfo[4];
406 uint32_t parameterCount = 6;
407 mockConcurrentGroup.metricEnumeratorReturn->metricProtoTypeReturn[0].mockOptionDescriptors[0].ValidValues->ValueType = MetricsDiscovery::VALUE_TYPE_LAST;
408 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, MetricProgrammable::fromHandle(programmable)->getParamInfo(&parameterCount, parameterInfo));
409
410 mockConcurrentGroup.metricEnumeratorReturn->metricProtoTypeReturn[0].mockOptionDescriptors[0].ValidValues->ValueType = MetricsDiscovery::VALUE_TYPE_UINT32;
411 metricEnumeration->cleanupExtendedMetricInformation();
412 }
413
414 TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableThenCorrectParamerterValueInfoIsReturned) {
415 MockIConcurrentGroup1x13 mockConcurrentGroup;
416 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
417 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
418 uint32_t count = 0;
419 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
420 EXPECT_EQ(count, 1u);
421 zet_metric_programmable_exp_handle_t programmable{};
422 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
423 std::vector<zet_metric_programmable_param_info_exp_t> parameterInfo(4);
424 uint32_t parameterCount = 2;
425 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->getParamInfo(&parameterCount, parameterInfo.data()));
426 uint32_t valueInfoCount = 2;
427 zet_metric_programmable_param_value_info_exp_t valueInfo{};
428 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->getParamValueInfo(0, &valueInfoCount, &valueInfo));
429 EXPECT_EQ(valueInfoCount, 1u);
430 EXPECT_EQ(valueInfo.valueInfo.ui32, 1u);
431 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->getParamValueInfo(1, &valueInfoCount, &valueInfo));
432 EXPECT_EQ(valueInfoCount, 1u);
433 EXPECT_EQ(valueInfo.valueInfo.ui64, 2u);
434 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->getParamValueInfo(2, &valueInfoCount, &valueInfo));
435 EXPECT_EQ(valueInfoCount, 1u);
436 EXPECT_EQ(valueInfo.valueInfo.ui64Range.ui64Min, 3u);
437 EXPECT_EQ(valueInfo.valueInfo.ui64Range.ui64Max, 4u);
438 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->getParamValueInfo(3, &valueInfoCount, &valueInfo));
439 EXPECT_EQ(valueInfoCount, 1u);
440 EXPECT_EQ(valueInfo.valueInfo.ui64Range.ui64Min, 5u);
441 EXPECT_EQ(valueInfo.valueInfo.ui64Range.ui64Max, 6u);
442
443 metricEnumeration->cleanupExtendedMetricInformation();
444 }
445
446 TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableWhenUnsupportedValueInfoFromMdapiIsObservedThenErrorIsReturned) {
447 MockIConcurrentGroup1x13 mockConcurrentGroup;
448 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
449 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
450 uint32_t count = 0;
451 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
452 EXPECT_EQ(count, 1u);
453 zet_metric_programmable_exp_handle_t programmable{};
454 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
455 std::vector<zet_metric_programmable_param_info_exp_t> parameterInfo(4);
456 uint32_t parameterCount = 2;
457 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->getParamInfo(&parameterCount, parameterInfo.data()));
458 uint32_t valueInfoCount = 2;
459 zet_metric_programmable_param_value_info_exp_t valueInfo{};
460
461 mockConcurrentGroup.metricEnumeratorReturn->metricProtoTypeReturn[0].mockOptionDescriptors[0].ValidValues->ValueType = MetricsDiscovery::VALUE_TYPE_LAST;
462 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, MetricProgrammable::fromHandle(programmable)->getParamValueInfo(0, &valueInfoCount, &valueInfo));
463 EXPECT_EQ(valueInfoCount, 0u);
464 mockConcurrentGroup.metricEnumeratorReturn->metricProtoTypeReturn[0].mockOptionDescriptors[0].ValidValues->ValueType = MetricsDiscovery::VALUE_TYPE_UINT32;
465 metricEnumeration->cleanupExtendedMetricInformation();
466 }
467
468 TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableThenCorrectParamerterValueInfoDescIsReturned) {
469 MockIConcurrentGroup1x13 mockConcurrentGroup;
470 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
471 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
472 uint32_t count = 0;
473 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
474 EXPECT_EQ(count, 1u);
475 zet_metric_programmable_exp_handle_t programmable{};
476 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
477 std::vector<zet_metric_programmable_param_info_exp_t> parameterInfo(4);
478 uint32_t parameterCount = 2;
479 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->getParamInfo(&parameterCount, parameterInfo.data()));
480 uint32_t valueInfoCount = 2;
481 zet_metric_programmable_param_value_info_exp_t valueInfo{};
482 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->getParamValueInfo(0, &valueInfoCount, &valueInfo));
483 EXPECT_EQ(valueInfoCount, 1u);
484 EXPECT_STREQ(valueInfo.description, "SymbolName");
485
486 metricEnumeration->cleanupExtendedMetricInformation();
487 }
488
489 TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableWhenQueryingForMoreParameterIndexThenErrorIsReturned) {
490 MockIConcurrentGroup1x13 mockConcurrentGroup;
491 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
492 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
493 uint32_t count = 0;
494 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
495 EXPECT_EQ(count, 1u);
496 zet_metric_programmable_exp_handle_t programmable{};
497 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
498 uint32_t valueInfoCount = 2;
499 zet_metric_programmable_param_value_info_exp_t valueInfo{};
500 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, MetricProgrammable::fromHandle(programmable)->getParamValueInfo(4, &valueInfoCount, &valueInfo));
501 metricEnumeration->cleanupExtendedMetricInformation();
502 }
503
504 TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableWhenCreatingMetricsFromItThenReturnSuccess) {
505 MockIConcurrentGroup1x13 mockConcurrentGroup;
506 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
507 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
508 uint32_t count = 0;
509 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
510 EXPECT_EQ(count, 1u);
511 zet_metric_programmable_exp_handle_t programmable{};
512 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
513 zet_metric_programmable_param_value_exp_t parameterValue[4];
514 parameterValue[0].value.ui32 = 20;
515 parameterValue[1].value.ui64 = 21;
516 parameterValue[2].value.ui32 = 22;
517 parameterValue[3].value.ui64 = 23;
518 uint32_t metricHandleCount = 0;
519 const char metricName[ZET_MAX_METRIC_NAME] = "metricName";
520 const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription";
521 EXPECT_EQ(ZE_RESULT_SUCCESS,
522 MetricProgrammable::fromHandle(programmable)->createMetric(parameterValue, 4, metricName, metricDescription, &metricHandleCount, nullptr));
523 EXPECT_EQ(metricHandleCount, 1u);
524
525 zet_metric_handle_t metricHandle{};
526 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(parameterValue, 4, metricName, metricDescription, &metricHandleCount, &metricHandle));
527
528 zetMetricDestroyExp(metricHandle);
529
530 metricEnumeration->cleanupExtendedMetricInformation();
531 }
532
533 TEST_F(OaMetricProgrammableTests, givenGetOptionDescriptorReturnsNullWhenCreatingMetricsThenReturnError) {
534 MockIConcurrentGroup1x13 mockConcurrentGroup;
535 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
536 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
537 uint32_t count = 0;
538 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
539 EXPECT_EQ(count, 1u);
540 zet_metric_programmable_exp_handle_t programmable{};
541 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
542 zet_metric_programmable_param_value_exp_t parameterValue[4];
543 parameterValue[0].value.ui32 = 20;
544 parameterValue[1].value.ui64 = 21;
545 parameterValue[2].value.ui32 = 22;
546 parameterValue[3].value.ui64 = 23;
547 const char metricName[ZET_MAX_METRIC_NAME] = "metricName";
548 const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription";
549 mockConcurrentGroup.metricEnumeratorReturn->metricProtoTypeReturn[0].mockOptionDescriptors.resize(0);
550 uint32_t metricHandleCount = 1;
551 zet_metric_handle_t metricHandle{};
552 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN,
553 MetricProgrammable::fromHandle(programmable)->createMetric(parameterValue, 4, metricName, metricDescription, &metricHandleCount, &metricHandle));
554 EXPECT_EQ(metricHandleCount, 0u);
555 metricEnumeration->cleanupExtendedMetricInformation();
556 }
557
558 TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableWhenCreatingMetricsUsingSameValueAsDefaultValueThenReturnSuccess) {
559 MockIConcurrentGroup1x13 mockConcurrentGroup;
560 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
561 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
562 uint32_t count = 0;
563 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
564 EXPECT_EQ(count, 1u);
565 zet_metric_programmable_exp_handle_t programmable{};
566 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
567 zet_metric_programmable_param_info_exp_t parameterInfo{};
568 uint32_t parameterCount = 1;
569 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->getParamInfo(&parameterCount, &parameterInfo));
570 zet_metric_programmable_param_value_exp_t parameterValue{};
571 parameterValue.value.ui64 = parameterInfo.defaultValue.ui64;
572 uint32_t metricHandleCount = 0;
573 const char metricName[ZET_MAX_METRIC_NAME] = "metricName";
574 const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription";
575 EXPECT_EQ(ZE_RESULT_SUCCESS,
576 MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr));
577 EXPECT_EQ(metricHandleCount, 1u);
578
579 zet_metric_handle_t metricHandle{};
580 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle));
581
582 zetMetricDestroyExp(metricHandle);
583
584 metricEnumeration->cleanupExtendedMetricInformation();
585 }
586
587 TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableWhenCreatingMetricsWithIncorrectParametersThenReturnsFailure) {
588 MockIConcurrentGroup1x13 mockConcurrentGroup;
589 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
590 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
591 uint32_t count = 0;
592 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
593 EXPECT_EQ(count, 1u);
594 zet_metric_programmable_exp_handle_t programmable{};
595 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
596 zet_metric_programmable_param_value_exp_t parameterValue{};
597 parameterValue.value.ui32 = 20;
598 uint32_t metricHandleCount = 0;
599 const char metricName[ZET_MAX_METRIC_NAME] = "metricName";
600 const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription";
601 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT,
602 MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 5, metricName, metricDescription, &metricHandleCount, nullptr));
603
604 metricEnumeration->cleanupExtendedMetricInformation();
605 }
606
607 TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableWhenCreatingMetricsAndMdapiFailsDuringCloneThenReturnsFailure) {
608 MockIConcurrentGroup1x13 mockConcurrentGroup;
609 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
610 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
611 uint32_t count = 0;
612 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
613 EXPECT_EQ(count, 1u);
614 zet_metric_programmable_exp_handle_t programmable{};
615 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
616 zet_metric_programmable_param_value_exp_t parameterValue{};
617 parameterValue.value.ui32 = 20;
618 uint32_t metricHandleCount = 1;
619 const char metricName[ZET_MAX_METRIC_NAME] = "metricName";
620 const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription";
621 mockConcurrentGroup.metricEnumeratorReturn->metricProtoTypeReturn[0].deleteClone();
622 zet_metric_handle_t metricHandle{};
623 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN,
624 MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle));
625
626 metricEnumeration->cleanupExtendedMetricInformation();
627 }
628
629 TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableWhenCreatingMetricsAndMdapiFailsDuringChangeNamesThenReturnsFailure) {
630 MockIConcurrentGroup1x13 mockConcurrentGroup;
631 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
632 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
633 uint32_t count = 0;
634 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
635 EXPECT_EQ(count, 1u);
636 zet_metric_programmable_exp_handle_t programmable{};
637 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
638 zet_metric_programmable_param_value_exp_t parameterValue{};
639 parameterValue.value.ui32 = 20;
640 uint32_t metricHandleCount = 1;
641 const char metricName[ZET_MAX_METRIC_NAME] = "metricName";
642 const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription";
643 mockConcurrentGroup.metricEnumeratorReturn->metricProtoTypeReturn[0].clone->mockChangeNamesReturnCode = MetricsDiscovery::CC_ERROR_GENERAL;
644 zet_metric_handle_t metricHandle{};
645 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN,
646 MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle));
647
648 metricEnumeration->cleanupExtendedMetricInformation();
649 }
650
651 TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableWhenCreatingMetricsWithIncorrectParametersAndMdapiFailsThenReturnsFailure) {
652 MockIConcurrentGroup1x13 mockConcurrentGroup;
653 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
654 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
655 uint32_t count = 0;
656 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
657 EXPECT_EQ(count, 1u);
658 zet_metric_programmable_exp_handle_t programmable{};
659 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
660 zet_metric_programmable_param_value_exp_t parameterValue{};
661 parameterValue.value.ui32 = 20;
662 uint32_t metricHandleCount = 1;
663 const char metricName[ZET_MAX_METRIC_NAME] = "metricName";
664 const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription";
665 mockConcurrentGroup.metricEnumeratorReturn->metricProtoTypeReturn[0].clone->mockSetOptionReturnCode = MetricsDiscovery::CC_ERROR_INVALID_PARAMETER;
666 zet_metric_handle_t metricHandle{};
667 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT,
668 MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle));
669
670 metricEnumeration->cleanupExtendedMetricInformation();
671 }
672
673 TEST_F(OaMetricProgrammableTests, givenValidMetricGroupWhenAddingOrRemovingMetricsThenSuccessIsReturned) {
674 MockIConcurrentGroup1x13 mockConcurrentGroup;
675 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
676 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
677 uint32_t count = 0;
678 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
679 EXPECT_EQ(count, 1u);
680 zet_metric_programmable_exp_handle_t programmable{};
681 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
682 zet_metric_programmable_param_value_exp_t parameterValue{};
683 parameterValue.value.ui32 = 20;
684 uint32_t metricHandleCount = 0;
685 const char metricName[ZET_MAX_METRIC_NAME] = "metricName";
686 const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription";
687 EXPECT_EQ(ZE_RESULT_SUCCESS,
688 MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr));
689 EXPECT_EQ(metricHandleCount, 1u);
690 zet_metric_handle_t metricHandle{};
691 size_t errorStringSize = 0;
692 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle));
693
694 uint32_t metricGroupCount = 0;
695 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
696 EXPECT_NE(metricGroupCount, 0u);
697 std::vector<zet_metric_group_handle_t> metricGroupHandles(metricGroupCount);
698 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data()));
699 EXPECT_NE(metricGroupCount, 0u);
700 zet_metric_group_handle_t metricGroupHandle = metricGroupHandles[0];
701
702 ASSERT_NE(metricGroupHandle, nullptr);
703 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle, &errorStringSize, nullptr));
704 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle, &errorStringSize, nullptr));
705 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupRemoveMetricExp(metricGroupHandle, metricHandle));
706 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle, &errorStringSize, nullptr));
707
708 for (auto destroyMetricGroupHandle : metricGroupHandles) {
709 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(destroyMetricGroupHandle));
710 }
711 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle));
712 metricEnumeration->cleanupExtendedMetricInformation();
713 }
714
715 TEST_F(OaMetricProgrammableTests, givenInvalidMeticWhenMetricGroupIsCreatedThenErrorIsReturned) {
716 MockMetricSource mockMetricSource{};
717 mockMetricSource.isAvailableReturn = true;
718 MockMetric mockMetric(mockMetricSource, mockMetricScopes);
719 uint32_t metricGroupCount = 0;
720 auto metricHandle = mockMetric.toHandle();
721 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
722 EXPECT_EQ(metricGroupCount, 0u);
723 metricEnumeration->cleanupExtendedMetricInformation();
724 }
725
726 TEST_F(OaMetricProgrammableTests, givenCreateMetricGroupsFromMetricsIsCalledWhenMetricCountIsZeroThenErrorIsReturned) {
727 MockIConcurrentGroup1x13 mockConcurrentGroup;
728 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
729 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
730 uint32_t count = 0;
731 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
732 EXPECT_EQ(count, 1u);
733
734 uint32_t metricGroupCount = 0;
735 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, deviceContext->createMetricGroupsFromMetrics(0, nullptr, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
736 EXPECT_EQ(metricGroupCount, 0u);
737
738 metricEnumeration->cleanupExtendedMetricInformation();
739 }
740
741 TEST_F(OaMetricProgrammableTests, givenValidMetricGroupWhenDestroyingMetricsBeforeDestroyingMetricGroupThenErrorIsReturned) {
742 MockIConcurrentGroup1x13 mockConcurrentGroup;
743 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
744 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
745 uint32_t count = 0;
746 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
747 EXPECT_EQ(count, 1u);
748 zet_metric_programmable_exp_handle_t programmable{};
749 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
750 zet_metric_programmable_param_value_exp_t parameterValue{};
751 parameterValue.value.ui32 = 20;
752 uint32_t metricHandleCount = 0;
753 const char metricName[ZET_MAX_METRIC_NAME] = "metricName";
754 const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription";
755 EXPECT_EQ(ZE_RESULT_SUCCESS,
756 MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr));
757 EXPECT_EQ(metricHandleCount, 1u);
758 zet_metric_handle_t metricHandle{};
759 size_t errorStringSize = 0;
760 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle));
761 uint32_t metricGroupCount = 0;
762 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
763 EXPECT_NE(metricGroupCount, 0u);
764 std::vector<zet_metric_group_handle_t> metricGroupHandles(metricGroupCount);
765 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data()));
766 EXPECT_NE(metricGroupCount, 0u);
767 zet_metric_group_handle_t metricGroupHandle = metricGroupHandles[0];
768
769 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle, &errorStringSize, nullptr));
770 EXPECT_EQ(ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE, zetMetricDestroyExp(metricHandle));
771 for (auto destroyMetricGroupHandle : metricGroupHandles) {
772 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(destroyMetricGroupHandle));
773 }
774 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle));
775 metricEnumeration->cleanupExtendedMetricInformation();
776 }
777
778 TEST_F(OaMetricProgrammableTests, givenValidMetricGroupWhenFinalizingMetricsThenSuccessIsReturned) {
779
780 MockIConcurrentGroup1x13 mockConcurrentGroup;
781 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
782 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
783 uint32_t count = 0;
784 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
785 EXPECT_EQ(count, 1u);
786 zet_metric_programmable_exp_handle_t programmable{};
787 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
788 zet_metric_programmable_param_value_exp_t parameterValue{};
789 parameterValue.value.ui32 = 20;
790 uint32_t metricHandleCount = 0;
791 const char metricName[ZET_MAX_METRIC_NAME] = "metricName";
792 const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription";
793 EXPECT_EQ(ZE_RESULT_SUCCESS,
794 MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr));
795 EXPECT_EQ(metricHandleCount, 1u);
796 zet_metric_handle_t metricHandle{};
797 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle));
798
799 uint32_t metricGroupCount = 0;
800 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
801 EXPECT_NE(metricGroupCount, 0u);
802 std::vector<zet_metric_group_handle_t> metricGroupHandles(metricGroupCount);
803 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data()));
804 EXPECT_NE(metricGroupCount, 0u);
805 zet_metric_group_handle_t metricGroupHandle = metricGroupHandles[0];
806
807 size_t errorStringSize = 0;
808 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle, &errorStringSize, nullptr));
809 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupCloseExp(metricGroupHandle));
810 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle, &errorStringSize, nullptr));
811 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupCloseExp(metricGroupHandle));
812 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupRemoveMetricExp(metricGroupHandle, metricHandle));
813 for (auto destroyMetricGroupHandle : metricGroupHandles) {
814 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(destroyMetricGroupHandle));
815 }
816 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle));
817 metricEnumeration->cleanupExtendedMetricInformation();
818 }
819
820 TEST_F(OaMetricProgrammableTests, givenValidMetricGroupWhenAddingMetricsAfterFinalizingThenSuccessIsReturned) {
821
822 MockIConcurrentGroup1x13 mockConcurrentGroup;
823 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
824 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
825 uint32_t count = 0;
826 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
827 EXPECT_EQ(count, 1u);
828 zet_metric_programmable_exp_handle_t programmable{};
829 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
830 zet_metric_programmable_param_value_exp_t parameterValue{};
831 parameterValue.value.ui32 = 20;
832 uint32_t metricHandleCount = 0;
833 const char metricName[ZET_MAX_METRIC_NAME] = "metricName";
834 const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription";
835 EXPECT_EQ(ZE_RESULT_SUCCESS,
836 MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr));
837 EXPECT_EQ(metricHandleCount, 1u);
838 zet_metric_handle_t metricHandle1{}, metricHandle2{};
839 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle1));
840 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle2));
841 size_t errorStringSize = 0;
842
843 uint32_t metricGroupCount = 0;
844 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle1, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
845 EXPECT_NE(metricGroupCount, 0u);
846 std::vector<zet_metric_group_handle_t> metricGroupHandles(metricGroupCount);
847 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle1, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data()));
848 EXPECT_NE(metricGroupCount, 0u);
849 zet_metric_group_handle_t metricGroupHandle = metricGroupHandles[0];
850
851 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle1, &errorStringSize, nullptr));
852 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupCloseExp(metricGroupHandle));
853 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle2, &errorStringSize, nullptr));
854 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupCloseExp(metricGroupHandle));
855 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupRemoveMetricExp(metricGroupHandle, metricHandle1));
856 for (auto destroyMetricGroupHandle : metricGroupHandles) {
857 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(destroyMetricGroupHandle));
858 }
859 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle1));
860 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle2));
861 metricEnumeration->cleanupExtendedMetricInformation();
862 }
863
864 TEST_F(OaMetricProgrammableTests, givenValidMetricGroupWhenRemovingAllMetricsAndClosedThenErrorIsReturned) {
865
866 MockIConcurrentGroup1x13 mockConcurrentGroup;
867 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
868 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
869 uint32_t count = 0;
870 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
871 EXPECT_EQ(count, 1u);
872 zet_metric_programmable_exp_handle_t programmable{};
873 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
874 zet_metric_programmable_param_value_exp_t parameterValue{};
875 parameterValue.value.ui32 = 20;
876 uint32_t metricHandleCount = 0;
877 const char metricName[ZET_MAX_METRIC_NAME] = "metricName";
878 const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription";
879 EXPECT_EQ(ZE_RESULT_SUCCESS,
880 MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr));
881 EXPECT_EQ(metricHandleCount, 1u);
882 zet_metric_handle_t metricHandle1{};
883 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle1));
884 uint32_t metricGroupCount = 0;
885 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle1, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
886 EXPECT_NE(metricGroupCount, 0u);
887 std::vector<zet_metric_group_handle_t> metricGroupHandles(metricGroupCount);
888 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle1, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data()));
889 EXPECT_NE(metricGroupCount, 0u);
890 zet_metric_group_handle_t metricGroupHandle = metricGroupHandles[0];
891 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupRemoveMetricExp(metricGroupHandle, metricHandle1));
892 EXPECT_EQ(ZE_RESULT_NOT_READY, zetMetricGroupCloseExp(metricGroupHandle));
893 for (auto destroyMetricGroupHandle : metricGroupHandles) {
894 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(destroyMetricGroupHandle));
895 }
896 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle1));
897 metricEnumeration->cleanupExtendedMetricInformation();
898 }
899
900 TEST_F(OaMetricProgrammableTests, givenActivatedValidMetricGroupWhenAddingOrRemovingMetricsThenErrorIsReturned) {
901 MockIConcurrentGroup1x13 mockConcurrentGroup;
902 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
903 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
904
905 uint32_t count = 0;
906 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
907 EXPECT_EQ(count, 1u);
908 zet_metric_programmable_exp_handle_t programmable{};
909 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
910 zet_metric_programmable_param_value_exp_t parameterValue{};
911 parameterValue.value.ui32 = 20;
912 uint32_t metricHandleCount = 0;
913 const char metricName[ZET_MAX_METRIC_NAME] = "metricName";
914 const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription";
915 EXPECT_EQ(ZE_RESULT_SUCCESS,
916 MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr));
917 EXPECT_EQ(metricHandleCount, 1u);
918 zet_metric_handle_t metricHandle{};
919 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle));
920 size_t errorStringSize = 0;
921
922 uint32_t metricGroupCount = 0;
923 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
924 EXPECT_NE(metricGroupCount, 0u);
925 std::vector<zet_metric_group_handle_t> metricGroupHandles(metricGroupCount);
926 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data()));
927 EXPECT_GE(metricGroupCount, 2u);
928 zet_metric_group_handle_t metricGroupHandle = metricGroupHandles[1];
929
930 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle, &errorStringSize, nullptr));
931 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupCloseExp(metricGroupHandle));
932 deviceContext->activateMetricGroupsPreferDeferred(1, &metricGroupHandle);
933 deviceContext->activateMetricGroups();
934 EXPECT_EQ(ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle, &errorStringSize, nullptr));
935 EXPECT_EQ(ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE, zetMetricGroupRemoveMetricExp(metricGroupHandle, metricHandle));
936 EXPECT_EQ(ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE, zetMetricGroupDestroyExp(metricGroupHandle));
937
938 deviceContext->activateMetricGroupsPreferDeferred(0, nullptr);
939 for (auto destroyMetricGroupHandle : metricGroupHandles) {
940 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(destroyMetricGroupHandle));
941 }
942 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle));
943 metricEnumeration->cleanupExtendedMetricInformation();
944 }
945
946 TEST_F(OaMetricProgrammableTests, givenErrorDuingActivationOfMetricsTheActivationStatusIsNotChanged) {
947 MockIConcurrentGroup1x13 mockConcurrentGroup;
948 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
949 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
950
951 uint32_t count = 0;
952 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
953 EXPECT_EQ(count, 1u);
954 zet_metric_programmable_exp_handle_t programmable{};
955 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
956 zet_metric_programmable_param_value_exp_t parameterValue{};
957 parameterValue.value.ui32 = 20;
958 uint32_t metricHandleCount = 0;
959 const char metricName[ZET_MAX_METRIC_NAME] = "metricName";
960 const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription";
961 EXPECT_EQ(ZE_RESULT_SUCCESS,
962 MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr));
963 EXPECT_EQ(metricHandleCount, 1u);
964 zet_metric_handle_t metricHandle{};
965 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle));
966 size_t errorStringSize = 0;
967
968 uint32_t metricGroupCount = 0;
969 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
970 EXPECT_NE(metricGroupCount, 0u);
971 std::vector<zet_metric_group_handle_t> metricGroupHandles(metricGroupCount);
972 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data()));
973 EXPECT_GE(metricGroupCount, 2u);
974 zet_metric_group_handle_t metricGroupHandle = metricGroupHandles[0];
975
976 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle, &errorStringSize, nullptr));
977 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupCloseExp(metricGroupHandle));
978 deviceContext->activateMetricGroupsPreferDeferred(1, &metricGroupHandle);
979 deviceContext->activateMetricGroups();
980 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle, &errorStringSize, nullptr));
981 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupRemoveMetricExp(metricGroupHandle, metricHandle));
982 deviceContext->activateMetricGroupsPreferDeferred(0, nullptr);
983 for (auto destroyMetricGroupHandle : metricGroupHandles) {
984 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(destroyMetricGroupHandle));
985 }
986 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle));
987 metricEnumeration->cleanupExtendedMetricInformation();
988 }
989
990 TEST_F(OaMetricProgrammableTests, givenUserDefinedMetricGroupWhenAddingMetricsAndErrorIsObservedThenErrorStringIsUpdated) {
991 MockIConcurrentGroup1x13 mockConcurrentGroup;
992 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[0] = MetricsDiscovery::CC_OK;
993 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
994 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
995 uint32_t count = 0;
996 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
997 EXPECT_EQ(count, 1u);
998 zet_metric_programmable_exp_handle_t programmable{};
999 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
1000 zet_metric_programmable_param_value_exp_t parameterValue{};
1001 parameterValue.value.ui32 = 20;
1002 uint32_t metricHandleCount = 0;
1003 const char metricName[ZET_MAX_METRIC_NAME] = "metricName";
1004 const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription";
1005 EXPECT_EQ(ZE_RESULT_SUCCESS,
1006 MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr));
1007 EXPECT_EQ(metricHandleCount, 1u);
1008 zet_metric_handle_t metricHandle{};
1009 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle));
1010
1011 uint32_t metricGroupCount = 0;
1012 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
1013 EXPECT_NE(metricGroupCount, 0u);
1014 std::vector<zet_metric_group_handle_t> metricGroupHandles(metricGroupCount);
1015 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data()));
1016 EXPECT_NE(metricGroupCount, 0u);
1017 zet_metric_group_handle_t metricGroupHandle = metricGroupHandles[0];
1018
1019 zet_metric_handle_t metricHandle1{};
1020 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle1));
1021 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[0] = MetricsDiscovery::CC_ERROR_GENERAL;
1022 size_t errorStringSize = 0;
1023 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle1, &errorStringSize, nullptr));
1024 EXPECT_NE(errorStringSize, 0u);
1025 std::vector<char> errorString(errorStringSize);
1026 errorString[0] = '\0';
1027 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle1, &errorStringSize, errorString.data()));
1028 EXPECT_NE(errorString[0], '\0');
1029 for (auto destroyMetricGroupHandle : metricGroupHandles) {
1030 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(destroyMetricGroupHandle));
1031 }
1032 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle));
1033 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle1));
1034 metricEnumeration->cleanupExtendedMetricInformation();
1035 MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet);
1036 }
1037
1038 TEST_F(OaMetricProgrammableTests, givenUserDefinedMetricGroupWhenCreatingWithMetricIfErrorIsEncounteredThenErrorIsReturned) {
1039 MockIConcurrentGroup1x13 mockConcurrentGroup;
1040 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[0] = MetricsDiscovery::CC_ERROR_GENERAL;
1041 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
1042 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
1043 uint32_t count = 0;
1044 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
1045 EXPECT_EQ(count, 1u);
1046 zet_metric_programmable_exp_handle_t programmable{};
1047 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
1048 zet_metric_programmable_param_value_exp_t parameterValue{};
1049 parameterValue.value.ui32 = 20;
1050 uint32_t metricHandleCount = 0;
1051 const char metricName[ZET_MAX_METRIC_NAME] = "metricName";
1052 const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription";
1053 EXPECT_EQ(ZE_RESULT_SUCCESS,
1054 MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr));
1055 EXPECT_EQ(metricHandleCount, 1u);
1056 zet_metric_handle_t metricHandle{};
1057 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle));
1058
1059 uint32_t metricGroupCount = 0;
1060 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
1061 EXPECT_NE(metricGroupCount, 0u);
1062 std::vector<zet_metric_group_handle_t> metricGroupHandles(metricGroupCount);
1063 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data()));
1064 EXPECT_EQ(metricGroupCount, 0u);
1065
1066 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle));
1067 metricEnumeration->cleanupExtendedMetricInformation();
1068 MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet);
1069 }
1070
1071 TEST_F(OaMetricProgrammableTests, givenUserDefinedMetricGroupWhenAddingMetricsWithIncompatibleSamplingTypeThenErrorIsObserved) {
1072 MockIConcurrentGroup1x13 mockConcurrentGroup;
1073 mockConcurrentGroup.mockMetricEnumerator.metricProtoTypeReturn[0].mockParams.ApiMask = MetricsDiscovery::API_TYPE_OCL | MetricsDiscovery::API_TYPE_OGL4_X;
1074 // Create Metric Handle 2 with different sampling type
1075 mockConcurrentGroup.mockMetricEnumerator.metricProtoTypeReturn[1].mockParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM;
1076 mockConcurrentGroup.mockMetricEnumerator.getMetricPrototypeCountReturn = 2;
1077 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
1078 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
1079 uint32_t count = 0;
1080 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
1081 ASSERT_EQ(count, 2u);
1082 std::vector<zet_metric_programmable_exp_handle_t> programmables(count);
1083 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, programmables.data()));
1084 zet_metric_programmable_param_value_exp_t parameterValue{};
1085 parameterValue.value.ui32 = 20;
1086 uint32_t metricHandleCount = 0;
1087 const char metricName[ZET_MAX_METRIC_NAME] = "metricName";
1088 const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription";
1089 EXPECT_EQ(ZE_RESULT_SUCCESS,
1090 MetricProgrammable::fromHandle(programmables[0])->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr));
1091 EXPECT_EQ(metricHandleCount, 1u);
1092 zet_metric_handle_t metricHandle1{};
1093 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmables[0])->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle1));
1094
1095 metricHandleCount = 0;
1096 EXPECT_EQ(ZE_RESULT_SUCCESS,
1097 MetricProgrammable::fromHandle(programmables[1])->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr));
1098 EXPECT_EQ(metricHandleCount, 1u);
1099 zet_metric_handle_t metricHandle2{};
1100 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmables[1])->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle2));
1101
1102 uint32_t metricGroupCount = 0;
1103 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle1, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
1104 EXPECT_NE(metricGroupCount, 0u);
1105 std::vector<zet_metric_group_handle_t> metricGroupHandles(metricGroupCount);
1106 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle1, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data()));
1107 EXPECT_EQ(metricGroupCount, 1u);
1108 size_t errorStringSize = 0;
1109 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetMetricGroupAddMetricExp(metricGroupHandles[0], metricHandle2, &errorStringSize, nullptr));
1110 EXPECT_NE(errorStringSize, 0u);
1111
1112 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroupHandles[0]));
1113 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle1));
1114 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle2));
1115 metricEnumeration->cleanupExtendedMetricInformation();
1116 }
1117
1118 TEST_F(OaMetricProgrammableTests, givenValidMetricGroupWhenAddingOrRemovingPreDefinedMetricsThenErrorIsReturned) {
1119 MockIConcurrentGroup1x13 mockConcurrentGroup;
1120 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
1121 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
1122
1123 uint32_t count = 0;
1124 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
1125 EXPECT_EQ(count, 1u);
1126 zet_metric_programmable_exp_handle_t programmable{};
1127 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
1128 zet_metric_programmable_param_value_exp_t parameterValue{};
1129 parameterValue.value.ui32 = 20;
1130 uint32_t metricHandleCount = 0;
1131 const char metricName[ZET_MAX_METRIC_NAME] = "metricName";
1132 const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription";
1133 EXPECT_EQ(ZE_RESULT_SUCCESS,
1134 MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr));
1135 EXPECT_EQ(metricHandleCount, 1u);
1136 zet_metric_handle_t metricHandle{};
1137 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle));
1138 size_t errorStringSize = 0;
1139 zet_metric_group_handle_t metricGroupHandle = nullptr;
1140
1141 uint32_t metricGroupCount = 0;
1142 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
1143 EXPECT_NE(metricGroupCount, 0u);
1144 std::vector<zet_metric_group_handle_t> metricGroupHandles(metricGroupCount);
1145 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data()));
1146 EXPECT_GE(metricGroupCount, 2u);
1147 // Access the query sampling type group
1148 metricGroupHandle = metricGroupHandles[1];
1149
1150 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle, &errorStringSize, nullptr));
1151 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupCloseExp(metricGroupHandle));
1152
1153 uint32_t metricCount = 0;
1154
1155 EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, nullptr), ZE_RESULT_SUCCESS);
1156 std::vector<zet_metric_handle_t> metricHandles(metricCount);
1157 EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, metricHandles.data()), ZE_RESULT_SUCCESS);
1158
1159 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandles[0], &errorStringSize, nullptr));
1160 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetMetricGroupRemoveMetricExp(metricGroupHandle, metricHandles[0]));
1161
1162 for (auto destroyMetricGroupHandle : metricGroupHandles) {
1163 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(destroyMetricGroupHandle));
1164 }
1165 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle));
1166 metricEnumeration->cleanupExtendedMetricInformation();
1167 }
1168
1169 TEST_F(OaMetricProgrammableTests, givenValidMetricGroupWhenAddingOrRemovingMetricsFromIncorrectSourceThenErrorIsReturned) {
1170 MockIConcurrentGroup1x13 mockConcurrentGroup;
1171 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
1172 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
1173
1174 uint32_t count = 0;
1175 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
1176 EXPECT_EQ(count, 1u);
1177 zet_metric_programmable_exp_handle_t programmable{};
1178 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
1179 zet_metric_programmable_param_value_exp_t parameterValue{};
1180 parameterValue.value.ui32 = 20;
1181 uint32_t metricHandleCount = 0;
1182 const char metricName[ZET_MAX_METRIC_NAME] = "metricName";
1183 const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription";
1184 EXPECT_EQ(ZE_RESULT_SUCCESS,
1185 MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr));
1186 EXPECT_EQ(metricHandleCount, 1u);
1187 zet_metric_handle_t metricHandle{};
1188 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle));
1189 size_t errorStringSize = 0;
1190 zet_metric_group_handle_t metricGroupHandle = nullptr;
1191
1192 uint32_t metricGroupCount = 0;
1193 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
1194 EXPECT_NE(metricGroupCount, 0u);
1195 std::vector<zet_metric_group_handle_t> metricGroupHandles(metricGroupCount);
1196 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data()));
1197 EXPECT_GE(metricGroupCount, 2u);
1198
1199 metricGroupHandle = metricGroupHandles[1];
1200
1201 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle, &errorStringSize, nullptr));
1202 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupCloseExp(metricGroupHandle));
1203
1204 MockMetricSource mockMetricSource{};
1205 mockMetricSource.isAvailableReturn = true;
1206 MockMetric mockMetric(mockMetricSource, mockMetricScopes);
1207 auto metricHandleIncorrectSource = mockMetric.toHandle();
1208
1209 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandleIncorrectSource, &errorStringSize, nullptr));
1210 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetMetricGroupRemoveMetricExp(metricGroupHandle, metricHandleIncorrectSource));
1211
1212 for (auto destroyMetricGroupHandle : metricGroupHandles) {
1213 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(destroyMetricGroupHandle));
1214 }
1215 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle));
1216 metricEnumeration->cleanupExtendedMetricInformation();
1217 }
1218
1219 TEST_F(OaMetricProgrammableTests, givenValidMetricGroupWhenMetricSetOpenFailsWhenAddingOrRemovingMetricsThenErrorIsReturned) {
1220 MockIConcurrentGroup1x13 mockConcurrentGroup;
1221 mockConcurrentGroup.mockMetricSet.mockApiMask = MetricsDiscovery::API_TYPE_VULKAN;
1222 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
1223 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
1224
1225 MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet);
1226 mockConcurrentGroup.mockMetricSet.mockOpenReturnCodeList.resize(2);
1227 mockConcurrentGroup.mockMetricSet.mockOpenReturnCodeList[0] = MetricsDiscovery::CC_OK;
1228 mockConcurrentGroup.mockMetricSet.mockOpenReturnCodeList[1] = MetricsDiscovery::CC_ERROR_NO_MEMORY;
1229
1230 uint32_t count = 0;
1231 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
1232 EXPECT_EQ(count, 1u);
1233 zet_metric_programmable_exp_handle_t programmable{};
1234 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
1235 zet_metric_programmable_param_info_exp_t parameterInfo{};
1236 uint32_t parameterCount = 1;
1237 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetParamInfoExp(programmable, &parameterCount, &parameterInfo));
1238 uint32_t valueInfoCount = 1;
1239 zet_metric_programmable_param_value_info_exp_t paramValueInfo{};
1240 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetParamValueInfoExp(programmable, 0, &valueInfoCount, &paramValueInfo));
1241 zet_metric_programmable_exp_properties_t properties{};
1242 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetPropertiesExp(programmable, &properties));
1243 zet_metric_programmable_param_value_exp_t parameterValue{};
1244 parameterValue.value.ui32 = 20;
1245 uint32_t metricHandleCount = 0;
1246 const char metricName[ZET_MAX_METRIC_NAME] = "metricName";
1247 const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription";
1248 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 1, &parameterValue, metricName, metricDescription, &metricHandleCount, nullptr));
1249 EXPECT_EQ(metricHandleCount, 1u);
1250 zet_metric_handle_t metricHandle1{};
1251 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 1, &parameterValue, metricName, metricDescription, &metricHandleCount, &metricHandle1));
1252 zet_metric_handle_t metricHandle2{};
1253 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 1, &parameterValue, metricName, metricDescription, &metricHandleCount, &metricHandle2));
1254
1255 zet_metric_handle_t metricHandles[] = {metricHandle1, metricHandle2};
1256
1257 uint32_t metricGroupCount = 0;
1258 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, metricHandles, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
1259 EXPECT_EQ(metricGroupCount, 2u);
1260 zet_metric_group_handle_t metricGroupHandle{};
1261 metricGroupCount = 1;
1262 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, metricHandles, "metricGroupName", "metricGroupDesc", &metricGroupCount, &metricGroupHandle));
1263 EXPECT_EQ(metricGroupCount, 1u);
1264 size_t errorStringSize = 0;
1265 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandles[1], &errorStringSize, nullptr));
1266 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, zetMetricGroupRemoveMetricExp(metricGroupHandle, metricHandles[0]));
1267 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroupHandle));
1268 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle1));
1269 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle2));
1270 metricEnumeration->cleanupExtendedMetricInformation();
1271 MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet);
1272 }
1273
1274 TEST_F(OaMetricProgrammableTests, givenValidMetricGroupWhenMetricGroupActivationReturnsFalseThenSuccessIsReturned) {
1275 MockIConcurrentGroup1x13 mockConcurrentGroup;
1276 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
1277 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
1278
1279 uint32_t count = 0;
1280 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
1281 EXPECT_EQ(count, 1u);
1282 zet_metric_programmable_exp_handle_t programmable{};
1283 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
1284 zet_metric_programmable_param_value_exp_t parameterValue{};
1285 parameterValue.value.ui32 = 20;
1286 uint32_t metricHandleCount = 0;
1287 const char metricName[ZET_MAX_METRIC_NAME] = "metricName";
1288 const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription";
1289 EXPECT_EQ(ZE_RESULT_SUCCESS,
1290 MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr));
1291 EXPECT_EQ(metricHandleCount, 1u);
1292 zet_metric_handle_t metricHandle{};
1293 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle));
1294 size_t errorStringSize = 0;
1295 zet_metric_group_handle_t metricGroupHandle = nullptr;
1296
1297 uint32_t metricGroupCount = 0;
1298 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
1299 EXPECT_NE(metricGroupCount, 0u);
1300 std::vector<zet_metric_group_handle_t> metricGroupHandles(metricGroupCount);
1301 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data()));
1302 EXPECT_EQ(metricGroupCount, 2u);
1303 metricGroupHandle = metricGroupHandles[1];
1304
1305 mockConcurrentGroup.mockMetricSet.mockApiMask = MetricsDiscovery::API_TYPE_VULKAN;
1306 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle, &errorStringSize, nullptr));
1307 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupCloseExp(metricGroupHandle));
1308 deviceContext->activateMetricGroupsPreferDeferred(1, &metricGroupHandle);
1309 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->activateMetricGroups());
1310
1311 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroupHandles[0]));
1312 deviceContext->activateMetricGroupsPreferDeferred(0, nullptr);
1313 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroupHandles[1]));
1314 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle));
1315 metricEnumeration->cleanupExtendedMetricInformation();
1316 MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet);
1317 }
1318
1319 TEST_F(OaMetricProgrammableTests, givenValidMetricGroupWhenDelayedActivatingMetricGroupBeforeCloseThenSuccessIsReturned) {
1320 MockIConcurrentGroup1x13 mockConcurrentGroup;
1321 mockConcurrentGroup.mockMetricSet.mockApiMask = MetricsDiscovery::API_TYPE_VULKAN;
1322 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
1323 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
1324
1325 uint32_t count = 0;
1326 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
1327 EXPECT_EQ(count, 1u);
1328 zet_metric_programmable_exp_handle_t programmable{};
1329 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
1330 zet_metric_programmable_param_info_exp_t parameterInfo{};
1331 uint32_t parameterCount = 1;
1332 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetParamInfoExp(programmable, &parameterCount, &parameterInfo));
1333 uint32_t valueInfoCount = 1;
1334 zet_metric_programmable_param_value_info_exp_t paramValueInfo{};
1335 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetParamValueInfoExp(programmable, 0, &valueInfoCount, &paramValueInfo));
1336 zet_metric_programmable_exp_properties_t properties{};
1337 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetPropertiesExp(programmable, &properties));
1338 zet_metric_programmable_param_value_exp_t parameterValue{};
1339 parameterValue.value.ui32 = 20;
1340 uint32_t metricHandleCount = 0;
1341 const char metricName[ZET_MAX_METRIC_NAME] = "metricName";
1342 const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription";
1343 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 1, &parameterValue, metricName, metricDescription, &metricHandleCount, nullptr));
1344 EXPECT_EQ(metricHandleCount, 1u);
1345 zet_metric_handle_t metricHandle{};
1346 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 1, &parameterValue, metricName, metricDescription, &metricHandleCount, &metricHandle));
1347 zet_metric_handle_t metricHandle1{};
1348 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 1, &parameterValue, metricName, metricDescription, &metricHandleCount, &metricHandle1));
1349 zet_metric_group_handle_t metricGroupHandle = nullptr;
1350
1351 uint32_t metricGroupCount = 0;
1352 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
1353 EXPECT_NE(metricGroupCount, 0u);
1354 std::vector<zet_metric_group_handle_t> metricGroupHandles(metricGroupCount);
1355 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data()));
1356 EXPECT_EQ(metricGroupCount, 2u);
1357 metricGroupHandle = metricGroupHandles[1];
1358
1359 size_t errorStringSize = 0;
1360 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle1, &errorStringSize, nullptr));
1361 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->activateMetricGroupsPreferDeferred(1, &metricGroupHandle));
1362 deviceContext->activateMetricGroups();
1363 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupCloseExp(metricGroupHandle));
1364 deviceContext->activateMetricGroupsPreferDeferred(0, nullptr);
1365 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->activateMetricGroups());
1366 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupCloseExp(metricGroupHandle));
1367 for (auto destroyMetricGroupHandle : metricGroupHandles) {
1368 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(destroyMetricGroupHandle));
1369 }
1370 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle1));
1371 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle));
1372 metricEnumeration->cleanupExtendedMetricInformation();
1373 MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet);
1374 }
1375
1376 TEST_F(OaMetricProgrammableTests, givenValidProgrammableWhenCreatingProgrammableWithUnknownMdapiValueTypeThenErrorIsReturned) {
1377 MockIConcurrentGroup1x13 mockConcurrentGroup;
1378 mockConcurrentGroup.mockMetricSet.mockApiMask = MetricsDiscovery::API_TYPE_VULKAN;
1379 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
1380 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
1381
1382 uint32_t count = 0;
1383 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
1384 EXPECT_EQ(count, 1u);
1385 zet_metric_programmable_exp_handle_t programmable{};
1386 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
1387 zet_metric_programmable_param_info_exp_t parameterInfo{};
1388 uint32_t parameterCount = 1;
1389 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetParamInfoExp(programmable, &parameterCount, &parameterInfo));
1390 uint32_t valueInfoCount = 1;
1391 zet_metric_programmable_param_value_info_exp_t paramValueInfo{};
1392 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetParamValueInfoExp(programmable, 0, &valueInfoCount, &paramValueInfo));
1393 zet_metric_programmable_exp_properties_t properties{};
1394 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetPropertiesExp(programmable, &properties));
1395 zet_metric_programmable_param_value_exp_t parameterValue{};
1396 parameterValue.value.ui32 = 20;
1397 uint32_t metricHandleCount = 0;
1398 const char metricName[ZET_MAX_METRIC_NAME] = "metricName";
1399 const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription";
1400 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 1, &parameterValue, metricName, metricDescription, &metricHandleCount, nullptr));
1401 EXPECT_EQ(metricHandleCount, 1u);
1402 zet_metric_handle_t metricHandle{};
1403
1404 mockConcurrentGroup.metricEnumeratorReturn->metricProtoTypeReturn[0].mockOptionDescriptors[0].ValidValues->ValueType = MetricsDiscovery::VALUE_TYPE_LAST;
1405 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, zetMetricCreateFromProgrammableExp2(programmable, 1, &parameterValue, metricName, metricDescription, &metricHandleCount, &metricHandle));
1406 mockConcurrentGroup.metricEnumeratorReturn->metricProtoTypeReturn[0].mockOptionDescriptors[0].ValidValues->ValueType = MetricsDiscovery::VALUE_TYPE_UINT32;
1407
1408 metricEnumeration->cleanupExtendedMetricInformation();
1409 MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet);
1410 }
1411
1412 TEST_F(OaMetricProgrammableTests, givenValidMetricGroupWhenCreatingLessThanAvailableMetricGroupsThenCorrectMetricGroupIsReturned) {
1413 MockIConcurrentGroup1x13 mockConcurrentGroup;
1414 mockConcurrentGroup.mockMetricSet.mockApiMask = MetricsDiscovery::API_TYPE_VULKAN;
1415 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
1416 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
1417
1418 MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet);
1419 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList.resize(2);
1420 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[0] = MetricsDiscovery::CC_OK;
1421 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[1] = MetricsDiscovery::CC_ERROR_NO_MEMORY;
1422
1423 uint32_t count = 0;
1424 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
1425 EXPECT_EQ(count, 1u);
1426 zet_metric_programmable_exp_handle_t programmable{};
1427 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
1428 zet_metric_programmable_param_info_exp_t parameterInfo{};
1429 uint32_t parameterCount = 1;
1430 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetParamInfoExp(programmable, &parameterCount, &parameterInfo));
1431 uint32_t valueInfoCount = 1;
1432 zet_metric_programmable_param_value_info_exp_t paramValueInfo{};
1433 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetParamValueInfoExp(programmable, 0, &valueInfoCount, &paramValueInfo));
1434 zet_metric_programmable_exp_properties_t properties{};
1435 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetPropertiesExp(programmable, &properties));
1436 zet_metric_programmable_param_value_exp_t parameterValue{};
1437 parameterValue.value.ui32 = 20;
1438 uint32_t metricHandleCount = 0;
1439 const char metricName[ZET_MAX_METRIC_NAME] = "metricName";
1440 const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription";
1441 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 1, &parameterValue, metricName, metricDescription, &metricHandleCount, nullptr));
1442 EXPECT_EQ(metricHandleCount, 1u);
1443 zet_metric_handle_t metricHandle1{};
1444 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 1, &parameterValue, metricName, metricDescription, &metricHandleCount, &metricHandle1));
1445 zet_metric_handle_t metricHandle2{};
1446 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp2(programmable, 1, &parameterValue, metricName, metricDescription, &metricHandleCount, &metricHandle2));
1447
1448 zet_metric_handle_t metricHandles[] = {metricHandle1, metricHandle2};
1449
1450 uint32_t metricGroupCount = 0;
1451 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(2, metricHandles, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
1452 EXPECT_EQ(metricGroupCount, 4u);
1453 zet_metric_group_handle_t metricGroupHandle{};
1454 metricGroupCount = 1;
1455 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(2, metricHandles, "metricGroupName", "metricGroupDesc", &metricGroupCount, &metricGroupHandle));
1456 EXPECT_EQ(metricGroupCount, 1u);
1457 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroupHandle));
1458 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle1));
1459 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle2));
1460 metricEnumeration->cleanupExtendedMetricInformation();
1461 MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet);
1462 }
1463
1464 TEST_F(OaMetricProgrammableTests, givenEnableProgrammableMetricsSupportIsNotSetWhenMetricGroupCreateIsCalledThenErrorIsReturned) {
1465
1466 DebugManagerStateRestore restorer;
1467 debugManager.flags.DisableProgrammableMetricsSupport.set(1);
1468 auto deviceContextTest = std::make_unique<MetricDeviceContext>(*device);
1469
1470 uint32_t metricGroupCount = 0;
1471 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, deviceContextTest->createMetricGroupsFromMetrics(0, nullptr, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
1472 EXPECT_EQ(metricGroupCount, 0u);
1473 }
1474
1475 TEST_F(OaMetricProgrammableTests, givenCreateMetricGroupsFromMetricsWhenUnembargoedMetricSourceIsUsedThenSuccessIsReturned) {
1476 MockMetricSource mockMetricSource{};
1477 mockMetricSource.isAvailableReturn = true;
1478 MockMetric mockMetric(mockMetricSource, mockMetricScopes);
1479 mockMetric.setPredefined(false);
1480
1481 uint32_t metricGroupCount = 0;
1482 auto metricHandle = mockMetric.toHandle();
1483 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
1484 EXPECT_EQ(metricGroupCount, 0u);
1485
1486 metricEnumeration->cleanupExtendedMetricInformation();
1487 }
1488
1489 TEST_F(OaMetricProgrammableTests, givenCreateMetricGroupsFromMetricsWhenMultipleMetricsCouldBeAddedToMultipleGroupsThenCorrectGroupCountIsReturned) {
1490
1491 MockIConcurrentGroup1x13 mockConcurrentGroup;
1492 mockConcurrentGroup.mockMetricEnumerator.metricProtoTypeReturn[0].mockParams.ApiMask = MetricsDiscovery::API_TYPE_OCL | MetricsDiscovery::API_TYPE_OGL4_X;
1493 // Create Metric Handle 2 with different sampling type
1494 mockConcurrentGroup.mockMetricEnumerator.metricProtoTypeReturn[1].mockParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM;
1495 mockConcurrentGroup.mockMetricEnumerator.getMetricPrototypeCountReturn = 2;
1496 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
1497 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
1498 uint32_t count = 0;
1499 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
1500 EXPECT_EQ(count, 2u);
1501 std::vector<zet_metric_programmable_exp_handle_t> programmables(2);
1502 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, programmables.data()));
1503 zet_metric_programmable_param_value_exp_t parameterValue{};
1504 parameterValue.value.ui32 = 20;
1505 uint32_t metricHandleCount = 0;
1506 const char metricName[ZET_MAX_METRIC_NAME] = "metricName";
1507 const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription";
1508 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmables[0])->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr));
1509 EXPECT_EQ(metricHandleCount, 1u);
1510 metricHandleCount = 0;
1511 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmables[1])->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr));
1512 EXPECT_EQ(metricHandleCount, 1u);
1513 zet_metric_handle_t metricHandle1{}, metricHandle2{};
1514 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmables[0])->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle1));
1515 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmables[1])->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle2));
1516
1517 uint32_t metricGroupCount = 0;
1518 zet_metric_handle_t metricHandles[] = {metricHandle1, metricHandle2};
1519 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(2, metricHandles, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
1520 EXPECT_NE(metricGroupCount, 0u);
1521 std::vector<zet_metric_group_handle_t> metricGroupHandles(metricGroupCount);
1522 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(2, metricHandles, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data()));
1523 EXPECT_EQ(metricGroupCount, 2u);
1524 metricGroupHandles.resize(metricGroupCount);
1525
1526 for (auto &metricGroupHandle : metricGroupHandles) {
1527 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroupHandle));
1528 }
1529 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle1));
1530 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle2));
1531 metricEnumeration->cleanupExtendedMetricInformation();
1532 }
1533
1534 TEST_F(OaMetricProgrammableTests, givenCreateMetricGroupsFromMetricsWhenFailureOccursDuringMetricGroupCreationFromMultipleMetricsThenFailureIsReturned) {
1535
1536 MockIConcurrentGroup1x13 mockConcurrentGroup;
1537
1538 MockIMetricSet1x13::addMetricCallCount = 0;
1539 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList.resize(4);
1540 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[0] = MetricsDiscovery::CC_OK;
1541 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[1] = MetricsDiscovery::CC_OK;
1542 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[2] = MetricsDiscovery::CC_OK;
1543 mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[3] = MetricsDiscovery::CC_ERROR_GENERAL;
1544
1545 mockConcurrentGroup.mockMetricEnumerator.metricProtoTypeReturn[0].mockParams.ApiMask = MetricsDiscovery::API_TYPE_OCL | MetricsDiscovery::API_TYPE_OGL4_X;
1546 // Create Metric Handle 2 with different sampling type
1547 mockConcurrentGroup.mockMetricEnumerator.metricProtoTypeReturn[1].mockParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM;
1548 mockConcurrentGroup.mockMetricEnumerator.getMetricPrototypeCountReturn = 2;
1549 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
1550 EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
1551 uint32_t count = 0;
1552 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
1553 EXPECT_EQ(count, 2u);
1554 std::vector<zet_metric_programmable_exp_handle_t> programmables(2);
1555 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, programmables.data()));
1556 zet_metric_programmable_param_value_exp_t parameterValue{};
1557 parameterValue.value.ui32 = 20;
1558 uint32_t metricHandleCount = 0;
1559 const char metricName[ZET_MAX_METRIC_NAME] = "metricName";
1560 const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription";
1561 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmables[0])->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr));
1562 EXPECT_EQ(metricHandleCount, 1u);
1563 metricHandleCount = 0;
1564 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmables[1])->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr));
1565 EXPECT_EQ(metricHandleCount, 1u);
1566 zet_metric_handle_t metricHandle1{}, metricHandle2{}, metricHandle3{}, metricHandle4;
1567 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmables[0])->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle1));
1568 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmables[0])->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle2));
1569 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmables[1])->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle3));
1570 EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmables[1])->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle4));
1571
1572 uint32_t metricGroupCount = 0;
1573 zet_metric_handle_t metricHandles[] = {metricHandle1, metricHandle2, metricHandle3, metricHandle4};
1574 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(4, metricHandles, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
1575 EXPECT_NE(metricGroupCount, 0u);
1576 std::vector<zet_metric_group_handle_t> metricGroupHandles(metricGroupCount);
1577 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, deviceContext->createMetricGroupsFromMetrics(4, metricHandles, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data()));
1578 EXPECT_EQ(metricGroupCount, 0u);
1579
1580 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle1));
1581 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle2));
1582 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle3));
1583 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle4));
1584 metricEnumeration->cleanupExtendedMetricInformation();
1585
1586 MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet);
1587 }
1588
1589 class MultiSourceOaMetricProgrammableFixture : public DeviceFixture,
1590 public ::testing::Test {
1591 protected:
1592 void SetUp() override;
1593 void TearDown() override;
1594 std::unique_ptr<MockMetricDeviceContextIpSampling> deviceContext = nullptr;
1595 OaMetricSourceImp *oaMetricSource = nullptr;
1596 MetricEnumeration *metricEnumeration = nullptr;
1597 MockIAdapterGroup1x13 mockAdapterGroup{};
1598 MockMetricIpSamplingSource *metricSource = nullptr;
1599 MockMetricScope *mockMetricScope = nullptr;
1600 std::vector<MetricScopeImp *> mockMetricScopes{};
1601 };
1602
1603 void MultiSourceOaMetricProgrammableFixture::TearDown() {
1604 DeviceFixture::tearDown();
1605 deviceContext.reset();
1606 delete mockMetricScope;
1607 mockMetricScope = nullptr;
1608 mockMetricScopes.clear();
1609 }
1610
1611 void MultiSourceOaMetricProgrammableFixture::SetUp() {
1612 DeviceFixture::setUp();
1613
1614 mockAdapterGroup.mockParams.Version.MajorNumber = 1;
1615 mockAdapterGroup.mockParams.Version.MinorNumber = 13;
1616 deviceContext = std::make_unique<MockMetricDeviceContextIpSampling>(*device);
1617 oaMetricSource = static_cast<OaMetricSourceImp *>(&deviceContext->getMetricSource<OaMetricSourceImp>());
1618 metricEnumeration = static_cast<MetricEnumeration *>(&oaMetricSource->getMetricEnumeration());
1619 metricEnumeration->setAdapterGroup(&mockAdapterGroup);
1620
1621 oaMetricSource->setInitializationState(ZE_RESULT_SUCCESS);
1622 metricEnumeration->setInitializationState(ZE_RESULT_SUCCESS);
1623
1624 metricSource = new MockMetricIpSamplingSource(*deviceContext);
1625 deviceContext->setMetricIpSamplingSource(metricSource);
1626 zet_intel_metric_scope_properties_exp_t scopeProperties{};
1627 scopeProperties.stype = ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP;
1628 scopeProperties.pNext = nullptr;
1629 mockMetricScope = new MockMetricScope(scopeProperties, false, 0);
1630 mockMetricScopes.push_back(mockMetricScope);
1631 }
1632
1633 TEST_F(MultiSourceOaMetricProgrammableFixture, givenCreateMetricGroupsFromMetricsIsCalledAndOneMetricSourcesReturnsUnsupportedThenSuccessIsReturned) {
1634 MockIConcurrentGroup1x13 mockConcurrentGroup;
1635 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
1636 ASSERT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
1637 uint32_t count = 0;
1638 ASSERT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
1639 ASSERT_EQ(count, 1u);
1640 zet_metric_programmable_exp_handle_t programmable{};
1641 ASSERT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
1642 zet_metric_programmable_param_value_exp_t parameterValue{};
1643 parameterValue.value.ui32 = 20;
1644 uint32_t metricHandleCount = 0;
1645 const char metricName[ZET_MAX_METRIC_NAME] = "metricName";
1646 const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription";
1647 ASSERT_EQ(ZE_RESULT_SUCCESS,
1648 MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr));
1649 ASSERT_EQ(metricHandleCount, 1u);
1650 zet_metric_handle_t metricHandle{};
1651 ASSERT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle));
1652
1653 MockMetricIpSamplingSource mockMetricTraceSource(*deviceContext);
1654 MockMetric mockMetric(mockMetricTraceSource, mockMetricScopes);
1655 mockMetric.setPredefined(false);
1656
1657 zet_metric_handle_t metricHandles[] = {metricHandle, mockMetric.toHandle()};
1658
1659 uint32_t metricGroupCount = 0;
1660 ASSERT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(2, metricHandles, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
1661 ASSERT_NE(metricGroupCount, 0u);
1662 std::vector<zet_metric_group_handle_t> metricGroupHandles(metricGroupCount);
1663 ASSERT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(2, metricHandles, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data()));
1664 ASSERT_NE(metricGroupCount, 0u);
1665 zet_metric_group_handle_t metricGroupHandle = metricGroupHandles[0];
1666
1667 ASSERT_NE(metricGroupHandle, nullptr);
1668
1669 for (auto destroyMetricGroupHandle : metricGroupHandles) {
1670 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(destroyMetricGroupHandle));
1671 }
1672 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle));
1673 metricEnumeration->cleanupExtendedMetricInformation();
1674 }
1675
1676 TEST_F(MultiSourceOaMetricProgrammableFixture, givenCreateMetricGroupsFromMetricsIsCalledAndOneMetricSourcesFailsThenFailureIsReturned) {
1677 MockIConcurrentGroup1x13 mockConcurrentGroup;
1678 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
1679 ASSERT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
1680 uint32_t count = 0;
1681 ASSERT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
1682 ASSERT_EQ(count, 1u);
1683 zet_metric_programmable_exp_handle_t programmable{};
1684 ASSERT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
1685 zet_metric_programmable_param_value_exp_t parameterValue{};
1686 parameterValue.value.ui32 = 20;
1687 uint32_t metricHandleCount = 0;
1688 const char metricName[ZET_MAX_METRIC_NAME] = "metricName";
1689 const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription";
1690 ASSERT_EQ(ZE_RESULT_SUCCESS,
1691 MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr));
1692 ASSERT_EQ(metricHandleCount, 1u);
1693 zet_metric_handle_t metricHandle{};
1694 ASSERT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle));
1695
1696 MockMetricIpSamplingSource &mockMetricTraceSource = static_cast<MockMetricIpSamplingSource &>(deviceContext->getMetricSource<IpSamplingMetricSourceImp>());
1697 MockMetric mockMetric(mockMetricTraceSource, mockMetricScopes);
1698 mockMetric.setPredefined(false);
1699
1700 zet_metric_handle_t metricHandles[] = {metricHandle, mockMetric.toHandle()};
1701 uint32_t metricGroupCount = 0;
1702 EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(2, metricHandles, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
1703 ASSERT_NE(metricGroupCount, 0u);
1704 // Allocate more space for the mockMetricTraceSource
1705 metricGroupCount += 1;
1706 std::vector<zet_metric_group_handle_t> metricGroupHandles(metricGroupCount);
1707 mockMetricTraceSource.createMetricGroupsFromMetricsReturn = ZE_RESULT_ERROR_INVALID_ARGUMENT;
1708 ASSERT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, deviceContext->createMetricGroupsFromMetrics(2, metricHandles, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data()));
1709 ASSERT_EQ(metricGroupCount, 0u);
1710 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle));
1711 metricEnumeration->cleanupExtendedMetricInformation();
1712 }
1713
1714 TEST_F(MultiSourceOaMetricProgrammableFixture, givenMetricProgrammableGetReturnsFailureForOneOfTheSourcesThenApiReturnsFailure) {
1715 MockIConcurrentGroup1x13 mockConcurrentGroup;
1716 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
1717 ASSERT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
1718 uint32_t count = 0;
1719 ASSERT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
1720 ASSERT_EQ(count, 1u);
1721 zet_metric_programmable_exp_handle_t programmable{};
1722 MockMetricIpSamplingSource &mockMetricTraceSource = static_cast<MockMetricIpSamplingSource &>(deviceContext->getMetricSource<IpSamplingMetricSourceImp>());
1723 mockMetricTraceSource.metricProgrammableGetReturn = ZE_RESULT_ERROR_UNKNOWN;
1724 count += 1;
1725 ASSERT_EQ(ZE_RESULT_ERROR_UNKNOWN, deviceContext->metricProgrammableGet(&count, &programmable));
1726 metricEnumeration->cleanupExtendedMetricInformation();
1727 }
1728
1729 TEST_F(MultiSourceOaMetricProgrammableFixture, givenCreateMetricGroupsFromMetricsIsCalledAndOneMetricSourcesFailsDuringCountCalculationThenFailureIsReturned) {
1730 MockIConcurrentGroup1x13 mockConcurrentGroup;
1731 MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup;
1732 ASSERT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
1733 uint32_t count = 0;
1734 ASSERT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr));
1735 ASSERT_EQ(count, 1u);
1736 zet_metric_programmable_exp_handle_t programmable{};
1737 ASSERT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable));
1738 zet_metric_programmable_param_value_exp_t parameterValue{};
1739 parameterValue.value.ui32 = 20;
1740 uint32_t metricHandleCount = 0;
1741 const char metricName[ZET_MAX_METRIC_NAME] = "metricName";
1742 const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription";
1743 ASSERT_EQ(ZE_RESULT_SUCCESS,
1744 MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr));
1745 ASSERT_EQ(metricHandleCount, 1u);
1746 zet_metric_handle_t metricHandle{};
1747 ASSERT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(&parameterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle));
1748
1749 MockMetricIpSamplingSource &mockMetricTraceSource = static_cast<MockMetricIpSamplingSource &>(deviceContext->getMetricSource<IpSamplingMetricSourceImp>());
1750 MockMetric mockMetric(mockMetricTraceSource, mockMetricScopes);
1751 mockMetric.setPredefined(false);
1752
1753 zet_metric_handle_t metricHandles[] = {metricHandle, mockMetric.toHandle()};
1754 uint32_t metricGroupCount = 0;
1755 mockMetricTraceSource.createMetricGroupsFromMetricsReturn = ZE_RESULT_ERROR_INVALID_ARGUMENT;
1756 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, deviceContext->createMetricGroupsFromMetrics(2, metricHandles, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr));
1757 EXPECT_EQ(metricGroupCount, 0u);
1758 EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle));
1759 metricEnumeration->cleanupExtendedMetricInformation();
1760 mockMetricTraceSource.createMetricGroupsFromMetricsReturn = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
1761 }
1762
1763 } // namespace ult
1764 } // namespace L0