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: add support for activateMetrics

Browse Source 
Related-To: NEO-9067

Signed-off-by: Joshua Santosh Ranjan <joshua.santosh.ranjan@intel.com>
This commit is contained in:
Joshua Santosh Ranjan
2023-12-01 07:56:57 +00:00
committed by Compute-Runtime-Automation
parent 950dacdcd7
commit 20e0b6f005
25 changed files with 544 additions and 182 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -93,80 +93,42 @@ ze_result_t MetricDeviceContext::metricGroupGet(uint32_t *pCount, zet_metric_gro
return result;
}
void MetricDeviceContext::activateMetricGroupsDeferred(uint32_t count, zet_metric_group_handle_t *phMetricGroups) {
ze_result_t MetricDeviceContext::activateMetricGroupsPreferDeferred(uint32_t count, zet_metric_group_handle_t *phMetricGroups) {
// Activation: postpone until zetMetricStreamerOpen or zeCommandQueueExecuteCommandLists
// Deactivation: execute immediately.
if (phMetricGroups == nullptr) {
deActivateAllDomains();
return;
}
auto isMetricGroupProvided = [phMetricGroups, count](const zet_metric_group_handle_t hMetricGroup) {
for (auto index = 0u; index < count; index++) {
if (hMetricGroup == phMetricGroups[index]) {
return true;
}
}
return false;
};
// Deactive existing metric groups which are not provided in phMetricGroups
std::vector<uint32_t> deactivateList = {};
for (const auto &[domainId, metricGroupPair] : domains) {
const auto &hMetricGroup = metricGroupPair.first;
if (isMetricGroupProvided(hMetricGroup) == false) {
deActivateDomain(domainId);
deactivateList.push_back(domainId);
}
}
// Remove deactivated ones from the map
for (const auto &domainId : deactivateList) {
domains.erase(domainId);
}
// Activate-deferred new metric groups if any
// Create a map of metric source types and Metric groups
std::map<uint32_t, std::vector<zet_metric_group_handle_t>> metricGroupsPerMetricSourceMap{};
for (auto index = 0u; index < count; index++) {
auto &metricGroupSource =
static_cast<MetricGroupImp *>(MetricGroup::fromHandle(phMetricGroups[index]))->getMetricSource();
metricGroupsPerMetricSourceMap[metricGroupSource.getType()].push_back(phMetricGroups[index]);
}
zet_metric_group_handle_t hMetricGroup = MetricGroup::fromHandle(phMetricGroups[index])->getMetricGroupForSubDevice(subDeviceIndex);
zet_metric_group_properties_t properties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
MetricGroup::fromHandle(hMetricGroup)->getProperties(&properties);
auto domain = properties.domain;
// Domain already associated with the same handle.
if (domains[domain].first == hMetricGroup) {
for (auto const &entry : metricSources) {
auto const &metricSourceEntry = entry.second;
auto status = ZE_RESULT_SUCCESS;
if (!metricSourceEntry->isAvailable()) {
continue;
}
domains[domain].first = hMetricGroup;
domains[domain].second = false;
}
}
auto sourceType = metricSourceEntry->getType();
ze_result_t MetricDeviceContext::activateAllDomains() {
for (auto &entry : domains) {
auto &metricGroup = entry.second;
DEBUG_BREAK_IF(metricGroup.first == nullptr);
MetricGroup::fromHandle(metricGroup.first)->activate();
metricGroup.second = true;
if (metricGroupsPerMetricSourceMap.find(sourceType) == metricGroupsPerMetricSourceMap.end()) {
status = metricSourceEntry->activateMetricGroupsPreferDeferred(0, nullptr);
} else {
auto &metricGroupVec = metricGroupsPerMetricSourceMap[sourceType];
status = metricSourceEntry->activateMetricGroupsPreferDeferred(
static_cast<uint32_t>(metricGroupVec.size()),
metricGroupVec.data());
}
if (status != ZE_RESULT_SUCCESS) {
return status;
}
}
return ZE_RESULT_SUCCESS;
}
void MetricDeviceContext::deActivateDomain(uint32_t domain) {
auto &metricGroupPair = domains[domain];
if (metricGroupPair.second == true) {
MetricGroup::fromHandle(metricGroupPair.first)->deactivate();
}
}
void MetricDeviceContext::deActivateAllDomains() {
for (auto &entry : domains) {
deActivateDomain(entry.first);
}
domains.clear();
}
ze_result_t MetricDeviceContext::appendMetricMemoryBarrier(CommandList &commandList) {
bool isSuccess = false;
@@ -186,32 +148,16 @@ ze_result_t MetricDeviceContext::appendMetricMemoryBarrier(CommandList &commandL
return isSuccess == false ? ZE_RESULT_ERROR_UNSUPPORTED_FEATURE : ZE_RESULT_SUCCESS;
}
bool MetricDeviceContext::isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) const {
for (auto const &entry : domains) {
auto const &metricGroup = entry.second;
if (metricGroup.first == hMetricGroup) {
return true;
}
}
return false;
}
bool MetricDeviceContext::isMetricGroupActivated() const {
for (auto const &entry : domains) {
auto const &metricGroup = entry.second;
if (metricGroup.second == true) {
return true;
}
}
return false;
}
bool MetricDeviceContext::isImplicitScalingCapable() const {
return multiDeviceCapable;
}
ze_result_t MetricDeviceContext::activateMetricGroups() {
return activateAllDomains();
for (auto const &entry : metricSources) {
auto const &metricSource = entry.second;
metricSource->activateMetricGroupsAlreadyDeferred();
}
return ZE_RESULT_SUCCESS;
}
uint32_t MetricDeviceContext::getSubDeviceIndex() const {
@@ -299,4 +245,102 @@ ze_result_t MetricGroup::getMetricGroupExtendedProperties(MetricSource &metricSo
return retVal;
}
bool MultiDomainDeferredActivationTracker::activateMetricGroupsDeferred(uint32_t count, zet_metric_group_handle_t *phMetricGroups) {
// Activation: postpone until zetMetricStreamerOpen or zeCommandQueueExecuteCommandLists
// Deactivation: execute immediately.
if (phMetricGroups == nullptr) {
deActivateAllDomains();
return true;
}
auto isMetricGroupProvided = [phMetricGroups, count](const zet_metric_group_handle_t hMetricGroup) {
for (auto index = 0u; index < count; index++) {
if (hMetricGroup == phMetricGroups[index]) {
return true;
}
}
return false;
};
// Deactive existing metric groups which are not provided in phMetricGroups
std::vector<uint32_t> deactivateList = {};
for (const auto &[domainId, metricGroupPair] : domains) {
const auto &hMetricGroup = metricGroupPair.first;
if (isMetricGroupProvided(hMetricGroup) == false) {
deActivateDomain(domainId);
deactivateList.push_back(domainId);
}
}
// Remove deactivated ones from the map
for (const auto &domainId : deactivateList) {
domains.erase(domainId);
}
// Activate-deferred new metric groups if any
for (auto index = 0u; index < count; index++) {
zet_metric_group_handle_t hMetricGroup = MetricGroup::fromHandle(phMetricGroups[index])->getMetricGroupForSubDevice(subDeviceIndex);
zet_metric_group_properties_t properties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
auto metricGroup = MetricGroup::fromHandle(hMetricGroup);
metricGroup->getProperties(&properties);
auto domain = properties.domain;
// Domain already associated with the same handle.
if (domains[domain].first == hMetricGroup) {
continue;
}
domains[domain].first = hMetricGroup;
domains[domain].second = false;
}
return true;
}
ze_result_t MultiDomainDeferredActivationTracker::activateMetricGroupsAlreadyDeferred() {
for (auto &entry : domains) {
auto &metricGroupEntry = entry.second;
DEBUG_BREAK_IF(metricGroupEntry.first == nullptr);
auto metricGroup = MetricGroup::fromHandle(metricGroupEntry.first);
metricGroup->activate();
metricGroupEntry.second = true;
}
return ZE_RESULT_SUCCESS;
}
void MultiDomainDeferredActivationTracker::deActivateDomain(uint32_t domain) {
auto &metricGroupPair = domains[domain];
if (metricGroupPair.second == true) {
MetricGroup::fromHandle(metricGroupPair.first)->deactivate();
}
}
void MultiDomainDeferredActivationTracker::deActivateAllDomains() {
for (auto &entry : domains) {
deActivateDomain(entry.first);
}
domains.clear();
}
bool MultiDomainDeferredActivationTracker::isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) const {
for (auto const &entry : domains) {
auto const &metricGroup = entry.second;
if (metricGroup.first == hMetricGroup) {
return true;
}
}
return false;
}
bool MultiDomainDeferredActivationTracker::isMetricGroupActivatedInHw() const {
for (auto const &entry : domains) {
auto const &metricGroup = entry.second;
if (metricGroup.second == true) {
return true;
}
}
return false;
}
} // namespace L0

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

@@ -39,7 +39,32 @@ class MetricSource {
virtual ze_result_t metricGroupGet(uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups) = 0;
virtual ze_result_t getTimerResolution(uint64_t &resolution) = 0;
virtual ze_result_t getTimestampValidBits(uint64_t &validBits) = 0;
virtual ze_result_t activateMetricGroupsPreferDeferred(uint32_t count, zet_metric_group_handle_t *phMetricGroups) = 0;
virtual ze_result_t activateMetricGroupsAlreadyDeferred() = 0;
virtual ~MetricSource() = default;
uint32_t getType() const {
return type;
}
protected:
uint32_t type = MetricSource::metricSourceTypeUndefined;
};
class MultiDomainDeferredActivationTracker {
public:
MultiDomainDeferredActivationTracker(uint32_t subDeviceIndex) : subDeviceIndex(subDeviceIndex) {}
virtual ~MultiDomainDeferredActivationTracker() = default;
ze_result_t activateMetricGroupsAlreadyDeferred();
virtual bool activateMetricGroupsDeferred(uint32_t count, zet_metric_group_handle_t *phMetricGroups);
bool isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) const;
bool isMetricGroupActivatedInHw() const;
protected:
void deActivateDomain(uint32_t domain);
void deActivateAllDomains();
std::map<uint32_t, std::pair<zet_metric_group_handle_t, bool>> domains = {};
uint32_t subDeviceIndex{};
};
class MetricDeviceContext {
@@ -47,11 +72,9 @@ class MetricDeviceContext {
public:
MetricDeviceContext(Device &device);
ze_result_t metricGroupGet(uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups);
void activateMetricGroupsDeferred(uint32_t count, zet_metric_group_handle_t *phMetricGroups);
ze_result_t activateMetricGroupsPreferDeferred(uint32_t count, zet_metric_group_handle_t *phMetricGroups);
ze_result_t activateMetricGroups();
ze_result_t appendMetricMemoryBarrier(CommandList &commandList);
bool isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) const;
bool isMetricGroupActivated() const;
bool isImplicitScalingCapable() const;
Device &getDevice() const;
uint32_t getSubDeviceIndex() const;
@@ -67,11 +90,7 @@ class MetricDeviceContext {
private:
bool enable();
ze_result_t activateAllDomains();
void deActivateAllDomains();
void deActivateDomain(uint32_t domain);
struct Device &device;
std::map<uint32_t, std::pair<zet_metric_group_handle_t, bool>> domains;
bool multiDeviceCapable = false;
uint32_t subDeviceIndex = 0;
};
@@ -87,6 +106,7 @@ struct Metric : _zet_metric_handle_t {
struct MetricGroup : _zet_metric_group_handle_t {
virtual ~MetricGroup() = default;
MetricGroup() {}
virtual ze_result_t getProperties(zet_metric_group_properties_t *pProperties) = 0;
virtual ze_result_t metricGet(uint32_t *pCount, zet_metric_handle_t *phMetrics) = 0;
@@ -124,6 +144,18 @@ struct MetricGroup : _zet_metric_group_handle_t {
uint8_t *pExportData) = 0;
};
struct MetricGroupImp : public MetricGroup {
MetricSource &getMetricSource() {
return metricSource;
}
~MetricGroupImp() override = default;
MetricGroupImp(MetricSource &metricSource) : metricSource(metricSource) {}
protected:
MetricSource &metricSource;
};
struct MetricGroupCalculateHeader {
static constexpr uint32_t magicValue = 0xFFFEDCBA;

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

@@ -31,6 +31,8 @@ std::unique_ptr<IpSamplingMetricSourceImp> IpSamplingMetricSourceImp::create(con
IpSamplingMetricSourceImp::IpSamplingMetricSourceImp(const MetricDeviceContext &metricDeviceContext) : metricDeviceContext(metricDeviceContext) {
metricIPSamplingpOsInterface = MetricIpSamplingOsInterface::create(metricDeviceContext.getDevice());
activationTracker = std::make_unique<MultiDomainDeferredActivationTracker>(metricDeviceContext.getSubDeviceIndex());
type = MetricSource::metricSourceTypeIpSampling;
}
ze_result_t IpSamplingMetricSourceImp::getTimerResolution(uint64_t &resolution) {
@@ -70,7 +72,8 @@ void IpSamplingMetricSourceImp::cacheMetricGroup() {
subDeviceMetricGroup.push_back(static_cast<IpSamplingMetricGroupImp *>(MetricGroup::fromHandle(hMetricGroup)));
}
cachedMetricGroup = MultiDeviceIpSamplingMetricGroupImp::create(subDeviceMetricGroup);
IpSamplingMetricSourceImp &source = deviceImp->getMetricDeviceContext().getMetricSource<IpSamplingMetricSourceImp>();
cachedMetricGroup = MultiDeviceIpSamplingMetricGroupImp::create(source, subDeviceMetricGroup);
return;
}
@@ -145,6 +148,23 @@ ze_result_t IpSamplingMetricSourceImp::appendMetricMemoryBarrier(CommandList &co
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t IpSamplingMetricSourceImp::activateMetricGroupsPreferDeferred(uint32_t count,
zet_metric_group_handle_t *phMetricGroups) {
auto status = activationTracker->activateMetricGroupsDeferred(count, phMetricGroups);
if (!status) {
return ZE_RESULT_ERROR_UNKNOWN;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t IpSamplingMetricSourceImp::activateMetricGroupsAlreadyDeferred() {
return activationTracker->activateMetricGroupsAlreadyDeferred();
}
bool IpSamplingMetricSourceImp::isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) const {
return activationTracker->isMetricGroupActivated(hMetricGroup);
}
void IpSamplingMetricSourceImp::setMetricOsInterface(std::unique_ptr<MetricIpSamplingOsInterface> &metricIPSamplingpOsInterface) {
this->metricIPSamplingpOsInterface = std::move(metricIPSamplingpOsInterface);
}
@@ -179,7 +199,7 @@ ze_result_t IpSamplingMetricGroupBase::getExportData(const uint8_t *pRawData, si
}
IpSamplingMetricGroupImp::IpSamplingMetricGroupImp(IpSamplingMetricSourceImp &metricSource,
std::vector<IpSamplingMetricImp> &metrics) : metricSource(metricSource) {
std::vector<IpSamplingMetricImp> &metrics) : IpSamplingMetricGroupBase(metricSource) {
this->metrics.reserve(metrics.size());
for (const auto &metric : metrics) {
this->metrics.push_back(std::make_unique<IpSamplingMetricImp>(metric));
@@ -628,9 +648,10 @@ ze_result_t MultiDeviceIpSamplingMetricGroupImp::getMetricTimestampsExp(const ze
}
std::unique_ptr<MultiDeviceIpSamplingMetricGroupImp> MultiDeviceIpSamplingMetricGroupImp::create(
MetricSource &metricSource,
std::vector<IpSamplingMetricGroupImp *> &subDeviceMetricGroup) {
UNRECOVERABLE_IF(subDeviceMetricGroup.size() == 0);
return std::unique_ptr<MultiDeviceIpSamplingMetricGroupImp>(new (std::nothrow) MultiDeviceIpSamplingMetricGroupImp(subDeviceMetricGroup));
return std::unique_ptr<MultiDeviceIpSamplingMetricGroupImp>(new (std::nothrow) MultiDeviceIpSamplingMetricGroupImp(metricSource, subDeviceMetricGroup));
}
IpSamplingMetricImp::IpSamplingMetricImp(zet_metric_properties_t &properties) : properties(properties) {

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

@@ -25,6 +25,10 @@ class IpSamplingMetricSourceImp : public MetricSource {
bool isAvailable() override;
ze_result_t metricGroupGet(uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups) override;
ze_result_t appendMetricMemoryBarrier(CommandList &commandList) override;
ze_result_t activateMetricGroupsAlreadyDeferred() override;
ze_result_t activateMetricGroupsPreferDeferred(const uint32_t count,
zet_metric_group_handle_t *phMetricGroups) override;
bool isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) const;
void setMetricOsInterface(std::unique_ptr<MetricIpSamplingOsInterface> &metricIPSamplingpOsInterface);
static std::unique_ptr<IpSamplingMetricSourceImp> create(const MetricDeviceContext &metricDeviceContext);
MetricIpSamplingOsInterface *getMetricOsInterface() { return metricIPSamplingpOsInterface.get(); }
@@ -32,6 +36,9 @@ class IpSamplingMetricSourceImp : public MetricSource {
const MetricDeviceContext &getMetricDeviceContext() const { return metricDeviceContext; }
ze_result_t getTimerResolution(uint64_t &resolution) override;
ze_result_t getTimestampValidBits(uint64_t &validBits) override;
void setActivationTracker(MultiDomainDeferredActivationTracker *inputActivationTracker) {
activationTracker.reset(inputActivationTracker);
}
protected:
void cacheMetricGroup();
@@ -40,6 +47,7 @@ class IpSamplingMetricSourceImp : public MetricSource {
const MetricDeviceContext &metricDeviceContext;
std::unique_ptr<MetricIpSamplingOsInterface> metricIPSamplingpOsInterface = nullptr;
std::unique_ptr<MetricGroup> cachedMetricGroup = nullptr;
std::unique_ptr<MultiDomainDeferredActivationTracker> activationTracker{};
};
typedef struct StallSumIpData {
@@ -56,7 +64,8 @@ typedef struct StallSumIpData {
typedef std::map<uint64_t, StallSumIpData_t> StallSumIpDataMap_t;
struct IpSamplingMetricGroupBase : public MetricGroup {
struct IpSamplingMetricGroupBase : public MetricGroupImp {
IpSamplingMetricGroupBase(MetricSource &metricSource) : MetricGroupImp(metricSource) {}
static constexpr uint32_t rawReportSize = 64u;
bool activate() override { return true; }
bool deactivate() override { return true; };
@@ -93,7 +102,7 @@ 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 metricSource; }
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,
@@ -109,12 +118,11 @@ struct IpSamplingMetricGroupImp : public IpSamplingMetricGroupBase {
bool stallIpDataMapUpdate(StallSumIpDataMap_t &, const uint8_t *pRawIpData);
void stallSumIpDataToTypedValues(uint64_t ip, StallSumIpData_t &sumIpData, std::vector<zet_typed_value_t> &ipDataValues);
bool isMultiDeviceCaptureData(const size_t rawDataSize, const uint8_t *pRawData);
IpSamplingMetricSourceImp &metricSource;
};
struct MultiDeviceIpSamplingMetricGroupImp : public IpSamplingMetricGroupBase {
MultiDeviceIpSamplingMetricGroupImp(std::vector<IpSamplingMetricGroupImp *> &subDeviceMetricGroup) : subDeviceMetricGroup(subDeviceMetricGroup){};
MultiDeviceIpSamplingMetricGroupImp(MetricSource &metricSource, std::vector<IpSamplingMetricGroupImp *> &subDeviceMetricGroup) : IpSamplingMetricGroupBase(metricSource), subDeviceMetricGroup(subDeviceMetricGroup){};
~MultiDeviceIpSamplingMetricGroupImp() override = default;
ze_result_t getProperties(zet_metric_group_properties_t *pProperties) override;
ze_result_t metricGet(uint32_t *pCount, zet_metric_handle_t *phMetrics) override;
@@ -135,7 +143,7 @@ struct MultiDeviceIpSamplingMetricGroupImp : public IpSamplingMetricGroupBase {
zet_metric_streamer_desc_t *desc,
ze_event_handle_t hNotificationEvent,
zet_metric_streamer_handle_t *phMetricStreamer) override;
static std::unique_ptr<MultiDeviceIpSamplingMetricGroupImp> create(std::vector<IpSamplingMetricGroupImp *> &subDeviceMetricGroup);
static std::unique_ptr<MultiDeviceIpSamplingMetricGroupImp> create(MetricSource &metricSource, std::vector<IpSamplingMetricGroupImp *> &subDeviceMetricGroup);
private:
void closeSubDeviceStreamers(std::vector<IpSamplingMetricStreamerImp *> &subDeviceStreamers);

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

@@ -42,21 +42,22 @@ ze_result_t IpSamplingMetricGroupImp::streamerOpen(
auto device = Device::fromHandle(hDevice);
// Check whether metric group is activated.
if (!device->getMetricDeviceContext().isMetricGroupActivated(this->toHandle())) {
IpSamplingMetricSourceImp &source = device->getMetricDeviceContext().getMetricSource<IpSamplingMetricSourceImp>();
if (!source.isMetricGroupActivated(this->toHandle())) {
return ZE_RESULT_NOT_READY;
}
// Check whether metric streamer is already open.
if (metricSource.pActiveStreamer != nullptr) {
if (source.pActiveStreamer != nullptr) {
return ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE;
}
auto pStreamerImp = new IpSamplingMetricStreamerImp(metricSource);
auto pStreamerImp = new IpSamplingMetricStreamerImp(source);
UNRECOVERABLE_IF(pStreamerImp == nullptr);
const ze_result_t result = metricSource.getMetricOsInterface()->startMeasurement(desc->notifyEveryNReports, desc->samplingPeriod);
const ze_result_t result = source.getMetricOsInterface()->startMeasurement(desc->notifyEveryNReports, desc->samplingPeriod);
if (result == ZE_RESULT_SUCCESS) {
metricSource.pActiveStreamer = pStreamerImp;
source.pActiveStreamer = pStreamerImp;
pStreamerImp->attachEvent(hNotificationEvent);
} else {
delete pStreamerImp;

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

@@ -273,8 +273,7 @@ ze_result_t MetricEnumeration::cacheMetricInformation() {
// Cache and aggregate all metric groups from all sub devices.
for (uint32_t i = 0; i < metricGroupCount; i++) {
auto metricGroupRootDevice = new OaMetricGroupImp();
metricGroupRootDevice->setMetricSource(&metricSource);
auto metricGroupRootDevice = new OaMetricGroupImp(metricSource);
for (auto subDevice : deviceImp.subDevices) {
MetricGroup *metricGroupSubDevice = subDevice->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>().getMetricEnumeration().getMetricGroupByIndex(i);
@@ -562,7 +561,7 @@ ze_result_t OaMetricGroupImp::getProperties(zet_metric_group_properties_t *pProp
copyProperties(properties, *pProperties);
pProperties->pNext = pNext;
if (pNext) {
status = getMetricGroupExtendedProperties(*metricSource, pNext);
status = getMetricGroupExtendedProperties(metricSource, pNext);
}
}
@@ -606,6 +605,7 @@ bool OaMetricGroupImp::activate() {
return true;
}
auto metricSource = getMetricSource();
auto hConfiguration = metricSource->getMetricsLibrary().getConfiguration(toHandle());
// Validate metrics library handle.
if (!hConfiguration.IsValid()) {
@@ -626,6 +626,7 @@ bool OaMetricGroupImp::deactivate() {
return true;
}
auto metricSource = getMetricSource();
auto hConfiguration = metricSource->getMetricsLibrary().getConfiguration(toHandle());
// Deactivate metric group configuration using metrics library.
metricSource->getMetricsLibrary().deactivateConfiguration(hConfiguration);
@@ -979,7 +980,6 @@ ze_result_t OaMetricGroupImp::initialize(const zet_metric_group_properties_t &so
pReferenceMetricSet = &metricSet;
pReferenceConcurrentGroup = &concurrentGroup;
metrics = groupMetrics;
this->metricSource = &metricSource;
return ZE_RESULT_SUCCESS;
}
@@ -1039,7 +1039,7 @@ void OaMetricGroupImp::copyValue(const MetricsDiscovery::TTypedValue_1_0 &source
}
const MetricEnumeration &OaMetricGroupImp::getMetricEnumeration() const {
return metricSource->getMetricEnumeration();
return getMetricSource()->getMetricEnumeration();
}
void OaMetricGroupImp::setCachedExportDataHeapSize(size_t size) {
@@ -1079,7 +1079,7 @@ MetricGroup *OaMetricGroupImp::create(zet_metric_group_properties_t &properties,
MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup,
const std::vector<Metric *> &metrics,
MetricSource &metricSource) {
auto pMetricGroup = new OaMetricGroupImp();
auto pMetricGroup = new OaMetricGroupImp(metricSource);
UNRECOVERABLE_IF(pMetricGroup == nullptr);
pMetricGroup->initialize(properties, metricSet, concurrentGroup, metrics, static_cast<OaMetricSourceImp &>(metricSource));
pMetricGroup->isPredefined = true;

10
level_zero/tools/source/metrics/metric_oa_enumeration_imp.h
View File

@@ -10,6 +10,7 @@
#include "shared/source/os_interface/os_library.h"
#include "level_zero/tools/source/metrics/metric.h"
#include "level_zero/tools/source/metrics/metric_oa_source.h"
#include <vector>
@@ -18,8 +19,6 @@ namespace L0 {
static constexpr std::string_view globalSymbolOaMaxBufferSize = "OABufferMaxSize";
static constexpr std::string_view globalSymbolOaMaxTimestamp = "MaxTimestamp";
class OaMetricSourceImp;
struct MetricEnumeration {
MetricEnumeration(OaMetricSourceImp &metricSource);
virtual ~MetricEnumeration();
@@ -122,8 +121,9 @@ struct MetricEnumeration {
static const char *oaConcurrentGroupName;
};
struct OaMetricGroupImp : MetricGroup {
struct OaMetricGroupImp : MetricGroupImp {
~OaMetricGroupImp() override;
OaMetricGroupImp(MetricSource &metricSource) : MetricGroupImp(metricSource) {}
ze_result_t getProperties(zet_metric_group_properties_t *pProperties) override;
ze_result_t metricGet(uint32_t *pCount, zet_metric_handle_t *phMetrics) override;
@@ -178,8 +178,7 @@ struct OaMetricGroupImp : MetricGroup {
MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup,
const std::vector<Metric *> &metrics,
MetricSource &metricSource);
OaMetricSourceImp *getMetricSource() { return metricSource; }
void setMetricSource(OaMetricSourceImp *inputMetricSource) { metricSource = inputMetricSource; }
OaMetricSourceImp *getMetricSource() const { return static_cast<OaMetricSourceImp *>(&metricSource); }
static ze_result_t getProperties(const zet_metric_group_handle_t handle, zet_metric_group_properties_t *pProperties);
uint32_t getRawReportSize();
const MetricEnumeration &getMetricEnumeration() const;
@@ -207,7 +206,6 @@ struct OaMetricGroupImp : MetricGroup {
MetricsDiscovery::IConcurrentGroup_1_5 *pReferenceConcurrentGroup = nullptr;
std::vector<zet_metric_group_handle_t> metricGroups;
OaMetricSourceImp *metricSource = nullptr;
size_t cachedExportDataHeapSize = 0;
bool isPredefined{};

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

@@ -718,6 +718,8 @@ ze_result_t OaMetricGroupImp::getExportDataHeapSize(size_t &exportDataHeapSize)
}
HeapUsageTracker memoryTracker(0, 0, HeapUsageTracker::OperationModeTrackOnly);
OaMetricSourceImp *metricSource = getMetricSource();
MetricsDiscovery::IMetricsDevice_1_5 *mdDevice = metricSource->getMetricEnumeration().getMdapiDevice();
MetricsDiscovery::IAdapter_1_9 *mdAdapter = metricSource->getMetricEnumeration().getMdapiAdapter();
@@ -763,6 +765,8 @@ ze_result_t OaMetricGroupImp::getExportData(const uint8_t *pRawData,
uintptr_t endHeapAddress = startHeapAddress + requiredHeapSize;
HeapUsageTracker memoryTracker(startHeapAddress, endHeapAddress);
OaMetricSourceImp *metricSource = getMetricSource();
MetricsDiscovery::IMetricsDevice_1_5 *mdDevice = metricSource->getMetricEnumeration().getMdapiDevice();
MetricsDiscovery::IAdapter_1_9 *mdAdapter = metricSource->getMetricEnumeration().getMdapiAdapter();
MetricOaExporter01 exporter01(*mdDevice, *mdAdapter, *pReferenceMetricSet, *pReferenceConcurrentGroup, memoryTracker);

2
level_zero/tools/source/metrics/metric_oa_query_imp.cpp
View File

@@ -586,7 +586,7 @@ ze_result_t OaMetricQueryPoolImp::destroy() {
// Check open queries.
if (metricSource.getMetricsLibrary().getMetricQueryCount() == 0) {
if (!metricSource.isMetricGroupActivated()) {
if (!metricSource.isMetricGroupActivatedInHw()) {
metricSource.getMetricsLibrary().release();
}
}

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

@@ -27,6 +27,8 @@ OaMetricSourceImp::OaMetricSourceImp(const MetricDeviceContext &metricDeviceCont
metricEnumeration(std::unique_ptr<MetricEnumeration>(new(std::nothrow) MetricEnumeration(*this))),
metricsLibrary(std::unique_ptr<MetricsLibrary>(new(std::nothrow) MetricsLibrary(*this))) {
metricOAOsInterface = MetricOAOsInterface::create(metricDeviceContext.getDevice());
activationTracker = std::make_unique<MultiDomainDeferredActivationTracker>(metricDeviceContext.getSubDeviceIndex());
type = MetricSource::metricSourceTypeOa;
}
OaMetricSourceImp::~OaMetricSourceImp() = default;
@@ -156,11 +158,11 @@ uint32_t OaMetricSourceImp::getSubDeviceIndex() {
}
bool OaMetricSourceImp::isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) const {
return metricDeviceContext.isMetricGroupActivated(hMetricGroup);
return activationTracker->isMetricGroupActivated(hMetricGroup);
}
bool OaMetricSourceImp::isMetricGroupActivated() const {
return metricDeviceContext.isMetricGroupActivated();
bool OaMetricSourceImp::isMetricGroupActivatedInHw() const {
return activationTracker->isMetricGroupActivatedInHw();
}
bool OaMetricSourceImp::isImplicitScalingCapable() const {
@@ -171,6 +173,16 @@ void OaMetricSourceImp::setMetricOsInterface(std::unique_ptr<MetricOAOsInterface
this->metricOAOsInterface = std::move(metricOAOsInterface);
}
ze_result_t OaMetricSourceImp::activateMetricGroupsPreferDeferred(uint32_t count,
zet_metric_group_handle_t *phMetricGroups) {
activationTracker->activateMetricGroupsDeferred(count, phMetricGroups);
return ZE_RESULT_SUCCESS;
}
ze_result_t OaMetricSourceImp::activateMetricGroupsAlreadyDeferred() {
return activationTracker->activateMetricGroupsAlreadyDeferred();
}
template <>
OaMetricSourceImp &MetricDeviceContext::getMetricSource<OaMetricSourceImp>() const {
return static_cast<OaMetricSourceImp &>(*metricSources.at(MetricSource::metricSourceTypeOa));

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

@@ -41,11 +41,11 @@ class OaMetricSourceImp : public MetricSource {
ze_result_t getTimerResolution(uint64_t &resolution) override;
ze_result_t getTimestampValidBits(uint64_t &validBits) override;
ze_result_t activateMetricGroups();
ze_result_t activateMetricGroupsDeferred(const uint32_t count,
zet_metric_group_handle_t *phMetricGroups);
ze_result_t activateMetricGroupsAlreadyDeferred() override;
ze_result_t activateMetricGroupsPreferDeferred(const uint32_t count,
zet_metric_group_handle_t *phMetricGroups) override;
bool isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) const;
bool isMetricGroupActivated() const;
bool isMetricGroupActivatedInHw() const;
void setUseCompute(const bool useCompute);
bool isComputeUsed() const;
uint32_t getSubDeviceIndex();
@@ -65,6 +65,7 @@ class OaMetricSourceImp : public MetricSource {
MetricStreamer *pMetricStreamer = nullptr;
bool useCompute = false;
std::unique_ptr<MetricOAOsInterface> metricOAOsInterface = nullptr;
std::unique_ptr<MultiDomainDeferredActivationTracker> activationTracker{};
};
template <>