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

refactor: support oa programmable metric group

Browse Source 
Related-To: NEO-12184


Signed-off-by: Joshua Santosh Ranjan <joshua.santosh.ranjan@intel.com>
This commit is contained in:
Joshua Santosh Ranjan
2024-10-23 14:52:02 +00:00
committed by Compute-Runtime-Automation
parent a4f34e6fcc
commit c9e48d0d2b
54 changed files with 7067 additions and 796 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
level_zero/tools/test/black_box_tests/zello_metrics/CMakeLists.txt
View File

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

964
level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_programmable_tests.cpp Normal file
View File

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

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

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

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

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

8
level_zero/tools/test/unit_tests/sources/metrics/linux/test_metric_oa_query_pool_linux.cpp
View File

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

68
level_zero/tools/test/unit_tests/sources/metrics/mock_metric_ip_sampling_source.h Normal file
View File

@@ -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

6
level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.cpp
View File

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

16
level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.h
View File

@@ -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 {

233
level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_enumeration.cpp
View File

@@ -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

68
level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_enumeration.h
View File

@@ -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) {

300
level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_programmable.cpp Normal file
View File

@@ -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

140
level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_programmable.h Normal file
View File

@@ -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

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

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

111
level_zero/tools/test/unit_tests/sources/metrics/test_metric_group.cpp Normal file
View File

@@ -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

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

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

456
level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_1.cpp
View File

File diff suppressed because it is too large Load Diff

192
level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_2.cpp
View File

@@ -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 = {};

34
level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_export.cpp
View File

@@ -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) {

20
level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_2.cpp
View File

@@ -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";

72
level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_3.cpp
View File

@@ -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";

48
level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_4.cpp
View File

@@ -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";

36
level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_5.cpp
View File

@@ -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";

124
level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_streamer_1.cpp
View File

@@ -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";

72
level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_streamer_2.cpp
View File

@@ -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";

28
level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_streamer_3.cpp
View File

@@ -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";

1847
level_zero/tools/test/unit_tests/sources/metrics/test_metric_programmable.cpp
View File

File diff suppressed because it is too large Load Diff

970
level_zero/tools/test/unit_tests/sources/metrics/test_multidevice_metric_programmable.cpp Normal file
View File

@@ -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