From 9cd5da1a87936794afcc4649a0a421aa3da2e951 Mon Sep 17 00:00:00 2001 From: Matias Cabral Date: Tue, 4 Nov 2025 18:34:41 +0000 Subject: [PATCH] refactor: update final param in calculate API Resolves: NEO-16569 Signed-off-by: Matias Cabral --- level_zero/tools/source/metrics/metric.cpp | 17 +- level_zero/tools/source/metrics/metric.h | 16 +- .../metrics/metric_ip_sampling_source.cpp | 8 +- .../metrics/metric_ip_sampling_source.h | 2 +- .../metrics/metric_ip_sampling_streamer.cpp | 2 +- .../metric_multidevice_programmable.cpp | 3 +- .../metrics/metric_oa_enumeration_imp.cpp | 3 +- .../metrics/metric_oa_enumeration_imp.h | 2 +- .../metrics/metric_oa_programmable_imp.cpp | 3 +- .../metrics/metric_oa_programmable_imp.h | 3 +- .../sources/metrics/mock_metric_source.h | 8 +- .../sources/metrics/test_metric.cpp | 109 ++++---- .../test_metric_ip_sampling_streamer_1.cpp | 8 +- .../test_metric_ip_sampling_streamer_2.cpp | 236 +++++++++--------- .../metrics/test_metric_programmable.cpp | 32 ++- .../test_multidevice_metric_programmable.cpp | 44 +++- 16 files changed, 282 insertions(+), 214 deletions(-) diff --git a/level_zero/tools/source/metrics/metric.cpp b/level_zero/tools/source/metrics/metric.cpp index 7655e371fb..0606fb65bf 100644 --- a/level_zero/tools/source/metrics/metric.cpp +++ b/level_zero/tools/source/metrics/metric.cpp @@ -754,8 +754,8 @@ ze_result_t MultiDeviceMetricImp::getProperties(zet_metric_properties_t *pProper return subDeviceMetrics[0]->getProperties(pProperties); } -MultiDeviceMetricImp *MultiDeviceMetricImp::create(MetricSource &metricSource, std::vector &subDeviceMetrics) { - return new (std::nothrow) MultiDeviceMetricImp(metricSource, subDeviceMetrics); +MultiDeviceMetricImp *MultiDeviceMetricImp::create(MetricSource &metricSource, std::vector &subDeviceMetrics, std::vector &metricScopes) { + return new (std::nothrow) MultiDeviceMetricImp(metricSource, subDeviceMetrics, metricScopes); } MetricImp *MultiDeviceMetricImp::getMetricAtSubDeviceIndex(uint32_t index) { @@ -767,13 +767,13 @@ MetricImp *MultiDeviceMetricImp::getMetricAtSubDeviceIndex(uint32_t index) { ze_result_t MetricImp::getScopes(uint32_t *pCount, zet_intel_metric_scope_exp_handle_t *phScopes) { if (*pCount == 0) { - *pCount = static_cast(scopes.size()); + *pCount = static_cast(metricScopes.size()); return ZE_RESULT_SUCCESS; } - *pCount = std::min(*pCount, static_cast(scopes.size())); + *pCount = std::min(*pCount, static_cast(metricScopes.size())); for (uint32_t i = 0; i < *pCount; i++) { - phScopes[i] = scopes[i]; + phScopes[i] = metricScopes[i]->toHandle(); } return ZE_RESULT_SUCCESS; } @@ -1007,7 +1007,8 @@ ze_result_t HomogeneousMultiDeviceMetricProgrammable::createMetric(zet_metric_pr for (auto &metricHandlesPerSubdevice : metricHandlesPerSubDeviceList) { homogenousMetricList.push_back(static_cast(Metric::fromHandle(metricHandlesPerSubdevice[index]))); } - phMetricHandles[index] = HomogeneousMultiDeviceMetricCreated::create(metricSource, homogenousMetricList)->toHandle(); + std::vector metricScopes{}; + phMetricHandles[index] = HomogeneousMultiDeviceMetricCreated::create(metricSource, homogenousMetricList, metricScopes)->toHandle(); } *pMetricHandleCount = static_cast(metricHandlesPerSubDeviceList[0].size()); @@ -1033,8 +1034,8 @@ ze_result_t HomogeneousMultiDeviceMetricCreated::destroy() { return status; } -MetricImp *HomogeneousMultiDeviceMetricCreated::create(MetricSource &metricSource, std::vector &subDeviceMetrics) { - return new (std::nothrow) HomogeneousMultiDeviceMetricCreated(metricSource, subDeviceMetrics); +MetricImp *HomogeneousMultiDeviceMetricCreated::create(MetricSource &metricSource, std::vector &subDeviceMetrics, std::vector &metricScopes) { + return new (std::nothrow) HomogeneousMultiDeviceMetricCreated(metricSource, subDeviceMetrics, metricScopes); } ze_result_t MetricCalcOpImp::getMetricsFromCalcOp(uint32_t *pCount, zet_metric_handle_t *phMetrics, bool isExcludedMetrics, zet_intel_metric_scope_exp_handle_t *phMetricScopes) { diff --git a/level_zero/tools/source/metrics/metric.h b/level_zero/tools/source/metrics/metric.h index aa75d7f784..5e6b93b83d 100644 --- a/level_zero/tools/source/metrics/metric.h +++ b/level_zero/tools/source/metrics/metric.h @@ -245,7 +245,7 @@ struct MetricImp : public Metric { return metricSource; } ~MetricImp() override = default; - MetricImp(MetricSource &metricSource) : metricSource(metricSource) {} + MetricImp(MetricSource &metricSource, std::vector &metricScopes) : metricSource(metricSource), metricScopes(metricScopes) {} bool isImmutable() { return isPredefined; } bool isRootDevice() { return isMultiDevice; } @@ -259,7 +259,7 @@ struct MetricImp : public Metric { bool isPredefined = true; bool isMultiDevice = false; MultiDeviceMetricImp *rootDeviceMetricImp = nullptr; - std::vector scopes = {}; + std::vector metricScopes = {}; public: ze_result_t getScopes(uint32_t *pCount, zet_intel_metric_scope_exp_handle_t *phScopes); @@ -267,7 +267,8 @@ struct MetricImp : public Metric { struct MultiDeviceMetricImp : public MetricImp { ~MultiDeviceMetricImp() override = default; - MultiDeviceMetricImp(MetricSource &metricSource, std::vector &subDeviceMetrics) : MetricImp(metricSource), subDeviceMetrics(subDeviceMetrics) { + MultiDeviceMetricImp(MetricSource &metricSource, std::vector &subDeviceMetrics, std::vector &metricScopes) + : MetricImp(metricSource, metricScopes), subDeviceMetrics(subDeviceMetrics) { isPredefined = true; isMultiDevice = true; rootDeviceMetricImp = nullptr; @@ -279,7 +280,7 @@ struct MultiDeviceMetricImp : public MetricImp { ze_result_t destroy() override { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } ze_result_t getProperties(zet_metric_properties_t *pProperties) override; - static MultiDeviceMetricImp *create(MetricSource &metricSource, std::vector &subDeviceMetrics); + static MultiDeviceMetricImp *create(MetricSource &metricSource, std::vector &subDeviceMetrics, std::vector &metricScopes); MetricImp *getMetricAtSubDeviceIndex(uint32_t index); protected: @@ -460,12 +461,13 @@ struct HomogeneousMultiDeviceMetricProgrammable : public MetricProgrammable { struct HomogeneousMultiDeviceMetricCreated : public MultiDeviceMetricImp { ~HomogeneousMultiDeviceMetricCreated() override {} - HomogeneousMultiDeviceMetricCreated(MetricSource &metricSource, std::vector &subDeviceMetrics) : MultiDeviceMetricImp(metricSource, subDeviceMetrics) { + HomogeneousMultiDeviceMetricCreated(MetricSource &metricSource, std::vector &subDeviceMetrics, std::vector &metricScopes) + : MultiDeviceMetricImp(metricSource, subDeviceMetrics, metricScopes) { isPredefined = false; isMultiDevice = true; } ze_result_t destroy() override; - static MetricImp *create(MetricSource &metricSource, std::vector &subDeviceMetrics); + static MetricImp *create(MetricSource &metricSource, std::vector &subDeviceMetrics, std::vector &metricScopes); }; struct MetricCalcOp : _zet_intel_metric_calculation_operation_exp_handle_t { @@ -525,7 +527,7 @@ struct MetricScopeImp : public MetricScope { private: zet_intel_metric_scope_properties_exp_t properties; bool aggregated = false; - uint32_t computeSubDevIndex = 0; // valid for compute scopes when aggregated is false + uint32_t computeSubDevIndex = 0; // valid for compute metricScopes when aggregated is false }; struct MetricCalcOpImp : public MetricCalcOp { ~MetricCalcOpImp() override = default; 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 bc07901a97..7626637e93 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_source.cpp +++ b/level_zero/tools/source/metrics/metric_ip_sampling_source.cpp @@ -113,7 +113,8 @@ ze_result_t IpSamplingMetricSourceImp::cacheMetricGroup() { strcpy_s(metricProperties.description, ZET_MAX_METRIC_DESCRIPTION, "IP address"); metricProperties.metricType = ZET_METRIC_TYPE_IP; strcpy_s(metricProperties.resultUnits, ZET_MAX_METRIC_RESULT_UNITS, "Address"); - metrics.push_back(IpSamplingMetricImp(*this, metricProperties)); + std::vector scopes{}; + metrics.push_back(IpSamplingMetricImp(*this, metricProperties, scopes)); std::vector> stallSamplingReportList = l0GfxCoreHelper.getStallSamplingReportMetrics(); @@ -124,7 +125,7 @@ ze_result_t IpSamplingMetricSourceImp::cacheMetricGroup() { for (auto &property : stallSamplingReportList) { strcpy_s(metricProperties.name, ZET_MAX_METRIC_NAME, property.first); strcpy_s(metricProperties.description, ZET_MAX_METRIC_DESCRIPTION, property.second); - metrics.push_back(IpSamplingMetricImp(*this, metricProperties)); + metrics.push_back(IpSamplingMetricImp(*this, metricProperties, scopes)); } cachedMetricGroup = IpSamplingMetricGroupImp::create(*this, metrics); @@ -511,7 +512,8 @@ std::unique_ptr MultiDeviceIpSamplingMetric return std::unique_ptr(new (std::nothrow) MultiDeviceIpSamplingMetricGroupImp(metricSource, subDeviceMetricGroup)); } -IpSamplingMetricImp::IpSamplingMetricImp(MetricSource &metricSource, zet_metric_properties_t &properties) : MetricImp(metricSource), properties(properties) { +IpSamplingMetricImp::IpSamplingMetricImp(MetricSource &metricSource, zet_metric_properties_t &properties, std::vector &scopes) + : MetricImp(metricSource, scopes), properties(properties) { } ze_result_t IpSamplingMetricImp::getProperties(zet_metric_properties_t *pProperties) { 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 db81a9701e..0e512d9187 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_source.h +++ b/level_zero/tools/source/metrics/metric_ip_sampling_source.h @@ -173,7 +173,7 @@ struct MultiDeviceIpSamplingMetricGroupImp : public IpSamplingMetricGroupBase { struct IpSamplingMetricImp : public MetricImp { ~IpSamplingMetricImp() override = default; - IpSamplingMetricImp(MetricSource &metricSource, zet_metric_properties_t &properties); + IpSamplingMetricImp(MetricSource &metricSource, zet_metric_properties_t &properties, std::vector &scopes); ze_result_t getProperties(zet_metric_properties_t *pProperties) override; ze_result_t destroy() override { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; 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 1079ddf9fb..c0269b7b41 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_streamer.cpp +++ b/level_zero/tools/source/metrics/metric_ip_sampling_streamer.cpp @@ -475,7 +475,7 @@ ze_result_t IpSamplingMetricCalcOpImp::metricCalculateValues(const size_t rawDat status = updateCachesForMultiScopes(dataSize, rawDataStart, newData, dataOverflow); if (status != ZE_RESULT_SUCCESS) { - // clearScopesCaches(); + clearScopesCaches(); METRICS_LOG_ERR("%s", "Failed to update stall data map"); return status; } diff --git a/level_zero/tools/source/metrics/metric_multidevice_programmable.cpp b/level_zero/tools/source/metrics/metric_multidevice_programmable.cpp index 69046f0e8b..4787106f16 100644 --- a/level_zero/tools/source/metrics/metric_multidevice_programmable.cpp +++ b/level_zero/tools/source/metrics/metric_multidevice_programmable.cpp @@ -187,7 +187,8 @@ ze_result_t MultiDeviceCreatedMetricGroupManager::close() { subDeviceMetrics[subDeviceIndex] = static_cast( Metric::fromHandle(subDeviceMetricHandles[subDeviceIndex][index])); } - arrangedMetricHandles[index] = MultiDeviceMetricImp::create(metricSource, subDeviceMetrics); + std::vector scopes{}; + arrangedMetricHandles[index] = MultiDeviceMetricImp::create(metricSource, subDeviceMetrics, scopes); } } diff --git a/level_zero/tools/source/metrics/metric_oa_enumeration_imp.cpp b/level_zero/tools/source/metrics/metric_oa_enumeration_imp.cpp index 337e6da026..fbbc47c450 100644 --- a/level_zero/tools/source/metrics/metric_oa_enumeration_imp.cpp +++ b/level_zero/tools/source/metrics/metric_oa_enumeration_imp.cpp @@ -1230,7 +1230,8 @@ MetricGroup *OaMetricGroupImp::create(zet_metric_group_properties_t &properties, } Metric *OaMetricImp::create(MetricSource &metricSource, zet_metric_properties_t &properties) { - auto pMetric = new OaMetricImp(metricSource); + std::vector metricScopes{}; + auto pMetric = new OaMetricImp(metricSource, metricScopes); UNRECOVERABLE_IF(pMetric == nullptr); pMetric->initialize(properties); pMetric->isPredefined = true; diff --git a/level_zero/tools/source/metrics/metric_oa_enumeration_imp.h b/level_zero/tools/source/metrics/metric_oa_enumeration_imp.h index 5a4c122d6e..8885fccab8 100644 --- a/level_zero/tools/source/metrics/metric_oa_enumeration_imp.h +++ b/level_zero/tools/source/metrics/metric_oa_enumeration_imp.h @@ -260,7 +260,7 @@ struct OaMetricGroupImp : public MetricGroupImp { struct OaMetricImp : public MetricImp { ~OaMetricImp() override{}; - OaMetricImp(MetricSource &metricSource) : MetricImp(metricSource) {} + OaMetricImp(MetricSource &metricSource, std::vector &metricScopes) : MetricImp(metricSource, metricScopes) {} ze_result_t getProperties(zet_metric_properties_t *pProperties) override; diff --git a/level_zero/tools/source/metrics/metric_oa_programmable_imp.cpp b/level_zero/tools/source/metrics/metric_oa_programmable_imp.cpp index 297758446f..25950ee4a5 100644 --- a/level_zero/tools/source/metrics/metric_oa_programmable_imp.cpp +++ b/level_zero/tools/source/metrics/metric_oa_programmable_imp.cpp @@ -280,7 +280,8 @@ Metric *OaMetricFromProgrammable::create(MetricSource &metricSource, zet_metric_ MetricsDiscovery::IMetricPrototype_1_13 *pClonedPrototype, uint32_t domain, zet_metric_group_sampling_type_flags_t supportedSamplingTypes) { - auto pMetric = new OaMetricFromProgrammable(metricSource); + std::vector scopes; + auto pMetric = new OaMetricFromProgrammable(metricSource, scopes); UNRECOVERABLE_IF(pMetric == nullptr); pMetric->initialize(properties); pMetric->pClonedPrototype = pClonedPrototype; diff --git a/level_zero/tools/source/metrics/metric_oa_programmable_imp.h b/level_zero/tools/source/metrics/metric_oa_programmable_imp.h index 74d40c4d51..dd62d61f55 100644 --- a/level_zero/tools/source/metrics/metric_oa_programmable_imp.h +++ b/level_zero/tools/source/metrics/metric_oa_programmable_imp.h @@ -48,7 +48,8 @@ struct OaMetricProgrammableImp : public MetricProgrammable { struct OaMetricFromProgrammable : OaMetricImp, MetricCreated { ~OaMetricFromProgrammable() override {} - OaMetricFromProgrammable(MetricSource &metricSource) : OaMetricImp(metricSource) {} + OaMetricFromProgrammable(MetricSource &metricSource, std::vector &scopes) + : OaMetricImp(metricSource, scopes) {} ze_result_t destroy() override; static Metric *create(MetricSource &metricSource, zet_metric_properties_t &properties, MetricsDiscovery::IMetricPrototype_1_13 *pClonedPrototype, diff --git a/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_source.h b/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_source.h index bc04bbddb1..8033d86248 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_source.h +++ b/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_source.h @@ -19,7 +19,8 @@ class MockMetric : public L0::MetricImp { public: ze_result_t destroyReturn = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; ~MockMetric() override = default; - MockMetric(MetricSource &metricSource) : L0::MetricImp(metricSource) {} + MockMetric(MetricSource &metricSource, std::vector &scopes) + : L0::MetricImp(metricSource, scopes) {} ze_result_t getProperties(zet_metric_properties_t *pProperties) override { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } @@ -62,6 +63,7 @@ class MockMetricCalcOp : public MetricCalcOpImp { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; }; }; + class MockMetricSource : public L0::MetricSource { public: ~MockMetricSource() override = default; @@ -113,12 +115,12 @@ class MockMetricSource : public L0::MetricSource { // Only support metric groups, enough for ULT for (uint32_t i = 0; i < pCalculationDesc->metricGroupCount; i++) { MockMetricSource metricSource{}; - metrics.push_back(new MockMetric(metricSource)); + metrics.push_back(new MockMetric(metricSource, const_cast &>(metricScopes))); } for (uint32_t i = 0; i < pCalculationDesc->metricCount; i++) { MockMetricSource metricSource{}; - metrics.push_back(new MockMetric(metricSource)); + metrics.push_back(new MockMetric(metricSource, const_cast &>(metricScopes))); } // Map each metric scope to all metrics 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 21a94c9528..a50016a8ab 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 @@ -21,13 +21,18 @@ namespace L0 { namespace ult { TEST(MultidevMetric, GivenMultideviceMetricCreatedThenReferenceIsUpdatedSuccessfully) { - MockMetricSource metricSource{}; - MockMetric mockMetric(metricSource); + MockMetricSource mockMetricSource{}; + zet_intel_metric_scope_properties_exp_t scopeProperties{}; + scopeProperties.stype = ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP; + scopeProperties.pNext = nullptr; + MockMetricScope mockMetricScope(scopeProperties, false, 0); + std::vector mockMetricScopes{&mockMetricScope}; + MockMetric mockMetric(mockMetricSource, mockMetricScopes); std::vector subDeviceMetrics; subDeviceMetrics.push_back(&mockMetric); - MultiDeviceMetricImp *multiDevMetric = MultiDeviceMetricImp::create(metricSource, subDeviceMetrics); + MultiDeviceMetricImp *multiDevMetric = MultiDeviceMetricImp::create(mockMetricSource, subDeviceMetrics, mockMetricScopes); EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, multiDevMetric->destroy()); zet_metric_properties_t properties; @@ -56,6 +61,7 @@ class CalcOperationFixture : public DeviceFixture, MockMetricScope *mockMetricScope; zet_intel_metric_scope_exp_handle_t hMetricScope = nullptr; + std::vector mockMetricScopes{}; DebugManagerStateRestore restorer; }; @@ -70,6 +76,7 @@ void CalcOperationFixture::SetUp() { scopeProperties.pNext = nullptr; mockMetricScope = new MockMetricScope(scopeProperties, false, 0); + mockMetricScopes.push_back(mockMetricScope); hMetricScope = mockMetricScope->toHandle(); } @@ -79,6 +86,7 @@ void CalcOperationFixture::TearDown() { delete mockMetricScope; hMetricGroup = nullptr; hMetricScope = nullptr; + mockMetricScopes.clear(); } class MetricScopesMultiDeviceFixture : public MultiDeviceFixture, @@ -94,7 +102,6 @@ class MetricScopesMultiDeviceFixture : public MultiDeviceFixture, MockMetricDeviceContext *mockSubDeviceContext = nullptr; MockMetricSource *mockSubMetricSource = nullptr; - DebugManagerStateRestore restorer; }; @@ -195,8 +202,8 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpWithMixedSourcesThenErrorIsReturn &hCalculationOperation)); // metrics from different source - MockMetric mockMetric(mockMetricSource); - MockMetric mockMetric2(mockMetricSource2); + MockMetric mockMetric(mockMetricSource, mockMetricScopes); + MockMetric mockMetric2(mockMetricSource2, mockMetricScopes); std::vector metrics{mockMetric.toHandle(), mockMetric2.toHandle()}; calculationDesc.metricGroupCount = 1; @@ -240,7 +247,7 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpWithMixedHierarchiesThenErrorIsRe device->toHandle(), &calculationDesc, &hCalculationOperation)); - MockMetric mockMetric(mockMetricSource), mockMetric2(mockMetricSource); + MockMetric mockMetric(mockMetricSource, mockMetricScopes), mockMetric2(mockMetricSource, mockMetricScopes); mockMetric2.setMultiDevice(true); std::vector metrics{mockMetric.toHandle(), mockMetric2.toHandle()}; @@ -256,20 +263,20 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpWithMixedHierarchiesThenErrorIsRe TEST_F(CalcOperationFixture, WhenCreatingCalcSubDeviceOnlyAcceptsOneScope) { - std::vector metricScopes{hMetricScope, hMetricScope}; + std::vector mockMetricScopes{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 + nullptr, // pNext + 1, // metricGroupCount + &hMetricGroup, // phMetricGroups + 0, // metricCount + nullptr, // phMetrics + 0, // timeWindowsCount + nullptr, // pCalculationTimeWindows + 1000, // timeAggregationWindow + 2, // metricScopesCount + mockMetricScopes.data(), // phMetricScopes }; zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation; @@ -304,7 +311,7 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpUseTheSourceFromMetricGroupOrMetr EXPECT_NE(nullptr, hCalculationOperation); EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalculationOperation)); - MockMetric mockMetric(mockMetricSource), mockMetric2(mockMetricSource); + MockMetric mockMetric(mockMetricSource, mockMetricScopes), mockMetric2(mockMetricSource, mockMetricScopes); std::vector metrics{mockMetric.toHandle(), mockMetric.toHandle()}; calculationDesc.metricGroupCount = 0; @@ -322,9 +329,9 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpObjectToAndFromHandleBaseClassWor std::vector mockMetricsInReport{}; std::vector mockExcludedMetrics{}; - std::vector metricScopes{mockMetricScope}; + std::vector mockMetricScopes{mockMetricScope}; - MockMetricCalcOp mockMetricCalcOp(false, metricScopes, mockMetricsInReport, mockExcludedMetrics); + MockMetricCalcOp mockMetricCalcOp(false, mockMetricScopes, mockMetricsInReport, mockExcludedMetrics); auto hMockCalcOp = mockMetricCalcOp.toHandle(); EXPECT_EQ(false, mockMetricCalcOp.isRootDevice()); @@ -334,16 +341,16 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpObjectToAndFromHandleBaseClassWor TEST_F(CalcOperationFixture, WhenGettingMetricsInReportAndExcludedMetricsThenTheyAreReturnedCorrectly) { std::vector mockMetricsInReport{}; - MockMetric mockMetricInReport(mockMetricSource); + MockMetric mockMetricInReport(mockMetricSource, mockMetricScopes); mockMetricsInReport.push_back(&mockMetricInReport); std::vector mockExcludedMetrics{}; - MockMetric mockExcludedMetric(mockMetricSource); + MockMetric mockExcludedMetric(mockMetricSource, mockMetricScopes); mockExcludedMetrics.push_back(&mockExcludedMetric); - std::vector metricScopes{mockMetricScope}; + std::vector mockMetricScopes{mockMetricScope}; - MockMetricCalcOp mockMetricCalcOp(false, metricScopes, mockMetricsInReport, mockExcludedMetrics); + MockMetricCalcOp mockMetricCalcOp(false, mockMetricScopes, mockMetricsInReport, mockExcludedMetrics); uint32_t metricCount = 0; EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationGetReportFormatExp(mockMetricCalcOp.toHandle(), &metricCount, nullptr, nullptr)); EXPECT_EQ(metricCount, 1U); @@ -493,18 +500,18 @@ HWTEST_F(MetricScopesMultiDeviceFixture, GivenRootDeviceThatDoesNOTSupportsMetri &metricScopesCount, nullptr)); EXPECT_EQ(metricScopesCount, numSubDevices); - std::vector metricScopes(metricScopesCount); + std::vector mockMetricScopes(metricScopesCount); EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricScopesGetExp(context->toHandle(), rootDevice->toHandle(), &metricScopesCount, - metricScopes.data())); + mockMetricScopes.data())); EXPECT_EQ(metricScopesCount, numSubDevices); zet_intel_metric_scope_properties_exp_t scopeProperties{}; scopeProperties.stype = ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP; scopeProperties.pNext = nullptr; for (uint32_t i = 0; i < metricScopesCount; i++) { - EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricScopeGetPropertiesExp(metricScopes[i], + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricScopeGetPropertiesExp(mockMetricScopes[i], &scopeProperties)); EXPECT_EQ(scopeProperties.iD, i); // ID of compute scopes should be sub-dev ID @@ -536,17 +543,17 @@ HWTEST_F(MetricScopesMultiDeviceFixture, GivenRootDeviceThatSupportsMetricsAggre &metricScopesCount, nullptr)); EXPECT_EQ(metricScopesCount, numRootDevices + numSubDevices); - std::vector metricScopes(metricScopesCount); + std::vector mockMetricScopes(metricScopesCount); EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricScopesGetExp(context->toHandle(), rootDevice->toHandle(), &metricScopesCount, - metricScopes.data())); + mockMetricScopes.data())); EXPECT_EQ(metricScopesCount, numRootDevices + numSubDevices); zet_intel_metric_scope_properties_exp_t scopeProperties{}; scopeProperties.stype = ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP; scopeProperties.pNext = nullptr; - EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricScopeGetPropertiesExp(metricScopes[0], + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricScopeGetPropertiesExp(mockMetricScopes[0], &scopeProperties)); // Aggregated scope must be first with ID 0 @@ -555,7 +562,7 @@ HWTEST_F(MetricScopesMultiDeviceFixture, GivenRootDeviceThatSupportsMetricsAggre EXPECT_STREQ(scopeProperties.description, aggregatedScopeDescription.data()); for (uint32_t i = 1; i < metricScopesCount; i++) { - EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricScopeGetPropertiesExp(metricScopes[i], + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricScopeGetPropertiesExp(mockMetricScopes[i], &scopeProperties)); EXPECT_EQ(scopeProperties.iD, i); // ID of compute scopes should be sub-dev ID+1 (since aggregated scope is 0) @@ -581,11 +588,11 @@ HWTEST_F(MetricScopesMultiDeviceFixture, GivenMetricsAggregationIsSupportedWhenC &metricScopesCount, nullptr)); EXPECT_EQ(metricScopesCount, numRootDevices + numSubDevices); - std::vector metricScopes(metricScopesCount); + std::vector mockMetricScopes(metricScopesCount); EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricScopesGetExp(context->toHandle(), rootDevice->toHandle(), &metricScopesCount, - metricScopes.data())); + mockMetricScopes.data())); EXPECT_EQ(metricScopesCount, numRootDevices + numSubDevices); @@ -594,21 +601,21 @@ HWTEST_F(MetricScopesMultiDeviceFixture, GivenMetricsAggregationIsSupportedWhenC zet_metric_group_handle_t hMetricGroup = mockMetricGroup.toHandle(); // send aggregated scope last - std::swap(metricScopes[0], metricScopes[metricScopesCount - 1]); + std::swap(mockMetricScopes[0], mockMetricScopes[metricScopesCount - 1]); // Aggregation window is zero 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 - 100, // timeAggregationWindow - metricScopesCount, // metricScopesCount - metricScopes.data(), // phMetricScopes + nullptr, // pNext + 1, // metricGroupCount + &hMetricGroup, // phMetricGroups + 0, // metricCount + nullptr, // phMetrics + 0, // timeWindowsCount + nullptr, // pCalculationTimeWindows + 100, // timeAggregationWindow + metricScopesCount, // metricScopesCount + mockMetricScopes.data(), // phMetricScopes }; zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation; @@ -672,15 +679,21 @@ TEST_F(MetricScopesMultiDeviceFixture, WhenCalcOperationCreateIsCalledWithDuplic std::vector metricScopes = { availableScopes[0], availableScopes[1], availableScopes[1], availableScopes[0]}; + std::vector metricScopeImps = { + static_cast(MetricScope::fromHandle(availableScopes[0])), + static_cast(MetricScope::fromHandle(availableScopes[1])), + static_cast(MetricScope::fromHandle(availableScopes[1])), + static_cast(MetricScope::fromHandle(availableScopes[0]))}; + // Create mock metric group for root device MockMetricGroup mockMetricGroup(*mockRootMetricSource); mockMetricGroup.isMultiDevice = true; zet_metric_group_handle_t hMetricGroup = mockMetricGroup.toHandle(); // Create mock metrics - MockMetric mockMetric1(*mockRootMetricSource); - MockMetric mockMetric2(*mockRootMetricSource); - MockMetric mockMetric3(*mockRootMetricSource); + MockMetric mockMetric1(*mockRootMetricSource, metricScopeImps); + MockMetric mockMetric2(*mockRootMetricSource, metricScopeImps); + MockMetric mockMetric3(*mockRootMetricSource, metricScopeImps); mockMetric1.setMultiDevice(true); mockMetric2.setMultiDevice(true); mockMetric3.setMultiDevice(true); diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_streamer_1.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_streamer_1.cpp index 580328e5fc..5037e131bb 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_streamer_1.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_streamer_1.cpp @@ -578,8 +578,8 @@ class MockMetricImp : public MetricImp { public: using MetricImp::MetricImp; - void setScopes(const std::vector &newScopes) { - scopes = newScopes; + void setScopes(const std::vector &newScopes) { + metricScopes = newScopes; } }; @@ -599,9 +599,9 @@ TEST_F(MetricIpSamplingMetricSupportedScopeTest, givenMetricWhenGettingSupported scopeProperties.stype = ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP; scopeProperties.pNext = nullptr; - std::vector metricScopesHandles; + std::vector metricScopesHandles; MockMetricScope *mockMetricScope = new MockMetricScope(scopeProperties, false, 0); - metricScopesHandles.push_back(mockMetricScope->toHandle()); + metricScopesHandles.push_back(mockMetricScope); auto metricImp = static_cast(Metric::fromHandle(phMetric)); metricImp->setScopes(metricScopesHandles); diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_streamer_2.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_streamer_2.cpp index c5e85c350e..5e1846b46e 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_streamer_2.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_streamer_2.cpp @@ -489,141 +489,140 @@ HWTEST2_F(MetricIpSamplingCalcAggregationTest, GivenIpSamplingCalcOpOnRootDevice MockRawDataHelper::addMultiSubDevHeader(rawDataWithHeader.data() + rawReportsBytesSize + sizeof(IpSamplingMultiDevDataHeader), rawDataWithHeader.size() - (rawReportsBytesSize + sizeof(IpSamplingMultiDevDataHeader)), reinterpret_cast(rawReports2.data()), rawReports2BytesSize, 1); - /* - uint32_t totalMetricReportCount = 0; - bool final = false; - size_t usedSize = 0; - uint32_t metricsInReportCount = 0; - zet_metric_properties_t ipSamplingMetricProperties = {}; - std::vector metricsInReport = {}; - std::vector metricScopesInReport = {}; - std::vector metricResults = {}; - for (auto &calcOp : hCalcOps) { - metricsInReportCount = 0; - EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationGetReportFormatExp(calcOp, &metricsInReportCount, nullptr, nullptr)); - // Expect 10 metrics per scope included in the calcOp - if (calcOp == hCalcOpCompScope1 || calcOp == hCalcOpCompScope2 || calcOp == hCalcOpAggScope) { - EXPECT_EQ(metricsInReportCount, 10u); + uint32_t totalMetricReportCount = 0; + bool final = false; + size_t usedSize = 0; + uint32_t metricsInReportCount = 0; + zet_metric_properties_t ipSamplingMetricProperties = {}; + std::vector metricsInReport = {}; + std::vector metricScopesInReport = {}; + std::vector metricResults = {}; + + for (auto &calcOp : hCalcOps) { + metricsInReportCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationGetReportFormatExp(calcOp, &metricsInReportCount, nullptr, nullptr)); + // Expect 10 metrics per scope included in the calcOp + if (calcOp == hCalcOpCompScope1 || calcOp == hCalcOpCompScope2 || calcOp == hCalcOpAggScope) { + EXPECT_EQ(metricsInReportCount, 10u); + } else if (calcOp == hCalcOpAllCompScopes) { + EXPECT_EQ(metricsInReportCount, 20u); + } else if (calcOp == hCalcOpAllScopes) { + EXPECT_EQ(metricsInReportCount, 30u); + } + + metricsInReport.resize(metricsInReportCount); + metricScopesInReport.resize(metricsInReportCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationGetReportFormatExp(calcOp, + &metricsInReportCount, + metricsInReport.data(), + metricScopesInReport.data())); + for (uint32_t i = 0; i < metricsInReportCount; i++) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGetProperties(metricsInReport[i], &ipSamplingMetricProperties)); + EXPECT_EQ(strcmp(ipSamplingMetricProperties.name, expectedMetricNamesInReport[i % expectedMetricNamesInReport.size()].c_str()), 0); + + if (calcOp == hCalcOpCompScope1) { + EXPECT_EQ(static_cast(MetricScope::fromHandle(metricScopesInReport[i])), mockMetricScopeCompute0); + } else if (calcOp == hCalcOpCompScope2) { + EXPECT_EQ(static_cast(MetricScope::fromHandle(metricScopesInReport[i])), mockMetricScopeCompute1); } else if (calcOp == hCalcOpAllCompScopes) { - EXPECT_EQ(metricsInReportCount, 20u); - } else if (calcOp == hCalcOpAllScopes) { - EXPECT_EQ(metricsInReportCount, 30u); - } - - metricsInReport.resize(metricsInReportCount); - metricScopesInReport.resize(metricsInReportCount); - EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationGetReportFormatExp(calcOp, - &metricsInReportCount, - metricsInReport.data(), - metricScopesInReport.data())); - for (uint32_t i = 0; i < metricsInReportCount; i++) { - EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGetProperties(metricsInReport[i], &ipSamplingMetricProperties)); - EXPECT_EQ(strcmp(ipSamplingMetricProperties.name, expectedMetricNamesInReport[i % expectedMetricNamesInReport.size()].c_str()), 0); - - if (calcOp == hCalcOpCompScope1) { + if (i < 10) { EXPECT_EQ(static_cast(MetricScope::fromHandle(metricScopesInReport[i])), mockMetricScopeCompute0); - } else if (calcOp == hCalcOpCompScope2) { + } else { EXPECT_EQ(static_cast(MetricScope::fromHandle(metricScopesInReport[i])), mockMetricScopeCompute1); - } else if (calcOp == hCalcOpAllCompScopes) { - if (i < 10) { - EXPECT_EQ(static_cast(MetricScope::fromHandle(metricScopesInReport[i])), mockMetricScopeCompute0); - } else { - EXPECT_EQ(static_cast(MetricScope::fromHandle(metricScopesInReport[i])), mockMetricScopeCompute1); - } - } else if (calcOp == hCalcOpAggScope) { + } + } else if (calcOp == hCalcOpAggScope) { + EXPECT_EQ(static_cast(MetricScope::fromHandle(metricScopesInReport[i])), mockMetricScopeAggregated); + } else if (calcOp == hCalcOpAllScopes) { + if (i < 10) { + // Expect aggregated scope first EXPECT_EQ(static_cast(MetricScope::fromHandle(metricScopesInReport[i])), mockMetricScopeAggregated); - } else if (calcOp == hCalcOpAllScopes) { - if (i < 10) { - // Expect aggregated scope first - EXPECT_EQ(static_cast(MetricScope::fromHandle(metricScopesInReport[i])), mockMetricScopeAggregated); - } else if (i >= 10 && i < 20) { - EXPECT_EQ(static_cast(MetricScope::fromHandle(metricScopesInReport[i])), mockMetricScopeCompute0); - } else { - EXPECT_EQ(static_cast(MetricScope::fromHandle(metricScopesInReport[i])), mockMetricScopeCompute1); - } + } else if (i >= 10 && i < 20) { + EXPECT_EQ(static_cast(MetricScope::fromHandle(metricScopesInReport[i])), mockMetricScopeCompute0); + } else { + EXPECT_EQ(static_cast(MetricScope::fromHandle(metricScopesInReport[i])), mockMetricScopeCompute1); } } + } - totalMetricReportCount = 0; - EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataSize, reinterpret_cast(rawDataWithHeader.data()), - calcOp, final, &usedSize, - &totalMetricReportCount, nullptr)); - EXPECT_EQ(usedSize, 0U); // query only, no data processed - if (calcOp == hCalcOpCompScope1 || calcOp == hCalcOpAllCompScopes) { - // three IPs in raw data for sub-dev 0 (rawReports) - EXPECT_EQ(totalMetricReportCount, 3U); - } else if (calcOp == hCalcOpCompScope2) { - // two IPs in raw data for sub-dev 1 (rawReports2) - EXPECT_EQ(totalMetricReportCount, 2U); - } else if (calcOp == hCalcOpAggScope || calcOp == hCalcOpAllScopes) { - // When aggregated scope is included expect unique IPs from both sub-devices: IP1, IP2, IP10, IP100 - EXPECT_EQ(totalMetricReportCount, 4U); - } + totalMetricReportCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataSize, reinterpret_cast(rawDataWithHeader.data()), + calcOp, final, &usedSize, + &totalMetricReportCount, nullptr)); + EXPECT_EQ(usedSize, 0U); // query only, no data processed + if (calcOp == hCalcOpCompScope1 || calcOp == hCalcOpAllCompScopes) { + // three IPs in raw data for sub-dev 0 (rawReports) + EXPECT_EQ(totalMetricReportCount, 3U); + } else if (calcOp == hCalcOpCompScope2) { + // two IPs in raw data for sub-dev 1 (rawReports2) + EXPECT_EQ(totalMetricReportCount, 2U); + } else if (calcOp == hCalcOpAggScope || calcOp == hCalcOpAllScopes) { + // When aggregated scope is included expect unique IPs from both sub-devices: IP1, IP2, IP10, IP100 + EXPECT_EQ(totalMetricReportCount, 4U); + } - EXPECT_EQ(usedSize, 0U); // query only, no data processed - metricResults.resize(totalMetricReportCount * metricsInReportCount); - EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataSize, reinterpret_cast(rawDataWithHeader.data()), - calcOp, final, &usedSize, - &totalMetricReportCount, metricResults.data())); - EXPECT_EQ(usedSize, rawDataSize); - if (calcOp == hCalcOpCompScope1 || calcOp == hCalcOpAllCompScopes) { - // three IPs in raw data for sub-dev 0 (rawReports) - EXPECT_EQ(totalMetricReportCount, 3U); - } else if (calcOp == hCalcOpCompScope2) { - // two IPs in raw data for sub-dev 1 (rawReports2) - EXPECT_EQ(totalMetricReportCount, 2U); - } else if (calcOp == hCalcOpAggScope || calcOp == hCalcOpAllScopes) { - // When aggregated scope is included expect unique IPs from both sub-devices: IP1, IP2, IP10, IP100 - EXPECT_EQ(totalMetricReportCount, 4U); - } + EXPECT_EQ(usedSize, 0U); // query only, no data processed + metricResults.resize(totalMetricReportCount * metricsInReportCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataSize, reinterpret_cast(rawDataWithHeader.data()), + calcOp, final, &usedSize, + &totalMetricReportCount, metricResults.data())); + EXPECT_EQ(usedSize, rawDataSize); + if (calcOp == hCalcOpCompScope1 || calcOp == hCalcOpAllCompScopes) { + // three IPs in raw data for sub-dev 0 (rawReports) + EXPECT_EQ(totalMetricReportCount, 3U); + } else if (calcOp == hCalcOpCompScope2) { + // two IPs in raw data for sub-dev 1 (rawReports2) + EXPECT_EQ(totalMetricReportCount, 2U); + } else if (calcOp == hCalcOpAggScope || calcOp == hCalcOpAllScopes) { + // When aggregated scope is included expect unique IPs from both sub-devices: IP1, IP2, IP10, IP100 + EXPECT_EQ(totalMetricReportCount, 4U); + } - // Data for sub dev 0 is from rawReports so expected results are from expectedMetricValues for IP1, IP10 and IP100 - for (uint32_t i = 0; i < totalMetricReportCount; i++) { - for (uint32_t j = 0; j < metricsInReportCount; j++) { - uint32_t resultIndex = i * metricsInReportCount + j; - if (calcOp == hCalcOpCompScope1) { - EXPECT_TRUE(metricResults[resultIndex].value.ui64 == expectedMetricValues[resultIndex].value.ui64); + // Data for sub dev 0 is from rawReports so expected results are from expectedMetricValues for IP1, IP10 and IP100 + for (uint32_t i = 0; i < totalMetricReportCount; i++) { + for (uint32_t j = 0; j < metricsInReportCount; j++) { + uint32_t resultIndex = i * metricsInReportCount + j; + if (calcOp == hCalcOpCompScope1) { + EXPECT_TRUE(metricResults[resultIndex].value.ui64 == expectedMetricValues[resultIndex].value.ui64); + EXPECT_TRUE(metricResults[resultIndex].resultStatus == ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID); + } else if (calcOp == hCalcOpCompScope2) { + EXPECT_TRUE(metricResults[resultIndex].value.ui64 == expectedMetricValues2[resultIndex].value.ui64); + EXPECT_TRUE(metricResults[resultIndex].resultStatus == ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID); + } else if (calcOp == hCalcOpAllCompScopes) { + EXPECT_TRUE(metricResults[resultIndex].value.ui64 == expectedMetricValuesCalcOpAllCompScopes[resultIndex]); + if (resultIndex < 50) { + // First two result reports have valid entries in compute caches EXPECT_TRUE(metricResults[resultIndex].resultStatus == ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID); - } else if (calcOp == hCalcOpCompScope2) { - EXPECT_TRUE(metricResults[resultIndex].value.ui64 == expectedMetricValues2[resultIndex].value.ui64); - EXPECT_TRUE(metricResults[resultIndex].resultStatus == ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID); - } else if (calcOp == hCalcOpAllCompScopes) { - EXPECT_TRUE(metricResults[resultIndex].value.ui64 == expectedMetricValuesCalcOpAllCompScopes[resultIndex]); - if (resultIndex < 50) { - // First two result reports have valid entries in compute caches - EXPECT_TRUE(metricResults[resultIndex].resultStatus == ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID); - } else { - // Third result report does not have IPs for sub-dev 1 in the cache: 3 IPs for subdev 0, 2 IPs for subdev 1 - EXPECT_TRUE(metricResults[resultIndex].resultStatus == ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID); - } + } else { + // Third result report does not have IPs for sub-dev 1 in the cache: 3 IPs for subdev 0, 2 IPs for subdev 1 + EXPECT_TRUE(metricResults[resultIndex].resultStatus == ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID); + } - } else if (calcOp == hCalcOpAggScope) { - // Expected results are the aggregation of both sub-devices - EXPECT_TRUE(metricResults[resultIndex].value.ui64 == expectedMetricValuesCalcOpAggScope[resultIndex]); + } else if (calcOp == hCalcOpAggScope) { + // Expected results are the aggregation of both sub-devices + EXPECT_TRUE(metricResults[resultIndex].value.ui64 == expectedMetricValuesCalcOpAggScope[resultIndex]); + EXPECT_TRUE(metricResults[resultIndex].resultStatus == ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID); + } else if (calcOp == hCalcOpAllScopes) { + EXPECT_TRUE(metricResults[resultIndex].value.ui64 == expectedMetricValuesCalcOpAllScopes[resultIndex]); + // Sub-dev 0 has 3 IPs, sub-dev 1 has 2 IPs, aggregated scope has 4 IPs + if (resultIndex < 80) { + // First two reports: all results are valid. + // Third result report: aggregated scope cache has IPs, sub-dev 0 has IPs EXPECT_TRUE(metricResults[resultIndex].resultStatus == ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID); - } else if (calcOp == hCalcOpAllScopes) { - EXPECT_TRUE(metricResults[resultIndex].value.ui64 == expectedMetricValuesCalcOpAllScopes[resultIndex]); - // Sub-dev 0 has 3 IPs, sub-dev 1 has 2 IPs, aggregated scope has 4 IPs - if (resultIndex < 80) { - // First two reports: all results are valid. - // Third result report: aggregated scope cache has IPs, sub-dev 0 has IPs - EXPECT_TRUE(metricResults[resultIndex].resultStatus == ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID); - } else if (resultIndex >= 80 && resultIndex < 90) { - // Third result report: sub-dev 1 cache ran out of IPs - EXPECT_TRUE(metricResults[resultIndex].resultStatus == ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID); - } else if (resultIndex >= 90 && resultIndex < 100) { - // Fourth result report: only aggregated scope cache has IPs - EXPECT_TRUE(metricResults[resultIndex].resultStatus == ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID); - } else { - // Fourth result report: both sub-devices caches ran out of IPs - EXPECT_TRUE(metricResults[resultIndex].resultStatus == ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID); - } + } else if (resultIndex >= 80 && resultIndex < 90) { + // Third result report: sub-dev 1 cache ran out of IPs + EXPECT_TRUE(metricResults[resultIndex].resultStatus == ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID); + } else if (resultIndex >= 90 && resultIndex < 100) { + // Fourth result report: only aggregated scope cache has IPs + EXPECT_TRUE(metricResults[resultIndex].resultStatus == ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID); + } else { + // Fourth result report: both sub-devices caches ran out of IPs + EXPECT_TRUE(metricResults[resultIndex].resultStatus == ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID); } } } } - */ + } } HWTEST2_F(MetricIpSamplingCalcAggregationTest, GivenIpSamplingCalcOpOnRootDeviceCalculatingConcatenatedDataExpectSuccess, EustallSupportedPlatforms) { @@ -978,7 +977,6 @@ HWTEST2_F(MetricIpSamplingCalcAggregationTest, GivenIpSamplingCalcOpOnRootDevice // Data for aggregated and both compute scopes EXPECT_TRUE(metricResults[j].value.ui64 == expectedMetricValuesCalcOpAllScopes[j]); } - EXPECT_TRUE(metricResults[j].resultStatus == ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID); } diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_programmable.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_programmable.cpp index aea0833d11..f51d3308c0 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_programmable.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_programmable.cpp @@ -28,11 +28,16 @@ class OaMetricProgrammableFixture : public DeviceFixture, MockIAdapterGroup1x13 mockAdapterGroup{}; void disableProgrammableMetricsSupport(); DebugManagerStateRestore restorer; + MockMetricScope *mockMetricScope = nullptr; + std::vector mockMetricScopes{}; }; void OaMetricProgrammableFixture::TearDown() { DeviceFixture::tearDown(); deviceContext.reset(); + delete mockMetricScope; + mockMetricScope = nullptr; + mockMetricScopes.clear(); } void OaMetricProgrammableFixture::SetUp() { @@ -48,6 +53,11 @@ void OaMetricProgrammableFixture::SetUp() { oaMetricSource->setInitializationState(ZE_RESULT_SUCCESS); metricEnumeration->setInitializationState(ZE_RESULT_SUCCESS); + zet_intel_metric_scope_properties_exp_t scopeProperties{}; + scopeProperties.stype = ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP; + scopeProperties.pNext = nullptr; + mockMetricScope = new MockMetricScope(scopeProperties, false, 0); + mockMetricScopes.push_back(mockMetricScope); } void OaMetricProgrammableFixture::disableProgrammableMetricsSupport() { @@ -705,7 +715,7 @@ TEST_F(OaMetricProgrammableTests, givenValidMetricGroupWhenAddingOrRemovingMetri TEST_F(OaMetricProgrammableTests, givenInvalidMeticWhenMetricGroupIsCreatedThenErrorIsReturned) { MockMetricSource mockMetricSource{}; mockMetricSource.isAvailableReturn = true; - MockMetric mockMetric(mockMetricSource); + MockMetric mockMetric(mockMetricSource, mockMetricScopes); uint32_t metricGroupCount = 0; auto metricHandle = mockMetric.toHandle(); EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, deviceContext->createMetricGroupsFromMetrics(1, &metricHandle, "metricGroupName", "metricGroupDesc", &metricGroupCount, nullptr)); @@ -1193,7 +1203,7 @@ TEST_F(OaMetricProgrammableTests, givenValidMetricGroupWhenAddingOrRemovingMetri MockMetricSource mockMetricSource{}; mockMetricSource.isAvailableReturn = true; - MockMetric mockMetric(mockMetricSource); + MockMetric mockMetric(mockMetricSource, mockMetricScopes); auto metricHandleIncorrectSource = mockMetric.toHandle(); EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetMetricGroupAddMetricExp(metricGroupHandle, metricHandleIncorrectSource, &errorStringSize, nullptr)); @@ -1465,7 +1475,7 @@ TEST_F(OaMetricProgrammableTests, givenEnableProgrammableMetricsSupportIsNotSetW TEST_F(OaMetricProgrammableTests, givenCreateMetricGroupsFromMetricsWhenUnembargoedMetricSourceIsUsedThenSuccessIsReturned) { MockMetricSource mockMetricSource{}; mockMetricSource.isAvailableReturn = true; - MockMetric mockMetric(mockMetricSource); + MockMetric mockMetric(mockMetricSource, mockMetricScopes); mockMetric.setPredefined(false); uint32_t metricGroupCount = 0; @@ -1586,11 +1596,16 @@ class MultiSourceOaMetricProgrammableFixture : public DeviceFixture, MetricEnumeration *metricEnumeration = nullptr; MockIAdapterGroup1x13 mockAdapterGroup{}; MockMetricIpSamplingSource *metricSource = nullptr; + MockMetricScope *mockMetricScope = nullptr; + std::vector mockMetricScopes{}; }; void MultiSourceOaMetricProgrammableFixture::TearDown() { DeviceFixture::tearDown(); deviceContext.reset(); + delete mockMetricScope; + mockMetricScope = nullptr; + mockMetricScopes.clear(); } void MultiSourceOaMetricProgrammableFixture::SetUp() { @@ -1608,6 +1623,11 @@ void MultiSourceOaMetricProgrammableFixture::SetUp() { metricSource = new MockMetricIpSamplingSource(*deviceContext); deviceContext->setMetricIpSamplingSource(metricSource); + zet_intel_metric_scope_properties_exp_t scopeProperties{}; + scopeProperties.stype = ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP; + scopeProperties.pNext = nullptr; + mockMetricScope = new MockMetricScope(scopeProperties, false, 0); + mockMetricScopes.push_back(mockMetricScope); } TEST_F(MultiSourceOaMetricProgrammableFixture, givenCreateMetricGroupsFromMetricsIsCalledAndOneMetricSourcesReturnsUnsupportedThenSuccessIsReturned) { @@ -1631,7 +1651,7 @@ TEST_F(MultiSourceOaMetricProgrammableFixture, givenCreateMetricGroupsFromMetric ASSERT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle)); MockMetricIpSamplingSource mockMetricTraceSource(*deviceContext); - MockMetric mockMetric(mockMetricTraceSource); + MockMetric mockMetric(mockMetricTraceSource, mockMetricScopes); mockMetric.setPredefined(false); zet_metric_handle_t metricHandles[] = {metricHandle, mockMetric.toHandle()}; @@ -1674,7 +1694,7 @@ TEST_F(MultiSourceOaMetricProgrammableFixture, givenCreateMetricGroupsFromMetric ASSERT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle)); MockMetricIpSamplingSource &mockMetricTraceSource = static_cast(deviceContext->getMetricSource()); - MockMetric mockMetric(mockMetricTraceSource); + MockMetric mockMetric(mockMetricTraceSource, mockMetricScopes); mockMetric.setPredefined(false); zet_metric_handle_t metricHandles[] = {metricHandle, mockMetric.toHandle()}; @@ -1727,7 +1747,7 @@ TEST_F(MultiSourceOaMetricProgrammableFixture, givenCreateMetricGroupsFromMetric ASSERT_EQ(ZE_RESULT_SUCCESS, MetricProgrammable::fromHandle(programmable)->createMetric(¶meterValue, 1, metricName, metricDescription, &metricHandleCount, &metricHandle)); MockMetricIpSamplingSource &mockMetricTraceSource = static_cast(deviceContext->getMetricSource()); - MockMetric mockMetric(mockMetricTraceSource); + MockMetric mockMetric(mockMetricTraceSource, mockMetricScopes); mockMetric.setPredefined(false); zet_metric_handle_t metricHandles[] = {metricHandle, mockMetric.toHandle()}; diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_multidevice_metric_programmable.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_multidevice_metric_programmable.cpp index 9444661ad4..ef87d611e9 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/test_multidevice_metric_programmable.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/test_multidevice_metric_programmable.cpp @@ -29,6 +29,7 @@ class OaMultiDeviceMetricProgrammableFixture : public MultiDeviceFixture, Device *rootDevice = nullptr; DebugManagerStateRestore restorer; MockIConcurrentGroup1x13 mockConcurrentGroup{}; + MockMetricSource mockMetricSource{}; void getMetricProgrammable(zet_metric_programmable_exp_handle_t &programmable); void getMetricFromProgrammable(zet_metric_programmable_exp_handle_t programmable, zet_metric_handle_t &metricHandle); @@ -527,8 +528,13 @@ TEST_F(OaMultiDeviceMetricProgrammableTests, givenMultiDeviceMetricGroupWhenAddA std::vector metricGroups{}; createMetricGroupFromMetric(metricHandle, metricGroups); - MockMetricSource metricSource{}; - MockMetric mockMetric(metricSource); + zet_intel_metric_scope_properties_exp_t scopeProperties{}; + scopeProperties.stype = ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP; + scopeProperties.pNext = nullptr; + MockMetricScope mockMetricScope(scopeProperties, false, 0); + std::vector mockMetricScopes{&mockMetricScope}; + MockMetric mockMetric(mockMetricSource, mockMetricScopes); + mockMetric.setMultiDevice(false); mockMetric.setPredefined(false); @@ -762,12 +768,16 @@ struct MockMetricProgrammable : public MetricProgrammable { MockMetricSource metricSource{}; std::vector allocatedMetricObjects{}; + std::vector mockMetricScopes{}; ~MockMetricProgrammable() override { for (auto &metric : allocatedMetricObjects) { delete metric; + delete mockMetricScopes.back(); + mockMetricScopes.pop_back(); } allocatedMetricObjects.clear(); + mockMetricScopes.clear(); } ze_result_t createMetricReturnStatus = ZE_RESULT_SUCCESS; @@ -805,11 +815,17 @@ struct MockMetricProgrammable : public MetricProgrammable { void prepareMetricObjects(uint32_t metricHandleCount) { + zet_intel_metric_scope_properties_exp_t scopeProperties{}; + scopeProperties.stype = ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP; + scopeProperties.pNext = nullptr; + bool additionalAllocationNecessary = metricHandleCount > static_cast(allocatedMetricObjects.size()); if (additionalAllocationNecessary) { uint32_t additionalAllocations = metricHandleCount - static_cast(allocatedMetricObjects.size()); for (uint32_t index = 0; index < additionalAllocations; index++) { - auto mockMetric = new MockMetric(metricSource); + auto mockMetricScope = new MockMetricScope(scopeProperties, false, 0); + mockMetricScopes.push_back(mockMetricScope); + auto mockMetric = new MockMetric(metricSource, mockMetricScopes); mockMetric->destroyReturn = ZE_RESULT_SUCCESS; allocatedMetricObjects.push_back(mockMetric); } @@ -910,11 +926,16 @@ TEST(HomogeneousMultiDeviceMetricProgrammableTest, givenSubDevicesReturnZeroMetr TEST(HomogeneousMultiDeviceMetricTest, givenMultiDeviceMetricWhenDestroyIsCalledThenUnsupportedFeatureIsReturned) { - MockMetricSource mockSource; - MockMetric mockMetric(mockSource); + MockMetricSource mockMetricSource{}; + zet_intel_metric_scope_properties_exp_t scopeProperties{}; + scopeProperties.stype = ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP; + scopeProperties.pNext = nullptr; + MockMetricScope mockMetricScope(scopeProperties, false, 0); + std::vector mockMetricScopes{&mockMetricScope}; + MockMetric mockMetric(mockMetricSource, mockMetricScopes); std::vector mockMetrics{&mockMetric}; MultiDeviceMetricImp *multiDevMetric = static_cast( - MultiDeviceMetricImp::create(mockSource, mockMetrics)); + MultiDeviceMetricImp::create(mockMetricSource, mockMetrics, mockMetricScopes)); EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, multiDevMetric->destroy()); delete multiDevMetric; } @@ -950,11 +971,16 @@ struct DummyMetricGroup : public MockMetricGroup { TEST_F(MultiDeviceCreatedMetricGroupManagerTest, givenMetricFromSubDeviceIsUsedWhenCreateMultipleFromHomogenousMetricsIsCalledThenErrorIsReturned) { MockMetricSource mockMetricSource{}; - MockMetric metric(mockMetricSource); - metric.setMultiDevice(false); + zet_intel_metric_scope_properties_exp_t scopeProperties{}; + scopeProperties.stype = ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP; + scopeProperties.pNext = nullptr; + MockMetricScope mockMetricScope(scopeProperties, false, 0); + std::vector mockMetricScopes{&mockMetricScope}; + MockMetric mockMetric(mockMetricSource, mockMetricScopes); + mockMetric.setMultiDevice(false); uint32_t metricGroupFromMetricsCount = 0; - auto metricHandle = metric.toHandle(); + auto metricHandle = mockMetric.toHandle(); std::vector metricGroups{}; std::vector metrics(1); metrics[0] = metricHandle;