intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-05 17:20:26 +08:00
Code Issues Packages Projects Releases Wiki Activity

feature: support for Metric Scopes

Browse Source 
Resolves: NEO-15136

Signed-off-by: Matias Cabral <matias.a.cabral@intel.com>
This commit is contained in:
Matias Cabral
2025-07-23 20:44:44 +00:00
committed by Compute-Runtime-Automation
parent bbcca97682
commit 93195e3501
21 changed files with 453 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -9,11 +9,15 @@
#include "shared/source/device/sub_device.h"
#include "shared/source/execution_environment/execution_environment.h"
#include "shared/source/execution_environment/root_device_environment.h"
#include "shared/source/helpers/gfx_core_helper.h"
#include "shared/source/helpers/hw_info.h"
#include "level_zero/core/source/device/device.h"
#include "level_zero/core/source/device/device_imp.h"
#include "level_zero/core/source/driver/driver.h"
#include "level_zero/core/source/driver/driver_handle_imp.h"
#include "level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper.h"
#include "level_zero/tools/source/metrics/metric_ip_sampling_source.h"
#include "level_zero/tools/source/metrics/metric_oa_source.h"
@@ -28,6 +32,48 @@ void MetricSource::getMetricGroupSourceIdProperty(zet_base_properties_t *propert
groupProperty->sourceId = type;
}
void MetricSource::initComputeMetricScopes(MetricDeviceContext &metricDeviceContext) {
auto createScope = [&metricDeviceContext](const std::string &name, const std::string &desc, uint32_t id) {
zet_intel_metric_scope_properties_exp_t scopeProperties = {ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP, nullptr};
scopeProperties.iD = id;
snprintf(scopeProperties.name, ZET_INTEL_MAX_METRIC_SCOPE_NAME_EXP, "%s", name.c_str());
snprintf(scopeProperties.description, ZET_INTEL_MAX_METRIC_SCOPE_NAME_EXP, "%s", desc.c_str());
auto metricScopeImp = MetricScopeImp::create(scopeProperties);
DEBUG_BREAK_IF(metricScopeImp == nullptr);
metricDeviceContext.addMetricScope(std::move(metricScopeImp));
};
if (metricDeviceContext.isMultiDeviceCapable()) {
auto deviceImp = static_cast<DeviceImp *>(&metricDeviceContext.getDevice());
uint32_t subDeviceCount = deviceImp->numSubDevices;
for (uint32_t i = 0; i < subDeviceCount; i++) {
std::string scopeName = "COMPUTE_TILE_" + std::to_string(i);
std::string scopeDesc = "Metrics results for tile " + std::to_string(i);
createScope(scopeName, scopeDesc, i);
}
auto &l0GfxCoreHelper = metricDeviceContext.getDevice().getNEODevice()->getRootDeviceEnvironment().getHelper<L0GfxCoreHelper>();
if (l0GfxCoreHelper.supportMetricsAggregation()) {
std::string scopeName = "DEVICE_AGGREGATED";
std::string scopeDesc = "Metrics results aggregated at device level";
createScope(scopeName, scopeDesc, subDeviceCount);
}
} else {
auto subDeviceIndex = metricDeviceContext.getSubDeviceIndex();
std::string scopeName = "COMPUTE_TILE_" + std::to_string(subDeviceIndex);
std::string scopeDesc = "Metrics results for tile " + std::to_string(subDeviceIndex);
createScope(scopeName, scopeDesc, subDeviceIndex);
}
metricDeviceContext.setComputeMetricScopeInitialized();
}
MetricDeviceContext::MetricDeviceContext(Device &inputDevice) : device(inputDevice) {
auto deviceNeo = device.getNEODevice();
std::tuple<uint32_t, uint32_t, uint32_t> subDeviceMap;
@@ -93,6 +139,11 @@ ze_result_t MetricDeviceContext::metricGroupGet(uint32_t *pCount, zet_metric_gro
ze_result_t result = ZE_RESULT_SUCCESS;
uint32_t availableCount = 0;
uint32_t requestCount = *pCount;
if (!metricScopesInitialized) {
initMetricScopes();
}
for (auto const &entry : metricSources) {
auto const &metricSource = entry.second;
@@ -198,14 +249,6 @@ ze_result_t MetricDeviceContext::activateMetricGroups() {
return ZE_RESULT_SUCCESS;
}
uint32_t MetricDeviceContext::getSubDeviceIndex() const {
return subDeviceIndex;
}
Device &MetricDeviceContext::getDevice() const {
return device;
}
void MetricDeviceContext::enableMetricApiForDevice(zet_device_handle_t hDevice, bool &isFailed) {
auto deviceImp = static_cast<DeviceImp *>(L0::Device::fromHandle(hDevice));
@@ -602,6 +645,53 @@ ze_result_t MetricDeviceContext::calcOperationCreate(zet_context_handle_t hConte
return metricSource.calcOperationCreate(*this, pCalculateDesc, pExcludedMetricCount, phExcludedMetrics, phCalculateOperation);
}
std::unique_ptr<MetricScopeImp> MetricScopeImp::create(zet_intel_metric_scope_properties_exp_t &scopeProperties) {
return std::make_unique<MetricScopeImp>(scopeProperties);
}
void MetricDeviceContext::initMetricScopes() {
for (auto const &entry : metricSources) {
auto const &metricSource = entry.second;
if (!metricSource->isAvailable()) {
continue;
}
metricSource->initMetricScopes(*this);
}
metricScopesInitialized = true;
}
ze_result_t MetricDeviceContext::metricScopesGet(zet_context_handle_t hContext, uint32_t *pMetricScopesCount,
zet_intel_metric_scope_exp_handle_t *phMetricScopes) {
if (!metricScopesInitialized) {
initMetricScopes();
}
if (*pMetricScopesCount == 0) {
*pMetricScopesCount = static_cast<uint32_t>(metricScopes.size());
return ZE_RESULT_SUCCESS;
}
// User is expected to allocate space.
DEBUG_BREAK_IF(phMetricScopes == nullptr);
*pMetricScopesCount = std::min(*pMetricScopesCount, static_cast<uint32_t>(metricScopes.size()));
for (uint32_t i = 0; i < *pMetricScopesCount; i++) {
phMetricScopes[i] = metricScopes[i]->toHandle();
}
return ZE_RESULT_SUCCESS;
}
ze_result_t MetricScopeImp::getProperties(zet_intel_metric_scope_properties_exp_t *pProperties) {
*pProperties = properties;
return ZE_RESULT_SUCCESS;
}
ze_result_t MultiDeviceMetricImp::getProperties(zet_metric_properties_t *pProperties) {
return subDeviceMetrics[0]->getProperties(pProperties);
}
@@ -970,4 +1060,21 @@ ze_result_t metricsDisable(zet_device_handle_t hDevice) {
return MetricDeviceContext::disableMetricApiForDevice(hDevice);
}
ze_result_t metricScopesGet(
zet_context_handle_t hContext,
zet_device_handle_t hDevice,
uint32_t *pMetricScopesCount,
zet_intel_metric_scope_exp_handle_t *phMetricScopes) {
DeviceImp *deviceImp = static_cast<DeviceImp *>(L0::Device::fromHandle(hDevice));
return deviceImp->getMetricDeviceContext().metricScopesGet(hContext, pMetricScopesCount, phMetricScopes);
}
ze_result_t metricScopeGetProperties(
zet_intel_metric_scope_exp_handle_t hMetricScope,
zet_intel_metric_scope_properties_exp_t *pMetricScopeProperties) {
return static_cast<MetricScopeImp *>(MetricScopeImp::fromHandle(hMetricScope))->getProperties(pMetricScopeProperties);
}
} // namespace L0

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

@@ -68,6 +68,7 @@ struct CommandList;
struct MetricStreamer;
struct MetricProgrammable;
class MetricDeviceContext;
struct MetricScopeImp;
class MetricSource {
public:
static constexpr uint32_t metricSourceTypeUndefined = 0u;
@@ -109,10 +110,12 @@ class MetricSource {
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;
protected:
uint32_t type = MetricSource::metricSourceTypeUndefined;
void getMetricGroupSourceIdProperty(zet_base_properties_t *property);
void initComputeMetricScopes(MetricDeviceContext &metricDeviceContext);
};
class MultiDomainDeferredActivationTracker {
@@ -137,7 +140,7 @@ class MetricDeviceContext {
public:
MetricDeviceContext(Device &device);
virtual ~MetricDeviceContext() {}
~MetricDeviceContext() {}
ze_result_t metricGroupGet(uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups);
ze_result_t activateMetricGroupsPreferDeferred(uint32_t count, zet_metric_group_handle_t *phMetricGroups);
ze_result_t activateMetricGroups();
@@ -148,8 +151,13 @@ class MetricDeviceContext {
zet_metric_group_sampling_type_flag_t samplingType,
zet_metric_group_handle_t *pMetricGroupHandle);
bool isImplicitScalingCapable() const;
Device &getDevice() const;
uint32_t getSubDeviceIndex() const;
Device &getDevice() const {
return device;
}
uint32_t getSubDeviceIndex() const {
return subDeviceIndex;
}
template <typename T>
T &getMetricSource() const;
void setSubDeviceIndex(uint32_t subDeviceIndex) { this->subDeviceIndex = subDeviceIndex; }
@@ -172,8 +180,25 @@ class MetricDeviceContext {
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,
zet_intel_metric_scope_exp_handle_t *phMetricScopes);
bool areMetricGroupsFromSameDeviceHierarchy(uint32_t count, zet_metric_group_handle_t *phMetricGroups);
void setMetricsCollectionAllowed(bool status) { isMetricsCollectionAllowed = status; }
bool isMultiDeviceCapable() const {
return multiDeviceCapable;
}
void addMetricScope(std::unique_ptr<MetricScopeImp> metricScope) {
metricScopes.push_back(std::move(metricScope));
}
void setComputeMetricScopeInitialized() {
computeMetricScopesInitialized = true;
}
bool isComputeMetricScopesInitialized() const {
return computeMetricScopesInitialized;
}
protected:
bool areMetricGroupsFromSameSource(uint32_t count, zet_metric_group_handle_t *phMetricGroups, uint32_t *sourceType);
@@ -181,17 +206,22 @@ class MetricDeviceContext {
bool areMetricsFromSameDeviceHierarchy(uint32_t count, zet_metric_handle_t *phMetrics);
std::map<uint32_t, std::unique_ptr<MetricSource>> metricSources;
bool multiDeviceCapable = false;
private:
bool enable();
bool canDisable();
void disable();
void initMetricScopes();
struct Device &device;
bool multiDeviceCapable = false;
uint32_t subDeviceIndex = 0;
bool isMetricsCollectionAllowed = false;
bool isEnableChecked = false;
std::mutex enableMetricsMutex;
std::vector<std::unique_ptr<MetricScopeImp>> metricScopes{};
bool metricScopesInitialized = false;
bool computeMetricScopesInitialized = false;
};
struct Metric : _zet_metric_handle_t {
@@ -458,6 +488,27 @@ struct MetricCalcOpImp : public MetricCalcOp {
bool isMultiDevice = false;
};
struct MetricScope : _zet_intel_metric_scope_exp_handle_t {
virtual ~MetricScope() = default;
MetricScope() {}
static MetricScope *fromHandle(zet_intel_metric_scope_exp_handle_t handle) {
return static_cast<MetricScope *>(handle);
}
inline zet_intel_metric_scope_exp_handle_t toHandle() { return this; }
};
struct MetricScopeImp : public MetricScope {
~MetricScopeImp() override = default;
MetricScopeImp(zet_intel_metric_scope_properties_exp_t &properties) : properties(properties){};
virtual ze_result_t getProperties(zet_intel_metric_scope_properties_exp_t *pProperties);
static std::unique_ptr<MetricScopeImp> create(zet_intel_metric_scope_properties_exp_t &scopeProperties);
private:
zet_intel_metric_scope_properties_exp_t properties;
};
// MetricGroup.
ze_result_t metricGroupGet(zet_device_handle_t hDevice, uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups);
@@ -535,5 +586,8 @@ ze_result_t metricDecodeCalculateMultipleValues(zet_intel_metric_decoder_exp_han
ze_result_t metricsEnable(zet_device_handle_t hDevice);
ze_result_t metricsDisable(zet_device_handle_t hDevice);
ze_result_t metricScopesGet(zet_context_handle_t hContext, zet_device_handle_t hDevice, uint32_t *pMetricScopesCount,
zet_intel_metric_scope_exp_handle_t *phMetricScopes);
ze_result_t metricScopeGetProperties(zet_intel_metric_scope_exp_handle_t hMetricScope, zet_intel_metric_scope_properties_exp_t *pMetricScopeProperties);
} // namespace L0

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

@@ -284,6 +284,12 @@ bool IpSamplingMetricSourceImp::canDisable() {
return !activationTracker->isAnyMetricGroupActivated();
}
void IpSamplingMetricSourceImp::initMetricScopes(MetricDeviceContext &metricDeviceContext) {
if (!metricDeviceContext.isComputeMetricScopesInitialized()) {
initComputeMetricScopes(metricDeviceContext);
}
}
IpSamplingMetricGroupImp::IpSamplingMetricGroupImp(IpSamplingMetricSourceImp &metricSource,
std::vector<IpSamplingMetricImp> &metrics) : IpSamplingMetricGroupBase(metricSource) {
this->metrics.reserve(metrics.size());

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

@@ -65,6 +65,7 @@ class IpSamplingMetricSourceImp : public MetricSource {
uint32_t metricSourceCount = 0;
bool canDisable() override;
void initMetricScopes(MetricDeviceContext &metricDeviceContext) override;
protected:
ze_result_t cacheMetricGroup();

6
level_zero/tools/source/metrics/metric_oa_source.cpp
View File

@@ -116,6 +116,12 @@ bool OaMetricSourceImp::canDisable() {
return !activationTracker->isAnyMetricGroupActivated();
}
void OaMetricSourceImp::initMetricScopes(MetricDeviceContext &metricDeviceContext) {
if (!metricDeviceContext.isComputeMetricScopesInitialized()) {
initComputeMetricScopes(metricDeviceContext);
}
}
MetricsLibrary &OaMetricSourceImp::getMetricsLibrary() {
return *metricsLibrary;
}

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

@@ -72,6 +72,7 @@ class OaMetricSourceImp : public MetricSource {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
bool canDisable() override;
void initMetricScopes(MetricDeviceContext &metricDeviceContext) override;
protected:
ze_result_t initializationState = ZE_RESULT_ERROR_UNINITIALIZED;