From 7a0b3f4c03be92dafa319644f9753d499a947882 Mon Sep 17 00:00:00 2001 From: Robert Krzemien Date: Tue, 13 Jul 2021 11:10:59 +0000 Subject: [PATCH] Metric Api: Metric enumeration for all sub devices. Signed-off-by: Robert Krzemien Signed-off-by: Joshua Santosh Ranjan Related-To: LOCI-2422 --- .../source/metrics/metric_enumeration_imp.cpp | 97 +++++++--- .../source/metrics/metric_enumeration_imp.h | 6 + .../sources/metrics/mock_metric.cpp | 26 ++- .../metrics/test_metric_enumeration.cpp | 172 +++++++++++++++--- 4 files changed, 244 insertions(+), 57 deletions(-) diff --git a/level_zero/tools/source/metrics/metric_enumeration_imp.cpp b/level_zero/tools/source/metrics/metric_enumeration_imp.cpp index d2582a38da..a014d7c263 100644 --- a/level_zero/tools/source/metrics/metric_enumeration_imp.cpp +++ b/level_zero/tools/source/metrics/metric_enumeration_imp.cpp @@ -48,6 +48,14 @@ ze_result_t MetricEnumeration::metricGroupGet(uint32_t &count, return ZE_RESULT_SUCCESS; } +MetricGroup *MetricEnumeration::getMetricGroupByIndex(const uint32_t index) { + return metricGroups[index]; +} + +uint32_t MetricEnumeration::getMetricGroupCount() { + return static_cast(metricGroups.size()); +} + bool MetricEnumeration::isInitialized() { if (initializationState == ZE_RESULT_ERROR_UNINITIALIZED) { @@ -128,11 +136,11 @@ ze_result_t MetricEnumeration::openMetricsDiscovery() { // Open metrics device for each sub device. const auto &deviceImp = *static_cast(&device); - for (uint32_t i = 0; i < deviceImp.subDevices.size(); i++) { + for (size_t i = 0; i < deviceImp.subDevices.size(); i++) { auto &metricsDevice = deviceImp.subDevices[i]->getMetricContext().getMetricEnumeration().pMetricsDevice; - pAdapter->OpenMetricsSubDevice(i, &metricsDevice); + pAdapter->OpenMetricsSubDevice(static_cast(i), &metricsDevice); if (metricsDevice == nullptr) { NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "unable to open metrics device %u\n", i); @@ -160,11 +168,6 @@ ze_result_t MetricEnumeration::openMetricsDiscovery() { } ze_result_t MetricEnumeration::cleanupMetricsDiscovery() { - for (uint32_t i = 0; i < metricGroups.size(); ++i) { - delete metricGroups[i]; - } - - metricGroups.clear(); if (pAdapter) { @@ -174,7 +177,7 @@ ze_result_t MetricEnumeration::cleanupMetricsDiscovery() { // Close metrics device for each sub device. const auto &deviceImp = *static_cast(&device); - for (uint32_t i = 0; i < deviceImp.subDevices.size(); i++) { + for (size_t i = 0; i < deviceImp.subDevices.size(); i++) { auto &metricsDevice = deviceImp.subDevices[i]->getMetricContext().getMetricEnumeration().pMetricsDevice; @@ -182,6 +185,14 @@ ze_result_t MetricEnumeration::cleanupMetricsDiscovery() { pAdapter->CloseMetricsDevice(metricsDevice); metricsDevice = nullptr; } + + auto &metricGroupsSubDevice = deviceImp.subDevices[i]->getMetricContext().getMetricEnumeration().metricGroups; + + for (size_t j = 0; j < metricGroupsSubDevice.size(); ++j) { + auto metricGroupSubDevice = MetricGroup::fromHandle(metricGroupsSubDevice[j]); + delete metricGroupSubDevice; + } + metricGroupsSubDevice.clear(); } } else if (pMetricsDevice) { @@ -191,6 +202,11 @@ ze_result_t MetricEnumeration::cleanupMetricsDiscovery() { } } + for (size_t i = 0; i < metricGroups.size(); ++i) { + delete metricGroups[i]; + } + metricGroups.clear(); + if (hMetricsDiscovery != nullptr) { openAdapterGroup = nullptr; hMetricsDiscovery.reset(); @@ -201,19 +217,38 @@ ze_result_t MetricEnumeration::cleanupMetricsDiscovery() { ze_result_t MetricEnumeration::cacheMetricInformation() { - MetricsDiscovery::IMetricsDevice_1_5 *pMetricsDevice = nullptr; - auto &device = metricContext.getDevice(); if (device.isMultiDeviceCapable()) { - // Get metric information from sub device 0. - const auto &deviceImp = *static_cast(&device); - pMetricsDevice = deviceImp.subDevices[0]->getMetricContext().getMetricEnumeration().pMetricsDevice; - } else { + ze_result_t result = ZE_RESULT_SUCCESS; - // Get metric information from root or sub device. - pMetricsDevice = this->pMetricsDevice; + // Get metric information from all sub devices. + const auto &deviceImp = *static_cast(&device); + for (auto subDevice : deviceImp.subDevices) { + result = subDevice->getMetricContext().getMetricEnumeration().cacheMetricInformation(); + if (ZE_RESULT_SUCCESS != result) { + return result; + } + } + + // Get metric groups count for one sub device. + const uint32_t metricGroupCount = deviceImp.subDevices[0]->getMetricContext().getMetricEnumeration().getMetricGroupCount(); + + // Cache and aggregate all metric groups from all sub devices. + for (uint32_t i = 0; i < metricGroupCount; i++) { + auto metricGroupRootDevice = new MetricGroupImp(); + + for (auto subDevice : deviceImp.subDevices) { + MetricGroup *metricGroupSubDevice = subDevice->getMetricContext().getMetricEnumeration().getMetricGroupByIndex(i); + + metricGroupRootDevice->getMetricGroups().push_back(metricGroupSubDevice); + } + + metricGroups.push_back(metricGroupRootDevice); + } + + return result; } DEBUG_BREAK_IF(pMetricsDevice == nullptr); @@ -457,7 +492,7 @@ zet_value_type_t MetricEnumeration::getMetricResultType( MetricGroupImp ::~MetricGroupImp() { - for (uint32_t i = 0; i < metrics.size(); ++i) { + for (size_t i = 0; i < metrics.size(); ++i) { delete metrics[i]; } @@ -465,7 +500,11 @@ MetricGroupImp ::~MetricGroupImp() { }; ze_result_t MetricGroupImp::getProperties(zet_metric_group_properties_t *pProperties) { - copyProperties(properties, *pProperties); + if (metricGroups.size() > 0) { + *pProperties = MetricGroup::getProperties(metricGroups[0]); + } else { + copyProperties(properties, *pProperties); + } return ZE_RESULT_SUCCESS; } @@ -480,18 +519,22 @@ zet_metric_group_properties_t MetricGroup::getProperties(const zet_metric_group_ } ze_result_t MetricGroupImp::getMetric(uint32_t *pCount, zet_metric_handle_t *phMetrics) { + + if (metricGroups.size() > 0) { + auto metricGroupSubDevice = MetricGroup::fromHandle(metricGroups[0]); + return metricGroupSubDevice->getMetric(pCount, phMetrics); + } + if (*pCount == 0) { *pCount = static_cast(metrics.size()); return ZE_RESULT_SUCCESS; - } else if (*pCount > metrics.size()) { + } + // User is expected to allocate space. + DEBUG_BREAK_IF(phMetrics == nullptr); + + if (*pCount > metrics.size()) { *pCount = static_cast(metrics.size()); } - - // User is expected to allocate space. - if (phMetrics == nullptr) { - return ZE_RESULT_ERROR_INVALID_ARGUMENT; - } - for (uint32_t i = 0; i < *pCount; i++) { phMetrics[i] = metrics[i]->toHandle(); } @@ -663,6 +706,10 @@ uint32_t MetricGroupImp::getRawReportSize() { : pMetricSetParams->QueryReportSize; } +std::vector &MetricGroupImp::getMetricGroups() { + return metricGroups; +} + void MetricGroupImp::copyProperties(const zet_metric_group_properties_t &source, zet_metric_group_properties_t &destination) { destination = source; diff --git a/level_zero/tools/source/metrics/metric_enumeration_imp.h b/level_zero/tools/source/metrics/metric_enumeration_imp.h index d3705d5c1a..fdfd85d048 100644 --- a/level_zero/tools/source/metrics/metric_enumeration_imp.h +++ b/level_zero/tools/source/metrics/metric_enumeration_imp.h @@ -22,6 +22,8 @@ struct MetricEnumeration { virtual ~MetricEnumeration(); ze_result_t metricGroupGet(uint32_t &count, zet_metric_group_handle_t *phMetricGroups); + MetricGroup *getMetricGroupByIndex(const uint32_t index); + uint32_t getMetricGroupCount(); virtual bool isInitialized(); @@ -98,6 +100,8 @@ struct MetricGroupImp : MetricGroup { ze_result_t readIoStream(uint32_t &reportCount, uint8_t &reportData) override; ze_result_t closeIoStream() override; + std::vector &getMetricGroups(); + protected: void copyProperties(const zet_metric_group_properties_t &source, zet_metric_group_properties_t &destination); @@ -118,6 +122,8 @@ struct MetricGroupImp : MetricGroup { }; MetricsDiscovery::IMetricSet_1_5 *pReferenceMetricSet = nullptr; MetricsDiscovery::IConcurrentGroup_1_5 *pReferenceConcurrentGroup = nullptr; + + std::vector metricGroups; }; struct MetricImp : Metric { diff --git a/level_zero/tools/test/unit_tests/sources/metrics/mock_metric.cpp b/level_zero/tools/test/unit_tests/sources/metrics/mock_metric.cpp index bf8bb0f3cd..deb5e57659 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/mock_metric.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/mock_metric.cpp @@ -146,6 +146,9 @@ void MetricMultiDeviceFixture::TearDown() { void MetricMultiDeviceFixture::openMetricsAdapter() { + auto &deviceImp = *static_cast(devices[0]); + const uint32_t subDeviceCount = static_cast(deviceImp.subDevices.size()); + EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery()) .Times(0); @@ -153,13 +156,13 @@ void MetricMultiDeviceFixture::openMetricsAdapter() { .Times(1) .WillOnce(DoAll(::testing::SetArgPointee<0>(&adapterGroup), Return(TCompletionCode::CC_OK))); - EXPECT_CALL(adapter, OpenMetricsDevice(_)) - .Times(1) - .WillOnce(DoAll(::testing::SetArgPointee<0>(&metricsDevice), Return(TCompletionCode::CC_OK))); + EXPECT_CALL(adapter, OpenMetricsSubDevice(_, _)) + .Times(subDeviceCount) + .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(&metricsDevice), Return(TCompletionCode::CC_OK))); EXPECT_CALL(adapter, CloseMetricsDevice(_)) - .Times(1) - .WillOnce(Return(TCompletionCode::CC_OK)); + .Times(subDeviceCount) + .WillRepeatedly(Return(TCompletionCode::CC_OK)); EXPECT_CALL(adapterGroup, GetAdapter(_)) .Times(0); @@ -171,6 +174,9 @@ void MetricMultiDeviceFixture::openMetricsAdapter() { void MetricMultiDeviceFixture::openMetricsAdapterGroup() { + auto &deviceImp = *static_cast(devices[0]); + const uint32_t subDeviceCount = static_cast(deviceImp.subDevices.size()); + EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery()) .Times(0); @@ -178,13 +184,13 @@ void MetricMultiDeviceFixture::openMetricsAdapterGroup() { .Times(1) .WillOnce(DoAll(::testing::SetArgPointee<0>(&adapterGroup), Return(TCompletionCode::CC_OK))); - EXPECT_CALL(adapter, OpenMetricsDevice(_)) - .Times(1) - .WillOnce(DoAll(::testing::SetArgPointee<0>(&metricsDevice), Return(TCompletionCode::CC_OK))); + EXPECT_CALL(adapter, OpenMetricsSubDevice(_, _)) + .Times(subDeviceCount) + .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(&metricsDevice), Return(TCompletionCode::CC_OK))); EXPECT_CALL(adapter, CloseMetricsDevice(_)) - .Times(1) - .WillOnce(Return(TCompletionCode::CC_OK)); + .Times(subDeviceCount) + .WillRepeatedly(Return(TCompletionCode::CC_OK)); } void MetricMultiDeviceContextFixture::SetUp() { diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_enumeration.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_enumeration.cpp index acd42d68d3..3a259902ca 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_enumeration.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_enumeration.cpp @@ -886,6 +886,9 @@ using MultiDeviceMetricEnumerationTest = Test; TEST_F(MultiDeviceMetricEnumerationTest, givenMultipleDevicesAndValidEventBasedMetricGroupWhenzetContextActivateMetricGroupsIsCalledThenReturnsSuccess) { + auto &deviceImp = *static_cast(devices[0]); + const uint32_t subDeviceCount = static_cast(deviceImp.subDevices.size()); + // Metrics Discovery device. metricsDeviceParams.ConcurrentGroupsCount = 1; @@ -923,11 +926,11 @@ TEST_F(MultiDeviceMetricEnumerationTest, givenMultipleDevicesAndValidEventBasedM .WillRepeatedly(Return(&metricsDeviceParams)); EXPECT_CALL(metricsDevice, GetConcurrentGroup(_)) - .Times(1) - .WillOnce(Return(&metricsConcurrentGroup)); + .Times(subDeviceCount) + .WillRepeatedly(Return(&metricsConcurrentGroup)); EXPECT_CALL(metricsConcurrentGroup, GetParams()) - .Times(1) + .Times(subDeviceCount) .WillRepeatedly(Return(&metricsConcurrentGroupParams)); EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_)) @@ -937,12 +940,12 @@ TEST_F(MultiDeviceMetricEnumerationTest, givenMultipleDevicesAndValidEventBasedM .WillRepeatedly(Return(&metricsSetParams)); EXPECT_CALL(metricsSet, GetMetric(_)) - .Times(1) - .WillOnce(Return(&metric)); + .Times(subDeviceCount) + .WillRepeatedly(Return(&metric)); EXPECT_CALL(metric, GetParams()) - .Times(1) - .WillOnce(Return(&metricParams)); + .Times(subDeviceCount) + .WillRepeatedly(Return(&metricParams)); EXPECT_CALL(metricsSet, SetApiFiltering(_)) .WillRepeatedly(Return(TCompletionCode::CC_OK)); @@ -963,6 +966,9 @@ TEST_F(MultiDeviceMetricEnumerationTest, givenMultipleDevicesAndValidEventBasedM TEST_F(MultiDeviceMetricEnumerationTest, givenMultipleDevicesAndTwoMetricGroupsWithTheSameDomainsWhenzetContextActivateMetricGroupsIsCalledThenReturnsFail) { + auto &deviceImp = *static_cast(devices[0]); + const uint32_t subDeviceCount = static_cast(deviceImp.subDevices.size()); + // Metrics Discovery device. metricsDeviceParams.ConcurrentGroupsCount = 1; @@ -1010,15 +1016,17 @@ TEST_F(MultiDeviceMetricEnumerationTest, givenMultipleDevicesAndTwoMetricGroupsW .WillRepeatedly(Return(&metricsDeviceParams)); EXPECT_CALL(metricsDevice, GetConcurrentGroup(_)) - .Times(1) - .WillOnce(Return(&metricsConcurrentGroup0)); + .Times(subDeviceCount) + .WillRepeatedly(Return(&metricsConcurrentGroup0)); EXPECT_CALL(metricsConcurrentGroup0, GetParams()) - .Times(1) + .Times(subDeviceCount) .WillRepeatedly(Return(&metricsConcurrentGroupParams0)); EXPECT_CALL(metricsConcurrentGroup0, GetMetricSet(_)) - .Times(2) + .Times(subDeviceCount * 2) + .WillOnce(Return(&metricsSet0)) + .WillOnce(Return(&metricsSet1)) .WillOnce(Return(&metricsSet0)) .WillOnce(Return(&metricsSet1)); @@ -1029,12 +1037,12 @@ TEST_F(MultiDeviceMetricEnumerationTest, givenMultipleDevicesAndTwoMetricGroupsW .WillRepeatedly(Return(&metricsSetParams1)); EXPECT_CALL(metricsSet0, GetMetric(_)) - .Times(1) - .WillOnce(Return(&metric0)); + .Times(subDeviceCount) + .WillRepeatedly(Return(&metric0)); EXPECT_CALL(metricsSet1, GetMetric(_)) - .Times(1) - .WillOnce(Return(&metric1)); + .Times(subDeviceCount) + .WillRepeatedly(Return(&metric1)); EXPECT_CALL(metricsSet0, SetApiFiltering(_)) .WillRepeatedly(Return(TCompletionCode::CC_OK)); @@ -1043,12 +1051,12 @@ TEST_F(MultiDeviceMetricEnumerationTest, givenMultipleDevicesAndTwoMetricGroupsW .WillRepeatedly(Return(TCompletionCode::CC_OK)); EXPECT_CALL(metric0, GetParams()) - .Times(1) - .WillOnce(Return(&metricParams0)); + .Times(subDeviceCount) + .WillRepeatedly(Return(&metricParams0)); EXPECT_CALL(metric1, GetParams()) - .Times(1) - .WillOnce(Return(&metricParams1)); + .Times(subDeviceCount) + .WillRepeatedly(Return(&metricParams1)); // Metric group count. uint32_t metricGroupCount = 0; @@ -2259,7 +2267,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesIsCa // Use first root device. auto &metricContext = devices[0]->getMetricContext(); - const uint32_t subDeviceCount = static_cast(devices.size()); + auto &deviceImp = *static_cast(devices[0]); + const uint32_t subDeviceCount = static_cast(deviceImp.subDevices.size()); Mock mockAdapterGroup; Mock mockAdapter; Mock mockDevice; @@ -2289,8 +2298,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesIsCa .WillRepeatedly(Return(TCompletionCode::CC_OK)); EXPECT_CALL(mockDevice, GetParams()) - .Times(1) - .WillOnce(Return(&metricsDeviceParams)); + .Times(subDeviceCount) + .WillRepeatedly(Return(&metricsDeviceParams)); // Use root device. metricContext.setSubDeviceIndex(0); @@ -2345,6 +2354,125 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesIsCa EXPECT_EQ(mockMetricEnumeration->baseIsInitialized(), false); } +TEST_F(MetricEnumerationMultiDeviceTest, givenIncorrectMetricsDiscoveryInterfaceVersionWhenZetGetMetricGroupIsCalledThenReturnsFail) { + + metricsDeviceParams.Version.MajorNumber = 0; + metricsDeviceParams.Version.MinorNumber = 1; + + openMetricsAdapter(); + + EXPECT_CALL(metricsDevice, GetParams()) + .Times(1) + .WillOnce(Return(&metricsDeviceParams)); + + uint32_t metricGroupCount = 0; + EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_ERROR_UNKNOWN); + EXPECT_EQ(metricGroupCount, 0u); +} + +TEST_F(MetricEnumerationMultiDeviceTest, givenValidArgumentsWhenZetMetricGetPropertiestIsCalledThenReturnSuccess) { + + // Use first root device. + auto &deviceImp = *static_cast(devices[0]); + const uint32_t subDeviceCount = static_cast(deviceImp.subDevices.size()); + + // Metrics Discovery device. + metricsDeviceParams.ConcurrentGroupsCount = 1; + + // Metrics Discovery concurrent group. + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + metricsConcurrentGroupParams.MetricSetsCount = 1; + metricsConcurrentGroupParams.SymbolName = "OA"; + metricsConcurrentGroupParams.Description = "OA description"; + + // Metrics Discovery:: metric set. + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; + metricsSetParams.MetricsCount = 0; + metricsSetParams.SymbolName = "Metric set name"; + metricsSetParams.ShortName = "Metric set description"; + metricsSetParams.MetricsCount = 1; + + // Metrics Discovery:: metric. + Mock metric; + TMetricParams_1_0 metricParams = {}; + metricParams.SymbolName = "Metric symbol name"; + metricParams.ShortName = "Metric short name"; + metricParams.LongName = "Metric long name"; + metricParams.ResultType = MetricsDiscovery::TMetricResultType::RESULT_UINT64; + metricParams.MetricType = MetricsDiscovery::TMetricType::METRIC_TYPE_RATIO; + zet_metric_properties_t metricProperties = {}; + + // One api: metric group handle. + zet_metric_group_handle_t metricGroupHandle = {}; + zet_metric_group_properties_t metricGroupProperties = {}; + + openMetricsAdapter(); + + EXPECT_CALL(metricsDevice, GetParams()) + .WillRepeatedly(Return(&metricsDeviceParams)); + + EXPECT_CALL(metricsDevice, GetConcurrentGroup(_)) + .Times(subDeviceCount) + .WillRepeatedly(Return(&metricsConcurrentGroup)); + + EXPECT_CALL(metricsConcurrentGroup, GetParams()) + .Times(subDeviceCount) + .WillRepeatedly(Return(&metricsConcurrentGroupParams)); + + EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_)) + .WillRepeatedly(Return(&metricsSet)); + + EXPECT_CALL(metricsSet, GetParams()) + .WillRepeatedly(Return(&metricsSetParams)); + + EXPECT_CALL(metricsSet, GetMetric(_)) + .Times(subDeviceCount) + .WillRepeatedly(Return(&metric)); + + EXPECT_CALL(metric, GetParams()) + .Times(subDeviceCount) + .WillRepeatedly(Return(&metricParams)); + + EXPECT_CALL(metricsSet, SetApiFiltering(_)) + .WillRepeatedly(Return(TCompletionCode::CC_OK)); + + // Metric group count. + uint32_t metricGroupCount = 0; + EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_SUCCESS); + EXPECT_EQ(metricGroupCount, 1u); + + // Metric group handle. + EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS); + EXPECT_EQ(metricGroupCount, 1u); + EXPECT_NE(metricGroupHandle, nullptr); + + // Metric group properties. + EXPECT_EQ(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_SUCCESS); + EXPECT_EQ(metricGroupProperties.domain, 0u); + EXPECT_EQ(metricGroupProperties.samplingType, ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED); + EXPECT_EQ(metricGroupProperties.metricCount, metricsSetParams.MetricsCount); + EXPECT_EQ(strcmp(metricGroupProperties.description, metricsSetParams.ShortName), 0); + EXPECT_EQ(strcmp(metricGroupProperties.name, metricsSetParams.SymbolName), 0); + + // Obtain metric. + uint32_t metricCount = 0; + zet_metric_handle_t metricHandle = {}; + EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, nullptr), ZE_RESULT_SUCCESS); + EXPECT_EQ(metricCount, 1u); + EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, &metricHandle), ZE_RESULT_SUCCESS); + EXPECT_NE(metricHandle, nullptr); + + // Obtain metric params. + EXPECT_EQ(zetMetricGetProperties(metricHandle, &metricProperties), ZE_RESULT_SUCCESS); + EXPECT_EQ(strcmp(metricProperties.name, metricParams.SymbolName), 0); + EXPECT_EQ(strcmp(metricProperties.description, metricParams.LongName), 0); + EXPECT_EQ(metricProperties.metricType, ZET_METRIC_TYPE_RATIO); + EXPECT_EQ(metricProperties.resultType, ZET_VALUE_TYPE_UINT64); +} + class MetricEnumerationTestMetricTypes : public MetricEnumerationTest, public ::testing::WithParamInterface { public: