diff --git a/level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper.h b/level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper.h index 8f0b7973f7..73566b9a5d 100644 --- a/level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper.h +++ b/level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper.h @@ -110,7 +110,6 @@ class L0GfxCoreHelper : public NEO::ApiGfxCoreHelper { virtual void stallSumIpDataToTypedValues(uint64_t ip, void *sumIpData, std::vector &ipDataValues) = 0; virtual bool stallIpDataMapUpdate(std::map &stallSumIpDataMap, const uint8_t *pRawIpData) = 0; virtual void stallIpDataMapDelete(std::map &stallSumIpDataMap) = 0; - virtual void stallIpDataMapDeleteEntry(std::map::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 &ipDataValues) override; bool stallIpDataMapUpdate(std::map &stallSumIpDataMap, const uint8_t *pRawIpData) override; void stallIpDataMapDelete(std::map &stallSumIpDataMap) override; - void stallIpDataMapDeleteEntry(std::map::iterator it) override; uint32_t getIpSamplingMetricCount() override; uint64_t getIpSamplingIpMask() const override; bool synchronizedDispatchSupported() const override; diff --git a/level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper_tgllp_to_dg2.inl b/level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper_tgllp_to_dg2.inl index 436d33ef9e..f132a7178a 100644 --- a/level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper_tgllp_to_dg2.inl +++ b/level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper_tgllp_to_dg2.inl @@ -127,11 +127,6 @@ void L0GfxCoreHelperHw::stallIpDataMapDelete(std::map return; } -template -void L0GfxCoreHelperHw::stallIpDataMapDeleteEntry(std::map::iterator it) { - return; -} - template bool L0GfxCoreHelperHw::stallIpDataMapUpdate(std::map &stallSumIpDataMap, const uint8_t *pRawIpData) { return false; diff --git a/level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper_xe2_hpg_and_later.inl b/level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper_xe2_hpg_and_later.inl index bb50293a47..505cef4e08 100644 --- a/level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper_xe2_hpg_and_later.inl +++ b/level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper_xe2_hpg_and_later.inl @@ -93,15 +93,6 @@ void L0GfxCoreHelperHw::stallIpDataMapDelete(std::map } } -template -void L0GfxCoreHelperHw::stallIpDataMapDeleteEntry(std::map::iterator it) { - StallSumIpDataXeCore_t *stallSumData = reinterpret_cast(it->second); - if (stallSumData) { - delete stallSumData; - it->second = nullptr; - } -} - template bool L0GfxCoreHelperHw::stallIpDataMapUpdate(std::map &stallSumIpDataMap, const uint8_t *pRawIpData) { constexpr int ipStallSamplingOffset = 3; // Offset to read the first Stall Sampling report after IP Address. diff --git a/level_zero/core/source/xe_hpc_core/l0_gfx_core_helper_xe_hpc_core.cpp b/level_zero/core/source/xe_hpc_core/l0_gfx_core_helper_xe_hpc_core.cpp index 34442b5a41..154a8da8d4 100644 --- a/level_zero/core/source/xe_hpc_core/l0_gfx_core_helper_xe_hpc_core.cpp +++ b/level_zero/core/source/xe_hpc_core/l0_gfx_core_helper_xe_hpc_core.cpp @@ -87,15 +87,6 @@ void L0GfxCoreHelperHw::stallIpDataMapDelete(std::map } } -template <> -void L0GfxCoreHelperHw::stallIpDataMapDeleteEntry(std::map::iterator it) { - StallSumIpData_t *stallSumData = reinterpret_cast(it->second); - if (stallSumData) { - delete stallSumData; - it->second = nullptr; - } -} - template <> bool L0GfxCoreHelperHw::stallIpDataMapUpdate(std::map &stallSumIpDataMap, const uint8_t *pRawIpData) { constexpr int ipStallSamplingOffset = 3; // Offset to read the first Stall Sampling report after IP Address. diff --git a/level_zero/core/test/unit_tests/gen12lp/test_l0_gfx_core_helper_gen12lp.cpp b/level_zero/core/test/unit_tests/gen12lp/test_l0_gfx_core_helper_gen12lp.cpp index 15cb8999a4..11bd045697 100644 --- a/level_zero/core/test/unit_tests/gen12lp/test_l0_gfx_core_helper_gen12lp.cpp +++ b/level_zero/core/test/unit_tests/gen12lp/test_l0_gfx_core_helper_gen12lp.cpp @@ -105,13 +105,6 @@ GEN12LPTEST_F(L0GfxCoreHelperTestGen12Lp, GivenGen12LpWhenStallIpDataMapDeleteIs l0GfxCoreHelper.stallIpDataMapDelete(stallSumIpDataMap); EXPECT_EQ(mapSizeBefore, stallSumIpDataMap.size()); } -GEN12LPTEST_F(L0GfxCoreHelperTestGen12Lp, GivenGen12LpWhenStallIpDataMapDeleteEntryIsCalledThenMapisUnchanged) { - auto &l0GfxCoreHelper = getHelper(); - std::map stallSumIpDataMap; - size_t mapSizeBefore = stallSumIpDataMap.size(); - l0GfxCoreHelper.stallIpDataMapDelete(stallSumIpDataMap); - EXPECT_EQ(mapSizeBefore, stallSumIpDataMap.size()); -} GEN12LPTEST_F(L0GfxCoreHelperTestGen12Lp, GivenGen12LpWhenStallSumIpDataToTypedValuesIsCalledThenNoChangeToDataValues) { auto &l0GfxCoreHelper = getHelper(); diff --git a/level_zero/core/test/unit_tests/xe2_hpg_core/test_l0_gfx_core_helper_xe2_hpg_core.cpp b/level_zero/core/test/unit_tests/xe2_hpg_core/test_l0_gfx_core_helper_xe2_hpg_core.cpp index 424164c104..142c53276e 100644 --- a/level_zero/core/test/unit_tests/xe2_hpg_core/test_l0_gfx_core_helper_xe2_hpg_core.cpp +++ b/level_zero/core/test/unit_tests/xe2_hpg_core/test_l0_gfx_core_helper_xe2_hpg_core.cpp @@ -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(); std::map stallSumIpDataMap; stallSumIpDataMap.emplace(std::pair(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(); - std::map 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(0ull, stallSumData)); - std::map::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(); EXPECT_EQ(0x1fffffffull, l0GfxCoreHelper.getIpSamplingIpMask()); diff --git a/level_zero/core/test/unit_tests/xe_hpc_core/test_l0_gfx_core_helper_xe_hpc_core.cpp b/level_zero/core/test/unit_tests/xe_hpc_core/test_l0_gfx_core_helper_xe_hpc_core.cpp index 380964d736..9b481974a0 100644 --- a/level_zero/core/test/unit_tests/xe_hpc_core/test_l0_gfx_core_helper_xe_hpc_core.cpp +++ b/level_zero/core/test/unit_tests/xe_hpc_core/test_l0_gfx_core_helper_xe_hpc_core.cpp @@ -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(); std::map stallSumIpDataMap; stallSumIpDataMap.emplace(std::pair(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(); - std::map 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(0ull, stallSumData)); - std::map::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(); EXPECT_EQ(0x1fffffffull, l0GfxCoreHelper.getIpSamplingIpMask()); diff --git a/level_zero/core/test/unit_tests/xe_hpg_core/test_l0_gfx_core_helper_xe_hpg_core.cpp b/level_zero/core/test/unit_tests/xe_hpg_core/test_l0_gfx_core_helper_xe_hpg_core.cpp index aaf870940c..919adad091 100644 --- a/level_zero/core/test/unit_tests/xe_hpg_core/test_l0_gfx_core_helper_xe_hpg_core.cpp +++ b/level_zero/core/test/unit_tests/xe_hpg_core/test_l0_gfx_core_helper_xe_hpg_core.cpp @@ -114,15 +114,6 @@ XE_HPG_CORETEST_F(L0GfxCoreHelperTestXeHpg, GivenXeHpgWhenStallIpDataMapDeleteIs EXPECT_EQ(mapSizeBefore, stallSumIpDataMap.size()); } -XE_HPG_CORETEST_F(L0GfxCoreHelperTestXeHpg, GivenXeHpgWhenStallIpDataMapDeleteEntryIsCalledThenMapisUnchanged) { - auto &l0GfxCoreHelper = getHelper(); - std::map stallSumIpDataMap; - size_t mapSizeBefore = stallSumIpDataMap.size(); - std::map::iterator it = stallSumIpDataMap.begin(); - l0GfxCoreHelper.stallIpDataMapDeleteEntry(it); - EXPECT_EQ(mapSizeBefore, stallSumIpDataMap.size()); -} - XE_HPG_CORETEST_F(L0GfxCoreHelperTestXeHpg, GivenXeHpgWhenStallSumIpDataToTypedValuesIsCalledThenNoChangeToDataValues) { auto &l0GfxCoreHelper = getHelper(); uint64_t ip = 0ull; diff --git a/level_zero/include/level_zero/ze_intel_results.h b/level_zero/include/level_zero/ze_intel_results.h index 05db44135e..9cac546c26 100644 --- a/level_zero/include/level_zero/ze_intel_results.h +++ b/level_zero/include/level_zero/ze_intel_results.h @@ -15,7 +15,8 @@ #include // Metrics experimental return codes -#define ZE_INTEL_RESULT_WARNING_NOT_CALCULABLE_METRICS_IGNORED_EXP static_cast(0x40000000) // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange) -#define ZE_INTEL_RESULT_WARNING_TIME_PARAMS_IGNORED_EXP static_cast(0x40000001) // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange) +#define ZE_INTEL_RESULT_WARNING_DATA_NOT_PROCESSED_EXP static_cast(0x40000000) // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange) +#define ZE_INTEL_RESULT_WARNING_NOT_CALCULABLE_METRICS_IGNORED_EXP static_cast(0x40000001) // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange) +#define ZE_INTEL_RESULT_WARNING_TIME_PARAMS_IGNORED_EXP static_cast(0x40000002) // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange) #endif // _ZE_INTEL_RESULTS_H \ No newline at end of file diff --git a/level_zero/tools/source/metrics/metric.cpp b/level_zero/tools/source/metrics/metric.cpp index 3c03e28ca8..9e4f3e0968 100644 --- a/level_zero/tools/source/metrics/metric.cpp +++ b/level_zero/tools/source/metrics/metric.cpp @@ -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 metricScopes; diff --git a/level_zero/tools/source/metrics/metric_ip_sampling_source.cpp b/level_zero/tools/source/metrics/metric_ip_sampling_source.cpp index 9238acc5a8..5790b7e31b 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_source.cpp +++ b/level_zero/tools/source/metrics/metric_ip_sampling_source.cpp @@ -23,6 +23,7 @@ #include #include +#include namespace L0 { constexpr uint32_t ipSamplinDomainId = 100u; @@ -98,7 +99,7 @@ ze_result_t IpSamplingMetricSourceImp::cacheMetricGroup() { std::vector metrics = {}; auto &l0GfxCoreHelper = deviceImp->getNEODevice()->getRootDeviceEnvironment().getHelper(); 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(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 &iPs) { +ze_result_t IpSamplingCalculation::getMetricCount(const uint8_t *pRawData, const size_t rawDataSize, + uint32_t &metricValueCount) { + + std::unordered_set 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(&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 stallReportIpCount{}; - - status = getIpsInRawData(pRawData, rawDataSize, stallReportIpCount); - if (status != ZE_RESULT_SUCCESS) { - metricValueCount = 0; - return status; - } - - metricValueCount = static_cast(stallReportIpCount.size()) * metricSource.metricCount; + metricValueCount = static_cast(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(rawDataSize) / rawReportSize; + + for (const uint8_t *pRawIpData = pRawData; pRawIpData < pRawData + (rawReportCount * rawReportSize); pRawIpData += rawReportSize) { + dataOverflow |= gfxCoreHelper.stallIpDataMapUpdate(stallReportDataMap, pRawIpData); + } + + metricValueCount = std::min(metricValueCount, static_cast(stallReportDataMap.size()) * metricSource.metricSourceCount); + std::vector 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 &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 &stallReportDataMap, - uint32_t metricReportCount, - std::vector includedMetricIndexes, - zet_intel_metric_result_exp_t *pMetricResults) { - std::vector 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 &stallReportDataMap, - uint32_t &metricValueCount, - zet_typed_value_t *pTypedValues) { - - metricValueCount = std::min(metricValueCount, static_cast(stallReportDataMap.size()) * metricSource.metricCount); - std::vector 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() const { return static_cast(*metricSources.at(MetricSource::metricSourceTypeIpSampling)); diff --git a/level_zero/tools/source/metrics/metric_ip_sampling_source.h b/level_zero/tools/source/metrics/metric_ip_sampling_source.h index 1701b4d5c6..b5e32c5b17 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_source.h +++ b/level_zero/tools/source/metrics/metric_ip_sampling_source.h @@ -10,7 +10,6 @@ #include "level_zero/tools/source/metrics/metric.h" #include "level_zero/tools/source/metrics/os_interface_metric.h" -#include namespace L0 { class L0GfxCoreHelper; struct IpSamplingMetricImp; @@ -64,7 +63,7 @@ class IpSamplingMetricSourceImp : public MetricSource { const std::vector &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(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 &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 &stallReportDataMap, bool *dataOverflow); - void stallDataMapToMetricResults(std::map &stallReportDataMap, - uint32_t metricReportCount, - std::vector includedMetricIndexes, - zet_intel_metric_result_exp_t *pMetricResults); - - void stallDataMapToTypedValues(std::map &stallReportDataMap, - uint32_t &metricValueCount, - zet_typed_value_t *pTypedValues); - protected: L0::L0GfxCoreHelper &gfxCoreHelper; IpSamplingMetricSourceImp &metricSource; diff --git a/level_zero/tools/source/metrics/metric_ip_sampling_streamer.cpp b/level_zero/tools/source/metrics/metric_ip_sampling_streamer.cpp index ecb8057379..db871889b6 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_streamer.cpp +++ b/level_zero/tools/source/metrics/metric_ip_sampling_streamer.cpp @@ -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(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(&(metricSource.getMetricDeviceContext().getDevice())); - L0::L0GfxCoreHelper &l0GfxCoreHelper = deviceImp->getNEODevice()->getRootDeviceEnvironment().getHelper(); +void IpSamplingMetricCalcOpImp::fillStallDataMap(const size_t rawDataSize, const uint8_t *pRawData, size_t *processedSize, + L0::L0GfxCoreHelper &l0GfxCoreHelper, + std::map &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 &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(); + + status = calcUtils->getMetricCount(pRawData, rawDataSize, resultCount); + if (status != ZE_RESULT_SUCCESS) { + *pTotalMetricReportCount = 0; + return status; + } + + uint32_t rawDataReportCount = resultCount / cachedMetricsCount; if (getSize) { - std::unordered_set iPs{}; - if (newData) { - status = ipSamplingCalculation->getIpsInRawData(pRawData, rawDataSize, iPs); - if (status != ZE_RESULT_SUCCESS) { - *pTotalMetricReportCount = 0; - return status; - } - } - - // Add cached IPs - if (!isScopeCacheEmpty(scopeId)) { - getScopeCacheIps(scopeId, iPs); - } - - *pTotalMetricReportCount = static_cast(iPs.size()); - - DEBUG_BREAK_IF(*pTotalMetricReportCount == 0); - + *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(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 &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(MetricGroup::fromHandle(hMetricGroup)); + DeviceImp *deviceImp = static_cast(&metricGroupBase->getMetricSource().getMetricDeviceContext().getDevice()); + L0::L0GfxCoreHelper &l0GfxCoreHelper = deviceImp->getNEODevice()->getRootDeviceEnvironment().getHelper(); 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 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(getScopeCache(scopeId)->size())); - - uint32_t metricReportCount = std::min(*pTotalMetricReportCount, static_cast(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(&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 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; } diff --git a/level_zero/tools/source/metrics/metric_ip_sampling_streamer.h b/level_zero/tools/source/metrics/metric_ip_sampling_streamer.h index 0c16e15a19..c36f2b03af 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_streamer.h +++ b/level_zero/tools/source/metrics/metric_ip_sampling_streamer.h @@ -10,7 +10,6 @@ #include "level_zero/tools/source/metrics/metric.h" #include "level_zero/tools/source/metrics/os_interface_metric.h" -#include namespace L0 { class IpSamplingMetricSourceImp; @@ -51,19 +50,14 @@ struct MultiDeviceIpSamplingMetricStreamerImp : public IpSamplingMetricStreamerB struct IpSamplingMetricCalcOpImp : public MetricCalcOpImp { IpSamplingMetricCalcOpImp(bool multidevice, const std::vector &metricScopes, + uint32_t cachedMetricsCount, std::vector &metricsInReport, - IpSamplingMetricSourceImp &metricSource, std::vector &includedMetricIndexes) : MetricCalcOpImp(multidevice, metricScopes, metricsInReport, std::vector()), - metricSource(metricSource), - includedMetricIndexes(includedMetricIndexes) { - for (auto &scope : metricScopes) { - scopeIdToCache[scope->getId()] = new std::map{}; - } - } + cachedMetricsCount(cachedMetricsCount), + includedMetricIndexes(includedMetricIndexes) {} ~IpSamplingMetricCalcOpImp() override{}; - static ze_result_t create(bool isMultiDevice, const std::vector &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 &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 &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 &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 &ips) { - for (const auto &entry : *scopeIdToCache[scopeId]) { - ips.insert(entry.first); - } - } - - std::map *getScopeCache(uint32_t scopeId) { - return scopeIdToCache[scopeId]; - } - - IpSamplingMetricSourceImp &metricSource; + uint32_t cachedMetricsCount = 0; std::vector includedMetricIndexes{}; - - std::map *> scopeIdToCache{}; - size_t processedSize = 0; }; } // namespace L0 diff --git a/level_zero/tools/test/unit_tests/sources/metrics/CMakeLists.txt b/level_zero/tools/test/unit_tests/sources/metrics/CMakeLists.txt index 25312ab502..ed6877d515 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/CMakeLists.txt +++ b/level_zero/tools/test/unit_tests/sources/metrics/CMakeLists.txt @@ -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 diff --git a/level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.cpp b/level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.cpp index 0edba600dc..6c0e3e8251 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.cpp @@ -43,7 +43,7 @@ void MetricIpSamplingMultiDevFixture::SetUp() { osInterfaceVector.push_back(mockMetricIpSamplingOsInterface); std::unique_ptr metricIpSamplingOsInterface = std::unique_ptr(mockMetricIpSamplingOsInterface); auto &metricSource = device->getMetricDeviceContext().getMetricSource(); - metricSource.metricCount = platformIpMetricCountXe; + metricSource.metricSourceCount = platformIpMetricCountXe; metricSource.setMetricOsInterface(metricIpSamplingOsInterface); auto &metricOaSource = device->getMetricDeviceContext().getMetricSource(); @@ -64,7 +64,7 @@ void MetricIpSamplingFixture::SetUp() { std::unique_ptr metricIpSamplingOsInterface = std::unique_ptr(mockMetricIpSamplingOsInterface); auto &metricSource = device->getMetricDeviceContext().getMetricSource(); - metricSource.metricCount = platformIpMetricCountXe; + metricSource.metricSourceCount = platformIpMetricCountXe; metricSource.setMetricOsInterface(metricIpSamplingOsInterface); auto &metricOaSource = device->getMetricDeviceContext().getMetricSource(); @@ -78,14 +78,6 @@ void MetricIpSamplingFixture::TearDown() { globalDriverHandles->clear(); } -void MetricIpSamplingCalculateBaseFixture::initRawReports() { - MockRawDataHelper::rawElementsToRawReports(static_cast(rawDataElements.size()), rawDataElements, rawReports); - rawReportsBytesSize = sizeof(rawReports[0][0]) * rawReports[0].size() * rawReports.size(); - - MockRawDataHelper::rawElementsToRawReports(static_cast(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; diff --git a/level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.h b/level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.h index 8b8ca444e2..f7a7e0a23e 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.h +++ b/level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.h @@ -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 @@ -21,6 +21,45 @@ class MockMetricIpSamplingOsInterface; using EustallSupportedPlatforms = IsProduct; +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 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> rawReports = std::vector>(rawDataElements.size()); - size_t rawReportsBytesSize = 0; + const auto expectedOutSize = sizeof(IpSamplingMetricDataHeader) + rawDataInSize; + if (expectedOutSize <= rawDataOutSize) { + + auto header = reinterpret_cast(rawDataOut); + header->magic = IpSamplingMetricDataHeader::magicValue; + header->rawDataSize = static_cast(rawDataInSize); + header->setIndex = setIndex; + memcpy_s(rawDataOut + sizeof(IpSamplingMetricDataHeader), rawDataOutSize - sizeof(IpSamplingMetricDataHeader), + rawDataIn, rawDataInSize); + } + } + + std::vector 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 expectedMetricNamesInReport = {"IP", "Active", "ControlStall", "PipeStall", "SendStall", "DistStall", "SbidStall", "SyncStall", "InstrFetchStall", "OtherStall"}; + size_t rawDataVectorSize = sizeof(rawDataVector[0]) * rawDataVector.size(); std::vector 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 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 expectedMetricValuesIP1FirstRawReport = { + std::vector 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 expectedMetricValuesIP1thirdRawReport = { + std::vector 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 expectedMetricValuesIP10 = { + std::vector 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 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 rawDataElementsOverflow = { - {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> rawReportsOverflow = std::vector>(rawDataElementsOverflow.size()); - size_t rawReportsBytesSizeOverflow = 0; + std::vector 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}}; + size_t rawDataVectorOverflowSize = sizeof(rawDataVectorOverflow[0]) * rawDataVectorOverflow.size(); std::vector 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(); }; diff --git a/level_zero/tools/test/unit_tests/sources/metrics/mock_ip_sampling_raw_data.h b/level_zero/tools/test/unit_tests/sources/metrics/mock_ip_sampling_raw_data.h deleted file mode 100644 index 26b30ab4a0..0000000000 --- a/level_zero/tools/test/unit_tests/sources/metrics/mock_ip_sampling_raw_data.h +++ /dev/null @@ -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 inputElements, std::vector> &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> &rawReports, std::vector &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(rawDataOut); - header->magic = IpSamplingMetricDataHeader::magicValue; - header->rawDataSize = static_cast(rawDataInSize); - header->setIndex = setIndex; - memcpy_s(rawDataOut + sizeof(IpSamplingMetricDataHeader), rawDataOutSize - sizeof(IpSamplingMetricDataHeader), - rawDataIn, rawDataInSize); - } - } -}; - -} // namespace ult -} // namespace L0 diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric.cpp index 74af7c9bb6..da601e6349 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/test_metric.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric.cpp @@ -254,30 +254,6 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpWithMixedHierarchiesThenErrorIsRe &hCalculationOperation)); } -TEST_F(CalcOperationFixture, WhenCreatingCalcSubDeviceOnlyAcceptsOneScope) { - - std::vector 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); diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_enumeration.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_enumeration.cpp index b6950249d5..ed2c1b7e7e 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_enumeration.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_enumeration.cpp @@ -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 rawDataWithHeader(rawReportsBytesSize + sizeof(IpSamplingMetricDataHeader)); - MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(rawReports.data()), rawReportsBytesSize, 0); + std::vector rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader)); + addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(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 rawDataWithHeader(rawReportsBytesSize + sizeof(IpSamplingMetricDataHeader)); - MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(rawReports.data()), rawReportsBytesSize, 0); + std::vector rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader)); + addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(rawDataVector.data()), rawDataVectorSize, 0); auto header = reinterpret_cast(rawDataWithHeader.data()); header->magic = IpSamplingMetricDataHeader::magicValue - 1; @@ -689,13 +689,13 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen uint32_t totalMetricValueCount = std::numeric_limits::max(); std::vector metricCounts(1); EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], - ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawReportsBytesSize, reinterpret_cast(rawReports.data()), + ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataVectorSize, reinterpret_cast(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(rawReports.data()), + ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataVectorSize, reinterpret_cast(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 metricCounts(1); EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, 1, - reinterpret_cast(rawReports.data()), + reinterpret_cast(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 rawDataWithHeader((rawReportsBytesSize + sizeof(IpSamplingMetricDataHeader)) * 2); - MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(rawReports.data()), rawReportsBytesSize, 1); - MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data() + rawReportsBytesSize + sizeof(IpSamplingMetricDataHeader), - rawDataWithHeader.size(), reinterpret_cast(rawReports.data()), rawReportsBytesSize, 0); + std::vector rawDataWithHeader((rawDataVectorSize + sizeof(IpSamplingMetricDataHeader)) * 2); + addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(rawDataVector.data()), rawDataVectorSize, 1); + addHeader(rawDataWithHeader.data() + rawDataVectorSize + sizeof(IpSamplingMetricDataHeader), + rawDataWithHeader.size(), reinterpret_cast(rawDataVector.data()), rawDataVectorSize, 0); // Use random initializer uint32_t setCount = std::numeric_limits::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 rawDataWithHeader(rawReportsBytesSize + sizeof(IpSamplingMetricDataHeader) + 1); - MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(rawReports.data()), rawReportsBytesSize, 0); + std::vector rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader) + 1); + addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(rawDataVector.data()), rawDataVectorSize, 0); uint32_t setCount = 0; uint32_t totalMetricValueCount = 0; @@ -839,11 +839,11 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, WhenCalculateMultipleMetricValue std::vector 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(rawReports.data()), rawReportsBytesSize, 0); + rawData.resize(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader)); + addHeader(rawData.data(), rawData.size(), reinterpret_cast(rawDataVector.data()), rawDataVectorSize, 0); } else { - rawData.resize(rawReportsBytesSize); - memcpy_s(rawData.data(), rawData.size(), reinterpret_cast(rawReports.data()), rawReportsBytesSize); + rawData.resize(rawDataVectorSize); + memcpy_s(rawData.data(), rawData.size(), reinterpret_cast(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(rawData.data()); - header->rawDataSize = static_cast(rawReportsBytesSize - 1); + header->rawDataSize = static_cast(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 rawDataWithHeader(rawReportsBytesSize + sizeof(IpSamplingMetricDataHeader) + 1); - MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(rawReports.data()), rawReportsBytesSize - 1, 0); + std::vector rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader) + 1); + addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(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 rawDataWithHeader(rawReportsBytesSize + sizeof(IpSamplingMetricDataHeader) + 1); - MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(rawReports.data()), rawReportsBytesSize - 1, 0); + std::vector rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader) + 1); + addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(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 rawDataWithHeader(rawReportsBytesSize + sizeof(IpSamplingMetricDataHeader)); - MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(rawReports.data()), rawReportsBytesSize, 0); + std::vector rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader)); + addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(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(rawReports.data()), &metricValueCount, nullptr), + rawDataVectorSize, reinterpret_cast(rawDataVector.data()), &metricValueCount, nullptr), expectedResult); if (!isRootdevice) { EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, - rawReportsBytesSize, reinterpret_cast(rawReports.data()), &metricValueCount, metricValues.data()), + rawDataVectorSize, reinterpret_cast(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 rawDataWithHeader(rawReportsBytesSize + sizeof(IpSamplingMetricDataHeader)); - MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(rawReports.data()), rawReportsBytesSize, 0); + std::vector rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader)); + addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(rawDataVector.data()), rawDataVectorSize, 0); uint32_t metricValueCount = 0; EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size(), reinterpret_cast(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 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(rawReports.data()), &metricValueCount, nullptr), + rawDataVectorSize, reinterpret_cast(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(rawReports.data()), &metricValueCount, metricValues.data()), + rawDataVectorSize, reinterpret_cast(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 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(rawReports.data()), &metricValueCount, nullptr), + rawDataVectorSize - 1, reinterpret_cast(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(rawReports.data()), &metricValueCount, nullptr), + rawDataVectorSize, reinterpret_cast(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(rawReports.data()), &metricValueCount, metricValues.data()), + rawDataVectorSize - 1, reinterpret_cast(rawDataVector.data()), &metricValueCount, metricValues.data()), ZE_RESULT_ERROR_INVALID_SIZE); } } @@ -1158,11 +1158,11 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenDataOverflowOccurredWhenStr std::vector 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(rawReportsOverflow.data()), rawReportsBytesSizeOverflow, 0); + rawData.resize(rawDataVectorOverflowSize + sizeof(IpSamplingMetricDataHeader)); + addHeader(rawData.data(), rawData.size(), reinterpret_cast(rawDataVectorOverflow.data()), rawDataVectorOverflowSize, 0); } else { - rawData.resize(rawReportsBytesSizeOverflow); - memcpy_s(rawData.data(), rawData.size(), reinterpret_cast(rawReportsOverflow.data()), rawReportsBytesSizeOverflow); + rawData.resize(rawDataVectorOverflowSize); + memcpy_s(rawData.data(), rawData.size(), reinterpret_cast(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(rawReports.data()), &metricValueCount, nullptr), + rawDataVectorSize, reinterpret_cast(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(rawReports.data()), &metricValueCount, metricValues.data()), + rawDataVectorSize, reinterpret_cast(rawDataVector.data()), &metricValueCount, metricValues.data()), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE); } } diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_streamer.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_streamer.cpp index 143010dab8..2dfcaeecef 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_streamer.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_streamer.cpp @@ -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 rawDataWithHeader(rawReportsBytesSize + sizeof(IpSamplingMetricDataHeader)); - MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(rawReports.data()), rawReportsBytesSize, 0); + std::vector rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader)); + addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(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(rawDataWithHeader.data()), hCalculationOperation, final, &usedSize, &totalMetricReportCount, nullptr)); - EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateValuesExp(rawReportsBytesSize, reinterpret_cast(rawReports.data()), + + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateValuesExp(rawDataVectorSize, reinterpret_cast(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(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(rawReports.data()), + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, reinterpret_cast(rawDataVector.data()), hCalculationOperation, final, &usedSize, &totalMetricReportCount, nullptr)); EXPECT_EQ(totalMetricReportCount, 3U); std::vector metricResults(totalMetricReportCount * metricsInReportCount); - EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawReportsBytesSize, reinterpret_cast(rawReports.data()), + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, reinterpret_cast(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 rawDataWithHeader(rawReportsBytesSize + sizeof(IpSamplingMetricDataHeader)); - MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(rawReports.data()), rawReportsBytesSize, 0); + std::vector rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader)); + addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(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(rawReports.data()), + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_SIZE, zetIntelMetricCalculateValuesExp(rawDataVectorSize / 30, reinterpret_cast(rawDataVector.data()), hCalculationOperation, final, &usedSize, &totalMetricReportCount, nullptr)); @@ -1103,12 +1089,12 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat size_t usedSize = 0; std::vector metricResults(totalMetricReportCount * 10); - EXPECT_EQ(ZE_RESULT_WARNING_DROPPED_DATA, zetIntelMetricCalculateValuesExp(rawReportsBytesSizeOverflow, reinterpret_cast(rawReportsOverflow.data()), + EXPECT_EQ(ZE_RESULT_WARNING_DROPPED_DATA, zetIntelMetricCalculateValuesExp(rawDataVectorOverflowSize, reinterpret_cast(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(rawReports.data()), + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, reinterpret_cast(rawDataVector.data()), hCalculationOperation, final, &usedSize, &totalMetricReportCount, nullptr)); std::vector metricResults(totalMetricReportCount * metricsInReportCount); - EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawReportsBytesSize, reinterpret_cast(rawReports.data()), + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, reinterpret_cast(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 metricsInReport(metricsInReportCount); - std::vector 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(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 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 metricsInReport(metricsInReportCount); - std::vector 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(rawReports.data()); - EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawReportsBytesSize, rawdata, - hCalculationOperation, final, &usedSize, + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, reinterpret_cast(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 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); + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateValuesExp(rawDataVectorSize, reinterpret_cast(rawDataVector.data()), + hCalculationOperation, + final, &usedSize, + &totalMetricReportCount, nullptr)); - 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 metricsInReport(metricsInReportCount); - std::vector 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(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 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 - - // 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 metricsInReport(metricsInReportCount); - std::vector 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(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 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 metricsInReport(metricsInReportCount); - std::vector 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(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 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)); }