From 1197ec47bc5918abefc0196da6c7feb6e34fb731 Mon Sep 17 00:00:00 2001 From: Matias Cabral Date: Wed, 20 Aug 2025 23:32:59 +0000 Subject: [PATCH] feature: calcOp supports metric scopes Resolves: NEO-14417 Signed-off-by: Matias Cabral --- level_zero/tools/source/metrics/metric.cpp | 60 +++-- level_zero/tools/source/metrics/metric.h | 30 ++- .../metrics/metric_ip_sampling_source.cpp | 3 +- .../metrics/metric_ip_sampling_source.h | 1 + .../metrics/metric_ip_sampling_streamer.cpp | 10 +- .../metrics/metric_ip_sampling_streamer.h | 17 +- .../tools/source/metrics/metric_oa_source.h | 1 + .../metrics/metric_ip_sampling_fixture.cpp | 53 ++++ .../metrics/metric_ip_sampling_fixture.h | 15 ++ .../sources/metrics/mock_metric_source.h | 12 +- .../sources/metrics/test_metric.cpp | 158 ++++++++++-- .../test_metric_ip_sampling_streamer.cpp | 243 ++++-------------- .../metrics/test_metric_oa_enumeration_1.cpp | 9 + 13 files changed, 353 insertions(+), 259 deletions(-) diff --git a/level_zero/tools/source/metrics/metric.cpp b/level_zero/tools/source/metrics/metric.cpp index 3f723810ae..607a0a818d 100644 --- a/level_zero/tools/source/metrics/metric.cpp +++ b/level_zero/tools/source/metrics/metric.cpp @@ -34,13 +34,13 @@ void MetricSource::getMetricGroupSourceIdProperty(zet_base_properties_t *propert void MetricSource::initComputeMetricScopes(MetricDeviceContext &metricDeviceContext) { - auto createScope = [&metricDeviceContext](const std::string &name, const std::string &desc, uint32_t id) { + auto createScope = [&metricDeviceContext](const std::string &name, const std::string &desc, uint32_t id, bool aggregated) { zet_intel_metric_scope_properties_exp_t scopeProperties = {ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP, nullptr}; scopeProperties.iD = id; snprintf(scopeProperties.name, ZET_INTEL_MAX_METRIC_SCOPE_NAME_EXP, "%s", name.c_str()); snprintf(scopeProperties.description, ZET_INTEL_MAX_METRIC_SCOPE_NAME_EXP, "%s", desc.c_str()); - auto metricScopeImp = MetricScopeImp::create(scopeProperties); + auto metricScopeImp = MetricScopeImp::create(scopeProperties, aggregated); DEBUG_BREAK_IF(metricScopeImp == nullptr); metricDeviceContext.addMetricScope(std::move(metricScopeImp)); }; @@ -50,25 +50,25 @@ void MetricSource::initComputeMetricScopes(MetricDeviceContext &metricDeviceCont auto deviceImp = static_cast(&metricDeviceContext.getDevice()); uint32_t subDeviceCount = deviceImp->numSubDevices; for (uint32_t i = 0; i < subDeviceCount; i++) { - std::string scopeName = "COMPUTE_TILE_" + std::to_string(i); - std::string scopeDesc = "Metrics results for tile " + std::to_string(i); + std::string scopeName = std::string(computeScopeNamePrefix) + std::to_string(i); + std::string scopeDesc = std::string(computeScopeDescriptionPrefix) + std::to_string(i); - createScope(scopeName, scopeDesc, i); + createScope(scopeName, scopeDesc, i, false); } auto &l0GfxCoreHelper = metricDeviceContext.getDevice().getNEODevice()->getRootDeviceEnvironment().getHelper(); if (l0GfxCoreHelper.supportMetricsAggregation()) { - std::string scopeName = "DEVICE_AGGREGATED"; - std::string scopeDesc = "Metrics results aggregated at device level"; + std::string scopeName(aggregatedScopeName); + std::string scopeDesc(aggregatedScopeDescription); - createScope(scopeName, scopeDesc, subDeviceCount); + createScope(scopeName, scopeDesc, subDeviceCount, true); } } else { auto subDeviceIndex = metricDeviceContext.getSubDeviceIndex(); - std::string scopeName = "COMPUTE_TILE_" + std::to_string(subDeviceIndex); - std::string scopeDesc = "Metrics results for tile " + std::to_string(subDeviceIndex); + std::string scopeName = std::string(computeScopeNamePrefix) + std::to_string(subDeviceIndex); + std::string scopeDesc = std::string(computeScopeDescriptionPrefix) + std::to_string(subDeviceIndex); - createScope(scopeName, scopeDesc, subDeviceIndex); + createScope(scopeName, scopeDesc, subDeviceIndex, false); } metricDeviceContext.setComputeMetricScopeInitialized(); @@ -646,12 +646,38 @@ ze_result_t MetricDeviceContext::calcOperationCreate(zet_context_handle_t hConte return ZE_RESULT_ERROR_INVALID_ARGUMENT; } + if (pCalculationDesc->metricScopesCount == 0) { + METRICS_LOG_ERR("%s", "Must define at least one metric scope"); + return ZE_RESULT_ERROR_INVALID_ARGUMENT; + } + + std::vector metricScopes; + bool aggregatedScopeProvided = false; + for (uint32_t i = 0; i < pCalculationDesc->metricScopesCount; i++) { + metricScopes.push_back(static_cast(MetricScope::fromHandle(pCalculationDesc->phMetricScopes[i]))); + if (metricScopes.back()->isAggregated()) { + aggregatedScopeProvided = true; + } + } + + std::sort(metricScopes.begin(), metricScopes.end()); + metricScopes.erase(std::unique(metricScopes.begin(), metricScopes.end()), metricScopes.end()); + + // If aggregated scope is provided, make it be listed first. + if (aggregatedScopeProvided) { + auto aggregatedScopeIt = std::find_if(metricScopes.begin(), metricScopes.end(), + [](const zet_intel_metric_scope_exp_handle_t &scope) { + return static_cast(MetricScope::fromHandle(scope))->isAggregated(); + }); + std::swap(metricScopes[0], *aggregatedScopeIt); + } + MetricSource &metricSource = (metricGroupImp) ? metricGroupImp->getMetricSource() : metricImp->getMetricSource(); // NOLINT(clang-analyzer-core.CallAndMessage) - return metricSource.calcOperationCreate(*this, pCalculationDesc, phCalculationOperation); + return metricSource.calcOperationCreate(*this, pCalculationDesc, metricScopes, phCalculationOperation); } -std::unique_ptr MetricScopeImp::create(zet_intel_metric_scope_properties_exp_t &scopeProperties) { - return std::make_unique(scopeProperties); +std::unique_ptr MetricScopeImp::create(zet_intel_metric_scope_properties_exp_t &scopeProperties, bool aggregated) { + return std::make_unique(scopeProperties, aggregated); } void MetricDeviceContext::initMetricScopes() { @@ -973,15 +999,15 @@ MetricImp *HomogeneousMultiDeviceMetricCreated::create(MetricSource &metricSourc ze_result_t MetricCalcOpImp::getMetricsFromCalcOp(uint32_t *pCount, zet_metric_handle_t *phMetrics, bool isExcludedMetrics) { if (*pCount == 0) { - *pCount = isExcludedMetrics ? excludedMetricCount : metricInReportCount; + *pCount = isExcludedMetrics ? getExcludedMetricsCount() : getMetricsInReportCount(); return ZE_RESULT_SUCCESS; - } else if (*pCount < (isExcludedMetrics ? excludedMetricCount : metricInReportCount)) { + } else if (*pCount < (isExcludedMetrics ? getExcludedMetricsCount() : getMetricsInReportCount())) { METRICS_LOG_ERR("%s", "Metric can't be smaller than report size"); *pCount = 0; return ZE_RESULT_ERROR_INVALID_ARGUMENT; } - *pCount = isExcludedMetrics ? excludedMetricCount : metricInReportCount; + *pCount = isExcludedMetrics ? getExcludedMetricsCount() : getMetricsInReportCount(); for (uint32_t index = 0; index < *pCount; index++) { phMetrics[index] = isExcludedMetrics ? excludedMetrics[index]->toHandle() : metricsInReport[index]->toHandle(); } diff --git a/level_zero/tools/source/metrics/metric.h b/level_zero/tools/source/metrics/metric.h index 4ab7397e82..47804239bf 100644 --- a/level_zero/tools/source/metrics/metric.h +++ b/level_zero/tools/source/metrics/metric.h @@ -107,6 +107,7 @@ class MetricSource { virtual ze_result_t appendMarker(zet_command_list_handle_t hCommandList, zet_metric_group_handle_t hMetricGroup, uint32_t value) = 0; virtual ze_result_t calcOperationCreate(MetricDeviceContext &metricDeviceContext, zet_intel_metric_calculation_exp_desc_t *pCalculationDesc, + const std::vector &metricScopes, zet_intel_metric_calculation_operation_exp_handle_t *phCalculationOperation) = 0; virtual bool canDisable() = 0; virtual void initMetricScopes(MetricDeviceContext &metricDeviceContext) = 0; @@ -479,26 +480,33 @@ struct MetricCalcOp : _zet_intel_metric_calculation_operation_exp_handle_t { struct MetricCalcOpImp : public MetricCalcOp { ~MetricCalcOpImp() override = default; - MetricCalcOpImp(bool multiDevice, const std::vector &inMetricsInReport, - uint32_t inExcludedMetricsCount = 0, const std::vector &inExcludedMetrics = std::vector()) - : isMultiDevice(multiDevice), metricInReportCount(static_cast(inMetricsInReport.size())), - metricsInReport(inMetricsInReport), excludedMetricCount(inExcludedMetricsCount), - excludedMetrics(inExcludedMetrics) {} + MetricCalcOpImp(bool multiDevice, + const std::vector &metricScopes, + const std::vector &metricsInReport, + const std::vector &excludedMetrics = std::vector()) + : isMultiDevice(multiDevice), + metricScopes(metricScopes), + metricsInReport(metricsInReport), + excludedMetrics(excludedMetrics) {} bool isRootDevice() { return isMultiDevice; } ze_result_t getReportFormat(uint32_t *pCount, zet_metric_handle_t *phMetrics) override; ze_result_t getExcludedMetrics(uint32_t *pCount, zet_metric_handle_t *phMetrics) override; - uint32_t getMetricsInReportCount() { return metricInReportCount; }; + uint32_t getMetricsInReportCount() { return static_cast(metricsInReport.size()); }; + uint32_t getExcludedMetricsCount() { return static_cast(excludedMetrics.size()); }; protected: ze_result_t getMetricsFromCalcOp(uint32_t *pCount, zet_metric_handle_t *phMetrics, bool isExcludedMetrics = false); bool isMultiDevice = false; - uint32_t metricInReportCount = 0; + std::vector metricScopes{}; std::vector metricsInReport{}; - uint32_t excludedMetricCount = 0; std::vector excludedMetrics{}; }; +static constexpr std::string_view computeScopeNamePrefix = "COMPUTE_TILE_"; +static constexpr std::string_view computeScopeDescriptionPrefix = "Metrics results for tile "; +static constexpr std::string_view aggregatedScopeName = "DEVICE_AGGREGATED"; +static constexpr std::string_view aggregatedScopeDescription = "Metrics results aggregated at device level"; struct MetricScope : _zet_intel_metric_scope_exp_handle_t { virtual ~MetricScope() = default; MetricScope() {} @@ -511,13 +519,15 @@ struct MetricScope : _zet_intel_metric_scope_exp_handle_t { struct MetricScopeImp : public MetricScope { ~MetricScopeImp() override = default; - MetricScopeImp(zet_intel_metric_scope_properties_exp_t &properties) : properties(properties){}; + MetricScopeImp(zet_intel_metric_scope_properties_exp_t &properties, bool aggregated) : properties(properties), aggregated(aggregated) {} virtual ze_result_t getProperties(zet_intel_metric_scope_properties_exp_t *pProperties); - static std::unique_ptr create(zet_intel_metric_scope_properties_exp_t &scopeProperties); + static std::unique_ptr create(zet_intel_metric_scope_properties_exp_t &scopeProperties, bool aggregated); + bool isAggregated() const { return aggregated; } private: zet_intel_metric_scope_properties_exp_t properties; + bool aggregated = false; }; // MetricGroup. 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 4816b7b79b..925e7c0b42 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_source.cpp +++ b/level_zero/tools/source/metrics/metric_ip_sampling_source.cpp @@ -274,11 +274,12 @@ ze_result_t IpSamplingMetricSourceImp::handleMetricGroupExtendedProperties(zet_m ze_result_t IpSamplingMetricSourceImp::calcOperationCreate(MetricDeviceContext &metricDeviceContext, zet_intel_metric_calculation_exp_desc_t *pCalculationDesc, + const std::vector &metricScopes, zet_intel_metric_calculation_operation_exp_handle_t *phCalculationOperation) { ze_result_t status = ZE_RESULT_ERROR_UNKNOWN; bool isMultiDevice = (metricDeviceContext.isImplicitScalingCapable()) ? true : false; - status = IpSamplingMetricCalcOpImp::create(*this, pCalculationDesc, isMultiDevice, phCalculationOperation); + status = IpSamplingMetricCalcOpImp::create(isMultiDevice, metricScopes, *this, pCalculationDesc, phCalculationOperation); return status; } 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 39a8a7d722..d97a2cd470 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_source.h +++ b/level_zero/tools/source/metrics/metric_ip_sampling_source.h @@ -59,6 +59,7 @@ class IpSamplingMetricSourceImp : public MetricSource { } ze_result_t calcOperationCreate(MetricDeviceContext &metricDeviceContext, zet_intel_metric_calculation_exp_desc_t *pCalculationDesc, + const std::vector &metricScopes, zet_intel_metric_calculation_operation_exp_handle_t *phCalculationOperation) override; uint32_t metricSourceCount = 0; 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 0ab26ba80b..97363026f7 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_streamer.cpp +++ b/level_zero/tools/source/metrics/metric_ip_sampling_streamer.cpp @@ -105,9 +105,10 @@ uint32_t IpSamplingMetricStreamerImp::getMaxSupportedReportCount() { return ipSamplingSource.getMetricOsInterface()->getRequiredBufferSize(UINT32_MAX) / unitReportSize; } -ze_result_t IpSamplingMetricCalcOpImp::create(IpSamplingMetricSourceImp &metricSource, +ze_result_t IpSamplingMetricCalcOpImp::create(bool isMultiDevice, + const std::vector &metricScopes, + IpSamplingMetricSourceImp &metricSource, zet_intel_metric_calculation_exp_desc_t *pCalculationDesc, - bool isMultiDevice, zet_intel_metric_calculation_operation_exp_handle_t *phCalculationOperation) { // There is only one valid metric group in IP sampling and time filtering is not supported @@ -140,9 +141,8 @@ ze_result_t IpSamplingMetricCalcOpImp::create(IpSamplingMetricSourceImp &metricS } } - auto calcOp = new IpSamplingMetricCalcOpImp(static_cast(hMetrics.size()), - metricsInReport, includedMetricIndexes, - isMultiDevice); + 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)) { 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 8147ea6d38..d3e984f521 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_streamer.h +++ b/level_zero/tools/source/metrics/metric_ip_sampling_streamer.h @@ -48,17 +48,20 @@ struct MultiDeviceIpSamplingMetricStreamerImp : public IpSamplingMetricStreamerB }; struct IpSamplingMetricCalcOpImp : public MetricCalcOpImp { - IpSamplingMetricCalcOpImp(uint32_t inCachedMetricsCount, + IpSamplingMetricCalcOpImp(bool multidevice, + const std::vector &metricScopes, + uint32_t cachedMetricsCount, std::vector &metricsInReport, - std::vector &inputIncludedMetricIndexes, bool multidevice) - : MetricCalcOpImp(multidevice, metricsInReport), - cachedMetricsCount(inCachedMetricsCount), - includedMetricIndexes(inputIncludedMetricIndexes) {} + std::vector &includedMetricIndexes) + : MetricCalcOpImp(multidevice, metricScopes, metricsInReport, std::vector()), + cachedMetricsCount(cachedMetricsCount), + includedMetricIndexes(includedMetricIndexes) {} ~IpSamplingMetricCalcOpImp() override{}; - static ze_result_t create(IpSamplingMetricSourceImp &metricSource, + static ze_result_t create(bool isMultiDevice, + const std::vector &metricScopes, + IpSamplingMetricSourceImp &metricSource, zet_intel_metric_calculation_exp_desc_t *pCalculationDesc, - bool isMultiDevice, zet_intel_metric_calculation_operation_exp_handle_t *phCalculationOperation); ze_result_t destroy() override; diff --git a/level_zero/tools/source/metrics/metric_oa_source.h b/level_zero/tools/source/metrics/metric_oa_source.h index 4e3c3b4c5c..efb1b5681a 100644 --- a/level_zero/tools/source/metrics/metric_oa_source.h +++ b/level_zero/tools/source/metrics/metric_oa_source.h @@ -66,6 +66,7 @@ class OaMetricSourceImp : public MetricSource { zet_metric_group_handle_t *pMetricGroupHandle); ze_result_t calcOperationCreate(MetricDeviceContext &metricDeviceContext, zet_intel_metric_calculation_exp_desc_t *pCalculationDesc, + const std::vector &metricScopes, zet_intel_metric_calculation_operation_exp_handle_t *phCalculationOperation) override { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } 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 27da1e87e0..e1083a5f32 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 @@ -76,5 +76,58 @@ void MetricIpSamplingFixture::TearDown() { globalDriverHandles->clear(); } +void MetricIpSamplingCalculateBaseFixture::initCalcDescriptor() { + 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); + hMockScope = mockMetricScope->toHandle(); + + calculationDesc.stype = ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP; + calculationDesc.pNext = nullptr; // pNext + calculationDesc.metricGroupCount = 0; // metricGroupCount + calculationDesc.phMetricGroups = nullptr; // phMetricGroups + calculationDesc.metricCount = 0; // metricCount + calculationDesc.phMetrics = nullptr; // phMetrics + calculationDesc.timeWindowsCount = 0; // timeWindowsCount + calculationDesc.pCalculationTimeWindows = nullptr; // pCalculationTimeWindows + calculationDesc.timeAggregationWindow = 0; // timeAggregationWindow + calculationDesc.metricScopesCount = 1; // metricScopesCount + calculationDesc.phMetricScopes = &hMockScope; // phMetricScopes +} + +void MetricIpSamplingCalculateBaseFixture::cleanupCalcDescriptor() { + delete mockMetricScope; + hMockScope = nullptr; +} + +void MetricIpSamplingCalculateMultiDevFixture::SetUp() { + MetricIpSamplingMultiDevFixture::SetUp(); + initCalcDescriptor(); +} + +void MetricIpSamplingCalculateMultiDevFixture::TearDown() { + MetricIpSamplingMultiDevFixture::TearDown(); + cleanupCalcDescriptor(); +} + +void MetricIpSamplingCalculateSingleDevFixture::SetUp() { + MetricIpSamplingFixture::SetUp(); + initCalcDescriptor(); + + device->getMetricDeviceContext().enableMetricApi(); + uint32_t metricGroupCount = 1; + zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle); + + calculationDesc.metricGroupCount = 1; + calculationDesc.phMetricGroups = &metricGroupHandle; +} + +void MetricIpSamplingCalculateSingleDevFixture::TearDown() { + MetricIpSamplingFixture::TearDown(); + cleanupCalcDescriptor(); +} + } // namespace ult } // namespace L0 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 6f338e9685..7d76059c0b 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 @@ -10,6 +10,7 @@ #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_metric_source.h" #include #include "gtest/gtest.h" @@ -223,11 +224,25 @@ class MetricIpSamplingCalculateBaseFixture { {ZET_VALUE_TYPE_UINT64, {110}}, {ZET_VALUE_TYPE_UINT64, {110}}, {ZET_VALUE_TYPE_UINT64, {110}}}; + + MockMetricScope *mockMetricScope; + zet_intel_metric_scope_exp_handle_t hMockScope = nullptr; + zet_intel_metric_calculation_exp_desc_t calculationDesc{}; + zet_metric_group_handle_t metricGroupHandle = nullptr; + + void initCalcDescriptor(); + void cleanupCalcDescriptor(); }; struct MetricIpSamplingCalculateSingleDevFixture : public MetricIpSamplingCalculateBaseFixture, MetricIpSamplingFixture { + public: + void SetUp() override; + void TearDown() override; }; struct MetricIpSamplingCalculateMultiDevFixture : public MetricIpSamplingCalculateBaseFixture, MetricIpSamplingMultiDevFixture { + public: + void SetUp() override; + void TearDown() override; }; } // namespace ult 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 c9970197c4..4b6a3dbad8 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 @@ -51,6 +51,7 @@ class MockMetricSource : public L0::MetricSource { ze_result_t calcOperationCreate(MetricDeviceContext &metricDeviceContext, zet_intel_metric_calculation_exp_desc_t *pCalculationDesc, + const std::vector &metricScopes, zet_intel_metric_calculation_operation_exp_handle_t *phCalculationOperation) override { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } @@ -161,9 +162,10 @@ class MockMetric : public L0::MetricImp { class MockMetricCalcOp : public MetricCalcOpImp { public: ~MockMetricCalcOp() override = default; - MockMetricCalcOp(bool multiDevice, const std::vector &inMetricsInReport, - uint32_t inExcludedMetricsCount, const std::vector &inExcludedMetrics) - : MetricCalcOpImp(multiDevice, inMetricsInReport, inExcludedMetricsCount, inExcludedMetrics) {} + MockMetricCalcOp(bool multiDevice, const std::vector &metricScopes, + const std::vector &metricsInReport, + const std::vector &excludedMetrics) + : MetricCalcOpImp(multiDevice, metricScopes, metricsInReport, excludedMetrics) {} ze_result_t destroy() override { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; @@ -199,8 +201,8 @@ class MockMetricDeviceContext : public MetricDeviceContext { class MockMetricScope : public MetricScopeImp { public: ~MockMetricScope() override = default; - MockMetricScope(zet_intel_metric_scope_properties_exp_t &properties) - : MetricScopeImp(properties) {} + MockMetricScope(zet_intel_metric_scope_properties_exp_t &properties, bool aggregated) + : MetricScopeImp(properties, aggregated) {} ze_result_t getProperties(zet_intel_metric_scope_properties_exp_t *pProperties) override { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } 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 d3cded61c5..6610642e54 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 @@ -5,9 +5,11 @@ * */ +#include "shared/test/common/test_macros/hw_test.h" #include "shared/test/common/test_macros/test.h" #include "shared/test/common/test_macros/test_base.h" +#include "level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper.h" #include "level_zero/core/test/unit_tests/fixtures/device_fixture.h" #include "level_zero/include/level_zero/zet_intel_gpu_metric.h" #include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_source.h" @@ -50,7 +52,10 @@ class CalcOperationFixture : public DeviceFixture, void TearDown() override; MockMetricSource mockMetricSource{}; MockMetricGroup *mockMetricGroup; - zet_metric_group_handle_t phMetricGroup = nullptr; + zet_metric_group_handle_t hMetricGroup = nullptr; + + MockMetricScope *mockMetricScope; + zet_intel_metric_scope_exp_handle_t hMetricScope = nullptr; DebugManagerStateRestore restorer; }; @@ -58,12 +63,22 @@ class CalcOperationFixture : public DeviceFixture, void CalcOperationFixture::SetUp() { DeviceFixture::setUp(); mockMetricGroup = new MockMetricGroup(mockMetricSource); - phMetricGroup = mockMetricGroup->toHandle(); + hMetricGroup = mockMetricGroup->toHandle(); + + 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); + hMetricScope = mockMetricScope->toHandle(); } void CalcOperationFixture::TearDown() { DeviceFixture::tearDown(); delete mockMetricGroup; + delete mockMetricScope; + hMetricGroup = nullptr; + hMetricScope = nullptr; } TEST_F(CalcOperationFixture, WhenCreatingCalcOpAndInvalidParamsPassedThenErrorIsHandled) { @@ -71,14 +86,16 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpAndInvalidParamsPassedThenErrorIs // Aggregation window is zero zet_intel_metric_calculation_exp_desc_t calculationDesc{ ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP, - nullptr, // pNext - 0, // metricGroupCount - nullptr, // phMetricGroups - 0, // metricCount - nullptr, // phMetrics - 0, // timeWindowsCount - nullptr, // pCalculationTimeWindows - 0, // timeAggregationWindow + nullptr, // pNext + 1, // metricGroupCount + &hMetricGroup, // phMetricGroups + 0, // metricCount + nullptr, // phMetrics + 0, // timeWindowsCount + nullptr, // pCalculationTimeWindows + 0, // timeAggregationWindow + 1, // metricScopesCount + &hMetricScope, // phMetricScopes }; zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation; @@ -98,7 +115,7 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpWithMixedSourcesThenErrorIsReturn MockMetricGroup mockMetricGroup2(mockMetricSource2); // metric groups from different source - std::vector metricGroups{phMetricGroup, mockMetricGroup2.toHandle()}; + std::vector metricGroups{hMetricGroup, mockMetricGroup2.toHandle()}; zet_intel_metric_calculation_exp_desc_t calculationDesc{ ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP, nullptr, // pNext @@ -109,6 +126,8 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpWithMixedSourcesThenErrorIsReturn 0, // timeWindowsCount nullptr, // pCalculationTimeWindows 1000, // timeAggregationWindow + 1, // metricScopesCount + &hMetricScope, // phMetricScopes }; zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation; @@ -122,7 +141,7 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpWithMixedSourcesThenErrorIsReturn std::vector metrics{mockMetric.toHandle(), mockMetric2.toHandle()}; calculationDesc.metricGroupCount = 1; - calculationDesc.phMetricGroups = &phMetricGroup; + calculationDesc.phMetricGroups = &hMetricGroup; calculationDesc.metricCount = 2; calculationDesc.phMetrics = metrics.data(); EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculationOperationCreateExp(context, @@ -142,7 +161,7 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpWithMixedHierarchiesThenErrorIsRe mockMetricGroup2.isMultiDevice = true; // metric groups from different hierarchy - std::vector metricGroups{phMetricGroup, mockMetricGroup2.toHandle()}; + std::vector metricGroups{hMetricGroup, mockMetricGroup2.toHandle()}; zet_intel_metric_calculation_exp_desc_t calculationDesc{ ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP, nullptr, // pNext @@ -153,6 +172,8 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpWithMixedHierarchiesThenErrorIsRe 0, // timeWindowsCount nullptr, // pCalculationTimeWindows 1000, // timeAggregationWindow + 1, // metricScopesCount + &hMetricScope, // phMetricScopes }; zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation; @@ -166,7 +187,7 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpWithMixedHierarchiesThenErrorIsRe std::vector metrics{mockMetric.toHandle(), mockMetric2.toHandle()}; calculationDesc.metricGroupCount = 1; - calculationDesc.phMetricGroups = &phMetricGroup; + calculationDesc.phMetricGroups = &hMetricGroup; calculationDesc.metricCount = 2; calculationDesc.phMetrics = metrics.data(); EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculationOperationCreateExp(context, @@ -178,7 +199,7 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpUseTheSourceFromMetricGroupOrMetr MockMetricGroup mockMetricGroup2(mockMetricSource); - std::vector metricGroups{phMetricGroup, mockMetricGroup2.toHandle()}; + std::vector metricGroups{hMetricGroup, mockMetricGroup2.toHandle()}; zet_intel_metric_calculation_exp_desc_t calculationDesc{ ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP, nullptr, // pNext @@ -189,6 +210,8 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpUseTheSourceFromMetricGroupOrMetr 0, // timeWindowsCount nullptr, // pCalculationTimeWindows 1000, // timeAggregationWindow + 1, // metricScopesCount + &hMetricScope, // phMetricScopes }; zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation; @@ -210,10 +233,11 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpUseTheSourceFromMetricGroupOrMetr TEST_F(CalcOperationFixture, WhenCreatingCalcOpObjectToAndFromHandleBaseClassWorkAsExpected) { std::vector mockMetricsInReport{}; - uint32_t mockExcludedMetricCount = 0; std::vector mockExcludedMetrics{}; - MockMetricCalcOp mockMetricCalcOp(false, mockMetricsInReport, mockExcludedMetricCount, mockExcludedMetrics); + std::vector metricScopes{mockMetricScope}; + + MockMetricCalcOp mockMetricCalcOp(false, metricScopes, mockMetricsInReport, mockExcludedMetrics); auto hMockCalcOp = mockMetricCalcOp.toHandle(); EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetIntelMetricCalculationOperationDestroyExp(hMockCalcOp)); @@ -228,11 +252,12 @@ TEST_F(CalcOperationFixture, WhenGettingMetricsInReportAndExcludedMetricsThenThe mockMetricsInReport.push_back(&mockMetricInReport); std::vector mockExcludedMetrics{}; - uint32_t mockExcludedMetricCount = 1; MockMetric mockExcludedMetric(mockMetricSource); mockExcludedMetrics.push_back(&mockExcludedMetric); - MockMetricCalcOp mockMetricCalcOp(false, mockMetricsInReport, mockExcludedMetricCount, mockExcludedMetrics); + std::vector metricScopes{mockMetricScope}; + + MockMetricCalcOp mockMetricCalcOp(false, metricScopes, mockMetricsInReport, mockExcludedMetrics); uint32_t metricCount = 0; EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationGetReportFormatExp(mockMetricCalcOp.toHandle(), &metricCount, nullptr)); EXPECT_EQ(metricCount, 1U); @@ -390,7 +415,7 @@ TEST_F(MetricScopesFixture, MetricScopeObjectToAndFromHandleBaseClassWorkAsExpec scopeProperties.stype = ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP; scopeProperties.pNext = nullptr; - MockMetricScope mockMetricScope(scopeProperties); + MockMetricScope mockMetricScope(scopeProperties, false); auto hMockScope = mockMetricScope.toHandle(); EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetIntelMetricScopeGetPropertiesExp(hMockScope, @@ -399,5 +424,98 @@ TEST_F(MetricScopesFixture, MetricScopeObjectToAndFromHandleBaseClassWorkAsExpec EXPECT_NE(nullptr, mockScope); } +template +struct MockL0GfxCoreHelperSupportMetricsAggregation : L0::L0GfxCoreHelperHw { + bool supportMetricsAggregation() const override { return true; } +}; + +HWTEST_F(MetricScopesFixture, GivenMetricsAggregationIsSupportedConfirmAggregatedMetricScopeIsCreated) { + + MockL0GfxCoreHelperSupportMetricsAggregation mockL0GfxCoreHelper; + std::unique_ptr l0GfxCoreHelperBackup(static_cast(&mockL0GfxCoreHelper)); + device->getNEODevice()->getRootDeviceEnvironmentRef().apiGfxCoreHelper.swap(l0GfxCoreHelperBackup); + + auto mockDeviceContext = new MockMetricDeviceContext(*device); + mockDeviceContext->clearAllSources(); + auto metricSource = new MockMetricSource(); + metricSource->isAvailableReturn = true; + mockDeviceContext->setMockMetricSource(metricSource); + + auto deviceImp = static_cast(device); + deviceImp->metricContext.reset(mockDeviceContext); + mockDeviceContext->setMultiDeviceCapable(true); + + uint32_t metricScopesCount = 1; + zet_intel_metric_scope_exp_handle_t metricScope; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricScopesGetExp(context->toHandle(), + device->toHandle(), + &metricScopesCount, + &metricScope)); + + EXPECT_EQ(metricScopesCount, 1u); + 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(metricScope, + &scopeProperties)); + EXPECT_EQ(scopeProperties.iD, 0u); + EXPECT_STREQ(scopeProperties.name, "DEVICE_AGGREGATED"); + EXPECT_STREQ(scopeProperties.description, "Metrics results aggregated at device level"); + + device->getNEODevice()->getRootDeviceEnvironmentRef().apiGfxCoreHelper.swap(l0GfxCoreHelperBackup); + l0GfxCoreHelperBackup.release(); +} + +HWTEST_F(MetricScopesFixture, GivenMetricsAggregationIsSupportedWhenCreatingCalcOpAggregatedScopeShouldBeFirst) { + + MockL0GfxCoreHelperSupportMetricsAggregation mockL0GfxCoreHelper; + std::unique_ptr l0GfxCoreHelperBackup(static_cast(&mockL0GfxCoreHelper)); + device->getNEODevice()->getRootDeviceEnvironmentRef().apiGfxCoreHelper.swap(l0GfxCoreHelperBackup); + + auto mockDeviceContext = new MockMetricDeviceContext(*device); + mockDeviceContext->clearAllSources(); + auto metricSource = new MockMetricSource(); + metricSource->isAvailableReturn = true; + mockDeviceContext->setMockMetricSource(metricSource); + auto deviceImp = static_cast(device); + deviceImp->metricContext.reset(mockDeviceContext); + mockDeviceContext->setMultiDeviceCapable(true); + + uint32_t metricScopesCount = 1; + zet_intel_metric_scope_exp_handle_t metricScope; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricScopesGetExp(context->toHandle(), + device->toHandle(), + &metricScopesCount, + &metricScope)); + + MockMetricGroup mockMetricGroup(*metricSource); + mockMetricGroup.isMultiDevice = true; + zet_metric_group_handle_t hMetricGroup = mockMetricGroup.toHandle(); + + // 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 + 1, // metricScopesCount + &metricScope, // phMetricScopes + }; + + zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation; + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetIntelMetricCalculationOperationCreateExp(context->toHandle(), + device->toHandle(), &calculationDesc, + &hCalculationOperation)); + + device->getNEODevice()->getRootDeviceEnvironmentRef().apiGfxCoreHelper.swap(l0GfxCoreHelperBackup); + l0GfxCoreHelperBackup.release(); +} + } // namespace ult } // namespace L0 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 c0ec2258b7..b8f1a13485 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 @@ -17,6 +17,7 @@ #include "level_zero/tools/source/metrics/os_interface_metric.h" #include "level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.h" #include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_ip_sampling.h" +#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_source.h" #include namespace L0 { @@ -597,17 +598,8 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingMetricGroupThenCrea EXPECT_EQ(metricGroupCount, 1u); EXPECT_NE(metricGroupHandle, nullptr); - zet_intel_metric_calculation_exp_desc_t calculationDesc{ - ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP, - nullptr, // pNext - 1, // metricGroupCount - &metricGroupHandle, // phMetricGroups - 0, // metricCount - nullptr, // phMetrics - 0, // timeWindowsCount - nullptr, // pCalculationTimeWindows - 0, // timeAggregationWindow - }; + calculationDesc.metricGroupCount = 1; + calculationDesc.phMetricGroups = &metricGroupHandle; zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation; EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(), @@ -647,17 +639,9 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingMetricGroupCreating EXPECT_EQ(metricGroupCount, 1u); EXPECT_NE(metricGroupHandle, nullptr); - zet_intel_metric_calculation_exp_desc_t calculationDesc{ - ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP, - nullptr, // pNext - 1, // metricGroupCount - &metricGroupHandle, // phMetricGroups - 0, // metricCount - nullptr, // phMetrics - 0, // timeWindowsCount - nullptr, // pCalculationTimeWindows - 100, // timeAggregationWindow, ip samping ingores it. - }; + calculationDesc.metricGroupCount = 1; + calculationDesc.phMetricGroups = &metricGroupHandle; + calculationDesc.timeAggregationWindow = 1000; zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation; EXPECT_EQ(ZE_INTEL_RESULT_WARNING_TIME_PARAMS_IGNORED_EXP, @@ -694,17 +678,8 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingCalcOpCanGetReportF EXPECT_EQ(metricGroupCount, 1u); EXPECT_NE(metricGroupHandle, nullptr); - zet_intel_metric_calculation_exp_desc_t calculationDesc{ - ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP, - nullptr, // pNext - 1, // metricGroupCount - &metricGroupHandle, // phMetricGroups - 0, // metricCount - nullptr, // phMetrics - 0, // timeWindowsCount - nullptr, // pCalculationTimeWindows - 0, // timeAggregationWindow - }; + calculationDesc.metricGroupCount = 1; + calculationDesc.phMetricGroups = &metricGroupHandle; zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation; @@ -765,17 +740,8 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingCalcOpGetReportForm uint32_t metricsToCalculateCount = static_cast(metricsToCalculate.size()); EXPECT_EQ(metricsToCalculateCount, 5u); - zet_intel_metric_calculation_exp_desc_t calculationDesc{ - ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP, - nullptr, // pNext - 0, // metricGroupCount - nullptr, // phMetricGroups - metricsToCalculateCount, // metricCount - metricsToCalculate.data(), // phMetrics - 0, // timeWindowsCount - nullptr, // pCalculationTimeWindows - 0, // timeAggregationWindow - }; + calculationDesc.metricCount = metricsToCalculateCount; + calculationDesc.phMetrics = metricsToCalculate.data(); zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation; EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(), @@ -812,17 +778,8 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingCalcOpCanGetExclude EXPECT_EQ(metricGroupCount, 1u); EXPECT_NE(metricGroupHandle, nullptr); - zet_intel_metric_calculation_exp_desc_t calculationDesc{ - ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP, - nullptr, // pNext - 1, // metricGroupCount - &metricGroupHandle, // phMetricGroups - 0, // metricCount - nullptr, // phMetrics - 0, // timeWindowsCount - nullptr, // pCalculationTimeWindows - 0, // timeAggregationWindow - }; + calculationDesc.metricGroupCount = 1; + calculationDesc.phMetricGroups = &metricGroupHandle; zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation; @@ -869,9 +826,12 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, WhenReadingMetricGroupTimeCalculat } } -using MetricIpSamplingCalcOpTest = MetricIpSamplingCalculateSingleDevFixture; +HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, GivenIpSamplingCalcOpCallingMetricCalculateValuesOnRootDeviceExpectSuccess, EustallSupportedPlatforms) { -HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculateValuesOnSubDeviceThenSuccessIsReturned, EustallSupportedPlatforms) { + auto device = testDevices[0]; + ze_device_properties_t props = {}; + device->getProperties(&props); + EXPECT_EQ(props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE, 0u); EXPECT_EQ(ZE_RESULT_SUCCESS, device->getMetricDeviceContext().enableMetricApi()); @@ -881,17 +841,34 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat EXPECT_EQ(metricGroupCount, 1u); EXPECT_NE(metricGroupHandle, nullptr); - zet_intel_metric_calculation_exp_desc_t calculationDesc{ - ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP, - nullptr, // pNext - 1, // metricGroupCount - &metricGroupHandle, // phMetricGroups - 0, // metricCount - nullptr, // phMetrics - 0, // timeWindowsCount - nullptr, // pCalculationTimeWindows - 0, // timeAggregationWindow - }; + calculationDesc.metricGroupCount = 1; + calculationDesc.phMetricGroups = &metricGroupHandle; + + zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation; + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(), + device->toHandle(), &calculationDesc, + &hCalculationOperation)); + + std::vector rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader)); + addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(rawDataVector.data()), rawDataVectorSize, 0); + + uint32_t totalMetricReportCount = 0; + size_t offset = 0; + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetIntelMetricCalculateValuesExp(rawDataWithHeader.size(), &offset, + reinterpret_cast(rawDataWithHeader.data()), hCalculationOperation, + &totalMetricReportCount, nullptr)); + + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateValuesExp(rawDataVectorSize, &offset, + reinterpret_cast(rawDataVector.data()), hCalculationOperation, + &totalMetricReportCount, nullptr)); + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalculationOperation)); +} + +using MetricIpSamplingCalcOpTest = MetricIpSamplingCalculateSingleDevFixture; + +HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculateValuesOnSubDeviceThenSuccessIsReturned, EustallSupportedPlatforms) { zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation; EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(), @@ -937,26 +914,6 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculateValuesOnSubDeviceThenHandleErrorConditions, EustallSupportedPlatforms) { - 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); - - zet_intel_metric_calculation_exp_desc_t calculationDesc{ - ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP, - nullptr, // pNext - 1, // metricGroupCount - &metricGroupHandle, // phMetricGroups - 0, // metricCount - nullptr, // phMetrics - 0, // timeWindowsCount - nullptr, // pCalculationTimeWindows - 0, // timeAggregationWindow - }; - zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation; EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(), @@ -983,26 +940,6 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculateValuesOnSubDeviceCanDetectRawDataOverflow, EustallSupportedPlatforms) { - 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); - - zet_intel_metric_calculation_exp_desc_t calculationDesc{ - ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP, - nullptr, // pNext - 1, // metricGroupCount - &metricGroupHandle, // phMetricGroups - 0, // metricCount - nullptr, // phMetrics - 0, // timeWindowsCount - nullptr, // pCalculationTimeWindows - 0, // timeAggregationWindow - }; - zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation; EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(), device->toHandle(), &calculationDesc, @@ -1022,14 +959,6 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculateValuesOnSubDeviceFilterMetricsInReport, EustallSupportedPlatforms) { - 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); - uint32_t metricCount = 0; EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, nullptr), ZE_RESULT_SUCCESS); EXPECT_EQ(metricCount, 10u); @@ -1049,17 +978,10 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat uint32_t metricsToCalculateCount = static_cast(metricsToCalculate.size()); EXPECT_EQ(metricsToCalculateCount, 5u); - zet_intel_metric_calculation_exp_desc_t calculationDesc{ - ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP, - nullptr, // pNext - 0, // metricGroupCount - nullptr, // phMetricGroups - metricsToCalculateCount, // metricCount - metricsToCalculate.data(), // phMetrics - 0, // timeWindowsCount - nullptr, // pCalculationTimeWindows - 0, // timeAggregationWindow - }; + calculationDesc.metricGroupCount = 0; + calculationDesc.phMetricGroups = nullptr; + calculationDesc.metricCount = metricsToCalculateCount; + calculationDesc.phMetrics = metricsToCalculate.data(); zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation; @@ -1093,24 +1015,6 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculateValuesDoesNotAllowLimitingResults, EustallSupportedPlatforms) { - 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); - - zet_intel_metric_calculation_exp_desc_t calculationDesc{ - ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP, - nullptr, // pNext - metricGroupCount, // metricGroupCount - &metricGroupHandle, // phMetricGroups - 0, // metricCount - nullptr, // phMetrics - 0, // timeWindowsCount - nullptr, // pCalculationTimeWindows - 0, // timeAggregationWindow - }; - zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation; EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(), device->toHandle(), &calculationDesc, @@ -1132,54 +1036,5 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalculationOperation)); } -HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, GivenIpSamplingCalcOpCallingMetricCalculateValuesOnRootDeviceExpectSuccess, EustallSupportedPlatforms) { - - auto device = testDevices[0]; - ze_device_properties_t props = {}; - device->getProperties(&props); - EXPECT_EQ(props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE, 0u); - - 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); - - zet_intel_metric_calculation_exp_desc_t calculationDesc{ - ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP, - nullptr, // pNext - 1, // metricGroupCount - &metricGroupHandle, // phMetricGroups - 0, // metricCount - nullptr, // phMetrics - 0, // timeWindowsCount - nullptr, // pCalculationTimeWindows - 0, // timeAggregationWindow - }; - - zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation; - - EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(), - device->toHandle(), &calculationDesc, - &hCalculationOperation)); - - std::vector rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader)); - addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(rawDataVector.data()), rawDataVectorSize, 0); - - uint32_t totalMetricReportCount = 0; - size_t offset = 0; - EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetIntelMetricCalculateValuesExp(rawDataWithHeader.size(), &offset, - reinterpret_cast(rawDataWithHeader.data()), hCalculationOperation, - &totalMetricReportCount, nullptr)); - - EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateValuesExp(rawDataVectorSize, &offset, - reinterpret_cast(rawDataVector.data()), hCalculationOperation, - &totalMetricReportCount, nullptr)); - - EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalculationOperation)); -} - } // namespace ult } // namespace L0 diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_1.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_1.cpp index f6355e0490..d17e71798b 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_1.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_1.cpp @@ -3688,6 +3688,13 @@ TEST_F(MetricEnumerationTest, givenValidOAMetricGroupThenOASourceCalcOperationIs EXPECT_EQ(metricGroupCount, 1u); EXPECT_NE(metricGroupHandle, nullptr); + 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); + auto hMockScope = mockMetricScope.toHandle(); + // metric groups from different source zet_intel_metric_calculation_exp_desc_t calculationDesc{ ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP, @@ -3699,6 +3706,8 @@ TEST_F(MetricEnumerationTest, givenValidOAMetricGroupThenOASourceCalcOperationIs 0, // timeWindowsCount nullptr, // pCalculationTimeWindows 1000, // timeAggregationWindow + 1, // metricScopesCount + &hMockScope, // phMetricScopes }; zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;