intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-03 06:49:52 +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

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

@@ -890,6 +890,28 @@ ze_result_t metricCalculateGetReportFormat(
return MetricCalcOp::fromHandle(hCalculateOperation)->getReportFormat(pCount, phMetrics);
}
ze_result_t metricCalculateValues(
const size_t rawDataSize,
size_t *pOffset,
const uint8_t *pRawData,
zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation,
uint32_t *pTotalMetricReportsCount,
zet_intel_metric_result_exp_t *pMetricResults) {
return MetricCalcOp::fromHandle(hCalculateOperation)->metricCalculateValues(rawDataSize, pOffset, pRawData, pTotalMetricReportsCount, pMetricResults);
}
ze_result_t metricCalculateMultipleValues(
const size_t rawDataSize,
size_t *offset,
const uint8_t *pRawData,
zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation,
uint32_t *pSetCount,
uint32_t *pMetricsReportCountPerSet,
uint32_t *pTotalMetricReportCount,
zet_intel_metric_result_exp_t *pMetricResults) {
return MetricCalcOp::fromHandle(hCalculateOperation)->metricCalculateMultipleValues(rawDataSize, offset, pRawData, pSetCount, pMetricsReportCountPerSet, pTotalMetricReportCount, pMetricResults);
}
ze_result_t metricsEnable(zet_device_handle_t hDevice) {
auto isFailed = false;

27
level_zero/tools/source/metrics/metric.h
View File

@@ -36,8 +36,6 @@ static_assert(IsCompliantWithDdiHandlesExt<_zet_metric_query_handle_t>);
struct _zet_metric_programmable_exp_handle_t : BaseHandle {};
static_assert(IsCompliantWithDdiHandlesExt<_zet_metric_programmable_exp_handle_t>);
struct _zet_intel_metric_calculate_operation_exp_handle_t {};
namespace L0 {
struct METRICS_LOG_BITMASK { // NOLINT(readability-identifier-naming)
@@ -428,16 +426,20 @@ struct HomogeneousMultiDeviceMetricCreated : public MultiDeviceMetricImp {
struct MetricCalcOp : _zet_intel_metric_calculate_operation_exp_handle_t {
virtual ~MetricCalcOp() = default;
MetricCalcOp() {}
virtual ze_result_t destroy() = 0;
virtual ze_result_t getReportFormat(uint32_t *pCount, zet_metric_handle_t *phMetrics) = 0;
static MetricCalcOp *fromHandle(zet_intel_metric_calculate_operation_exp_handle_t handle) {
return static_cast<MetricCalcOp *>(handle);
}
inline zet_intel_metric_calculate_operation_exp_handle_t toHandle() { return this; }
virtual ze_result_t metricCalculateMultipleValues(size_t rawDataSize, size_t *offset, const uint8_t *pRawData,
virtual ze_result_t destroy() = 0;
virtual ze_result_t getReportFormat(uint32_t *pCount, zet_metric_handle_t *phMetrics) = 0;
virtual ze_result_t metricCalculateMultipleValues(const size_t rawDataSize, size_t *offset, const uint8_t *pRawData,
uint32_t *pSetCount, uint32_t *pMetricsReportCountPerSet,
uint32_t *pTotalMetricReportCount,
zet_intel_metric_result_exp_t *pMetricResults) = 0;
virtual 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) = 0;
};
struct MetricCalcOpImp : public MetricCalcOp {
@@ -509,6 +511,21 @@ ze_result_t metricCalculateOperationDestroy(zet_intel_metric_calculate_operation
ze_result_t metricCalculateGetReportFormat(zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation,
uint32_t *pCount, zet_metric_handle_t *phMetrics);
ze_result_t metricCalculateValues(const size_t rawDataSize, size_t *pOffset, const uint8_t *pRawData,
zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation,
uint32_t *pTotalMetricReportsCount, zet_intel_metric_result_exp_t *pMetricResults);
ze_result_t metricCalculateMultipleValues(const size_t rawDataSize, size_t *offset, const uint8_t *pRawData,
zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation,
uint32_t *pSetCount, uint32_t *pMetricsReportCountPerSet,
uint32_t *pTotalMetricReportCount, zet_intel_metric_result_exp_t *pMetricResults);
ze_result_t metricDecodeCalculateMultipleValues(zet_intel_metric_decoder_exp_handle_t hMetricDecoder,
const size_t rawDataSize, size_t *offset, const uint8_t *pRawData,
zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation,
uint32_t *pSetCount, uint32_t *pMetricReportCountPerSet,
uint32_t *pTotalMetricReportCount, zet_intel_metric_result_exp_t *pMetricResults);
ze_result_t metricsEnable(zet_device_handle_t hDevice);
} // namespace L0

15
level_zero/tools/source/metrics/metric_device_context_create.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2023-2024 Intel Corporation
* Copyright (C) 2023-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -82,4 +82,17 @@ ze_result_t metricTracerDecode(
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t metricDecodeCalculateMultipleValues(
zet_intel_metric_decoder_exp_handle_t hMetricDecoder,
const size_t rawDataSize,
size_t *offset,
const uint8_t *pRawData,
zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation,
uint32_t *pSetCount,
uint32_t *pMetricReportCountPerSet,
uint32_t *pTotalMetricReportCount,
zet_intel_metric_result_exp_t *pMetricResults) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
} // namespace L0

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

@@ -93,7 +93,7 @@ void IpSamplingMetricSourceImp::cacheMetricGroup() {
metricProperties.tierNumber = 4;
metricProperties.resultType = ZET_VALUE_TYPE_UINT64;
// Preparing properties for IP seperately because of unique values
// Preparing properties for IP separately because of unique values
strcpy_s(metricProperties.name, ZET_MAX_METRIC_NAME, "IP");
strcpy_s(metricProperties.description, ZET_MAX_METRIC_DESCRIPTION, "IP address");
metricProperties.metricType = ZET_METRIC_TYPE_IP;
@@ -140,6 +140,7 @@ ze_result_t IpSamplingMetricSourceImp::metricGroupGet(uint32_t *pCount, zet_metr
}
ze_result_t IpSamplingMetricSourceImp::appendMetricMemoryBarrier(CommandList &commandList) {
METRICS_LOG_ERR("%s", "Memory barrier not supported for IP Sampling");
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
@@ -147,6 +148,7 @@ ze_result_t IpSamplingMetricSourceImp::activateMetricGroupsPreferDeferred(uint32
zet_metric_group_handle_t *phMetricGroups) {
auto status = activationTracker->activateMetricGroupsDeferred(count, phMetricGroups);
if (!status) {
METRICS_LOG_ERR("%s", "Metric group activation failed");
return ZE_RESULT_ERROR_UNKNOWN;
}
return ZE_RESULT_SUCCESS;
@@ -252,7 +254,6 @@ ze_result_t IpSamplingMetricSourceImp::calcOperationCreate(MetricDeviceContext &
// All metrics in Ip sampling allow calculation
*pCount = 0;
*phExcludedMetrics = nullptr;
bool isMultiDevice = (metricDeviceContext.isImplicitScalingCapable()) ? true : false;
status = IpSamplingMetricCalcOpImp::create(*this, pCalculateDesc, isMultiDevice, phCalculateOperation);
@@ -305,7 +306,7 @@ ze_result_t IpSamplingMetricGroupImp::metricGet(uint32_t *pCount, zet_metric_han
return ZE_RESULT_SUCCESS;
}
bool IpSamplingMetricGroupImp::isMultiDeviceCaptureData(const size_t rawDataSize, const uint8_t *pRawData) {
bool IpSamplingMetricGroupBase::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;
@@ -319,8 +320,8 @@ ze_result_t IpSamplingMetricGroupImp::calculateMetricValues(const zet_metric_gro
const bool calculateCountOnly = *pMetricValueCount == 0;
if (isMultiDeviceCaptureData(rawDataSize, pRawData)) {
METRICS_LOG_INFO("%s", "The call is not supported for multiple devices");
METRICS_LOG_INFO("%s", "Please use zetMetricGroupCalculateMultipleMetricValuesExp instead");
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;
}
@@ -404,6 +405,8 @@ ze_result_t IpSamplingMetricGroupImp::getCalculatedMetricCount(const uint8_t *pR
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;
}
@@ -494,6 +497,7 @@ ze_result_t IpSamplingMetricGroupImp::getCalculatedMetricValues(const zet_metric
// 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;
}
@@ -502,6 +506,8 @@ ze_result_t IpSamplingMetricGroupImp::getCalculatedMetricValues(const zet_metric
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;
}

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

@@ -100,6 +100,9 @@ struct IpSamplingMetricGroupBase : public MetricGroupImp {
ze_result_t destroy() override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
static bool isMultiDeviceCaptureData(const size_t rawDataSize, const uint8_t *pRawData);
IpSamplingMetricSourceImp &getMetricSource() { return static_cast<IpSamplingMetricSourceImp &>(metricSource); }
};
struct IpSamplingMetricGroupImp : public IpSamplingMetricGroupBase {
@@ -127,20 +130,18 @@ struct IpSamplingMetricGroupImp : public IpSamplingMetricGroupBase {
zet_metric_streamer_handle_t *phMetricStreamer) override;
static std::unique_ptr<IpSamplingMetricGroupImp> create(IpSamplingMetricSourceImp &metricSource,
std::vector<IpSamplingMetricImp> &ipSamplingMetrics);
IpSamplingMetricSourceImp &getMetricSource() { return static_cast<IpSamplingMetricSourceImp &>(metricSource); }
ze_result_t getCalculatedMetricCount(const uint8_t *pMultiMetricData, const size_t rawDataSize, uint32_t &metricValueCount, const uint32_t setIndex);
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 getCalculatedMetricCount(const uint8_t *pRawData, const size_t rawDataSize, uint32_t &metricValueCount);
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);
bool isMultiDeviceCaptureData(const size_t rawDataSize, const uint8_t *pRawData);
};
struct MultiDeviceIpSamplingMetricGroupImp : public IpSamplingMetricGroupBase {

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

@@ -7,7 +7,11 @@
#include "level_zero/tools/source/metrics/metric_ip_sampling_streamer.h"
#include "shared/source/execution_environment/root_device_environment.h"
#include "level_zero/core/source/device/device.h"
#include "level_zero/core/source/device/device_imp.h"
#include "level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper.h"
#include "level_zero/tools/source/metrics/metric.h"
#include "level_zero/tools/source/metrics/metric_ip_sampling_source.h"
#include "level_zero/tools/source/metrics/os_interface_metric.h"
@@ -115,19 +119,23 @@ ze_result_t IpSamplingMetricCalcOpImp::create(IpSamplingMetricSourceImp &metricS
std::vector<zet_metric_handle_t> hMetrics(metricCount);
MetricGroup::fromHandle(hMetricGroup)->metricGet(&metricCount, hMetrics.data());
std::vector<MetricImp *> inputMetricsInReport = {};
std::vector<uint32_t> includedMetricIndexes = {};
for (uint32_t i = 0; i < metricCount; i++) {
auto metric = static_cast<MetricImp *>(Metric::fromHandle(hMetrics[i]));
if (pCalculateDesc->metricGroupCount > 0) {
inputMetricsInReport.push_back(metric);
includedMetricIndexes.push_back(i);
} else {
if (uniqueMetricHandles.find(hMetrics[i]) != uniqueMetricHandles.end()) {
inputMetricsInReport.push_back(metric);
includedMetricIndexes.push_back(i);
}
}
}
auto calcOp = new IpSamplingMetricCalcOpImp(inputMetricsInReport, isMultiDevice);
auto calcOp = new IpSamplingMetricCalcOpImp(static_cast<uint32_t>(hMetrics.size()),
inputMetricsInReport, includedMetricIndexes, isMultiDevice);
*phCalculateOperation = calcOp->toHandle();
return ZE_RESULT_SUCCESS;
}
@@ -140,22 +148,156 @@ ze_result_t IpSamplingMetricCalcOpImp::destroy() {
ze_result_t IpSamplingMetricCalcOpImp::getReportFormat(uint32_t *pCount, zet_metric_handle_t *phMetrics) {
if (*pCount == 0) {
*pCount = metricCount;
*pCount = metricsInReportCount;
return ZE_RESULT_SUCCESS;
} else if (*pCount < metricCount) {
} else if (*pCount < metricsInReportCount) {
METRICS_LOG_ERR("%s", "Metric can't be smaller than report size");
*pCount = 0;
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
*pCount = metricCount;
for (uint32_t index = 0; index < metricCount; index++) {
*pCount = metricsInReportCount;
for (uint32_t index = 0; index < metricsInReportCount; index++) {
phMetrics[index] = metricsInReport[index]->toHandle();
}
return ZE_RESULT_SUCCESS;
}
void IpSamplingMetricCalcOpImp::fillStallDataMap(const size_t rawDataSize, const uint8_t *pRawData, size_t *processedSize,
L0::L0GfxCoreHelper &l0GfxCoreHelper,
std::map<uint64_t, void *> &stallReportDataMap,
bool *dataOVerflow,
bool allowInterrupt,
uint32_t requestedReportCount) {
const uint32_t rawReportSize = IpSamplingMetricGroupBase::rawReportSize;
*processedSize = 0;
uint32_t processedReportCount = 0;
const uint8_t *dataToProcess = pRawData;
do {
*dataOVerflow |= l0GfxCoreHelper.stallIpDataMapUpdate(stallReportDataMap, dataToProcess);
*processedSize += rawReportSize;
dataToProcess += rawReportSize;
// Number of reports is defined by the number of IPs in the raw data.
processedReportCount = static_cast<uint32_t>(stallReportDataMap.size());
} while ((*processedSize < rawDataSize) &&
(!allowInterrupt || (processedReportCount < requestedReportCount)));
return;
}
ze_result_t IpSamplingMetricCalcOpImp::metricCalculateValuesSingle(const size_t rawDataSize, size_t *pOffset, const uint8_t *pRawData,
uint32_t *pTotalMetricReportCount,
L0::L0GfxCoreHelper &l0GfxCoreHelper,
IpSamplingMetricGroupBase *metricGroupBase,
bool getSize,
bool &dataOverflow,
std::map<uint64_t, void *> &stallReportDataMap) {
ze_result_t status = ZE_RESULT_ERROR_UNKNOWN;
uint32_t resultCount = 0;
*pOffset = 0;
status = static_cast<IpSamplingMetricGroupImp *>(metricGroupBase)->getCalculatedMetricCount(pRawData, rawDataSize, resultCount);
if (status != ZE_RESULT_SUCCESS) {
*pTotalMetricReportCount = 0;
return status;
}
uint32_t rawDataReportCount = resultCount / cachedMetricsCount;
if (getSize) {
*pTotalMetricReportCount = rawDataReportCount;
return ZE_RESULT_SUCCESS;
}
// Only allow interrupting when requesting less reports than available since it affects the bytes
// processed: report count can be reached before processing all data.
bool allowInterrupt = false;
if (*pTotalMetricReportCount < rawDataReportCount) {
allowInterrupt = true;
}
fillStallDataMap(rawDataSize, pRawData, pOffset, l0GfxCoreHelper, stallReportDataMap,
&dataOverflow, allowInterrupt, *pTotalMetricReportCount);
*pTotalMetricReportCount = static_cast<uint32_t>(stallReportDataMap.size());
return status;
}
ze_result_t IpSamplingMetricCalcOpImp::metricCalculateValuesMulti(const size_t rawDataSize, size_t *pOffset, const uint8_t *pRawData,
uint32_t *pTotalMetricReportCount,
L0::L0GfxCoreHelper &l0GfxCoreHelper,
IpSamplingMetricGroupBase *metricGroupBase,
bool getSize,
uint32_t numSubDevices,
bool &dataOverflow,
std::map<uint64_t, void *> &stallReportDataMap) {
ze_result_t status = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
return status;
}
ze_result_t IpSamplingMetricCalcOpImp::metricCalculateValues(const size_t rawDataSize, size_t *pOffset, const uint8_t *pRawData,
uint32_t *pTotalMetricReportCount,
zet_intel_metric_result_exp_t *pMetricResults) {
ze_result_t status = ZE_RESULT_ERROR_UNKNOWN;
bool dataOverflow = false;
uint32_t metricGroupCount = 1;
zet_metric_group_handle_t hMetricGroup = {};
metricsInReport[0]->getMetricSource().metricGroupGet(&metricGroupCount, &hMetricGroup);
bool isMultiDeviceData = IpSamplingMetricGroupBase::isMultiDeviceCaptureData(rawDataSize, pRawData);
IpSamplingMetricGroupBase *metricGroupBase = static_cast<IpSamplingMetricGroupBase *>(MetricGroup::fromHandle(hMetricGroup));
DeviceImp *deviceImp = static_cast<DeviceImp *>(&metricGroupBase->getMetricSource().getMetricDeviceContext().getDevice());
L0::L0GfxCoreHelper &l0GfxCoreHelper = deviceImp->getNEODevice()->getRootDeviceEnvironment().getHelper<L0GfxCoreHelper>();
pRawData += *pOffset; // Input Offset
bool getSize = (*pTotalMetricReportCount == 0);
std::map<uint64_t, void *> stallReportDataMap;
if (!isMultiDevice) {
if (isMultiDeviceData) {
METRICS_LOG_ERR("%s", "Cannot use root device raw data in a sub-device calculate operation handle");
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
status = metricCalculateValuesSingle(rawDataSize, pOffset, pRawData, pTotalMetricReportCount,
l0GfxCoreHelper, metricGroupBase, getSize, dataOverflow, stallReportDataMap);
} else {
if (!isMultiDeviceData) {
METRICS_LOG_ERR("%s", "Cannot use sub-device raw data in a root device calculate operation handle");
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
status = metricCalculateValuesMulti(rawDataSize, pOffset, pRawData, pTotalMetricReportCount,
l0GfxCoreHelper, metricGroupBase, getSize, deviceImp->numSubDevices,
dataOverflow, stallReportDataMap);
}
if ((status != ZE_RESULT_SUCCESS) || (getSize)) {
return status;
}
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 (uint32_t j = 0; j < includedMetricIndexes.size(); j++) {
(pMetricResults + i)->value = ipDataValues[includedMetricIndexes[j]].value;
(pMetricResults + i)->resultStatus = ZET_INTEL_METRIC_CALCULATE_EXP_RESULT_VALID;
i++;
}
ipDataValues.clear();
}
l0GfxCoreHelper.stallIpDataMapDelete(stallReportDataMap);
stallReportDataMap.clear();
return dataOverflow ? ZE_RESULT_WARNING_DROPPED_DATA : ZE_RESULT_SUCCESS;
}
ze_result_t MultiDeviceIpSamplingMetricGroupImp::streamerOpen(
zet_context_handle_t hContext,
zet_device_handle_t hDevice,

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

@@ -14,6 +14,9 @@ namespace L0 {
class IpSamplingMetricSourceImp;
struct IpSamplingMetricImp;
struct IpSamplingMetricGroupBase;
struct IpSamplingMetricGroupImp;
class L0GfxCoreHelper;
struct IpSamplingMetricStreamerBase : public MetricStreamer {
ze_result_t appendStreamerMarker(CommandList &commandList, uint32_t value) override { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; }
@@ -45,10 +48,13 @@ struct MultiDeviceIpSamplingMetricStreamerImp : public IpSamplingMetricStreamerB
};
struct IpSamplingMetricCalcOpImp : public MetricCalcOpImp {
IpSamplingMetricCalcOpImp(std::vector<MetricImp *> &inputMetricsInReport,
bool multidevice) : MetricCalcOpImp(multidevice),
metricCount(static_cast<uint32_t>(inputMetricsInReport.size())),
metricsInReport(inputMetricsInReport) {}
IpSamplingMetricCalcOpImp(uint32_t inputCachedMetricsCount, std::vector<MetricImp *> &inputMetricsInReport,
std::vector<uint32_t> &inputIncludedMetricIndexes, bool multidevice)
: MetricCalcOpImp(multidevice),
cachedMetricsCount(inputCachedMetricsCount),
metricsInReportCount(static_cast<uint32_t>(inputMetricsInReport.size())),
metricsInReport(inputMetricsInReport),
includedMetricIndexes(inputIncludedMetricIndexes) {}
~IpSamplingMetricCalcOpImp() override{};
static ze_result_t create(IpSamplingMetricSourceImp &metricSource,
@@ -57,16 +63,44 @@ struct IpSamplingMetricCalcOpImp : public MetricCalcOpImp {
zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation);
ze_result_t destroy() override;
ze_result_t getReportFormat(uint32_t *pCount, zet_metric_handle_t *phMetrics) override;
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 *pMetricsReportCountPerSet,
uint32_t *pTotalMetricReportCount,
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;
void fillStallDataMap(const size_t rawDataSize, const uint8_t *pRawData, size_t *processedSize,
L0GfxCoreHelper &l0GfxCoreHelper,
std::map<uint64_t, void *> &stallReportDataMap,
bool *dataOVerflow,
bool allowInterrupt,
uint32_t requestedReportCount);
protected:
uint32_t metricCount = 0;
ze_result_t metricCalculateValuesSingle(const size_t rawDataSize, size_t *pOffset, const uint8_t *pRawData,
uint32_t *pTotalMetricReportCount,
L0::L0GfxCoreHelper &l0GfxCoreHelper,
IpSamplingMetricGroupBase *metricGroupBase,
bool getSize,
bool &dataOverflow,
std::map<uint64_t, void *> &stallReportDataMap);
ze_result_t metricCalculateValuesMulti(const size_t rawDataSize, size_t *pOffset, const uint8_t *pRawData,
uint32_t *pTotalMetricReportCount,
L0::L0GfxCoreHelper &l0GfxCoreHelper,
IpSamplingMetricGroupBase *metricGroupBase,
bool getSize,
uint32_t numSubDevices,
bool &dataOverflow,
std::map<uint64_t, void *> &stallReportDataMap);
uint32_t cachedMetricsCount = 0;
uint32_t metricsInReportCount = 0;
std::vector<MetricImp *> metricsInReport{};
std::vector<uint32_t> includedMetricIndexes{};
};
} // namespace L0

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

@@ -855,8 +855,8 @@ ze_result_t OaMetricGroupImp::calculateMetricValues(const zet_metric_group_calcu
const MetricGroupCalculateHeader *pRawHeader = reinterpret_cast<const MetricGroupCalculateHeader *>(pRawData);
if (pRawHeader->magic == MetricGroupCalculateHeader::magicValue) {
METRICS_LOG_INFO("%s", "The call is not supported for multiple devices");
METRICS_LOG_INFO("%s", "Please use zetMetricGroupCalculateMultipleMetricValuesExp instead");
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;
}