From c9e48d0d2b070c0c4fb54203ce4bfb192b301d56 Mon Sep 17 00:00:00 2001 From: Joshua Santosh Ranjan Date: Wed, 23 Oct 2024 14:52:02 +0000 Subject: [PATCH] refactor: support oa programmable metric group Related-To: NEO-12184 Signed-off-by: Joshua Santosh Ranjan --- .../driver_experimental/public/zex_metric.cpp | 30 + .../driver/extension_function_address.cpp | 1 + level_zero/include/zet_intel_gpu_metric.h | 30 + .../tools/source/metrics/CMakeLists.txt | 5 + .../os_metric_oa_enumeration_imp_linux.cpp | 2 +- .../os_metric_oa_enumeration_imp_linux.h | 2 +- level_zero/tools/source/metrics/metric.cpp | 309 +++ level_zero/tools/source/metrics/metric.h | 79 + .../metrics/metric_device_context_create.cpp | 51 +- .../metrics/metric_ip_sampling_source.h | 8 + .../metric_multidevice_programmable.cpp | 219 ++ .../metrics/metric_multidevice_programmable.h | 43 + .../metric_multidevice_programmable.inl | 137 ++ .../metrics/metric_oa_enumeration_imp.cpp | 129 +- .../metrics/metric_oa_enumeration_imp.h | 86 +- .../metrics/metric_oa_programmable_imp.cpp | 591 ++++++ .../metrics/metric_oa_programmable_imp.h | 108 + .../tools/source/metrics/metric_oa_source.cpp | 162 ++ .../tools/source/metrics/metric_oa_source.h | 12 + .../metrics/os_metric_oa_enumeration_drm.cpp | 2 +- .../os_metric_oa_enumeration_drm_or_wddm.cpp | 2 +- .../os_metric_oa_enumeration_imp_drm.cpp | 2 +- .../metrics/os_metric_oa_enumeration_wddm.cpp | 2 +- .../os_metric_oa_enumeration_imp_wddm.cpp | 2 +- .../wddm/os_metric_oa_enumeration_imp_wddm.h | 2 +- .../zello_metrics/CMakeLists.txt | 1 + .../zello_metrics_programmable_tests.cpp | 964 +++++++++ .../unit_tests/sources/metrics/CMakeLists.txt | 8 +- .../sources/metrics/linux/CMakeLists.txt | 2 +- .../linux/test_metric_oa_query_pool_linux.cpp | 8 +- .../metrics/mock_metric_ip_sampling_source.h | 68 + .../sources/metrics/mock_metric_oa.cpp | 6 +- .../sources/metrics/mock_metric_oa.h | 16 +- .../metrics/mock_metric_oa_enumeration.cpp | 233 ++- .../metrics/mock_metric_oa_enumeration.h | 68 +- .../metrics/mock_metric_oa_programmable.cpp | 300 +++ .../metrics/mock_metric_oa_programmable.h | 140 ++ .../sources/metrics/mock_metric_source.h | 8 + .../sources/metrics/test_metric_group.cpp | 111 + .../test_metric_ip_sampling_enumeration.cpp | 13 + .../metrics/test_metric_oa_enumeration_1.cpp | 456 ++-- .../metrics/test_metric_oa_enumeration_2.cpp | 192 +- .../sources/metrics/test_metric_oa_export.cpp | 34 +- .../metrics/test_metric_oa_query_pool_2.cpp | 20 +- .../metrics/test_metric_oa_query_pool_3.cpp | 72 +- .../metrics/test_metric_oa_query_pool_4.cpp | 48 +- .../metrics/test_metric_oa_query_pool_5.cpp | 36 +- .../metrics/test_metric_oa_streamer_1.cpp | 124 +- .../metrics/test_metric_oa_streamer_2.cpp | 72 +- .../metrics/test_metric_oa_streamer_3.cpp | 28 +- .../metrics/test_metric_programmable.cpp | 1847 +++++++++++++++-- .../test_multidevice_metric_programmable.cpp | 970 +++++++++ .../debug_settings/debug_variables_base.inl | 1 + shared/test/common/test_files/igdrcl.config | 1 + 54 files changed, 7067 insertions(+), 796 deletions(-) create mode 100644 level_zero/tools/source/metrics/metric_multidevice_programmable.cpp create mode 100644 level_zero/tools/source/metrics/metric_multidevice_programmable.h create mode 100644 level_zero/tools/source/metrics/metric_multidevice_programmable.inl create mode 100644 level_zero/tools/source/metrics/metric_oa_programmable_imp.cpp create mode 100644 level_zero/tools/source/metrics/metric_oa_programmable_imp.h create mode 100644 level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_programmable_tests.cpp create mode 100644 level_zero/tools/test/unit_tests/sources/metrics/mock_metric_ip_sampling_source.h create mode 100644 level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_programmable.cpp create mode 100644 level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_programmable.h create mode 100644 level_zero/tools/test/unit_tests/sources/metrics/test_metric_group.cpp create mode 100644 level_zero/tools/test/unit_tests/sources/metrics/test_multidevice_metric_programmable.cpp diff --git a/level_zero/api/driver_experimental/public/zex_metric.cpp b/level_zero/api/driver_experimental/public/zex_metric.cpp index bb8b76fe58..3331c1c00b 100644 --- a/level_zero/api/driver_experimental/public/zex_metric.cpp +++ b/level_zero/api/driver_experimental/public/zex_metric.cpp @@ -8,6 +8,7 @@ #include "level_zero/core/source/device/device.h" #include "level_zero/include/zet_intel_gpu_metric.h" #include "level_zero/tools/source/metrics/metric.h" +#include "level_zero/tools/source/metrics/metric_oa_programmable_imp.h" namespace L0 { @@ -23,6 +24,21 @@ zetIntelDeviceGetConcurrentMetricGroupsExp( return static_cast(device->getMetricDeviceContext()).getConcurrentMetricGroups(metricGroupCount, phMetricGroups, pConcurrentGroupCount, pCountPerConcurrentGroup); } +ze_result_t ZE_APICALL +zetIntelDeviceCreateMetricGroupsFromMetricsExp( + zet_device_handle_t hDevice, + uint32_t metricCount, + zet_metric_handle_t *phMetrics, + const char metricGroupNamePrefix[ZET_INTEL_MAX_METRIC_GROUP_NAME_PREFIX_EXP], + const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION], + uint32_t *pMetricGroupCount, + zet_metric_group_handle_t *phMetricGroups) { + + hDevice = toInternalType(hDevice); + auto device = Device::fromHandle(hDevice); + return device->getMetricDeviceContext().createMetricGroupsFromMetrics(metricCount, phMetrics, metricGroupNamePrefix, description, pMetricGroupCount, phMetricGroups); +} + } // namespace L0 extern "C" { @@ -39,4 +55,18 @@ zetIntelDeviceGetConcurrentMetricGroupsExp( pConcurrentGroupCount, pCountPerConcurrentGroup); } +ze_result_t ZE_APICALL +zetIntelDeviceCreateMetricGroupsFromMetricsExp( + zet_device_handle_t hDevice, + uint32_t metricCount, + zet_metric_handle_t *phMetrics, + const char metricGroupNamePrefix[ZET_INTEL_MAX_METRIC_GROUP_NAME_PREFIX_EXP], + const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION], + uint32_t *metricGroupCount, + zet_metric_group_handle_t *phMetricGroups) { + + return L0::zetIntelDeviceCreateMetricGroupsFromMetricsExp( + hDevice, metricCount, phMetrics, metricGroupNamePrefix, description, metricGroupCount, phMetricGroups); +} + } // extern "C" diff --git a/level_zero/core/source/driver/extension_function_address.cpp b/level_zero/core/source/driver/extension_function_address.cpp index 8b423df464..1207da5249 100644 --- a/level_zero/core/source/driver/extension_function_address.cpp +++ b/level_zero/core/source/driver/extension_function_address.cpp @@ -45,6 +45,7 @@ void *ExtensionFunctionAddressHelper::getExtensionFunctionAddress(const std::str RETURN_FUNC_PTR_IF_EXIST(zeMemGetPitchFor2dImage); RETURN_FUNC_PTR_IF_EXIST(zeImageGetDeviceOffsetExp); RETURN_FUNC_PTR_IF_EXIST(zetIntelDeviceGetConcurrentMetricGroupsExp); + RETURN_FUNC_PTR_IF_EXIST(zetIntelDeviceCreateMetricGroupsFromMetricsExp); RETURN_FUNC_PTR_IF_EXIST(zeIntelGetDriverVersionString); RETURN_FUNC_PTR_IF_EXIST(zeIntelMediaCommunicationCreate); diff --git a/level_zero/include/zet_intel_gpu_metric.h b/level_zero/include/zet_intel_gpu_metric.h index 36e97a7d74..7097fe5c0d 100644 --- a/level_zero/include/zet_intel_gpu_metric.h +++ b/level_zero/include/zet_intel_gpu_metric.h @@ -20,6 +20,12 @@ extern "C" { #define ZET_INTEL_GPU_METRIC_VERSION_MAJOR 0 #define ZET_INTEL_GPU_METRIC_VERSION_MINOR 1 +#define ZET_INTEL_MAX_METRIC_GROUP_NAME_PREFIX_EXP 64u +#define ZET_INTEL_METRIC_PROGRAMMABLE_PARAM_TYPE_NORMALIZATION_BYTE_EXP (0x5) +#define ZET_INTEL_VALUE_INFO_TYPE_FLOAT64_RANGE_EXP (0x7ffffffe) +#define ZET_INTEL_METRIC_PROGRAMMABLE_PARAM_TYPE_GENERIC_EXP (0x7ffffffe) +#define ZET_INTEL_MAX_METRIC_PROGRAMMABLE_VALUE_DESCRIPTION_EXP (128) +#define ZET_INTEL_STRUCTURE_TYPE_METRIC_PROGRAMMABLE_PARAM_VALUE_INFO_DESC_EXP (0x00010006) #define ZET_INTEL_STRUCTURE_TYPE_METRIC_GROUP_TYPE_EXP (static_cast(0x00010006)) #define ZET_INTEL_STRUCTURE_TYPE_EXPORT_DMA_PROPERTIES_EXP (static_cast(0x00010007)) #define ZET_INTEL_METRIC_TYPE_EXPORT_DMA_BUF (0x7ffffffd) @@ -42,6 +48,20 @@ typedef struct _zet_intel_metric_group_type_exp_t { zet_intel_metric_group_type_exp_flags_t type; //[out] metric group type } zet_intel_metric_group_type_exp_t; +typedef enum _zet_intel_metric_sampling_type_exp_flag_t { + ZET_INTEL_METRIC_SAMPLING_TYPE_EXP_FLAG_EVENT_BASED = ZE_BIT(0), ///< Event based sampling + ZET_INTEL_METRIC_SAMPLING_TYPE_EXP_FLAG_TIME_BASED = ZE_BIT(1), ///< Time based sampling + ZET_INTEL_METRIC_SAMPLING_TYPE_EXP_FLAG_TIME_AND_EVENT_BASED = ZE_BIT(0) | ZE_BIT(1), + ZET_INTEL_METRIC_SAMPLING_TYPE_EXP_FLAG_FORCE_UINT32 = 0x7fffffff +} zet_intel_metric_sampling_type_exp_flag_t; + +typedef struct _zet_intel_metric_programmable_param_value_info_exp_desc_t { + zet_structure_type_t stype; ///< [in] type of this structure + const void *pNext; ///< [in][optional] must be null or a pointer to an extension-specific + ///< structure (i.e. contains stype and pNext). + char description[ZET_INTEL_MAX_METRIC_PROGRAMMABLE_VALUE_DESCRIPTION_EXP]; +} zet_intel_metric_programmable_param_value_info_exp_desc_t; + /////////////////////////////////////////////////////////////////////////////// /// @brief Get sets of metric groups which could be collected concurrently. /// @@ -62,6 +82,16 @@ zetIntelDeviceGetConcurrentMetricGroupsExp( uint32_t *pConcurrentGroupCount, // [out] number of concurrent groups. uint32_t *pCountPerConcurrentGroup); // [in,out][optional][*pConcurrentGroupCount] count of metric groups per concurrent group. +ze_result_t ZE_APICALL +zetIntelDeviceCreateMetricGroupsFromMetricsExp( + zet_device_handle_t hDevice, // [in] handle of the device. + uint32_t metricCount, // [in] metric handle count in phMetrics. + zet_metric_handle_t *phMetrics, // [in] metric handles. + const char metricGroupNamePrefix[ZET_INTEL_MAX_METRIC_GROUP_NAME_PREFIX_EXP], // [in] prefix to names of metric group handles returned. + const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION], // [in] description of metric group handles returned. + uint32_t *pMetricGroupCount, // [out] number of metric groups. + zet_metric_group_handle_t *phMetricGroups); // [in,out][optional][*pMetricGroupCount] created metric groups. + #if defined(__cplusplus) } // extern "C" #endif diff --git a/level_zero/tools/source/metrics/CMakeLists.txt b/level_zero/tools/source/metrics/CMakeLists.txt index 396821796d..0fa81ce9c9 100644 --- a/level_zero/tools/source/metrics/CMakeLists.txt +++ b/level_zero/tools/source/metrics/CMakeLists.txt @@ -23,6 +23,11 @@ target_sources(${L0_STATIC_LIB_NAME} ${CMAKE_CURRENT_SOURCE_DIR}/metric_ip_sampling_streamer.h ${CMAKE_CURRENT_SOURCE_DIR}/metric_ip_sampling_streamer.cpp ${CMAKE_CURRENT_SOURCE_DIR}/os_interface_metric.h + ${CMAKE_CURRENT_SOURCE_DIR}/metric_oa_programmable_imp.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/metric_oa_programmable_imp.h + ${CMAKE_CURRENT_SOURCE_DIR}/metric_multidevice_programmable.h + ${CMAKE_CURRENT_SOURCE_DIR}/metric_multidevice_programmable.inl + ${CMAKE_CURRENT_SOURCE_DIR}/metric_multidevice_programmable.cpp ${CMAKE_CURRENT_SOURCE_DIR}/os_metric_oa_enumeration_${DRIVER_MODEL}.cpp ${CMAKE_CURRENT_SOURCE_DIR}/${BRANCH_DIR_SUFFIX}/metric_device_context_create.cpp ) diff --git a/level_zero/tools/source/metrics/linux/os_metric_oa_enumeration_imp_linux.cpp b/level_zero/tools/source/metrics/linux/os_metric_oa_enumeration_imp_linux.cpp index 4ff1459305..1ac63fee1e 100644 --- a/level_zero/tools/source/metrics/linux/os_metric_oa_enumeration_imp_linux.cpp +++ b/level_zero/tools/source/metrics/linux/os_metric_oa_enumeration_imp_linux.cpp @@ -42,7 +42,7 @@ bool getDrmAdapterId(uint32_t &adapterMajor, uint32_t &adapterMinor, Device &dev return result == 0; } -MetricsDiscovery::IAdapter_1_9 *getDrmMetricsAdapter(MetricEnumeration *metricEnumeration) { +MetricsDiscovery::IAdapter_1_13 *getDrmMetricsAdapter(MetricEnumeration *metricEnumeration) { // Obtain drm minor / major version. uint32_t drmMajor = 0; uint32_t drmMinor = 0; diff --git a/level_zero/tools/source/metrics/linux/os_metric_oa_enumeration_imp_linux.h b/level_zero/tools/source/metrics/linux/os_metric_oa_enumeration_imp_linux.h index 4827e4e951..b0f17b00fa 100644 --- a/level_zero/tools/source/metrics/linux/os_metric_oa_enumeration_imp_linux.h +++ b/level_zero/tools/source/metrics/linux/os_metric_oa_enumeration_imp_linux.h @@ -16,7 +16,7 @@ struct MetricEnumeration; bool getDrmAdapterId(uint32_t &adapterMajor, uint32_t &adapterMinor, Device &device); -MetricsDiscovery::IAdapter_1_9 *getDrmMetricsAdapter(MetricEnumeration *metricEnumeration); +MetricsDiscovery::IAdapter_1_13 *getDrmMetricsAdapter(MetricEnumeration *metricEnumeration); class MetricOALinuxImp : public MetricOAOsInterface { public: diff --git a/level_zero/tools/source/metrics/metric.cpp b/level_zero/tools/source/metrics/metric.cpp index b4262f0a61..e67e364f4a 100644 --- a/level_zero/tools/source/metrics/metric.cpp +++ b/level_zero/tools/source/metrics/metric.cpp @@ -44,6 +44,10 @@ MetricDeviceContext::MetricDeviceContext(Device &inputDevice) : device(inputDevi } metricSources[MetricSource::metricSourceTypeOa] = OaMetricSourceImp::create(*this); metricSources[MetricSource::metricSourceTypeIpSampling] = IpSamplingMetricSourceImp::create(*this); + + if (NEO::debugManager.flags.EnableProgrammableMetricsSupport.get()) { + isProgrammableMetricsEnabled = true; + } } bool MetricDeviceContext::enable() { @@ -288,6 +292,130 @@ ze_result_t MetricDeviceContext::getConcurrentMetricGroups(uint32_t metricGroupC return ZE_RESULT_SUCCESS; } +ze_result_t MetricDeviceContext::metricProgrammableGet( + uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables) { + + if (!isProgrammableMetricsEnabled) { + *pCount = 0; + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + } + + 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; + + if (!metricSource->isAvailable()) { + continue; + } + + result = metricSource->metricProgrammableGet(&requestCount, phMetricProgrammables); + if (result == ZE_RESULT_ERROR_UNSUPPORTED_FEATURE) { + result = ZE_RESULT_SUCCESS; + continue; + } + + if (result != ZE_RESULT_SUCCESS) { + // Currently there is no error possible other than unsupported feature + DEBUG_BREAK_IF(true); + break; + } + + availableCount += requestCount; + if (*pCount == 0) { + requestCount = 0; + } else { + DEBUG_BREAK_IF(availableCount > *pCount); + phMetricProgrammables += requestCount; + requestCount = *pCount - availableCount; + if (requestCount == 0) { + break; + } + } + } + *pCount = availableCount; + + return result; +} + +ze_result_t MetricDeviceContext::createMetricGroupsFromMetrics(uint32_t metricCount, zet_metric_handle_t *phMetrics, + const char metricGroupNamePrefix[ZET_INTEL_MAX_METRIC_GROUP_NAME_PREFIX_EXP], + const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION], + uint32_t *pMetricGroupCount, + zet_metric_group_handle_t *phMetricGroups) { + if (!isProgrammableMetricsEnabled) { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + } + + if (metricCount == 0) { + return ZE_RESULT_ERROR_INVALID_ARGUMENT; + } + + zet_metric_group_handle_t *cleanupMetricGroups = phMetricGroups; + + // Create a map of metric source types and Metrics + std::map> metricsPerMetricSourceMap{}; + for (auto index = 0u; index < metricCount; index++) { + + auto metricImp = static_cast(Metric::fromHandle(phMetrics[index])); + if (metricImp->isImmutable()) { + *pMetricGroupCount = 0; + return ZE_RESULT_ERROR_INVALID_ARGUMENT; + } + auto &metricSource = metricImp->getMetricSource(); + metricsPerMetricSourceMap[&metricSource].push_back(phMetrics[index]); + } + + auto isGetMetricGroupCountPath = *pMetricGroupCount == 0u; + uint32_t remainingMetricGroupCount = *pMetricGroupCount; + auto cleanupApi = [&]() { + if (!isGetMetricGroupCountPath) { + for (uint32_t index = 0; index < (*pMetricGroupCount - remainingMetricGroupCount); index++) { + zetMetricGroupDestroyExp(cleanupMetricGroups[index]); + } + } + }; + + for (auto &metricSourceEntry : metricsPerMetricSourceMap) { + + MetricSource *metricSource = metricSourceEntry.first; + std::vector metricGroupList{}; + uint32_t metricGroupCountPerSource = remainingMetricGroupCount; + auto status = metricSource->createMetricGroupsFromMetrics(metricSourceEntry.second, metricGroupNamePrefix, description, &metricGroupCountPerSource, metricGroupList); + if (status != ZE_RESULT_SUCCESS) { + if (status == ZE_RESULT_ERROR_UNSUPPORTED_FEATURE) { + continue; + } + cleanupApi(); + *pMetricGroupCount = 0; + return status; + } + + if (isGetMetricGroupCountPath) { + *pMetricGroupCount += metricGroupCountPerSource; + } else { + memcpy_s(phMetricGroups, remainingMetricGroupCount * sizeof(zet_metric_group_handle_t), metricGroupList.data(), metricGroupCountPerSource * sizeof(metricGroupList[0])); + DEBUG_BREAK_IF(metricGroupCountPerSource > remainingMetricGroupCount); + phMetricGroups += metricGroupCountPerSource; + remainingMetricGroupCount -= metricGroupCountPerSource; + if (!remainingMetricGroupCount) { + break; + } + } + } + + *pMetricGroupCount = *pMetricGroupCount - remainingMetricGroupCount; + return ZE_RESULT_SUCCESS; +} + +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 MultiDeviceMetricImp::getProperties(zet_metric_properties_t *pProperties) { return subDeviceMetrics[0]->getProperties(pProperties); } @@ -427,9 +555,190 @@ void MetricCollectorEventNotify::detachEvent() { } } +void MetricGroupUserDefined::updateErrorString(std::string &errorString, size_t *errorStringSize, char *pErrorString) { + if (*errorStringSize == 0) { + *errorStringSize = errorString.length() + 1; + } else { + *errorStringSize = std::min(*errorStringSize, errorString.length() + 1); + strncpy_s(pErrorString, *errorStringSize, errorString.data(), *errorStringSize); + } +} + +MetricProgrammable *HomogeneousMultiDeviceMetricProgrammable::create(MetricSource &metricSource, + std::vector &subDeviceProgrammables) { + return static_cast(new (std::nothrow) HomogeneousMultiDeviceMetricProgrammable(metricSource, subDeviceProgrammables)); +} + +ze_result_t HomogeneousMultiDeviceMetricProgrammable::getProperties(zet_metric_programmable_exp_properties_t *pProperties) { + return subDeviceProgrammables[0]->getProperties(pProperties); +} + +ze_result_t HomogeneousMultiDeviceMetricProgrammable::getParamInfo(uint32_t *pParameterCount, zet_metric_programmable_param_info_exp_t *pParameterInfo) { + return subDeviceProgrammables[0]->getParamInfo(pParameterCount, pParameterInfo); +} + +ze_result_t HomogeneousMultiDeviceMetricProgrammable::getParamValueInfo(uint32_t parameterOrdinal, uint32_t *pValueInfoCount, + zet_metric_programmable_param_value_info_exp_t *pValueInfo) { + return subDeviceProgrammables[0]->getParamValueInfo(parameterOrdinal, pValueInfoCount, pValueInfo); +} + +ze_result_t HomogeneousMultiDeviceMetricProgrammable::createMetric(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) { + + auto isCountEstimationPath = *pMetricHandleCount == 0; + ze_result_t status = ZE_RESULT_SUCCESS; + + uint32_t expectedMetricHandleCount = 0; + auto isExpectedHandleCount = [&](const uint32_t actualHandleCount) { + if (expectedMetricHandleCount != 0 && expectedMetricHandleCount != actualHandleCount) { + METRICS_LOG_ERR("Unexpected Metric Handle Count for subdevice expected:%d, actual:%d", expectedMetricHandleCount, actualHandleCount); + return false; + } + expectedMetricHandleCount = actualHandleCount; + return true; + }; + + if (isCountEstimationPath) { + for (auto &subDeviceProgrammable : subDeviceProgrammables) { + uint32_t metricHandleCount = 0; + status = subDeviceProgrammable->createMetric(pParameterValues, parameterCount, name, description, &metricHandleCount, nullptr); + if (status != ZE_RESULT_SUCCESS || metricHandleCount == 0u) { + *pMetricHandleCount = 0; + return status; + } + if (!isExpectedHandleCount(metricHandleCount)) { + *pMetricHandleCount = 0; + return ZE_RESULT_ERROR_UNKNOWN; + } + } + *pMetricHandleCount = expectedMetricHandleCount; + return status; + } + + std::vector> metricHandlesPerSubDeviceList{}; + auto cleanupApi = [&]() { + for (auto &metricHandlesPerSubDevice : metricHandlesPerSubDeviceList) { + for (auto &metricHandle : metricHandlesPerSubDevice) { + if (metricHandle != nullptr) { + [[maybe_unused]] auto status = static_cast(metricHandle)->destroy(); + DEBUG_BREAK_IF(status != ZE_RESULT_SUCCESS); + } + } + metricHandlesPerSubDevice.clear(); + } + metricHandlesPerSubDeviceList.clear(); + }; + + metricHandlesPerSubDeviceList.resize(subDeviceProgrammables.size()); + for (uint32_t index = 0; index < static_cast(subDeviceProgrammables.size()); index++) { + auto &subDeviceProgrammable = subDeviceProgrammables[index]; + uint32_t metricHandleCount = *pMetricHandleCount; + + metricHandlesPerSubDeviceList[index].resize(metricHandleCount); + status = subDeviceProgrammable->createMetric(pParameterValues, parameterCount, name, description, &metricHandleCount, metricHandlesPerSubDeviceList[index].data()); + if (status != ZE_RESULT_SUCCESS || metricHandleCount == 0u) { + cleanupApi(); + *pMetricHandleCount = 0; + return status; + } + if (!isExpectedHandleCount(metricHandleCount)) { + cleanupApi(); + *pMetricHandleCount = 0; + return ZE_RESULT_ERROR_UNKNOWN; + } + metricHandlesPerSubDeviceList[index].resize(metricHandleCount); + } + + DEBUG_BREAK_IF(metricHandlesPerSubDeviceList[0].size() > *pMetricHandleCount); + + // Create Root device Metric handles from sub-device handles + for (uint32_t index = 0; index < static_cast(metricHandlesPerSubDeviceList[0].size()); index++) { + std::vector homogenousMetricList{}; + homogenousMetricList.reserve(subDeviceProgrammables.size()); + for (auto &metricHandlesPerSubdevice : metricHandlesPerSubDeviceList) { + homogenousMetricList.push_back(static_cast(Metric::fromHandle(metricHandlesPerSubdevice[index]))); + } + phMetricHandles[index] = HomogeneousMultiDeviceMetricCreated::create(metricSource, homogenousMetricList)->toHandle(); + } + + *pMetricHandleCount = static_cast(metricHandlesPerSubDeviceList[0].size()); + return ZE_RESULT_SUCCESS; +} + +ze_result_t HomogeneousMultiDeviceMetricCreated::destroy() { + + auto status = ZE_RESULT_SUCCESS; + for (auto &subDeviceMetric : subDeviceMetrics) { + ze_result_t subDeviceStatus = subDeviceMetric->destroy(); + // Hold the first error + if (status == ZE_RESULT_SUCCESS) { + status = subDeviceStatus; + } + } + + // release only if object is unused + if (status != ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE) { + subDeviceMetrics.clear(); + delete this; + } + return status; +} + +MetricImp *HomogeneousMultiDeviceMetricCreated::create(MetricSource &metricSource, std::vector &subDeviceMetrics) { + return new (std::nothrow) HomogeneousMultiDeviceMetricCreated(metricSource, subDeviceMetrics); +} + +void MetricProgrammable::setParamValueInfoDescription(zet_metric_programmable_param_value_info_exp_t *pValueInfo, const char *desc) { + + auto pNext = const_cast(pValueInfo->pNext); + while (pNext != nullptr) { + auto baseProps = reinterpret_cast(pNext); + if (baseProps->stype == ZET_INTEL_STRUCTURE_TYPE_METRIC_PROGRAMMABLE_PARAM_VALUE_INFO_DESC_EXP) { + zet_intel_metric_programmable_param_value_info_exp_desc_t *infoDesc = reinterpret_cast(baseProps); + snprintf(infoDesc->description, sizeof(infoDesc->description), "%s", desc); + break; + } + pNext = const_cast(baseProps->pNext); + } +} + 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); } +ze_result_t metricProgrammableGetProperties( + zet_metric_programmable_exp_handle_t hMetricProgrammable, + zet_metric_programmable_exp_properties_t *pProperties) { + return L0::MetricProgrammable::fromHandle(hMetricProgrammable)->getProperties(pProperties); +} + +ze_result_t metricProgrammableGetParamInfo( + zet_metric_programmable_exp_handle_t hMetricProgrammable, + uint32_t *pParameterCount, + zet_metric_programmable_param_info_exp_t *pParameterInfo) { + return L0::MetricProgrammable::fromHandle(hMetricProgrammable)->getParamInfo(pParameterCount, 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) { + return L0::MetricProgrammable::fromHandle(hMetricProgrammable)->getParamValueInfo(parameterOrdinal, pValueInfoCount, 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) { + return L0::MetricProgrammable::fromHandle(hMetricProgrammable)->createMetric(pParameterValues, parameterCount, name, description, pMetricHandleCount, phMetricHandles); +} + } // namespace L0 diff --git a/level_zero/tools/source/metrics/metric.h b/level_zero/tools/source/metrics/metric.h index a8cf033893..dec1b77d77 100644 --- a/level_zero/tools/source/metrics/metric.h +++ b/level_zero/tools/source/metrics/metric.h @@ -7,6 +7,7 @@ #pragma once #include "level_zero/core/source/event/event.h" +#include "level_zero/include/zet_intel_gpu_metric.h" #include "level_zero/tools/source/metrics/os_interface_metric.h" #include @@ -50,6 +51,7 @@ struct METRICS_LOG_BITMASK { // NOLINT(readability-identifier struct CommandList; struct MetricStreamer; +struct MetricProgrammable; static constexpr uint64_t nsecPerSec = 1000000000ull; @@ -80,6 +82,11 @@ class MetricSource { return type; } virtual ze_result_t handleMetricGroupExtendedProperties(zet_metric_group_handle_t hMetricGroup, void *pNext) = 0; + virtual ze_result_t createMetricGroupsFromMetrics(std::vector &metricList, + const char metricGroupNamePrefix[ZET_INTEL_MAX_METRIC_GROUP_NAME_PREFIX_EXP], + const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION], + uint32_t *maxMetricGroupCount, + std::vector &metricGroupList) = 0; protected: uint32_t type = MetricSource::metricSourceTypeUndefined; @@ -129,6 +136,11 @@ class MetricDeviceContext { uint32_t *pConcurrentGroupCount, uint32_t *pCountPerConcurrentGroup); bool isProgrammableMetricsEnabled = false; + ze_result_t createMetricGroupsFromMetrics(uint32_t metricCount, zet_metric_handle_t *phMetrics, + const char metricGroupNamePrefix[ZET_INTEL_MAX_METRIC_GROUP_NAME_PREFIX_EXP], + const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION], + uint32_t *pMetricGroupCount, + zet_metric_group_handle_t *phMetricGroups); protected: std::map> metricSources; @@ -308,6 +320,73 @@ struct MetricQuery : _zet_metric_query_handle_t { zet_metric_query_handle_t toHandle(); }; +struct MetricProgrammable : _zet_metric_programmable_exp_handle_t { + virtual ~MetricProgrammable() = default; + virtual ze_result_t getProperties(zet_metric_programmable_exp_properties_t *pProperties) = 0; + virtual ze_result_t getParamInfo(uint32_t *pParameterCount, zet_metric_programmable_param_info_exp_t *pParameterInfo) = 0; + virtual ze_result_t getParamValueInfo(uint32_t parameterOrdinal, uint32_t *pValueInfoCount, + zet_metric_programmable_param_value_info_exp_t *pValueInfo) = 0; + virtual ze_result_t createMetric(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) = 0; + static MetricProgrammable *fromHandle(zet_metric_programmable_exp_handle_t handle) { + return static_cast(handle); + } + static void setParamValueInfoDescription(zet_metric_programmable_param_value_info_exp_t *pValueInfo, const char *desc); + zet_metric_programmable_exp_handle_t toHandle() { return this; } +}; + +struct MetricCreated { + virtual ~MetricCreated() = default; + void incrementRefCount() { + refCount++; + } + void decrementRefCount() { + refCount -= 1; + DEBUG_BREAK_IF(refCount < 0); + refCount = std::max(0, refCount); + } + + protected: + int32_t refCount = 0; +}; + +struct MetricGroupUserDefined { + virtual ~MetricGroupUserDefined() = default; + static void updateErrorString(std::string &errorString, size_t *errorStringSize, char *pErrorString); +}; + +struct HomogeneousMultiDeviceMetricProgrammable : public MetricProgrammable { + HomogeneousMultiDeviceMetricProgrammable(MetricSource &metricSource, + std::vector &subDeviceProgrammables) : metricSource(metricSource), subDeviceProgrammables(subDeviceProgrammables) {} + ~HomogeneousMultiDeviceMetricProgrammable() override = default; + ze_result_t getProperties(zet_metric_programmable_exp_properties_t *pProperties) override; + ze_result_t getParamInfo(uint32_t *pParameterCount, zet_metric_programmable_param_info_exp_t *pParameterInfo) override; + ze_result_t getParamValueInfo(uint32_t parameterOrdinal, uint32_t *pValueInfoCount, + zet_metric_programmable_param_value_info_exp_t *pValueInfo) override; + ze_result_t createMetric(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) override; + static MetricProgrammable *create(MetricSource &metricSource, + std::vector &subDeviceProgrammables); + + protected: + MetricSource &metricSource; + std::vector subDeviceProgrammables{}; +}; + +struct HomogeneousMultiDeviceMetricCreated : public MultiDeviceMetricImp { + ~HomogeneousMultiDeviceMetricCreated() override {} + HomogeneousMultiDeviceMetricCreated(MetricSource &metricSource, std::vector &subDeviceMetrics) : MultiDeviceMetricImp(metricSource, subDeviceMetrics) { + isPredefined = false; + isMultiDevice = true; + } + ze_result_t destroy() override; + static MetricImp *create(MetricSource &metricSource, std::vector &subDeviceMetrics); +}; + // MetricGroup. ze_result_t metricGroupGet(zet_device_handle_t hDevice, uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups); 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 fb20990ff1..83cbf0cc2e 100644 --- a/level_zero/tools/source/metrics/metric_device_context_create.cpp +++ b/level_zero/tools/source/metrics/metric_device_context_create.cpp @@ -6,60 +6,13 @@ */ #include "level_zero/tools/source/metrics/metric.h" +#include "level_zero/tools/source/metrics/metric_oa_programmable_imp.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 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 330b91fe1b..e1a872a36d 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_source.h +++ b/level_zero/tools/source/metrics/metric_ip_sampling_source.h @@ -41,6 +41,14 @@ class IpSamplingMetricSourceImp : public MetricSource { IpSamplingMetricStreamerImp *pActiveStreamer = nullptr; const MetricDeviceContext &getMetricDeviceContext() const { return metricDeviceContext; } ze_result_t handleMetricGroupExtendedProperties(zet_metric_group_handle_t hMetricGroup, void *pNext) override; + ze_result_t createMetricGroupsFromMetrics(std::vector &metricList, + const char metricGroupNamePrefix[ZET_INTEL_MAX_METRIC_GROUP_NAME_PREFIX_EXP], + const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION], + uint32_t *maxMetricGroupCount, + std::vector &metricGroupList) override { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + } + void setActivationTracker(MultiDomainDeferredActivationTracker *inputActivationTracker) { activationTracker.reset(inputActivationTracker); } diff --git a/level_zero/tools/source/metrics/metric_multidevice_programmable.cpp b/level_zero/tools/source/metrics/metric_multidevice_programmable.cpp new file mode 100644 index 0000000000..e9e9a9f2c5 --- /dev/null +++ b/level_zero/tools/source/metrics/metric_multidevice_programmable.cpp @@ -0,0 +1,219 @@ +/* + * Copyright (C) 2024 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "level_zero/tools/source/metrics/metric_multidevice_programmable.h" + +#include "shared/source/debug_settings/debug_settings_manager.h" + +#include "level_zero/core/source/device/device_imp.h" +#include "level_zero/tools/source/metrics/metric.h" +#include "level_zero/tools/source/metrics/metric_multidevice_programmable.inl" + +namespace L0 { + +MultiDeviceCreatedMetricGroupManager::MultiDeviceCreatedMetricGroupManager(MetricSource &metricSource, + std::vector &subDeviceMetricGroupsCreated, + std::vector &inMultiDeviceMetrics) : metricSource(metricSource), + subDeviceMetricGroupsCreated(subDeviceMetricGroupsCreated), + multiDeviceMetrics(inMultiDeviceMetrics) {} + +ze_result_t MultiDeviceCreatedMetricGroupManager::destroy() { + + auto status = ZE_RESULT_SUCCESS; + + for (auto &metric : multiDeviceMetrics) { + deleteMetricAddedDuringClose(metric); + } + multiDeviceMetrics.clear(); + + for (auto &subDeviceMetricGroup : subDeviceMetricGroupsCreated) { + [[maybe_unused]] auto destroyStatus = MetricGroup::fromHandle(subDeviceMetricGroup)->destroy(); + DEBUG_BREAK_IF(destroyStatus != ZE_RESULT_SUCCESS); + } + return status; +} + +ze_result_t MultiDeviceCreatedMetricGroupManager::metricGet(uint32_t *pCount, zet_metric_handle_t *phMetrics) { + + if (*pCount == 0) { + *pCount = static_cast(multiDeviceMetrics.size()); + } else { + *pCount = std::min(*pCount, static_cast(multiDeviceMetrics.size())); + for (uint32_t index = 0; index < *pCount; index++) { + phMetrics[index] = multiDeviceMetrics[index]; + } + } + + return ZE_RESULT_SUCCESS; +} + +ze_result_t MultiDeviceCreatedMetricGroupManager::addMetric(zet_metric_handle_t hMetric, size_t *errorStringSize, char *pErrorString) { + + MetricImp *metricImp = static_cast(Metric::fromHandle(hMetric)); + if (metricImp->isImmutable() || !metricImp->isRootDevice()) { + METRICS_LOG_ERR("%s", "Cannot add metric which was not created from a programmable"); + return ZE_RESULT_ERROR_INVALID_ARGUMENT; + } + + HomogeneousMultiDeviceMetricCreated *multiDeviceMetric = static_cast(metricImp); + + auto cleanupApi = [&](uint32_t subDeviceLimit) { + for (uint32_t subDeviceIndex = 0; subDeviceIndex < subDeviceLimit; subDeviceIndex++) { + auto metricGroup = MetricGroup::fromHandle(subDeviceMetricGroupsCreated[subDeviceIndex]); + [[maybe_unused]] auto result = metricGroup->removeMetric(multiDeviceMetric->getMetricAtSubDeviceIndex(subDeviceIndex)); + DEBUG_BREAK_IF(result != ZE_RESULT_SUCCESS); + } + }; + + for (uint32_t subDeviceIndex = 0; subDeviceIndex < static_cast(subDeviceMetricGroupsCreated.size()); subDeviceIndex++) { + auto metricGroup = MetricGroup::fromHandle(subDeviceMetricGroupsCreated[subDeviceIndex]); + auto result = metricGroup->addMetric(multiDeviceMetric->getMetricAtSubDeviceIndex(subDeviceIndex), + errorStringSize, pErrorString); + if (result != ZE_RESULT_SUCCESS) { + cleanupApi(subDeviceIndex); + return result; + } + } + + multiDeviceMetrics.push_back(multiDeviceMetric); + + return ZE_RESULT_SUCCESS; +} + +ze_result_t MultiDeviceCreatedMetricGroupManager::removeMetric(zet_metric_handle_t hMetric) { + + MetricImp *metricImp = static_cast(Metric::fromHandle(hMetric)); + if (metricImp->isImmutable() || !metricImp->isRootDevice()) { + METRICS_LOG_ERR("%s", "Cannot remove metric which was not created from a programmable"); + return ZE_RESULT_ERROR_INVALID_ARGUMENT; + } + + HomogeneousMultiDeviceMetricCreated *multiDeviceMetric = static_cast(metricImp); + auto cleanupApi = [&](uint32_t subDeviceLimit) { + for (uint32_t subDeviceIndex = 0; subDeviceIndex < subDeviceLimit; subDeviceIndex++) { + size_t errorStringSize = 0; + auto metricGroup = MetricGroup::fromHandle(subDeviceMetricGroupsCreated[subDeviceIndex]); + [[maybe_unused]] auto result = metricGroup->addMetric(multiDeviceMetric->getMetricAtSubDeviceIndex(subDeviceIndex), + &errorStringSize, nullptr); + DEBUG_BREAK_IF(result != ZE_RESULT_SUCCESS); + } + }; + + for (uint32_t subDeviceIndex = 0; subDeviceIndex < static_cast(subDeviceMetricGroupsCreated.size()); subDeviceIndex++) { + auto metricGroup = MetricGroup::fromHandle(subDeviceMetricGroupsCreated[subDeviceIndex]); + auto result = metricGroup->removeMetric(multiDeviceMetric->getMetricAtSubDeviceIndex(subDeviceIndex)); + if (result != ZE_RESULT_SUCCESS) { + cleanupApi(subDeviceIndex); + return result; + } + } + + auto iterator = std::find(multiDeviceMetrics.begin(), multiDeviceMetrics.end(), hMetric); + if (iterator != multiDeviceMetrics.end()) { + multiDeviceMetrics.erase(iterator); + } + + return ZE_RESULT_SUCCESS; +} + +ze_result_t MultiDeviceCreatedMetricGroupManager::close() { + + auto closeResult = ZE_RESULT_SUCCESS; + // Close the subdevice groups to get the updated metric count + for (auto &subDevMetricGroup : subDeviceMetricGroupsCreated) { + auto metricGroup = MetricGroup::fromHandle(subDevMetricGroup); + auto result = metricGroup->close(); + if (closeResult == ZE_RESULT_SUCCESS) { + closeResult = result; + } + } + + if (closeResult != ZE_RESULT_SUCCESS) { + return closeResult; + } + + uint32_t expectedMetricHandleCount = 0; + auto isExpectedHandleCount = [&](const uint32_t actualHandleCount) { + if (expectedMetricHandleCount != 0 && expectedMetricHandleCount != actualHandleCount) { + METRICS_LOG_ERR("Unexpected Metric Handle Count for subdevice expected:%d, actual:%d", expectedMetricHandleCount, actualHandleCount); + return false; + } + expectedMetricHandleCount = actualHandleCount; + return true; + }; + + uint32_t subDeviceCount = static_cast(subDeviceMetricGroupsCreated.size()); + std::vector> subDeviceMetricHandles(subDeviceCount); + // Get all metric handles from all sub-devices + for (uint32_t index = 0; index < subDeviceCount; index++) { + uint32_t count = 0; + auto metricGroup = MetricGroup::fromHandle(subDeviceMetricGroupsCreated[index]); + [[maybe_unused]] auto status = metricGroup->metricGet(&count, nullptr); + DEBUG_BREAK_IF(status != ZE_RESULT_SUCCESS || count == 0); + if (isExpectedHandleCount(count)) { + subDeviceMetricHandles[index].resize(count); + auto metricGroup = MetricGroup::fromHandle(subDeviceMetricGroupsCreated[index]); + metricGroup->metricGet(&count, subDeviceMetricHandles[index].data()); + } else { + METRICS_LOG_ERR("%s", "Different Metric counts received from the sub-devices"); + return ZE_RESULT_ERROR_UNKNOWN; + } + } + + auto getRelatedHomogenousMultiDeviceHandle = [&](zet_metric_handle_t subDeviceMetricHandle) { + for (auto &multiDeviceMetric : multiDeviceMetrics) { + auto mutableMetric = static_cast(multiDeviceMetric); + auto matchingMetric = mutableMetric->getMetricAtSubDeviceIndex(0)->toHandle(); + if (matchingMetric == subDeviceMetricHandle) { + return mutableMetric; + } + } + return static_cast(nullptr); + }; + + // Arrange metric handles based on sub-device handles + const uint32_t metricCountPerSubdevice = static_cast(subDeviceMetricHandles[0].size()); + std::vector arrangedMetricHandles(metricCountPerSubdevice); + for (uint32_t index = 0; index < metricCountPerSubdevice; index++) { + auto multiDeviceMetric = getRelatedHomogenousMultiDeviceHandle(subDeviceMetricHandles[0][index]); + + if (multiDeviceMetric != nullptr) { + arrangedMetricHandles[index] = multiDeviceMetric; + } else { + // Create a new multidevice immutable metric for new metrics added during close + std::vector subDeviceMetrics(subDeviceCount); + for (uint32_t subDeviceIndex = 0; subDeviceIndex < subDeviceCount; subDeviceIndex++) { + subDeviceMetrics[subDeviceIndex] = static_cast( + Metric::fromHandle(subDeviceMetricHandles[subDeviceIndex][index])); + } + arrangedMetricHandles[index] = MultiDeviceMetricImp::create(metricSource, subDeviceMetrics); + } + } + + // Clean up and use the new list + if (arrangedMetricHandles != multiDeviceMetrics) { + for (auto &metric : multiDeviceMetrics) { + if (std::find(arrangedMetricHandles.begin(), arrangedMetricHandles.end(), metric) == arrangedMetricHandles.end()) { + deleteMetricAddedDuringClose(metric); + } + } + } + + multiDeviceMetrics = std::move(arrangedMetricHandles); + + return ZE_RESULT_SUCCESS; +} + +void MultiDeviceCreatedMetricGroupManager::deleteMetricAddedDuringClose(Metric *metric) { + MetricImp *metricImp = static_cast(metric); + // Only destroy metrics added during Close. Other metrics are managed by application + if (metricImp->isImmutable()) { + delete metricImp; + } +} + +} // namespace L0 diff --git a/level_zero/tools/source/metrics/metric_multidevice_programmable.h b/level_zero/tools/source/metrics/metric_multidevice_programmable.h new file mode 100644 index 0000000000..46f51f1f0e --- /dev/null +++ b/level_zero/tools/source/metrics/metric_multidevice_programmable.h @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2024 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#pragma once + +#include "shared/source/debug_settings/debug_settings_manager.h" + +#include "level_zero/core/source/device/device_imp.h" +#include "level_zero/tools/source/metrics/metric.h" + +namespace L0 { + +struct MultiDeviceCreatedMetricGroupManager { + + MultiDeviceCreatedMetricGroupManager(MetricSource &metricSource, + std::vector &subDeviceMetricGroupsCreated, + std::vector &multiDeviceMetrics); + template + static ze_result_t createMultipleMetricGroupsFromMetrics(const MetricDeviceContext &metricDeviceContext, + MetricSource &metricSource, + std::vector &metricList, + const char metricGroupNamePrefix[ZET_INTEL_MAX_METRIC_GROUP_NAME_PREFIX_EXP], + const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION], + uint32_t *maxMetricGroupCount, + std::vector &metricGroupList); + ze_result_t metricGet(uint32_t *pCount, zet_metric_handle_t *phMetrics); + ze_result_t addMetric(zet_metric_handle_t hMetric, size_t *errorStringSize, char *pErrorString); + ze_result_t removeMetric(zet_metric_handle_t hMetric); + ze_result_t close(); + ze_result_t destroy(); + void deleteMetricAddedDuringClose(Metric *metric); + + protected: + MetricSource &metricSource; + std::vector &subDeviceMetricGroupsCreated; + std::vector &multiDeviceMetrics; +}; + +} // namespace L0 \ No newline at end of file diff --git a/level_zero/tools/source/metrics/metric_multidevice_programmable.inl b/level_zero/tools/source/metrics/metric_multidevice_programmable.inl new file mode 100644 index 0000000000..139116b53c --- /dev/null +++ b/level_zero/tools/source/metrics/metric_multidevice_programmable.inl @@ -0,0 +1,137 @@ +/* + * Copyright (C) 2024 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "level_zero/tools/source/metrics/metric_multidevice_programmable.h" + +namespace L0 { + +template +ze_result_t MultiDeviceCreatedMetricGroupManager::createMultipleMetricGroupsFromMetrics(const MetricDeviceContext &metricDeviceContext, + MetricSource &metricSource, + std::vector &metricList, + const char metricGroupNamePrefix[ZET_INTEL_MAX_METRIC_GROUP_NAME_PREFIX_EXP], + const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION], + uint32_t *maxMetricGroupCount, + std::vector &metricGroupList) { + const auto isCountCalculationPath = *maxMetricGroupCount == 0; + + uint32_t subDeviceCount = static_cast(static_cast(&metricDeviceContext.getDevice())->subDevices.size()); + std::vector> metricGroupsPerSubDevice(subDeviceCount); + + auto cleanupCreatedGroups = [](std::vector &createdMetricGroupList) { + for (auto &metricGroup : createdMetricGroupList) { + zetMetricGroupDestroyExp(metricGroup); + } + createdMetricGroupList.clear(); + }; + + auto cleanupCreatedGroupsFromSubDevices = [&](uint32_t subDeviceLimit) { + for (uint32_t index = 0; index < subDeviceLimit; index++) { + cleanupCreatedGroups(metricGroupsPerSubDevice[index]); + } + metricGroupsPerSubDevice.clear(); + }; + + uint32_t expectedMetricGroupCount = 0; + auto isExpectedGroupCount = [&](const uint32_t actualGroupCount) { + if (expectedMetricGroupCount != 0 && expectedMetricGroupCount != actualGroupCount) { + METRICS_LOG_ERR("Unexpected Metric Group Count for subdevice expected:%d, actual:%d", expectedMetricGroupCount, actualGroupCount); + return false; + } + expectedMetricGroupCount = actualGroupCount; + return true; + }; + + // For each of the sub-devices, create Metric Groups + for (uint32_t subDeviceIndex = 0; subDeviceIndex < subDeviceCount; subDeviceIndex++) { + std::vector metricHandles(metricList.size()); + + // Collect the metric handles at each sub-device index + for (uint32_t inputMetricIndex = 0; inputMetricIndex < static_cast(metricList.size()); inputMetricIndex++) { + auto &multiDeviceMetric = metricList[inputMetricIndex]; + auto metricImp = static_cast(multiDeviceMetric); + DEBUG_BREAK_IF(metricImp->isImmutable() == true); + if (!metricImp->isRootDevice()) { + METRICS_LOG_ERR("%s", "Metric from sub-device cannot be used for creating group at root-device"); + return ZE_RESULT_ERROR_INVALID_ARGUMENT; + } + auto homogenousMetric = static_cast(metricImp); + metricHandles[inputMetricIndex] = homogenousMetric->getMetricAtSubDeviceIndex(subDeviceIndex)->toHandle(); + } + + // Get the source from one of the Metrics + auto &subDeviceMetricSource = static_cast(metricHandles[0])->getMetricSource(); + + uint32_t metricGroupCountPerSubDevice = *maxMetricGroupCount; + auto status = subDeviceMetricSource.createMetricGroupsFromMetrics(metricHandles, + metricGroupNamePrefix, description, + &metricGroupCountPerSubDevice, + metricGroupsPerSubDevice[subDeviceIndex]); + if (status != ZE_RESULT_SUCCESS) { + // cleanup till the current sub device Index + cleanupCreatedGroupsFromSubDevices(subDeviceIndex); + *maxMetricGroupCount = 0; + METRICS_LOG_ERR("%s", "createMetricGroupsFromMetrics for subdevices returned error"); + return status; + } + + // Count calculation path + if (isCountCalculationPath) { + *maxMetricGroupCount = metricGroupCountPerSubDevice; + // We can return by looking at only one sub device + return ZE_RESULT_SUCCESS; + } + + if (!isExpectedGroupCount(metricGroupCountPerSubDevice)) { + // +1 to cleanup current subdevice as well + cleanupCreatedGroupsFromSubDevices(subDeviceIndex + 1); + *maxMetricGroupCount = 0; + METRICS_LOG_ERR("%s", "Different Metric group counts received from the sub-devices"); + return ZE_RESULT_ERROR_UNKNOWN; + } + } + + for (uint32_t groupIndex = 0; groupIndex < static_cast(metricGroupsPerSubDevice[0].size()); groupIndex++) { + std::vector metricGroupsAcrossSubDevices(subDeviceCount); + for (uint32_t subDeviceIndex = 0; subDeviceIndex < subDeviceCount; subDeviceIndex++) { + metricGroupsAcrossSubDevices[subDeviceIndex] = static_cast(metricGroupsPerSubDevice[subDeviceIndex][groupIndex]); + } + // All metric groups use the input metric list. A call to close() will finalize the list of metrics included in each group + std::vector multiDeviceMetricImp{}; + multiDeviceMetricImp.reserve(metricList.size()); + for (auto &hMetric : metricList) { + multiDeviceMetricImp.push_back(static_cast(Metric::fromHandle(hMetric))); + } + auto metricGroup = T::create(metricSource, metricGroupsAcrossSubDevices, multiDeviceMetricImp); + auto closeStatus = metricGroup->close(); + if (closeStatus != ZE_RESULT_SUCCESS) { + // Cleanup and exit + metricGroup->destroy(); + for (auto &metricGroupCreated : metricGroupList) { + MetricGroup::fromHandle(metricGroupCreated)->destroy(); + } + metricGroupList.clear(); + + // Delete the remaining subdevice groups + for (uint32_t subDevGroupIndex = groupIndex + 1; subDevGroupIndex < static_cast(metricGroupsPerSubDevice[0].size()); subDevGroupIndex++) { + for (uint32_t subDeviceIndex = 0; subDeviceIndex < subDeviceCount; subDeviceIndex++) { + [[maybe_unused]] auto status = zetMetricGroupDestroyExp(metricGroupsPerSubDevice[subDeviceIndex][subDevGroupIndex]); + DEBUG_BREAK_IF(status != ZE_RESULT_SUCCESS); + } + } + *maxMetricGroupCount = 0; + return closeStatus; + } + metricGroupList.push_back(metricGroup); + } + + *maxMetricGroupCount = static_cast(metricGroupList.size()); + + return ZE_RESULT_SUCCESS; +} + +} // namespace L0 diff --git a/level_zero/tools/source/metrics/metric_oa_enumeration_imp.cpp b/level_zero/tools/source/metrics/metric_oa_enumeration_imp.cpp index 1ad9725e15..e1e46b66fc 100644 --- a/level_zero/tools/source/metrics/metric_oa_enumeration_imp.cpp +++ b/level_zero/tools/source/metrics/metric_oa_enumeration_imp.cpp @@ -13,6 +13,7 @@ #include "shared/source/os_interface/os_library.h" #include "level_zero/core/source/device/device_imp.h" +#include "level_zero/tools/source/metrics/metric_oa_programmable_imp.h" #include "level_zero/tools/source/metrics/metric_oa_query_imp.h" #include "level_zero/tools/source/metrics/metric_oa_source.h" @@ -297,7 +298,7 @@ ze_result_t MetricEnumeration::cacheMetricInformation() { MetricsDiscovery::TMetricsDeviceParams_1_2 *pMetricsDeviceParams = pMetricsDevice->GetParams(); DEBUG_BREAK_IF(pMetricsDeviceParams == nullptr); - // Check required Metrics Discovery API version - should be at least 1.5. + // Check required Metrics Discovery API version - should be at least 1.13. const bool unsupportedMajorVersion = pMetricsDeviceParams->Version.MajorNumber < requiredMetricsDiscoveryMajorVersion; const bool unsupportedMinorVersion = @@ -310,7 +311,7 @@ ze_result_t MetricEnumeration::cacheMetricInformation() { } // 1. Iterate over concurrent groups. - MetricsDiscovery::IConcurrentGroup_1_5 *pConcurrentGroup = nullptr; + MetricsDiscovery::IConcurrentGroup_1_13 *pConcurrentGroup = nullptr; for (uint32_t i = 0; i < pMetricsDeviceParams->ConcurrentGroupsCount; ++i) { pConcurrentGroup = getConcurrentGroupFromDevice(pMetricsDevice, i); DEBUG_BREAK_IF(pConcurrentGroup == nullptr); @@ -367,7 +368,7 @@ ze_result_t MetricEnumeration::cacheMetricInformation() { ze_result_t MetricEnumeration::cacheMetricGroup(MetricsDiscovery::IMetricSet_1_5 &metricSet, - MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup, + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup, const uint32_t domain, const zet_metric_group_sampling_type_flag_t samplingType) { MetricsDiscovery::TMetricSetParams_1_4 *pMetricSetParams = metricSet.GetParams(); @@ -560,6 +561,120 @@ zet_value_type_t MetricEnumeration::getMetricResultType( } } +ze_result_t MetricEnumeration::cacheExtendedMetricInformation( + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup, + const uint32_t domain) { + + if (isMetricProgrammableSupportEnabled()) { + pConcurrentGroup = &concurrentGroup; + cacheMetricPrototypes(concurrentGroup, domain); + } + return ZE_RESULT_SUCCESS; +} + +void MetricEnumeration::cacheMetricPrototypes(MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup, + const uint32_t domain) { + + auto metricEnumerator = concurrentGroup.GetMetricEnumerator(); + if (metricEnumerator == nullptr) { + METRICS_LOG_ERR("MetricPrototype Enumeration Failed for domain %d. MetricProgrammable unavailable", domain); + return; + } + uint32_t metricPrototypeCount = metricEnumerator->GetMetricPrototypeCount(); + if (metricPrototypeCount == 0) { + METRICS_LOG_DBG("%s", "MetricPrototypeCount is 0"); + return; + } + std::vector metricPrototypes(metricPrototypeCount); + metricEnumerator->GetMetricPrototypes(0, &metricPrototypeCount, metricPrototypes.data()); + updateMetricProgrammablesFromPrototypes(concurrentGroup, metricPrototypes, domain); +} + +void MetricEnumeration::updateMetricProgrammablesFromPrototypes( + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup, + const std::vector &metricPrototypes, + uint32_t domain) { + + for (auto &metricPrototype : metricPrototypes) { + auto metricPrototypeParams = metricPrototype->GetParams(); + // Any failure just avoids adding programmables + if (metricPrototypeParams == nullptr) { + continue; + } + zet_metric_programmable_exp_properties_t properties{}; + snprintf(properties.component, sizeof(properties.component), "%s", + metricPrototypeParams->GroupName); + snprintf(properties.name, sizeof(properties.name), "%s", + metricPrototypeParams->SymbolName); // To always have a null-terminated string + snprintf(properties.description, sizeof(properties.description), "%s", + metricPrototypeParams->LongName); + properties.domain = domain; + properties.tierNumber = getMetricTierNumber(metricPrototypeParams->UsageFlagsMask); + properties.samplingType = getSamplingTypeFromApiMask(metricPrototypeParams->ApiMask); + properties.parameterCount = metricPrototypeParams->OptionDescriptorCount; + properties.sourceId = oaSourceId; + auto pMetricProgrammable = OaMetricProgrammableImp::create(properties, concurrentGroup, *metricPrototype, metricSource); + metricProgrammables.push_back(pMetricProgrammable); + } +} + +ze_result_t MetricEnumeration::metricProgrammableGet(uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables) { + ze_result_t result = initialize(); + if (result != ZE_RESULT_SUCCESS) { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + } + + // For Root device, create multi device programmables + if (metricProgrammables.size() == 0 && metricSource.isImplicitScalingCapable()) { + auto &device = metricSource.getDevice(); + const auto &deviceImp = *static_cast(&device); + MetricEnumeration &metricEnumeration = deviceImp.subDevices[0]->getMetricDeviceContext().getMetricSource().getMetricEnumeration(); + const uint32_t programmableCount = static_cast(metricEnumeration.getProgrammables().size()); + metricProgrammables.reserve(programmableCount); + + for (uint32_t index = 0; index < programmableCount; index++) { + std::vector subDeviceProgrammables{}; + // Get metric programmables from all sub devices. + for (auto subDevice : deviceImp.subDevices) { + MetricEnumeration &subDeviceEnumeration = subDevice->getMetricDeviceContext().getMetricSource().getMetricEnumeration(); + subDeviceProgrammables.push_back(subDeviceEnumeration.getProgrammables()[index]); + } + metricProgrammables.push_back(HomogeneousMultiDeviceMetricProgrammable::create(metricSource, subDeviceProgrammables)); + } + } + + if (*pCount == 0) { + *pCount = static_cast(metricProgrammables.size()); + return ZE_RESULT_SUCCESS; + } + + *pCount = std::min(*pCount, static_cast(metricProgrammables.size())); + for (uint32_t i = 0; i < *pCount; i++) { + phMetricProgrammables[i] = metricProgrammables[i]->toHandle(); + } + return ZE_RESULT_SUCCESS; +} + +zet_intel_metric_sampling_type_exp_flag_t MetricEnumeration::getSamplingTypeFromApiMask(const uint32_t apiMask) { + const uint32_t checkMask = MetricsDiscovery::API_TYPE_IOSTREAM | MetricsDiscovery::API_TYPE_OCL | MetricsDiscovery::API_TYPE_OGL4_X; + if ((apiMask & checkMask) == checkMask) { + return ZET_INTEL_METRIC_SAMPLING_TYPE_EXP_FLAG_TIME_AND_EVENT_BASED; + } + + if (apiMask & MetricsDiscovery::API_TYPE_IOSTREAM) { + return ZET_INTEL_METRIC_SAMPLING_TYPE_EXP_FLAG_TIME_BASED; + } else { + return ZET_INTEL_METRIC_SAMPLING_TYPE_EXP_FLAG_EVENT_BASED; + } +} + +void MetricEnumeration::cleanupExtendedMetricInformation() { + for (size_t i = 0; i < metricProgrammables.size(); ++i) { + delete metricProgrammables[i]; + } + metricProgrammables.clear(); +} + OaMetricGroupImp ::~OaMetricGroupImp() { for (size_t i = 0; i < metrics.size(); ++i) { @@ -898,8 +1013,8 @@ ze_result_t OaMetricGroupImp::getMetricTimestampsExp(const ze_bool_t synchronize uint32_t cpuId; MetricsDiscovery::ECompletionCode mdapiRetVal; - MetricsDiscovery::IMetricsDevice_1_5 *metricDevice; - metricDevice = getMetricSource()->getMetricEnumeration().getMetricDevice(); + MetricsDiscovery::IMetricsDevice_1_13 *metricDevice; + metricDevice = getMetricSource()->getMetricEnumeration().getMdapiDevice(); // MDAPI returns GPU timestamps in nanoseconds mdapiRetVal = metricDevice->GetGpuCpuTimestamps(metricTimestamp, &hostTimestamp, &cpuId); @@ -999,7 +1114,7 @@ ze_result_t OaMetricGroupImp::getCalculatedMetricValues(const zet_metric_group_c ze_result_t OaMetricGroupImp::initialize(const zet_metric_group_properties_t &sourceProperties, MetricsDiscovery::IMetricSet_1_5 &metricSet, - MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup, + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup, const std::vector &groupMetrics, OaMetricSourceImp &metricSource) { copyProperties(sourceProperties, properties); @@ -1102,7 +1217,7 @@ void OaMetricImp::copyProperties(const zet_metric_properties_t &source, MetricGroup *OaMetricGroupImp::create(zet_metric_group_properties_t &properties, MetricsDiscovery::IMetricSet_1_5 &metricSet, - MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup, + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup, const std::vector &metrics, MetricSource &metricSource) { auto pMetricGroup = new OaMetricGroupImp(metricSource); 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 008efeab6d..f626867cc7 100644 --- a/level_zero/tools/source/metrics/metric_oa_enumeration_imp.h +++ b/level_zero/tools/source/metrics/metric_oa_enumeration_imp.h @@ -20,6 +20,7 @@ static constexpr std::string_view globalSymbolOaMaxBufferSize = "OABufferMaxSize static constexpr std::string_view globalSymbolOaMaxTimestamp = "MaxTimestamp"; struct MetricEnumeration { + static const uint32_t oaSourceId = 0x0A; MetricEnumeration(OaMetricSourceImp &metricSource); virtual ~MetricEnumeration(); @@ -34,40 +35,38 @@ struct MetricEnumeration { uint32_t getMaxOaBufferSize() const { return maximumOaBufferSize; } bool readGlobalSymbol(const char *name, uint32_t &symbolValue); bool readGlobalSymbol(const char *name, uint64_t &symbolValue); - MetricsDiscovery::IMetricsDevice_1_5 *getMetricDevice() { return pMetricsDevice; }; - - MetricsDiscovery::IMetricsDevice_1_5 *getMdapiDevice() { return pMetricsDevice; } - MetricsDiscovery::IAdapter_1_9 *getMdapiAdapter() { return pAdapter; } - MetricsDiscovery::IAdapterGroup_1_9 *getMdapiAdapterGroup() { return pAdapterGroup; } + MetricsDiscovery::IMetricsDevice_1_13 *getMdapiDevice() { return pMetricsDevice; } + MetricsDiscovery::IAdapter_1_13 *getMdapiAdapter() { return pAdapter; } + MetricsDiscovery::IAdapterGroup_1_13 *getMdapiAdapterGroup() { return pAdapterGroup; } OaMetricSourceImp &getMetricSource() { return metricSource; } - virtual MetricsDiscovery::IAdapter_1_9 *getAdapterFromAdapterGroup( - MetricsDiscovery::IAdapterGroup_1_9 *adapterGroup, + virtual MetricsDiscovery::IAdapter_1_13 *getAdapterFromAdapterGroup( + MetricsDiscovery::IAdapterGroup_1_13 *adapterGroup, uint32_t index) { UNRECOVERABLE_IF(pAdapterGroup == nullptr); UNRECOVERABLE_IF(pAdapterGroup->GetAdapter(index) == nullptr); return pAdapterGroup->GetAdapter(index); } - virtual const MetricsDiscovery::TAdapterGroupParams_1_6 *getAdapterGroupParams(MetricsDiscovery::IAdapterGroup_1_9 *adapterGroup) { + virtual const MetricsDiscovery::TAdapterGroupParams_1_6 *getAdapterGroupParams(MetricsDiscovery::IAdapterGroup_1_13 *adapterGroup) { return adapterGroup->GetParams(); } virtual const MetricsDiscovery::TAdapterParams_1_9 *getAdapterParams( - MetricsDiscovery::IAdapter_1_9 *pAdapter) { + MetricsDiscovery::IAdapter_1_13 *pAdapter) { return pAdapter->GetParams(); } - virtual void openMetricsSubDeviceFromAdapter(MetricsDiscovery::IAdapter_1_9 *pAdapter, - const uint32_t subDeviceIndex, MetricsDiscovery::IMetricsDevice_1_5 **metricsDevice) { + virtual void openMetricsSubDeviceFromAdapter(MetricsDiscovery::IAdapter_1_13 *pAdapter, + const uint32_t subDeviceIndex, MetricsDiscovery::IMetricsDevice_1_13 **metricsDevice) { pAdapter->OpenMetricsSubDevice(subDeviceIndex, metricsDevice); } virtual void openMetricsDeviceFromAdapter( - MetricsDiscovery::IAdapter_1_9 *pAdapter, - MetricsDiscovery::IMetricsDevice_1_5 **metricsDevice) { + MetricsDiscovery::IAdapter_1_13 *pAdapter, + MetricsDiscovery::IMetricsDevice_1_13 **metricsDevice) { pAdapter->OpenMetricsDevice(metricsDevice); } - virtual MetricsDiscovery::IConcurrentGroup_1_5 *getConcurrentGroupFromDevice( - MetricsDiscovery::IMetricsDevice_1_5 *metricDevice, + virtual MetricsDiscovery::IConcurrentGroup_1_13 *getConcurrentGroupFromDevice( + MetricsDiscovery::IMetricsDevice_1_13 *metricDevice, uint32_t index) { return metricDevice->GetConcurrentGroup(index); } @@ -77,18 +76,34 @@ struct MetricEnumeration { void getL0MetricPropertiesFromMdapiMetric(zet_metric_properties_t &l0MetricProps, MetricsDiscovery::IMetric_1_0 *mdapiMetric); void getL0MetricPropertiesFromMdapiInformation(zet_metric_properties_t &l0MetricProps, MetricsDiscovery::IInformation_1_0 *mdapiInformation); MetricsDiscovery::IInformationLatest *getOaBufferOverflowInformation() const { return pOaBufferOverflowInformation; } + ze_result_t metricProgrammableGet(uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables); + MetricsDiscovery::IConcurrentGroup_1_13 *getConcurrentGroup() { + return pConcurrentGroup; + } + void cleanupExtendedMetricInformation(); + void setAdapterGroup(MetricsDiscovery::IAdapterGroup_1_13 *adapterGroup) { + pAdapterGroup = adapterGroup; + } + ze_result_t cacheExtendedMetricInformation( + MetricsDiscovery::IConcurrentGroup_1_13 &pConcurrentGroup, + const uint32_t domain); + void setInitializationState(ze_result_t state) { + initializationState = state; + } protected: ze_result_t initialize(); - virtual ze_result_t openMetricsDiscovery(); virtual bool getAdapterId(uint32_t &major, uint32_t &minor); - virtual MetricsDiscovery::IAdapter_1_9 *getMetricsAdapter(); + virtual MetricsDiscovery::IAdapter_1_13 *getMetricsAdapter(); ze_result_t cleanupMetricsDiscovery(); + bool isMetricProgrammableSupportEnabled() { + return metricSource.getMetricDeviceContext().isProgrammableMetricsEnabled; + } ze_result_t cacheMetricInformation(); ze_result_t cacheMetricGroup(MetricsDiscovery::IMetricSet_1_5 &metricSet, - MetricsDiscovery::IConcurrentGroup_1_5 &pConcurrentGroup, + MetricsDiscovery::IConcurrentGroup_1_13 &pConcurrentGroup, const uint32_t domain, const zet_metric_group_sampling_type_flag_t samplingType); ze_result_t createMetrics(MetricsDiscovery::IMetricSet_1_5 &metricSet, @@ -98,30 +113,37 @@ struct MetricEnumeration { uint32_t getMetricTierNumber(const uint32_t sourceUsageFlagsMask) const; zet_metric_type_t getMetricType(const MetricsDiscovery::TInformationType sourceInformationType) const; - virtual ze_result_t cacheExtendedMetricInformation( - MetricsDiscovery::IConcurrentGroup_1_5 &pConcurrentGroup, - const uint32_t domain) { return ZE_RESULT_SUCCESS; }; + zet_intel_metric_sampling_type_exp_flag_t getSamplingTypeFromApiMask(const uint32_t apiMask); + std::vector &getProgrammables() { + return metricProgrammables; + } - virtual void cleanupExtendedMetricInformation() {} - - protected: OaMetricSourceImp &metricSource; std::vector metricGroups; // Cached metric groups + std::vector metricProgrammables{}; ze_result_t initializationState = ZE_RESULT_ERROR_UNINITIALIZED; // Metrics Discovery API. std::unique_ptr hMetricsDiscovery = nullptr; MetricsDiscovery::OpenAdapterGroup_fn openAdapterGroup = nullptr; - MetricsDiscovery::IAdapterGroup_1_9 *pAdapterGroup = nullptr; - MetricsDiscovery::IAdapter_1_9 *pAdapter = nullptr; - MetricsDiscovery::IMetricsDevice_1_5 *pMetricsDevice = nullptr; + MetricsDiscovery::IAdapterGroup_1_13 *pAdapterGroup = nullptr; + MetricsDiscovery::IAdapter_1_13 *pAdapter = nullptr; + MetricsDiscovery::IMetricsDevice_1_13 *pMetricsDevice = nullptr; uint32_t maximumOaBufferSize = 0u; MetricsDiscovery::IInformationLatest *pOaBufferOverflowInformation = nullptr; + void cacheMetricPrototypes( + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup, + const uint32_t domain); + void updateMetricProgrammablesFromPrototypes( + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup, + const std::vector &metricPrototypes, + uint32_t domain); + MetricsDiscovery::IConcurrentGroup_1_13 *pConcurrentGroup = nullptr; public: - // Metrics Discovery version should be at least 1.5. + // Metrics Discovery version should be at least 1.13. static const uint32_t requiredMetricsDiscoveryMajorVersion = 1; - static const uint32_t requiredMetricsDiscoveryMinorVersion = 5; + static const uint32_t requiredMetricsDiscoveryMinorVersion = 13; static const char *oaConcurrentGroupName; }; @@ -155,7 +177,7 @@ struct OaMetricGroupImp : public MetricGroupImp { } ze_result_t initialize(const zet_metric_group_properties_t &sourceProperties, MetricsDiscovery::IMetricSet_1_5 &metricSet, - MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup, + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup, const std::vector &groupMetrics, OaMetricSourceImp &metricSource); @@ -191,7 +213,7 @@ struct OaMetricGroupImp : public MetricGroupImp { uint8_t *pExportData) override; static MetricGroup *create(zet_metric_group_properties_t &properties, MetricsDiscovery::IMetricSet_1_5 &metricSet, - MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup, + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup, const std::vector &metrics, MetricSource &metricSource); OaMetricSourceImp *getMetricSource() const { return static_cast(&metricSource); } @@ -218,7 +240,7 @@ struct OaMetricGroupImp : public MetricGroupImp { std::vector metrics; zet_metric_group_properties_t properties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; MetricsDiscovery::IMetricSet_1_5 *pReferenceMetricSet = nullptr; - MetricsDiscovery::IConcurrentGroup_1_5 *pReferenceConcurrentGroup = nullptr; + MetricsDiscovery::IConcurrentGroup_1_13 *pReferenceConcurrentGroup = nullptr; std::vector metricGroups; size_t cachedExportDataHeapSize = 0; diff --git a/level_zero/tools/source/metrics/metric_oa_programmable_imp.cpp b/level_zero/tools/source/metrics/metric_oa_programmable_imp.cpp new file mode 100644 index 0000000000..c3e2d1a507 --- /dev/null +++ b/level_zero/tools/source/metrics/metric_oa_programmable_imp.cpp @@ -0,0 +1,591 @@ +/* + * Copyright (C) 2023-2024 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "level_zero/tools/source/metrics/metric_oa_programmable_imp.h" + +#include "shared/source/debug_settings/debug_settings_manager.h" + +#include "level_zero/tools/source/metrics/metric.h" +#include "level_zero/tools/source/metrics/metric_oa_enumeration_imp.h" + +#include +#include +#include + +namespace L0 { + +static const std::map optionTypeToParameterTypeMap{ + {MetricsDiscovery::OPTION_DESCRIPTOR_TYPE_DISAGGREGATION, ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_DISAGGREGATION}, + {MetricsDiscovery::OPTION_DESCRIPTOR_TYPE_LATENCY, ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_LATENCY}, + {MetricsDiscovery::OPTION_DESCRIPTOR_TYPE_NORMALIZATION_UTILIZATION, ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_NORMALIZATION_UTILIZATION}, + {MetricsDiscovery::OPTION_DESCRIPTOR_TYPE_NORMALIZATION_AVERAGE, ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_NORMALIZATION_AVERAGE}, + {MetricsDiscovery::OPTION_DESCRIPTOR_TYPE_NORMALIZATION_RATE, ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_NORMALIZATION_RATE}, + {MetricsDiscovery::OPTION_DESCRIPTOR_TYPE_NORMALIZATION_BYTE, static_cast(ZET_INTEL_METRIC_PROGRAMMABLE_PARAM_TYPE_NORMALIZATION_BYTE_EXP)}}; + +static const std::map optionTypeToDefaultValueMap{ + // Default value for disaggregation is disabled (which means aggregated). + // However, MDAPI accepts values for disaggregation which represent slice index. + // So having a special default-value (UINT64_MAX) to represent aggregated case + {MetricsDiscovery::OPTION_DESCRIPTOR_TYPE_DISAGGREGATION, UINT64_MAX}, + {MetricsDiscovery::OPTION_DESCRIPTOR_TYPE_LATENCY, 0u}, + {MetricsDiscovery::OPTION_DESCRIPTOR_TYPE_NORMALIZATION_UTILIZATION, 0u}, + {MetricsDiscovery::OPTION_DESCRIPTOR_TYPE_NORMALIZATION_AVERAGE, 0u}, + {MetricsDiscovery::OPTION_DESCRIPTOR_TYPE_NORMALIZATION_RATE, 0u}, + {MetricsDiscovery::OPTION_DESCRIPTOR_TYPE_NORMALIZATION_BYTE, 0u}}; + +static const std::map valueTypeToValueInfoTypeMap{ + {MetricsDiscovery::VALUE_TYPE_UINT32, ZET_VALUE_INFO_TYPE_EXP_UINT32}, + {MetricsDiscovery::VALUE_TYPE_UINT64, ZET_VALUE_INFO_TYPE_EXP_UINT64}, + {MetricsDiscovery::VALUE_TYPE_FLOAT, ZET_VALUE_INFO_TYPE_EXP_FLOAT32}, + {MetricsDiscovery::VALUE_TYPE_BOOL, ZET_VALUE_INFO_TYPE_EXP_BOOL8}, + {MetricsDiscovery::VALUE_TYPE_UINT32_RANGE, ZET_VALUE_INFO_TYPE_EXP_UINT64_RANGE}, + {MetricsDiscovery::VALUE_TYPE_UINT64_RANGE, ZET_VALUE_INFO_TYPE_EXP_UINT64_RANGE}}; + +ze_result_t OaMetricProgrammableImp::getProperties(zet_metric_programmable_exp_properties_t *pProperties) { + + memcpy(&pProperties->component, properties.component, sizeof(pProperties->component)); + memcpy(pProperties->description, properties.description, sizeof(pProperties->description)); + pProperties->domain = properties.domain; + memcpy(pProperties->name, properties.name, sizeof(pProperties->name)); + pProperties->tierNumber = properties.tierNumber; + pProperties->samplingType = properties.samplingType; + pProperties->parameterCount = properties.parameterCount; + pProperties->sourceId = properties.sourceId; + return ZE_RESULT_SUCCESS; +} + +ze_result_t OaMetricProgrammableImp::getParamInfo(uint32_t *pParameterCount, zet_metric_programmable_param_info_exp_t *pParameterInfo) { + + *pParameterCount = std::min(*pParameterCount, properties.parameterCount); + + for (uint32_t i = 0; i < *pParameterCount; i++) { + auto optionDescriptor = pPrototype->GetOptionDescriptor(i); + if (optionDescriptor == nullptr) { + DEBUG_BREAK_IF(true); + return ZE_RESULT_ERROR_UNKNOWN; + } + strcpy_s(pParameterInfo[i].name, ZET_MAX_METRIC_PROGRAMMABLE_PARAMETER_NAME_EXP, optionDescriptor->SymbolName); + pParameterInfo[i].valueInfoCount = optionDescriptor->ValidValueCount; + + { + auto iterator = optionTypeToParameterTypeMap.find(optionDescriptor->Type); + if (iterator == optionTypeToParameterTypeMap.end()) { + DEBUG_BREAK_IF(true); + return ZE_RESULT_ERROR_UNKNOWN; + } + pParameterInfo[i].type = optionTypeToParameterTypeMap.at(optionDescriptor->Type); + } + { + DEBUG_BREAK_IF(optionDescriptor->ValidValueCount == 0); + auto iterator = valueTypeToValueInfoTypeMap.find(optionDescriptor->ValidValues[0].ValueType); + if (iterator == valueTypeToValueInfoTypeMap.end()) { + DEBUG_BREAK_IF(true); + return ZE_RESULT_ERROR_UNKNOWN; + } + pParameterInfo[i].valueInfoType = valueTypeToValueInfoTypeMap.at(optionDescriptor->ValidValues[0].ValueType); + pParameterInfo[i].defaultValue.ui64 = optionTypeToDefaultValueMap.at(optionDescriptor->Type); + } + } + + return ZE_RESULT_SUCCESS; +} + +ze_result_t OaMetricProgrammableImp::copyMdapiValidValueToL0ValueInfo(zet_value_info_exp_t &l0Value, const MetricsDiscovery::TValidValue_1_13 &mdapiValue) { + + switch (mdapiValue.ValueType) { + case MetricsDiscovery::VALUE_TYPE_UINT32: + l0Value.ui32 = mdapiValue.ValueUInt32; + break; + case MetricsDiscovery::VALUE_TYPE_UINT64: + l0Value.ui64 = mdapiValue.ValueUInt64; + break; + case MetricsDiscovery::VALUE_TYPE_UINT32_RANGE: + l0Value.ui64Range.ui64Min = mdapiValue.ValueUInt32Range.Min; + l0Value.ui64Range.ui64Max = mdapiValue.ValueUInt32Range.Max; + break; + case MetricsDiscovery::VALUE_TYPE_UINT64_RANGE: + l0Value.ui64Range.ui64Min = mdapiValue.ValueUInt64Range.Min; + l0Value.ui64Range.ui64Max = mdapiValue.ValueUInt64Range.Max; + break; + default: + DEBUG_BREAK_IF(true); + return ZE_RESULT_ERROR_UNKNOWN; + }; + return ZE_RESULT_SUCCESS; +} + +ze_result_t OaMetricProgrammableImp::getParamValueInfo(uint32_t parameterOrdinal, uint32_t *pValueInfoCount, + zet_metric_programmable_param_value_info_exp_t *pValueInfo) { + + if (parameterOrdinal >= properties.parameterCount) { + return ZE_RESULT_ERROR_INVALID_ARGUMENT; + } + + auto optionDescriptor = pPrototype->GetOptionDescriptor(parameterOrdinal); + + *pValueInfoCount = std::min(*pValueInfoCount, optionDescriptor->ValidValueCount); + for (uint32_t i = 0; i < *pValueInfoCount; i++) { + auto status = copyMdapiValidValueToL0ValueInfo(pValueInfo[i].valueInfo, optionDescriptor->ValidValues[i]); + if (status != ZE_RESULT_SUCCESS) { + *pValueInfoCount = 0; + return status; + } + setParamValueInfoDescription(&pValueInfo[i], properties.name); + } + + return ZE_RESULT_SUCCESS; +} + +ze_result_t OaMetricProgrammableImp::copyL0ValueToMdapiTypedValue(MetricsDiscovery::TTypedValue_1_0 &mdapiValue, + const zet_value_t &l0Value) { + + switch (mdapiValue.ValueType) { + case MetricsDiscovery::VALUE_TYPE_UINT32_RANGE: + case MetricsDiscovery::VALUE_TYPE_UINT32: + mdapiValue.ValueUInt32 = l0Value.ui32; + mdapiValue.ValueType = MetricsDiscovery::VALUE_TYPE_UINT32; + break; + case MetricsDiscovery::VALUE_TYPE_UINT64_RANGE: + case MetricsDiscovery::VALUE_TYPE_UINT64: + mdapiValue.ValueUInt64 = l0Value.ui64; + mdapiValue.ValueType = MetricsDiscovery::VALUE_TYPE_UINT64; + break; + default: + DEBUG_BREAK_IF(true); + return ZE_RESULT_ERROR_UNKNOWN; + }; + + return ZE_RESULT_SUCCESS; +} + +ze_result_t OaMetricProgrammableImp::createMetric(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) { + + if (parameterCount > properties.parameterCount) { + return ZE_RESULT_ERROR_INVALID_ARGUMENT; + } + + // OA generates 1 metric per programmable for 1 combination of parameters + const uint32_t maxMetricHandleCount = 1u; + + if (*pMetricHandleCount == 0) { + *pMetricHandleCount = maxMetricHandleCount; + return ZE_RESULT_SUCCESS; + } + + // Clone the prototype and change name + auto clonedPrototype = pPrototype->Clone(); + if (clonedPrototype == nullptr) { + DEBUG_BREAK_IF(true); + *pMetricHandleCount = 0; + return ZE_RESULT_ERROR_UNKNOWN; + } + + auto mdapiStatus = clonedPrototype->ChangeNames(name, name, description, nullptr); + if (mdapiStatus != MetricsDiscovery::CC_OK) { + DEBUG_BREAK_IF(true); + *pMetricHandleCount = 0; + return ZE_RESULT_ERROR_UNKNOWN; + } + + // Apply the parameter values on the cloned prototype + for (uint32_t i = 0; i < parameterCount; i++) { + + auto optionDescriptor = pPrototype->GetOptionDescriptor(i); + if (optionDescriptor == nullptr) { + *pMetricHandleCount = 0; + DEBUG_BREAK_IF(true); + return ZE_RESULT_ERROR_UNKNOWN; + } + + // If default value, no setting to MDAPI is necessary + if (pParameterValues[i].value.ui64 == + optionTypeToDefaultValueMap.at(optionDescriptor->Type)) { + continue; + } + + MetricsDiscovery::TTypedValue_1_0 mdapiValue{}; + mdapiValue.ValueType = optionDescriptor->ValidValues[0].ValueType; + auto status = copyL0ValueToMdapiTypedValue(mdapiValue, pParameterValues[i].value); + if (status != ZE_RESULT_SUCCESS) { + *pMetricHandleCount = 0; + return status; + } + + auto mdapiStatus = clonedPrototype->SetOption(optionDescriptor->Type, &mdapiValue); + if (mdapiStatus != MetricsDiscovery::CC_OK) { + *pMetricHandleCount = 0; + return ZE_RESULT_ERROR_INVALID_ARGUMENT; + } + } + + // Prepare metric properties + auto prototypeParams = clonedPrototype->GetParams(); + zet_metric_properties_t metricProperties{}; + snprintf(metricProperties.component, sizeof(metricProperties.component), "%s", + prototypeParams->GroupName); + snprintf(metricProperties.name, sizeof(metricProperties.name), "%s", + prototypeParams->SymbolName); // To always have a null-terminated string + snprintf(metricProperties.description, sizeof(metricProperties.description), "%s", + prototypeParams->LongName); + snprintf(metricProperties.resultUnits, sizeof(metricProperties.resultUnits), "%s", + prototypeParams->MetricResultUnits); + metricProperties.tierNumber = properties.tierNumber; + + auto oaMetricSourceImp = static_cast(metricSource); + metricProperties.metricType = oaMetricSourceImp->getMetricEnumeration().getMetricType(prototypeParams->MetricType); + metricProperties.resultType = oaMetricSourceImp->getMetricEnumeration().getMetricResultType(prototypeParams->ResultType); + + // Create MetricFromProgrammable using the properties + *phMetricHandles = OaMetricFromProgrammable::create(*oaMetricSourceImp, metricProperties, clonedPrototype, properties.domain, properties.samplingType)->toHandle(); + *pMetricHandleCount = maxMetricHandleCount; + + return ZE_RESULT_SUCCESS; +} + +void OaMetricProgrammableImp::initialize(zet_metric_programmable_exp_properties_t &properties, + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup, + MetricsDiscovery::IMetricPrototype_1_13 &prototype, + OaMetricSourceImp &metricSource) { + + memcpy(&this->properties, &properties, sizeof(zet_metric_programmable_exp_properties_t)); + this->pConcurrentGroup = &concurrentGroup; + this->pPrototype = &prototype; + this->metricSource = &metricSource; +} + +MetricProgrammable *OaMetricProgrammableImp::create(zet_metric_programmable_exp_properties_t &properties, + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup, + MetricsDiscovery::IMetricPrototype_1_13 &prototype, + MetricSource &metricSource) { + auto pMetricProgrammable = new OaMetricProgrammableImp(); + pMetricProgrammable->initialize(properties, concurrentGroup, prototype, static_cast(metricSource)); + return pMetricProgrammable; +} + +Metric *OaMetricFromProgrammable::create(MetricSource &metricSource, zet_metric_properties_t &properties, + MetricsDiscovery::IMetricPrototype_1_13 *pClonedPrototype, + uint32_t domain, + zet_metric_group_sampling_type_flags_t supportedSamplingTypes) { + auto pMetric = new OaMetricFromProgrammable(metricSource); + UNRECOVERABLE_IF(pMetric == nullptr); + pMetric->initialize(properties); + pMetric->pClonedPrototype = pClonedPrototype; + pMetric->isPredefined = false; + pMetric->domain = domain; + pMetric->supportedSamplingTypes = supportedSamplingTypes; + + return pMetric; +} + +ze_result_t OaMetricFromProgrammable::destroy() { + + // Destroy pClonedPrototype + if (refCount > 0) { + return ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE; + } + delete this; + return ZE_RESULT_SUCCESS; +} + +MetricGroup *OaMetricGroupUserDefined::create(zet_metric_group_properties_t &properties, + MetricsDiscovery::IMetricSet_1_13 &metricSet, + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup, + MetricSource &metricSource) { + + auto pMetricGroup = new OaMetricGroupUserDefined(metricSource); + std::vector groupMetrics{}; + pMetricGroup->initialize(properties, metricSet, concurrentGroup, groupMetrics, static_cast(metricSource)); + + UNRECOVERABLE_IF(pMetricGroup == nullptr); + + return pMetricGroup; +} + +void OaMetricGroupUserDefined::removeMetrics(bool immutable, std::vector &removedMetricList) { + removedMetricList.clear(); + + for (auto &metric : metrics) { + if (immutable == static_cast(metric)->isImmutable()) { + removedMetricList.push_back(metric); + } + } + + for (auto &metric : removedMetricList) { + metrics.erase(std::remove(metrics.begin(), metrics.end(), metric), metrics.end()); + } +} + +ze_result_t OaMetricGroupUserDefined::addMetric(zet_metric_handle_t hMetric, size_t *errorStringSize, char *pErrorString) { + + if (isActivated == true) { + return ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE; + } + + auto metricImp = static_cast(Metric::fromHandle(hMetric)); + if (metricImp->getMetricSource().getType() != MetricSource::metricSourceTypeOa) { + return ZE_RESULT_ERROR_INVALID_ARGUMENT; + } + + auto metric = static_cast(Metric::fromHandle(hMetric)); + if (metric->isImmutable()) { + return ZE_RESULT_ERROR_INVALID_ARGUMENT; + } + + auto metricFromProgrammable = static_cast(metric); + if ((metricFromProgrammable->getSupportedSamplingType() & properties.samplingType) != properties.samplingType) { + + std::string errorString("MetricGroup does not support Metric's samplingtype "); + MetricGroupUserDefined::updateErrorString(errorString, errorStringSize, pErrorString); + + return ZE_RESULT_ERROR_INVALID_ARGUMENT; + } + + // If metric was already added, do nothing + if (std::find(metrics.begin(), metrics.end(), metric) != metrics.end()) { + return ZE_RESULT_SUCCESS; + } + + auto metricSet = getMetricSet(); + + // Trying to add to a finalized Metric group. + if (!isMetricSetOpened) { + auto mdapiStatus = metricSet->Open(); + if (mdapiStatus != MetricsDiscovery::CC_OK) { + DEBUG_BREAK_IF(true); + return ZE_RESULT_ERROR_UNKNOWN; + } + isMetricSetOpened = true; + // Remove immutable metrics, since MDAPI adds them during finalize + std::vector removedMetricList{}; + removeMetrics(true, removedMetricList); + // Delete all removed L0 metric handles, which were previously added + // during finalize, to correspond with MDAPI metrics. + for (auto &removedMetric : removedMetricList) { + delete removedMetric; + } + } + + auto mdapiStatus = metricSet->AddMetric(metricFromProgrammable->pClonedPrototype); + + if (mdapiStatus != MetricsDiscovery::CC_OK) { + + // Use a default string, since this is not supported by Mdapi + std::string errorString("Incompatible Metric"); + MetricGroupUserDefined::updateErrorString(errorString, errorStringSize, pErrorString); + return ZE_RESULT_ERROR_INVALID_ARGUMENT; + } + + properties.domain = metricFromProgrammable->getDomain(); + metricFromProgrammable->incrementRefCount(); + metrics.push_back(metric); + readyToActivate = false; + + return ZE_RESULT_SUCCESS; +} + +ze_result_t OaMetricGroupUserDefined::removeMetric(zet_metric_handle_t hMetric) { + + if (isActivated == true) { + return ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE; + } + + auto metricImp = static_cast(Metric::fromHandle(hMetric)); + if (metricImp->getMetricSource().getType() != MetricSource::metricSourceTypeOa) { + return ZE_RESULT_ERROR_INVALID_ARGUMENT; + } + + auto metric = static_cast(Metric::fromHandle(hMetric)); + if (metric->isImmutable()) { + return ZE_RESULT_ERROR_INVALID_ARGUMENT; + } + + if (std::find(metrics.begin(), metrics.end(), metric) == metrics.end()) { + return ZE_RESULT_SUCCESS; + } + + // Trying to remove from a finalized Metric group + if (!isMetricSetOpened) { + auto mdapiStatus = getMetricSet()->Open(); + if (mdapiStatus != MetricsDiscovery::CC_OK) { + DEBUG_BREAK_IF(true); + return ZE_RESULT_ERROR_UNKNOWN; + } + isMetricSetOpened = true; + + // Remove immutable metrics, since MDAPI adds them during finalize + std::vector removedMetricList{}; + removeMetrics(true, removedMetricList); + // Delete all removed L0 metric handles, which were previously added + // during finalize to correspond with MDAPI metrics. + for (auto &removedMetric : removedMetricList) { + delete removedMetric; + } + } + + auto metricFromProgrammable = static_cast(metric); + auto mdapiStatus = getMetricSet()->RemoveMetric(metricFromProgrammable->pClonedPrototype); + + metrics.erase(std::remove(metrics.begin(), metrics.end(), metric), metrics.end()); + metricFromProgrammable->decrementRefCount(); + if (mdapiStatus != MetricsDiscovery::CC_OK) { + DEBUG_BREAK_IF(true); + return ZE_RESULT_ERROR_UNKNOWN; + } + + readyToActivate = false; + + return ZE_RESULT_SUCCESS; +} + +ze_result_t OaMetricGroupUserDefined::close() { + + // Already closed group + if (readyToActivate == true) { + return ZE_RESULT_SUCCESS; + } + + // Groups are closed by default. + // Open Activated Groups are not possible. + DEBUG_BREAK_IF(isActivated == true); + + if (metrics.size() == 0) { + METRICS_LOG_ERR("%s", "metrics count is 0 for the metric group.") + return ZE_RESULT_NOT_READY; + } + + auto metricSet = getMetricSet(); + auto mdapiStatus = metricSet->Finalize(); + if (mdapiStatus != MetricsDiscovery::CC_OK) { + DEBUG_BREAK_IF(true); + return ZE_RESULT_ERROR_UNKNOWN; + } + isMetricSetOpened = false; + + // Set API filtering to get metric count as per API + metricSet->SetApiFiltering(OaMetricGroupImp::getApiMask(properties.samplingType)); + auto metricSetParams = metricSet->GetParams(); + auto defaultMetricCount = metricSetParams->MetricsCount - metrics.size(); + OaMetricSourceImp *metricSource = getMetricSource(); + auto &enumeration = metricSource->getMetricEnumeration(); + + // Create and add default metrics + for (int32_t i = static_cast(defaultMetricCount - 1); i >= 0; i--) { + auto mdapiMetric = metricSet->GetMetric(static_cast(i)); + zet_metric_properties_t properties = {}; + enumeration.getL0MetricPropertiesFromMdapiMetric(properties, mdapiMetric); + auto pMetric = OaMetricImp::create(*metricSource, properties); + UNRECOVERABLE_IF(pMetric == nullptr); + + // Insert it to the beginning + metrics.insert(metrics.begin(), pMetric); + } + + // Create and add default information + for (uint32_t i = 0; i < metricSetParams->InformationCount; i++) { + auto mdapiInformation = metricSet->GetInformation(i); + zet_metric_properties_t properties = {}; + enumeration.getL0MetricPropertiesFromMdapiInformation(properties, mdapiInformation); + auto pMetric = OaMetricImp::create(*metricSource, properties); + UNRECOVERABLE_IF(pMetric == nullptr); + + metrics.push_back(pMetric); + } + properties.metricCount = static_cast(metrics.size()); + + readyToActivate = true; + + // Disable API filtering + metricSet->SetApiFiltering(MetricsDiscovery::API_TYPE_ALL); + return ZE_RESULT_SUCCESS; +} + +OaMetricGroupUserDefined::~OaMetricGroupUserDefined() { + // Remove mutable metrics, since they will destroyed + // by the application + std::vector removedMetricList{}; + removeMetrics(false, removedMetricList); + for (auto mutableMetric : removedMetricList) { + auto metricFromProgrammable = static_cast(L0::Metric::fromHandle(mutableMetric)); + metricFromProgrammable->decrementRefCount(); + } +} + +ze_result_t OaMetricGroupUserDefined::destroy() { + + if (isActivated == true) { + return ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE; + } + + delete this; + return ZE_RESULT_SUCCESS; +} + +bool OaMetricGroupUserDefined::activate() { + + auto status = false; + + if (readyToActivate) { + status = OaMetricGroupImp::activate(); + if (status == true) { + isActivated = true; + } + } + + return status; +} + +bool OaMetricGroupUserDefined::deactivate() { + + bool status = true; + if (isActivated) { + status = OaMetricGroupImp::deactivate(); + } + isActivated = false; + return status; +} + +OaMultiDeviceMetricGroupUserDefined *OaMultiDeviceMetricGroupUserDefined::create( + MetricSource &metricSource, + std::vector &subDeviceMetricGroups, + std::vector &inMultiDeviceMetrics) { + auto metricGroupUserDefined = new OaMultiDeviceMetricGroupUserDefined(metricSource); + metricGroupUserDefined->metricGroups = subDeviceMetricGroups; + metricGroupUserDefined->multiDeviceMetrics = inMultiDeviceMetrics; + + metricGroupUserDefined->createdMetricGroupManager = std::make_unique( + metricSource, + metricGroupUserDefined->metricGroups, + metricGroupUserDefined->multiDeviceMetrics); + return metricGroupUserDefined; +} + +ze_result_t OaMultiDeviceMetricGroupUserDefined::metricGet(uint32_t *pCount, zet_metric_handle_t *phMetrics) { + return createdMetricGroupManager->metricGet(pCount, phMetrics); +} + +ze_result_t OaMultiDeviceMetricGroupUserDefined::addMetric(zet_metric_handle_t hMetric, size_t *errorStringSize, char *pErrorString) { + return createdMetricGroupManager->addMetric(hMetric, errorStringSize, pErrorString); +} + +ze_result_t OaMultiDeviceMetricGroupUserDefined::removeMetric(zet_metric_handle_t hMetric) { + return createdMetricGroupManager->removeMetric(hMetric); +} + +ze_result_t OaMultiDeviceMetricGroupUserDefined::close() { + return createdMetricGroupManager->close(); +} + +ze_result_t OaMultiDeviceMetricGroupUserDefined::destroy() { + auto status = createdMetricGroupManager->destroy(); + delete this; + return status; +} + +} // namespace L0 diff --git a/level_zero/tools/source/metrics/metric_oa_programmable_imp.h b/level_zero/tools/source/metrics/metric_oa_programmable_imp.h new file mode 100644 index 0000000000..e592cf1c35 --- /dev/null +++ b/level_zero/tools/source/metrics/metric_oa_programmable_imp.h @@ -0,0 +1,108 @@ +/* + * Copyright (C) 2023-2024 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#pragma once + +#include "level_zero/tools/source/metrics/metric.h" +#include "level_zero/tools/source/metrics/metric_multidevice_programmable.h" +#include "level_zero/tools/source/metrics/metric_oa_enumeration_imp.h" + +#include + +namespace L0 { + +struct OaMetricProgrammableImp : public MetricProgrammable { + OaMetricProgrammableImp() = default; + ~OaMetricProgrammableImp() override = default; + ze_result_t getProperties(zet_metric_programmable_exp_properties_t *pProperties) override; + ze_result_t getParamInfo(uint32_t *pParameterCount, zet_metric_programmable_param_info_exp_t *pParameterInfo) override; + ze_result_t getParamValueInfo(uint32_t parameterOrdinal, uint32_t *pValueInfoCount, + zet_metric_programmable_param_value_info_exp_t *pValueInfo) override; + ze_result_t createMetric(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) override; + void initialize(zet_metric_programmable_exp_properties_t &properties, + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup, + MetricsDiscovery::IMetricPrototype_1_13 &prototype, + OaMetricSourceImp &metricSource); + static MetricProgrammable *create(zet_metric_programmable_exp_properties_t &properties, + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup, + MetricsDiscovery::IMetricPrototype_1_13 &prototype, + MetricSource &metricSource); + + protected: + zet_metric_programmable_exp_properties_t properties{}; + MetricsDiscovery::IConcurrentGroup_1_13 *pConcurrentGroup = nullptr; + MetricsDiscovery::IMetricPrototype_1_13 *pPrototype = nullptr; + MetricSource *metricSource = nullptr; + + ze_result_t copyMdapiValidValueToL0ValueInfo(zet_value_info_exp_t &l0Value, const MetricsDiscovery::TValidValue_1_13 &mdapiValue); + ze_result_t copyL0ValueToMdapiTypedValue(MetricsDiscovery::TTypedValue_1_0 &mdapiValue, const zet_value_t &l0Value); +}; + +struct OaMetricFromProgrammable : OaMetricImp, MetricCreated { + ~OaMetricFromProgrammable() override {} + OaMetricFromProgrammable(MetricSource &metricSource) : OaMetricImp(metricSource) {} + ze_result_t destroy() override; + static Metric *create(MetricSource &metricSource, zet_metric_properties_t &properties, + MetricsDiscovery::IMetricPrototype_1_13 *pClonedPrototype, + uint32_t domain, + zet_metric_group_sampling_type_flags_t supportedSamplingTypes); + MetricsDiscovery::IMetricPrototype_1_13 *pClonedPrototype = nullptr; + uint32_t getDomain() { return domain; } + zet_metric_group_sampling_type_flags_t getSupportedSamplingType() { + return supportedSamplingTypes; + } + + protected: + uint32_t domain = 0; + zet_metric_group_sampling_type_flags_t supportedSamplingTypes = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_FORCE_UINT32; +}; + +struct OaMetricGroupUserDefined : OaMetricGroupImp { + ~OaMetricGroupUserDefined() override; + bool activate() override; + bool deactivate() override; + static MetricGroup *create(zet_metric_group_properties_t &properties, + MetricsDiscovery::IMetricSet_1_13 &metricSet, + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup, + MetricSource &metricSource); + ze_result_t addMetric(zet_metric_handle_t hMetric, size_t *errorStringSize, char *pErrorString) override; + ze_result_t removeMetric(zet_metric_handle_t hMetric) override; + ze_result_t close() override; + ze_result_t destroy() override; + + protected: + OaMetricGroupUserDefined(MetricSource &metricSource) : OaMetricGroupImp(metricSource) { isPredefined = false; } + bool readyToActivate = false; + bool isMetricSetOpened = false; + bool isActivated = false; + void removeMetrics(bool immutable, std::vector &removedMetricList); + MetricsDiscovery::IMetricSet_1_13 *getMetricSet() { + return static_cast(pReferenceMetricSet); + } +}; + +struct OaMultiDeviceMetricGroupUserDefined : OaMetricGroupImp { + + OaMultiDeviceMetricGroupUserDefined(MetricSource &metricSource) : OaMetricGroupImp(metricSource) {} + static OaMultiDeviceMetricGroupUserDefined *create(MetricSource &metricSource, + std::vector &subDeviceMetricGroups, + std::vector &multiDeviceMetrics); + ze_result_t metricGet(uint32_t *pCount, zet_metric_handle_t *phMetrics) override; + ze_result_t addMetric(zet_metric_handle_t hMetric, size_t *errorStringSize, char *pErrorString) override; + ze_result_t removeMetric(zet_metric_handle_t hMetric) override; + ze_result_t close() override; + ze_result_t destroy() override; + + private: + std::unique_ptr createdMetricGroupManager = nullptr; + std::vector multiDeviceMetrics{}; +}; + +} // namespace L0 diff --git a/level_zero/tools/source/metrics/metric_oa_source.cpp b/level_zero/tools/source/metrics/metric_oa_source.cpp index 7b102381cf..37d17afa45 100644 --- a/level_zero/tools/source/metrics/metric_oa_source.cpp +++ b/level_zero/tools/source/metrics/metric_oa_source.cpp @@ -13,7 +13,10 @@ #include "level_zero/core/source/device/device_imp.h" #include "level_zero/include/zet_intel_gpu_metric.h" #include "level_zero/tools/source/metrics/metric.h" +#include "level_zero/tools/source/metrics/metric_multidevice_programmable.h" +#include "level_zero/tools/source/metrics/metric_multidevice_programmable.inl" #include "level_zero/tools/source/metrics/metric_oa_enumeration_imp.h" +#include "level_zero/tools/source/metrics/metric_oa_programmable_imp.h" #include "level_zero/tools/source/metrics/metric_oa_query_imp.h" namespace L0 { @@ -236,6 +239,165 @@ ze_result_t OaMetricSourceImp::handleMetricGroupExtendedProperties(zet_metric_gr return retVal; } +void 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) { + + zet_metric_group_properties_t properties{}; + memcpy_s(properties.description, ZET_MAX_METRIC_GROUP_DESCRIPTION, description, ZET_MAX_METRIC_GROUP_DESCRIPTION); + memcpy_s(properties.name, ZET_MAX_METRIC_GROUP_NAME, name, ZET_MAX_METRIC_GROUP_NAME); + properties.samplingType = samplingType; + properties.domain = UINT32_MAX; + + auto concurrentGrp = getMetricEnumeration().getConcurrentGroup(); + MetricsDiscovery::IMetricSet_1_13 *metricSet = concurrentGrp->AddMetricSet(name, description); + auto metricGroup = OaMetricGroupUserDefined::create(properties, *metricSet, *concurrentGrp, *this); + *pMetricGroupHandle = metricGroup->toHandle(); +} + +ze_result_t OaMetricSourceImp::metricGroupCreateFromMetric(const char *pName, const char *pDescription, + zet_metric_group_sampling_type_flags_t samplingType, zet_metric_handle_t hMetric, + zet_metric_group_handle_t *phMetricGroup) { + + zet_metric_group_handle_t hMetricGroup{}; + metricGroupCreate(pName, pDescription, static_cast(samplingType), &hMetricGroup); + + auto oaMetricGroupImp = static_cast(MetricGroup::fromHandle(hMetricGroup)); + size_t errorStringSize = 0; + auto status = oaMetricGroupImp->addMetric(hMetric, &errorStringSize, nullptr); + if (status != ZE_RESULT_SUCCESS) { + oaMetricGroupImp->destroy(); + return status; + } + + *phMetricGroup = hMetricGroup; + return status; +} + +ze_result_t OaMetricSourceImp::createMetricGroupsFromMetrics(std::vector &metricList, + const char metricGroupNamePrefix[ZET_INTEL_MAX_METRIC_GROUP_NAME_PREFIX_EXP], + const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION], + uint32_t *maxMetricGroupCount, + std::vector &metricGroupList) { + + if (isImplicitScalingCapable()) { + return MultiDeviceCreatedMetricGroupManager::createMultipleMetricGroupsFromMetrics( + metricDeviceContext, *this, metricList, + metricGroupNamePrefix, description, + maxMetricGroupCount, metricGroupList); + } + + const auto isCountCalculationPath = *maxMetricGroupCount == 0; + + auto cleanupCreatedGroups = [](std::vector &createdMetricGroupList) { + for (auto &metricGroup : createdMetricGroupList) { + zetMetricGroupDestroyExp(metricGroup); + } + createdMetricGroupList.clear(); + }; + + if (isCountCalculationPath) { + // Metric group can be for streamer and query from a single programmable + // So multiplying by 2 to estimate the maximum metric group count + *maxMetricGroupCount = static_cast(metricList.size()) * 2u; + return ZE_RESULT_SUCCESS; + } + + // Arrange the metrics based on their sampling types + std::map> samplingTypeToMeticMap{}; + for (auto &metric : metricList) { + auto metricImp = static_cast(Metric::fromHandle(metric)); + auto metricFromProgrammable = static_cast(metricImp); + auto samplingType = metricFromProgrammable->getSupportedSamplingType(); + // Different metric groups based on sampling type + if (samplingType == ZET_INTEL_METRIC_SAMPLING_TYPE_EXP_FLAG_TIME_AND_EVENT_BASED) { + samplingTypeToMeticMap[ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED].push_back(metric); + samplingTypeToMeticMap[ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED].push_back(metric); + } else { + samplingTypeToMeticMap[samplingType].push_back(metric); + } + } + + metricGroupList.clear(); + uint32_t numMetricGroupsCreated = 0; + + auto createMetricGroupAndAddMetric = [&](zet_metric_handle_t metricHandle, + zet_metric_group_sampling_type_flags_t samplingType, + zet_metric_group_handle_t &metricGroup) { + char metricGroupName[ZET_MAX_METRIC_GROUP_NAME] = {}; + snprintf(metricGroupName, ZET_MAX_METRIC_GROUP_NAME - 1, "%s%d", metricGroupNamePrefix, numMetricGroupsCreated); + auto status = metricGroupCreateFromMetric(metricGroupName, description, samplingType, metricHandle, &metricGroup); + if (status != ZE_RESULT_SUCCESS) { + return status; + } + numMetricGroupsCreated++; + return ZE_RESULT_SUCCESS; + }; + + bool isMaxMetricGroupCountReached = numMetricGroupsCreated >= *maxMetricGroupCount; + // Process the metrics in each sampling type seperately + for (auto &entry : samplingTypeToMeticMap) { + if (isMaxMetricGroupCountReached) { + break; + } + std::vector perSamplingTypeMetricGroupList{}; + zet_metric_group_handle_t currentMetricGroup{}; + auto samplingType = entry.first; + + // Create and add the metrics to group + for (uint32_t index = 0; index < static_cast(entry.second.size()); index++) { + + auto &metricToAdd = entry.second[index]; + bool isAddedToExistingMetricGroup = false; + for (auto &perSamplingTypeMetricGroup : perSamplingTypeMetricGroupList) { + auto oaMetricGroup = static_cast(MetricGroup::fromHandle(perSamplingTypeMetricGroup)); + size_t errorStringSize = 0; + auto status = oaMetricGroup->addMetric(metricToAdd, &errorStringSize, nullptr); + if (status == ZE_RESULT_SUCCESS) { + isAddedToExistingMetricGroup = true; + break; + } + } + + if (!isAddedToExistingMetricGroup) { + if (isMaxMetricGroupCountReached) { + break; + } + currentMetricGroup = nullptr; + auto status = createMetricGroupAndAddMetric(metricToAdd, samplingType, currentMetricGroup); + if (status != ZE_RESULT_SUCCESS) { + cleanupCreatedGroups(metricGroupList); + cleanupCreatedGroups(perSamplingTypeMetricGroupList); + *maxMetricGroupCount = 0; + return status; + } + perSamplingTypeMetricGroupList.push_back(currentMetricGroup); + isMaxMetricGroupCountReached = numMetricGroupsCreated >= *maxMetricGroupCount; + } + } + metricGroupList.insert(metricGroupList.end(), perSamplingTypeMetricGroupList.begin(), perSamplingTypeMetricGroupList.end()); + } + + // close all the metric groups + for (auto &metricGroup : metricGroupList) { + auto oaMetricGroup = static_cast(MetricGroup::fromHandle(metricGroup)); + auto status = oaMetricGroup->close(); + if (status != ZE_RESULT_SUCCESS) { + cleanupCreatedGroups(metricGroupList); + *maxMetricGroupCount = 0; + return status; + } + } + + *maxMetricGroupCount = static_cast(metricGroupList.size()); + return ZE_RESULT_SUCCESS; +} + +ze_result_t OaMetricSourceImp::metricProgrammableGet(uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables) { + return getMetricEnumeration().metricProgrammableGet(pCount, phMetricProgrammables); +} + template <> OaMetricSourceImp &MetricDeviceContext::getMetricSource() const { return static_cast(*metricSources.at(MetricSource::metricSourceTypeOa)); diff --git a/level_zero/tools/source/metrics/metric_oa_source.h b/level_zero/tools/source/metrics/metric_oa_source.h index b85377c4fa..58ee4397f0 100644 --- a/level_zero/tools/source/metrics/metric_oa_source.h +++ b/level_zero/tools/source/metrics/metric_oa_source.h @@ -51,6 +51,18 @@ class OaMetricSourceImp : public MetricSource { static std::unique_ptr create(const MetricDeviceContext &metricDeviceContext); void setMetricOsInterface(std::unique_ptr &metricOAOsInterface); MetricOAOsInterface *getMetricOsInterface() { return metricOAOsInterface.get(); } + ze_result_t metricGroupCreateFromMetric(const char *pName, const char *pDescription, + zet_metric_group_sampling_type_flags_t samplingType, zet_metric_handle_t hMetric, + zet_metric_group_handle_t *phMetricGroup); + ze_result_t createMetricGroupsFromMetrics(std::vector &metricList, + const char metricGroupNamePrefix[ZET_INTEL_MAX_METRIC_GROUP_NAME_PREFIX_EXP], + const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION], + uint32_t *maxMetricGroupCount, + std::vector &metricGroupList) override; + void 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); protected: ze_result_t initializationState = ZE_RESULT_ERROR_UNINITIALIZED; diff --git a/level_zero/tools/source/metrics/os_metric_oa_enumeration_drm.cpp b/level_zero/tools/source/metrics/os_metric_oa_enumeration_drm.cpp index d3779b46a6..2e5aba6612 100644 --- a/level_zero/tools/source/metrics/os_metric_oa_enumeration_drm.cpp +++ b/level_zero/tools/source/metrics/os_metric_oa_enumeration_drm.cpp @@ -15,7 +15,7 @@ bool MetricEnumeration::getAdapterId(uint32_t &major, uint32_t &minor) { return getDrmAdapterId(major, minor, device); } -MetricsDiscovery::IAdapter_1_9 *MetricEnumeration::getMetricsAdapter() { +MetricsDiscovery::IAdapter_1_13 *MetricEnumeration::getMetricsAdapter() { return getDrmMetricsAdapter(this); } diff --git a/level_zero/tools/source/metrics/os_metric_oa_enumeration_drm_or_wddm.cpp b/level_zero/tools/source/metrics/os_metric_oa_enumeration_drm_or_wddm.cpp index 6d2be40eac..c214488a33 100644 --- a/level_zero/tools/source/metrics/os_metric_oa_enumeration_drm_or_wddm.cpp +++ b/level_zero/tools/source/metrics/os_metric_oa_enumeration_drm_or_wddm.cpp @@ -27,7 +27,7 @@ bool MetricEnumeration::getAdapterId(uint32_t &major, uint32_t &minor) { return getDrmAdapterId(major, minor, device); } -MetricsDiscovery::IAdapter_1_9 *MetricEnumeration::getMetricsAdapter() { +MetricsDiscovery::IAdapter_1_13 *MetricEnumeration::getMetricsAdapter() { auto osInterface = metricSource.getMetricDeviceContext().getDevice().getNEODevice()->getRootDeviceEnvironment().osInterface.get(); if (osInterface && osInterface->getDriverModel()->getDriverModelType() == NEO::DriverModelType::wddm) diff --git a/level_zero/tools/source/metrics/os_metric_oa_enumeration_imp_drm.cpp b/level_zero/tools/source/metrics/os_metric_oa_enumeration_imp_drm.cpp index d3779b46a6..2e5aba6612 100644 --- a/level_zero/tools/source/metrics/os_metric_oa_enumeration_imp_drm.cpp +++ b/level_zero/tools/source/metrics/os_metric_oa_enumeration_imp_drm.cpp @@ -15,7 +15,7 @@ bool MetricEnumeration::getAdapterId(uint32_t &major, uint32_t &minor) { return getDrmAdapterId(major, minor, device); } -MetricsDiscovery::IAdapter_1_9 *MetricEnumeration::getMetricsAdapter() { +MetricsDiscovery::IAdapter_1_13 *MetricEnumeration::getMetricsAdapter() { return getDrmMetricsAdapter(this); } diff --git a/level_zero/tools/source/metrics/os_metric_oa_enumeration_wddm.cpp b/level_zero/tools/source/metrics/os_metric_oa_enumeration_wddm.cpp index f62258729e..eec9e39702 100644 --- a/level_zero/tools/source/metrics/os_metric_oa_enumeration_wddm.cpp +++ b/level_zero/tools/source/metrics/os_metric_oa_enumeration_wddm.cpp @@ -15,7 +15,7 @@ bool MetricEnumeration::getAdapterId(uint32_t &major, uint32_t &minor) { return getWddmAdapterId(major, minor, device); } -MetricsDiscovery::IAdapter_1_9 *MetricEnumeration::getMetricsAdapter() { +MetricsDiscovery::IAdapter_1_13 *MetricEnumeration::getMetricsAdapter() { return getWddmMetricsAdapter(this); } diff --git a/level_zero/tools/source/metrics/wddm/os_metric_oa_enumeration_imp_wddm.cpp b/level_zero/tools/source/metrics/wddm/os_metric_oa_enumeration_imp_wddm.cpp index ef5174194b..6e0a76e7f2 100644 --- a/level_zero/tools/source/metrics/wddm/os_metric_oa_enumeration_imp_wddm.cpp +++ b/level_zero/tools/source/metrics/wddm/os_metric_oa_enumeration_imp_wddm.cpp @@ -24,7 +24,7 @@ bool getWddmAdapterId(uint32_t &major, uint32_t &minor, Device &device) { return true; } -MetricsDiscovery::IAdapter_1_9 *getWddmMetricsAdapter(MetricEnumeration *metricEnumeration) { +MetricsDiscovery::IAdapter_1_13 *getWddmMetricsAdapter(MetricEnumeration *metricEnumeration) { uint32_t major = 0; uint32_t minor = 0; diff --git a/level_zero/tools/source/metrics/wddm/os_metric_oa_enumeration_imp_wddm.h b/level_zero/tools/source/metrics/wddm/os_metric_oa_enumeration_imp_wddm.h index 245007c8ec..c7558d53b3 100644 --- a/level_zero/tools/source/metrics/wddm/os_metric_oa_enumeration_imp_wddm.h +++ b/level_zero/tools/source/metrics/wddm/os_metric_oa_enumeration_imp_wddm.h @@ -17,7 +17,7 @@ struct MetricEnumeration; bool getWddmAdapterId(uint32_t &major, uint32_t &minor, Device &device); -MetricsDiscovery::IAdapter_1_9 *getWddmMetricsAdapter(MetricEnumeration *metricEnumeration); +MetricsDiscovery::IAdapter_1_13 *getWddmMetricsAdapter(MetricEnumeration *metricEnumeration); class MetricOAWindowsImp : public MetricOAOsInterface { public: diff --git a/level_zero/tools/test/black_box_tests/zello_metrics/CMakeLists.txt b/level_zero/tools/test/black_box_tests/zello_metrics/CMakeLists.txt index 8850b0d02a..c4c7a57a02 100644 --- a/level_zero/tools/test/black_box_tests/zello_metrics/CMakeLists.txt +++ b/level_zero/tools/test/black_box_tests/zello_metrics/CMakeLists.txt @@ -17,6 +17,7 @@ target_sources(${ZELLO_METRICS_TARGET} ${CMAKE_CURRENT_SOURCE_DIR}/zello_metrics_util.cpp ${CMAKE_CURRENT_SOURCE_DIR}/zello_metrics_export.cpp ${CMAKE_CURRENT_SOURCE_DIR}/zello_metrics_tests.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/zello_metrics_programmable_tests.cpp ${CMAKE_CURRENT_SOURCE_DIR}/zello_metrics_util.h ${CMAKE_CURRENT_SOURCE_DIR}/zello_metrics.h ) diff --git a/level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_programmable_tests.cpp b/level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_programmable_tests.cpp new file mode 100644 index 0000000000..3e0526c9ca --- /dev/null +++ b/level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_programmable_tests.cpp @@ -0,0 +1,964 @@ +/* + * Copyright (C) 2024 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "level_zero/include/zet_intel_gpu_metric.h" +#include "level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics.h" +#include "level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_util.h" + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace zmu = ZelloMetricsUtility; + +////////////////////////// +/// displayAllProgrammables +////////////////////////// +bool displayAllProgrammables() { + // This test shows all programmables available on the device along with its parameter information + bool status = true; + + zmu::TestMachineConfiguration machineConfig = {}; + zmu::getTestMachineConfiguration(machineConfig); + + auto printValueInfo = [](zet_value_info_type_exp_t type, zet_value_info_exp_t valueInfo) { + switch (static_cast(type)) { + case ZET_VALUE_INFO_TYPE_EXP_UINT32: + LOG(zmu::LogLevel::INFO) << valueInfo.ui32; + break; + case ZET_VALUE_INFO_TYPE_EXP_UINT64: + LOG(zmu::LogLevel::INFO) << valueInfo.ui64; + break; + case ZET_VALUE_INFO_TYPE_EXP_FLOAT32: + LOG(zmu::LogLevel::INFO) << valueInfo.fp32; + break; + case ZET_VALUE_INFO_TYPE_EXP_FLOAT64: + LOG(zmu::LogLevel::INFO) << valueInfo.fp64; + break; + case ZET_VALUE_INFO_TYPE_EXP_BOOL8: + LOG(zmu::LogLevel::INFO) << valueInfo.b8; + break; + case ZET_VALUE_INFO_TYPE_EXP_UINT8: + LOG(zmu::LogLevel::INFO) << valueInfo.ui8; + break; + case ZET_VALUE_INFO_TYPE_EXP_UINT16: + LOG(zmu::LogLevel::INFO) << valueInfo.ui16; + break; + case ZET_VALUE_INFO_TYPE_EXP_UINT64_RANGE: + LOG(zmu::LogLevel::INFO) << "[" << valueInfo.ui64Range.ui64Min << "," << valueInfo.ui64Range.ui64Max << "]"; + break; + case ZET_INTEL_VALUE_INFO_TYPE_FLOAT64_RANGE_EXP: { + double minVal = 0; + memcpy(&minVal, &valueInfo.ui64Range.ui64Min, sizeof(uint64_t)); + double maxVal = 0; + memcpy(&maxVal, &valueInfo.ui64Range.ui64Max, sizeof(uint64_t)); + LOG(zmu::LogLevel::INFO) << "[" << minVal << "," << maxVal << "]"; + } break; + default: + VALIDATECALL(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE); + break; + } + }; + + auto printValue = [](zet_value_info_type_exp_t type, zet_value_t value) { + switch (static_cast(type)) { + case ZET_VALUE_INFO_TYPE_EXP_UINT32: + LOG(zmu::LogLevel::INFO) << value.ui32; + break; + case ZET_VALUE_INFO_TYPE_EXP_UINT64: + LOG(zmu::LogLevel::INFO) << value.ui64; + break; + case ZET_VALUE_INFO_TYPE_EXP_FLOAT32: + LOG(zmu::LogLevel::INFO) << value.fp32; + break; + case ZET_VALUE_INFO_TYPE_EXP_FLOAT64: + LOG(zmu::LogLevel::INFO) << value.fp64; + break; + case ZET_VALUE_INFO_TYPE_EXP_BOOL8: + LOG(zmu::LogLevel::INFO) << static_cast(value.b8); + break; + case ZET_VALUE_INFO_TYPE_EXP_UINT8: + LOG(zmu::LogLevel::INFO) << value.ui32; + break; + case ZET_VALUE_INFO_TYPE_EXP_UINT16: + LOG(zmu::LogLevel::INFO) << value.ui32; + break; + case ZET_VALUE_INFO_TYPE_EXP_UINT64_RANGE: + LOG(zmu::LogLevel::INFO) << value.ui64; + break; + case ZET_INTEL_VALUE_INFO_TYPE_FLOAT64_RANGE_EXP: + LOG(zmu::LogLevel::INFO) << value.fp64; + break; + default: + VALIDATECALL(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE); + break; + } + }; + + auto showProgrammableInfo = [&](uint32_t deviceId, int32_t subDeviceId, std::string &metricGroupName) { + if (!zmu::isDeviceAvailable(deviceId, subDeviceId)) { + return false; + } + + LOG(zmu::LogLevel::INFO) << "Displaying Programmable Info : Device [" << deviceId << ", " << subDeviceId << " ] \n"; + + std::unique_ptr executionCtxt = + std::make_unique(deviceId, subDeviceId); + + uint32_t programmableCount = 0; + VALIDATECALL(zetMetricProgrammableGetExp(executionCtxt->getDeviceHandle(0), &programmableCount, nullptr)); + LOG(zmu::LogLevel::INFO) << "Programmable Count" << programmableCount << "\n"; + std::vector metricProgrammables(programmableCount); + VALIDATECALL(zetMetricProgrammableGetExp(executionCtxt->getDeviceHandle(0), &programmableCount, metricProgrammables.data())); + + // Print Programmable information + for (auto &programmable : metricProgrammables) { + zet_metric_programmable_exp_properties_t props{}; + VALIDATECALL(zetMetricProgrammableGetPropertiesExp(programmable, &props)); + LOG(zmu::LogLevel::INFO) << "name:" << props.name << " | desc:" << props.description << " | comp:" << props.component << "\n"; + LOG(zmu::LogLevel::INFO) << "\t paramCount:" << props.parameterCount << " | samplingType:" << props.samplingType << " | sourceId:" << props.sourceId << "\n"; + LOG(zmu::LogLevel::INFO) << "\t tierNum:" << props.tierNumber << " | domain:" << props.domain << "\n"; + + std::vector parameterInfos(props.parameterCount); + uint32_t parameterCount = props.parameterCount; + zetMetricProgrammableGetParamInfoExp(programmable, ¶meterCount, parameterInfos.data()); + + // Print Parameter information in the programmable + for (uint32_t paramIndex = 0; paramIndex < props.parameterCount; paramIndex++) { + LOG(zmu::LogLevel::INFO) << "\t\t [" << paramIndex << "] " + << "name:" << parameterInfos[paramIndex].name << " | type:" << parameterInfos[paramIndex].type << " | valInfoCount:" << parameterInfos[paramIndex].valueInfoCount + << " | valInfoType:" << parameterInfos[paramIndex].valueInfoType << " | default "; + printValue(parameterInfos[paramIndex].valueInfoType, parameterInfos[paramIndex].defaultValue); + + uint32_t paramValueInfoCount = parameterInfos[paramIndex].valueInfoCount; + std::vector paramValueInfos(paramValueInfoCount); + std::vector paramValueInfoDescList(paramValueInfoCount); + for (auto &desc : paramValueInfoDescList) { + desc.stype = static_cast(ZET_INTEL_STRUCTURE_TYPE_METRIC_PROGRAMMABLE_PARAM_VALUE_INFO_DESC_EXP); + desc.pNext = nullptr; + } + + for (uint32_t index = 0; index < paramValueInfos.size(); index++) { + paramValueInfos[index].pNext = ¶mValueInfoDescList[index]; + } + VALIDATECALL(zetMetricProgrammableGetParamValueInfoExp(programmable, paramIndex, ¶mValueInfoCount, paramValueInfos.data())); + + // Print Parameter Value Information in the programmable + for (uint32_t valInfoIndex = 0; valInfoIndex < parameterInfos[paramIndex].valueInfoCount; valInfoIndex++) { + LOG(zmu::LogLevel::INFO) << "\n"; + LOG(zmu::LogLevel::INFO) << "\t\t\t [" << valInfoIndex << "] " + << "desc:" << paramValueInfoDescList[valInfoIndex].description << " | value:"; + printValueInfo(parameterInfos[paramIndex].valueInfoType, paramValueInfos[valInfoIndex].valueInfo); + } + LOG(zmu::LogLevel::INFO) << "\n\n"; + } + LOG(zmu::LogLevel::INFO) << " --------------------------------------------------------\n"; + } + + return true; + }; + + auto testSettings = zmu::TestSettings::get(); + + if (testSettings->deviceId.get() == -1) { + for (uint32_t deviceId = 0; deviceId < machineConfig.deviceCount; deviceId++) { + // Run for all subdevices + for (uint32_t subDeviceId = 0; subDeviceId < machineConfig.devices[deviceId].subDeviceCount; subDeviceId++) { + status &= showProgrammableInfo(deviceId, subDeviceId, testSettings->metricGroupName.get()); + } + // Run for root device + status &= showProgrammableInfo(deviceId, -1, testSettings->metricGroupName.get()); + } + } else { + // Run for specific device + status &= showProgrammableInfo(testSettings->deviceId.get(), testSettings->subDeviceId.get(), testSettings->metricGroupName.get()); + } + + return status; +} + +////////////////////////// +/// CreateMetricFromProgrammables +////////////////////////// +bool createMetricFromProgrammables() { + // This test creates metric from programmables + bool status = true; + + zmu::TestMachineConfiguration machineConfig = {}; + zmu::getTestMachineConfiguration(machineConfig); + + auto printValue = [](zet_value_info_type_exp_t type, zet_value_t value) { + switch (static_cast(type)) { + case ZET_VALUE_INFO_TYPE_EXP_UINT32: + LOG(zmu::LogLevel::DEBUG) << value.ui32; + break; + case ZET_VALUE_INFO_TYPE_EXP_UINT64: + LOG(zmu::LogLevel::DEBUG) << value.ui64; + break; + case ZET_VALUE_INFO_TYPE_EXP_FLOAT32: + LOG(zmu::LogLevel::DEBUG) << value.fp32; + break; + case ZET_VALUE_INFO_TYPE_EXP_FLOAT64: + LOG(zmu::LogLevel::DEBUG) << value.fp64; + break; + case ZET_VALUE_INFO_TYPE_EXP_BOOL8: + LOG(zmu::LogLevel::DEBUG) << static_cast(value.b8); + break; + case ZET_VALUE_INFO_TYPE_EXP_UINT8: + LOG(zmu::LogLevel::DEBUG) << value.ui32; + break; + case ZET_VALUE_INFO_TYPE_EXP_UINT16: + LOG(zmu::LogLevel::DEBUG) << value.ui32; + break; + case ZET_VALUE_INFO_TYPE_EXP_UINT64_RANGE: + LOG(zmu::LogLevel::DEBUG) << value.ui64; + break; + case ZET_INTEL_VALUE_INFO_TYPE_FLOAT64_RANGE_EXP: + LOG(zmu::LogLevel::DEBUG) << value.fp64; + break; + default: + VALIDATECALL(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE); + break; + } + }; + + auto showProgrammableInfo = [&](uint32_t deviceId, int32_t subDeviceId, std::string &metricGroupName) { + if (!zmu::isDeviceAvailable(deviceId, subDeviceId)) { + return false; + } + + LOG(zmu::LogLevel::INFO) << "Displaying Programmable Info : Device [" << deviceId << ", " << subDeviceId << " ] \n"; + + std::unique_ptr executionCtxt = + std::make_unique(deviceId, subDeviceId); + + uint32_t programmableCount = 0; + VALIDATECALL(zetMetricProgrammableGetExp(executionCtxt->getDeviceHandle(0), &programmableCount, nullptr)); + LOG(zmu::LogLevel::INFO) << "Programmable Count" << programmableCount << "\n"; + std::vector metricProgrammables(programmableCount); + VALIDATECALL(zetMetricProgrammableGetExp(executionCtxt->getDeviceHandle(0), &programmableCount, metricProgrammables.data())); + + std::vector parameterValues{}; + + // Print Programmable information + for (auto &programmable : metricProgrammables) { + zet_metric_programmable_exp_properties_t props{}; + VALIDATECALL(zetMetricProgrammableGetPropertiesExp(programmable, &props)); + LOG(zmu::LogLevel::INFO) << "Programmable name:" << props.name << " | desc:" << props.description << "|"; + LOG(zmu::LogLevel::INFO) << " paramCount:" << props.parameterCount << " | samplingType:" << props.samplingType << "| "; + LOG(zmu::LogLevel::INFO) << " tierNum:" << props.tierNumber << " | domain:" << props.domain << "\n"; + + std::vector parameterInfos(props.parameterCount); + uint32_t parameterCount = props.parameterCount; + VALIDATECALL(zetMetricProgrammableGetParamInfoExp(programmable, ¶meterCount, parameterInfos.data())); + EXPECT(parameterCount == props.parameterCount); + + parameterValues.clear(); + parameterValues.resize(props.parameterCount); + + // Print Parameter information in the programmable + for (uint32_t paramIndex = 0; paramIndex < props.parameterCount; paramIndex++) { + LOG(zmu::LogLevel::DEBUG) << "\t\t [" << paramIndex << "] " + << " Param name:" << parameterInfos[paramIndex].name << " | type:" << parameterInfos[paramIndex].type << " | valInfoCount:" << parameterInfos[paramIndex].valueInfoCount + << " | valInfoType:" << parameterInfos[paramIndex].valueInfoType << " | default "; + printValue(parameterInfos[paramIndex].valueInfoType, parameterInfos[paramIndex].defaultValue); + parameterValues[paramIndex].value = parameterInfos[paramIndex].defaultValue; + LOG(zmu::LogLevel::DEBUG) << "\n"; + } + + uint32_t metricHandleCount = 0; + VALIDATECALL(zetMetricCreateFromProgrammableExp(programmable, parameterValues.data(), + props.parameterCount, props.name, props.description, + &metricHandleCount, nullptr)); + std::vector metricHandles(metricHandleCount); + VALIDATECALL(zetMetricCreateFromProgrammableExp(programmable, parameterValues.data(), + props.parameterCount, props.name, props.description, + &metricHandleCount, metricHandles.data())); + LOG(zmu::LogLevel::INFO) << "MetricHandle Count: " << metricHandleCount << "\n"; + for (uint32_t j = 0; j < metricHandleCount; ++j) { + const zet_metric_handle_t metric = metricHandles[j]; + zet_metric_properties_t metricProperties = {}; + VALIDATECALL(zetMetricGetProperties(metric, &metricProperties)); + LOG(zmu::LogLevel::INFO) << "\tMETRIC[" << j << "]: " + << "desc: " << metricProperties.description << "\n"; + LOG(zmu::LogLevel::INFO) << "\t\t -> name: " << metricProperties.name << " | " + << "metricType: " << metricProperties.metricType << " | " + << "resultType: " << metricProperties.resultType << " | " + << "units: " << metricProperties.resultUnits << " | " + << "component: " << metricProperties.component << " | " + << "tier: " << metricProperties.tierNumber << " | " << std::endl; + } + + for (uint32_t j = 0; j < metricHandleCount; ++j) { + VALIDATECALL(zetMetricDestroyExp(metricHandles[j])); + } + + LOG(zmu::LogLevel::DEBUG) << " --------------------------------------------------------\n"; + } + + return true; + }; + + auto testSettings = zmu::TestSettings::get(); + + if (testSettings->deviceId.get() == -1) { + for (uint32_t deviceId = 0; deviceId < machineConfig.deviceCount; deviceId++) { + // Run for all subdevices + for (uint32_t subDeviceId = 0; subDeviceId < machineConfig.devices[deviceId].subDeviceCount; subDeviceId++) { + status &= showProgrammableInfo(deviceId, subDeviceId, testSettings->metricGroupName.get()); + } + // Run for root device + status &= showProgrammableInfo(deviceId, -1, testSettings->metricGroupName.get()); + } + } else { + // Run for specific device + status &= showProgrammableInfo(testSettings->deviceId.get(), testSettings->subDeviceId.get(), testSettings->metricGroupName.get()); + } + + return status; +} + +////////////////////////// +/// testProgrammableMetricGroupCreateDestroy +////////////////////////// +bool testProgrammableMetricGroupCreateDestroy() { + // This test creates metric from programmables + bool status = true; + + zmu::TestMachineConfiguration machineConfig = {}; + zmu::getTestMachineConfiguration(machineConfig); + + auto printValue = [](zet_value_info_type_exp_t type, zet_value_t value) { + switch (static_cast(type)) { + case ZET_VALUE_INFO_TYPE_EXP_UINT32: + LOG(zmu::LogLevel::DEBUG) << value.ui32; + break; + case ZET_VALUE_INFO_TYPE_EXP_UINT64: + LOG(zmu::LogLevel::DEBUG) << value.ui64; + break; + case ZET_VALUE_INFO_TYPE_EXP_FLOAT32: + LOG(zmu::LogLevel::DEBUG) << value.fp32; + break; + case ZET_VALUE_INFO_TYPE_EXP_FLOAT64: + LOG(zmu::LogLevel::DEBUG) << value.fp64; + break; + case ZET_VALUE_INFO_TYPE_EXP_BOOL8: + LOG(zmu::LogLevel::DEBUG) << static_cast(value.b8); + break; + case ZET_VALUE_INFO_TYPE_EXP_UINT8: + LOG(zmu::LogLevel::DEBUG) << value.ui32; + break; + case ZET_VALUE_INFO_TYPE_EXP_UINT16: + LOG(zmu::LogLevel::DEBUG) << value.ui32; + break; + case ZET_VALUE_INFO_TYPE_EXP_UINT64_RANGE: + LOG(zmu::LogLevel::DEBUG) << value.ui64; + break; + case ZET_INTEL_VALUE_INFO_TYPE_FLOAT64_RANGE_EXP: + LOG(zmu::LogLevel::DEBUG) << value.fp64; + break; + default: + VALIDATECALL(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE); + break; + } + }; + + auto testMetricGroupCreateDestroy = [&](uint32_t deviceId, int32_t subDeviceId, std::string &metricGroupName) { + if (!zmu::isDeviceAvailable(deviceId, subDeviceId)) { + return false; + } + + LOG(zmu::LogLevel::INFO) << "Test Programmable Metric Group Create and Destroy: Device [" << deviceId << ", " << subDeviceId << " ] \n"; + + std::unique_ptr executionCtxt = + std::make_unique(deviceId, subDeviceId); + typedef ze_result_t (*pFnzetIntelDeviceCreateMetricGroupsFromMetricsExp)( + zet_device_handle_t hDevice, uint32_t metricCount, zet_metric_handle_t * phMetrics, + const char metricGroupNamePrefix[ZET_INTEL_MAX_METRIC_GROUP_NAME_PREFIX_EXP], + const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION], + uint32_t *metricGroupCount, zet_metric_group_handle_t *phMetricGroups); + pFnzetIntelDeviceCreateMetricGroupsFromMetricsExp zetIntelDeviceCreateMetricGroupsFromMetricsExp = nullptr; + VALIDATECALL(zeDriverGetExtensionFunctionAddress(executionCtxt->getDriverHandle(0), "zetIntelDeviceCreateMetricGroupsFromMetricsExp", reinterpret_cast(&zetIntelDeviceCreateMetricGroupsFromMetricsExp))); + + uint32_t programmableCount = 0; + VALIDATECALL(zetMetricProgrammableGetExp(executionCtxt->getDeviceHandle(0), &programmableCount, nullptr)); + LOG(zmu::LogLevel::DEBUG) << "Programmable Count" << programmableCount << "\n"; + std::vector metricProgrammables(programmableCount); + VALIDATECALL(zetMetricProgrammableGetExp(executionCtxt->getDeviceHandle(0), &programmableCount, metricProgrammables.data())); + + std::vector parameterValues{}; + + auto &programmable = metricProgrammables[0]; + { + zet_metric_programmable_exp_properties_t props{}; + VALIDATECALL(zetMetricProgrammableGetPropertiesExp(programmable, &props)); + std::vector parameterInfos(props.parameterCount); + uint32_t parameterCount = props.parameterCount; + VALIDATECALL(zetMetricProgrammableGetParamInfoExp(programmable, ¶meterCount, parameterInfos.data())); + EXPECT(parameterCount == props.parameterCount); + + parameterValues.clear(); + parameterValues.resize(props.parameterCount); + + // Print Parameter information in the programmable + for (uint32_t paramIndex = 0; paramIndex < props.parameterCount; paramIndex++) { + LOG(zmu::LogLevel::DEBUG) << "\t\t [" << paramIndex << "] " + << " Param name:" << parameterInfos[paramIndex].name << " | type:" << parameterInfos[paramIndex].type << " | valInfoCount:" << parameterInfos[paramIndex].valueInfoCount + << " | valInfoType:" << parameterInfos[paramIndex].valueInfoType << " | default "; + printValue(parameterInfos[paramIndex].valueInfoType, parameterInfos[paramIndex].defaultValue); + parameterValues[paramIndex].value = parameterInfos[paramIndex].defaultValue; + LOG(zmu::LogLevel::DEBUG) << "\n"; + } + + uint32_t metricHandleCount = 0; + VALIDATECALL(zetMetricCreateFromProgrammableExp(programmable, parameterValues.data(), + props.parameterCount, props.name, props.description, + &metricHandleCount, nullptr)); + std::vector metricHandles(metricHandleCount); + VALIDATECALL(zetMetricCreateFromProgrammableExp(programmable, parameterValues.data(), + props.parameterCount, props.name, props.description, + &metricHandleCount, metricHandles.data())); + LOG(zmu::LogLevel::DEBUG) << "MetricHandle Count: " << metricHandleCount << "\n"; + + zet_metric_group_handle_t metricGroup{}; + uint32_t metricGroupCount = 1; + VALIDATECALL(zetIntelDeviceCreateMetricGroupsFromMetricsExp(executionCtxt->getDeviceHandle(0), 1, &metricHandles[0], "name", "desc", &metricGroupCount, &metricGroup)); + zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; + VALIDATECALL(zetMetricGroupGetProperties(metricGroup, &metricGroupProperties)); + zmu::printMetricGroupProperties(metricGroupProperties); + + VALIDATECALL(zetMetricGroupCloseExp(metricGroup)); + VALIDATECALL(zetMetricGroupGetProperties(metricGroup, &metricGroupProperties)); + LOG(zmu::LogLevel::INFO) << " Metric Count After initial close " << metricGroupProperties.metricCount << "\n"; + + VALIDATECALL(zetMetricGroupCloseExp(metricGroup)); + + VALIDATECALL(zetContextActivateMetricGroups(executionCtxt->getContextHandle(0), + executionCtxt->getDeviceHandle(0), 1, + &metricGroup)); + + VALIDATECALL(zetContextActivateMetricGroups(executionCtxt->getContextHandle(0), + executionCtxt->getDeviceHandle(0), 0, + nullptr)); + VALIDATECALL(zetMetricGroupDestroyExp(metricGroup)); + + for (uint32_t j = 0; j < metricHandleCount; ++j) { + VALIDATECALL(zetMetricDestroyExp(metricHandles[j])); + } + + LOG(zmu::LogLevel::DEBUG) << " --------------------------------------------------------\n"; + } + + return true; + }; + + auto testSettings = zmu::TestSettings::get(); + + if (testSettings->deviceId.get() == -1) { + for (uint32_t deviceId = 0; deviceId < machineConfig.deviceCount; deviceId++) { + // Run for all subdevices + for (uint32_t subDeviceId = 0; subDeviceId < machineConfig.devices[deviceId].subDeviceCount; subDeviceId++) { + status &= testMetricGroupCreateDestroy(deviceId, subDeviceId, testSettings->metricGroupName.get()); + } + // Run for root device + status &= testMetricGroupCreateDestroy(deviceId, -1, testSettings->metricGroupName.get()); + } + } else { + // Run for specific device + status &= testMetricGroupCreateDestroy(testSettings->deviceId.get(), testSettings->subDeviceId.get(), testSettings->metricGroupName.get()); + } + + return status; +} + +///////////////////////////////////////////////// +/// testProgrammableMetricGroupAddRemoveMetric +///////////////////////////////////////////////// +bool testProgrammableMetricGroupAddRemoveMetric() { + bool status = true; + + zmu::TestMachineConfiguration machineConfig = {}; + zmu::getTestMachineConfiguration(machineConfig); + + auto testMetricGroupAddRemoveMetric = [&](uint32_t deviceId, int32_t subDeviceId, std::string &metricGroupName) { + if (!zmu::isDeviceAvailable(deviceId, subDeviceId)) { + return false; + } + + LOG(zmu::LogLevel::INFO) << "Test Programmable Metric Group for adding and removing metrics: Device [" << deviceId << ", " << subDeviceId << " ] \n"; + LOG(zmu::LogLevel::INFO) << "1. Creates default metrics (programmable with default values) \n"; + LOG(zmu::LogLevel::INFO) << "2. Creates multiple metric groups from the metrics \n"; + LOG(zmu::LogLevel::INFO) << "3. Remove half of the metrics from each group and re-add them \n"; + LOG(zmu::LogLevel::INFO) << "4. Verify that metric count is as expected\n"; + + std::unique_ptr executionCtxt = + std::make_unique(deviceId, subDeviceId); + typedef ze_result_t (*pFnzetIntelDeviceCreateMetricGroupsFromMetricsExp)( + zet_device_handle_t hDevice, uint32_t metricCount, zet_metric_handle_t * phMetrics, + const char metricGroupNamePrefix[ZET_INTEL_MAX_METRIC_GROUP_NAME_PREFIX_EXP], + const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION], + uint32_t *metricGroupCount, zet_metric_group_handle_t *phMetricGroups); + pFnzetIntelDeviceCreateMetricGroupsFromMetricsExp zetIntelDeviceCreateMetricGroupsFromMetricsExp = nullptr; + VALIDATECALL(zeDriverGetExtensionFunctionAddress(executionCtxt->getDriverHandle(0), "zetIntelDeviceCreateMetricGroupsFromMetricsExp", reinterpret_cast(&zetIntelDeviceCreateMetricGroupsFromMetricsExp))); + + typedef ze_result_t (*pFnzetIntelDeviceGetConcurrentMetricGroupsExp)( + zet_device_handle_t hDevice, + uint32_t metricGroupCount, + zet_metric_group_handle_t * phMetricGroups, + uint32_t * pConcurrentGroupCount, + uint32_t * pCountPerConcurrentGroup); + pFnzetIntelDeviceGetConcurrentMetricGroupsExp zetIntelDeviceGetConcurrentMetricGroupsExp = nullptr; + VALIDATECALL(zeDriverGetExtensionFunctionAddress(executionCtxt->getDriverHandle(0), "zetIntelDeviceGetConcurrentMetricGroupsExp", reinterpret_cast(&zetIntelDeviceGetConcurrentMetricGroupsExp))); + + uint32_t programmableCount = 0; + VALIDATECALL(zetMetricProgrammableGetExp(executionCtxt->getDeviceHandle(0), &programmableCount, nullptr)); + LOG(zmu::LogLevel::DEBUG) << "Programmable Count" << programmableCount << "\n"; + std::vector metricProgrammables(programmableCount); + VALIDATECALL(zetMetricProgrammableGetExp(executionCtxt->getDeviceHandle(0), &programmableCount, metricProgrammables.data())); + + // Create Metrics from all programmables + std::vector metricHandlesFromProgrammables{}; + for (auto &programmable : metricProgrammables) { + uint32_t metricHandleCount = 0; + zet_metric_programmable_exp_properties_t programmableProperties{}; + VALIDATECALL(zetMetricProgrammableGetPropertiesExp(programmable, &programmableProperties)); + VALIDATECALL(zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, programmableProperties.name, programmableProperties.description, &metricHandleCount, nullptr)); + std::vector metricHandles(metricHandleCount); + VALIDATECALL(zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, programmableProperties.name, programmableProperties.description, &metricHandleCount, metricHandles.data())); + metricHandles.resize(metricHandleCount); + metricHandlesFromProgrammables.insert(metricHandlesFromProgrammables.end(), metricHandles.begin(), metricHandles.end()); + } + + // Create metric groups from metrics + uint32_t metricGroupCount = 0; + VALIDATECALL(zetIntelDeviceCreateMetricGroupsFromMetricsExp(executionCtxt->getDeviceHandle(0), + static_cast(metricHandlesFromProgrammables.size()), + metricHandlesFromProgrammables.data(), + "metricGroupName", + "metricGroupDesc", + &metricGroupCount, nullptr)); + std::vector metricGroupHandles(metricGroupCount); + VALIDATECALL(zetIntelDeviceCreateMetricGroupsFromMetricsExp(executionCtxt->getDeviceHandle(0), + static_cast(metricHandlesFromProgrammables.size()), + metricHandlesFromProgrammables.data(), + "metricGroupName", + "metricGroupDesc", + &metricGroupCount, metricGroupHandles.data())); + metricGroupHandles.resize(metricGroupCount); + + // From each metric group remove half of the metrics and re-add them + bool runStatus = true; + for (auto &metricGroup : metricGroupHandles) { + + // Get metric handles which were created from programmables + + zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; + VALIDATECALL(zetMetricGroupGetProperties(metricGroup, &metricGroupProperties)); + uint32_t actualMetricCount = metricGroupProperties.metricCount; + LOG(zmu::LogLevel::INFO) << "Metric Group: " << metricGroupProperties.name << " | metric count : " << metricGroupProperties.metricCount << "\n"; + std::vector allMetricHandles(actualMetricCount); + VALIDATECALL(zetMetricGet(metricGroup, &actualMetricCount, allMetricHandles.data())); + + // Get the list of removable metrics + std::vector removableMetricsFromMetricGroup{}; + for (auto &metricHandle : allMetricHandles) { + if (std::find(metricHandlesFromProgrammables.begin(), metricHandlesFromProgrammables.end(), metricHandle) != + metricHandlesFromProgrammables.end()) { + removableMetricsFromMetricGroup.push_back(metricHandle); + } + } + + const uint32_t originalMetricCount = static_cast(removableMetricsFromMetricGroup.size()); + LOG(zmu::LogLevel::INFO) << "Removable metric count : " << originalMetricCount << "\n"; + uint32_t halfMetricCount = originalMetricCount / 2u; + + for (uint32_t index = 0; index < halfMetricCount; index++) { + VALIDATECALL(zetMetricGroupRemoveMetricExp(metricGroup, removableMetricsFromMetricGroup[index])); + } + VALIDATECALL(zetMetricGroupCloseExp(metricGroup)); + VALIDATECALL(zetMetricGroupGetProperties(metricGroup, &metricGroupProperties)); + LOG(zmu::LogLevel::INFO) << "Metric count after removal: " << metricGroupProperties.metricCount << "\n"; + + for (uint32_t index = 0; index < halfMetricCount; index++) { + size_t errorStringSize = 0; + VALIDATECALL(zetMetricGroupAddMetricExp(metricGroup, removableMetricsFromMetricGroup[index], &errorStringSize, nullptr)); + } + VALIDATECALL(zetMetricGroupCloseExp(metricGroup)); + VALIDATECALL(zetMetricGroupGetProperties(metricGroup, &metricGroupProperties)); + LOG(zmu::LogLevel::INFO) << "After adding all the metrics back, metric count : " << metricGroupProperties.metricCount << "\n"; + EXPECT(metricGroupProperties.metricCount == actualMetricCount); + runStatus &= metricGroupProperties.metricCount == actualMetricCount; + } + + for (auto &metricGroup : metricGroupHandles) { + VALIDATECALL(zetMetricGroupDestroyExp(metricGroup)); + } + metricGroupHandles.clear(); + + for (auto &metricHandle : metricHandlesFromProgrammables) { + VALIDATECALL(zetMetricDestroyExp(metricHandle)); + } + metricHandlesFromProgrammables.clear(); + + LOG(zmu::LogLevel::DEBUG) << " --------------------------------------------------------\n"; + return runStatus; + }; + + auto testSettings = zmu::TestSettings::get(); + + if (testSettings->deviceId.get() == -1) { + for (uint32_t deviceId = 0; deviceId < machineConfig.deviceCount; deviceId++) { + // Run for all subdevices + for (uint32_t subDeviceId = 0; subDeviceId < machineConfig.devices[deviceId].subDeviceCount; subDeviceId++) { + status &= testMetricGroupAddRemoveMetric(deviceId, subDeviceId, testSettings->metricGroupName.get()); + } + // Run for root device + status &= testMetricGroupAddRemoveMetric(deviceId, -1, testSettings->metricGroupName.get()); + } + } else { + // Run for specific device + status &= testMetricGroupAddRemoveMetric(testSettings->deviceId.get(), testSettings->subDeviceId.get(), testSettings->metricGroupName.get()); + } + + return status; +} + +////////////////////////////////////////// +/// testProgrammableMetricGroupStreamer +////////////////////////////////////////// +bool testProgrammableMetricGroupStreamer() { + // This test creates metric from programmables + bool status = true; + + zmu::TestMachineConfiguration machineConfig = {}; + zmu::getTestMachineConfiguration(machineConfig); + + auto testMetricProgrammableStreamer = [&](uint32_t deviceId, int32_t subDeviceId, std::string &metricGroupName) { + if (!zmu::isDeviceAvailable(deviceId, subDeviceId)) { + return false; + } + + LOG(zmu::LogLevel::INFO) << "Test Programmable Metric Group for streamer: Device [" << deviceId << ", " << subDeviceId << " ] \n"; + LOG(zmu::LogLevel::INFO) << "1. Creates default metrics (programmable with default values) \n"; + LOG(zmu::LogLevel::INFO) << "2. Creates multiple metric groups from the metrics \n"; + LOG(zmu::LogLevel::INFO) << "3. Creates Concurrent metric groups \n"; + LOG(zmu::LogLevel::INFO) << "4. For each concurrent metric groups do streamer mode testing\n"; + + std::unique_ptr executionCtxt = + std::make_unique(deviceId, subDeviceId); + typedef ze_result_t (*pFnzetIntelDeviceCreateMetricGroupsFromMetricsExp)( + zet_device_handle_t hDevice, uint32_t metricCount, zet_metric_handle_t * phMetrics, + const char metricGroupNamePrefix[ZET_INTEL_MAX_METRIC_GROUP_NAME_PREFIX_EXP], + const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION], + uint32_t *metricGroupCount, zet_metric_group_handle_t *phMetricGroups); + pFnzetIntelDeviceCreateMetricGroupsFromMetricsExp zetIntelDeviceCreateMetricGroupsFromMetricsExp = nullptr; + VALIDATECALL(zeDriverGetExtensionFunctionAddress(executionCtxt->getDriverHandle(0), "zetIntelDeviceCreateMetricGroupsFromMetricsExp", reinterpret_cast(&zetIntelDeviceCreateMetricGroupsFromMetricsExp))); + + typedef ze_result_t (*pFnzetIntelDeviceGetConcurrentMetricGroupsExp)( + zet_device_handle_t hDevice, + uint32_t metricGroupCount, + zet_metric_group_handle_t * phMetricGroups, + uint32_t * pConcurrentGroupCount, + uint32_t * pCountPerConcurrentGroup); + pFnzetIntelDeviceGetConcurrentMetricGroupsExp zetIntelDeviceGetConcurrentMetricGroupsExp = nullptr; + VALIDATECALL(zeDriverGetExtensionFunctionAddress(executionCtxt->getDriverHandle(0), "zetIntelDeviceGetConcurrentMetricGroupsExp", reinterpret_cast(&zetIntelDeviceGetConcurrentMetricGroupsExp))); + + uint32_t programmableCount = 0; + VALIDATECALL(zetMetricProgrammableGetExp(executionCtxt->getDeviceHandle(0), &programmableCount, nullptr)); + LOG(zmu::LogLevel::DEBUG) << "Programmable Count" << programmableCount << "\n"; + std::vector metricProgrammables(programmableCount); + VALIDATECALL(zetMetricProgrammableGetExp(executionCtxt->getDeviceHandle(0), &programmableCount, metricProgrammables.data())); + + // Create Metrics from all programmables + std::vector metricHandlesFromProgrammables{}; + for (auto &programmable : metricProgrammables) { + uint32_t metricHandleCount = 0; + zet_metric_programmable_exp_properties_t programmableProperties{}; + VALIDATECALL(zetMetricProgrammableGetPropertiesExp(programmable, &programmableProperties)); + VALIDATECALL(zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, programmableProperties.name, programmableProperties.description, &metricHandleCount, nullptr)); + std::vector metricHandles(metricHandleCount); + VALIDATECALL(zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, programmableProperties.name, programmableProperties.description, &metricHandleCount, metricHandles.data())); + metricHandles.resize(metricHandleCount); + metricHandlesFromProgrammables.insert(metricHandlesFromProgrammables.end(), metricHandles.begin(), metricHandles.end()); + } + + // Create metric groups from metrics + uint32_t metricGroupCount = 0; + VALIDATECALL(zetIntelDeviceCreateMetricGroupsFromMetricsExp(executionCtxt->getDeviceHandle(0), + static_cast(metricHandlesFromProgrammables.size()), + metricHandlesFromProgrammables.data(), + "metricGroupName", + "metricGroupDesc", + &metricGroupCount, nullptr)); + std::vector metricGroupHandles(metricGroupCount); + VALIDATECALL(zetIntelDeviceCreateMetricGroupsFromMetricsExp(executionCtxt->getDeviceHandle(0), + static_cast(metricHandlesFromProgrammables.size()), + metricHandlesFromProgrammables.data(), + "metricGroupName", + "metricGroupDesc", + &metricGroupCount, metricGroupHandles.data())); + metricGroupHandles.resize(metricGroupCount); + // filter out non-streamer metric groups + metricGroupHandles.erase(std::remove_if(metricGroupHandles.begin(), metricGroupHandles.end(), + [&](zet_metric_group_handle_t metricGroup) { + zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; + VALIDATECALL(zetMetricGroupGetProperties(metricGroup, &metricGroupProperties)); + auto toBeRemoved = metricGroupProperties.samplingType != ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED; + if (toBeRemoved) { + VALIDATECALL(zetMetricGroupDestroyExp(metricGroup)); + } + return toBeRemoved; + }), + metricGroupHandles.end()); + + // print the finalized list of metric groups + for (auto &metricGroup : metricGroupHandles) { + zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; + VALIDATECALL(zetMetricGroupGetProperties(metricGroup, &metricGroupProperties)); + zmu::printMetricGroupProperties(metricGroupProperties); + } + + // Create concurrent metric groups + uint32_t concurrentGroupCount = 0; + VALIDATECALL(zetIntelDeviceGetConcurrentMetricGroupsExp(executionCtxt->getDeviceHandle(0), + static_cast(metricGroupHandles.size()), + metricGroupHandles.data(), + &concurrentGroupCount, nullptr)); + std::vector countPerConcurrentGroupList(concurrentGroupCount); + VALIDATECALL(zetIntelDeviceGetConcurrentMetricGroupsExp(executionCtxt->getDeviceHandle(0), + static_cast(metricGroupHandles.size()), + metricGroupHandles.data(), + &concurrentGroupCount, countPerConcurrentGroupList.data())); + countPerConcurrentGroupList.resize(concurrentGroupCount); + // Activate and collect + // Streamer allows single metric group collection. + bool runStatus = true; + + for (auto &metricGroup : metricGroupHandles) { + executionCtxt->reset(); + executionCtxt->setExecutionTimeInMilliseconds(5); + std::unique_ptr workload1 = + std::make_unique(executionCtxt.get()); + std::unique_ptr collector = + std::make_unique(executionCtxt.get(), metricGroup); + std::unique_ptr testRunner = std::make_unique(static_cast(executionCtxt.get())); + testRunner->addCollector(collector.get()); + testRunner->addWorkload(workload1.get()); + + runStatus &= testRunner->run(); + + if (!runStatus) { + break; + } + } + + for (auto &metricGroup : metricGroupHandles) { + VALIDATECALL(zetMetricGroupDestroyExp(metricGroup)); + } + metricGroupHandles.clear(); + + for (auto &metricHandle : metricHandlesFromProgrammables) { + VALIDATECALL(zetMetricDestroyExp(metricHandle)); + } + metricHandlesFromProgrammables.clear(); + + LOG(zmu::LogLevel::DEBUG) << " --------------------------------------------------------\n"; + return runStatus; + }; + + auto testSettings = zmu::TestSettings::get(); + + if (testSettings->deviceId.get() == -1) { + for (uint32_t deviceId = 0; deviceId < machineConfig.deviceCount; deviceId++) { + // Run for all subdevices + for (uint32_t subDeviceId = 0; subDeviceId < machineConfig.devices[deviceId].subDeviceCount; subDeviceId++) { + status &= testMetricProgrammableStreamer(deviceId, subDeviceId, testSettings->metricGroupName.get()); + } + // Run for root device + status &= testMetricProgrammableStreamer(deviceId, -1, testSettings->metricGroupName.get()); + } + } else { + // Run for specific device + status &= testMetricProgrammableStreamer(testSettings->deviceId.get(), testSettings->subDeviceId.get(), testSettings->metricGroupName.get()); + } + + return status; +} + +////////////////////////////////////////// +/// testProgrammableMetricGroupQuery +////////////////////////////////////////// +bool testProgrammableMetricGroupQuery() { + // This test creates metric from programmables + bool status = true; + + zmu::TestMachineConfiguration machineConfig = {}; + zmu::getTestMachineConfiguration(machineConfig); + + auto testMetricProgrammableQuery = [&](uint32_t deviceId, int32_t subDeviceId, std::string &metricGroupName) { + if (!zmu::isDeviceAvailable(deviceId, subDeviceId)) { + return false; + } + + LOG(zmu::LogLevel::INFO) << "Test Programmable Metric Group For Query Mode: Device [" << deviceId << ", " << subDeviceId << " ] \n"; + LOG(zmu::LogLevel::INFO) << "1. Creates default metrics (programmable with default values) \n"; + LOG(zmu::LogLevel::INFO) << "2. Creates multiple metric groups from the metrics \n"; + LOG(zmu::LogLevel::INFO) << "3. Creates Concurrent metric groups \n"; + LOG(zmu::LogLevel::INFO) << "4. For each concurrent metric groups do Query mode testing\n"; + + std::unique_ptr executionCtxt = + std::make_unique(deviceId, subDeviceId); + typedef ze_result_t (*pFnzetIntelDeviceCreateMetricGroupsFromMetricsExp)( + zet_device_handle_t hDevice, uint32_t metricCount, zet_metric_handle_t * phMetrics, + const char metricGroupNamePrefix[ZET_INTEL_MAX_METRIC_GROUP_NAME_PREFIX_EXP], + const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION], + uint32_t *metricGroupCount, zet_metric_group_handle_t *phMetricGroups); + pFnzetIntelDeviceCreateMetricGroupsFromMetricsExp zetIntelDeviceCreateMetricGroupsFromMetricsExp = nullptr; + VALIDATECALL(zeDriverGetExtensionFunctionAddress(executionCtxt->getDriverHandle(0), "zetIntelDeviceCreateMetricGroupsFromMetricsExp", reinterpret_cast(&zetIntelDeviceCreateMetricGroupsFromMetricsExp))); + + typedef ze_result_t (*pFnzetIntelDeviceGetConcurrentMetricGroupsExp)( + zet_device_handle_t hDevice, + uint32_t metricGroupCount, + zet_metric_group_handle_t * phMetricGroups, + uint32_t * pConcurrentGroupCount, + uint32_t * pCountPerConcurrentGroup); + pFnzetIntelDeviceGetConcurrentMetricGroupsExp zetIntelDeviceGetConcurrentMetricGroupsExp = nullptr; + VALIDATECALL(zeDriverGetExtensionFunctionAddress(executionCtxt->getDriverHandle(0), "zetIntelDeviceGetConcurrentMetricGroupsExp", reinterpret_cast(&zetIntelDeviceGetConcurrentMetricGroupsExp))); + + uint32_t programmableCount = 0; + VALIDATECALL(zetMetricProgrammableGetExp(executionCtxt->getDeviceHandle(0), &programmableCount, nullptr)); + LOG(zmu::LogLevel::DEBUG) << "Programmable Count" << programmableCount << "\n"; + std::vector metricProgrammables(programmableCount); + VALIDATECALL(zetMetricProgrammableGetExp(executionCtxt->getDeviceHandle(0), &programmableCount, metricProgrammables.data())); + + // Create Metrics from all programmables + std::vector metricHandlesFromProgrammables{}; + for (auto &programmable : metricProgrammables) { + uint32_t metricHandleCount = 0; + zet_metric_programmable_exp_properties_t programmableProperties{}; + VALIDATECALL(zetMetricProgrammableGetPropertiesExp(programmable, &programmableProperties)); + VALIDATECALL(zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, programmableProperties.name, programmableProperties.description, &metricHandleCount, nullptr)); + std::vector metricHandles(metricHandleCount); + VALIDATECALL(zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, programmableProperties.name, programmableProperties.description, &metricHandleCount, metricHandles.data())); + metricHandles.resize(metricHandleCount); + metricHandlesFromProgrammables.insert(metricHandlesFromProgrammables.end(), metricHandles.begin(), metricHandles.end()); + } + + // Create metric groups from metrics + uint32_t metricGroupCount = 0; + VALIDATECALL(zetIntelDeviceCreateMetricGroupsFromMetricsExp(executionCtxt->getDeviceHandle(0), + static_cast(metricHandlesFromProgrammables.size()), + metricHandlesFromProgrammables.data(), + "metricGroupName", + "metricGroupDesc", + &metricGroupCount, nullptr)); + std::vector metricGroupHandles(metricGroupCount); + VALIDATECALL(zetIntelDeviceCreateMetricGroupsFromMetricsExp(executionCtxt->getDeviceHandle(0), + static_cast(metricHandlesFromProgrammables.size()), + metricHandlesFromProgrammables.data(), + "metricGroupName", + "metricGroupDesc", + &metricGroupCount, metricGroupHandles.data())); + metricGroupHandles.resize(metricGroupCount); + // filter out non-query metric groups + metricGroupHandles.erase(std::remove_if(metricGroupHandles.begin(), metricGroupHandles.end(), + [](zet_metric_group_handle_t metricGroup) { + zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; + VALIDATECALL(zetMetricGroupGetProperties(metricGroup, &metricGroupProperties)); + auto toBeRemoved = metricGroupProperties.samplingType != ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED; + if (toBeRemoved) { + VALIDATECALL(zetMetricGroupDestroyExp(metricGroup)); + } + return toBeRemoved; + }), + metricGroupHandles.end()); + + // print the finalized list of metric groups + for (auto &metricGroup : metricGroupHandles) { + zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; + VALIDATECALL(zetMetricGroupGetProperties(metricGroup, &metricGroupProperties)); + zmu::printMetricGroupProperties(metricGroupProperties); + } + + // Create concurrent metric groups + uint32_t concurrentGroupCount = 0; + VALIDATECALL(zetIntelDeviceGetConcurrentMetricGroupsExp(executionCtxt->getDeviceHandle(0), + static_cast(metricGroupHandles.size()), + metricGroupHandles.data(), + &concurrentGroupCount, nullptr)); + std::vector countPerConcurrentGroupList(concurrentGroupCount); + VALIDATECALL(zetIntelDeviceGetConcurrentMetricGroupsExp(executionCtxt->getDeviceHandle(0), + static_cast(metricGroupHandles.size()), + metricGroupHandles.data(), + &concurrentGroupCount, countPerConcurrentGroupList.data())); + countPerConcurrentGroupList.resize(concurrentGroupCount); + // Activate and collect + // Streamer allows single metric group collection. + bool runStatus = true; + + for (auto &metricGroup : metricGroupHandles) { + executionCtxt->reset(); + executionCtxt->setExecutionTimeInMilliseconds(5); + std::unique_ptr workload1 = + std::make_unique(executionCtxt.get()); + std::unique_ptr collector = + std::make_unique(executionCtxt.get(), metricGroup); + std::unique_ptr testRunner = std::make_unique(static_cast(executionCtxt.get())); + testRunner->addCollector(collector.get()); + testRunner->addWorkload(workload1.get()); + + runStatus &= testRunner->run(); + + if (!runStatus) { + break; + } + } + + for (auto &metricGroup : metricGroupHandles) { + VALIDATECALL(zetMetricGroupDestroyExp(metricGroup)); + } + metricGroupHandles.clear(); + + for (auto &metricHandle : metricHandlesFromProgrammables) { + VALIDATECALL(zetMetricDestroyExp(metricHandle)); + } + metricHandlesFromProgrammables.clear(); + + LOG(zmu::LogLevel::DEBUG) << " --------------------------------------------------------\n"; + return runStatus; + }; + + auto testSettings = zmu::TestSettings::get(); + + if (testSettings->deviceId.get() == -1) { + for (uint32_t deviceId = 0; deviceId < machineConfig.deviceCount; deviceId++) { + // Run for all subdevices + for (uint32_t subDeviceId = 0; subDeviceId < machineConfig.devices[deviceId].subDeviceCount; subDeviceId++) { + status &= testMetricProgrammableQuery(deviceId, subDeviceId, testSettings->metricGroupName.get()); + } + // Run for root device + status &= testMetricProgrammableQuery(deviceId, -1, testSettings->metricGroupName.get()); + } + } else { + // Run for specific device + status &= testMetricProgrammableQuery(testSettings->deviceId.get(), testSettings->subDeviceId.get(), testSettings->metricGroupName.get()); + } + + return status; +} + +ZELLO_METRICS_ADD_TEST(displayAllProgrammables) +ZELLO_METRICS_ADD_TEST(createMetricFromProgrammables) +ZELLO_METRICS_ADD_TEST(testProgrammableMetricGroupCreateDestroy) +ZELLO_METRICS_ADD_TEST(testProgrammableMetricGroupStreamer) +ZELLO_METRICS_ADD_TEST(testProgrammableMetricGroupQuery) +ZELLO_METRICS_ADD_TEST(testProgrammableMetricGroupAddRemoveMetric) \ No newline at end of file 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 d35bda7b49..069f83f2b1 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/CMakeLists.txt +++ b/level_zero/tools/test/unit_tests/sources/metrics/CMakeLists.txt @@ -10,6 +10,7 @@ target_sources(${TARGET_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/${BRANCH_DIR_SUFFIX}/metric_ip_sampling_fixture.h ${CMAKE_CURRENT_SOURCE_DIR}/metric_query_pool_fixture.cpp ${CMAKE_CURRENT_SOURCE_DIR}/metric_query_pool_fixture.h + ${CMAKE_CURRENT_SOURCE_DIR}/mock_metric_ip_sampling_source.h ${CMAKE_CURRENT_SOURCE_DIR}/mock_metric_oa.h ${CMAKE_CURRENT_SOURCE_DIR}/mock_metric_source.h ${CMAKE_CURRENT_SOURCE_DIR}/mock_metric_oa.cpp @@ -26,13 +27,16 @@ target_sources(${TARGET_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/test_metric_oa_streamer_2.cpp ${CMAKE_CURRENT_SOURCE_DIR}/test_metric_oa_streamer_3.cpp ${CMAKE_CURRENT_SOURCE_DIR}/test_metric_oa_initialization.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/mock_metric_oa_programmable.h + ${CMAKE_CURRENT_SOURCE_DIR}/mock_metric_oa_programmable.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/test_metric_group.cpp ${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 + ${CMAKE_CURRENT_SOURCE_DIR}/test_metric_programmable.cpp ${CMAKE_CURRENT_SOURCE_DIR}/test_metric_concurrent_groups.cpp ${CMAKE_CURRENT_SOURCE_DIR}/test_metric.cpp - + ${CMAKE_CURRENT_SOURCE_DIR}/test_multidevice_metric_programmable.cpp ) add_subdirectories() diff --git a/level_zero/tools/test/unit_tests/sources/metrics/linux/CMakeLists.txt b/level_zero/tools/test/unit_tests/sources/metrics/linux/CMakeLists.txt index 5ede221b07..6ccf80e175 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/linux/CMakeLists.txt +++ b/level_zero/tools/test/unit_tests/sources/metrics/linux/CMakeLists.txt @@ -6,8 +6,8 @@ set(L0_TOOLS_METRICS_LINUX_TESTS_LINUX ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt - ${CMAKE_CURRENT_SOURCE_DIR}/test_metric_oa_query_pool_linux.cpp ${CMAKE_CURRENT_SOURCE_DIR}/${BRANCH_DIR_SUFFIX}/test_metric_ip_sampling_linux.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/test_metric_oa_query_pool_linux.cpp ) if(TESTS_PVC) diff --git a/level_zero/tools/test/unit_tests/sources/metrics/linux/test_metric_oa_query_pool_linux.cpp b/level_zero/tools/test/unit_tests/sources/metrics/linux/test_metric_oa_query_pool_linux.cpp index f5737a4064..ed15750605 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/linux/test_metric_oa_query_pool_linux.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/linux/test_metric_oa_query_pool_linux.cpp @@ -188,8 +188,8 @@ TEST_F(MetricQueryPoolLinuxTest, givenMetricLibraryIsInIncorrectInitializedState TEST_F(MetricQueryPoolLinuxTest, givenCorrectArgumentsWhenCacheConfigurationIsCalledThenCacheingIsSuccessfull) { metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -205,8 +205,8 @@ TEST_F(MetricQueryPoolLinuxTest, givenCorrectArgumentsWhenCacheConfigurationIsCa MetricsDiscovery::TInformationParams_1_0 oaInformation = {}; oaInformation.SymbolName = "BufferOverflow"; oaInformation.IoReadEquation = &ioReadEquation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; openMetricsAdapter(); diff --git a/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_ip_sampling_source.h b/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_ip_sampling_source.h new file mode 100644 index 0000000000..b1011a4436 --- /dev/null +++ b/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_ip_sampling_source.h @@ -0,0 +1,68 @@ +/* + * Copyright (C) 2024 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#pragma once +#include "level_zero/tools/source/metrics/metric_ip_sampling_source.h" + +namespace L0 { +namespace ult { + +class MockMetricIpSamplingSource : public IpSamplingMetricSourceImp { + public: + ze_result_t createMetricGroupsFromMetricsReturn = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + ze_result_t metricProgrammableGetReturn = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + MockMetricIpSamplingSource(const MetricDeviceContext &metricDeviceContext) : IpSamplingMetricSourceImp(metricDeviceContext) {} + ~MockMetricIpSamplingSource() override = default; + + ze_result_t metricProgrammableGet(uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables) override { + return metricProgrammableGetReturn; + } + + bool isAvailable() override { return true; } + void enable() override {} + ze_result_t metricGroupGet(uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups) override { + *pCount = 0; + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + } + ze_result_t activateMetricGroupsAlreadyDeferred() override { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + } + ze_result_t activateMetricGroupsPreferDeferred(const uint32_t count, zet_metric_group_handle_t *phMetricGroups) override { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + } + bool isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) const { + return false; + } + ze_result_t getConcurrentMetricGroups(std::vector &hMetricGroups, + uint32_t *pConcurrentGroupCount, + uint32_t *pCountPerConcurrentGroup) override { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + } + ze_result_t createMetricGroupsFromMetrics(std::vector &metricList, + const char metricGroupNamePrefix[ZET_INTEL_MAX_METRIC_GROUP_NAME_PREFIX_EXP], + const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION], + uint32_t *maxMetricGroupCount, + std::vector &metricGroupList) override { + return createMetricGroupsFromMetricsReturn; + } + + ze_result_t handleMetricGroupExtendedProperties(zet_metric_group_handle_t hMetricGroup, void *pNext) override { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + } +}; + +class MockMetricDeviceContext : public MetricDeviceContext { + public: + MockMetricDeviceContext(Device &device) : MetricDeviceContext(device) {} + + void setMetricTraceSource(MockMetricIpSamplingSource *metricSource) { + metricSources[MetricSource::metricSourceTypeIpSampling] = std::unique_ptr(metricSource); + } +}; + +} // namespace ult +} // namespace L0 \ No newline at end of file diff --git a/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.cpp b/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.cpp index 0390a7ec22..4b786a4e05 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020-2023 Intel Corporation + * Copyright (C) 2020-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -83,7 +83,7 @@ void MetricContextFixture::openMetricsAdapterGroup() { adapter.openMetricsDeviceOutDevice = &metricsDevice; } -void MetricContextFixture::setupDefaultMocksForMetricDevice(Mock &metricDevice) { +void MetricContextFixture::setupDefaultMocksForMetricDevice(Mock &metricDevice) { metricDevice.GetParamsResult = &metricsDeviceParams; } @@ -198,7 +198,7 @@ void MetricMultiDeviceFixture::openMetricsAdapterGroup() { adapter.openMetricsDeviceOutDevice = &metricsDevice; } -void MetricMultiDeviceFixture::setupDefaultMocksForMetricDevice(Mock &metricDevice) { +void MetricMultiDeviceFixture::setupDefaultMocksForMetricDevice(Mock &metricDevice) { metricDevice.GetParamsResult = &metricsDeviceParams; } diff --git a/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.h b/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.h index d751b426c3..d36636345c 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.h +++ b/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.h @@ -277,12 +277,12 @@ class MetricContextFixture : public DeviceFixture { MockMetricsDiscoveryApi mockMetricsDiscoveryApi = {}; // Metrics discovery device - Mock adapterGroup; - Mock adapter; - Mock metricsDevice; + Mock adapterGroup; + Mock adapter; + Mock metricsDevice; MetricsDiscovery::TMetricsDeviceParams_1_2 metricsDeviceParams = {}; MetricsDiscovery::TTypedValue_1_0 defaultMaximumOaBufferSize = {}; - void setupDefaultMocksForMetricDevice(Mock &metricDevice); + void setupDefaultMocksForMetricDevice(Mock &metricDevice); MockOAOsInterface *mockOAOsInterface; MockIpSamplingOsInterface *mockIpSamplingOsInterface; }; @@ -312,12 +312,12 @@ class MetricMultiDeviceFixture : public MultiDeviceFixture { MockMetricsDiscoveryApi mockMetricsDiscoveryApi = {}; // Metrics discovery device - Mock adapterGroup; - Mock adapter; - Mock metricsDevice; + Mock adapterGroup; + Mock adapter; + Mock metricsDevice; MetricsDiscovery::TMetricsDeviceParams_1_2 metricsDeviceParams = {}; // MetricsDiscovery::TTypedValue_1_0 defaultMaximumOaBufferSize = {}; - void setupDefaultMocksForMetricDevice(Mock &metricDevice); + void setupDefaultMocksForMetricDevice(Mock &metricDevice); }; class MetricStreamerMultiDeviceFixture : public MetricMultiDeviceFixture { diff --git a/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_enumeration.cpp b/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_enumeration.cpp index 837e693733..2289aaba38 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_enumeration.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_enumeration.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020-2023 Intel Corporation + * Copyright (C) 2020-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -359,4 +359,235 @@ TCompletionCode IAdapter_1_9::OpenMetricsSubDeviceFromFile(const uint32_t subDev return CC_ERROR_NOT_SUPPORTED; } +IAdapter_1_10 *IAdapterGroup_1_10::GetAdapter(uint32_t index) { + UNRECOVERABLE_IF(true); + return nullptr; +} + +IAdapter_1_11 *IAdapterGroup_1_11::GetAdapter(uint32_t index) { + UNRECOVERABLE_IF(true); + return nullptr; +} + +IAdapter_1_13 *IAdapterGroup_1_13::GetAdapter(uint32_t index) { + UNRECOVERABLE_IF(true); + return nullptr; +} + +TConcurrentGroupParams_1_13 *IConcurrentGroup_1_13::GetParams(void) { + UNRECOVERABLE_IF(true); + return nullptr; +} + +IMetricSet_1_13 *IConcurrentGroup_1_13::GetMetricSet(uint32_t index) { + UNRECOVERABLE_IF(true); + return nullptr; +} + +IMetricEnumerator_1_13 *IConcurrentGroup_1_13::GetMetricEnumerator(void) { + UNRECOVERABLE_IF(true); + return nullptr; +} +IMetricEnumerator_1_13 *IConcurrentGroup_1_13::GetMetricEnumeratorFromFile(const char *fileName) { + UNRECOVERABLE_IF(true); + return nullptr; +} +IMetricSet_1_13 *IConcurrentGroup_1_13::AddMetricSet(const char *symbolName, const char *shortName) { + UNRECOVERABLE_IF(true); + return nullptr; +} +TCompletionCode IConcurrentGroup_1_13::RemoveMetricSet(IMetricSet_1_13 *metricSet) { + UNRECOVERABLE_IF(true); + return CC_ERROR_NOT_SUPPORTED; +} + +IMetricSet_1_11 *IConcurrentGroup_1_11::GetMetricSet(uint32_t index) { + UNRECOVERABLE_IF(true); + return nullptr; +} + +IMetricEnumerator_1_13::~IMetricEnumerator_1_13() {} +uint32_t IMetricEnumerator_1_13::GetMetricPrototypeCount(void) { + UNRECOVERABLE_IF(true); + return 0; +} + +IMetricPrototype_1_13 *IMetricEnumerator_1_13::GetMetricPrototype(const uint32_t index) { + UNRECOVERABLE_IF(true); + return nullptr; +} + +TCompletionCode IMetricEnumerator_1_13::GetMetricPrototypes(const uint32_t index, uint32_t *count, IMetricPrototype_1_13 **metrics) { + UNRECOVERABLE_IF(true); + return CC_ERROR_NOT_SUPPORTED; +} + +TCompletionCode IMetricEnumerator_1_13::RemoveClonedMetricPrototype(IMetricPrototype_1_13 *clonedPrototype) { + UNRECOVERABLE_IF(true); + return CC_ERROR_NOT_SUPPORTED; +} + +IMetricPrototype_1_13::~IMetricPrototype_1_13() {} + +const TMetricPrototypeParams_1_13 *IMetricPrototype_1_13::GetParams(void) const { + UNRECOVERABLE_IF(true); + return nullptr; +} +IMetricPrototype_1_13 *IMetricPrototype_1_13::Clone(void) { + UNRECOVERABLE_IF(true); + return nullptr; +} +const TMetricPrototypeOptionDescriptor_1_13 *IMetricPrototype_1_13::GetOptionDescriptor(uint32_t index) const { + UNRECOVERABLE_IF(true); + return nullptr; +} + +TCompletionCode IMetricPrototype_1_13::SetOption(const TOptionDescriptorType optionType, const TTypedValue_1_0 *typedValue) { + UNRECOVERABLE_IF(true); + return CC_ERROR_NOT_SUPPORTED; +} +TCompletionCode IMetricPrototype_1_13::ChangeNames(const char *symbolName, const char *shortName, const char *longName, const char *resultUnits) { + UNRECOVERABLE_IF(true); + return CC_ERROR_NOT_SUPPORTED; +} + +IConcurrentGroup_1_11 *IMetricsDevice_1_11::GetConcurrentGroup(uint32_t index) { + UNRECOVERABLE_IF(true); + return nullptr; +} + +TCompletionCode IMetricsDevice_1_10::GetGpuCpuTimestamps(uint64_t *gpuTimestampNs, uint64_t *cpuTimestampNs, uint32_t *cpuId, uint64_t *correlationIndicatorNs) { + UNRECOVERABLE_IF(true); + return CC_ERROR_NOT_SUPPORTED; +} + +IConcurrentGroup_1_13 *IMetricsDevice_1_13::GetConcurrentGroup(uint32_t index) { + UNRECOVERABLE_IF(true); + return nullptr; +} + +TCompletionCode IAdapter_1_10::OpenMetricsDevice(IMetricsDevice_1_10 **metricsDevice) { + UNRECOVERABLE_IF(true); + return CC_ERROR_NOT_SUPPORTED; +} +TCompletionCode IAdapter_1_10::OpenMetricsDeviceFromFile(const char *fileName, void *openParams, IMetricsDevice_1_10 **metricsDevice) { + UNRECOVERABLE_IF(true); + return CC_ERROR_NOT_SUPPORTED; +} +TCompletionCode IAdapter_1_10::OpenMetricsSubDevice(const uint32_t subDeviceIndex, IMetricsDevice_1_10 **metricsDevice) { + UNRECOVERABLE_IF(true); + return CC_ERROR_NOT_SUPPORTED; +} +TCompletionCode IAdapter_1_10::OpenMetricsSubDeviceFromFile(const uint32_t subDeviceIndex, const char *fileName, void *openParams, IMetricsDevice_1_10 **metricsDevice) { + UNRECOVERABLE_IF(true); + return CC_ERROR_NOT_SUPPORTED; +} + +TCompletionCode IAdapter_1_11::OpenMetricsDevice(IMetricsDevice_1_11 **metricsDevice) { + UNRECOVERABLE_IF(true); + return CC_ERROR_NOT_SUPPORTED; +} +TCompletionCode IAdapter_1_11::OpenMetricsDeviceFromFile(const char *fileName, void *openParams, IMetricsDevice_1_11 **metricsDevice) { + UNRECOVERABLE_IF(true); + return CC_ERROR_NOT_SUPPORTED; +} +TCompletionCode IAdapter_1_11::OpenMetricsSubDevice(const uint32_t subDeviceIndex, IMetricsDevice_1_11 **metricsDevice) { + UNRECOVERABLE_IF(true); + return CC_ERROR_NOT_SUPPORTED; +} +TCompletionCode IAdapter_1_11::OpenMetricsSubDeviceFromFile(const uint32_t subDeviceIndex, const char *fileName, void *openParams, IMetricsDevice_1_11 **metricsDevice) { + UNRECOVERABLE_IF(true); + return CC_ERROR_NOT_SUPPORTED; +} +TCompletionCode IAdapter_1_11::SaveMetricsDeviceToFile(const char *fileName, void *saveParams, IMetricsDevice_1_11 *metricsDevice, const uint32_t minMajorApiVersion, const uint32_t minMinorApiVersion) { + UNRECOVERABLE_IF(true); + return CC_ERROR_NOT_SUPPORTED; +} + +TCompletionCode IAdapter_1_13::OpenMetricsDevice(IMetricsDevice_1_13 **metricsDevice) { + UNRECOVERABLE_IF(true); + return CC_ERROR_NOT_SUPPORTED; +} + +TCompletionCode IAdapter_1_13::OpenMetricsDeviceFromFile(const char *fileName, void *openParams, IMetricsDevice_1_13 **metricsDevice) { + UNRECOVERABLE_IF(true); + return CC_ERROR_NOT_SUPPORTED; +} +TCompletionCode IAdapter_1_13::OpenMetricsSubDevice(const uint32_t subDeviceIndex, IMetricsDevice_1_13 **metricsDevice) { + UNRECOVERABLE_IF(true); + return CC_ERROR_NOT_SUPPORTED; +} +TCompletionCode IAdapter_1_13::OpenMetricsSubDeviceFromFile(const uint32_t subDeviceIndex, const char *fileName, void *openParams, IMetricsDevice_1_13 **metricsDevice) { + UNRECOVERABLE_IF(true); + return CC_ERROR_NOT_SUPPORTED; +} + +const TEngineParams_1_13 *IAdapter_1_13::GetEngineParams(const uint32_t subDeviceIndex, const uint32_t engineIndex) { + UNRECOVERABLE_IF(true); + return nullptr; +} + +IMetricSet_1_11::~IMetricSet_1_11() { +} +TMetricSetParams_1_11 *IMetricSet_1_11::GetParams(void) { + UNRECOVERABLE_IF(true); + return nullptr; +} + +IMetricSet_1_13::~IMetricSet_1_13() { +} +TCompletionCode IMetricSet_1_13::Open() { + UNRECOVERABLE_IF(true); + return CC_ERROR_NOT_SUPPORTED; +} +TCompletionCode IMetricSet_1_13::AddMetric(IMetricPrototype_1_13 *metricPrototype) { + UNRECOVERABLE_IF(true); + return CC_ERROR_NOT_SUPPORTED; +} +TCompletionCode IMetricSet_1_13::RemoveMetric(IMetricPrototype_1_13 *metricPrototype) { + UNRECOVERABLE_IF(true); + return CC_ERROR_NOT_SUPPORTED; +} +TCompletionCode IMetricSet_1_13::Finalize() { + UNRECOVERABLE_IF(true); + return CC_ERROR_NOT_SUPPORTED; +} + +IMetric_1_13 *IMetricSet_1_13::AddCustomMetric( + const char *symbolName, + const char *shortName, + const char *groupName, + const char *longName, + const char *dxToOglAlias, + uint32_t usageFlagsMask, + uint32_t apiMask, + TMetricResultType resultType, + const char *resultUnits, + TMetricType metricType, + int64_t loWatermark, + int64_t hiWatermark, + THwUnitType hwType, + const char *ioReadEquation, + const char *deltaFunction, + const char *queryReadEquation, + const char *normalizationEquation, + const char *maxValueEquation, + const char *signalName, + uint32_t queryModeMask) { + UNRECOVERABLE_IF(true); + return nullptr; +} + +IMetric_1_13 *IMetricSet_1_13::GetMetric(uint32_t index) { + UNRECOVERABLE_IF(true); + return nullptr; +} + +IMetric_1_13::~IMetric_1_13() {} + +TMetricParams_1_13 *IMetric_1_13::GetParams() { + UNRECOVERABLE_IF(true); + return nullptr; +} + } // namespace MetricsDiscovery diff --git a/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_enumeration.h b/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_enumeration.h index 241c78bace..0b6c1b2af1 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_enumeration.h +++ b/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_enumeration.h @@ -23,20 +23,27 @@ struct WhiteBox<::L0::MetricGroup> : public ::L0::MetricGroup { using MetricGroup = WhiteBox<::L0::MetricGroup>; +using MetricsDiscovery::IAdapter_1_13; using MetricsDiscovery::IAdapter_1_6; using MetricsDiscovery::IAdapter_1_8; using MetricsDiscovery::IAdapter_1_9; +using MetricsDiscovery::IAdapterGroup_1_13; using MetricsDiscovery::IAdapterGroup_1_6; using MetricsDiscovery::IAdapterGroup_1_8; using MetricsDiscovery::IAdapterGroup_1_9; using MetricsDiscovery::IAdapterGroupLatest; +using MetricsDiscovery::IConcurrentGroup_1_13; using MetricsDiscovery::IConcurrentGroup_1_5; using MetricsDiscovery::IEquation_1_0; using MetricsDiscovery::IInformation_1_0; using MetricsDiscovery::IMetric_1_0; +using MetricsDiscovery::IMetric_1_13; +using MetricsDiscovery::IMetricsDevice_1_11; +using MetricsDiscovery::IMetricsDevice_1_13; using MetricsDiscovery::IMetricsDevice_1_5; using MetricsDiscovery::IMetricsDeviceLatest; using MetricsDiscovery::IMetricSet_1_0; +using MetricsDiscovery::IMetricSet_1_13; using MetricsDiscovery::IMetricSet_1_5; using MetricsDiscovery::IOverride_1_2; using MetricsDiscovery::TAdapterGroupParams_1_6; @@ -45,11 +52,15 @@ using MetricsDiscovery::TAdapterParams_1_8; using MetricsDiscovery::TAdapterParams_1_9; using MetricsDiscovery::TCompletionCode; using MetricsDiscovery::TConcurrentGroupParams_1_0; +using MetricsDiscovery::TConcurrentGroupParams_1_13; +using MetricsDiscovery::TEngineParams_1_13; using MetricsDiscovery::TEngineParams_1_9; using MetricsDiscovery::TEquationElement_1_0; using MetricsDiscovery::TGlobalSymbol_1_0; using MetricsDiscovery::TMetricParams_1_0; +using MetricsDiscovery::TMetricParams_1_13; using MetricsDiscovery::TMetricsDeviceParams_1_2; +using MetricsDiscovery::TMetricSetParams_1_11; using MetricsDiscovery::TMetricSetParams_1_4; using MetricsDiscovery::TSamplingType; using MetricsDiscovery::TSubDeviceParams_1_9; @@ -64,48 +75,48 @@ struct MockMetricsDiscoveryApi { }; template <> -class Mock : public IAdapterGroup_1_9 { +class Mock : public IAdapterGroup_1_13 { public: ~Mock() override = default; - ADDMETHOD_NOBASE(GetAdapter, IAdapter_1_9 *, nullptr, (uint32_t)); + ADDMETHOD_NOBASE(GetAdapter, IAdapter_1_13 *, nullptr, (uint32_t)); ADDMETHOD_CONST_NOBASE(GetParams, const TAdapterGroupParams_1_6 *, nullptr, ()); ADDMETHOD_NOBASE(Close, TCompletionCode, TCompletionCode::CC_OK, ()); }; template <> -class Mock : public IAdapter_1_9 { +class Mock : public IAdapter_1_13 { public: ~Mock() override = default; - // 1.9 + // 1.13 ADDMETHOD_NOBASE(GetSubDeviceParams, const TSubDeviceParams_1_9 *, nullptr, (const uint32_t subDeviceIndex)); - ADDMETHOD_NOBASE(GetEngineParams, const TEngineParams_1_9 *, nullptr, (const uint32_t subDeviceIndex, const uint32_t engineIndex)); - ADDMETHOD_NOBASE(OpenMetricsSubDeviceFromFile, TCompletionCode, TCompletionCode::CC_OK, (const uint32_t subDeviceIndex, const char *fileName, void *openParams, IMetricsDevice_1_5 **metricsDevice)); + ADDMETHOD_NOBASE(GetEngineParams, const TEngineParams_1_13 *, nullptr, (const uint32_t subDeviceIndex, const uint32_t engineIndex)); + ADDMETHOD_NOBASE(OpenMetricsSubDeviceFromFile, TCompletionCode, TCompletionCode::CC_OK, (const uint32_t subDeviceIndex, const char *fileName, void *openParams, IMetricsDevice_1_13 **metricsDevice)); ADDMETHOD_CONST_NOBASE(GetParams, const TAdapterParams_1_9 *, nullptr, ()); ADDMETHOD_NOBASE(Reset, TCompletionCode, TCompletionCode::CC_OK, ()); - ADDMETHOD_NOBASE(OpenMetricsDeviceFromFile, TCompletionCode, TCompletionCode::CC_OK, (const char *, void *, IMetricsDevice_1_5 **)); + ADDMETHOD_NOBASE(OpenMetricsDeviceFromFile, TCompletionCode, TCompletionCode::CC_OK, (const char *, void *, IMetricsDevice_1_13 **)); ADDMETHOD_NOBASE(CloseMetricsDevice, TCompletionCode, TCompletionCode::CC_OK, (IMetricsDevice_1_5 *)); - ADDMETHOD_NOBASE(SaveMetricsDeviceToFile, TCompletionCode, TCompletionCode::CC_OK, (const char *, void *, IMetricsDevice_1_5 *)); + ADDMETHOD_NOBASE(SaveMetricsDeviceToFile, TCompletionCode, TCompletionCode::CC_OK, (const char *, void *, IMetricsDevice_1_11 *, const uint32_t, const uint32_t)); - TCompletionCode OpenMetricsDevice(IMetricsDevice_1_5 **metricsDevice) override { + TCompletionCode OpenMetricsDevice(IMetricsDevice_1_13 **metricsDevice) override { *metricsDevice = openMetricsDeviceOutDevice; return openMetricsDeviceResult; } - TCompletionCode OpenMetricsSubDevice(const uint32_t subDeviceIndex, IMetricsDevice_1_5 **metricsDevice) override { + TCompletionCode OpenMetricsSubDevice(const uint32_t subDeviceIndex, IMetricsDevice_1_13 **metricsDevice) override { *metricsDevice = openMetricsSubDeviceOutDevice; return openMetricsSubDeviceResult; } - IMetricsDevice_1_5 *openMetricsSubDeviceOutDevice = nullptr; - IMetricsDevice_1_5 *openMetricsDeviceOutDevice = nullptr; + IMetricsDevice_1_13 *openMetricsSubDeviceOutDevice = nullptr; + IMetricsDevice_1_13 *openMetricsDeviceOutDevice = nullptr; TCompletionCode openMetricsSubDeviceResult = TCompletionCode::CC_OK; TCompletionCode openMetricsDeviceResult = TCompletionCode::CC_OK; }; template <> -class Mock : public IMetricsDevice_1_5 { +class Mock : public IMetricsDevice_1_13 { public: ~Mock() override = default; @@ -114,8 +125,9 @@ class Mock : public IMetricsDevice_1_5 { ADDMETHOD_NOBASE(GetOverrideByName, IOverride_1_2 *, nullptr, (const char *symbolName)); ADDMETHOD_NOBASE(GetGlobalSymbol, TGlobalSymbol_1_0 *, nullptr, (uint32_t index)); ADDMETHOD_NOBASE(GetLastError, TCompletionCode, TCompletionCode::CC_OK, ()); + ADDMETHOD_NOBASE(GetGpuCpuTimestamps, TCompletionCode, TCompletionCode::CC_OK, (uint64_t *, uint64_t *, uint32_t *, uint64_t *)); - IConcurrentGroup_1_5 *GetConcurrentGroup(uint32_t index) override { + IConcurrentGroup_1_13 *GetConcurrentGroup(uint32_t index) override { return getConcurrentGroupResults[index]; } @@ -156,22 +168,22 @@ class Mock : public IMetricsDevice_1_5 { return MetricsDiscovery::CC_OK; } - std::vector getConcurrentGroupResults; + std::vector getConcurrentGroupResults; }; template <> -class Mock : public IConcurrentGroup_1_5 { +class Mock : public IConcurrentGroup_1_13 { public: ~Mock() override = default; - ADDMETHOD_NOBASE(GetParams, TConcurrentGroupParams_1_0 *, nullptr, ()); + ADDMETHOD_NOBASE(GetParams, TConcurrentGroupParams_1_13 *, nullptr, ()); ADDMETHOD_NOBASE(CloseIoStream, TCompletionCode, TCompletionCode::CC_OK, ()); ADDMETHOD_NOBASE(WaitForReports, TCompletionCode, TCompletionCode::CC_OK, (uint32_t milliseconds)); ADDMETHOD_NOBASE(SetIoStreamSamplingType, TCompletionCode, TCompletionCode::CC_OK, (TSamplingType type)); ADDMETHOD_NOBASE(GetIoMeasurementInformation, IInformation_1_0 *, nullptr, (uint32_t index)); ADDMETHOD_NOBASE(GetIoGpuContextInformation, IInformation_1_0 *, nullptr, (uint32_t index)); - IMetricSet_1_5 *GetMetricSet(uint32_t index) override { + IMetricSet_1_13 *GetMetricSet(uint32_t index) override { if (!getMetricSetResults.empty()) { return getMetricSetResults[index]; } @@ -197,8 +209,8 @@ class Mock : public IConcurrentGroup_1_5 { return readIoStreamResult; } - IMetricSet_1_5 *getMetricSetResult = nullptr; - std::vector getMetricSetResults; + IMetricSet_1_13 *getMetricSetResult = nullptr; + std::vector getMetricSetResults; std::vector readIoStreamOutReportsCount{}; uint32_t *openIoStreamOutOaBufferSize = nullptr; TCompletionCode openIoStreamResult = TCompletionCode::CC_OK; @@ -227,12 +239,12 @@ class Mock : public IEquation_1_0 { }; template <> -class Mock : public IMetricSet_1_5 { +class Mock : public IMetricSet_1_13 { public: ~Mock() override = default; - ADDMETHOD_NOBASE(GetParams, TMetricSetParams_1_4 *, nullptr, ()); - ADDMETHOD_NOBASE(GetMetric, IMetric_1_0 *, nullptr, (uint32_t index)); + ADDMETHOD_NOBASE(GetParams, TMetricSetParams_1_11 *, nullptr, ()); + ADDMETHOD_NOBASE(GetMetric, IMetric_1_13 *, nullptr, (uint32_t index)); ADDMETHOD_NOBASE(GetInformation, IInformation_1_0 *, nullptr, (uint32_t index)); ADDMETHOD_NOBASE(Activate, TCompletionCode, TCompletionCode::CC_OK, ()); ADDMETHOD_NOBASE(Deactivate, TCompletionCode, TCompletionCode::CC_OK, ()); @@ -253,11 +265,11 @@ class Mock : public IMetricSet_1_5 { }; template <> -class Mock : public IMetric_1_0 { +class Mock : public IMetric_1_13 { public: ~Mock() override = default; - ADDMETHOD_NOBASE(GetParams, TMetricParams_1_0 *, nullptr, ()); + ADDMETHOD_NOBASE(GetParams, TMetricParams_1_13 *, nullptr, ()); }; template <> @@ -287,7 +299,11 @@ struct Mock : public MetricEnumeration { // Mock metric enumeration functions. ADDMETHOD(isInitialized, bool, false, true, (), ()); ADDMETHOD(loadMetricsDiscovery, ze_result_t, false, ZE_RESULT_SUCCESS, (), ()); - ADDMETHOD_NOBASE(getMetricsAdapter, MetricsDiscovery::IAdapter_1_9 *, nullptr, ()); + + MetricsDiscovery::IAdapter_1_13 *getMetricsAdapterResult = nullptr; + MetricsDiscovery::IAdapter_1_13 *getMetricsAdapter() override { + return getMetricsAdapterResult; + } bool getAdapterId(uint32_t &drmMajor, uint32_t &drmMinor) override { if (getAdapterIdCallBase) { diff --git a/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_programmable.cpp b/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_programmable.cpp new file mode 100644 index 0000000000..14acbe5f19 --- /dev/null +++ b/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_programmable.cpp @@ -0,0 +1,300 @@ +/* + * Copyright (C) 2024 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_programmable.h" + +#include "shared/test/common/test_macros/test.h" + +namespace L0 { +namespace ult { + +uint32_t MockIMetricSet1x13::openMetricCallCount = 0; +uint32_t MockIMetricSet1x13::addMetricCallCount = 0; +uint32_t MockIMetricSet1x13::removeMetricCallCount = 0; +uint32_t MockIMetricSet1x13::getParamsCallCount = 0; +uint32_t MockIMetricSet1x13::closeCallCount = 0; + +const MetricsDiscovery::TMetricPrototypeParams_1_13 *MockIMetricPrototype1x13::GetParams(void) const { + return getParamsReturn; +} +void MockIMetricPrototype1x13::setUpDefaultParams(bool createClone) { + mockParams.GroupName = "GroupName"; + mockParams.LongName = "LongName"; + mockParams.SymbolName = "SymbolName"; + mockParams.UsageFlagsMask = MetricsDiscovery::USAGE_FLAG_TIER_1; + mockParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM | + MetricsDiscovery::API_TYPE_OCL | + MetricsDiscovery::API_TYPE_OGL4_X; + mockParams.OptionDescriptorCount = 4; + mockParams.MetricType = MetricsDiscovery::METRIC_TYPE_EVENT; + mockParams.MetricResultUnits = "percent"; + mockParams.ResultType = MetricsDiscovery::RESULT_UINT64; + mockParams.HwUnitType = MetricsDiscovery::HW_UNIT_GPU; + mockParams.ShortName = "ShortName"; + + // Setup 4 option descriptors + { + MetricsDiscovery::TMetricPrototypeOptionDescriptor_1_13 mockOptionDescriptor; + mockOptionDescriptor.SymbolName = "mockParam1"; + mockOptionDescriptor.Type = MetricsDiscovery::OPTION_DESCRIPTOR_TYPE_DISAGGREGATION; + mockOptionDescriptor.ValidValueCount = 1; + static MetricsDiscovery::TValidValue_1_13 validValue{}; + validValue.ValueType = MetricsDiscovery::VALUE_TYPE_UINT32; + validValue.ValueUInt32 = 1; + mockOptionDescriptor.ValidValues = &validValue; + mockOptionDescriptors.push_back(mockOptionDescriptor); + } + + { + MetricsDiscovery::TMetricPrototypeOptionDescriptor_1_13 mockOptionDescriptor; + mockOptionDescriptor.SymbolName = "mockParam2"; + mockOptionDescriptor.Type = MetricsDiscovery::OPTION_DESCRIPTOR_TYPE_LATENCY; + mockOptionDescriptor.ValidValueCount = 1; + static MetricsDiscovery::TValidValue_1_13 validValue{}; + validValue.ValueType = MetricsDiscovery::VALUE_TYPE_UINT64; + validValue.ValueUInt64 = 2; + mockOptionDescriptor.ValidValues = &validValue; + mockOptionDescriptors.push_back(mockOptionDescriptor); + } + + { + MetricsDiscovery::TMetricPrototypeOptionDescriptor_1_13 mockOptionDescriptor; + mockOptionDescriptor.SymbolName = "mockParam3"; + mockOptionDescriptor.Type = MetricsDiscovery::OPTION_DESCRIPTOR_TYPE_NORMALIZATION_UTILIZATION; + mockOptionDescriptor.ValidValueCount = 1; + static MetricsDiscovery::TValidValue_1_13 validValue{}; + validValue.ValueType = MetricsDiscovery::VALUE_TYPE_UINT32_RANGE; + validValue.ValueUInt32Range.Min = 3; + validValue.ValueUInt32Range.Max = 4; + mockOptionDescriptor.ValidValues = &validValue; + mockOptionDescriptors.push_back(mockOptionDescriptor); + } + + { + MetricsDiscovery::TMetricPrototypeOptionDescriptor_1_13 mockOptionDescriptor; + mockOptionDescriptor.SymbolName = "mockParam4"; + mockOptionDescriptor.Type = MetricsDiscovery::OPTION_DESCRIPTOR_TYPE_NORMALIZATION_BYTE; + mockOptionDescriptor.ValidValueCount = 1; + static MetricsDiscovery::TValidValue_1_13 validValue{}; + validValue.ValueType = MetricsDiscovery::VALUE_TYPE_UINT64_RANGE; + validValue.ValueUInt64Range.Min = 5; + validValue.ValueUInt64Range.Max = 6; + mockOptionDescriptor.ValidValues = &validValue; + mockOptionDescriptors.push_back(mockOptionDescriptor); + } + + if (!clone && createClone) { + clone = new MockIMetricPrototype1x13(); + clone->setUpDefaultParams(false); + } +} + +void MockIMetricPrototype1x13::deleteClone() { + if (clone) { + delete clone; + clone = nullptr; + } +} + +MockIMetricPrototype1x13::~MockIMetricPrototype1x13() { + deleteClone(); +} + +MetricsDiscovery::IMetricPrototype_1_13 *MockIMetricPrototype1x13::Clone(void) { + return clone; +} +const MetricsDiscovery::TMetricPrototypeOptionDescriptor_1_13 *MockIMetricPrototype1x13::GetOptionDescriptor(uint32_t index) const { + if (index < mockOptionDescriptors.size()) { + return &mockOptionDescriptors[index]; + } else { + return nullptr; + } +} + +MetricsDiscovery::TCompletionCode MockIMetricPrototype1x13::SetOption(const MetricsDiscovery::TOptionDescriptorType optionType, const MetricsDiscovery::TTypedValue_1_0 *typedValue) { + return mockSetOptionReturnCode; +} +MetricsDiscovery::TCompletionCode MockIMetricPrototype1x13::ChangeNames(const char *symbolName, const char *shortName, const char *longName, const char *resultUnits) { + mockParams.LongName = longName; + mockParams.SymbolName = symbolName; + return mockChangeNamesReturnCode; +} + +uint32_t MockIMetricEnumerator1x13::GetMetricPrototypeCount(void) { + return getMetricPrototypeCountReturn; +} + +MetricsDiscovery::IMetricPrototype_1_13 *MockIMetricEnumerator1x13::GetMetricPrototype(const uint32_t index) { + return nullptr; +} + +MetricsDiscovery::TCompletionCode MockIMetricEnumerator1x13::GetMetricPrototypes( + const uint32_t index, uint32_t *count, + MetricsDiscovery::IMetricPrototype_1_13 **metrics) { + *count = getMetricPrototypeCountReturn; + + for (uint32_t index = 0; index < *count; index++) { + metrics[index] = &metricProtoTypeReturn[index % maxMockPrototypesSupported]; + } + return MetricsDiscovery::CC_OK; +} + +MockIMetricEnumerator1x13::MockIMetricEnumerator1x13() { + for (uint32_t index = 0; index < maxMockPrototypesSupported; index++) { + metricProtoTypeReturn[index].setUpDefaultParams(true); + } +} + +MetricsDiscovery::TMetricParams_1_13 *MockIMetric1x13::GetParams() { + mockMetricParams.SymbolName = "Metric symbol name"; + mockMetricParams.ShortName = "Metric short name"; + mockMetricParams.LongName = "Metric long name"; + mockMetricParams.ResultType = MetricsDiscovery::TMetricResultType::RESULT_UINT64; + mockMetricParams.MetricType = MetricsDiscovery::TMetricType::METRIC_TYPE_RATIO; + + return &mockMetricParams; +} + +MetricsDiscovery::TInformationParams_1_0 *MockIInformation1x0::GetParams() { + mockInformationParams.SymbolName = "Info symbol name"; + mockInformationParams.ShortName = "Info short name"; + mockInformationParams.LongName = "Info long name"; + mockInformationParams.InfoType = MetricsDiscovery::INFORMATION_TYPE_REPORT_REASON; + + return &mockInformationParams; +} + +MetricsDiscovery::TCompletionCode MockIMetricSet1x13::Open() { + auto index = std::min(openMetricCallCount, static_cast(mockOpenReturnCodeList.size() - 1)); + auto returnStatus = mockOpenReturnCodeList[index]; + openMetricCallCount++; + return returnStatus; +} + +MetricsDiscovery::TCompletionCode MockIMetricSet1x13::AddMetric(MetricsDiscovery::IMetricPrototype_1_13 *metricPrototype) { + + auto index = std::min(addMetricCallCount, static_cast(mockAddMetricReturnCodeList.size() - 1)); + auto returnStatus = mockAddMetricReturnCodeList[index]; + addMetricCallCount++; + return returnStatus; +} + +MetricsDiscovery::TCompletionCode MockIMetricSet1x13::RemoveMetric(MetricsDiscovery::IMetricPrototype_1_13 *metricPrototype) { + auto index = std::min(removeMetricCallCount, static_cast(mockRemoveMetricReturnCodeList.size() - 1)); + auto returnStatus = mockRemoveMetricReturnCodeList[index]; + removeMetricCallCount++; + return returnStatus; +} +MetricsDiscovery::TCompletionCode MockIMetricSet1x13::Finalize() { + auto index = std::min(closeCallCount, static_cast(mockCloseReturnCodeList.size() - 1)); + auto returnStatus = mockCloseReturnCodeList[index]; + closeCallCount++; + return returnStatus; +} + +MetricsDiscovery::TMetricSetParams_1_11 *MockIMetricSet1x13::GetParams(void) { + mockMetricSetParams.ApiMask = mockApiMask; + mockMetricSetParams.InformationCount = mockInformationCount; + auto index = std::min(getParamsCallCount, static_cast(mockMetricCountList.size() - 1)); + mockMetricSetParams.MetricsCount = mockMetricCountList[index]; + getParamsCallCount++; + mockMetricSetParams.SymbolName = "Metric set name"; + mockMetricSetParams.ShortName = "Metric set description"; + return &mockMetricSetParams; +} + +MetricsDiscovery::TCompletionCode MockIMetricSet1x13::SetApiFiltering(uint32_t apiMask) { return MetricsDiscovery::CC_OK; } + +MetricsDiscovery::IMetric_1_13 *MockIMetricSet1x13::GetMetric(uint32_t index) { + return &mockMetric; +} + +MetricsDiscovery::IInformation_1_0 *MockIMetricSet1x13::GetInformation(uint32_t index) { + return &mockInformation; +} + +void MockIMetricSet1x13::resetMocks(MockIMetricSet1x13 *mockMetricSet) { + mockMetricSet->mockAddMetricReturnCodeList.resize(1); + mockMetricSet->mockAddMetricReturnCodeList[0] = MetricsDiscovery::CC_OK; + addMetricCallCount = 0; + + mockMetricSet->mockRemoveMetricReturnCodeList.resize(1); + mockMetricSet->mockRemoveMetricReturnCodeList[0] = MetricsDiscovery::CC_OK; + removeMetricCallCount = 0; + + mockMetricSet->mockOpenReturnCodeList.resize(1); + mockMetricSet->mockOpenReturnCodeList[0] = MetricsDiscovery::CC_OK; + openMetricCallCount = 0; + + mockMetricSet->mockCloseReturnCodeList.resize(1); + mockMetricSet->mockCloseReturnCodeList[0] = MetricsDiscovery::CC_OK; + closeCallCount = 0; + + mockMetricSet->mockMetricCountList.resize(1); + mockMetricSet->mockMetricCountList[0] = 2; + getParamsCallCount = 0; + + mockMetricSet->mockInformationCount = 1; + mockMetricSet->mockApiMask = MetricsDiscovery::API_TYPE_OCL | MetricsDiscovery::API_TYPE_IOSTREAM; +} + +MetricsDiscovery::IMetricEnumerator_1_13 *MockIConcurrentGroup1x13::GetMetricEnumerator() { + return metricEnumeratorReturn; +} + +MetricsDiscovery::TConcurrentGroupParams_1_13 *MockIConcurrentGroup1x13::GetParams(void) { return nullptr; } +MetricsDiscovery::IMetricSet_1_13 *MockIConcurrentGroup1x13::GetMetricSet(uint32_t index) { return nullptr; } +MetricsDiscovery::IMetricEnumerator_1_13 *MockIConcurrentGroup1x13::GetMetricEnumeratorFromFile(const char *fileName) { return nullptr; } +MetricsDiscovery::IMetricSet_1_13 *MockIConcurrentGroup1x13::AddMetricSet(const char *symbolName, const char *shortName) { return &mockMetricSet; } +MetricsDiscovery::TCompletionCode MockIConcurrentGroup1x13::RemoveMetricSet(MetricsDiscovery::IMetricSet_1_13 *metricSet) { return mockRemoveMetricSetReturn; } + +MetricsDiscovery::IConcurrentGroup_1_13 *MockIMetricsDevice1x13::GetConcurrentGroup(uint32_t index) { + return concurrentGroupReturn; +} + +MetricsDiscovery::TCompletionCode MockIAdapter1x13::OpenMetricsDevice(MetricsDiscovery::IMetricsDevice_1_13 **metricsDevice) { + *metricsDevice = metricsDeviceReturn; + return MetricsDiscovery::CC_OK; +} +MetricsDiscovery::TCompletionCode MockIAdapter1x13::OpenMetricsDevice(MetricsDiscovery::IMetricsDevice_1_5 **metricsDevice) { + *metricsDevice = static_cast(metricsDeviceReturn); + return MetricsDiscovery::CC_OK; +} +MetricsDiscovery::TCompletionCode MockIAdapter1x13::OpenMetricsDeviceFromFile(const char *fileName, void *openParams, MetricsDiscovery::IMetricsDevice_1_13 **metricsDevice) { + return MetricsDiscovery::CC_ERROR_NOT_SUPPORTED; +} +MetricsDiscovery::TCompletionCode MockIAdapter1x13::OpenMetricsSubDevice(const uint32_t subDeviceIndex, MetricsDiscovery::IMetricsDevice_1_13 **metricsDevice) { + *metricsDevice = metricsDeviceReturn; + return MetricsDiscovery::CC_OK; +} +MetricsDiscovery::TCompletionCode MockIAdapter1x13::OpenMetricsSubDevice(const uint32_t subDeviceIndex, MetricsDiscovery::IMetricsDevice_1_5 **metricsDevice) { + *metricsDevice = static_cast(metricsDeviceReturn); + return MetricsDiscovery::CC_OK; +} +MetricsDiscovery::TCompletionCode MockIAdapter1x13::OpenMetricsSubDeviceFromFile(const uint32_t subDeviceIndex, const char *fileName, void *openParams, MetricsDiscovery::IMetricsDevice_1_13 **metricsDevice) { + return MetricsDiscovery::CC_ERROR_NOT_SUPPORTED; +} + +const MetricsDiscovery::TAdapterParams_1_9 *MockIAdapter1x13::GetParams(void) const { + return &mockAdapterParams; +} +MockIAdapter1x13::MockIAdapter1x13() { + mockAdapterParams.BusNumber = 100; +} + +const MetricsDiscovery::TAdapterGroupParams_1_6 *MockIAdapterGroup1x13::GetParams() const { + return &mockParams; +} +MetricsDiscovery::IAdapter_1_13 *MockIAdapterGroup1x13::GetAdapter(uint32_t index) { + return adapterReturn; +} +MetricsDiscovery::TCompletionCode MockIAdapterGroup1x13::Close() { + return MetricsDiscovery::CC_OK; +} + +} // namespace ult +} // namespace L0 \ No newline at end of file diff --git a/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_programmable.h b/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_programmable.h new file mode 100644 index 0000000000..117a321d62 --- /dev/null +++ b/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_programmable.h @@ -0,0 +1,140 @@ +/* + * Copyright (C) 2024 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#pragma once +#include "level_zero/tools/source/metrics/metric_oa_programmable_imp.h" + +namespace L0 { +namespace ult { +class MockIMetricPrototype1x13 : public MetricsDiscovery::IMetricPrototype_1_13 { + public: + MetricsDiscovery::TMetricPrototypeParams_1_13 mockParams{}; + MetricsDiscovery::TMetricPrototypeParams_1_13 *getParamsReturn = &mockParams; + std::vector mockOptionDescriptors{}; + MetricsDiscovery::TCompletionCode mockSetOptionReturnCode = MetricsDiscovery::CC_OK; + MockIMetricPrototype1x13 *clone = nullptr; + MetricsDiscovery::TCompletionCode mockChangeNamesReturnCode = MetricsDiscovery::CC_OK; + void setUpDefaultParams(bool createClone); + void deleteClone(); + + ~MockIMetricPrototype1x13() override; + const MetricsDiscovery::TMetricPrototypeParams_1_13 *GetParams(void) const override; + MetricsDiscovery::IMetricPrototype_1_13 *Clone(void) override; + const MetricsDiscovery::TMetricPrototypeOptionDescriptor_1_13 *GetOptionDescriptor(uint32_t index) const override; + MetricsDiscovery::TCompletionCode SetOption(const MetricsDiscovery::TOptionDescriptorType optionType, const MetricsDiscovery::TTypedValue_1_0 *typedValue) override; + MetricsDiscovery::TCompletionCode ChangeNames(const char *symbolName, const char *shortName, const char *longName, const char *resultUnits) override; +}; + +constexpr uint32_t maxMockPrototypesSupported = 2; + +class MockIMetricEnumerator1x13 : public MetricsDiscovery::IMetricEnumerator_1_13 { + public: + ~MockIMetricEnumerator1x13() override = default; + uint32_t getMetricPrototypeCountReturn = 1; + uint32_t GetMetricPrototypeCount(void) override; + MetricsDiscovery::IMetricPrototype_1_13 *GetMetricPrototype(const uint32_t index) override; + MockIMetricPrototype1x13 metricProtoTypeReturn[maxMockPrototypesSupported]; + MetricsDiscovery::TCompletionCode GetMetricPrototypes(const uint32_t index, uint32_t *count, + MetricsDiscovery::IMetricPrototype_1_13 **metrics) override; + + MockIMetricEnumerator1x13(); +}; + +class MockIMetric1x13 : public MetricsDiscovery::IMetric_1_13 { + public: + MetricsDiscovery::TMetricParams_1_13 mockMetricParams{}; + ~MockIMetric1x13() override{}; + MetricsDiscovery::TMetricParams_1_13 *GetParams() override; +}; + +class MockIInformation1x0 : public MetricsDiscovery::IInformation_1_0 { + public: + MetricsDiscovery::TInformationParams_1_0 mockInformationParams{}; + ~MockIInformation1x0() override{}; + MetricsDiscovery::TInformationParams_1_0 *GetParams() override; +}; + +class MockIMetricSet1x13 : public MetricsDiscovery::IMetricSet_1_13 { + public: + MetricsDiscovery::TMetricSetParams_1_11 mockMetricSetParams{}; + std::vector mockOpenReturnCodeList{MetricsDiscovery::CC_OK}; + std::vector mockAddMetricReturnCodeList{MetricsDiscovery::CC_OK}; + std::vector mockRemoveMetricReturnCodeList{MetricsDiscovery::CC_OK}; + std::vector mockCloseReturnCodeList{MetricsDiscovery::CC_OK}; + uint32_t mockApiMask = MetricsDiscovery::API_TYPE_OCL | MetricsDiscovery::API_TYPE_IOSTREAM; + std::vector mockMetricCountList{2u}; + uint32_t mockInformationCount = 1; + MockIInformation1x0 mockInformation{}; + static uint32_t openMetricCallCount; + static uint32_t addMetricCallCount; + static uint32_t removeMetricCallCount; + static uint32_t closeCallCount; + static uint32_t getParamsCallCount; + MockIMetric1x13 mockMetric{}; + ~MockIMetricSet1x13() override {} + MetricsDiscovery::TCompletionCode Open() override; + MetricsDiscovery::TCompletionCode AddMetric(MetricsDiscovery::IMetricPrototype_1_13 *metricPrototype) override; + MetricsDiscovery::TCompletionCode RemoveMetric(MetricsDiscovery::IMetricPrototype_1_13 *metricPrototype) override; + MetricsDiscovery::TCompletionCode Finalize() override; + MetricsDiscovery::TMetricSetParams_1_11 *GetParams(void) override; + MetricsDiscovery::TCompletionCode SetApiFiltering(uint32_t apiMask) override; + + MetricsDiscovery::IMetric_1_13 *GetMetric(uint32_t index) override; + MetricsDiscovery::IInformation_1_0 *GetInformation(uint32_t index) override; + static void resetMocks(MockIMetricSet1x13 *mockMetricSet); +}; + +class MockIConcurrentGroup1x13 : public MetricsDiscovery::IConcurrentGroup_1_13 { + public: + ~MockIConcurrentGroup1x13() override {} + MockIMetricEnumerator1x13 mockMetricEnumerator; + MockIMetricSet1x13 mockMetricSet; + + MockIMetricEnumerator1x13 *metricEnumeratorReturn = &mockMetricEnumerator; + MetricsDiscovery::TCompletionCode mockRemoveMetricSetReturn = MetricsDiscovery::CC_OK; + MetricsDiscovery::IMetricEnumerator_1_13 *GetMetricEnumerator() override; + MetricsDiscovery::TConcurrentGroupParams_1_13 *GetParams(void) override; + MetricsDiscovery::IMetricSet_1_13 *GetMetricSet(uint32_t index) override; + MetricsDiscovery::IMetricEnumerator_1_13 *GetMetricEnumeratorFromFile(const char *fileName) override; + MetricsDiscovery::IMetricSet_1_13 *AddMetricSet(const char *symbolName, const char *shortName) override; + MetricsDiscovery::TCompletionCode RemoveMetricSet(MetricsDiscovery::IMetricSet_1_13 *metricSet) override; +}; + +class MockIMetricsDevice1x13 : public MetricsDiscovery::IMetricsDevice_1_13 { + public: + MockIConcurrentGroup1x13 concurrentGroup{}; + MockIConcurrentGroup1x13 *concurrentGroupReturn = &concurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 *GetConcurrentGroup(uint32_t index) override; +}; + +class MockIAdapter1x13 : public MetricsDiscovery::IAdapter_1_13 { + public: + MockIMetricsDevice1x13 mockMetricsDevice{}; + MockIMetricsDevice1x13 *metricsDeviceReturn = &mockMetricsDevice; + MetricsDiscovery::TCompletionCode OpenMetricsDevice(MetricsDiscovery::IMetricsDevice_1_13 **metricsDevice) override; + MetricsDiscovery::TCompletionCode OpenMetricsDevice(MetricsDiscovery::IMetricsDevice_1_5 **metricsDevice) override; + MetricsDiscovery::TCompletionCode OpenMetricsDeviceFromFile(const char *fileName, void *openParams, MetricsDiscovery::IMetricsDevice_1_13 **metricsDevice) override; + MetricsDiscovery::TCompletionCode OpenMetricsSubDevice(const uint32_t subDeviceIndex, MetricsDiscovery::IMetricsDevice_1_13 **metricsDevice) override; + MetricsDiscovery::TCompletionCode OpenMetricsSubDevice(const uint32_t subDeviceIndex, MetricsDiscovery::IMetricsDevice_1_5 **metricsDevice) override; + MetricsDiscovery::TCompletionCode OpenMetricsSubDeviceFromFile(const uint32_t subDeviceIndex, const char *fileName, void *openParams, MetricsDiscovery::IMetricsDevice_1_13 **metricsDevice) override; + MetricsDiscovery::TAdapterParams_1_9 mockAdapterParams; + const MetricsDiscovery::TAdapterParams_1_9 *GetParams(void) const override; + MockIAdapter1x13(); +}; +class MockIAdapterGroup1x13 : public MetricsDiscovery::IAdapterGroup_1_13 { + public: + ~MockIAdapterGroup1x13() override = default; + MetricsDiscovery::TAdapterGroupParams_1_6 mockParams{}; + const MetricsDiscovery::TAdapterGroupParams_1_6 *GetParams() const override; + MockIAdapter1x13 mockAdapter{}; + MockIAdapter1x13 *adapterReturn = &mockAdapter; + MetricsDiscovery::IAdapter_1_13 *GetAdapter(uint32_t index) override; + MetricsDiscovery::TCompletionCode Close() override; +}; + +} // namespace ult +} // namespace L0 \ No newline at end of file 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 b7db21ed38..700b1ddb8f 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 @@ -26,6 +26,13 @@ class MockMetricSource : public L0::MetricSource { ze_result_t metricProgrammableGet(uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables) override { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } + ze_result_t createMetricGroupsFromMetrics(std::vector &metricList, + const char metricGroupNamePrefix[ZET_INTEL_MAX_METRIC_GROUP_NAME_PREFIX_EXP], + const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION], + uint32_t *maxMetricGroupCount, + std::vector &metricGroupList) override { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + } ze_result_t getConcurrentMetricGroups(std::vector &hMetricGroups, uint32_t *pConcurrentGroupCount, uint32_t *pCountPerConcurrentGroup) override { @@ -34,6 +41,7 @@ class MockMetricSource : public L0::MetricSource { void setType(uint32_t type) { this->type = type; } + ~MockMetricSource() override = default; }; diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_group.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_group.cpp new file mode 100644 index 0000000000..e2fb330e04 --- /dev/null +++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_group.cpp @@ -0,0 +1,111 @@ +/* + * Copyright (C) 2023-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/include/zet_intel_gpu_metric.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 MetricGroupUserDefinedTest = Test; + +TEST_F(MetricGroupUserDefinedTest, givenImmutableMetricGroupAndMetricsWhenUsingApisForProgrammableMetricsThenErrorIsReturned) { + + // Metrics Discovery device. + metricsDeviceParams.ConcurrentGroupsCount = 1; + + // Metrics Discovery concurrent group. + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; + metricsConcurrentGroupParams.MetricSetsCount = 1; + metricsConcurrentGroupParams.SymbolName = "OA"; + metricsConcurrentGroupParams.Description = "OA description"; + metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; + + Mock ioReadEquation; + MetricsDiscovery::TEquationElement_1_0 ioEquationElement = {}; + ioEquationElement.Type = MetricsDiscovery::EQUATION_ELEM_IMM_UINT64; + ioEquationElement.ImmediateUInt64 = 0; + + ioReadEquation.getEquationElement.push_back(&ioEquationElement); + + Mock ioMeasurement; + MetricsDiscovery::TInformationParams_1_0 oaInformation = {}; + oaInformation.SymbolName = "BufferOverflow"; + oaInformation.IoReadEquation = &ioReadEquation; + + // Metrics Discovery:: metric set. + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 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_13 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_DURATION; + + // 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; + metricsConcurrentGroup.GetIoMeasurementInformationResult = &ioMeasurement; + ioMeasurement.GetParamsResult = &oaInformation; + + metricsSet.GetParamsResult = &metricsSetParams; + metricsSet.GetMetricResult = &metric; + + metric.GetParamsResult = &metricParams; + + // Metric group count. + uint32_t metricGroupCount = 0; + EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_SUCCESS); + EXPECT_EQ(metricGroupCount, 1u); + + // Metric group handle. + EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS); + EXPECT_EQ(metricGroupCount, 1u); + EXPECT_NE(metricGroupHandle, nullptr); + + // 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); + + size_t errorStringSize = 0; + EXPECT_EQ(zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle, &errorStringSize, 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); + EXPECT_EQ(1u, metric.GetParamsCalled); +} + +} // namespace ult +} // namespace L0 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 28c220b1a4..6b4305f04d 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 @@ -58,6 +58,19 @@ HWTEST2_F(MetricIpSamplingEnumerationTest, GivenDependenciesUnAvailableForSubDev EXPECT_TRUE(metricSource1.isAvailable()); } +HWTEST2_F(MetricIpSamplingEnumerationTest, GivenIpSamplingAvailableWhenCreateMetricGroupsFromMetricsIsCalledThenErrorIsReturned, EustallSupportedPlatforms) { + + EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi()); + auto &metricSource = testDevices[0]->getMetricDeviceContext().getMetricSource(); + + std::vector metricList{}; + const char metricGroupNamePrefix[ZET_INTEL_MAX_METRIC_GROUP_NAME_PREFIX_EXP] = {}; + const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION] = {}; + uint32_t maxMetricGroupCount = 0; + std::vector metricGroupList = {}; + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, metricSource.createMetricGroupsFromMetrics(metricList, metricGroupNamePrefix, description, &maxMetricGroupCount, metricGroupList)); +} + HWTEST2_F(MetricIpSamplingEnumerationTest, GivenDependenciesAvailableWhenMetricGroupGetIsCalledThenValidMetricGroupIsReturned, EustallSupportedPlatforms) { EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi()); diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_1.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_1.cpp index f3f14d0068..96af81383e 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_1.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_1.cpp @@ -89,10 +89,10 @@ TEST_F(MetricEnumerationTest, givenTwoConcurrentMetricGroupsWhenZetGetMetricGrou metricsDeviceParams.ConcurrentGroupsCount = 2; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup0; - Mock metricsConcurrentGroup1; + Mock metricsConcurrentGroup0; + Mock metricsConcurrentGroup1; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -113,8 +113,8 @@ TEST_F(MetricEnumerationTest, givenTwoConcurrentMetricGroupsWhenZetGetMetricGrou ioMeasurement.GetParamsResult = &oaInformation; // Metrics Discovery:: metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; openMetricsAdapter(); @@ -149,8 +149,8 @@ TEST_F(MetricEnumerationTest, givenInvalidArgumentsWhenZetGetMetricGroupProperti metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -170,8 +170,8 @@ TEST_F(MetricEnumerationTest, givenInvalidArgumentsWhenZetGetMetricGroupProperti ioMeasurement.GetParamsResult = &oaInformation; // Metrics Discovery:: metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; // One api: metric group handle. @@ -206,8 +206,8 @@ TEST_F(MetricEnumerationTest, givenValidArgumentsWhenZetGetMetricGroupProperties metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -228,8 +228,8 @@ TEST_F(MetricEnumerationTest, givenValidArgumentsWhenZetGetMetricGroupProperties ioMeasurement.GetParamsResult = &oaInformation; // Metrics Discovery:: metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -275,8 +275,8 @@ TEST_F(MetricEnumerationTest, givenInvalidArgumentsWhenZetMetricGetIsCalledThenR metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -295,8 +295,8 @@ TEST_F(MetricEnumerationTest, givenInvalidArgumentsWhenZetMetricGetIsCalledThenR oaInformation.IoReadEquation = &ioReadEquation; // Metrics Discovery:: metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -335,8 +335,8 @@ TEST_F(MetricEnumerationTest, givenValidArgumentsWhenZetMetricGetIsCalledThenRet metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -355,8 +355,8 @@ TEST_F(MetricEnumerationTest, givenValidArgumentsWhenZetMetricGetIsCalledThenRet oaInformation.IoReadEquation = &ioReadEquation; // Metrics Discovery:: metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -364,8 +364,8 @@ TEST_F(MetricEnumerationTest, givenValidArgumentsWhenZetMetricGetIsCalledThenRet metricsSetParams.MetricsCount = 1; // Metrics Discovery:: metric. - Mock metric; - TMetricParams_1_0 metricParams = {}; + Mock metric; + TMetricParams_1_13 metricParams = {}; // One api: metric group handle. zet_metric_group_handle_t metricGroupHandle = {}; @@ -409,8 +409,8 @@ TEST_F(MetricEnumerationTest, GivenEnumerationIsSuccessfulWhenReadingMetricsFreq metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -431,8 +431,8 @@ TEST_F(MetricEnumerationTest, GivenEnumerationIsSuccessfulWhenReadingMetricsFreq ioMeasurement.GetParamsResult = &oaInformation; // Metrics Discovery:: metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -486,8 +486,8 @@ TEST_F(MetricEnumerationTest, GivenValidMetricGroupWhenReadingPropertiesAndIncor metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -506,8 +506,8 @@ TEST_F(MetricEnumerationTest, GivenValidMetricGroupWhenReadingPropertiesAndIncor oaInformation.IoReadEquation = &ioReadEquation; // Metrics Discovery:: metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -556,8 +556,8 @@ TEST_F(MetricEnumerationTest, GivenValidMetricGroupWhenReadingFrequencyAndIntern metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -578,8 +578,8 @@ TEST_F(MetricEnumerationTest, GivenValidMetricGroupWhenReadingFrequencyAndIntern ioMeasurement.GetParamsResult = &oaInformation; // Metrics Discovery:: metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -671,8 +671,8 @@ TEST_F(MetricEnumerationTest, GivenEnumerationIsSuccessfulWhenReadingMetricsFreq metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -693,8 +693,8 @@ TEST_F(MetricEnumerationTest, GivenEnumerationIsSuccessfulWhenReadingMetricsFreq ioMeasurement.GetParamsResult = &oaInformation; // Metrics Discovery:: metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -751,8 +751,8 @@ TEST_F(MetricEnumerationTest, GivenEnumerationIsSuccessfulWhenFailingToReadMetri metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -773,8 +773,8 @@ TEST_F(MetricEnumerationTest, GivenEnumerationIsSuccessfulWhenFailingToReadMetri ioMeasurement.GetParamsResult = &oaInformation; // Metrics Discovery:: metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -832,8 +832,8 @@ TEST_F(MetricEnumerationTest, givenValidArgumentsWhenZetMetricGetIsCalledThenRet metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -854,8 +854,8 @@ TEST_F(MetricEnumerationTest, givenValidArgumentsWhenZetMetricGetIsCalledThenRet ioMeasurement.GetParamsResult = &oaInformation; // Metrics Discovery:: metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -863,8 +863,8 @@ TEST_F(MetricEnumerationTest, givenValidArgumentsWhenZetMetricGetIsCalledThenRet metricsSetParams.MetricsCount = 1; // Metrics Discovery:: metric. - Mock metric; - TMetricParams_1_0 metricParams = {}; + Mock metric; + TMetricParams_1_13 metricParams = {}; // One api: metric group handle. zet_metric_group_handle_t metricGroupHandle = {}; @@ -909,8 +909,8 @@ TEST_F(MetricEnumerationTest, givenInvalidArgumentsWhenZetMetricGetPropertiestIs metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -931,8 +931,8 @@ TEST_F(MetricEnumerationTest, givenInvalidArgumentsWhenZetMetricGetPropertiestIs ioMeasurement.GetParamsResult = &oaInformation; // Metrics Discovery:: metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -940,8 +940,8 @@ TEST_F(MetricEnumerationTest, givenInvalidArgumentsWhenZetMetricGetPropertiestIs metricsSetParams.MetricsCount = 1; // Metrics Discovery:: metric. - Mock metric; - TMetricParams_1_0 metricParams = {}; + Mock metric; + TMetricParams_1_13 metricParams = {}; // One api: metric group handle. zet_metric_group_handle_t metricGroupHandle = {}; @@ -986,8 +986,8 @@ TEST_F(MetricEnumerationTest, givenValidArgumentsWhenZetMetricGetPropertiestIsCa metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -1006,8 +1006,8 @@ TEST_F(MetricEnumerationTest, givenValidArgumentsWhenZetMetricGetPropertiestIsCa oaInformation.IoReadEquation = &ioReadEquation; // Metrics Discovery:: metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -1015,8 +1015,8 @@ TEST_F(MetricEnumerationTest, givenValidArgumentsWhenZetMetricGetPropertiestIsCa metricsSetParams.MetricsCount = 1; // Metrics Discovery:: metric. - Mock metric; - TMetricParams_1_0 metricParams = {}; + Mock metric; + TMetricParams_1_13 metricParams = {}; metricParams.SymbolName = "Metric symbol name"; metricParams.ShortName = "Metric short name"; metricParams.LongName = "Metric long name"; @@ -1076,8 +1076,8 @@ TEST_F(MetricEnumerationTest, givenValidArgumentsWhenZetMetricGetPropertiestIsCa metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -1098,8 +1098,8 @@ TEST_F(MetricEnumerationTest, givenValidArgumentsWhenZetMetricGetPropertiestIsCa ioMeasurement.GetParamsResult = &oaInformation; // Metrics Discovery:: metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -1107,8 +1107,8 @@ TEST_F(MetricEnumerationTest, givenValidArgumentsWhenZetMetricGetPropertiestIsCa metricsSetParams.MetricsCount = 1; // Metrics Discovery:: metric. - Mock metric; - TMetricParams_1_0 metricParams = {}; + Mock metric; + TMetricParams_1_13 metricParams = {}; metricParams.SymbolName = "Metric symbol name"; metricParams.ShortName = "Metric short name"; metricParams.LongName = "Metric long name"; @@ -1165,8 +1165,8 @@ TEST_F(MetricEnumerationTest, givenInvalidArgumentsWhenzetContextActivateMetricG metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -1187,8 +1187,8 @@ TEST_F(MetricEnumerationTest, givenInvalidArgumentsWhenzetContextActivateMetricG ioMeasurement.GetParamsResult = &oaInformation; // Metrics Discovery:: metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -1196,8 +1196,8 @@ TEST_F(MetricEnumerationTest, givenInvalidArgumentsWhenzetContextActivateMetricG metricsSetParams.MetricsCount = 1; // Metrics Discovery:: metric. - Mock metric; - TMetricParams_1_0 metricParams = {}; + Mock metric; + TMetricParams_1_13 metricParams = {}; metricParams.SymbolName = "Metric symbol name"; metricParams.ShortName = "Metric short name"; metricParams.LongName = "Metric long name"; @@ -1238,8 +1238,8 @@ TEST_F(MetricEnumerationTest, givenValidEventBasedMetricGroupWhenzetContextActiv metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -1260,8 +1260,8 @@ TEST_F(MetricEnumerationTest, givenValidEventBasedMetricGroupWhenzetContextActiv ioMeasurement.GetParamsResult = &oaInformation; // Metrics Discovery:: metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -1269,8 +1269,8 @@ TEST_F(MetricEnumerationTest, givenValidEventBasedMetricGroupWhenzetContextActiv metricsSetParams.MetricsCount = 1; // Metrics Discovery:: metric. - Mock metric; - TMetricParams_1_0 metricParams = {}; + Mock metric; + TMetricParams_1_13 metricParams = {}; metricParams.SymbolName = "Metric symbol name"; metricParams.ShortName = "Metric short name"; metricParams.LongName = "Metric long name"; @@ -1315,8 +1315,8 @@ TEST_F(MultiDeviceMetricEnumerationTest, givenMultipleDevicesAndValidEventBasedM metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -1335,8 +1335,8 @@ TEST_F(MultiDeviceMetricEnumerationTest, givenMultipleDevicesAndValidEventBasedM oaInformation.IoReadEquation = &ioReadEquation; // Metrics Discovery:: metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -1344,8 +1344,8 @@ TEST_F(MultiDeviceMetricEnumerationTest, givenMultipleDevicesAndValidEventBasedM metricsSetParams.MetricsCount = 1; // Metrics Discovery:: metric. - Mock metric; - TMetricParams_1_0 metricParams = {}; + Mock metric; + TMetricParams_1_13 metricParams = {}; metricParams.SymbolName = "Metric symbol name"; metricParams.ShortName = "Metric short name"; metricParams.LongName = "Metric long name"; @@ -1391,8 +1391,8 @@ TEST_F(MultiDeviceMetricEnumerationTest, givenMultipleDevicesAndTwoMetricGroupsW metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup0; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams0 = {}; + Mock metricsConcurrentGroup0; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams0 = {}; metricsConcurrentGroupParams0.MetricSetsCount = 2; metricsConcurrentGroupParams0.SymbolName = "OA"; metricsConcurrentGroupParams0.Description = "OA description"; @@ -1411,10 +1411,10 @@ TEST_F(MultiDeviceMetricEnumerationTest, givenMultipleDevicesAndTwoMetricGroupsW oaInformation.IoReadEquation = &ioReadEquation; // Metrics Discovery:: metric set. - Mock metricsSet0; - Mock metricsSet1; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams0 = {}; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams1 = {}; + Mock metricsSet0; + Mock metricsSet1; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams0 = {}; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams1 = {}; metricsSetParams0.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams0.SymbolName = "Metric set ZERO"; metricsSetParams0.ShortName = "Metric set ZERO description"; @@ -1425,16 +1425,16 @@ TEST_F(MultiDeviceMetricEnumerationTest, givenMultipleDevicesAndTwoMetricGroupsW metricsSetParams1.MetricsCount = 1; // Metrics Discovery:: metric. - Mock metric0; - TMetricParams_1_0 metricParams0 = {}; + Mock metric0; + TMetricParams_1_13 metricParams0 = {}; metricParams0.SymbolName = "Metric ZERO symbol name"; metricParams0.ShortName = "Metric ZERO short name"; metricParams0.LongName = "Metric ZERO long name"; metricParams0.ResultType = MetricsDiscovery::TMetricResultType::RESULT_UINT64; metricParams0.MetricType = MetricsDiscovery::TMetricType::METRIC_TYPE_RATIO; - Mock metric1; - TMetricParams_1_0 metricParams1 = {}; + Mock metric1; + TMetricParams_1_13 metricParams1 = {}; metricParams1.SymbolName = "Metric ONE symbol name"; metricParams1.ShortName = "Metric ONE short name"; metricParams1.LongName = "Metric ONE long name"; @@ -1493,8 +1493,8 @@ TEST_F(MetricEnumerationTest, givenValidTimeBasedMetricGroupWhenzetContextActiva metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -1515,8 +1515,8 @@ TEST_F(MetricEnumerationTest, givenValidTimeBasedMetricGroupWhenzetContextActiva ioMeasurement.GetParamsResult = &oaInformation; // Metrics Discovery:: metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -1524,8 +1524,8 @@ TEST_F(MetricEnumerationTest, givenValidTimeBasedMetricGroupWhenzetContextActiva metricsSetParams.MetricsCount = 1; // Metrics Discovery:: metric. - Mock metric; - TMetricParams_1_0 metricParams = {}; + Mock metric; + TMetricParams_1_13 metricParams = {}; metricParams.SymbolName = "Metric symbol name"; metricParams.ShortName = "Metric short name"; metricParams.LongName = "Metric long name"; @@ -1569,8 +1569,8 @@ TEST_F(MetricEnumerationTest, givenActivateTheSameMetricGroupTwiceWhenzetContext metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -1591,8 +1591,8 @@ TEST_F(MetricEnumerationTest, givenActivateTheSameMetricGroupTwiceWhenzetContext ioMeasurement.GetParamsResult = &oaInformation; // Metrics Discovery:: metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -1600,8 +1600,8 @@ TEST_F(MetricEnumerationTest, givenActivateTheSameMetricGroupTwiceWhenzetContext metricsSetParams.MetricsCount = 1; // Metrics Discovery:: metric. - Mock metric; - TMetricParams_1_0 metricParams = {}; + Mock metric; + TMetricParams_1_13 metricParams = {}; metricParams.SymbolName = "Metric symbol name"; metricParams.ShortName = "Metric short name"; metricParams.LongName = "Metric long name"; @@ -1646,10 +1646,10 @@ TEST_F(MetricEnumerationTest, givenActivateTwoMetricGroupsWithDifferentDomainsWh metricsDeviceParams.ConcurrentGroupsCount = 2; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup0; - Mock metricsConcurrentGroup1; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams0 = {}; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams1 = {}; + Mock metricsConcurrentGroup0; + Mock metricsConcurrentGroup1; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams0 = {}; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams1 = {}; metricsConcurrentGroupParams0.MetricSetsCount = 1; metricsConcurrentGroupParams1.MetricSetsCount = 1; metricsConcurrentGroupParams0.SymbolName = "OA"; @@ -1674,8 +1674,8 @@ TEST_F(MetricEnumerationTest, givenActivateTwoMetricGroupsWithDifferentDomainsWh metricsConcurrentGroup1.GetIoMeasurementInformationResult = &ioMeasurement; // Metrics Discovery: metric set - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; // One api: metric group. @@ -1721,10 +1721,10 @@ TEST_F(MetricEnumerationTest, givenActivateTwoMetricGroupsWithDifferentDomainsAt metricsDeviceParams.ConcurrentGroupsCount = 2; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup0; - Mock metricsConcurrentGroup1; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams0 = {}; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams1 = {}; + Mock metricsConcurrentGroup0; + Mock metricsConcurrentGroup1; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams0 = {}; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams1 = {}; metricsConcurrentGroupParams0.MetricSetsCount = 1; metricsConcurrentGroupParams1.MetricSetsCount = 1; metricsConcurrentGroupParams0.SymbolName = "OA"; @@ -1749,8 +1749,8 @@ TEST_F(MetricEnumerationTest, givenActivateTwoMetricGroupsWithDifferentDomainsAt metricsConcurrentGroup1.GetIoMeasurementInformationResult = &ioMeasurement; // Metrics Discovery: metric set - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; // One api: metric group. @@ -1794,8 +1794,8 @@ TEST_F(MetricEnumerationTest, givenActivateTwoMetricGroupsWithTheSameDomainsWhen metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 2; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -1815,10 +1815,10 @@ TEST_F(MetricEnumerationTest, givenActivateTwoMetricGroupsWithTheSameDomainsWhen ioMeasurement.GetParamsResult = &oaInformation; // Metrics Discovery: metric set - Mock metricsSet0; - Mock metricsSet1; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams0 = {}; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams1 = {}; + Mock metricsSet0; + Mock metricsSet1; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams0 = {}; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams1 = {}; metricsSetParams0.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams1.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; @@ -1864,8 +1864,8 @@ TEST_F(MetricEnumerationTest, givenValidMetricGroupWhenDeactivateIsDoneThenDomai metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -1885,8 +1885,8 @@ TEST_F(MetricEnumerationTest, givenValidMetricGroupWhenDeactivateIsDoneThenDomai ioMeasurement.GetParamsResult = &oaInformation; // Metrics Discovery: metric set - Mock metricsSet0; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams0 = {}; + Mock metricsSet0; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams0 = {}; metricsSetParams0.ApiMask = MetricsDiscovery::API_TYPE_OCL; zet_metric_group_handle_t metricGroupHandle[2] = {}; @@ -1919,8 +1919,8 @@ TEST_F(MetricEnumerationTest, GivenAlreadyActivatedMetricGroupWhenzetContextActi metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 2; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -1938,8 +1938,8 @@ TEST_F(MetricEnumerationTest, GivenAlreadyActivatedMetricGroupWhenzetContextActi oaInformation.IoReadEquation = &ioReadEquation; // Metrics Discovery: metric set - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; // One api: metric group. @@ -2001,8 +2001,8 @@ TEST_F(MetricEnumerationTest, givenInvalidArgumentsWhenZetMetricGroupCalculateMe metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -2022,8 +2022,8 @@ TEST_F(MetricEnumerationTest, givenInvalidArgumentsWhenZetMetricGroupCalculateMe ioMeasurement.GetParamsResult = &oaInformation; // Metrics Discovery: metric set - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; // One api: metric group. @@ -2053,8 +2053,8 @@ TEST_F(MetricEnumerationTest, givenIncorrectRawReportSizeWhenZetMetricGroupCalcu metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -2074,8 +2074,8 @@ TEST_F(MetricEnumerationTest, givenIncorrectRawReportSizeWhenZetMetricGroupCalcu ioMeasurement.GetParamsResult = &oaInformation; // Metrics Discovery: metric set - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.QueryReportSize = 256; @@ -2120,8 +2120,8 @@ TEST_F(MetricEnumerationTest, givenIncorrectRawReportSizeWhenZetMetricGroupCalcu metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -2141,8 +2141,8 @@ TEST_F(MetricEnumerationTest, givenIncorrectRawReportSizeWhenZetMetricGroupCalcu ioMeasurement.GetParamsResult = &oaInformation; // Metrics Discovery: metric set - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.QueryReportSize = 0; @@ -2189,8 +2189,8 @@ TEST_F(MetricEnumerationTest, givenCorrectRawReportSizeWhenZetMetricGroupCalcula metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -2209,14 +2209,14 @@ TEST_F(MetricEnumerationTest, givenCorrectRawReportSizeWhenZetMetricGroupCalcula metricsConcurrentGroup.GetIoMeasurementInformationResult = &ioMeasurement; ioMeasurement.GetParamsResult = &oaInformation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.QueryReportSize = 256; metricsSetParams.MetricsCount = 11; - Mock metric; - MetricsDiscovery::TMetricParams_1_0 metricParams = {}; + Mock metric; + MetricsDiscovery::TMetricParams_1_13 metricParams = {}; zet_metric_group_handle_t metricGroupHandle = {}; @@ -2265,8 +2265,8 @@ TEST_F(MetricEnumerationTest, givenFailedCalculateMetricsWhenZetMetricGroupCalcu metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -2285,14 +2285,14 @@ TEST_F(MetricEnumerationTest, givenFailedCalculateMetricsWhenZetMetricGroupCalcu metricsConcurrentGroup.GetIoMeasurementInformationResult = &ioMeasurement; ioMeasurement.GetParamsResult = &oaInformation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.QueryReportSize = 256; metricsSetParams.MetricsCount = 11; - Mock metric; - MetricsDiscovery::TMetricParams_1_0 metricParams = {}; + Mock metric; + MetricsDiscovery::TMetricParams_1_13 metricParams = {}; zet_metric_group_handle_t metricGroupHandle = {}; @@ -2339,8 +2339,8 @@ TEST_F(MetricEnumerationTest, givenInvalidQueryReportSizeWhenZetMetricGroupCalcu metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -2359,14 +2359,14 @@ TEST_F(MetricEnumerationTest, givenInvalidQueryReportSizeWhenZetMetricGroupCalcu metricsConcurrentGroup.GetIoMeasurementInformationResult = &ioMeasurement; ioMeasurement.GetParamsResult = &oaInformation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.QueryReportSize = 0; metricsSetParams.MetricsCount = 11; - Mock metric; - MetricsDiscovery::TMetricParams_1_0 metricParams = {}; + Mock metric; + MetricsDiscovery::TMetricParams_1_13 metricParams = {}; zet_metric_group_handle_t metricGroupHandle = {}; @@ -2417,8 +2417,8 @@ TEST_F(MetricEnumerationTest, givenCorrectRawDataHeaderWhenZetMetricGroupCalcula metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -2437,14 +2437,14 @@ TEST_F(MetricEnumerationTest, givenCorrectRawDataHeaderWhenZetMetricGroupCalcula metricsConcurrentGroup.GetIoMeasurementInformationResult = &ioMeasurement; ioMeasurement.GetParamsResult = &oaInformation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.QueryReportSize = 256; metricsSetParams.MetricsCount = 11; - Mock metric; - MetricsDiscovery::TMetricParams_1_0 metricParams = {}; + Mock metric; + MetricsDiscovery::TMetricParams_1_13 metricParams = {}; zet_metric_group_handle_t metricGroupHandle = {}; @@ -2507,8 +2507,8 @@ TEST_F(MetricEnumerationTest, givenCorrectRawReportSizeWhenZetMetricGroupCalcula metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -2526,15 +2526,15 @@ TEST_F(MetricEnumerationTest, givenCorrectRawReportSizeWhenZetMetricGroupCalcula oaInformation.IoReadEquation = &ioReadEquation; // Metrics Discovery: metric set - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.QueryReportSize = 256; metricsSetParams.MetricsCount = 11; // Metrics Discovery: metric - Mock metric; - MetricsDiscovery::TMetricParams_1_0 metricParams = {}; + Mock metric; + MetricsDiscovery::TMetricParams_1_13 metricParams = {}; // One api: metric group. zet_metric_group_handle_t metricGroupHandle = {}; @@ -2588,8 +2588,8 @@ TEST_F(MetricEnumerationTest, givenCorrectRawReportSizeAndLowerProvidedCalculate metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -2609,15 +2609,15 @@ TEST_F(MetricEnumerationTest, givenCorrectRawReportSizeAndLowerProvidedCalculate ioMeasurement.GetParamsResult = &oaInformation; // Metrics Discovery: metric set - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.QueryReportSize = 256; metricsSetParams.MetricsCount = 11; // Metrics Discovery: metric - Mock metric; - MetricsDiscovery::TMetricParams_1_0 metricParams = {}; + Mock metric; + MetricsDiscovery::TMetricParams_1_13 metricParams = {}; // One api: metric group. zet_metric_group_handle_t metricGroupHandle = {}; @@ -2664,8 +2664,8 @@ TEST_F(MetricEnumerationTest, givenCorrectRawReportSizeAndCorrectCalculatedRepor metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -2685,15 +2685,15 @@ TEST_F(MetricEnumerationTest, givenCorrectRawReportSizeAndCorrectCalculatedRepor ioMeasurement.GetParamsResult = &oaInformation; // Metrics Discovery: metric set - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.QueryReportSize = 256; metricsSetParams.MetricsCount = 11; // Metrics Discovery: metric - Mock metric; - MetricsDiscovery::TMetricParams_1_0 metricParams = {}; + Mock metric; + MetricsDiscovery::TMetricParams_1_13 metricParams = {}; // One api: metric group. zet_metric_group_handle_t metricGroupHandle = {}; @@ -2737,8 +2737,8 @@ TEST_F(MetricEnumerationTest, givenCorrectRawReportSizeAndCorrectCalculatedRepor metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -2758,15 +2758,15 @@ TEST_F(MetricEnumerationTest, givenCorrectRawReportSizeAndCorrectCalculatedRepor ioMeasurement.GetParamsResult = &oaInformation; // Metrics Discovery: metric set - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.QueryReportSize = 256; metricsSetParams.MetricsCount = 11; // Metrics Discovery: metric - Mock metric; - MetricsDiscovery::TMetricParams_1_0 metricParams = {}; + Mock metric; + MetricsDiscovery::TMetricParams_1_13 metricParams = {}; // One api: metric group. zet_metric_group_handle_t metricGroupHandle = {}; @@ -2811,8 +2811,8 @@ TEST_F(MetricEnumerationTest, givenIncorrectCalculationTypeWhenZetMetricGroupCal metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -2830,15 +2830,15 @@ TEST_F(MetricEnumerationTest, givenIncorrectCalculationTypeWhenZetMetricGroupCal oaInformation.IoReadEquation = &ioReadEquation; // Metrics Discovery: metric set - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.QueryReportSize = 256; metricsSetParams.MetricsCount = 11; // Metrics Discovery: metric - Mock metric; - MetricsDiscovery::TMetricParams_1_0 metricParams = {}; + Mock metric; + MetricsDiscovery::TMetricParams_1_13 metricParams = {}; // One api: metric group. zet_metric_group_handle_t metricGroupHandle = {}; @@ -2887,8 +2887,8 @@ TEST_F(MetricEnumerationTest, givenNotInitializedMetricEnumerationWhenIsInitiali metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -2906,15 +2906,15 @@ TEST_F(MetricEnumerationTest, givenNotInitializedMetricEnumerationWhenIsInitiali oaInformation.IoReadEquation = &ioReadEquation; // Metrics Discovery: metric set - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.QueryReportSize = 256; metricsSetParams.MetricsCount = 11; // Metrics Discovery: metric - Mock metric; - MetricsDiscovery::TMetricParams_1_0 metricParams = {}; + Mock metric; + MetricsDiscovery::TMetricParams_1_13 metricParams = {}; openMetricsAdapter(); @@ -2958,9 +2958,9 @@ TEST_F(MetricEnumerationTest, givenNotLoadedMetricsLibraryAndDiscoveryWhenLoadDe TEST_F(MetricEnumerationTest, givenRootDeviceWhenLoadDependenciesIsCalledThenLegacyOpenMetricsDeviceWillBeCalled) { auto &metricSource = device->getMetricDeviceContext().getMetricSource(); - Mock mockAdapterGroup; - Mock mockAdapter; - Mock mockDevice; + Mock mockAdapterGroup; + Mock mockAdapter; + Mock mockDevice; mockMetricEnumeration->globalMockApi->adapterGroup = reinterpret_cast(&mockAdapterGroup); mockMetricEnumeration->getMetricsAdapterResult = &mockAdapter; @@ -2996,8 +2996,8 @@ TEST_P(MetricEnumerationTestMetricTypes, givenValidMetricTypesWhenSetAndGetIsSam metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -3016,8 +3016,8 @@ TEST_P(MetricEnumerationTestMetricTypes, givenValidMetricTypesWhenSetAndGetIsSam oaInformation.IoReadEquation = &ioReadEquation; // Metrics Discovery:: metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -3025,8 +3025,8 @@ TEST_P(MetricEnumerationTestMetricTypes, givenValidMetricTypesWhenSetAndGetIsSam metricsSetParams.MetricsCount = 1; // Metrics Discovery:: metric. - Mock metric; - TMetricParams_1_0 metricParams = {}; + Mock metric; + TMetricParams_1_13 metricParams = {}; metricParams.SymbolName = "Metric symbol name"; metricParams.ShortName = "Metric short name"; metricParams.LongName = "Metric long name"; @@ -3117,8 +3117,8 @@ TEST_P(MetricEnumerationTestInformationTypes, givenValidInformationTypesWhenSetA metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -3139,8 +3139,8 @@ TEST_P(MetricEnumerationTestInformationTypes, givenValidInformationTypesWhenSetA ioMeasurement.GetParamsResult = &oaInformation; // Metrics Discovery:: metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.InformationCount = 1; @@ -3218,7 +3218,7 @@ INSTANTIATE_TEST_SUITE_P(parameterizedMetricEnumerationTestInformationTypes, TEST_F(MetricEnumerationTest, givenMetricSetWhenActivateIsCalledActivateReturnsTrue) { - Mock metricsSet; + Mock metricsSet; MockMetricSource mockMetricSource{}; MetricGroupImpTest metricGroup(mockMetricSource); @@ -3229,7 +3229,7 @@ TEST_F(MetricEnumerationTest, givenMetricSetWhenActivateIsCalledActivateReturnsT TEST_F(MetricEnumerationTest, givenMetricSetWhenActivateIsCalledActivateReturnsFalse) { - Mock metricsSet; + Mock metricsSet; MockMetricSource mockMetricSource{}; MetricGroupImpTest metricGroup(mockMetricSource); @@ -3241,7 +3241,7 @@ TEST_F(MetricEnumerationTest, givenMetricSetWhenActivateIsCalledActivateReturnsF TEST_F(MetricEnumerationTest, givenMetricSetWhenDeactivateIsCalledDeactivateReturnsTrue) { - Mock metricsSet; + Mock metricsSet; MockMetricSource mockMetricSource{}; MetricGroupImpTest metricGroup(mockMetricSource); @@ -3252,7 +3252,7 @@ TEST_F(MetricEnumerationTest, givenMetricSetWhenDeactivateIsCalledDeactivateRetu TEST_F(MetricEnumerationTest, givenMetricSetWhenDeactivateIsCalledDeactivateReturnsFalse) { - Mock metricsSet; + Mock metricsSet; MockMetricSource mockMetricSource{}; MetricGroupImpTest metricGroup(mockMetricSource); @@ -3264,7 +3264,7 @@ TEST_F(MetricEnumerationTest, givenMetricSetWhenDeactivateIsCalledDeactivateRetu TEST_F(MetricEnumerationTest, givenMetricSetWhenWaitForReportsIsCalledWaitForReportsReturnsSuccess) { - Mock concurrentGroup; + Mock concurrentGroup; MockMetricSource mockMetricSource{}; MetricGroupImpTest metricGroup(mockMetricSource); @@ -3276,7 +3276,7 @@ TEST_F(MetricEnumerationTest, givenMetricSetWhenWaitForReportsIsCalledWaitForRep TEST_F(MetricEnumerationTest, givenMetricSetWhenWaitForReportsIsCalledWaitForReportsReturnsNotReady) { - Mock concurrentGroup; + Mock concurrentGroup; MockMetricSource mockMetricSource{}; MetricGroupImpTest metricGroup(mockMetricSource); @@ -3293,8 +3293,8 @@ TEST_F(MetricEnumerationTest, givenValidArgumentsWhenZetGetMetricGroupProperties metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -3315,8 +3315,8 @@ TEST_F(MetricEnumerationTest, givenValidArgumentsWhenZetGetMetricGroupProperties ioMeasurement.GetParamsResult = &oaInformation; // Metrics Discovery:: metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_2.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_2.cpp index c1ec060e59..382f688075 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_2.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_2.cpp @@ -20,7 +20,7 @@ using MetricEnumerationTest = Test; TEST_F(MetricEnumerationTest, givenTimeAndBufferSizeWhenOpenIoStreamReturnsErrorThenTheMetricGroupOpenIoStreamReturnsErrorUnknown) { - Mock concurrentGroup; + Mock concurrentGroup; MockMetricSource mockSource{}; MetricGroupImpTest metricGroup(mockSource); @@ -35,7 +35,7 @@ TEST_F(MetricEnumerationTest, givenTimeAndBufferSizeWhenOpenIoStreamReturnsError TEST_F(MetricEnumerationTest, givenReportCountAndReportDataWhenReadIoStreamReturnsErrorThenMetrigGroupReadIoStreamReturnsError) { - Mock concurrentGroup; + Mock concurrentGroup; MockMetricSource mockSource{}; MetricGroupImpTest metricGroup(mockSource); @@ -50,7 +50,7 @@ TEST_F(MetricEnumerationTest, givenReportCountAndReportDataWhenReadIoStreamRetur TEST_F(MetricEnumerationTest, givenTimeAndBufferSizeWhenCloseIoStreamIsCalledCloseAndFailThenIoStreamReturnsErrorUnknown) { - Mock concurrentGroup; + Mock concurrentGroup; MockMetricSource mockSource{}; MetricGroupImpTest metricGroup(mockSource); @@ -110,9 +110,9 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesIsCa // Use first root device. auto &metricSource = devices[0]->getMetricDeviceContext().getMetricSource(); - Mock mockAdapterGroup; - Mock mockAdapter; - Mock mockDevice; + Mock mockAdapterGroup; + Mock mockAdapter; + Mock mockDevice; mockMetricEnumeration->globalMockApi->adapterGroup = reinterpret_cast(&mockAdapterGroup); mockMetricEnumeration->getMetricsAdapterResult = &mockAdapter; @@ -139,9 +139,9 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenSubDeviceWhenOpenMetricsDiscoveryI auto &deviceImp = *static_cast(devices[0]); const uint32_t subDeviceCount = static_cast(deviceImp.subDevices.size()); ASSERT_GE(subDeviceCount, 2u); - Mock mockAdapterGroup; - Mock mockAdapter; - Mock mockDevice; + Mock mockAdapterGroup; + Mock mockAdapter; + Mock mockDevice; mockMetricEnumeration->globalMockApi->adapterGroup = reinterpret_cast(&mockAdapterGroup); @@ -161,9 +161,9 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenSubDeviceWhenOpenMetricsDiscoveryI auto &deviceImp = *static_cast(devices[0]); const uint32_t subDeviceCount = static_cast(deviceImp.subDevices.size()); ASSERT_GE(subDeviceCount, 2u); - Mock mockAdapterGroup; - Mock mockAdapter; - Mock mockDevice; + Mock mockAdapterGroup; + Mock mockAdapter; + Mock mockDevice; mockMetricEnumeration->globalMockApi->adapterGroup = reinterpret_cast(&mockAdapterGroup); mockMetricEnumerationSubDevices[1]->getMetricsAdapterResult = &mockAdapter; @@ -180,9 +180,9 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesIsCa // Use first root device. auto &metricSource = devices[0]->getMetricDeviceContext().getMetricSource(); - Mock mockAdapterGroup; - Mock mockAdapter; - Mock mockDevice; + Mock mockAdapterGroup; + Mock mockAdapter; + Mock mockDevice; mockMetricEnumeration->globalMockApi->adapterGroup = reinterpret_cast(&mockAdapterGroup); mockMetricEnumeration->getMetricsAdapterResult = &mockAdapter; @@ -204,9 +204,9 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesAndO // Use first root device. auto &metricSource = devices[0]->getMetricDeviceContext().getMetricSource(); - Mock mockAdapterGroup; - Mock mockAdapter; - Mock mockDevice; + Mock mockAdapterGroup; + Mock mockAdapter; + Mock mockDevice; mockMetricEnumeration->globalMockApi->adapterGroup = reinterpret_cast(&mockAdapterGroup); @@ -245,8 +245,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenValidArgumentsWhenZetMetricGetProp metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -265,8 +265,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenValidArgumentsWhenZetMetricGetProp oaInformation.IoReadEquation = &ioReadEquation; // Metrics Discovery:: metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -274,8 +274,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenValidArgumentsWhenZetMetricGetProp metricsSetParams.MetricsCount = 1; // Metrics Discovery:: metric. - Mock metric; - TMetricParams_1_0 metricParams = {}; + Mock metric; + TMetricParams_1_13 metricParams = {}; metricParams.SymbolName = "Metric symbol name"; metricParams.ShortName = "Metric short name"; metricParams.LongName = "Metric long name"; @@ -344,8 +344,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceIsEnumeratedAfterSubDevi auto &deviceImp = *static_cast(devices[0]); metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -363,16 +363,16 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceIsEnumeratedAfterSubDevi oaInformation.SymbolName = "BufferOverflow"; oaInformation.IoReadEquation = &ioReadEquation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; metricsSetParams.ShortName = "Metric set description"; metricsSetParams.MetricsCount = 1; - Mock metric; - TMetricParams_1_0 metricParams = {}; + Mock metric; + TMetricParams_1_13 metricParams = {}; metricParams.SymbolName = "Metric symbol name"; metricParams.ShortName = "Metric short name"; metricParams.LongName = "Metric long name"; @@ -412,8 +412,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenCorrectRawDataHeaderWhenZetMetricG metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -430,14 +430,14 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenCorrectRawDataHeaderWhenZetMetricG oaInformation.SymbolName = "BufferOverflow"; oaInformation.IoReadEquation = &ioReadEquation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.QueryReportSize = 256; metricsSetParams.MetricsCount = 11; - Mock metric; - MetricsDiscovery::TMetricParams_1_0 metricParams = {}; + Mock metric; + MetricsDiscovery::TMetricParams_1_13 metricParams = {}; zet_metric_group_handle_t metricGroupHandle = {}; @@ -507,8 +507,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenInvalidDataCountAndTotalMetricCoun metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -527,14 +527,14 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenInvalidDataCountAndTotalMetricCoun metricsConcurrentGroup.GetIoMeasurementInformationResult = &ioMeasurement; ioMeasurement.GetParamsResult = &oaInformation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.QueryReportSize = 256; metricsSetParams.MetricsCount = 11; - Mock metric; - MetricsDiscovery::TMetricParams_1_0 metricParams = {}; + Mock metric; + MetricsDiscovery::TMetricParams_1_13 metricParams = {}; zet_metric_group_handle_t metricGroupHandle = {}; @@ -600,8 +600,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenInvalidQueryReportSizeWhenZetMetri metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -620,14 +620,14 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenInvalidQueryReportSizeWhenZetMetri metricsConcurrentGroup.GetIoMeasurementInformationResult = &ioMeasurement; ioMeasurement.GetParamsResult = &oaInformation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.QueryReportSize = 0; metricsSetParams.MetricsCount = 11; - Mock metric; - MetricsDiscovery::TMetricParams_1_0 metricParams = {}; + Mock metric; + MetricsDiscovery::TMetricParams_1_13 metricParams = {}; zet_metric_group_handle_t metricGroupHandle = {}; @@ -685,8 +685,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenErrorGeneralOnCalculateMetricsWhen metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -705,14 +705,14 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenErrorGeneralOnCalculateMetricsWhen metricsConcurrentGroup.GetIoMeasurementInformationResult = &ioMeasurement; ioMeasurement.GetParamsResult = &oaInformation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.QueryReportSize = 256; metricsSetParams.MetricsCount = 11; - Mock metric; - MetricsDiscovery::TMetricParams_1_0 metricParams = {}; + Mock metric; + MetricsDiscovery::TMetricParams_1_13 metricParams = {}; zet_metric_group_handle_t metricGroupHandle = {}; @@ -778,8 +778,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenCorrectRawDataHeaderWhenZetMetricG metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -798,14 +798,14 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenCorrectRawDataHeaderWhenZetMetricG metricsConcurrentGroup.GetIoMeasurementInformationResult = &ioMeasurement; ioMeasurement.GetParamsResult = &oaInformation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.QueryReportSize = 256; metricsSetParams.MetricsCount = 11; - Mock metric; - MetricsDiscovery::TMetricParams_1_0 metricParams = {}; + Mock metric; + MetricsDiscovery::TMetricParams_1_13 metricParams = {}; zet_metric_group_handle_t metricGroupHandle = {}; @@ -861,8 +861,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenCorrectRawDataHeaderWhenFirstSubDe metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -881,14 +881,14 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenCorrectRawDataHeaderWhenFirstSubDe metricsConcurrentGroup.GetIoMeasurementInformationResult = &ioMeasurement; ioMeasurement.GetParamsResult = &oaInformation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.RawReportSize = 256; metricsSetParams.MetricsCount = 11; - Mock metric; - MetricsDiscovery::TMetricParams_1_0 metricParams = {}; + Mock metric; + MetricsDiscovery::TMetricParams_1_13 metricParams = {}; zet_metric_group_handle_t metricGroupHandle = {}; @@ -957,8 +957,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenCorrectRawDataHeaderWhenSecondSubD metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -977,14 +977,14 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenCorrectRawDataHeaderWhenSecondSubD metricsConcurrentGroup.GetIoMeasurementInformationResult = &ioMeasurement; ioMeasurement.GetParamsResult = &oaInformation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.RawReportSize = 256; metricsSetParams.MetricsCount = 11; - Mock metric; - MetricsDiscovery::TMetricParams_1_0 metricParams = {}; + Mock metric; + MetricsDiscovery::TMetricParams_1_13 metricParams = {}; zet_metric_group_handle_t metricGroupHandle = {}; @@ -1053,8 +1053,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenCorrectRawDataHeaderWhenBothSubDev metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -1073,14 +1073,14 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenCorrectRawDataHeaderWhenBothSubDev metricsConcurrentGroup.GetIoMeasurementInformationResult = &ioMeasurement; ioMeasurement.GetParamsResult = &oaInformation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.RawReportSize = 256; metricsSetParams.MetricsCount = 11; - Mock metric; - MetricsDiscovery::TMetricParams_1_0 metricParams = {}; + Mock metric; + MetricsDiscovery::TMetricParams_1_13 metricParams = {}; zet_metric_group_handle_t metricGroupHandle = {}; @@ -1139,8 +1139,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenCorrectRawDataHeaderWhenBothSubDev metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -1159,14 +1159,14 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenCorrectRawDataHeaderWhenBothSubDev metricsConcurrentGroup.GetIoMeasurementInformationResult = &ioMeasurement; ioMeasurement.GetParamsResult = &oaInformation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.RawReportSize = 256; metricsSetParams.MetricsCount = 11; - Mock metric; - MetricsDiscovery::TMetricParams_1_0 metricParams = {}; + Mock metric; + MetricsDiscovery::TMetricParams_1_13 metricParams = {}; zet_metric_group_handle_t metricGroupHandle = {}; @@ -1234,8 +1234,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenCorrectRawDataHeaderWhenBothSubDev metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -1254,14 +1254,14 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenCorrectRawDataHeaderWhenBothSubDev metricsConcurrentGroup.GetIoMeasurementInformationResult = &ioMeasurement; ioMeasurement.GetParamsResult = &oaInformation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.RawReportSize = 256; metricsSetParams.MetricsCount = 11; - Mock metric; - MetricsDiscovery::TMetricParams_1_0 metricParams = {}; + Mock metric; + MetricsDiscovery::TMetricParams_1_13 metricParams = {}; zet_metric_group_handle_t metricGroupHandle = {}; @@ -1329,8 +1329,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenOaMetricSourceWhenGetConcurrentMet metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -1347,14 +1347,14 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenOaMetricSourceWhenGetConcurrentMet oaInformation.SymbolName = "BufferOverflow"; oaInformation.IoReadEquation = &ioReadEquation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.RawReportSize = 256; metricsSetParams.MetricsCount = 11; - Mock metric; - MetricsDiscovery::TMetricParams_1_0 metricParams = {}; + Mock metric; + MetricsDiscovery::TMetricParams_1_13 metricParams = {}; zet_metric_group_handle_t metricGroupHandle = {}; diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_export.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_export.cpp index fdff10f012..61785d86cf 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_export.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_export.cpp @@ -54,7 +54,7 @@ class MetricExportDataOaTest : public Test { metricsDeviceParams.GlobalSymbolsCount = globalSymbolsCount; metricsDeviceParams.Version.BuildNumber = 20; metricsDeviceParams.Version.MajorNumber = 1; - metricsDeviceParams.Version.MinorNumber = 10; + metricsDeviceParams.Version.MinorNumber = 13; } void setupConcurrentGroupParams(TConcurrentGroupParams_1_0 &metricsConcurrentGroupParams) { @@ -147,7 +147,7 @@ class MetricExportDataOaTest : public Test { EXPECT_EQ(readUnaligned(&oaData->deviceParams.globalSymbolsCount), globalSymbolsCount); EXPECT_EQ(readUnaligned(&oaData->deviceParams.version.buildNumber), 20u); EXPECT_EQ(readUnaligned(&oaData->deviceParams.version.majorNumber), 1u); - EXPECT_EQ(readUnaligned(&oaData->deviceParams.version.minorNumber), 10u); + EXPECT_EQ(readUnaligned(&oaData->deviceParams.version.minorNumber), 13u); } void validateGlobalSymbols(zet_intel_metric_df_gpu_export_data_format_t *data) { @@ -207,7 +207,7 @@ class MetricExportDataOaTest : public Test { auto oaData = &data->format01.oaData; // Validate Metric Set Parameters EXPECT_EQ(readUnaligned(&oaData->metricSet.params.apiMask), 50u); - EXPECT_EQ(readUnaligned(&oaData->metricSet.params.availabilityEquation), ZET_INTEL_GPU_METRIC_INVALID_OFFSET); + EXPECT_EQ(readUnaligned(&oaData->metricSet.params.availabilityEquation), 1064u); EXPECT_EQ(readUnaligned(&oaData->metricSet.params.informationCount), 1u); EXPECT_EQ(readUnaligned(&oaData->metricSet.params.metricsCount), 1u); auto shortNamePtr = zet_intel_metric_df_gpu_offset_to_ptr(cstring_offset_t, oaData->metricSet.params.shortName, data); @@ -448,9 +448,9 @@ class MetricExportDataOaTest : public Test { uint8_t byteArrayData[5] = {10, 20, 30, 40, 50}; MetricsDiscovery::TByteArray_1_0 valueByteArray; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; - Mock metricsSet; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; + Mock metricsSet; MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; TAdapterParams_1_9 adapterParams{}; TGlobalSymbol_1_0 globalSymbol{}; @@ -458,8 +458,8 @@ class MetricExportDataOaTest : public Test { MetricsDiscovery::TDeltaFunction_1_0 deltaFunction{}; Mock information{}; MetricsDiscovery::TInformationParams_1_0 informationParams{}; - TMetricParams_1_0 metricParams = {}; - Mock metric; + TMetricParams_1_13 metricParams = {}; + Mock metric; }; TEST_F(MetricExportDataOaTest, givenValidArgumentsWhenMetricGroupGetExportDataIsCalledThenReturnSuccess) { @@ -972,6 +972,24 @@ TEST_F(MetricExportDataOaTest, givenUnSupportedVersionWhenMetricGroupGetExportDa auto base = reinterpret_cast(exportData.data()); auto oaData = &base->format01.oaData; EXPECT_EQ(oaData->metricSet.params.availabilityEquation, ZET_INTEL_GPU_METRIC_INVALID_OFFSET); + + metricsDeviceParams.Version.MajorNumber = 1; + metricsDeviceParams.Version.MinorNumber = 10; + + dummyRawData = 0; + exportDataSize = 0; + + EXPECT_EQ(zetMetricGroupGetExportDataExp(metricGroupHandle, + &dummyRawData, dummyRawDataSize, &exportDataSize, nullptr), + ZE_RESULT_SUCCESS); + EXPECT_GT(exportDataSize, 0u); + exportData.resize(exportDataSize); + EXPECT_EQ(zetMetricGroupGetExportDataExp(metricGroupHandle, + &dummyRawData, dummyRawDataSize, &exportDataSize, exportData.data()), + ZE_RESULT_SUCCESS); + base = reinterpret_cast(exportData.data()); + oaData = &base->format01.oaData; + EXPECT_EQ(oaData->metricSet.params.availabilityEquation, ZET_INTEL_GPU_METRIC_INVALID_OFFSET); } TEST_F(MetricExportDataOaTest, givenIncorrectExportSizeIsPassedWhenMetricGroupGetExportDataIsCalledThenErrorIsReturned) { diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_2.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_2.cpp index 681f1195dc..dc725f432d 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_2.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_2.cpp @@ -38,8 +38,8 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenStreamerIsOpenThenQueryPool metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -57,8 +57,8 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenStreamerIsOpenThenQueryPool oaInformation.SymbolName = "BufferOverflow"; oaInformation.IoReadEquation = &ioReadEquation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -482,8 +482,8 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenActivateMetricGroupsIsCalle metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -501,16 +501,16 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenActivateMetricGroupsIsCalle oaInformation.SymbolName = "BufferOverflow"; oaInformation.IoReadEquation = &ioReadEquation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; metricsSetParams.ShortName = "Metric set description"; metricsSetParams.MetricsCount = 1; - Mock metric; - TMetricParams_1_0 metricParams = {}; + Mock metric; + TMetricParams_1_13 metricParams = {}; metricParams.SymbolName = "Metric symbol name"; metricParams.ShortName = "Metric short name"; metricParams.LongName = "Metric long name"; diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_3.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_3.cpp index 9d85957515..f0f67b9d58 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_3.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_3.cpp @@ -81,8 +81,8 @@ TEST_F(MetricQueryPoolTest, givenMetricQueryIsActiveWhenMetricGroupDeactivateIsC metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -100,16 +100,16 @@ TEST_F(MetricQueryPoolTest, givenMetricQueryIsActiveWhenMetricGroupDeactivateIsC oaInformation.SymbolName = "BufferOverflow"; oaInformation.IoReadEquation = &ioReadEquation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; metricsSetParams.ShortName = "Metric set description"; metricsSetParams.MetricsCount = 1; - Mock metric; - TMetricParams_1_0 metricParams = {}; + Mock metric; + TMetricParams_1_13 metricParams = {}; metricParams.SymbolName = "Metric symbol name"; metricParams.ShortName = "Metric short name"; metricParams.LongName = "Metric long name"; @@ -189,8 +189,8 @@ TEST_F(MetricQueryPoolTest, givenMetricGroupIsActiveWhenQueryPoolDestroyIsCalled metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -208,16 +208,16 @@ TEST_F(MetricQueryPoolTest, givenMetricGroupIsActiveWhenQueryPoolDestroyIsCalled oaInformation.SymbolName = "BufferOverflow"; oaInformation.IoReadEquation = &ioReadEquation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; metricsSetParams.ShortName = "Metric set description"; metricsSetParams.MetricsCount = 1; - Mock metric; - TMetricParams_1_0 metricParams = {}; + Mock metric; + TMetricParams_1_13 metricParams = {}; metricParams.SymbolName = "Metric symbol name"; metricParams.ShortName = "Metric short name"; metricParams.LongName = "Metric long name"; @@ -360,8 +360,8 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenCorrectArgumentsWhenZetMetricQueryPo metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -381,16 +381,16 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenCorrectArgumentsWhenZetMetricQueryPo metricsConcurrentGroup.GetIoMeasurementInformationResult = &ioMeasurement; ioMeasurement.GetParamsResult = &oaInformation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; metricsSetParams.ShortName = "Metric set description"; metricsSetParams.MetricsCount = 1; - Mock metric; - TMetricParams_1_0 metricParams = {}; + Mock metric; + TMetricParams_1_13 metricParams = {}; metricParams.SymbolName = "Metric symbol name"; metricParams.ShortName = "Metric short name"; metricParams.LongName = "Metric long name"; @@ -467,8 +467,8 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenImplicitScalingIsEnabledWhenMetricsA metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -488,16 +488,16 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenImplicitScalingIsEnabledWhenMetricsA metricsConcurrentGroup.GetIoMeasurementInformationResult = &ioMeasurement; ioMeasurement.GetParamsResult = &oaInformation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; metricsSetParams.ShortName = "Metric set description"; metricsSetParams.MetricsCount = 1; - Mock metric; - TMetricParams_1_0 metricParams = {}; + Mock metric; + TMetricParams_1_13 metricParams = {}; metricParams.SymbolName = "Metric symbol name"; metricParams.ShortName = "Metric short name"; metricParams.LongName = "Metric long name"; @@ -568,8 +568,8 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenEnableWalkerPartitionIsOnWhenZetComm metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -587,16 +587,16 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenEnableWalkerPartitionIsOnWhenZetComm oaInformation.SymbolName = "BufferOverflow"; oaInformation.IoReadEquation = &ioReadEquation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; metricsSetParams.ShortName = "Metric set description"; metricsSetParams.MetricsCount = 1; - Mock metric; - TMetricParams_1_0 metricParams = {}; + Mock metric; + TMetricParams_1_13 metricParams = {}; metricParams.SymbolName = "Metric symbol name"; metricParams.ShortName = "Metric short name"; metricParams.LongName = "Metric long name"; @@ -697,8 +697,8 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenFailedMetricsLibraryContextWhenZetMe metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -718,16 +718,16 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenFailedMetricsLibraryContextWhenZetMe metricsConcurrentGroup.GetIoMeasurementInformationResult = &ioMeasurement; ioMeasurement.GetParamsResult = &oaInformation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; metricsSetParams.ShortName = "Metric set description"; metricsSetParams.MetricsCount = 1; - Mock metric; - TMetricParams_1_0 metricParams = {}; + Mock metric; + TMetricParams_1_13 metricParams = {}; metricParams.SymbolName = "Metric symbol name"; metricParams.ShortName = "Metric short name"; metricParams.LongName = "Metric long name"; diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_4.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_4.cpp index dd6a3d003b..f329a506c0 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_4.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_4.cpp @@ -24,8 +24,8 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenFailedGetDataWhenZetMetricQueryGetDa metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -43,16 +43,16 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenFailedGetDataWhenZetMetricQueryGetDa oaInformation.SymbolName = "BufferOverflow"; oaInformation.IoReadEquation = &ioReadEquation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; metricsSetParams.ShortName = "Metric set description"; metricsSetParams.MetricsCount = 1; - Mock metric; - TMetricParams_1_0 metricParams = {}; + Mock metric; + TMetricParams_1_13 metricParams = {}; metricParams.SymbolName = "Metric symbol name"; metricParams.ShortName = "Metric short name"; metricParams.LongName = "Metric long name"; @@ -156,8 +156,8 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenCorrectArgumentsWhenZetCommandListAp metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -177,16 +177,16 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenCorrectArgumentsWhenZetCommandListAp metricsConcurrentGroup.GetIoMeasurementInformationResult = &ioMeasurement; ioMeasurement.GetParamsResult = &oaInformation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; metricsSetParams.ShortName = "Metric set description"; metricsSetParams.MetricsCount = 1; - Mock metric; - TMetricParams_1_0 metricParams = {}; + Mock metric; + TMetricParams_1_13 metricParams = {}; metricParams.SymbolName = "Metric symbol name"; metricParams.ShortName = "Metric short name"; metricParams.LongName = "Metric long name"; @@ -304,8 +304,8 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenInvalidCommandBufferGetSizeWhenZetCo metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -323,16 +323,16 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenInvalidCommandBufferGetSizeWhenZetCo oaInformation.SymbolName = "BufferOverflow"; oaInformation.IoReadEquation = &ioReadEquation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; metricsSetParams.ShortName = "Metric set description"; metricsSetParams.MetricsCount = 1; - Mock metric; - TMetricParams_1_0 metricParams = {}; + Mock metric; + TMetricParams_1_13 metricParams = {}; metricParams.SymbolName = "Metric symbol name"; metricParams.ShortName = "Metric short name"; metricParams.LongName = "Metric long name"; @@ -418,8 +418,8 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenInvalidCommandBufferGetWhenZetComman metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -439,16 +439,16 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenInvalidCommandBufferGetWhenZetComman metricsConcurrentGroup.GetIoMeasurementInformationResult = &ioMeasurement; ioMeasurement.GetParamsResult = &oaInformation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; metricsSetParams.ShortName = "Metric set description"; metricsSetParams.MetricsCount = 1; - Mock metric; - TMetricParams_1_0 metricParams = {}; + Mock metric; + TMetricParams_1_13 metricParams = {}; metricParams.SymbolName = "Metric symbol name"; metricParams.ShortName = "Metric short name"; metricParams.LongName = "Metric long name"; diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_5.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_5.cpp index 0a5e712fc1..b4054ccc37 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_5.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_5.cpp @@ -34,8 +34,8 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenValidArgumentsWhenZetMetricGroupCalc metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -55,8 +55,8 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenValidArgumentsWhenZetMetricGroupCalc metricsConcurrentGroup.GetIoMeasurementInformationResult = &ioMeasurement; ioMeasurement.GetParamsResult = &oaInformation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -64,8 +64,8 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenValidArgumentsWhenZetMetricGroupCalc metricsSetParams.QueryReportSize = 256; metricsSetParams.MetricsCount = 1; - Mock metric; - TMetricParams_1_0 metricParams = {}; + Mock metric; + TMetricParams_1_13 metricParams = {}; metricParams.SymbolName = "Metric symbol name"; metricParams.ShortName = "Metric short name"; metricParams.LongName = "Metric long name"; @@ -176,8 +176,8 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenCorrectArgumentsWhenActivateMetricGr metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -195,16 +195,16 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenCorrectArgumentsWhenActivateMetricGr oaInformation.SymbolName = "BufferOverflow"; oaInformation.IoReadEquation = &ioReadEquation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; metricsSetParams.ShortName = "Metric set description"; metricsSetParams.MetricsCount = 1; - Mock metric; - TMetricParams_1_0 metricParams = {}; + Mock metric; + TMetricParams_1_13 metricParams = {}; metricParams.SymbolName = "Metric symbol name"; metricParams.ShortName = "Metric short name"; metricParams.LongName = "Metric long name"; @@ -271,8 +271,8 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenMetricQueryPoolIsDestroyedWhenMetric metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -292,16 +292,16 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenMetricQueryPoolIsDestroyedWhenMetric metricsConcurrentGroup.GetIoMeasurementInformationResult = &ioMeasurement; ioMeasurement.GetParamsResult = &oaInformation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; metricsSetParams.ShortName = "Metric set description"; metricsSetParams.MetricsCount = 1; - Mock metric; - TMetricParams_1_0 metricParams = {}; + Mock metric; + TMetricParams_1_13 metricParams = {}; metricParams.SymbolName = "Metric symbol name"; metricParams.ShortName = "Metric short name"; metricParams.LongName = "Metric long name"; diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_streamer_1.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_streamer_1.cpp index b6fea84267..5961f76205 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_streamer_1.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_streamer_1.cpp @@ -44,8 +44,8 @@ TEST_F(MetricStreamerTest, givenInvalidMetricGroupTypeWhenZetMetricStreamerOpenI metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; @@ -62,14 +62,14 @@ TEST_F(MetricStreamerTest, givenInvalidMetricGroupTypeWhenZetMetricStreamerOpenI oaInformation.SymbolName = "BufferOverflow"; oaInformation.IoReadEquation = &ioReadEquation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.QueryReportSize = 0; metricsSetParams.MetricsCount = 11; - Mock metric; - MetricsDiscovery::TMetricParams_1_0 metricParams = {}; + Mock metric; + MetricsDiscovery::TMetricParams_1_13 metricParams = {}; openMetricsAdapter(); @@ -112,8 +112,8 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetMetricStreamerOpenIsCalledT metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -131,8 +131,8 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetMetricStreamerOpenIsCalledT oaInformation.SymbolName = "BufferOverflow"; oaInformation.IoReadEquation = &ioReadEquation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -202,8 +202,8 @@ TEST_F(MetricStreamerTest, givenRawReportSizeAsZeroWhenZetMetricStreamerOpenIsCa metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -223,8 +223,8 @@ TEST_F(MetricStreamerTest, givenRawReportSizeAsZeroWhenZetMetricStreamerOpenIsCa metricsConcurrentGroup.GetIoMeasurementInformationResult = &ioMeasurement; ioMeasurement.GetParamsResult = &oaInformation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -291,8 +291,8 @@ TEST_F(MetricStreamerTest, givenValidArgumentsAndMetricGroupsIsNotActivatedWhenZ metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -310,8 +310,8 @@ TEST_F(MetricStreamerTest, givenValidArgumentsAndMetricGroupsIsNotActivatedWhenZ oaInformation.SymbolName = "BufferOverflow"; oaInformation.IoReadEquation = &ioReadEquation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -352,8 +352,8 @@ TEST_F(MetricStreamerTest, givenInValidOaInformationSymbolNameWhenZetMetricGroup metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -373,8 +373,8 @@ TEST_F(MetricStreamerTest, givenInValidOaInformationSymbolNameWhenZetMetricGroup ioMeasurement.GetParamsResult = &oaInformation; // Metrics Discovery metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -410,8 +410,8 @@ TEST_F(MetricStreamerTest, givenInValidInformationElementCountWhenZetMetricGroup metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -432,8 +432,8 @@ TEST_F(MetricStreamerTest, givenInValidInformationElementCountWhenZetMetricGroup ioMeasurement.GetParamsResult = &oaInformation; // Metrics Discovery metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -469,8 +469,8 @@ TEST_F(MetricStreamerTest, givenInValidInformationElementTypeWhenZetMetricGroupG metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -490,8 +490,8 @@ TEST_F(MetricStreamerTest, givenInValidInformationElementTypeWhenZetMetricGroupG ioMeasurement.GetParamsResult = &oaInformation; // Metrics Discovery metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -542,8 +542,8 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetMetricStreamerOpenIsCalledT metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -562,8 +562,8 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetMetricStreamerOpenIsCalledT oaInformation.IoReadEquation = &ioReadEquation; // Metrics Discovery metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -697,8 +697,8 @@ TEST_F(MetricStreamerTest, givenInvalidArgumentsWhenZetMetricStreamerReadDataIsC metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -719,8 +719,8 @@ TEST_F(MetricStreamerTest, givenInvalidArgumentsWhenZetMetricStreamerReadDataIsC ioMeasurement.GetParamsResult = &oaInformation; // Metrics Discovery metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -792,16 +792,16 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetMetricStreamerReadDataIsCal metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; // Metrics Discovery metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -898,8 +898,8 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetMetricStreamerReadDataIsCal metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -919,8 +919,8 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetMetricStreamerReadDataIsCal ioMeasurement.GetParamsResult = &oaInformation; // Metrics Discovery metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -992,15 +992,15 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetMetricStreamerReadDataIsCal zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle(); zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -1091,8 +1091,8 @@ TEST_F(MetricStreamerTest, givenInvalidArgumentsWhenZetCommandListAppendMetricSt metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -1113,8 +1113,8 @@ TEST_F(MetricStreamerTest, givenInvalidArgumentsWhenZetCommandListAppendMetricSt ioMeasurement.GetParamsResult = &oaInformation; // Metrics Discovery metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -1191,8 +1191,8 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetCommandListAppendMetricStre metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -1211,8 +1211,8 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetCommandListAppendMetricStre oaInformation.IoReadEquation = &ioReadEquation; // Metrics Discovery metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -1308,8 +1308,8 @@ TEST_F(MetricStreamerTest, givenMultipleMarkerInsertionsWhenZetCommandListAppend metricsDeviceParams.ConcurrentGroupsCount = 1; // Metrics Discovery concurrent group. - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -1328,8 +1328,8 @@ TEST_F(MetricStreamerTest, givenMultipleMarkerInsertionsWhenZetCommandListAppend oaInformation.IoReadEquation = &ioReadEquation; // Metrics Discovery metric set. - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_streamer_2.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_streamer_2.cpp index 276eb71e00..ce570ee978 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_streamer_2.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_streamer_2.cpp @@ -38,8 +38,8 @@ TEST_F(MetricStreamerMultiDeviceTest, givenInvalidMetricGroupTypeWhenZetMetricSt metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -57,8 +57,8 @@ TEST_F(MetricStreamerMultiDeviceTest, givenInvalidMetricGroupTypeWhenZetMetricSt oaInformation.SymbolName = "BufferOverflow"; oaInformation.IoReadEquation = &ioReadEquation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -116,8 +116,8 @@ TEST_F(MetricStreamerMultiDeviceTest, givenValidArgumentsWhenZetMetricStreamerOp zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -135,8 +135,8 @@ TEST_F(MetricStreamerMultiDeviceTest, givenValidArgumentsWhenZetMetricStreamerOp oaInformation.SymbolName = "BufferOverflow"; oaInformation.IoReadEquation = &ioReadEquation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -203,8 +203,8 @@ TEST_F(MetricStreamerMultiDeviceTest, givenEnableWalkerPartitionIsOnWhenZetMetri zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -222,8 +222,8 @@ TEST_F(MetricStreamerMultiDeviceTest, givenEnableWalkerPartitionIsOnWhenZetMetri oaInformation.SymbolName = "BufferOverflow"; oaInformation.IoReadEquation = &ioReadEquation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -289,8 +289,8 @@ TEST_F(MetricStreamerMultiDeviceTest, givenValidArgumentsWhenZetMetricStreamerOp metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -310,8 +310,8 @@ TEST_F(MetricStreamerMultiDeviceTest, givenValidArgumentsWhenZetMetricStreamerOp metricsConcurrentGroup.GetIoMeasurementInformationResult = &ioMeasurement; ioMeasurement.GetParamsResult = &oaInformation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -360,8 +360,8 @@ TEST_F(MetricStreamerMultiDeviceTest, givenValidArgumentsAndCloseIoStreamFailsWh metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -379,8 +379,8 @@ TEST_F(MetricStreamerMultiDeviceTest, givenValidArgumentsAndCloseIoStreamFailsWh oaInformation.SymbolName = "BufferOverflow"; oaInformation.IoReadEquation = &ioReadEquation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -457,8 +457,8 @@ TEST_F(MetricStreamerMultiDeviceTest, givenValidArgumentsWhenZetMetricStreamerOp metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -476,8 +476,8 @@ TEST_F(MetricStreamerMultiDeviceTest, givenValidArgumentsWhenZetMetricStreamerOp oaInformation.SymbolName = "BufferOverflow"; oaInformation.IoReadEquation = &ioReadEquation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -546,15 +546,15 @@ TEST_F(MetricStreamerMultiDeviceTest, givenValidArgumentsWhenZetMetricStreamerRe metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -653,8 +653,8 @@ TEST_F(MetricStreamerMultiDeviceTest, givenValidArgumentsWhenZetMetricStreamerRe metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -672,8 +672,8 @@ TEST_F(MetricStreamerMultiDeviceTest, givenValidArgumentsWhenZetMetricStreamerRe oaInformation.SymbolName = "BufferOverflow"; oaInformation.IoReadEquation = &ioReadEquation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -740,8 +740,8 @@ TEST_F(MetricStreamerMultiDeviceTest, givenMultipleMarkerInsertionsWhenZetComman metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -759,8 +759,8 @@ TEST_F(MetricStreamerMultiDeviceTest, givenMultipleMarkerInsertionsWhenZetComman oaInformation.SymbolName = "BufferOverflow"; oaInformation.IoReadEquation = &ioReadEquation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_streamer_3.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_streamer_3.cpp index d1e1a17e97..91df811314 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_streamer_3.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_streamer_3.cpp @@ -43,8 +43,8 @@ TEST_F(MetricStreamerMultiDeviceTest, givenEnableWalkerPartitionIsOnWhenZetComma metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -62,8 +62,8 @@ TEST_F(MetricStreamerMultiDeviceTest, givenEnableWalkerPartitionIsOnWhenZetComma oaInformation.SymbolName = "BufferOverflow"; oaInformation.IoReadEquation = &ioReadEquation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; @@ -137,15 +137,15 @@ TEST_F(MetricStreamerMultiDeviceTest, givenValidArgumentsWhenZetMetricGroupCalcu metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.SymbolName = "Metric set name"; metricsSetParams.ShortName = "Metric set description"; @@ -164,8 +164,8 @@ TEST_F(MetricStreamerMultiDeviceTest, givenValidArgumentsWhenZetMetricGroupCalcu oaInformation.SymbolName = "BufferOverflow"; oaInformation.IoReadEquation = &ioReadEquation; - Mock metric; - MetricsDiscovery::TMetricParams_1_0 metricParams = {}; + Mock metric; + MetricsDiscovery::TMetricParams_1_13 metricParams = {}; uint32_t returnedMetricCount = 1; @@ -239,8 +239,8 @@ TEST_F(MetricStreamerTest, givenRawReportSizeIsNotAlignedToOaBufferSizeWhenZetMe zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle(); metricsDeviceParams.ConcurrentGroupsCount = 1; - Mock metricsConcurrentGroup; - TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {}; metricsConcurrentGroupParams.MetricSetsCount = 1; metricsConcurrentGroupParams.SymbolName = "OA"; metricsConcurrentGroupParams.Description = "OA description"; @@ -258,8 +258,8 @@ TEST_F(MetricStreamerTest, givenRawReportSizeIsNotAlignedToOaBufferSizeWhenZetMe oaInformation.SymbolName = "BufferOverflow"; oaInformation.IoReadEquation = &ioReadEquation; - Mock metricsSet; - MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {}; metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; metricsSetParams.MetricsCount = 0; metricsSetParams.SymbolName = "Metric set name"; 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 index 746d8ec58b..043e66c084 100644 --- 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 @@ -7,136 +7,1737 @@ #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" +#include "level_zero/core/source/device/device.h" +#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h" +#include "level_zero/tools/source/metrics/metric.h" +#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_ip_sampling_source.h" +#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_programmable.h" +#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_source.h" namespace L0 { namespace ult { -using MetricEnumerationProgrammableTest = Test; +class OaMetricProgrammableFixture : public DeviceFixture, + public ::testing::Test { + protected: + void SetUp() override; + void TearDown() override; + std::unique_ptr deviceContext = nullptr; + OaMetricSourceImp *oaMetricSource = nullptr; + MetricEnumeration *metricEnumeration = nullptr; + MockIAdapterGroup1x13 mockAdapterGroup{}; + void disableProgrammableMetricsSupport(); +}; -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"; - metricsConcurrentGroupParams.IoMeasurementInformationCount = 1; - - Mock ioReadEquation; - MetricsDiscovery::TEquationElement_1_0 ioEquationElement = {}; - ioEquationElement.Type = MetricsDiscovery::EQUATION_ELEM_IMM_UINT64; - ioEquationElement.ImmediateUInt64 = 0; - - ioReadEquation.getEquationElement.push_back(&ioEquationElement); - - Mock ioMeasurement; - MetricsDiscovery::TInformationParams_1_0 oaInformation = {}; - oaInformation.SymbolName = "BufferOverflow"; - oaInformation.IoReadEquation = &ioReadEquation; - metricsConcurrentGroup.GetIoMeasurementInformationResult = &ioMeasurement; - ioMeasurement.GetParamsResult = &oaInformation; - - // 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)); +void OaMetricProgrammableFixture::TearDown() { + DeviceFixture::tearDown(); + deviceContext.reset(); } -TEST_F(MetricEnumerationProgrammableTest, givenNonRootDeviceMetricwhenIsRootDeviceIsCalledThenReturnFalse) { - MockMetricSource metricSource{}; - MockMetric metric(metricSource); - EXPECT_FALSE(metric.isRootDevice()); +void OaMetricProgrammableFixture::SetUp() { + DeviceFixture::setUp(); + + DebugManagerStateRestore restorer; + debugManager.flags.EnableProgrammableMetricsSupport.set(1); + mockAdapterGroup.mockParams.Version.MajorNumber = 1; + mockAdapterGroup.mockParams.Version.MinorNumber = 13; + deviceContext = std::make_unique(*device); + oaMetricSource = static_cast(&deviceContext->getMetricSource()); + metricEnumeration = static_cast(&oaMetricSource->getMetricEnumeration()); + metricEnumeration->setAdapterGroup(&mockAdapterGroup); + + oaMetricSource->setInitializationState(ZE_RESULT_SUCCESS); + metricEnumeration->setInitializationState(ZE_RESULT_SUCCESS); +} + +void OaMetricProgrammableFixture::disableProgrammableMetricsSupport() { + + deviceContext.reset(); + + DebugManagerStateRestore restorer; + debugManager.flags.EnableProgrammableMetricsSupport.set(0); + mockAdapterGroup.mockParams.Version.MajorNumber = 1; + mockAdapterGroup.mockParams.Version.MinorNumber = 13; + deviceContext = std::make_unique(*device); + oaMetricSource = static_cast(&deviceContext->getMetricSource()); + metricEnumeration = static_cast(&oaMetricSource->getMetricEnumeration()); + metricEnumeration->setAdapterGroup(&mockAdapterGroup); + + oaMetricSource->setInitializationState(ZE_RESULT_SUCCESS); + metricEnumeration->setInitializationState(ZE_RESULT_SUCCESS); +} + +using OaMetricProgrammableTests = OaMetricProgrammableFixture; + +TEST_F(OaMetricProgrammableTests, givenMetricProgrammableIsSupportedThenValidHandlesAreReturned) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_exp_properties_t properties{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->getProperties(&properties)); + EXPECT_STREQ(properties.component, "GroupName"); + EXPECT_STREQ(properties.description, "LongName"); + EXPECT_STREQ(properties.name, "SymbolName"); + EXPECT_EQ(properties.domain, 1u); + EXPECT_EQ(properties.tierNumber, 1u); + EXPECT_EQ(properties.samplingType, ZET_INTEL_METRIC_SAMPLING_TYPE_EXP_FLAG_TIME_AND_EVENT_BASED); + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenMetricProgrammableIsSupportedAndMoreThanAvailableCountIsRequestedThenSuccessIsReturned) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + + zet_metric_programmable_exp_handle_t programmable{}; + count += 1; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenEnableProgrammableMetricsSupportIsNotSetWhenMetricProgrammableGetIsCalledThenErrorIsReturned) { + + uint32_t count = 0; + DebugManagerStateRestore restorer; + debugManager.flags.EnableProgrammableMetricsSupport.set(0); + auto deviceContextTest = std::make_unique(*device); + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, deviceContextTest->metricProgrammableGet(&count, nullptr)); +} + +TEST_F(OaMetricProgrammableTests, givenEnumerationHasErroreWhenmetricProgrammableGetIsCalledThenErrorIsReturned) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + metricEnumeration->setInitializationState(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, oaMetricSource->metricProgrammableGet(&count, nullptr)); + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenConcurrentGroupVersionIsMetThenMetricProgrammableCountIsNonZero) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + mockAdapterGroup.mockParams.Version.MajorNumber = 2; + mockAdapterGroup.mockParams.Version.MinorNumber = 0; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_GT(count, 0u); + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenMetricEnumeratorIsNullThenMetricProgrammableCountIsZero) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + mockConcurrentGroup.metricEnumeratorReturn = nullptr; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 0u); + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenMetricPrototypeCountIsZeroThenMetricProgrammableCountIsZero) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + mockConcurrentGroup.metricEnumeratorReturn->getMetricPrototypeCountReturn = 0; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 0u); + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenMetricPrototypeParamsAreNullThenMetricProgrammableCountIsZero) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + mockConcurrentGroup.metricEnumeratorReturn->metricProtoTypeReturn[0].getParamsReturn = nullptr; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 0u); + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, whenRetrievingConcurrentGroupFromAdapterGroupThenAllParametersAreCorrect) { + + auto adapterGroupParams = metricEnumeration->getAdapterGroupParams( + static_cast(&mockAdapterGroup)); + EXPECT_EQ(adapterGroupParams->Version.MajorNumber, 1u); + EXPECT_EQ(adapterGroupParams->Version.MinorNumber, 13u); + auto adapter = metricEnumeration->getAdapterFromAdapterGroup( + static_cast(&mockAdapterGroup), 0); + const auto adapterParams19 = metricEnumeration->getAdapterParams(adapter); + EXPECT_EQ(adapterParams19->BusNumber, 100u); + MetricsDiscovery::IMetricsDevice_1_13 *metricsDevice = nullptr; + metricEnumeration->openMetricsDeviceFromAdapter(adapter, &metricsDevice); + EXPECT_NE(metricsDevice, nullptr); + metricsDevice = nullptr; + metricEnumeration->openMetricsSubDeviceFromAdapter(adapter, 0, &metricsDevice); + EXPECT_NE(metricsDevice, nullptr); + auto concurrentGroup = metricEnumeration->getConcurrentGroupFromDevice(metricsDevice, 0); + EXPECT_NE(concurrentGroup, nullptr); +} + +TEST_F(OaMetricProgrammableTests, givenMetricProgrammableIsSupportedWhenCacheingForMulitpleConcurrentGroupsThenValidHandlesAreReturned) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 2u); + zet_metric_programmable_exp_handle_t programmable[2] = {}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, programmable)); + + for (uint32_t i = 0; i < 2u; i++) { + zet_metric_programmable_exp_properties_t properties{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable[i])->getProperties(&properties)); + EXPECT_STREQ(properties.component, "GroupName"); + EXPECT_STREQ(properties.description, "LongName"); + EXPECT_STREQ(properties.name, "SymbolName"); + EXPECT_EQ(properties.domain, 1u); + EXPECT_EQ(properties.tierNumber, 1u); + EXPECT_EQ(properties.samplingType, ZET_INTEL_METRIC_SAMPLING_TYPE_EXP_FLAG_TIME_AND_EVENT_BASED); + } + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenMetricsProgrammableSupportIsDisabledWhenmetricProgrammableGetIsCalledThenErrorIsReturned) { + disableProgrammableMetricsSupport(); + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, L0::metricProgrammableGet(device, &count, nullptr)); + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenMetricsProgrammableSupportIsDisabledWhenRetrievingConcurrentGroupFromAdapterGroupThenAllParametersAreCorrect) { + + disableProgrammableMetricsSupport(); + auto adapterGroupParams = metricEnumeration->getAdapterGroupParams( + static_cast(&mockAdapterGroup)); + EXPECT_EQ(adapterGroupParams->Version.MajorNumber, 1u); + EXPECT_EQ(adapterGroupParams->Version.MinorNumber, 13u); + auto adapter = metricEnumeration->getAdapterFromAdapterGroup( + static_cast(&mockAdapterGroup), 0); + const auto adapterParams19 = metricEnumeration->getAdapterParams(adapter); + EXPECT_EQ(adapterParams19->BusNumber, 100u); + MetricsDiscovery::IMetricsDevice_1_13 *metricsDevice = nullptr; + metricEnumeration->openMetricsDeviceFromAdapter(adapter, &metricsDevice); + EXPECT_NE(metricsDevice, nullptr); + metricsDevice = nullptr; + metricEnumeration->openMetricsSubDeviceFromAdapter(adapter, 0, &metricsDevice); + EXPECT_NE(metricsDevice, nullptr); + auto concurrentGroup = metricEnumeration->getConcurrentGroupFromDevice(metricsDevice, 0); + EXPECT_NE(concurrentGroup, nullptr); +} + +TEST_F(OaMetricProgrammableTests, givenMetricProgrammableIsSupportedAndApiMaskIsIoStreamThenCorrectSamplingTypeIsSet) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + mockConcurrentGroup.mockMetricEnumerator.metricProtoTypeReturn[0].mockParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_exp_properties_t properties{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->getProperties(&properties)); + EXPECT_EQ(properties.samplingType, ZET_INTEL_METRIC_SAMPLING_TYPE_EXP_FLAG_TIME_BASED); + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenMetricProgrammableIsSupportedAndApiMaskIsNotIoStreamThenCorrectSamplingTypeIsSet) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + mockConcurrentGroup.mockMetricEnumerator.metricProtoTypeReturn[0].mockParams.ApiMask = MetricsDiscovery::API_TYPE_OCL | MetricsDiscovery::API_TYPE_OGL4_X; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_exp_properties_t properties{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->getProperties(&properties)); + EXPECT_EQ(properties.samplingType, ZET_INTEL_METRIC_SAMPLING_TYPE_EXP_FLAG_EVENT_BASED); + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableThenCorrectParamerterInfoIsReturned) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_param_info_exp_t parameterInfo[4]; + + uint32_t parameterCount = 6; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->getParamInfo(¶meterCount, parameterInfo)); + EXPECT_EQ(parameterCount, 4u); + + EXPECT_EQ(parameterInfo[0].defaultValue.ui64, UINT64_MAX); + EXPECT_STREQ(parameterInfo[0].name, "mockParam1"); + EXPECT_EQ(parameterInfo[0].type, ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_DISAGGREGATION); + EXPECT_EQ(parameterInfo[0].valueInfoCount, 1u); + EXPECT_EQ(parameterInfo[0].valueInfoType, ZET_VALUE_INFO_TYPE_EXP_UINT32); + + EXPECT_EQ(parameterInfo[1].defaultValue.ui64, 0u); + EXPECT_STREQ(parameterInfo[1].name, "mockParam2"); + EXPECT_EQ(parameterInfo[1].type, ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_LATENCY); + EXPECT_EQ(parameterInfo[1].valueInfoCount, 1u); + EXPECT_EQ(parameterInfo[1].valueInfoType, ZET_VALUE_INFO_TYPE_EXP_UINT64); + + EXPECT_EQ(parameterInfo[2].defaultValue.ui64, 0u); + EXPECT_STREQ(parameterInfo[2].name, "mockParam3"); + EXPECT_EQ(parameterInfo[2].type, ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_NORMALIZATION_UTILIZATION); + EXPECT_EQ(parameterInfo[2].valueInfoCount, 1u); + EXPECT_EQ(parameterInfo[2].valueInfoType, ZET_VALUE_INFO_TYPE_EXP_UINT64_RANGE); + + EXPECT_EQ(parameterInfo[3].defaultValue.ui64, 0u); + EXPECT_STREQ(parameterInfo[3].name, "mockParam4"); + EXPECT_EQ(parameterInfo[3].type, static_cast(ZET_INTEL_METRIC_PROGRAMMABLE_PARAM_TYPE_NORMALIZATION_BYTE_EXP)); + EXPECT_EQ(parameterInfo[3].valueInfoCount, 1u); + EXPECT_EQ(parameterInfo[3].valueInfoType, ZET_VALUE_INFO_TYPE_EXP_UINT64_RANGE); + + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableWhenGetOptionDescriptorReturnsNullThenErrorIsReturned) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_param_info_exp_t parameterInfo[4]; + uint32_t parameterCount = 6; + mockConcurrentGroup.metricEnumeratorReturn->metricProtoTypeReturn[0].mockOptionDescriptors.resize(0); + EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, MetricProgrammable::fromHandle(programmable)->getParamInfo(¶meterCount, parameterInfo)); + + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableWhenGetOptionDescriptorTypeIsUnsupportedThenErrorIsReturned) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_param_info_exp_t parameterInfo[4]; + uint32_t parameterCount = 6; + mockConcurrentGroup.metricEnumeratorReturn->metricProtoTypeReturn[0].mockOptionDescriptors[0].Type = MetricsDiscovery::OPTION_DESCRIPTOR_TYPE_LAST; + EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, MetricProgrammable::fromHandle(programmable)->getParamInfo(¶meterCount, parameterInfo)); + + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableWhenGetOptionDescriptorValueTypeIsUnsupportedThenErrorIsReturned) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_param_info_exp_t parameterInfo[4]; + uint32_t parameterCount = 6; + mockConcurrentGroup.metricEnumeratorReturn->metricProtoTypeReturn[0].mockOptionDescriptors[0].ValidValues->ValueType = MetricsDiscovery::VALUE_TYPE_LAST; + EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, MetricProgrammable::fromHandle(programmable)->getParamInfo(¶meterCount, parameterInfo)); + + mockConcurrentGroup.metricEnumeratorReturn->metricProtoTypeReturn[0].mockOptionDescriptors[0].ValidValues->ValueType = MetricsDiscovery::VALUE_TYPE_UINT32; + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableThenCorrectParamerterValueInfoIsReturned) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + std::vector parameterInfo(4); + uint32_t parameterCount = 2; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->getParamInfo(¶meterCount, parameterInfo.data())); + uint32_t valueInfoCount = 2; + zet_metric_programmable_param_value_info_exp_t valueInfo{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->getParamValueInfo(0, &valueInfoCount, &valueInfo)); + EXPECT_EQ(valueInfoCount, 1u); + EXPECT_EQ(valueInfo.valueInfo.ui32, 1u); + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->getParamValueInfo(1, &valueInfoCount, &valueInfo)); + EXPECT_EQ(valueInfoCount, 1u); + EXPECT_EQ(valueInfo.valueInfo.ui64, 2u); + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->getParamValueInfo(2, &valueInfoCount, &valueInfo)); + EXPECT_EQ(valueInfoCount, 1u); + EXPECT_EQ(valueInfo.valueInfo.ui64Range.ui64Min, 3u); + EXPECT_EQ(valueInfo.valueInfo.ui64Range.ui64Max, 4u); + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->getParamValueInfo(3, &valueInfoCount, &valueInfo)); + EXPECT_EQ(valueInfoCount, 1u); + EXPECT_EQ(valueInfo.valueInfo.ui64Range.ui64Min, 5u); + EXPECT_EQ(valueInfo.valueInfo.ui64Range.ui64Max, 6u); + + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableWhenUnsupportedValueInfoFromMdapiIsObservedThenErrorIsReturned) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + std::vector parameterInfo(4); + uint32_t parameterCount = 2; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->getParamInfo(¶meterCount, parameterInfo.data())); + uint32_t valueInfoCount = 2; + zet_metric_programmable_param_value_info_exp_t valueInfo{}; + + mockConcurrentGroup.metricEnumeratorReturn->metricProtoTypeReturn[0].mockOptionDescriptors[0].ValidValues->ValueType = MetricsDiscovery::VALUE_TYPE_LAST; + EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, MetricProgrammable::fromHandle(programmable)->getParamValueInfo(0, &valueInfoCount, &valueInfo)); + EXPECT_EQ(valueInfoCount, 0u); + mockConcurrentGroup.metricEnumeratorReturn->metricProtoTypeReturn[0].mockOptionDescriptors[0].ValidValues->ValueType = MetricsDiscovery::VALUE_TYPE_UINT32; + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableThenCorrectParamerterValueInfoDescIsReturned) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + std::vector parameterInfo(4); + uint32_t parameterCount = 2; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->getParamInfo(¶meterCount, parameterInfo.data())); + uint32_t valueInfoCount = 2; + zet_metric_programmable_param_value_info_exp_t valueInfo{}; + zet_intel_metric_programmable_param_value_info_exp_desc_t paramValueInfoDesc{}; + paramValueInfoDesc.stype = static_cast(ZET_INTEL_STRUCTURE_TYPE_METRIC_PROGRAMMABLE_PARAM_VALUE_INFO_DESC_EXP); + paramValueInfoDesc.pNext = nullptr; + valueInfo.pNext = ¶mValueInfoDesc; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->getParamValueInfo(0, &valueInfoCount, &valueInfo)); + EXPECT_EQ(valueInfoCount, 1u); + EXPECT_STREQ(paramValueInfoDesc.description, "SymbolName"); + + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableWhenUnsupportedStructureTypeIsSetThenHandleOnlySupportedOnes) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + std::vector parameterInfo(4); + uint32_t parameterCount = 2; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->getParamInfo(¶meterCount, parameterInfo.data())); + uint32_t valueInfoCount = 2; + zet_metric_programmable_param_value_info_exp_t valueInfo{}; + zet_intel_metric_programmable_param_value_info_exp_desc_t paramValueInfoDesc{}; + paramValueInfoDesc.stype = static_cast(ZET_STRUCTURE_TYPE_FORCE_UINT32); + paramValueInfoDesc.pNext = nullptr; + strcpy_s(paramValueInfoDesc.description, ZET_INTEL_MAX_METRIC_PROGRAMMABLE_VALUE_DESCRIPTION_EXP, "default"); + valueInfo.pNext = ¶mValueInfoDesc; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->getParamValueInfo(0, &valueInfoCount, &valueInfo)); + EXPECT_EQ(valueInfoCount, 1u); + EXPECT_STREQ(paramValueInfoDesc.description, "default"); + + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableWhenQueryingForMoreParameterIndexThenErrorIsReturned) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + uint32_t valueInfoCount = 2; + zet_metric_programmable_param_value_info_exp_t valueInfo{}; + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, MetricProgrammable::fromHandle(programmable)->getParamValueInfo(4, &valueInfoCount, &valueInfo)); + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableWhenCreatingMetricsFromItThenReturnSuccess) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_param_value_exp_t parameterValue[4]; + parameterValue[0].value.ui32 = 20; + parameterValue[1].value.ui64 = 21; + parameterValue[2].value.ui32 = 22; + parameterValue[3].value.ui64 = 23; + uint32_t metricHandleCount = 0; + const char metricName[ZET_MAX_METRIC_NAME] = "metricName"; + const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription"; + EXPECT_EQ(ZE_RESULT_SUCCESS, + MetricProgrammable::fromHandle(programmable)->createMetric(parameterValue, 4, metricName, metricDescription, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + + zet_metric_handle_t metricHandle{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(parameterValue, 4, metricName, metricDescription, &metricHandleCount, &metricHandle)); + + zetMetricDestroyExp(metricHandle); + + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenGetOptionDescriptorReturnsNullWhenCreatingMetricsThenReturnError) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_param_value_exp_t parameterValue[4]; + parameterValue[0].value.ui32 = 20; + parameterValue[1].value.ui64 = 21; + parameterValue[2].value.ui32 = 22; + parameterValue[3].value.ui64 = 23; + const char metricName[ZET_MAX_METRIC_NAME] = "metricName"; + const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription"; + mockConcurrentGroup.metricEnumeratorReturn->metricProtoTypeReturn[0].mockOptionDescriptors.resize(0); + uint32_t metricHandleCount = 1; + zet_metric_handle_t metricHandle{}; + EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, + MetricProgrammable::fromHandle(programmable)->createMetric(parameterValue, 4, metricName, metricDescription, &metricHandleCount, &metricHandle)); + EXPECT_EQ(metricHandleCount, 0u); + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableWhenCreatingMetricsUsingSameValueAsDefaultValueThenReturnSuccess) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_param_info_exp_t parameterInfo{}; + uint32_t parameterCount = 1; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->getParamInfo(¶meterCount, ¶meterInfo)); + zet_metric_programmable_param_value_exp_t parameterValue{}; + parameterValue.value.ui64 = parameterInfo.defaultValue.ui64; + uint32_t metricHandleCount = 0; + const char metricName[ZET_MAX_METRIC_NAME] = "metricName"; + const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription"; + EXPECT_EQ(ZE_RESULT_SUCCESS, + MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + + zet_metric_handle_t metricHandle{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle)); + + zetMetricDestroyExp(metricHandle); + + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableWhenCreatingMetricsWithIncorrectParametersThenReturnsFailure) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_param_value_exp_t parameterValue{}; + parameterValue.value.ui32 = 20; + uint32_t metricHandleCount = 0; + const char metricName[ZET_MAX_METRIC_NAME] = "metricName"; + const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription"; + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, + MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 5, metricName, metricDescription, &metricHandleCount, nullptr)); + + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableWhenCreatingMetricsAndMdapiFailsDuringCloneThenReturnsFailure) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_param_value_exp_t parameterValue{}; + parameterValue.value.ui32 = 20; + uint32_t metricHandleCount = 1; + const char metricName[ZET_MAX_METRIC_NAME] = "metricName"; + const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription"; + mockConcurrentGroup.metricEnumeratorReturn->metricProtoTypeReturn[0].deleteClone(); + zet_metric_handle_t metricHandle{}; + EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, + MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle)); + + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableWhenCreatingMetricsAndMdapiFailsDuringChangeNamesThenReturnsFailure) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_param_value_exp_t parameterValue{}; + parameterValue.value.ui32 = 20; + uint32_t metricHandleCount = 1; + const char metricName[ZET_MAX_METRIC_NAME] = "metricName"; + const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription"; + mockConcurrentGroup.metricEnumeratorReturn->metricProtoTypeReturn[0].clone->mockChangeNamesReturnCode = MetricsDiscovery::CC_ERROR_GENERAL; + zet_metric_handle_t metricHandle{}; + EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, + MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle)); + + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenValidMetricProgrammableWhenCreatingMetricsWithIncorrectParametersAndMdapiFailsThenReturnsFailure) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_param_value_exp_t parameterValue{}; + parameterValue.value.ui32 = 20; + uint32_t metricHandleCount = 1; + const char metricName[ZET_MAX_METRIC_NAME] = "metricName"; + const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription"; + mockConcurrentGroup.metricEnumeratorReturn->metricProtoTypeReturn[0].clone->mockSetOptionReturnCode = MetricsDiscovery::CC_ERROR_INVALID_PARAMETER; + zet_metric_handle_t metricHandle{}; + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, + MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle)); + + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenValidMetricGroupWhenAddingOrRemovingMetricsThenSuccessIsReturned) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_param_value_exp_t parameterValue{}; + parameterValue.value.ui32 = 20; + uint32_t metricHandleCount = 0; + const char metricName[ZET_MAX_METRIC_NAME] = "metricName"; + const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription"; + EXPECT_EQ(ZE_RESULT_SUCCESS, + MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle{}; + size_t errorStringSize = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle)); + + uint32_t metricGroupCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_NE(metricGroupCount, 0u); + std::vector metricGroupHandles(metricGroupCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data())); + EXPECT_NE(metricGroupCount, 0u); + zet_metric_group_handle_t metricGroupHandle = metricGroupHandles[0]; + + ASSERT_NE(metricGroupHandle, nullptr); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle, &errorStringSize, nullptr)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle, &errorStringSize, nullptr)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupRemoveMetricExp(metricGroupHandle, metricHandle)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle, &errorStringSize, nullptr)); + + for (auto destroyMetricGroupHandle : metricGroupHandles) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(destroyMetricGroupHandle)); + } + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle)); + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenInvalidMeticWhenMetricGroupIsCreatedThenErrorIsReturned) { + MockMetricSource mockMetricSource{}; + mockMetricSource.isAvailableReturn = true; + MockMetric mockMetric(mockMetricSource); + uint32_t metricGroupCount = 0; + auto metricHandle = mockMetric.toHandle(); + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_EQ(metricGroupCount, 0u); + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenCreateMetrifGroupsFromMetricsIsCalledWhenMetricCountIsZeroThenErrorIsReturned) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + + uint32_t metricGroupCount = 0; + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, deviceContext->createMetricGroupsFromMetrics(0, nullptr, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_EQ(metricGroupCount, 0u); + + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenValidMetricGroupWhenDestroyingMetricsBeforeDestroyingMetricGroupThenErrorIsReturned) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_param_value_exp_t parameterValue{}; + parameterValue.value.ui32 = 20; + uint32_t metricHandleCount = 0; + const char metricName[ZET_MAX_METRIC_NAME] = "metricName"; + const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription"; + EXPECT_EQ(ZE_RESULT_SUCCESS, + MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle{}; + size_t errorStringSize = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle)); + uint32_t metricGroupCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_NE(metricGroupCount, 0u); + std::vector metricGroupHandles(metricGroupCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data())); + EXPECT_NE(metricGroupCount, 0u); + zet_metric_group_handle_t metricGroupHandle = metricGroupHandles[0]; + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle, &errorStringSize, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE, zetMetricDestroyExp(metricHandle)); + for (auto destroyMetricGroupHandle : metricGroupHandles) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(destroyMetricGroupHandle)); + } + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle)); + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenValidMetricGroupWhenFinalizingMetricsThenSuccessIsReturned) { + + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_param_value_exp_t parameterValue{}; + parameterValue.value.ui32 = 20; + uint32_t metricHandleCount = 0; + const char metricName[ZET_MAX_METRIC_NAME] = "metricName"; + const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription"; + EXPECT_EQ(ZE_RESULT_SUCCESS, + MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle)); + + uint32_t metricGroupCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_NE(metricGroupCount, 0u); + std::vector metricGroupHandles(metricGroupCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data())); + EXPECT_NE(metricGroupCount, 0u); + zet_metric_group_handle_t metricGroupHandle = metricGroupHandles[0]; + + size_t errorStringSize = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle, &errorStringSize, nullptr)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupCloseExp(metricGroupHandle)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle, &errorStringSize, nullptr)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupCloseExp(metricGroupHandle)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupRemoveMetricExp(metricGroupHandle, metricHandle)); + for (auto destroyMetricGroupHandle : metricGroupHandles) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(destroyMetricGroupHandle)); + } + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle)); + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenValidMetricGroupWhenAddingMetricsAfterFinalizingThenSuccessIsReturned) { + + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_param_value_exp_t parameterValue{}; + parameterValue.value.ui32 = 20; + uint32_t metricHandleCount = 0; + const char metricName[ZET_MAX_METRIC_NAME] = "metricName"; + const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription"; + EXPECT_EQ(ZE_RESULT_SUCCESS, + MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle1{}, metricHandle2{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle1)); + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle2)); + size_t errorStringSize = 0; + + uint32_t metricGroupCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle1, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_NE(metricGroupCount, 0u); + std::vector metricGroupHandles(metricGroupCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle1, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data())); + EXPECT_NE(metricGroupCount, 0u); + zet_metric_group_handle_t metricGroupHandle = metricGroupHandles[0]; + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle1, &errorStringSize, nullptr)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupCloseExp(metricGroupHandle)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle2, &errorStringSize, nullptr)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupCloseExp(metricGroupHandle)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupRemoveMetricExp(metricGroupHandle, metricHandle1)); + for (auto destroyMetricGroupHandle : metricGroupHandles) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(destroyMetricGroupHandle)); + } + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle1)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle2)); + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenValidMetricGroupWhenRemovingAllMetricsAndClosedThenErrorIsReturned) { + + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_param_value_exp_t parameterValue{}; + parameterValue.value.ui32 = 20; + uint32_t metricHandleCount = 0; + const char metricName[ZET_MAX_METRIC_NAME] = "metricName"; + const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription"; + EXPECT_EQ(ZE_RESULT_SUCCESS, + MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle1{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle1)); + uint32_t metricGroupCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle1, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_NE(metricGroupCount, 0u); + std::vector metricGroupHandles(metricGroupCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle1, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data())); + EXPECT_NE(metricGroupCount, 0u); + zet_metric_group_handle_t metricGroupHandle = metricGroupHandles[0]; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupRemoveMetricExp(metricGroupHandle, metricHandle1)); + EXPECT_EQ(ZE_RESULT_NOT_READY, zetMetricGroupCloseExp(metricGroupHandle)); + for (auto destroyMetricGroupHandle : metricGroupHandles) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(destroyMetricGroupHandle)); + } + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle1)); + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenActivatedValidMetricGroupWhenAddingOrRemovingMetricsThenErrorIsReturned) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_param_value_exp_t parameterValue{}; + parameterValue.value.ui32 = 20; + uint32_t metricHandleCount = 0; + const char metricName[ZET_MAX_METRIC_NAME] = "metricName"; + const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription"; + EXPECT_EQ(ZE_RESULT_SUCCESS, + MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle)); + size_t errorStringSize = 0; + + uint32_t metricGroupCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_NE(metricGroupCount, 0u); + std::vector metricGroupHandles(metricGroupCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data())); + EXPECT_GE(metricGroupCount, 2u); + zet_metric_group_handle_t metricGroupHandle = metricGroupHandles[1]; + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle, &errorStringSize, nullptr)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupCloseExp(metricGroupHandle)); + deviceContext->activateMetricGroupsPreferDeferred(1, &metricGroupHandle); + deviceContext->activateMetricGroups(); + EXPECT_EQ(ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle, &errorStringSize, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE, zetMetricGroupRemoveMetricExp(metricGroupHandle, metricHandle)); + EXPECT_EQ(ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE, zetMetricGroupDestroyExp(metricGroupHandle)); + + deviceContext->activateMetricGroupsPreferDeferred(0, nullptr); + for (auto destroyMetricGroupHandle : metricGroupHandles) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(destroyMetricGroupHandle)); + } + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle)); + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenErrorDuingActivationOfMetricsTheActivationStatusIsNotChanged) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_param_value_exp_t parameterValue{}; + parameterValue.value.ui32 = 20; + uint32_t metricHandleCount = 0; + const char metricName[ZET_MAX_METRIC_NAME] = "metricName"; + const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription"; + EXPECT_EQ(ZE_RESULT_SUCCESS, + MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle)); + size_t errorStringSize = 0; + + uint32_t metricGroupCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_NE(metricGroupCount, 0u); + std::vector metricGroupHandles(metricGroupCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data())); + EXPECT_GE(metricGroupCount, 2u); + zet_metric_group_handle_t metricGroupHandle = metricGroupHandles[0]; + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle, &errorStringSize, nullptr)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupCloseExp(metricGroupHandle)); + deviceContext->activateMetricGroupsPreferDeferred(1, &metricGroupHandle); + deviceContext->activateMetricGroups(); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle, &errorStringSize, nullptr)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupRemoveMetricExp(metricGroupHandle, metricHandle)); + deviceContext->activateMetricGroupsPreferDeferred(0, nullptr); + for (auto destroyMetricGroupHandle : metricGroupHandles) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(destroyMetricGroupHandle)); + } + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle)); + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenUserDefinedMetricGroupWhenAddingMetricsAndErrorIsObservedThenErrorStringIsUpdated) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[0] = MetricsDiscovery::CC_OK; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_param_value_exp_t parameterValue{}; + parameterValue.value.ui32 = 20; + uint32_t metricHandleCount = 0; + const char metricName[ZET_MAX_METRIC_NAME] = "metricName"; + const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription"; + EXPECT_EQ(ZE_RESULT_SUCCESS, + MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle)); + + uint32_t metricGroupCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_NE(metricGroupCount, 0u); + std::vector metricGroupHandles(metricGroupCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data())); + EXPECT_NE(metricGroupCount, 0u); + zet_metric_group_handle_t metricGroupHandle = metricGroupHandles[0]; + + zet_metric_handle_t metricHandle1{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle1)); + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[0] = MetricsDiscovery::CC_ERROR_GENERAL; + size_t errorStringSize = 0; + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle1, &errorStringSize, nullptr)); + EXPECT_NE(errorStringSize, 0u); + std::vector errorString(errorStringSize); + errorString[0] = '\0'; + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle1, &errorStringSize, errorString.data())); + EXPECT_NE(errorString[0], '\0'); + for (auto destroyMetricGroupHandle : metricGroupHandles) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(destroyMetricGroupHandle)); + } + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle1)); + metricEnumeration->cleanupExtendedMetricInformation(); + MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet); +} + +TEST_F(OaMetricProgrammableTests, givenUserDefinedMetricGroupWhenCreatingWithMetricIfErrorIsEncounteredThenErrorIsReturned) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[0] = MetricsDiscovery::CC_ERROR_GENERAL; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_param_value_exp_t parameterValue{}; + parameterValue.value.ui32 = 20; + uint32_t metricHandleCount = 0; + const char metricName[ZET_MAX_METRIC_NAME] = "metricName"; + const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription"; + EXPECT_EQ(ZE_RESULT_SUCCESS, + MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle)); + + uint32_t metricGroupCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_NE(metricGroupCount, 0u); + std::vector metricGroupHandles(metricGroupCount); + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data())); + EXPECT_EQ(metricGroupCount, 0u); + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle)); + metricEnumeration->cleanupExtendedMetricInformation(); + MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet); +} + +TEST_F(OaMetricProgrammableTests, givenUserDefinedMetricGroupWhenAddingMetricsWithIncompatibleSamplingTypeThenErrorIsObserved) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + mockConcurrentGroup.mockMetricEnumerator.metricProtoTypeReturn[0].mockParams.ApiMask = MetricsDiscovery::API_TYPE_OCL | MetricsDiscovery::API_TYPE_OGL4_X; + // Create Metric Handle 2 with different sampling type + mockConcurrentGroup.mockMetricEnumerator.metricProtoTypeReturn[1].mockParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; + mockConcurrentGroup.mockMetricEnumerator.getMetricPrototypeCountReturn = 2; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + ASSERT_EQ(count, 2u); + std::vector programmables(count); + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, programmables.data())); + zet_metric_programmable_param_value_exp_t parameterValue{}; + parameterValue.value.ui32 = 20; + uint32_t metricHandleCount = 0; + const char metricName[ZET_MAX_METRIC_NAME] = "metricName"; + const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription"; + EXPECT_EQ(ZE_RESULT_SUCCESS, + MetricProgrammable::fromHandle(programmables[0])->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle1{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmables[0])->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle1)); + + metricHandleCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, + MetricProgrammable::fromHandle(programmables[1])->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle2{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmables[1])->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle2)); + + uint32_t metricGroupCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle1, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_NE(metricGroupCount, 0u); + std::vector metricGroupHandles(metricGroupCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle1, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data())); + EXPECT_EQ(metricGroupCount, 1u); + size_t errorStringSize = 0; + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetMetricGroupAddMetricExp(metricGroupHandles[0], metricHandle2, &errorStringSize, nullptr)); + EXPECT_NE(errorStringSize, 0u); + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroupHandles[0])); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle1)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle2)); + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenValidMetricGroupWhenAddingOrRemovingPreDefinedMetricsThenErrorIsReturned) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_param_value_exp_t parameterValue{}; + parameterValue.value.ui32 = 20; + uint32_t metricHandleCount = 0; + const char metricName[ZET_MAX_METRIC_NAME] = "metricName"; + const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription"; + EXPECT_EQ(ZE_RESULT_SUCCESS, + MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle)); + size_t errorStringSize = 0; + zet_metric_group_handle_t metricGroupHandle = nullptr; + + uint32_t metricGroupCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_NE(metricGroupCount, 0u); + std::vector metricGroupHandles(metricGroupCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data())); + EXPECT_GE(metricGroupCount, 2u); + // Access the query sampling type group + metricGroupHandle = metricGroupHandles[1]; + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle, &errorStringSize, nullptr)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupCloseExp(metricGroupHandle)); + + uint32_t metricCount = 0; + + EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, nullptr), ZE_RESULT_SUCCESS); + std::vector metricHandles(metricCount); + EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, metricHandles.data()), ZE_RESULT_SUCCESS); + + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandles[0], &errorStringSize, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetMetricGroupRemoveMetricExp(metricGroupHandle, metricHandles[0])); + + for (auto destroyMetricGroupHandle : metricGroupHandles) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(destroyMetricGroupHandle)); + } + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle)); + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenValidMetricGroupWhenAddingOrRemovingMetricsFromIncorrectSourceThenErrorIsReturned) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_param_value_exp_t parameterValue{}; + parameterValue.value.ui32 = 20; + uint32_t metricHandleCount = 0; + const char metricName[ZET_MAX_METRIC_NAME] = "metricName"; + const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription"; + EXPECT_EQ(ZE_RESULT_SUCCESS, + MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle)); + size_t errorStringSize = 0; + zet_metric_group_handle_t metricGroupHandle = nullptr; + + uint32_t metricGroupCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_NE(metricGroupCount, 0u); + std::vector metricGroupHandles(metricGroupCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data())); + EXPECT_GE(metricGroupCount, 2u); + + metricGroupHandle = metricGroupHandles[1]; + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle, &errorStringSize, nullptr)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupCloseExp(metricGroupHandle)); + + MockMetricSource mockMetricSource{}; + mockMetricSource.isAvailableReturn = true; + MockMetric mockMetric(mockMetricSource); + auto metricHandleIncorrectSource = mockMetric.toHandle(); + + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandleIncorrectSource, &errorStringSize, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetMetricGroupRemoveMetricExp(metricGroupHandle, metricHandleIncorrectSource)); + + for (auto destroyMetricGroupHandle : metricGroupHandles) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(destroyMetricGroupHandle)); + } + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle)); + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenValidMetricGroupWhenMetricSetOpenFailsWhenAddingOrRemovingMetricsThenErrorIsReturned) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + mockConcurrentGroup.mockMetricSet.mockApiMask = MetricsDiscovery::API_TYPE_VULKAN; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + + MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet); + mockConcurrentGroup.mockMetricSet.mockOpenReturnCodeList.resize(2); + mockConcurrentGroup.mockMetricSet.mockOpenReturnCodeList[0] = MetricsDiscovery::CC_OK; + mockConcurrentGroup.mockMetricSet.mockOpenReturnCodeList[1] = MetricsDiscovery::CC_ERROR_NO_MEMORY; + + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_param_info_exp_t parameterInfo{}; + uint32_t parameterCount = 1; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetParamInfoExp(programmable, ¶meterCount, ¶meterInfo)); + uint32_t valueInfoCount = 1; + zet_metric_programmable_param_value_info_exp_t paramValueInfo{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetParamValueInfoExp(programmable, 0, &valueInfoCount, ¶mValueInfo)); + zet_metric_programmable_exp_properties_t properties{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetPropertiesExp(programmable, &properties)); + zet_metric_programmable_param_value_exp_t parameterValue{}; + parameterValue.value.ui32 = 20; + uint32_t metricHandleCount = 0; + const char metricName[ZET_MAX_METRIC_NAME] = "metricName"; + const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription"; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, ¶meterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle1{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, ¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle1)); + zet_metric_handle_t metricHandle2{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, ¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle2)); + + zet_metric_handle_t metricHandles[] = {metricHandle1, metricHandle2}; + + uint32_t metricGroupCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, metricHandles, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_EQ(metricGroupCount, 2u); + zet_metric_group_handle_t metricGroupHandle{}; + metricGroupCount = 1; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, metricHandles, "metricGroupName", "metricGroupDesc", &metricGroupCount, &metricGroupHandle)); + EXPECT_EQ(metricGroupCount, 1u); + size_t errorStringSize = 0; + EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandles[1], &errorStringSize, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, zetMetricGroupRemoveMetricExp(metricGroupHandle, metricHandles[0])); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroupHandle)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle1)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle2)); + metricEnumeration->cleanupExtendedMetricInformation(); + MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet); +} + +TEST_F(OaMetricProgrammableTests, givenValidMetricGroupWhenMetricGroupActivationReturnsFalseThenSuccessIsReturned) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_param_value_exp_t parameterValue{}; + parameterValue.value.ui32 = 20; + uint32_t metricHandleCount = 0; + const char metricName[ZET_MAX_METRIC_NAME] = "metricName"; + const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription"; + EXPECT_EQ(ZE_RESULT_SUCCESS, + MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle)); + size_t errorStringSize = 0; + zet_metric_group_handle_t metricGroupHandle = nullptr; + + uint32_t metricGroupCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_NE(metricGroupCount, 0u); + std::vector metricGroupHandles(metricGroupCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data())); + EXPECT_EQ(metricGroupCount, 2u); + metricGroupHandle = metricGroupHandles[1]; + + mockConcurrentGroup.mockMetricSet.mockApiMask = MetricsDiscovery::API_TYPE_VULKAN; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle, &errorStringSize, nullptr)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupCloseExp(metricGroupHandle)); + deviceContext->activateMetricGroupsPreferDeferred(1, &metricGroupHandle); + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->activateMetricGroups()); + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroupHandles[0])); + deviceContext->activateMetricGroupsPreferDeferred(0, nullptr); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroupHandles[1])); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle)); + metricEnumeration->cleanupExtendedMetricInformation(); + MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet); +} + +TEST_F(OaMetricProgrammableTests, givenValidMetricGroupWhenDelayedActivatingMetricGroupBeforeCloseThenSuccessIsReturned) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + mockConcurrentGroup.mockMetricSet.mockApiMask = MetricsDiscovery::API_TYPE_VULKAN; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_param_info_exp_t parameterInfo{}; + uint32_t parameterCount = 1; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetParamInfoExp(programmable, ¶meterCount, ¶meterInfo)); + uint32_t valueInfoCount = 1; + zet_metric_programmable_param_value_info_exp_t paramValueInfo{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetParamValueInfoExp(programmable, 0, &valueInfoCount, ¶mValueInfo)); + zet_metric_programmable_exp_properties_t properties{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetPropertiesExp(programmable, &properties)); + zet_metric_programmable_param_value_exp_t parameterValue{}; + parameterValue.value.ui32 = 20; + uint32_t metricHandleCount = 0; + const char metricName[ZET_MAX_METRIC_NAME] = "metricName"; + const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription"; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, ¶meterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, ¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle)); + zet_metric_handle_t metricHandle1{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, ¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle1)); + zet_metric_group_handle_t metricGroupHandle = nullptr; + + uint32_t metricGroupCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_NE(metricGroupCount, 0u); + std::vector metricGroupHandles(metricGroupCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data())); + EXPECT_EQ(metricGroupCount, 2u); + metricGroupHandle = metricGroupHandles[1]; + + size_t errorStringSize = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandle1, &errorStringSize, nullptr)); + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->activateMetricGroupsPreferDeferred(1, &metricGroupHandle)); + deviceContext->activateMetricGroups(); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupCloseExp(metricGroupHandle)); + deviceContext->activateMetricGroupsPreferDeferred(0, nullptr); + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->activateMetricGroups()); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupCloseExp(metricGroupHandle)); + for (auto destroyMetricGroupHandle : metricGroupHandles) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(destroyMetricGroupHandle)); + } + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle1)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle)); + metricEnumeration->cleanupExtendedMetricInformation(); + MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet); +} + +TEST_F(OaMetricProgrammableTests, givenValidProgrammableWhenCreatingProgrammableWithUnknownMdapiValueTypeThenErrorIsReturned) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + mockConcurrentGroup.mockMetricSet.mockApiMask = MetricsDiscovery::API_TYPE_VULKAN; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_param_info_exp_t parameterInfo{}; + uint32_t parameterCount = 1; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetParamInfoExp(programmable, ¶meterCount, ¶meterInfo)); + uint32_t valueInfoCount = 1; + zet_metric_programmable_param_value_info_exp_t paramValueInfo{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetParamValueInfoExp(programmable, 0, &valueInfoCount, ¶mValueInfo)); + zet_metric_programmable_exp_properties_t properties{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetPropertiesExp(programmable, &properties)); + zet_metric_programmable_param_value_exp_t parameterValue{}; + parameterValue.value.ui32 = 20; + uint32_t metricHandleCount = 0; + const char metricName[ZET_MAX_METRIC_NAME] = "metricName"; + const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription"; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, ¶meterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle{}; + + mockConcurrentGroup.metricEnumeratorReturn->metricProtoTypeReturn[0].mockOptionDescriptors[0].ValidValues->ValueType = MetricsDiscovery::VALUE_TYPE_LAST; + EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, zetMetricCreateFromProgrammableExp(programmable, ¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle)); + mockConcurrentGroup.metricEnumeratorReturn->metricProtoTypeReturn[0].mockOptionDescriptors[0].ValidValues->ValueType = MetricsDiscovery::VALUE_TYPE_UINT32; + + metricEnumeration->cleanupExtendedMetricInformation(); + MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet); +} + +TEST_F(OaMetricProgrammableTests, givenValidMetricGroupWhenCreatingLessThanAvailableMetricGroupsThenCorrectMetricGroupIsReturned) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + mockConcurrentGroup.mockMetricSet.mockApiMask = MetricsDiscovery::API_TYPE_VULKAN; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + + MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet); + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList.resize(2); + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[0] = MetricsDiscovery::CC_OK; + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[1] = MetricsDiscovery::CC_ERROR_NO_MEMORY; + + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_param_info_exp_t parameterInfo{}; + uint32_t parameterCount = 1; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetParamInfoExp(programmable, ¶meterCount, ¶meterInfo)); + uint32_t valueInfoCount = 1; + zet_metric_programmable_param_value_info_exp_t paramValueInfo{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetParamValueInfoExp(programmable, 0, &valueInfoCount, ¶mValueInfo)); + zet_metric_programmable_exp_properties_t properties{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetPropertiesExp(programmable, &properties)); + zet_metric_programmable_param_value_exp_t parameterValue{}; + parameterValue.value.ui32 = 20; + uint32_t metricHandleCount = 0; + const char metricName[ZET_MAX_METRIC_NAME] = "metricName"; + const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription"; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, ¶meterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle1{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, ¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle1)); + zet_metric_handle_t metricHandle2{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, ¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle2)); + + zet_metric_handle_t metricHandles[] = {metricHandle1, metricHandle2}; + + uint32_t metricGroupCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(2, metricHandles, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_EQ(metricGroupCount, 4u); + zet_metric_group_handle_t metricGroupHandle{}; + metricGroupCount = 1; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(2, metricHandles, "metricGroupName", "metricGroupDesc", &metricGroupCount, &metricGroupHandle)); + EXPECT_EQ(metricGroupCount, 1u); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroupHandle)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle1)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle2)); + metricEnumeration->cleanupExtendedMetricInformation(); + MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet); +} + +TEST_F(OaMetricProgrammableTests, givenEnableProgrammableMetricsSupportIsNotSetWhenMetricGroupCreateIsCalledThenErrorIsReturned) { + + DebugManagerStateRestore restorer; + debugManager.flags.EnableProgrammableMetricsSupport.set(0); + auto deviceContextTest = std::make_unique(*device); + + uint32_t metricGroupCount = 0; + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, deviceContextTest->createMetricGroupsFromMetrics(0, nullptr, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_EQ(metricGroupCount, 0u); +} + +TEST_F(OaMetricProgrammableTests, givenCreateMetricGroupsFromMetricsWhenUnembargoedMetricSourceIsUsedThenSuccessIsReturned) { + MockMetricSource mockMetricSource{}; + mockMetricSource.isAvailableReturn = true; + MockMetric mockMetric(mockMetricSource); + mockMetric.setPredefined(false); + + uint32_t metricGroupCount = 0; + auto metricHandle = mockMetric.toHandle(); + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_EQ(metricGroupCount, 0u); + + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenCreateMetricGroupsFromMetricsWhenMultipleMetricsCouldBeAddedToMultipleGroupsThenCorrectGroupCountIsReturned) { + + MockIConcurrentGroup1x13 mockConcurrentGroup; + mockConcurrentGroup.mockMetricEnumerator.metricProtoTypeReturn[0].mockParams.ApiMask = MetricsDiscovery::API_TYPE_OCL | MetricsDiscovery::API_TYPE_OGL4_X; + // Create Metric Handle 2 with different sampling type + mockConcurrentGroup.mockMetricEnumerator.metricProtoTypeReturn[1].mockParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; + mockConcurrentGroup.mockMetricEnumerator.getMetricPrototypeCountReturn = 2; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 2u); + std::vector programmables(2); + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, programmables.data())); + zet_metric_programmable_param_value_exp_t parameterValue{}; + parameterValue.value.ui32 = 20; + uint32_t metricHandleCount = 0; + const char metricName[ZET_MAX_METRIC_NAME] = "metricName"; + const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription"; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmables[0])->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + metricHandleCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmables[1])->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle1{}, metricHandle2{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmables[0])->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle1)); + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmables[1])->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle2)); + + uint32_t metricGroupCount = 0; + zet_metric_handle_t metricHandles[] = {metricHandle1, metricHandle2}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(2, metricHandles, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_NE(metricGroupCount, 0u); + std::vector metricGroupHandles(metricGroupCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(2, metricHandles, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data())); + EXPECT_EQ(metricGroupCount, 2u); + metricGroupHandles.resize(metricGroupCount); + + for (auto &metricGroupHandle : metricGroupHandles) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroupHandle)); + } + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle1)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle2)); + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(OaMetricProgrammableTests, givenCreateMetricGroupsFromMetricsWhenFailureOccursDuringMetricGroupCreationFromMultipleMetricsThenFailureIsReturned) { + + MockIConcurrentGroup1x13 mockConcurrentGroup; + + MockIMetricSet1x13::addMetricCallCount = 0; + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList.resize(4); + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[0] = MetricsDiscovery::CC_OK; + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[1] = MetricsDiscovery::CC_OK; + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[2] = MetricsDiscovery::CC_OK; + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[3] = MetricsDiscovery::CC_ERROR_GENERAL; + + mockConcurrentGroup.mockMetricEnumerator.metricProtoTypeReturn[0].mockParams.ApiMask = MetricsDiscovery::API_TYPE_OCL | MetricsDiscovery::API_TYPE_OGL4_X; + // Create Metric Handle 2 with different sampling type + mockConcurrentGroup.mockMetricEnumerator.metricProtoTypeReturn[1].mockParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM; + mockConcurrentGroup.mockMetricEnumerator.getMetricPrototypeCountReturn = 2; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + EXPECT_EQ(count, 2u); + std::vector programmables(2); + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, programmables.data())); + zet_metric_programmable_param_value_exp_t parameterValue{}; + parameterValue.value.ui32 = 20; + uint32_t metricHandleCount = 0; + const char metricName[ZET_MAX_METRIC_NAME] = "metricName"; + const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription"; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmables[0])->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + metricHandleCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmables[1])->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle1{}, metricHandle2{}, metricHandle3{}, metricHandle4; + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmables[0])->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle1)); + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmables[0])->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle2)); + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmables[1])->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle3)); + EXPECT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmables[1])->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle4)); + + uint32_t metricGroupCount = 0; + zet_metric_handle_t metricHandles[] = {metricHandle1, metricHandle2, metricHandle3, metricHandle4}; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(4, metricHandles, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_NE(metricGroupCount, 0u); + std::vector metricGroupHandles(metricGroupCount); + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, deviceContext->createMetricGroupsFromMetrics(4, metricHandles, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data())); + EXPECT_EQ(metricGroupCount, 0u); + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle1)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle2)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle3)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle4)); + metricEnumeration->cleanupExtendedMetricInformation(); + + MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet); +} + +class MultiSourceOaMetricProgrammableFixture : public DeviceFixture, + public ::testing::Test { + protected: + void SetUp() override; + void TearDown() override; + std::unique_ptr deviceContext = nullptr; + OaMetricSourceImp *oaMetricSource = nullptr; + MetricEnumeration *metricEnumeration = nullptr; + MockIAdapterGroup1x13 mockAdapterGroup{}; + MockMetricIpSamplingSource *metricSource = nullptr; +}; + +void MultiSourceOaMetricProgrammableFixture::TearDown() { + DeviceFixture::tearDown(); + deviceContext.reset(); +} + +void MultiSourceOaMetricProgrammableFixture::SetUp() { + DeviceFixture::setUp(); + + DebugManagerStateRestore restorer; + debugManager.flags.EnableProgrammableMetricsSupport.set(1); + mockAdapterGroup.mockParams.Version.MajorNumber = 1; + mockAdapterGroup.mockParams.Version.MinorNumber = 13; + deviceContext = std::make_unique(*device); + oaMetricSource = static_cast(&deviceContext->getMetricSource()); + metricEnumeration = static_cast(&oaMetricSource->getMetricEnumeration()); + metricEnumeration->setAdapterGroup(&mockAdapterGroup); + + oaMetricSource->setInitializationState(ZE_RESULT_SUCCESS); + metricEnumeration->setInitializationState(ZE_RESULT_SUCCESS); + + metricSource = new MockMetricIpSamplingSource(*deviceContext); + deviceContext->setMetricTraceSource(metricSource); +} + +TEST_F(MultiSourceOaMetricProgrammableFixture, givenCreateMetricGroupsFromMetricsIsCalledAndOneMetricSourcesReturnsUnsupportedThenSuccessIsReturned) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + ASSERT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + ASSERT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + ASSERT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + ASSERT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_param_value_exp_t parameterValue{}; + parameterValue.value.ui32 = 20; + uint32_t metricHandleCount = 0; + const char metricName[ZET_MAX_METRIC_NAME] = "metricName"; + const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription"; + ASSERT_EQ(ZE_RESULT_SUCCESS, + MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr)); + ASSERT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle{}; + ASSERT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle)); + + MockMetricIpSamplingSource mockMetricTraceSource(*deviceContext); + MockMetric mockMetric(mockMetricTraceSource); + mockMetric.setPredefined(false); + + zet_metric_handle_t metricHandles[] = {metricHandle, mockMetric.toHandle()}; + + uint32_t metricGroupCount = 0; + ASSERT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(2, metricHandles, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + ASSERT_NE(metricGroupCount, 0u); + std::vector metricGroupHandles(metricGroupCount); + ASSERT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(2, metricHandles, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data())); + ASSERT_NE(metricGroupCount, 0u); + zet_metric_group_handle_t metricGroupHandle = metricGroupHandles[0]; + + ASSERT_NE(metricGroupHandle, nullptr); + + for (auto destroyMetricGroupHandle : metricGroupHandles) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(destroyMetricGroupHandle)); + } + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle)); + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(MultiSourceOaMetricProgrammableFixture, givenCreateMetricGroupsFromMetricsIsCalledAndOneMetricSourcesFailsThenFailureIsReturned) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + ASSERT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + ASSERT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + ASSERT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + ASSERT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_param_value_exp_t parameterValue{}; + parameterValue.value.ui32 = 20; + uint32_t metricHandleCount = 0; + const char metricName[ZET_MAX_METRIC_NAME] = "metricName"; + const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription"; + ASSERT_EQ(ZE_RESULT_SUCCESS, + MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr)); + ASSERT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle{}; + ASSERT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle)); + + MockMetricIpSamplingSource &mockMetricTraceSource = static_cast(deviceContext->getMetricSource()); + MockMetric mockMetric(mockMetricTraceSource); + mockMetric.setPredefined(false); + + zet_metric_handle_t metricHandles[] = {metricHandle, mockMetric.toHandle()}; + uint32_t metricGroupCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, deviceContext->createMetricGroupsFromMetrics(2, metricHandles, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + ASSERT_NE(metricGroupCount, 0u); + // Allocate more space for the mockMetricTraceSource + metricGroupCount += 1; + std::vector metricGroupHandles(metricGroupCount); + mockMetricTraceSource.createMetricGroupsFromMetricsReturn = ZE_RESULT_ERROR_INVALID_ARGUMENT; + ASSERT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, deviceContext->createMetricGroupsFromMetrics(2, metricHandles, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data())); + ASSERT_EQ(metricGroupCount, 0u); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle)); + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(MultiSourceOaMetricProgrammableFixture, givenMetricProgrammableGetReturnsFailureForOneOfTheSourcesThenApiReturnsFailure) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + ASSERT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + ASSERT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + ASSERT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + MockMetricIpSamplingSource &mockMetricTraceSource = static_cast(deviceContext->getMetricSource()); + mockMetricTraceSource.metricProgrammableGetReturn = ZE_RESULT_ERROR_UNKNOWN; + count += 1; + ASSERT_EQ(ZE_RESULT_ERROR_UNKNOWN, deviceContext->metricProgrammableGet(&count, &programmable)); + metricEnumeration->cleanupExtendedMetricInformation(); +} + +TEST_F(MultiSourceOaMetricProgrammableFixture, givenCreateMetricGroupsFromMetricsIsCalledAndOneMetricSourcesFailsDuringCountCalculationThenFailureIsReturned) { + MockIConcurrentGroup1x13 mockConcurrentGroup; + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = mockConcurrentGroup; + ASSERT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + uint32_t count = 0; + ASSERT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, nullptr)); + ASSERT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + ASSERT_EQ(ZE_RESULT_SUCCESS, deviceContext->metricProgrammableGet(&count, &programmable)); + zet_metric_programmable_param_value_exp_t parameterValue{}; + parameterValue.value.ui32 = 20; + uint32_t metricHandleCount = 0; + const char metricName[ZET_MAX_METRIC_NAME] = "metricName"; + const char metricDescription[ZET_MAX_METRIC_NAME] = "metricDescription"; + ASSERT_EQ(ZE_RESULT_SUCCESS, + MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, nullptr)); + ASSERT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle{}; + ASSERT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle)); + + MockMetricIpSamplingSource &mockMetricTraceSource = static_cast(deviceContext->getMetricSource()); + MockMetric mockMetric(mockMetricTraceSource); + mockMetric.setPredefined(false); + + zet_metric_handle_t metricHandles[] = {metricHandle, mockMetric.toHandle()}; + uint32_t metricGroupCount = 0; + mockMetricTraceSource.createMetricGroupsFromMetricsReturn = ZE_RESULT_ERROR_INVALID_ARGUMENT; + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, deviceContext->createMetricGroupsFromMetrics(2, metricHandles, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_EQ(metricGroupCount, 0u); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle)); + metricEnumeration->cleanupExtendedMetricInformation(); + mockMetricTraceSource.createMetricGroupsFromMetricsReturn = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } } // namespace ult diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_multidevice_metric_programmable.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_multidevice_metric_programmable.cpp new file mode 100644 index 0000000000..c7c6dd31b4 --- /dev/null +++ b/level_zero/tools/test/unit_tests/sources/metrics/test_multidevice_metric_programmable.cpp @@ -0,0 +1,970 @@ +/* + * Copyright (C) 2024 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "shared/test/common/test_macros/test.h" + +#include "level_zero/core/source/device/device.h" +#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h" +#include "level_zero/tools/source/metrics/metric.h" +#include "level_zero/tools/source/metrics/metric_multidevice_programmable.h" +#include "level_zero/tools/source/metrics/metric_multidevice_programmable.inl" +#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_programmable.h" +#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_source.h" + +namespace L0 { +namespace ult { + +class OaMultiDeviceMetricProgrammableFixture : public MultiDeviceFixture, + public ::testing::Test { + protected: + void SetUp() override; + void TearDown() override; + MockIAdapterGroup1x13 mockAdapterGroup{}; + + std::vector subDevices = {}; + L0::Device *rootDevice = nullptr; + DebugManagerStateRestore restorer; + MockIConcurrentGroup1x13 mockConcurrentGroup{}; + + void getMetricProgrammable(zet_metric_programmable_exp_handle_t &programmable); + void getMetricFromProgrammable(zet_metric_programmable_exp_handle_t programmable, zet_metric_handle_t &metricHandle); + void createMetricGroupFromMetric(zet_metric_handle_t metric, std::vector &metricGroupHandles); +}; + +void OaMultiDeviceMetricProgrammableFixture::TearDown() { + MultiDeviceFixture::tearDown(); + + auto &deviceImp = *static_cast(rootDevice); + auto &rootDeviceOaSourceImp = deviceImp.getMetricDeviceContext().getMetricSource(); + auto rootDeviceMetricEnumeration = static_cast(&rootDeviceOaSourceImp.getMetricEnumeration()); + rootDeviceMetricEnumeration->cleanupExtendedMetricInformation(); + + for (auto &subDevice : subDevices) { + auto &subDeviceImp = *static_cast(subDevice); + auto &subDeviceOaSourceImp = subDeviceImp.getMetricDeviceContext().getMetricSource(); + auto subDeviceMetricEnumeration = static_cast(&subDeviceOaSourceImp.getMetricEnumeration()); + subDeviceMetricEnumeration->cleanupExtendedMetricInformation(); + } +} + +void OaMultiDeviceMetricProgrammableFixture::getMetricProgrammable(zet_metric_programmable_exp_handle_t &programmable) { + + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, nullptr)); + EXPECT_EQ(count, 1u); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, &programmable)); +} + +void OaMultiDeviceMetricProgrammableFixture::getMetricFromProgrammable(zet_metric_programmable_exp_handle_t programmable, zet_metric_handle_t &metricHandle) { + const char *metricName = "MetricName"; + const char *metricDesc = "MetricDesc"; + uint32_t metricHandleCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, metricName, metricDesc, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, metricName, metricDesc, &metricHandleCount, &metricHandle)); + EXPECT_NE(metricHandle, nullptr); +} + +void OaMultiDeviceMetricProgrammableFixture::createMetricGroupFromMetric(zet_metric_handle_t metricHandle, std::vector &metricGroupHandles) { + + metricGroupHandles.clear(); + uint32_t metricGroupCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_GT(metricGroupCount, 0u); + metricGroupHandles.resize(metricGroupCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data())); + + for (auto &metricGroup : metricGroupHandles) { + EXPECT_NE(metricGroup, nullptr); + } +} + +void OaMultiDeviceMetricProgrammableFixture::SetUp() { + debugManager.flags.EnableImplicitScaling.set(1); + debugManager.flags.EnableProgrammableMetricsSupport.set(1); + + MultiDeviceFixture::numRootDevices = 1; + MultiDeviceFixture::numSubDevices = 3; + MultiDeviceFixture::setUp(); + + mockAdapterGroup.mockParams.Version.MajorNumber = 1; + mockAdapterGroup.mockParams.Version.MinorNumber = 13; + + rootDevice = driverHandle->devices[0]; + auto &deviceImp = *static_cast(rootDevice); + auto &rootDeviceOaSourceImp = deviceImp.getMetricDeviceContext().getMetricSource(); + rootDeviceOaSourceImp.setInitializationState(ZE_RESULT_SUCCESS); + auto rootDeviceMetricEnumeration = static_cast(&rootDeviceOaSourceImp.getMetricEnumeration()); + rootDeviceMetricEnumeration->setInitializationState(ZE_RESULT_SUCCESS); + const uint32_t subDeviceCount = static_cast(deviceImp.subDevices.size()); + + for (uint32_t i = 0; i < subDeviceCount; i++) { + subDevices.push_back(deviceImp.subDevices[i]); + auto deviceContext = new MetricDeviceContext(*deviceImp.subDevices[i]); + auto oaMetricSource = static_cast(&deviceContext->getMetricSource()); + auto metricEnumeration = static_cast(&oaMetricSource->getMetricEnumeration()); + metricEnumeration->setAdapterGroup(&mockAdapterGroup); + oaMetricSource->setInitializationState(ZE_RESULT_SUCCESS); + metricEnumeration->setInitializationState(ZE_RESULT_SUCCESS); + + MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = static_cast(mockConcurrentGroup); + EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1)); + static_cast(deviceImp.subDevices[i])->metricContext.reset(deviceContext); + } +} + +using OaMultiDeviceMetricProgrammableTests = OaMultiDeviceMetricProgrammableFixture; + +TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricProgrammableIsSupportedThenValidHandlesAreReturned) { + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, &programmable)); + zet_metric_programmable_exp_properties_t properties{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetPropertiesExp(programmable, &properties)); + EXPECT_STREQ(properties.component, "GroupName"); + EXPECT_STREQ(properties.description, "LongName"); + EXPECT_STREQ(properties.name, "SymbolName"); + EXPECT_EQ(properties.domain, 1u); + EXPECT_EQ(properties.tierNumber, 1u); + EXPECT_EQ(properties.samplingType, ZET_INTEL_METRIC_SAMPLING_TYPE_EXP_FLAG_TIME_AND_EVENT_BASED); +} + +TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricProgrammableThenCorrectParamerterInfoIsReturned) { + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, &programmable)); + ASSERT_NE(programmable, nullptr); + zet_metric_programmable_param_info_exp_t parameterInfo[4]; + uint32_t parameterCount = 6; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetParamInfoExp(programmable, ¶meterCount, parameterInfo)); + EXPECT_EQ(parameterCount, 4u); + + EXPECT_EQ(parameterInfo[0].defaultValue.ui64, UINT64_MAX); + EXPECT_STREQ(parameterInfo[0].name, "mockParam1"); + EXPECT_EQ(parameterInfo[0].type, ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_DISAGGREGATION); + EXPECT_EQ(parameterInfo[0].valueInfoCount, 1u); + EXPECT_EQ(parameterInfo[0].valueInfoType, ZET_VALUE_INFO_TYPE_EXP_UINT32); + + EXPECT_EQ(parameterInfo[1].defaultValue.ui64, 0u); + EXPECT_STREQ(parameterInfo[1].name, "mockParam2"); + EXPECT_EQ(parameterInfo[1].type, ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_LATENCY); + EXPECT_EQ(parameterInfo[1].valueInfoCount, 1u); + EXPECT_EQ(parameterInfo[1].valueInfoType, ZET_VALUE_INFO_TYPE_EXP_UINT64); + + EXPECT_EQ(parameterInfo[2].defaultValue.ui64, 0u); + EXPECT_STREQ(parameterInfo[2].name, "mockParam3"); + EXPECT_EQ(parameterInfo[2].type, ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_NORMALIZATION_UTILIZATION); + EXPECT_EQ(parameterInfo[2].valueInfoCount, 1u); + EXPECT_EQ(parameterInfo[2].valueInfoType, ZET_VALUE_INFO_TYPE_EXP_UINT64_RANGE); + + EXPECT_EQ(parameterInfo[3].defaultValue.ui64, 0u); + EXPECT_STREQ(parameterInfo[3].name, "mockParam4"); + EXPECT_EQ(parameterInfo[3].type, static_cast(ZET_INTEL_METRIC_PROGRAMMABLE_PARAM_TYPE_NORMALIZATION_BYTE_EXP)); // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange), NEO-12901 + EXPECT_EQ(parameterInfo[3].valueInfoCount, 1u); + EXPECT_EQ(parameterInfo[3].valueInfoType, ZET_VALUE_INFO_TYPE_EXP_UINT64_RANGE); +} + +TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricProgrammableThenCorrectParamerterValueInfoIsReturned) { + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, &programmable)); + ASSERT_NE(programmable, nullptr); + std::vector parameterInfo(4); + uint32_t parameterCount = 2; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetParamInfoExp(programmable, ¶meterCount, parameterInfo.data())); + uint32_t valueInfoCount = 2; + zet_metric_programmable_param_value_info_exp_t valueInfo{}; + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetParamValueInfoExp(programmable, 0, &valueInfoCount, &valueInfo)); + EXPECT_EQ(valueInfoCount, 1u); + EXPECT_EQ(valueInfo.valueInfo.ui32, 1u); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetParamValueInfoExp(programmable, 1, &valueInfoCount, &valueInfo)); + EXPECT_EQ(valueInfoCount, 1u); + EXPECT_EQ(valueInfo.valueInfo.ui64, 2u); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetParamValueInfoExp(programmable, 2, &valueInfoCount, &valueInfo)); + EXPECT_EQ(valueInfoCount, 1u); + EXPECT_EQ(valueInfo.valueInfo.ui64Range.ui64Min, 3u); + EXPECT_EQ(valueInfo.valueInfo.ui64Range.ui64Max, 4u); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetParamValueInfoExp(programmable, 3, &valueInfoCount, &valueInfo)); + EXPECT_EQ(valueInfoCount, 1u); + EXPECT_EQ(valueInfo.valueInfo.ui64Range.ui64Min, 5u); + EXPECT_EQ(valueInfo.valueInfo.ui64Range.ui64Max, 6u); +} + +TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricProgrammableWhenCreateMetricIsCalledThenValidMetricHandleIsReturned) { + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, &programmable)); + const char *metricName = "MetricName"; + const char *metricDesc = "MetricDesc"; + uint32_t metricHandleCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, metricName, metricDesc, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle = nullptr; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, metricName, metricDesc, &metricHandleCount, &metricHandle)); + EXPECT_NE(metricHandle, nullptr); + zet_metric_properties_t metricProperties{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGetProperties(metricHandle, &metricProperties)); + EXPECT_STREQ(metricProperties.name, metricName); + EXPECT_STREQ(metricProperties.description, metricDesc); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle)); +} + +TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricsWhenMetricGroupIsCreatedFromThemThenValidMetricGroupIsReturned) { + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, &programmable)); + const char *metricName = "MetricName"; + const char *metricDesc = "MetricDesc"; + uint32_t metricHandleCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, metricName, metricDesc, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle = nullptr; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, metricName, metricDesc, &metricHandleCount, &metricHandle)); + EXPECT_NE(metricHandle, nullptr); + uint32_t metricGroupCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_GT(metricGroupCount, 0u); + std::vector metricGroupHandles(metricGroupCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data())); + EXPECT_NE(metricGroupHandles[0], nullptr); + zet_metric_group_properties_t metricGroupProperties{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupGetProperties(metricGroupHandles[0], &metricGroupProperties)); + + for (uint32_t index = 0; index < metricGroupCount; index++) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroupHandles[index])); + } + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle)); +} + +TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricsWhenMetricGroupCreationFailsInOneOfTheSubDeviceThenErrorIsReturned) { + MockIMetricSet1x13::addMetricCallCount = 0; + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList.resize(3); + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[0] = MetricsDiscovery::CC_OK; + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[1] = MetricsDiscovery::CC_OK; + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[2] = MetricsDiscovery::CC_ERROR_GENERAL; + + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, &programmable)); + const char *metricName = "MetricName"; + const char *metricDesc = "MetricDesc"; + uint32_t metricHandleCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, metricName, metricDesc, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle = nullptr; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, metricName, metricDesc, &metricHandleCount, &metricHandle)); + EXPECT_NE(metricHandle, nullptr); + uint32_t metricGroupCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_GT(metricGroupCount, 0u); + std::vector metricGroupHandles(metricGroupCount); + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data())); + EXPECT_EQ(metricGroupHandles[0], nullptr); + + for (uint32_t index = 0; index < metricGroupCount; index++) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroupHandles[index])); + } + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle)); + + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList.resize(1); + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[0] = MetricsDiscovery::CC_OK; + MockIMetricSet1x13::addMetricCallCount = 0; + MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet); +} + +TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricsWhenMetricGroupCreationReturnsDifferentGroupCountForDifferentSubDevicesThenErrorIsReturned) { + + MockIMetricSet1x13::addMetricCallCount = 0; + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList.resize(7); + // 1st Group creation - OK + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[0] = MetricsDiscovery::CC_OK; + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[1] = MetricsDiscovery::CC_OK; + + // 2nd Group creation - OK + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[2] = MetricsDiscovery::CC_OK; + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[3] = MetricsDiscovery::CC_OK; + + // 3rd Group creation + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[4] = MetricsDiscovery::CC_OK; + // fail during adding 2nd metric + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[5] = MetricsDiscovery::CC_ERROR_GENERAL; + // New Metric group created here + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[6] = MetricsDiscovery::CC_OK; + + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, &programmable)); + const char *metricName = "MetricName"; + const char *metricDesc = "MetricDesc"; + uint32_t metricHandleCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, metricName, metricDesc, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle[2] = {}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, metricName, metricDesc, &metricHandleCount, &metricHandle[0])); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, metricName, metricDesc, &metricHandleCount, &metricHandle[1])); + EXPECT_NE(metricHandle[0], nullptr); + EXPECT_NE(metricHandle[1], nullptr); + uint32_t metricGroupCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 2, metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_GT(metricGroupCount, 0u); + + std::vector metricGroupHandles(metricGroupCount); + EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, zetIntelDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 2, metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data())); + EXPECT_EQ(metricGroupHandles[0], nullptr); + EXPECT_EQ(metricGroupCount, 0u); + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle[0])); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle[1])); + + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList.resize(1); + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[0] = MetricsDiscovery::CC_OK; + MockIMetricSet1x13::addMetricCallCount = 0; + MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet); +} + +TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricGroupThenMetricGetReturnsSuccess) { + + zet_metric_programmable_exp_handle_t programmable{}; + getMetricProgrammable(programmable); + + zet_metric_handle_t metricHandle{}; + getMetricFromProgrammable(programmable, metricHandle); + + std::vector metricGroups{}; + createMetricGroupFromMetric(metricHandle, metricGroups); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGet(metricGroups[0], &count, nullptr)); + // Additional metrics added during close + EXPECT_EQ(count, 3u); + zet_metric_handle_t getMetric{}; + count = 1; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGet(metricGroups[0], &count, &getMetric)); + EXPECT_NE(getMetric, nullptr); + for (auto &metricGroup : metricGroups) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroup)); + } + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle)); +} + +TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricGroupWhenSubdevicesAddDifferentMetricCountsThenErrorIsObserved) { + + MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet); + mockConcurrentGroup.mockMetricSet.mockMetricCountList.resize(4); + // First Subdevice metric count + mockConcurrentGroup.mockMetricSet.mockMetricCountList[0] = 1; + mockConcurrentGroup.mockMetricSet.mockMetricCountList[1] = 1; + // Second Subdevice metric count + mockConcurrentGroup.mockMetricSet.mockMetricCountList[2] = 3; + mockConcurrentGroup.mockMetricSet.mockMetricCountList[3] = 3; + mockConcurrentGroup.mockMetricSet.mockInformationCount = 0; + + zet_metric_programmable_exp_handle_t programmable{}; + getMetricProgrammable(programmable); + zet_metric_handle_t metricHandle{}; + getMetricFromProgrammable(programmable, metricHandle); + std::vector metricGroupHandles{}; + + metricGroupHandles.clear(); + uint32_t metricGroupCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_GT(metricGroupCount, 0u); + metricGroupHandles.resize(metricGroupCount); + EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, zetIntelDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data())); + EXPECT_EQ(metricGroupCount, 0u); + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle)); + MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet); +} + +TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricGroupWhenMetricGroupCloseFailsForOneOfTheGroupThenErrorIsObserved) { + + MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet); + mockConcurrentGroup.mockMetricSet.mockMetricCountList.resize(6); + // Group0: First Subdevice metric count + mockConcurrentGroup.mockMetricSet.mockMetricCountList[0] = 1; + // Group0: Second Subdevice metric count + mockConcurrentGroup.mockMetricSet.mockMetricCountList[1] = 1; + // Group0: Third Subdevice metric count + mockConcurrentGroup.mockMetricSet.mockMetricCountList[2] = 1; + + // Group1: First Subdevice metric count + mockConcurrentGroup.mockMetricSet.mockMetricCountList[3] = 1; + // Group1: Second Subdevice metric count + mockConcurrentGroup.mockMetricSet.mockMetricCountList[4] = 1; + // Group1: Third Subdevice metric count + mockConcurrentGroup.mockMetricSet.mockMetricCountList[5] = 3; + mockConcurrentGroup.mockMetricSet.mockInformationCount = 0; + + zet_metric_programmable_exp_handle_t programmable{}; + getMetricProgrammable(programmable); + zet_metric_handle_t metricHandle{}; + getMetricFromProgrammable(programmable, metricHandle); + std::vector metricGroupHandles{}; + + metricGroupHandles.clear(); + uint32_t metricGroupCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_GT(metricGroupCount, 0u); + metricGroupHandles.resize(metricGroupCount); + EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, zetIntelDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data())); + EXPECT_EQ(metricGroupCount, 0u); + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle)); + MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet); +} + +TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricGroupWhenCloseDoesNotAddNewMetricsThenMetricCountIsCorrect) { + + mockConcurrentGroup.mockMetricSet.mockMetricCountList.resize(1); + mockConcurrentGroup.mockMetricSet.mockMetricCountList[0] = 1; + mockConcurrentGroup.mockMetricSet.mockInformationCount = 0; + + zet_metric_programmable_exp_handle_t programmable{}; + getMetricProgrammable(programmable); + + zet_metric_handle_t metricHandle{}; + getMetricFromProgrammable(programmable, metricHandle); + + std::vector metricGroups{}; + createMetricGroupFromMetric(metricHandle, metricGroups); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGet(metricGroups[0], &count, nullptr)); + + EXPECT_EQ(count, 1u); + zet_metric_handle_t getMetric{}; + count = 1; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGet(metricGroups[0], &count, &getMetric)); + EXPECT_NE(getMetric, nullptr); + for (auto &metricGroup : metricGroups) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroup)); + } + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle)); + MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet); +} + +TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricGroupThenAddAndRemoveMetricReturnsSuccess) { + zet_metric_programmable_exp_handle_t programmable{}; + getMetricProgrammable(programmable); + zet_metric_handle_t metricHandle{}; + getMetricFromProgrammable(programmable, metricHandle); + std::vector metricGroups{}; + createMetricGroupFromMetric(metricHandle, metricGroups); + + zet_metric_handle_t metricHandle1{}; + getMetricFromProgrammable(programmable, metricHandle1); + + size_t errorStringSize = 0; + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroups[0], metricHandle1, &errorStringSize, nullptr)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupRemoveMetricExp(metricGroups[0], metricHandle1)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupRemoveMetricExp(metricGroups[0], metricHandle1)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupCloseExp(metricGroups[0])); + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroups[0], metricHandle1, &errorStringSize, nullptr)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupRemoveMetricExp(metricGroups[0], metricHandle1)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupCloseExp(metricGroups[0])); + + for (uint32_t index = 0; index < static_cast(metricGroups.size()); index++) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroups[index])); + } + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle1)); +} + +TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricGroupWhenAddMetricFailsForOneOfTheSubDevicesThenReturnFailure) { + zet_metric_programmable_exp_handle_t programmable{}; + getMetricProgrammable(programmable); + zet_metric_handle_t metricHandle{}; + getMetricFromProgrammable(programmable, metricHandle); + std::vector metricGroups{}; + createMetricGroupFromMetric(metricHandle, metricGroups); + + zet_metric_handle_t metricHandle1{}; + getMetricFromProgrammable(programmable, metricHandle1); + + size_t errorStringSize = 0; + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroups[0], metricHandle1, &errorStringSize, nullptr)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupRemoveMetricExp(metricGroups[0], metricHandle1)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupCloseExp(metricGroups[0])); + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroups[0], metricHandle1, &errorStringSize, nullptr)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupRemoveMetricExp(metricGroups[0], metricHandle1)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupCloseExp(metricGroups[0])); + + for (uint32_t index = 0; index < static_cast(metricGroups.size()); index++) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroups[index])); + } + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle1)); +} + +TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricGroupWhenAddAndRemoveMetricIsCalledWithIncorrectMetricThenReturnFailure) { + zet_metric_programmable_exp_handle_t programmable{}; + getMetricProgrammable(programmable); + zet_metric_handle_t metricHandle{}; + getMetricFromProgrammable(programmable, metricHandle); + std::vector metricGroups{}; + createMetricGroupFromMetric(metricHandle, metricGroups); + + MockMetricSource metricSource{}; + MockMetric mockMetric(metricSource); + mockMetric.setMultiDevice(false); + mockMetric.setPredefined(false); + + size_t errorStringSize = 0; + + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetMetricGroupAddMetricExp(metricGroups[0], mockMetric.toHandle(), &errorStringSize, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetMetricGroupRemoveMetricExp(metricGroups[0], mockMetric.toHandle())); + + mockMetric.setMultiDevice(true); + mockMetric.setPredefined(true); + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetMetricGroupAddMetricExp(metricGroups[0], mockMetric.toHandle(), &errorStringSize, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetMetricGroupRemoveMetricExp(metricGroups[0], mockMetric.toHandle())); + + for (uint32_t index = 0; index < static_cast(metricGroups.size()); index++) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroups[index])); + } + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle)); +} + +TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricGroupWhenAddMetricIsCalledAndOneSubDeviceFailsThenReturnFailure) { + + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, &programmable)); + const char *metricName = "MetricName"; + const char *metricDesc = "MetricDesc"; + uint32_t metricHandleCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, metricName, metricDesc, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle[2] = {}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, metricName, metricDesc, &metricHandleCount, &metricHandle[0])); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, metricName, metricDesc, &metricHandleCount, &metricHandle[1])); + EXPECT_NE(metricHandle[0], nullptr); + EXPECT_NE(metricHandle[1], nullptr); + uint32_t metricGroupCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_GT(metricGroupCount, 0u); + std::vector metricGroupHandles(metricGroupCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data())); + EXPECT_GT(metricGroupCount, 0u); + + // Prepare AddMetric return status for failure + MockIMetricSet1x13::addMetricCallCount = 0; + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList.resize(3); + // 1st Group + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[0] = MetricsDiscovery::CC_OK; + // 2nd Group + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[1] = MetricsDiscovery::CC_OK; + // 3rd Group + mockConcurrentGroup.mockMetricSet.mockAddMetricReturnCodeList[2] = MetricsDiscovery::CC_ERROR_GENERAL; + + size_t errorStringSize = 0; + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetMetricGroupAddMetricExp(metricGroupHandles[0], metricHandle[1], &errorStringSize, nullptr)); + + for (uint32_t index = 0; index < metricGroupCount; index++) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroupHandles[index])); + } + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle[0])); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle[1])); + + MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet); +} + +TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricGroupWhenRemoveMetricIsCalledAndOneSubDeviceFailsThenReturnFailure) { + + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, &programmable)); + const char *metricName = "MetricName"; + const char *metricDesc = "MetricDesc"; + uint32_t metricHandleCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, metricName, metricDesc, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle[2] = {}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, metricName, metricDesc, &metricHandleCount, &metricHandle[0])); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, metricName, metricDesc, &metricHandleCount, &metricHandle[1])); + EXPECT_NE(metricHandle[0], nullptr); + EXPECT_NE(metricHandle[1], nullptr); + uint32_t metricGroupCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 2, metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_GT(metricGroupCount, 0u); + std::vector metricGroupHandles(metricGroupCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 2, metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data())); + EXPECT_GT(metricGroupCount, 0u); + + MockIMetricSet1x13::removeMetricCallCount = 0; + mockConcurrentGroup.mockMetricSet.mockRemoveMetricReturnCodeList.resize(3); + // 1st Group + mockConcurrentGroup.mockMetricSet.mockRemoveMetricReturnCodeList[0] = MetricsDiscovery::CC_OK; + // 2nd Group + mockConcurrentGroup.mockMetricSet.mockRemoveMetricReturnCodeList[1] = MetricsDiscovery::CC_OK; + // 3rd Group + mockConcurrentGroup.mockMetricSet.mockRemoveMetricReturnCodeList[2] = MetricsDiscovery::CC_ERROR_GENERAL; + + EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, zetMetricGroupRemoveMetricExp(metricGroupHandles[0], metricHandle[1])); + + for (uint32_t index = 0; index < metricGroupCount; index++) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroupHandles[index])); + } + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle[0])); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle[1])); + + MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet); + MockIMetricSet1x13::addMetricCallCount = 0; +} + +TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricGroupWhenCloseIsCalledAndOneSubDeviceFailsThenReturnFailure) { + + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, &programmable)); + const char *metricName = "MetricName"; + const char *metricDesc = "MetricDesc"; + uint32_t metricHandleCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, metricName, metricDesc, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle[2] = {}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, metricName, metricDesc, &metricHandleCount, &metricHandle[0])); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, metricName, metricDesc, &metricHandleCount, &metricHandle[1])); + EXPECT_NE(metricHandle[0], nullptr); + EXPECT_NE(metricHandle[1], nullptr); + uint32_t metricGroupCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_GT(metricGroupCount, 0u); + std::vector metricGroupHandles(metricGroupCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data())); + EXPECT_GT(metricGroupCount, 0u); + size_t errorStringSize = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupAddMetricExp(metricGroupHandles[0], metricHandle[1], &errorStringSize, nullptr)); + + MockIMetricSet1x13::closeCallCount = 0; + mockConcurrentGroup.mockMetricSet.mockCloseReturnCodeList.resize(3); + // 1st Group + mockConcurrentGroup.mockMetricSet.mockCloseReturnCodeList[0] = MetricsDiscovery::CC_OK; + // 2nd Group + mockConcurrentGroup.mockMetricSet.mockCloseReturnCodeList[1] = MetricsDiscovery::CC_ERROR_GENERAL; + // 3rd Group + mockConcurrentGroup.mockMetricSet.mockCloseReturnCodeList[2] = MetricsDiscovery::CC_OK; + EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, zetMetricGroupCloseExp(metricGroupHandles[0])); + + for (uint32_t index = 0; index < metricGroupCount; index++) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroupHandles[index])); + } + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle[0])); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle[1])); + + MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet); +} + +TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricGroupWhenCreateIsCalledAndCloseForOneSubDeviceFailsThenReturnFailure) { + + MockIMetricSet1x13::closeCallCount = 0; + mockConcurrentGroup.mockMetricSet.mockCloseReturnCodeList.resize(3); + // 1st Group + mockConcurrentGroup.mockMetricSet.mockCloseReturnCodeList[0] = MetricsDiscovery::CC_OK; + // 2nd Group + mockConcurrentGroup.mockMetricSet.mockCloseReturnCodeList[1] = MetricsDiscovery::CC_OK; + // 3rd Group + mockConcurrentGroup.mockMetricSet.mockCloseReturnCodeList[2] = MetricsDiscovery::CC_ERROR_GENERAL; + + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, &programmable)); + const char *metricName = "MetricName"; + const char *metricDesc = "MetricDesc"; + uint32_t metricHandleCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, metricName, metricDesc, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle[2] = {}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, metricName, metricDesc, &metricHandleCount, &metricHandle[0])); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, metricName, metricDesc, &metricHandleCount, &metricHandle[1])); + EXPECT_NE(metricHandle[0], nullptr); + EXPECT_NE(metricHandle[1], nullptr); + uint32_t metricGroupCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_GT(metricGroupCount, 0u); + std::vector metricGroupHandles(metricGroupCount); + EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, zetIntelDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data())); + EXPECT_EQ(metricGroupCount, 0u); + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle[0])); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle[1])); + + MockIMetricSet1x13::resetMocks(&mockConcurrentGroup.mockMetricSet); +} + +TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricsWhenMetricIsDestroyedBeforeMetricGroupDestroyThenErrorInUseIsReturned) { + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, nullptr)); + EXPECT_EQ(count, 1u); + zet_metric_programmable_exp_handle_t programmable{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetExp(rootDevice->toHandle(), &count, &programmable)); + const char *metricName = "MetricName"; + const char *metricDesc = "MetricDesc"; + uint32_t metricHandleCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, metricName, metricDesc, &metricHandleCount, nullptr)); + EXPECT_EQ(metricHandleCount, 1u); + zet_metric_handle_t metricHandle = nullptr; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricCreateFromProgrammableExp(programmable, nullptr, 0, metricName, metricDesc, &metricHandleCount, &metricHandle)); + EXPECT_NE(metricHandle, nullptr); + uint32_t metricGroupCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); + EXPECT_GT(metricGroupCount, 0u); + std::vector metricGroupHandles(metricGroupCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelDeviceCreateMetricGroupsFromMetricsExp(rootDevice->toHandle(), 1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, metricGroupHandles.data())); + EXPECT_NE(metricGroupHandles[0], nullptr); + zet_metric_group_properties_t metricGroupProperties{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupGetProperties(metricGroupHandles[0], &metricGroupProperties)); + + EXPECT_EQ(ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE, zetMetricDestroyExp(metricHandle)); + + for (uint32_t index = 0; index < metricGroupCount; index++) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupDestroyExp(metricGroupHandles[index])); + } + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricDestroyExp(metricHandle)); +} + +struct MockMetricProgrammable : public MetricProgrammable { + + MockMetricSource metricSource{}; + std::vector allocatedMetricObjects{}; + + ~MockMetricProgrammable() override { + for (auto &metric : allocatedMetricObjects) { + delete metric; + } + allocatedMetricObjects.clear(); + } + + ze_result_t createMetricReturnStatus = ZE_RESULT_SUCCESS; + uint32_t createMetricReturnHandleCount = 2; + + ze_result_t getProperties(zet_metric_programmable_exp_properties_t *pProperties) override { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + } + ze_result_t getParamInfo(uint32_t *pParameterCount, zet_metric_programmable_param_info_exp_t *pParameterInfo) override { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + } + ze_result_t getParamValueInfo(uint32_t parameterOrdinal, uint32_t *pValueInfoCount, + zet_metric_programmable_param_value_info_exp_t *pValueInfo) override { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + } + ze_result_t createMetric(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) override { + + if (*pMetricHandleCount == 0) { + *pMetricHandleCount = createMetricReturnHandleCount; + return createMetricReturnStatus; + } + + *pMetricHandleCount = std::min(*pMetricHandleCount, createMetricReturnHandleCount); + prepareMetricObjects(*pMetricHandleCount); + + for (uint32_t index = 0; index < *pMetricHandleCount; index++) { + *phMetricHandles++ = allocatedMetricObjects[index]; + } + + return createMetricReturnStatus; + } + + void prepareMetricObjects(uint32_t metricHandleCount) { + + bool additionalAllocationNecessary = metricHandleCount > static_cast(allocatedMetricObjects.size()); + if (additionalAllocationNecessary) { + uint32_t additionalAllocations = metricHandleCount - static_cast(allocatedMetricObjects.size()); + for (uint32_t index = 0; index < additionalAllocations; index++) { + auto mockMetric = new MockMetric(metricSource); + mockMetric->destroyReturn = ZE_RESULT_SUCCESS; + allocatedMetricObjects.push_back(mockMetric); + } + } + } +}; + +TEST(HomogeneousMultiDeviceMetricProgrammableTest, givenSubDevicesReturnNonHomogenousMetricsWhenCreateMetricsIsCalledThenErrorIsReturned) { + + MockMetricSource mockMetricSource{}; + MockMetricProgrammable mockSubDeviceProgrammables[2]; + std::vector subDeviceProgrammables{}; + subDeviceProgrammables.push_back(&mockSubDeviceProgrammables[0]); + subDeviceProgrammables.push_back(&mockSubDeviceProgrammables[1]); + + MetricProgrammable *multiDeviceProgrammable = HomogeneousMultiDeviceMetricProgrammable::create(mockMetricSource, subDeviceProgrammables); + const char *name = "name"; + const char *desc = "desc"; + uint32_t metricHandleCount = 0; + mockSubDeviceProgrammables[0].createMetricReturnHandleCount = 2; + mockSubDeviceProgrammables[1].createMetricReturnHandleCount = 3; + EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, multiDeviceProgrammable->createMetric(nullptr, 0, name, desc, &metricHandleCount, nullptr)); + + mockSubDeviceProgrammables[0].createMetricReturnHandleCount = 2; + mockSubDeviceProgrammables[1].createMetricReturnHandleCount = 3; + metricHandleCount = 4; + std::vector metricHandles(metricHandleCount); + EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, multiDeviceProgrammable->createMetric(nullptr, 0, name, desc, &metricHandleCount, metricHandles.data())); + + mockSubDeviceProgrammables[0].createMetricReturnHandleCount = 3; + mockSubDeviceProgrammables[0].prepareMetricObjects(3); + static_cast(mockSubDeviceProgrammables[0].allocatedMetricObjects[0])->destroyReturn = ZE_RESULT_SUCCESS; + mockSubDeviceProgrammables[1].createMetricReturnHandleCount = 3; + metricHandleCount = 4; + EXPECT_EQ(ZE_RESULT_SUCCESS, multiDeviceProgrammable->createMetric(nullptr, 0, name, desc, &metricHandleCount, metricHandles.data())); + EXPECT_EQ(metricHandleCount, 3u); + + for (uint32_t index = 0; index < metricHandleCount; index++) { + zetMetricDestroyExp(metricHandles[index]); + } + + delete multiDeviceProgrammable; +} + +TEST(HomogeneousMultiDeviceMetricProgrammableTest, givenSubDevicesReturnErrorWhenCreateMetricsIsCalledThenErrorIsReturned) { + + MockMetricSource mockMetricSource{}; + MockMetricProgrammable mockSubDeviceProgrammables[2]; + std::vector subDeviceProgrammables{}; + subDeviceProgrammables.push_back(&mockSubDeviceProgrammables[0]); + subDeviceProgrammables.push_back(&mockSubDeviceProgrammables[1]); + + MetricProgrammable *multiDeviceProgrammable = HomogeneousMultiDeviceMetricProgrammable::create(mockMetricSource, subDeviceProgrammables); + const char *name = "name"; + const char *desc = "desc"; + uint32_t metricHandleCount = 0; + mockSubDeviceProgrammables[0].createMetricReturnHandleCount = 2; + mockSubDeviceProgrammables[1].createMetricReturnHandleCount = 3; + mockSubDeviceProgrammables[1].createMetricReturnStatus = ZE_RESULT_ERROR_INVALID_ARGUMENT; + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, multiDeviceProgrammable->createMetric(nullptr, 0, name, desc, &metricHandleCount, nullptr)); + + mockSubDeviceProgrammables[0].createMetricReturnHandleCount = 2; + mockSubDeviceProgrammables[1].createMetricReturnHandleCount = 3; + mockSubDeviceProgrammables[1].createMetricReturnStatus = ZE_RESULT_ERROR_INVALID_ARGUMENT; + metricHandleCount = 4; + std::vector metricHandles(metricHandleCount); + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, multiDeviceProgrammable->createMetric(nullptr, 0, name, desc, &metricHandleCount, metricHandles.data())); + + delete multiDeviceProgrammable; +} + +TEST(HomogeneousMultiDeviceMetricProgrammableTest, givenSubDevicesReturnZeroMetricWhenCreateMetricsIsCalledThenSuccessIsReturned) { + + MockMetricSource mockMetricSource{}; + MockMetricProgrammable mockSubDeviceProgrammables[2]; + std::vector subDeviceProgrammables{}; + subDeviceProgrammables.push_back(&mockSubDeviceProgrammables[0]); + subDeviceProgrammables.push_back(&mockSubDeviceProgrammables[1]); + + MetricProgrammable *multiDeviceProgrammable = HomogeneousMultiDeviceMetricProgrammable::create(mockMetricSource, subDeviceProgrammables); + const char *name = "name"; + const char *desc = "desc"; + uint32_t metricHandleCount = 0; + mockSubDeviceProgrammables[0].createMetricReturnHandleCount = 0; + mockSubDeviceProgrammables[1].createMetricReturnHandleCount = 0; + mockSubDeviceProgrammables[1].createMetricReturnStatus = ZE_RESULT_SUCCESS; + EXPECT_EQ(ZE_RESULT_SUCCESS, multiDeviceProgrammable->createMetric(nullptr, 0, name, desc, &metricHandleCount, nullptr)); + + mockSubDeviceProgrammables[0].createMetricReturnHandleCount = 0; + mockSubDeviceProgrammables[1].createMetricReturnHandleCount = 0; + mockSubDeviceProgrammables[1].createMetricReturnStatus = ZE_RESULT_SUCCESS; + metricHandleCount = 4; + std::vector metricHandles(metricHandleCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, multiDeviceProgrammable->createMetric(nullptr, 0, name, desc, &metricHandleCount, metricHandles.data())); + + delete multiDeviceProgrammable; +} + +TEST(HomogeneousMultiDeviceMetricTest, givenMultiDeviceMetricWhenDestroyIsCalledThenUnsupportedFeatureIsReturned) { + + MockMetricSource mockSource; + MockMetric mockMetric(mockSource); + std::vector mockMetrics{&mockMetric}; + MultiDeviceMetricImp *multiDevMetric = static_cast( + MultiDeviceMetricImp::create(mockSource, mockMetrics)); + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, multiDevMetric->destroy()); + delete multiDevMetric; +} + +struct MultiDeviceCreatedMetricGroupManagerTest : public MultiDeviceFixture, + + public ::testing::Test { + void SetUp() override { + MultiDeviceFixture::numRootDevices = 1; + MultiDeviceFixture::numSubDevices = 2; + debugManager.flags.EnableProgrammableMetricsSupport.set(1); + MultiDeviceFixture::setUp(); + rootDevice = driverHandle->devices[0]; + rootDeviceMetricContext = &(static_cast(rootDevice)->getMetricDeviceContext()); + } + + void TearDown() override { + MultiDeviceFixture::tearDown(); + } + + DebugManagerStateRestore restorer; + Device *rootDevice = nullptr; + MetricDeviceContext *rootDeviceMetricContext = nullptr; +}; + +struct DummyMetricGroup : public MockMetricGroup { + static DummyMetricGroup *create(MetricSource &metricSource, + std::vector &subDeviceMetricGroups, + std::vector &multiDeviceMetrics) { + return nullptr; + } +}; + +TEST_F(MultiDeviceCreatedMetricGroupManagerTest, givenMetricFromSubDeviceIsUsedWhenCreateMultipleFromHomogenousMetricsIsCalledThenErrorIsReturned) { + + MockMetricSource mockMetricSource{}; + MockMetric metric(mockMetricSource); + metric.setMultiDevice(false); + + uint32_t metricGroupFromMetricsCount = 0; + auto metricHandle = metric.toHandle(); + std::vector metricGroups{}; + std::vector metrics(1); + metrics[0] = metricHandle; + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, MultiDeviceCreatedMetricGroupManager::createMultipleMetricGroupsFromMetrics( + *rootDeviceMetricContext, mockMetricSource, + metrics, "name", "desc", &metricGroupFromMetricsCount, metricGroups)); + EXPECT_EQ(metricGroupFromMetricsCount, 0u); +} + +} // namespace ult +} // namespace L0 diff --git a/shared/source/debug_settings/debug_variables_base.inl b/shared/source/debug_settings/debug_variables_base.inl index 29a609ace4..528bc30934 100644 --- a/shared/source/debug_settings/debug_variables_base.inl +++ b/shared/source/debug_settings/debug_variables_base.inl @@ -468,6 +468,7 @@ DECLARE_DEBUG_VARIABLE(bool, ForceSamplerLowFilteringPrecision, false, "Force Lo DECLARE_DEBUG_VARIABLE(bool, EnablePrivateBO, false, "Enable PRELIM_I915_GEM_CREATE_EXT_VM_PRIVATE extension creating VM_PRIVATE BOs") DECLARE_DEBUG_VARIABLE(bool, EnableAIL, true, "Enables AIL") DECLARE_DEBUG_VARIABLE(bool, EnableReservingInSvmRange, false, "Enables reserving virtual memory in the SVM range") +DECLARE_DEBUG_VARIABLE(bool, EnableProgrammableMetricsSupport, false, "Enable Programmable Metrics support") DECLARE_DEBUG_VARIABLE(int64_t, VmBindWaitUserFenceTimeout, -1, "-1: default, >0: time in ns for wait function timeout") DECLARE_DEBUG_VARIABLE(int32_t, ForceRunAloneContext, -1, "Control creation of run-alone HW context, -1:default, 0:disable, 1:enable") DECLARE_DEBUG_VARIABLE(int32_t, AddClGlSharing, -1, "Add cl-gl extension") diff --git a/shared/test/common/test_files/igdrcl.config b/shared/test/common/test_files/igdrcl.config index f786295357..a675bd992a 100644 --- a/shared/test/common/test_files/igdrcl.config +++ b/shared/test/common/test_files/igdrcl.config @@ -630,6 +630,7 @@ ForceNonWalkerSplitMemoryCopy = -1 FinalizerInputType = 0 FinalizerLibraryName = unk DirectSubmissionSwitchSemaphoreMode = -1 +EnableProgrammableMetricsSupport = 0 OverrideTimestampWidth = -1 IgnoreZebinUnknownAttributes = 0 DebugUmdFifoPollInterval = -1