Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Metric Api: Metric enumeration for all sub devices. 

Signed-off-by: Robert Krzemien <robert.krzemien@intel.com>
Signed-off-by: Joshua Santosh Ranjan <joshua.santosh.ranjan@intel.com>

Related-To: LOCI-2422
This commit is contained in:
Robert Krzemien 2021-07-13 11:10:59 +00:00 committed by Compute-Runtime-Automation
parent b7bdb3b9ce
commit 7a0b3f4c03
4 changed files with 244 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

97
level_zero/tools/source/metrics/metric_enumeration_imp.cpp
View File

@ -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<uint32_t>(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<DeviceImp *>(&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<uint32_t>(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<DeviceImp *>(&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<DeviceImp *>(&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<DeviceImp *>(&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<uint32_t>(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<uint32_t>(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<zet_metric_group_handle_t> &MetricGroupImp::getMetricGroups() {
return metricGroups;
}
void MetricGroupImp::copyProperties(const zet_metric_group_properties_t &source,
zet_metric_group_properties_t &destination) {
destination = source;

6
level_zero/tools/source/metrics/metric_enumeration_imp.h
View File

@ -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<zet_metric_group_handle_t> &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<zet_metric_group_handle_t> metricGroups;
};
struct MetricImp : Metric {

26
level_zero/tools/test/unit_tests/sources/metrics/mock_metric.cpp
View File

@ -146,6 +146,9 @@ void MetricMultiDeviceFixture::TearDown() {
void MetricMultiDeviceFixture::openMetricsAdapter() {
auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
const uint32_t subDeviceCount = static_cast<uint32_t>(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<DeviceImp *>(devices[0]);
const uint32_t subDeviceCount = static_cast<uint32_t>(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() {

172
level_zero/tools/test/unit_tests/sources/metrics/test_metric_enumeration.cpp
View File

@ -886,6 +886,9 @@ using MultiDeviceMetricEnumerationTest = Test<MetricMultiDeviceContextFixture>;
TEST_F(MultiDeviceMetricEnumerationTest, givenMultipleDevicesAndValidEventBasedMetricGroupWhenzetContextActivateMetricGroupsIsCalledThenReturnsSuccess) {
auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
const uint32_t subDeviceCount = static_cast<uint32_t>(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<DeviceImp *>(devices[0]);
const uint32_t subDeviceCount = static_cast<uint32_t>(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<uint32_t>(devices.size());
auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
Mock<IAdapterGroup_1_9> mockAdapterGroup;
Mock<IAdapter_1_9> mockAdapter;
Mock<IMetricsDevice_1_5> 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<DeviceImp *>(devices[0]);
const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
// Metrics Discovery device.
metricsDeviceParams.ConcurrentGroupsCount = 1;
// Metrics Discovery concurrent group.
Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
metricsConcurrentGroupParams.MetricSetsCount = 1;
metricsConcurrentGroupParams.SymbolName = "OA";
metricsConcurrentGroupParams.Description = "OA description";
// Metrics Discovery:: metric set.
Mock<MetricsDiscovery::IMetricSet_1_5> 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<IMetric_1_0> 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<MetricsDiscovery::TMetricType> {
public: