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

refactor: re organize IP sampling calculate helpers

Browse Source 
Resolves: NEO-14678

Signed-off-by: Matias Cabral <matias.a.cabral@intel.com>
This commit is contained in:
Matias Cabral
2025-09-19 18:34:57 +00:00
committed by Compute-Runtime-Automation
parent 88788a52c5
commit e7e3c4126d
6 changed files with 540 additions and 463 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -37,6 +37,10 @@ IpSamplingMetricSourceImp::IpSamplingMetricSourceImp(const MetricDeviceContext &
metricIPSamplingpOsInterface = MetricIpSamplingOsInterface::create(metricDeviceContext.getDevice());
activationTracker = std::make_unique<MultiDomainDeferredActivationTracker>(metricDeviceContext.getSubDeviceIndex());
type = MetricSource::metricSourceTypeIpSampling;
const auto deviceImp = static_cast<DeviceImp *>(&metricDeviceContext.getDevice());
L0::L0GfxCoreHelper &l0GfxCoreHelper = deviceImp->getNEODevice()->getRootDeviceEnvironment().getHelper<L0GfxCoreHelper>();
ipSamplingCalculation = std::make_unique<IpSamplingCalculation>(l0GfxCoreHelper, *this);
}
ze_result_t IpSamplingMetricSourceImp::getTimerResolution(uint64_t &resolution) {
@@ -350,19 +354,7 @@ bool IpSamplingMetricGroupBase::isMultiDeviceCaptureData(const size_t rawDataSiz
ze_result_t IpSamplingMetricGroupImp::calculateMetricValues(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
const uint8_t *pRawData, uint32_t *pMetricValueCount,
zet_typed_value_t *pMetricValues) {
const bool calculateCountOnly = *pMetricValueCount == 0;
if (isMultiDeviceCaptureData(rawDataSize, pRawData)) {
METRICS_LOG_ERR("%s", "The call is not supported for multiple devices");
METRICS_LOG_ERR("%s", "Please use zetMetricGroupCalculateMultipleMetricValuesExp instead");
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
if (calculateCountOnly) {
return getCalculatedMetricCount(pRawData, rawDataSize, *pMetricValueCount);
} else {
return getCalculatedMetricValues(type, rawDataSize, pRawData, *pMetricValueCount, pMetricValues);
}
return getMetricSource().ipSamplingCalculation->calculateMetricForSubdevice(type, rawDataSize, pRawData, pMetricValueCount, pMetricValues);
}
ze_result_t IpSamplingMetricGroupImp::calculateMetricValuesExp(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
@@ -379,11 +371,8 @@ ze_result_t IpSamplingMetricGroupImp::calculateMetricValuesExp(const zet_metric_
if (!isMultiDeviceCaptureData(rawDataSize, pRawData)) {
result = this->calculateMetricValues(type, rawDataSize, pRawData, pTotalMetricValueCount, pMetricValues);
} else {
if (calculateCountOnly) {
result = getCalculatedMetricCount(pRawData, rawDataSize, *pTotalMetricValueCount, 0);
} else {
result = getCalculatedMetricValues(type, rawDataSize, pRawData, *pTotalMetricValueCount, pMetricValues, 0);
}
METRICS_LOG_ERR("%s", "Calculating sub-device results using root device captured data is not supported");
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
if ((result == ZE_RESULT_SUCCESS) || (result == ZE_RESULT_WARNING_DROPPED_DATA)) {
@@ -429,146 +418,6 @@ ze_result_t IpSamplingMetricGroupImp::getMetricTimestampsExp(const ze_bool_t syn
return getDeviceTimestamps(deviceImp, synchronizedWithHost, globalTimestamp, metricTimestamp);
}
ze_result_t IpSamplingMetricGroupImp::getCalculatedMetricCount(const uint8_t *pRawData, const size_t rawDataSize,
uint32_t &metricValueCount) {
std::unordered_set<uint64_t> stallReportIpCount{};
constexpr uint32_t rawReportSize = IpSamplingMetricGroupBase::rawReportSize;
if ((rawDataSize % rawReportSize) != 0) {
METRICS_LOG_ERR("%s", "Invalid input raw data size");
metricValueCount = 0;
return ZE_RESULT_ERROR_INVALID_SIZE;
}
DeviceImp *deviceImp = static_cast<DeviceImp *>(&this->getMetricSource().getMetricDeviceContext().getDevice());
auto &l0GfxCoreHelper = deviceImp->getNEODevice()->getRootDeviceEnvironment().getHelper<L0GfxCoreHelper>();
const uint32_t rawReportCount = static_cast<uint32_t>(rawDataSize) / rawReportSize;
for (const uint8_t *pRawIpData = pRawData; pRawIpData < pRawData + (rawReportCount * rawReportSize); pRawIpData += rawReportSize) {
uint64_t ip = 0ULL;
memcpy_s(reinterpret_cast<uint8_t *>(&ip), sizeof(ip), pRawIpData, sizeof(ip));
ip &= l0GfxCoreHelper.getIpSamplingIpMask();
stallReportIpCount.insert(ip);
}
metricValueCount = static_cast<uint32_t>(stallReportIpCount.size()) * properties.metricCount;
return ZE_RESULT_SUCCESS;
}
ze_result_t IpSamplingMetricGroupImp::getCalculatedMetricCount(const uint8_t *pMultiMetricData, const size_t rawDataSize, uint32_t &metricValueCount, const uint32_t setIndex) {
// Iterate through headers and assign required sizes
auto processedSize = 0u;
while (processedSize < rawDataSize) {
auto processMetricData = pMultiMetricData + processedSize;
if (!isMultiDeviceCaptureData(rawDataSize - processedSize, processMetricData)) {
return ZE_RESULT_ERROR_INVALID_SIZE;
}
auto header = reinterpret_cast<const IpSamplingMetricDataHeader *>(processMetricData);
processedSize += sizeof(IpSamplingMetricDataHeader) + header->rawDataSize;
if (header->setIndex != setIndex) {
continue;
}
auto currTotalMetricValueCount = 0u;
auto result = this->getCalculatedMetricCount((processMetricData + sizeof(IpSamplingMetricDataHeader)), header->rawDataSize, currTotalMetricValueCount);
if (result != ZE_RESULT_SUCCESS) {
metricValueCount = 0;
return result;
}
metricValueCount += currTotalMetricValueCount;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t IpSamplingMetricGroupImp::getCalculatedMetricValues(const zet_metric_group_calculation_type_t type, const size_t rawDataSize, const uint8_t *pMultiMetricData,
uint32_t &metricValueCount,
zet_typed_value_t *pCalculatedData, const uint32_t setIndex) {
auto processedSize = 0u;
auto isDataDropped = false;
auto requestTotalMetricValueCount = metricValueCount;
while (processedSize < rawDataSize && requestTotalMetricValueCount > 0) {
auto processMetricData = pMultiMetricData + processedSize;
if (!isMultiDeviceCaptureData(rawDataSize - processedSize, processMetricData)) {
return ZE_RESULT_ERROR_INVALID_SIZE;
}
auto header = reinterpret_cast<const IpSamplingMetricDataHeader *>(processMetricData);
processedSize += header->rawDataSize + sizeof(IpSamplingMetricDataHeader);
if (header->setIndex != setIndex) {
continue;
}
auto processMetricRawData = processMetricData + sizeof(IpSamplingMetricDataHeader);
auto currTotalMetricValueCount = requestTotalMetricValueCount;
auto result = this->calculateMetricValues(type, header->rawDataSize, processMetricRawData, &currTotalMetricValueCount, pCalculatedData);
if (result != ZE_RESULT_SUCCESS) {
if (result == ZE_RESULT_WARNING_DROPPED_DATA) {
isDataDropped = true;
} else {
metricValueCount = 0;
return result;
}
}
pCalculatedData += currTotalMetricValueCount;
requestTotalMetricValueCount -= currTotalMetricValueCount;
}
metricValueCount -= requestTotalMetricValueCount;
return isDataDropped ? ZE_RESULT_WARNING_DROPPED_DATA : ZE_RESULT_SUCCESS;
}
ze_result_t IpSamplingMetricGroupImp::getCalculatedMetricValues(const zet_metric_group_calculation_type_t type, const size_t rawDataSize, const uint8_t *pRawData,
uint32_t &metricValueCount,
zet_typed_value_t *pCalculatedData) {
bool dataOverflow = false;
std::map<uint64_t, void *> stallReportDataMap;
// MAX_METRIC_VALUES is not supported yet.
if (type != ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES) {
METRICS_LOG_ERR("%s", "IP sampling only supports ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES");
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
DEBUG_BREAK_IF(pCalculatedData == nullptr);
const uint32_t rawReportSize = IpSamplingMetricGroupBase::rawReportSize;
if ((rawDataSize % rawReportSize) != 0) {
METRICS_LOG_ERR("%s", "Invalid input raw data size");
metricValueCount = 0;
return ZE_RESULT_ERROR_INVALID_SIZE;
}
const uint32_t rawReportCount = static_cast<uint32_t>(rawDataSize) / rawReportSize;
DeviceImp *deviceImp = static_cast<DeviceImp *>(&this->getMetricSource().getMetricDeviceContext().getDevice());
auto &l0GfxCoreHelper = deviceImp->getNEODevice()->getRootDeviceEnvironment().getHelper<L0GfxCoreHelper>();
for (const uint8_t *pRawIpData = pRawData; pRawIpData < pRawData + (rawReportCount * rawReportSize); pRawIpData += rawReportSize) {
dataOverflow |= l0GfxCoreHelper.stallIpDataMapUpdate(stallReportDataMap, pRawIpData);
}
metricValueCount = std::min<uint32_t>(metricValueCount, static_cast<uint32_t>(stallReportDataMap.size()) * properties.metricCount);
std::vector<zet_typed_value_t> ipDataValues;
uint32_t i = 0;
for (auto it = stallReportDataMap.begin(); it != stallReportDataMap.end(); ++it) {
l0GfxCoreHelper.stallSumIpDataToTypedValues(it->first, it->second, ipDataValues);
for (auto jt = ipDataValues.begin(); (jt != ipDataValues.end()) && (i < metricValueCount); jt++, i++) {
*(pCalculatedData + i) = *jt;
}
ipDataValues.clear();
}
l0GfxCoreHelper.stallIpDataMapDelete(stallReportDataMap);
stallReportDataMap.clear();
return dataOverflow ? ZE_RESULT_WARNING_DROPPED_DATA : ZE_RESULT_SUCCESS;
}
zet_metric_group_handle_t IpSamplingMetricGroupImp::getMetricGroupForSubDevice(const uint32_t subDeviceIndex) {
return toHandle();
}
@@ -589,7 +438,15 @@ ze_result_t MultiDeviceIpSamplingMetricGroupImp::metricGet(uint32_t *pCount, zet
ze_result_t MultiDeviceIpSamplingMetricGroupImp::calculateMetricValues(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
const uint8_t *pRawData, uint32_t *pMetricValueCount,
zet_typed_value_t *pMetricValues) {
return subDeviceMetricGroup[0]->calculateMetricValues(type, rawDataSize, pRawData, pMetricValueCount, pMetricValues);
if (IpSamplingCalculation::isMultiDeviceCaptureData(rawDataSize, pRawData)) {
METRICS_LOG_ERR("%s", "The API is not supported for root device captured data");
METRICS_LOG_ERR("%s", "Please use zetMetricGroupCalculateMultipleMetricValuesExp instead");
} else {
METRICS_LOG_ERR("%s", "Cannot validate root device captured data. Input size or captured data are invalid");
}
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
ze_result_t MultiDeviceIpSamplingMetricGroupImp::calculateMetricValuesExp(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
@@ -601,12 +458,13 @@ ze_result_t MultiDeviceIpSamplingMetricGroupImp::calculateMetricValuesExp(const
bool isDroppedData = false;
ze_result_t result = ZE_RESULT_SUCCESS;
auto calcUtils = getMetricSource().ipSamplingCalculation.get();
if (calculateCountOnly) {
*pSetCount = 0;
*pTotalMetricValueCount = 0;
for (uint32_t setIndex = 0; setIndex < subDeviceMetricGroup.size(); setIndex++) {
uint32_t currTotalMetricValueCount = 0;
result = subDeviceMetricGroup[setIndex]->getCalculatedMetricCount(pRawData, rawDataSize, currTotalMetricValueCount, setIndex);
result = calcUtils->getMetricCountSubDevIndex(pRawData, rawDataSize, currTotalMetricValueCount, setIndex);
if (result != ZE_RESULT_SUCCESS) {
return result;
}
@@ -620,7 +478,7 @@ ze_result_t MultiDeviceIpSamplingMetricGroupImp::calculateMetricValuesExp(const
auto tempTotalMetricValueCount = *pTotalMetricValueCount;
for (uint32_t setIndex = 0; setIndex < maxSets; setIndex++) {
uint32_t currTotalMetricValueCount = tempTotalMetricValueCount;
result = subDeviceMetricGroup[setIndex]->getCalculatedMetricValues(type, rawDataSize, pRawData, currTotalMetricValueCount, pMetricValues, setIndex);
result = calcUtils->calculateMetricValuesSubDevIndex(type, rawDataSize, pRawData, currTotalMetricValueCount, pMetricValues, setIndex);
if (result != ZE_RESULT_SUCCESS) {
if (result == ZE_RESULT_WARNING_DROPPED_DATA) {
isDroppedData = true;
@@ -684,6 +542,168 @@ ze_result_t IpSamplingMetricImp::getProperties(zet_metric_properties_t *pPropert
return ZE_RESULT_SUCCESS;
}
bool IpSamplingCalculation::isMultiDeviceCaptureData(const size_t rawDataSize, const uint8_t *pRawData) {
if (rawDataSize >= sizeof(IpSamplingMetricDataHeader)) {
const auto header = reinterpret_cast<const IpSamplingMetricDataHeader *>(pRawData);
return header->magic == IpSamplingMetricDataHeader::magicValue;
}
return false;
}
ze_result_t IpSamplingCalculation::getMetricCount(const uint8_t *pRawData, const size_t rawDataSize,
uint32_t &metricValueCount) {
std::unordered_set<uint64_t> stallReportIpCount{};
constexpr uint32_t rawReportSize = IpSamplingMetricGroupBase::rawReportSize;
if ((rawDataSize % rawReportSize) != 0) {
METRICS_LOG_ERR("%s", "Invalid input raw data size");
metricValueCount = 0;
return ZE_RESULT_ERROR_INVALID_SIZE;
}
const uint32_t rawReportCount = static_cast<uint32_t>(rawDataSize) / rawReportSize;
for (const uint8_t *pRawIpData = pRawData; pRawIpData < pRawData + (rawReportCount * rawReportSize); pRawIpData += rawReportSize) {
uint64_t ip = 0ULL;
memcpy_s(reinterpret_cast<uint8_t *>(&ip), sizeof(ip), pRawIpData, sizeof(ip));
ip &= gfxCoreHelper.getIpSamplingIpMask();
stallReportIpCount.insert(ip);
}
metricValueCount = static_cast<uint32_t>(stallReportIpCount.size()) * metricSource.metricSourceCount;
return ZE_RESULT_SUCCESS;
}
ze_result_t IpSamplingCalculation::getMetricCountSubDevIndex(const uint8_t *pMultiMetricData, const size_t rawDataSize, uint32_t &metricValueCount, const uint32_t setIndex) {
// Iterate through headers and assign required sizes
auto processedSize = 0u;
while (processedSize < rawDataSize) {
auto processMetricData = pMultiMetricData + processedSize;
if (!isMultiDeviceCaptureData(rawDataSize - processedSize, processMetricData)) {
METRICS_LOG_ERR("%s", "Cannot validate root device captured data. Input size or captured data are invalid");
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
auto header = reinterpret_cast<const IpSamplingMetricDataHeader *>(processMetricData);
processedSize += sizeof(IpSamplingMetricDataHeader) + header->rawDataSize;
if (header->setIndex != setIndex) {
continue;
}
auto currTotalMetricValueCount = 0u;
auto result = getMetricCount((processMetricData + sizeof(IpSamplingMetricDataHeader)), header->rawDataSize, currTotalMetricValueCount);
if (result != ZE_RESULT_SUCCESS) {
metricValueCount = 0;
return result;
}
metricValueCount += currTotalMetricValueCount;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t IpSamplingCalculation::calculateMetricValues(const zet_metric_group_calculation_type_t type, const size_t rawDataSize,
const uint8_t *pRawData, uint32_t &metricValueCount,
zet_typed_value_t *pCalculatedData) {
bool dataOverflow = false;
std::map<uint64_t, void *> stallReportDataMap;
// MAX_METRIC_VALUES is not supported yet.
if (type != ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES) {
METRICS_LOG_ERR("%s", "IP sampling only supports ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES");
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
DEBUG_BREAK_IF(pCalculatedData == nullptr);
const uint32_t rawReportSize = IpSamplingMetricGroupBase::rawReportSize;
if ((rawDataSize % rawReportSize) != 0) {
METRICS_LOG_ERR("%s", "Invalid input raw data size");
metricValueCount = 0;
return ZE_RESULT_ERROR_INVALID_SIZE;
}
const uint32_t rawReportCount = static_cast<uint32_t>(rawDataSize) / rawReportSize;
for (const uint8_t *pRawIpData = pRawData; pRawIpData < pRawData + (rawReportCount * rawReportSize); pRawIpData += rawReportSize) {
dataOverflow |= gfxCoreHelper.stallIpDataMapUpdate(stallReportDataMap, pRawIpData);
}
metricValueCount = std::min<uint32_t>(metricValueCount, static_cast<uint32_t>(stallReportDataMap.size()) * metricSource.metricSourceCount);
std::vector<zet_typed_value_t> ipDataValues;
uint32_t i = 0;
for (auto it = stallReportDataMap.begin(); it != stallReportDataMap.end(); ++it) {
gfxCoreHelper.stallSumIpDataToTypedValues(it->first, it->second, ipDataValues);
for (auto jt = ipDataValues.begin(); (jt != ipDataValues.end()) && (i < metricValueCount); jt++, i++) {
*(pCalculatedData + i) = *jt;
}
ipDataValues.clear();
}
gfxCoreHelper.stallIpDataMapDelete(stallReportDataMap);
stallReportDataMap.clear();
return dataOverflow ? ZE_RESULT_WARNING_DROPPED_DATA : ZE_RESULT_SUCCESS;
}
ze_result_t IpSamplingCalculation::calculateMetricValuesSubDevIndex(const zet_metric_group_calculation_type_t type, const size_t rawDataSize,
const uint8_t *pMultiMetricData, uint32_t &metricValueCount,
zet_typed_value_t *pCalculatedData, const uint32_t setIndex) {
auto processedSize = 0u;
auto isDataDropped = false;
auto requestTotalMetricValueCount = metricValueCount;
while (processedSize < rawDataSize && requestTotalMetricValueCount > 0) {
auto processMetricData = pMultiMetricData + processedSize;
if (!isMultiDeviceCaptureData(rawDataSize - processedSize, processMetricData)) {
METRICS_LOG_ERR("%s", "Calculating root device results using sub-device captured data is not supported");
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
auto header = reinterpret_cast<const IpSamplingMetricDataHeader *>(processMetricData);
processedSize += header->rawDataSize + sizeof(IpSamplingMetricDataHeader);
if (header->setIndex != setIndex) {
continue;
}
auto processMetricRawData = processMetricData + sizeof(IpSamplingMetricDataHeader);
auto currTotalMetricValueCount = requestTotalMetricValueCount;
auto result = calculateMetricValues(type, header->rawDataSize, processMetricRawData, currTotalMetricValueCount, pCalculatedData);
if (result != ZE_RESULT_SUCCESS) {
if (result == ZE_RESULT_WARNING_DROPPED_DATA) {
isDataDropped = true;
} else {
metricValueCount = 0;
return result;
}
}
pCalculatedData += currTotalMetricValueCount;
requestTotalMetricValueCount -= currTotalMetricValueCount;
}
metricValueCount -= requestTotalMetricValueCount;
return isDataDropped ? ZE_RESULT_WARNING_DROPPED_DATA : ZE_RESULT_SUCCESS;
}
ze_result_t IpSamplingCalculation::calculateMetricForSubdevice(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
const uint8_t *pRawData, uint32_t *pMetricValueCount,
zet_typed_value_t *pMetricValues) {
const bool calculateCountOnly = *pMetricValueCount == 0;
if (isMultiDeviceCaptureData(rawDataSize, pRawData)) {
METRICS_LOG_ERR("%s", "Calculating sub-device results using root device captured data is not supported");
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
if (calculateCountOnly) {
return getMetricCount(pRawData, rawDataSize, *pMetricValueCount);
} else {
return calculateMetricValues(type, rawDataSize, pRawData, *pMetricValueCount, pMetricValues);
}
}
template <>
IpSamplingMetricSourceImp &MetricDeviceContext::getMetricSource<IpSamplingMetricSourceImp>() const {
return static_cast<IpSamplingMetricSourceImp &>(*metricSources.at(MetricSource::metricSourceTypeIpSampling));

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

@@ -15,6 +15,7 @@ namespace L0 {
struct IpSamplingMetricImp;
struct IpSamplingMetricGroupImp;
struct IpSamplingMetricStreamerImp;
struct IpSamplingCalculation;
class IpSamplingMetricSourceImp : public MetricSource {
@@ -66,6 +67,8 @@ class IpSamplingMetricSourceImp : public MetricSource {
bool canDisable() override;
void initMetricScopes(MetricDeviceContext &metricDeviceContext) override;
std::unique_ptr<IpSamplingCalculation> ipSamplingCalculation = nullptr;
protected:
ze_result_t cacheMetricGroup();
bool isEnabled = false;
@@ -131,18 +134,10 @@ struct IpSamplingMetricGroupImp : public IpSamplingMetricGroupBase {
zet_metric_streamer_handle_t *phMetricStreamer) override;
static std::unique_ptr<IpSamplingMetricGroupImp> create(IpSamplingMetricSourceImp &metricSource,
std::vector<IpSamplingMetricImp> &ipSamplingMetrics);
ze_result_t getCalculatedMetricValues(const zet_metric_group_calculation_type_t type, const size_t rawDataSize, const uint8_t *pMultiMetricData,
uint32_t &metricValueCount,
zet_typed_value_t *pCalculatedData, const uint32_t setIndex);
ze_result_t getCalculatedMetricCount(const uint8_t *pRawData, const size_t rawDataSize, uint32_t &metricValueCount);
ze_result_t getCalculatedMetricCount(const uint8_t *pMultiMetricData, const size_t rawDataSize, uint32_t &metricValueCount, const uint32_t setIndex);
private:
std::vector<std::unique_ptr<IpSamplingMetricImp>> metrics = {};
zet_metric_group_properties_t properties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
ze_result_t getCalculatedMetricValues(const zet_metric_group_calculation_type_t type, const size_t rawDataSize, const uint8_t *pRawData,
uint32_t &metricValueCount,
zet_typed_value_t *pCalculatedData);
};
struct MultiDeviceIpSamplingMetricGroupImp : public IpSamplingMetricGroupBase {
@@ -189,6 +184,40 @@ struct IpSamplingMetricImp : public MetricImp {
zet_metric_properties_t properties;
};
struct IpSamplingCalculation {
IpSamplingCalculation(L0::L0GfxCoreHelper &gfxCoreHelper, IpSamplingMetricSourceImp &metricSource)
: gfxCoreHelper(gfxCoreHelper), metricSource(metricSource) {}
~IpSamplingCalculation() = default;
static bool isMultiDeviceCaptureData(const size_t rawDataSize, const uint8_t *pRawData);
ze_result_t getMetricCount(const uint8_t *pRawData, const size_t rawDataSize,
uint32_t &metricValueCount);
ze_result_t getMetricCountSubDevIndex(const uint8_t *pMultiMetricData, const size_t rawDataSize,
uint32_t &metricValueCount, const uint32_t setIndex);
ze_result_t calculateMetricValues(const zet_metric_group_calculation_type_t type, const size_t rawDataSize,
const uint8_t *pRawData, uint32_t &metricValueCount,
zet_typed_value_t *pCalculatedData);
ze_result_t calculateMetricValuesSubDevIndex(const zet_metric_group_calculation_type_t type, const size_t rawDataSize,
const uint8_t *pMultiMetricData, uint32_t &metricValueCount,
zet_typed_value_t *pCalculatedData, const uint32_t setIndex);
ze_result_t calculateMetricForSubdevice(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
const uint8_t *pRawData, uint32_t *pMetricValueCount,
zet_typed_value_t *pMetricValues);
void fillStallDataMap(const size_t rawDataSize, const uint8_t *pRawData, size_t *processedSize,
L0GfxCoreHelper &l0GfxCoreHelper,
std::map<uint64_t, void *> &stallReportDataMap,
bool *dataOverflow);
protected:
L0::L0GfxCoreHelper &gfxCoreHelper;
IpSamplingMetricSourceImp &metricSource;
};
struct IpSamplingMetricDataHeader {
static constexpr uint32_t magicValue = 0xFEEDBCBA;
uint32_t magic;

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

@@ -190,7 +190,9 @@ ze_result_t IpSamplingMetricCalcOpImp::metricCalculateValuesSingle(const size_t
uint32_t resultCount = 0;
*usedSize = 0;
status = static_cast<IpSamplingMetricGroupImp *>(metricGroupBase)->getCalculatedMetricCount(pRawData, rawDataSize, resultCount);
auto calcUtils = metricGroupBase->getMetricSource().ipSamplingCalculation.get();
status = calcUtils->getMetricCount(pRawData, rawDataSize, resultCount);
if (status != ZE_RESULT_SUCCESS) {
*pTotalMetricReportCount = 0;
return status;