diff --git a/level_zero/api/tools/ze_tools_loader.cpp b/level_zero/api/tools/ze_tools_loader.cpp index e1d20aef5c..3402be9a4b 100644 --- a/level_zero/api/tools/ze_tools_loader.cpp +++ b/level_zero/api/tools/ze_tools_loader.cpp @@ -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; +} \ No newline at end of file diff --git a/level_zero/api/tools/zet_metric_api_entrypoints.h b/level_zero/api/tools/zet_metric_api_entrypoints.h index eeea777ca5..9047b71d17 100644 --- a/level_zero/api/tools/zet_metric_api_entrypoints.h +++ b/level_zero/api/tools/zet_metric_api_entrypoints.h @@ -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 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(device->getMetricDeviceContext()).metricGroupCreate(name, description, static_cast(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" diff --git a/level_zero/tools/source/metrics/metric.cpp b/level_zero/tools/source/metrics/metric.cpp index 03cc4c00fa..f9925fbbce 100644 --- a/level_zero/tools/source/metrics/metric.cpp +++ b/level_zero/tools/source/metrics/metric.cpp @@ -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(device->getMetricDeviceContext()).metricProgrammableGet(pCount, phMetricProgrammables); +} + } // namespace L0 diff --git a/level_zero/tools/source/metrics/metric.h b/level_zero/tools/source/metrics/metric.h index ade13ac2ec..d7b9706aa8 100644 --- a/level_zero/tools/source/metrics/metric.h +++ b/level_zero/tools/source/metrics/metric.h @@ -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 create(Device &device); static ze_result_t enableMetricApi(); + bool isProgrammableMetricsEnabled = false; + protected: std::map> 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(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(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 diff --git a/level_zero/tools/source/metrics/metric_device_context_create.cpp b/level_zero/tools/source/metrics/metric_device_context_create.cpp index c825937adb..f63bcf288e 100644 --- a/level_zero/tools/source/metrics/metric_device_context_create.cpp +++ b/level_zero/tools/source/metrics/metric_device_context_create.cpp @@ -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::create(Device &device) { return std::make_unique(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 \ No newline at end of file diff --git a/level_zero/tools/source/metrics/metric_ip_sampling_source.h b/level_zero/tools/source/metrics/metric_ip_sampling_source.h index cffe3b9974..f48ff952fd 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_source.h +++ b/level_zero/tools/source/metrics/metric_ip_sampling_source.h @@ -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 &metricIPSamplingpOsInterface); static std::unique_ptr 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; diff --git a/level_zero/tools/source/metrics/metric_oa_enumeration_imp.h b/level_zero/tools/source/metrics/metric_oa_enumeration_imp.h index 9c9aad038d..e36243d5fb 100644 --- a/level_zero/tools/source/metrics/metric_oa_enumeration_imp.h +++ b/level_zero/tools/source/metrics/metric_oa_enumeration_imp.h @@ -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); diff --git a/level_zero/tools/source/metrics/metric_oa_source.h b/level_zero/tools/source/metrics/metric_oa_source.h index ff85116ec2..59f7b69914 100644 --- a/level_zero/tools/source/metrics/metric_oa_source.h +++ b/level_zero/tools/source/metrics/metric_oa_source.h @@ -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); diff --git a/level_zero/tools/test/unit_tests/sources/metrics/CMakeLists.txt b/level_zero/tools/test/unit_tests/sources/metrics/CMakeLists.txt index dcafc90e7a..f6c71af31e 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/CMakeLists.txt +++ b/level_zero/tools/test/unit_tests/sources/metrics/CMakeLists.txt @@ -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 ) diff --git a/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_source.h b/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_source.h index 195522a713..740e15bf59 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_source.h +++ b/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_source.h @@ -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 diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_enumeration.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_enumeration.cpp index 4a08ead9e7..0ccca84907 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_enumeration.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_enumeration.cpp @@ -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 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(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(device))->getMetricDeviceContext().getMetricSource(); + + 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(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 diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_programmable.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_programmable.cpp new file mode 100644 index 0000000000..726142b15d --- /dev/null +++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_programmable.cpp @@ -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; + +TEST_F(MetricEnumerationProgrammableTest, whenProgrammableApisAreCalledUnsupportedErrorIsReturned) { + + // Metrics Discovery device. + metricsDeviceParams.ConcurrentGroupsCount = 1; + + // Metrics Discovery concurrent group. + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + metricsConcurrentGroupParams.MetricSetsCount = 1; + metricsConcurrentGroupParams.SymbolName = "OA"; + metricsConcurrentGroupParams.Description = "OA description"; + + // Metrics Discovery:: metric set. + Mock 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 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(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(); + 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, ¶meterCount, ¶meterInfo)); + 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, ¶meterValues, parameterCount, metricName, metricDescription, &metricHandleCount, nullptr)); +} + +} // namespace ult +} // namespace L0