Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

refactor: refactor metric programmable to use open source 

Related-To: NEO-10451

Signed-off-by: Joshua Santosh Ranjan <joshua.santosh.ranjan@intel.com>
This commit is contained in:
Joshua Santosh Ranjan 2024-02-29 19:38:12 +00:00 committed by Compute-Runtime-Automation
parent 39b1536f44
commit a3e60acc8f
12 changed files with 595 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
level_zero/api/tools/ze_tools_loader.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
* Copyright (C) 2020-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -237,5 +237,51 @@ zetGetMetricGroupExpProcAddrTable(
pDdiTable->pfnGetExportDataExp = L0::zetMetricGroupGetExportDataExp;
pDdiTable->pfnCalculateMetricExportDataExp = L0::zetDriverCalculateMetricExportDataExp;
if (version >= ZE_API_VERSION_1_9) {
pDdiTable->pfnCreateExp = L0::zetMetricGroupCreateExp;
pDdiTable->pfnAddMetricExp = L0::zetMetricGroupAddMetricExp;
pDdiTable->pfnRemoveMetricExp = L0::zetMetricGroupRemoveMetricExp;
pDdiTable->pfnCloseExp = L0::zetMetricGroupCloseExp;
pDdiTable->pfnDestroyExp = L0::zetMetricGroupDestroyExp;
}
return result;
}
ZE_DLLEXPORT ze_result_t ZE_APICALL
zetGetMetricProgrammableExpProcAddrTable(
ze_api_version_t version,
zet_metric_programmable_exp_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (version < ZE_API_VERSION_1_9) {
return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnGetExp = L0::zetMetricProgrammableGetExp;
pDdiTable->pfnGetPropertiesExp = L0::zetMetricProgrammableGetPropertiesExp;
pDdiTable->pfnGetParamInfoExp = L0::zetMetricProgrammableGetParamInfoExp;
pDdiTable->pfnGetParamValueInfoExp = L0::zetMetricProgrammableGetParamValueInfoExp;
return result;
}
ZE_DLLEXPORT ze_result_t ZE_APICALL
zetGetMetricExpProcAddrTable(
ze_api_version_t version,
zet_metric_exp_dditable_t *pDdiTable) {
if (nullptr == pDdiTable)
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
if (version < ZE_API_VERSION_1_9) {
return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
}
ze_result_t result = ZE_RESULT_SUCCESS;
pDdiTable->pfnCreateFromProgrammableExp = L0::zetMetricCreateFromProgrammableExp;
pDdiTable->pfnDestroyExp = L0::zetMetricDestroyExp;
return result;
}

186
level_zero/api/tools/zet_metric_api_entrypoints.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
* Copyright (C) 2020-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -14,6 +14,7 @@
#include <level_zero/zet_api.h>
namespace L0 {
ze_result_t zetMetricGroupGet(
zet_device_handle_t hDevice,
uint32_t *pCount,
@ -171,6 +172,100 @@ zetDriverCalculateMetricExportDataExp(
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t ZE_APICALL
zetMetricProgrammableGetExp(
zet_device_handle_t hDevice,
uint32_t *pCount,
zet_metric_programmable_exp_handle_t *phMetricProgrammables) {
return L0::metricProgrammableGet(hDevice, pCount, phMetricProgrammables);
}
ze_result_t ZE_APICALL
zetMetricProgrammableGetPropertiesExp(
zet_metric_programmable_exp_handle_t hMetricProgrammable,
zet_metric_programmable_exp_properties_t *pProperties) {
return L0::metricProgrammableGetProperties(hMetricProgrammable, pProperties);
}
ze_result_t ZE_APICALL
zetMetricProgrammableGetParamInfoExp(
zet_metric_programmable_exp_handle_t hMetricProgrammable,
uint32_t *pParameterCount,
zet_metric_programmable_param_info_exp_t *pParameterInfo) {
return L0::metricProgrammableGetParamInfo(hMetricProgrammable, pParameterCount, pParameterInfo);
}
ze_result_t ZE_APICALL
zetMetricProgrammableGetParamValueInfoExp(
zet_metric_programmable_exp_handle_t hMetricProgrammable,
uint32_t parameterOrdinal,
uint32_t *pValueInfoCount,
zet_metric_programmable_param_value_info_exp_t *pValueInfo) {
return L0::metricProgrammableGetParamValueInfo(hMetricProgrammable, parameterOrdinal, pValueInfoCount, pValueInfo);
}
ze_result_t ZE_APICALL
zetMetricCreateFromProgrammableExp(
zet_metric_programmable_exp_handle_t hMetricProgrammable,
zet_metric_programmable_param_value_exp_t *pParameterValues,
uint32_t parameterCount,
const char name[ZET_MAX_METRIC_NAME],
const char description[ZET_MAX_METRIC_DESCRIPTION],
uint32_t *pMetricHandleCount,
zet_metric_handle_t *phMetricHandles) {
return L0::metricCreateFromProgrammable(hMetricProgrammable, pParameterValues, parameterCount, name, description, pMetricHandleCount, phMetricHandles);
}
ze_result_t ZE_APICALL
zetMetricGroupCreateExp(
zet_device_handle_t hDevice,
const char *name,
const char *description,
zet_metric_group_sampling_type_flags_t samplingType,
zet_metric_group_handle_t *pMetricGroupHandle) {
auto device = Device::fromHandle(hDevice);
return static_cast<MetricDeviceContext &>(device->getMetricDeviceContext()).metricGroupCreate(name, description, static_cast<zet_metric_group_sampling_type_flag_t>(samplingType), pMetricGroupHandle);
}
ze_result_t ZE_APICALL
zetMetricGroupAddMetricExp(
zet_metric_group_handle_t hMetricGroup,
zet_metric_handle_t hMetric,
size_t *errorStringSize,
char *pErrorString) {
auto metricGroup = L0::MetricGroup::fromHandle(hMetricGroup);
return metricGroup->addMetric(hMetric, errorStringSize, pErrorString);
}
ze_result_t ZE_APICALL
zetMetricGroupRemoveMetricExp(
zet_metric_group_handle_t hMetricGroup,
zet_metric_handle_t hMetric) {
auto metricGroup = L0::MetricGroup::fromHandle(hMetricGroup);
return metricGroup->removeMetric(hMetric);
}
ze_result_t ZE_APICALL
zetMetricGroupCloseExp(
zet_metric_group_handle_t hMetricGroup) {
auto metricGroup = L0::MetricGroup::fromHandle(hMetricGroup);
return metricGroup->close();
}
ze_result_t ZE_APICALL
zetMetricGroupDestroyExp(
zet_metric_group_handle_t hMetricGroup) {
auto metricGroup = L0::MetricGroup::fromHandle(hMetricGroup);
return metricGroup->destroy();
}
ze_result_t ZE_APICALL
zetMetricDestroyExp(
zet_metric_handle_t hMetric) {
auto metric = L0::Metric::fromHandle(hMetric);
return metric->destroy();
}
} // namespace L0
extern "C" {
@ -386,4 +481,93 @@ zetDriverCalculateMetricExportDataExp(
return L0::zetDriverCalculateMetricExportDataExp(hDriver, type, exportDataSize, pExportData, pCalculateDescriptor,
pSetCount, pTotalMetricValueCount, pMetricCounts, pMetricValues);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetMetricProgrammableGetExp(
zet_device_handle_t hDevice,
uint32_t *pCount,
zet_metric_programmable_exp_handle_t *phMetricProgrammables) {
return L0::zetMetricProgrammableGetExp(hDevice, pCount, phMetricProgrammables);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetMetricProgrammableGetPropertiesExp(
zet_metric_programmable_exp_handle_t hMetricProgrammable,
zet_metric_programmable_exp_properties_t *pProperties) {
return L0::zetMetricProgrammableGetPropertiesExp(hMetricProgrammable, pProperties);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetMetricProgrammableGetParamInfoExp(
zet_metric_programmable_exp_handle_t hMetricProgrammable,
uint32_t *pParameterCount,
zet_metric_programmable_param_info_exp_t *pParameterInfo) {
return L0::zetMetricProgrammableGetParamInfoExp(hMetricProgrammable, pParameterCount, pParameterInfo);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetMetricProgrammableGetParamValueInfoExp(
zet_metric_programmable_exp_handle_t hMetricProgrammable,
uint32_t parameterOrdinal,
uint32_t *pValueInfoCount,
zet_metric_programmable_param_value_info_exp_t *pValueInfo) {
return L0::zetMetricProgrammableGetParamValueInfoExp(hMetricProgrammable, parameterOrdinal, pValueInfoCount, pValueInfo);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetMetricCreateFromProgrammableExp(
zet_metric_programmable_exp_handle_t hMetricProgrammable,
zet_metric_programmable_param_value_exp_t *pParameterValues,
uint32_t parameterCount,
const char name[ZET_MAX_METRIC_NAME],
const char description[ZET_MAX_METRIC_DESCRIPTION],
uint32_t *pMetricHandleCount,
zet_metric_handle_t *phMetricHandles) {
return L0::zetMetricCreateFromProgrammableExp(hMetricProgrammable, pParameterValues, parameterCount, name, description, pMetricHandleCount, phMetricHandles);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetMetricGroupCreateExp(
zet_device_handle_t hDevice,
const char *name,
const char *description,
zet_metric_group_sampling_type_flags_t samplingType,
zet_metric_group_handle_t *pMetricGroupHandle) {
return L0::zetMetricGroupCreateExp(hDevice, name, description, samplingType, pMetricGroupHandle);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetMetricGroupAddMetricExp(
zet_metric_group_handle_t hMetricGroup,
zet_metric_handle_t hMetric,
size_t *errorStringSize,
char *pErrorString) {
return L0::zetMetricGroupAddMetricExp(hMetricGroup, hMetric, errorStringSize, pErrorString);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetMetricGroupRemoveMetricExp(
zet_metric_group_handle_t hMetricGroup,
zet_metric_handle_t hMetric) {
return L0::zetMetricGroupRemoveMetricExp(hMetricGroup, hMetric);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetMetricGroupCloseExp(
zet_metric_group_handle_t hMetricGroup) {
return L0::zetMetricGroupCloseExp(hMetricGroup);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetMetricGroupDestroyExp(
zet_metric_group_handle_t hMetricGroup) {
return L0::zetMetricGroupDestroyExp(hMetricGroup);
}
ZE_APIEXPORT ze_result_t ZE_APICALL
zetMetricDestroyExp(
zet_metric_handle_t hMetric) {
return L0::zetMetricDestroyExp(hMetric);
}
} // extern "C"

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
* Copyright (C) 2020-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -358,4 +358,9 @@ void MetricCollectorEventNotify::detachEvent() {
}
}
ze_result_t metricProgrammableGet(zet_device_handle_t hDevice, uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables) {
auto device = Device::fromHandle(hDevice);
return static_cast<MetricDeviceContext &>(device->getMetricDeviceContext()).metricProgrammableGet(pCount, phMetricProgrammables);
}
} // namespace L0

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
* Copyright (C) 2020-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -20,6 +20,7 @@ struct _zet_metric_handle_t {};
struct _zet_metric_streamer_handle_t {};
struct _zet_metric_query_pool_handle_t {};
struct _zet_metric_query_handle_t {};
struct _zet_metric_programmable_exp_handle_t {};
namespace L0 {
struct CommandList;
@ -41,6 +42,11 @@ class MetricSource {
virtual ze_result_t getTimestampValidBits(uint64_t &validBits) = 0;
virtual ze_result_t activateMetricGroupsPreferDeferred(uint32_t count, zet_metric_group_handle_t *phMetricGroups) = 0;
virtual ze_result_t activateMetricGroupsAlreadyDeferred() = 0;
virtual ze_result_t metricProgrammableGet(uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables) = 0;
virtual ze_result_t metricGroupCreate(const char name[ZET_MAX_METRIC_GROUP_NAME],
const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION],
zet_metric_group_sampling_type_flag_t samplingType,
zet_metric_group_handle_t *pMetricGroupHandle) = 0;
virtual ~MetricSource() = default;
uint32_t getType() const {
return type;
@ -71,10 +77,16 @@ class MetricDeviceContext {
public:
MetricDeviceContext(Device &device);
virtual ~MetricDeviceContext() {}
ze_result_t metricGroupGet(uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups);
ze_result_t activateMetricGroupsPreferDeferred(uint32_t count, zet_metric_group_handle_t *phMetricGroups);
ze_result_t activateMetricGroups();
ze_result_t appendMetricMemoryBarrier(CommandList &commandList);
ze_result_t metricProgrammableGet(uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables);
ze_result_t metricGroupCreate(const char name[ZET_MAX_METRIC_GROUP_NAME],
const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION],
zet_metric_group_sampling_type_flag_t samplingType,
zet_metric_group_handle_t *pMetricGroupHandle);
bool isImplicitScalingCapable() const;
Device &getDevice() const;
uint32_t getSubDeviceIndex() const;
@ -85,6 +97,8 @@ class MetricDeviceContext {
static std::unique_ptr<MetricDeviceContext> create(Device &device);
static ze_result_t enableMetricApi();
bool isProgrammableMetricsEnabled = false;
protected:
std::map<uint32_t, std::unique_ptr<MetricSource>> metricSources;
@ -99,7 +113,7 @@ struct Metric : _zet_metric_handle_t {
virtual ~Metric() = default;
virtual ze_result_t getProperties(zet_metric_properties_t *pProperties) = 0;
virtual ze_result_t destroy() = 0;
static Metric *fromHandle(zet_metric_handle_t handle) { return static_cast<Metric *>(handle); }
inline zet_metric_handle_t toHandle() { return this; }
};
@ -120,7 +134,10 @@ struct MetricGroup : _zet_metric_group_handle_t {
virtual ze_result_t getMetricTimestampsExp(const ze_bool_t synchronizedWithHost,
uint64_t *globalTimestamp,
uint64_t *metricTimestamp) = 0;
virtual ze_result_t addMetric(zet_metric_handle_t hMetric, size_t *errorStringSize, char *pErrorString) = 0;
virtual ze_result_t removeMetric(zet_metric_handle_t hMetric) = 0;
virtual ze_result_t close() = 0;
virtual ze_result_t destroy() = 0;
static MetricGroup *fromHandle(zet_metric_group_handle_t handle) {
return static_cast<MetricGroup *>(handle);
}
@ -226,4 +243,22 @@ ze_result_t metricStreamerOpen(zet_context_handle_t hContext, zet_device_handle_
ze_result_t metricQueryPoolCreate(zet_context_handle_t hContext, zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup,
const zet_metric_query_pool_desc_t *pDesc, zet_metric_query_pool_handle_t *phMetricQueryPool);
// MetricProgrammable
ze_result_t metricProgrammableGet(zet_device_handle_t hDevice, uint32_t *pCount,
zet_metric_programmable_exp_handle_t *phMetricProgrammables);
ze_result_t metricProgrammableGetProperties(zet_metric_programmable_exp_handle_t hMetricProgrammable,
zet_metric_programmable_exp_properties_t *pProperties);
ze_result_t metricProgrammableGetParamInfo(zet_metric_programmable_exp_handle_t hMetricProgrammable,
uint32_t *pParameterCount, zet_metric_programmable_param_info_exp_t *pParameterInfo);
ze_result_t metricProgrammableGetParamValueInfo(zet_metric_programmable_exp_handle_t hMetricProgrammable,
uint32_t parameterOrdinal, uint32_t *pValueInfoCount, zet_metric_programmable_param_value_info_exp_t *pValueInfo);
ze_result_t metricCreateFromProgrammable(zet_metric_programmable_exp_handle_t hMetricProgrammable,
zet_metric_programmable_param_value_exp_t *pParameterValues, uint32_t parameterCount,
const char name[ZET_MAX_METRIC_NAME], const char description[ZET_MAX_METRIC_DESCRIPTION],
uint32_t *pMetricHandleCount, zet_metric_handle_t *phMetricHandles);
} // namespace L0

59
level_zero/tools/source/metrics/metric_device_context_create.cpp
View File

@ -1,16 +1,71 @@
/*
* Copyright (C) 2023 Intel Corporation
* Copyright (C) 2023-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/tools/source/metrics/metric.h"
#include "level_zero/tools/source/metrics/metric_oa_source.h"
namespace L0 {
std::unique_ptr<MetricDeviceContext> MetricDeviceContext::create(Device &device) {
return std::make_unique<MetricDeviceContext>(device);
}
ze_result_t MetricDeviceContext::metricProgrammableGet(
uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t MetricDeviceContext::metricGroupCreate(const char name[ZET_MAX_METRIC_GROUP_NAME],
const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION],
zet_metric_group_sampling_type_flag_t samplingType,
zet_metric_group_handle_t *pMetricGroupHandle) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t OaMetricSourceImp::metricProgrammableGet(uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t OaMetricSourceImp::metricGroupCreate(const char name[ZET_MAX_METRIC_GROUP_NAME],
const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION],
zet_metric_group_sampling_type_flag_t samplingType,
zet_metric_group_handle_t *pMetricGroupHandle) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t metricProgrammableGetProperties(
zet_metric_programmable_exp_handle_t hMetricProgrammable,
zet_metric_programmable_exp_properties_t *pProperties) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t metricProgrammableGetParamInfo(
zet_metric_programmable_exp_handle_t hMetricProgrammable,
uint32_t *pParameterCount,
zet_metric_programmable_param_info_exp_t *pParameterInfo) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t metricProgrammableGetParamValueInfo(
zet_metric_programmable_exp_handle_t hMetricProgrammable,
uint32_t parameterOrdinal,
uint32_t *pValueInfoCount,
zet_metric_programmable_param_value_info_exp_t *pValueInfo) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t metricCreateFromProgrammable(
zet_metric_programmable_exp_handle_t hMetricProgrammable,
zet_metric_programmable_param_value_exp_t *pParameterValues,
uint32_t parameterCount,
const char name[ZET_MAX_METRIC_NAME],
const char description[ZET_MAX_METRIC_DESCRIPTION],
uint32_t *pMetricHandleCount,
zet_metric_handle_t *phMetricHandles) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
} // namespace L0

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2022-2023 Intel Corporation
* Copyright (C) 2022-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -28,6 +28,15 @@ class IpSamplingMetricSourceImp : public MetricSource {
ze_result_t activateMetricGroupsAlreadyDeferred() override;
ze_result_t activateMetricGroupsPreferDeferred(const uint32_t count,
zet_metric_group_handle_t *phMetricGroups) override;
ze_result_t metricProgrammableGet(uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t metricGroupCreate(const char name[ZET_MAX_METRIC_GROUP_NAME],
const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION],
zet_metric_group_sampling_type_flag_t samplingType,
zet_metric_group_handle_t *pMetricGroupHandle) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
bool isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) const;
void setMetricOsInterface(std::unique_ptr<MetricIpSamplingOsInterface> &metricIPSamplingpOsInterface);
static std::unique_ptr<IpSamplingMetricSourceImp> create(const MetricDeviceContext &metricDeviceContext);
@ -75,6 +84,18 @@ struct IpSamplingMetricGroupBase : public MetricGroupImp {
const zet_metric_query_pool_desc_t *desc,
zet_metric_query_pool_handle_t *phMetricQueryPool) override { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; }
ze_result_t getExportData(const uint8_t *pRawData, size_t rawDataSize, size_t *pExportDataSize, uint8_t *pExportData) override;
ze_result_t addMetric(zet_metric_handle_t hMetric, size_t *errorStringSize, char *pErrorString) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t removeMetric(zet_metric_handle_t hMetric) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t close() override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t destroy() override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
};
struct IpSamplingMetricGroupImp : public IpSamplingMetricGroupBase {
@ -154,6 +175,9 @@ struct IpSamplingMetricImp : public Metric {
~IpSamplingMetricImp() override = default;
IpSamplingMetricImp(zet_metric_properties_t &properties);
ze_result_t getProperties(zet_metric_properties_t *pProperties) override;
ze_result_t destroy() override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
private:
zet_metric_properties_t properties;

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
* Copyright (C) 2020-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -121,7 +121,7 @@ struct MetricEnumeration {
static const char *oaConcurrentGroupName;
};
struct OaMetricGroupImp : MetricGroupImp {
struct OaMetricGroupImp : public MetricGroupImp {
~OaMetricGroupImp() override;
OaMetricGroupImp(MetricSource &metricSource) : MetricGroupImp(metricSource) {}
@ -137,6 +137,18 @@ struct OaMetricGroupImp : MetricGroupImp {
ze_result_t getMetricTimestampsExp(const ze_bool_t synchronizedWithHost,
uint64_t *globalTimestamp,
uint64_t *metricTimestamp) override;
ze_result_t addMetric(zet_metric_handle_t hMetric, size_t *errorStringSize, char *pErrorString) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t removeMetric(zet_metric_handle_t hMetric) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t close() override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t destroy() override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t initialize(const zet_metric_group_properties_t &sourceProperties,
MetricsDiscovery::IMetricSet_1_5 &metricSet,
MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup,
@ -214,11 +226,15 @@ struct OaMetricGroupImp : MetricGroupImp {
zet_metric_streamer_handle_t *phMetricStreamer);
};
struct OaMetricImp : Metric {
struct OaMetricImp : public Metric {
~OaMetricImp() override{};
ze_result_t getProperties(zet_metric_properties_t *pProperties) override;
ze_result_t destroy() override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t initialize(const zet_metric_properties_t &sourceProperties);
static Metric *create(zet_metric_properties_t &properties);

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2022-2023 Intel Corporation
* Copyright (C) 2022-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -44,6 +44,11 @@ class OaMetricSourceImp : public MetricSource {
ze_result_t activateMetricGroupsAlreadyDeferred() override;
ze_result_t activateMetricGroupsPreferDeferred(const uint32_t count,
zet_metric_group_handle_t *phMetricGroups) override;
ze_result_t metricProgrammableGet(uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables) override;
ze_result_t metricGroupCreate(const char name[ZET_MAX_METRIC_GROUP_NAME],
const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION],
zet_metric_group_sampling_type_flag_t samplingType,
zet_metric_group_handle_t *pMetricGroupHandle) override;
bool isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) const;
bool isMetricGroupActivatedInHw() const;
void setUseCompute(const bool useCompute);

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

@ -1,5 +1,5 @@
#
# Copyright (C) 2020-2023 Intel Corporation
# Copyright (C) 2020-2024 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
@ -29,6 +29,7 @@ target_sources(${TARGET_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/test_metric_ip_sampling_enumeration.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_metric_ip_sampling_streamer.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_metric_oa_export.cpp
${CMAKE_CURRENT_SOURCE_DIR}/${BRANCH_DIR_SUFFIX}/test_metric_programmable.cpp
)

23
level_zero/tools/test/unit_tests/sources/metrics/mock_metric_source.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
* Copyright (C) 2020-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -21,6 +21,15 @@ class MockMetricSource : public L0::MetricSource {
ze_result_t getTimestampValidBits(uint64_t &validBits) override { return ZE_RESULT_ERROR_UNKNOWN; }
ze_result_t activateMetricGroupsPreferDeferred(uint32_t count, zet_metric_group_handle_t *phMetricGroups) override { return ZE_RESULT_ERROR_UNKNOWN; }
ze_result_t activateMetricGroupsAlreadyDeferred() override { return ZE_RESULT_ERROR_UNKNOWN; }
ze_result_t metricProgrammableGet(uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t metricGroupCreate(const char name[ZET_MAX_METRIC_GROUP_NAME],
const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION],
zet_metric_group_sampling_type_flag_t samplingType,
zet_metric_group_handle_t *pMetricGroupHandle) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
~MockMetricSource() override = default;
};
@ -81,6 +90,18 @@ class MockMetricGroup : public L0::MetricGroupImp {
uint8_t *pExportData) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t addMetric(zet_metric_handle_t hMetric, size_t *errorStringSize, char *pErrorString) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t removeMetric(zet_metric_handle_t hMetric) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t close() override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t destroy() override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
};
} // namespace ult

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2022-2023 Intel Corporation
* Copyright (C) 2022-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -167,6 +167,7 @@ TEST_F(MetricIpSamplingEnumerationTest, GivenDependenciesAvailableWhenMetricGrou
zet_metric_properties_t ipSamplingMetricProperties = {};
for (auto &metricHandle : metricHandles) {
EXPECT_EQ(zetMetricGetProperties(metricHandle, &ipSamplingMetricProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(zetMetricDestroyExp(metricHandle), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
EXPECT_EQ(strcmp(ipSamplingMetricProperties.name, propertiesIter->name), 0);
EXPECT_EQ(strcmp(ipSamplingMetricProperties.description, propertiesIter->description), 0);
EXPECT_EQ(strcmp(ipSamplingMetricProperties.component, propertiesIter->component), 0);
@ -200,6 +201,34 @@ TEST_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulThenDummyAct
}
}
TEST_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulThenUnsupportedApisForMetricGroupReturnsFailure) {
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
for (auto device : testDevices) {
uint32_t metricGroupCount = 0;
zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr);
std::vector<zet_metric_group_handle_t> metricGroups;
metricGroups.resize(metricGroupCount);
ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
ASSERT_NE(metricGroups[0], nullptr);
zet_metric_handle_t hMetric{};
EXPECT_EQ(zetMetricGroupAddMetricExp(metricGroups[0], hMetric, nullptr, nullptr), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
EXPECT_EQ(zetMetricGroupRemoveMetricExp(metricGroups[0], hMetric), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
EXPECT_EQ(zetMetricGroupCloseExp(metricGroups[0]), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
EXPECT_EQ(zetMetricGroupDestroyExp(metricGroups[0]), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
EXPECT_EQ(zetContextActivateMetricGroups(context->toHandle(), device->toHandle(), 1, &metricGroups[0]), ZE_RESULT_SUCCESS);
static_cast<DeviceImp *>(device)->activateMetricGroups();
EXPECT_EQ(zetContextActivateMetricGroups(context->toHandle(), device->toHandle(), 0, nullptr), ZE_RESULT_SUCCESS);
}
}
TEST_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulWhenReadingMetricsFrequencyAndValidBitsThenConfirmAreTheSameAsDevice) {
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
@ -1087,5 +1116,41 @@ TEST_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulAndActivatio
}
}
TEST_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulWhenUnsupportedFunctionsAreCalledErrorIsReturned) {
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
for (auto device : testDevices) {
auto &metricSource = (static_cast<DeviceImp *>(device))->getMetricDeviceContext().getMetricSource<IpSamplingMetricSourceImp>();
char name[ZET_MAX_METRIC_GROUP_NAME] = {};
char description[ZET_MAX_METRIC_GROUP_DESCRIPTION] = {};
zet_metric_group_sampling_type_flag_t samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
zet_metric_group_handle_t *pMetricGroupHandle = nullptr;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, metricSource.metricGroupCreate(
name, description, samplingType, pMetricGroupHandle));
uint32_t count = 0;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, metricSource.metricProgrammableGet(
&count, nullptr));
}
}
TEST_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulWhenUnsupportedFunctionsForDeviceContextAreCalledErrorIsReturned) {
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
for (auto device : testDevices) {
auto &deviceContext = (static_cast<DeviceImp *>(device))->getMetricDeviceContext();
char name[ZET_MAX_METRIC_GROUP_NAME] = {};
char description[ZET_MAX_METRIC_GROUP_DESCRIPTION] = {};
zet_metric_group_sampling_type_flag_t samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
zet_metric_group_handle_t *pMetricGroupHandle = nullptr;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, deviceContext.metricGroupCreate(
name, description, samplingType, pMetricGroupHandle));
uint32_t count = 0;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, deviceContext.metricProgrammableGet(
&count, nullptr));
}
}
} // namespace ult
} // namespace L0

122
level_zero/tools/test/unit_tests/sources/metrics/test_metric_programmable.cpp Normal file
View File

@ -0,0 +1,122 @@
/*
* Copyright (C) 2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/test/common/test_macros/test.h"
#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_oa_source.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.h"
#include "gtest/gtest.h"
namespace L0 {
namespace ult {
using MetricEnumerationProgrammableTest = Test<MetricMultiDeviceFixture>;
TEST_F(MetricEnumerationProgrammableTest, whenProgrammableApisAreCalledUnsupportedErrorIsReturned) {
// Metrics Discovery device.
metricsDeviceParams.ConcurrentGroupsCount = 1;
// Metrics Discovery concurrent group.
Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
metricsConcurrentGroupParams.MetricSetsCount = 1;
metricsConcurrentGroupParams.SymbolName = "OA";
metricsConcurrentGroupParams.Description = "OA description";
// Metrics Discovery:: metric set.
Mock<MetricsDiscovery::IMetricSet_1_5> metricsSet;
MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
metricsSetParams.MetricsCount = 0;
metricsSetParams.SymbolName = "Metric set name";
metricsSetParams.ShortName = "Metric set description";
metricsSetParams.MetricsCount = 1;
// Metrics Discovery:: metric.
Mock<IMetric_1_0> metric;
TMetricParams_1_0 metricParams = {};
metricParams.SymbolName = "Metric symbol name";
metricParams.ShortName = "Metric short name";
metricParams.LongName = "Metric long name";
metricParams.ResultType = MetricsDiscovery::TMetricResultType::RESULT_UINT64;
metricParams.MetricType = MetricsDiscovery::TMetricType::METRIC_TYPE_RATIO;
// One api: metric group handle.
zet_metric_group_handle_t metricGroupHandle = {};
openMetricsAdapter();
setupDefaultMocksForMetricDevice(metricsDevice);
metricsDevice.getConcurrentGroupResults.push_back(&metricsConcurrentGroup);
metricsConcurrentGroup.GetParamsResult = &metricsConcurrentGroupParams;
metricsConcurrentGroup.getMetricSetResult = &metricsSet;
metricsSet.GetParamsResult = &metricsSetParams;
metricsSet.GetMetricResult = &metric;
metric.GetParamsResult = &metricParams;
// Metric group count.
uint32_t metricGroupCount = 0;
EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
// Metric group handle.
EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
// Obtain metric.
uint32_t metricCount = 0;
zet_metric_handle_t metricHandle = {};
EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricCount, 1u);
EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, &metricHandle), ZE_RESULT_SUCCESS);
EXPECT_NE(metricHandle, nullptr);
EXPECT_TRUE(static_cast<OaMetricImp *>(metricHandle)->isImmutable());
EXPECT_EQ(zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle, nullptr, nullptr), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
EXPECT_EQ(zetMetricGroupRemoveMetricExp(metricGroupHandle, metricHandle), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
EXPECT_EQ(zetMetricGroupCloseExp(metricGroupHandle), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
EXPECT_EQ(zetMetricGroupDestroyExp(metricGroupHandle), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
EXPECT_EQ(zetMetricDestroyExp(metricHandle), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
auto &metricSource = devices[0]->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
char name[ZET_MAX_METRIC_GROUP_NAME] = {};
char description[ZET_MAX_METRIC_GROUP_DESCRIPTION] = {};
zet_metric_group_sampling_type_flag_t samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
zet_metric_group_handle_t *pMetricGroupHandle = nullptr;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, metricSource.metricGroupCreate(
name, description, samplingType, pMetricGroupHandle));
uint32_t count = 0;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, metricSource.metricProgrammableGet(
&count, nullptr));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetMetricProgrammableGetExp(devices[0]->toHandle(), &count, nullptr));
zet_metric_programmable_exp_handle_t hMetricProgrammable{};
zet_metric_programmable_exp_properties_t properties{};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetMetricProgrammableGetPropertiesExp(hMetricProgrammable, &properties));
uint32_t parameterCount{};
zet_metric_programmable_param_info_exp_t parameterInfo{};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetMetricProgrammableGetParamInfoExp(hMetricProgrammable, &parameterCount, &parameterInfo));
uint32_t parameterOrdinal{};
uint32_t valueInfoCount{};
zet_metric_programmable_param_value_info_exp_t valueInfo{};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetMetricProgrammableGetParamValueInfoExp(hMetricProgrammable, parameterOrdinal, &valueInfoCount, &valueInfo));
zet_metric_programmable_param_value_exp_t parameterValues{};
const char metricName[ZET_MAX_METRIC_NAME] = "";
const char metricDescription[ZET_MAX_METRIC_DESCRIPTION] = "";
uint32_t metricHandleCount = 0;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetMetricCreateFromProgrammableExp(hMetricProgrammable, &parameterValues, parameterCount, metricName, metricDescription, &metricHandleCount, nullptr));
}
} // namespace ult
} // namespace L0