intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-03 14:55:24 +08:00
Code Issues Packages Projects Releases Wiki Activity

Cleanup comments in Metrics

Browse Source 
Change-Id: Id7eae81cf3d1da2c263ded3dbe57fd85e04c5e04
Signed-off: Jaime Arteaga <jaime.a.arteaga.molina@intel.com>
This commit is contained in:
Jaime Arteaga
2020-03-03 22:58:02 -08:00
parent 77749889cd
commit a685834b25
9 changed files with 14 additions and 350 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -23,8 +23,6 @@
namespace L0 {
///////////////////////////////////////////////////////////////////////////////
/// @brief Metric groups associated with device domains (for example oa unit).
struct MetricGroupDomains {
public:
@@ -46,8 +44,6 @@ struct MetricGroupDomains {
std::map<uint32_t, std::pair<zet_metric_group_handle_t, bool>> domains;
};
///////////////////////////////////////////////////////////////////////////////
/// @brief Metric context object that implements MetricContext interface.
struct MetricContextImp : public MetricContext {
public:
MetricContextImp(Device &device);
@@ -82,8 +78,6 @@ struct MetricContextImp : public MetricContext {
bool useCcs = false;
};
///////////////////////////////////////////////////////////////////////////////
/// @brief Metric context constructor.
MetricContextImp::MetricContextImp(Device &deviceInput)
: device(deviceInput),
metricEnumeration(std::unique_ptr<MetricEnumeration>(new (std::nothrow) MetricEnumeration(*this))),
@@ -91,15 +85,11 @@ MetricContextImp::MetricContextImp(Device &deviceInput)
metricGroupDomains(*this) {
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Metric context destructor.
MetricContextImp::~MetricContextImp() {
metricsLibrary.reset();
metricEnumeration.reset();
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Loads all metric context dependencies.
bool MetricContextImp::loadDependencies() {
bool result = true;
if (metricEnumeration->loadMetricsDiscovery() != ZE_RESULT_SUCCESS) {
@@ -116,68 +106,44 @@ bool MetricContextImp::loadDependencies() {
return result;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns metric context object initialization state.
bool MetricContextImp::isInitialized() {
return initializationState == ZE_RESULT_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Sets metric context object initialization state.
void MetricContextImp::setInitializationState(const ze_result_t state) {
initializationState = state;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns device associated with metric context.
Device &MetricContextImp::getDevice() { return device; }
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns metrics library associated with metric context.
MetricsLibrary &MetricContextImp::getMetricsLibrary() { return *metricsLibrary; }
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns metric enumeration object associated with metric context.
MetricEnumeration &MetricContextImp::getMetricEnumeration() { return *metricEnumeration; }
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns metric tracer object associated with metric context.
MetricTracer *MetricContextImp::getMetricTracer() { return pMetricTracer; }
///////////////////////////////////////////////////////////////////////////////
/// @brief Associates metric tracer object with metric context.
void MetricContextImp::setMetricTracer(MetricTracer *pMetricTracer) {
this->pMetricTracer = pMetricTracer;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Associates metrics library implementation with metric context.
void MetricContextImp::setMetricsLibrary(MetricsLibrary &metricsLibrary) {
this->metricsLibrary.release();
this->metricsLibrary.reset(&metricsLibrary);
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Associates metric enumeration implementation with metric context.
void MetricContextImp::setMetricEnumeration(MetricEnumeration &metricEnumeration) {
this->metricEnumeration.release();
this->metricEnumeration.reset(&metricEnumeration);
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Associates using compute command streamer with metric context.
void MetricContextImp::setUseCcs(const bool useCcs) {
this->useCcs = useCcs;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns if compute command streamer is used with metric context.
bool MetricContextImp::isCcsUsed() {
return useCcs;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Associates metrics groups with device.
ze_result_t
MetricContextImp::activateMetricGroupsDeferred(const uint32_t count,
zet_metric_group_handle_t *phMetricGroups) {
@@ -188,18 +154,12 @@ MetricContextImp::activateMetricGroupsDeferred(const uint32_t count,
: metricGroupDomains.deactivate();
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns true if the given metric group was previously activated, false otherwise.
bool MetricContextImp::isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) {
return metricGroupDomains.isActivated(hMetricGroup);
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Activates metrics groups by writing them to gpu.
ze_result_t MetricContextImp::activateMetricGroups() { return metricGroupDomains.activate(); }
///////////////////////////////////////////////////////////////////////////////
/// @brief Creates metric context objects for each core device.
void MetricContext::enableMetricApi(ze_result_t &result) {
if (!getenv_tobool("ZE_ENABLE_METRICS")) {
result = ZE_RESULT_SUCCESS;
@@ -236,16 +196,12 @@ void MetricContext::enableMetricApi(ze_result_t &result) {
}
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Creates metric context object.
std::unique_ptr<MetricContext> MetricContext::create(Device &device) {
auto metricContextImp = new (std::nothrow) MetricContextImp(device);
std::unique_ptr<MetricContext> metricContext{metricContextImp};
return metricContext;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Creates metric context object.
bool MetricContext::isMetricApiAvailable() {
std::unique_ptr<NEO::OsLibrary> library = nullptr;
@@ -265,13 +221,9 @@ bool MetricContext::isMetricApiAvailable() {
return true;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Metric group domains constructor.
MetricGroupDomains::MetricGroupDomains(MetricContext &metricContext)
: metricsLibrary(metricContext.getMetricsLibrary()) {}
///////////////////////////////////////////////////////////////////////////////
/// @brief Associates metric groups with the device domain (for example oa).
ze_result_t MetricGroupDomains::activateDeferred(const uint32_t count,
zet_metric_group_handle_t *phMetricGroups) {
// For each metric group:
@@ -287,8 +239,6 @@ ze_result_t MetricGroupDomains::activateDeferred(const uint32_t count,
return ZE_RESULT_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Associates a single metric group with the domain.
bool MetricGroupDomains::activateMetricGroupDeffered(const zet_metric_group_handle_t hMetricGroup) {
const auto properites = MetricGroup::getProperties(hMetricGroup);
@@ -316,8 +266,6 @@ bool MetricGroupDomains::activateMetricGroupDeffered(const zet_metric_group_hand
return true;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Activates metric groups by writing to gpu.
ze_result_t MetricGroupDomains::activate() {
// For each domain.
@@ -345,10 +293,7 @@ ze_result_t MetricGroupDomains::activate() {
return ZE_RESULT_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Activates event based metric group by writing to gpu.
bool MetricGroupDomains::activateEventMetricGroup(const zet_metric_group_handle_t hMetricGroup) {
// Obtain metric group configuration handle from metrics library.
auto hConfiguration = metricsLibrary.getConfiguration(hMetricGroup);
@@ -361,15 +306,11 @@ bool MetricGroupDomains::activateEventMetricGroup(const zet_metric_group_handle_
// Write metric group configuration to gpu.
const bool result = metricsLibrary.activateConfiguration(hConfiguration);
// Validate result.
UNRECOVERABLE_IF(!result);
return result;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Deactivates metric groups associated with domains.
ze_result_t MetricGroupDomains::deactivate() {
// Deactivate metric group for each domain.
for (auto &domain : domains) {
@@ -395,8 +336,6 @@ ze_result_t MetricGroupDomains::deactivate() {
return ZE_RESULT_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns true if the given metric group was previously activated, false otherwise.
bool MetricGroupDomains::isActivated(const zet_metric_group_handle_t hMetricGroup) {
auto metricGroupProperties = MetricGroup::getProperties(hMetricGroup);
@@ -410,23 +349,17 @@ bool MetricGroupDomains::isActivated(const zet_metric_group_handle_t hMetricGrou
return domain->second.first == hMetricGroup;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns metric group handles and their count.
ze_result_t metricGroupGet(zet_device_handle_t hDevice, uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups) {
auto device = Device::fromHandle(hDevice);
return device->getMetricContext().getMetricEnumeration().metricGroupGet(*pCount,
phMetricGroups);
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns metric handles and their count.
ze_result_t metricGet(zet_metric_group_handle_t hMetricGroup, uint32_t *pCount, zet_metric_handle_t *phMetrics) {
auto metricGroup = MetricGroup::fromHandle(hMetricGroup);
return metricGroup->getMetric(pCount, phMetrics);
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Starts tracer measurements.
ze_result_t metricTracerOpen(zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup,
zet_metric_tracer_desc_t *pDesc, ze_event_handle_t hNotificationEvent,
zet_metric_tracer_handle_t *phMetricTracer) {

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

@@ -17,23 +17,17 @@ struct _zet_metric_tracer_handle_t {};
struct _zet_metric_query_pool_handle_t {};
struct _zet_metric_query_handle_t {};
///////////////////////////////////////////////////////////////////////////////
/// @brief Metrics Discovery forward declarations.
namespace MetricsDiscovery {
class IMetricSet_1_5;
class IConcurrentGroup_1_5;
} // namespace MetricsDiscovery
namespace L0 {
///////////////////////////////////////////////////////////////////////////////
/// @brief Level zero forward declarations.
struct MetricsLibrary;
struct CommandList;
struct MetricEnumeration;
struct MetricTracer;
///////////////////////////////////////////////////////////////////////////////
/// @brief Metric context base object.
struct MetricContext {
virtual ~MetricContext() = default;
static std::unique_ptr<MetricContext> create(struct Device &device);
@@ -62,33 +56,25 @@ struct MetricContext {
virtual bool isCcsUsed() = 0;
};
///////////////////////////////////////////////////////////////////////////////
/// @brief Metric base object.
struct Metric : _zet_metric_handle_t {
virtual ~Metric() = default;
// API.
virtual ze_result_t getProperties(zet_metric_properties_t *pProperties) = 0;
// Non-API.
static Metric *create(zet_metric_properties_t &properties);
static Metric *fromHandle(zet_metric_handle_t handle) { return static_cast<Metric *>(handle); }
inline zet_metric_handle_t toHandle() { return this; }
};
///////////////////////////////////////////////////////////////////////////////
/// @brief Metric group base object.
struct MetricGroup : _zet_metric_group_handle_t {
virtual ~MetricGroup() = default;
// API.
virtual ze_result_t getProperties(zet_metric_group_properties_t *pProperties) = 0;
virtual ze_result_t getMetric(uint32_t *pCount, zet_metric_handle_t *phMetrics) = 0;
virtual ze_result_t calculateMetricValues(size_t rawDataSize,
const uint8_t *pRawData, uint32_t *pMetricValueCount,
zet_typed_value_t *pMetricValues) = 0;
// Non-API static.
static MetricGroup *create(zet_metric_group_properties_t &properties,
MetricsDiscovery::IMetricSet_1_5 &metricSet,
MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup,
@@ -98,7 +84,6 @@ struct MetricGroup : _zet_metric_group_handle_t {
}
static zet_metric_group_properties_t getProperties(const zet_metric_group_handle_t handle);
// Non-API.
zet_metric_group_handle_t toHandle() { return this; }
virtual uint32_t getRawReportSize() = 0;
@@ -112,52 +97,39 @@ struct MetricGroup : _zet_metric_group_handle_t {
virtual ze_result_t closeIoStream() = 0;
};
///////////////////////////////////////////////////////////////////////////////
/// @brief Metric tracer base object.
struct MetricTracer : _zet_metric_tracer_handle_t {
virtual ~MetricTracer() = default;
// API.
virtual ze_result_t readData(uint32_t maxReportCount, size_t *pRawDataSize,
uint8_t *pRawData) = 0;
virtual ze_result_t close() = 0;
// Non-API static.
static MetricTracer *open(zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup,
zet_metric_tracer_desc_t &desc, ze_event_handle_t hNotificationEvent);
static MetricTracer *fromHandle(zet_metric_tracer_handle_t handle) {
return static_cast<MetricTracer *>(handle);
}
// Non-API.
virtual Event::State getNotificationState() = 0;
inline zet_metric_tracer_handle_t toHandle() { return this; }
};
///////////////////////////////////////////////////////////////////////////////
/// @brief Metric query pool base object.
struct MetricQueryPool : _zet_metric_query_pool_handle_t {
virtual ~MetricQueryPool() = default;
// API.
virtual bool destroy() = 0;
virtual ze_result_t createMetricQuery(uint32_t index,
zet_metric_query_handle_t *phMetricQuery) = 0;
// Non-API static.
static MetricQueryPool *create(zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup, const zet_metric_query_pool_desc_t &desc);
static MetricQueryPool *fromHandle(zet_metric_query_pool_handle_t handle);
// Non-API.
zet_metric_query_pool_handle_t toHandle();
};
///////////////////////////////////////////////////////////////////////////////
/// @brief Metric query base object.
struct MetricQuery : _zet_metric_query_handle_t {
virtual ~MetricQuery() = default;
// API.
virtual ze_result_t appendBegin(CommandList &commandList) = 0;
virtual ze_result_t appendEnd(CommandList &commandList, ze_event_handle_t hCompletionEvent) = 0;
@@ -170,10 +142,8 @@ struct MetricQuery : _zet_metric_query_handle_t {
virtual ze_result_t reset() = 0;
virtual ze_result_t destroy() = 0;
// Non-API static.
static MetricQuery *fromHandle(zet_metric_query_handle_t handle);
// Non-API.
zet_metric_query_handle_t toHandle();
};

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

@@ -15,24 +15,16 @@
namespace L0 {
///////////////////////////////////////////////////////////////////////////////
/// @brief Static const field initialization.
const char *MetricEnumeration::oaConcurrentGroupName = "OA";
///////////////////////////////////////////////////////////////////////////////
/// @brief Metric enumeration constructor.
MetricEnumeration::MetricEnumeration(MetricContext &metricContextInput)
: metricContext(metricContextInput) {}
///////////////////////////////////////////////////////////////////////////////
/// @brief Metric enumeration destructor.
MetricEnumeration::~MetricEnumeration() {
cleanupMetricsDiscovery();
initializationState = ZE_RESULT_ERROR_UNINITIALIZED;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Return metric group handles and their count.
ze_result_t MetricEnumeration::metricGroupGet(uint32_t &count,
zet_metric_group_handle_t *phMetricGroups) {
if (initialize() != ZE_RESULT_SUCCESS) {
@@ -58,12 +50,8 @@ ze_result_t MetricEnumeration::metricGroupGet(uint32_t &count,
return ZE_RESULT_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns enumeration object initialization state.
bool MetricEnumeration::isInitialized() { return initializationState == ZE_RESULT_SUCCESS; }
///////////////////////////////////////////////////////////////////////////////
/// @brief Initializes metric enumeration object.
ze_result_t MetricEnumeration::initialize() {
if (initializationState == ZE_RESULT_ERROR_UNINITIALIZED) {
if (metricContext.isInitialized() &&
@@ -79,8 +67,6 @@ ze_result_t MetricEnumeration::initialize() {
return initializationState;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Loads Metrics Discovery API library and its functions.
ze_result_t MetricEnumeration::loadMetricsDiscovery() {
// Load library.
hMetricsDiscovery.reset(NEO::OsLibrary::load(getMetricsDiscoveryFilename()));
@@ -106,10 +92,7 @@ ze_result_t MetricEnumeration::loadMetricsDiscovery() {
return ZE_RESULT_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Opens Metrics Discovery APIs MetricDevice.
ze_result_t MetricEnumeration::openMetricsDiscovery() {
// #TODO_P1 reset MDAPI/instrumentation state - call close multiple times?
UNRECOVERABLE_IF(openMetricsDevice == nullptr);
UNRECOVERABLE_IF(closeMetricsDevice == nullptr);
@@ -121,10 +104,7 @@ ze_result_t MetricEnumeration::openMetricsDiscovery() {
return ZE_RESULT_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Closes Metrics Discovery APIs MetricDevice and unloads its library.
ze_result_t MetricEnumeration::cleanupMetricsDiscovery() {
for (uint32_t i = 0; i < metricGroups.size(); ++i) {
delete metricGroups[i];
}
@@ -147,10 +127,7 @@ ze_result_t MetricEnumeration::cleanupMetricsDiscovery() {
return ZE_RESULT_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Caches metric group / metric information for later use.
ze_result_t MetricEnumeration::cacheMetricInformation() {
// #TODO_val keep checks, e.g. metricsDevice, deviceParams?
UNRECOVERABLE_IF(pMetricsDevice == nullptr);
MetricsDiscovery::TMetricsDeviceParams_1_2 *pMetricsDeviceParams = pMetricsDevice->GetParams();
@@ -178,7 +155,7 @@ ze_result_t MetricEnumeration::cacheMetricInformation() {
pConcurrentGroup->GetParams();
UNRECOVERABLE_IF(pConcurrentGroupParams == nullptr);
// 2. Find "OA" concurrent group. // #TODO_P2 other groups than OA?
// 2. Find "OA" concurrent group.
if (strcmp(pConcurrentGroupParams->SymbolName, oaConcurrentGroupName) == 0) {
// Reserve memory for metric groups
metricGroups.reserve(pConcurrentGroupParams->MetricSetsCount);
@@ -199,8 +176,6 @@ ze_result_t MetricEnumeration::cacheMetricInformation() {
return ZE_RESULT_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Creates and caches metric groups, mapping metric sets from Metrics Discovery.
ze_result_t
MetricEnumeration::cacheMetricGroup(MetricsDiscovery::IMetricSet_1_5 &metricSet,
MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup,
@@ -244,8 +219,6 @@ MetricEnumeration::cacheMetricGroup(MetricsDiscovery::IMetricSet_1_5 &metricSet,
return ZE_RESULT_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Creates metrics, mapping metrics from Metrics Discovery.
ze_result_t MetricEnumeration::createMetrics(MetricsDiscovery::IMetricSet_1_5 &metricSet,
std::vector<Metric *> &metrics) {
MetricsDiscovery::TMetricSetParams_1_4 *pMetricSetParams = metricSet.GetParams();
@@ -283,8 +256,6 @@ ze_result_t MetricEnumeration::createMetrics(MetricsDiscovery::IMetricSet_1_5 &m
// Map information to level zero format and add them to 'metrics' vector (as metrics).
for (uint32_t i = 0; i < pMetricSetParams->InformationCount; ++i) {
// #TODO_P1 not every information is needed? e.g. PTBR, reportCount, etc. shouldn't be
// available #TODO_P2 split e.g. report_reason to separate flags?
MetricsDiscovery::IInformation_1_0 *pSourceInformation = metricSet.GetInformation(i);
UNRECOVERABLE_IF(pSourceInformation == nullptr);
@@ -302,10 +273,10 @@ ze_result_t MetricEnumeration::createMetrics(MetricsDiscovery::IMetricSet_1_5 &m
pSourceInformationParams->GroupName);
snprintf(properties.resultUnits, sizeof(properties.resultUnits), "%s",
pSourceInformationParams->InfoUnits);
properties.tierNumber = 1; // #TODO_P2 default tier for information?
properties.tierNumber = 1;
properties.metricType = getMetricType(pSourceInformationParams->InfoType);
properties.resultType =
ZET_VALUE_TYPE_UINT64; // MetricsDiscovery information are always UINT64
// MetricsDiscovery information are always UINT64
properties.resultType = ZET_VALUE_TYPE_UINT64;
auto pMetric = Metric::create(properties);
UNRECOVERABLE_IF(pMetric == nullptr);
@@ -315,8 +286,6 @@ ze_result_t MetricEnumeration::createMetrics(MetricsDiscovery::IMetricSet_1_5 &m
return ZE_RESULT_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Maps Metrics Discovery metric usage flags to level zero format (tier numbers).
uint32_t MetricEnumeration::getMetricTierNumber(const uint32_t sourceUsageFlagsMask) const {
uint32_t tierNumber = 0;
if (sourceUsageFlagsMask & MetricsDiscovery::USAGE_FLAG_TIER_1) {
@@ -334,8 +303,6 @@ uint32_t MetricEnumeration::getMetricTierNumber(const uint32_t sourceUsageFlagsM
return tierNumber;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Maps Metrics Discovery metric types to level zero format.
zet_metric_type_t
MetricEnumeration::getMetricType(const MetricsDiscovery::TMetricType sourceMetricType) const {
switch (sourceMetricType) {
@@ -361,8 +328,6 @@ MetricEnumeration::getMetricType(const MetricsDiscovery::TMetricType sourceMetri
}
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Maps Metrics Discovery information types to level zero format.
zet_metric_type_t MetricEnumeration::getMetricType(
const MetricsDiscovery::TInformationType sourceInformationType) const {
@@ -384,8 +349,6 @@ zet_metric_type_t MetricEnumeration::getMetricType(
}
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Maps Metrics Discovery metric result types to level zero format.
zet_value_type_t MetricEnumeration::getMetricResultType(
const MetricsDiscovery::TMetricResultType sourceMetricResultType) const {
@@ -404,8 +367,6 @@ zet_value_type_t MetricEnumeration::getMetricResultType(
}
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Metric group destructor.
MetricGroupImp ::~MetricGroupImp() {
for (uint32_t i = 0; i < metrics.size(); ++i) {
@@ -415,16 +376,12 @@ MetricGroupImp ::~MetricGroupImp() {
metrics.clear();
};
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns metric group properties (copies data to user).
ze_result_t MetricGroupImp::getProperties(zet_metric_group_properties_t *pProperties) {
UNRECOVERABLE_IF(pProperties->version > ZET_METRIC_GROUP_PROPERTIES_VERSION_CURRENT);
copyProperties(properties, *pProperties);
return ZE_RESULT_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns metric group properties.
zet_metric_group_properties_t MetricGroup::getProperties(const zet_metric_group_handle_t handle) {
auto metricGroup = MetricGroup::fromHandle(handle);
UNRECOVERABLE_IF(!metricGroup);
@@ -435,8 +392,6 @@ zet_metric_group_properties_t MetricGroup::getProperties(const zet_metric_group_
return properties;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns metric handles and their count.
ze_result_t MetricGroupImp::getMetric(uint32_t *pCount, zet_metric_handle_t *phMetrics) {
if (*pCount == 0) {
*pCount = static_cast<uint32_t>(metrics.size());
@@ -457,8 +412,6 @@ ze_result_t MetricGroupImp::getMetric(uint32_t *pCount, zet_metric_handle_t *phM
return ZE_RESULT_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Activates metric group in the kernel.
bool MetricGroupImp::activate() {
UNRECOVERABLE_IF(pReferenceMetricSet == nullptr);
const bool result = pReferenceMetricSet->Activate() == MetricsDiscovery::CC_OK;
@@ -466,24 +419,18 @@ bool MetricGroupImp::activate() {
return result;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Deactivates metric group in the kernel.
bool MetricGroupImp::deactivate() {
UNRECOVERABLE_IF(pReferenceMetricSet == nullptr);
const bool result = pReferenceMetricSet->Deactivate() == MetricsDiscovery::CC_OK;
return result;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns metrics discovery api filtering type
/// for a given metric group sampling type.
uint32_t MetricGroupImp::getApiMask(const zet_metric_group_sampling_type_t samplingType) {
switch (samplingType) {
case ZET_METRIC_GROUP_SAMPLING_TYPE_TIME_BASED:
return MetricsDiscovery::API_TYPE_IOSTREAM;
case ZET_METRIC_GROUP_SAMPLING_TYPE_EVENT_BASED:
// #TODO Expose ocl metric sets from open source metrics discovery.
return MetricsDiscovery::API_TYPE_OCL | MetricsDiscovery::API_TYPE_OGL4_X;
default:
UNRECOVERABLE_IF(true);
@@ -491,34 +438,27 @@ uint32_t MetricGroupImp::getApiMask(const zet_metric_group_sampling_type_t sampl
}
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Opens metrics discovery io stream.
ze_result_t MetricGroupImp::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;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Checks if metric tracer reports are available.
ze_result_t MetricGroupImp::waitForReports(const uint32_t timeoutMs) {
return (pReferenceConcurrentGroup->WaitForReports(timeoutMs) == MetricsDiscovery::TCompletionCode::CC_OK)
? ZE_RESULT_SUCCESS
: ZE_RESULT_NOT_READY;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Reads raw data from metrics discovery io stream.
ze_result_t MetricGroupImp::readIoStream(uint32_t &reportCount, uint8_t &reportData) {
char *castedReportData = reinterpret_cast<char *>(&reportData);
// #TODO_tracer_P2 use IO_READ_FLAG_DROP_OLD_REPORTS flag?
const auto readResult =
pReferenceConcurrentGroup->ReadIoStream(&reportCount, castedReportData, 0);
switch (readResult) {
case MetricsDiscovery::CC_OK:
case MetricsDiscovery::CC_READ_PENDING: // #TODO_tracer_P1 what about pending?
case MetricsDiscovery::CC_READ_PENDING:
return ZE_RESULT_SUCCESS;
default:
@@ -526,15 +466,11 @@ ze_result_t MetricGroupImp::readIoStream(uint32_t &reportCount, uint8_t &reportD
}
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Closes metrics discovery io stream.
ze_result_t MetricGroupImp::closeIoStream() {
const auto closeResult = pReferenceConcurrentGroup->CloseIoStream();
return (closeResult == MetricsDiscovery::CC_OK) ? ZE_RESULT_SUCCESS : ZE_RESULT_ERROR_UNKNOWN;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Calculates raw data, returns metric values.
ze_result_t MetricGroupImp::calculateMetricValues(size_t rawDataSize,
const uint8_t *pRawData, uint32_t *pMetricValueCount,
zet_typed_value_t *pMetricValues) {
@@ -546,8 +482,6 @@ ze_result_t MetricGroupImp::calculateMetricValues(size_t rawDataSize,
return result ? ZE_RESULT_SUCCESS : ZE_RESULT_ERROR_UNKNOWN;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns calculated metric value count for a given raw data.
bool MetricGroupImp::getCalculatedMetricCount(const size_t rawDataSize,
uint32_t &metricValueCount) {
uint32_t rawReportSize = getRawReportSize();
@@ -565,8 +499,6 @@ bool MetricGroupImp::getCalculatedMetricCount(const size_t rawDataSize,
return true;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns calculated metric values for a given raw data.
bool MetricGroupImp::getCalculatedMetricValues(const size_t rawDataSize, const uint8_t *pRawData,
uint32_t &metricValueCount,
zet_typed_value_t *pCalculatedData) {
@@ -600,7 +532,7 @@ bool MetricGroupImp::getCalculatedMetricValues(const size_t rawDataSize, const u
// Adjust copied reports to buffer provided by the user.
metricValueCount = std::min<uint32_t>(metricValueCount, calculatedReportCount * properties.metricCount);
// Translate metrics from metrics discovery to one api format.
// Translate metrics from metrics discovery to oneAPI format.
for (size_t i = 0; i < metricValueCount; ++i) {
copyValue(calculatedMetrics[i], pCalculatedData[i]);
}
@@ -609,8 +541,6 @@ bool MetricGroupImp::getCalculatedMetricValues(const size_t rawDataSize, const u
return result;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Initializes metric group object.
ze_result_t MetricGroupImp::initialize(const zet_metric_group_properties_t &sourceProperties,
MetricsDiscovery::IMetricSet_1_5 &metricSet,
MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup,
@@ -622,8 +552,6 @@ ze_result_t MetricGroupImp::initialize(const zet_metric_group_properties_t &sour
return ZE_RESULT_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns size of raw reports produced by this metric group.
uint32_t MetricGroupImp::getRawReportSize() {
auto pMetricSetParams = pReferenceMetricSet->GetParams();
@@ -632,8 +560,6 @@ uint32_t MetricGroupImp::getRawReportSize() {
: pMetricSetParams->QueryReportSize;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Copies metric group properties from 'source' to 'destination'.
void MetricGroupImp::copyProperties(const zet_metric_group_properties_t &source,
zet_metric_group_properties_t &destination) {
UNRECOVERABLE_IF(source.version < destination.version);
@@ -644,8 +570,6 @@ void MetricGroupImp::copyProperties(const zet_metric_group_properties_t &source,
source.description, sizeof(destination.description));
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Translates metrics discovery typed value into one api format.
void MetricGroupImp::copyValue(const MetricsDiscovery::TTypedValue_1_0 &source,
zet_typed_value_t &destination) const {
@@ -680,23 +604,17 @@ void MetricGroupImp::copyValue(const MetricsDiscovery::TTypedValue_1_0 &source,
}
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns metric properties (copies data to user).
ze_result_t MetricImp::getProperties(zet_metric_properties_t *pProperties) {
UNRECOVERABLE_IF(pProperties->version > ZET_METRIC_PROPERTIES_VERSION_CURRENT);
copyProperties(properties, *pProperties);
return ZE_RESULT_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Initializes metric object.
ze_result_t MetricImp::initialize(const zet_metric_properties_t &sourceProperties) {
copyProperties(sourceProperties, properties);
return ZE_RESULT_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Copies metric properties from 'source' to 'destination'.
void MetricImp::copyProperties(const zet_metric_properties_t &source,
zet_metric_properties_t &destination) {
UNRECOVERABLE_IF(source.version < destination.version);
@@ -711,8 +629,6 @@ void MetricImp::copyProperties(const zet_metric_properties_t &source,
source.resultUnits, sizeof(destination.resultUnits));
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Creates metric group object.
MetricGroup *MetricGroup::create(zet_metric_group_properties_t &properties,
MetricsDiscovery::IMetricSet_1_5 &metricSet,
MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup,
@@ -723,8 +639,6 @@ MetricGroup *MetricGroup::create(zet_metric_group_properties_t &properties,
return pMetricGroup;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Creates metric object.
Metric *Metric::create(zet_metric_properties_t &properties) {
auto pMetric = new MetricImp();
UNRECOVERABLE_IF(pMetric == nullptr);

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

@@ -29,31 +29,23 @@
namespace L0 {
///////////////////////////////////////////////////////////////////////////////
/// @brief Metric enumeration object implementation.
struct MetricEnumeration {
MetricEnumeration(MetricContext &metricContext);
virtual ~MetricEnumeration();
// API (called from static API functions).
ze_result_t metricGroupGet(uint32_t &count, zet_metric_group_handle_t *phMetricGroups);
// Non-API.
virtual bool isInitialized();
// Initialization.
virtual ze_result_t loadMetricsDiscovery();
static const char *getMetricsDiscoveryFilename();
protected:
// Initialization.
ze_result_t initialize();
// Metrics Discovery.
virtual ze_result_t openMetricsDiscovery();
virtual ze_result_t cleanupMetricsDiscovery();
// Metric caching.
ze_result_t cacheMetricInformation();
ze_result_t cacheMetricGroup(MetricsDiscovery::IMetricSet_1_5 &metricSet,
MetricsDiscovery::IConcurrentGroup_1_5 &pConcurrentGroup,
@@ -82,7 +74,6 @@ struct MetricEnumeration {
MetricsDiscovery::OpenMetricsDeviceFromFile_fn openMetricsDeviceFromFile = nullptr;
MetricsDiscovery::IMetricsDevice_1_5 *pMetricsDevice = nullptr;
// Public due to unit tests.
public:
// Metrics Discovery version should be at least 1.5.
static const uint32_t requiredMetricsDiscoveryMajorVersion = 1;
@@ -90,19 +81,15 @@ struct MetricEnumeration {
static const char *oaConcurrentGroupName;
};
///////////////////////////////////////////////////////////////////////////////
/// @brief Metric group object implementation.
struct MetricGroupImp : MetricGroup {
~MetricGroupImp() override;
// API.
ze_result_t getProperties(zet_metric_group_properties_t *pProperties) override;
ze_result_t getMetric(uint32_t *pCount, zet_metric_handle_t *phMetrics) override;
ze_result_t calculateMetricValues(size_t rawDataSize, const uint8_t *pRawData,
uint32_t *pMetricValueCount,
zet_typed_value_t *pCalculatedData) override;
// Non-API.
ze_result_t initialize(const zet_metric_group_properties_t &sourceProperties,
MetricsDiscovery::IMetricSet_1_5 &metricSet,
MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup,
@@ -110,7 +97,6 @@ struct MetricGroupImp : MetricGroup {
uint32_t getRawReportSize() override;
// Activation.
bool activate() override;
bool deactivate() override;
@@ -145,15 +131,11 @@ struct MetricGroupImp : MetricGroup {
MetricsDiscovery::IConcurrentGroup_1_5 *pReferenceConcurrentGroup = nullptr;
};
///////////////////////////////////////////////////////////////////////////////
/// @brief Metric object implementation.
struct MetricImp : Metric {
~MetricImp() override{};
// API.
ze_result_t getProperties(zet_metric_properties_t *pProperties) override;
// Non-API.
ze_result_t initialize(const zet_metric_properties_t &sourceProperties);
protected:

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

@@ -23,15 +23,10 @@ using namespace MetricsLibraryApi;
namespace L0 {
///////////////////////////////////////////////////////////////////////////////
/// @brief Metric library constructor.
MetricsLibrary::MetricsLibrary(MetricContext &metricContextInput)
: metricContext(metricContextInput) {}
///////////////////////////////////////////////////////////////////////////////
/// @brief Metric library destructor.
MetricsLibrary::~MetricsLibrary() {
// Deactivate all metric group configurations.
for (auto &configuration : configurations) {
deactivateConfiguration(configuration.second);
@@ -46,10 +41,7 @@ MetricsLibrary::~MetricsLibrary() {
}
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns metrics library initialization state.
bool MetricsLibrary::isInitialized() {
// Try to initialize metrics library only once.
if (initializationState == ZE_RESULT_ERROR_UNINITIALIZED) {
initialize();
@@ -58,8 +50,6 @@ bool MetricsLibrary::isInitialized() {
return initializationState == ZE_RESULT_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Creates metrics library metric query object.
bool MetricsLibrary::createMetricQuery(const uint32_t slotsCount, QueryHandle_1_0 &query,
NEO::GraphicsAllocation *&pAllocation) {
// Validate metrics library state.
@@ -109,8 +99,6 @@ bool MetricsLibrary::createMetricQuery(const uint32_t slotsCount, QueryHandle_1_
return true;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Destroys metrics library metric query object.
bool MetricsLibrary::destroyMetricQuery(QueryHandle_1_0 &query) {
UNRECOVERABLE_IF(!query.IsValid());
@@ -119,10 +107,7 @@ bool MetricsLibrary::destroyMetricQuery(QueryHandle_1_0 &query) {
return result;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns metric query report size.
bool MetricsLibrary::getMetricQueryReportSize(size_t &rawDataSize) {
ValueType valueType = ValueType::Last;
TypedValue_1_0 value = {};
@@ -132,8 +117,6 @@ bool MetricsLibrary::getMetricQueryReportSize(size_t &rawDataSize) {
return result;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns metric query report.
bool MetricsLibrary::getMetricQueryReport(QueryHandle_1_0 &query, const size_t rawDataSize,
uint8_t *pData) {
@@ -150,10 +133,7 @@ bool MetricsLibrary::getMetricQueryReport(QueryHandle_1_0 &query, const size_t r
return result;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Initializes metric library.
void MetricsLibrary::initialize() {
auto &metricsEnumeration = metricContext.getMetricEnumeration();
// Function should be called only once.
@@ -168,10 +148,7 @@ void MetricsLibrary::initialize() {
UNRECOVERABLE_IF(initializationState != ZE_RESULT_SUCCESS);
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Loads metric library.
bool MetricsLibrary::load() {
// Load library.
handle = NEO::OsLibrary::load(getFilename());
@@ -189,10 +166,7 @@ bool MetricsLibrary::load() {
return result;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Creates metrics library context associated with xe device.
bool MetricsLibrary::createContext() {
auto &device = metricContext.getDevice();
const auto &hwHelper = device.getHwHelper();
const auto &asyncComputeEngines = hwHelper.getGpgpuEngineInstances(device.getHwInfo());
@@ -236,15 +210,11 @@ bool MetricsLibrary::createContext() {
return result;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns metrics library gen type.
ClientGen MetricsLibrary::getGenType(const uint32_t gen) const {
auto &hwHelper = NEO::HwHelper::get(static_cast<GFXCORE_FAMILY>(gen));
return static_cast<MetricsLibraryApi::ClientGen>(hwHelper.getMetricsLibraryGenId());
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns gpu commands size for a given object.
uint32_t MetricsLibrary::getGpuCommandsSize(CommandBufferData_1_0 &commandBuffer) {
CommandBufferSize_1_0 commandBufferSize = {};
@@ -260,8 +230,6 @@ uint32_t MetricsLibrary::getGpuCommandsSize(CommandBufferData_1_0 &commandBuffer
return result ? commandBufferSize.GpuMemorySize : 0;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Writes gpu commands into command buffer.
bool MetricsLibrary::getGpuCommands(CommandList &commandList,
CommandBufferData_1_0 &commandBuffer) {
@@ -294,12 +262,9 @@ bool MetricsLibrary::getGpuCommands(CommandList &commandList,
return result;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Creates metrics library configuration for a given metric group.
ConfigurationHandle_1_0
MetricsLibrary::createConfiguration(const zet_metric_group_handle_t metricGroupHandle,
const zet_metric_group_properties_t properties) {
// Metric group internal data.
auto metricGroup = MetricGroup::fromHandle(metricGroupHandle);
UNRECOVERABLE_IF(!metricGroup);
@@ -330,8 +295,6 @@ MetricsLibrary::createConfiguration(const zet_metric_group_handle_t metricGroupH
return validActivate ? handle : nullptr;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns metric library configuration handle for a given metric group.
ConfigurationHandle_1_0 MetricsLibrary::getConfiguration(zet_metric_group_handle_t handle) {
auto iter = configurations.find(handle);
@@ -341,10 +304,7 @@ ConfigurationHandle_1_0 MetricsLibrary::getConfiguration(zet_metric_group_handle
return configuration;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Adds metric library configuration handle for a given metric group.
ConfigurationHandle_1_0 MetricsLibrary::addConfiguration(zet_metric_group_handle_t handle) {
ConfigurationHandle_1_0 libraryHandle = {};
UNRECOVERABLE_IF(!handle);
@@ -363,8 +323,6 @@ ConfigurationHandle_1_0 MetricsLibrary::addConfiguration(zet_metric_group_handle
return libraryHandle;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Creates metric query pool object.
ze_result_t metricQueryPoolCreate(zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup, const zet_metric_query_pool_desc_t *pDesc,
zet_metric_query_pool_handle_t *phMetricQueryPool) {
// Create metric query pool
@@ -374,8 +332,6 @@ ze_result_t metricQueryPoolCreate(zet_device_handle_t hDevice, zet_metric_group_
return (*phMetricQueryPool != nullptr) ? ZE_RESULT_SUCCESS : ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Creates metric query pool object.
MetricQueryPool *MetricQueryPool::create(zet_device_handle_t hDevice,
zet_metric_group_handle_t hMetricGroup,
const zet_metric_query_pool_desc_t &desc) {
@@ -390,8 +346,6 @@ MetricQueryPool *MetricQueryPool::create(zet_device_handle_t hDevice,
return metricPoolImp;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Metric query pool constructor.
MetricQueryPoolImp::MetricQueryPoolImp(MetricContext &metricContextInput,
zet_metric_group_handle_t hEventMetricGroupInput,
const zet_metric_query_pool_desc_t &poolDescription)
@@ -399,10 +353,7 @@ MetricQueryPoolImp::MetricQueryPoolImp(MetricContext &metricContextInput,
description(poolDescription),
hMetricGroup(hEventMetricGroupInput) {}
///////////////////////////////////////////////////////////////////////////////
/// @brief Creates metric query pool.
bool MetricQueryPoolImp::create() {
switch (description.flags) {
case ZET_METRIC_QUERY_POOL_FLAG_PERFORMANCE:
return createMetricQueryPool();
@@ -413,10 +364,7 @@ bool MetricQueryPoolImp::create() {
}
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Destroys metric query pool.
bool MetricQueryPoolImp::destroy() {
bool result = false;
switch (description.flags) {
@@ -435,10 +383,7 @@ bool MetricQueryPoolImp::destroy() {
return result;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Creates performance metric query pool.
bool MetricQueryPoolImp::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_EVENT_BASED;
@@ -457,47 +402,33 @@ bool MetricQueryPoolImp::createMetricQueryPool() {
return metricsLibrary.createMetricQuery(description.count, query, pAllocation);
}
//////////////////////////////////////////////////////////////////////////////
/// @brief Destroys metric query pool object.
ze_result_t metricQueryPoolDestroy(zet_metric_query_pool_handle_t hMetricQueryPool) {
MetricQueryPool::fromHandle(hMetricQueryPool)->destroy();
return ZE_RESULT_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns metric query pool from handle.
MetricQueryPool *MetricQueryPool::fromHandle(zet_metric_query_pool_handle_t handle) {
return static_cast<MetricQueryPool *>(handle);
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns metric query pool handle.
zet_metric_query_pool_handle_t MetricQueryPool::toHandle() { return this; }
///////////////////////////////////////////////////////////////////////////////
/// @brief Creates metric query from the pool.
// clang-format off
ze_result_t MetricQueryPoolImp::createMetricQuery(uint32_t index,
zet_metric_query_handle_t *phMetricQuery) {
zet_metric_query_handle_t *phMetricQuery) {
*phMetricQuery = (index < description.count)
? &(pool[index])
: nullptr;
? &(pool[index])
: nullptr;
return (*phMetricQuery != nullptr)
? ZE_RESULT_SUCCESS
: ZE_RESULT_ERROR_INVALID_ARGUMENT;
? ZE_RESULT_SUCCESS
: ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
// clang-format on
///////////////////////////////////////////////////////////////////////////////
/// @brief Metric query constructor.
MetricQueryImp::MetricQueryImp(MetricContext &metricContextInput, MetricQueryPoolImp &poolInput,
const uint32_t slotInput)
: metricContext(metricContextInput), metricsLibrary(metricContext.getMetricsLibrary()),
pool(poolInput), slot(slotInput) {}
///////////////////////////////////////////////////////////////////////////////
/// @brief Writes metric query gpu commands to command list.
ze_result_t MetricQueryImp::appendBegin(CommandList &commandList) {
switch (pool.description.flags) {
@@ -510,8 +441,6 @@ ze_result_t MetricQueryImp::appendBegin(CommandList &commandList) {
}
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Writes metric query gpu commands to command list.
ze_result_t MetricQueryImp::appendEnd(CommandList &commandList,
ze_event_handle_t hCompletionEvent) {
switch (pool.description.flags) {
@@ -524,8 +453,6 @@ ze_result_t MetricQueryImp::appendEnd(CommandList &commandList,
}
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns metric query raw report.
ze_result_t MetricQueryImp::getData(size_t *pRawDataSize, uint8_t *pRawData) {
const bool calculateSizeOnly = *pRawDataSize == 0;
@@ -538,23 +465,16 @@ ze_result_t MetricQueryImp::getData(size_t *pRawDataSize, uint8_t *pRawData) {
: ZE_RESULT_ERROR_UNKNOWN;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Resets metric query.
ze_result_t MetricQueryImp::reset() {
return ZE_RESULT_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Destroys metric query.
ze_result_t MetricQueryImp::destroy() {
return ZE_RESULT_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Writes performance metrics into a command buffer.
ze_result_t MetricQueryImp::writeMetricQuery(CommandList &commandList,
ze_event_handle_t hCompletionEvent, const bool begin) {
// Make gpu allocation visible.
commandList.commandContainer.addToResidencyContainer(pool.pAllocation);
@@ -582,10 +502,7 @@ ze_result_t MetricQueryImp::writeMetricQuery(CommandList &commandList,
return result ? ZE_RESULT_SUCCESS : ZE_RESULT_ERROR_UNKNOWN;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Writes gpu commands to flush all read/write caches.
ze_result_t MetricQuery::appendMemoryBarrier(CommandList &commandList) {
auto &metricContext = commandList.device->getMetricContext();
auto &metricsLibrary = metricContext.getMetricsLibrary();
@@ -601,8 +518,6 @@ ze_result_t MetricQuery::appendMemoryBarrier(CommandList &commandList) {
: ZE_RESULT_ERROR_UNKNOWN;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Writes gpu commands to trigger oa report in oa buffer with user's marker.
ze_result_t MetricQuery::appendTracerMarker(CommandList &commandList,
zet_metric_tracer_handle_t hMetricTracer,
uint32_t value) {
@@ -622,13 +537,10 @@ ze_result_t MetricQuery::appendTracerMarker(CommandList &commandList,
: ZE_RESULT_ERROR_UNKNOWN;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns metric query object for a given handle.
MetricQuery *MetricQuery::fromHandle(zet_metric_query_handle_t handle) {
return static_cast<MetricQuery *>(handle);
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns metric query handle.
zet_metric_query_handle_t MetricQuery::toHandle() { return this; }
} // namespace L0

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

@@ -13,8 +13,6 @@
#include <map>
#include <vector>
///////////////////////////////////////////////////////////////////////////////
/// @brief Forward declaration.
using MetricsLibraryApi::ClientCallbacks_1_0;
using MetricsLibraryApi::ClientGen;
using MetricsLibraryApi::CommandBufferData_1_0;
@@ -39,8 +37,6 @@ class GraphicsAllocation;
namespace L0 {
///////////////////////////////////////////////////////////////////////////////
/// @brief Metric library implementation.
struct MetricsLibrary {
public:
MetricsLibrary(MetricContext &metricContext);
@@ -90,24 +86,20 @@ struct MetricsLibrary {
ContextHandle_1_0 context = {};
ContextCreateFunction_1_0 contextCreateFunction = nullptr;
ContextDeleteFunction_1_0 contextDeleteFunction = nullptr;
std::map<zet_metric_group_handle_t, ConfigurationHandle_1_0> configurations; // MetricGroup configurations
// MetricGroup configurations
std::map<zet_metric_group_handle_t, ConfigurationHandle_1_0> configurations;
};
///////////////////////////////////////////////////////////////////////////////
/// @brief Metric query object implementation.
struct MetricQueryImp : MetricQuery {
public:
MetricQueryImp(MetricContext &metricContext, struct MetricQueryPoolImp &pool,
const uint32_t slot);
// Begin/end gpu commands.
ze_result_t appendBegin(CommandList &commandList) override;
ze_result_t appendEnd(CommandList &commandList, ze_event_handle_t hCompletionEvent) override;
// Query results.
ze_result_t getData(size_t *pRawDataSize, uint8_t *pRawData) override;
// Query reset/destroy.
ze_result_t reset() override;
ze_result_t destroy() override;
@@ -122,8 +114,6 @@ struct MetricQueryImp : MetricQuery {
uint32_t slot;
};
///////////////////////////////////////////////////////////////////////////////
/// @brief Metric query pool implementation.
struct MetricQueryPoolImp : MetricQueryPool {
public:
MetricQueryPoolImp(MetricContext &metricContext, zet_metric_group_handle_t hEventMetricGroup, const zet_metric_query_pool_desc_t &poolDescription);

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

@@ -43,39 +43,27 @@ ze_result_t MetricQuery::appendTracerMarker(CommandList &commandList,
MetricQuery *MetricQuery::fromHandle(zet_metric_query_handle_t handle) { return nullptr; }
///////////////////////////////////////////////////////////////////////////////
/// @brief Creates metric context objects for each core device.
void MetricContext::enableMetricApi(ze_result_t &result) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
return;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Creates metric context object.
std::unique_ptr<MetricContext> MetricContext::create(Device &device) {
return nullptr;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Creates metric context object.
bool MetricContext::isMetricApiAvailable() {
return false;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns metric group handles and their count.
ze_result_t metricGroupGet(zet_device_handle_t hDevice, uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns metric handles and their count.
ze_result_t metricGet(zet_metric_group_handle_t hMetricGroup, uint32_t *pCount, zet_metric_handle_t *phMetrics) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Starts tracer measurements.
ze_result_t metricTracerOpen(zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup,
zet_metric_tracer_desc_t *pDesc, ze_event_handle_t hNotificationEvent,
zet_metric_tracer_handle_t *phMetricTracer) {

21
level_zero/tools/source/metrics/metric_tracer_imp.cpp
View File

@@ -13,8 +13,6 @@
namespace L0 {
///////////////////////////////////////////////////////////////////////////////
/// @brief Reads raw data blob from metric tracer object.
ze_result_t MetricTracerImp::readData(uint32_t maxReportCount, size_t *pRawDataSize,
uint8_t *pRawData) {
UNRECOVERABLE_IF(rawReportSize == 0);
@@ -44,8 +42,6 @@ ze_result_t MetricTracerImp::readData(uint32_t maxReportCount, size_t *pRawDataS
return result;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Stops measurements and destroys metric tracer object.
ze_result_t MetricTracerImp::close() {
const auto result = stopMeasurements();
if (result == ZE_RESULT_SUCCESS) {
@@ -65,8 +61,6 @@ ze_result_t MetricTracerImp::close() {
return result;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Initializes metric tracer object.
ze_result_t MetricTracerImp::initialize(ze_device_handle_t hDevice,
zet_metric_group_handle_t hMetricGroup) {
this->hDevice = hDevice;
@@ -78,8 +72,6 @@ ze_result_t MetricTracerImp::initialize(ze_device_handle_t hDevice,
return ZE_RESULT_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Creates metric tracer object and starts measurements.
ze_result_t MetricTracerImp::startMeasurements(uint32_t &notifyEveryNReports,
uint32_t &samplingPeriodNs,
ze_event_handle_t hNotificationEvent) {
@@ -103,8 +95,6 @@ ze_result_t MetricTracerImp::startMeasurements(uint32_t &notifyEveryNReports,
return result;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Stops measurements and destroys metric tracer object.
ze_result_t MetricTracerImp::stopMeasurements() {
auto metricGroup = MetricGroup::fromHandle(hMetricGroup);
@@ -116,15 +106,11 @@ ze_result_t MetricTracerImp::stopMeasurements() {
return result;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Converts OA buffer size in 'notifyEveryNReports' format to size in bytes.
uint32_t MetricTracerImp::getOaBufferSize(const uint32_t notifyEveryNReports) const {
// Notification is on half full buffer, hence multiplication by 2.
return notifyEveryNReports * rawReportSize * 2;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Converts OA buffer size in bytes to 'notifyEveryNReports' format.
uint32_t MetricTracerImp::getNotifyEveryNReports(const uint32_t oaBufferSize) const {
// Notification is on half full buffer, hence division by 2.
return rawReportSize
@@ -132,8 +118,6 @@ uint32_t MetricTracerImp::getNotifyEveryNReports(const uint32_t oaBufferSize) co
: 0;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns a metric tracer state that can be used by associated notification event.
Event::State MetricTracerImp::getNotificationState() {
auto metricGroup = MetricGroup::fromHandle(hMetricGroup);
@@ -144,8 +128,6 @@ Event::State MetricTracerImp::getNotificationState() {
: Event::State::STATE_INITIAL;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Returns required buffer size for tracer reports during read.
uint32_t MetricTracerImp::getRequiredBufferSize(const uint32_t maxReportCount) const {
UNRECOVERABLE_IF(rawReportSize == 0);
uint32_t maxOaBufferReportCount = oaBufferSize / rawReportSize;
@@ -155,8 +137,6 @@ uint32_t MetricTracerImp::getRequiredBufferSize(const uint32_t maxReportCount) c
: maxReportCount * rawReportSize;
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Creates metric tracer object and start measurements.
MetricTracer *MetricTracer::open(zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup,
zet_metric_tracer_desc_t &desc, ze_event_handle_t hNotificationEvent) {
auto pDevice = Device::fromHandle(hDevice);
@@ -190,7 +170,6 @@ MetricTracer *MetricTracer::open(zet_device_handle_t hDevice, zet_metric_group_h
delete pMetricTracer;
pMetricTracer = nullptr;
}
// #TODO_tracer_P1 Query shouldn't be available when stream is running? Where to return error, onExecute?
return pMetricTracer;
}

4
level_zero/tools/source/metrics/metric_tracer_imp.h
View File

@@ -13,16 +13,12 @@ struct Event;
namespace L0 {
///////////////////////////////////////////////////////////////////////////////
/// @brief Metric tracer object implementation.
struct MetricTracerImp : MetricTracer {
~MetricTracerImp() override{};
// API.
ze_result_t readData(uint32_t maxReportCount, size_t *pRawDataSize, uint8_t *pRawData) override;
ze_result_t close() override;
// Non-API.
ze_result_t initialize(ze_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup);
ze_result_t startMeasurements(uint32_t &notifyEveryNReports, uint32_t &samplingPeriodNs, ze_event_handle_t hNotificationEvent);
Event::State getNotificationState() override;