intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-18 22:08:53 +08:00
Code Issues Packages Projects Releases Wiki Activity

Metrics Refactor Rename Metric Source Specific Classes

Browse Source 
Renaming Oa Specific classes.

Related-To: LOCI-2753

Signed-off-by: Joshua Santosh Ranjan <joshua.santosh.ranjan@intel.com>
This commit is contained in:
Joshua Santosh Ranjan
2021-12-17 11:05:02 +00:00
committed by Compute-Runtime-Automation
parent 4aef9925b0
commit 78fa21f31a
9 changed files with 121 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -266,7 +266,7 @@ ze_result_t MetricGroupDomains::activateDeferred(const uint32_t subDeviceIndex,
DEBUG_BREAK_IF(!phMetricGroups[i]);
zet_metric_group_handle_t handle = phMetricGroups[i];
auto pMetricGroupImp = static_cast<MetricGroupImp *>(MetricGroup::fromHandle(handle));
auto pMetricGroupImp = static_cast<OaMetricGroupImp *>(MetricGroup::fromHandle(handle));
if (pMetricGroupImp->getMetricGroups().size() > 0) {
handle = pMetricGroupImp->getMetricGroups()[subDeviceIndex];
}

86
level_zero/tools/source/metrics/metric_enumeration_imp.cpp
View File

@@ -218,7 +218,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 MetricGroupImp();
auto metricGroupRootDevice = new OaMetricGroupImp();
for (auto subDevice : deviceImp.subDevices) {
MetricGroup *metricGroupSubDevice = subDevice->getMetricContext().getMetricEnumeration().getMetricGroupByIndex(i);
@@ -288,7 +288,7 @@ MetricEnumeration::cacheMetricGroup(MetricsDiscovery::IMetricSet_1_5 &metricSet,
MetricsDiscovery::TMetricSetParams_1_4 *pMetricSetParams = metricSet.GetParams();
DEBUG_BREAK_IF(pMetricSetParams == nullptr);
const uint32_t sourceApiMask = MetricGroupImp::getApiMask(samplingType);
const uint32_t sourceApiMask = OaMetricGroupImp::getApiMask(samplingType);
// Map metric groups to level zero format and cache them.
if (pMetricSetParams->ApiMask & sourceApiMask) {
@@ -472,7 +472,7 @@ zet_value_type_t MetricEnumeration::getMetricResultType(
}
}
MetricGroupImp ::~MetricGroupImp() {
OaMetricGroupImp ::~OaMetricGroupImp() {
for (size_t i = 0; i < metrics.size(); ++i) {
delete metrics[i];
@@ -481,7 +481,7 @@ MetricGroupImp ::~MetricGroupImp() {
metrics.clear();
};
ze_result_t MetricGroupImp::getProperties(zet_metric_group_properties_t *pProperties) {
ze_result_t OaMetricGroupImp::getProperties(zet_metric_group_properties_t *pProperties) {
if (metricGroups.size() > 0) {
*pProperties = MetricGroup::getProperties(metricGroups[0]);
} else {
@@ -500,7 +500,7 @@ zet_metric_group_properties_t MetricGroup::getProperties(const zet_metric_group_
return properties;
}
ze_result_t MetricGroupImp::getMetric(uint32_t *pCount, zet_metric_handle_t *phMetrics) {
ze_result_t OaMetricGroupImp::getMetric(uint32_t *pCount, zet_metric_handle_t *phMetrics) {
if (metricGroups.size() > 0) {
auto metricGroupSubDevice = MetricGroup::fromHandle(metricGroups[0]);
@@ -524,20 +524,20 @@ ze_result_t MetricGroupImp::getMetric(uint32_t *pCount, zet_metric_handle_t *phM
return ZE_RESULT_SUCCESS;
}
bool MetricGroupImp::activate() {
bool OaMetricGroupImp::activate() {
DEBUG_BREAK_IF(pReferenceMetricSet == nullptr);
const bool result = pReferenceMetricSet->Activate() == MetricsDiscovery::CC_OK;
DEBUG_BREAK_IF(!result);
return result;
}
bool MetricGroupImp::deactivate() {
bool OaMetricGroupImp::deactivate() {
DEBUG_BREAK_IF(pReferenceMetricSet == nullptr);
const bool result = pReferenceMetricSet->Deactivate() == MetricsDiscovery::CC_OK;
return result;
}
uint32_t MetricGroupImp::getApiMask(const zet_metric_group_sampling_type_flags_t samplingType) {
uint32_t OaMetricGroupImp::getApiMask(const zet_metric_group_sampling_type_flags_t samplingType) {
switch (samplingType) {
case ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED:
@@ -550,19 +550,19 @@ uint32_t MetricGroupImp::getApiMask(const zet_metric_group_sampling_type_flags_t
}
}
ze_result_t MetricGroupImp::openIoStream(uint32_t &timerPeriodNs, uint32_t &oaBufferSize) {
ze_result_t OaMetricGroupImp::openIoStream(uint32_t &timerPeriodNs, uint32_t &oaBufferSize) {
const auto openResult = pReferenceConcurrentGroup->OpenIoStream(pReferenceMetricSet, 0,
&timerPeriodNs, &oaBufferSize);
return (openResult == MetricsDiscovery::CC_OK) ? ZE_RESULT_SUCCESS : ZE_RESULT_ERROR_UNKNOWN;
}
ze_result_t MetricGroupImp::waitForReports(const uint32_t timeoutMs) {
ze_result_t OaMetricGroupImp::waitForReports(const uint32_t timeoutMs) {
return (pReferenceConcurrentGroup->WaitForReports(timeoutMs) == MetricsDiscovery::TCompletionCode::CC_OK)
? ZE_RESULT_SUCCESS
: ZE_RESULT_NOT_READY;
}
ze_result_t MetricGroupImp::readIoStream(uint32_t &reportCount, uint8_t &reportData) {
ze_result_t OaMetricGroupImp::readIoStream(uint32_t &reportCount, uint8_t &reportData) {
char *castedReportData = reinterpret_cast<char *>(&reportData);
const auto readResult =
@@ -578,14 +578,14 @@ ze_result_t MetricGroupImp::readIoStream(uint32_t &reportCount, uint8_t &reportD
}
}
ze_result_t MetricGroupImp::closeIoStream() {
ze_result_t OaMetricGroupImp::closeIoStream() {
const auto closeResult = pReferenceConcurrentGroup->CloseIoStream();
return (closeResult == MetricsDiscovery::CC_OK) ? ZE_RESULT_SUCCESS : ZE_RESULT_ERROR_UNKNOWN;
}
ze_result_t MetricGroupImp::calculateMetricValues(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
const uint8_t *pRawData, uint32_t *pMetricValueCount,
zet_typed_value_t *pMetricValues) {
ze_result_t OaMetricGroupImp::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 MetricGroupCalculateHeader *pRawHeader = reinterpret_cast<const MetricGroupCalculateHeader *>(pRawData);
if (pRawHeader->magic == MetricGroupCalculateHeader::magicValue) {
@@ -603,10 +603,10 @@ ze_result_t MetricGroupImp::calculateMetricValues(const zet_metric_group_calcula
return result ? ZE_RESULT_SUCCESS : ZE_RESULT_ERROR_UNKNOWN;
}
ze_result_t MetricGroupImp::calculateMetricValuesExp(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
const uint8_t *pRawData, uint32_t *pSetCount,
uint32_t *pTotalMetricValueCount, uint32_t *pMetricCounts,
zet_typed_value_t *pMetricValues) {
ze_result_t OaMetricGroupImp::calculateMetricValuesExp(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
const uint8_t *pRawData, uint32_t *pSetCount,
uint32_t *pTotalMetricValueCount, uint32_t *pMetricCounts,
zet_typed_value_t *pMetricValues) {
const MetricGroupCalculateHeader *pRawHeader = reinterpret_cast<const MetricGroupCalculateHeader *>(pRawData);
@@ -653,7 +653,7 @@ ze_result_t MetricGroupImp::calculateMetricValuesExp(const zet_metric_group_calc
for (size_t i = 0; i < metricGroupCount; i++) {
uint32_t metricCount = 0;
auto &metricGroup = *static_cast<MetricGroupImp *>(metricGroups[i]);
auto &metricGroup = *static_cast<OaMetricGroupImp *>(metricGroups[i]);
result = metricGroup.getCalculatedMetricCount(pRawDataSizesUnpacked[i], metricCount);
if (!result) {
@@ -680,7 +680,7 @@ ze_result_t MetricGroupImp::calculateMetricValuesExp(const zet_metric_group_calc
const uint32_t maxTotalMetricValueCount = *pTotalMetricValueCount;
*pTotalMetricValueCount = 0;
for (size_t i = 0; i < *pSetCount; i++) {
auto &metricGroup = *static_cast<MetricGroupImp *>(metricGroups[i]);
auto &metricGroup = *static_cast<OaMetricGroupImp *>(metricGroups[i]);
const uint32_t dataSize = pRawDataSizesUnpacked[i];
const uint8_t *pRawDataOffset = pRawDataOffsetUnpacked + pRawDataOffsetsUnpacked[i];
pMetricCounts[i] = maxTotalMetricValueCount;
@@ -702,8 +702,8 @@ ze_result_t MetricGroupImp::calculateMetricValuesExp(const zet_metric_group_calc
return result ? ZE_RESULT_SUCCESS : ZE_RESULT_ERROR_UNKNOWN;
}
bool MetricGroupImp::getCalculatedMetricCount(const size_t rawDataSize,
uint32_t &metricValueCount) {
bool OaMetricGroupImp::getCalculatedMetricCount(const size_t rawDataSize,
uint32_t &metricValueCount) {
uint32_t rawReportSize = getRawReportSize();
if (rawReportSize == 0) {
@@ -719,9 +719,9 @@ bool MetricGroupImp::getCalculatedMetricCount(const size_t rawDataSize,
return true;
}
bool MetricGroupImp::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 OaMetricGroupImp::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) {
uint32_t calculatedReportCount = 0;
uint32_t expectedMetricValueCount = 0;
@@ -739,7 +739,7 @@ bool MetricGroupImp::getCalculatedMetricValues(const zet_metric_group_calculatio
std::vector<MetricsDiscovery::TTypedValue_1_0> maximumValues(expectedMetricValueCount);
// Set filtering type.
pReferenceMetricSet->SetApiFiltering(MetricGroupImp::getApiMask(properties.samplingType));
pReferenceMetricSet->SetApiFiltering(OaMetricGroupImp::getApiMask(properties.samplingType));
// Calculate metrics.
const uint32_t outMetricsSize = static_cast<uint32_t>(calculatedMetrics.size()) * sizeof(MetricsDiscovery::TTypedValue_1_0);
@@ -777,10 +777,10 @@ bool MetricGroupImp::getCalculatedMetricValues(const zet_metric_group_calculatio
return result;
}
ze_result_t MetricGroupImp::initialize(const zet_metric_group_properties_t &sourceProperties,
MetricsDiscovery::IMetricSet_1_5 &metricSet,
MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup,
const std::vector<Metric *> &groupMetrics) {
ze_result_t OaMetricGroupImp::initialize(const zet_metric_group_properties_t &sourceProperties,
MetricsDiscovery::IMetricSet_1_5 &metricSet,
MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup,
const std::vector<Metric *> &groupMetrics) {
copyProperties(sourceProperties, properties);
pReferenceMetricSet = &metricSet;
pReferenceConcurrentGroup = &concurrentGroup;
@@ -788,7 +788,7 @@ ze_result_t MetricGroupImp::initialize(const zet_metric_group_properties_t &sour
return ZE_RESULT_SUCCESS;
}
uint32_t MetricGroupImp::getRawReportSize() {
uint32_t OaMetricGroupImp::getRawReportSize() {
auto pMetricSetParams = pReferenceMetricSet->GetParams();
return (properties.samplingType == ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED)
@@ -796,12 +796,12 @@ uint32_t MetricGroupImp::getRawReportSize() {
: pMetricSetParams->QueryReportSize;
}
std::vector<zet_metric_group_handle_t> &MetricGroupImp::getMetricGroups() {
std::vector<zet_metric_group_handle_t> &OaMetricGroupImp::getMetricGroups() {
return metricGroups;
}
void MetricGroupImp::copyProperties(const zet_metric_group_properties_t &source,
zet_metric_group_properties_t &destination) {
void OaMetricGroupImp::copyProperties(const zet_metric_group_properties_t &source,
zet_metric_group_properties_t &destination) {
destination = source;
memcpy_s(destination.name, sizeof(destination.name),
source.name, sizeof(destination.name));
@@ -809,8 +809,8 @@ void MetricGroupImp::copyProperties(const zet_metric_group_properties_t &source,
source.description, sizeof(destination.description));
}
void MetricGroupImp::copyValue(const MetricsDiscovery::TTypedValue_1_0 &source,
zet_typed_value_t &destination) const {
void OaMetricGroupImp::copyValue(const MetricsDiscovery::TTypedValue_1_0 &source,
zet_typed_value_t &destination) const {
destination = {};
@@ -843,18 +843,18 @@ void MetricGroupImp::copyValue(const MetricsDiscovery::TTypedValue_1_0 &source,
}
}
ze_result_t MetricImp::getProperties(zet_metric_properties_t *pProperties) {
ze_result_t OaMetricImp::getProperties(zet_metric_properties_t *pProperties) {
copyProperties(properties, *pProperties);
return ZE_RESULT_SUCCESS;
}
ze_result_t MetricImp::initialize(const zet_metric_properties_t &sourceProperties) {
ze_result_t OaMetricImp::initialize(const zet_metric_properties_t &sourceProperties) {
copyProperties(sourceProperties, properties);
return ZE_RESULT_SUCCESS;
}
void MetricImp::copyProperties(const zet_metric_properties_t &source,
zet_metric_properties_t &destination) {
void OaMetricImp::copyProperties(const zet_metric_properties_t &source,
zet_metric_properties_t &destination) {
destination = source;
memcpy_s(destination.name, sizeof(destination.name),
source.name, sizeof(destination.name));
@@ -870,14 +870,14 @@ MetricGroup *MetricGroup::create(zet_metric_group_properties_t &properties,
MetricsDiscovery::IMetricSet_1_5 &metricSet,
MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup,
const std::vector<Metric *> &metrics) {
auto pMetricGroup = new MetricGroupImp();
auto pMetricGroup = new OaMetricGroupImp();
UNRECOVERABLE_IF(pMetricGroup == nullptr);
pMetricGroup->initialize(properties, metricSet, concurrentGroup, metrics);
return pMetricGroup;
}
Metric *Metric::create(zet_metric_properties_t &properties) {
auto pMetric = new MetricImp();
auto pMetric = new OaMetricImp();
UNRECOVERABLE_IF(pMetric == nullptr);
pMetric->initialize(properties);
return pMetric;

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

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -71,8 +71,8 @@ struct MetricEnumeration {
static const char *oaConcurrentGroupName;
};
struct MetricGroupImp : MetricGroup {
~MetricGroupImp() override;
struct OaMetricGroupImp : MetricGroup {
~OaMetricGroupImp() override;
ze_result_t getProperties(zet_metric_group_properties_t *pProperties) override;
ze_result_t getMetric(uint32_t *pCount, zet_metric_handle_t *phMetrics) override;
@@ -128,8 +128,8 @@ struct MetricGroupImp : MetricGroup {
std::vector<zet_metric_group_handle_t> metricGroups;
};
struct MetricImp : Metric {
~MetricImp() override{};
struct OaMetricImp : Metric {
~OaMetricImp() override{};
ze_result_t getProperties(zet_metric_properties_t *pProperties) override;

66
level_zero/tools/source/metrics/metric_query_imp.cpp
View File

@@ -433,13 +433,13 @@ ze_result_t metricQueryPoolCreate(zet_context_handle_t hContext, zet_device_hand
}
const auto &deviceImp = *static_cast<DeviceImp *>(device);
auto metricPoolImp = new MetricQueryPoolImp(device->getMetricContext(), hMetricGroup, *pDesc);
auto metricPoolImp = new OaMetricQueryPoolImp(device->getMetricContext(), hMetricGroup, *pDesc);
if (metricContext.isImplicitScalingCapable()) {
auto emptyMetricGroups = std::vector<zet_metric_group_handle_t>();
auto &metricGroups = hMetricGroup
? static_cast<MetricGroupImp *>(MetricGroup::fromHandle(hMetricGroup))->getMetricGroups()
? static_cast<OaMetricGroupImp *>(MetricGroup::fromHandle(hMetricGroup))->getMetricGroups()
: emptyMetricGroups;
const bool useMetricGroupSubDevice = metricGroups.size() > 0;
@@ -457,7 +457,7 @@ ze_result_t metricQueryPoolCreate(zet_context_handle_t hContext, zet_device_hand
? metricGroups[subDeviceMetricContext.getSubDeviceIndex()]
: hMetricGroup;
auto metricPoolSubdeviceImp = new MetricQueryPoolImp(subDeviceMetricContext, metricGroupHandle, *pDesc);
auto metricPoolSubdeviceImp = new OaMetricQueryPoolImp(subDeviceMetricContext, metricGroupHandle, *pDesc);
// Create metric query pool.
if (!metricPoolSubdeviceImp->create()) {
@@ -496,14 +496,14 @@ ze_result_t metricQueryPoolCreate(zet_context_handle_t hContext, zet_device_hand
return ZE_RESULT_SUCCESS;
}
MetricQueryPoolImp::MetricQueryPoolImp(MetricContext &metricContextInput,
zet_metric_group_handle_t hEventMetricGroupInput,
const zet_metric_query_pool_desc_t &poolDescription)
OaMetricQueryPoolImp::OaMetricQueryPoolImp(MetricContext &metricContextInput,
zet_metric_group_handle_t hEventMetricGroupInput,
const zet_metric_query_pool_desc_t &poolDescription)
: metricContext(metricContextInput), metricsLibrary(metricContext.getMetricsLibrary()),
description(poolDescription),
hMetricGroup(hEventMetricGroupInput) {}
bool MetricQueryPoolImp::create() {
bool OaMetricQueryPoolImp::create() {
switch (description.type) {
case ZET_METRIC_QUERY_POOL_TYPE_PERFORMANCE:
return createMetricQueryPool();
@@ -515,7 +515,7 @@ bool MetricQueryPoolImp::create() {
}
}
ze_result_t MetricQueryPoolImp::destroy() {
ze_result_t OaMetricQueryPoolImp::destroy() {
switch (description.type) {
case ZET_METRIC_QUERY_POOL_TYPE_PERFORMANCE:
if (metricQueryPools.size() > 0) {
@@ -552,7 +552,7 @@ ze_result_t MetricQueryPoolImp::destroy() {
return ZE_RESULT_SUCCESS;
}
bool MetricQueryPoolImp::allocateGpuMemory() {
bool OaMetricQueryPoolImp::allocateGpuMemory() {
if (description.type == ZET_METRIC_QUERY_POOL_TYPE_PERFORMANCE) {
// Get allocation size.
@@ -579,7 +579,7 @@ bool MetricQueryPoolImp::allocateGpuMemory() {
return true;
}
bool MetricQueryPoolImp::createMetricQueryPool() {
bool OaMetricQueryPoolImp::createMetricQueryPool() {
// Validate metric group query - only event based is supported.
auto metricGroupProperites = MetricGroup::getProperties(hMetricGroup);
const bool validMetricGroup = metricGroupProperites.samplingType == ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
@@ -598,7 +598,7 @@ bool MetricQueryPoolImp::createMetricQueryPool() {
return metricsLibrary.createMetricQuery(description.count, query, pAllocation);
}
bool MetricQueryPoolImp::createSkipExecutionQueryPool() {
bool OaMetricQueryPoolImp::createSkipExecutionQueryPool() {
pool.reserve(description.count);
for (uint32_t i = 0; i < description.count; ++i) {
@@ -614,8 +614,8 @@ MetricQueryPool *MetricQueryPool::fromHandle(zet_metric_query_pool_handle_t hand
zet_metric_query_pool_handle_t MetricQueryPool::toHandle() { return this; }
ze_result_t MetricQueryPoolImp::createMetricQuery(uint32_t index,
zet_metric_query_handle_t *phMetricQuery) {
ze_result_t OaMetricQueryPoolImp::createMetricQuery(uint32_t index,
zet_metric_query_handle_t *phMetricQuery) {
if (index >= description.count) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
@@ -623,11 +623,11 @@ ze_result_t MetricQueryPoolImp::createMetricQuery(uint32_t index,
if (metricQueryPools.size() > 0) {
auto pMetricQueryImp = new MetricQueryImp(metricContext, *this, index);
auto pMetricQueryImp = new OaMetricQueryImp(metricContext, *this, index);
for (auto metricQueryPoolHandle : metricQueryPools) {
auto &metricQueries = pMetricQueryImp->getMetricQueries();
auto metricQueryPoolImp = static_cast<MetricQueryPoolImp *>(MetricQueryPool::fromHandle(metricQueryPoolHandle));
auto metricQueryPoolImp = static_cast<OaMetricQueryPoolImp *>(MetricQueryPool::fromHandle(metricQueryPoolHandle));
metricQueries.push_back(&metricQueryPoolImp->pool[index]);
}
@@ -643,16 +643,16 @@ ze_result_t MetricQueryPoolImp::createMetricQuery(uint32_t index,
}
}
std::vector<zet_metric_query_pool_handle_t> &MetricQueryPoolImp::getMetricQueryPools() {
std::vector<zet_metric_query_pool_handle_t> &OaMetricQueryPoolImp::getMetricQueryPools() {
return metricQueryPools;
}
MetricQueryImp::MetricQueryImp(MetricContext &metricContextInput, MetricQueryPoolImp &poolInput,
const uint32_t slotInput)
OaMetricQueryImp::OaMetricQueryImp(MetricContext &metricContextInput, OaMetricQueryPoolImp &poolInput,
const uint32_t slotInput)
: metricContext(metricContextInput), metricsLibrary(metricContext.getMetricsLibrary()),
pool(poolInput), slot(slotInput) {}
ze_result_t MetricQueryImp::appendBegin(CommandList &commandList) {
ze_result_t OaMetricQueryImp::appendBegin(CommandList &commandList) {
switch (pool.description.type) {
case ZET_METRIC_QUERY_POOL_TYPE_PERFORMANCE:
return writeMetricQuery(commandList, nullptr, 0, nullptr, true);
@@ -664,8 +664,8 @@ ze_result_t MetricQueryImp::appendBegin(CommandList &commandList) {
}
}
ze_result_t MetricQueryImp::appendEnd(CommandList &commandList, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) {
ze_result_t OaMetricQueryImp::appendEnd(CommandList &commandList, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) {
switch (pool.description.type) {
case ZET_METRIC_QUERY_POOL_TYPE_PERFORMANCE:
return writeMetricQuery(commandList, hSignalEvent, numWaitEvents, phWaitEvents, false);
@@ -677,7 +677,7 @@ ze_result_t MetricQueryImp::appendEnd(CommandList &commandList, ze_event_handle_
}
}
ze_result_t MetricQueryImp::getData(size_t *pRawDataSize, uint8_t *pRawData) {
ze_result_t OaMetricQueryImp::getData(size_t *pRawDataSize, uint8_t *pRawData) {
const bool calculateSizeOnly = *pRawDataSize == 0;
const size_t metricQueriesSize = metricQueries.size();
@@ -691,7 +691,7 @@ ze_result_t MetricQueryImp::getData(size_t *pRawDataSize, uint8_t *pRawData) {
const size_t rawDataOffsetsRequiredSize = sizeof(uint32_t) * metricQueriesSize;
const size_t rawDataSizesRequiredSize = sizeof(uint32_t) * metricQueriesSize;
auto pMetricQueryImp = static_cast<MetricQueryImp *>(MetricQuery::fromHandle(metricQueries[0]));
auto pMetricQueryImp = static_cast<OaMetricQueryImp *>(MetricQuery::fromHandle(metricQueries[0]));
result = pMetricQueryImp->metricsLibrary.getMetricQueryReportSize(*pRawDataSize);
const size_t rawDataRequiredSize = *pRawDataSize * metricQueriesSize;
@@ -744,11 +744,11 @@ ze_result_t MetricQueryImp::getData(size_t *pRawDataSize, uint8_t *pRawData) {
: ZE_RESULT_ERROR_UNKNOWN;
}
ze_result_t MetricQueryImp::reset() {
ze_result_t OaMetricQueryImp::reset() {
return ZE_RESULT_SUCCESS;
}
ze_result_t MetricQueryImp::destroy() {
ze_result_t OaMetricQueryImp::destroy() {
if (metricQueries.size() > 0) {
delete this;
@@ -757,13 +757,13 @@ ze_result_t MetricQueryImp::destroy() {
return ZE_RESULT_SUCCESS;
}
std::vector<zet_metric_query_handle_t> &MetricQueryImp::getMetricQueries() {
std::vector<zet_metric_query_handle_t> &OaMetricQueryImp::getMetricQueries() {
return metricQueries;
}
ze_result_t MetricQueryImp::writeMetricQuery(CommandList &commandList, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents,
const bool begin) {
ze_result_t OaMetricQueryImp::writeMetricQuery(CommandList &commandList, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents,
const bool begin) {
bool result = true;
const bool writeCompletionEvent = hSignalEvent && !begin;
@@ -790,7 +790,7 @@ ze_result_t MetricQueryImp::writeMetricQuery(CommandList &commandList, ze_event_
uint64_t gpuAddress = pool.pAllocation->getGpuAddress() + (i * allocationSizeForSubDevice);
uint8_t *cpuAddress = static_cast<uint8_t *>(pool.pAllocation->getUnderlyingBuffer()) + (i * allocationSizeForSubDevice);
auto &metricQueryImp = *static_cast<MetricQueryImp *>(MetricQuery::fromHandle(metricQueries[i]));
auto &metricQueryImp = *static_cast<OaMetricQueryImp *>(MetricQuery::fromHandle(metricQueries[i]));
auto &metricLibrarySubDevice = metricQueryImp.metricsLibrary;
auto &metricContextSubDevice = metricQueryImp.metricContext;
@@ -861,9 +861,9 @@ ze_result_t MetricQueryImp::writeMetricQuery(CommandList &commandList, ze_event_
return result ? ZE_RESULT_SUCCESS : ZE_RESULT_ERROR_UNKNOWN;
}
ze_result_t MetricQueryImp::writeSkipExecutionQuery(CommandList &commandList, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents,
const bool begin) {
ze_result_t OaMetricQueryImp::writeSkipExecutionQuery(CommandList &commandList, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents,
const bool begin) {
bool writeCompletionEvent = hSignalEvent && !begin;
bool result = false;

16
level_zero/tools/source/metrics/metric_query_imp.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -105,10 +105,10 @@ struct MetricsLibrary {
std::vector<QueryHandle_1_0> queries;
};
struct MetricQueryImp : MetricQuery {
struct OaMetricQueryImp : MetricQuery {
public:
MetricQueryImp(MetricContext &metricContext, struct MetricQueryPoolImp &pool,
const uint32_t slot);
OaMetricQueryImp(MetricContext &metricContext, struct OaMetricQueryPoolImp &pool,
const uint32_t slot);
ze_result_t appendBegin(CommandList &commandList) override;
ze_result_t appendEnd(CommandList &commandList, ze_event_handle_t hSignalEvent,
@@ -132,14 +132,14 @@ struct MetricQueryImp : MetricQuery {
protected:
MetricContext &metricContext;
MetricsLibrary &metricsLibrary;
MetricQueryPoolImp &pool;
OaMetricQueryPoolImp &pool;
uint32_t slot;
std::vector<zet_metric_query_handle_t> metricQueries;
};
struct MetricQueryPoolImp : MetricQueryPool {
struct OaMetricQueryPoolImp : MetricQueryPool {
public:
MetricQueryPoolImp(MetricContext &metricContext, zet_metric_group_handle_t hEventMetricGroup, const zet_metric_query_pool_desc_t &poolDescription);
OaMetricQueryPoolImp(MetricContext &metricContext, zet_metric_group_handle_t hEventMetricGroup, const zet_metric_query_pool_desc_t &poolDescription);
bool create();
ze_result_t destroy() override;
@@ -157,7 +157,7 @@ struct MetricQueryPoolImp : MetricQueryPool {
public:
MetricContext &metricContext;
MetricsLibrary &metricsLibrary;
std::vector<MetricQueryImp> pool;
std::vector<OaMetricQueryImp> pool;
NEO::GraphicsAllocation *pAllocation = nullptr;
uint32_t allocationSize = 0;
zet_metric_query_pool_desc_t description = {};

40
level_zero/tools/source/metrics/metric_streamer_imp.cpp
View File

@@ -15,8 +15,8 @@
namespace L0 {
ze_result_t MetricStreamerImp::readData(uint32_t maxReportCount, size_t *pRawDataSize,
uint8_t *pRawData) {
ze_result_t OaMetricStreamerImp::readData(uint32_t maxReportCount, size_t *pRawDataSize,
uint8_t *pRawData) {
ze_result_t result = ZE_RESULT_SUCCESS;
const size_t metricStreamerSize = metricStreamers.size();
@@ -27,7 +27,7 @@ ze_result_t MetricStreamerImp::readData(uint32_t maxReportCount, size_t *pRawDat
const size_t headerSize = sizeof(MetricGroupCalculateHeader);
const size_t rawDataOffsetsRequiredSize = sizeof(uint32_t) * metricStreamerSize;
const size_t rawDataSizesRequiredSize = sizeof(uint32_t) * metricStreamerSize;
const size_t rawDataRequiredSize = static_cast<MetricStreamerImp *>(pMetricStreamer)->getRequiredBufferSize(maxReportCount) * metricStreamerSize;
const size_t rawDataRequiredSize = static_cast<OaMetricStreamerImp *>(pMetricStreamer)->getRequiredBufferSize(maxReportCount) * metricStreamerSize;
*pRawDataSize = headerSize + rawDataOffsetsRequiredSize + rawDataSizesRequiredSize + rawDataRequiredSize;
return ZE_RESULT_SUCCESS;
}
@@ -90,7 +90,7 @@ ze_result_t MetricStreamerImp::readData(uint32_t maxReportCount, size_t *pRawDat
return result;
}
ze_result_t MetricStreamerImp::close() {
ze_result_t OaMetricStreamerImp::close() {
ze_result_t result = ZE_RESULT_SUCCESS;
if (metricStreamers.size() > 0) {
@@ -135,8 +135,8 @@ ze_result_t MetricStreamerImp::close() {
return result;
}
ze_result_t MetricStreamerImp::initialize(ze_device_handle_t hDevice,
zet_metric_group_handle_t hMetricGroup) {
ze_result_t OaMetricStreamerImp::initialize(ze_device_handle_t hDevice,
zet_metric_group_handle_t hMetricGroup) {
this->hDevice = hDevice;
this->hMetricGroup = hMetricGroup;
@@ -146,8 +146,8 @@ ze_result_t MetricStreamerImp::initialize(ze_device_handle_t hDevice,
return ZE_RESULT_SUCCESS;
}
ze_result_t MetricStreamerImp::startMeasurements(uint32_t &notifyEveryNReports,
uint32_t &samplingPeriodNs) {
ze_result_t OaMetricStreamerImp::startMeasurements(uint32_t &notifyEveryNReports,
uint32_t &samplingPeriodNs) {
auto metricGroup = MetricGroup::fromHandle(hMetricGroup);
uint32_t requestedOaBufferSize = getOaBufferSize(notifyEveryNReports);
@@ -162,7 +162,7 @@ ze_result_t MetricStreamerImp::startMeasurements(uint32_t &notifyEveryNReports,
return result;
}
void MetricStreamerImp::attachEvent(ze_event_handle_t hNotificationEvent) {
void OaMetricStreamerImp::attachEvent(ze_event_handle_t hNotificationEvent) {
// Associate notification event with metric streamer.
pNotificationEvent = Event::fromHandle(hNotificationEvent);
if (pNotificationEvent != nullptr) {
@@ -170,14 +170,14 @@ void MetricStreamerImp::attachEvent(ze_event_handle_t hNotificationEvent) {
}
}
void MetricStreamerImp::detachEvent() {
void OaMetricStreamerImp::detachEvent() {
// Release notification event.
if (pNotificationEvent != nullptr) {
pNotificationEvent->metricStreamer = nullptr;
}
}
ze_result_t MetricStreamerImp::stopMeasurements() {
ze_result_t OaMetricStreamerImp::stopMeasurements() {
auto metricGroup = MetricGroup::fromHandle(hMetricGroup);
const ze_result_t result = metricGroup->closeIoStream();
@@ -188,19 +188,19 @@ ze_result_t MetricStreamerImp::stopMeasurements() {
return result;
}
uint32_t MetricStreamerImp::getOaBufferSize(const uint32_t notifyEveryNReports) const {
uint32_t OaMetricStreamerImp::getOaBufferSize(const uint32_t notifyEveryNReports) const {
// Notification is on half full buffer, hence multiplication by 2.
return notifyEveryNReports * rawReportSize * 2;
}
uint32_t MetricStreamerImp::getNotifyEveryNReports(const uint32_t oaBufferSize) const {
uint32_t OaMetricStreamerImp::getNotifyEveryNReports(const uint32_t oaBufferSize) const {
// Notification is on half full buffer, hence division by 2.
return rawReportSize
? oaBufferSize / (rawReportSize * 2)
: 0;
}
Event::State MetricStreamerImp::getNotificationState() {
Event::State OaMetricStreamerImp::getNotificationState() {
if (metricStreamers.size() > 0) {
for (auto metricStreamer : metricStreamers) {
@@ -220,11 +220,11 @@ Event::State MetricStreamerImp::getNotificationState() {
: Event::State::STATE_INITIAL;
}
std::vector<zet_metric_streamer_handle_t> &MetricStreamerImp::getMetricStreamers() {
std::vector<zet_metric_streamer_handle_t> &OaMetricStreamerImp::getMetricStreamers() {
return metricStreamers;
}
uint32_t MetricStreamerImp::getRequiredBufferSize(const uint32_t maxReportCount) const {
uint32_t OaMetricStreamerImp::getRequiredBufferSize(const uint32_t maxReportCount) const {
DEBUG_BREAK_IF(rawReportSize == 0);
uint32_t maxOaBufferReportCount = oaBufferSize / rawReportSize;
@@ -268,7 +268,7 @@ ze_result_t MetricStreamer::openForDevice(Device *pDevice, zet_metric_group_hand
return ZE_RESULT_NOT_READY;
}
auto pMetricStreamer = new MetricStreamerImp();
auto pMetricStreamer = new OaMetricStreamerImp();
UNRECOVERABLE_IF(pMetricStreamer == nullptr);
pMetricStreamer->initialize(pDevice->toHandle(), hMetricGroup);
@@ -296,12 +296,12 @@ ze_result_t MetricStreamer::open(zet_context_handle_t hContext, zet_device_handl
if (pDeviceImp->metricContext->isImplicitScalingCapable()) {
const uint32_t subDeviceCount = pDeviceImp->numSubDevices;
auto pMetricStreamer = new MetricStreamerImp();
auto pMetricStreamer = new OaMetricStreamerImp();
UNRECOVERABLE_IF(pMetricStreamer == nullptr);
auto &metricStreamers = pMetricStreamer->getMetricStreamers();
metricStreamers.resize(subDeviceCount);
auto metricGroupRootDevice = static_cast<MetricGroupImp *>(MetricGroup::fromHandle(hMetricGroup));
auto metricGroupRootDevice = static_cast<OaMetricGroupImp *>(MetricGroup::fromHandle(hMetricGroup));
for (uint32_t i = 0; i < subDeviceCount; i++) {
@@ -324,7 +324,7 @@ ze_result_t MetricStreamer::open(zet_context_handle_t hContext, zet_device_handl
}
if (result == ZE_RESULT_SUCCESS) {
MetricStreamerImp *metImp = static_cast<MetricStreamerImp *>(MetricStreamer::fromHandle(*phMetricStreamer));
OaMetricStreamerImp *metImp = static_cast<OaMetricStreamerImp *>(MetricStreamer::fromHandle(*phMetricStreamer));
metImp->attachEvent(hNotificationEvent);
}

6
level_zero/tools/source/metrics/metric_streamer_imp.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -13,8 +13,8 @@ struct Event;
namespace L0 {
struct MetricStreamerImp : MetricStreamer {
~MetricStreamerImp() override{};
struct OaMetricStreamerImp : MetricStreamer {
~OaMetricStreamerImp() override{};
ze_result_t readData(uint32_t maxReportCount, size_t *pRawDataSize, uint8_t *pRawData) override;
ze_result_t close() override;

4
level_zero/tools/test/unit_tests/sources/metrics/mock_metric.cpp
View File

@@ -266,12 +266,12 @@ void MetricMultiDeviceFixture::openMetricsAdapterGroup() {
void MetricStreamerMultiDeviceFixture::cleanup(zet_device_handle_t &hDevice, zet_metric_streamer_handle_t &hStreamer) {
MetricStreamerImp *pStreamerImp = static_cast<MetricStreamerImp *>(MetricStreamer::fromHandle(hStreamer));
OaMetricStreamerImp *pStreamerImp = static_cast<OaMetricStreamerImp *>(MetricStreamer::fromHandle(hStreamer));
auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
for (size_t index = 0; index < deviceImp.subDevices.size(); index++) {
zet_metric_streamer_handle_t metricStreamerSubDeviceHandle = pStreamerImp->getMetricStreamers()[index];
MetricStreamerImp *pStreamerSubDevImp = static_cast<MetricStreamerImp *>(MetricStreamer::fromHandle(metricStreamerSubDeviceHandle));
OaMetricStreamerImp *pStreamerSubDevImp = static_cast<OaMetricStreamerImp *>(MetricStreamer::fromHandle(metricStreamerSubDeviceHandle));
auto device = deviceImp.subDevices[index];
auto &metricContext = device->getMetricContext();
auto &metricsLibrary = metricContext.getMetricsLibrary();

10
level_zero/tools/test/unit_tests/sources/metrics/mock_metric_enumeration.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -212,10 +212,10 @@ struct Mock<MetricGroup> : public MetricGroup {
MOCK_METHOD(ze_result_t, closeIoStream, (), (override));
};
struct MetricGroupImpTest : public MetricGroupImp {
using MetricGroupImp::copyValue;
using MetricGroupImp::pReferenceConcurrentGroup;
using MetricGroupImp::pReferenceMetricSet;
struct MetricGroupImpTest : public OaMetricGroupImp {
using OaMetricGroupImp::copyValue;
using OaMetricGroupImp::pReferenceConcurrentGroup;
using OaMetricGroupImp::pReferenceMetricSet;
};
} // namespace ult