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

feature: Support for metrics group exp extension

Browse Source 
Support zet_metric_global_timestamps_resolution_exp_t

Resolves: LOCI-4350

Signed-off-by: Matias Cabral <matias.a.cabral@intel.com>
This commit is contained in:
Matias Cabral
2023-04-25 17:31:35 +00:00
committed by Compute-Runtime-Automation
parent f329fa5f87
commit cfa187aec6
47 changed files with 796 additions and 178 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -20,7 +20,7 @@ target_sources(${L0_STATIC_LIB_NAME}
${CMAKE_CURRENT_SOURCE_DIR}/metric_ip_sampling_source.cpp
${CMAKE_CURRENT_SOURCE_DIR}/metric_ip_sampling_streamer.h
${CMAKE_CURRENT_SOURCE_DIR}/metric_ip_sampling_streamer.cpp
${CMAKE_CURRENT_SOURCE_DIR}/os_metric_ip_sampling.h
${CMAKE_CURRENT_SOURCE_DIR}/os_interface_metric.h
)
add_subdirectories()

35
level_zero/tools/source/metrics/linux/os_metric_ip_sampling_imp_linux.cpp
View File

@@ -18,7 +18,8 @@
#include "level_zero/core/source/device/device.h"
#include "level_zero/core/source/device/device_imp.h"
#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
#include "level_zero/tools/source/metrics/metric.h"
#include "level_zero/tools/source/metrics/os_interface_metric.h"
#include <algorithm>
@@ -39,6 +40,7 @@ class MetricIpSamplingLinuxImp : public MetricIpSamplingOsInterface {
uint32_t getUnitReportSize() override;
bool isNReportsAvailable() override;
bool isDependencyAvailable() override;
ze_result_t getMetricsTimerResolution(uint64_t &timerResolution) override;
private:
int32_t stream = -1;
@@ -51,18 +53,17 @@ MetricIpSamplingLinuxImp::MetricIpSamplingLinuxImp(Device &device) : device(devi
ze_result_t MetricIpSamplingLinuxImp::getNearestSupportedSamplingUnit(uint32_t &samplingPeriodNs, uint32_t &samplingUnit) {
static constexpr uint64_t nsecPerSec = 1000000000ull;
static constexpr uint32_t samplingClockGranularity = 251u;
static constexpr uint32_t minSamplingUnit = 1u;
static constexpr uint32_t maxSamplingUnit = 7u;
const auto drm = device.getOsInterface().getDriverModel()->as<NEO::Drm>();
int32_t gpuTimeStampfrequency = 0;
int32_t ret = drm->getTimestampFrequency(gpuTimeStampfrequency);
if (ret < 0 || gpuTimeStampfrequency == 0) {
return ZE_RESULT_ERROR_UNKNOWN;
uint64_t gpuTimeStampfrequency = 0;
ze_result_t ret = getMetricsTimerResolution(gpuTimeStampfrequency);
if (ret != ZE_RESULT_SUCCESS) {
return ret;
}
uint64_t gpuClockPeriodNs = nsecPerSec / static_cast<uint64_t>(gpuTimeStampfrequency);
uint64_t gpuClockPeriodNs = nsecPerSec / gpuTimeStampfrequency;
uint64_t numberOfClocks = samplingPeriodNs / gpuClockPeriodNs;
samplingUnit = std::clamp(static_cast<uint32_t>(numberOfClocks / samplingClockGranularity), minSamplingUnit, maxSamplingUnit);
@@ -205,6 +206,24 @@ bool MetricIpSamplingLinuxImp::isDependencyAvailable() {
return status == ZE_RESULT_SUCCESS ? true : false;
}
ze_result_t MetricIpSamplingLinuxImp::getMetricsTimerResolution(uint64_t &timerResolution) {
ze_result_t result = ZE_RESULT_SUCCESS;
const auto drm = device.getOsInterface().getDriverModel()->as<NEO::Drm>();
int32_t gpuTimeStampfrequency = 0;
int32_t ret = drm->getTimestampFrequency(gpuTimeStampfrequency);
if (ret < 0 || gpuTimeStampfrequency == 0) {
timerResolution = 0;
result = ZE_RESULT_ERROR_UNKNOWN;
PRINT_DEBUG_STRING(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "getTimestampFrequency() failed errno = %d | ret = %d \n",
errno, ret);
} else {
timerResolution = static_cast<uint64_t>(gpuTimeStampfrequency);
}
return result;
}
std::unique_ptr<MetricIpSamplingOsInterface> MetricIpSamplingOsInterface::create(Device &device) {
return std::make_unique<MetricIpSamplingLinuxImp>(device);
}

37
level_zero/tools/source/metrics/linux/os_metric_oa_enumeration_imp_linux.cpp
View File

@@ -1,10 +1,11 @@
/*
* Copyright (C) 2020-2022 Intel Corporation
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/os_interface/linux/drm_neo.h"
#include "shared/source/os_interface/linux/sys_calls.h"
#include "shared/source/os_interface/os_interface.h"
@@ -12,6 +13,7 @@
#include "level_zero/core/source/device/device.h"
#include "level_zero/tools/source/metrics/metric_oa_enumeration_imp.h"
#include "level_zero/tools/source/metrics/metric_oa_source.h"
#include "level_zero/tools/source/metrics/os_interface_metric.h"
#include <sys/stat.h>
#include <sys/sysmacros.h>
@@ -81,5 +83,38 @@ MetricsDiscovery::IAdapter_1_9 *MetricEnumeration::getMetricsAdapter() {
return nullptr;
}
class MetricOALinuxImp : public MetricOAOsInterface {
public:
MetricOALinuxImp(Device &device);
~MetricOALinuxImp() override = default;
ze_result_t getMetricsTimerResolution(uint64_t &timerResolution) override;
private:
Device &device;
};
MetricOALinuxImp::MetricOALinuxImp(Device &device) : device(device) {}
std::unique_ptr<MetricOAOsInterface> MetricOAOsInterface::create(Device &device) {
return std::make_unique<MetricOALinuxImp>(device);
}
ze_result_t MetricOALinuxImp::getMetricsTimerResolution(uint64_t &timerResolution) {
ze_result_t result = ZE_RESULT_SUCCESS;
const auto drm = device.getOsInterface().getDriverModel()->as<NEO::Drm>();
int32_t timestampFrequency;
int32_t ret = drm->getOATimestampFrequency(timestampFrequency);
if (ret < 0 || timestampFrequency == 0) {
timerResolution = 0;
result = ZE_RESULT_ERROR_UNKNOWN;
PRINT_DEBUG_STRING(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "getOATimestampFrequenc() failed errno = %d | ret = %d \n",
errno, ret);
} else {
timerResolution = static_cast<uint64_t>(timestampFrequency);
}
return result;
}
} // namespace L0

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

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2022 Intel Corporation
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -122,7 +122,7 @@ void MetricDeviceContext::activateMetricGroupsDeferred(uint32_t count, zet_metri
for (auto index = 0u; index < count; index++) {
zet_metric_group_handle_t hMetricGroup = MetricGroup::fromHandle(phMetricGroups[index])->getMetricGroupForSubDevice(subDeviceIndex);
zet_metric_group_properties_t properties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES};
zet_metric_group_properties_t properties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
MetricGroup::fromHandle(hMetricGroup)->getProperties(&properties);
auto domain = properties.domain;
// Domain already associated with the same handle.
@@ -259,4 +259,36 @@ ze_result_t metricStreamerOpen(zet_context_handle_t hContext, zet_device_handle_
return MetricGroup::fromHandle(hMetricGroup)->streamerOpen(hContext, hDevice, pDesc, hNotificationEvent, phMetricStreamer);
}
ze_result_t MetricGroup::getMetricGroupExtendedProperties(MetricSource &metricSource, void *pNext) {
ze_result_t retVal = ZE_RESULT_ERROR_INVALID_ARGUMENT;
while (pNext) {
zet_base_desc_t *extendedProperties = reinterpret_cast<zet_base_desc_t *>(pNext);
if (extendedProperties->stype == ZET_STRUCTURE_TYPE_GLOBAL_METRICS_TIMESTAMPS_EXP_PROPERTIES) {
zet_metric_global_timestamps_resolution_exp_t *metricsTimestampProperties =
reinterpret_cast<zet_metric_global_timestamps_resolution_exp_t *>(extendedProperties);
retVal = metricSource.getTimerResolution(metricsTimestampProperties->timerResolution);
if (retVal != ZE_RESULT_SUCCESS) {
metricsTimestampProperties->timerResolution = 0;
metricsTimestampProperties->timestampValidBits = 0;
return retVal;
}
retVal = metricSource.getTimestampValidBits(metricsTimestampProperties->timestampValidBits);
if (retVal != ZE_RESULT_SUCCESS) {
metricsTimestampProperties->timerResolution = 0;
metricsTimestampProperties->timestampValidBits = 0;
return retVal;
}
}
pNext = const_cast<void *>(extendedProperties->pNext);
}
return retVal;
}
} // namespace L0

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

@@ -7,6 +7,7 @@
#pragma once
#include "level_zero/core/source/event/event.h"
#include "level_zero/tools/source/metrics/os_interface_metric.h"
#include <level_zero/zet_api.h>
#include "metrics_discovery_api.h"
@@ -24,6 +25,8 @@ namespace L0 {
struct CommandList;
struct MetricStreamer;
static constexpr uint64_t nsecPerSec = 1000000000ull;
class MetricSource {
public:
enum class SourceType {
@@ -35,7 +38,11 @@ class MetricSource {
virtual bool isAvailable() = 0;
virtual ze_result_t appendMetricMemoryBarrier(CommandList &commandList) = 0;
virtual ze_result_t metricGroupGet(uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups) = 0;
virtual ze_result_t getTimerResolution(uint64_t &resolution) = 0;
virtual ze_result_t getTimestampValidBits(uint64_t &validBits) = 0;
virtual ~MetricSource() = default;
private:
};
class MetricDeviceContext {
@@ -109,6 +116,7 @@ struct MetricGroup : _zet_metric_group_handle_t {
zet_device_handle_t hDevice,
const zet_metric_query_pool_desc_t *desc,
zet_metric_query_pool_handle_t *phMetricQueryPool) = 0;
ze_result_t getMetricGroupExtendedProperties(MetricSource &metricSource, void *pnext);
};
struct MetricGroupCalculateHeader {

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

@@ -8,12 +8,14 @@
#include "level_zero/tools/source/metrics/metric_ip_sampling_source.h"
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/helpers/hw_info.h"
#include "shared/source/helpers/string.h"
#include "level_zero/core/source/device/device.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_ip_sampling_streamer.h"
#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
#include "level_zero/tools/source/metrics/os_interface_metric.h"
#include <level_zero/zet_api.h>
#include <cstring>
@@ -27,11 +29,21 @@ std::unique_ptr<IpSamplingMetricSourceImp> IpSamplingMetricSourceImp::create(con
}
IpSamplingMetricSourceImp::IpSamplingMetricSourceImp(const MetricDeviceContext &metricDeviceContext) : metricDeviceContext(metricDeviceContext) {
metricOsInterface = MetricIpSamplingOsInterface::create(metricDeviceContext.getDevice());
metricIPSamplingOsInterface = MetricIpSamplingOsInterface::create(metricDeviceContext.getDevice());
}
ze_result_t IpSamplingMetricSourceImp::getTimerResolution(uint64_t &resolution) {
resolution = metricDeviceContext.getDevice().getNEODevice()->getDeviceInfo().outProfilingTimerClock;
return ZE_RESULT_SUCCESS;
}
ze_result_t IpSamplingMetricSourceImp::getTimestampValidBits(uint64_t &validBits) {
validBits = metricDeviceContext.getDevice().getNEODevice()->getHardwareInfo().capabilityTable.timestampValidBits;
return ZE_RESULT_SUCCESS;
}
void IpSamplingMetricSourceImp::enable() {
isEnabled = metricOsInterface->isDependencyAvailable();
isEnabled = metricIPSamplingOsInterface->isDependencyAvailable();
}
bool IpSamplingMetricSourceImp::isAvailable() {
@@ -132,8 +144,8 @@ ze_result_t IpSamplingMetricSourceImp::appendMetricMemoryBarrier(CommandList &co
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
void IpSamplingMetricSourceImp::setMetricOsInterface(std::unique_ptr<MetricIpSamplingOsInterface> &metricOsInterface) {
this->metricOsInterface = std::move(metricOsInterface);
void IpSamplingMetricSourceImp::setMetricOsInterface(std::unique_ptr<MetricIpSamplingOsInterface> &metricIPSamplingOsInterface) {
this->metricIPSamplingOsInterface = std::move(metricIPSamplingOsInterface);
}
IpSamplingMetricGroupImp::IpSamplingMetricGroupImp(IpSamplingMetricSourceImp &metricSource,
@@ -153,7 +165,14 @@ IpSamplingMetricGroupImp::IpSamplingMetricGroupImp(IpSamplingMetricSourceImp &me
}
ze_result_t IpSamplingMetricGroupImp::getProperties(zet_metric_group_properties_t *pProperties) {
void *pNext = pProperties->pNext;
*pProperties = properties;
pProperties->pNext = pNext;
if (pNext) {
return getMetricGroupExtendedProperties(metricSource, pNext);
}
return ZE_RESULT_SUCCESS;
}

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

@@ -8,7 +8,7 @@
#pragma once
#include "level_zero/tools/source/metrics/metric.h"
#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
#include "level_zero/tools/source/metrics/os_interface_metric.h"
namespace L0 {
@@ -25,18 +25,20 @@ class IpSamplingMetricSourceImp : public MetricSource {
bool isAvailable() override;
ze_result_t metricGroupGet(uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups) override;
ze_result_t appendMetricMemoryBarrier(CommandList &commandList) override;
void setMetricOsInterface(std::unique_ptr<MetricIpSamplingOsInterface> &metricOsInterface);
void setMetricOsInterface(std::unique_ptr<MetricIpSamplingOsInterface> &metricIPSamplingOsInterface);
static std::unique_ptr<IpSamplingMetricSourceImp> create(const MetricDeviceContext &metricDeviceContext);
MetricIpSamplingOsInterface *getMetricOsInterface() { return metricOsInterface.get(); }
MetricIpSamplingOsInterface *getMetricOsInterface() { return metricIPSamplingOsInterface.get(); }
IpSamplingMetricStreamerImp *pActiveStreamer = nullptr;
const MetricDeviceContext &getMetricDeviceContext() const { return metricDeviceContext; }
ze_result_t getTimerResolution(uint64_t &resolution) override;
ze_result_t getTimestampValidBits(uint64_t &validBits) override;
protected:
void cacheMetricGroup();
bool isEnabled = false;
const MetricDeviceContext &metricDeviceContext;
std::unique_ptr<MetricIpSamplingOsInterface> metricOsInterface = nullptr;
std::unique_ptr<MetricIpSamplingOsInterface> metricIPSamplingOsInterface = nullptr;
std::unique_ptr<MetricGroup> cachedMetricGroup = nullptr;
};
@@ -95,7 +97,7 @@ struct IpSamplingMetricGroupImp : public IpSamplingMetricGroupBase {
private:
std::vector<std::unique_ptr<IpSamplingMetricImp>> metrics = {};
zet_metric_group_properties_t properties = {};
zet_metric_group_properties_t properties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
ze_result_t getCalculatedMetricCount(const size_t rawDataSize, uint32_t &metricValueCount);
ze_result_t getCalculatedMetricValues(const zet_metric_group_calculation_type_t type, const size_t rawDataSize, const uint8_t *pRawData,
uint32_t &metricValueCount,

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

@@ -10,7 +10,7 @@
#include "level_zero/core/source/device/device.h"
#include "level_zero/tools/source/metrics/metric.h"
#include "level_zero/tools/source/metrics/metric_ip_sampling_source.h"
#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
#include "level_zero/tools/source/metrics/os_interface_metric.h"
#include <level_zero/zet_api.h>
#include <string.h>

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

@@ -8,7 +8,7 @@
#pragma once
#include "level_zero/tools/source/metrics/metric.h"
#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
#include "level_zero/tools/source/metrics/os_interface_metric.h"
namespace L0 {

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

@@ -68,11 +68,22 @@ bool MetricEnumeration::isInitialized() {
return initializationState == ZE_RESULT_SUCCESS;
}
void MetricEnumeration::readGlobalSymbols() {
auto symbolValue = pMetricsDevice->GetGlobalSymbolValueByName(globalSymbolOaMaxBufferSize.data());
if (symbolValue != nullptr) {
maximumOaBufferSize = symbolValue->ValueUInt32;
bool MetricEnumeration::readGlobalSymbol(const char *name, uint32_t &symbolValue) {
auto tempValue = pMetricsDevice->GetGlobalSymbolValueByName(name);
if (tempValue != nullptr) {
symbolValue = tempValue->ValueUInt32;
return true;
}
return false;
}
bool MetricEnumeration::readGlobalSymbol(const char *name, uint64_t &symbolValue) {
auto tempValue = pMetricsDevice->GetGlobalSymbolValueByName(name);
if (tempValue != nullptr) {
symbolValue = tempValue->ValueUInt64;
return true;
}
return false;
}
ze_result_t MetricEnumeration::initialize() {
@@ -169,7 +180,8 @@ ze_result_t MetricEnumeration::openMetricsDiscovery() {
cleanupMetricsDiscovery();
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
subDeviceMetricEnumeraion.readGlobalSymbols();
subDeviceMetricEnumeraion.readGlobalSymbol(globalSymbolOaMaxBufferSize.data(), maximumOaBufferSize);
}
} else {
auto &deviceImp = *static_cast<DeviceImp *>(&metricSource.getDevice());
@@ -188,7 +200,7 @@ ze_result_t MetricEnumeration::openMetricsDiscovery() {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
readGlobalSymbols();
readGlobalSymbol(globalSymbolOaMaxBufferSize.data(), maximumOaBufferSize);
}
return ZE_RESULT_SUCCESS;
@@ -334,8 +346,7 @@ MetricEnumeration::cacheMetricGroup(MetricsDiscovery::IMetricSet_1_5 &metricSet,
// Obtain params once again - updated after SetApiFiltering
pMetricSetParams = metricSet.GetParams();
zet_metric_group_properties_t properties = {};
properties.stype = ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES;
zet_metric_group_properties_t properties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
snprintf(properties.name, sizeof(properties.name), "%s",
pMetricSetParams->SymbolName); // To always have null-terminated string
snprintf(properties.description, sizeof(properties.description), "%s",
@@ -519,22 +530,28 @@ OaMetricGroupImp ::~OaMetricGroupImp() {
};
ze_result_t OaMetricGroupImp::getProperties(zet_metric_group_properties_t *pProperties) {
ze_result_t status = ZE_RESULT_SUCCESS;
if (metricGroups.size() > 0) {
*pProperties = OaMetricGroupImp::getProperties(metricGroups[0]);
status = OaMetricGroupImp::getProperties(metricGroups[0], pProperties);
} else {
void *pNext = pProperties->pNext;
copyProperties(properties, *pProperties);
pProperties->pNext = pNext;
if (pNext) {
status = getMetricGroupExtendedProperties(*metricSource, pNext);
}
}
return ZE_RESULT_SUCCESS;
return status;
}
zet_metric_group_properties_t OaMetricGroupImp::getProperties(const zet_metric_group_handle_t handle) {
ze_result_t OaMetricGroupImp::getProperties(const zet_metric_group_handle_t handle, zet_metric_group_properties_t *pProperties) {
auto metricGroup = MetricGroup::fromHandle(handle);
UNRECOVERABLE_IF(!metricGroup);
zet_metric_group_properties_t properties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES};
metricGroup->getProperties(&properties);
return properties;
return metricGroup->getProperties(pProperties);
}
ze_result_t OaMetricGroupImp::metricGet(uint32_t *pCount, zet_metric_handle_t *phMetrics) {

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

@@ -16,6 +16,7 @@
namespace L0 {
static constexpr std::string_view globalSymbolOaMaxBufferSize = "OABufferMaxSize";
static constexpr std::string_view globalSymbolOaMaxTimestamp = "MaxTimestamp";
class OaMetricSourceImp;
@@ -32,6 +33,8 @@ struct MetricEnumeration {
virtual ze_result_t loadMetricsDiscovery();
void getMetricsDiscoveryFilename(std::vector<const char *> &names) const;
uint32_t getMaxOaBufferSize() const { return maximumOaBufferSize; }
bool readGlobalSymbol(const char *name, uint32_t &symbolValue);
bool readGlobalSymbol(const char *name, uint64_t &symbolValue);
protected:
ze_result_t initialize();
@@ -56,7 +59,6 @@ struct MetricEnumeration {
getMetricType(const MetricsDiscovery::TInformationType sourceInformationType) const;
zet_value_type_t
getMetricResultType(const MetricsDiscovery::TMetricResultType sourceMetricResultType) const;
void readGlobalSymbols();
protected:
OaMetricSourceImp &metricSource;
@@ -129,7 +131,7 @@ struct OaMetricGroupImp : MetricGroup {
MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup,
const std::vector<Metric *> &metrics,
MetricSource &metricSource);
static zet_metric_group_properties_t getProperties(const zet_metric_group_handle_t handle);
static ze_result_t getProperties(const zet_metric_group_handle_t handle, zet_metric_group_properties_t *pProperties);
uint32_t getRawReportSize();
const MetricEnumeration &getMetricEnumeration() const;
@@ -148,9 +150,7 @@ struct OaMetricGroupImp : MetricGroup {
// Cached metrics.
std::vector<Metric *> metrics;
zet_metric_group_properties_t properties{
ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES,
};
zet_metric_group_properties_t properties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
MetricsDiscovery::IMetricSet_1_5 *pReferenceMetricSet = nullptr;
MetricsDiscovery::IConcurrentGroup_1_5 *pReferenceConcurrentGroup = nullptr;

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

@@ -397,7 +397,8 @@ ConfigurationHandle_1_0 MetricsLibrary::addConfiguration(zet_metric_group_handle
// Create metrics library configuration.
auto metricGroup = MetricGroup::fromHandle(handle);
auto properties = OaMetricGroupImp::getProperties(handle);
zet_metric_group_properties_t properties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
OaMetricGroupImp::getProperties(handle, &properties);
auto configuration = createConfiguration(metricGroup, properties);
// Cache configuration if valid.
@@ -604,7 +605,8 @@ bool OaMetricQueryPoolImp::allocateGpuMemory() {
bool OaMetricQueryPoolImp::createMetricQueryPool() {
// Validate metric group query - only event based is supported.
auto metricGroupProperites = OaMetricGroupImp::getProperties(hMetricGroup);
zet_metric_group_properties_t metricGroupProperites = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
OaMetricGroupImp::getProperties(hMetricGroup, &metricGroupProperites);
const bool validMetricGroup = metricGroupProperites.samplingType == ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
if (!validMetricGroup) {

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

@@ -26,6 +26,7 @@ std::unique_ptr<OaMetricSourceImp> OaMetricSourceImp::create(const MetricDeviceC
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))) {
metricOAOsInterface = MetricOAOsInterface::create(metricDeviceContext.getDevice());
}
OaMetricSourceImp::~OaMetricSourceImp() = default;
@@ -34,6 +35,39 @@ void OaMetricSourceImp::enable() {
loadDependencies();
}
ze_result_t OaMetricSourceImp::getTimerResolution(uint64_t &resolution) {
ze_result_t result = getMetricOsInterface()->getMetricsTimerResolution(resolution);
if (result != ZE_RESULT_SUCCESS) {
resolution = 0;
}
return result;
}
ze_result_t OaMetricSourceImp::getTimestampValidBits(uint64_t &validBits) {
ze_result_t retVal = ZE_RESULT_SUCCESS;
uint64_t maxNanoSeconds = 0;
if (!metricEnumeration->readGlobalSymbol(globalSymbolOaMaxTimestamp.data(), maxNanoSeconds)) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
uint64_t timerFreqquency;
retVal = getTimerResolution(timerFreqquency);
if (retVal != ZE_RESULT_SUCCESS) {
validBits = 0;
return retVal;
}
uint64_t maxTimeStamp = maxNanoSeconds * timerFreqquency / nsecPerSec;
auto bits = std::bitset<64>(maxTimeStamp);
validBits = bits.count();
return retVal;
}
bool OaMetricSourceImp::isAvailable() {
return isInitialized();
}
@@ -143,6 +177,10 @@ bool OaMetricSourceImp::isImplicitScalingCapable() const {
return metricDeviceContext.isImplicitScalingCapable();
}
void OaMetricSourceImp::setMetricOsInterface(std::unique_ptr<MetricOAOsInterface> &metricOAOsInterface) {
this->metricOAOsInterface = std::move(metricOAOsInterface);
}
template <>
OaMetricSourceImp &MetricDeviceContext::getMetricSource<OaMetricSourceImp>() const {
return static_cast<OaMetricSourceImp &>(*metricSources.at(MetricSource::SourceType::Oa));

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

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2022 Intel Corporation
* Copyright (C) 2022-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -38,6 +38,9 @@ class OaMetricSourceImp : public MetricSource {
void setMetricsLibrary(MetricsLibrary &metricsLibrary);
void setMetricEnumeration(MetricEnumeration &metricEnumeration);
ze_result_t getTimerResolution(uint64_t &resolution) override;
ze_result_t getTimestampValidBits(uint64_t &validBits) override;
ze_result_t activateMetricGroups();
ze_result_t activateMetricGroupsDeferred(const uint32_t count,
zet_metric_group_handle_t *phMetricGroups);
@@ -49,6 +52,8 @@ class OaMetricSourceImp : public MetricSource {
bool isImplicitScalingCapable() const;
const MetricDeviceContext &getMetricDeviceContext() const { return metricDeviceContext; }
static std::unique_ptr<OaMetricSourceImp> create(const MetricDeviceContext &metricDeviceContext);
void setMetricOsInterface(std::unique_ptr<MetricOAOsInterface> &metricOAOsInterface);
MetricOAOsInterface *getMetricOsInterface() { return metricOAOsInterface.get(); }
using OsLibraryLoadPtr = std::add_pointer<NEO::OsLibrary *(const std::string &)>::type;
static OsLibraryLoadPtr osLibraryLoadFunction;
@@ -59,6 +64,7 @@ class OaMetricSourceImp : public MetricSource {
std::unique_ptr<MetricsLibrary> metricsLibrary = nullptr;
MetricStreamer *pMetricStreamer = nullptr;
bool useCompute = false;
std::unique_ptr<MetricOAOsInterface> metricOAOsInterface = nullptr;
};
template <>

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

@@ -258,7 +258,7 @@ ze_result_t OaMetricGroupImp::openForDevice(Device *pDevice, zet_metric_streamer
}
// Check metric group sampling type.
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
getProperties(&metricGroupProperties);
if (metricGroupProperties.samplingType != ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;

20
level_zero/tools/source/metrics/os_metric_ip_sampling.h → level_zero/tools/source/metrics/os_interface_metric.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2022 Intel Corporation
* Copyright (C) 2022-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -14,10 +14,16 @@
namespace L0 {
struct Device;
class MetricIpSamplingOsInterface {
class MetricOsInterface {
public:
virtual ~MetricIpSamplingOsInterface() = default;
virtual ~MetricOsInterface() = default;
virtual ze_result_t getMetricsTimerResolution(uint64_t &timerResolution) = 0;
static std::unique_ptr<MetricOsInterface> create(Device &device);
};
class MetricIpSamplingOsInterface : public MetricOsInterface {
public:
~MetricIpSamplingOsInterface() override = default;
virtual ze_result_t startMeasurement(uint32_t &notifyEveryNReports, uint32_t &samplingPeriodNs) = 0;
virtual ze_result_t stopMeasurement() = 0;
virtual ze_result_t readData(uint8_t *pRawData, size_t *pRawDataSize) = 0;
@@ -28,4 +34,10 @@ class MetricIpSamplingOsInterface {
static std::unique_ptr<MetricIpSamplingOsInterface> create(Device &device);
};
class MetricOAOsInterface : public MetricOsInterface {
public:
~MetricOAOsInterface() override = default;
static std::unique_ptr<MetricOAOsInterface> create(Device &device);
};
} // namespace L0

7
level_zero/tools/source/metrics/windows/os_metric_ip_sampling_imp_windows.cpp
View File

@@ -1,12 +1,12 @@
/*
* Copyright (C) 2022 Intel Corporation
* Copyright (C) 2022-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/core/source/device/device.h"
#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
#include "level_zero/tools/source/metrics/os_interface_metric.h"
namespace L0 {
@@ -34,6 +34,9 @@ class MetricIpSamplingWindowsImp : public MetricIpSamplingOsInterface {
bool isDependencyAvailable() override {
return false;
}
ze_result_t getMetricsTimerResolution(uint64_t &timerResolution) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
};
std::unique_ptr<MetricIpSamplingOsInterface> MetricIpSamplingOsInterface::create(Device &device) {

22
level_zero/tools/source/metrics/windows/os_metric_oa_enumeration_imp_windows.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2022 Intel Corporation
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -70,4 +70,24 @@ MetricsDiscovery::IAdapter_1_9 *MetricEnumeration::getMetricsAdapter() {
return nullptr;
}
class MetricOAWindowsImp : public MetricOAOsInterface {
public:
MetricOAWindowsImp(Device &device);
~MetricOAWindowsImp() override = default;
ze_result_t getMetricsTimerResolution(uint64_t &timerResolution) override;
private:
Device &device;
};
MetricOAWindowsImp::MetricOAWindowsImp(Device &device) : device(device) {}
std::unique_ptr<MetricOAOsInterface> MetricOAOsInterface::create(Device &device) {
return std::make_unique<MetricOAWindowsImp>(device);
}
ze_result_t MetricOAWindowsImp::getMetricsTimerResolution(uint64_t &timerResolution) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
} // namespace L0

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

@@ -8,7 +8,7 @@
#include "shared/test/common/test_macros/hw_test.h"
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
#include "level_zero/tools/source/metrics/os_interface_metric.h"
namespace L0 {
namespace ult {

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

@@ -18,7 +18,7 @@
#include "shared/test/common/test_macros/hw_test.h"
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
#include "level_zero/tools/source/metrics/os_interface_metric.h"
namespace NEO {
namespace SysCalls {

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

@@ -9,7 +9,7 @@
#include "shared/test/common/libult/linux/drm_mock.h"
#include "shared/test/common/test_macros/hw_test.h"
#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
#include "level_zero/tools/source/metrics/os_interface_metric.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.h"
namespace L0 {

27
level_zero/tools/test/unit_tests/sources/metrics/linux/test_metric_oa_query_pool_linux.cpp
View File

@@ -12,6 +12,7 @@
#include "shared/test/common/mocks/mock_io_functions.h"
#include "shared/test/common/test_macros/test.h"
#include "level_zero/tools/source/metrics/os_interface_metric.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.h"
#include "gmock/gmock.h"
@@ -221,6 +222,32 @@ class MetricEnumerationTestLinux : public MetricContextFixture,
}
};
TEST_F(MetricEnumerationTestLinux, givenCorrectLinuxDrmAdapterWhenGettingOATimerResolutionThenReturnSuccess) {
std::unique_ptr<MetricOAOsInterface> OAOsInterface = MetricOAOsInterface::create(*device);
uint64_t timerResolution;
OAOsInterface->getMetricsTimerResolution(timerResolution);
EXPECT_EQ(OAOsInterface->getMetricsTimerResolution(timerResolution), ZE_RESULT_SUCCESS);
EXPECT_EQ(timerResolution, 123456UL);
}
TEST_F(MetricEnumerationTestLinux, givenDrmFailureWhenGettingOATimerResolutionThenReturnError) {
std::unique_ptr<MetricOAOsInterface> OAOsInterface = MetricOAOsInterface::create(*device);
uint64_t timerResolution;
OAOsInterface->getMetricsTimerResolution(timerResolution);
auto drm = static_cast<DrmMock *>(device->getOsInterface().getDriverModel()->as<NEO::Drm>());
drm->storedRetVal = -1;
EXPECT_EQ(OAOsInterface->getMetricsTimerResolution(timerResolution), ZE_RESULT_ERROR_UNKNOWN);
EXPECT_EQ(timerResolution, 0UL);
drm->storedRetVal = 0;
drm->storedOaTimestampFrequency = 0;
EXPECT_EQ(OAOsInterface->getMetricsTimerResolution(timerResolution), ZE_RESULT_ERROR_UNKNOWN);
EXPECT_EQ(timerResolution, 0UL);
}
TEST_F(MetricEnumerationTestLinux, givenCorrectLinuxDrmAdapterWhenGetMetricsAdapterThenReturnSuccess) {
auto adapterGroupParams = TAdapterGroupParams_1_6{};

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

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2022 Intel Corporation
* Copyright (C) 2022-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -8,7 +8,7 @@
#pragma once
#include "shared/test/common/test_macros/test.h"
#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
#include "level_zero/tools/source/metrics/os_interface_metric.h"
namespace L0 {
namespace ult {
@@ -19,6 +19,7 @@ class MockMetricIpSamplingOsInterface : public MetricIpSamplingOsInterface {
ze_result_t startMeasurementReturn = ZE_RESULT_SUCCESS;
ze_result_t stopMeasurementReturn = ZE_RESULT_SUCCESS;
ze_result_t readDataReturn = ZE_RESULT_SUCCESS;
ze_result_t getMetricsTimerResolutionReturn = ZE_RESULT_SUCCESS;
uint32_t getUnitReportSizeReturn = 64;
bool isNReportsAvailableReturn = true;
bool isDependencyAvailableReturn = true;
@@ -53,6 +54,11 @@ class MockMetricIpSamplingOsInterface : public MetricIpSamplingOsInterface {
bool isDependencyAvailable() override {
return isDependencyAvailableReturn;
}
ze_result_t getMetricsTimerResolution(uint64_t &timerResolution) override {
timerResolution = 1000;
return getMetricsTimerResolutionReturn;
}
};
} // namespace ult

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

@@ -13,7 +13,7 @@
#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"
#include "level_zero/tools/source/metrics/os_interface_metric.h"
using namespace MetricsLibraryApi;
@@ -23,32 +23,22 @@ 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.
DeviceFixture::setUp();
// Initialize metric api.
mockOAOsInterface = new MockOAOsInterface();
std::unique_ptr<MetricOAOsInterface> metricOAOsInterface =
std::unique_ptr<MetricOAOsInterface>(mockOAOsInterface);
auto &metricSource = device->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
metricSource.setMetricOsInterface(metricOAOsInterface);
metricSource.setInitializationState(ZE_RESULT_SUCCESS);
mockIpSamplingOsInterface = new MockIpSamplingOsInterface();
std::unique_ptr<MetricIpSamplingOsInterface> metricIpSamplingOsInterface =
std::unique_ptr<MetricIpSamplingOsInterface>(new MockIpSamplingOsInterface());
std::unique_ptr<MetricIpSamplingOsInterface>(mockIpSamplingOsInterface);
auto &ipMetricSource = device->getMetricDeviceContext().getMetricSource<IpSamplingMetricSourceImp>();
ipMetricSource.setMetricOsInterface(metricIpSamplingOsInterface);
@@ -136,11 +126,6 @@ void MetricContextFixture::openMetricsAdapterGroup() {
void MetricContextFixture::setupDefaultMocksForMetricDevice(Mock<IMetricsDevice_1_5> &metricDevice) {
EXPECT_CALL(metricDevice, GetParams())
.WillRepeatedly(testing::Return(&metricsDeviceParams));
defaultMaximumOaBufferSize.ValueType = MetricsDiscovery::TValueType::VALUE_TYPE_UINT32;
defaultMaximumOaBufferSize.ValueUInt32 = 1024;
EXPECT_CALL(metricDevice, GetGlobalSymbolValueByName(_))
.WillRepeatedly(testing::Return(&defaultMaximumOaBufferSize));
}
void MetricMultiDeviceFixture::setUp() {
@@ -336,11 +321,6 @@ void MetricMultiDeviceFixture::openMetricsAdapterGroup() {
void MetricMultiDeviceFixture::setupDefaultMocksForMetricDevice(Mock<IMetricsDevice_1_5> &metricDevice) {
EXPECT_CALL(metricDevice, GetParams())
.WillRepeatedly(testing::Return(&metricsDeviceParams));
defaultMaximumOaBufferSize.ValueType = MetricsDiscovery::TValueType::VALUE_TYPE_UINT32;
defaultMaximumOaBufferSize.ValueUInt32 = 1024;
EXPECT_CALL(metricDevice, GetGlobalSymbolValueByName(_))
.WillRepeatedly(testing::Return(&defaultMaximumOaBufferSize));
}
void MetricStreamerMultiDeviceFixture::cleanup(zet_device_handle_t &hDevice, zet_metric_streamer_handle_t &hStreamer) {

43
level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.h
View File

@@ -143,6 +143,45 @@ struct Mock<MetricQuery> : public MetricQuery {
MOCK_METHOD(ze_result_t, destroy, (), (override));
};
class MockIpSamplingOsInterface : public MetricIpSamplingOsInterface {
public:
ze_result_t getMetricsTimerResolutionReturn = ZE_RESULT_SUCCESS;
~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; }
ze_result_t getMetricsTimerResolution(uint64_t &timerResolution) override {
timerResolution = 12500000UL;
return getMetricsTimerResolutionReturn;
}
};
class MockOAOsInterface : public MetricOAOsInterface {
public:
~MockOAOsInterface() override = default;
ze_result_t getMetricsTimerResolutionReturn = ZE_RESULT_SUCCESS;
uint8_t failGetResolutionOnCall = 0;
uint8_t getResolutionCallCount = 0;
ze_result_t getMetricsTimerResolution(uint64_t &timerResolution) override {
ze_result_t retVal;
getResolutionCallCount++;
if ((failGetResolutionOnCall) && (getResolutionCallCount >= failGetResolutionOnCall)) {
timerResolution = 0UL;
retVal = getMetricsTimerResolutionReturn;
} else {
timerResolution = 25000000UL; // PVC as reference
retVal = ZE_RESULT_SUCCESS;
}
return retVal;
}
};
class MetricContextFixture : public DeviceFixture {
protected:
@@ -167,6 +206,8 @@ class MetricContextFixture : public DeviceFixture {
MetricsDiscovery::TMetricsDeviceParams_1_2 metricsDeviceParams = {};
MetricsDiscovery::TTypedValue_1_0 defaultMaximumOaBufferSize = {};
void setupDefaultMocksForMetricDevice(Mock<IMetricsDevice_1_5> &metricDevice);
MockOAOsInterface *mockOAOsInterface;
MockIpSamplingOsInterface *mockIpSamplingOsInterface;
};
class MetricMultiDeviceFixture : public MultiDeviceFixture {
@@ -198,7 +239,7 @@ class MetricMultiDeviceFixture : public MultiDeviceFixture {
Mock<IAdapter_1_9> adapter;
Mock<IMetricsDevice_1_5> metricsDevice;
MetricsDiscovery::TMetricsDeviceParams_1_2 metricsDeviceParams = {};
MetricsDiscovery::TTypedValue_1_0 defaultMaximumOaBufferSize = {};
// MetricsDiscovery::TTypedValue_1_0 defaultMaximumOaBufferSize = {};
void setupDefaultMocksForMetricDevice(Mock<IMetricsDevice_1_5> &metricDevice);
};

26
level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_enumeration.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2022 Intel Corporation
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -109,7 +109,29 @@ class Mock<IMetricsDevice_1_5> : public IMetricsDevice_1_5 {
MOCK_METHOD(IOverride_1_2 *, GetOverrideByName, (const char *symbolName), (override));
MOCK_METHOD(IConcurrentGroup_1_5 *, GetConcurrentGroup, (uint32_t index), (override));
MOCK_METHOD(TGlobalSymbol_1_0 *, GetGlobalSymbol, (uint32_t index), (override));
MOCK_METHOD(TTypedValue_1_0 *, GetGlobalSymbolValueByName, (const char *name), (override));
MetricsDiscovery::TTypedValue_1_0 symbolValue = {};
bool forceGetSymbolByNameFail = false;
TTypedValue_1_0 *GetGlobalSymbolValueByName(const char *name) override {
bool found = false;
if (forceGetSymbolByNameFail) {
return nullptr;
} else if (std::strcmp(name, "OABufferMaxSize") == 0) {
symbolValue.ValueType = MetricsDiscovery::TValueType::VALUE_TYPE_UINT32;
symbolValue.ValueUInt32 = 1024;
found = true;
} else if (std::strcmp(name, "MaxTimestamp") == 0) {
symbolValue.ValueType = MetricsDiscovery::TValueType::VALUE_TYPE_UINT64;
symbolValue.ValueUInt64 = 171798691800UL; // PVC as refference
found = true;
}
if (found) {
return &symbolValue;
}
return nullptr;
}
MOCK_METHOD(TCompletionCode, GetLastError, (), (override));
MOCK_METHOD(TCompletionCode, GetGpuCpuTimestamps, (uint64_t * gpuTimestampNs, uint64_t *cpuTimestampNs, uint32_t *cpuId), (override));
};

89
level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_enumeration.cpp
View File

@@ -11,7 +11,7 @@
#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/source/metrics/os_interface_metric.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_ip_sampling.h"
#include <level_zero/zet_api.h>
@@ -104,7 +104,7 @@ TEST_F(MetricIpSamplingEnumerationTest, GivenDependenciesAvailableWhenMetricGrou
ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
ASSERT_NE(metricGroups[0], nullptr);
zet_metric_group_properties_t metricGroupProperties;
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
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);
@@ -150,7 +150,7 @@ TEST_F(MetricIpSamplingEnumerationTest, GivenDependenciesAvailableWhenMetricGrou
zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data());
ASSERT_NE(metricGroups[0], nullptr);
zet_metric_group_properties_t metricGroupProperties;
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties);
uint32_t metricCount = 0;
@@ -188,7 +188,7 @@ TEST_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulThenDummyAct
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;
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
@@ -197,6 +197,37 @@ TEST_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulThenDummyAct
EXPECT_EQ(zetContextActivateMetricGroups(context->toHandle(), device->toHandle(), 0, nullptr), ZE_RESULT_SUCCESS);
}
}
TEST_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulWhenReadingMetricsFrequencyAndValidBitsThenConfirmAreTheSameAsDevice) {
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
for (auto device : testDevices) {
ze_device_properties_t deviceProps = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES_1_2, nullptr};
device->getProperties(&deviceProps);
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_global_timestamps_resolution_exp_t metricTimestampProperties = {ZET_STRUCTURE_TYPE_GLOBAL_METRICS_TIMESTAMPS_EXP_PROPERTIES, nullptr};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, &metricTimestampProperties};
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.description, "EU stall sampling"), 0);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
EXPECT_EQ(metricTimestampProperties.timerResolution, deviceProps.timerResolution);
EXPECT_EQ(metricTimestampProperties.timestampValidBits, deviceProps.timestampValidBits);
}
}
using MetricIpSamplingCalculateMetricsTest = MetricIpSamplingCalculateMetricsFixture;
TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCalculateMultipleMetricValuesExpIsCalledThenValidDataIsReturned) {
@@ -207,7 +238,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
for (auto device : testDevices) {
auto expectedSetCount = 2u;
ze_device_properties_t props{};
ze_device_properties_t props = {};
device->getProperties(&props);
if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) {
@@ -220,7 +251,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
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;
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
@@ -258,7 +289,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
for (auto device : testDevices) {
ze_device_properties_t props{};
ze_device_properties_t props = {};
device->getProperties(&props);
if ((props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) == 0) {
@@ -269,7 +300,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
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;
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
@@ -298,7 +329,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
for (auto device : testDevices) {
auto expectedSetCount = 2u;
ze_device_properties_t props{};
ze_device_properties_t props = {};
device->getProperties(&props);
if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) {
@@ -310,7 +341,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
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;
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
@@ -345,7 +376,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
std::vector<zet_typed_value_t> metricValues(30);
for (auto device : testDevices) {
ze_device_properties_t props{};
ze_device_properties_t props = {};
device->getProperties(&props);
if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) {
uint32_t metricGroupCount = 0;
@@ -354,7 +385,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
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;
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
@@ -378,7 +409,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
for (auto device : testDevices) {
auto expectedSetCount = 2u;
ze_device_properties_t props{};
ze_device_properties_t props = {};
device->getProperties(&props);
if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) {
@@ -391,7 +422,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
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;
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
@@ -440,7 +471,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
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;
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
@@ -470,7 +501,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, WhenCalculateMultipleMetricValuesEx
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;
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
@@ -506,7 +537,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, WhenCalculateMultipleMetricValuesEx
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;
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
@@ -535,7 +566,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, WhenCalculateMultipleMetricValuesEx
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;
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
@@ -562,7 +593,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
for (auto device : testDevices) {
auto expectedSetCount = 2u;
ze_device_properties_t props{};
ze_device_properties_t props = {};
device->getProperties(&props);
if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) {
@@ -575,7 +606,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
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;
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
@@ -612,7 +643,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
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;
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
@@ -646,7 +677,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
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;
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
@@ -674,7 +705,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
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;
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
@@ -707,7 +738,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWithBad
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;
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
@@ -732,7 +763,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
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;
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
@@ -755,7 +786,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenDataOverflowOccurredWhenStream
for (auto device : testDevices) {
auto expectedSetCount = 2u;
ze_device_properties_t props{};
ze_device_properties_t props = {};
device->getProperties(&props);
if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) {
@@ -767,7 +798,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenDataOverflowOccurredWhenStream
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;
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
@@ -811,7 +842,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWithCAL
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;
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
@@ -837,7 +868,7 @@ TEST_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulWhenQueryPoo
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;
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);

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

@@ -11,7 +11,7 @@
#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/source/metrics/os_interface_metric.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_ip_sampling.h"
#include <level_zero/zet_api.h>

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

@@ -223,7 +223,7 @@ TEST_F(MetricEnumerationTest, givenValidArgumentsWhenZetGetMetricGroupProperties
// One api: metric group handle.
zet_metric_group_handle_t metricGroupHandle = {};
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
openMetricsAdapter();
@@ -393,6 +393,253 @@ TEST_F(MetricEnumerationTest, givenValidArgumentsWhenZetMetricGetIsCalledThenRet
EXPECT_EQ(metricCount, 1u);
}
TEST_F(MetricEnumerationTest, GivenEnumerationIsSuccessfulWhenReadingMetricsFrequencyAndValidBitsThenConfirmExpectedValuesAreReturned) {
// Metrics Discovery device.
metricsDeviceParams.ConcurrentGroupsCount = 1;
// Metrics Discovery concurrent group.
Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
metricsConcurrentGroupParams.MetricSetsCount = 1;
metricsConcurrentGroupParams.SymbolName = "OA";
metricsConcurrentGroupParams.Description = "OA description";
// Metrics Discovery:: metric set.
Mock<MetricsDiscovery::IMetricSet_1_5> metricsSet;
MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
metricsSetParams.MetricsCount = 0;
metricsSetParams.SymbolName = "Metric set name";
metricsSetParams.ShortName = "Metric set description";
// One api: metric group handle.
zet_metric_group_handle_t metricGroupHandle = {};
zet_metric_global_timestamps_resolution_exp_t metricTimestampProperties = {ZET_STRUCTURE_TYPE_GLOBAL_METRICS_TIMESTAMPS_EXP_PROPERTIES, nullptr};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, &metricTimestampProperties};
MetricsDiscovery::TTypedValue_1_0 defaultMaxTimestamp = {};
defaultMaxTimestamp.ValueType = MetricsDiscovery::TValueType::VALUE_TYPE_UINT64;
defaultMaxTimestamp.ValueUInt64 = UINT64_MAX;
openMetricsAdapter();
setupDefaultMocksForMetricDevice(metricsDevice);
EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
.Times(1)
.WillOnce(Return(&metricsConcurrentGroup));
EXPECT_CALL(metricsConcurrentGroup, GetParams())
.Times(1)
.WillRepeatedly(Return(&metricsConcurrentGroupParams));
EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
.WillRepeatedly(Return(&metricsSet));
EXPECT_CALL(metricsSet, GetParams())
.WillRepeatedly(Return(&metricsSetParams));
EXPECT_CALL(metricsSet, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
// Metric group count.
uint32_t metricGroupCount = 0;
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
// Metric group handle.
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
// Metric group properties.
EXPECT_EQ(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupProperties.domain, 0u);
EXPECT_EQ(metricGroupProperties.samplingType, ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED);
EXPECT_EQ(metricGroupProperties.metricCount, metricsSetParams.MetricsCount);
EXPECT_EQ(strcmp(metricGroupProperties.description, metricsSetParams.ShortName), 0);
EXPECT_EQ(strcmp(metricGroupProperties.name, metricsSetParams.SymbolName), 0);
EXPECT_EQ(metricTimestampProperties.timerResolution, 25000000UL);
EXPECT_EQ(metricTimestampProperties.timestampValidBits, 32UL);
}
TEST_F(MetricEnumerationTest, GivenValidMetricGroupWhenReadingPropertiesAndIncorrectStructPassedThenFailsWithInvalidArgument) {
// Metrics Discovery device.
metricsDeviceParams.ConcurrentGroupsCount = 1;
// Metrics Discovery concurrent group.
Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
metricsConcurrentGroupParams.MetricSetsCount = 1;
metricsConcurrentGroupParams.SymbolName = "OA";
metricsConcurrentGroupParams.Description = "OA description";
// Metrics Discovery:: metric set.
Mock<MetricsDiscovery::IMetricSet_1_5> metricsSet;
MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
metricsSetParams.MetricsCount = 0;
metricsSetParams.SymbolName = "Metric set name";
metricsSetParams.ShortName = "Metric set description";
// One api: metric group handle.
zet_metric_group_handle_t metricGroupHandle = {};
zet_metric_properties_t metricProperties = {ZET_STRUCTURE_TYPE_METRIC_PROPERTIES, nullptr};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, &metricProperties};
MetricsDiscovery::TTypedValue_1_0 defaultMaxTimestamp = {};
defaultMaxTimestamp.ValueType = MetricsDiscovery::TValueType::VALUE_TYPE_UINT64;
defaultMaxTimestamp.ValueUInt64 = UINT64_MAX;
openMetricsAdapter();
setupDefaultMocksForMetricDevice(metricsDevice);
EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
.Times(1)
.WillOnce(Return(&metricsConcurrentGroup));
EXPECT_CALL(metricsConcurrentGroup, GetParams())
.Times(1)
.WillRepeatedly(Return(&metricsConcurrentGroupParams));
EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
.WillRepeatedly(Return(&metricsSet));
EXPECT_CALL(metricsSet, GetParams())
.WillRepeatedly(Return(&metricsSetParams));
EXPECT_CALL(metricsSet, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
// Metric group count.
uint32_t metricGroupCount = 0;
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
// Metric group handle.
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
// Metric group properties.
EXPECT_EQ(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_ERROR_INVALID_ARGUMENT);
}
TEST_F(MetricEnumerationTest, GivenValidMetricGroupWhenReadingFrequencyAndInternalFailuresValuesReturnZero) {
// Metrics Discovery device.
metricsDeviceParams.ConcurrentGroupsCount = 1;
// Metrics Discovery concurrent group.
Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
metricsConcurrentGroupParams.MetricSetsCount = 1;
metricsConcurrentGroupParams.SymbolName = "OA";
metricsConcurrentGroupParams.Description = "OA description";
// Metrics Discovery:: metric set.
Mock<MetricsDiscovery::IMetricSet_1_5> metricsSet;
MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
metricsSetParams.MetricsCount = 0;
metricsSetParams.SymbolName = "Metric set name";
metricsSetParams.ShortName = "Metric set description";
// One api: metric group handle.
zet_metric_group_handle_t metricGroupHandle = {};
zet_metric_global_timestamps_resolution_exp_t metricTimestampProperties = {ZET_STRUCTURE_TYPE_GLOBAL_METRICS_TIMESTAMPS_EXP_PROPERTIES, nullptr};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, &metricTimestampProperties};
MetricsDiscovery::TTypedValue_1_0 defaultMaxTimestamp = {};
defaultMaxTimestamp.ValueType = MetricsDiscovery::TValueType::VALUE_TYPE_UINT64;
defaultMaxTimestamp.ValueUInt64 = UINT64_MAX;
openMetricsAdapter();
setupDefaultMocksForMetricDevice(metricsDevice);
EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
.Times(1)
.WillOnce(Return(&metricsConcurrentGroup));
EXPECT_CALL(metricsConcurrentGroup, GetParams())
.Times(1)
.WillRepeatedly(Return(&metricsConcurrentGroupParams));
EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
.WillRepeatedly(Return(&metricsSet));
EXPECT_CALL(metricsSet, GetParams())
.WillRepeatedly(Return(&metricsSetParams));
EXPECT_CALL(metricsSet, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
// Metric group count.
uint32_t metricGroupCount = 0;
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
// Metric group handle.
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
// Metric group properties.
mockOAOsInterface->getMetricsTimerResolutionReturn = ZE_RESULT_ERROR_UNKNOWN;
mockOAOsInterface->failGetResolutionOnCall = 1;
EXPECT_EQ(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_ERROR_UNKNOWN);
EXPECT_EQ(metricGroupProperties.domain, 0u);
EXPECT_EQ(metricGroupProperties.samplingType, ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED);
EXPECT_EQ(metricGroupProperties.metricCount, metricsSetParams.MetricsCount);
EXPECT_EQ(strcmp(metricGroupProperties.description, metricsSetParams.ShortName), 0);
EXPECT_EQ(strcmp(metricGroupProperties.name, metricsSetParams.SymbolName), 0);
EXPECT_EQ(metricTimestampProperties.timerResolution, 0UL);
EXPECT_EQ(metricTimestampProperties.timestampValidBits, 0UL);
mockOAOsInterface->getMetricsTimerResolutionReturn = ZE_RESULT_SUCCESS;
mockOAOsInterface->failGetResolutionOnCall = 0;
metricsDevice.forceGetSymbolByNameFail = true;
EXPECT_EQ(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_ERROR_NOT_AVAILABLE);
EXPECT_EQ(metricGroupProperties.domain, 0u);
EXPECT_EQ(metricGroupProperties.samplingType, ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED);
EXPECT_EQ(metricGroupProperties.metricCount, metricsSetParams.MetricsCount);
EXPECT_EQ(strcmp(metricGroupProperties.description, metricsSetParams.ShortName), 0);
EXPECT_EQ(strcmp(metricGroupProperties.name, metricsSetParams.SymbolName), 0);
EXPECT_EQ(metricTimestampProperties.timerResolution, 0UL);
EXPECT_EQ(metricTimestampProperties.timestampValidBits, 0UL);
metricsDevice.forceGetSymbolByNameFail = false;
mockOAOsInterface->getMetricsTimerResolutionReturn = ZE_RESULT_ERROR_UNKNOWN;
mockOAOsInterface->getResolutionCallCount = 0;
mockOAOsInterface->failGetResolutionOnCall = 2; // getTimestampValidBits() also calls getTimestampValidBits()
EXPECT_EQ(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_ERROR_UNKNOWN);
EXPECT_EQ(metricGroupProperties.domain, 0u);
EXPECT_EQ(metricGroupProperties.samplingType, ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED);
EXPECT_EQ(metricGroupProperties.metricCount, metricsSetParams.MetricsCount);
EXPECT_EQ(strcmp(metricGroupProperties.description, metricsSetParams.ShortName), 0);
EXPECT_EQ(strcmp(metricGroupProperties.name, metricsSetParams.SymbolName), 0);
EXPECT_EQ(metricTimestampProperties.timerResolution, 0UL);
EXPECT_EQ(metricTimestampProperties.timestampValidBits, 0UL);
mockOAOsInterface->getMetricsTimerResolutionReturn = ZE_RESULT_SUCCESS;
mockOAOsInterface->failGetResolutionOnCall = 0;
}
TEST_F(MetricEnumerationTest, givenValidArgumentsWhenZetMetricGetIsCalledThenReturnsCorrectMetric) {
// Metrics Discovery device.
@@ -1060,10 +1307,10 @@ TEST_F(MultiDeviceMetricEnumerationTest, givenMultipleDevicesAndTwoMetricGroupsW
EXPECT_NE(metricGroupHandles[0], nullptr);
EXPECT_NE(metricGroupHandles[1], nullptr);
zet_metric_group_properties_t properties0;
zet_metric_group_properties_t properties0 = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupGetProperties(metricGroupHandles[0], &properties0));
zet_metric_group_properties_t properties1;
zet_metric_group_properties_t properties1 = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupGetProperties(metricGroupHandles[1], &properties1));
// Activate metric groups.
@@ -1246,6 +1493,8 @@ TEST_F(MetricEnumerationTest, givenActivateTwoMetricGroupsWithDifferentDomainsWh
// One api: metric group.
zet_metric_group_handle_t metricGroupHandle[2] = {};
zet_metric_group_properties_t metricGroupProperties[2] = {};
metricGroupProperties[0] = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties[1] = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
openMetricsAdapter();
@@ -1315,6 +1564,8 @@ TEST_F(MetricEnumerationTest, givenActivateTwoMetricGroupsWithDifferentDomainsAt
// One api: metric group.
zet_metric_group_handle_t metricGroupHandle[2] = {};
zet_metric_group_properties_t metricGroupProperties[2] = {};
metricGroupProperties[0] = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties[1] = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
openMetricsAdapter();
@@ -1382,6 +1633,8 @@ TEST_F(MetricEnumerationTest, givenActivateTwoMetricGroupsWithTheSameDomainsWhen
// One api: metric group.
zet_metric_group_handle_t metricGroupHandle[2] = {};
zet_metric_group_properties_t metricGroupProperties[2] = {};
metricGroupProperties[0] = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties[1] = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
openMetricsAdapter();
@@ -1502,6 +1755,8 @@ TEST_F(MetricEnumerationTest, GivenAlreadyActivatedMetricGroupWhenzetContextActi
// One api: metric group.
zet_metric_group_handle_t metricGroupHandle[2] = {};
zet_metric_group_properties_t metricGroupProperties[2] = {};
metricGroupProperties[0] = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties[1] = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
openMetricsAdapter();

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

@@ -256,8 +256,7 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenSubDeviceWhenOpenMetricsDiscoveryI
.Times(1)
.WillRepeatedly(DoAll(::testing::SetArgPointee<1>(&mockDevice), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(mockDevice, GetGlobalSymbolValueByName(_))
.WillRepeatedly(testing::Return(nullptr));
mockDevice.forceGetSymbolByNameFail = true;
EXPECT_EQ(mockMetricEnumerationSubDevices[1]->openMetricsDiscovery(), ZE_RESULT_SUCCESS);
EXPECT_EQ(mockMetricEnumerationSubDevices[1]->getMaxOaBufferSize(), 0u);

34
level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_1.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2022 Intel Corporation
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -26,7 +26,7 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenZetMetricQueryPoolCreateIsC
zet_device_handle_t metricDevice = device->toHandle();
Mock<MetricGroup> metricGroup;
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
zet_metric_query_pool_handle_t poolHandle = {};
@@ -87,7 +87,7 @@ TEST_F(MetricQueryPoolTest, givenIncorrectMetricGroupTypeWhenZetMetricQueryPoolC
zet_device_handle_t metricDevice = device->toHandle();
Mock<MetricGroup> metricGroup;
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED;
zet_metric_query_pool_handle_t poolHandle = {};
@@ -139,7 +139,7 @@ TEST_F(MetricQueryPoolTest, givenIncorrectParameterWhenZetMetricQueryPoolCreateI
zet_device_handle_t metricDevice = device->toHandle();
Mock<MetricGroup> metricGroup;
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
zet_metric_query_pool_handle_t poolHandle = {};
@@ -199,7 +199,7 @@ TEST_F(MetricQueryPoolTest, givenIncorrectContextWhenZetMetricQueryPoolCreateIsC
zet_device_handle_t metricDevice = device->toHandle();
Mock<MetricGroup> metricGroup;
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
zet_metric_query_pool_handle_t poolHandle = {};
@@ -236,7 +236,7 @@ TEST_F(MetricQueryPoolTest, givenIncorrectContextDataWhenZetMetricQueryPoolCreat
zet_device_handle_t metricDevice = device->toHandle();
Mock<MetricGroup> metricGroup;
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
zet_metric_query_pool_handle_t poolHandle = {};
@@ -269,7 +269,7 @@ TEST_F(MetricQueryPoolTest, givenIncorrectGpuReportSizeWhenZetMetricQueryPoolCre
zet_device_handle_t metricDevice = device->toHandle();
Mock<MetricGroup> metricGroup;
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
zet_metric_query_pool_handle_t poolHandle = {};
@@ -329,7 +329,7 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenZetMetricQueryCreateIsCalle
zet_device_handle_t metricDevice = device->toHandle();
Mock<MetricGroup> metricGroup;
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
zet_metric_query_handle_t queryHandle = {};
@@ -400,7 +400,7 @@ TEST_F(MetricQueryPoolTest, givenIncorrectSlotIndexWhenZetMetricQueryCreateIsCal
zet_device_handle_t metricDevice = device->toHandle();
Mock<MetricGroup> metricGroup;
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
zet_metric_query_handle_t queryHandle = {};
@@ -469,7 +469,7 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenZetMetricQueryResetIsCalled
zet_device_handle_t metricDevice = device->toHandle();
Mock<MetricGroup> metricGroup;
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
zet_metric_query_handle_t queryHandle = {};
@@ -543,7 +543,7 @@ TEST_F(MetricQueryPoolTest, givenIncorrectArgumentsWhenZetCommandListAppendMetri
zet_device_handle_t metricDevice = device->toHandle();
Mock<MetricGroup> metricGroup;
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
zet_metric_query_handle_t queryHandle = {};
@@ -620,7 +620,7 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenZetCommandListAppendMetricQ
zet_command_list_handle_t commandListHandle = commandList->toHandle();
Mock<MetricGroup> metricGroup;
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
zet_metric_query_handle_t queryHandle = {};
@@ -786,7 +786,7 @@ TEST_F(MetricQueryPoolTest, givenIncorrectArgumentsWhenZetCommandListAppendMetri
eventDesc.signal = ZE_EVENT_SCOPE_FLAG_DEVICE;
Mock<MetricGroup> metricGroup;
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
zet_metric_query_handle_t queryHandle = {};
@@ -898,7 +898,7 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenZetCommandListAppendMetricQ
Mock<MetricGroup> metricGroup;
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
zet_metric_query_handle_t queryHandle = {};
@@ -1014,7 +1014,7 @@ TEST_F(MetricQueryPoolTest, givenIncorrectArgumentsWhenZetMetricQueryGetDataIsCa
eventDesc.signal = ZE_EVENT_SCOPE_FLAG_DEVICE;
Mock<MetricGroup> metricGroup;
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
zet_metric_query_handle_t queryHandle = {};
@@ -1130,7 +1130,7 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenZetMetricQueryGetDataIsCall
eventDesc.signal = ZE_EVENT_SCOPE_FLAG_DEVICE;
Mock<MetricGroup> metricGroup;
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
zet_metric_query_handle_t queryHandle = {};
@@ -1274,7 +1274,7 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenZetMetricQueryGetDataIsCall
eventDesc.signal = ZE_EVENT_SCOPE_FLAG_DEVICE;
Mock<MetricGroup> metricGroup;
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
uint32_t queriesCount = 10;

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

@@ -37,7 +37,7 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenStreamerIsOpenThenQueryPool
Mock<MetricGroup> metricGroup;
zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricsDeviceParams.ConcurrentGroupsCount = 1;
@@ -636,7 +636,7 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenActivateMetricGroupsIsCalle
zet_metric_group_handle_t metricGroupHandle = {};
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
TypedValue_1_0 value = {};

12
level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_3.cpp
View File

@@ -28,7 +28,7 @@ TEST_F(MetricQueryPoolTest, givenMetricQueryIsActiveWhenMetricQueryPoolDestroyIs
zet_device_handle_t metricDevice = device->toHandle();
Mock<MetricGroup> metricGroup;
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
zet_metric_query_handle_t queryHandle[2] = {};
@@ -136,7 +136,7 @@ TEST_F(MetricQueryPoolTest, givenMetricQueryIsActiveWhenMetricGroupDeactivateIsC
zet_metric_group_handle_t metricGroupHandle = {};
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
zet_metric_query_handle_t queryHandle = {};
@@ -334,7 +334,7 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenCorrectArgumentsWhenZetMetricQueryPo
zet_metric_group_handle_t metricGroupHandle = {};
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
zet_metric_query_handle_t queryHandle = {};
@@ -468,7 +468,7 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenImplicitScalingIsEnabledWhenMetricsA
metricParams.ResultType = MetricsDiscovery::TMetricResultType::RESULT_UINT64;
metricParams.MetricType = MetricsDiscovery::TMetricType::METRIC_TYPE_RATIO;
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
TypedValue_1_0 value = {};
value.Type = ValueType::Uint32;
@@ -571,7 +571,7 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenEnableWalkerPartitionIsOnWhenZetComm
zet_metric_group_handle_t metricGroupHandle = {};
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
zet_metric_query_handle_t queryHandle = {};
@@ -753,7 +753,7 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenFailedMetricsLibraryContextWhenZetMe
zet_metric_group_handle_t metricGroupHandle = {};
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
zet_metric_query_pool_handle_t poolHandle = {};

8
level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_4.cpp
View File

@@ -52,7 +52,7 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenFailedGetDataWhenZetMetricQueryGetDa
zet_metric_group_handle_t metricGroupHandle = {};
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
zet_metric_query_handle_t queryHandle = {};
@@ -215,7 +215,7 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenCorrectArgumentsWhenZetCommandListAp
zet_metric_group_handle_t metricGroupHandle = {};
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
ze_event_pool_handle_t eventPoolHandle = {};
@@ -401,7 +401,7 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenInvalidCommandBufferGetSizeWhenZetCo
zet_metric_group_handle_t metricGroupHandle = {};
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
zet_metric_query_handle_t queryHandle = {};
@@ -549,7 +549,7 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenInvalidCommandBufferGetWhenZetComman
zet_metric_group_handle_t metricGroupHandle = {};
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
zet_metric_query_handle_t queryHandle = {};

6
level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_5.cpp
View File

@@ -65,7 +65,7 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenValidArgumentsWhenZetMetricGroupCalc
zet_metric_group_handle_t metricGroupHandle = {};
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
zet_metric_query_handle_t queryHandle = {};
@@ -239,7 +239,7 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenCorrectArgumentsWhenActivateMetricGr
zet_metric_group_handle_t metricGroupHandle = {};
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
TypedValue_1_0 value = {};
@@ -375,7 +375,7 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenMetricQueryPoolIsDestroyedWhenMetric
zet_metric_group_handle_t metricGroupHandle = {};
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
zet_metric_query_handle_t queryHandle = {};

22
level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_streamer_1.cpp
View File

@@ -39,7 +39,7 @@ TEST_F(MetricStreamerTest, givenInvalidMetricGroupTypeWhenZetMetricStreamerOpenI
// One api: metric group handle.
Mock<MetricGroup> metricGroup;
zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
@@ -67,7 +67,7 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetMetricStreamerOpenIsCalledT
Mock<MetricGroup> metricGroup;
zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricsDeviceParams.ConcurrentGroupsCount = 1;
@@ -167,7 +167,7 @@ TEST_F(MetricStreamerTest, givenRawReportSizeAsZeroWhenZetMetricStreamerOpenIsCa
Mock<MetricGroup> metricGroup;
zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricsDeviceParams.ConcurrentGroupsCount = 1;
@@ -334,7 +334,7 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetMetricStreamerOpenIsCalledT
// One api: metric group handle.
Mock<MetricGroup> metricGroup;
zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
// Metrics Discovery device.
metricsDeviceParams.ConcurrentGroupsCount = 1;
@@ -436,7 +436,7 @@ TEST_F(MetricStreamerTest, givenCorrectArgumentsWhenZetMetricQueryPoolCreateExtI
// One api: metric group handle.
Mock<MetricGroup> metricGroup;
zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
// One api: query pool handle.
@@ -519,7 +519,7 @@ TEST_F(MetricStreamerTest, givenInvalidArgumentsWhenZetMetricStreamerReadDataIsC
// One api: metric group handle.
Mock<MetricGroup> metricGroup;
zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
// Metrics Discovery device.
metricsDeviceParams.ConcurrentGroupsCount = 1;
@@ -616,7 +616,7 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetMetricStreamerReadDataIsCal
// One api: metric group handle.
Mock<MetricGroup> metricGroup;
zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
// Metrics Discovery device.
metricsDeviceParams.ConcurrentGroupsCount = 1;
@@ -721,7 +721,7 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetMetricStreamerReadDataIsCal
streamerDesc.samplingPeriod = 1000;
Mock<MetricGroup> metricGroup;
zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricsDeviceParams.ConcurrentGroupsCount = 1;
Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
@@ -822,7 +822,7 @@ TEST_F(MetricStreamerTest, givenInvalidArgumentsWhenZetCommandListAppendMetricSt
// One api: metric group handle.
Mock<MetricGroup> metricGroup;
zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
// Metrics Discovery device.
metricsDeviceParams.ConcurrentGroupsCount = 1;
@@ -933,7 +933,7 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetCommandListAppendMetricStre
// One api: metric group handle.
Mock<MetricGroup> metricGroup;
zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
// Metrics Discovery device.
metricsDeviceParams.ConcurrentGroupsCount = 1;
@@ -1073,7 +1073,7 @@ TEST_F(MetricStreamerTest, givenMultipleMarkerInsertionsWhenZetCommandListAppend
// One api: metric group handle.
Mock<MetricGroup> metricGroup;
zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
// Metrics Discovery device.
metricsDeviceParams.ConcurrentGroupsCount = 1;

10
level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_streamer_2.cpp
View File

@@ -37,7 +37,7 @@ TEST_F(MetricStreamerMultiDeviceTest, givenInvalidMetricGroupTypeWhenZetMetricSt
Mock<MetricGroup> metricGroup;
zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricsDeviceParams.ConcurrentGroupsCount = 1;
@@ -114,7 +114,7 @@ TEST_F(MetricStreamerMultiDeviceTest, givenValidArgumentsWhenZetMetricStreamerOp
Mock<MetricGroup> metricGroup;
zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricsDeviceParams.ConcurrentGroupsCount = 1;
Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
@@ -202,7 +202,7 @@ TEST_F(MetricStreamerMultiDeviceTest, givenEnableWalkerPartitionIsOnWhenZetMetri
Mock<MetricGroup> metricGroup;
zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricsDeviceParams.ConcurrentGroupsCount = 1;
Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
@@ -379,7 +379,7 @@ TEST_F(MetricStreamerMultiDeviceTest, givenValidArgumentsAndCloseIoStreamFailsWh
Mock<MetricGroup> metricGroup;
zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricsDeviceParams.ConcurrentGroupsCount = 1;
@@ -774,7 +774,7 @@ TEST_F(MetricStreamerMultiDeviceTest, givenMultipleMarkerInsertionsWhenZetComman
Mock<MetricGroup> metricGroup;
zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricsDeviceParams.ConcurrentGroupsCount = 1;

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

@@ -41,7 +41,7 @@ TEST_F(MetricStreamerMultiDeviceTest, givenEnableWalkerPartitionIsOnWhenZetComma
Mock<MetricGroup> metricGroup;
zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
zet_metric_group_properties_t metricGroupProperties = {};
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
metricsDeviceParams.ConcurrentGroupsCount = 1;

7
level_zero/tools/test/unit_tests/sources/metrics/windows/test_metric_ip_sampling_windows.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2022 Intel Corporation
* Copyright (C) 2022-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -8,7 +8,7 @@
#include "shared/test/common/test_macros/hw_test.h"
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
#include "level_zero/tools/source/metrics/os_interface_metric.h"
using ::testing::_;
using ::testing::Return;
@@ -31,7 +31,7 @@ class MetricIpSamplingWindowsTest : public DeviceFixture,
};
TEST_F(MetricIpSamplingWindowsTest, WhenIpSamplingOsInterfaceIsUsedReturnUnsupported) {
uint64_t timerResolution;
EXPECT_FALSE(metricIpSamplingOsInterface->isDependencyAvailable());
EXPECT_FALSE(metricIpSamplingOsInterface->isNReportsAvailable());
EXPECT_EQ(metricIpSamplingOsInterface->getRequiredBufferSize(0), 0);
@@ -40,6 +40,7 @@ TEST_F(MetricIpSamplingWindowsTest, WhenIpSamplingOsInterfaceIsUsedReturnUnsuppo
uint32_t dummy;
EXPECT_EQ(metricIpSamplingOsInterface->startMeasurement(dummy, dummy), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
EXPECT_EQ(metricIpSamplingOsInterface->stopMeasurement(), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
EXPECT_EQ(metricIpSamplingOsInterface->getMetricsTimerResolution(timerResolution), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
} // namespace ult

5
level_zero/tools/test/unit_tests/sources/metrics/windows/test_metric_oa_enumeration_windows.cpp
View File

@@ -42,6 +42,8 @@ TEST_F(MetricEnumerationTestWindows, givenCorrectWindowsAdapterWhenGetMetricsAda
setupDefaultMocksForMetricDevice(metricsDevice);
std::unique_ptr<MetricOAOsInterface> OAOsInterface = MetricOAOsInterface::create(*device);
EXPECT_CALL(adapterGroup, GetParams())
.Times(1)
.WillOnce(Return(&adapterGroupParams));
@@ -61,6 +63,9 @@ TEST_F(MetricEnumerationTestWindows, givenCorrectWindowsAdapterWhenGetMetricsAda
.WillOnce([&]() { return mockMetricEnumeration->baseGetMetricsAdapter(); });
EXPECT_EQ(mockMetricEnumeration->openMetricsDiscovery(), ZE_RESULT_SUCCESS);
uint64_t timerResolution;
EXPECT_EQ(OAOsInterface->getMetricsTimerResolution(timerResolution), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
} // namespace ult
} // namespace L0

5
shared/source/os_interface/linux/drm_neo.cpp
View File

@@ -817,6 +817,11 @@ int Drm::getTimestampFrequency(int &frequency) {
return getParamIoctl(DrmParam::ParamCsTimestampFrequency, &frequency);
}
int Drm::getOATimestampFrequency(int &frequency) {
frequency = 0;
return getParamIoctl(DrmParam::ParamOATimestampFrequency, &frequency);
}
bool Drm::queryEngineInfo() {
return Drm::queryEngineInfo(false);
}

1
shared/source/os_interface/linux/drm_neo.h
View File

@@ -97,6 +97,7 @@ class Drm : public DriverModel {
int getEnabledPooledEu(int &enabled);
int getMinEuInPool(int &minEUinPool);
int getTimestampFrequency(int &frequency);
int getOATimestampFrequency(int &frequency);
MOCKABLE_VIRTUAL int queryGttSize(uint64_t &gttSizeOutput);
bool isPreemptionSupported() const { return preemptionSupported; }

3
shared/source/os_interface/linux/drm_wrappers.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2022 Intel Corporation
* Copyright (C) 2022-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -291,6 +291,7 @@ enum class DrmParam {
ParamSubsliceTotal,
ParamMinEuInPool,
ParamCsTimestampFrequency,
ParamOATimestampFrequency,
ParamHasVmBind,
ParamHasPageFault,
QueryEngineInfo,

4
shared/source/os_interface/linux/ioctl_helper.cpp
View File

@@ -289,6 +289,8 @@ int IoctlHelper::getDrmParamValueBase(DrmParam drmParam) const {
return I915_TILING_NONE;
case DrmParam::TilingY:
return I915_TILING_Y;
case DrmParam::ParamOATimestampFrequency:
return I915_PARAM_OA_TIMESTAMP_FREQUENCY;
default:
UNRECOVERABLE_IF(true);
return 0;
@@ -315,6 +317,8 @@ std::string IoctlHelper::getDrmParamStringBase(DrmParam drmParam) const {
return "I915_PARAM_MIN_EU_IN_POOL";
case DrmParam::ParamCsTimestampFrequency:
return "I915_PARAM_CS_TIMESTAMP_FREQUENCY";
case DrmParam::ParamOATimestampFrequency:
return "I915_PARAM_OA_TIMESTAMP_FREQUENCY";
default:
UNRECOVERABLE_IF(true);
return "";

4
shared/test/common/libult/linux/drm_mock.cpp
View File

@@ -101,6 +101,10 @@ int DrmMock::ioctl(DrmIoctl request, void *arg) {
*gp->value = this->storedCsTimestampFrequency;
return this->storedRetVal;
}
if (gp->param == I915_PARAM_OA_TIMESTAMP_FREQUENCY) {
*gp->value = this->storedOaTimestampFrequency;
return this->storedRetVal;
}
}
if ((request == DrmIoctl::GemContextCreateExt) && (arg != nullptr)) {

1
shared/test/common/libult/linux/drm_mock.h
View File

@@ -200,6 +200,7 @@ class DrmMock : public Drm {
int storedExecSoftPin = 0;
int storedRetValForVmId = 1;
int storedCsTimestampFrequency = 1000;
int storedOaTimestampFrequency = 123456;
bool disableSomeTopology = false;
bool allowDebugAttach = false;
bool allowDebugAttachCallBase = false;

22
shared/test/unit_test/os_interface/linux/drm_tests.cpp
View File

@@ -905,6 +905,28 @@ TEST(DrmTest, givenPrintIoctlDebugFlagNotSetWhenGettingTimestampFrequencyThenCap
EXPECT_EQ(std::string::npos, outputString.find(expectedString));
}
TEST(DrmTest, givenPrintIoctlDebugFlagSetWhenGettingOATimestampFrequencyThenCaptureExpectedOutput) {
DebugManagerStateRestore restore;
DebugManager.flags.PrintIoctlEntries.set(true);
auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
DrmMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
int frequency = 0;
testing::internal::CaptureStdout(); // start capturing
int ret = drm.getOATimestampFrequency(frequency);
DebugManager.flags.PrintIoctlEntries.set(false);
std::string outputString = testing::internal::GetCapturedStdout(); // stop capturing
EXPECT_EQ(0, ret);
EXPECT_EQ(123456, frequency);
std::string expectedString = "DRM_IOCTL_I915_GETPARAM: param: I915_PARAM_OA_TIMESTAMP_FREQUENCY, output value: 123456, retCode: 0";
EXPECT_NE(std::string::npos, outputString.find(expectedString));
}
TEST(DrmTest, givenProgramDebuggingWhenCreatingContextThenUnrecoverableContextIsSet) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->setDebuggingMode(NEO::DebuggingMode::Online);