intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-08 14:02:58 +08:00
Code Issues Packages Projects Releases Wiki Activity

feature: metrics aggregation for EU Stall

Browse Source 
Resolves: NEO-13999

Signed-off-by: Matias Cabral <matias.a.cabral@intel.com>
This commit is contained in:
Matias Cabral
2025-04-10 00:41:18 +00:00
committed by Compute-Runtime-Automation
parent 447b258c65
commit 25ed9d1989
16 changed files with 1144 additions and 237 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -79,7 +79,7 @@ class MetricIpSamplingFixture : public DeviceFixture,
std::vector<MockMetricIpSamplingOsInterface *> osInterfaceVector = {};
};
class MetricIpSamplingCalculateMetricsFixture : public MetricIpSamplingMultiDevFixture {
class MetricIpSamplingCalculateBaseFixture {
public:
void addHeader(uint8_t *rawDataOut, size_t rawDataOutSize, uint8_t *rawDataIn, size_t rawDataInSize, uint32_t setIndex) {
@@ -90,19 +90,26 @@ class MetricIpSamplingCalculateMetricsFixture : public MetricIpSamplingMultiDevF
header->magic = IpSamplingMetricDataHeader::magicValue;
header->rawDataSize = static_cast<uint32_t>(rawDataInSize);
header->setIndex = setIndex;
memcpy_s(rawDataOut + sizeof(IpSamplingMetricDataHeader), rawDataOutSize, rawDataIn, rawDataInSize);
memcpy_s(rawDataOut + sizeof(IpSamplingMetricDataHeader), rawDataOutSize - sizeof(IpSamplingMetricDataHeader),
rawDataIn, rawDataInSize);
}
}
std::vector<MockStallRawIpData> rawDataVector = {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1000, 0x01},
{1, 9, 8, 7, 6, 5, 4, 3, 2, 1, 1000, 0x02},
{10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 1001, 0x000},
{10, 90, 80, 70, 60, 50, 40, 30, 20, 10, 1000, 0x3}};
{1, 9, 8, 7, 6, 5, 4, 3, 2, 1, 1000, 0x02},
{10, 90, 80, 70, 60, 50, 40, 30, 20, 10, 1000, 0x3},
{100, 190, 180, 170, 160, 150, 140, 130, 120, 110, 1000, 0x3},
{100, 20, 30, 40, 50, 60, 70, 80, 90, 100, 1000, 0x3}};
std::vector<std::string> expectedMetricNamesInReport = {"IP", "Active", "ControlStall", "PipeStall",
"SendStall", "DistStall", "SbidStall", "SyncStall",
"InstrFetchStall", "OtherStall"};
size_t rawDataVectorSize = sizeof(rawDataVector[0]) * rawDataVector.size();
std::vector<zet_typed_value_t> expectedMetricValues = {
{ZET_VALUE_TYPE_UINT64, {1}},
{ZET_VALUE_TYPE_UINT64, {11}},
{ZET_VALUE_TYPE_UINT64, {11}}, // 1st raw report + 3rd raw report
{ZET_VALUE_TYPE_UINT64, {11}},
{ZET_VALUE_TYPE_UINT64, {11}},
{ZET_VALUE_TYPE_UINT64, {11}},
@@ -112,6 +119,7 @@ class MetricIpSamplingCalculateMetricsFixture : public MetricIpSamplingMultiDevF
{ZET_VALUE_TYPE_UINT64, {11}},
{ZET_VALUE_TYPE_UINT64, {11}},
{ZET_VALUE_TYPE_UINT64, {10}},
{ZET_VALUE_TYPE_UINT64, {110}}, // 2nd raw report + 4th raw report
{ZET_VALUE_TYPE_UINT64, {110}},
{ZET_VALUE_TYPE_UINT64, {110}},
{ZET_VALUE_TYPE_UINT64, {110}},
@@ -120,7 +128,74 @@ class MetricIpSamplingCalculateMetricsFixture : public MetricIpSamplingMultiDevF
{ZET_VALUE_TYPE_UINT64, {110}},
{ZET_VALUE_TYPE_UINT64, {110}},
{ZET_VALUE_TYPE_UINT64, {110}},
{ZET_VALUE_TYPE_UINT64, {110}}};
{ZET_VALUE_TYPE_UINT64, {100}},
{ZET_VALUE_TYPE_UINT64, {210}}, // 5th raw report + 6th raw report
{ZET_VALUE_TYPE_UINT64, {210}},
{ZET_VALUE_TYPE_UINT64, {210}},
{ZET_VALUE_TYPE_UINT64, {210}},
{ZET_VALUE_TYPE_UINT64, {210}},
{ZET_VALUE_TYPE_UINT64, {210}},
{ZET_VALUE_TYPE_UINT64, {210}},
{ZET_VALUE_TYPE_UINT64, {210}},
{ZET_VALUE_TYPE_UINT64, {210}}};
std::vector<zet_typed_value_t> interruptedExpectedMetricValues12 = {
{ZET_VALUE_TYPE_UINT64, {1}},
{ZET_VALUE_TYPE_UINT64, {2}},
{ZET_VALUE_TYPE_UINT64, {4}},
{ZET_VALUE_TYPE_UINT64, {5}},
{ZET_VALUE_TYPE_UINT64, {6}},
{ZET_VALUE_TYPE_UINT64, {7}},
{ZET_VALUE_TYPE_UINT64, {8}},
{ZET_VALUE_TYPE_UINT64, {9}},
{ZET_VALUE_TYPE_UINT64, {10}},
{ZET_VALUE_TYPE_UINT64, {3}}, // L0GfxCoreHelperHw arranges "OtherStall" to the end
{ZET_VALUE_TYPE_UINT64, {10}},
{ZET_VALUE_TYPE_UINT64, {20}},
{ZET_VALUE_TYPE_UINT64, {40}},
{ZET_VALUE_TYPE_UINT64, {50}},
{ZET_VALUE_TYPE_UINT64, {60}},
{ZET_VALUE_TYPE_UINT64, {70}},
{ZET_VALUE_TYPE_UINT64, {80}},
{ZET_VALUE_TYPE_UINT64, {90}},
{ZET_VALUE_TYPE_UINT64, {100}},
{ZET_VALUE_TYPE_UINT64, {30}} // L0GfxCoreHelperHw arranges "OtherStall" to the end
};
std::vector<zet_typed_value_t> interruptedExpectedMetricValues3 = {
{ZET_VALUE_TYPE_UINT64, {1}},
{ZET_VALUE_TYPE_UINT64, {9}},
{ZET_VALUE_TYPE_UINT64, {7}},
{ZET_VALUE_TYPE_UINT64, {6}},
{ZET_VALUE_TYPE_UINT64, {5}},
{ZET_VALUE_TYPE_UINT64, {4}},
{ZET_VALUE_TYPE_UINT64, {3}},
{ZET_VALUE_TYPE_UINT64, {2}},
{ZET_VALUE_TYPE_UINT64, {1}},
{ZET_VALUE_TYPE_UINT64, {8}} // L0GfxCoreHelperHw arranges "OtherStall" to the end
};
std::vector<zet_typed_value_t> interruptedExpectedMetricValues456 = {
{ZET_VALUE_TYPE_UINT64, {10}}, // 4rd raw report
{ZET_VALUE_TYPE_UINT64, {90}},
{ZET_VALUE_TYPE_UINT64, {70}},
{ZET_VALUE_TYPE_UINT64, {60}},
{ZET_VALUE_TYPE_UINT64, {50}},
{ZET_VALUE_TYPE_UINT64, {40}},
{ZET_VALUE_TYPE_UINT64, {30}},
{ZET_VALUE_TYPE_UINT64, {20}},
{ZET_VALUE_TYPE_UINT64, {10}},
{ZET_VALUE_TYPE_UINT64, {80}}, // L0GfxCoreHelperHw arranges "OtherStall" to the end
{ZET_VALUE_TYPE_UINT64, {100}},
{ZET_VALUE_TYPE_UINT64, {210}}, // 5th raw report + th raw report
{ZET_VALUE_TYPE_UINT64, {210}},
{ZET_VALUE_TYPE_UINT64, {210}},
{ZET_VALUE_TYPE_UINT64, {210}},
{ZET_VALUE_TYPE_UINT64, {210}},
{ZET_VALUE_TYPE_UINT64, {210}},
{ZET_VALUE_TYPE_UINT64, {210}},
{ZET_VALUE_TYPE_UINT64, {210}},
{ZET_VALUE_TYPE_UINT64, {210}}};
std::vector<MockStallRawIpData> rawDataVectorOverflow = {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1000, 0x01},
{1, 9, 8, 7, 6, 5, 4, 3, 2, 1, 1000, 0x02},
@@ -151,5 +226,10 @@ class MetricIpSamplingCalculateMetricsFixture : public MetricIpSamplingMultiDevF
{ZET_VALUE_TYPE_UINT64, {110}}};
};
struct MetricIpSamplingCalculateSingleDevFixture : public MetricIpSamplingCalculateBaseFixture, MetricIpSamplingFixture {
};
struct MetricIpSamplingCalculateMultiDevFixture : public MetricIpSamplingCalculateBaseFixture, MetricIpSamplingMultiDevFixture {
};
} // namespace ult
} // namespace L0

11
level_zero/tools/test/unit_tests/sources/metrics/mock_metric_source.h
View File

@@ -164,10 +164,17 @@ class MockMetricCalcOp : public MetricCalcOpImp {
ze_result_t getReportFormat(uint32_t *pCount, zet_metric_handle_t *phMetrics) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
};
ze_result_t metricCalculateMultipleValues(size_t rawDataSize, size_t *offset, const uint8_t *pRawData,
ze_result_t metricCalculateMultipleValues(const size_t rawDataSize, size_t *offset, const uint8_t *pRawData,
uint32_t *pSetCount, uint32_t *pMetricReportCountPerSet,
uint32_t *pTotalMetricReportCount,
zet_intel_metric_result_exp_t *pMetricResults) override { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; };
zet_intel_metric_result_exp_t *pMetricResults) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
};
ze_result_t metricCalculateValues(const size_t rawDataSize, size_t *pOffset, const uint8_t *pRawData,
uint32_t *pTotalMetricReportCount,
zet_intel_metric_result_exp_t *pMetricResults) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
};
};
class MockMetricDeviceContext : public MetricDeviceContext {

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

@@ -502,7 +502,7 @@ HWTEST2_F(MetricIpSamplingTimestampTest, GivenGetGpuCpuTimeIsFalseWhenReadingMet
EXPECT_EQ(metricTimestamp, 0UL);
}
using MetricIpSamplingCalculateMetricsTest = MetricIpSamplingCalculateMetricsFixture;
using MetricIpSamplingCalculateMetricsTest = MetricIpSamplingCalculateMultiDevFixture;
HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCalculateMultipleMetricValuesExpIsCalledThenValidDataIsReturned, EustallSupportedPlatforms) {
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
@@ -541,14 +541,14 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
&setCount, &totalMetricValueCount, metricCounts.data(), nullptr),
ZE_RESULT_SUCCESS);
EXPECT_EQ(setCount, expectedSetCount);
EXPECT_EQ(totalMetricValueCount, 20u);
EXPECT_EQ(totalMetricValueCount, 30u); // Three IPs plus nine metrics per IP
EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0],
ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataWithHeader.data()),
&setCount, &totalMetricValueCount, metricCounts.data(), metricValues.data()),
ZE_RESULT_SUCCESS);
EXPECT_EQ(setCount, expectedSetCount);
EXPECT_EQ(totalMetricValueCount, 20u);
EXPECT_EQ(metricCounts[0], 20u);
EXPECT_EQ(totalMetricValueCount, 30u);
EXPECT_EQ(metricCounts[0], 30u);
for (uint32_t i = 0; i < totalMetricValueCount; i++) {
EXPECT_TRUE(expectedMetricValues[i].type == metricValues[i].type);
EXPECT_TRUE(expectedMetricValues[i].value.ui64 == metricValues[i].value.ui64);
@@ -628,14 +628,14 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
&setCount, &totalMetricValueCount, metricCounts.data(), nullptr),
ZE_RESULT_SUCCESS);
EXPECT_EQ(setCount, expectedSetCount);
EXPECT_EQ(totalMetricValueCount, 20u);
EXPECT_EQ(totalMetricValueCount, 30u);
EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0],
ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()),
&setCount, &totalMetricValueCount, metricCounts.data(), metricValues.data()),
ZE_RESULT_SUCCESS);
EXPECT_EQ(setCount, expectedSetCount);
EXPECT_EQ(totalMetricValueCount, 20u);
EXPECT_EQ(metricCounts[0], 20u);
EXPECT_EQ(totalMetricValueCount, 30u);
EXPECT_EQ(metricCounts[0], 30u);
for (uint32_t i = 0; i < totalMetricValueCount; i++) {
EXPECT_TRUE(expectedMetricValues[i].type == metricValues[i].type);
EXPECT_TRUE(expectedMetricValues[i].value.ui64 == metricValues[i].value.ui64);
@@ -716,7 +716,7 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
&setCount, &totalMetricValueCount, metricCounts.data(), nullptr),
ZE_RESULT_SUCCESS);
EXPECT_EQ(setCount, expectedSetCount);
EXPECT_EQ(totalMetricValueCount, 40u);
EXPECT_EQ(totalMetricValueCount, 60u);
totalMetricValueCount = 10;
EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0],
ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size(),
@@ -895,7 +895,7 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
&setCount, &totalMetricValueCount, metricCounts.data(), nullptr),
ZE_RESULT_SUCCESS);
EXPECT_EQ(setCount, expectedSetCount);
EXPECT_EQ(totalMetricValueCount, 20u);
EXPECT_EQ(totalMetricValueCount, 30u);
totalMetricValueCount += 1;
EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0],
ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size() + 1, reinterpret_cast<uint8_t *>(rawDataWithHeader.data()),
@@ -926,11 +926,11 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES,
rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()), &metricValueCount, nullptr),
ZE_RESULT_SUCCESS);
EXPECT_TRUE(metricValueCount == 20);
EXPECT_TRUE(metricValueCount == 30);
EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES,
rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()), &metricValueCount, metricValues.data()),
ZE_RESULT_SUCCESS);
EXPECT_TRUE(metricValueCount == 20);
EXPECT_TRUE(metricValueCount == 30);
for (uint32_t i = 0; i < metricValueCount; i++) {
EXPECT_TRUE(expectedMetricValues[i].type == metricValues[i].type);
EXPECT_TRUE(expectedMetricValues[i].value.ui64 == metricValues[i].value.ui64);
@@ -988,7 +988,7 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES,
rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()), &metricValueCount, nullptr),
ZE_RESULT_SUCCESS);
EXPECT_TRUE(metricValueCount == 20);
EXPECT_TRUE(metricValueCount == 30);
metricValueCount = 15;
EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES,
rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()), &metricValueCount, metricValues.data()),
@@ -1046,7 +1046,7 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES,
rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()), &metricValueCount, nullptr),
ZE_RESULT_SUCCESS);
EXPECT_TRUE(metricValueCount == 20);
EXPECT_TRUE(metricValueCount == 30);
EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES,
rawDataVectorSize - 1, reinterpret_cast<uint8_t *>(rawDataVector.data()), &metricValueCount, metricValues.data()),
ZE_RESULT_ERROR_INVALID_SIZE);
@@ -1125,189 +1125,13 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWith
EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES,
rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()), &metricValueCount, nullptr),
ZE_RESULT_SUCCESS);
EXPECT_TRUE(metricValueCount == 20);
EXPECT_TRUE(metricValueCount == 30);
EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_MAX_METRIC_VALUES,
rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()), &metricValueCount, metricValues.data()),
ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
}
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));
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, givenIpSamplingCalcOpCanGetReportFormat, 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));
uint32_t metricsInReportCount = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation, &metricsInReportCount, nullptr));
EXPECT_EQ(metricsInReportCount, 10u);
std::vector<zet_metric_handle_t> metricsInReport(metricsInReportCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation, &metricsInReportCount, metricsInReport.data()));
EXPECT_EQ(metricsInReportCount, 10u);
zet_metric_properties_t ipSamplingMetricProperties = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGetProperties(metricsInReport[0], &ipSamplingMetricProperties));
EXPECT_EQ(strcmp(ipSamplingMetricProperties.name, "IP"), 0);
// Can't filter metrics in report
metricsInReportCount = 1;
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation, &metricsInReportCount, metricsInReport.data()));
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());

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

@@ -8,8 +8,11 @@
#include "shared/test/common/test_macros/test_base.h"
#include "level_zero/core/source/cmdlist/cmdlist.h"
#include "level_zero/core/source/device/device.h"
#include "level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper.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/metric_ip_sampling_fixture.h"
@@ -545,5 +548,685 @@ TEST_F(MetricIpSamplingStreamerTest, whenGetConcurrentMetricGroupsIsCalledThenCo
}
}
using MetricIpSamplingCalcOpMultiDevTest = MetricIpSamplingCalculateMultiDevFixture;
HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, 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(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingCalcOpCanGetReportFormat, 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));
uint32_t metricsInReportCount = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation, &metricsInReportCount, nullptr));
EXPECT_EQ(metricsInReportCount, 10u);
std::vector<zet_metric_handle_t> metricsInReport(metricsInReportCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation, &metricsInReportCount, metricsInReport.data()));
EXPECT_EQ(metricsInReportCount, 10u);
zet_metric_properties_t ipSamplingMetricProperties = {};
for (uint32_t i = 0; i < metricsInReportCount; i++) {
EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGetProperties(metricsInReport[i], &ipSamplingMetricProperties));
EXPECT_EQ(strcmp(ipSamplingMetricProperties.name, expectedMetricNamesInReport[i].c_str()), 0);
}
// Can't filter metrics in report
metricsInReportCount = 1;
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation, &metricsInReportCount, metricsInReport.data()));
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation));
}
}
HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingCalcOpGetReportFormatIncludesSelectedMetrics, 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);
uint32_t metricCount = 0;
EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricCount, 10u);
std::vector<zet_metric_handle_t> phMetrics(metricCount);
EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, phMetrics.data()), ZE_RESULT_SUCCESS);
std::vector<zet_metric_handle_t> metricsToCalculate;
// select only odd metrics
for (uint32_t i = 0; i < metricCount; i++) {
if (i % 2) {
metricsToCalculate.push_back(phMetrics[i]);
}
}
uint32_t metricsToCalculateCount = static_cast<uint32_t>(metricsToCalculate.size());
EXPECT_EQ(metricsToCalculateCount, 5u);
zet_intel_metric_calculate_exp_desc_t calculateDesc{
ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATE_DESC_EXP,
nullptr, // pNext
0, // metricGroupCount
nullptr, // phMetricGroups
metricsToCalculateCount, // metricCount
metricsToCalculate.data(), // 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));
uint32_t metricsInReportCount = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation, &metricsInReportCount, nullptr));
EXPECT_EQ(metricsInReportCount, 5u);
std::vector<zet_metric_handle_t> metricsInReport(metricsInReportCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation, &metricsInReportCount, metricsInReport.data()));
EXPECT_EQ(metricsInReportCount, 5u);
// Metrics must be in the report but can be in different order
for (auto metric : metricsToCalculate) {
auto it = std::find(metricsInReport.begin(), metricsInReport.end(), metric);
EXPECT_NE(it, metricsInReport.end());
}
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation));
}
}
HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, 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);
}
}
using MetricIpSamplingCalcOpTest = MetricIpSamplingCalculateSingleDevFixture;
HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculateValuesOnSubDeviceThenSuccessIsReturned, EustallSupportedPlatforms) {
EXPECT_EQ(ZE_RESULT_SUCCESS, device->getMetricDeviceContext().enableMetricApi());
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));
uint32_t metricsInReportCount = 10;
std::vector<zet_metric_handle_t> metricsInReport(metricsInReportCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation,
&metricsInReportCount,
metricsInReport.data()));
EXPECT_EQ(metricsInReportCount, 10u);
std::vector<zet_metric_properties_t> metricProperties(metricsInReportCount);
for (uint32_t i = 0; i < metricsInReportCount; i++) {
EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGetProperties(metricsInReport[i], &metricProperties[i]));
}
uint32_t totalMetricReportCount = 0;
size_t offset = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, &offset,
reinterpret_cast<uint8_t *>(rawDataVector.data()), hCalculateOperation,
&totalMetricReportCount, nullptr));
EXPECT_EQ(totalMetricReportCount, 3U);
std::vector<zet_intel_metric_result_exp_t> metricResults(totalMetricReportCount * metricsInReportCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, &offset,
reinterpret_cast<uint8_t *>(rawDataVector.data()), hCalculateOperation,
&totalMetricReportCount, metricResults.data()));
EXPECT_EQ(totalMetricReportCount, 3U);
EXPECT_EQ(offset, rawDataVectorSize);
for (uint32_t i = 0; i < totalMetricReportCount; i++) {
for (uint32_t j = 0; j < metricsInReportCount; j++) {
uint32_t resultIndex = i * metricsInReportCount + j;
EXPECT_TRUE(metricProperties[j].resultType == expectedMetricValues[resultIndex].type);
EXPECT_TRUE(metricResults[resultIndex].value.ui64 == expectedMetricValues[resultIndex].value.ui64);
EXPECT_TRUE(metricResults[resultIndex].resultStatus == ZET_INTEL_METRIC_CALCULATE_EXP_RESULT_VALID);
}
}
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation));
}
HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculateValuesOnSubDevicedCanInterruptAndContinue, EustallSupportedPlatforms) {
EXPECT_EQ(ZE_RESULT_SUCCESS, device->getMetricDeviceContext().enableMetricApi());
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));
uint32_t metricsInReportCount = 10;
std::vector<zet_metric_handle_t> metricsInReport(metricsInReportCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation,
&metricsInReportCount,
metricsInReport.data()));
EXPECT_EQ(metricsInReportCount, 10u);
std::vector<zet_metric_properties_t> metricProperties(metricsInReportCount);
for (uint32_t i = 0; i < metricsInReportCount; i++) {
EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGetProperties(metricsInReport[i], &metricProperties[i]));
}
uint32_t totalMetricReportCount = 0;
size_t processedSize = 0;
size_t offset = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, &offset,
reinterpret_cast<uint8_t *>(rawDataVector.data()), hCalculateOperation,
&totalMetricReportCount, nullptr));
EXPECT_EQ(totalMetricReportCount, 3U);
// Request number of reports smaller than available
totalMetricReportCount = 2;
std::vector<zet_intel_metric_result_exp_t> metricResults(totalMetricReportCount * metricsInReportCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, &offset,
reinterpret_cast<uint8_t *>(rawDataVector.data()), hCalculateOperation,
&totalMetricReportCount, metricResults.data()));
EXPECT_EQ(totalMetricReportCount, 2U);
EXPECT_EQ(offset, IpSamplingMetricGroupBase::rawReportSize * 2);
processedSize += offset;
for (uint32_t i = 0; i < totalMetricReportCount; i++) {
for (uint32_t j = 0; j < metricsInReportCount; j++) {
uint32_t resultIndex = i * metricsInReportCount + j;
EXPECT_TRUE(metricProperties[j].resultType == interruptedExpectedMetricValues12[resultIndex].type);
EXPECT_TRUE(metricResults[resultIndex].value.ui64 == interruptedExpectedMetricValues12[resultIndex].value.ui64);
EXPECT_TRUE(metricResults[resultIndex].resultStatus == ZET_INTEL_METRIC_CALCULATE_EXP_RESULT_VALID);
}
}
// calculate one more report form the offset returned
offset = processedSize;
totalMetricReportCount = 1;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize - processedSize, &offset,
reinterpret_cast<uint8_t *>(rawDataVector.data()), hCalculateOperation,
&totalMetricReportCount, metricResults.data()));
EXPECT_EQ(totalMetricReportCount, 1U);
EXPECT_EQ(offset, IpSamplingMetricGroupBase::rawReportSize);
processedSize += offset;
EXPECT_EQ(processedSize, IpSamplingMetricGroupBase::rawReportSize * 3);
for (uint32_t i = 0; i < totalMetricReportCount; i++) {
for (uint32_t j = 0; j < metricsInReportCount; j++) {
uint32_t resultIndex = i * metricsInReportCount + j;
EXPECT_TRUE(metricProperties[j].resultType == interruptedExpectedMetricValues3[resultIndex].type);
EXPECT_TRUE(metricResults[resultIndex].value.ui64 == interruptedExpectedMetricValues3[resultIndex].value.ui64);
EXPECT_TRUE(metricResults[resultIndex].resultStatus == ZET_INTEL_METRIC_CALCULATE_EXP_RESULT_VALID);
}
}
// calculate remaining reports in raw data.
totalMetricReportCount = 4; // intentionally set to more than left available
metricResults.resize(totalMetricReportCount * metricsInReportCount);
offset = processedSize;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize - processedSize, &offset,
reinterpret_cast<uint8_t *>(rawDataVector.data()), hCalculateOperation,
&totalMetricReportCount, metricResults.data()));
EXPECT_EQ(totalMetricReportCount, 2U);
EXPECT_EQ(offset, IpSamplingMetricGroupBase::rawReportSize * 3);
processedSize += offset;
EXPECT_EQ(processedSize, rawDataVectorSize);
for (uint32_t i = 0; i < totalMetricReportCount; i++) {
for (uint32_t j = 0; j < metricsInReportCount; j++) {
uint32_t resultIndex = i * metricsInReportCount + j;
EXPECT_TRUE(metricProperties[j].resultType == interruptedExpectedMetricValues456[resultIndex].type);
EXPECT_TRUE(metricResults[resultIndex].value.ui64 == interruptedExpectedMetricValues456[resultIndex].value.ui64);
EXPECT_TRUE(metricResults[resultIndex].resultStatus == ZET_INTEL_METRIC_CALCULATE_EXP_RESULT_VALID);
}
}
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation));
}
HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCoverBoundaryConditionsOfFillStallDataMap, EustallSupportedPlatforms) {
EXPECT_EQ(ZE_RESULT_SUCCESS, device->getMetricDeviceContext().enableMetricApi());
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));
uint32_t totalMetricReportCount = 0;
size_t offset = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, &offset,
reinterpret_cast<uint8_t *>(rawDataVector.data()), hCalculateOperation,
&totalMetricReportCount, nullptr));
EXPECT_EQ(totalMetricReportCount, 3U);
IpSamplingMetricCalcOpImp *calcop = static_cast<IpSamplingMetricCalcOpImp *>(MetricCalcOpImp::fromHandle(hCalculateOperation));
size_t rawDataSize = 0;
size_t processedSize = 0;
L0::L0GfxCoreHelper &l0GfxCoreHelper = neoDevice->getRootDeviceEnvironment().getHelper<L0GfxCoreHelper>();
std::map<uint64_t, void *> stallReportDataMap;
bool dataOverflow = false;
bool allowInterrupt = false;
uint32_t requestedReportCount = 0;
// Allow interrupting but pass less than needed for the report count requested
rawDataSize = IpSamplingMetricGroupBase::rawReportSize;
allowInterrupt = true;
requestedReportCount = 2;
calcop->fillStallDataMap(rawDataSize, reinterpret_cast<uint8_t *>(rawDataVector.data()), &processedSize,
l0GfxCoreHelper, stallReportDataMap, &dataOverflow,
allowInterrupt, requestedReportCount);
EXPECT_EQ(stallReportDataMap.size(), 1u);
EXPECT_EQ(processedSize, IpSamplingMetricGroupBase::rawReportSize);
EXPECT_TRUE(dataOverflow == false);
// Sames as above but request just one report
requestedReportCount = 1;
calcop->fillStallDataMap(rawDataSize, reinterpret_cast<uint8_t *>(rawDataVector.data()), &processedSize,
l0GfxCoreHelper, stallReportDataMap, &dataOverflow,
allowInterrupt, requestedReportCount);
EXPECT_EQ(stallReportDataMap.size(), 1u);
EXPECT_EQ(processedSize, IpSamplingMetricGroupBase::rawReportSize);
EXPECT_TRUE(dataOverflow == false);
l0GfxCoreHelper.stallIpDataMapDelete(stallReportDataMap);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation));
}
HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculateValuesOnSubDeviceThenHandleErrorConditions, EustallSupportedPlatforms) {
EXPECT_EQ(ZE_RESULT_SUCCESS, device->getMetricDeviceContext().enableMetricApi());
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));
std::vector<uint8_t> rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader));
addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataVector.data()), rawDataVectorSize, 0);
uint32_t totalMetricReportCount = 0;
size_t offset = 0;
// sub-device cal op does not accept root device data
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateValuesExp(rawDataWithHeader.size(), &offset,
reinterpret_cast<uint8_t *>(rawDataWithHeader.data()), hCalculateOperation,
&totalMetricReportCount, nullptr));
// invalid input raw data size
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_SIZE, zetIntelMetricCalculateValuesExp(rawDataVectorSize / 30, &offset,
reinterpret_cast<uint8_t *>(rawDataVector.data()), hCalculateOperation,
&totalMetricReportCount, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation));
}
HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculateValuesOnSubDeviceCanDetectRawDataOverflow, EustallSupportedPlatforms) {
EXPECT_EQ(ZE_RESULT_SUCCESS, device->getMetricDeviceContext().enableMetricApi());
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));
uint32_t totalMetricReportCount = 2;
size_t offset = 0;
std::vector<zet_intel_metric_result_exp_t> metricResults(totalMetricReportCount * 10);
EXPECT_EQ(ZE_RESULT_WARNING_DROPPED_DATA, zetIntelMetricCalculateValuesExp(rawDataVectorOverflowSize, &offset,
reinterpret_cast<uint8_t *>(rawDataVectorOverflow.data()), hCalculateOperation,
&totalMetricReportCount, metricResults.data()));
EXPECT_EQ(totalMetricReportCount, 2U);
EXPECT_EQ(offset, rawDataVectorOverflowSize);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation));
}
HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculateValuesOnSubDeviceFilterMetricsInReport, EustallSupportedPlatforms) {
EXPECT_EQ(ZE_RESULT_SUCCESS, device->getMetricDeviceContext().enableMetricApi());
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);
uint32_t metricCount = 0;
EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricCount, 10u);
std::vector<zet_metric_handle_t> phMetrics(metricCount);
EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, phMetrics.data()), ZE_RESULT_SUCCESS);
std::vector<zet_metric_handle_t> metricsToCalculate;
// Select only odd index metrics. According to expectedMetricNamesInReport there are:
// "Active", "PipeStall" "DistStall", "SyncStall", "OtherStall"
for (uint32_t i = 0; i < metricCount; i++) {
if (i % 2) {
metricsToCalculate.push_back(phMetrics[i]);
}
}
uint32_t metricsToCalculateCount = static_cast<uint32_t>(metricsToCalculate.size());
EXPECT_EQ(metricsToCalculateCount, 5u);
zet_intel_metric_calculate_exp_desc_t calculateDesc{
ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATE_DESC_EXP,
nullptr, // pNext
0, // metricGroupCount
nullptr, // phMetricGroups
metricsToCalculateCount, // metricCount
metricsToCalculate.data(), // 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));
uint32_t metricsInReportCount = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation, &metricsInReportCount, nullptr));
EXPECT_EQ(metricsInReportCount, 5u);
// calculate only one report and expect results follow the order of rawDataVector
uint32_t totalMetricReportCount = 1;
size_t offset = 0;
std::vector<zet_intel_metric_result_exp_t> metricResults(totalMetricReportCount * metricsInReportCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, &offset,
reinterpret_cast<uint8_t *>(rawDataVector.data()), hCalculateOperation,
&totalMetricReportCount, metricResults.data()));
EXPECT_EQ(totalMetricReportCount, 1U);
EXPECT_EQ(offset, IpSamplingMetricGroupBase::rawReportSize);
// Expect only odd index metrics results of the first report
for (uint32_t j = 0; j < metricsInReportCount; j++) {
EXPECT_TRUE(metricResults[j].value.ui64 == interruptedExpectedMetricValues12[j * 2 + 1].value.ui64);
}
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation));
}
HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, GivenIpSamplingCalcOpCallingMetricCalculateValuesOnRootDeviceExpectSuccess, EustallSupportedPlatforms) {
auto device = testDevices[0];
ze_device_properties_t props = {};
device->getProperties(&props);
EXPECT_EQ(props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE, 0u);
EXPECT_EQ(ZE_RESULT_SUCCESS, device->getMetricDeviceContext().enableMetricApi());
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));
std::vector<uint8_t> rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader));
addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataVector.data()), rawDataVectorSize, 0);
uint32_t totalMetricReportCount = 0;
size_t offset = 0;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetIntelMetricCalculateValuesExp(rawDataWithHeader.size(), &offset,
reinterpret_cast<uint8_t *>(rawDataWithHeader.data()), hCalculateOperation,
&totalMetricReportCount, nullptr));
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateValuesExp(rawDataVectorSize, &offset,
reinterpret_cast<uint8_t *>(rawDataVector.data()), hCalculateOperation,
&totalMetricReportCount, nullptr));
uint32_t setCount = 0;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetIntelMetricCalculateMultipleValuesExp(rawDataVectorSize, &offset,
reinterpret_cast<uint8_t *>(rawDataVector.data()),
hCalculateOperation, &setCount, nullptr,
nullptr, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation));
}
} // namespace ult
} // namespace L0

7
level_zero/tools/test/unit_tests/sources/metrics/test_metric_tracer.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2024 Intel Corporation
* Copyright (C) 2024-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -7,6 +7,7 @@
#include "shared/test/common/test_macros/test.h"
#include "level_zero/include/level_zero/zet_intel_gpu_metric.h"
#include <level_zero/zet_api.h>
#include "gtest/gtest.h"
@@ -25,6 +26,10 @@ TEST(MetricTracerTest, WhenTracerRelatedApisAreCalledThenReturnUnsupportedFeatur
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetMetricDecoderDestroyExp(nullptr));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetMetricDecoderGetDecodableMetricsExp(nullptr, nullptr, nullptr));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetMetricTracerDecodeExp(nullptr, nullptr, nullptr, 0, nullptr, nullptr, nullptr, nullptr, nullptr));
size_t rawDataSize = 0;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetIntelMetricDecodeCalculateMultipleValuesExp(nullptr,
rawDataSize, nullptr, nullptr, nullptr,
nullptr, nullptr, nullptr, nullptr));
}
} // namespace ult