1 /*
2 * Copyright (C) 2020-2021 Intel Corporation
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 */
7
8 #include "shared/source/os_interface/device_factory.h"
9 #include "shared/test/common/mocks/ult_device_factory.h"
10 #include "shared/test/common/test_macros/test.h"
11
12 #include "level_zero/core/source/driver/driver_imp.h"
13 #include "level_zero/core/test/unit_tests/mocks/mock_cmdlist.h"
14 #include "level_zero/core/test/unit_tests/mocks/mock_device.h"
15 #include "level_zero/core/test/unit_tests/mocks/mock_driver_handle.h"
16 #include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric.h"
17
18 #include "gmock/gmock.h"
19 #include "gtest/gtest.h"
20
21 using ::testing::_;
22 using ::testing::Return;
23
24 namespace L0 {
25 namespace ult {
26
27 class MetricQueryPoolTest : public MetricContextFixture,
28 public ::testing::Test {
29 public:
SetUp()30 void SetUp() override {
31 ze_result_t returnValue = ZE_RESULT_SUCCESS;
32 MetricContextFixture::SetUp();
33 auto executionEnvironment = new NEO::ExecutionEnvironment();
34 driverHandle.reset(DriverHandle::create(NEO::DeviceFactory::createDevices(*executionEnvironment), L0EnvVariables{}, &returnValue));
35 }
36
TearDown()37 void TearDown() override {
38 MetricContextFixture::TearDown();
39 driverHandle.reset();
40 GlobalDriver = nullptr;
41 }
42 std::unique_ptr<L0::DriverHandle> driverHandle;
43 };
44
TEST_F(MetricQueryPoolTest,givenCorrectArgumentsWhenStreamerIsOpenThenQueryPoolIsNotAvailable)45 TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenStreamerIsOpenThenQueryPoolIsNotAvailable) {
46
47 zet_device_handle_t metricDevice = device->toHandle();
48
49 ze_event_handle_t eventHandle = {};
50
51 zet_metric_streamer_handle_t streamerHandle = {};
52 zet_metric_streamer_desc_t streamerDesc = {};
53
54 streamerDesc.stype = ZET_STRUCTURE_TYPE_METRIC_STREAMER_DESC;
55 streamerDesc.notifyEveryNReports = 32768;
56 streamerDesc.samplingPeriod = 1000;
57
58 Mock<MetricGroup> metricGroup;
59 zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
60 zet_metric_group_properties_t metricGroupProperties = {};
61
62 metricsDeviceParams.ConcurrentGroupsCount = 1;
63
64 Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
65 TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
66 metricsConcurrentGroupParams.MetricSetsCount = 1;
67 metricsConcurrentGroupParams.SymbolName = "OA";
68 metricsConcurrentGroupParams.Description = "OA description";
69
70 Mock<MetricsDiscovery::IMetricSet_1_5> metricsSet;
71 MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
72 metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM;
73 metricsSetParams.MetricsCount = 0;
74 metricsSetParams.SymbolName = "Metric set name";
75 metricsSetParams.ShortName = "Metric set description";
76 metricsSetParams.RawReportSize = 256;
77
78 zet_metric_query_pool_handle_t poolHandle = {};
79 zet_metric_query_pool_desc_t poolDesc = {};
80 poolDesc.stype = ZET_STRUCTURE_TYPE_METRIC_QUERY_POOL_DESC;
81 poolDesc.count = 1;
82 poolDesc.type = ZET_METRIC_QUERY_POOL_TYPE_PERFORMANCE;
83
84 TypedValue_1_0 value = {};
85 value.Type = ValueType::Uint32;
86 value.ValueUInt32 = 64;
87
88 QueryHandle_1_0 queryHandle = {&value};
89 ContextHandle_1_0 contextHandle = {&value};
90
91 EXPECT_CALL(*mockMetricsLibrary, load())
92 .Times(0);
93
94 openMetricsAdapter();
95
96 EXPECT_CALL(metricsDevice, GetParams())
97 .WillRepeatedly(Return(&metricsDeviceParams));
98
99 EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
100 .Times(1)
101 .WillOnce(Return(&metricsConcurrentGroup));
102
103 EXPECT_CALL(metricsConcurrentGroup, GetParams())
104 .Times(1)
105 .WillRepeatedly(Return(&metricsConcurrentGroupParams));
106
107 EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
108 .WillRepeatedly(Return(&metricsSet));
109
110 EXPECT_CALL(metricsSet, GetParams())
111 .WillRepeatedly(Return(&metricsSetParams));
112
113 EXPECT_CALL(metricsSet, SetApiFiltering(_))
114 .WillRepeatedly(Return(TCompletionCode::CC_OK));
115
116 EXPECT_CALL(metricsConcurrentGroup, OpenIoStream(_, _, _, _))
117 .Times(1)
118 .WillOnce(Return(TCompletionCode::CC_OK));
119
120 EXPECT_CALL(metricsConcurrentGroup, CloseIoStream())
121 .Times(1)
122 .WillOnce(Return(TCompletionCode::CC_OK));
123
124 uint32_t metricGroupCount = 0;
125 EXPECT_EQ(zetMetricGroupGet(metricDevice, &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
126 EXPECT_EQ(metricGroupCount, 1u);
127
128 EXPECT_EQ(zetMetricGroupGet(metricDevice, &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
129 EXPECT_EQ(metricGroupCount, 1u);
130 EXPECT_NE(metricGroupHandle, nullptr);
131
132 EXPECT_EQ(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_SUCCESS);
133 EXPECT_EQ(metricGroupProperties.domain, 0u);
134 EXPECT_EQ(metricGroupProperties.samplingType, ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED);
135 EXPECT_EQ(metricGroupProperties.metricCount, metricsSetParams.MetricsCount);
136 EXPECT_EQ(strcmp(metricGroupProperties.description, metricsSetParams.ShortName), 0);
137 EXPECT_EQ(strcmp(metricGroupProperties.name, metricsSetParams.SymbolName), 0);
138
139 EXPECT_EQ(zetContextActivateMetricGroups(context->toHandle(), metricDevice, 1, &metricGroupHandle), ZE_RESULT_SUCCESS);
140
141 EXPECT_EQ(zetMetricStreamerOpen(context->toHandle(), metricDevice, metricGroupHandle, &streamerDesc, eventHandle, &streamerHandle), ZE_RESULT_SUCCESS);
142 EXPECT_NE(streamerHandle, nullptr);
143
144 EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), metricDevice, metricGroupHandle, &poolDesc, &poolHandle), ZE_RESULT_ERROR_NOT_AVAILABLE);
145
146 EXPECT_EQ(zetMetricStreamerClose(streamerHandle), ZE_RESULT_SUCCESS);
147 EXPECT_NE(streamerHandle, nullptr);
148 }
149
TEST_F(MetricQueryPoolTest,givenExecutionQueryTypeWhenZetMetricQueryPoolCreateIsCalledThenQueryPoolIsObtained)150 TEST_F(MetricQueryPoolTest, givenExecutionQueryTypeWhenZetMetricQueryPoolCreateIsCalledThenQueryPoolIsObtained) {
151
152 zet_device_handle_t metricDevice = device->toHandle();
153
154 zet_metric_query_pool_handle_t poolHandle = {};
155 zet_metric_query_pool_desc_t poolDesc = {};
156 poolDesc.stype = ZET_STRUCTURE_TYPE_METRIC_QUERY_POOL_DESC;
157 poolDesc.count = 1;
158 poolDesc.type = ZET_METRIC_QUERY_POOL_TYPE_EXECUTION;
159
160 EXPECT_CALL(*mockMetricsLibrary, load())
161 .Times(0);
162
163 EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), metricDevice, nullptr, &poolDesc, &poolHandle), ZE_RESULT_SUCCESS);
164 EXPECT_NE(poolHandle, nullptr);
165 EXPECT_EQ(zetMetricQueryPoolDestroy(poolHandle), ZE_RESULT_SUCCESS);
166 }
167
TEST_F(MetricQueryPoolTest,givenExecutionQueryTypeWhenAppendMetricQueryBeginAndEndIsCalledThenReturnSuccess)168 TEST_F(MetricQueryPoolTest, givenExecutionQueryTypeWhenAppendMetricQueryBeginAndEndIsCalledThenReturnSuccess) {
169
170 zet_device_handle_t metricDevice = device->toHandle();
171
172 zet_metric_query_pool_handle_t poolHandle = {};
173 zet_metric_query_handle_t queryHandle = {};
174 zet_metric_query_pool_desc_t poolDesc = {};
175 poolDesc.stype = ZET_STRUCTURE_TYPE_METRIC_QUERY_POOL_DESC;
176 poolDesc.count = 1;
177 poolDesc.type = ZET_METRIC_QUERY_POOL_TYPE_EXECUTION;
178
179 ze_result_t returnValue;
180 std::unique_ptr<L0::CommandList> commandList(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue));
181 zet_command_list_handle_t commandListHandle = commandList->toHandle();
182
183 TypedValue_1_0 value = {};
184 value.Type = ValueType::Uint32;
185 value.ValueUInt32 = 64;
186 QueryHandle_1_0 metricsLibraryQueryHandle = {&value};
187 ContextHandle_1_0 metricsLibraryContextHandle = {&value};
188
189 CommandBufferSize_1_0 commandBufferSize = {};
190 commandBufferSize.GpuMemorySize = 100;
191
192 EXPECT_CALL(*mockMetricEnumeration, isInitialized())
193 .Times(1)
194 .WillOnce(Return(true));
195
196 EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
197 .Times(1)
198 .WillOnce(Return(true));
199
200 EXPECT_CALL(*mockMetricsLibrary, load())
201 .Times(0);
202
203 EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
204 .Times(1)
205 .WillOnce(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
206
207 EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
208 .Times(1)
209 .WillOnce(Return(StatusCode::Success));
210
211 EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGetSize(_, _))
212 .Times(3)
213 .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(::testing::ByRef(commandBufferSize)), Return(StatusCode::Success)));
214
215 EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGet(_))
216 .Times(3)
217 .WillRepeatedly(Return(StatusCode::Success));
218
219 EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), metricDevice, nullptr, &poolDesc, &poolHandle), ZE_RESULT_SUCCESS);
220 EXPECT_EQ(zetMetricQueryCreate(poolHandle, 0, &queryHandle), ZE_RESULT_SUCCESS);
221 EXPECT_NE(queryHandle, nullptr);
222
223 EXPECT_EQ(zetCommandListAppendMetricQueryBegin(commandListHandle, queryHandle), ZE_RESULT_SUCCESS);
224 EXPECT_EQ(zetCommandListAppendMetricQueryEnd(commandListHandle, queryHandle, nullptr, 0, nullptr), ZE_RESULT_SUCCESS);
225
226 EXPECT_EQ(zetCommandListAppendMetricMemoryBarrier(commandListHandle), ZE_RESULT_SUCCESS);
227
228 EXPECT_EQ(zetMetricQueryDestroy(queryHandle), ZE_RESULT_SUCCESS);
229 EXPECT_EQ(zetMetricQueryPoolDestroy(poolHandle), ZE_RESULT_SUCCESS);
230 }
231
TEST_F(MetricQueryPoolTest,givenExecutionQueryTypeAndCompletionEventWhenAppendMetricQueryBeginAndEndIsCalledThenReturnSuccess)232 TEST_F(MetricQueryPoolTest, givenExecutionQueryTypeAndCompletionEventWhenAppendMetricQueryBeginAndEndIsCalledThenReturnSuccess) {
233
234 zet_device_handle_t metricDevice = device->toHandle();
235
236 zet_metric_query_pool_handle_t poolHandle = {};
237 zet_metric_query_handle_t queryHandle = {};
238 zet_metric_query_pool_desc_t poolDesc = {};
239 poolDesc.stype = ZET_STRUCTURE_TYPE_METRIC_QUERY_POOL_DESC;
240 poolDesc.count = 1;
241 poolDesc.type = ZET_METRIC_QUERY_POOL_TYPE_EXECUTION;
242
243 ze_result_t returnValue;
244 std::unique_ptr<L0::CommandList> commandList(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue));
245 zet_command_list_handle_t commandListHandle = commandList->toHandle();
246
247 TypedValue_1_0 value = {};
248 value.Type = ValueType::Uint32;
249 value.ValueUInt32 = 64;
250 QueryHandle_1_0 metricsLibraryQueryHandle = {&value};
251 ContextHandle_1_0 metricsLibraryContextHandle = {&value};
252
253 CommandBufferSize_1_0 commandBufferSize = {};
254 commandBufferSize.GpuMemorySize = 100;
255
256 EXPECT_CALL(*mockMetricEnumeration, isInitialized())
257 .Times(1)
258 .WillOnce(Return(true));
259
260 EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
261 .Times(1)
262 .WillOnce(Return(true));
263
264 EXPECT_CALL(*mockMetricsLibrary, load())
265 .Times(0);
266
267 EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
268 .Times(1)
269 .WillOnce(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
270
271 EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
272 .Times(1)
273 .WillOnce(Return(StatusCode::Success));
274
275 EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGetSize(_, _))
276 .Times(2)
277 .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(::testing::ByRef(commandBufferSize)), Return(StatusCode::Success)));
278
279 EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGet(_))
280 .Times(2)
281 .WillRepeatedly(Return(StatusCode::Success));
282
283 ze_event_pool_handle_t eventPoolHandle = {};
284 ze_event_pool_desc_t eventPoolDesc = {};
285 eventPoolDesc.count = 1;
286 eventPoolDesc.flags = 0;
287 eventPoolDesc.stype = ZE_STRUCTURE_TYPE_EVENT_POOL_DESC;
288
289 ze_event_handle_t eventHandle = {};
290 ze_event_desc_t eventDesc = {};
291 eventDesc.index = 0;
292 eventDesc.stype = ZE_STRUCTURE_TYPE_EVENT_DESC;
293 eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
294 eventDesc.signal = ZE_EVENT_SCOPE_FLAG_DEVICE;
295
296 EXPECT_EQ(zeEventPoolCreate(context->toHandle(), &eventPoolDesc, 1, &metricDevice, &eventPoolHandle), ZE_RESULT_SUCCESS);
297 EXPECT_NE(eventPoolHandle, nullptr);
298
299 EXPECT_EQ(zeEventCreate(eventPoolHandle, &eventDesc, &eventHandle), ZE_RESULT_SUCCESS);
300 EXPECT_NE(eventHandle, nullptr);
301
302 EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), metricDevice, nullptr, &poolDesc, &poolHandle), ZE_RESULT_SUCCESS);
303 EXPECT_EQ(zetMetricQueryCreate(poolHandle, 0, &queryHandle), ZE_RESULT_SUCCESS);
304 EXPECT_NE(queryHandle, nullptr);
305
306 EXPECT_EQ(zetCommandListAppendMetricQueryBegin(commandListHandle, queryHandle), ZE_RESULT_SUCCESS);
307 EXPECT_EQ(zetCommandListAppendMetricQueryEnd(commandListHandle, queryHandle, eventHandle, 0, nullptr), ZE_RESULT_SUCCESS);
308
309 EXPECT_EQ(zetMetricQueryDestroy(queryHandle), ZE_RESULT_SUCCESS);
310 EXPECT_EQ(zetMetricQueryPoolDestroy(poolHandle), ZE_RESULT_SUCCESS);
311
312 EXPECT_EQ(zeEventDestroy(eventHandle), ZE_RESULT_SUCCESS);
313 EXPECT_EQ(zeEventPoolDestroy(eventPoolHandle), ZE_RESULT_SUCCESS);
314 }
315
TEST_F(MetricQueryPoolTest,givenExecutionQueryTypeAndMetricsLibraryWillFailWhenAppendMetricQueryBeginAndEndIsCalledThenReturnFail)316 TEST_F(MetricQueryPoolTest, givenExecutionQueryTypeAndMetricsLibraryWillFailWhenAppendMetricQueryBeginAndEndIsCalledThenReturnFail) {
317
318 zet_device_handle_t metricDevice = device->toHandle();
319
320 zet_metric_query_pool_handle_t poolHandle = {};
321 zet_metric_query_handle_t queryHandle = {};
322 zet_metric_query_pool_desc_t poolDesc = {};
323 poolDesc.stype = ZET_STRUCTURE_TYPE_METRIC_QUERY_POOL_DESC;
324 poolDesc.count = 1;
325 poolDesc.type = ZET_METRIC_QUERY_POOL_TYPE_EXECUTION;
326
327 ze_result_t returnValue;
328 std::unique_ptr<L0::CommandList> commandList(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue));
329 zet_command_list_handle_t commandListHandle = commandList->toHandle();
330
331 TypedValue_1_0 value = {};
332 value.Type = ValueType::Uint32;
333 value.ValueUInt32 = 64;
334 QueryHandle_1_0 metricsLibraryQueryHandle = {&value};
335 ContextHandle_1_0 metricsLibraryContextHandle = {&value};
336
337 CommandBufferSize_1_0 commandBufferSize = {};
338 commandBufferSize.GpuMemorySize = 100;
339
340 EXPECT_CALL(*mockMetricEnumeration, isInitialized())
341 .Times(1)
342 .WillOnce(Return(true));
343
344 EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
345 .Times(1)
346 .WillOnce(Return(true));
347
348 EXPECT_CALL(*mockMetricsLibrary, load())
349 .Times(0);
350
351 EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
352 .Times(1)
353 .WillOnce(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
354
355 EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
356 .Times(1)
357 .WillOnce(Return(StatusCode::Success));
358
359 EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGetSize(_, _))
360 .Times(2)
361 .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(::testing::ByRef(commandBufferSize)), Return(StatusCode::Failed)));
362
363 ze_event_pool_handle_t eventPoolHandle = {};
364 ze_event_pool_desc_t eventPoolDesc = {};
365 eventPoolDesc.count = 1;
366 eventPoolDesc.flags = 0;
367 eventPoolDesc.stype = ZE_STRUCTURE_TYPE_EVENT_POOL_DESC;
368
369 ze_event_handle_t eventHandle = {};
370 ze_event_desc_t eventDesc = {};
371 eventDesc.index = 0;
372 eventDesc.stype = ZE_STRUCTURE_TYPE_EVENT_DESC;
373 eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
374 eventDesc.signal = ZE_EVENT_SCOPE_FLAG_DEVICE;
375
376 EXPECT_EQ(zeEventPoolCreate(context->toHandle(), &eventPoolDesc, 1, &metricDevice, &eventPoolHandle), ZE_RESULT_SUCCESS);
377 EXPECT_NE(eventPoolHandle, nullptr);
378
379 EXPECT_EQ(zeEventCreate(eventPoolHandle, &eventDesc, &eventHandle), ZE_RESULT_SUCCESS);
380 EXPECT_NE(eventHandle, nullptr);
381
382 EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), metricDevice, nullptr, &poolDesc, &poolHandle), ZE_RESULT_SUCCESS);
383 EXPECT_EQ(zetMetricQueryCreate(poolHandle, 0, &queryHandle), ZE_RESULT_SUCCESS);
384 EXPECT_NE(queryHandle, nullptr);
385
386 EXPECT_NE(zetCommandListAppendMetricQueryBegin(commandListHandle, queryHandle), ZE_RESULT_SUCCESS);
387 EXPECT_NE(zetCommandListAppendMetricQueryEnd(commandListHandle, queryHandle, eventHandle, 0, nullptr), ZE_RESULT_SUCCESS);
388
389 EXPECT_EQ(zetMetricQueryDestroy(queryHandle), ZE_RESULT_SUCCESS);
390 EXPECT_EQ(zetMetricQueryPoolDestroy(poolHandle), ZE_RESULT_SUCCESS);
391
392 EXPECT_EQ(zeEventDestroy(eventHandle), ZE_RESULT_SUCCESS);
393 EXPECT_EQ(zeEventPoolDestroy(eventPoolHandle), ZE_RESULT_SUCCESS);
394 }
395
TEST_F(MetricQueryPoolTest,givenRootDeviceWhenGetSubDeviceClientOptionsIsCalledThenReturnRootDeviceProperties)396 TEST_F(MetricQueryPoolTest, givenRootDeviceWhenGetSubDeviceClientOptionsIsCalledThenReturnRootDeviceProperties) {
397
398 auto &metricContext = device->getMetricContext();
399 auto &metricsLibrary = metricContext.getMetricsLibrary();
400 auto subDevice = ClientOptionsData_1_0{};
401 auto subDeviceIndex = ClientOptionsData_1_0{};
402 auto subDeviceCount = ClientOptionsData_1_0{};
403 auto workloadPartition = ClientOptionsData_1_0{};
404
405 metricsLibrary.getSubDeviceClientOptions(subDevice, subDeviceIndex, subDeviceCount, workloadPartition);
406
407 // Root device
408 EXPECT_EQ(subDevice.Type, MetricsLibraryApi::ClientOptionsType::SubDevice);
409 EXPECT_EQ(subDevice.SubDevice.Enabled, false);
410
411 EXPECT_EQ(subDeviceIndex.Type, MetricsLibraryApi::ClientOptionsType::SubDeviceIndex);
412 EXPECT_EQ(subDeviceIndex.SubDeviceIndex.Index, 0u);
413
414 EXPECT_EQ(subDeviceCount.Type, MetricsLibraryApi::ClientOptionsType::SubDeviceCount);
415 EXPECT_EQ(subDeviceCount.SubDeviceCount.Count, std::max(device->getNEODevice()->getNumSubDevices(), 1u));
416
417 EXPECT_EQ(workloadPartition.Type, MetricsLibraryApi::ClientOptionsType::WorkloadPartition);
418 EXPECT_EQ(workloadPartition.WorkloadPartition.Enabled, false);
419 }
420
TEST_F(MetricQueryPoolTest,givenUninitializedMetricEnumerationWhenGetQueryReportGpuSizeIsCalledThenReturnInvalidSize)421 TEST_F(MetricQueryPoolTest, givenUninitializedMetricEnumerationWhenGetQueryReportGpuSizeIsCalledThenReturnInvalidSize) {
422
423 auto &metricContext = device->getMetricContext();
424 auto &metricsLibrary = metricContext.getMetricsLibrary();
425
426 EXPECT_CALL(*mockMetricEnumeration, isInitialized())
427 .Times(1)
428 .WillOnce(Return(false));
429
430 const uint32_t invalidSize = metricsLibrary.getQueryReportGpuSize();
431
432 EXPECT_EQ(invalidSize, 0u);
433 }
434
TEST_F(MetricQueryPoolTest,givenCorrectArgumentsWhenActivateMetricGroupsIsCalledThenReturnsSuccess)435 TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenActivateMetricGroupsIsCalledThenReturnsSuccess) {
436
437 zet_device_handle_t metricDevice = device->toHandle();
438
439 metricsDeviceParams.ConcurrentGroupsCount = 1;
440
441 Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
442 TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
443 metricsConcurrentGroupParams.MetricSetsCount = 1;
444 metricsConcurrentGroupParams.SymbolName = "OA";
445 metricsConcurrentGroupParams.Description = "OA description";
446
447 Mock<MetricsDiscovery::IMetricSet_1_5> metricsSet;
448 MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
449 metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
450 metricsSetParams.MetricsCount = 0;
451 metricsSetParams.SymbolName = "Metric set name";
452 metricsSetParams.ShortName = "Metric set description";
453 metricsSetParams.MetricsCount = 1;
454
455 Mock<IMetric_1_0> metric;
456 TMetricParams_1_0 metricParams = {};
457 metricParams.SymbolName = "Metric symbol name";
458 metricParams.ShortName = "Metric short name";
459 metricParams.LongName = "Metric long name";
460 metricParams.ResultType = MetricsDiscovery::TMetricResultType::RESULT_UINT64;
461 metricParams.MetricType = MetricsDiscovery::TMetricType::METRIC_TYPE_RATIO;
462
463 zet_metric_group_handle_t metricGroupHandle = {};
464
465 zet_metric_group_properties_t metricGroupProperties = {};
466 metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
467
468 TypedValue_1_0 value = {};
469 value.Type = ValueType::Uint32;
470 value.ValueUInt32 = 64;
471
472 ConfigurationHandle_1_0 metricsLibraryConfigurationHandle = {&value};
473 ContextHandle_1_0 metricsLibraryContextHandle = {&value};
474
475 openMetricsAdapter();
476
477 EXPECT_CALL(metricsDevice, GetParams())
478 .WillRepeatedly(Return(&metricsDeviceParams));
479
480 EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
481 .Times(1)
482 .WillOnce(Return(&metricsConcurrentGroup));
483
484 EXPECT_CALL(metricsConcurrentGroup, GetParams())
485 .Times(1)
486 .WillOnce(Return(&metricsConcurrentGroupParams));
487
488 EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
489 .WillRepeatedly(Return(&metricsSet));
490
491 EXPECT_CALL(metricsSet, GetParams())
492 .WillRepeatedly(Return(&metricsSetParams));
493
494 EXPECT_CALL(metricsSet, GetMetric(_))
495 .Times(1)
496 .WillOnce(Return(&metric));
497
498 EXPECT_CALL(metricsSet, Activate())
499 .Times(1)
500 .WillOnce(Return(MetricsDiscovery::CC_OK));
501
502 EXPECT_CALL(metricsSet, Deactivate())
503 .Times(1)
504 .WillOnce(Return(MetricsDiscovery::CC_OK));
505
506 EXPECT_CALL(metric, GetParams())
507 .Times(1)
508 .WillOnce(Return(&metricParams));
509
510 EXPECT_CALL(metricsSet, SetApiFiltering(_))
511 .WillRepeatedly(Return(TCompletionCode::CC_OK));
512
513 EXPECT_CALL(*mockMetricEnumeration, isInitialized())
514 .Times(1)
515 .WillOnce(Return(true));
516
517 EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
518 .Times(1)
519 .WillOnce(Return(true));
520
521 EXPECT_CALL(*mockMetricsLibrary, load())
522 .Times(0);
523
524 EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
525 .Times(1)
526 .WillOnce(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
527
528 EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
529 .Times(1)
530 .WillOnce(Return(StatusCode::Success));
531
532 EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockConfigurationCreate(_, _))
533 .Times(1)
534 .WillOnce(DoAll(::testing::SetArgPointee<1>(metricsLibraryConfigurationHandle), Return(StatusCode::Success)));
535
536 EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockConfigurationActivate(_, _))
537 .Times(1)
538 .WillOnce(Return(StatusCode::Success));
539
540 EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockConfigurationDeactivate(_))
541 .Times(1)
542 .WillOnce(Return(StatusCode::Success));
543
544 EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockConfigurationDelete(_))
545 .Times(1)
546 .WillOnce(Return(StatusCode::Success));
547
548 // Metric group count.
549 uint32_t metricGroupCount = 0;
550 EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
551 EXPECT_EQ(metricGroupCount, 1u);
552
553 // Metric group handle.
554 EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
555 EXPECT_EQ(metricGroupCount, 1u);
556 EXPECT_NE(metricGroupHandle, nullptr);
557
558 // Activate metric group.
559 EXPECT_EQ(zetContextActivateMetricGroups(context->toHandle(), device->toHandle(), 1, &metricGroupHandle), ZE_RESULT_SUCCESS);
560
561 // Activate metric groups.
562 device->activateMetricGroups();
563
564 EXPECT_EQ(zetContextActivateMetricGroups(context->toHandle(), metricDevice, 0, nullptr), ZE_RESULT_SUCCESS);
565 }
566
567 } // namespace ult
568 } // namespace L0
569