refactor: support oa programmable metric group

Related-To: NEO-12184


Signed-off-by: Joshua Santosh Ranjan <joshua.santosh.ranjan@intel.com>

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<MetricDeviceContext &>(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"

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);

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<zet_structure_type_t>(0x00010006))
 #define ZET_INTEL_STRUCTURE_TYPE_EXPORT_DMA_PROPERTIES_EXP (static_cast<zet_structure_type_t>(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

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
 )

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;

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:

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<MetricSource *, std::vector<zet_metric_handle_t>> metricsPerMetricSourceMap{};
+    for (auto index = 0u; index < metricCount; index++) {
+
+        auto metricImp = static_cast<MetricImp *>(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<zet_metric_group_handle_t> 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<MetricProgrammable *> &subDeviceProgrammables) {
+    return static_cast<MetricProgrammable *>(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<std::vector<zet_metric_handle_t>> metricHandlesPerSubDeviceList{};
+    auto cleanupApi = [&]() {
+        for (auto &metricHandlesPerSubDevice : metricHandlesPerSubDeviceList) {
+            for (auto &metricHandle : metricHandlesPerSubDevice) {
+                if (metricHandle != nullptr) {
+                    [[maybe_unused]] auto status = static_cast<MetricImp *>(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<uint32_t>(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<uint32_t>(metricHandlesPerSubDeviceList[0].size()); index++) {
+        std::vector<MetricImp *> homogenousMetricList{};
+        homogenousMetricList.reserve(subDeviceProgrammables.size());
+        for (auto &metricHandlesPerSubdevice : metricHandlesPerSubDeviceList) {
+            homogenousMetricList.push_back(static_cast<MetricImp *>(Metric::fromHandle(metricHandlesPerSubdevice[index])));
+        }
+        phMetricHandles[index] = HomogeneousMultiDeviceMetricCreated::create(metricSource, homogenousMetricList)->toHandle();
+    }
+
+    *pMetricHandleCount = static_cast<uint32_t>(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<MetricImp *> &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<void *>(pValueInfo->pNext);
+    while (pNext != nullptr) {
+        auto baseProps = reinterpret_cast<zet_base_properties_t *>(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<zet_intel_metric_programmable_param_value_info_exp_desc_t *>(baseProps);
+            snprintf(infoDesc->description, sizeof(infoDesc->description), "%s", desc);
+            break;
+        }
+        pNext = const_cast<void *>(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<MetricDeviceContext &>(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

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 <level_zero/zet_api.h>
 
@@ -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<zet_metric_handle_t> &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<zet_metric_group_handle_t> &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<uint32_t, std::unique_ptr<MetricSource>> 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<MetricProgrammable *>(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<MetricProgrammable *> &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<MetricProgrammable *> &subDeviceProgrammables);
+
+  protected:
+    MetricSource &metricSource;
+    std::vector<MetricProgrammable *> subDeviceProgrammables{};
+};
+
+struct HomogeneousMultiDeviceMetricCreated : public MultiDeviceMetricImp {
+    ~HomogeneousMultiDeviceMetricCreated() override {}
+    HomogeneousMultiDeviceMetricCreated(MetricSource &metricSource, std::vector<MetricImp *> &subDeviceMetrics) : MultiDeviceMetricImp(metricSource, subDeviceMetrics) {
+        isPredefined = false;
+        isMultiDevice = true;
+    }
+    ze_result_t destroy() override;
+    static MetricImp *create(MetricSource &metricSource, std::vector<MetricImp *> &subDeviceMetrics);
+};
+
 // MetricGroup.
 ze_result_t metricGroupGet(zet_device_handle_t hDevice, uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups);
 

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> MetricDeviceContext::create(Device &device) {
     return std::make_unique<MetricDeviceContext>(device);
 }
 
-ze_result_t MetricDeviceContext::metricProgrammableGet(
-    uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables) {
-
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ze_result_t MetricDeviceContext::metricGroupCreate(const char name[ZET_MAX_METRIC_GROUP_NAME],
-                                                   const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION],
-                                                   zet_metric_group_sampling_type_flag_t samplingType,
-                                                   zet_metric_group_handle_t *pMetricGroupHandle) {
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ze_result_t OaMetricSourceImp::metricProgrammableGet(uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables) {
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ze_result_t 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

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<zet_metric_handle_t> &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<zet_metric_group_handle_t> &metricGroupList) override {
+        return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    }
+
     void setActivationTracker(MultiDomainDeferredActivationTracker *inputActivationTracker) {
         activationTracker.reset(inputActivationTracker);
     }

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<MetricGroupImp *> &subDeviceMetricGroupsCreated,
+                                                                           std::vector<MultiDeviceMetricImp *> &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<uint32_t>(multiDeviceMetrics.size());
+    } else {
+        *pCount = std::min(*pCount, static_cast<uint32_t>(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<MetricImp *>(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<HomogeneousMultiDeviceMetricCreated *>(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<uint32_t>(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<MetricImp *>(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<HomogeneousMultiDeviceMetricCreated *>(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<uint32_t>(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<uint32_t>(subDeviceMetricGroupsCreated.size());
+    std::vector<std::vector<zet_metric_handle_t>> 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<HomogeneousMultiDeviceMetricCreated *>(multiDeviceMetric);
+            auto matchingMetric = mutableMetric->getMetricAtSubDeviceIndex(0)->toHandle();
+            if (matchingMetric == subDeviceMetricHandle) {
+                return mutableMetric;
+            }
+        }
+        return static_cast<HomogeneousMultiDeviceMetricCreated *>(nullptr);
+    };
+
+    // Arrange metric handles based on sub-device handles
+    const uint32_t metricCountPerSubdevice = static_cast<uint32_t>(subDeviceMetricHandles[0].size());
+    std::vector<MultiDeviceMetricImp *> 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<MetricImp *> subDeviceMetrics(subDeviceCount);
+            for (uint32_t subDeviceIndex = 0; subDeviceIndex < subDeviceCount; subDeviceIndex++) {
+                subDeviceMetrics[subDeviceIndex] = static_cast<MetricImp *>(
+                    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<MetricImp *>(metric);
+    // Only destroy metrics added during Close. Other metrics are managed by application
+    if (metricImp->isImmutable()) {
+        delete metricImp;
+    }
+}
+
+} // namespace L0

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<MetricGroupImp *> &subDeviceMetricGroupsCreated,
+                                         std::vector<MultiDeviceMetricImp *> &multiDeviceMetrics);
+    template <typename T>
+    static ze_result_t createMultipleMetricGroupsFromMetrics(const MetricDeviceContext &metricDeviceContext,
+                                                             MetricSource &metricSource,
+                                                             std::vector<zet_metric_handle_t> &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<zet_metric_group_handle_t> &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<MetricGroupImp *> &subDeviceMetricGroupsCreated;
+    std::vector<MultiDeviceMetricImp *> &multiDeviceMetrics;
+};
+
+} // namespace L0

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 <typename T>
+ze_result_t MultiDeviceCreatedMetricGroupManager::createMultipleMetricGroupsFromMetrics(const MetricDeviceContext &metricDeviceContext,
+                                                                                        MetricSource &metricSource,
+                                                                                        std::vector<zet_metric_handle_t> &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<zet_metric_group_handle_t> &metricGroupList) {
+    const auto isCountCalculationPath = *maxMetricGroupCount == 0;
+
+    uint32_t subDeviceCount = static_cast<uint32_t>(static_cast<DeviceImp *>(&metricDeviceContext.getDevice())->subDevices.size());
+    std::vector<std::vector<zet_metric_group_handle_t>> metricGroupsPerSubDevice(subDeviceCount);
+
+    auto cleanupCreatedGroups = [](std::vector<zet_metric_group_handle_t> &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<zet_metric_handle_t> metricHandles(metricList.size());
+
+        // Collect the metric handles at each sub-device index
+        for (uint32_t inputMetricIndex = 0; inputMetricIndex < static_cast<uint32_t>(metricList.size()); inputMetricIndex++) {
+            auto &multiDeviceMetric = metricList[inputMetricIndex];
+            auto metricImp = static_cast<MetricImp *>(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<HomogeneousMultiDeviceMetricCreated *>(metricImp);
+            metricHandles[inputMetricIndex] = homogenousMetric->getMetricAtSubDeviceIndex(subDeviceIndex)->toHandle();
+        }
+
+        // Get the source from one of the Metrics
+        auto &subDeviceMetricSource = static_cast<MetricImp *>(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<uint32_t>(metricGroupsPerSubDevice[0].size()); groupIndex++) {
+        std::vector<MetricGroupImp *> metricGroupsAcrossSubDevices(subDeviceCount);
+        for (uint32_t subDeviceIndex = 0; subDeviceIndex < subDeviceCount; subDeviceIndex++) {
+            metricGroupsAcrossSubDevices[subDeviceIndex] = static_cast<MetricGroupImp *>(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{};
+        multiDeviceMetricImp.reserve(metricList.size());
+        for (auto &hMetric : metricList) {
+            multiDeviceMetricImp.push_back(static_cast<MultiDeviceMetricImp *>(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<uint32_t>(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<uint32_t>(metricGroupList.size());
+
+    return ZE_RESULT_SUCCESS;
+}
+
+} // namespace L0

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<MetricsDiscovery::IMetricPrototype_1_13 *> metricPrototypes(metricPrototypeCount);
+    metricEnumerator->GetMetricPrototypes(0, &metricPrototypeCount, metricPrototypes.data());
+    updateMetricProgrammablesFromPrototypes(concurrentGroup, metricPrototypes, domain);
+}
+
+void MetricEnumeration::updateMetricProgrammablesFromPrototypes(
+    MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup,
+    const std::vector<MetricsDiscovery::IMetricPrototype_1_13 *> &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<DeviceImp *>(&device);
+        MetricEnumeration &metricEnumeration = deviceImp.subDevices[0]->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>().getMetricEnumeration();
+        const uint32_t programmableCount = static_cast<uint32_t>(metricEnumeration.getProgrammables().size());
+        metricProgrammables.reserve(programmableCount);
+
+        for (uint32_t index = 0; index < programmableCount; index++) {
+            std::vector<MetricProgrammable *> subDeviceProgrammables{};
+            // Get metric programmables from all sub devices.
+            for (auto subDevice : deviceImp.subDevices) {
+                MetricEnumeration &subDeviceEnumeration = subDevice->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>().getMetricEnumeration();
+                subDeviceProgrammables.push_back(subDeviceEnumeration.getProgrammables()[index]);
+            }
+            metricProgrammables.push_back(HomogeneousMultiDeviceMetricProgrammable::create(metricSource, subDeviceProgrammables));
+        }
+    }
+
+    if (*pCount == 0) {
+        *pCount = static_cast<uint32_t>(metricProgrammables.size());
+        return ZE_RESULT_SUCCESS;
+    }
+
+    *pCount = std::min<uint32_t>(*pCount, static_cast<uint32_t>(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<Metric *> &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<Metric *> &metrics,
                                       MetricSource &metricSource) {
     auto pMetricGroup = new OaMetricGroupImp(metricSource);

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<MetricProgrammable *> &getProgrammables() {
+        return metricProgrammables;
+    }
 
-    virtual void cleanupExtendedMetricInformation() {}
-
-  protected:
     OaMetricSourceImp &metricSource;
     std::vector<MetricGroup *> metricGroups; // Cached metric groups
+    std::vector<MetricProgrammable *> metricProgrammables{};
     ze_result_t initializationState = ZE_RESULT_ERROR_UNINITIALIZED;
 
     // Metrics Discovery API.
     std::unique_ptr<NEO::OsLibrary> 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<MetricsDiscovery::IMetricPrototype_1_13 *> &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<Metric *> &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<Metric *> &metrics,
                                MetricSource &metricSource);
     OaMetricSourceImp *getMetricSource() const { return static_cast<OaMetricSourceImp *>(&metricSource); }
@@ -218,7 +240,7 @@ struct OaMetricGroupImp : public MetricGroupImp {
     std::vector<Metric *> 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<MetricGroupImp *> metricGroups;
     size_t cachedExportDataHeapSize = 0;

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 <algorithm>
+#include <cstring>
+#include <vector>
+
+namespace L0 {
+
+static const std::map<MetricsDiscovery::TOptionDescriptorType, zet_metric_programmable_param_type_exp_t> 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_metric_programmable_param_type_exp_t>(ZET_INTEL_METRIC_PROGRAMMABLE_PARAM_TYPE_NORMALIZATION_BYTE_EXP)}};
+
+static const std::map<MetricsDiscovery::TOptionDescriptorType, uint64_t> 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<MetricsDiscovery::TValueType, zet_value_info_type_exp_t> 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<OaMetricSourceImp *>(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<OaMetricSourceImp &>(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<Metric *> groupMetrics{};
+    pMetricGroup->initialize(properties, metricSet, concurrentGroup, groupMetrics, static_cast<OaMetricSourceImp &>(metricSource));
+
+    UNRECOVERABLE_IF(pMetricGroup == nullptr);
+
+    return pMetricGroup;
+}
+
+void OaMetricGroupUserDefined::removeMetrics(bool immutable, std::vector<Metric *> &removedMetricList) {
+    removedMetricList.clear();
+
+    for (auto &metric : metrics) {
+        if (immutable == static_cast<OaMetricImp *>(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<MetricImp *>(Metric::fromHandle(hMetric));
+    if (metricImp->getMetricSource().getType() != MetricSource::metricSourceTypeOa) {
+        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    auto metric = static_cast<OaMetricImp *>(Metric::fromHandle(hMetric));
+    if (metric->isImmutable()) {
+        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    auto metricFromProgrammable = static_cast<OaMetricFromProgrammable *>(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<Metric *> 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<MetricImp *>(Metric::fromHandle(hMetric));
+    if (metricImp->getMetricSource().getType() != MetricSource::metricSourceTypeOa) {
+        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    auto metric = static_cast<OaMetricImp *>(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<Metric *> 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<OaMetricFromProgrammable *>(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<int32_t>(defaultMetricCount - 1); i >= 0; i--) {
+        auto mdapiMetric = metricSet->GetMetric(static_cast<uint32_t>(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<uint32_t>(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<Metric *> removedMetricList{};
+    removeMetrics(false, removedMetricList);
+    for (auto mutableMetric : removedMetricList) {
+        auto metricFromProgrammable = static_cast<OaMetricFromProgrammable *>(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<MetricGroupImp *> &subDeviceMetricGroups,
+    std::vector<MultiDeviceMetricImp *> &inMultiDeviceMetrics) {
+    auto metricGroupUserDefined = new OaMultiDeviceMetricGroupUserDefined(metricSource);
+    metricGroupUserDefined->metricGroups = subDeviceMetricGroups;
+    metricGroupUserDefined->multiDeviceMetrics = inMultiDeviceMetrics;
+
+    metricGroupUserDefined->createdMetricGroupManager = std::make_unique<MultiDeviceCreatedMetricGroupManager>(
+        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

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 <vector>
+
+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<Metric *> &removedMetricList);
+    MetricsDiscovery::IMetricSet_1_13 *getMetricSet() {
+        return static_cast<MetricsDiscovery::IMetricSet_1_13 *>(pReferenceMetricSet);
+    }
+};
+
+struct OaMultiDeviceMetricGroupUserDefined : OaMetricGroupImp {
+
+    OaMultiDeviceMetricGroupUserDefined(MetricSource &metricSource) : OaMetricGroupImp(metricSource) {}
+    static OaMultiDeviceMetricGroupUserDefined *create(MetricSource &metricSource,
+                                                       std::vector<MetricGroupImp *> &subDeviceMetricGroups,
+                                                       std::vector<MultiDeviceMetricImp *> &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<MultiDeviceCreatedMetricGroupManager> createdMetricGroupManager = nullptr;
+    std::vector<MultiDeviceMetricImp *> multiDeviceMetrics{};
+};
+
+} // namespace L0

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<zet_metric_group_sampling_type_flag_t>(samplingType), &hMetricGroup);
+
+    auto oaMetricGroupImp = static_cast<OaMetricGroupUserDefined *>(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<zet_metric_handle_t> &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<zet_metric_group_handle_t> &metricGroupList) {
+
+    if (isImplicitScalingCapable()) {
+        return MultiDeviceCreatedMetricGroupManager::createMultipleMetricGroupsFromMetrics<OaMultiDeviceMetricGroupUserDefined>(
+            metricDeviceContext, *this, metricList,
+            metricGroupNamePrefix, description,
+            maxMetricGroupCount, metricGroupList);
+    }
+
+    const auto isCountCalculationPath = *maxMetricGroupCount == 0;
+
+    auto cleanupCreatedGroups = [](std::vector<zet_metric_group_handle_t> &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<uint32_t>(metricList.size()) * 2u;
+        return ZE_RESULT_SUCCESS;
+    }
+
+    // Arrange the metrics based on their sampling types
+    std::map<zet_metric_group_sampling_type_flags_t, std::vector<zet_metric_handle_t>> samplingTypeToMeticMap{};
+    for (auto &metric : metricList) {
+        auto metricImp = static_cast<OaMetricImp *>(Metric::fromHandle(metric));
+        auto metricFromProgrammable = static_cast<OaMetricFromProgrammable *>(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<zet_metric_group_handle_t> 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<uint32_t>(entry.second.size()); index++) {
+
+            auto &metricToAdd = entry.second[index];
+            bool isAddedToExistingMetricGroup = false;
+            for (auto &perSamplingTypeMetricGroup : perSamplingTypeMetricGroupList) {
+                auto oaMetricGroup = static_cast<OaMetricGroupUserDefined *>(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<OaMetricGroupUserDefined *>(MetricGroup::fromHandle(metricGroup));
+        auto status = oaMetricGroup->close();
+        if (status != ZE_RESULT_SUCCESS) {
+            cleanupCreatedGroups(metricGroupList);
+            *maxMetricGroupCount = 0;
+            return status;
+        }
+    }
+
+    *maxMetricGroupCount = static_cast<uint32_t>(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<OaMetricSourceImp>() const {
     return static_cast<OaMetricSourceImp &>(*metricSources.at(MetricSource::metricSourceTypeOa));

level_zero/tools/source/metrics/metric_oa_source.h

@@ -51,6 +51,18 @@ class OaMetricSourceImp : public MetricSource {
     static std::unique_ptr<OaMetricSourceImp> create(const MetricDeviceContext &metricDeviceContext);
     void setMetricOsInterface(std::unique_ptr<MetricOAOsInterface> &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<zet_metric_handle_t> &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<zet_metric_group_handle_t> &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;

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);
 }
 

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)

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);
 }
 

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);
 }
 

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;
 

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:

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
 )

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 <algorithm>
+#include <atomic>
+#include <cstring>
+#include <functional>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <thread>
+
+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<int32_t>(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<int32_t>(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<bool>(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<SingleDeviceSingleQueueExecutionCtxt> executionCtxt =
+            std::make_unique<SingleDeviceSingleQueueExecutionCtxt>(deviceId, subDeviceId);
+
+        uint32_t programmableCount = 0;
+        VALIDATECALL(zetMetricProgrammableGetExp(executionCtxt->getDeviceHandle(0), &programmableCount, nullptr));
+        LOG(zmu::LogLevel::INFO) << "Programmable Count" << programmableCount << "\n";
+        std::vector<zet_metric_programmable_exp_handle_t> 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<zet_metric_programmable_param_info_exp_t> parameterInfos(props.parameterCount);
+            uint32_t parameterCount = props.parameterCount;
+            zetMetricProgrammableGetParamInfoExp(programmable, &parameterCount, 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<zet_metric_programmable_param_value_info_exp_t> paramValueInfos(paramValueInfoCount);
+                std::vector<zet_intel_metric_programmable_param_value_info_exp_desc_t> paramValueInfoDescList(paramValueInfoCount);
+                for (auto &desc : paramValueInfoDescList) {
+                    desc.stype = static_cast<zet_structure_type_t>(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 = &paramValueInfoDescList[index];
+                }
+                VALIDATECALL(zetMetricProgrammableGetParamValueInfoExp(programmable, paramIndex, &paramValueInfoCount, 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<int32_t>(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<bool>(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<SingleDeviceSingleQueueExecutionCtxt> executionCtxt =
+            std::make_unique<SingleDeviceSingleQueueExecutionCtxt>(deviceId, subDeviceId);
+
+        uint32_t programmableCount = 0;
+        VALIDATECALL(zetMetricProgrammableGetExp(executionCtxt->getDeviceHandle(0), &programmableCount, nullptr));
+        LOG(zmu::LogLevel::INFO) << "Programmable Count" << programmableCount << "\n";
+        std::vector<zet_metric_programmable_exp_handle_t> metricProgrammables(programmableCount);
+        VALIDATECALL(zetMetricProgrammableGetExp(executionCtxt->getDeviceHandle(0), &programmableCount, metricProgrammables.data()));
+
+        std::vector<zet_metric_programmable_param_value_exp_t> 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<zet_metric_programmable_param_info_exp_t> parameterInfos(props.parameterCount);
+            uint32_t parameterCount = props.parameterCount;
+            VALIDATECALL(zetMetricProgrammableGetParamInfoExp(programmable, &parameterCount, 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<zet_metric_handle_t> 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<int32_t>(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<bool>(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<SingleDeviceSingleQueueExecutionCtxt> executionCtxt =
+            std::make_unique<SingleDeviceSingleQueueExecutionCtxt>(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<void **>(&zetIntelDeviceCreateMetricGroupsFromMetricsExp)));
+
+        uint32_t programmableCount = 0;
+        VALIDATECALL(zetMetricProgrammableGetExp(executionCtxt->getDeviceHandle(0), &programmableCount, nullptr));
+        LOG(zmu::LogLevel::DEBUG) << "Programmable Count" << programmableCount << "\n";
+        std::vector<zet_metric_programmable_exp_handle_t> metricProgrammables(programmableCount);
+        VALIDATECALL(zetMetricProgrammableGetExp(executionCtxt->getDeviceHandle(0), &programmableCount, metricProgrammables.data()));
+
+        std::vector<zet_metric_programmable_param_value_exp_t> parameterValues{};
+
+        auto &programmable = metricProgrammables[0];
+        {
+            zet_metric_programmable_exp_properties_t props{};
+            VALIDATECALL(zetMetricProgrammableGetPropertiesExp(programmable, &props));
+            std::vector<zet_metric_programmable_param_info_exp_t> parameterInfos(props.parameterCount);
+            uint32_t parameterCount = props.parameterCount;
+            VALIDATECALL(zetMetricProgrammableGetParamInfoExp(programmable, &parameterCount, 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<zet_metric_handle_t> 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<SingleDeviceSingleQueueExecutionCtxt> executionCtxt =
+            std::make_unique<SingleDeviceSingleQueueExecutionCtxt>(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<void **>(&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<void **>(&zetIntelDeviceGetConcurrentMetricGroupsExp)));
+
+        uint32_t programmableCount = 0;
+        VALIDATECALL(zetMetricProgrammableGetExp(executionCtxt->getDeviceHandle(0), &programmableCount, nullptr));
+        LOG(zmu::LogLevel::DEBUG) << "Programmable Count" << programmableCount << "\n";
+        std::vector<zet_metric_programmable_exp_handle_t> metricProgrammables(programmableCount);
+        VALIDATECALL(zetMetricProgrammableGetExp(executionCtxt->getDeviceHandle(0), &programmableCount, metricProgrammables.data()));
+
+        // Create Metrics from all programmables
+        std::vector<zet_metric_handle_t> 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<zet_metric_handle_t> 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<uint32_t>(metricHandlesFromProgrammables.size()),
+                                                                    metricHandlesFromProgrammables.data(),
+                                                                    "metricGroupName",
+                                                                    "metricGroupDesc",
+                                                                    &metricGroupCount, nullptr));
+        std::vector<zet_metric_group_handle_t> metricGroupHandles(metricGroupCount);
+        VALIDATECALL(zetIntelDeviceCreateMetricGroupsFromMetricsExp(executionCtxt->getDeviceHandle(0),
+                                                                    static_cast<uint32_t>(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<zet_metric_handle_t> allMetricHandles(actualMetricCount);
+            VALIDATECALL(zetMetricGet(metricGroup, &actualMetricCount, allMetricHandles.data()));
+
+            // Get the list of removable metrics
+            std::vector<zet_metric_handle_t> 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<uint32_t>(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<SingleDeviceSingleQueueExecutionCtxt> executionCtxt =
+            std::make_unique<SingleDeviceSingleQueueExecutionCtxt>(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<void **>(&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<void **>(&zetIntelDeviceGetConcurrentMetricGroupsExp)));
+
+        uint32_t programmableCount = 0;
+        VALIDATECALL(zetMetricProgrammableGetExp(executionCtxt->getDeviceHandle(0), &programmableCount, nullptr));
+        LOG(zmu::LogLevel::DEBUG) << "Programmable Count" << programmableCount << "\n";
+        std::vector<zet_metric_programmable_exp_handle_t> metricProgrammables(programmableCount);
+        VALIDATECALL(zetMetricProgrammableGetExp(executionCtxt->getDeviceHandle(0), &programmableCount, metricProgrammables.data()));
+
+        // Create Metrics from all programmables
+        std::vector<zet_metric_handle_t> 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<zet_metric_handle_t> 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<uint32_t>(metricHandlesFromProgrammables.size()),
+                                                                    metricHandlesFromProgrammables.data(),
+                                                                    "metricGroupName",
+                                                                    "metricGroupDesc",
+                                                                    &metricGroupCount, nullptr));
+        std::vector<zet_metric_group_handle_t> metricGroupHandles(metricGroupCount);
+        VALIDATECALL(zetIntelDeviceCreateMetricGroupsFromMetricsExp(executionCtxt->getDeviceHandle(0),
+                                                                    static_cast<uint32_t>(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<uint32_t>(metricGroupHandles.size()),
+                                                                metricGroupHandles.data(),
+                                                                &concurrentGroupCount, nullptr));
+        std::vector<uint32_t> countPerConcurrentGroupList(concurrentGroupCount);
+        VALIDATECALL(zetIntelDeviceGetConcurrentMetricGroupsExp(executionCtxt->getDeviceHandle(0),
+                                                                static_cast<uint32_t>(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<AppendMemoryCopyFromHeapToDeviceAndBackToHost> workload1 =
+                std::make_unique<AppendMemoryCopyFromHeapToDeviceAndBackToHost>(executionCtxt.get());
+            std::unique_ptr<SingleMetricStreamerCollector> collector =
+                std::make_unique<SingleMetricStreamerCollector>(executionCtxt.get(), metricGroup);
+            std::unique_ptr<SingleDeviceTestRunner> testRunner = std::make_unique<SingleDeviceTestRunner>(static_cast<ExecutionContext *>(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<SingleDeviceSingleQueueExecutionCtxt> executionCtxt =
+            std::make_unique<SingleDeviceSingleQueueExecutionCtxt>(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<void **>(&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<void **>(&zetIntelDeviceGetConcurrentMetricGroupsExp)));
+
+        uint32_t programmableCount = 0;
+        VALIDATECALL(zetMetricProgrammableGetExp(executionCtxt->getDeviceHandle(0), &programmableCount, nullptr));
+        LOG(zmu::LogLevel::DEBUG) << "Programmable Count" << programmableCount << "\n";
+        std::vector<zet_metric_programmable_exp_handle_t> metricProgrammables(programmableCount);
+        VALIDATECALL(zetMetricProgrammableGetExp(executionCtxt->getDeviceHandle(0), &programmableCount, metricProgrammables.data()));
+
+        // Create Metrics from all programmables
+        std::vector<zet_metric_handle_t> 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<zet_metric_handle_t> 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<uint32_t>(metricHandlesFromProgrammables.size()),
+                                                                    metricHandlesFromProgrammables.data(),
+                                                                    "metricGroupName",
+                                                                    "metricGroupDesc",
+                                                                    &metricGroupCount, nullptr));
+        std::vector<zet_metric_group_handle_t> metricGroupHandles(metricGroupCount);
+        VALIDATECALL(zetIntelDeviceCreateMetricGroupsFromMetricsExp(executionCtxt->getDeviceHandle(0),
+                                                                    static_cast<uint32_t>(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<uint32_t>(metricGroupHandles.size()),
+                                                                metricGroupHandles.data(),
+                                                                &concurrentGroupCount, nullptr));
+        std::vector<uint32_t> countPerConcurrentGroupList(concurrentGroupCount);
+        VALIDATECALL(zetIntelDeviceGetConcurrentMetricGroupsExp(executionCtxt->getDeviceHandle(0),
+                                                                static_cast<uint32_t>(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<AppendMemoryCopyFromHeapToDeviceAndBackToHost> workload1 =
+                std::make_unique<AppendMemoryCopyFromHeapToDeviceAndBackToHost>(executionCtxt.get());
+            std::unique_ptr<SingleMetricQueryCollector> collector =
+                std::make_unique<SingleMetricQueryCollector>(executionCtxt.get(), metricGroup);
+            std::unique_ptr<SingleDeviceTestRunner> testRunner = std::make_unique<SingleDeviceTestRunner>(static_cast<ExecutionContext *>(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)

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()

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)

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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> metricsSet;
+    MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {};
     metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
     openMetricsAdapter();
 

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<zet_metric_group_handle_t> &hMetricGroups,
+                                          uint32_t *pConcurrentGroupCount,
+                                          uint32_t *pCountPerConcurrentGroup) override {
+        return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    }
+    ze_result_t createMetricGroupsFromMetrics(std::vector<zet_metric_handle_t> &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<zet_metric_group_handle_t> &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<MockMetricIpSamplingSource>(metricSource);
+    }
+};
+
+} // namespace ult
+} // namespace L0

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<IMetricsDevice_1_5> &metricDevice) {
+void MetricContextFixture::setupDefaultMocksForMetricDevice(Mock<IMetricsDevice_1_13> &metricDevice) {
     metricDevice.GetParamsResult = &metricsDeviceParams;
 }
 
@@ -198,7 +198,7 @@ void MetricMultiDeviceFixture::openMetricsAdapterGroup() {
     adapter.openMetricsDeviceOutDevice = &metricsDevice;
 }
 
-void MetricMultiDeviceFixture::setupDefaultMocksForMetricDevice(Mock<IMetricsDevice_1_5> &metricDevice) {
+void MetricMultiDeviceFixture::setupDefaultMocksForMetricDevice(Mock<IMetricsDevice_1_13> &metricDevice) {
     metricDevice.GetParamsResult = &metricsDeviceParams;
 }
 

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<IAdapterGroup_1_9> adapterGroup;
-    Mock<IAdapter_1_9> adapter;
-    Mock<IMetricsDevice_1_5> metricsDevice;
+    Mock<IAdapterGroup_1_13> adapterGroup;
+    Mock<IAdapter_1_13> adapter;
+    Mock<IMetricsDevice_1_13> metricsDevice;
     MetricsDiscovery::TMetricsDeviceParams_1_2 metricsDeviceParams = {};
     MetricsDiscovery::TTypedValue_1_0 defaultMaximumOaBufferSize = {};
-    void setupDefaultMocksForMetricDevice(Mock<IMetricsDevice_1_5> &metricDevice);
+    void setupDefaultMocksForMetricDevice(Mock<IMetricsDevice_1_13> &metricDevice);
     MockOAOsInterface *mockOAOsInterface;
     MockIpSamplingOsInterface *mockIpSamplingOsInterface;
 };
@@ -312,12 +312,12 @@ class MetricMultiDeviceFixture : public MultiDeviceFixture {
     MockMetricsDiscoveryApi mockMetricsDiscoveryApi = {};
 
     // Metrics discovery device
-    Mock<IAdapterGroup_1_9> adapterGroup;
-    Mock<IAdapter_1_9> adapter;
-    Mock<IMetricsDevice_1_5> metricsDevice;
+    Mock<IAdapterGroup_1_13> adapterGroup;
+    Mock<IAdapter_1_13> adapter;
+    Mock<IMetricsDevice_1_13> metricsDevice;
     MetricsDiscovery::TMetricsDeviceParams_1_2 metricsDeviceParams = {};
     //    MetricsDiscovery::TTypedValue_1_0 defaultMaximumOaBufferSize = {};
-    void setupDefaultMocksForMetricDevice(Mock<IMetricsDevice_1_5> &metricDevice);
+    void setupDefaultMocksForMetricDevice(Mock<IMetricsDevice_1_13> &metricDevice);
 };
 
 class MetricStreamerMultiDeviceFixture : public MetricMultiDeviceFixture {

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

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<IAdapterGroup_1_9> : public IAdapterGroup_1_9 {
+class Mock<IAdapterGroup_1_13> : 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<IAdapter_1_9> : public IAdapter_1_9 {
+class Mock<IAdapter_1_13> : 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<IMetricsDevice_1_5> : public IMetricsDevice_1_5 {
+class Mock<IMetricsDevice_1_13> : public IMetricsDevice_1_13 {
   public:
     ~Mock() override = default;
 
@@ -114,8 +125,9 @@ class Mock<IMetricsDevice_1_5> : 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<IMetricsDevice_1_5> : public IMetricsDevice_1_5 {
         return MetricsDiscovery::CC_OK;
     }
 
-    std::vector<IConcurrentGroup_1_5 *> getConcurrentGroupResults;
+    std::vector<IConcurrentGroup_1_13 *> getConcurrentGroupResults;
 };
 
 template <>
-class Mock<IConcurrentGroup_1_5> : public IConcurrentGroup_1_5 {
+class Mock<IConcurrentGroup_1_13> : 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<IConcurrentGroup_1_5> : public IConcurrentGroup_1_5 {
         return readIoStreamResult;
     }
 
-    IMetricSet_1_5 *getMetricSetResult = nullptr;
-    std::vector<IMetricSet_1_5 *> getMetricSetResults;
+    IMetricSet_1_13 *getMetricSetResult = nullptr;
+    std::vector<IMetricSet_1_13 *> getMetricSetResults;
     std::vector<uint32_t> readIoStreamOutReportsCount{};
     uint32_t *openIoStreamOutOaBufferSize = nullptr;
     TCompletionCode openIoStreamResult = TCompletionCode::CC_OK;
@@ -227,12 +239,12 @@ class Mock<IEquation_1_0> : public IEquation_1_0 {
 };
 
 template <>
-class Mock<IMetricSet_1_5> : public IMetricSet_1_5 {
+class Mock<IMetricSet_1_13> : 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<IMetricSet_1_5> : public IMetricSet_1_5 {
 };
 
 template <>
-class Mock<IMetric_1_0> : public IMetric_1_0 {
+class Mock<IMetric_1_13> : 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<MetricEnumeration> : 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) {

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<uint32_t>(openMetricCallCount, static_cast<uint32_t>(mockOpenReturnCodeList.size() - 1));
+    auto returnStatus = mockOpenReturnCodeList[index];
+    openMetricCallCount++;
+    return returnStatus;
+}
+
+MetricsDiscovery::TCompletionCode MockIMetricSet1x13::AddMetric(MetricsDiscovery::IMetricPrototype_1_13 *metricPrototype) {
+
+    auto index = std::min<uint32_t>(addMetricCallCount, static_cast<uint32_t>(mockAddMetricReturnCodeList.size() - 1));
+    auto returnStatus = mockAddMetricReturnCodeList[index];
+    addMetricCallCount++;
+    return returnStatus;
+}
+
+MetricsDiscovery::TCompletionCode MockIMetricSet1x13::RemoveMetric(MetricsDiscovery::IMetricPrototype_1_13 *metricPrototype) {
+    auto index = std::min<uint32_t>(removeMetricCallCount, static_cast<uint32_t>(mockRemoveMetricReturnCodeList.size() - 1));
+    auto returnStatus = mockRemoveMetricReturnCodeList[index];
+    removeMetricCallCount++;
+    return returnStatus;
+}
+MetricsDiscovery::TCompletionCode MockIMetricSet1x13::Finalize() {
+    auto index = std::min<uint32_t>(closeCallCount, static_cast<uint32_t>(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<uint32_t>(getParamsCallCount, static_cast<uint32_t>(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<MetricsDiscovery::IMetricsDevice_1_5 *>(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<MetricsDiscovery::IMetricsDevice_1_5 *>(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

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<MetricsDiscovery::TMetricPrototypeOptionDescriptor_1_13> 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<MetricsDiscovery::TCompletionCode> mockOpenReturnCodeList{MetricsDiscovery::CC_OK};
+    std::vector<MetricsDiscovery::TCompletionCode> mockAddMetricReturnCodeList{MetricsDiscovery::CC_OK};
+    std::vector<MetricsDiscovery::TCompletionCode> mockRemoveMetricReturnCodeList{MetricsDiscovery::CC_OK};
+    std::vector<MetricsDiscovery::TCompletionCode> mockCloseReturnCodeList{MetricsDiscovery::CC_OK};
+    uint32_t mockApiMask = MetricsDiscovery::API_TYPE_OCL | MetricsDiscovery::API_TYPE_IOSTREAM;
+    std::vector<uint32_t> 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

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<zet_metric_handle_t> &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<zet_metric_group_handle_t> &metricGroupList) override {
+        return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    }
     ze_result_t getConcurrentMetricGroups(std::vector<zet_metric_group_handle_t> &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;
 };
 

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<MetricContextFixture>;
+
+TEST_F(MetricGroupUserDefinedTest, givenImmutableMetricGroupAndMetricsWhenUsingApisForProgrammableMetricsThenErrorIsReturned) {
+
+    // Metrics Discovery device.
+    metricsDeviceParams.ConcurrentGroupsCount = 1;
+
+    // Metrics Discovery concurrent group.
+    Mock<IConcurrentGroup_1_13> metricsConcurrentGroup;
+    TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {};
+    metricsConcurrentGroupParams.MetricSetsCount = 1;
+    metricsConcurrentGroupParams.SymbolName = "OA";
+    metricsConcurrentGroupParams.Description = "OA description";
+    metricsConcurrentGroupParams.IoMeasurementInformationCount = 1;
+
+    Mock<MetricsDiscovery::IEquation_1_0> ioReadEquation;
+    MetricsDiscovery::TEquationElement_1_0 ioEquationElement = {};
+    ioEquationElement.Type = MetricsDiscovery::EQUATION_ELEM_IMM_UINT64;
+    ioEquationElement.ImmediateUInt64 = 0;
+
+    ioReadEquation.getEquationElement.push_back(&ioEquationElement);
+
+    Mock<MetricsDiscovery::IInformation_1_0> ioMeasurement;
+    MetricsDiscovery::TInformationParams_1_0 oaInformation = {};
+    oaInformation.SymbolName = "BufferOverflow";
+    oaInformation.IoReadEquation = &ioReadEquation;
+
+    // Metrics Discovery:: metric set.
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IMetric_1_13> 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

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<IpSamplingMetricSourceImp>();
+
+    std::vector<zet_metric_handle_t> 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<zet_metric_group_handle_t> 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());

level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_2.cpp

@@ -20,7 +20,7 @@ using MetricEnumerationTest = Test<MetricContextFixture>;
 
 TEST_F(MetricEnumerationTest, givenTimeAndBufferSizeWhenOpenIoStreamReturnsErrorThenTheMetricGroupOpenIoStreamReturnsErrorUnknown) {
 
-    Mock<MetricsDiscovery::IConcurrentGroup_1_5> concurrentGroup;
+    Mock<MetricsDiscovery::IConcurrentGroup_1_13> concurrentGroup;
     MockMetricSource mockSource{};
     MetricGroupImpTest metricGroup(mockSource);
 
@@ -35,7 +35,7 @@ TEST_F(MetricEnumerationTest, givenTimeAndBufferSizeWhenOpenIoStreamReturnsError
 
 TEST_F(MetricEnumerationTest, givenReportCountAndReportDataWhenReadIoStreamReturnsErrorThenMetrigGroupReadIoStreamReturnsError) {
 
-    Mock<MetricsDiscovery::IConcurrentGroup_1_5> concurrentGroup;
+    Mock<MetricsDiscovery::IConcurrentGroup_1_13> concurrentGroup;
     MockMetricSource mockSource{};
     MetricGroupImpTest metricGroup(mockSource);
 
@@ -50,7 +50,7 @@ TEST_F(MetricEnumerationTest, givenReportCountAndReportDataWhenReadIoStreamRetur
 
 TEST_F(MetricEnumerationTest, givenTimeAndBufferSizeWhenCloseIoStreamIsCalledCloseAndFailThenIoStreamReturnsErrorUnknown) {
 
-    Mock<MetricsDiscovery::IConcurrentGroup_1_5> concurrentGroup;
+    Mock<MetricsDiscovery::IConcurrentGroup_1_13> concurrentGroup;
     MockMetricSource mockSource{};
     MetricGroupImpTest metricGroup(mockSource);
 
@@ -110,9 +110,9 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesIsCa
 
     // Use first root device.
     auto &metricSource = devices[0]->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
-    Mock<IAdapterGroup_1_9> mockAdapterGroup;
-    Mock<IAdapter_1_9> mockAdapter;
-    Mock<IMetricsDevice_1_5> mockDevice;
+    Mock<IAdapterGroup_1_13> mockAdapterGroup;
+    Mock<IAdapter_1_13> mockAdapter;
+    Mock<IMetricsDevice_1_13> mockDevice;
 
     mockMetricEnumeration->globalMockApi->adapterGroup = reinterpret_cast<IAdapterGroupLatest *>(&mockAdapterGroup);
     mockMetricEnumeration->getMetricsAdapterResult = &mockAdapter;
@@ -139,9 +139,9 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenSubDeviceWhenOpenMetricsDiscoveryI
     auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
     const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
     ASSERT_GE(subDeviceCount, 2u);
-    Mock<IAdapterGroup_1_9> mockAdapterGroup;
-    Mock<IAdapter_1_9> mockAdapter;
-    Mock<IMetricsDevice_1_5> mockDevice;
+    Mock<IAdapterGroup_1_13> mockAdapterGroup;
+    Mock<IAdapter_1_13> mockAdapter;
+    Mock<IMetricsDevice_1_13> mockDevice;
 
     mockMetricEnumeration->globalMockApi->adapterGroup = reinterpret_cast<IAdapterGroupLatest *>(&mockAdapterGroup);
 
@@ -161,9 +161,9 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenSubDeviceWhenOpenMetricsDiscoveryI
     auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
     const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
     ASSERT_GE(subDeviceCount, 2u);
-    Mock<IAdapterGroup_1_9> mockAdapterGroup;
-    Mock<IAdapter_1_9> mockAdapter;
-    Mock<IMetricsDevice_1_5> mockDevice;
+    Mock<IAdapterGroup_1_13> mockAdapterGroup;
+    Mock<IAdapter_1_13> mockAdapter;
+    Mock<IMetricsDevice_1_13> mockDevice;
     mockMetricEnumeration->globalMockApi->adapterGroup = reinterpret_cast<IAdapterGroupLatest *>(&mockAdapterGroup);
     mockMetricEnumerationSubDevices[1]->getMetricsAdapterResult = &mockAdapter;
 
@@ -180,9 +180,9 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesIsCa
 
     // Use first root device.
     auto &metricSource = devices[0]->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
-    Mock<IAdapterGroup_1_9> mockAdapterGroup;
-    Mock<IAdapter_1_9> mockAdapter;
-    Mock<IMetricsDevice_1_5> mockDevice;
+    Mock<IAdapterGroup_1_13> mockAdapterGroup;
+    Mock<IAdapter_1_13> mockAdapter;
+    Mock<IMetricsDevice_1_13> mockDevice;
 
     mockMetricEnumeration->globalMockApi->adapterGroup = reinterpret_cast<IAdapterGroupLatest *>(&mockAdapterGroup);
     mockMetricEnumeration->getMetricsAdapterResult = &mockAdapter;
@@ -204,9 +204,9 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesAndO
 
     // Use first root device.
     auto &metricSource = devices[0]->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
-    Mock<IAdapterGroup_1_9> mockAdapterGroup;
-    Mock<IAdapter_1_9> mockAdapter;
-    Mock<IMetricsDevice_1_5> mockDevice;
+    Mock<IAdapterGroup_1_13> mockAdapterGroup;
+    Mock<IAdapter_1_13> mockAdapter;
+    Mock<IMetricsDevice_1_13> mockDevice;
 
     mockMetricEnumeration->globalMockApi->adapterGroup = reinterpret_cast<IAdapterGroupLatest *>(&mockAdapterGroup);
 
@@ -245,8 +245,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenValidArgumentsWhenZetMetricGetProp
     metricsDeviceParams.ConcurrentGroupsCount = 1;
 
     // Metrics Discovery concurrent group.
-    Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IMetric_1_0> metric;
-    TMetricParams_1_0 metricParams = {};
+    Mock<IMetric_1_13> 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<DeviceImp *>(devices[0]);
     metricsDeviceParams.ConcurrentGroupsCount = 1;
 
-    Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IMetric_1_0> metric;
-    TMetricParams_1_0 metricParams = {};
+    Mock<IMetric_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<IMetricSet_1_13> metricsSet;
+    MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {};
     metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
     metricsSetParams.QueryReportSize = 256;
     metricsSetParams.MetricsCount = 11;
 
-    Mock<IMetric_1_0> metric;
-    MetricsDiscovery::TMetricParams_1_0 metricParams = {};
+    Mock<IMetric_1_13> metric;
+    MetricsDiscovery::TMetricParams_1_13 metricParams = {};
 
     zet_metric_group_handle_t metricGroupHandle = {};
 
@@ -507,8 +507,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenInvalidDataCountAndTotalMetricCoun
 
     metricsDeviceParams.ConcurrentGroupsCount = 1;
 
-    Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<IMetricSet_1_13> metricsSet;
+    MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {};
     metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
     metricsSetParams.QueryReportSize = 256;
     metricsSetParams.MetricsCount = 11;
 
-    Mock<IMetric_1_0> metric;
-    MetricsDiscovery::TMetricParams_1_0 metricParams = {};
+    Mock<IMetric_1_13> metric;
+    MetricsDiscovery::TMetricParams_1_13 metricParams = {};
 
     zet_metric_group_handle_t metricGroupHandle = {};
 
@@ -600,8 +600,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenInvalidQueryReportSizeWhenZetMetri
 
     metricsDeviceParams.ConcurrentGroupsCount = 1;
 
-    Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<IMetricSet_1_13> metricsSet;
+    MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {};
     metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
     metricsSetParams.QueryReportSize = 0;
     metricsSetParams.MetricsCount = 11;
 
-    Mock<IMetric_1_0> metric;
-    MetricsDiscovery::TMetricParams_1_0 metricParams = {};
+    Mock<IMetric_1_13> metric;
+    MetricsDiscovery::TMetricParams_1_13 metricParams = {};
 
     zet_metric_group_handle_t metricGroupHandle = {};
 
@@ -685,8 +685,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenErrorGeneralOnCalculateMetricsWhen
 
     metricsDeviceParams.ConcurrentGroupsCount = 1;
 
-    Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<IMetricSet_1_13> metricsSet;
+    MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {};
     metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
     metricsSetParams.QueryReportSize = 256;
     metricsSetParams.MetricsCount = 11;
 
-    Mock<IMetric_1_0> metric;
-    MetricsDiscovery::TMetricParams_1_0 metricParams = {};
+    Mock<IMetric_1_13> metric;
+    MetricsDiscovery::TMetricParams_1_13 metricParams = {};
 
     zet_metric_group_handle_t metricGroupHandle = {};
 
@@ -778,8 +778,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenCorrectRawDataHeaderWhenZetMetricG
 
     metricsDeviceParams.ConcurrentGroupsCount = 1;
 
-    Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<IMetricSet_1_13> metricsSet;
+    MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {};
     metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
     metricsSetParams.QueryReportSize = 256;
     metricsSetParams.MetricsCount = 11;
 
-    Mock<IMetric_1_0> metric;
-    MetricsDiscovery::TMetricParams_1_0 metricParams = {};
+    Mock<IMetric_1_13> metric;
+    MetricsDiscovery::TMetricParams_1_13 metricParams = {};
 
     zet_metric_group_handle_t metricGroupHandle = {};
 
@@ -861,8 +861,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenCorrectRawDataHeaderWhenFirstSubDe
 
     metricsDeviceParams.ConcurrentGroupsCount = 1;
 
-    Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<IMetricSet_1_13> metricsSet;
+    MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {};
     metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM;
     metricsSetParams.RawReportSize = 256;
     metricsSetParams.MetricsCount = 11;
 
-    Mock<IMetric_1_0> metric;
-    MetricsDiscovery::TMetricParams_1_0 metricParams = {};
+    Mock<IMetric_1_13> metric;
+    MetricsDiscovery::TMetricParams_1_13 metricParams = {};
 
     zet_metric_group_handle_t metricGroupHandle = {};
 
@@ -957,8 +957,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenCorrectRawDataHeaderWhenSecondSubD
 
     metricsDeviceParams.ConcurrentGroupsCount = 1;
 
-    Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<IMetricSet_1_13> metricsSet;
+    MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {};
     metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM;
     metricsSetParams.RawReportSize = 256;
     metricsSetParams.MetricsCount = 11;
 
-    Mock<IMetric_1_0> metric;
-    MetricsDiscovery::TMetricParams_1_0 metricParams = {};
+    Mock<IMetric_1_13> metric;
+    MetricsDiscovery::TMetricParams_1_13 metricParams = {};
 
     zet_metric_group_handle_t metricGroupHandle = {};
 
@@ -1053,8 +1053,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenCorrectRawDataHeaderWhenBothSubDev
 
     metricsDeviceParams.ConcurrentGroupsCount = 1;
 
-    Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<IMetricSet_1_13> metricsSet;
+    MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {};
     metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM;
     metricsSetParams.RawReportSize = 256;
     metricsSetParams.MetricsCount = 11;
 
-    Mock<IMetric_1_0> metric;
-    MetricsDiscovery::TMetricParams_1_0 metricParams = {};
+    Mock<IMetric_1_13> metric;
+    MetricsDiscovery::TMetricParams_1_13 metricParams = {};
 
     zet_metric_group_handle_t metricGroupHandle = {};
 
@@ -1139,8 +1139,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenCorrectRawDataHeaderWhenBothSubDev
 
     metricsDeviceParams.ConcurrentGroupsCount = 1;
 
-    Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<IMetricSet_1_13> metricsSet;
+    MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {};
     metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM;
     metricsSetParams.RawReportSize = 256;
     metricsSetParams.MetricsCount = 11;
 
-    Mock<IMetric_1_0> metric;
-    MetricsDiscovery::TMetricParams_1_0 metricParams = {};
+    Mock<IMetric_1_13> metric;
+    MetricsDiscovery::TMetricParams_1_13 metricParams = {};
 
     zet_metric_group_handle_t metricGroupHandle = {};
 
@@ -1234,8 +1234,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenCorrectRawDataHeaderWhenBothSubDev
 
     metricsDeviceParams.ConcurrentGroupsCount = 1;
 
-    Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<IMetricSet_1_13> metricsSet;
+    MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {};
     metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM;
     metricsSetParams.RawReportSize = 256;
     metricsSetParams.MetricsCount = 11;
 
-    Mock<IMetric_1_0> metric;
-    MetricsDiscovery::TMetricParams_1_0 metricParams = {};
+    Mock<IMetric_1_13> metric;
+    MetricsDiscovery::TMetricParams_1_13 metricParams = {};
 
     zet_metric_group_handle_t metricGroupHandle = {};
 
@@ -1329,8 +1329,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenOaMetricSourceWhenGetConcurrentMet
 
     metricsDeviceParams.ConcurrentGroupsCount = 1;
 
-    Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<IMetricSet_1_13> metricsSet;
+    MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {};
     metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM;
     metricsSetParams.RawReportSize = 256;
     metricsSetParams.MetricsCount = 11;
 
-    Mock<IMetric_1_0> metric;
-    MetricsDiscovery::TMetricParams_1_0 metricParams = {};
+    Mock<IMetric_1_13> metric;
+    MetricsDiscovery::TMetricParams_1_13 metricParams = {};
 
     zet_metric_group_handle_t metricGroupHandle = {};
 

level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_export.cpp

@@ -54,7 +54,7 @@ class MetricExportDataOaTest : public Test<MetricMultiDeviceFixture> {
         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<MetricMultiDeviceFixture> {
         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<MetricMultiDeviceFixture> {
         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<MetricMultiDeviceFixture> {
     uint8_t byteArrayData[5] = {10, 20, 30, 40, 50};
     MetricsDiscovery::TByteArray_1_0 valueByteArray;
 
-    Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
-    Mock<MetricsDiscovery::IMetricSet_1_5> metricsSet;
+    Mock<IConcurrentGroup_1_13> metricsConcurrentGroup;
+    TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> metricsSet;
     MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {};
     TAdapterParams_1_9 adapterParams{};
     TGlobalSymbol_1_0 globalSymbol{};
@@ -458,8 +458,8 @@ class MetricExportDataOaTest : public Test<MetricMultiDeviceFixture> {
     MetricsDiscovery::TDeltaFunction_1_0 deltaFunction{};
     Mock<IInformation_1_0> information{};
     MetricsDiscovery::TInformationParams_1_0 informationParams{};
-    TMetricParams_1_0 metricParams = {};
-    Mock<IMetric_1_0> metric;
+    TMetricParams_1_13 metricParams = {};
+    Mock<IMetric_1_13> metric;
 };
 
 TEST_F(MetricExportDataOaTest, givenValidArgumentsWhenMetricGroupGetExportDataIsCalledThenReturnSuccess) {
@@ -972,6 +972,24 @@ TEST_F(MetricExportDataOaTest, givenUnSupportedVersionWhenMetricGroupGetExportDa
     auto base = reinterpret_cast<zet_intel_metric_df_gpu_export_data_format_t *>(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<zet_intel_metric_df_gpu_export_data_format_t *>(exportData.data());
+    oaData = &base->format01.oaData;
+    EXPECT_EQ(oaData->metricSet.params.availabilityEquation, ZET_INTEL_GPU_METRIC_INVALID_OFFSET);
 }
 
 TEST_F(MetricExportDataOaTest, givenIncorrectExportSizeIsPassedWhenMetricGroupGetExportDataIsCalledThenErrorIsReturned) {

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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IMetric_1_0> metric;
-    TMetricParams_1_0 metricParams = {};
+    Mock<IMetric_1_13> metric;
+    TMetricParams_1_13 metricParams = {};
     metricParams.SymbolName = "Metric symbol name";
     metricParams.ShortName = "Metric short name";
     metricParams.LongName = "Metric long name";

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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IMetric_1_0> metric;
-    TMetricParams_1_0 metricParams = {};
+    Mock<IMetric_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IMetric_1_0> metric;
-    TMetricParams_1_0 metricParams = {};
+    Mock<IMetric_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IMetric_1_0> metric;
-    TMetricParams_1_0 metricParams = {};
+    Mock<IMetric_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IMetric_1_0> metric;
-    TMetricParams_1_0 metricParams = {};
+    Mock<IMetric_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IMetric_1_0> metric;
-    TMetricParams_1_0 metricParams = {};
+    Mock<IMetric_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IMetric_1_0> metric;
-    TMetricParams_1_0 metricParams = {};
+    Mock<IMetric_1_13> metric;
+    TMetricParams_1_13 metricParams = {};
     metricParams.SymbolName = "Metric symbol name";
     metricParams.ShortName = "Metric short name";
     metricParams.LongName = "Metric long name";

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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IMetric_1_0> metric;
-    TMetricParams_1_0 metricParams = {};
+    Mock<IMetric_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IMetric_1_0> metric;
-    TMetricParams_1_0 metricParams = {};
+    Mock<IMetric_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IMetric_1_0> metric;
-    TMetricParams_1_0 metricParams = {};
+    Mock<IMetric_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IMetric_1_0> metric;
-    TMetricParams_1_0 metricParams = {};
+    Mock<IMetric_1_13> metric;
+    TMetricParams_1_13 metricParams = {};
     metricParams.SymbolName = "Metric symbol name";
     metricParams.ShortName = "Metric short name";
     metricParams.LongName = "Metric long name";

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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IMetric_1_0> metric;
-    TMetricParams_1_0 metricParams = {};
+    Mock<IMetric_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IMetric_1_0> metric;
-    TMetricParams_1_0 metricParams = {};
+    Mock<IMetric_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IMetric_1_0> metric;
-    TMetricParams_1_0 metricParams = {};
+    Mock<IMetric_1_13> metric;
+    TMetricParams_1_13 metricParams = {};
     metricParams.SymbolName = "Metric symbol name";
     metricParams.ShortName = "Metric short name";
     metricParams.LongName = "Metric long name";

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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<IMetricSet_1_13> metricsSet;
+    MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {};
     metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
     metricsSetParams.QueryReportSize = 0;
     metricsSetParams.MetricsCount = 11;
 
-    Mock<IMetric_1_0> metric;
-    MetricsDiscovery::TMetricParams_1_0 metricParams = {};
+    Mock<IMetric_1_13> metric;
+    MetricsDiscovery::TMetricParams_1_13 metricParams = {};
 
     openMetricsAdapter();
 
@@ -112,8 +112,8 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetMetricStreamerOpenIsCalledT
 
     metricsDeviceParams.ConcurrentGroupsCount = 1;
 
-    Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> metricsConcurrentGroup;
+    TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {};
     metricsConcurrentGroupParams.MetricSetsCount = 1;
     metricsConcurrentGroupParams.SymbolName = "OA";
     metricsConcurrentGroupParams.Description = "OA description";
     metricsConcurrentGroupParams.IoMeasurementInformationCount = 1;
 
     // Metrics Discovery metric set.
-    Mock<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> metricsConcurrentGroup;
+    TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {};
     metricsConcurrentGroupParams.MetricSetsCount = 1;
     metricsConcurrentGroupParams.SymbolName = "OA";
     metricsConcurrentGroupParams.Description = "OA description";
     metricsConcurrentGroupParams.IoMeasurementInformationCount = 1;
 
-    Mock<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> metricsSet;
+    MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {};
     metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM;
     metricsSetParams.MetricsCount = 0;
     metricsSetParams.SymbolName = "Metric set name";

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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> metricsConcurrentGroup;
+    TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {};
     metricsConcurrentGroupParams.MetricSetsCount = 1;
     metricsConcurrentGroupParams.SymbolName = "OA";
     metricsConcurrentGroupParams.Description = "OA description";
     metricsConcurrentGroupParams.IoMeasurementInformationCount = 1;
 
-    Mock<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> metricsSet;
+    MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {};
     metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM;
     metricsSetParams.MetricsCount = 0;
     metricsSetParams.SymbolName = "Metric set name";

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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> metricsConcurrentGroup;
+    TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {};
     metricsConcurrentGroupParams.MetricSetsCount = 1;
     metricsConcurrentGroupParams.SymbolName = "OA";
     metricsConcurrentGroupParams.Description = "OA description";
     metricsConcurrentGroupParams.IoMeasurementInformationCount = 1;
 
-    Mock<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> 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<IMetric_1_0> metric;
-    MetricsDiscovery::TMetricParams_1_0 metricParams = {};
+    Mock<IMetric_1_13> 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<IConcurrentGroup_1_5> metricsConcurrentGroup;
-    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    Mock<IConcurrentGroup_1_13> 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<MetricsDiscovery::IMetricSet_1_5> metricsSet;
-    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    Mock<MetricsDiscovery::IMetricSet_1_13> metricsSet;
+    MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {};
     metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM;
     metricsSetParams.MetricsCount = 0;
     metricsSetParams.SymbolName = "Metric set name";

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<L0::Device *> 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<zet_metric_group_handle_t> &metricGroupHandles);
+};
+
+void OaMultiDeviceMetricProgrammableFixture::TearDown() {
+    MultiDeviceFixture::tearDown();
+
+    auto &deviceImp = *static_cast<DeviceImp *>(rootDevice);
+    auto &rootDeviceOaSourceImp = deviceImp.getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
+    auto rootDeviceMetricEnumeration = static_cast<MetricEnumeration *>(&rootDeviceOaSourceImp.getMetricEnumeration());
+    rootDeviceMetricEnumeration->cleanupExtendedMetricInformation();
+
+    for (auto &subDevice : subDevices) {
+        auto &subDeviceImp = *static_cast<DeviceImp *>(subDevice);
+        auto &subDeviceOaSourceImp = subDeviceImp.getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
+        auto subDeviceMetricEnumeration = static_cast<MetricEnumeration *>(&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<zet_metric_group_handle_t> &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<DeviceImp *>(rootDevice);
+    auto &rootDeviceOaSourceImp = deviceImp.getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
+    rootDeviceOaSourceImp.setInitializationState(ZE_RESULT_SUCCESS);
+    auto rootDeviceMetricEnumeration = static_cast<MetricEnumeration *>(&rootDeviceOaSourceImp.getMetricEnumeration());
+    rootDeviceMetricEnumeration->setInitializationState(ZE_RESULT_SUCCESS);
+    const uint32_t subDeviceCount = static_cast<uint32_t>(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<OaMetricSourceImp *>(&deviceContext->getMetricSource<OaMetricSourceImp>());
+        auto metricEnumeration = static_cast<MetricEnumeration *>(&oaMetricSource->getMetricEnumeration());
+        metricEnumeration->setAdapterGroup(&mockAdapterGroup);
+        oaMetricSource->setInitializationState(ZE_RESULT_SUCCESS);
+        metricEnumeration->setInitializationState(ZE_RESULT_SUCCESS);
+
+        MetricsDiscovery::IConcurrentGroup_1_13 &concurrentGroup1x13 = static_cast<MetricsDiscovery::IConcurrentGroup_1_13 &>(mockConcurrentGroup);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, metricEnumeration->cacheExtendedMetricInformation(concurrentGroup1x13, 1));
+        static_cast<DeviceImp *>(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, &parameterCount, 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_metric_programmable_param_type_exp_t>(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<zet_metric_programmable_param_info_exp_t> parameterInfo(4);
+    uint32_t parameterCount = 2;
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricProgrammableGetParamInfoExp(programmable, &parameterCount, 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<zet_metric_group_handle_t> 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<zet_metric_group_handle_t> 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<zet_metric_group_handle_t> 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<zet_metric_group_handle_t> 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<zet_metric_group_handle_t> 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<zet_metric_group_handle_t> 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<zet_metric_group_handle_t> 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<zet_metric_group_handle_t> 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<uint32_t>(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<zet_metric_group_handle_t> 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<uint32_t>(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<zet_metric_group_handle_t> 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<uint32_t>(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<zet_metric_group_handle_t> 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<zet_metric_group_handle_t> 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<zet_metric_group_handle_t> 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<zet_metric_group_handle_t> 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<zet_metric_group_handle_t> 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<MockMetric *> 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<uint32_t>(allocatedMetricObjects.size());
+        if (additionalAllocationNecessary) {
+            uint32_t additionalAllocations = metricHandleCount - static_cast<uint32_t>(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<MetricProgrammable *> 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<zet_metric_handle_t> 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<MockMetric *>(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<MetricProgrammable *> 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<zet_metric_handle_t> 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<MetricProgrammable *> 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<zet_metric_handle_t> 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<MetricImp *> mockMetrics{&mockMetric};
+    MultiDeviceMetricImp *multiDevMetric = static_cast<MultiDeviceMetricImp *>(
+        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<DeviceImp *>(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<MetricGroupImp *> &subDeviceMetricGroups,
+                                    std::vector<MultiDeviceMetricImp *> &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<zet_metric_group_handle_t> metricGroups{};
+    std::vector<zet_metric_handle_t> metrics(1);
+    metrics[0] = metricHandle;
+    EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, MultiDeviceCreatedMetricGroupManager::createMultipleMetricGroupsFromMetrics<DummyMetricGroup>(
+                                                    *rootDeviceMetricContext, mockMetricSource,
+                                                    metrics, "name", "desc", &metricGroupFromMetricsCount, metricGroups));
+    EXPECT_EQ(metricGroupFromMetricsCount, 0u);
+}
+
+} // namespace ult
+} // namespace L0

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")

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