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

Revert "feature: EUStall metrics calculation supports scopes"

Browse Source 
This reverts commit 2d2b77d908.

Signed-off-by: Compute-Runtime-Validation <compute-runtime-validation@intel.com>
This commit is contained in:
Compute-Runtime-Validation
2025-10-17 08:18:44 +02:00
committed by Compute-Runtime-Automation
parent f63ace10bf
commit d07e97a38a
21 changed files with 310 additions and 933 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper.h
View File

@@ -110,7 +110,6 @@ class L0GfxCoreHelper : public NEO::ApiGfxCoreHelper {
virtual void stallSumIpDataToTypedValues(uint64_t ip, void *sumIpData, std::vector<zet_typed_value_t> &ipDataValues) = 0;
virtual bool stallIpDataMapUpdate(std::map<uint64_t, void *> &stallSumIpDataMap, const uint8_t *pRawIpData) = 0;
virtual void stallIpDataMapDelete(std::map<uint64_t, void *> &stallSumIpDataMap) = 0;
virtual void stallIpDataMapDeleteEntry(std::map<uint64_t, void *>::iterator it) = 0;
virtual uint32_t getIpSamplingMetricCount() = 0;
virtual uint64_t getIpSamplingIpMask() const = 0;
virtual bool synchronizedDispatchSupported() const = 0;
@@ -172,7 +171,6 @@ class L0GfxCoreHelperHw : public L0GfxCoreHelper {
void stallSumIpDataToTypedValues(uint64_t ip, void *sumIpData, std::vector<zet_typed_value_t> &ipDataValues) override;
bool stallIpDataMapUpdate(std::map<uint64_t, void *> &stallSumIpDataMap, const uint8_t *pRawIpData) override;
void stallIpDataMapDelete(std::map<uint64_t, void *> &stallSumIpDataMap) override;
void stallIpDataMapDeleteEntry(std::map<uint64_t, void *>::iterator it) override;
uint32_t getIpSamplingMetricCount() override;
uint64_t getIpSamplingIpMask() const override;
bool synchronizedDispatchSupported() const override;

5
level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper_tgllp_to_dg2.inl
View File

@@ -127,11 +127,6 @@ void L0GfxCoreHelperHw<Family>::stallIpDataMapDelete(std::map<uint64_t, void *>
return;
}
template <typename Family>
void L0GfxCoreHelperHw<Family>::stallIpDataMapDeleteEntry(std::map<uint64_t, void *>::iterator it) {
return;
}
template <typename Family>
bool L0GfxCoreHelperHw<Family>::stallIpDataMapUpdate(std::map<uint64_t, void *> &stallSumIpDataMap, const uint8_t *pRawIpData) {
return false;

9
level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper_xe2_hpg_and_later.inl
View File

@@ -93,15 +93,6 @@ void L0GfxCoreHelperHw<Family>::stallIpDataMapDelete(std::map<uint64_t, void *>
}
}
template <typename Family>
void L0GfxCoreHelperHw<Family>::stallIpDataMapDeleteEntry(std::map<uint64_t, void *>::iterator it) {
StallSumIpDataXeCore_t *stallSumData = reinterpret_cast<StallSumIpDataXeCore_t *>(it->second);
if (stallSumData) {
delete stallSumData;
it->second = nullptr;
}
}
template <typename Family>
bool L0GfxCoreHelperHw<Family>::stallIpDataMapUpdate(std::map<uint64_t, void *> &stallSumIpDataMap, const uint8_t *pRawIpData) {
constexpr int ipStallSamplingOffset = 3; // Offset to read the first Stall Sampling report after IP Address.

9
level_zero/core/source/xe_hpc_core/l0_gfx_core_helper_xe_hpc_core.cpp
View File

@@ -87,15 +87,6 @@ void L0GfxCoreHelperHw<Family>::stallIpDataMapDelete(std::map<uint64_t, void *>
}
}
template <>
void L0GfxCoreHelperHw<Family>::stallIpDataMapDeleteEntry(std::map<uint64_t, void *>::iterator it) {
StallSumIpData_t *stallSumData = reinterpret_cast<StallSumIpData_t *>(it->second);
if (stallSumData) {
delete stallSumData;
it->second = nullptr;
}
}
template <>
bool L0GfxCoreHelperHw<Family>::stallIpDataMapUpdate(std::map<uint64_t, void *> &stallSumIpDataMap, const uint8_t *pRawIpData) {
constexpr int ipStallSamplingOffset = 3; // Offset to read the first Stall Sampling report after IP Address.

7
level_zero/core/test/unit_tests/gen12lp/test_l0_gfx_core_helper_gen12lp.cpp
View File

@@ -105,13 +105,6 @@ GEN12LPTEST_F(L0GfxCoreHelperTestGen12Lp, GivenGen12LpWhenStallIpDataMapDeleteIs
l0GfxCoreHelper.stallIpDataMapDelete(stallSumIpDataMap);
EXPECT_EQ(mapSizeBefore, stallSumIpDataMap.size());
}
GEN12LPTEST_F(L0GfxCoreHelperTestGen12Lp, GivenGen12LpWhenStallIpDataMapDeleteEntryIsCalledThenMapisUnchanged) {
auto &l0GfxCoreHelper = getHelper<L0GfxCoreHelper>();
std::map<uint64_t, void *> stallSumIpDataMap;
size_t mapSizeBefore = stallSumIpDataMap.size();
l0GfxCoreHelper.stallIpDataMapDelete(stallSumIpDataMap);
EXPECT_EQ(mapSizeBefore, stallSumIpDataMap.size());
}
GEN12LPTEST_F(L0GfxCoreHelperTestGen12Lp, GivenGen12LpWhenStallSumIpDataToTypedValuesIsCalledThenNoChangeToDataValues) {
auto &l0GfxCoreHelper = getHelper<L0GfxCoreHelper>();

30
level_zero/core/test/unit_tests/xe2_hpg_core/test_l0_gfx_core_helper_xe2_hpg_core.cpp
View File

@@ -147,7 +147,7 @@ XE2_HPG_CORETEST_F(L0GfxCoreHelperTestXe2Hpg, GivenXe3pWhenCallingisThreadContro
EXPECT_TRUE(l0GfxCoreHelper.isThreadControlStoppedSupported());
}
XE2_HPG_CORETEST_F(L0GfxCoreHelperTestXe2Hpg, GivenXe2HpgWhenCheckingL0HelperForDeletingIpSamplingMapWithNullValuesThenMapRemainstheSameSize) {
XE2_HPG_CORETEST_F(L0GfxCoreHelperTestXe2Hpg, GivenXe2HpgWhenCheckingL0HelperForDeletingIpSamplingEntryWithNullValuesThenMapRemainstheSameSize) {
auto &l0GfxCoreHelper = getHelper<L0GfxCoreHelper>();
std::map<uint64_t, void *> stallSumIpDataMap;
stallSumIpDataMap.emplace(std::pair<uint64_t, void *>(0ull, nullptr));
@@ -155,34 +155,6 @@ XE2_HPG_CORETEST_F(L0GfxCoreHelperTestXe2Hpg, GivenXe2HpgWhenCheckingL0HelperFor
EXPECT_NE(0u, stallSumIpDataMap.size());
}
XE2_HPG_CORETEST_F(L0GfxCoreHelperTestXe2Hpg, GivenXe2HpgWhenCheckingL0HelperForDeletingIpSamplingEntryWithThenMapRemainstheSameSize) {
auto &l0GfxCoreHelper = getHelper<L0GfxCoreHelper>();
std::map<uint64_t, void *> stallSumIpDataMap;
#pragma pack(1)
typedef struct StallSumIpData {
uint64_t activeCount;
uint64_t otherCount;
uint64_t controlCount;
uint64_t pipeStallCount;
uint64_t sendCount;
uint64_t distAccCount;
uint64_t sbidCount;
uint64_t syncCount;
uint64_t instFetchCount;
} StallSumIpData_t;
#pragma pack()
StallSumIpData_t *stallSumData = new StallSumIpData_t;
stallSumIpDataMap.emplace(std::pair<uint64_t, void *>(0ull, stallSumData));
std::map<uint64_t, void *>::iterator it = stallSumIpDataMap.begin();
l0GfxCoreHelper.stallIpDataMapDeleteEntry(it);
EXPECT_EQ(1u, stallSumIpDataMap.size());
l0GfxCoreHelper.stallIpDataMapDeleteEntry(it); // if entry not found it is skipped
EXPECT_EQ(1u, stallSumIpDataMap.size());
}
XE2_HPG_CORETEST_F(L0GfxCoreHelperTestXe2Hpg, GivenXe2HpgWhenCheckingL0HelperForGetIpSamplingIpMaskThenCorrectValueIsReturned) {
auto &l0GfxCoreHelper = getHelper<L0GfxCoreHelper>();
EXPECT_EQ(0x1fffffffull, l0GfxCoreHelper.getIpSamplingIpMask());

30
level_zero/core/test/unit_tests/xe_hpc_core/test_l0_gfx_core_helper_xe_hpc_core.cpp
View File

@@ -88,7 +88,7 @@ XE_HPC_CORETEST_F(L0GfxCoreHelperTestXeHpc, GivenXeHpcWhenGettingRecordReplayGra
EXPECT_EQ(0u, l0GfxCoreHelper.getPlatformRecordReplayGraphCapabilities());
}
XE_HPC_CORETEST_F(L0GfxCoreHelperTestXeHpc, GivenXeHpcWhenCheckingL0HelperForDeletingIpSamplingMapWithNullValuesThenMapRemainstheSameSize) {
XE_HPC_CORETEST_F(L0GfxCoreHelperTestXeHpc, GivenXeHpcWhenCheckingL0HelperForDeletingIpSamplingEntryWithNullValuesThenMapRemainstheSameSize) {
auto &l0GfxCoreHelper = getHelper<L0GfxCoreHelper>();
std::map<uint64_t, void *> stallSumIpDataMap;
stallSumIpDataMap.emplace(std::pair<uint64_t, void *>(0ull, nullptr));
@@ -96,34 +96,6 @@ XE_HPC_CORETEST_F(L0GfxCoreHelperTestXeHpc, GivenXeHpcWhenCheckingL0HelperForDel
EXPECT_NE(0u, stallSumIpDataMap.size());
}
XE_HPC_CORETEST_F(L0GfxCoreHelperTestXeHpc, GivenXeHpcWhenCheckingL0HelperForDeletingIpSamplingEntryWithThenMapRemainstheSameSize) {
auto &l0GfxCoreHelper = getHelper<L0GfxCoreHelper>();
std::map<uint64_t, void *> stallSumIpDataMap;
#pragma pack(1)
typedef struct StallSumIpData {
uint64_t activeCount;
uint64_t otherCount;
uint64_t controlCount;
uint64_t pipeStallCount;
uint64_t sendCount;
uint64_t distAccCount;
uint64_t sbidCount;
uint64_t syncCount;
uint64_t instFetchCount;
} StallSumIpData_t;
#pragma pack()
StallSumIpData_t *stallSumData = new StallSumIpData_t;
stallSumIpDataMap.emplace(std::pair<uint64_t, void *>(0ull, stallSumData));
std::map<uint64_t, void *>::iterator it = stallSumIpDataMap.begin();
l0GfxCoreHelper.stallIpDataMapDeleteEntry(it);
EXPECT_EQ(1u, stallSumIpDataMap.size());
l0GfxCoreHelper.stallIpDataMapDeleteEntry(it); // if entry not found it is skipped
EXPECT_EQ(1u, stallSumIpDataMap.size());
}
XE_HPC_CORETEST_F(L0GfxCoreHelperTestXeHpc, GivenXeHpcWhenCheckingL0HelperForGetIpSamplingIpMaskThenCorrectValueIsReturned) {
auto &l0GfxCoreHelper = getHelper<L0GfxCoreHelper>();
EXPECT_EQ(0x1fffffffull, l0GfxCoreHelper.getIpSamplingIpMask());

9
level_zero/core/test/unit_tests/xe_hpg_core/test_l0_gfx_core_helper_xe_hpg_core.cpp
View File

@@ -114,15 +114,6 @@ XE_HPG_CORETEST_F(L0GfxCoreHelperTestXeHpg, GivenXeHpgWhenStallIpDataMapDeleteIs
EXPECT_EQ(mapSizeBefore, stallSumIpDataMap.size());
}
XE_HPG_CORETEST_F(L0GfxCoreHelperTestXeHpg, GivenXeHpgWhenStallIpDataMapDeleteEntryIsCalledThenMapisUnchanged) {
auto &l0GfxCoreHelper = getHelper<L0GfxCoreHelper>();
std::map<uint64_t, void *> stallSumIpDataMap;
size_t mapSizeBefore = stallSumIpDataMap.size();
std::map<uint64_t, void *>::iterator it = stallSumIpDataMap.begin();
l0GfxCoreHelper.stallIpDataMapDeleteEntry(it);
EXPECT_EQ(mapSizeBefore, stallSumIpDataMap.size());
}
XE_HPG_CORETEST_F(L0GfxCoreHelperTestXeHpg, GivenXeHpgWhenStallSumIpDataToTypedValuesIsCalledThenNoChangeToDataValues) {
auto &l0GfxCoreHelper = getHelper<L0GfxCoreHelper>();
uint64_t ip = 0ull;

5
level_zero/include/level_zero/ze_intel_results.h
View File

@@ -15,7 +15,8 @@
#include <cstdint>
// Metrics experimental return codes
#define ZE_INTEL_RESULT_WARNING_NOT_CALCULABLE_METRICS_IGNORED_EXP static_cast<ze_result_t>(0x40000000) // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
#define ZE_INTEL_RESULT_WARNING_TIME_PARAMS_IGNORED_EXP static_cast<ze_result_t>(0x40000001) // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
#define ZE_INTEL_RESULT_WARNING_DATA_NOT_PROCESSED_EXP static_cast<ze_result_t>(0x40000000) // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
#define ZE_INTEL_RESULT_WARNING_NOT_CALCULABLE_METRICS_IGNORED_EXP static_cast<ze_result_t>(0x40000001) // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
#define ZE_INTEL_RESULT_WARNING_TIME_PARAMS_IGNORED_EXP static_cast<ze_result_t>(0x40000002) // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
#endif // _ZE_INTEL_RESULTS_H

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

@@ -633,9 +633,6 @@ ze_result_t MetricDeviceContext::calcOperationCreate(zet_context_handle_t hConte
if (pCalculationDesc->metricScopesCount == 0) {
METRICS_LOG_ERR("%s", "Must define at least one metric scope");
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
} else if (!isImplicitScalingCapable() && (pCalculationDesc->metricScopesCount > 1)) {
METRICS_LOG_ERR("%s", "Sub-device can only calculate single metric scope");
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
std::vector<MetricScopeImp *> metricScopes;

117
level_zero/tools/source/metrics/metric_ip_sampling_source.cpp
View File

@@ -23,6 +23,7 @@
#include <level_zero/zet_api.h>
#include <cstring>
#include <unordered_set>
namespace L0 {
constexpr uint32_t ipSamplinDomainId = 100u;
@@ -98,7 +99,7 @@ ze_result_t IpSamplingMetricSourceImp::cacheMetricGroup() {
std::vector<IpSamplingMetricImp> metrics = {};
auto &l0GfxCoreHelper = deviceImp->getNEODevice()->getRootDeviceEnvironment().getHelper<L0GfxCoreHelper>();
metrics.reserve(l0GfxCoreHelper.getIpSamplingMetricCount());
metricCount = l0GfxCoreHelper.getIpSamplingMetricCount();
metricSourceCount = l0GfxCoreHelper.getIpSamplingMetricCount();
zet_metric_properties_t metricProperties = {};
@@ -308,7 +309,7 @@ IpSamplingMetricGroupImp::IpSamplingMetricGroupImp(IpSamplingMetricSourceImp &me
strcpy_s(properties.description, ZET_MAX_METRIC_GROUP_DESCRIPTION, "EU stall sampling");
properties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED;
properties.domain = ipSamplinDomainId;
properties.metricCount = this->getMetricSource().metricCount;
properties.metricCount = this->getMetricSource().metricSourceCount;
}
ze_result_t IpSamplingMetricGroupImp::getProperties(zet_metric_group_properties_t *pProperties) {
@@ -341,6 +342,14 @@ ze_result_t IpSamplingMetricGroupImp::metricGet(uint32_t *pCount, zet_metric_han
return ZE_RESULT_SUCCESS;
}
bool IpSamplingMetricGroupBase::isMultiDeviceCaptureData(const size_t rawDataSize, const uint8_t *pRawData) {
if (rawDataSize >= sizeof(IpSamplingMetricDataHeader)) {
const auto header = reinterpret_cast<const IpSamplingMetricDataHeader *>(pRawData);
return header->magic == IpSamplingMetricDataHeader::magicValue;
}
return false;
}
ze_result_t IpSamplingMetricGroupImp::calculateMetricValues(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
const uint8_t *pRawData, uint32_t *pMetricValueCount,
zet_typed_value_t *pMetricValues) {
@@ -358,7 +367,7 @@ ze_result_t IpSamplingMetricGroupImp::calculateMetricValuesExp(const zet_metric_
*pSetCount = 0;
}
if (!IpSamplingCalculation::isMultiDeviceCaptureData(rawDataSize, pRawData)) {
if (!isMultiDeviceCaptureData(rawDataSize, pRawData)) {
result = this->calculateMetricValues(type, rawDataSize, pRawData, pTotalMetricValueCount, pMetricValues);
} else {
METRICS_LOG_ERR("%s", "Calculating sub-device results using root device captured data is not supported");
@@ -540,11 +549,15 @@ bool IpSamplingCalculation::isMultiDeviceCaptureData(const size_t rawDataSize, c
return false;
}
ze_result_t IpSamplingCalculation::getIpsInRawData(const uint8_t *pRawData, const size_t rawDataSize,
std::unordered_set<uint64_t> &iPs) {
ze_result_t IpSamplingCalculation::getMetricCount(const uint8_t *pRawData, const size_t rawDataSize,
uint32_t &metricValueCount) {
std::unordered_set<uint64_t> stallReportIpCount{};
constexpr uint32_t rawReportSize = IpSamplingMetricGroupBase::rawReportSize;
if ((rawDataSize % rawReportSize) != 0) {
METRICS_LOG_ERR("%s", "Invalid input raw data size");
metricValueCount = 0;
return ZE_RESULT_ERROR_INVALID_SIZE;
}
@@ -554,24 +567,10 @@ ze_result_t IpSamplingCalculation::getIpsInRawData(const uint8_t *pRawData, cons
uint64_t ip = 0ULL;
memcpy_s(reinterpret_cast<uint8_t *>(&ip), sizeof(ip), pRawIpData, sizeof(ip));
ip &= gfxCoreHelper.getIpSamplingIpMask();
iPs.insert(ip);
stallReportIpCount.insert(ip);
}
return ZE_RESULT_SUCCESS;
}
ze_result_t IpSamplingCalculation::getMetricCount(const uint8_t *pRawData, const size_t rawDataSize,
uint32_t &metricValueCount) {
ze_result_t status = ZE_RESULT_SUCCESS;
std::unordered_set<uint64_t> stallReportIpCount{};
status = getIpsInRawData(pRawData, rawDataSize, stallReportIpCount);
if (status != ZE_RESULT_SUCCESS) {
metricValueCount = 0;
return status;
}
metricValueCount = static_cast<uint32_t>(stallReportIpCount.size()) * metricSource.metricCount;
metricValueCount = static_cast<uint32_t>(stallReportIpCount.size()) * metricSource.metricSourceCount;
return ZE_RESULT_SUCCESS;
}
@@ -617,14 +616,32 @@ ze_result_t IpSamplingCalculation::calculateMetricValues(const zet_metric_group_
DEBUG_BREAK_IF(pCalculatedData == nullptr);
const uint32_t rawReportSize = IpSamplingMetricGroupBase::rawReportSize;
if ((rawDataSize % rawReportSize) != 0) {
METRICS_LOG_ERR("%s", "Invalid input raw data size");
metricValueCount = 0;
return ZE_RESULT_ERROR_INVALID_SIZE;
}
fillStallDataMap(rawDataSize, pRawData, stallReportDataMap, &dataOverflow);
stallDataMapToTypedValues(stallReportDataMap, metricValueCount, pCalculatedData);
const uint32_t rawReportCount = static_cast<uint32_t>(rawDataSize) / rawReportSize;
for (const uint8_t *pRawIpData = pRawData; pRawIpData < pRawData + (rawReportCount * rawReportSize); pRawIpData += rawReportSize) {
dataOverflow |= gfxCoreHelper.stallIpDataMapUpdate(stallReportDataMap, pRawIpData);
}
metricValueCount = std::min<uint32_t>(metricValueCount, static_cast<uint32_t>(stallReportDataMap.size()) * metricSource.metricSourceCount);
std::vector<zet_typed_value_t> ipDataValues;
uint32_t i = 0;
for (auto it = stallReportDataMap.begin(); it != stallReportDataMap.end(); ++it) {
gfxCoreHelper.stallSumIpDataToTypedValues(it->first, it->second, ipDataValues);
for (auto jt = ipDataValues.begin(); (jt != ipDataValues.end()) && (i < metricValueCount); jt++, i++) {
*(pCalculatedData + i) = *jt;
}
ipDataValues.clear();
}
gfxCoreHelper.stallIpDataMapDelete(stallReportDataMap);
stallReportDataMap.clear();
return dataOverflow ? ZE_RESULT_WARNING_DROPPED_DATA : ZE_RESULT_SUCCESS;
}
@@ -686,60 +703,6 @@ ze_result_t IpSamplingCalculation::calculateMetricForSubdevice(const zet_metric_
}
}
void IpSamplingCalculation::fillStallDataMap(const size_t rawDataSize, const uint8_t *pRawData,
std::map<uint64_t, void *> &stallReportDataMap,
bool *dataOverflow) {
size_t processedSize = 0;
const uint8_t *dataToProcess = pRawData;
do {
*dataOverflow |= gfxCoreHelper.stallIpDataMapUpdate(stallReportDataMap, dataToProcess);
processedSize += rawReportSize;
dataToProcess += rawReportSize;
} while (processedSize < rawDataSize);
return;
}
void IpSamplingCalculation::stallDataMapToMetricResults(std::map<uint64_t, void *> &stallReportDataMap,
uint32_t metricReportCount,
std::vector<uint32_t> includedMetricIndexes,
zet_intel_metric_result_exp_t *pMetricResults) {
std::vector<zet_typed_value_t> ipDataValues;
uint32_t i = 0;
auto endIt = stallReportDataMap.begin();
std::advance(endIt, metricReportCount);
for (auto it = stallReportDataMap.begin(); it != endIt;) {
gfxCoreHelper.stallSumIpDataToTypedValues(it->first, it->second, ipDataValues);
for (uint32_t j = 0; j < includedMetricIndexes.size(); j++) {
(pMetricResults + i)->value = ipDataValues[includedMetricIndexes[j]].value;
(pMetricResults + i)->resultStatus = ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID;
i++;
}
ipDataValues.clear();
gfxCoreHelper.stallIpDataMapDeleteEntry(it);
it = stallReportDataMap.erase(it);
}
}
void IpSamplingCalculation::stallDataMapToTypedValues(std::map<uint64_t, void *> &stallReportDataMap,
uint32_t &metricValueCount,
zet_typed_value_t *pTypedValues) {
metricValueCount = std::min<uint32_t>(metricValueCount, static_cast<uint32_t>(stallReportDataMap.size()) * metricSource.metricCount);
std::vector<zet_typed_value_t> ipDataValues;
uint32_t i = 0;
for (auto it = stallReportDataMap.begin(); it != stallReportDataMap.end(); ++it) {
gfxCoreHelper.stallSumIpDataToTypedValues(it->first, it->second, ipDataValues);
for (auto jt = ipDataValues.begin(); (jt != ipDataValues.end()) && (i < metricValueCount); jt++, i++) {
*(pTypedValues + i) = *jt;
}
ipDataValues.clear();
}
gfxCoreHelper.stallIpDataMapDelete(stallReportDataMap);
stallReportDataMap.clear();
}
template <>
IpSamplingMetricSourceImp &MetricDeviceContext::getMetricSource<IpSamplingMetricSourceImp>() const {
return static_cast<IpSamplingMetricSourceImp &>(*metricSources.at(MetricSource::metricSourceTypeIpSampling));

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

@@ -10,7 +10,6 @@
#include "level_zero/tools/source/metrics/metric.h"
#include "level_zero/tools/source/metrics/os_interface_metric.h"
#include <unordered_set>
namespace L0 {
class L0GfxCoreHelper;
struct IpSamplingMetricImp;
@@ -64,7 +63,7 @@ class IpSamplingMetricSourceImp : public MetricSource {
const std::vector<MetricScopeImp *> &metricScopes,
zet_intel_metric_calculation_operation_exp_handle_t *phCalculationOperation) override;
uint32_t metricCount = 0;
uint32_t metricSourceCount = 0;
bool canDisable() override;
void initMetricScopes(MetricDeviceContext &metricDeviceContext) override;
@@ -84,7 +83,7 @@ class IpSamplingMetricSourceImp : public MetricSource {
struct IpSamplingMetricGroupBase : public MetricGroupImp {
IpSamplingMetricGroupBase(MetricSource &metricSource) : MetricGroupImp(metricSource) {}
static constexpr uint32_t rawReportSize = 64u;
bool activate() override { return true; }
bool deactivate() override { return true; };
ze_result_t metricQueryPoolCreate(
@@ -106,6 +105,7 @@ struct IpSamplingMetricGroupBase : public MetricGroupImp {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
static bool isMultiDeviceCaptureData(const size_t rawDataSize, const uint8_t *pRawData);
IpSamplingMetricSourceImp &getMetricSource() { return static_cast<IpSamplingMetricSourceImp &>(metricSource); }
};
@@ -190,12 +190,8 @@ struct IpSamplingCalculation {
: gfxCoreHelper(gfxCoreHelper), metricSource(metricSource) {}
~IpSamplingCalculation() = default;
static constexpr uint32_t rawReportSize = 64u;
static bool isMultiDeviceCaptureData(const size_t rawDataSize, const uint8_t *pRawData);
ze_result_t getIpsInRawData(const uint8_t *pRawData, const size_t rawDataSize,
std::unordered_set<uint64_t> &iPs);
ze_result_t getMetricCount(const uint8_t *pRawData, const size_t rawDataSize,
uint32_t &metricValueCount);
ze_result_t getMetricCountSubDevIndex(const uint8_t *pMultiMetricData, const size_t rawDataSize,
@@ -212,19 +208,11 @@ struct IpSamplingCalculation {
const uint8_t *pRawData, uint32_t *pMetricValueCount,
zet_typed_value_t *pMetricValues);
void fillStallDataMap(const size_t rawDataSize, const uint8_t *pRawData,
void fillStallDataMap(const size_t rawDataSize, const uint8_t *pRawData, size_t *processedSize,
L0GfxCoreHelper &l0GfxCoreHelper,
std::map<uint64_t, void *> &stallReportDataMap,
bool *dataOverflow);
void stallDataMapToMetricResults(std::map<uint64_t, void *> &stallReportDataMap,
uint32_t metricReportCount,
std::vector<uint32_t> includedMetricIndexes,
zet_intel_metric_result_exp_t *pMetricResults);
void stallDataMapToTypedValues(std::map<uint64_t, void *> &stallReportDataMap,
uint32_t &metricValueCount,
zet_typed_value_t *pTypedValues);
protected:
L0::L0GfxCoreHelper &gfxCoreHelper;
IpSamplingMetricSourceImp &metricSource;

158
level_zero/tools/source/metrics/metric_ip_sampling_streamer.cpp
View File

@@ -143,9 +143,8 @@ ze_result_t IpSamplingMetricCalcOpImp::create(bool isMultiDevice,
}
}
auto calcOp = new IpSamplingMetricCalcOpImp(isMultiDevice, metricScopes, metricsInReport,
metricSource, includedMetricIndexes);
auto calcOp = new IpSamplingMetricCalcOpImp(isMultiDevice, metricScopes, static_cast<uint32_t>(hMetrics.size()),
metricsInReport, includedMetricIndexes);
*phCalculationOperation = calcOp->toHandle();
ze_result_t status = ZE_RESULT_SUCCESS;
if ((pCalculationDesc->timeWindowsCount > 0) || (pCalculationDesc->timeAggregationWindow != 0)) {
@@ -158,73 +157,77 @@ ze_result_t IpSamplingMetricCalcOpImp::create(bool isMultiDevice,
}
ze_result_t IpSamplingMetricCalcOpImp::destroy() {
for (auto &it : scopeIdToCache) {
if (!isScopeCacheEmpty(it.first)) {
clearScopeCache(it.first);
}
delete it.second;
}
scopeIdToCache.clear();
delete this;
return ZE_RESULT_SUCCESS;
}
void IpSamplingMetricCalcOpImp::clearScopeCache(uint32_t scopeId) {
const auto deviceImp = static_cast<DeviceImp *>(&(metricSource.getMetricDeviceContext().getDevice()));
L0::L0GfxCoreHelper &l0GfxCoreHelper = deviceImp->getNEODevice()->getRootDeviceEnvironment().getHelper<L0GfxCoreHelper>();
void IpSamplingMetricCalcOpImp::fillStallDataMap(const size_t rawDataSize, const uint8_t *pRawData, size_t *processedSize,
L0::L0GfxCoreHelper &l0GfxCoreHelper,
std::map<uint64_t, void *> &stallReportDataMap,
bool *dataOverflow) {
if (scopeIdToCache.find(scopeId) != scopeIdToCache.end()) {
l0GfxCoreHelper.stallIpDataMapDelete(*scopeIdToCache[scopeId]);
scopeIdToCache[scopeId]->clear();
}
const uint32_t rawReportSize = IpSamplingMetricGroupBase::rawReportSize;
*processedSize = 0;
const uint8_t *dataToProcess = pRawData;
do {
*dataOverflow |= l0GfxCoreHelper.stallIpDataMapUpdate(stallReportDataMap, dataToProcess);
*processedSize += rawReportSize;
dataToProcess += rawReportSize;
} while (*processedSize < rawDataSize);
return;
}
ze_result_t IpSamplingMetricCalcOpImp::metricCalculateValuesSingle(const size_t rawDataSize, const uint8_t *pRawData,
bool newData, uint32_t *pTotalMetricReportCount,
bool getSize, uint32_t scopeId,
bool &dataOverflow) {
uint32_t *pTotalMetricReportCount,
L0::L0GfxCoreHelper &l0GfxCoreHelper,
IpSamplingMetricGroupBase *metricGroupBase,
bool getSize,
size_t *usedSize,
bool &dataOverflow,
std::map<uint64_t, void *> &stallReportDataMap) {
ze_result_t status = ZE_RESULT_ERROR_UNKNOWN;
uint32_t resultCount = 0;
*usedSize = 0;
auto ipSamplingCalculation = metricSource.ipSamplingCalculation.get();
auto calcUtils = metricGroupBase->getMetricSource().ipSamplingCalculation.get();
if (getSize) {
std::unordered_set<uint64_t> iPs{};
if (newData) {
status = ipSamplingCalculation->getIpsInRawData(pRawData, rawDataSize, iPs);
status = calcUtils->getMetricCount(pRawData, rawDataSize, resultCount);
if (status != ZE_RESULT_SUCCESS) {
*pTotalMetricReportCount = 0;
return status;
}
}
// Add cached IPs
if (!isScopeCacheEmpty(scopeId)) {
getScopeCacheIps(scopeId, iPs);
}
*pTotalMetricReportCount = static_cast<uint32_t>(iPs.size());
DEBUG_BREAK_IF(*pTotalMetricReportCount == 0);
uint32_t rawDataReportCount = resultCount / cachedMetricsCount;
if (getSize) {
*pTotalMetricReportCount = rawDataReportCount;
return ZE_RESULT_SUCCESS;
}
if (newData) {
ipSamplingCalculation->fillStallDataMap(rawDataSize, pRawData,
*getScopeCache(scopeId), &dataOverflow);
if (*pTotalMetricReportCount < rawDataReportCount) {
METRICS_LOG_ERR("%s", "EU Stall does not allow calculating fewer results than available in raw data");
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
DEBUG_BREAK_IF(isScopeCacheEmpty(scopeId));
fillStallDataMap(rawDataSize, pRawData, usedSize, l0GfxCoreHelper, stallReportDataMap,
&dataOverflow);
return ZE_RESULT_SUCCESS;
*pTotalMetricReportCount = static_cast<uint32_t>(stallReportDataMap.size());
return status;
}
ze_result_t IpSamplingMetricCalcOpImp::metricCalculateValuesMulti(const size_t rawDataSize, const uint8_t *pRawData,
uint32_t *pTotalMetricReportCount,
L0::L0GfxCoreHelper &l0GfxCoreHelper,
IpSamplingMetricGroupBase *metricGroupBase,
bool getSize,
uint32_t numSubDevices,
size_t *usedSize,
bool &dataOverflow) {
bool &dataOverflow,
std::map<uint64_t, void *> &stallReportDataMap) {
ze_result_t status = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
return status;
}
@@ -235,28 +238,17 @@ ze_result_t IpSamplingMetricCalcOpImp::metricCalculateValues(const size_t rawDat
zet_intel_metric_result_exp_t *pMetricResults) {
ze_result_t status = ZE_RESULT_ERROR_UNKNOWN;
bool dataOverflow = false;
uint32_t metricGroupCount = 1;
zet_metric_group_handle_t hMetricGroup = {};
metricsInReport[0]->getMetricSource().metricGroupGet(&metricGroupCount, &hMetricGroup);
bool isMultiDeviceData = IpSamplingMetricGroupBase::isMultiDeviceCaptureData(rawDataSize, pRawData);
auto ipSamplingCalculation = metricSource.ipSamplingCalculation.get();
bool isMultiDeviceData = IpSamplingCalculation::isMultiDeviceCaptureData(rawDataSize, pRawData);
IpSamplingMetricGroupBase *metricGroupBase = static_cast<IpSamplingMetricGroupBase *>(MetricGroup::fromHandle(hMetricGroup));
DeviceImp *deviceImp = static_cast<DeviceImp *>(&metricGroupBase->getMetricSource().getMetricDeviceContext().getDevice());
L0::L0GfxCoreHelper &l0GfxCoreHelper = deviceImp->getNEODevice()->getRootDeviceEnvironment().getHelper<L0GfxCoreHelper>();
bool getSize = (*pTotalMetricReportCount == 0);
bool newData = false; // Track if there is fresh new raw data that requires updating caches
uint64_t dataSize = rawDataSize;
const uint8_t *rawDataStart = pRawData;
if (areAllCachesEmpty()) {
// All data is new: user asked to calculate all results available in the raw data. So, all caches are empty
newData = true;
} else if (rawDataSize > processedSize) {
// Previous call user requested fewer results than available. So, algo cached pending results and
// processed size = input size - rawReportSize because returned used size = rawReportSize.
// Then user is expected to move pRawData by rawReportSize. If data gets appended user must update
// new size accordingly.
newData = true;
rawDataStart += processedSize;
dataSize = rawDataSize - processedSize;
}
std::map<uint64_t, void *> stallReportDataMap;
if (!isMultiDevice) {
if (isMultiDeviceData) {
@@ -264,43 +256,37 @@ ze_result_t IpSamplingMetricCalcOpImp::metricCalculateValues(const size_t rawDat
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
uint32_t scopeId = 0; // Sub-devices will always have its compute scope with ID 0
status = metricCalculateValuesSingle(dataSize, rawDataStart, newData, pTotalMetricReportCount,
getSize, scopeId, dataOverflow);
if ((status != ZE_RESULT_SUCCESS) || (getSize)) {
return status;
}
bool keepCachedResults = (*pTotalMetricReportCount < static_cast<uint32_t>(getScopeCache(scopeId)->size()));
uint32_t metricReportCount = std::min<uint32_t>(*pTotalMetricReportCount, static_cast<uint32_t>(getScopeCache(scopeId)->size()));
ipSamplingCalculation->stallDataMapToMetricResults(*getScopeCache(scopeId), metricReportCount, includedMetricIndexes, pMetricResults);
if (keepCachedResults) {
*usedSize = IpSamplingCalculation::rawReportSize;
processedSize = rawDataSize - IpSamplingCalculation::rawReportSize;
} else {
*usedSize = rawDataSize;
processedSize = 0;
}
if (final || !keepCachedResults) {
clearScopeCache(scopeId);
}
status = metricCalculateValuesSingle(rawDataSize, pRawData, pTotalMetricReportCount,
l0GfxCoreHelper, metricGroupBase, getSize, usedSize, dataOverflow, stallReportDataMap);
} else {
if (!isMultiDeviceData) {
METRICS_LOG_ERR("%s", "Cannot use sub-device raw data in a root device calculation operation handle");
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
DeviceImp *deviceImp = static_cast<DeviceImp *>(&metricSource.getMetricDeviceContext().getDevice());
status = metricCalculateValuesMulti(rawDataSize, pRawData, pTotalMetricReportCount,
getSize, deviceImp->numSubDevices,
usedSize, dataOverflow);
l0GfxCoreHelper, metricGroupBase, getSize, deviceImp->numSubDevices,
usedSize, dataOverflow, stallReportDataMap);
}
if ((status != ZE_RESULT_SUCCESS) || (getSize)) {
return status;
}
std::vector<zet_typed_value_t> ipDataValues;
uint32_t i = 0;
for (auto it = stallReportDataMap.begin(); it != stallReportDataMap.end(); ++it) {
l0GfxCoreHelper.stallSumIpDataToTypedValues(it->first, it->second, ipDataValues);
for (uint32_t j = 0; j < includedMetricIndexes.size(); j++) {
(pMetricResults + i)->value = ipDataValues[includedMetricIndexes[j]].value;
(pMetricResults + i)->resultStatus = ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID;
i++;
}
ipDataValues.clear();
}
l0GfxCoreHelper.stallIpDataMapDelete(stallReportDataMap);
stallReportDataMap.clear();
return dataOverflow ? ZE_RESULT_WARNING_DROPPED_DATA : ZE_RESULT_SUCCESS;
}

62
level_zero/tools/source/metrics/metric_ip_sampling_streamer.h
View File

@@ -10,7 +10,6 @@
#include "level_zero/tools/source/metrics/metric.h"
#include "level_zero/tools/source/metrics/os_interface_metric.h"
#include <unordered_set>
namespace L0 {
class IpSamplingMetricSourceImp;
@@ -51,19 +50,14 @@ struct MultiDeviceIpSamplingMetricStreamerImp : public IpSamplingMetricStreamerB
struct IpSamplingMetricCalcOpImp : public MetricCalcOpImp {
IpSamplingMetricCalcOpImp(bool multidevice,
const std::vector<MetricScopeImp *> &metricScopes,
uint32_t cachedMetricsCount,
std::vector<MetricImp *> &metricsInReport,
IpSamplingMetricSourceImp &metricSource,
std::vector<uint32_t> &includedMetricIndexes)
: MetricCalcOpImp(multidevice, metricScopes, metricsInReport, std::vector<MetricImp *>()),
metricSource(metricSource),
includedMetricIndexes(includedMetricIndexes) {
for (auto &scope : metricScopes) {
scopeIdToCache[scope->getId()] = new std::map<uint64_t, void *>{};
}
}
cachedMetricsCount(cachedMetricsCount),
includedMetricIndexes(includedMetricIndexes) {}
~IpSamplingMetricCalcOpImp() override{};
static ze_result_t create(bool isMultiDevice,
const std::vector<MetricScopeImp *> &metricScopes,
IpSamplingMetricSourceImp &metricSource,
@@ -76,48 +70,32 @@ struct IpSamplingMetricCalcOpImp : public MetricCalcOpImp {
uint32_t *pTotalMetricReportCount,
zet_intel_metric_result_exp_t *pMetricResults) override;
void fillStallDataMap(const size_t rawDataSize, const uint8_t *pRawData, size_t *processedSize,
L0GfxCoreHelper &l0GfxCoreHelper,
std::map<uint64_t, void *> &stallReportDataMap,
bool *dataOverflow);
protected:
ze_result_t metricCalculateValuesSingle(const size_t rawDataSize, const uint8_t *pRawData,
bool newData, uint32_t *pTotalMetricReportCount,
bool getSize, uint32_t scopeId,
bool &dataOverflow);
uint32_t *pTotalMetricReportCount,
L0::L0GfxCoreHelper &l0GfxCoreHelper,
IpSamplingMetricGroupBase *metricGroupBase,
bool getSize,
size_t *usedSize,
bool &dataOverflow,
std::map<uint64_t, void *> &stallReportDataMap);
ze_result_t metricCalculateValuesMulti(const size_t rawDataSize, const uint8_t *pRawData,
uint32_t *pTotalMetricReportCount,
L0::L0GfxCoreHelper &l0GfxCoreHelper,
IpSamplingMetricGroupBase *metricGroupBase,
bool getSize,
uint32_t numSubDevices,
size_t *usedSize,
bool &dataOverflow);
bool &dataOverflow,
std::map<uint64_t, void *> &stallReportDataMap);
bool isScopeCacheEmpty(uint32_t scopeId) {
return scopeIdToCache[scopeId]->empty();
}
bool areAllCachesEmpty() {
for (uint32_t i = 0; i < metricScopes.size(); i++) {
if (!isScopeCacheEmpty(i)) {
return false;
}
}
return true;
}
void clearScopeCache(uint32_t scopeId);
void getScopeCacheIps(uint32_t scopeId, std::unordered_set<uint64_t> &ips) {
for (const auto &entry : *scopeIdToCache[scopeId]) {
ips.insert(entry.first);
}
}
std::map<uint64_t, void *> *getScopeCache(uint32_t scopeId) {
return scopeIdToCache[scopeId];
}
IpSamplingMetricSourceImp &metricSource;
uint32_t cachedMetricsCount = 0;
std::vector<uint32_t> includedMetricIndexes{};
std::map<uint32_t, std::map<uint64_t, void *> *> scopeIdToCache{};
size_t processedSize = 0;
};
} // namespace L0

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

@@ -11,8 +11,6 @@ target_sources(${TARGET_NAME} PRIVATE
${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_ip_sampling_raw_data.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_metric_ip_sampling.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

15
level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.cpp
View File

@@ -43,7 +43,7 @@ void MetricIpSamplingMultiDevFixture::SetUp() {
osInterfaceVector.push_back(mockMetricIpSamplingOsInterface);
std::unique_ptr<MetricIpSamplingOsInterface> metricIpSamplingOsInterface = std::unique_ptr<MetricIpSamplingOsInterface>(mockMetricIpSamplingOsInterface);
auto &metricSource = device->getMetricDeviceContext().getMetricSource<IpSamplingMetricSourceImp>();
metricSource.metricCount = platformIpMetricCountXe;
metricSource.metricSourceCount = platformIpMetricCountXe;
metricSource.setMetricOsInterface(metricIpSamplingOsInterface);
auto &metricOaSource = device->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
@@ -64,7 +64,7 @@ void MetricIpSamplingFixture::SetUp() {
std::unique_ptr<MetricIpSamplingOsInterface> metricIpSamplingOsInterface = std::unique_ptr<MetricIpSamplingOsInterface>(mockMetricIpSamplingOsInterface);
auto &metricSource = device->getMetricDeviceContext().getMetricSource<IpSamplingMetricSourceImp>();
metricSource.metricCount = platformIpMetricCountXe;
metricSource.metricSourceCount = platformIpMetricCountXe;
metricSource.setMetricOsInterface(metricIpSamplingOsInterface);
auto &metricOaSource = device->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
@@ -78,14 +78,6 @@ void MetricIpSamplingFixture::TearDown() {
globalDriverHandles->clear();
}
void MetricIpSamplingCalculateBaseFixture::initRawReports() {
MockRawDataHelper::rawElementsToRawReports(static_cast<uint32_t>(rawDataElements.size()), rawDataElements, rawReports);
rawReportsBytesSize = sizeof(rawReports[0][0]) * rawReports[0].size() * rawReports.size();
MockRawDataHelper::rawElementsToRawReports(static_cast<uint32_t>(rawDataElementsOverflow.size()), rawDataElementsOverflow, rawReportsOverflow);
rawReportsBytesSizeOverflow = sizeof(rawReportsOverflow[0][0]) * rawReportsOverflow[0].size() * rawReportsOverflow.size();
}
void MetricIpSamplingCalculateBaseFixture::initCalcDescriptor() {
zet_intel_metric_scope_properties_exp_t scopeProperties{};
scopeProperties.stype = ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP;
@@ -115,8 +107,6 @@ void MetricIpSamplingCalculateBaseFixture::cleanupCalcDescriptor() {
void MetricIpSamplingCalculateMultiDevFixture::SetUp() {
MetricIpSamplingMultiDevFixture::SetUp();
initCalcDescriptor();
initRawReports();
// metricGroupHandle is expected to be set by each test for the expected device level
}
void MetricIpSamplingCalculateMultiDevFixture::TearDown() {
@@ -127,7 +117,6 @@ void MetricIpSamplingCalculateMultiDevFixture::TearDown() {
void MetricIpSamplingCalculateSingleDevFixture::SetUp() {
MetricIpSamplingFixture::SetUp();
initCalcDescriptor();
initRawReports();
device->getMetricDeviceContext().enableMetricApi();
uint32_t metricGroupCount = 1;

140
level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.h
View File

@@ -5,11 +5,11 @@
*
*/
#pragma once
#include "shared/test/common/test_macros/hw_test.h"
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
#include "level_zero/tools/source/metrics/metric_ip_sampling_source.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/mock_ip_sampling_raw_data.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_source.h"
#include <level_zero/zet_api.h>
@@ -21,6 +21,45 @@ class MockMetricIpSamplingOsInterface;
using EustallSupportedPlatforms = IsProduct<IGFX_PVC>;
class MockStallRawIpData {
public:
static constexpr uint32_t ipShift = 29;
static constexpr uint32_t ipMask = 0x1fffffff;
static constexpr uint32_t byteShift = 8;
static constexpr uint32_t byteMask = 0xff;
static constexpr uint32_t wordShift = 16;
static constexpr uint32_t wordMask = 0xffff;
uint64_t rawData[8];
MockStallRawIpData(uint64_t ip, uint64_t activeCount, uint64_t otherCount, uint64_t controlCount,
uint64_t pipeStallCount, uint64_t sendCount, uint64_t distAccCount,
uint64_t sbidCount, uint64_t syncCount, uint64_t instFetchCount, uint64_t subSlice,
uint64_t flags) {
rawData[0] = (ip & ipMask) |
((activeCount & byteMask) << ipShift) |
((otherCount & byteMask) << (ipShift + byteShift)) |
((controlCount & byteMask) << (ipShift + 2 * byteShift)) |
((pipeStallCount & byteMask) << (ipShift + 3 * byteShift)) |
((sendCount & 0x7) << (ipShift + 4 * byteShift));
rawData[1] = ((sendCount & 0xf8) >> 3) |
((distAccCount & byteMask) << 5) |
((sbidCount & byteMask) << (5 + byteShift)) |
((syncCount & byteMask) << (5 + 2 * byteShift)) |
((instFetchCount & byteMask) << (5 + 3 * byteShift));
rawData[2] = 0LL;
rawData[3] = 0LL;
rawData[4] = 0LL;
rawData[5] = 0LL;
rawData[6] = (subSlice & wordMask) | ((flags & wordMask) << wordShift);
rawData[7] = 0;
}
};
constexpr uint32_t platformIpMetricCountXe = 10;
class MetricIpSamplingMultiDevFixture : public MultiDeviceFixture,
public ::testing::Test {
@@ -44,22 +83,32 @@ class MetricIpSamplingFixture : public DeviceFixture,
class MetricIpSamplingCalculateBaseFixture {
public:
std::vector<MockRawDataHelper::RawReportElements> rawDataElements = {
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1000, 0x01}, // 1st raw report
{10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 1001, 0x000}, // 2nd raw report
{1, 9, 8, 7, 6, 5, 4, 3, 2, 1, 1000, 0x02}, // 3rd raw report
{10, 90, 80, 70, 60, 50, 40, 30, 20, 10, 1000, 0x3}, // 4th raw report
{100, 190, 180, 170, 160, 150, 140, 130, 120, 110, 1000, 0x3}, // 5th raw report
{100, 20, 30, 40, 50, 60, 70, 80, 90, 100, 1000, 0x3}}; // 6th raw report
void addHeader(uint8_t *rawDataOut, size_t rawDataOutSize, uint8_t *rawDataIn, size_t rawDataInSize, uint32_t setIndex) {
// Raw reports are 64Bytes, 8 x uint64_t
std::vector<std::array<uint64_t, 8>> rawReports = std::vector<std::array<uint64_t, 8>>(rawDataElements.size());
size_t rawReportsBytesSize = 0;
const auto expectedOutSize = sizeof(IpSamplingMetricDataHeader) + rawDataInSize;
if (expectedOutSize <= rawDataOutSize) {
auto header = reinterpret_cast<IpSamplingMetricDataHeader *>(rawDataOut);
header->magic = IpSamplingMetricDataHeader::magicValue;
header->rawDataSize = static_cast<uint32_t>(rawDataInSize);
header->setIndex = setIndex;
memcpy_s(rawDataOut + sizeof(IpSamplingMetricDataHeader), rawDataOutSize - sizeof(IpSamplingMetricDataHeader),
rawDataIn, rawDataInSize);
}
}
std::vector<MockStallRawIpData> rawDataVector = {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1000, 0x01},
{10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 1001, 0x000},
{1, 9, 8, 7, 6, 5, 4, 3, 2, 1, 1000, 0x02},
{10, 90, 80, 70, 60, 50, 40, 30, 20, 10, 1000, 0x3},
{100, 190, 180, 170, 160, 150, 140, 130, 120, 110, 1000, 0x3},
{100, 20, 30, 40, 50, 60, 70, 80, 90, 100, 1000, 0x3}};
std::vector<std::string> expectedMetricNamesInReport = {"IP", "Active", "ControlStall", "PipeStall",
"SendStall", "DistStall", "SbidStall", "SyncStall",
"InstrFetchStall", "OtherStall"};
size_t rawDataVectorSize = sizeof(rawDataVector[0]) * rawDataVector.size();
std::vector<zet_typed_value_t> expectedMetricValues = {
{ZET_VALUE_TYPE_UINT64, {1}},
{ZET_VALUE_TYPE_UINT64, {11}}, // 1st raw report + 3rd raw report
@@ -92,22 +141,7 @@ class MetricIpSamplingCalculateBaseFixture {
{ZET_VALUE_TYPE_UINT64, {210}},
{ZET_VALUE_TYPE_UINT64, {210}}};
// Expected values when calculating only IP1 on first and third *raw* reports in rawReports
std::vector<zet_typed_value_t> expectedMetricValuesIP1 = {
{ZET_VALUE_TYPE_UINT64, {1}},
{ZET_VALUE_TYPE_UINT64, {11}},
{ZET_VALUE_TYPE_UINT64, {11}},
{ZET_VALUE_TYPE_UINT64, {11}},
{ZET_VALUE_TYPE_UINT64, {11}},
{ZET_VALUE_TYPE_UINT64, {11}},
{ZET_VALUE_TYPE_UINT64, {11}},
{ZET_VALUE_TYPE_UINT64, {11}},
{ZET_VALUE_TYPE_UINT64, {11}},
{ZET_VALUE_TYPE_UINT64, {11}},
};
// Expected values when calculating only IP1 only on first *raw* reports in rawReports
std::vector<zet_typed_value_t> expectedMetricValuesIP1FirstRawReport = {
std::vector<zet_typed_value_t> interruptedExpectedMetricValues12 = {
{ZET_VALUE_TYPE_UINT64, {1}},
{ZET_VALUE_TYPE_UINT64, {2}},
{ZET_VALUE_TYPE_UINT64, {4}},
@@ -117,11 +151,20 @@ class MetricIpSamplingCalculateBaseFixture {
{ZET_VALUE_TYPE_UINT64, {8}},
{ZET_VALUE_TYPE_UINT64, {9}},
{ZET_VALUE_TYPE_UINT64, {10}},
{ZET_VALUE_TYPE_UINT64, {3}}, // L0GfxCoreHelperHw arranges "OtherStall" metric at the end
{ZET_VALUE_TYPE_UINT64, {3}}, // L0GfxCoreHelperHw arranges "OtherStall" to the end
{ZET_VALUE_TYPE_UINT64, {10}},
{ZET_VALUE_TYPE_UINT64, {20}},
{ZET_VALUE_TYPE_UINT64, {40}},
{ZET_VALUE_TYPE_UINT64, {50}},
{ZET_VALUE_TYPE_UINT64, {60}},
{ZET_VALUE_TYPE_UINT64, {70}},
{ZET_VALUE_TYPE_UINT64, {80}},
{ZET_VALUE_TYPE_UINT64, {90}},
{ZET_VALUE_TYPE_UINT64, {100}},
{ZET_VALUE_TYPE_UINT64, {30}} // L0GfxCoreHelperHw arranges "OtherStall" to the end
};
// Expected values when calculating only IP1 only on third *raw* reports in rawReports
std::vector<zet_typed_value_t> expectedMetricValuesIP1thirdRawReport = {
std::vector<zet_typed_value_t> interruptedExpectedMetricValues3 = {
{ZET_VALUE_TYPE_UINT64, {1}},
{ZET_VALUE_TYPE_UINT64, {9}},
{ZET_VALUE_TYPE_UINT64, {7}},
@@ -131,27 +174,22 @@ class MetricIpSamplingCalculateBaseFixture {
{ZET_VALUE_TYPE_UINT64, {3}},
{ZET_VALUE_TYPE_UINT64, {2}},
{ZET_VALUE_TYPE_UINT64, {1}},
{ZET_VALUE_TYPE_UINT64, {8}}, // L0GfxCoreHelperHw arranges "OtherStall" metric at the end
{ZET_VALUE_TYPE_UINT64, {8}} // L0GfxCoreHelperHw arranges "OtherStall" to the end
};
// Expected values when calculating only IP10, which is in second and fourth *raw* reports in rawReports
std::vector<zet_typed_value_t> expectedMetricValuesIP10 = {
std::vector<zet_typed_value_t> interruptedExpectedMetricValues456 = {
{ZET_VALUE_TYPE_UINT64, {10}}, // 4rd raw report
{ZET_VALUE_TYPE_UINT64, {90}},
{ZET_VALUE_TYPE_UINT64, {70}},
{ZET_VALUE_TYPE_UINT64, {60}},
{ZET_VALUE_TYPE_UINT64, {50}},
{ZET_VALUE_TYPE_UINT64, {40}},
{ZET_VALUE_TYPE_UINT64, {30}},
{ZET_VALUE_TYPE_UINT64, {20}},
{ZET_VALUE_TYPE_UINT64, {10}},
{ZET_VALUE_TYPE_UINT64, {110}},
{ZET_VALUE_TYPE_UINT64, {110}},
{ZET_VALUE_TYPE_UINT64, {110}},
{ZET_VALUE_TYPE_UINT64, {110}},
{ZET_VALUE_TYPE_UINT64, {110}},
{ZET_VALUE_TYPE_UINT64, {110}},
{ZET_VALUE_TYPE_UINT64, {110}},
{ZET_VALUE_TYPE_UINT64, {110}},
{ZET_VALUE_TYPE_UINT64, {110}},
};
// Expected values when calculating only IP100, which is in fifth and sixth *raw* reports in rawReports
std::vector<zet_typed_value_t> expectedMetricValuesIP100 = {
{ZET_VALUE_TYPE_UINT64, {80}}, // L0GfxCoreHelperHw arranges "OtherStall" to the end
{ZET_VALUE_TYPE_UINT64, {100}},
{ZET_VALUE_TYPE_UINT64, {210}},
{ZET_VALUE_TYPE_UINT64, {210}}, // 5th raw report + th raw report
{ZET_VALUE_TYPE_UINT64, {210}},
{ZET_VALUE_TYPE_UINT64, {210}},
{ZET_VALUE_TYPE_UINT64, {210}},
@@ -161,15 +199,12 @@ class MetricIpSamplingCalculateBaseFixture {
{ZET_VALUE_TYPE_UINT64, {210}},
{ZET_VALUE_TYPE_UINT64, {210}}};
std::vector<MockRawDataHelper::RawReportElements> rawDataElementsOverflow = {
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1000, 0x01},
std::vector<MockStallRawIpData> rawDataVectorOverflow = {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1000, 0x01},
{1, 9, 8, 7, 6, 5, 4, 3, 2, 1, 1000, 0x02},
{10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 1001, 0x100}, // set the overflow bit in flags
{10, 90, 80, 70, 60, 50, 40, 30, 20, 10, 1000, 0x3}};
// Raw reports are 64Bytes, 8 x uint64_t
std::vector<std::array<uint64_t, 8>> rawReportsOverflow = std::vector<std::array<uint64_t, 8>>(rawDataElementsOverflow.size());
size_t rawReportsBytesSizeOverflow = 0;
size_t rawDataVectorOverflowSize = sizeof(rawDataVectorOverflow[0]) * rawDataVectorOverflow.size();
std::vector<zet_typed_value_t> expectedMetricOverflowValues = {
{ZET_VALUE_TYPE_UINT64, {1}},
{ZET_VALUE_TYPE_UINT64, {11}},
@@ -197,7 +232,6 @@ class MetricIpSamplingCalculateBaseFixture {
zet_intel_metric_calculation_exp_desc_t calculationDesc{};
zet_metric_group_handle_t metricGroupHandle = nullptr;
void initRawReports();
void initCalcDescriptor();
void cleanupCalcDescriptor();
};

98
level_zero/tools/test/unit_tests/sources/metrics/mock_ip_sampling_raw_data.h
View File

@@ -1,98 +0,0 @@
/*
* Copyright (C) 2022-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
namespace L0 {
namespace ult {
class MockRawDataHelper {
public:
MockRawDataHelper() = default;
~MockRawDataHelper() = default;
static constexpr uint32_t ipShift = 29;
static constexpr uint32_t ipMask = 0x1fffffff;
static constexpr uint32_t byteShift = 8;
static constexpr uint32_t byteMask = 0xff;
static constexpr uint32_t wordShift = 16;
static constexpr uint32_t wordMask = 0xffff;
struct RawReportElements {
uint64_t ip;
uint64_t activeCount;
uint64_t otherCount;
uint64_t controlCount;
uint64_t pipeStallCount;
uint64_t sendCount;
uint64_t distAccCount;
uint64_t sbidCount;
uint64_t syncCount;
uint64_t instFetchCount;
uint64_t subSlice;
uint64_t flags;
};
static void rawElementsToRawReports(uint32_t reportCount, std::vector<RawReportElements> inputElements, std::vector<std::array<uint64_t, 8>> &rawReports) {
for (uint32_t i = 0; i < reportCount; i++) {
rawReports[i][0] = (inputElements[i].ip & ipMask) |
((inputElements[i].activeCount & byteMask) << ipShift) |
((inputElements[i].otherCount & byteMask) << (ipShift + byteShift)) |
((inputElements[i].controlCount & byteMask) << (ipShift + 2 * byteShift)) |
((inputElements[i].pipeStallCount & byteMask) << (ipShift + 3 * byteShift)) |
((inputElements[i].sendCount & 0x7) << (ipShift + 4 * byteShift));
rawReports[i][1] = ((inputElements[i].sendCount & 0xf8) >> 3) |
((inputElements[i].distAccCount & byteMask) << 5) |
((inputElements[i].sbidCount & byteMask) << (5 + byteShift)) |
((inputElements[i].syncCount & byteMask) << (5 + 2 * byteShift)) |
((inputElements[i].instFetchCount & byteMask) << (5 + 3 * byteShift));
rawReports[i][2] = 0LL;
rawReports[i][3] = 0LL;
rawReports[i][4] = 0LL;
rawReports[i][5] = 0LL;
rawReports[i][6] = (inputElements[i].subSlice & wordMask) | ((inputElements[i].flags & wordMask) << wordShift);
rawReports[i][7] = 0;
}
}
static void rawReportsToRawElements(uint32_t reportCount, const std::vector<std::array<uint64_t, 8>> &rawReports, std::vector<RawReportElements> &outputElements) {
outputElements.resize(reportCount);
for (uint32_t i = 0; i < reportCount; i++) {
outputElements[i].ip = rawReports[i][0] & ipMask;
outputElements[i].activeCount = (rawReports[i][0] >> ipShift) & byteMask;
outputElements[i].otherCount = (rawReports[i][0] >> (ipShift + byteShift)) & byteMask;
outputElements[i].controlCount = (rawReports[i][0] >> (ipShift + 2 * byteShift)) & byteMask;
outputElements[i].pipeStallCount = (rawReports[i][0] >> (ipShift + 3 * byteShift)) & byteMask;
outputElements[i].sendCount = ((rawReports[i][0] >> (ipShift + 4 * byteShift)) & 0x7) |
((rawReports[i][1] & 0x1f) << 3);
outputElements[i].distAccCount = (rawReports[i][1] >> 5) & byteMask;
outputElements[i].sbidCount = (rawReports[i][1] >> (5 + byteShift)) & byteMask;
outputElements[i].syncCount = (rawReports[i][1] >> (5 + 2 * byteShift)) & byteMask;
outputElements[i].instFetchCount = (rawReports[i][1] >> (5 + 3 * byteShift)) & byteMask;
outputElements[i].subSlice = rawReports[i][6] & wordMask;
outputElements[i].flags = (rawReports[i][6] >> wordShift) & wordMask;
}
}
static void addMultiSubDevHeader(uint8_t *rawDataOut, size_t rawDataOutSize, uint8_t *rawDataIn, size_t rawDataInSize, uint32_t setIndex) {
const auto expectedOutSize = sizeof(IpSamplingMetricDataHeader) + rawDataInSize;
if (expectedOutSize <= rawDataOutSize) {
auto header = reinterpret_cast<IpSamplingMetricDataHeader *>(rawDataOut);
header->magic = IpSamplingMetricDataHeader::magicValue;
header->rawDataSize = static_cast<uint32_t>(rawDataInSize);
header->setIndex = setIndex;
memcpy_s(rawDataOut + sizeof(IpSamplingMetricDataHeader), rawDataOutSize - sizeof(IpSamplingMetricDataHeader),
rawDataIn, rawDataInSize);
}
}
};
} // namespace ult
} // namespace L0

24
level_zero/tools/test/unit_tests/sources/metrics/test_metric.cpp
View File

@@ -254,30 +254,6 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpWithMixedHierarchiesThenErrorIsRe
&hCalculationOperation));
}
TEST_F(CalcOperationFixture, WhenCreatingCalcSubDeviceOnlyAcceptsOneScope) {
std::vector<zet_intel_metric_scope_exp_handle_t> metricScopes{hMetricScope, hMetricScope};
zet_intel_metric_calculation_exp_desc_t calculationDesc{
ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP,
nullptr, // pNext
1, // metricGroupCount
&hMetricGroup, // phMetricGroups
0, // metricCount
nullptr, // phMetrics
0, // timeWindowsCount
nullptr, // pCalculationTimeWindows
1000, // timeAggregationWindow
2, // metricScopesCount
metricScopes.data(), // phMetricScopes
};
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculationOperationCreateExp(context,
device->toHandle(), &calculationDesc,
&hCalculationOperation));
}
TEST_F(CalcOperationFixture, WhenCreatingCalcOpUseTheSourceFromMetricGroupOrMetricWhenAvailable) {
MockMetricGroup mockMetricGroup2(mockMetricSource);

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

@@ -603,8 +603,8 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
std::vector<uint8_t> rawDataWithHeader(rawReportsBytesSize + sizeof(IpSamplingMetricDataHeader));
MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawReports.data()), rawReportsBytesSize, 0);
std::vector<uint8_t> rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader));
addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataVector.data()), rawDataVectorSize, 0);
uint32_t setCount = 0;
// Use random initializer
@@ -648,8 +648,8 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
std::vector<uint8_t> rawDataWithHeader(rawReportsBytesSize + sizeof(IpSamplingMetricDataHeader));
MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawReports.data()), rawReportsBytesSize, 0);
std::vector<uint8_t> rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader));
addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataVector.data()), rawDataVectorSize, 0);
auto header = reinterpret_cast<IpSamplingMetricDataHeader *>(rawDataWithHeader.data());
header->magic = IpSamplingMetricDataHeader::magicValue - 1;
@@ -689,13 +689,13 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
uint32_t totalMetricValueCount = std::numeric_limits<uint32_t>::max();
std::vector<uint32_t> metricCounts(1);
EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0],
ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawReportsBytesSize, reinterpret_cast<uint8_t *>(rawReports.data()),
ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()),
&setCount, &totalMetricValueCount, metricCounts.data(), nullptr),
ZE_RESULT_SUCCESS);
EXPECT_EQ(setCount, 1u);
EXPECT_EQ(totalMetricValueCount, 30u);
EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0],
ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawReportsBytesSize, reinterpret_cast<uint8_t *>(rawReports.data()),
ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()),
&setCount, &totalMetricValueCount, metricCounts.data(), metricValues.data()),
ZE_RESULT_SUCCESS);
EXPECT_EQ(setCount, 1u);
@@ -733,7 +733,7 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
std::vector<uint32_t> metricCounts(1);
EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0],
ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, 1,
reinterpret_cast<uint8_t *>(rawReports.data()),
reinterpret_cast<uint8_t *>(rawDataVector.data()),
&setCount, &totalMetricValueCount, metricCounts.data(), nullptr),
ZE_RESULT_ERROR_INVALID_SIZE);
}
@@ -758,10 +758,10 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
// Allocate for 2 reads
std::vector<uint8_t> rawDataWithHeader((rawReportsBytesSize + sizeof(IpSamplingMetricDataHeader)) * 2);
MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawReports.data()), rawReportsBytesSize, 1);
MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data() + rawReportsBytesSize + sizeof(IpSamplingMetricDataHeader),
rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawReports.data()), rawReportsBytesSize, 0);
std::vector<uint8_t> rawDataWithHeader((rawDataVectorSize + sizeof(IpSamplingMetricDataHeader)) * 2);
addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataVector.data()), rawDataVectorSize, 1);
addHeader(rawDataWithHeader.data() + rawDataVectorSize + sizeof(IpSamplingMetricDataHeader),
rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataVector.data()), rawDataVectorSize, 0);
// Use random initializer
uint32_t setCount = std::numeric_limits<uint32_t>::max();
@@ -806,8 +806,8 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
std::vector<uint8_t> rawDataWithHeader(rawReportsBytesSize + sizeof(IpSamplingMetricDataHeader) + 1);
MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawReports.data()), rawReportsBytesSize, 0);
std::vector<uint8_t> rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader) + 1);
addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataVector.data()), rawDataVectorSize, 0);
uint32_t setCount = 0;
uint32_t totalMetricValueCount = 0;
@@ -839,11 +839,11 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, WhenCalculateMultipleMetricValue
std::vector<uint8_t> rawData;
if (isRootdevice) { // Root device data (rawDataWithHeader) makes sense only for calculating with root device mg handle.
rawData.resize(rawReportsBytesSize + sizeof(IpSamplingMetricDataHeader));
MockRawDataHelper::addMultiSubDevHeader(rawData.data(), rawData.size(), reinterpret_cast<uint8_t *>(rawReports.data()), rawReportsBytesSize, 0);
rawData.resize(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader));
addHeader(rawData.data(), rawData.size(), reinterpret_cast<uint8_t *>(rawDataVector.data()), rawDataVectorSize, 0);
} else {
rawData.resize(rawReportsBytesSize);
memcpy_s(rawData.data(), rawData.size(), reinterpret_cast<uint8_t *>(rawReports.data()), rawReportsBytesSize);
rawData.resize(rawDataVectorSize);
memcpy_s(rawData.data(), rawData.size(), reinterpret_cast<uint8_t *>(rawDataVector.data()), rawDataVectorSize);
}
uint32_t setCount = 0;
@@ -857,7 +857,7 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, WhenCalculateMultipleMetricValue
size_t rawDatSize = rawData.size();
if (isRootdevice) {
auto header = reinterpret_cast<IpSamplingMetricDataHeader *>(rawData.data());
header->rawDataSize = static_cast<uint32_t>(rawReportsBytesSize - 1);
header->rawDataSize = static_cast<uint32_t>(rawDataVectorSize - 1);
} else {
rawDatSize = rawData.size() - 1;
}
@@ -885,8 +885,8 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, WhenCalculateMultipleMetricValue
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
std::vector<uint8_t> rawDataWithHeader(rawReportsBytesSize + sizeof(IpSamplingMetricDataHeader) + 1);
MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawReports.data()), rawReportsBytesSize - 1, 0);
std::vector<uint8_t> rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader) + 1);
addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataVector.data()), rawDataVectorSize - 1, 0);
uint32_t setCount = 0;
uint32_t totalMetricValueCount = 0;
@@ -913,8 +913,8 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, WhenCalculateMultipleMetricValue
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
std::vector<uint8_t> rawDataWithHeader(rawReportsBytesSize + sizeof(IpSamplingMetricDataHeader) + 1);
MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawReports.data()), rawReportsBytesSize - 1, 0);
std::vector<uint8_t> rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader) + 1);
addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataVector.data()), rawDataVectorSize - 1, 0);
uint32_t setCount = 0;
uint32_t totalMetricValueCount = 10;
@@ -943,8 +943,8 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
std::vector<uint8_t> rawDataWithHeader(rawReportsBytesSize + sizeof(IpSamplingMetricDataHeader));
MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawReports.data()), rawReportsBytesSize, 0);
std::vector<uint8_t> rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader));
addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataVector.data()), rawDataVectorSize, 0);
uint32_t setCount = 0;
uint32_t totalMetricValueCount = 0;
@@ -976,7 +976,7 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
device->getProperties(&props);
if (!(props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE)) {
// Sub-device data (rawReports) will work only with sub-device metric group handle.
// Sub-device data (rawDataVector) will work only with sub-device metric group handle.
// Calling calculate with root-device metric group handle will return INVALID ARGUMENT.
isRootdevice = true;
expectedResult = ZE_RESULT_ERROR_INVALID_ARGUMENT;
@@ -994,11 +994,11 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
uint32_t metricValueCount = 0;
EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES,
rawReportsBytesSize, reinterpret_cast<uint8_t *>(rawReports.data()), &metricValueCount, nullptr),
rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()), &metricValueCount, nullptr),
expectedResult);
if (!isRootdevice) {
EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES,
rawReportsBytesSize, reinterpret_cast<uint8_t *>(rawReports.data()), &metricValueCount, metricValues.data()),
rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()), &metricValueCount, metricValues.data()),
expectedResult);
EXPECT_TRUE(metricValueCount == 30);
@@ -1027,8 +1027,8 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
std::vector<uint8_t> rawDataWithHeader(rawReportsBytesSize + sizeof(IpSamplingMetricDataHeader));
MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawReports.data()), rawReportsBytesSize, 0);
std::vector<uint8_t> rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader));
addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataVector.data()), rawDataVectorSize, 0);
uint32_t metricValueCount = 0;
EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES,
rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataWithHeader.data()),
@@ -1046,7 +1046,7 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
for (auto device : testDevices) {
ze_device_properties_t props = {};
device->getProperties(&props);
if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) { // Sub-device data (rawReports) will work only with sub-device metric group handle.
if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) { // Sub-device data (rawDataVector) will work only with sub-device metric group handle.
uint32_t metricGroupCount = 0;
zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr);
std::vector<zet_metric_group_handle_t> metricGroups;
@@ -1059,13 +1059,13 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
uint32_t metricValueCount = 0;
EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES,
rawReportsBytesSize, reinterpret_cast<uint8_t *>(rawReports.data()), &metricValueCount, nullptr),
rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()), &metricValueCount, nullptr),
ZE_RESULT_SUCCESS);
EXPECT_TRUE(metricValueCount == 30);
metricValueCount = 15;
EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES,
rawReportsBytesSize, reinterpret_cast<uint8_t *>(rawReports.data()), &metricValueCount, metricValues.data()),
rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()), &metricValueCount, metricValues.data()),
ZE_RESULT_SUCCESS);
EXPECT_TRUE(metricValueCount == 15);
for (uint32_t i = 0; i < metricValueCount; i++) {
@@ -1083,7 +1083,7 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWith
for (auto device : testDevices) {
ze_device_properties_t props = {};
device->getProperties(&props);
if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) { // Sub-device data (rawReports) will work only with sub-device metric group handle.
if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) { // Sub-device data (rawDataVector) will work only with sub-device metric group handle.
uint32_t metricGroupCount = 0;
zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr);
std::vector<zet_metric_group_handle_t> metricGroups;
@@ -1096,7 +1096,7 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWith
uint32_t metricValueCount = 0;
EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES,
rawReportsBytesSize - 1, reinterpret_cast<uint8_t *>(rawReports.data()), &metricValueCount, nullptr),
rawDataVectorSize - 1, reinterpret_cast<uint8_t *>(rawDataVector.data()), &metricValueCount, nullptr),
ZE_RESULT_ERROR_INVALID_SIZE);
}
}
@@ -1111,7 +1111,7 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
for (auto device : testDevices) {
ze_device_properties_t props = {};
device->getProperties(&props);
if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) { // Sub-device data (rawReports) will work only with sub-device metric group handle.
if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) { // Sub-device data (rawDataVector) will work only with sub-device metric group handle.
uint32_t metricGroupCount = 0;
zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr);
@@ -1125,12 +1125,12 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen
uint32_t metricValueCount = 0;
EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES,
rawReportsBytesSize, reinterpret_cast<uint8_t *>(rawReports.data()), &metricValueCount, nullptr),
rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()), &metricValueCount, nullptr),
ZE_RESULT_SUCCESS);
EXPECT_TRUE(metricValueCount == 30u);
EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES,
rawReportsBytesSize - 1, reinterpret_cast<uint8_t *>(rawReports.data()), &metricValueCount, metricValues.data()),
rawDataVectorSize - 1, reinterpret_cast<uint8_t *>(rawDataVector.data()), &metricValueCount, metricValues.data()),
ZE_RESULT_ERROR_INVALID_SIZE);
}
}
@@ -1158,11 +1158,11 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenDataOverflowOccurredWhenStr
std::vector<uint8_t> rawData;
if (isRootdevice) { // Root device data (rawDataWithHeader) makes sense only for calculating with root device mg handle.
rawData.resize(rawReportsBytesSizeOverflow + sizeof(IpSamplingMetricDataHeader));
MockRawDataHelper::addMultiSubDevHeader(rawData.data(), rawData.size(), reinterpret_cast<uint8_t *>(rawReportsOverflow.data()), rawReportsBytesSizeOverflow, 0);
rawData.resize(rawDataVectorOverflowSize + sizeof(IpSamplingMetricDataHeader));
addHeader(rawData.data(), rawData.size(), reinterpret_cast<uint8_t *>(rawDataVectorOverflow.data()), rawDataVectorOverflowSize, 0);
} else {
rawData.resize(rawReportsBytesSizeOverflow);
memcpy_s(rawData.data(), rawData.size(), reinterpret_cast<uint8_t *>(rawReportsOverflow.data()), rawReportsBytesSizeOverflow);
rawData.resize(rawDataVectorOverflowSize);
memcpy_s(rawData.data(), rawData.size(), reinterpret_cast<uint8_t *>(rawDataVectorOverflow.data()), rawDataVectorOverflowSize);
}
uint32_t setCount = 0;
@@ -1199,7 +1199,7 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWith
for (auto device : testDevices) {
ze_device_properties_t props = {};
device->getProperties(&props);
if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) { // Sub-device data (rawReports) will work only with sub-device metric group handle.
if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) { // Sub-device data (rawDataVector) will work only with sub-device metric group handle.
uint32_t metricGroupCount = 0;
zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr);
@@ -1213,12 +1213,12 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWith
uint32_t metricValueCount = 0;
EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES,
rawReportsBytesSize, reinterpret_cast<uint8_t *>(rawReports.data()), &metricValueCount, nullptr),
rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()), &metricValueCount, nullptr),
ZE_RESULT_SUCCESS);
EXPECT_EQ(metricValueCount, 30u);
EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_MAX_METRIC_VALUES,
rawReportsBytesSize, reinterpret_cast<uint8_t *>(rawReports.data()), &metricValueCount, metricValues.data()),
rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()), &metricValueCount, metricValues.data()),
ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
}

390
level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_streamer.cpp
View File

@@ -771,6 +771,7 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingCalcOpGetReportForm
for (auto device : testDevices) {
uint32_t metricGroupCount = 1;
zet_metric_group_handle_t metricGroupHandle = nullptr;
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
@@ -848,6 +849,7 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingMultiScopeCalcOpGet
EXPECT_EQ(ZE_RESULT_SUCCESS, device->getMetricDeviceContext().enableMetricApi());
uint32_t metricGroupCount = 1;
zet_metric_group_handle_t metricGroupHandle = nullptr;
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
@@ -967,6 +969,7 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, GivenIpSamplingCalcOpCallingMetric
EXPECT_EQ(ZE_RESULT_SUCCESS, device->getMetricDeviceContext().enableMetricApi());
uint32_t metricGroupCount = 1;
zet_metric_group_handle_t metricGroupHandle = nullptr;
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
@@ -980,8 +983,8 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, GivenIpSamplingCalcOpCallingMetric
device->toHandle(), &calculationDesc,
&hCalculationOperation));
std::vector<uint8_t> rawDataWithHeader(rawReportsBytesSize + sizeof(IpSamplingMetricDataHeader));
MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawReports.data()), rawReportsBytesSize, 0);
std::vector<uint8_t> rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader));
addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataVector.data()), rawDataVectorSize, 0);
uint32_t totalMetricReportCount = 0;
bool final = true;
@@ -989,7 +992,8 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, GivenIpSamplingCalcOpCallingMetric
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetIntelMetricCalculateValuesExp(rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataWithHeader.data()),
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, nullptr));
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateValuesExp(rawReportsBytesSize, reinterpret_cast<uint8_t *>(rawReports.data()),
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateValuesExp(rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()),
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, nullptr));
@@ -998,23 +1002,6 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, GivenIpSamplingCalcOpCallingMetric
using MetricIpSamplingCalcOpTest = MetricIpSamplingCalculateSingleDevFixture;
HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpDeletingAnInvalidCacheIdIsIgnored, EustallSupportedPlatforms) {
struct MockIpSamplingMetricCalcOpImp : IpSamplingMetricCalcOpImp {
void mockClearScopeCache(uint32_t cacheId) {
clearScopeCache(cacheId);
}
};
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(),
device->toHandle(), &calculationDesc,
&hCalculationOperation));
MockIpSamplingMetricCalcOpImp *calcOp = static_cast<MockIpSamplingMetricCalcOpImp *>(MetricCalcOp::fromHandle(hCalculationOperation));
calcOp->mockClearScopeCache(12345); // some random invalid cache id
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalculationOperation));
}
HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculateValuesOnSubDeviceThenSuccessIsReturned, EustallSupportedPlatforms) {
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
@@ -1038,18 +1025,17 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat
uint32_t totalMetricReportCount = 0;
bool final = true;
size_t usedSize = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawReportsBytesSize, reinterpret_cast<uint8_t *>(rawReports.data()),
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()),
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, nullptr));
EXPECT_EQ(totalMetricReportCount, 3U);
std::vector<zet_intel_metric_result_exp_t> metricResults(totalMetricReportCount * metricsInReportCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawReportsBytesSize, reinterpret_cast<uint8_t *>(rawReports.data()),
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()),
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, metricResults.data()));
EXPECT_EQ(totalMetricReportCount, 3U);
EXPECT_EQ(usedSize, rawReportsBytesSize);
EXPECT_EQ(usedSize, rawDataVectorSize);
for (uint32_t i = 0; i < totalMetricReportCount; i++) {
for (uint32_t j = 0; j < metricsInReportCount; j++) {
@@ -1071,8 +1057,8 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat
device->toHandle(), &calculationDesc,
&hCalculationOperation));
std::vector<uint8_t> rawDataWithHeader(rawReportsBytesSize + sizeof(IpSamplingMetricDataHeader));
MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawReports.data()), rawReportsBytesSize, 0);
std::vector<uint8_t> rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader));
addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataVector.data()), rawDataVectorSize, 0);
uint32_t totalMetricReportCount = 0;
bool final = true;
@@ -1084,7 +1070,7 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat
&totalMetricReportCount, nullptr));
// invalid input raw data size
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_SIZE, zetIntelMetricCalculateValuesExp(rawReportsBytesSize / 30, reinterpret_cast<uint8_t *>(rawReports.data()),
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_SIZE, zetIntelMetricCalculateValuesExp(rawDataVectorSize / 30, reinterpret_cast<uint8_t *>(rawDataVector.data()),
hCalculationOperation,
final, &usedSize,
&totalMetricReportCount, nullptr));
@@ -1103,12 +1089,12 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat
size_t usedSize = 0;
std::vector<zet_intel_metric_result_exp_t> metricResults(totalMetricReportCount * 10);
EXPECT_EQ(ZE_RESULT_WARNING_DROPPED_DATA, zetIntelMetricCalculateValuesExp(rawReportsBytesSizeOverflow, reinterpret_cast<uint8_t *>(rawReportsOverflow.data()),
EXPECT_EQ(ZE_RESULT_WARNING_DROPPED_DATA, zetIntelMetricCalculateValuesExp(rawDataVectorOverflowSize, reinterpret_cast<uint8_t *>(rawDataVectorOverflow.data()),
hCalculationOperation,
final, &usedSize,
&totalMetricReportCount, metricResults.data()));
EXPECT_EQ(totalMetricReportCount, 2U);
EXPECT_EQ(usedSize, rawReportsBytesSizeOverflow);
EXPECT_EQ(usedSize, rawDataVectorOverflowSize);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalculationOperation));
}
@@ -1152,18 +1138,18 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat
bool final = true;
size_t usedSize = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawReportsBytesSize, reinterpret_cast<uint8_t *>(rawReports.data()),
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()),
hCalculationOperation,
final, &usedSize,
&totalMetricReportCount, nullptr));
std::vector<zet_intel_metric_result_exp_t> metricResults(totalMetricReportCount * metricsInReportCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawReportsBytesSize, reinterpret_cast<uint8_t *>(rawReports.data()),
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()),
hCalculationOperation,
final, &usedSize,
&totalMetricReportCount, metricResults.data()));
EXPECT_EQ(totalMetricReportCount, 3U);
EXPECT_EQ(usedSize, rawReportsBytesSize);
EXPECT_EQ(usedSize, rawDataVectorSize);
// Expect only odd index metrics results of the first report
for (uint32_t j = 0; j < metricsInReportCount; j++) {
@@ -1173,353 +1159,29 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalculationOperation));
}
HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCallingMetricCalculateValuesOnSubDeviceCanRequestFewerValuesThanAvailable, EustallSupportedPlatforms) {
HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculateValuesDoesNotAllowLimitingResults, EustallSupportedPlatforms) {
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(),
device->toHandle(), &calculationDesc,
&hCalculationOperation));
uint32_t metricsInReportCount = 10;
std::vector<zet_metric_handle_t> metricsInReport(metricsInReportCount);
std::vector<zet_intel_metric_scope_exp_handle_t> metricScopesInReport(metricsInReportCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationGetReportFormatExp(hCalculationOperation,
&metricsInReportCount,
metricsInReport.data(),
metricScopesInReport.data()));
EXPECT_EQ(metricsInReportCount, 10u);
uint32_t totalMetricReportCount = 0;
bool final = false;
size_t usedSize = 0;
uint8_t *rawdata = reinterpret_cast<uint8_t *>(rawReports.data());
size_t dataBytesSize = rawReportsBytesSize;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(dataBytesSize, rawdata,
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, nullptr));
EXPECT_EQ(totalMetricReportCount, 3U);
// Request only one report even if three are available
totalMetricReportCount = 1;
std::vector<zet_intel_metric_result_exp_t> metricResults(metricsInReportCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(dataBytesSize, rawdata,
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, metricResults.data()));
EXPECT_EQ(totalMetricReportCount, 1U);
EXPECT_EQ(usedSize, IpSamplingCalculation::rawReportSize);
for (uint32_t j = 0; j < expectedMetricValuesIP1.size(); j++) {
EXPECT_TRUE(metricResults[j].value.ui64 == expectedMetricValuesIP1[j].value.ui64);
}
dataBytesSize -= usedSize;
rawdata += usedSize;
totalMetricReportCount = 0; // query again available reports
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(dataBytesSize, rawdata,
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, nullptr));
EXPECT_EQ(totalMetricReportCount, 2U); // two reports are available, cached
// Request only one report
totalMetricReportCount = 1;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(dataBytesSize, rawdata,
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, metricResults.data()));
EXPECT_EQ(totalMetricReportCount, 1U);
EXPECT_EQ(usedSize, IpSamplingCalculation::rawReportSize);
for (uint32_t j = 0; j < expectedMetricValuesIP10.size(); j++) {
EXPECT_TRUE(metricResults[j].value.ui64 == expectedMetricValuesIP10[j].value.ui64);
}
dataBytesSize -= usedSize;
rawdata += usedSize;
totalMetricReportCount = 0; // query again available reports
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(dataBytesSize, rawdata,
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, nullptr));
EXPECT_EQ(totalMetricReportCount, 1U); // one report is available, cached
// Request only one report
totalMetricReportCount = 1;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(dataBytesSize, rawdata,
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, metricResults.data()));
EXPECT_EQ(totalMetricReportCount, 1U);
EXPECT_EQ(usedSize, dataBytesSize);
for (uint32_t j = 0; j < expectedMetricValuesIP100.size(); j++) {
EXPECT_TRUE(metricResults[j].value.ui64 == expectedMetricValuesIP100[j].value.ui64);
}
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalculationOperation));
}
HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCallingMetricCalculateValuesOnSubDeviceCanRequestFewerValuesThanAvailableFinalTrue, EustallSupportedPlatforms) {
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(),
device->toHandle(), &calculationDesc,
&hCalculationOperation));
uint32_t metricsInReportCount = 10;
std::vector<zet_metric_handle_t> metricsInReport(metricsInReportCount);
std::vector<zet_intel_metric_scope_exp_handle_t> metricScopesInReport(metricsInReportCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationGetReportFormatExp(hCalculationOperation,
&metricsInReportCount,
metricsInReport.data(),
metricScopesInReport.data()));
EXPECT_EQ(metricsInReportCount, 10u);
uint32_t totalMetricReportCount = 0;
bool final = true;
size_t usedSize = 0;
uint8_t *rawdata = reinterpret_cast<uint8_t *>(rawReports.data());
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawReportsBytesSize, rawdata,
hCalculationOperation, final, &usedSize,
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()),
hCalculationOperation,
final, &usedSize,
&totalMetricReportCount, nullptr));
EXPECT_EQ(totalMetricReportCount, 3U);
// Request only one report even if three are available
// Request fewer reports
totalMetricReportCount = 1;
std::vector<zet_intel_metric_result_exp_t> metricResults(metricsInReportCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawReportsBytesSize, rawdata,
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, metricResults.data()));
EXPECT_EQ(totalMetricReportCount, 1U);
EXPECT_EQ(usedSize, IpSamplingCalculation::rawReportSize);
for (uint32_t j = 0; j < expectedMetricValuesIP1.size(); j++) {
EXPECT_TRUE(metricResults[j].value.ui64 == expectedMetricValuesIP1[j].value.ui64);
}
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalculationOperation));
}
HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCallingMetricCalculateValuesOnSubDeviceCanConcatenateData, EustallSupportedPlatforms) {
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(),
device->toHandle(), &calculationDesc,
&hCalculationOperation));
uint32_t metricsInReportCount = 10;
std::vector<zet_metric_handle_t> metricsInReport(metricsInReportCount);
std::vector<zet_intel_metric_scope_exp_handle_t> metricScopesInReport(metricsInReportCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationGetReportFormatExp(hCalculationOperation,
&metricsInReportCount,
metricsInReport.data(),
metricScopesInReport.data()));
EXPECT_EQ(metricsInReportCount, 10u);
uint32_t totalMetricReportCount = 0;
bool final = false;
size_t usedSize = 0;
uint8_t *rawdata = reinterpret_cast<uint8_t *>(rawReports.data());
size_t dataSize = 2 * IpSamplingCalculation::rawReportSize; // Only use the first two raw reports
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(dataSize, rawdata,
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, nullptr));
EXPECT_EQ(totalMetricReportCount, 2U); // IP1 first raw report, IP10 second raw report
// Request only one report even if two are available, leave result for IP 10 (second raw report) cached
totalMetricReportCount = 1;
std::vector<zet_intel_metric_result_exp_t> metricResults(metricsInReportCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(dataSize, rawdata,
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, metricResults.data()));
EXPECT_EQ(totalMetricReportCount, 1U);
EXPECT_EQ(usedSize, IpSamplingCalculation::rawReportSize); // If cached results remain, used size will be a single raw report
for (uint32_t j = 0; j < expectedMetricValuesIP1FirstRawReport.size(); j++) {
EXPECT_TRUE(metricResults[j].value.ui64 == expectedMetricValuesIP1FirstRawReport[j].value.ui64);
}
// Advance already processed data and simulate appending
rawdata += usedSize; // now points to second raw report
// simulate appending one new raw report at the end. Third of rawReports
dataSize = 2 * IpSamplingCalculation::rawReportSize;
totalMetricReportCount = 0; // query again available reports
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(dataSize, rawdata,
hCalculationOperation, final, &usedSize,
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateValuesExp(rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()),
hCalculationOperation,
final, &usedSize,
&totalMetricReportCount, nullptr));
EXPECT_EQ(totalMetricReportCount, 2U); // IP 10 cached plus new IP 1 from third raw report
// Request only one report
totalMetricReportCount = 1;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(dataSize, rawdata,
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, metricResults.data()));
EXPECT_EQ(totalMetricReportCount, 1U);
EXPECT_EQ(usedSize, IpSamplingCalculation::rawReportSize); // If cached results remain, used size will be a single raw report
// Once again expect to find results for IP1, but this time from the third raw report.
for (uint32_t j = 0; j < expectedMetricValuesIP1thirdRawReport.size(); j++) {
EXPECT_TRUE(metricResults[j].value.ui64 == expectedMetricValuesIP1thirdRawReport[j].value.ui64);
}
// Advance already processed data and simulate appending
rawdata += usedSize; // now points to the third raw report
// simulate appending two new raw reports at the end. Fourth and fifth of rawReports
dataSize = 3 * IpSamplingCalculation::rawReportSize;
totalMetricReportCount = 0; // query again available reports
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(dataSize, rawdata,
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, nullptr));
EXPECT_EQ(totalMetricReportCount, 2U); // IP 10 cached and also new from forth report and IP 100 from fifth raw report
// Request only one report
totalMetricReportCount = 1;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(dataSize, rawdata,
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, metricResults.data()));
EXPECT_EQ(totalMetricReportCount, 1U);
EXPECT_EQ(usedSize, IpSamplingCalculation::rawReportSize); // If cached results remain, used size will be a single raw report
// Results from IP 10 should be the sum of the values cached plus new data found
for (uint32_t j = 0; j < expectedMetricValuesIP10.size(); j++) {
EXPECT_TRUE(metricResults[j].value.ui64 == expectedMetricValuesIP10[j].value.ui64);
}
// Advance already processed data and simulate appending
rawdata += usedSize; // // now points to the fourth raw report
// simulate appending one new raw report at the end. sixth of rawReports
// Note: since previously appended two but progressed only one, now the new size is 3 raw reports
dataSize = 3 * IpSamplingCalculation::rawReportSize;
totalMetricReportCount = 0; // query again available reports
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(dataSize, rawdata,
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, nullptr));
EXPECT_EQ(totalMetricReportCount, 1U); // IP100, cached and from the sixth raw report
// Request only one report
totalMetricReportCount = 1;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(dataSize, rawdata,
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, metricResults.data()));
EXPECT_EQ(totalMetricReportCount, 1U);
EXPECT_EQ(usedSize, dataSize); // all cached data consumed, usedSize should be equal to input size
// Results from IP 100 should be the sum of the values cached plus new data found
for (uint32_t j = 0; j < expectedMetricValuesIP100.size(); j++) {
EXPECT_TRUE(metricResults[j].value.ui64 == expectedMetricValuesIP100[j].value.ui64);
}
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalculationOperation));
}
HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCallingMetricCalculateValuesOnSubDeviceCanConcatenateDataFinalTrue, EustallSupportedPlatforms) {
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(),
device->toHandle(), &calculationDesc,
&hCalculationOperation));
uint32_t metricsInReportCount = 10;
std::vector<zet_metric_handle_t> metricsInReport(metricsInReportCount);
std::vector<zet_intel_metric_scope_exp_handle_t> metricScopesInReport(metricsInReportCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationGetReportFormatExp(hCalculationOperation,
&metricsInReportCount,
metricsInReport.data(),
metricScopesInReport.data()));
EXPECT_EQ(metricsInReportCount, 10u);
uint32_t totalMetricReportCount = 0;
bool final = false;
size_t usedSize = 0;
uint8_t *rawdata = reinterpret_cast<uint8_t *>(rawReports.data());
size_t dataSize = 2 * IpSamplingCalculation::rawReportSize; // Only use the first two raw reports
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(dataSize, rawdata,
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, nullptr));
EXPECT_EQ(totalMetricReportCount, 2U); // IP1 first raw report, IP10 second raw report
// Request only one report even if two are available, leave result for IP 10 (second raw report) cached
totalMetricReportCount = 1;
std::vector<zet_intel_metric_result_exp_t> metricResults(metricsInReportCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(dataSize, rawdata,
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, metricResults.data()));
EXPECT_EQ(totalMetricReportCount, 1U);
EXPECT_EQ(usedSize, IpSamplingCalculation::rawReportSize); // If cached results remain, used size will be a single raw report
for (uint32_t j = 0; j < expectedMetricValuesIP1FirstRawReport.size(); j++) {
EXPECT_TRUE(metricResults[j].value.ui64 == expectedMetricValuesIP1FirstRawReport[j].value.ui64);
}
// Advance already processed data and simulate appending
rawdata += usedSize; // now points to second raw report
// simulate appending one new raw report at the end. Third of rawReports
dataSize = 2 * IpSamplingCalculation::rawReportSize;
totalMetricReportCount = 0; // query again available reports
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(dataSize, rawdata,
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, nullptr));
EXPECT_EQ(totalMetricReportCount, 2U); // IP 10 cached plus new IP 1 from third raw report
final = true; // clean all
// Request only one report
totalMetricReportCount = 1;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(dataSize, rawdata,
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, metricResults.data()));
EXPECT_EQ(totalMetricReportCount, 1U);
EXPECT_EQ(usedSize, IpSamplingCalculation::rawReportSize); // If cached results remain, used size will be a single raw report
// Once again expect to find results for IP1, but this time from the third raw report.
for (uint32_t j = 0; j < expectedMetricValuesIP1thirdRawReport.size(); j++) {
EXPECT_TRUE(metricResults[j].value.ui64 == expectedMetricValuesIP1thirdRawReport[j].value.ui64);
}
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalculationOperation));
}
HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingWhenDestroyingCalcOpCachesareFreed, EustallSupportedPlatforms) {
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(),
device->toHandle(), &calculationDesc,
&hCalculationOperation));
uint32_t metricsInReportCount = 10;
std::vector<zet_metric_handle_t> metricsInReport(metricsInReportCount);
std::vector<zet_intel_metric_scope_exp_handle_t> metricScopesInReport(metricsInReportCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationGetReportFormatExp(hCalculationOperation,
&metricsInReportCount,
metricsInReport.data(),
metricScopesInReport.data()));
EXPECT_EQ(metricsInReportCount, 10u);
uint32_t totalMetricReportCount = 0;
bool final = false;
size_t usedSize = 0;
uint8_t *rawdata = reinterpret_cast<uint8_t *>(rawReports.data());
size_t dataBytesSize = rawReportsBytesSize;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(dataBytesSize, rawdata,
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, nullptr));
EXPECT_EQ(totalMetricReportCount, 3U);
// Request only one report even if three are available
totalMetricReportCount = 1;
std::vector<zet_intel_metric_result_exp_t> metricResults(metricsInReportCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(dataBytesSize, rawdata,
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, metricResults.data()));
EXPECT_EQ(totalMetricReportCount, 1U);
EXPECT_EQ(usedSize, IpSamplingCalculation::rawReportSize);
// 2 IPs remain cached.
// Destroying calcOp should free the cached IP results
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalculationOperation));
}