diff --git a/level_zero/tools/source/metrics/metric.cpp b/level_zero/tools/source/metrics/metric.cpp index 9fca528f18..60dbc8f3d2 100644 --- a/level_zero/tools/source/metrics/metric.cpp +++ b/level_zero/tools/source/metrics/metric.cpp @@ -531,12 +531,14 @@ ze_result_t MetricDeviceContext::calcOperationCreate(zet_context_handle_t hConte METRICS_LOG_ERR("%s", "Metrics must be from the same domain"); return ZE_RESULT_ERROR_INVALID_ARGUMENT; } - if (!areMetricsFromSameDeviceHierarchy(pCalculateDesc->metricCount, pCalculateDesc->phMetrics)) { + + metricImp = static_cast(Metric::fromHandle(pCalculateDesc->phMetrics[0])); + // IpSampling does not use multi-device metrics + if ((metricImp->getMetricSource().getType() != MetricSource::metricSourceTypeIpSampling) && + (!areMetricsFromSameDeviceHierarchy(pCalculateDesc->metricCount, pCalculateDesc->phMetrics))) { METRICS_LOG_ERR("%s", "Mix of root device and sub-device metric handle is not allowed"); return ZE_RESULT_ERROR_INVALID_ARGUMENT; } - - metricImp = static_cast(Metric::fromHandle(pCalculateDesc->phMetrics[0])); } if (pCalculateDesc->metricGroupCount > 0) { 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 d338b2e58f..b8e83bf55e 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_source.cpp +++ b/level_zero/tools/source/metrics/metric_ip_sampling_source.cpp @@ -243,6 +243,22 @@ ze_result_t IpSamplingMetricSourceImp::handleMetricGroupExtendedProperties(zet_m return retVal; } +ze_result_t IpSamplingMetricSourceImp::calcOperationCreate(MetricDeviceContext &metricDeviceContext, + zet_intel_metric_calculate_exp_desc_t *pCalculateDesc, + uint32_t *pCount, + zet_metric_handle_t *phExcludedMetrics, + zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation) { + ze_result_t status = ZE_RESULT_ERROR_UNKNOWN; + + // All metrics in Ip sampling allow calculation + *pCount = 0; + *phExcludedMetrics = nullptr; + + bool isMultiDevice = (metricDeviceContext.isImplicitScalingCapable()) ? true : false; + status = IpSamplingMetricCalcOpImp::create(*this, pCalculateDesc, isMultiDevice, phCalculateOperation); + return status; +} + IpSamplingMetricGroupImp::IpSamplingMetricGroupImp(IpSamplingMetricSourceImp &metricSource, std::vector &metrics) : IpSamplingMetricGroupBase(metricSource) { this->metrics.reserve(metrics.size()); 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 ef728cea33..3d883d9fb1 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_source.h +++ b/level_zero/tools/source/metrics/metric_ip_sampling_source.h @@ -61,9 +61,7 @@ class IpSamplingMetricSourceImp : public MetricSource { zet_intel_metric_calculate_exp_desc_t *pCalculateDesc, uint32_t *pCount, zet_metric_handle_t *phExcludedMetrics, - zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation) override { - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; - } + zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation) 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 bf19bf73e9..4b0ce63189 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_streamer.cpp +++ b/level_zero/tools/source/metrics/metric_ip_sampling_streamer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2022-2023 Intel Corporation + * Copyright (C) 2022-2025 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -13,6 +13,7 @@ #include "level_zero/tools/source/metrics/os_interface_metric.h" #include +#include #include namespace L0 { @@ -94,6 +95,48 @@ uint32_t IpSamplingMetricStreamerImp::getMaxSupportedReportCount() { return ipSamplingSource.getMetricOsInterface()->getRequiredBufferSize(UINT32_MAX) / unitReportSize; } +ze_result_t IpSamplingMetricCalcOpImp::create(IpSamplingMetricSourceImp &metricSource, + zet_intel_metric_calculate_exp_desc_t *pCalculateDesc, + bool isMultiDevice, + zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation) { + + // There is only one valid metric group in IP sampling and time filtering is not supported + // So only metrics handles are used to filter the metrics + + // avoid duplicates + std::set uniqueMetricHandles(pCalculateDesc->phMetrics, pCalculateDesc->phMetrics + pCalculateDesc->metricCount); + + // The order of metrics in the report should be the same as the one in the HW report to optimize calculation + uint32_t metricGroupCount = 1; + zet_metric_group_handle_t hMetricGroup = {}; + metricSource.metricGroupGet(&metricGroupCount, &hMetricGroup); + uint32_t metricCount = 0; + MetricGroup::fromHandle(hMetricGroup)->metricGet(&metricCount, nullptr); + std::vector hMetrics(metricCount); + MetricGroup::fromHandle(hMetricGroup)->metricGet(&metricCount, hMetrics.data()); + std::vector inputMetricsInReport = {}; + + for (uint32_t i = 0; i < metricCount; i++) { + auto metric = static_cast(Metric::fromHandle(hMetrics[i])); + if (pCalculateDesc->metricGroupCount > 0) { + inputMetricsInReport.push_back(metric); + } else { + if (uniqueMetricHandles.find(hMetrics[i]) != uniqueMetricHandles.end()) { + inputMetricsInReport.push_back(metric); + } + } + } + + auto calcOp = new IpSamplingMetricCalcOpImp(inputMetricsInReport, isMultiDevice); + *phCalculateOperation = calcOp->toHandle(); + return ZE_RESULT_SUCCESS; +} + +ze_result_t IpSamplingMetricCalcOpImp::destroy() { + delete this; + return ZE_RESULT_SUCCESS; +} + ze_result_t MultiDeviceIpSamplingMetricGroupImp::streamerOpen( zet_context_handle_t hContext, zet_device_handle_t hDevice, 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 ca8eb36b4f..94cbc923c5 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_streamer.h +++ b/level_zero/tools/source/metrics/metric_ip_sampling_streamer.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2022-2023 Intel Corporation + * Copyright (C) 2022-2025 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -13,6 +13,7 @@ namespace L0 { class IpSamplingMetricSourceImp; +struct IpSamplingMetricImp; struct IpSamplingMetricStreamerBase : public MetricStreamer { ze_result_t appendStreamerMarker(CommandList &commandList, uint32_t value) override { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } @@ -43,4 +44,33 @@ struct MultiDeviceIpSamplingMetricStreamerImp : public IpSamplingMetricStreamerB std::vector subDeviceStreamers = {}; }; +struct IpSamplingMetricCalcOpImp : public MetricCalcOpImp { + IpSamplingMetricCalcOpImp(std::vector &inputMetricsInReport, + bool multidevice) : MetricCalcOpImp(multidevice), + metricCount(static_cast(inputMetricsInReport.size())), + metricsInReport(inputMetricsInReport) {} + + ~IpSamplingMetricCalcOpImp() override{}; + static ze_result_t create(IpSamplingMetricSourceImp &metricSource, + zet_intel_metric_calculate_exp_desc_t *pCalculateDesc, + bool isMultiDevice, + zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation); + ze_result_t destroy() override; + ze_result_t getReportFormat(uint32_t *pCount, zet_metric_handle_t *phMetrics) override { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + } + std::vector &getMetricsInReport() { return metricsInReport; }; + uint32_t getMetricsInReportCount() { return metricCount; }; + ze_result_t metricCalculateMultipleValues(size_t rawDataSize, size_t *offset, const uint8_t *pRawData, + uint32_t *pSetCount, uint32_t *pMetricsReportCountPerSet, + uint32_t *pTotalMetricReportCount, + zet_intel_metric_result_exp_t *pMetricResults) override { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + } + + protected: + uint32_t metricCount = 0; + std::vector metricsInReport{}; +}; + } // namespace L0 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 834d8f76be..27da1e87e0 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 @@ -18,7 +18,7 @@ extern std::vector<_ze_driver_handle_t *> *globalDriverHandles; namespace ult { -void MetricIpSamplingFixture::SetUp() { +void MetricIpSamplingMultiDevFixture::SetUp() { debugManager.flags.EnableImplicitScaling.set(1); @@ -51,12 +51,12 @@ void MetricIpSamplingFixture::SetUp() { globalDriverHandles->push_back(driverHandle.get()); } -void MetricIpSamplingFixture::TearDown() { +void MetricIpSamplingMultiDevFixture::TearDown() { MultiDeviceFixture::tearDown(); globalDriverHandles->clear(); } -void MetricIpSamplingTimestampFixture::SetUp() { +void MetricIpSamplingFixture::SetUp() { DeviceFixture::setUp(); auto mockMetricIpSamplingOsInterface = new MockMetricIpSamplingOsInterface(); osInterfaceVector.push_back(mockMetricIpSamplingOsInterface); @@ -71,7 +71,7 @@ void MetricIpSamplingTimestampFixture::SetUp() { globalDriverHandles->push_back(driverHandle.get()); } -void MetricIpSamplingTimestampFixture::TearDown() { +void MetricIpSamplingFixture::TearDown() { DeviceFixture::tearDown(); globalDriverHandles->clear(); } 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 d86706e94f..a9e4ab2793 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 @@ -1,5 +1,5 @@ /* - * Copyright (C) 2022-2024 Intel Corporation + * Copyright (C) 2022-2025 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -59,8 +59,8 @@ class MockStallRawIpData { rawData[7] = 0; } }; -class MetricIpSamplingFixture : public MultiDeviceFixture, - public ::testing::Test { +class MetricIpSamplingMultiDevFixture : public MultiDeviceFixture, + public ::testing::Test { public: void SetUp() override; void TearDown() override; @@ -69,8 +69,8 @@ class MetricIpSamplingFixture : public MultiDeviceFixture, std::vector testDevices = {}; }; -class MetricIpSamplingTimestampFixture : public DeviceFixture, - public ::testing::Test { +class MetricIpSamplingFixture : public DeviceFixture, + public ::testing::Test { public: void SetUp() override; void TearDown() override; @@ -79,7 +79,7 @@ class MetricIpSamplingTimestampFixture : public DeviceFixture, std::vector osInterfaceVector = {}; }; -class MetricIpSamplingCalculateMetricsFixture : public MetricIpSamplingFixture { +class MetricIpSamplingCalculateMetricsFixture : public MetricIpSamplingMultiDevFixture { public: void addHeader(uint8_t *rawDataOut, size_t rawDataOutSize, uint8_t *rawDataIn, size_t rawDataInSize, uint32_t setIndex) { diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_enumeration.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_enumeration.cpp index bd7e8aa59e..ed374a34d2 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_enumeration.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_enumeration.cpp @@ -12,9 +12,11 @@ #include "level_zero/core/source/cmdlist/cmdlist.h" #include "level_zero/core/test/unit_tests/fixtures/device_fixture.h" #include "level_zero/tools/source/metrics/metric_ip_sampling_source.h" +#include "level_zero/tools/source/metrics/metric_ip_sampling_streamer.h" #include "level_zero/tools/source/metrics/metric_oa_source.h" #include "level_zero/tools/source/metrics/os_interface_metric.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 "level_zero/zet_intel_gpu_metric.h" #include "level_zero/zet_intel_gpu_metric_export.h" #include @@ -26,7 +28,7 @@ extern _ze_driver_handle_t *globalDriverHandle; namespace ult { -using MetricIpSamplingEnumerationTest = MetricIpSamplingFixture; +using MetricIpSamplingEnumerationTest = MetricIpSamplingMultiDevFixture; HWTEST2_F(MetricIpSamplingEnumerationTest, GivenDependenciesAvailableWhenInititializingThenSuccessIsReturned, EustallSupportedPlatforms) { @@ -428,7 +430,7 @@ HWTEST2_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulOnMulitDe } } -using MetricIpSamplingTimestampTest = MetricIpSamplingTimestampFixture; +using MetricIpSamplingTimestampTest = MetricIpSamplingFixture; HWTEST2_F(MetricIpSamplingTimestampTest, GivenEnumerationIsSuccessfulWhenReadingMetricsFrequencyThenValuesAreUpdated, EustallSupportedPlatforms) { @@ -1130,6 +1132,136 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWith } } +using MetricIpSamplingCalcOpTest = MetricIpSamplingMultiDevFixture; + +HWTEST2_F(MetricIpSamplingCalcOpTest, givenIpSamplingMetricGroupThenCreateAndDestroyCalcOpIsSuccessful, EustallSupportedPlatforms) { + + EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi()); + + for (auto device : testDevices) { + + ze_device_properties_t props = {}; + device->getProperties(&props); + + 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_calculate_exp_desc_t calculateDesc{ + ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATE_DESC_EXP, + nullptr, // pNext + 1, // metricGroupCount + &metricGroupHandle, // phMetricGroups + 0, // metricCount + nullptr, // phMetrics + 0, // timeWindowsCount + nullptr, // pCalculateTimeWindows + 1000, // timeAggregationWindow + }; + + zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation; + uint32_t excludedMetricsCount = 0; + zet_metric_handle_t phExcludedMetrics; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationCreateExp(context->toHandle(), + device->toHandle(), &calculateDesc, + &excludedMetricsCount, &phExcludedMetrics, + &hCalculateOperation)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation)); + + uint32_t metricCount = 0; + EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, nullptr), ZE_RESULT_SUCCESS); + EXPECT_EQ(metricCount, 10u); + zet_metric_handle_t phMetric{}; + metricCount = 1; + EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, &phMetric), ZE_RESULT_SUCCESS); + + calculateDesc.metricGroupCount = 0; + calculateDesc.metricCount = 1; + calculateDesc.phMetrics = &phMetric; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationCreateExp(context->toHandle(), + device->toHandle(), &calculateDesc, + &excludedMetricsCount, &phExcludedMetrics, + &hCalculateOperation)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation)); + } +} +HWTEST2_F(MetricIpSamplingCalcOpTest, givenIpSamplingCalcOpCheckUnsupportedAPIs, EustallSupportedPlatforms) { + + EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi()); + + for (auto device : testDevices) { + + uint32_t metricGroupCount = 1; + zet_metric_group_handle_t metricGroupHandle = nullptr; + EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS); + EXPECT_EQ(metricGroupCount, 1u); + EXPECT_NE(metricGroupHandle, nullptr); + + zet_intel_metric_calculate_exp_desc_t calculateDesc{ + ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATE_DESC_EXP, + nullptr, // pNext + 1, // metricGroupCount + &metricGroupHandle, // phMetricGroups + 0, // metricCount + nullptr, // phMetrics + 0, // timeWindowsCount + nullptr, // pCalculateTimeWindows + 1000, // timeAggregationWindow + }; + + zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation; + uint32_t excludedMetricsCount = 0; + zet_metric_handle_t phExcludedMetrics; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationCreateExp(context->toHandle(), + device->toHandle(), &calculateDesc, + &excludedMetricsCount, &phExcludedMetrics, + &hCalculateOperation)); + auto calcOpImp = static_cast(MetricCalcOp::fromHandle(hCalculateOperation)); + uint32_t count; + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, calcOpImp->getReportFormat(&count, nullptr)); + std::vector metricsInReport = calcOpImp->getMetricsInReport(); + EXPECT_EQ(10U, metricsInReport.size()); + uint32_t metricsInReportCount = calcOpImp->getMetricsInReportCount(); + EXPECT_EQ(10U, metricsInReportCount); + size_t rawDataSize = 0; + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, calcOpImp->metricCalculateMultipleValues(rawDataSize, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation)); + } +} + +HWTEST2_F(MetricIpSamplingCalcOpTest, WhenReadingMetricGroupTimeCalculateFilterThenCorrectValueIsReturned, EustallSupportedPlatforms) { + + EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi()); + + for (auto device : testDevices) { + + uint32_t metricGroupCount = 0; + zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr); + EXPECT_EQ(metricGroupCount, 1u); + + std::vector metricGroups; + metricGroups.resize(metricGroupCount); + + ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS); + ASSERT_NE(metricGroups[0], nullptr); + + zet_intel_metric_group_calculate_properties_exp_t metricGroupCalcProps{}; + metricGroupCalcProps.stype = ZET_INTEL_STRUCTURE_TYPE_METRIC_GROUP_CALCULATE_EXP_PROPERTIES; + metricGroupCalcProps.pNext = nullptr; + metricGroupCalcProps.isTimeFilterSupported = true; + + zet_metric_group_properties_t properties{}; + properties.pNext = &metricGroupCalcProps; + + EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &properties), ZE_RESULT_SUCCESS); + EXPECT_EQ(strcmp(properties.description, "EU stall sampling"), 0); + EXPECT_EQ(strcmp(properties.name, "EuStallSampling"), 0); + EXPECT_EQ(metricGroupCalcProps.isTimeFilterSupported, false); + } +} + HWTEST2_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulWhenQueryPoolCreateIsCalledThenUnsupportedFeatureIsReturned, EustallSupportedPlatforms) { EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi()); @@ -1163,7 +1295,7 @@ HWTEST2_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulWhenAppen EXPECT_EQ(zetCommandListAppendMetricMemoryBarrier(commandListHandle), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE); } -using MetricExportDataIpSamplingTest = MetricIpSamplingEnumerationTest; +using MetricExportDataIpSamplingTest = MetricIpSamplingMultiDevFixture; HWTEST2_F(MetricExportDataIpSamplingTest, WhenMetricGroupGetExportDataIsCalledThenReturnSuccess, EustallSupportedPlatforms) { @@ -1297,70 +1429,5 @@ HWTEST2_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulWhenUnsup } } -HWTEST2_F(MetricIpSamplingEnumerationTest, givenValidIPSamplingMetricGroupThenOASourceCalcOperationIsCalled, EustallSupportedPlatforms) { - - EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi()); - - uint32_t metricGroupCount = 1; - zet_metric_group_handle_t metricGroupHandle = nullptr; - EXPECT_EQ(zetMetricGroupGet(testDevices[0]->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS); - EXPECT_EQ(metricGroupCount, 1u); - EXPECT_NE(metricGroupHandle, nullptr); - - // metric groups from different source - zet_intel_metric_calculate_exp_desc_t calculateDesc{ - ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATE_DESC_EXP, - nullptr, // pNext - 1, // metricGroupCount - &metricGroupHandle, // phMetricGroups - 0, // metricCount - nullptr, // phMetrics - 0, // timeWindowsCount - nullptr, // pCalculateTimeWindows - 1000, // timeAggregationWindow - }; - - zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation; - uint32_t excludedMetricsCount = 0; - zet_metric_handle_t *phExcludedMetrics = nullptr; - EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetIntelMetricCalculateOperationCreateExp(context->toHandle(), - testDevices[0]->toHandle(), &calculateDesc, - &excludedMetricsCount, phExcludedMetrics, - &hCalculateOperation)); -} -HWTEST2_F(MetricIpSamplingEnumerationTest, WhenReadingMetricGroupTimeCalculateFilterThenCorrectValueIsReturned, EustallSupportedPlatforms) { - - EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi()); - - for (auto device : testDevices) { - - ze_device_properties_t deviceProps = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES_1_2, nullptr}; - device->getProperties(&deviceProps); - - uint32_t metricGroupCount = 0; - zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr); - EXPECT_EQ(metricGroupCount, 1u); - - std::vector metricGroups; - metricGroups.resize(metricGroupCount); - - ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS); - ASSERT_NE(metricGroups[0], nullptr); - - zet_intel_metric_group_calculate_properties_exp_t metricGroupCalcProps{}; - metricGroupCalcProps.stype = ZET_INTEL_STRUCTURE_TYPE_METRIC_GROUP_CALCULATE_EXP_PROPERTIES; - metricGroupCalcProps.pNext = nullptr; - metricGroupCalcProps.isTimeFilterSupported = true; - - zet_metric_group_properties_t properties{}; - properties.pNext = &metricGroupCalcProps; - - EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &properties), ZE_RESULT_SUCCESS); - EXPECT_EQ(strcmp(properties.description, "EU stall sampling"), 0); - EXPECT_EQ(strcmp(properties.name, "EuStallSampling"), 0); - EXPECT_EQ(metricGroupCalcProps.isTimeFilterSupported, false); - } -} - } // 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 5dc10b5f4a..e5847a28f5 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 @@ -1,5 +1,5 @@ /* - * Copyright (C) 2022-2024 Intel Corporation + * Copyright (C) 2022-2025 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -21,7 +21,7 @@ extern _ze_driver_handle_t *globalDriverHandle; namespace ult { -class MetricIpSamplingStreamerTest : public MetricIpSamplingFixture { +class MetricIpSamplingStreamerTest : public MetricIpSamplingMultiDevFixture { public: zet_metric_group_handle_t getMetricGroup(L0::Device *device) {