Skip to content

Commit bc6eb0a

Browse files
matcabralCompute-Runtime-Automation
matcabral
authored and
Compute-Runtime-Automation
committed
feature: EUStall calcOp accept metrics handles
Resolves: NEO-16534 Signed-off-by: Matias Cabral <matias.a.cabral@intel.com>
1 parent cfa007e commit bc6eb0a

File tree

5 files changed

+168
-22
lines changed

5 files changed

+168
-22
lines changed

‎level_zero/tools/source/metrics/metric_ip_sampling_source.cpp‎

Lines changed: 34 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -81,8 +81,23 @@ ze_result_t IpSamplingMetricSourceImp::cacheMetricGroup() {
8181
subDeviceMetricGroup.push_back(static_cast<IpSamplingMetricGroupImp *>(MetricGroup::fromHandle(hMetricGroup)));
8282
}
8383

84-
IpSamplingMetricSourceImp &source = deviceImp->getMetricDeviceContext().getMetricSource<IpSamplingMetricSourceImp>();
85-
cachedMetricGroup = MultiDeviceIpSamplingMetricGroupImp::create(source, subDeviceMetricGroup);
84+
UNRECOVERABLE_IF(subDeviceMetricGroup.size() == 0);
85+
IpSamplingMetricSourceImp &rootDevSource = deviceImp->getMetricDeviceContext().getMetricSource<IpSamplingMetricSourceImp>();
86+
uint32_t pCount = 0;
87+
subDeviceMetricGroup[0]->metricGet(&pCount, nullptr);
88+
std::vector<zet_metric_handle_t> hMetrics(pCount);
89+
subDeviceMetricGroup[0]->metricGet(&pCount, hMetrics.data());
90+
std::vector<IpSamplingMetricImp> metrics = {};
91+
92+
// Root device metrics must have the root device source
93+
for (const auto &hMetric : hMetrics) {
94+
zet_metric_properties_t metricProperties = {ZET_STRUCTURE_TYPE_METRIC_PROPERTIES, nullptr};
95+
Metric::fromHandle(hMetric)->getProperties(&metricProperties);
96+
std::vector<MetricScopeImp *> scopes{};
97+
metrics.push_back(IpSamplingMetricImp(rootDevSource, metricProperties, scopes));
98+
}
99+
100+
cachedMetricGroup = MultiDeviceIpSamplingMetricGroupImp::create(rootDevSource, subDeviceMetricGroup, metrics);
86101
return ZE_RESULT_SUCCESS;
87102
}
88103

@@ -323,7 +338,8 @@ ze_result_t IpSamplingMetricGroupImp::getProperties(zet_metric_group_properties_
323338
return ZE_RESULT_SUCCESS;
324339
}
325340

326-
ze_result_t IpSamplingMetricGroupImp::metricGet(uint32_t *pCount, zet_metric_handle_t *phMetrics) {
341+
ze_result_t IpSamplingMetricGroupBase::metricGet(uint32_t *pCount,
342+
zet_metric_handle_t *phMetrics) {
327343

328344
if (*pCount == 0) {
329345
*pCount = static_cast<uint32_t>(metrics.size());
@@ -421,10 +437,6 @@ ze_result_t MultiDeviceIpSamplingMetricGroupImp::getProperties(zet_metric_group_
421437
return subDeviceMetricGroup[0]->getProperties(pProperties);
422438
}
423439

424-
ze_result_t MultiDeviceIpSamplingMetricGroupImp::metricGet(uint32_t *pCount, zet_metric_handle_t *phMetrics) {
425-
return subDeviceMetricGroup[0]->metricGet(pCount, phMetrics);
426-
}
427-
428440
ze_result_t MultiDeviceIpSamplingMetricGroupImp::calculateMetricValues(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
429441
const uint8_t *pRawData, uint32_t *pMetricValueCount,
430442
zet_typed_value_t *pMetricValues) {
@@ -507,9 +519,22 @@ ze_result_t MultiDeviceIpSamplingMetricGroupImp::getMetricTimestampsExp(const ze
507519

508520
std::unique_ptr<MultiDeviceIpSamplingMetricGroupImp> MultiDeviceIpSamplingMetricGroupImp::create(
509521
MetricSource &metricSource,
510-
std::vector<IpSamplingMetricGroupImp *> &subDeviceMetricGroup) {
522+
std::vector<IpSamplingMetricGroupImp *> &subDeviceMetricGroup,
523+
std::vector<IpSamplingMetricImp> &ipSamplingMetrics) {
511524
UNRECOVERABLE_IF(subDeviceMetricGroup.size() == 0);
512-
return std::unique_ptr<MultiDeviceIpSamplingMetricGroupImp>(new (std::nothrow) MultiDeviceIpSamplingMetricGroupImp(metricSource, subDeviceMetricGroup));
525+
UNRECOVERABLE_IF(ipSamplingMetrics.size() == 0);
526+
return std::unique_ptr<MultiDeviceIpSamplingMetricGroupImp>(new (std::nothrow) MultiDeviceIpSamplingMetricGroupImp(
527+
metricSource, subDeviceMetricGroup, ipSamplingMetrics));
528+
}
529+
530+
MultiDeviceIpSamplingMetricGroupImp::MultiDeviceIpSamplingMetricGroupImp(
531+
MetricSource &metricSource,
532+
std::vector<IpSamplingMetricGroupImp *> &subDeviceMetricGroup,
533+
std::vector<IpSamplingMetricImp> &ipSamplingMetrics) : IpSamplingMetricGroupBase(metricSource), subDeviceMetricGroup(subDeviceMetricGroup) {
534+
isMultiDevice = true;
535+
for (auto &metric : ipSamplingMetrics) {
536+
this->metrics.push_back(std::make_unique<IpSamplingMetricImp>(metric));
537+
}
513538
}
514539

515540
IpSamplingMetricImp::IpSamplingMetricImp(MetricSource &metricSource, zet_metric_properties_t &properties, std::vector<MetricScopeImp *> &scopes)

‎level_zero/tools/source/metrics/metric_ip_sampling_source.h‎

Lines changed: 12 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -83,9 +83,11 @@ class IpSamplingMetricSourceImp : public MetricSource {
8383

8484
struct IpSamplingMetricGroupBase : public MetricGroupImp {
8585
IpSamplingMetricGroupBase(MetricSource &metricSource) : MetricGroupImp(metricSource) {}
86+
~IpSamplingMetricGroupBase() override = default;
8687

8788
bool activate() override { return true; }
8889
bool deactivate() override { return true; };
90+
ze_result_t metricGet(uint32_t *pCount, zet_metric_handle_t *phMetrics) override;
8991
ze_result_t metricQueryPoolCreate(
9092
zet_context_handle_t hContext,
9193
zet_device_handle_t hDevice,
@@ -106,14 +108,16 @@ struct IpSamplingMetricGroupBase : public MetricGroupImp {
106108
}
107109

108110
IpSamplingMetricSourceImp &getMetricSource() { return static_cast<IpSamplingMetricSourceImp &>(metricSource); }
111+
112+
protected:
113+
std::vector<std::unique_ptr<IpSamplingMetricImp>> metrics = {};
109114
};
110115

111116
struct IpSamplingMetricGroupImp : public IpSamplingMetricGroupBase {
112117
IpSamplingMetricGroupImp(IpSamplingMetricSourceImp &metricSource, std::vector<IpSamplingMetricImp> &metrics);
113118
~IpSamplingMetricGroupImp() override = default;
114119

115120
ze_result_t getProperties(zet_metric_group_properties_t *pProperties) override;
116-
ze_result_t metricGet(uint32_t *pCount, zet_metric_handle_t *phMetrics) override;
117121
ze_result_t calculateMetricValues(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
118122
const uint8_t *pRawData, uint32_t *pMetricValueCount,
119123
zet_typed_value_t *pMetricValues) override;
@@ -135,18 +139,17 @@ struct IpSamplingMetricGroupImp : public IpSamplingMetricGroupBase {
135139
std::vector<IpSamplingMetricImp> &ipSamplingMetrics);
136140

137141
private:
138-
std::vector<std::unique_ptr<IpSamplingMetricImp>> metrics = {};
139142
zet_metric_group_properties_t properties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
140143
};
141144

142145
struct MultiDeviceIpSamplingMetricGroupImp : public IpSamplingMetricGroupBase {
143146

144-
MultiDeviceIpSamplingMetricGroupImp(MetricSource &metricSource, std::vector<IpSamplingMetricGroupImp *> &subDeviceMetricGroup) : IpSamplingMetricGroupBase(metricSource), subDeviceMetricGroup(subDeviceMetricGroup) {
145-
isMultiDevice = true;
146-
};
147+
MultiDeviceIpSamplingMetricGroupImp(MetricSource &metricSource,
148+
std::vector<IpSamplingMetricGroupImp *> &subDeviceMetricGroup,
149+
std::vector<IpSamplingMetricImp> &ipSamplingMetrics);
147150
~MultiDeviceIpSamplingMetricGroupImp() override = default;
151+
148152
ze_result_t getProperties(zet_metric_group_properties_t *pProperties) override;
149-
ze_result_t metricGet(uint32_t *pCount, zet_metric_handle_t *phMetrics) override;
150153
ze_result_t calculateMetricValues(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
151154
const uint8_t *pRawData, uint32_t *pMetricValueCount,
152155
zet_typed_value_t *pMetricValues) override;
@@ -164,7 +167,9 @@ struct MultiDeviceIpSamplingMetricGroupImp : public IpSamplingMetricGroupBase {
164167
zet_metric_streamer_desc_t *desc,
165168
ze_event_handle_t hNotificationEvent,
166169
zet_metric_streamer_handle_t *phMetricStreamer) override;
167-
static std::unique_ptr<MultiDeviceIpSamplingMetricGroupImp> create(MetricSource &metricSource, std::vector<IpSamplingMetricGroupImp *> &subDeviceMetricGroup);
170+
static std::unique_ptr<MultiDeviceIpSamplingMetricGroupImp> create(MetricSource &metricSource,
171+
std::vector<IpSamplingMetricGroupImp *> &subDeviceMetricGroup,
172+
std::vector<IpSamplingMetricImp> &ipSamplingMetrics);
168173

169174
private:
170175
void closeSubDeviceStreamers(std::vector<IpSamplingMetricStreamerImp *> &subDeviceStreamers);

‎level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.h‎

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -163,6 +163,24 @@ class MetricIpSamplingCalculateBaseFixture {
163163
{ZET_VALUE_TYPE_UINT64, {210}},
164164
{ZET_VALUE_TYPE_UINT64, {210}}};
165165

166+
// Expected values when calculating only odd index metrics from all raw reports in rawReports
167+
std::vector<zet_typed_value_t> expectedMetricValuesOddMetrics{
168+
{ZET_VALUE_TYPE_UINT64, {11}},
169+
{ZET_VALUE_TYPE_UINT64, {11}},
170+
{ZET_VALUE_TYPE_UINT64, {11}},
171+
{ZET_VALUE_TYPE_UINT64, {11}},
172+
{ZET_VALUE_TYPE_UINT64, {11}},
173+
{ZET_VALUE_TYPE_UINT64, {110}},
174+
{ZET_VALUE_TYPE_UINT64, {110}},
175+
{ZET_VALUE_TYPE_UINT64, {110}},
176+
{ZET_VALUE_TYPE_UINT64, {110}},
177+
{ZET_VALUE_TYPE_UINT64, {110}},
178+
{ZET_VALUE_TYPE_UINT64, {210}},
179+
{ZET_VALUE_TYPE_UINT64, {210}},
180+
{ZET_VALUE_TYPE_UINT64, {210}},
181+
{ZET_VALUE_TYPE_UINT64, {210}},
182+
{ZET_VALUE_TYPE_UINT64, {210}}};
183+
166184
std::vector<MockRawDataHelper::RawReportElements> rawDataElementsOverflow = {
167185
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1000, 0x01},
168186
{1, 9, 8, 7, 6, 5, 4, 3, 2, 1, 1000, 0x02},

‎level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_streamer_1.cpp‎

Lines changed: 103 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1010,12 +1010,12 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, WhenReadingMetricGroupTimeCalculat
10101010
metricGroupCalcProps.pNext = nullptr;
10111011
metricGroupCalcProps.isTimeFilterSupported = true;
10121012

1013-
zet_metric_group_properties_t properties{};
1014-
properties.pNext = &metricGroupCalcProps;
1013+
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
1014+
metricGroupProperties.pNext = &metricGroupCalcProps;
10151015

1016-
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &properties), ZE_RESULT_SUCCESS);
1017-
EXPECT_EQ(strcmp(properties.description, "EU stall sampling"), 0);
1018-
EXPECT_EQ(strcmp(properties.name, "EuStallSampling"), 0);
1016+
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
1017+
EXPECT_EQ(strcmp(metricGroupProperties.description, "EU stall sampling"), 0);
1018+
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
10191019
EXPECT_EQ(metricGroupCalcProps.isTimeFilterSupported, false);
10201020
}
10211021
}
@@ -1229,5 +1229,103 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, GivenMultipleScopesWhenAllAreUnsup
12291229
delete mockMetricScope3;
12301230
}
12311231

1232+
HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, GivenRootDeviceCreatingCalcOpWithOnlyMetricsHandlesOnlyThoseMetricsAreInResultReport, EustallSupportedPlatforms) {
1233+
1234+
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
1235+
auto rootDevice = testDevices[0];
1236+
1237+
uint32_t metricGroupCount = 1;
1238+
zet_metric_group_handle_t metricGroupHandle = nullptr;
1239+
1240+
ASSERT_EQ(zetMetricGroupGet(rootDevice->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
1241+
EXPECT_EQ(metricGroupCount, 1u);
1242+
ASSERT_NE(metricGroupHandle, nullptr);
1243+
1244+
uint32_t metricCount = 0;
1245+
EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, nullptr), ZE_RESULT_SUCCESS);
1246+
EXPECT_EQ(metricCount, 10u);
1247+
std::vector<zet_metric_handle_t> phMetrics(metricCount);
1248+
EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, phMetrics.data()), ZE_RESULT_SUCCESS);
1249+
1250+
std::vector<zet_metric_handle_t> metricsToCalculate;
1251+
1252+
// Select only odd index metrics. According to expectedMetricNamesInReport there are:
1253+
// "Active", "PipeStall" "DistStall", "SyncStall", "OtherStall"
1254+
for (uint32_t i = 0; i < metricCount; i++) {
1255+
if (i % 2) {
1256+
metricsToCalculate.push_back(phMetrics[i]);
1257+
}
1258+
}
1259+
1260+
uint32_t metricsToCalculateCount = static_cast<uint32_t>(metricsToCalculate.size());
1261+
EXPECT_EQ(metricsToCalculateCount, 5u);
1262+
1263+
calculationDesc.metricGroupCount = 0;
1264+
calculationDesc.phMetricGroups = nullptr;
1265+
calculationDesc.metricCount = metricsToCalculateCount;
1266+
calculationDesc.phMetrics = metricsToCalculate.data();
1267+
1268+
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
1269+
1270+
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(),
1271+
rootDevice->toHandle(), &calculationDesc,
1272+
&hCalculationOperation));
1273+
uint32_t metricsInReportCount = 0;
1274+
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationGetReportFormatExp(hCalculationOperation, &metricsInReportCount, nullptr, nullptr));
1275+
EXPECT_EQ(metricsInReportCount, 5u);
1276+
std::vector<zet_metric_handle_t> metricsInReport(metricsInReportCount);
1277+
std::vector<zet_intel_metric_scope_exp_handle_t> metricScopesInReport(metricsInReportCount);
1278+
1279+
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationGetReportFormatExp(hCalculationOperation, &metricsInReportCount,
1280+
metricsInReport.data(), metricScopesInReport.data()));
1281+
1282+
EXPECT_EQ(metricsInReportCount, 5u);
1283+
// Expect only odd index metrics in the result report
1284+
zet_metric_properties_t ipSamplingMetricProperties = {};
1285+
for (uint32_t i = 0; i < metricsInReportCount; i++) {
1286+
EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGetProperties(metricsInReport[i], &ipSamplingMetricProperties));
1287+
EXPECT_EQ(strcmp(ipSamplingMetricProperties.name, expectedMetricNamesInReport[i * 2 + 1].c_str()), 0);
1288+
EXPECT_EQ(static_cast<MockMetricScope *>(MetricScope::fromHandle(metricScopesInReport[i])), hMockScope);
1289+
}
1290+
1291+
// Raw data for a single read with different data for sub-device 0 and 1
1292+
size_t rawDataSize = sizeof(IpSamplingMultiDevDataHeader) + rawReportsBytesSize + sizeof(IpSamplingMultiDevDataHeader) + rawReportsBytesSize;
1293+
std::vector<uint8_t> rawDataWithHeader(rawDataSize);
1294+
// sub device index 0
1295+
MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawReports.data()), rawReportsBytesSize, 0);
1296+
// sub device index 1
1297+
MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data() + rawReportsBytesSize + sizeof(IpSamplingMultiDevDataHeader),
1298+
rawDataWithHeader.size() - (rawReportsBytesSize + sizeof(IpSamplingMultiDevDataHeader)),
1299+
reinterpret_cast<uint8_t *>(rawReports.data()), rawReportsBytesSize, 1);
1300+
1301+
uint32_t totalMetricReportCount = 0;
1302+
bool final = true;
1303+
size_t usedSize = 0;
1304+
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataSize, reinterpret_cast<uint8_t *>(rawDataWithHeader.data()),
1305+
hCalculationOperation,
1306+
final, &usedSize,
1307+
&totalMetricReportCount, nullptr));
1308+
1309+
EXPECT_EQ(totalMetricReportCount, 3U); // three IPs in rawReports
1310+
EXPECT_EQ(usedSize, 0U); // query only, no data processed
1311+
1312+
std::vector<zet_intel_metric_result_exp_t> metricResults(totalMetricReportCount * metricsInReportCount);
1313+
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataSize, reinterpret_cast<uint8_t *>(rawDataWithHeader.data()),
1314+
hCalculationOperation,
1315+
final, &usedSize,
1316+
&totalMetricReportCount, metricResults.data()));
1317+
EXPECT_EQ(totalMetricReportCount, 3U);
1318+
EXPECT_EQ(usedSize, rawDataSize);
1319+
1320+
for (uint32_t i = 0; i < totalMetricReportCount; i++) {
1321+
for (uint32_t j = 0; j < metricsInReportCount; j++) {
1322+
uint32_t resultIndex = i * metricsInReportCount + j;
1323+
EXPECT_TRUE(metricResults[resultIndex].value.ui64 == expectedMetricValuesOddMetrics[resultIndex].value.ui64);
1324+
}
1325+
}
1326+
1327+
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalculationOperation));
1328+
}
1329+
12321330
} // namespace ult
12331331
} // namespace L0

‎level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_streamer_2.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -116,7 +116,7 @@ HWTEST2_F(MetricIpSamplingCalcOpSingleDeviceTest, GivenIpSamplingCalcOpCallingMe
116116
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalculationOperation));
117117
}
118118

119-
HWTEST2_F(MetricIpSamplingCalcOpSingleDeviceTest, GivenIpSamplingCalcOpCallingMetricCalculateValuesOnSubDeviceFilterMetricsInReport, EustallSupportedPlatforms) {
119+
HWTEST2_F(MetricIpSamplingCalcOpSingleDeviceTest, GivenSubDeviceCreatingCalcOpWithOnlyMetricsHandlesOnlyThoseMetricsAreInresultReport, EustallSupportedPlatforms) {
120120

121121
uint32_t metricCount = 0;
122122
EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, nullptr), ZE_RESULT_SUCCESS);

0 commit comments

Comments
 (0)