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

Metric Refactor Metric Context

Browse Source 
Rename Metric Context and move OA specific functions
and members from Metric Context to OA specific class(MetricSource).
This refactoring is done so that additional Metric Source
like Stall Sampling could be Seamlessly implemented.

Related-To: LOCI-2753


Signed-off-by: Joshua Santosh Ranjan <joshua.santosh.ranjan@intel.com>
This commit is contained in:
Joshua Santosh Ranjan
2022-01-12 08:24:41 +00:00
committed by Compute-Runtime-Automation
parent 27c90ac2d6
commit f1c50a8c89
31 changed files with 697 additions and 527 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
level_zero/core/source/cmdlist/cmdlist_imp.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -36,7 +36,8 @@ ze_result_t CommandListImp::destroy() {
}
ze_result_t CommandListImp::appendMetricMemoryBarrier() {
return MetricQuery::appendMemoryBarrier(*this);
return device->getMetricDeviceContext().appendMetricMemoryBarrier(*this);
}
ze_result_t CommandListImp::appendMetricStreamerMarker(zet_metric_streamer_handle_t hMetricStreamer,

4
level_zero/core/source/device/device.h
View File

@@ -36,7 +36,7 @@ namespace L0 {
struct DriverHandle;
struct BuiltinFunctionsLib;
struct ExecutionEnvironment;
struct MetricContext;
class MetricDeviceContext;
struct SysmanDevice;
struct DebugSession;
@@ -103,7 +103,7 @@ struct Device : _ze_device_handle_t {
virtual const NEO::HardwareInfo &getHwInfo() const = 0;
virtual NEO::OSInterface &getOsInterface() = 0;
virtual uint32_t getPlatformInfo() const = 0;
virtual MetricContext &getMetricContext() = 0;
virtual MetricDeviceContext &getMetricDeviceContext() = 0;
virtual DebugSession *getDebugSession(const zet_debug_config_t &config) = 0;
virtual DebugSession *createDebugSession(const zet_debug_config_t &config, ze_result_t &result) = 0;
virtual void removeDebugSession() = 0;

8
level_zero/core/source/device/device_imp.cpp
View File

@@ -734,7 +734,7 @@ ze_result_t DeviceImp::activateMetricGroupsDeferred(uint32_t count,
ze_result_t result = ZE_RESULT_ERROR_UNKNOWN;
if (!this->isSubdevice && this->isImplicitScalingCapable()) {
for (auto subDevice : this->subDevices) {
result = subDevice->getMetricContext().activateMetricGroupsDeferred(count, phMetricGroups);
result = subDevice->getMetricDeviceContext().activateMetricGroupsDeferred(count, phMetricGroups);
if (result != ZE_RESULT_SUCCESS)
break;
}
@@ -764,13 +764,13 @@ uint32_t DeviceImp::getPlatformInfo() const {
return hardwareInfo.platform.eRenderCoreFamily;
}
MetricContext &DeviceImp::getMetricContext() { return *metricContext; }
MetricDeviceContext &DeviceImp::getMetricDeviceContext() { return *metricContext; }
void DeviceImp::activateMetricGroups() {
if (metricContext != nullptr) {
if (metricContext->isImplicitScalingCapable()) {
for (uint32_t i = 0; i < numSubDevices; i++) {
subDevices[i]->getMetricContext().activateMetricGroups();
subDevices[i]->getMetricDeviceContext().activateMetricGroups();
}
} else {
metricContext->activateMetricGroups();
@@ -815,7 +815,7 @@ Device *Device::create(DriverHandle *driverHandle, NEO::Device *neoDevice, bool
device->allocationsForReuse = std::make_unique<NEO::AllocationsList>();
bool platformImplicitScaling = hwHelper.platformSupportsImplicitScaling(hwInfo);
device->implicitScalingCapable = NEO::ImplicitScalingHelper::isImplicitScalingEnabled(neoDevice->getDeviceBitfield(), platformImplicitScaling);
device->metricContext = MetricContext::create(*device);
device->metricContext = MetricDeviceContext::create(*device);
device->builtins = BuiltinFunctionsLib::create(
device, neoDevice->getBuiltIns());
device->cacheReservation = CacheReservation::create(*device);

4
level_zero/core/source/device/device_imp.h
View File

@@ -69,7 +69,7 @@ struct DeviceImp : public Device {
const NEO::HardwareInfo &getHwInfo() const override;
NEO::OSInterface &getOsInterface() override;
uint32_t getPlatformInfo() const override;
MetricContext &getMetricContext() override;
MetricDeviceContext &getMetricDeviceContext() override;
DebugSession *getDebugSession(const zet_debug_config_t &config) override;
DebugSession *createDebugSession(const zet_debug_config_t &config, ze_result_t &result) override;
void removeDebugSession() override { debugSession.release(); }
@@ -104,7 +104,7 @@ struct DeviceImp : public Device {
bool isSubdevice = false;
void *execEnvironment = nullptr;
std::unique_ptr<BuiltinFunctionsLib> builtins = nullptr;
std::unique_ptr<MetricContext> metricContext = nullptr;
std::unique_ptr<MetricDeviceContext> metricContext = nullptr;
std::unique_ptr<CacheReservation> cacheReservation = nullptr;
uint32_t maxNumHwThreads = 0;
uint32_t numSubDevices = 0;

4
level_zero/core/source/driver/driver.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -60,7 +60,7 @@ void DriverImp::initialize(ze_result_t *result) {
*result = ZE_RESULT_SUCCESS;
if (envVariables.metrics) {
*result = MetricContext::enableMetricApi();
*result = MetricDeviceContext::enableMetricApi();
if (*result != ZE_RESULT_SUCCESS) {
delete GlobalDriver;
GlobalDriverHandle = nullptr;

2
level_zero/core/test/unit_tests/mocks/mock_device.h
View File

@@ -62,7 +62,7 @@ struct Mock<Device> : public Device {
ADDMETHOD_NOBASE(activateMetricGroupsDeferred, ze_result_t, ZE_RESULT_SUCCESS, (uint32_t count, zet_metric_group_handle_t *phMetricGroups));
ADDMETHOD_NOBASE_REFRETURN(getOsInterface, NEO::OSInterface &, ());
ADDMETHOD_CONST_NOBASE(getPlatformInfo, uint32_t, 0u, ());
ADDMETHOD_NOBASE_REFRETURN(getMetricContext, MetricContext &, ());
ADDMETHOD_NOBASE_REFRETURN(getMetricDeviceContext, MetricDeviceContext &, ());
ADDMETHOD_CONST_NOBASE_REFRETURN(getHwInfo, const NEO::HardwareInfo &, ());
ADDMETHOD_NOBASE(getDriverHandle, L0::DriverHandle *, nullptr, ());
ADDMETHOD_NOBASE_VOIDRETURN(setDriverHandle, (L0::DriverHandle *));

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

@@ -1,5 +1,5 @@
#
# Copyright (C) 2020-2021 Intel Corporation
# Copyright (C) 2020-2022 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
@@ -12,6 +12,7 @@ list(APPEND L0_SRCS_TOOLS_METRICS
${CMAKE_CURRENT_SOURCE_DIR}/metric_enumeration_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/metric_streamer_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/metric_query_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/metric_source_oa.h
)
if(UNIX)

5
level_zero/tools/source/metrics/linux/os_metric_enumeration_imp_linux.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -10,6 +10,7 @@
#include "shared/source/os_interface/os_interface.h"
#include "level_zero/tools/source/metrics/metric_enumeration_imp.h"
#include "level_zero/tools/source/metrics/metric_source_oa.h"
#include <sys/stat.h>
#include <sys/sysmacros.h>
@@ -20,7 +21,7 @@ const char *MetricEnumeration::getMetricsDiscoveryFilename() { return "libmd.so.
bool MetricEnumeration::getAdapterId(uint32_t &adapterMajor, uint32_t &adapterMinor) {
auto &device = metricContext.getDevice();
auto &device = metricSource.getMetricDeviceContext().getDevice();
auto &osInterface = device.getOsInterface();
auto drm = osInterface.getDriverModel()->as<NEO::Drm>();
auto drmFile = drm->getFileDescriptor();

3
level_zero/tools/source/metrics/linux/os_metric_query_imp_linux.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -10,6 +10,7 @@
#include "level_zero/core/source/device/device.h"
#include "level_zero/tools/source/metrics/metric_query_imp.h"
#include "level_zero/tools/source/metrics/metric_source_oa.h"
using namespace MetricsLibraryApi;

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

@@ -9,102 +9,89 @@
#include "shared/source/os_interface/os_library.h"
#include "level_zero/core/source/device/device.h"
#include "level_zero/core/source/device/device_imp.h"
#include "level_zero/core/source/driver/driver.h"
#include "level_zero/core/source/driver/driver_handle_imp.h"
#include "level_zero/source/inc/ze_intel_gpu.h"
#include "level_zero/tools/source/metrics/metric_enumeration_imp.h"
#include "level_zero/tools/source/metrics/metric_query_imp.h"
#include "level_zero/tools/source/metrics/metric_source_oa.h"
#include <map>
#include <utility>
namespace L0 {
struct MetricGroupDomains {
OaMetricSourceImp::OsLibraryLoadPtr OaMetricSourceImp::osLibraryLoadFunction(NEO::OsLibrary::load);
public:
MetricGroupDomains(MetricContext &metricContext);
ze_result_t activateDeferred(const uint32_t subDeviceIndex, const uint32_t count, zet_metric_group_handle_t *phMetricGroups);
ze_result_t activate();
ze_result_t deactivate();
bool isActivated(const zet_metric_group_handle_t hMetricGroup);
uint32_t getActivatedCount();
protected:
bool activateMetricGroupDeferred(const zet_metric_group_handle_t hMetricGroup);
bool activateEventMetricGroup(const zet_metric_group_handle_t hMetricGroup);
protected:
MetricContext &metricContext;
// Map holds activated domains and associated metric groups.
// Content: <domain number, pair<metric group, is activated on gpu flag>
std::map<uint32_t, std::pair<zet_metric_group_handle_t, bool>> domains;
};
struct MetricContextImp : public MetricContext {
public:
MetricContextImp(Device &device);
~MetricContextImp() override;
bool loadDependencies() override;
bool isInitialized() override;
void setInitializationState(const ze_result_t state) override;
Device &getDevice() override;
MetricsLibrary &getMetricsLibrary() override;
MetricEnumeration &getMetricEnumeration() override;
MetricStreamer *getMetricStreamer() override;
void setMetricStreamer(MetricStreamer *pMetricStreamer) override;
void setMetricsLibrary(MetricsLibrary &metricsLibrary) override;
void setMetricEnumeration(MetricEnumeration &metricEnumeration) override;
ze_result_t activateMetricGroups() override;
ze_result_t activateMetricGroupsDeferred(const uint32_t count,
zet_metric_group_handle_t *phMetricGroups) override;
bool isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) override;
bool isMetricGroupActivated() override;
void setUseCompute(const bool useCompute) override;
bool isComputeUsed() override;
uint32_t getSubDeviceIndex() override;
void setSubDeviceIndex(const uint32_t index) override;
bool isImplicitScalingCapable() override;
protected:
ze_result_t initializationState = ZE_RESULT_ERROR_UNINITIALIZED;
struct Device &device;
std::unique_ptr<MetricEnumeration> metricEnumeration = nullptr;
std::unique_ptr<MetricsLibrary> metricsLibrary = nullptr;
MetricGroupDomains metricGroupDomains;
MetricStreamer *pMetricStreamer = nullptr;
uint32_t subDeviceIndex = 0;
bool useCompute = false;
bool implicitScalingCapable = false;
};
MetricContextImp::MetricContextImp(Device &deviceInput)
: device(deviceInput),
metricEnumeration(std::unique_ptr<MetricEnumeration>(new (std::nothrow) MetricEnumeration(*this))),
metricsLibrary(std::unique_ptr<MetricsLibrary>(new (std::nothrow) MetricsLibrary(*this))),
metricGroupDomains(*this) {
auto deviceNeo = deviceInput.getNEODevice();
bool isSubDevice = deviceNeo->isSubDevice();
subDeviceIndex = isSubDevice
? static_cast<NEO::SubDevice *>(deviceNeo)->getSubDeviceIndex()
: 0;
implicitScalingCapable = !isSubDevice && device.isImplicitScalingCapable();
std::unique_ptr<OaMetricSourceImp> OaMetricSourceImp::create(const MetricDeviceContext &metricDeviceContext) {
return std::unique_ptr<OaMetricSourceImp>(new (std::nothrow) OaMetricSourceImp(metricDeviceContext));
}
MetricContextImp::~MetricContextImp() {
metricsLibrary.reset();
metricEnumeration.reset();
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))) {
}
bool MetricContextImp::loadDependencies() {
OaMetricSourceImp::~OaMetricSourceImp() = default;
bool OaMetricSourceImp::checkDependencies() {
std::unique_ptr<NEO::OsLibrary> library = nullptr;
// Check Metrics Discovery availability.
library.reset(osLibraryLoadFunction(MetricEnumeration::getMetricsDiscoveryFilename()));
if (library == nullptr) {
PRINT_DEBUG_STRING(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Unable to find metrics discovery %s\n", MetricEnumeration::getMetricsDiscoveryFilename());
return false;
}
// Check Metrics Library availability.
library.reset(osLibraryLoadFunction(MetricsLibrary::getFilename()));
if (library == nullptr) {
PRINT_DEBUG_STRING(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Unable to find metrics library %s\n", MetricsLibrary::getFilename());
return false;
}
return true;
}
void OaMetricSourceImp::enable() {
available = false;
if (loadDependencies()) {
available = true;
}
}
bool OaMetricSourceImp::isAvailable() {
return available;
}
ze_result_t OaMetricSourceImp::appendMetricMemoryBarrier(CommandList &commandList) {
DeviceImp *pDeviceImp = static_cast<DeviceImp *>(commandList.device);
if (pDeviceImp->metricContext->isImplicitScalingCapable()) {
// Use one of the sub-device contexts to append to command list.
pDeviceImp = static_cast<DeviceImp *>(pDeviceImp->subDevices[0]);
}
auto &metricContext = pDeviceImp->getMetricDeviceContext();
auto &metricsLibrary = metricContext.getMetricSource<OaMetricSourceImp>().getMetricsLibrary();
// Obtain gpu commands.
CommandBufferData_1_0 commandBuffer = {};
commandBuffer.CommandsType = MetricsLibraryApi::ObjectType::OverrideFlushCaches;
commandBuffer.Override.Enable = true;
commandBuffer.Type = metricContext.getMetricSource<OaMetricSourceImp>().isComputeUsed()
? MetricsLibraryApi::GpuCommandBufferType::Compute
: MetricsLibraryApi::GpuCommandBufferType::Render;
return metricsLibrary.getGpuCommands(commandList, commandBuffer) ? ZE_RESULT_SUCCESS
: ZE_RESULT_ERROR_UNKNOWN;
}
bool OaMetricSourceImp::loadDependencies() {
bool result = true;
if (metricEnumeration->loadMetricsDiscovery() != ZE_RESULT_SUCCESS) {
result = false;
@@ -122,80 +109,224 @@ bool MetricContextImp::loadDependencies() {
return result;
}
bool MetricContextImp::isInitialized() {
bool OaMetricSourceImp::isInitialized() {
return initializationState == ZE_RESULT_SUCCESS;
}
void MetricContextImp::setInitializationState(const ze_result_t state) {
void OaMetricSourceImp::setInitializationState(const ze_result_t state) {
initializationState = state;
}
Device &MetricContextImp::getDevice() { return device; }
Device &OaMetricSourceImp::getDevice() {
return metricDeviceContext.getDevice();
}
MetricsLibrary &MetricContextImp::getMetricsLibrary() { return *metricsLibrary; }
MetricsLibrary &OaMetricSourceImp::getMetricsLibrary() {
return *metricsLibrary;
}
MetricEnumeration &OaMetricSourceImp::getMetricEnumeration() {
return *metricEnumeration;
}
MetricStreamer *OaMetricSourceImp::getMetricStreamer() {
return pMetricStreamer;
}
MetricEnumeration &MetricContextImp::getMetricEnumeration() { return *metricEnumeration; }
MetricStreamer *MetricContextImp::getMetricStreamer() { return pMetricStreamer; }
void MetricContextImp::setMetricStreamer(MetricStreamer *pMetricStreamer) {
void OaMetricSourceImp::setMetricStreamer(MetricStreamer *pMetricStreamer) {
this->pMetricStreamer = pMetricStreamer;
}
void MetricContextImp::setMetricsLibrary(MetricsLibrary &metricsLibrary) {
void OaMetricSourceImp::setMetricsLibrary(MetricsLibrary &metricsLibrary) {
this->metricsLibrary.release();
this->metricsLibrary.reset(&metricsLibrary);
}
void MetricContextImp::setMetricEnumeration(MetricEnumeration &metricEnumeration) {
void OaMetricSourceImp::setMetricEnumeration(MetricEnumeration &metricEnumeration) {
this->metricEnumeration.release();
this->metricEnumeration.reset(&metricEnumeration);
}
void MetricContextImp::setUseCompute(const bool useCompute) {
void OaMetricSourceImp::setUseCompute(const bool useCompute) {
this->useCompute = useCompute;
}
bool MetricContextImp::isComputeUsed() {
bool OaMetricSourceImp::isComputeUsed() const {
return useCompute;
}
uint32_t MetricContextImp::getSubDeviceIndex() {
return subDeviceIndex;
ze_result_t OaMetricSourceImp::metricGroupGet(uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups) {
return getMetricEnumeration().metricGroupGet(*pCount, phMetricGroups);
}
void MetricContextImp::setSubDeviceIndex(const uint32_t index) {
subDeviceIndex = index;
uint32_t OaMetricSourceImp::getSubDeviceIndex() {
return metricDeviceContext.getSubDeviceIndex();
}
bool MetricContextImp::isImplicitScalingCapable() {
return implicitScalingCapable;
bool OaMetricSourceImp::isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) const {
return metricDeviceContext.isMetricGroupActivated(hMetricGroup);
}
ze_result_t
MetricContextImp::activateMetricGroupsDeferred(const uint32_t count,
zet_metric_group_handle_t *phMetricGroups) {
bool OaMetricSourceImp::isMetricGroupActivated() const {
return metricDeviceContext.isMetricGroupActivated();
}
bool OaMetricSourceImp::isImplicitScalingCapable() const {
return metricDeviceContext.isImplicitScalingCapable();
}
std::unique_ptr<MetricDeviceContext> MetricDeviceContext::create(Device &device) {
return std::make_unique<MetricDeviceContext>(device);
}
MetricDeviceContext::MetricDeviceContext(Device &inputDevice) : device(inputDevice) {
auto deviceNeo = device.getNEODevice();
bool isSubDevice = deviceNeo->isSubDevice();
subDeviceIndex = isSubDevice
? static_cast<NEO::SubDevice *>(deviceNeo)->getSubDeviceIndex()
: 0;
multiDeviceCapable = !isSubDevice && device.isImplicitScalingCapable();
metricSources[MetricSource::SourceType::Oa] = OaMetricSourceImp::create(*this);
}
bool MetricDeviceContext::enable() {
bool status = false;
for (auto const &entry : metricSources) {
auto const &metricSource = entry.second;
metricSource->enable();
status |= metricSource->isAvailable();
}
return status;
}
ze_result_t MetricDeviceContext::metricGroupGet(uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups) {
ze_result_t result = ZE_RESULT_SUCCESS;
uint32_t availableCount = 0;
uint32_t requestCount = *pCount;
for (auto const &entry : metricSources) {
auto const &metricSource = entry.second;
result = metricSource->metricGroupGet(&requestCount, phMetricGroups);
if (result != ZE_RESULT_SUCCESS) {
break;
}
availableCount += requestCount;
if (*pCount == 0) {
requestCount = 0;
} else {
DEBUG_BREAK_IF(availableCount > *pCount);
phMetricGroups += requestCount;
requestCount = *pCount - availableCount;
if (requestCount == 0) {
break;
}
}
}
*pCount = availableCount;
return result;
}
ze_result_t MetricDeviceContext::activateMetricGroupsDeferred(uint32_t count, zet_metric_group_handle_t *phMetricGroups) {
// Activation: postpone until zetMetricStreamerOpen or zeCommandQueueExecuteCommandLists
// Deactivation: execute immediately.
return phMetricGroups ? metricGroupDomains.activateDeferred(subDeviceIndex, count, phMetricGroups)
: metricGroupDomains.deactivate();
if (phMetricGroups == nullptr) {
return deActivateAllDomains();
}
for (auto index = 0u; index < count; index++) {
zet_metric_group_handle_t hMetricGroup = MetricGroup::fromHandle(phMetricGroups[index])->getMetricGroupForSubDevice(subDeviceIndex);
auto domain = MetricGroup::getProperties(hMetricGroup).domain;
// Domain already associated with the same handle.
if (domains[domain].first == hMetricGroup) {
continue;
}
// Domain empty; So create new deactiavted association.
if (domains[domain].first == nullptr) {
domains[domain].first = hMetricGroup;
domains[domain].second = false;
continue;
}
// Attempt to overwrite a previous association is an error.
return ZE_RESULT_ERROR_UNKNOWN;
}
return ZE_RESULT_SUCCESS;
}
bool MetricContextImp::isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) {
return metricGroupDomains.isActivated(hMetricGroup);
ze_result_t MetricDeviceContext::activateAllDomains() {
for (auto &entry : domains) {
auto &metricGroup = entry.second;
MetricGroup::fromHandle(metricGroup.first)->activate();
metricGroup.second = true;
}
return ZE_RESULT_SUCCESS;
}
bool MetricContextImp::isMetricGroupActivated() {
return metricGroupDomains.getActivatedCount() > 0;
ze_result_t MetricDeviceContext::deActivateAllDomains() {
for (auto &entry : domains) {
auto &metricGroup = entry.second;
if (metricGroup.second == true) {
MetricGroup::fromHandle(metricGroup.first)->deactivate();
}
metricGroup = {};
}
return ZE_RESULT_SUCCESS;
}
ze_result_t MetricContextImp::activateMetricGroups() { return metricGroupDomains.activate(); }
ze_result_t MetricDeviceContext::appendMetricMemoryBarrier(CommandList &commandList) {
ze_result_t result = ZE_RESULT_SUCCESS;
for (auto const &entry : metricSources) {
auto const &metricSource = entry.second;
ze_result_t MetricContext::enableMetricApi() {
result = metricSource->appendMetricMemoryBarrier(commandList);
if (result != ZE_RESULT_SUCCESS) {
return result;
}
}
return result;
}
if (!isMetricApiAvailable()) {
bool MetricDeviceContext::isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) const {
for (auto const &entry : domains) {
auto const &metricGroup = entry.second;
if (metricGroup.first == hMetricGroup) {
return true;
}
}
return false;
}
bool MetricDeviceContext::isMetricGroupActivated() const {
for (auto const &entry : domains) {
auto const &metricGroup = entry.second;
if (metricGroup.second == true) {
return true;
}
}
return false;
}
bool MetricDeviceContext::isImplicitScalingCapable() const {
return multiDeviceCapable;
}
ze_result_t MetricDeviceContext::activateMetricGroups() {
return activateAllDomains();
}
uint32_t MetricDeviceContext::getSubDeviceIndex() const {
return subDeviceIndex;
}
Device &MetricDeviceContext::getDevice() const {
return device;
}
ze_result_t MetricDeviceContext::enableMetricApi() {
if (!OaMetricSourceImp::checkDependencies()) {
return ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
}
@@ -212,14 +343,17 @@ ze_result_t MetricContext::enableMetricApi() {
driverHandle->getDevice(&rootDeviceCount, rootDevices.data());
for (auto rootDeviceHandle : rootDevices) {
// Initialize root device.
auto rootDevice = static_cast<DeviceImp *>(L0::Device::fromHandle(rootDeviceHandle));
failed |= !rootDevice->metricContext->loadDependencies();
// Initialize root device.
failed |= !rootDevice->metricContext->enable();
if (failed) {
continue;
}
// Initialize sub devices.
for (uint32_t i = 0; i < rootDevice->numSubDevices; ++i) {
failed |= !rootDevice->subDevices[i]->getMetricContext().loadDependencies();
failed |= !rootDevice->subDevices[i]->getMetricDeviceContext().enable();
}
}
@@ -228,181 +362,9 @@ ze_result_t MetricContext::enableMetricApi() {
: ZE_RESULT_SUCCESS;
}
std::unique_ptr<MetricContext> MetricContext::create(Device &device) {
auto metricContextImp = new (std::nothrow) MetricContextImp(device);
std::unique_ptr<MetricContext> metricContext{metricContextImp};
return metricContext;
}
bool MetricContext::isMetricApiAvailable() {
std::unique_ptr<NEO::OsLibrary> library = nullptr;
// Check Metrics Discovery availability.
library.reset(NEO::OsLibrary::load(MetricEnumeration::getMetricsDiscoveryFilename()));
if (library == nullptr) {
PRINT_DEBUG_STRING(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Unable to find metrics discovery %s\n", MetricEnumeration::getMetricsDiscoveryFilename());
return false;
}
// Check Metrics Library availability.
library.reset(NEO::OsLibrary::load(MetricsLibrary::getFilename()));
if (library == nullptr) {
PRINT_DEBUG_STRING(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Unable to find metrics library %s\n", MetricsLibrary::getFilename());
return false;
}
return true;
}
MetricGroupDomains::MetricGroupDomains(MetricContext &metricContext)
: metricContext(metricContext) {}
ze_result_t MetricGroupDomains::activateDeferred(const uint32_t subDeviceIndex,
const uint32_t count,
zet_metric_group_handle_t *phMetricGroups) {
// For each metric group:
for (uint32_t i = 0; i < count; ++i) {
DEBUG_BREAK_IF(!phMetricGroups[i]);
zet_metric_group_handle_t handle = phMetricGroups[i];
auto pMetricGroupImp = static_cast<OaMetricGroupImp *>(MetricGroup::fromHandle(handle));
if (pMetricGroupImp->getMetricGroups().size() > 0) {
handle = pMetricGroupImp->getMetricGroups()[subDeviceIndex];
}
// Try to associate it with a domain (oa, ...).
if (!activateMetricGroupDeferred(handle)) {
return ZE_RESULT_ERROR_UNKNOWN;
}
}
return ZE_RESULT_SUCCESS;
}
bool MetricGroupDomains::activateMetricGroupDeferred(const zet_metric_group_handle_t hMetricGroup) {
const auto properites = MetricGroup::getProperties(hMetricGroup);
const auto domain = properites.domain;
const bool isDomainFree = domains[domain].first == nullptr;
const bool isSameGroup = domains[domain].first == hMetricGroup;
// The same metric group has been already associated.
if (isSameGroup) {
return true;
}
// Domain has been already associated with a different metric group.
if (!isDomainFree) {
return false;
}
// Associate metric group with domain and mark it as not active.
// Activation will be performed during zeCommandQueueExecuteCommandLists (query)
// or zetMetricStreamerOpen (time based sampling).
domains[domain].first = hMetricGroup;
domains[domain].second = false;
return true;
}
ze_result_t MetricGroupDomains::activate() {
// For each domain.
for (auto &domain : domains) {
auto hMetricGroup = domain.second.first;
bool &metricGroupActive = domain.second.second;
bool metricGroupEventBased =
hMetricGroup && MetricGroup::getProperties(hMetricGroup).samplingType ==
ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
// Activate only event based metric groups.
// Time based metric group will be activated during zetMetricStreamerOpen.
if (metricGroupEventBased && !metricGroupActive) {
metricGroupActive = activateEventMetricGroup(hMetricGroup);
if (metricGroupActive == false) {
DEBUG_BREAK_IF(true);
return ZE_RESULT_ERROR_UNKNOWN;
}
}
}
return ZE_RESULT_SUCCESS;
}
bool MetricGroupDomains::activateEventMetricGroup(const zet_metric_group_handle_t hMetricGroup) {
// Obtain metric group configuration handle from metrics library.
auto hConfiguration = metricContext.getMetricsLibrary().getConfiguration(hMetricGroup);
// Validate metrics library handle.
if (!hConfiguration.IsValid()) {
DEBUG_BREAK_IF(true);
return false;
}
// Write metric group configuration to gpu.
const bool result = metricContext.getMetricsLibrary().activateConfiguration(hConfiguration);
DEBUG_BREAK_IF(!result);
return result;
}
ze_result_t MetricGroupDomains::deactivate() {
// Deactivate metric group for each domain.
for (auto &domain : domains) {
auto hMetricGroup = domain.second.first;
bool metricGroupActivatedOnGpu = domain.second.second;
if (metricGroupActivatedOnGpu) {
// Only event based metric groups are activated on Gpu.
DEBUG_BREAK_IF(MetricGroup::getProperties(hMetricGroup).samplingType != ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED);
auto hConfiguration = metricContext.getMetricsLibrary().getConfiguration(hMetricGroup);
// Deactivate metric group configuration using metrics library.
metricContext.getMetricsLibrary().deactivateConfiguration(hConfiguration);
}
// Mark domain as free.
domain.second = {};
}
// Check any open queries.
if (metricContext.getMetricsLibrary().getMetricQueryCount() == 0) {
if (metricContext.getMetricsLibrary().getInitializationState() != ZE_RESULT_ERROR_UNINITIALIZED) {
metricContext.getMetricsLibrary().release();
}
}
return ZE_RESULT_SUCCESS;
}
bool MetricGroupDomains::isActivated(const zet_metric_group_handle_t hMetricGroup) {
auto metricGroupProperties = MetricGroup::getProperties(hMetricGroup);
// 1. Check whether domain is activated.
const auto domain = domains.find(metricGroupProperties.domain);
if (domain == domains.end()) {
return false;
}
// 2. Check whether the specific MetricGroup is activated.
return domain->second.first == hMetricGroup;
}
uint32_t MetricGroupDomains::getActivatedCount() {
uint32_t count = 0;
for (const auto &domain : domains) {
count += domain.second.second ? 1 : 0;
}
return count;
}
ze_result_t metricGroupGet(zet_device_handle_t hDevice, uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups) {
auto device = Device::fromHandle(hDevice);
return device->getMetricContext().getMetricEnumeration().metricGroupGet(*pCount,
phMetricGroups);
return device->getMetricDeviceContext().metricGroupGet(pCount, phMetricGroups);
}
ze_result_t metricStreamerOpen(zet_context_handle_t hContext, zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup,
@@ -412,4 +374,9 @@ ze_result_t metricStreamerOpen(zet_context_handle_t hContext, zet_device_handle_
return MetricStreamer::open(hContext, hDevice, hMetricGroup, *pDesc, hNotificationEvent, phMetricStreamer);
}
template <>
OaMetricSourceImp &MetricDeviceContext::getMetricSource<OaMetricSourceImp>() const {
return static_cast<OaMetricSourceImp &>(*metricSources.at(MetricSource::SourceType::Oa));
}
} // namespace L0

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

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -20,41 +20,51 @@ struct _zet_metric_query_pool_handle_t {};
struct _zet_metric_query_handle_t {};
namespace L0 {
struct MetricsLibrary;
struct CommandList;
struct MetricEnumeration;
struct MetricStreamer;
struct MetricContext {
virtual ~MetricContext() = default;
static std::unique_ptr<MetricContext> create(struct Device &device);
static bool isMetricApiAvailable();
virtual bool loadDependencies() = 0;
virtual bool isInitialized() = 0;
virtual void setInitializationState(const ze_result_t state) = 0;
virtual Device &getDevice() = 0;
virtual MetricsLibrary &getMetricsLibrary() = 0;
virtual MetricEnumeration &getMetricEnumeration() = 0;
virtual MetricStreamer *getMetricStreamer() = 0;
virtual void setMetricStreamer(MetricStreamer *pMetricStreamer) = 0;
virtual void setMetricsLibrary(MetricsLibrary &metricsLibrary) = 0;
virtual void setMetricEnumeration(MetricEnumeration &metricEnumeration) = 0;
class MetricSource {
public:
enum class SourceType {
Undefined,
Oa
};
virtual void enable() = 0;
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 ~MetricSource() = default;
};
// Called by zeInit.
class MetricDeviceContext {
public:
MetricDeviceContext(Device &device);
ze_result_t metricGroupGet(uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups);
ze_result_t activateMetricGroupsDeferred(uint32_t count, zet_metric_group_handle_t *phMetricGroups);
ze_result_t activateMetricGroups();
ze_result_t appendMetricMemoryBarrier(CommandList &commandList);
bool isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) const;
bool isMetricGroupActivated() const;
bool isImplicitScalingCapable() const;
Device &getDevice() const;
uint32_t getSubDeviceIndex() const;
template <typename T>
T &getMetricSource() const;
void setSubDeviceIndex(uint32_t subDeviceIndex) { this->subDeviceIndex = subDeviceIndex; }
static std::unique_ptr<MetricDeviceContext> create(Device &device);
static ze_result_t enableMetricApi();
// Metric groups activation.
virtual ze_result_t activateMetricGroups() = 0;
virtual ze_result_t activateMetricGroupsDeferred(const uint32_t count,
zet_metric_group_handle_t *phMetricGroups) = 0;
virtual bool isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) = 0;
virtual bool isMetricGroupActivated() = 0;
virtual void setUseCompute(const bool useCompute) = 0;
virtual bool isComputeUsed() = 0;
virtual uint32_t getSubDeviceIndex() = 0;
virtual void setSubDeviceIndex(const uint32_t index) = 0;
virtual bool isImplicitScalingCapable() = 0;
private:
bool enable();
ze_result_t activateAllDomains();
ze_result_t deActivateAllDomains();
struct Device &device;
std::map<uint32_t, std::pair<zet_metric_group_handle_t, bool>> domains;
bool multiDeviceCapable = false;
uint32_t subDeviceIndex = 0;
std::map<MetricSource::SourceType, std::unique_ptr<MetricSource>> metricSources;
};
struct Metric : _zet_metric_handle_t {
@@ -83,7 +93,8 @@ struct MetricGroup : _zet_metric_group_handle_t {
static MetricGroup *create(zet_metric_group_properties_t &properties,
MetricsDiscovery::IMetricSet_1_5 &metricSet,
MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup,
const std::vector<Metric *> &metrics);
const std::vector<Metric *> &metrics,
MetricSource &metricSource);
static MetricGroup *fromHandle(zet_metric_group_handle_t handle) {
return static_cast<MetricGroup *>(handle);
}
@@ -95,6 +106,7 @@ struct MetricGroup : _zet_metric_group_handle_t {
virtual bool activate() = 0;
virtual bool deactivate() = 0;
virtual zet_metric_group_handle_t getMetricGroupForSubDevice(const uint32_t subDeviceIndex) = 0;
virtual ze_result_t openIoStream(uint32_t &timerPeriodNs, uint32_t &oaBufferSize) = 0;
virtual ze_result_t waitForReports(const uint32_t timeoutMs) = 0;
@@ -149,11 +161,8 @@ struct MetricQuery : _zet_metric_query_handle_t {
virtual ze_result_t appendBegin(CommandList &commandList) = 0;
virtual ze_result_t appendEnd(CommandList &commandList, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) = 0;
static ze_result_t appendMemoryBarrier(CommandList &commandList);
static ze_result_t appendStreamerMarker(CommandList &commandList,
zet_metric_streamer_handle_t hMetricStreamer, uint32_t value);
virtual ze_result_t getData(size_t *pRawDataSize, uint8_t *pRawData) = 0;
virtual ze_result_t reset() = 0;

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

@@ -12,6 +12,8 @@
#include "shared/source/os_interface/os_library.h"
#include "level_zero/core/source/device/device_imp.h"
#include "level_zero/tools/source/metrics/metric_query_imp.h"
#include "level_zero/tools/source/metrics/metric_source_oa.h"
#include <algorithm>
@@ -19,8 +21,8 @@ namespace L0 {
const char *MetricEnumeration::oaConcurrentGroupName = "OA";
MetricEnumeration::MetricEnumeration(MetricContext &metricContextInput)
: metricContext(metricContextInput) {}
MetricEnumeration::MetricEnumeration(OaMetricSourceImp &metricSourceInput)
: metricSource(metricSourceInput) {}
MetricEnumeration::~MetricEnumeration() {
cleanupMetricsDiscovery();
@@ -82,7 +84,7 @@ ze_result_t MetricEnumeration::initialize() {
ze_result_t MetricEnumeration::loadMetricsDiscovery() {
// Load library.
hMetricsDiscovery.reset(NEO::OsLibrary::load(getMetricsDiscoveryFilename()));
hMetricsDiscovery.reset(OaMetricSourceImp::osLibraryLoadFunction(getMetricsDiscoveryFilename()));
// Load exported functions.
if (hMetricsDiscovery) {
@@ -103,7 +105,7 @@ ze_result_t MetricEnumeration::loadMetricsDiscovery() {
ze_result_t MetricEnumeration::openMetricsDiscovery() {
UNRECOVERABLE_IF(openAdapterGroup == nullptr);
const uint32_t subDeviceIndex = metricContext.getSubDeviceIndex();
const uint32_t subDeviceIndex = metricSource.getSubDeviceIndex();
// Clean up members.
pAdapterGroup = nullptr;
@@ -126,16 +128,16 @@ ze_result_t MetricEnumeration::openMetricsDiscovery() {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
auto &device = metricContext.getDevice();
auto &device = metricSource.getDevice();
const auto &deviceImp = *static_cast<DeviceImp *>(&device);
if (metricContext.isImplicitScalingCapable()) {
if (metricSource.isImplicitScalingCapable()) {
// Open metrics device for each sub device.
for (size_t i = 0; i < deviceImp.numSubDevices; i++) {
auto &metricsDevice = deviceImp.subDevices[i]->getMetricContext().getMetricEnumeration().pMetricsDevice;
auto &metricsDevice = deviceImp.subDevices[i]->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>().getMetricEnumeration().pMetricsDevice;
pAdapter->OpenMetricsSubDevice(static_cast<uint32_t>(i), &metricsDevice);
deviceImp.subDevices[i]->getMetricContext().getMetricEnumeration().pAdapter = pAdapter;
deviceImp.subDevices[i]->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>().getMetricEnumeration().pAdapter = pAdapter;
if (metricsDevice == nullptr) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "unable to open metrics device %u\n", i);
@@ -165,12 +167,12 @@ ze_result_t MetricEnumeration::openMetricsDiscovery() {
ze_result_t MetricEnumeration::cleanupMetricsDiscovery() {
if (pAdapter) {
auto &device = metricContext.getDevice();
auto &device = metricSource.getDevice();
const auto &deviceImp = *static_cast<DeviceImp *>(&device);
if (metricContext.isImplicitScalingCapable()) {
if (metricSource.isImplicitScalingCapable()) {
for (size_t i = 0; i < deviceImp.numSubDevices; i++) {
deviceImp.subDevices[i]->getMetricContext().getMetricEnumeration().cleanupMetricsDiscovery();
deviceImp.subDevices[i]->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>().getMetricEnumeration().cleanupMetricsDiscovery();
}
} else if (pMetricsDevice) {
@@ -199,29 +201,29 @@ ze_result_t MetricEnumeration::cleanupMetricsDiscovery() {
ze_result_t MetricEnumeration::cacheMetricInformation() {
auto &device = metricContext.getDevice();
auto &device = metricSource.getDevice();
const auto &deviceImp = *static_cast<DeviceImp *>(&device);
if (metricContext.isImplicitScalingCapable()) {
if (metricSource.isImplicitScalingCapable()) {
ze_result_t result = ZE_RESULT_SUCCESS;
// Get metric information from all sub devices.
for (auto subDevice : deviceImp.subDevices) {
result = subDevice->getMetricContext().getMetricEnumeration().cacheMetricInformation();
result = subDevice->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>().getMetricEnumeration().cacheMetricInformation();
if (ZE_RESULT_SUCCESS != result) {
return result;
}
}
// Get metric groups count for one sub device.
const uint32_t metricGroupCount = deviceImp.subDevices[0]->getMetricContext().getMetricEnumeration().getMetricGroupCount();
const uint32_t metricGroupCount = deviceImp.subDevices[0]->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>().getMetricEnumeration().getMetricGroupCount();
// Cache and aggregate all metric groups from all sub devices.
for (uint32_t i = 0; i < metricGroupCount; i++) {
auto metricGroupRootDevice = new OaMetricGroupImp();
for (auto subDevice : deviceImp.subDevices) {
MetricGroup *metricGroupSubDevice = subDevice->getMetricContext().getMetricEnumeration().getMetricGroupByIndex(i);
MetricGroup *metricGroupSubDevice = subDevice->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>().getMetricEnumeration().getMetricGroupByIndex(i);
metricGroupRootDevice->getMetricGroups().push_back(metricGroupSubDevice);
}
@@ -311,7 +313,7 @@ MetricEnumeration::cacheMetricGroup(MetricsDiscovery::IMetricSet_1_5 &metricSet,
std::vector<Metric *> metrics;
createMetrics(metricSet, metrics);
auto pMetricGroup = MetricGroup::create(properties, metricSet, concurrentGroup, metrics);
auto pMetricGroup = MetricGroup::create(properties, metricSet, concurrentGroup, metrics, metricSource);
DEBUG_BREAK_IF(pMetricGroup == nullptr);
metricGroups.push_back(pMetricGroup);
@@ -525,13 +527,52 @@ ze_result_t OaMetricGroupImp::getMetric(uint32_t *pCount, zet_metric_handle_t *p
}
bool OaMetricGroupImp::activate() {
if (properties.samplingType != ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED) {
return true;
}
auto hConfiguration = metricSource->getMetricsLibrary().getConfiguration(toHandle());
// Validate metrics library handle.
if (!hConfiguration.IsValid()) {
DEBUG_BREAK_IF(true);
return false;
}
// Write metric group configuration to gpu.
const bool result = metricSource->getMetricsLibrary().activateConfiguration(hConfiguration);
DEBUG_BREAK_IF(!result);
return result;
}
bool OaMetricGroupImp::deactivate() {
if (properties.samplingType != ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED) {
return true;
}
auto hConfiguration = metricSource->getMetricsLibrary().getConfiguration(toHandle());
// Deactivate metric group configuration using metrics library.
metricSource->getMetricsLibrary().deactivateConfiguration(hConfiguration);
// Release Metrics Library is not used.
if (metricSource->getMetricsLibrary().getMetricQueryCount() == 0) {
if (metricSource->getMetricsLibrary().getInitializationState() != ZE_RESULT_ERROR_UNINITIALIZED) {
metricSource->getMetricsLibrary().release();
}
}
return true;
}
bool OaMetricGroupImp::activateMetricSet() {
DEBUG_BREAK_IF(pReferenceMetricSet == nullptr);
const bool result = pReferenceMetricSet->Activate() == MetricsDiscovery::CC_OK;
DEBUG_BREAK_IF(!result);
return result;
}
bool OaMetricGroupImp::deactivate() {
bool OaMetricGroupImp::deactivateMetricSet() {
DEBUG_BREAK_IF(pReferenceMetricSet == nullptr);
const bool result = pReferenceMetricSet->Deactivate() == MetricsDiscovery::CC_OK;
return result;
@@ -550,6 +591,13 @@ uint32_t OaMetricGroupImp::getApiMask(const zet_metric_group_sampling_type_flags
}
}
zet_metric_group_handle_t OaMetricGroupImp::getMetricGroupForSubDevice(const uint32_t subDeviceIndex) {
if (metricGroups.size() > 0) {
return metricGroups[subDeviceIndex];
}
return toHandle();
}
ze_result_t OaMetricGroupImp::openIoStream(uint32_t &timerPeriodNs, uint32_t &oaBufferSize) {
const auto openResult = pReferenceConcurrentGroup->OpenIoStream(pReferenceMetricSet, 0,
&timerPeriodNs, &oaBufferSize);
@@ -780,11 +828,13 @@ bool OaMetricGroupImp::getCalculatedMetricValues(const zet_metric_group_calculat
ze_result_t OaMetricGroupImp::initialize(const zet_metric_group_properties_t &sourceProperties,
MetricsDiscovery::IMetricSet_1_5 &metricSet,
MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup,
const std::vector<Metric *> &groupMetrics) {
const std::vector<Metric *> &groupMetrics,
OaMetricSourceImp &metricSource) {
copyProperties(sourceProperties, properties);
pReferenceMetricSet = &metricSet;
pReferenceConcurrentGroup = &concurrentGroup;
metrics = groupMetrics;
this->metricSource = &metricSource;
return ZE_RESULT_SUCCESS;
}
@@ -869,10 +919,11 @@ void OaMetricImp::copyProperties(const zet_metric_properties_t &source,
MetricGroup *MetricGroup::create(zet_metric_group_properties_t &properties,
MetricsDiscovery::IMetricSet_1_5 &metricSet,
MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup,
const std::vector<Metric *> &metrics) {
const std::vector<Metric *> &metrics,
MetricSource &metricSource) {
auto pMetricGroup = new OaMetricGroupImp();
UNRECOVERABLE_IF(pMetricGroup == nullptr);
pMetricGroup->initialize(properties, metricSet, concurrentGroup, metrics);
pMetricGroup->initialize(properties, metricSet, concurrentGroup, metrics, static_cast<OaMetricSourceImp &>(metricSource));
return pMetricGroup;
}

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

@@ -15,8 +15,10 @@
namespace L0 {
class OaMetricSourceImp;
struct MetricEnumeration {
MetricEnumeration(MetricContext &metricContext);
MetricEnumeration(OaMetricSourceImp &metricSource);
virtual ~MetricEnumeration();
ze_result_t metricGroupGet(uint32_t &count, zet_metric_group_handle_t *phMetricGroups);
@@ -53,7 +55,7 @@ struct MetricEnumeration {
getMetricResultType(const MetricsDiscovery::TMetricResultType sourceMetricResultType) const;
protected:
MetricContext &metricContext;
OaMetricSourceImp &metricSource;
std::vector<MetricGroup *> metricGroups; // Cached metric groups
ze_result_t initializationState = ZE_RESULT_ERROR_UNINITIALIZED;
@@ -83,18 +85,22 @@ struct OaMetricGroupImp : MetricGroup {
const uint8_t *pRawData, uint32_t *pSetCount,
uint32_t *pTotalMetricValueCount, uint32_t *pMetricCounts,
zet_typed_value_t *pMetricValues) override;
ze_result_t initialize(const zet_metric_group_properties_t &sourceProperties,
MetricsDiscovery::IMetricSet_1_5 &metricSet,
MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup,
const std::vector<Metric *> &groupMetrics);
const std::vector<Metric *> &groupMetrics,
OaMetricSourceImp &metricSource);
uint32_t getRawReportSize() override;
bool activate() override;
bool deactivate() override;
bool activateMetricSet();
bool deactivateMetricSet();
static uint32_t getApiMask(const zet_metric_group_sampling_type_flags_t samplingType);
zet_metric_group_handle_t getMetricGroupForSubDevice(const uint32_t subDeviceIndex) override;
// Time based measurements.
ze_result_t openIoStream(uint32_t &timerPeriodNs, uint32_t &oaBufferSize) override;
@@ -126,6 +132,8 @@ struct OaMetricGroupImp : MetricGroup {
MetricsDiscovery::IConcurrentGroup_1_5 *pReferenceConcurrentGroup = nullptr;
std::vector<zet_metric_group_handle_t> metricGroups;
OaMetricSourceImp *metricSource;
};
struct OaMetricImp : Metric {

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

@@ -20,13 +20,14 @@
#include "level_zero/core/source/device/device.h"
#include "level_zero/core/source/device/device_imp.h"
#include "level_zero/tools/source/metrics/metric_enumeration_imp.h"
#include "level_zero/tools/source/metrics/metric_source_oa.h"
using namespace MetricsLibraryApi;
namespace L0 {
MetricsLibrary::MetricsLibrary(MetricContext &metricContextInput)
: metricContext(metricContextInput) {}
MetricsLibrary::MetricsLibrary(OaMetricSourceImp &metricSourceInput)
: metricSource(metricSourceInput) {}
MetricsLibrary::~MetricsLibrary() {
release();
@@ -141,7 +142,7 @@ bool MetricsLibrary::getMetricQueryReport(QueryHandle_1_0 &query, const uint32_t
}
void MetricsLibrary::initialize() {
auto &metricsEnumeration = metricContext.getMetricEnumeration();
auto &metricsEnumeration = metricSource.getMetricEnumeration();
// Function should be called only once.
DEBUG_BREAK_IF(initializationState != ZE_RESULT_ERROR_UNINITIALIZED);
@@ -175,7 +176,7 @@ void MetricsLibrary::release() {
bool MetricsLibrary::load() {
// Load library.
handle = NEO::OsLibrary::load(getFilename());
handle = OaMetricSourceImp::osLibraryLoadFunction(getFilename());
// Load exported functions.
if (handle) {
@@ -204,7 +205,7 @@ void MetricsLibrary::getSubDeviceClientOptions(
ClientOptionsData_1_0 &subDeviceCount,
ClientOptionsData_1_0 &workloadPartition) {
const auto &deviceImp = *static_cast<DeviceImp *>(&metricContext.getDevice());
const auto &deviceImp = *static_cast<DeviceImp *>(&metricSource.getDevice());
if (!deviceImp.isSubdevice) {
@@ -239,7 +240,7 @@ void MetricsLibrary::getSubDeviceClientOptions(
}
bool MetricsLibrary::createContext() {
auto &device = metricContext.getDevice();
auto &device = metricSource.getDevice();
const auto &hwHelper = device.getHwHelper();
const auto &asyncComputeEngines = hwHelper.getGpgpuEngineInstances(device.getHwInfo());
ContextCreateData_1_0 createData = {};
@@ -258,7 +259,7 @@ bool MetricsLibrary::createContext() {
const auto engineType = commandStreamReceiver.getOsContext().getEngineType();
const bool isComputeUsed = NEO::EngineHelpers::isCcs(engineType);
metricContext.setUseCompute(isComputeUsed);
metricSource.setUseCompute(isComputeUsed);
// Create metrics library context.
DEBUG_BREAK_IF(!contextCreateFunction);
@@ -269,7 +270,7 @@ bool MetricsLibrary::createContext() {
clientOptions[0].Compute.Asynchronous = asyncComputeEngine != asyncComputeEngines.end();
clientOptions[1].Type = ClientOptionsType::Tbs;
clientOptions[1].Tbs.Enabled = metricContext.getMetricStreamer() != nullptr;
clientOptions[1].Tbs.Enabled = metricSource.getMetricStreamer() != nullptr;
// Sub device client options #2
getSubDeviceClientOptions(clientOptions[2], clientOptions[3], clientOptions[4], clientOptions[5]);
@@ -349,7 +350,7 @@ ConfigurationHandle_1_0
MetricsLibrary::createConfiguration(const zet_metric_group_handle_t metricGroupHandle,
const zet_metric_group_properties_t properties) {
// Metric group internal data.
auto metricGroup = MetricGroup::fromHandle(metricGroupHandle);
auto metricGroup = static_cast<OaMetricGroupImp *>(MetricGroup::fromHandle(metricGroupHandle));
auto metricGroupDummy = ConfigurationHandle_1_0{};
DEBUG_BREAK_IF(!metricGroup);
@@ -366,14 +367,14 @@ MetricsLibrary::createConfiguration(const zet_metric_group_handle_t metricGroupH
// Activate metric group through metrics discovery to send metric group
// configuration to kernel driver.
const bool validActivate = isInitialized() && validSampling && metricGroup->activate();
const bool validActivate = isInitialized() && validSampling && metricGroup->activateMetricSet();
if (validActivate) {
// Use metrics library to create configuration for the activated metric group.
api.ConfigurationCreate(&handleData, &handle);
// Use metrics discovery to deactivate metric group.
metricGroup->deactivate();
metricGroup->deactivateMetricSet();
}
return validActivate ? handle : metricGroupDummy;
@@ -424,18 +425,19 @@ ze_result_t metricQueryPoolCreate(zet_context_handle_t hContext, zet_device_hand
const zet_metric_query_pool_desc_t *pDesc, zet_metric_query_pool_handle_t *phMetricQueryPool) {
auto device = Device::fromHandle(hDevice);
auto &metricContext = device->getMetricContext();
auto &metricSource = device->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
// Metric query cannot be used with streamer simultaneously
// (due to oa buffer usage constraints).
if (metricContext.getMetricStreamer() != nullptr) {
if (metricSource.getMetricStreamer() != nullptr) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
const auto &deviceImp = *static_cast<DeviceImp *>(device);
auto metricPoolImp = new OaMetricQueryPoolImp(device->getMetricContext(), hMetricGroup, *pDesc);
auto metricPoolImp = new OaMetricQueryPoolImp(metricSource, hMetricGroup, *pDesc);
if (metricContext.isImplicitScalingCapable()) {
if (metricSource.isImplicitScalingCapable()) {
auto emptyMetricGroups = std::vector<zet_metric_group_handle_t>();
auto &metricGroups = hMetricGroup
@@ -449,15 +451,15 @@ ze_result_t metricQueryPoolCreate(zet_context_handle_t hContext, zet_device_hand
for (size_t i = 0; i < deviceImp.numSubDevices; ++i) {
auto &subDevice = deviceImp.subDevices[i];
auto &subDeviceMetricContext = subDevice->getMetricContext();
auto &subDeviceMetricSource = subDevice->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
subDeviceMetricContext.getMetricsLibrary().enableWorkloadPartition();
subDeviceMetricSource.getMetricsLibrary().enableWorkloadPartition();
zet_metric_group_handle_t metricGroupHandle = useMetricGroupSubDevice
? metricGroups[subDeviceMetricContext.getSubDeviceIndex()]
? metricGroups[subDeviceMetricSource.getSubDeviceIndex()]
: hMetricGroup;
auto metricPoolSubdeviceImp = new OaMetricQueryPoolImp(subDeviceMetricContext, metricGroupHandle, *pDesc);
auto metricPoolSubdeviceImp = new OaMetricQueryPoolImp(subDeviceMetricSource, metricGroupHandle, *pDesc);
// Create metric query pool.
if (!metricPoolSubdeviceImp->create()) {
@@ -496,10 +498,10 @@ ze_result_t metricQueryPoolCreate(zet_context_handle_t hContext, zet_device_hand
return ZE_RESULT_SUCCESS;
}
OaMetricQueryPoolImp::OaMetricQueryPoolImp(MetricContext &metricContextInput,
OaMetricQueryPoolImp::OaMetricQueryPoolImp(OaMetricSourceImp &metricSourceInput,
zet_metric_group_handle_t hEventMetricGroupInput,
const zet_metric_query_pool_desc_t &poolDescription)
: metricContext(metricContextInput), metricsLibrary(metricContext.getMetricsLibrary()),
: metricSource(metricSourceInput), metricsLibrary(metricSource.getMetricsLibrary()),
description(poolDescription),
hMetricGroup(hEventMetricGroupInput) {}
@@ -527,7 +529,7 @@ ze_result_t OaMetricQueryPoolImp::destroy() {
metricsLibrary.destroyMetricQuery(query);
}
if (pAllocation) {
metricContext.getDevice().getDriverHandle()->getMemoryManager()->freeGraphicsMemory(pAllocation);
metricSource.getDevice().getDriverHandle()->getMemoryManager()->freeGraphicsMemory(pAllocation);
}
break;
case ZET_METRIC_QUERY_POOL_TYPE_EXECUTION:
@@ -541,9 +543,9 @@ ze_result_t OaMetricQueryPoolImp::destroy() {
}
// Check open queries.
if (metricContext.getMetricsLibrary().getMetricQueryCount() == 0) {
if (!metricContext.isMetricGroupActivated()) {
metricContext.getMetricsLibrary().release();
if (metricSource.getMetricsLibrary().getMetricQueryCount() == 0) {
if (!metricSource.isMetricGroupActivated()) {
metricSource.getMetricsLibrary().release();
}
}
@@ -556,9 +558,10 @@ bool OaMetricQueryPoolImp::allocateGpuMemory() {
if (description.type == ZET_METRIC_QUERY_POOL_TYPE_PERFORMANCE) {
// Get allocation size.
const auto &deviceImp = *static_cast<DeviceImp *>(&metricContext.getDevice());
allocationSize = (metricContext.isImplicitScalingCapable())
? deviceImp.subDevices[0]->getMetricContext().getMetricsLibrary().getQueryReportGpuSize() * description.count * deviceImp.numSubDevices
const auto &deviceImp = *static_cast<DeviceImp *>(&metricSource.getDevice());
allocationSize = (metricSource.isImplicitScalingCapable())
? deviceImp.subDevices[0]->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>().getMetricsLibrary().getQueryReportGpuSize() * description.count * deviceImp.numSubDevices
: metricsLibrary.getQueryReportGpuSize() * description.count;
if (allocationSize == 0) {
@@ -567,9 +570,9 @@ bool OaMetricQueryPoolImp::allocateGpuMemory() {
// Allocate gpu memory.
NEO::AllocationProperties properties(
metricContext.getDevice().getRootDeviceIndex(), allocationSize, NEO::GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY, metricContext.getDevice().getNEODevice()->getDeviceBitfield());
metricSource.getDevice().getRootDeviceIndex(), allocationSize, NEO::GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY, metricSource.getDevice().getNEODevice()->getDeviceBitfield());
properties.alignment = 64u;
pAllocation = metricContext.getDevice().getDriverHandle()->getMemoryManager()->allocateGraphicsMemoryWithProperties(properties);
pAllocation = metricSource.getDevice().getDriverHandle()->getMemoryManager()->allocateGraphicsMemoryWithProperties(properties);
UNRECOVERABLE_IF(pAllocation == nullptr);
@@ -591,7 +594,7 @@ bool OaMetricQueryPoolImp::createMetricQueryPool() {
// Pool initialization.
pool.reserve(description.count);
for (uint32_t i = 0; i < description.count; ++i) {
pool.push_back({metricContext, *this, i});
pool.push_back({metricSource, *this, i});
}
// Metrics library query object initialization.
@@ -602,7 +605,7 @@ bool OaMetricQueryPoolImp::createSkipExecutionQueryPool() {
pool.reserve(description.count);
for (uint32_t i = 0; i < description.count; ++i) {
pool.push_back({metricContext, *this, i});
pool.push_back({metricSource, *this, i});
}
return true;
@@ -623,7 +626,7 @@ ze_result_t OaMetricQueryPoolImp::createMetricQuery(uint32_t index,
if (metricQueryPools.size() > 0) {
auto pMetricQueryImp = new OaMetricQueryImp(metricContext, *this, index);
auto pMetricQueryImp = new OaMetricQueryImp(metricSource, *this, index);
for (auto metricQueryPoolHandle : metricQueryPools) {
auto &metricQueries = pMetricQueryImp->getMetricQueries();
@@ -647,9 +650,9 @@ std::vector<zet_metric_query_pool_handle_t> &OaMetricQueryPoolImp::getMetricQuer
return metricQueryPools;
}
OaMetricQueryImp::OaMetricQueryImp(MetricContext &metricContextInput, OaMetricQueryPoolImp &poolInput,
OaMetricQueryImp::OaMetricQueryImp(OaMetricSourceImp &metricSourceInput, OaMetricQueryPoolImp &poolInput,
const uint32_t slotInput)
: metricContext(metricContextInput), metricsLibrary(metricContext.getMetricsLibrary()),
: metricSource(metricSourceInput), metricsLibrary(metricSource.getMetricsLibrary()),
pool(poolInput), slot(slotInput) {}
ze_result_t OaMetricQueryImp::appendBegin(CommandList &commandList) {
@@ -792,7 +795,7 @@ ze_result_t OaMetricQueryImp::writeMetricQuery(CommandList &commandList, ze_even
auto &metricQueryImp = *static_cast<OaMetricQueryImp *>(MetricQuery::fromHandle(metricQueries[i]));
auto &metricLibrarySubDevice = metricQueryImp.metricsLibrary;
auto &metricContextSubDevice = metricQueryImp.metricContext;
auto &metricSourceSubDevice = metricQueryImp.metricSource;
// Obtain gpu commands.
CommandBufferData_1_0 commandBuffer = {};
@@ -802,7 +805,7 @@ ze_result_t OaMetricQueryImp::writeMetricQuery(CommandList &commandList, ze_even
commandBuffer.QueryHwCounters.Slot = slot;
commandBuffer.Allocation.GpuAddress = gpuAddress;
commandBuffer.Allocation.CpuAddress = cpuAddress;
commandBuffer.Type = metricContextSubDevice.isComputeUsed()
commandBuffer.Type = metricSourceSubDevice.isComputeUsed()
? GpuCommandBufferType::Compute
: GpuCommandBufferType::Render;
@@ -845,7 +848,7 @@ ze_result_t OaMetricQueryImp::writeMetricQuery(CommandList &commandList, ze_even
commandBuffer.QueryHwCounters.Slot = slot;
commandBuffer.Allocation.GpuAddress = pool.pAllocation->getGpuAddress();
commandBuffer.Allocation.CpuAddress = pool.pAllocation->getUnderlyingBuffer();
commandBuffer.Type = metricContext.isComputeUsed()
commandBuffer.Type = metricSource.isComputeUsed()
? GpuCommandBufferType::Compute
: GpuCommandBufferType::Render;
@@ -872,7 +875,7 @@ ze_result_t OaMetricQueryImp::writeSkipExecutionQuery(CommandList &commandList,
CommandBufferData_1_0 commandBuffer = {};
commandBuffer.CommandsType = ObjectType::OverrideNullHardware;
commandBuffer.Override.Enable = begin;
commandBuffer.Type = metricContext.isComputeUsed()
commandBuffer.Type = metricSource.isComputeUsed()
? GpuCommandBufferType::Compute
: GpuCommandBufferType::Render;
@@ -891,30 +894,6 @@ ze_result_t OaMetricQueryImp::writeSkipExecutionQuery(CommandList &commandList,
return result ? ZE_RESULT_SUCCESS : ZE_RESULT_ERROR_UNKNOWN;
}
ze_result_t MetricQuery::appendMemoryBarrier(CommandList &commandList) {
DeviceImp *pDeviceImp = static_cast<DeviceImp *>(commandList.device);
if (pDeviceImp->metricContext->isImplicitScalingCapable()) {
// Use one of the sub-device contexts to append to command list.
pDeviceImp = static_cast<DeviceImp *>(pDeviceImp->subDevices[0]);
}
auto &metricContext = pDeviceImp->getMetricContext();
auto &metricsLibrary = metricContext.getMetricsLibrary();
// Obtain gpu commands.
CommandBufferData_1_0 commandBuffer = {};
commandBuffer.CommandsType = ObjectType::OverrideFlushCaches;
commandBuffer.Override.Enable = true;
commandBuffer.Type = metricContext.isComputeUsed()
? GpuCommandBufferType::Compute
: GpuCommandBufferType::Render;
return metricsLibrary.getGpuCommands(commandList, commandBuffer) ? ZE_RESULT_SUCCESS
: ZE_RESULT_ERROR_UNKNOWN;
}
ze_result_t MetricQuery::appendStreamerMarker(CommandList &commandList,
zet_metric_streamer_handle_t hMetricStreamer,
uint32_t value) {
@@ -924,10 +903,11 @@ ze_result_t MetricQuery::appendStreamerMarker(CommandList &commandList,
if (pDeviceImp->metricContext->isImplicitScalingCapable()) {
// Use one of the sub-device contexts to append to command list.
pDeviceImp = static_cast<DeviceImp *>(pDeviceImp->subDevices[0]);
pDeviceImp->metricContext->getMetricsLibrary().enableWorkloadPartition();
pDeviceImp->metricContext->getMetricSource<OaMetricSourceImp>().getMetricsLibrary().enableWorkloadPartition();
}
auto &metricContext = pDeviceImp->getMetricContext();
auto &metricsLibrary = metricContext.getMetricsLibrary();
OaMetricSourceImp &metricSource = pDeviceImp->metricContext->getMetricSource<OaMetricSourceImp>();
auto &metricsLibrary = metricSource.getMetricsLibrary();
const uint32_t streamerMarkerHighBitsShift = 25;
@@ -936,7 +916,7 @@ ze_result_t MetricQuery::appendStreamerMarker(CommandList &commandList,
commandBuffer.CommandsType = ObjectType::MarkerStreamUser;
commandBuffer.MarkerStreamUser.Value = value;
commandBuffer.MarkerStreamUser.Reserved = (value >> streamerMarkerHighBitsShift);
commandBuffer.Type = metricContext.isComputeUsed()
commandBuffer.Type = metricSource.isComputeUsed()
? GpuCommandBufferType::Compute
: GpuCommandBufferType::Render;

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

@@ -27,6 +27,7 @@ namespace L0 {
struct Device;
struct CommandList;
struct MetricGroup;
class OaMetricSourceImp;
} // namespace L0
namespace NEO {
@@ -38,7 +39,7 @@ namespace L0 {
struct MetricsLibrary {
public:
MetricsLibrary(MetricContext &metricContext);
MetricsLibrary(OaMetricSourceImp &metricSource);
virtual ~MetricsLibrary();
// Initialization.
@@ -90,7 +91,7 @@ struct MetricsLibrary {
protected:
NEO::OsLibrary *handle = nullptr;
MetricContext &metricContext;
OaMetricSourceImp &metricSource;
ze_result_t initializationState = ZE_RESULT_ERROR_UNINITIALIZED;
bool isWorkloadPartitionEnabled = false;
std::mutex mutex;
@@ -107,7 +108,7 @@ struct MetricsLibrary {
struct OaMetricQueryImp : MetricQuery {
public:
OaMetricQueryImp(MetricContext &metricContext, struct OaMetricQueryPoolImp &pool,
OaMetricQueryImp(OaMetricSourceImp &metricSource, struct OaMetricQueryPoolImp &pool,
const uint32_t slot);
ze_result_t appendBegin(CommandList &commandList) override;
@@ -130,7 +131,7 @@ struct OaMetricQueryImp : MetricQuery {
const bool begin);
protected:
MetricContext &metricContext;
OaMetricSourceImp &metricSource;
MetricsLibrary &metricsLibrary;
OaMetricQueryPoolImp &pool;
uint32_t slot;
@@ -139,7 +140,7 @@ struct OaMetricQueryImp : MetricQuery {
struct OaMetricQueryPoolImp : MetricQueryPool {
public:
OaMetricQueryPoolImp(MetricContext &metricContext, zet_metric_group_handle_t hEventMetricGroup, const zet_metric_query_pool_desc_t &poolDescription);
OaMetricQueryPoolImp(OaMetricSourceImp &metricSource, zet_metric_group_handle_t hEventMetricGroup, const zet_metric_query_pool_desc_t &poolDescription);
bool create();
ze_result_t destroy() override;
@@ -155,7 +156,7 @@ struct OaMetricQueryPoolImp : MetricQueryPool {
bool createSkipExecutionQueryPool();
public:
MetricContext &metricContext;
OaMetricSourceImp &metricSource;
MetricsLibrary &metricsLibrary;
std::vector<OaMetricQueryImp> pool;
NEO::GraphicsAllocation *pAllocation = nullptr;

69
level_zero/tools/source/metrics/metric_source_oa.h Normal file
View File

@@ -0,0 +1,69 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "level_zero/tools/source/metrics/metric.h"
#include "level_zero/tools/source/metrics/metric_enumeration_imp.h"
#include "level_zero/tools/source/metrics/metric_query_imp.h"
#include "level_zero/tools/source/metrics/metric_streamer_imp.h"
namespace NEO {
class OsLibrary;
} // namespace NEO
namespace L0 {
class OaMetricSourceImp : public MetricSource {
public:
OaMetricSourceImp(const MetricDeviceContext &metricDeviceContext);
virtual ~OaMetricSourceImp();
void enable() override;
bool isAvailable() override;
ze_result_t metricGroupGet(uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups) override;
ze_result_t appendMetricMemoryBarrier(CommandList &commandList) override;
bool loadDependencies();
bool isInitialized();
void setInitializationState(const ze_result_t state);
Device &getDevice();
MetricsLibrary &getMetricsLibrary();
MetricEnumeration &getMetricEnumeration();
MetricStreamer *getMetricStreamer();
void setMetricStreamer(MetricStreamer *pMetricStreamer);
void setMetricsLibrary(MetricsLibrary &metricsLibrary);
void setMetricEnumeration(MetricEnumeration &metricEnumeration);
ze_result_t activateMetricGroups();
ze_result_t activateMetricGroupsDeferred(const uint32_t count,
zet_metric_group_handle_t *phMetricGroups);
bool isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) const;
bool isMetricGroupActivated() const;
void setUseCompute(const bool useCompute);
bool isComputeUsed() const;
uint32_t getSubDeviceIndex();
bool isImplicitScalingCapable() const;
const MetricDeviceContext &getMetricDeviceContext() const { return metricDeviceContext; }
static bool checkDependencies();
static std::unique_ptr<OaMetricSourceImp> create(const MetricDeviceContext &metricDeviceContext);
using OsLibraryLoadPtr = std::add_pointer<NEO::OsLibrary *(const std::string &)>::type;
static OsLibraryLoadPtr osLibraryLoadFunction;
protected:
ze_result_t initializationState = ZE_RESULT_ERROR_UNINITIALIZED;
const MetricDeviceContext &metricDeviceContext;
std::unique_ptr<MetricEnumeration> metricEnumeration = nullptr;
std::unique_ptr<MetricsLibrary> metricsLibrary = nullptr;
MetricStreamer *pMetricStreamer = nullptr;
bool useCompute = false;
bool available = false;
};
template <>
OaMetricSourceImp &MetricDeviceContext::getMetricSource<OaMetricSourceImp>() const;
} // namespace L0

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

@@ -12,6 +12,7 @@
#include "level_zero/core/source/device/device_imp.h"
#include "level_zero/tools/source/metrics/metric_enumeration_imp.h"
#include "level_zero/tools/source/metrics/metric_query_imp.h"
#include "level_zero/tools/source/metrics/metric_source_oa.h"
namespace L0 {
@@ -114,12 +115,12 @@ ze_result_t OaMetricStreamerImp::close() {
if (result == ZE_RESULT_SUCCESS) {
auto device = Device::fromHandle(hDevice);
auto &metricContext = device->getMetricContext();
auto &metricsLibrary = metricContext.getMetricsLibrary();
auto &metricSource = device->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
auto &metricsLibrary = metricSource.getMetricsLibrary();
// Clear metric streamer reference in context.
// Another metric streamer instance or query can be used.
metricContext.setMetricStreamer(nullptr);
metricSource.setMetricStreamer(nullptr);
// Close metrics library (if was used to generate streamer's marker gpu commands).
// It will allow metric query to use Linux Tbs stream exclusively
@@ -235,26 +236,27 @@ uint32_t OaMetricStreamerImp::getRequiredBufferSize(const uint32_t maxReportCoun
ze_result_t MetricStreamer::openForDevice(Device *pDevice, zet_metric_group_handle_t hMetricGroup,
zet_metric_streamer_desc_t &desc, zet_metric_streamer_handle_t *phMetricStreamer) {
auto &metricContext = pDevice->getMetricContext();
auto &metricSource = pDevice->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
*phMetricStreamer = nullptr;
// Check whether metric streamer is already open.
if (metricContext.getMetricStreamer() != nullptr) {
if (metricSource.getMetricStreamer() != nullptr) {
return ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE;
}
// metric streamer cannot be used with query simultaneously
// (oa buffer cannot be shared).
if (metricContext.getMetricsLibrary().getMetricQueryCount() > 0) {
if (metricSource.getMetricsLibrary().getMetricQueryCount() > 0) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
// Unload metrics library if there are no active queries.
// It will allow to open metric streamer. Query and streamer cannot be used
// simultaneously since they use the same exclusive resource (oa buffer).
if (metricContext.getMetricsLibrary().getInitializationState() == ZE_RESULT_SUCCESS) {
metricContext.getMetricsLibrary().release();
if (metricSource.getMetricsLibrary().getInitializationState() == ZE_RESULT_SUCCESS) {
metricSource.getMetricsLibrary().release();
}
// Check metric group sampling type.
@@ -264,7 +266,7 @@ ze_result_t MetricStreamer::openForDevice(Device *pDevice, zet_metric_group_hand
}
// Check whether metric group is activated.
if (!metricContext.isMetricGroupActivated(hMetricGroup)) {
if (!metricSource.isMetricGroupActivated(hMetricGroup)) {
return ZE_RESULT_NOT_READY;
}
@@ -275,7 +277,7 @@ ze_result_t MetricStreamer::openForDevice(Device *pDevice, zet_metric_group_hand
const ze_result_t result = pMetricStreamer->startMeasurements(
desc.notifyEveryNReports, desc.samplingPeriod);
if (result == ZE_RESULT_SUCCESS) {
metricContext.setMetricStreamer(pMetricStreamer);
metricSource.setMetricStreamer(pMetricStreamer);
} else {
delete pMetricStreamer;
pMetricStreamer = nullptr;

5
level_zero/tools/source/metrics/windows/os_metric_enumeration_imp_windows.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -9,6 +9,7 @@
#include "shared/source/os_interface/windows/wddm/wddm.h"
#include "level_zero/tools/source/metrics/metric_enumeration_imp.h"
#include "level_zero/tools/source/metrics/metric_source_oa.h"
#if defined(_WIN64)
#define METRICS_DISCOVERY_NAME "igdmd64.dll"
@@ -24,7 +25,7 @@ const char *MetricEnumeration::getMetricsDiscoveryFilename() { return METRICS_DI
bool MetricEnumeration::getAdapterId(uint32_t &major, uint32_t &minor) {
auto &device = metricContext.getDevice();
auto &device = metricSource.getMetricDeviceContext().getDevice();
auto wddm = device.getOsInterface().getDriverModel()->as<NEO::Wddm>();
auto luid = wddm->getAdapterLuid();

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

@@ -1,5 +1,5 @@
#
# Copyright (C) 2020-2021 Intel Corporation
# Copyright (C) 2020-2022 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
@@ -18,6 +18,7 @@ target_sources(${TARGET_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/test_metric_streamer_1.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_metric_streamer_2.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_metric_streamer_3.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_metric_initialization.cpp
)

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

@@ -10,6 +10,7 @@
#include "shared/source/command_container/implicit_scaling.h"
#include "shared/test/common/mocks/mock_os_library.h"
#include "level_zero/tools/source/metrics/metric_source_oa.h"
#include "level_zero/tools/source/metrics/metric_streamer_imp.h"
using namespace MetricsLibraryApi;
@@ -26,16 +27,16 @@ void MetricContextFixture::SetUp() {
ContextFixture::SetUp();
// Initialize metric api.
auto &metricContext = device->getMetricContext();
metricContext.setInitializationState(ZE_RESULT_SUCCESS);
auto &metricSource = device->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
metricSource.setInitializationState(ZE_RESULT_SUCCESS);
// Mock metrics library.
mockMetricsLibrary = std::unique_ptr<Mock<MetricsLibrary>>(new (std::nothrow) Mock<MetricsLibrary>(metricContext));
mockMetricsLibrary = std::unique_ptr<Mock<MetricsLibrary>>(new (std::nothrow) Mock<MetricsLibrary>(metricSource));
mockMetricsLibrary->setMockedApi(&mockMetricsLibraryApi);
mockMetricsLibrary->handle = new MockOsLibrary();
// Mock metric enumeration.
mockMetricEnumeration = std::unique_ptr<Mock<MetricEnumeration>>(new (std::nothrow) Mock<MetricEnumeration>(metricContext));
mockMetricEnumeration = std::unique_ptr<Mock<MetricEnumeration>>(new (std::nothrow) Mock<MetricEnumeration>(metricSource));
mockMetricEnumeration->setMockedApi(&mockMetricsDiscoveryApi);
mockMetricEnumeration->hMetricsDiscovery = std::make_unique<MockOsLibrary>();
@@ -122,15 +123,15 @@ void MetricMultiDeviceFixture::SetUp() {
}
// Initialize metric api.
auto &metricContext = devices[0]->getMetricContext();
auto &metricSource = devices[0]->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
// Mock metrics library.
mockMetricsLibrary = std::unique_ptr<Mock<MetricsLibrary>>(new (std::nothrow) Mock<MetricsLibrary>(metricContext));
mockMetricsLibrary = std::unique_ptr<Mock<MetricsLibrary>>(new (std::nothrow) Mock<MetricsLibrary>(metricSource));
mockMetricsLibrary->setMockedApi(&mockMetricsLibraryApi);
mockMetricsLibrary->handle = new MockOsLibrary();
// Mock metric enumeration.
mockMetricEnumeration = std::unique_ptr<Mock<MetricEnumeration>>(new (std::nothrow) Mock<MetricEnumeration>(metricContext));
mockMetricEnumeration = std::unique_ptr<Mock<MetricEnumeration>>(new (std::nothrow) Mock<MetricEnumeration>(metricSource));
mockMetricEnumeration->setMockedApi(&mockMetricsDiscoveryApi);
mockMetricEnumeration->hMetricsDiscovery = std::make_unique<MockOsLibrary>();
@@ -140,7 +141,7 @@ void MetricMultiDeviceFixture::SetUp() {
mockMetricsLibrarySubDevices.resize(subDeviceCount);
for (uint32_t i = 0; i < subDeviceCount; i++) {
auto &metricsSubDeviceContext = deviceImp.subDevices[i]->getMetricContext();
auto &metricsSubDeviceContext = deviceImp.subDevices[i]->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
mockMetricEnumerationSubDevices[i] = std::unique_ptr<Mock<MetricEnumeration>>(new (std::nothrow) Mock<MetricEnumeration>(metricsSubDeviceContext));
mockMetricEnumerationSubDevices[i]->setMockedApi(&mockMetricsDiscoveryApi);
mockMetricEnumerationSubDevices[i]->hMetricsDiscovery = std::make_unique<MockOsLibrary>();
@@ -273,18 +274,18 @@ void MetricStreamerMultiDeviceFixture::cleanup(zet_device_handle_t &hDevice, zet
zet_metric_streamer_handle_t metricStreamerSubDeviceHandle = pStreamerImp->getMetricStreamers()[index];
OaMetricStreamerImp *pStreamerSubDevImp = static_cast<OaMetricStreamerImp *>(MetricStreamer::fromHandle(metricStreamerSubDeviceHandle));
auto device = deviceImp.subDevices[index];
auto &metricContext = device->getMetricContext();
auto &metricsLibrary = metricContext.getMetricsLibrary();
metricContext.setMetricStreamer(nullptr);
auto &metricSource = device->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
auto &metricsLibrary = metricSource.getMetricsLibrary();
metricSource.setMetricStreamer(nullptr);
metricsLibrary.release();
delete pStreamerSubDevImp;
}
auto &metricContext = devices[0]->getMetricContext();
metricContext.setMetricStreamer(nullptr);
auto &metricSource = devices[0]->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
metricSource.setMetricStreamer(nullptr);
delete pStreamerImp;
}
Mock<MetricsLibrary>::Mock(::L0::MetricContext &metricContext) : MetricsLibrary(metricContext) {
Mock<MetricsLibrary>::Mock(::L0::OaMetricSourceImp &metricSource) : MetricsLibrary(metricSource) {
}
Mock<MetricsLibrary>::~Mock() {
@@ -297,8 +298,8 @@ void Mock<MetricsLibrary>::setMockedApi(MockMetricsLibraryApi *mockedApi) {
if (mockedApi) {
// Mock class used to communicate with metrics library.
metricsLibrary = &metricContext.getMetricsLibrary();
metricContext.setMetricsLibrary(*this);
metricsLibrary = &metricSource.getMetricsLibrary();
metricSource.setMetricsLibrary(*this);
// Mock metrics library api functions.
contextCreateFunction = mockedApi->ContextCreate;
@@ -331,7 +332,7 @@ void Mock<MetricsLibrary>::setMockedApi(MockMetricsLibraryApi *mockedApi) {
} else {
// Restore an original class used to communicate with metrics library.
metricContext.setMetricsLibrary(*metricsLibrary);
metricSource.setMetricsLibrary(*metricsLibrary);
}
}

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

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -99,7 +99,7 @@ template <>
struct Mock<MetricsLibrary> : public MetricsLibrary {
public:
Mock(::L0::MetricContext &metricContext);
Mock(::L0::OaMetricSourceImp &metricSource);
~Mock() override;
using MetricsLibrary::handle;

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

@@ -1,16 +1,18 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/tools/source/metrics/metric_enumeration_imp.h"
#include "level_zero/tools/source/metrics/metric_source_oa.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric.h"
namespace L0 {
namespace ult {
Mock<MetricEnumeration>::Mock(::L0::MetricContext &metricContext) : MetricEnumeration(metricContext) {
Mock<MetricEnumeration>::Mock(::L0::OaMetricSourceImp &metricSource) : MetricEnumeration(metricSource) {
}
Mock<MetricEnumeration>::~Mock() {
@@ -39,8 +41,8 @@ void Mock<MetricEnumeration>::setMockedApi(MockMetricsDiscoveryApi *mockedApi) {
if (mockedApi) {
// Mock class used to communicate with metrics library.
metricEnumeration = &metricContext.getMetricEnumeration();
metricContext.setMetricEnumeration(*this);
metricEnumeration = &metricSource.getMetricEnumeration();
metricSource.setMetricEnumeration(*this);
// Mock metrics library api functions.
openAdapterGroup = mockedApi->OpenAdapterGroup;
@@ -51,7 +53,7 @@ void Mock<MetricEnumeration>::setMockedApi(MockMetricsDiscoveryApi *mockedApi) {
} else {
// Restore an original class used to communicate with metrics library.
metricContext.setMetricEnumeration(*metricEnumeration);
metricSource.setMetricEnumeration(*metricEnumeration);
}
}

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

@@ -164,7 +164,7 @@ class Mock<IInformation_1_0> : public IInformation_1_0 {
template <>
struct Mock<MetricEnumeration> : public MetricEnumeration {
Mock(::L0::MetricContext &metricContext);
Mock(::L0::OaMetricSourceImp &metricSource);
~Mock() override;
using MetricEnumeration::cleanupMetricsDiscovery;
@@ -210,6 +210,9 @@ struct Mock<MetricGroup> : public MetricGroup {
MOCK_METHOD(ze_result_t, openIoStream, (uint32_t &, uint32_t &), (override));
MOCK_METHOD(ze_result_t, readIoStream, (uint32_t &, uint8_t &), (override));
MOCK_METHOD(ze_result_t, closeIoStream, (), (override));
zet_metric_group_handle_t getMetricGroupForSubDevice(const uint32_t subDeviceIndex) override {
return nullptr;
}
};
struct MetricGroupImpTest : public OaMetricGroupImp {

47
level_zero/tools/test/unit_tests/sources/metrics/test_metric_enumeration_1.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -9,6 +9,7 @@
#include "level_zero/core/source/device/device_imp.h"
#include "level_zero/core/test/unit_tests/mocks/mock_driver.h"
#include "level_zero/tools/source/metrics/metric_source_oa.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric.h"
#include "gmock/gmock.h"
@@ -2497,9 +2498,9 @@ TEST_F(MetricEnumerationTest, givenLoadedMetricsLibraryAndDiscoveryAndMetricsLib
mockMetricsLibrary->initializationState = ZE_RESULT_SUCCESS;
auto &metricContext = device->getMetricContext();
EXPECT_EQ(metricContext.loadDependencies(), true);
EXPECT_EQ(metricContext.isInitialized(), true);
auto &metricSource = device->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
EXPECT_EQ(metricSource.loadDependencies(), true);
EXPECT_EQ(metricSource.isInitialized(), true);
}
TEST_F(MetricEnumerationTest, givenNotLoadedMetricsLibraryAndDiscoveryWhenLoadDependenciesThenReturnFail) {
@@ -2508,14 +2509,14 @@ TEST_F(MetricEnumerationTest, givenNotLoadedMetricsLibraryAndDiscoveryWhenLoadDe
.Times(1)
.WillOnce(Return(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE));
auto &metricContext = device->getMetricContext();
EXPECT_EQ(metricContext.loadDependencies(), false);
EXPECT_EQ(metricContext.isInitialized(), false);
auto &metricSource = device->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
EXPECT_EQ(metricSource.loadDependencies(), false);
EXPECT_EQ(metricSource.isInitialized(), false);
}
TEST_F(MetricEnumerationTest, givenRootDeviceWhenLoadDependenciesIsCalledThenLegacyOpenMetricsDeviceWillBeCalled) {
auto &metricContext = device->getMetricContext();
auto &metricSource = device->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
Mock<IAdapterGroup_1_9> mockAdapterGroup;
Mock<IAdapter_1_9> mockAdapter;
Mock<IMetricsDevice_1_5> mockDevice;
@@ -2553,18 +2554,18 @@ TEST_F(MetricEnumerationTest, givenRootDeviceWhenLoadDependenciesIsCalledThenLeg
.WillOnce(Return(TCompletionCode::CC_OK));
// Use first sub device.
metricContext.setSubDeviceIndex(0);
device->getMetricDeviceContext().setSubDeviceIndex(0);
mockMetricsLibrary->initializationState = ZE_RESULT_SUCCESS;
EXPECT_EQ(metricContext.loadDependencies(), true);
EXPECT_EQ(metricContext.isInitialized(), true);
EXPECT_EQ(metricSource.loadDependencies(), true);
EXPECT_EQ(metricSource.isInitialized(), true);
EXPECT_EQ(mockMetricEnumeration->baseIsInitialized(), true);
EXPECT_EQ(mockMetricEnumeration->cleanupMetricsDiscovery(), ZE_RESULT_SUCCESS);
}
TEST_F(MetricEnumerationTest, givenSubDeviceWhenLoadDependenciesIsCalledThenOpenMetricsSubDeviceWillBeCalled) {
auto &metricContext = device->getMetricContext();
auto &metricSource = device->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
Mock<IAdapterGroup_1_9> mockAdapterGroup;
Mock<IAdapter_1_9> mockAdapter;
Mock<IMetricsDevice_1_5> mockDevice;
@@ -2602,18 +2603,18 @@ TEST_F(MetricEnumerationTest, givenSubDeviceWhenLoadDependenciesIsCalledThenOpen
.WillOnce(Return(TCompletionCode::CC_OK));
// Use second sub device.
metricContext.setSubDeviceIndex(1);
device->getMetricDeviceContext().setSubDeviceIndex(1);
mockMetricsLibrary->initializationState = ZE_RESULT_SUCCESS;
EXPECT_EQ(metricContext.loadDependencies(), true);
EXPECT_EQ(metricContext.isInitialized(), true);
EXPECT_EQ(metricSource.loadDependencies(), true);
EXPECT_EQ(metricSource.isInitialized(), true);
EXPECT_EQ(mockMetricEnumeration->baseIsInitialized(), true);
EXPECT_EQ(mockMetricEnumeration->cleanupMetricsDiscovery(), ZE_RESULT_SUCCESS);
}
TEST_F(MetricEnumerationTest, givenSubDeviceWhenLoadDependenciesIsCalledThenOpenMetricsSubDeviceWillBeCalledWithoutSuccess) {
auto &metricContext = device->getMetricContext();
auto &metricSource = device->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
Mock<IAdapterGroup_1_9> mockAdapterGroup;
Mock<IAdapter_1_9> mockAdapter;
Mock<IMetricsDevice_1_5> mockDevice;
@@ -2649,11 +2650,11 @@ TEST_F(MetricEnumerationTest, givenSubDeviceWhenLoadDependenciesIsCalledThenOpen
.WillOnce(Return(TCompletionCode::CC_OK));
// Use second sub device.
metricContext.setSubDeviceIndex(1);
device->getMetricDeviceContext().setSubDeviceIndex(1);
mockMetricsLibrary->initializationState = ZE_RESULT_SUCCESS;
EXPECT_EQ(metricContext.loadDependencies(), true);
EXPECT_EQ(metricContext.isInitialized(), true);
EXPECT_EQ(metricSource.loadDependencies(), true);
EXPECT_EQ(metricSource.isInitialized(), true);
EXPECT_EQ(mockMetricEnumeration->baseIsInitialized(), false);
}
@@ -2904,7 +2905,7 @@ TEST_F(MetricEnumerationTest, givenMetricSetWhenActivateIsCalledActivateReturnsT
EXPECT_CALL(metricsSet, Activate())
.WillRepeatedly(Return(MetricsDiscovery::CC_OK));
EXPECT_EQ(metricGroup.activate(), true);
EXPECT_EQ(metricGroup.activateMetricSet(), true);
}
TEST_F(MetricEnumerationTest, givenMetricSetWhenActivateIsCalledActivateReturnsFalse) {
@@ -2916,7 +2917,7 @@ TEST_F(MetricEnumerationTest, givenMetricSetWhenActivateIsCalledActivateReturnsF
EXPECT_CALL(metricsSet, Activate())
.WillRepeatedly(Return(MetricsDiscovery::CC_ERROR_GENERAL));
EXPECT_EQ(metricGroup.activate(), false);
EXPECT_EQ(metricGroup.activateMetricSet(), false);
}
TEST_F(MetricEnumerationTest, givenMetricSetWhenDeactivateIsCalledDeactivateReturnsTrue) {
@@ -2928,7 +2929,7 @@ TEST_F(MetricEnumerationTest, givenMetricSetWhenDeactivateIsCalledDeactivateRetu
EXPECT_CALL(metricsSet, Deactivate())
.WillRepeatedly(Return(MetricsDiscovery::CC_OK));
EXPECT_EQ(metricGroup.deactivate(), true);
EXPECT_EQ(metricGroup.deactivateMetricSet(), true);
}
TEST_F(MetricEnumerationTest, givenMetricSetWhenDeactivateIsCalledDeactivateReturnsFalse) {
@@ -2940,7 +2941,7 @@ TEST_F(MetricEnumerationTest, givenMetricSetWhenDeactivateIsCalledDeactivateRetu
EXPECT_CALL(metricsSet, Deactivate())
.WillRepeatedly(Return(MetricsDiscovery::CC_ERROR_GENERAL));
EXPECT_EQ(metricGroup.deactivate(), false);
EXPECT_EQ(metricGroup.deactivateMetricSet(), false);
}
TEST_F(MetricEnumerationTest, givenMetricSetWhenWaitForReportsIsCalledWaitForReportsReturnsSuccess) {

19
level_zero/tools/test/unit_tests/sources/metrics/test_metric_enumeration_2.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2021 Intel Corporation
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -9,6 +9,7 @@
#include "level_zero/core/source/device/device_imp.h"
#include "level_zero/core/test/unit_tests/mocks/mock_driver.h"
#include "level_zero/tools/source/metrics/metric_source_oa.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric.h"
#include "gmock/gmock.h"
@@ -25,7 +26,7 @@ using MetricEnumerationMultiDeviceTest = Test<MetricMultiDeviceFixture>;
TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesIsCalledThenOpenMetricsSubDeviceWillBeCalled) {
// Use first root device.
auto &metricContext = devices[0]->getMetricContext();
auto &metricSource = devices[0]->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
Mock<IAdapterGroup_1_9> mockAdapterGroup;
@@ -65,11 +66,11 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesIsCa
.WillOnce(Return(TCompletionCode::CC_OK));
// Use root device.
metricContext.setSubDeviceIndex(0);
devices[0]->getMetricDeviceContext().setSubDeviceIndex(0);
mockMetricsLibrary->initializationState = ZE_RESULT_SUCCESS;
EXPECT_EQ(metricContext.loadDependencies(), true);
EXPECT_EQ(metricContext.isInitialized(), true);
EXPECT_EQ(metricSource.loadDependencies(), true);
EXPECT_EQ(metricSource.isInitialized(), true);
EXPECT_EQ(mockMetricEnumeration->baseIsInitialized(), true);
EXPECT_EQ(mockMetricEnumeration->cleanupMetricsDiscovery(), ZE_RESULT_SUCCESS);
}
@@ -77,7 +78,7 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesIsCa
TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesIsCalledThenOpenMetricsSubDeviceWillBeCalledWithoutSuccess) {
// Use first root device.
auto &metricContext = devices[0]->getMetricContext();
auto &metricSource = devices[0]->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
Mock<IAdapterGroup_1_9> mockAdapterGroup;
Mock<IAdapter_1_9> mockAdapter;
Mock<IMetricsDevice_1_5> mockDevice;
@@ -113,11 +114,11 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesIsCa
.WillOnce(Return(TCompletionCode::CC_OK));
// Use root device.
metricContext.setSubDeviceIndex(0);
devices[0]->getMetricDeviceContext().setSubDeviceIndex(0);
mockMetricsLibrary->initializationState = ZE_RESULT_SUCCESS;
EXPECT_EQ(metricContext.loadDependencies(), true);
EXPECT_EQ(metricContext.isInitialized(), true);
EXPECT_EQ(metricSource.loadDependencies(), true);
EXPECT_EQ(metricSource.isInitialized(), true);
EXPECT_EQ(mockMetricEnumeration->baseIsInitialized(), false);
}

64
level_zero/tools/test/unit_tests/sources/metrics/test_metric_initialization.cpp Normal file
View File

@@ -0,0 +1,64 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/os_interface/os_library.h"
#include "level_zero/core/test/unit_tests/mocks/mock_driver.h"
#include "level_zero/tools/source/metrics/metric_source_oa.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
using ::testing::Return;
namespace L0 {
extern _ze_driver_handle_t *GlobalDriverHandle;
namespace ult {
class MockOsLibrary : public NEO::OsLibrary {
public:
MockOsLibrary(const std::string &name, std::string *errorValue) {
}
void *getProcAddress(const std::string &procName) override {
return nullptr;
}
bool isLoaded() override {
return false;
}
static OsLibrary *load(const std::string &name) {
auto ptr = new (std::nothrow) MockOsLibrary(name, nullptr);
if (ptr == nullptr) {
return nullptr;
}
return ptr;
}
};
using MetricInitializationTest = Test<MetricContextFixture>;
TEST_F(MetricInitializationTest, GivenOaDependenciesAreAvailableThenMetricInitializationIsSuccess) {
GlobalDriverHandle = static_cast<_ze_driver_handle_t *>(driverHandle.get());
EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
.Times(1)
.WillOnce(Return(ZE_RESULT_SUCCESS));
EXPECT_CALL(*mockMetricsLibrary, load())
.Times(1)
.WillOnce(Return(true));
OaMetricSourceImp::osLibraryLoadFunction = MockOsLibrary::load;
EXPECT_EQ(device->getMetricDeviceContext().enableMetricApi(), ZE_RESULT_SUCCESS);
OaMetricSourceImp::osLibraryLoadFunction = NEO::OsLibrary::load;
}
} // namespace ult
} // namespace L0

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

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -12,6 +12,7 @@
#include "level_zero/core/test/unit_tests/mocks/mock_cmdlist.h"
#include "level_zero/core/test/unit_tests/mocks/mock_device.h"
#include "level_zero/core/test/unit_tests/mocks/mock_driver_handle.h"
#include "level_zero/tools/source/metrics/metric_source_oa.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric.h"
#include "gmock/gmock.h"

11
level_zero/tools/test/unit_tests/sources/metrics/test_metric_query_pool_2.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -13,6 +13,7 @@
#include "level_zero/core/test/unit_tests/mocks/mock_cmdlist.h"
#include "level_zero/core/test/unit_tests/mocks/mock_device.h"
#include "level_zero/core/test/unit_tests/mocks/mock_driver_handle.h"
#include "level_zero/tools/source/metrics/metric_source_oa.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric.h"
#include "gmock/gmock.h"
@@ -395,8 +396,8 @@ TEST_F(MetricQueryPoolTest, givenExecutionQueryTypeAndMetricsLibraryWillFailWhen
TEST_F(MetricQueryPoolTest, givenRootDeviceWhenGetSubDeviceClientOptionsIsCalledThenReturnRootDeviceProperties) {
auto &metricContext = device->getMetricContext();
auto &metricsLibrary = metricContext.getMetricsLibrary();
auto &metricSource = device->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
auto &metricsLibrary = metricSource.getMetricsLibrary();
auto subDevice = ClientOptionsData_1_0{};
auto subDeviceIndex = ClientOptionsData_1_0{};
auto subDeviceCount = ClientOptionsData_1_0{};
@@ -420,8 +421,8 @@ TEST_F(MetricQueryPoolTest, givenRootDeviceWhenGetSubDeviceClientOptionsIsCalled
TEST_F(MetricQueryPoolTest, givenUninitializedMetricEnumerationWhenGetQueryReportGpuSizeIsCalledThenReturnInvalidSize) {
auto &metricContext = device->getMetricContext();
auto &metricsLibrary = metricContext.getMetricsLibrary();
auto &metricSource = device->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
auto &metricsLibrary = metricSource.getMetricsLibrary();
EXPECT_CALL(*mockMetricEnumeration, isInitialized())
.Times(1)

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

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -13,6 +13,7 @@
#include "level_zero/core/test/unit_tests/mocks/mock_cmdlist.h"
#include "level_zero/core/test/unit_tests/mocks/mock_device.h"
#include "level_zero/core/test/unit_tests/mocks/mock_driver_handle.h"
#include "level_zero/tools/source/metrics/metric_source_oa.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric.h"
#include "gmock/gmock.h"
@@ -53,8 +54,8 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenSubDeviceWhenGetSubDeviceClientOptio
// Sub devices
for (uint32_t i = 0, count = deviceImp.numSubDevices; i < count; ++i) {
auto &metricContext = deviceImp.subDevices[i]->getMetricContext();
auto &metricsLibrary = metricContext.getMetricsLibrary();
auto &metricSource = deviceImp.subDevices[i]->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
auto &metricsLibrary = metricSource.getMetricsLibrary();
metricsLibrary.getSubDeviceClientOptions(subDevice, subDeviceIndex, subDeviceCount, workloadPartition);
@@ -83,8 +84,8 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenSubDeviceWithWorkloadPartitionWhenGe
// Sub devices
for (uint32_t i = 0, count = deviceImp.numSubDevices; i < count; ++i) {
auto &metricContext = deviceImp.subDevices[i]->getMetricContext();
auto &metricsLibrary = metricContext.getMetricsLibrary();
auto &metricSource = deviceImp.subDevices[i]->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
auto &metricsLibrary = metricSource.getMetricsLibrary();
metricsLibrary.enableWorkloadPartition();
@@ -1224,8 +1225,8 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenInvalidCommandBufferGetWhenZetComman
TEST_F(MultiDeviceMetricQueryPoolTest, givenUninitializedMetricsLibraryWhenGetGpuCommandsIsCalledThenReturnsFail) {
auto &metricContext = devices[0]->getMetricContext();
auto &metricsLibrary = metricContext.getMetricsLibrary();
auto &metricSource = devices[0]->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
auto &metricsLibrary = metricSource.getMetricsLibrary();
CommandBufferData_1_0 commandBuffer = {};
EXPECT_CALL(*mockMetricEnumeration, isInitialized())

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

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -9,6 +9,7 @@
#include "level_zero/core/test/unit_tests/mocks/mock_cmdlist.h"
#include "level_zero/core/test/unit_tests/mocks/mock_driver.h"
#include "level_zero/tools/source/metrics/metric_source_oa.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric.h"
#include "gmock/gmock.h"
@@ -123,9 +124,9 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetMetricStreamerOpenIsCalledT
mockMetricsLibrary->initializationState = ZE_RESULT_SUCCESS;
auto &metricContext = device->getMetricContext();
EXPECT_TRUE(metricContext.loadDependencies());
EXPECT_TRUE(metricContext.isInitialized());
auto &metricSource = device->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
EXPECT_TRUE(metricSource.loadDependencies());
EXPECT_TRUE(metricSource.isInitialized());
uint32_t metricGroupCount = 0;
EXPECT_EQ(zetMetricGroupGet(metricDeviceHandle, &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
@@ -224,9 +225,9 @@ TEST_F(MetricStreamerTest, givenRawReportSizeAsZeroWhenZetMetricStreamerOpenIsCa
mockMetricsLibrary->initializationState = ZE_RESULT_SUCCESS;
auto &metricContext = device->getMetricContext();
EXPECT_TRUE(metricContext.loadDependencies());
EXPECT_TRUE(metricContext.isInitialized());
auto &metricSource = device->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
EXPECT_TRUE(metricSource.loadDependencies());
EXPECT_TRUE(metricSource.isInitialized());
uint32_t metricGroupCount = 0;
EXPECT_EQ(zetMetricGroupGet(metricDeviceHandle, &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);

1
level_zero/tools/test/unit_tests/sources/metrics/test_metric_streamer_2.cpp
View File

@@ -7,6 +7,7 @@
#include "shared/test/common/test_macros/test.h"
#include "level_zero/tools/source/metrics/metric_source_oa.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric.h"
using ::testing::_;