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

Metrics IP Sampling Enumeration Support

Browse Source 
This patch adds enumeration of metric group for
IP sampling.

Related-To: LOCI-2754


Signed-off-by: Joshua Santosh Ranjan <joshua.santosh.ranjan@intel.com>
This commit is contained in:
Joshua Santosh Ranjan
2022-02-18 07:28:22 +00:00
committed by Compute-Runtime-Automation
parent fc2f8cadfd
commit 41988fc429
16 changed files with 895 additions and 183 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
level_zero/tools/source/metrics/CMakeLists.txt
View File

@@ -15,8 +15,11 @@ list(APPEND L0_SRCS_TOOLS_METRICS
${CMAKE_CURRENT_SOURCE_DIR}/metric_oa_streamer_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/metric_oa_query_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/metric_oa_query_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/metric_oa_source.cpp
${CMAKE_CURRENT_SOURCE_DIR}/metric_oa_source.h
${CMAKE_CURRENT_SOURCE_DIR}/os_metric_ip_sampling.h
${CMAKE_CURRENT_SOURCE_DIR}/metric_ip_sampling_source.h
${CMAKE_CURRENT_SOURCE_DIR}/metric_ip_sampling_source.cpp
)
if(UNIX)

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

@@ -7,15 +7,12 @@
#include "level_zero/tools/source/metrics/metric.h"
#include "shared/source/os_interface/os_library.h"
#include "level_zero/core/source/device/device.h"
#include "level_zero/core/source/device/device_imp.h"
#include "level_zero/core/source/driver/driver.h"
#include "level_zero/core/source/driver/driver_handle_imp.h"
#include "level_zero/source/inc/ze_intel_gpu.h"
#include "level_zero/tools/source/metrics/metric_oa_enumeration_imp.h"
#include "level_zero/tools/source/metrics/metric_oa_query_imp.h"
#include "level_zero/tools/source/metrics/metric_ip_sampling_source.h"
#include "level_zero/tools/source/metrics/metric_oa_source.h"
#include <map>
@@ -23,156 +20,6 @@
namespace L0 {
OaMetricSourceImp::OsLibraryLoadPtr OaMetricSourceImp::osLibraryLoadFunction(NEO::OsLibrary::load);
std::unique_ptr<OaMetricSourceImp> OaMetricSourceImp::create(const MetricDeviceContext &metricDeviceContext) {
return std::unique_ptr<OaMetricSourceImp>(new (std::nothrow) OaMetricSourceImp(metricDeviceContext));
}
OaMetricSourceImp::OaMetricSourceImp(const MetricDeviceContext &metricDeviceContext) : metricDeviceContext(metricDeviceContext),
metricEnumeration(std::unique_ptr<MetricEnumeration>(new (std::nothrow) MetricEnumeration(*this))),
metricsLibrary(std::unique_ptr<MetricsLibrary>(new (std::nothrow) MetricsLibrary(*this))) {
}
OaMetricSourceImp::~OaMetricSourceImp() = default;
bool OaMetricSourceImp::checkDependencies() {
std::unique_ptr<NEO::OsLibrary> library = nullptr;
// Check Metrics Discovery availability.
library.reset(osLibraryLoadFunction(MetricEnumeration::getMetricsDiscoveryFilename()));
if (library == nullptr) {
PRINT_DEBUG_STRING(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Unable to find metrics discovery %s\n", MetricEnumeration::getMetricsDiscoveryFilename());
return false;
}
// Check Metrics Library availability.
library.reset(osLibraryLoadFunction(MetricsLibrary::getFilename()));
if (library == nullptr) {
PRINT_DEBUG_STRING(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Unable to find metrics library %s\n", MetricsLibrary::getFilename());
return false;
}
return true;
}
void OaMetricSourceImp::enable() {
available = false;
if (loadDependencies()) {
available = true;
}
}
bool OaMetricSourceImp::isAvailable() {
return available;
}
ze_result_t OaMetricSourceImp::appendMetricMemoryBarrier(CommandList &commandList) {
DeviceImp *pDeviceImp = static_cast<DeviceImp *>(commandList.device);
if (pDeviceImp->metricContext->isImplicitScalingCapable()) {
// Use one of the sub-device contexts to append to command list.
pDeviceImp = static_cast<DeviceImp *>(pDeviceImp->subDevices[0]);
}
auto &metricContext = pDeviceImp->getMetricDeviceContext();
auto &metricsLibrary = metricContext.getMetricSource<OaMetricSourceImp>().getMetricsLibrary();
// Obtain gpu commands.
CommandBufferData_1_0 commandBuffer = {};
commandBuffer.CommandsType = MetricsLibraryApi::ObjectType::OverrideFlushCaches;
commandBuffer.Override.Enable = true;
commandBuffer.Type = metricContext.getMetricSource<OaMetricSourceImp>().isComputeUsed()
? MetricsLibraryApi::GpuCommandBufferType::Compute
: MetricsLibraryApi::GpuCommandBufferType::Render;
return metricsLibrary.getGpuCommands(commandList, commandBuffer) ? ZE_RESULT_SUCCESS
: ZE_RESULT_ERROR_UNKNOWN;
}
bool OaMetricSourceImp::loadDependencies() {
bool result = true;
if (metricEnumeration->loadMetricsDiscovery() != ZE_RESULT_SUCCESS) {
result = false;
DEBUG_BREAK_IF(!result);
}
if (result && !metricsLibrary->load()) {
result = false;
DEBUG_BREAK_IF(!result);
}
// Set metric context initialization state.
setInitializationState(result
? ZE_RESULT_SUCCESS
: ZE_RESULT_ERROR_UNKNOWN);
return result;
}
bool OaMetricSourceImp::isInitialized() {
return initializationState == ZE_RESULT_SUCCESS;
}
void OaMetricSourceImp::setInitializationState(const ze_result_t state) {
initializationState = state;
}
Device &OaMetricSourceImp::getDevice() {
return metricDeviceContext.getDevice();
}
MetricsLibrary &OaMetricSourceImp::getMetricsLibrary() {
return *metricsLibrary;
}
MetricEnumeration &OaMetricSourceImp::getMetricEnumeration() {
return *metricEnumeration;
}
MetricStreamer *OaMetricSourceImp::getMetricStreamer() {
return pMetricStreamer;
}
void OaMetricSourceImp::setMetricStreamer(MetricStreamer *pMetricStreamer) {
this->pMetricStreamer = pMetricStreamer;
}
void OaMetricSourceImp::setMetricsLibrary(MetricsLibrary &metricsLibrary) {
this->metricsLibrary.release();
this->metricsLibrary.reset(&metricsLibrary);
}
void OaMetricSourceImp::setMetricEnumeration(MetricEnumeration &metricEnumeration) {
this->metricEnumeration.release();
this->metricEnumeration.reset(&metricEnumeration);
}
void OaMetricSourceImp::setUseCompute(const bool useCompute) {
this->useCompute = useCompute;
}
bool OaMetricSourceImp::isComputeUsed() const {
return useCompute;
}
ze_result_t OaMetricSourceImp::metricGroupGet(uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups) {
return getMetricEnumeration().metricGroupGet(*pCount, phMetricGroups);
}
uint32_t OaMetricSourceImp::getSubDeviceIndex() {
return metricDeviceContext.getSubDeviceIndex();
}
bool OaMetricSourceImp::isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) const {
return metricDeviceContext.isMetricGroupActivated(hMetricGroup);
}
bool OaMetricSourceImp::isMetricGroupActivated() const {
return metricDeviceContext.isMetricGroupActivated();
}
bool OaMetricSourceImp::isImplicitScalingCapable() const {
return metricDeviceContext.isImplicitScalingCapable();
}
std::unique_ptr<MetricDeviceContext> MetricDeviceContext::create(Device &device) {
return std::make_unique<MetricDeviceContext>(device);
}
@@ -186,6 +33,7 @@ MetricDeviceContext::MetricDeviceContext(Device &inputDevice) : device(inputDevi
multiDeviceCapable = !isSubDevice && device.isImplicitScalingCapable();
metricSources[MetricSource::SourceType::Oa] = OaMetricSourceImp::create(*this);
metricSources[MetricSource::SourceType::IpSampling] = IpSamplingMetricSourceImp::create(*this);
}
bool MetricDeviceContext::enable() {
@@ -205,7 +53,17 @@ ze_result_t MetricDeviceContext::metricGroupGet(uint32_t *pCount, zet_metric_gro
uint32_t requestCount = *pCount;
for (auto const &entry : metricSources) {
auto const &metricSource = entry.second;
if (!metricSource->isAvailable()) {
continue;
}
result = metricSource->metricGroupGet(&requestCount, phMetricGroups);
if (result == ZE_RESULT_ERROR_UNSUPPORTED_FEATURE) {
result = ZE_RESULT_SUCCESS;
continue;
}
if (result != ZE_RESULT_SUCCESS) {
break;
}
@@ -278,16 +136,22 @@ ze_result_t MetricDeviceContext::deActivateAllDomains() {
}
ze_result_t MetricDeviceContext::appendMetricMemoryBarrier(CommandList &commandList) {
ze_result_t result = ZE_RESULT_SUCCESS;
bool isSuccess = false;
for (auto const &entry : metricSources) {
auto const &metricSource = entry.second;
if (!metricSource->isAvailable()) {
continue;
}
result = metricSource->appendMetricMemoryBarrier(commandList);
if (result != ZE_RESULT_SUCCESS) {
ze_result_t result = metricSource->appendMetricMemoryBarrier(commandList);
if (result == ZE_RESULT_SUCCESS) {
isSuccess = true;
} else if (result != ZE_RESULT_ERROR_UNSUPPORTED_FEATURE) {
return result;
}
}
return result;
return isSuccess == false ? ZE_RESULT_ERROR_UNSUPPORTED_FEATURE : ZE_RESULT_SUCCESS;
}
bool MetricDeviceContext::isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) const {
@@ -328,10 +192,6 @@ Device &MetricDeviceContext::getDevice() const {
ze_result_t MetricDeviceContext::enableMetricApi() {
if (!OaMetricSourceImp::checkDependencies()) {
return ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
}
bool failed = false;
auto driverHandle = L0::DriverHandle::fromHandle(GlobalDriverHandle);
@@ -350,7 +210,7 @@ ze_result_t MetricDeviceContext::enableMetricApi() {
failed |= !rootDevice->metricContext->enable();
if (failed) {
continue;
break;
}
// Initialize sub devices.
@@ -375,9 +235,4 @@ ze_result_t metricStreamerOpen(zet_context_handle_t hContext, zet_device_handle_
return MetricGroup::fromHandle(hMetricGroup)->streamerOpen(hContext, hDevice, pDesc, hNotificationEvent, phMetricStreamer);
}
template <>
OaMetricSourceImp &MetricDeviceContext::getMetricSource<OaMetricSourceImp>() const {
return static_cast<OaMetricSourceImp &>(*metricSources.at(MetricSource::SourceType::Oa));
}
} // namespace L0

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

@@ -27,7 +27,8 @@ class MetricSource {
public:
enum class SourceType {
Undefined,
Oa
Oa,
IpSampling
};
virtual void enable() = 0;
virtual bool isAvailable() = 0;
@@ -72,7 +73,6 @@ struct Metric : _zet_metric_handle_t {
virtual ze_result_t getProperties(zet_metric_properties_t *pProperties) = 0;
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; }
};

207
level_zero/tools/source/metrics/metric_ip_sampling_source.cpp Normal file
View File

@@ -0,0 +1,207 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/tools/source/metrics/metric_ip_sampling_source.h"
#include "level_zero/tools/source/metrics/metric.h"
#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
#include <level_zero/zet_api.h>
namespace L0 {
constexpr uint32_t ipSamplinMetricCount = 10u;
constexpr uint32_t ipSamplinDomainId = 100u;
std::unique_ptr<IpSamplingMetricSourceImp> IpSamplingMetricSourceImp::create(const MetricDeviceContext &metricDeviceContext) {
return std::unique_ptr<IpSamplingMetricSourceImp>(new (std::nothrow) IpSamplingMetricSourceImp(metricDeviceContext));
}
IpSamplingMetricSourceImp::IpSamplingMetricSourceImp(const MetricDeviceContext &metricDeviceContext) : metricDeviceContext(metricDeviceContext) {
metricOsInterface = MetricIpSamplingOsInterface::create(metricDeviceContext.getDevice());
}
void IpSamplingMetricSourceImp::enable() {
isEnabled = metricOsInterface->isDependencyAvailable();
}
bool IpSamplingMetricSourceImp::isAvailable() {
return isEnabled;
}
void IpSamplingMetricSourceImp::cacheMetricGroup() {
std::vector<IpSamplingMetricImp> metrics = {};
metrics.reserve(ipSamplinMetricCount);
zet_metric_properties_t metricProperties = {};
metricProperties.stype = ZET_STRUCTURE_TYPE_METRIC_PROPERTIES;
metricProperties.pNext = nullptr;
strcpy_s(metricProperties.component, ZET_MAX_METRIC_COMPONENT, "XVE");
metricProperties.tierNumber = 4;
metricProperties.resultType = ZET_VALUE_TYPE_UINT64;
// Preparing properties for IP seperately because of unique values
strcpy_s(metricProperties.name, ZET_MAX_METRIC_NAME, "IP");
strcpy_s(metricProperties.description, ZET_MAX_METRIC_DESCRIPTION, "IP address");
metricProperties.metricType = ZET_METRIC_TYPE_IP_EXP;
strcpy_s(metricProperties.resultUnits, ZET_MAX_METRIC_RESULT_UNITS, "Address");
metrics.push_back(IpSamplingMetricImp(metricProperties));
std::vector<std::pair<const char *, const char *>> metricPropertiesList = {
{"Active", "Active cycles"},
{"ControlStall", "Stall on control"},
{"PipeStall", "Stall on pipe"},
{"SendStall", "Stall on send"},
{"DistStall", "Stall on distance"},
{"SbidStall", "Stall on scoreboard"},
{"SyncStall", "Stall on sync"},
{"InstrFetchStall", "Stall on instruction fetch"},
{"OtherStall", "Stall on other condition"},
};
// Preparing properties for others because of common values
metricProperties.metricType = ZET_METRIC_TYPE_EVENT;
strcpy_s(metricProperties.resultUnits, ZET_MAX_METRIC_RESULT_UNITS, "Events");
for (auto &property : metricPropertiesList) {
strcpy_s(metricProperties.name, ZET_MAX_METRIC_NAME, property.first);
strcpy_s(metricProperties.description, ZET_MAX_METRIC_DESCRIPTION, property.second);
metrics.push_back(IpSamplingMetricImp(metricProperties));
}
cachedMetricGroup = IpSamplingMetricGroupImp::create(metrics);
DEBUG_BREAK_IF(cachedMetricGroup == nullptr);
}
ze_result_t IpSamplingMetricSourceImp::metricGroupGet(uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups) {
if (!isEnabled) {
*pCount = 0;
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
if (*pCount == 0) {
*pCount = 1;
return ZE_RESULT_SUCCESS;
}
if (cachedMetricGroup == nullptr) {
cacheMetricGroup();
}
DEBUG_BREAK_IF(phMetricGroups == nullptr);
phMetricGroups[0] = cachedMetricGroup->toHandle();
*pCount = 1;
return ZE_RESULT_SUCCESS;
}
ze_result_t IpSamplingMetricSourceImp::appendMetricMemoryBarrier(CommandList &commandList) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
void IpSamplingMetricSourceImp::setMetricOsInterface(std::unique_ptr<MetricIpSamplingOsInterface> &metricOsInterface) {
this->metricOsInterface = std::move(metricOsInterface);
}
IpSamplingMetricGroupImp::IpSamplingMetricGroupImp(std::vector<IpSamplingMetricImp> &metrics) {
this->metrics.reserve(metrics.size());
for (const auto &metric : metrics) {
this->metrics.push_back(std::make_unique<IpSamplingMetricImp>(metric));
}
properties.stype = ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES;
properties.pNext = nullptr;
strcpy_s(properties.name, ZET_MAX_METRIC_GROUP_NAME, "EuStallSampling");
strcpy_s(properties.description, ZET_MAX_METRIC_GROUP_DESCRIPTION, "EU stall sampling");
properties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED;
properties.domain = ipSamplinDomainId;
properties.metricCount = ipSamplinMetricCount;
}
ze_result_t IpSamplingMetricGroupImp::getProperties(zet_metric_group_properties_t *pProperties) {
*pProperties = properties;
return ZE_RESULT_SUCCESS;
}
ze_result_t IpSamplingMetricGroupImp::metricGet(uint32_t *pCount, zet_metric_handle_t *phMetrics) {
if (*pCount == 0) {
*pCount = static_cast<uint32_t>(metrics.size());
return ZE_RESULT_SUCCESS;
}
// User is expected to allocate space.
DEBUG_BREAK_IF(phMetrics == nullptr);
*pCount = std::min(*pCount, static_cast<uint32_t>(metrics.size()));
for (uint32_t i = 0; i < *pCount; i++) {
phMetrics[i] = metrics[i]->toHandle();
}
return ZE_RESULT_SUCCESS;
}
ze_result_t IpSamplingMetricGroupImp::calculateMetricValues(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
const uint8_t *pRawData, uint32_t *pMetricValueCount,
zet_typed_value_t *pMetricValues) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t IpSamplingMetricGroupImp::calculateMetricValuesExp(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
const uint8_t *pRawData, uint32_t *pSetCount,
uint32_t *pTotalMetricValueCount, uint32_t *pMetricCounts,
zet_typed_value_t *pMetricValues) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
bool IpSamplingMetricGroupImp::activate() {
return false;
}
bool IpSamplingMetricGroupImp::deactivate() {
return false;
}
zet_metric_group_handle_t IpSamplingMetricGroupImp::getMetricGroupForSubDevice(const uint32_t subDeviceIndex) {
return toHandle();
}
ze_result_t IpSamplingMetricGroupImp::streamerOpen(
zet_context_handle_t hContext,
zet_device_handle_t hDevice,
zet_metric_streamer_desc_t *desc,
ze_event_handle_t hNotificationEvent,
zet_metric_streamer_handle_t *phMetricStreamer) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t IpSamplingMetricGroupImp::metricQueryPoolCreate(
zet_context_handle_t hContext,
zet_device_handle_t hDevice,
const zet_metric_query_pool_desc_t *desc,
zet_metric_query_pool_handle_t *phMetricQueryPool) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
std::unique_ptr<IpSamplingMetricGroupImp> IpSamplingMetricGroupImp::create(std::vector<IpSamplingMetricImp> &ipSamplingMetrics) {
return std::unique_ptr<IpSamplingMetricGroupImp>(new (std::nothrow) IpSamplingMetricGroupImp(ipSamplingMetrics));
}
IpSamplingMetricImp::IpSamplingMetricImp(zet_metric_properties_t &properties) : properties(properties) {
}
ze_result_t IpSamplingMetricImp::getProperties(zet_metric_properties_t *pProperties) {
*pProperties = properties;
return ZE_RESULT_SUCCESS;
}
template <>
IpSamplingMetricSourceImp &MetricDeviceContext::getMetricSource<IpSamplingMetricSourceImp>() const {
return static_cast<IpSamplingMetricSourceImp &>(*metricSources.at(MetricSource::SourceType::IpSampling));
}
} // namespace L0

84
level_zero/tools/source/metrics/metric_ip_sampling_source.h Normal file
View File

@@ -0,0 +1,84 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "level_zero/tools/source/metrics/metric.h"
#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
namespace L0 {
struct IpSamplingMetricImp;
struct IpSamplingMetricGroupImp;
class IpSamplingMetricSourceImp : public MetricSource {
public:
IpSamplingMetricSourceImp(const MetricDeviceContext &metricDeviceContext);
virtual ~IpSamplingMetricSourceImp() = default;
void enable() override;
bool isAvailable() override;
ze_result_t metricGroupGet(uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups) override;
ze_result_t appendMetricMemoryBarrier(CommandList &commandList) override;
void setMetricOsInterface(std::unique_ptr<MetricIpSamplingOsInterface> &metricOsInterface);
static std::unique_ptr<IpSamplingMetricSourceImp> create(const MetricDeviceContext &metricDeviceContext);
protected:
void cacheMetricGroup();
bool isEnabled = false;
const MetricDeviceContext &metricDeviceContext;
std::unique_ptr<MetricIpSamplingOsInterface> metricOsInterface = nullptr;
std::unique_ptr<IpSamplingMetricGroupImp> cachedMetricGroup = nullptr;
};
struct IpSamplingMetricGroupImp : public MetricGroup {
IpSamplingMetricGroupImp(std::vector<IpSamplingMetricImp> &metrics);
virtual ~IpSamplingMetricGroupImp() = default;
ze_result_t getProperties(zet_metric_group_properties_t *pProperties) override;
ze_result_t metricGet(uint32_t *pCount, zet_metric_handle_t *phMetrics) override;
ze_result_t calculateMetricValues(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
const uint8_t *pRawData, uint32_t *pMetricValueCount,
zet_typed_value_t *pMetricValues) override;
ze_result_t calculateMetricValuesExp(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
const uint8_t *pRawData, uint32_t *pSetCount,
uint32_t *pTotalMetricValueCount, uint32_t *pMetricCounts,
zet_typed_value_t *pMetricValues) override;
bool activate() override;
bool deactivate() override;
zet_metric_group_handle_t getMetricGroupForSubDevice(const uint32_t subDeviceIndex) override;
ze_result_t streamerOpen(
zet_context_handle_t hContext,
zet_device_handle_t hDevice,
zet_metric_streamer_desc_t *desc,
ze_event_handle_t hNotificationEvent,
zet_metric_streamer_handle_t *phMetricStreamer) override;
ze_result_t metricQueryPoolCreate(
zet_context_handle_t hContext,
zet_device_handle_t hDevice,
const zet_metric_query_pool_desc_t *desc,
zet_metric_query_pool_handle_t *phMetricQueryPool) override;
static std::unique_ptr<IpSamplingMetricGroupImp> create(std::vector<IpSamplingMetricImp> &ipSamplingMetrics);
private:
std::vector<std::unique_ptr<IpSamplingMetricImp>> metrics = {};
zet_metric_group_properties_t properties = {};
};
struct IpSamplingMetricImp : public Metric {
virtual ~IpSamplingMetricImp() = default;
IpSamplingMetricImp(zet_metric_properties_t &properties);
ze_result_t getProperties(zet_metric_properties_t *pProperties) override;
private:
zet_metric_properties_t properties;
};
template <>
IpSamplingMetricSourceImp &MetricDeviceContext::getMetricSource<IpSamplingMetricSourceImp>() const;
} // namespace L0

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

@@ -33,7 +33,7 @@ ze_result_t MetricEnumeration::metricGroupGet(uint32_t &count,
zet_metric_group_handle_t *phMetricGroups) {
ze_result_t result = initialize();
if (result != ZE_RESULT_SUCCESS) {
return result;
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
if (count == 0) {
@@ -354,7 +354,7 @@ ze_result_t MetricEnumeration::createMetrics(MetricsDiscovery::IMetricSet_1_5 &m
properties.metricType = getMetricType(pSourceMetricParams->MetricType);
properties.resultType = getMetricResultType(pSourceMetricParams->ResultType);
auto pMetric = Metric::create(properties);
auto pMetric = OaMetricImp::create(properties);
UNRECOVERABLE_IF(pMetric == nullptr);
metrics.push_back(pMetric);
@@ -385,7 +385,7 @@ ze_result_t MetricEnumeration::createMetrics(MetricsDiscovery::IMetricSet_1_5 &m
? ZET_VALUE_TYPE_BOOL8
: ZET_VALUE_TYPE_UINT64;
auto pMetric = Metric::create(properties);
auto pMetric = OaMetricImp::create(properties);
UNRECOVERABLE_IF(pMetric == nullptr);
metrics.push_back(pMetric);
@@ -927,7 +927,7 @@ MetricGroup *OaMetricGroupImp::create(zet_metric_group_properties_t &properties,
return pMetricGroup;
}
Metric *Metric::create(zet_metric_properties_t &properties) {
Metric *OaMetricImp::create(zet_metric_properties_t &properties) {
auto pMetric = new OaMetricImp();
UNRECOVERABLE_IF(pMetric == nullptr);
pMetric->initialize(properties);

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

@@ -164,6 +164,8 @@ struct OaMetricImp : Metric {
ze_result_t initialize(const zet_metric_properties_t &sourceProperties);
static Metric *create(zet_metric_properties_t &properties);
protected:
void copyProperties(const zet_metric_properties_t &source,
zet_metric_properties_t &destination);

150
level_zero/tools/source/metrics/metric_oa_source.cpp Normal file
View File

@@ -0,0 +1,150 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/tools/source/metrics/metric_oa_source.h"
#include "shared/source/os_interface/os_library.h"
#include "level_zero/core/source/device/device_imp.h"
#include "level_zero/tools/source/metrics/metric.h"
#include "level_zero/tools/source/metrics/metric_oa_enumeration_imp.h"
#include "level_zero/tools/source/metrics/metric_oa_query_imp.h"
namespace L0 {
OaMetricSourceImp::OsLibraryLoadPtr OaMetricSourceImp::osLibraryLoadFunction(NEO::OsLibrary::load);
std::unique_ptr<OaMetricSourceImp> OaMetricSourceImp::create(const MetricDeviceContext &metricDeviceContext) {
return std::unique_ptr<OaMetricSourceImp>(new (std::nothrow) OaMetricSourceImp(metricDeviceContext));
}
OaMetricSourceImp::OaMetricSourceImp(const MetricDeviceContext &metricDeviceContext) : metricDeviceContext(metricDeviceContext),
metricEnumeration(std::unique_ptr<MetricEnumeration>(new (std::nothrow) MetricEnumeration(*this))),
metricsLibrary(std::unique_ptr<MetricsLibrary>(new (std::nothrow) MetricsLibrary(*this))) {
}
OaMetricSourceImp::~OaMetricSourceImp() = default;
void OaMetricSourceImp::enable() {
loadDependencies();
}
bool OaMetricSourceImp::isAvailable() {
return isInitialized();
}
ze_result_t OaMetricSourceImp::appendMetricMemoryBarrier(CommandList &commandList) {
DeviceImp *pDeviceImp = static_cast<DeviceImp *>(commandList.device);
if (pDeviceImp->metricContext->isImplicitScalingCapable()) {
// Use one of the sub-device contexts to append to command list.
pDeviceImp = static_cast<DeviceImp *>(pDeviceImp->subDevices[0]);
}
auto &metricContext = pDeviceImp->getMetricDeviceContext();
auto &metricsLibrary = metricContext.getMetricSource<OaMetricSourceImp>().getMetricsLibrary();
// Obtain gpu commands.
CommandBufferData_1_0 commandBuffer = {};
commandBuffer.CommandsType = MetricsLibraryApi::ObjectType::OverrideFlushCaches;
commandBuffer.Override.Enable = true;
commandBuffer.Type = metricContext.getMetricSource<OaMetricSourceImp>().isComputeUsed()
? MetricsLibraryApi::GpuCommandBufferType::Compute
: MetricsLibraryApi::GpuCommandBufferType::Render;
return metricsLibrary.getGpuCommands(commandList, commandBuffer) ? ZE_RESULT_SUCCESS
: ZE_RESULT_ERROR_UNKNOWN;
}
bool OaMetricSourceImp::loadDependencies() {
bool result = true;
if (metricEnumeration->loadMetricsDiscovery() != ZE_RESULT_SUCCESS) {
result = false;
DEBUG_BREAK_IF(!result);
}
if (result && !metricsLibrary->load()) {
result = false;
DEBUG_BREAK_IF(!result);
}
// Set metric context initialization state.
setInitializationState(result
? ZE_RESULT_SUCCESS
: ZE_RESULT_ERROR_UNKNOWN);
return result;
}
bool OaMetricSourceImp::isInitialized() {
return initializationState == ZE_RESULT_SUCCESS;
}
void OaMetricSourceImp::setInitializationState(const ze_result_t state) {
initializationState = state;
}
Device &OaMetricSourceImp::getDevice() {
return metricDeviceContext.getDevice();
}
MetricsLibrary &OaMetricSourceImp::getMetricsLibrary() {
return *metricsLibrary;
}
MetricEnumeration &OaMetricSourceImp::getMetricEnumeration() {
return *metricEnumeration;
}
MetricStreamer *OaMetricSourceImp::getMetricStreamer() {
return pMetricStreamer;
}
void OaMetricSourceImp::setMetricStreamer(MetricStreamer *pMetricStreamer) {
this->pMetricStreamer = pMetricStreamer;
}
void OaMetricSourceImp::setMetricsLibrary(MetricsLibrary &metricsLibrary) {
this->metricsLibrary.release();
this->metricsLibrary.reset(&metricsLibrary);
}
void OaMetricSourceImp::setMetricEnumeration(MetricEnumeration &metricEnumeration) {
this->metricEnumeration.release();
this->metricEnumeration.reset(&metricEnumeration);
}
void OaMetricSourceImp::setUseCompute(const bool useCompute) {
this->useCompute = useCompute;
}
bool OaMetricSourceImp::isComputeUsed() const {
return useCompute;
}
ze_result_t OaMetricSourceImp::metricGroupGet(uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups) {
return getMetricEnumeration().metricGroupGet(*pCount, phMetricGroups);
}
uint32_t OaMetricSourceImp::getSubDeviceIndex() {
return metricDeviceContext.getSubDeviceIndex();
}
bool OaMetricSourceImp::isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) const {
return metricDeviceContext.isMetricGroupActivated(hMetricGroup);
}
bool OaMetricSourceImp::isMetricGroupActivated() const {
return metricDeviceContext.isMetricGroupActivated();
}
bool OaMetricSourceImp::isImplicitScalingCapable() const {
return metricDeviceContext.isImplicitScalingCapable();
}
template <>
OaMetricSourceImp &MetricDeviceContext::getMetricSource<OaMetricSourceImp>() const {
return static_cast<OaMetricSourceImp &>(*metricSources.at(MetricSource::SourceType::Oa));
}
} // namespace L0

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

@@ -60,7 +60,6 @@ class OaMetricSourceImp : public MetricSource {
std::unique_ptr<MetricsLibrary> metricsLibrary = nullptr;
MetricStreamer *pMetricStreamer = nullptr;
bool useCompute = false;
bool available = false;
};
template <>

2
level_zero/tools/source/metrics/os_metric_ip_sampling.h
View File

@@ -5,6 +5,8 @@
*
*/
#pragma once
#include <level_zero/zet_api.h>
#include <memory>

1
level_zero/tools/test/unit_tests/sources/metrics/CMakeLists.txt
View File

@@ -19,6 +19,7 @@ target_sources(${TARGET_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/test_metric_oa_streamer_2.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_metric_oa_streamer_3.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_metric_oa_initialization.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_metric_ip_sampling_enumeration.cpp
)

52
level_zero/tools/test/unit_tests/sources/metrics/mock_metric_ip_sampling.h Normal file
View File

@@ -0,0 +1,52 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/test/common/test_macros/test.h"
#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
namespace L0 {
namespace ult {
class MockMetricIpSamplingOsInterface : public MetricIpSamplingOsInterface {
public:
ze_result_t startMeasurementReturn = ZE_RESULT_SUCCESS;
ze_result_t stopMeasurementReturn = ZE_RESULT_SUCCESS;
ze_result_t readDataReturn = ZE_RESULT_SUCCESS;
uint32_t getRequiredBufferSizeReturn = ZE_RESULT_SUCCESS;
uint32_t getUnitReportSizeReturn = 64;
bool isNReportsAvailableReturn = true;
bool isDependencyAvailableReturn = true;
~MockMetricIpSamplingOsInterface() override = default;
ze_result_t startMeasurement(uint32_t &notifyEveryNReports, uint32_t &samplingPeriodNs) override {
return startMeasurementReturn;
}
ze_result_t stopMeasurement() override {
return stopMeasurementReturn;
}
ze_result_t readData(uint8_t *pRawData, size_t *pRawDataSize) override {
return readDataReturn;
}
uint32_t getRequiredBufferSize(const uint32_t maxReportCount) override {
return getRequiredBufferSizeReturn;
}
uint32_t getUnitReportSize() override {
return getUnitReportSizeReturn;
}
bool isNReportsAvailable() override {
return isNReportsAvailableReturn;
}
bool isDependencyAvailable() override {
return isDependencyAvailableReturn;
}
};
} // namespace ult
} // namespace L0

25
level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.cpp
View File

@@ -10,8 +10,10 @@
#include "shared/source/command_container/implicit_scaling.h"
#include "shared/test/common/mocks/mock_os_library.h"
#include "level_zero/tools/source/metrics/metric_ip_sampling_source.h"
#include "level_zero/tools/source/metrics/metric_oa_source.h"
#include "level_zero/tools/source/metrics/metric_oa_streamer_imp.h"
#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
using namespace MetricsLibraryApi;
@@ -21,6 +23,21 @@ using ::testing::Return;
namespace L0 {
namespace ult {
class MockIpSamplingOsInterface : public MetricIpSamplingOsInterface {
public:
~MockIpSamplingOsInterface() override = default;
ze_result_t startMeasurement(uint32_t &notifyEveryNReports, uint32_t &samplingPeriodNs) override {
return ZE_RESULT_ERROR_UNKNOWN;
}
ze_result_t stopMeasurement() override { return ZE_RESULT_ERROR_UNKNOWN; }
ze_result_t readData(uint8_t *pRawData, size_t *pRawDataSize) override { return ZE_RESULT_ERROR_UNKNOWN; }
uint32_t getRequiredBufferSize(const uint32_t maxReportCount) override { return 0; }
uint32_t getUnitReportSize() override { return 0; }
bool isNReportsAvailable() override { return false; }
bool isDependencyAvailable() override { return false; }
};
void MetricContextFixture::SetUp() {
// Call base class.
@@ -30,6 +47,11 @@ void MetricContextFixture::SetUp() {
auto &metricSource = device->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
metricSource.setInitializationState(ZE_RESULT_SUCCESS);
std::unique_ptr<MetricIpSamplingOsInterface> metricIpSamplingOsInterface =
std::unique_ptr<MetricIpSamplingOsInterface>(new MockIpSamplingOsInterface());
auto &ipMetricSource = device->getMetricDeviceContext().getMetricSource<IpSamplingMetricSourceImp>();
ipMetricSource.setMetricOsInterface(metricIpSamplingOsInterface);
// Mock metrics library.
mockMetricsLibrary = std::unique_ptr<Mock<MetricsLibrary>>(new (std::nothrow) Mock<MetricsLibrary>(metricSource));
mockMetricsLibrary->setMockedApi(&mockMetricsLibraryApi);
@@ -124,6 +146,7 @@ void MetricMultiDeviceFixture::SetUp() {
// Initialize metric api.
auto &metricSource = devices[0]->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
metricSource.setInitializationState(ZE_RESULT_SUCCESS);
// Mock metrics library.
mockMetricsLibrary = std::unique_ptr<Mock<MetricsLibrary>>(new (std::nothrow) Mock<MetricsLibrary>(metricSource));
@@ -149,6 +172,8 @@ void MetricMultiDeviceFixture::SetUp() {
mockMetricsLibrarySubDevices[i] = std::unique_ptr<Mock<MetricsLibrary>>(new (std::nothrow) Mock<MetricsLibrary>(metricsSubDeviceContext));
mockMetricsLibrarySubDevices[i]->setMockedApi(&mockMetricsLibraryApi);
mockMetricsLibrarySubDevices[i]->handle = new MockOsLibrary();
metricsSubDeviceContext.setInitializationState(ZE_RESULT_SUCCESS);
}
// Metrics Discovery device common settings.
metricsDeviceParams.Version.MajorNumber = MetricEnumeration::requiredMetricsDiscoveryMajorVersion;

331
level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_enumeration.cpp Normal file
View File

@@ -0,0 +1,331 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
#include "level_zero/tools/source/metrics/metric_ip_sampling_source.h"
#include "level_zero/tools/source/metrics/metric_oa_source.h"
#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_ip_sampling.h"
#include <level_zero/zet_api.h>
namespace L0 {
extern _ze_driver_handle_t *GlobalDriverHandle;
namespace ult {
class MetricIpSamplingEnumerationTest : public MultiDeviceFixture,
public ::testing::Test {
public:
void SetUp() override {
MultiDeviceFixture::numRootDevices = 1;
MultiDeviceFixture::numSubDevices = 2;
MultiDeviceFixture::SetUp();
testDevices.reserve(MultiDeviceFixture::numRootDevices +
(MultiDeviceFixture::numRootDevices *
MultiDeviceFixture::numSubDevices));
for (auto device : driverHandle->devices) {
testDevices.push_back(device);
auto &deviceImp = *static_cast<DeviceImp *>(device);
const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
for (uint32_t i = 0; i < subDeviceCount; i++) {
testDevices.push_back(deviceImp.subDevices[i]);
}
}
osInterfaceVector.reserve(testDevices.size());
for (auto device : testDevices) {
auto mockMetricIpSamplingOsInterface = new MockMetricIpSamplingOsInterface();
osInterfaceVector.push_back(mockMetricIpSamplingOsInterface);
std::unique_ptr<MetricIpSamplingOsInterface> metricIpSamplingOsInterface = std::unique_ptr<MetricIpSamplingOsInterface>(mockMetricIpSamplingOsInterface);
auto &metricSource = device->getMetricDeviceContext().getMetricSource<IpSamplingMetricSourceImp>();
metricSource.setMetricOsInterface(metricIpSamplingOsInterface);
auto &metricOaSource = device->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
metricOaSource.setInitializationState(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
GlobalDriverHandle = static_cast<_ze_driver_handle_t *>(driverHandle.get());
}
void TearDown() override {
MultiDeviceFixture::TearDown();
}
std::vector<MockMetricIpSamplingOsInterface *> osInterfaceVector = {};
std::vector<L0::Device *> testDevices = {};
};
TEST_F(MetricIpSamplingEnumerationTest, GivenDependenciesAvailableWhenInititializingThenSuccessIsReturned) {
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
for (auto device : testDevices) {
auto &metricSource = device->getMetricDeviceContext().getMetricSource<IpSamplingMetricSourceImp>();
EXPECT_TRUE(metricSource.isAvailable());
}
}
TEST_F(MetricIpSamplingEnumerationTest, GivenDependenciesUnAvailableForRootDeviceWhenInititializingThenFailureIsReturned) {
osInterfaceVector[0]->isDependencyAvailableReturn = false;
EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, testDevices[0]->getMetricDeviceContext().enableMetricApi());
}
TEST_F(MetricIpSamplingEnumerationTest, GivenDependenciesUnAvailableForSubDeviceWhenInititializingThenFailureIsReturned) {
osInterfaceVector[1]->isDependencyAvailableReturn = false;
EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, testDevices[0]->getMetricDeviceContext().enableMetricApi());
auto &metricSource = testDevices[0]->getMetricDeviceContext().getMetricSource<IpSamplingMetricSourceImp>();
EXPECT_TRUE(metricSource.isAvailable());
auto &metricSource0 = testDevices[1]->getMetricDeviceContext().getMetricSource<IpSamplingMetricSourceImp>();
EXPECT_FALSE(metricSource0.isAvailable());
auto &metricSource1 = testDevices[2]->getMetricDeviceContext().getMetricSource<IpSamplingMetricSourceImp>();
EXPECT_TRUE(metricSource1.isAvailable());
}
TEST_F(MetricIpSamplingEnumerationTest, GivenDependenciesAvailableWhenMetricGroupGetIsCalledThenValidMetricGroupIsReturned) {
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
for (auto device : testDevices) {
uint32_t metricGroupCount = 0;
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
std::vector<zet_metric_group_handle_t> metricGroups;
metricGroups.resize(metricGroupCount);
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
EXPECT_NE(metricGroups[0], nullptr);
}
}
TEST_F(MetricIpSamplingEnumerationTest, GivenDependenciesAvailableWhenMetricGroupGetIsCalledMultipleTimesThenValidMetricGroupIsReturned) {
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
for (auto device : testDevices) {
uint32_t metricGroupCount = 0;
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
std::vector<zet_metric_group_handle_t> metricGroups;
metricGroups.resize(metricGroupCount);
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
EXPECT_NE(metricGroups[0], nullptr);
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
EXPECT_NE(metricGroups[0], nullptr);
}
}
TEST_F(MetricIpSamplingEnumerationTest, GivenDependenciesAvailableWhenMetricGroupGetIsCalledThenMetricGroupWithCorrectPropertiesIsReturned) {
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
for (auto device : testDevices) {
uint32_t metricGroupCount = 0;
zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr);
EXPECT_EQ(metricGroupCount, 1u);
std::vector<zet_metric_group_handle_t> metricGroups;
metricGroups.resize(metricGroupCount);
ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
ASSERT_NE(metricGroups[0], nullptr);
zet_metric_group_properties_t metricGroupProperties;
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupProperties.domain, 100u);
EXPECT_EQ(metricGroupProperties.samplingType, ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED);
EXPECT_EQ(metricGroupProperties.metricCount, 10u);
EXPECT_EQ(strcmp(metricGroupProperties.description, "EU stall sampling"), 0);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
}
}
TEST_F(MetricIpSamplingEnumerationTest, GivenDependenciesAvailableWhenMetricGroupGetIsCalledThenCorrectMetricsAreReturned) {
struct MetricProperties {
const char *name;
const char *description;
const char *component;
uint32_t tierNumber;
zet_metric_type_t metricType;
zet_value_type_t resultType;
const char *resultUnits;
};
std::vector<struct MetricProperties> expectedProperties = {
{"IP", "IP address", "XVE", 4, ZET_METRIC_TYPE_IP_EXP, ZET_VALUE_TYPE_UINT64, "Address"},
{"Active", "Active cycles", "XVE", 4, ZET_METRIC_TYPE_EVENT, ZET_VALUE_TYPE_UINT64, "Events"},
{"ControlStall", "Stall on control", "XVE", 4, ZET_METRIC_TYPE_EVENT, ZET_VALUE_TYPE_UINT64, "Events"},
{"PipeStall", "Stall on pipe", "XVE", 4, ZET_METRIC_TYPE_EVENT, ZET_VALUE_TYPE_UINT64, "Events"},
{"SendStall", "Stall on send", "XVE", 4, ZET_METRIC_TYPE_EVENT, ZET_VALUE_TYPE_UINT64, "Events"},
{"DistStall", "Stall on distance", "XVE", 4, ZET_METRIC_TYPE_EVENT, ZET_VALUE_TYPE_UINT64, "Events"},
{"SbidStall", "Stall on scoreboard", "XVE", 4, ZET_METRIC_TYPE_EVENT, ZET_VALUE_TYPE_UINT64, "Events"},
{"SyncStall", "Stall on sync", "XVE", 4, ZET_METRIC_TYPE_EVENT, ZET_VALUE_TYPE_UINT64, "Events"},
{"InstrFetchStall", "Stall on instruction fetch", "XVE", 4, ZET_METRIC_TYPE_EVENT, ZET_VALUE_TYPE_UINT64, "Events"},
{"OtherStall", "Stall on other condition", "XVE", 4, ZET_METRIC_TYPE_EVENT, ZET_VALUE_TYPE_UINT64, "Events"},
};
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
for (auto device : testDevices) {
uint32_t metricGroupCount = 0;
zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr);
EXPECT_EQ(metricGroupCount, 1u);
std::vector<zet_metric_group_handle_t> metricGroups;
metricGroups.resize(metricGroupCount);
zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data());
ASSERT_NE(metricGroups[0], nullptr);
zet_metric_group_properties_t metricGroupProperties;
zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties);
uint32_t metricCount = 0;
std::vector<zet_metric_handle_t> metricHandles = {};
metricHandles.resize(metricGroupProperties.metricCount);
EXPECT_EQ(zetMetricGet(metricGroups[0], &metricCount, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricCount, metricGroupProperties.metricCount);
EXPECT_EQ(zetMetricGet(metricGroups[0], &metricCount, metricHandles.data()), ZE_RESULT_SUCCESS);
std::vector<struct MetricProperties>::iterator propertiesIter = expectedProperties.begin();
zet_metric_properties_t ipSamplingMetricProperties = {};
for (auto &metricHandle : metricHandles) {
EXPECT_EQ(zetMetricGetProperties(metricHandle, &ipSamplingMetricProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(ipSamplingMetricProperties.name, propertiesIter->name), 0);
EXPECT_EQ(strcmp(ipSamplingMetricProperties.description, propertiesIter->description), 0);
EXPECT_EQ(strcmp(ipSamplingMetricProperties.component, propertiesIter->component), 0);
EXPECT_EQ(ipSamplingMetricProperties.tierNumber, propertiesIter->tierNumber);
EXPECT_EQ(ipSamplingMetricProperties.metricType, propertiesIter->metricType);
EXPECT_EQ(ipSamplingMetricProperties.resultType, propertiesIter->resultType);
EXPECT_EQ(strcmp(ipSamplingMetricProperties.resultUnits, propertiesIter->resultUnits), 0);
propertiesIter++;
}
}
}
TEST_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulThenDummyActivationAndDeActivationHappens) {
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
for (auto device : testDevices) {
uint32_t metricGroupCount = 0;
zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr);
std::vector<zet_metric_group_handle_t> metricGroups;
metricGroups.resize(metricGroupCount);
ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
ASSERT_NE(metricGroups[0], nullptr);
zet_metric_group_properties_t metricGroupProperties;
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
EXPECT_EQ(zetContextActivateMetricGroups(context->toHandle(), device->toHandle(), 1, &metricGroups[0]), ZE_RESULT_SUCCESS);
static_cast<DeviceImp *>(device)->activateMetricGroups();
EXPECT_EQ(zetContextActivateMetricGroups(context->toHandle(), device->toHandle(), 0, nullptr), ZE_RESULT_SUCCESS);
}
}
TEST_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulWhenCalculateMultipleMetricValuesExpIsCalledThenUnsupportedFeatureIsReturned) {
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
for (auto device : testDevices) {
uint32_t metricGroupCount = 0;
zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr);
std::vector<zet_metric_group_handle_t> metricGroups;
metricGroups.resize(metricGroupCount);
ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
ASSERT_NE(metricGroups[0], nullptr);
zet_metric_group_properties_t metricGroupProperties;
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
EXPECT_EQ(zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0],
ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, 0x0, nullptr,
nullptr, nullptr, nullptr, nullptr),
ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
}
TEST_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulWhenCalculateMetricValuesIsCalledThenUnsupportedFeatureIsReturned) {
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
for (auto device : testDevices) {
uint32_t metricGroupCount = 0;
zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr);
std::vector<zet_metric_group_handle_t> metricGroups;
metricGroups.resize(metricGroupCount);
ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
ASSERT_NE(metricGroups[0], nullptr);
zet_metric_group_properties_t metricGroupProperties;
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES,
0, nullptr, nullptr, nullptr),
ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
}
TEST_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulWhenQueryPoolCreateIsCalledThenUnsupportedFeatureIsReturned) {
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
for (auto device : testDevices) {
uint32_t metricGroupCount = 0;
zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr);
std::vector<zet_metric_group_handle_t> metricGroups;
metricGroups.resize(metricGroupCount);
ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
ASSERT_NE(metricGroups[0], nullptr);
zet_metric_group_properties_t metricGroupProperties;
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
zet_metric_query_pool_desc_t poolDesc = {};
poolDesc.stype = ZET_STRUCTURE_TYPE_METRIC_QUERY_POOL_DESC;
poolDesc.count = 1;
poolDesc.type = ZET_METRIC_QUERY_POOL_TYPE_PERFORMANCE;
EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), device, metricGroups[0], &poolDesc, nullptr), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
}
TEST_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulWhenStreamerOpenIsCalledThenUnsupportedFeatureIsReturned) {
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
for (auto device : testDevices) {
uint32_t metricGroupCount = 0;
zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr);
std::vector<zet_metric_group_handle_t> metricGroups;
metricGroups.resize(metricGroupCount);
ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
ASSERT_NE(metricGroups[0], nullptr);
zet_metric_group_properties_t metricGroupProperties;
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
EXPECT_EQ(zetMetricStreamerOpen(context->toHandle(), device, metricGroups[0], nullptr, nullptr, nullptr), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
}
TEST_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulWhenAppendMetricMemoryBarrierIsCalledThenUnsupportedFeatureIsReturned) {
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
auto &device = testDevices[0];
ze_result_t returnValue;
std::unique_ptr<L0::CommandList> commandList(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue));
zet_command_list_handle_t commandListHandle = commandList->toHandle();
EXPECT_EQ(zetCommandListAppendMetricMemoryBarrier(commandListHandle), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
} // namespace ult
} // namespace L0

15
level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_1.cpp
View File

@@ -25,7 +25,7 @@ namespace ult {
using MetricEnumerationTest = Test<MetricContextFixture>;
TEST_F(MetricEnumerationTest, givenIncorrectMetricsDiscoveryDeviceWhenZetGetMetricGroupIsCalledThenReturnsFail) {
TEST_F(MetricEnumerationTest, givenIncorrectMetricsDiscoveryDeviceWhenZetGetMetricGroupIsCalledThenNoMetricGroupsAreReturned) {
EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
.Times(0);
@@ -35,7 +35,7 @@ TEST_F(MetricEnumerationTest, givenIncorrectMetricsDiscoveryDeviceWhenZetGetMetr
.WillOnce(DoAll(::testing::SetArgPointee<0>(nullptr), Return(TCompletionCode::CC_ERROR_GENERAL)));
uint32_t metricGroupCount = 0;
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_ERROR_UNKNOWN);
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 0u);
}
@@ -55,16 +55,17 @@ TEST_F(MetricEnumerationTest, givenIncorrectMetricDiscoveryWhenLoadMetricsDiscov
EXPECT_EQ(mockMetricEnumeration->baseLoadMetricsDiscovery(), ZE_RESULT_ERROR_NOT_AVAILABLE);
}
TEST_F(MetricEnumerationTest, givenIncorrectMetricDiscoveryWhenMetricGroupGetIsCalledThenReturnsErrorUnknown) {
TEST_F(MetricEnumerationTest, givenIncorrectMetricDiscoveryWhenMetricGroupGetIsCalledThenNoMetricGroupsAreReturned) {
mockMetricEnumeration->hMetricsDiscovery = nullptr;
mockMetricEnumeration->openAdapterGroup = nullptr;
uint32_t metricGroupCount = 0;
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_ERROR_UNKNOWN);
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 0u);
}
TEST_F(MetricEnumerationTest, givenIncorrectMetricsDiscoveryInterfaceVersionWhenZetGetMetricGroupIsCalledThenReturnsFail) {
TEST_F(MetricEnumerationTest, givenIncorrectMetricsDiscoveryInterfaceVersionWhenZetGetMetricGroupIsCalledThenNoMetricGroupsAreReturned) {
metricsDeviceParams.Version.MajorNumber = 0;
metricsDeviceParams.Version.MinorNumber = 1;
@@ -76,11 +77,11 @@ TEST_F(MetricEnumerationTest, givenIncorrectMetricsDiscoveryInterfaceVersionWhen
.WillOnce(Return(&metricsDeviceParams));
uint32_t metricGroupCount = 0;
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_ERROR_UNKNOWN);
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 0u);
}
TEST_F(MetricEnumerationTest, givenNoConcurrentMetricGroupsWhenZetGetMetricGroupIsCalledThenReturnsZeroMetricsGroups) {
TEST_F(MetricEnumerationTest, givenNoConcurrentMetricGroupsWhenZetGetMetricGroupIsCalledThenNoMetricGroupsAreReturned) {
openMetricsAdapter();

2
level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_2.cpp
View File

@@ -134,7 +134,7 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenIncorrectMetricsDiscoveryInterface
.WillOnce(Return(&metricsDeviceParams));
uint32_t metricGroupCount = 0;
EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_ERROR_UNKNOWN);
EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 0u);
}