diff --git a/level_zero/tools/source/metrics/metric.cpp b/level_zero/tools/source/metrics/metric.cpp index 289c4628c9..818062d4b2 100644 --- a/level_zero/tools/source/metrics/metric.cpp +++ b/level_zero/tools/source/metrics/metric.cpp @@ -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> 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(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::create(Device &device) { auto metricContextImp = new (std::nothrow) MetricContextImp(device); std::unique_ptr metricContext{metricContextImp}; return metricContext; } -/////////////////////////////////////////////////////////////////////////////// -/// @brief Creates metric context object. bool MetricContext::isMetricApiAvailable() { std::unique_ptr 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) { diff --git a/level_zero/tools/source/metrics/metric.h b/level_zero/tools/source/metrics/metric.h index 26c60fe51d..a20755514d 100644 --- a/level_zero/tools/source/metrics/metric.h +++ b/level_zero/tools/source/metrics/metric.h @@ -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 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(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(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(); }; diff --git a/level_zero/tools/source/metrics/metric_enumeration_imp.cpp b/level_zero/tools/source/metrics/metric_enumeration_imp.cpp index e55e935494..c64db9d0b6 100644 --- a/level_zero/tools/source/metrics/metric_enumeration_imp.cpp +++ b/level_zero/tools/source/metrics/metric_enumeration_imp.cpp @@ -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 &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(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(&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(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); diff --git a/level_zero/tools/source/metrics/metric_enumeration_imp.h b/level_zero/tools/source/metrics/metric_enumeration_imp.h index 7294293543..0564610f17 100644 --- a/level_zero/tools/source/metrics/metric_enumeration_imp.h +++ b/level_zero/tools/source/metrics/metric_enumeration_imp.h @@ -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: diff --git a/level_zero/tools/source/metrics/metric_query_imp.cpp b/level_zero/tools/source/metrics/metric_query_imp.cpp index 181d9d85c2..dde79e88b1 100644 --- a/level_zero/tools/source/metrics/metric_query_imp.cpp +++ b/level_zero/tools/source/metrics/metric_query_imp.cpp @@ -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(gen)); return static_cast(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(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(handle); } -/////////////////////////////////////////////////////////////////////////////// -/// @brief Returns metric query handle. zet_metric_query_handle_t MetricQuery::toHandle() { return this; } + } // namespace L0 diff --git a/level_zero/tools/source/metrics/metric_query_imp.h b/level_zero/tools/source/metrics/metric_query_imp.h index 14e7f769ee..5198ab5eef 100644 --- a/level_zero/tools/source/metrics/metric_query_imp.h +++ b/level_zero/tools/source/metrics/metric_query_imp.h @@ -13,8 +13,6 @@ #include #include -/////////////////////////////////////////////////////////////////////////////// -/// @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 configurations; // MetricGroup configurations + // MetricGroup configurations + std::map 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); diff --git a/level_zero/tools/source/metrics/metric_stubs.cpp b/level_zero/tools/source/metrics/metric_stubs.cpp index 109e1a117c..a3ab29cd78 100644 --- a/level_zero/tools/source/metrics/metric_stubs.cpp +++ b/level_zero/tools/source/metrics/metric_stubs.cpp @@ -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::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) { diff --git a/level_zero/tools/source/metrics/metric_tracer_imp.cpp b/level_zero/tools/source/metrics/metric_tracer_imp.cpp index b572b13249..f760a5be7f 100644 --- a/level_zero/tools/source/metrics/metric_tracer_imp.cpp +++ b/level_zero/tools/source/metrics/metric_tracer_imp.cpp @@ -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 ¬ifyEveryNReports, uint32_t &samplingPeriodNs, ze_event_handle_t hNotificationEvent) { @@ -103,8 +95,6 @@ ze_result_t MetricTracerImp::startMeasurements(uint32_t ¬ifyEveryNReports, 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; } diff --git a/level_zero/tools/source/metrics/metric_tracer_imp.h b/level_zero/tools/source/metrics/metric_tracer_imp.h index 9cac4af5c7..d09ffd88e3 100644 --- a/level_zero/tools/source/metrics/metric_tracer_imp.h +++ b/level_zero/tools/source/metrics/metric_tracer_imp.h @@ -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 ¬ifyEveryNReports, uint32_t &samplingPeriodNs, ze_event_handle_t hNotificationEvent); Event::State getNotificationState() override;