Skip to content

Commit aac687b

Browse files
joshuaranjanCompute-Runtime-Automation
joshuaranjan
authored and
Compute-Runtime-Automation
committed
Metrics: Add Implicitit Scaling support for EuStallSampling
This patch adds support for Implicit Scaling for EuStallSampling Metric group Related-To: LOCI-2760 Signed-off-by: Joshua Santosh Ranjan <joshua.santosh.ranjan@intel.com>
1 parent c59abbe commit aac687b

File tree

10 files changed

+436
-90
lines changed

10 files changed

+436
-90
lines changed

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

Lines changed: 65 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,9 @@
77

88
#include "level_zero/tools/source/metrics/metric_ip_sampling_source.h"
99

10+
#include "level_zero/core/source/device/device_imp.h"
1011
#include "level_zero/tools/source/metrics/metric.h"
12+
#include "level_zero/tools/source/metrics/metric_ip_sampling_streamer.h"
1113
#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
1214
#include <level_zero/zet_api.h>
1315

@@ -35,6 +37,27 @@ bool IpSamplingMetricSourceImp::isAvailable() {
3537

3638
void IpSamplingMetricSourceImp::cacheMetricGroup() {
3739

40+
if (metricDeviceContext.isImplicitScalingCapable()) {
41+
const auto deviceImp = static_cast<DeviceImp *>(&metricDeviceContext.getDevice());
42+
std::vector<IpSamplingMetricGroupImp *> subDeviceMetricGroup = {};
43+
subDeviceMetricGroup.reserve(deviceImp->subDevices.size());
44+
45+
// Prepare cached metric group for sub-devices
46+
for (auto &subDevice : deviceImp->subDevices) {
47+
IpSamplingMetricSourceImp &source = subDevice->getMetricDeviceContext().getMetricSource<IpSamplingMetricSourceImp>();
48+
// 1 metric group available for IP Sampling
49+
uint32_t count = 1;
50+
zet_metric_group_handle_t hMetricGroup = {};
51+
const auto result = source.metricGroupGet(&count, &hMetricGroup);
52+
// Getting MetricGroup from sub-device cannot fail, since RootDevice is successful
53+
UNRECOVERABLE_IF(result != ZE_RESULT_SUCCESS);
54+
subDeviceMetricGroup.push_back(static_cast<IpSamplingMetricGroupImp *>(MetricGroup::fromHandle(hMetricGroup)));
55+
}
56+
57+
cachedMetricGroup = MultiDeviceIpSamplingMetricGroupImp::create(subDeviceMetricGroup);
58+
return;
59+
}
60+
3861
std::vector<IpSamplingMetricImp> metrics = {};
3962
metrics.reserve(ipSamplinMetricCount);
4063

@@ -75,7 +98,7 @@ void IpSamplingMetricSourceImp::cacheMetricGroup() {
7598
metrics.push_back(IpSamplingMetricImp(metricProperties));
7699
}
77100

78-
cachedMetricGroup = IpSamplingMetricGroupImp::create(metrics);
101+
cachedMetricGroup = IpSamplingMetricGroupImp::create(*this, metrics);
79102
DEBUG_BREAK_IF(cachedMetricGroup == nullptr);
80103
}
81104

@@ -110,7 +133,8 @@ void IpSamplingMetricSourceImp::setMetricOsInterface(std::unique_ptr<MetricIpSam
110133
this->metricOsInterface = std::move(metricOsInterface);
111134
}
112135

113-
IpSamplingMetricGroupImp::IpSamplingMetricGroupImp(std::vector<IpSamplingMetricImp> &metrics) {
136+
IpSamplingMetricGroupImp::IpSamplingMetricGroupImp(IpSamplingMetricSourceImp &metricSource,
137+
std::vector<IpSamplingMetricImp> &metrics) : metricSource(metricSource) {
114138
this->metrics.reserve(metrics.size());
115139
for (const auto &metric : metrics) {
116140
this->metrics.push_back(std::make_unique<IpSamplingMetricImp>(metric));
@@ -341,28 +365,52 @@ void IpSamplingMetricGroupImp::stallSumIpDataToTypedValues(uint64_t ip,
341365
ipDataValues.push_back(tmpValueData);
342366
}
343367

344-
bool IpSamplingMetricGroupImp::activate() {
345-
// There is no hardware specific activation, since metric collection starts in streamer open
346-
return true;
368+
zet_metric_group_handle_t IpSamplingMetricGroupImp::getMetricGroupForSubDevice(const uint32_t subDeviceIndex) {
369+
return toHandle();
347370
}
348371

349-
bool IpSamplingMetricGroupImp::deactivate() {
350-
return true;
372+
std::unique_ptr<IpSamplingMetricGroupImp> IpSamplingMetricGroupImp::create(IpSamplingMetricSourceImp &metricSource,
373+
std::vector<IpSamplingMetricImp> &ipSamplingMetrics) {
374+
return std::unique_ptr<IpSamplingMetricGroupImp>(new (std::nothrow) IpSamplingMetricGroupImp(metricSource, ipSamplingMetrics));
351375
}
352-
zet_metric_group_handle_t IpSamplingMetricGroupImp::getMetricGroupForSubDevice(const uint32_t subDeviceIndex) {
353-
return toHandle();
376+
377+
ze_result_t MultiDeviceIpSamplingMetricGroupImp::getProperties(zet_metric_group_properties_t *pProperties) {
378+
return subDeviceMetricGroup[0]->getProperties(pProperties);
354379
}
355380

356-
ze_result_t IpSamplingMetricGroupImp::metricQueryPoolCreate(
357-
zet_context_handle_t hContext,
358-
zet_device_handle_t hDevice,
359-
const zet_metric_query_pool_desc_t *desc,
360-
zet_metric_query_pool_handle_t *phMetricQueryPool) {
361-
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
381+
ze_result_t MultiDeviceIpSamplingMetricGroupImp::metricGet(uint32_t *pCount, zet_metric_handle_t *phMetrics) {
382+
return subDeviceMetricGroup[0]->metricGet(pCount, phMetrics);
383+
}
384+
385+
ze_result_t MultiDeviceIpSamplingMetricGroupImp::calculateMetricValues(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
386+
const uint8_t *pRawData, uint32_t *pMetricValueCount,
387+
zet_typed_value_t *pMetricValues) {
388+
return subDeviceMetricGroup[0]->calculateMetricValues(type, rawDataSize, pRawData, pMetricValueCount, pMetricValues);
389+
}
390+
391+
ze_result_t MultiDeviceIpSamplingMetricGroupImp::calculateMetricValuesExp(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
392+
const uint8_t *pRawData, uint32_t *pSetCount,
393+
uint32_t *pTotalMetricValueCount, uint32_t *pMetricCounts,
394+
zet_typed_value_t *pMetricValues) {
395+
396+
return subDeviceMetricGroup[0]->calculateMetricValuesExp(type, rawDataSize, pRawData, pSetCount, pTotalMetricValueCount,
397+
pMetricCounts, pMetricValues);
398+
}
399+
400+
zet_metric_group_handle_t MultiDeviceIpSamplingMetricGroupImp::getMetricGroupForSubDevice(const uint32_t subDeviceIndex) {
401+
return subDeviceMetricGroup[subDeviceIndex]->toHandle();
402+
}
403+
404+
void MultiDeviceIpSamplingMetricGroupImp::closeSubDeviceStreamers(std::vector<IpSamplingMetricStreamerImp *> &subDeviceStreamers) {
405+
for (auto streamer : subDeviceStreamers) {
406+
streamer->close();
407+
}
362408
}
363409

364-
std::unique_ptr<IpSamplingMetricGroupImp> IpSamplingMetricGroupImp::create(std::vector<IpSamplingMetricImp> &ipSamplingMetrics) {
365-
return std::unique_ptr<IpSamplingMetricGroupImp>(new (std::nothrow) IpSamplingMetricGroupImp(ipSamplingMetrics));
410+
std::unique_ptr<MultiDeviceIpSamplingMetricGroupImp> MultiDeviceIpSamplingMetricGroupImp::create(
411+
std::vector<IpSamplingMetricGroupImp *> &subDeviceMetricGroup) {
412+
UNRECOVERABLE_IF(subDeviceMetricGroup.size() == 0);
413+
return std::unique_ptr<MultiDeviceIpSamplingMetricGroupImp>(new (std::nothrow) MultiDeviceIpSamplingMetricGroupImp(subDeviceMetricGroup));
366414
}
367415

368416
IpSamplingMetricImp::IpSamplingMetricImp(zet_metric_properties_t &properties) : properties(properties) {

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

Lines changed: 45 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -29,14 +29,15 @@ class IpSamplingMetricSourceImp : public MetricSource {
2929
static std::unique_ptr<IpSamplingMetricSourceImp> create(const MetricDeviceContext &metricDeviceContext);
3030
MetricIpSamplingOsInterface *getMetricOsInterface() { return metricOsInterface.get(); }
3131
IpSamplingMetricStreamerImp *pActiveStreamer = nullptr;
32+
const MetricDeviceContext &getMetricDeviceContext() const { return metricDeviceContext; }
3233

3334
protected:
3435
void cacheMetricGroup();
3536
bool isEnabled = false;
3637

3738
const MetricDeviceContext &metricDeviceContext;
3839
std::unique_ptr<MetricIpSamplingOsInterface> metricOsInterface = nullptr;
39-
std::unique_ptr<IpSamplingMetricGroupImp> cachedMetricGroup = nullptr;
40+
std::unique_ptr<MetricGroup> cachedMetricGroup = nullptr;
4041
};
4142

4243
typedef struct StallSumIpData {
@@ -53,8 +54,18 @@ typedef struct StallSumIpData {
5354

5455
typedef std::map<uint64_t, StallSumIpData_t> StallSumIpDataMap_t;
5556

56-
struct IpSamplingMetricGroupImp : public MetricGroup {
57-
IpSamplingMetricGroupImp(std::vector<IpSamplingMetricImp> &metrics);
57+
struct IpSamplingMetricGroupBase : public MetricGroup {
58+
bool activate() override { return true; }
59+
bool deactivate() override { return true; };
60+
ze_result_t metricQueryPoolCreate(
61+
zet_context_handle_t hContext,
62+
zet_device_handle_t hDevice,
63+
const zet_metric_query_pool_desc_t *desc,
64+
zet_metric_query_pool_handle_t *phMetricQueryPool) override { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; }
65+
};
66+
67+
struct IpSamplingMetricGroupImp : public IpSamplingMetricGroupBase {
68+
IpSamplingMetricGroupImp(IpSamplingMetricSourceImp &metricSource, std::vector<IpSamplingMetricImp> &metrics);
5869
~IpSamplingMetricGroupImp() override = default;
5970

6071
ze_result_t getProperties(zet_metric_group_properties_t *pProperties) override;
@@ -66,21 +77,16 @@ struct IpSamplingMetricGroupImp : public MetricGroup {
6677
const uint8_t *pRawData, uint32_t *pSetCount,
6778
uint32_t *pTotalMetricValueCount, uint32_t *pMetricCounts,
6879
zet_typed_value_t *pMetricValues) override;
69-
bool activate() override;
70-
bool deactivate() override;
7180
zet_metric_group_handle_t getMetricGroupForSubDevice(const uint32_t subDeviceIndex) override;
7281
ze_result_t streamerOpen(
7382
zet_context_handle_t hContext,
7483
zet_device_handle_t hDevice,
7584
zet_metric_streamer_desc_t *desc,
7685
ze_event_handle_t hNotificationEvent,
7786
zet_metric_streamer_handle_t *phMetricStreamer) override;
78-
ze_result_t metricQueryPoolCreate(
79-
zet_context_handle_t hContext,
80-
zet_device_handle_t hDevice,
81-
const zet_metric_query_pool_desc_t *desc,
82-
zet_metric_query_pool_handle_t *phMetricQueryPool) override;
83-
static std::unique_ptr<IpSamplingMetricGroupImp> create(std::vector<IpSamplingMetricImp> &ipSamplingMetrics);
87+
static std::unique_ptr<IpSamplingMetricGroupImp> create(IpSamplingMetricSourceImp &metricSource,
88+
std::vector<IpSamplingMetricImp> &ipSamplingMetrics);
89+
IpSamplingMetricSourceImp &getMetricSource() { return metricSource; }
8490

8591
private:
8692
std::vector<std::unique_ptr<IpSamplingMetricImp>> metrics = {};
@@ -91,6 +97,34 @@ struct IpSamplingMetricGroupImp : public MetricGroup {
9197
zet_typed_value_t *pCalculatedData);
9298
void stallIpDataMapUpdate(StallSumIpDataMap_t &, const uint8_t *pRawIpData);
9399
void stallSumIpDataToTypedValues(uint64_t ip, StallSumIpData_t &sumIpData, std::vector<zet_typed_value_t> &ipDataValues);
100+
IpSamplingMetricSourceImp &metricSource;
101+
};
102+
103+
struct MultiDeviceIpSamplingMetricGroupImp : public IpSamplingMetricGroupBase {
104+
105+
MultiDeviceIpSamplingMetricGroupImp(std::vector<IpSamplingMetricGroupImp *> &subDeviceMetricGroup) : subDeviceMetricGroup(subDeviceMetricGroup){};
106+
~MultiDeviceIpSamplingMetricGroupImp() override = default;
107+
ze_result_t getProperties(zet_metric_group_properties_t *pProperties) override;
108+
ze_result_t metricGet(uint32_t *pCount, zet_metric_handle_t *phMetrics) override;
109+
ze_result_t calculateMetricValues(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
110+
const uint8_t *pRawData, uint32_t *pMetricValueCount,
111+
zet_typed_value_t *pMetricValues) override;
112+
ze_result_t calculateMetricValuesExp(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
113+
const uint8_t *pRawData, uint32_t *pSetCount,
114+
uint32_t *pTotalMetricValueCount, uint32_t *pMetricCounts,
115+
zet_typed_value_t *pMetricValues) override;
116+
zet_metric_group_handle_t getMetricGroupForSubDevice(const uint32_t subDeviceIndex) override;
117+
ze_result_t streamerOpen(
118+
zet_context_handle_t hContext,
119+
zet_device_handle_t hDevice,
120+
zet_metric_streamer_desc_t *desc,
121+
ze_event_handle_t hNotificationEvent,
122+
zet_metric_streamer_handle_t *phMetricStreamer) override;
123+
static std::unique_ptr<MultiDeviceIpSamplingMetricGroupImp> create(std::vector<IpSamplingMetricGroupImp *> &subDeviceMetricGroup);
124+
125+
private:
126+
void closeSubDeviceStreamers(std::vector<IpSamplingMetricStreamerImp *> &subDeviceStreamers);
127+
std::vector<IpSamplingMetricGroupImp *> subDeviceMetricGroup = {};
94128
};
95129

96130
struct IpSamplingMetricImp : public Metric {

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

Lines changed: 107 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -14,6 +14,21 @@
1414

1515
namespace L0 {
1616

17+
void IpSamplingMetricStreamerBase::attachEvent(ze_event_handle_t hNotificationEvent) {
18+
// Associate notification event with metric streamer.
19+
pNotificationEvent = Event::fromHandle(hNotificationEvent);
20+
if (pNotificationEvent != nullptr) {
21+
pNotificationEvent->metricStreamer = this;
22+
}
23+
}
24+
25+
void IpSamplingMetricStreamerBase::detachEvent() {
26+
// Release notification event.
27+
if (pNotificationEvent != nullptr) {
28+
pNotificationEvent->metricStreamer = nullptr;
29+
}
30+
}
31+
1732
ze_result_t IpSamplingMetricGroupImp::streamerOpen(
1833
zet_context_handle_t hContext,
1934
zet_device_handle_t hDevice,
@@ -28,7 +43,6 @@ ze_result_t IpSamplingMetricGroupImp::streamerOpen(
2843
return ZE_RESULT_NOT_READY;
2944
}
3045

31-
auto &metricSource = device->getMetricDeviceContext().getMetricSource<IpSamplingMetricSourceImp>();
3246
// Check whether metric streamer is already open.
3347
if (metricSource.pActiveStreamer != nullptr) {
3448
return ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE;
@@ -85,24 +99,105 @@ Event::State IpSamplingMetricStreamerImp::getNotificationState() {
8599
: Event::State::STATE_INITIAL;
86100
}
87101

88-
ze_result_t IpSamplingMetricStreamerImp::appendStreamerMarker(CommandList &commandList, uint32_t value) {
102+
ze_result_t MultiDeviceIpSamplingMetricGroupImp::streamerOpen(
103+
zet_context_handle_t hContext,
104+
zet_device_handle_t hDevice,
105+
zet_metric_streamer_desc_t *desc,
106+
ze_event_handle_t hNotificationEvent,
107+
zet_metric_streamer_handle_t *phMetricStreamer) {
108+
109+
ze_result_t result = ZE_RESULT_SUCCESS;
110+
111+
std::vector<IpSamplingMetricStreamerImp *> subDeviceStreamers = {};
112+
subDeviceStreamers.reserve(subDeviceMetricGroup.size());
113+
114+
// Open SubDevice Streamers
115+
for (auto &metricGroup : subDeviceMetricGroup) {
116+
zet_metric_streamer_handle_t subDeviceMetricStreamer = {};
117+
zet_device_handle_t hSubDevice = metricGroup->getMetricSource().getMetricDeviceContext().getDevice().toHandle();
118+
result = metricGroup->streamerOpen(hContext, hSubDevice, desc, nullptr, &subDeviceMetricStreamer);
119+
if (result != ZE_RESULT_SUCCESS) {
120+
closeSubDeviceStreamers(subDeviceStreamers);
121+
return result;
122+
}
123+
subDeviceStreamers.push_back(static_cast<IpSamplingMetricStreamerImp *>(MetricStreamer::fromHandle(subDeviceMetricStreamer)));
124+
}
125+
126+
auto pStreamerImp = new MultiDeviceIpSamplingMetricStreamerImp(subDeviceStreamers);
127+
UNRECOVERABLE_IF(pStreamerImp == nullptr);
89128

90-
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
129+
pStreamerImp->attachEvent(hNotificationEvent);
130+
*phMetricStreamer = pStreamerImp->toHandle();
131+
return result;
91132
}
92133

93-
void IpSamplingMetricStreamerImp::attachEvent(ze_event_handle_t hNotificationEvent) {
94-
// Associate notification event with metric streamer.
95-
pNotificationEvent = Event::fromHandle(hNotificationEvent);
96-
if (pNotificationEvent != nullptr) {
97-
pNotificationEvent->metricStreamer = this;
134+
ze_result_t MultiDeviceIpSamplingMetricStreamerImp::readData(uint32_t maxReportCount, size_t *pRawDataSize, uint8_t *pRawData) {
135+
136+
if (*pRawDataSize == 0) {
137+
return subDeviceStreamers[0]->readData(maxReportCount, pRawDataSize, pRawData);
98138
}
139+
140+
// Find single report size
141+
size_t singleReportSize = 0;
142+
subDeviceStreamers[0]->readData(1, &singleReportSize, nullptr);
143+
144+
size_t calcRawDataSize = *pRawDataSize;
145+
146+
// Recalculate maximum possible report count for the raw data size
147+
calcRawDataSize = std::min(calcRawDataSize, singleReportSize * maxReportCount);
148+
maxReportCount = static_cast<uint32_t>(calcRawDataSize / singleReportSize);
149+
uint8_t *pCurrRawData = pRawData;
150+
size_t currRawDataSize = calcRawDataSize;
151+
152+
ze_result_t result = ZE_RESULT_SUCCESS;
153+
154+
for (auto &streamer : subDeviceStreamers) {
155+
result = streamer->readData(maxReportCount, &currRawDataSize, pCurrRawData);
156+
if (result != ZE_RESULT_SUCCESS) {
157+
return result;
158+
}
159+
160+
calcRawDataSize -= currRawDataSize;
161+
pCurrRawData += currRawDataSize;
162+
// Check whether memory available for next read
163+
if (calcRawDataSize < singleReportSize) {
164+
break;
165+
}
166+
maxReportCount -= static_cast<uint32_t>(currRawDataSize / singleReportSize);
167+
currRawDataSize = calcRawDataSize;
168+
}
169+
170+
*pRawDataSize = pCurrRawData - pRawData;
171+
return result;
99172
}
100173

101-
void IpSamplingMetricStreamerImp::detachEvent() {
102-
// Release notification event.
103-
if (pNotificationEvent != nullptr) {
104-
pNotificationEvent->metricStreamer = nullptr;
174+
ze_result_t MultiDeviceIpSamplingMetricStreamerImp::close() {
175+
176+
ze_result_t result = ZE_RESULT_SUCCESS;
177+
for (auto &streamer : subDeviceStreamers) {
178+
result = streamer->close();
179+
if (result != ZE_RESULT_SUCCESS) {
180+
break;
181+
}
105182
}
183+
184+
subDeviceStreamers.clear();
185+
detachEvent();
186+
delete this;
187+
return result;
188+
}
189+
190+
Event::State MultiDeviceIpSamplingMetricStreamerImp::getNotificationState() {
191+
192+
Event::State state = Event::State::STATE_INITIAL;
193+
for (auto &streamer : subDeviceStreamers) {
194+
state = streamer->getNotificationState();
195+
if (state == Event::State::STATE_SIGNALED) {
196+
break;
197+
}
198+
}
199+
200+
return state;
106201
}
107202

108203
} // namespace L0

0 commit comments

Comments
 (0)