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

feature: support excluded metrics from calc op

Browse Source 
Resolves: NEO-15492

Signed-off-by: Matias Cabral <matias.a.cabral@intel.com>
This commit is contained in:
Matias Cabral
2025-07-22 17:42:38 +00:00
committed by Compute-Runtime-Automation
parent ad78ea7da4
commit b7f9d55118
17 changed files with 221 additions and 144 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -590,8 +590,6 @@ bool MetricDeviceContext::areMetricsFromSameSource(uint32_t count, zet_metric_ha
ze_result_t MetricDeviceContext::calcOperationCreate(zet_context_handle_t hContext,
zet_intel_metric_calculate_exp_desc_t *pCalculateDesc,
uint32_t *pExcludedMetricCount,
zet_metric_handle_t *phExcludedMetrics,
zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation) {
if (pCalculateDesc->timeAggregationWindow == 0) {
@@ -642,7 +640,7 @@ ze_result_t MetricDeviceContext::calcOperationCreate(zet_context_handle_t hConte
}
MetricSource &metricSource = (metricGroupImp) ? metricGroupImp->getMetricSource() : metricImp->getMetricSource(); // NOLINT(clang-analyzer-core.CallAndMessage)
return metricSource.calcOperationCreate(*this, pCalculateDesc, pExcludedMetricCount, phExcludedMetrics, phCalculateOperation);
return metricSource.calcOperationCreate(*this, pCalculateDesc, phCalculateOperation);
}
std::unique_ptr<MetricScopeImp> MetricScopeImp::create(zet_intel_metric_scope_properties_exp_t &scopeProperties) {
@@ -966,6 +964,32 @@ MetricImp *HomogeneousMultiDeviceMetricCreated::create(MetricSource &metricSourc
return new (std::nothrow) HomogeneousMultiDeviceMetricCreated(metricSource, subDeviceMetrics);
}
ze_result_t MetricCalcOpImp::getMetricsFromCalcOp(uint32_t *pCount, zet_metric_handle_t *phMetrics, bool isExcludedMetrics) {
if (*pCount == 0) {
*pCount = isExcludedMetrics ? excludedMetricCount : metricInReportCount;
return ZE_RESULT_SUCCESS;
} else if (*pCount < (isExcludedMetrics ? excludedMetricCount : metricInReportCount)) {
METRICS_LOG_ERR("%s", "Metric can't be smaller than report size");
*pCount = 0;
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
*pCount = isExcludedMetrics ? excludedMetricCount : metricInReportCount;
for (uint32_t index = 0; index < *pCount; index++) {
phMetrics[index] = isExcludedMetrics ? excludedMetrics[index]->toHandle() : metricsInReport[index]->toHandle();
}
return ZE_RESULT_SUCCESS;
}
ze_result_t MetricCalcOpImp::getReportFormat(uint32_t *pCount, zet_metric_handle_t *phMetrics) {
return getMetricsFromCalcOp(pCount, phMetrics, false);
}
ze_result_t MetricCalcOpImp::getExcludedMetrics(uint32_t *pCount, zet_metric_handle_t *phMetrics) {
return getMetricsFromCalcOp(pCount, phMetrics, true);
}
ze_result_t metricProgrammableGet(zet_device_handle_t hDevice, uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables) {
auto device = Device::fromHandle(hDevice);
return static_cast<MetricDeviceContext &>(device->getMetricDeviceContext()).metricProgrammableGet(pCount, phMetricProgrammables);
@@ -1007,12 +1031,10 @@ ze_result_t metricCalculateOperationCreate(
zet_context_handle_t hContext,
zet_device_handle_t hDevice,
zet_intel_metric_calculate_exp_desc_t *pCalculateDesc,
uint32_t *pExcludedMetricCount,
zet_metric_handle_t *phExcludedMetrics,
zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation) {
DeviceImp *deviceImp = static_cast<DeviceImp *>(L0::Device::fromHandle(hDevice));
return deviceImp->getMetricDeviceContext().calcOperationCreate(hContext, pCalculateDesc, pExcludedMetricCount, phExcludedMetrics, phCalculateOperation);
return deviceImp->getMetricDeviceContext().calcOperationCreate(hContext, pCalculateDesc, phCalculateOperation);
}
ze_result_t metricCalculateOperationDestroy(
@@ -1027,6 +1049,13 @@ ze_result_t metricCalculateGetReportFormat(
return MetricCalcOp::fromHandle(hCalculateOperation)->getReportFormat(pCount, phMetrics);
}
ze_result_t metricCalculateGetExcludedMetrics(
zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation,
uint32_t *pCount,
zet_metric_handle_t *phMetrics) {
return MetricCalcOp::fromHandle(hCalculateOperation)->getExcludedMetrics(pCount, phMetrics);
}
ze_result_t metricCalculateValues(
const size_t rawDataSize,
size_t *pOffset,

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

@@ -106,8 +106,6 @@ class MetricSource {
virtual ze_result_t appendMarker(zet_command_list_handle_t hCommandList, zet_metric_group_handle_t hMetricGroup, uint32_t value) = 0;
virtual ze_result_t calcOperationCreate(MetricDeviceContext &metricDeviceContext,
zet_intel_metric_calculate_exp_desc_t *pCalculateDesc,
uint32_t *pCount,
zet_metric_handle_t *phExcludedMetrics,
zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation) = 0;
virtual bool canDisable() = 0;
virtual void initMetricScopes(MetricDeviceContext &metricDeviceContext) = 0;
@@ -177,8 +175,6 @@ class MetricDeviceContext {
zet_metric_group_handle_t *phMetricGroups);
ze_result_t calcOperationCreate(zet_context_handle_t hContext,
zet_intel_metric_calculate_exp_desc_t *pCalculateDesc,
uint32_t *pExcludedMetricCount,
zet_metric_handle_t *phExcludedMetrics,
zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation);
ze_result_t metricScopesGet(zet_context_handle_t hContext,
uint32_t *pMetricScopesCount,
@@ -470,6 +466,7 @@ struct MetricCalcOp : _zet_intel_metric_calculate_operation_exp_handle_t {
virtual ze_result_t destroy() = 0;
virtual ze_result_t getReportFormat(uint32_t *pCount, zet_metric_handle_t *phMetrics) = 0;
virtual ze_result_t getExcludedMetrics(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,
@@ -481,11 +478,24 @@ struct MetricCalcOp : _zet_intel_metric_calculate_operation_exp_handle_t {
struct MetricCalcOpImp : public MetricCalcOp {
~MetricCalcOpImp() override = default;
MetricCalcOpImp(bool multiDevice) : isMultiDevice(multiDevice) {}
MetricCalcOpImp(bool multiDevice, const std::vector<MetricImp *> &inMetricsInReport,
uint32_t inExcludedMetricsCount = 0, const std::vector<MetricImp *> &inExcludedMetrics = std::vector<MetricImp *>())
: isMultiDevice(multiDevice), metricInReportCount(static_cast<uint32_t>(inMetricsInReport.size())),
metricsInReport(inMetricsInReport), excludedMetricCount(inExcludedMetricsCount),
excludedMetrics(inExcludedMetrics) {}
bool isRootDevice() { return isMultiDevice; }
ze_result_t getReportFormat(uint32_t *pCount, zet_metric_handle_t *phMetrics) override;
ze_result_t getExcludedMetrics(uint32_t *pCount, zet_metric_handle_t *phMetrics) override;
uint32_t getMetricsInReportCount() { return metricInReportCount; };
protected:
ze_result_t getMetricsFromCalcOp(uint32_t *pCount, zet_metric_handle_t *phMetrics, bool isExcludedMetrics = false);
bool isMultiDevice = false;
uint32_t metricInReportCount = 0;
std::vector<MetricImp *> metricsInReport{};
uint32_t excludedMetricCount = 0;
std::vector<MetricImp *> excludedMetrics{};
};
struct MetricScope : _zet_intel_metric_scope_exp_handle_t {
@@ -562,13 +572,16 @@ ze_result_t metricTracerDecode(zet_metric_decoder_exp_handle_t hMetricDecoder, s
uint32_t *pMetricEntriesCount, zet_metric_entry_exp_t *pMetricEntries);
ze_result_t metricCalculateOperationCreate(zet_context_handle_t hContext, zet_device_handle_t hDevice, zet_intel_metric_calculate_exp_desc_t *pCalculateDesc,
uint32_t *pCount, zet_metric_handle_t *phExcludedMetrics, zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation);
zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation);
ze_result_t metricCalculateOperationDestroy(zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation);
ze_result_t metricCalculateGetReportFormat(zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation,
uint32_t *pCount, zet_metric_handle_t *phMetrics);
ze_result_t metricCalculateGetExcludedMetrics(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);

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

@@ -267,14 +267,9 @@ ze_result_t IpSamplingMetricSourceImp::handleMetricGroupExtendedProperties(zet_m
ze_result_t IpSamplingMetricSourceImp::calcOperationCreate(MetricDeviceContext &metricDeviceContext,
zet_intel_metric_calculate_exp_desc_t *pCalculateDesc,
uint32_t *pExcludedMetricCount,
zet_metric_handle_t *phExcludedMetrics,
zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation) {
ze_result_t status = ZE_RESULT_ERROR_UNKNOWN;
// All metrics in Ip sampling allow calculation
*pExcludedMetricCount = 0;
bool isMultiDevice = (metricDeviceContext.isImplicitScalingCapable()) ? true : false;
status = IpSamplingMetricCalcOpImp::create(*this, pCalculateDesc, isMultiDevice, phCalculateOperation);
return status;

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

@@ -59,8 +59,6 @@ class IpSamplingMetricSourceImp : public MetricSource {
}
ze_result_t calcOperationCreate(MetricDeviceContext &metricDeviceContext,
zet_intel_metric_calculate_exp_desc_t *pCalculateDesc,
uint32_t *pExcludedMetricCount,
zet_metric_handle_t *phExcludedMetrics,
zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation) override;
uint32_t metricSourceCount = 0;

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

@@ -118,24 +118,25 @@ ze_result_t IpSamplingMetricCalcOpImp::create(IpSamplingMetricSourceImp &metricS
MetricGroup::fromHandle(hMetricGroup)->metricGet(&metricCount, nullptr);
std::vector<zet_metric_handle_t> hMetrics(metricCount);
MetricGroup::fromHandle(hMetricGroup)->metricGet(&metricCount, hMetrics.data());
std::vector<MetricImp *> inputMetricsInReport = {};
std::vector<MetricImp *> metricsInReport = {};
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);
metricsInReport.push_back(metric);
includedMetricIndexes.push_back(i);
} else {
if (uniqueMetricHandles.find(hMetrics[i]) != uniqueMetricHandles.end()) {
inputMetricsInReport.push_back(metric);
metricsInReport.push_back(metric);
includedMetricIndexes.push_back(i);
}
}
}
auto calcOp = new IpSamplingMetricCalcOpImp(static_cast<uint32_t>(hMetrics.size()),
inputMetricsInReport, includedMetricIndexes, isMultiDevice);
metricsInReport, includedMetricIndexes,
isMultiDevice);
*phCalculateOperation = calcOp->toHandle();
return ZE_RESULT_SUCCESS;
}
@@ -145,25 +146,6 @@ ze_result_t IpSamplingMetricCalcOpImp::destroy() {
return ZE_RESULT_SUCCESS;
}
ze_result_t IpSamplingMetricCalcOpImp::getReportFormat(uint32_t *pCount, zet_metric_handle_t *phMetrics) {
if (*pCount == 0) {
*pCount = metricsInReportCount;
return ZE_RESULT_SUCCESS;
} 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 = 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,

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

@@ -48,12 +48,11 @@ struct MultiDeviceIpSamplingMetricStreamerImp : public IpSamplingMetricStreamerB
};
struct IpSamplingMetricCalcOpImp : public MetricCalcOpImp {
IpSamplingMetricCalcOpImp(uint32_t inputCachedMetricsCount, std::vector<MetricImp *> &inputMetricsInReport,
IpSamplingMetricCalcOpImp(uint32_t inCachedMetricsCount,
std::vector<MetricImp *> &metricsInReport,
std::vector<uint32_t> &inputIncludedMetricIndexes, bool multidevice)
: MetricCalcOpImp(multidevice),
cachedMetricsCount(inputCachedMetricsCount),
metricsInReportCount(static_cast<uint32_t>(inputMetricsInReport.size())),
metricsInReport(inputMetricsInReport),
: MetricCalcOpImp(multidevice, metricsInReport),
cachedMetricsCount(inCachedMetricsCount),
includedMetricIndexes(inputIncludedMetricIndexes) {}
~IpSamplingMetricCalcOpImp() override{};
@@ -62,7 +61,6 @@ struct IpSamplingMetricCalcOpImp : public MetricCalcOpImp {
bool isMultiDevice,
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(const size_t rawDataSize, size_t *offset, const uint8_t *pRawData,
uint32_t *pSetCount, uint32_t *pMetricsReportCountPerSet,
uint32_t *pTotalMetricReportCount,
@@ -98,8 +96,6 @@ struct IpSamplingMetricCalcOpImp : public MetricCalcOpImp {
std::map<uint64_t, void *> &stallReportDataMap);
uint32_t cachedMetricsCount = 0;
uint32_t metricsInReportCount = 0;
std::vector<MetricImp *> metricsInReport{};
std::vector<uint32_t> includedMetricIndexes{};
};

2
level_zero/tools/source/metrics/metric_oa_source.h
View File

@@ -66,8 +66,6 @@ class OaMetricSourceImp : public MetricSource {
zet_metric_group_handle_t *pMetricGroupHandle);
ze_result_t calcOperationCreate(MetricDeviceContext &metricDeviceContext,
zet_intel_metric_calculate_exp_desc_t *pCalculateDesc,
uint32_t *pExcludedMetricCount,
zet_metric_handle_t *phExcludedMetrics,
zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}