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

feature: calculate operation for IP sampling 

Resolves: NEO-13997

Signed-off-by: Matias Cabral <matias.a.cabral@intel.com>
This commit is contained in:
Matias Cabral 2025-03-14 19:21:13 +00:00 committed by Compute-Runtime-Automation
parent 6e17df4fb3
commit 38506298d3
9 changed files with 244 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
level_zero/tools/source/metrics/metric.cpp
View File

@ -531,12 +531,14 @@ ze_result_t MetricDeviceContext::calcOperationCreate(zet_context_handle_t hConte
METRICS_LOG_ERR("%s", "Metrics must be from the same domain");
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
if (!areMetricsFromSameDeviceHierarchy(pCalculateDesc->metricCount, pCalculateDesc->phMetrics)) {
metricImp = static_cast<MetricImp *>(Metric::fromHandle(pCalculateDesc->phMetrics[0]));
// IpSampling does not use multi-device metrics
if ((metricImp->getMetricSource().getType() != MetricSource::metricSourceTypeIpSampling) &&
(!areMetricsFromSameDeviceHierarchy(pCalculateDesc->metricCount, pCalculateDesc->phMetrics))) {
METRICS_LOG_ERR("%s", "Mix of root device and sub-device metric handle is not allowed");
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
metricImp = static_cast<MetricImp *>(Metric::fromHandle(pCalculateDesc->phMetrics[0]));
}
if (pCalculateDesc->metricGroupCount > 0) {

16
level_zero/tools/source/metrics/metric_ip_sampling_source.cpp
View File

@ -243,6 +243,22 @@ ze_result_t IpSamplingMetricSourceImp::handleMetricGroupExtendedProperties(zet_m
return retVal;
}
ze_result_t IpSamplingMetricSourceImp::calcOperationCreate(MetricDeviceContext &metricDeviceContext,
zet_intel_metric_calculate_exp_desc_t *pCalculateDesc,
uint32_t *pCount,
zet_metric_handle_t *phExcludedMetrics,
zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation) {
ze_result_t status = ZE_RESULT_ERROR_UNKNOWN;
// All metrics in Ip sampling allow calculation
*pCount = 0;
*phExcludedMetrics = nullptr;
bool isMultiDevice = (metricDeviceContext.isImplicitScalingCapable()) ? true : false;
status = IpSamplingMetricCalcOpImp::create(*this, pCalculateDesc, isMultiDevice, phCalculateOperation);
return status;
}
IpSamplingMetricGroupImp::IpSamplingMetricGroupImp(IpSamplingMetricSourceImp &metricSource,
std::vector<IpSamplingMetricImp> &metrics) : IpSamplingMetricGroupBase(metricSource) {
this->metrics.reserve(metrics.size());

4
level_zero/tools/source/metrics/metric_ip_sampling_source.h
View File

@ -61,9 +61,7 @@ class IpSamplingMetricSourceImp : public MetricSource {
zet_intel_metric_calculate_exp_desc_t *pCalculateDesc,
uint32_t *pCount,
zet_metric_handle_t *phExcludedMetrics,
zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation) override;
uint32_t metricSourceCount = 0;

45
level_zero/tools/source/metrics/metric_ip_sampling_streamer.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2022-2023 Intel Corporation
* Copyright (C) 2022-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -13,6 +13,7 @@
#include "level_zero/tools/source/metrics/os_interface_metric.h"
#include <level_zero/zet_api.h>
#include <set>
#include <string.h>
namespace L0 {
@ -94,6 +95,48 @@ uint32_t IpSamplingMetricStreamerImp::getMaxSupportedReportCount() {
return ipSamplingSource.getMetricOsInterface()->getRequiredBufferSize(UINT32_MAX) / unitReportSize;
}
ze_result_t IpSamplingMetricCalcOpImp::create(IpSamplingMetricSourceImp &metricSource,
zet_intel_metric_calculate_exp_desc_t *pCalculateDesc,
bool isMultiDevice,
zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation) {
// There is only one valid metric group in IP sampling and time filtering is not supported
// So only metrics handles are used to filter the metrics
// avoid duplicates
std::set<zet_metric_handle_t> uniqueMetricHandles(pCalculateDesc->phMetrics, pCalculateDesc->phMetrics + pCalculateDesc->metricCount);
// The order of metrics in the report should be the same as the one in the HW report to optimize calculation
uint32_t metricGroupCount = 1;
zet_metric_group_handle_t hMetricGroup = {};
metricSource.metricGroupGet(&metricGroupCount, &hMetricGroup);
uint32_t metricCount = 0;
MetricGroup::fromHandle(hMetricGroup)->metricGet(&metricCount, nullptr);
std::vector<zet_metric_handle_t> hMetrics(metricCount);
MetricGroup::fromHandle(hMetricGroup)->metricGet(&metricCount, hMetrics.data());
std::vector<MetricImp *> inputMetricsInReport = {};
for (uint32_t i = 0; i < metricCount; i++) {
auto metric = static_cast<MetricImp *>(Metric::fromHandle(hMetrics[i]));
if (pCalculateDesc->metricGroupCount > 0) {
inputMetricsInReport.push_back(metric);
} else {
if (uniqueMetricHandles.find(hMetrics[i]) != uniqueMetricHandles.end()) {
inputMetricsInReport.push_back(metric);
}
}
}
auto calcOp = new IpSamplingMetricCalcOpImp(inputMetricsInReport, isMultiDevice);
*phCalculateOperation = calcOp->toHandle();
return ZE_RESULT_SUCCESS;
}
ze_result_t IpSamplingMetricCalcOpImp::destroy() {
delete this;
return ZE_RESULT_SUCCESS;
}
ze_result_t MultiDeviceIpSamplingMetricGroupImp::streamerOpen(
zet_context_handle_t hContext,
zet_device_handle_t hDevice,

32
level_zero/tools/source/metrics/metric_ip_sampling_streamer.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2022-2023 Intel Corporation
* Copyright (C) 2022-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -13,6 +13,7 @@
namespace L0 {
class IpSamplingMetricSourceImp;
struct IpSamplingMetricImp;
struct IpSamplingMetricStreamerBase : public MetricStreamer {
ze_result_t appendStreamerMarker(CommandList &commandList, uint32_t value) override { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; }
@ -43,4 +44,33 @@ struct MultiDeviceIpSamplingMetricStreamerImp : public IpSamplingMetricStreamerB
std::vector<IpSamplingMetricStreamerImp *> subDeviceStreamers = {};
};
struct IpSamplingMetricCalcOpImp : public MetricCalcOpImp {
IpSamplingMetricCalcOpImp(std::vector<MetricImp *> &inputMetricsInReport,
bool multidevice) : MetricCalcOpImp(multidevice),
metricCount(static_cast<uint32_t>(inputMetricsInReport.size())),
metricsInReport(inputMetricsInReport) {}
~IpSamplingMetricCalcOpImp() override{};
static ze_result_t create(IpSamplingMetricSourceImp &metricSource,
zet_intel_metric_calculate_exp_desc_t *pCalculateDesc,
bool isMultiDevice,
zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation);
ze_result_t destroy() override;
ze_result_t getReportFormat(uint32_t *pCount, zet_metric_handle_t *phMetrics) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
std::vector<MetricImp *> &getMetricsInReport() { return metricsInReport; };
uint32_t getMetricsInReportCount() { return metricCount; };
ze_result_t metricCalculateMultipleValues(size_t rawDataSize, size_t *offset, const uint8_t *pRawData,
uint32_t *pSetCount, uint32_t *pMetricsReportCountPerSet,
uint32_t *pTotalMetricReportCount,
zet_intel_metric_result_exp_t *pMetricResults) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
protected:
uint32_t metricCount = 0;
std::vector<MetricImp *> metricsInReport{};
};
} // namespace L0

8
level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.cpp
View File

@ -18,7 +18,7 @@ extern std::vector<_ze_driver_handle_t *> *globalDriverHandles;
namespace ult {
void MetricIpSamplingFixture::SetUp() {
void MetricIpSamplingMultiDevFixture::SetUp() {
debugManager.flags.EnableImplicitScaling.set(1);
@ -51,12 +51,12 @@ void MetricIpSamplingFixture::SetUp() {
globalDriverHandles->push_back(driverHandle.get());
}
void MetricIpSamplingFixture::TearDown() {
void MetricIpSamplingMultiDevFixture::TearDown() {
MultiDeviceFixture::tearDown();
globalDriverHandles->clear();
}
void MetricIpSamplingTimestampFixture::SetUp() {
void MetricIpSamplingFixture::SetUp() {
DeviceFixture::setUp();
auto mockMetricIpSamplingOsInterface = new MockMetricIpSamplingOsInterface();
osInterfaceVector.push_back(mockMetricIpSamplingOsInterface);
@ -71,7 +71,7 @@ void MetricIpSamplingTimestampFixture::SetUp() {
globalDriverHandles->push_back(driverHandle.get());
}
void MetricIpSamplingTimestampFixture::TearDown() {
void MetricIpSamplingFixture::TearDown() {
DeviceFixture::tearDown();
globalDriverHandles->clear();
}

12
level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2022-2024 Intel Corporation
* Copyright (C) 2022-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -59,8 +59,8 @@ class MockStallRawIpData {
rawData[7] = 0;
}
};
class MetricIpSamplingFixture : public MultiDeviceFixture,
public ::testing::Test {
class MetricIpSamplingMultiDevFixture : public MultiDeviceFixture,
public ::testing::Test {
public:
void SetUp() override;
void TearDown() override;
@ -69,8 +69,8 @@ class MetricIpSamplingFixture : public MultiDeviceFixture,
std::vector<L0::Device *> testDevices = {};
};
class MetricIpSamplingTimestampFixture : public DeviceFixture,
public ::testing::Test {
class MetricIpSamplingFixture : public DeviceFixture,
public ::testing::Test {
public:
void SetUp() override;
void TearDown() override;
@ -79,7 +79,7 @@ class MetricIpSamplingTimestampFixture : public DeviceFixture,
std::vector<MockMetricIpSamplingOsInterface *> osInterfaceVector = {};
};
class MetricIpSamplingCalculateMetricsFixture : public MetricIpSamplingFixture {
class MetricIpSamplingCalculateMetricsFixture : public MetricIpSamplingMultiDevFixture {
public:
void addHeader(uint8_t *rawDataOut, size_t rawDataOutSize, uint8_t *rawDataIn, size_t rawDataInSize, uint32_t setIndex) {

203
level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_enumeration.cpp
View File

@ -12,9 +12,11 @@
#include "level_zero/core/source/cmdlist/cmdlist.h"
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
#include "level_zero/tools/source/metrics/metric_ip_sampling_source.h"
#include "level_zero/tools/source/metrics/metric_ip_sampling_streamer.h"
#include "level_zero/tools/source/metrics/metric_oa_source.h"
#include "level_zero/tools/source/metrics/os_interface_metric.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_ip_sampling.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_source.h"
#include "level_zero/zet_intel_gpu_metric.h"
#include "level_zero/zet_intel_gpu_metric_export.h"
#include <level_zero/zet_api.h>
@ -26,7 +28,7 @@ extern _ze_driver_handle_t *globalDriverHandle;
namespace ult {
using MetricIpSamplingEnumerationTest = MetricIpSamplingFixture;
using MetricIpSamplingEnumerationTest = MetricIpSamplingMultiDevFixture;
HWTEST2_F(MetricIpSamplingEnumerationTest, GivenDependenciesAvailableWhenInititializingThenSuccessIsReturned, EustallSupportedPlatforms) {
@ -428,7 +430,7 @@ HWTEST2_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulOnMulitDe
}
}
using MetricIpSamplingTimestampTest = MetricIpSamplingTimestampFixture;
using MetricIpSamplingTimestampTest = MetricIpSamplingFixture;
HWTEST2_F(MetricIpSamplingTimestampTest, GivenEnumerationIsSuccessfulWhenReadingMetricsFrequencyThenValuesAreUpdated, EustallSupportedPlatforms) {
@ -1130,6 +1132,136 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWith
}
}
using MetricIpSamplingCalcOpTest = MetricIpSamplingMultiDevFixture;
HWTEST2_F(MetricIpSamplingCalcOpTest, givenIpSamplingMetricGroupThenCreateAndDestroyCalcOpIsSuccessful, EustallSupportedPlatforms) {
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
for (auto device : testDevices) {
ze_device_properties_t props = {};
device->getProperties(&props);
uint32_t metricGroupCount = 1;
zet_metric_group_handle_t metricGroupHandle = nullptr;
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
zet_intel_metric_calculate_exp_desc_t calculateDesc{
ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATE_DESC_EXP,
nullptr, // pNext
1, // metricGroupCount
&metricGroupHandle, // phMetricGroups
0, // metricCount
nullptr, // phMetrics
0, // timeWindowsCount
nullptr, // pCalculateTimeWindows
1000, // timeAggregationWindow
};
zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation;
uint32_t excludedMetricsCount = 0;
zet_metric_handle_t phExcludedMetrics;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationCreateExp(context->toHandle(),
device->toHandle(), &calculateDesc,
&excludedMetricsCount, &phExcludedMetrics,
&hCalculateOperation));
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation));
uint32_t metricCount = 0;
EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricCount, 10u);
zet_metric_handle_t phMetric{};
metricCount = 1;
EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, &phMetric), ZE_RESULT_SUCCESS);
calculateDesc.metricGroupCount = 0;
calculateDesc.metricCount = 1;
calculateDesc.phMetrics = &phMetric;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationCreateExp(context->toHandle(),
device->toHandle(), &calculateDesc,
&excludedMetricsCount, &phExcludedMetrics,
&hCalculateOperation));
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation));
}
}
HWTEST2_F(MetricIpSamplingCalcOpTest, givenIpSamplingCalcOpCheckUnsupportedAPIs, EustallSupportedPlatforms) {
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
for (auto device : testDevices) {
uint32_t metricGroupCount = 1;
zet_metric_group_handle_t metricGroupHandle = nullptr;
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
zet_intel_metric_calculate_exp_desc_t calculateDesc{
ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATE_DESC_EXP,
nullptr, // pNext
1, // metricGroupCount
&metricGroupHandle, // phMetricGroups
0, // metricCount
nullptr, // phMetrics
0, // timeWindowsCount
nullptr, // pCalculateTimeWindows
1000, // timeAggregationWindow
};
zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation;
uint32_t excludedMetricsCount = 0;
zet_metric_handle_t phExcludedMetrics;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationCreateExp(context->toHandle(),
device->toHandle(), &calculateDesc,
&excludedMetricsCount, &phExcludedMetrics,
&hCalculateOperation));
auto calcOpImp = static_cast<IpSamplingMetricCalcOpImp *>(MetricCalcOp::fromHandle(hCalculateOperation));
uint32_t count;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, calcOpImp->getReportFormat(&count, nullptr));
std::vector<MetricImp *> metricsInReport = calcOpImp->getMetricsInReport();
EXPECT_EQ(10U, metricsInReport.size());
uint32_t metricsInReportCount = calcOpImp->getMetricsInReportCount();
EXPECT_EQ(10U, metricsInReportCount);
size_t rawDataSize = 0;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, calcOpImp->metricCalculateMultipleValues(rawDataSize, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation));
}
}
HWTEST2_F(MetricIpSamplingCalcOpTest, WhenReadingMetricGroupTimeCalculateFilterThenCorrectValueIsReturned, EustallSupportedPlatforms) {
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
for (auto device : testDevices) {
uint32_t metricGroupCount = 0;
zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr);
EXPECT_EQ(metricGroupCount, 1u);
std::vector<zet_metric_group_handle_t> metricGroups;
metricGroups.resize(metricGroupCount);
ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
ASSERT_NE(metricGroups[0], nullptr);
zet_intel_metric_group_calculate_properties_exp_t metricGroupCalcProps{};
metricGroupCalcProps.stype = ZET_INTEL_STRUCTURE_TYPE_METRIC_GROUP_CALCULATE_EXP_PROPERTIES;
metricGroupCalcProps.pNext = nullptr;
metricGroupCalcProps.isTimeFilterSupported = true;
zet_metric_group_properties_t properties{};
properties.pNext = &metricGroupCalcProps;
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &properties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(properties.description, "EU stall sampling"), 0);
EXPECT_EQ(strcmp(properties.name, "EuStallSampling"), 0);
EXPECT_EQ(metricGroupCalcProps.isTimeFilterSupported, false);
}
}
HWTEST2_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulWhenQueryPoolCreateIsCalledThenUnsupportedFeatureIsReturned, EustallSupportedPlatforms) {
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
@ -1163,7 +1295,7 @@ HWTEST2_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulWhenAppen
EXPECT_EQ(zetCommandListAppendMetricMemoryBarrier(commandListHandle), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
using MetricExportDataIpSamplingTest = MetricIpSamplingEnumerationTest;
using MetricExportDataIpSamplingTest = MetricIpSamplingMultiDevFixture;
HWTEST2_F(MetricExportDataIpSamplingTest, WhenMetricGroupGetExportDataIsCalledThenReturnSuccess, EustallSupportedPlatforms) {
@ -1297,70 +1429,5 @@ HWTEST2_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulWhenUnsup
}
}
HWTEST2_F(MetricIpSamplingEnumerationTest, givenValidIPSamplingMetricGroupThenOASourceCalcOperationIsCalled, EustallSupportedPlatforms) {
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
uint32_t metricGroupCount = 1;
zet_metric_group_handle_t metricGroupHandle = nullptr;
EXPECT_EQ(zetMetricGroupGet(testDevices[0]->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
// metric groups from different source
zet_intel_metric_calculate_exp_desc_t calculateDesc{
ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATE_DESC_EXP,
nullptr, // pNext
1, // metricGroupCount
&metricGroupHandle, // phMetricGroups
0, // metricCount
nullptr, // phMetrics
0, // timeWindowsCount
nullptr, // pCalculateTimeWindows
1000, // timeAggregationWindow
};
zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation;
uint32_t excludedMetricsCount = 0;
zet_metric_handle_t *phExcludedMetrics = nullptr;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetIntelMetricCalculateOperationCreateExp(context->toHandle(),
testDevices[0]->toHandle(), &calculateDesc,
&excludedMetricsCount, phExcludedMetrics,
&hCalculateOperation));
}
HWTEST2_F(MetricIpSamplingEnumerationTest, WhenReadingMetricGroupTimeCalculateFilterThenCorrectValueIsReturned, EustallSupportedPlatforms) {
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
for (auto device : testDevices) {
ze_device_properties_t deviceProps = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES_1_2, nullptr};
device->getProperties(&deviceProps);
uint32_t metricGroupCount = 0;
zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr);
EXPECT_EQ(metricGroupCount, 1u);
std::vector<zet_metric_group_handle_t> metricGroups;
metricGroups.resize(metricGroupCount);
ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
ASSERT_NE(metricGroups[0], nullptr);
zet_intel_metric_group_calculate_properties_exp_t metricGroupCalcProps{};
metricGroupCalcProps.stype = ZET_INTEL_STRUCTURE_TYPE_METRIC_GROUP_CALCULATE_EXP_PROPERTIES;
metricGroupCalcProps.pNext = nullptr;
metricGroupCalcProps.isTimeFilterSupported = true;
zet_metric_group_properties_t properties{};
properties.pNext = &metricGroupCalcProps;
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &properties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(properties.description, "EU stall sampling"), 0);
EXPECT_EQ(strcmp(properties.name, "EuStallSampling"), 0);
EXPECT_EQ(metricGroupCalcProps.isTimeFilterSupported, false);
}
}
} // namespace ult
} // namespace L0

4
level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_streamer.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2022-2024 Intel Corporation
* Copyright (C) 2022-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -21,7 +21,7 @@ extern _ze_driver_handle_t *globalDriverHandle;
namespace ult {
class MetricIpSamplingStreamerTest : public MetricIpSamplingFixture {
class MetricIpSamplingStreamerTest : public MetricIpSamplingMultiDevFixture {
public:
zet_metric_group_handle_t getMetricGroup(L0::Device *device) {