diff --git a/level_zero/api/driver_experimental/public/zex_metric.cpp b/level_zero/api/driver_experimental/public/zex_metric.cpp index 7d98f80263..02a6bc06e9 100644 --- a/level_zero/api/driver_experimental/public/zex_metric.cpp +++ b/level_zero/api/driver_experimental/public/zex_metric.cpp @@ -80,22 +80,28 @@ ze_result_t ZE_APICALL zetIntelMetricTracerDecodeExp(zet_intel_metric_decoder_ex ze_result_t ZE_APICALL zetIntelMetricCalculateOperationCreateExp(zet_context_handle_t hContext, zet_device_handle_t hDevice, zet_intel_metric_calculate_exp_desc_t *pCalculateDesc, - uint32_t *pExcludedMetricCount, zet_metric_handle_t *phExcludedMetrics, zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation) { - return L0::metricCalculateOperationCreate(hContext, hDevice, pCalculateDesc, pExcludedMetricCount, phExcludedMetrics, phCalculateOperation); + return L0::metricCalculateOperationCreate(hContext, hDevice, pCalculateDesc, phCalculateOperation); } ze_result_t ZE_APICALL zetIntelMetricCalculateOperationDestroyExp(zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation) { return L0::metricCalculateOperationDestroy(hCalculateOperation); } -ze_result_t ZE_APICALL zetIntelMetricCalculateGetReportFormatExp( +ze_result_t ZE_APICALL zetIntelMetricCalculateOperationGetReportFormatExp( zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation, uint32_t *pCount, zet_metric_handle_t *phMetrics) { return L0::metricCalculateGetReportFormat(hCalculateOperation, pCount, phMetrics); } +ze_result_t ZE_APICALL zetIntelMetricCalculateOperationGetExcludedMetricsExp( + zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation, + uint32_t *pCount, + zet_metric_handle_t *phMetrics) { + return L0::metricCalculateGetExcludedMetrics(hCalculateOperation, pCount, phMetrics); +} + ze_result_t ZE_APICALL zetIntelMetricCalculateValuesExp(const size_t rawDataSize, size_t *pOffset, const uint8_t *pRawData, zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation, uint32_t *pTotalMetricReportsCount, zet_intel_metric_result_exp_t *pMetricResults) { @@ -217,10 +223,8 @@ ze_result_t ZE_APICALL zetIntelMetricCalculateOperationCreateExp( zet_context_handle_t hContext, zet_device_handle_t hDevice, zet_intel_metric_calculate_exp_desc_t *pCalculateDesc, - uint32_t *pExcludedMetricCount, - zet_metric_handle_t *phExcludedMetrics, zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation) { - return L0::zetIntelMetricCalculateOperationCreateExp(hContext, hDevice, pCalculateDesc, pExcludedMetricCount, phExcludedMetrics, phCalculateOperation); + return L0::zetIntelMetricCalculateOperationCreateExp(hContext, hDevice, pCalculateDesc, phCalculateOperation); } ze_result_t ZE_APICALL zetIntelMetricCalculateOperationDestroyExp( @@ -228,11 +232,18 @@ ze_result_t ZE_APICALL zetIntelMetricCalculateOperationDestroyExp( return L0::zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation); } -ze_result_t ZE_APICALL zetIntelMetricCalculateGetReportFormatExp( +ze_result_t ZE_APICALL zetIntelMetricCalculateOperationGetReportFormatExp( zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation, uint32_t *pCount, zet_metric_handle_t *phMetrics) { - return L0::zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation, pCount, phMetrics); + return L0::zetIntelMetricCalculateOperationGetReportFormatExp(hCalculateOperation, pCount, phMetrics); +} + +ze_result_t ZE_APICALL zetIntelMetricCalculateOperationGetExcludedMetricsExp( + zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation, + uint32_t *pCount, + zet_metric_handle_t *phMetrics) { + return L0::zetIntelMetricCalculateOperationGetExcludedMetricsExp(hCalculateOperation, pCount, phMetrics); } ze_result_t ZE_APICALL zetIntelMetricCalculateValuesExp(const size_t rawDataSize, size_t *pOffset, const uint8_t *pRawData, zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation, diff --git a/level_zero/core/source/driver/extension_function_address.cpp b/level_zero/core/source/driver/extension_function_address.cpp index 1facd995fb..7b8e6a4c29 100644 --- a/level_zero/core/source/driver/extension_function_address.cpp +++ b/level_zero/core/source/driver/extension_function_address.cpp @@ -119,7 +119,8 @@ void *ExtensionFunctionAddressHelper::getExtensionFunctionAddress(const std::str RETURN_FUNC_PTR_IF_EXIST(zetIntelMetricTracerDecodeExp); RETURN_FUNC_PTR_IF_EXIST(zetIntelMetricCalculateOperationCreateExp); RETURN_FUNC_PTR_IF_EXIST(zetIntelMetricCalculateOperationDestroyExp); - RETURN_FUNC_PTR_IF_EXIST(zetIntelMetricCalculateGetReportFormatExp); + RETURN_FUNC_PTR_IF_EXIST(zetIntelMetricCalculateOperationGetExcludedMetricsExp); + RETURN_FUNC_PTR_IF_EXIST(zetIntelMetricCalculateOperationGetReportFormatExp); RETURN_FUNC_PTR_IF_EXIST(zetIntelMetricDecodeCalculateMultipleValuesExp); RETURN_FUNC_PTR_IF_EXIST(zetIntelMetricCalculateMultipleValuesExp); RETURN_FUNC_PTR_IF_EXIST(zetIntelMetricCalculateValuesExp); diff --git a/level_zero/include/level_zero/zet_intel_gpu_metric.h b/level_zero/include/level_zero/zet_intel_gpu_metric.h index eabff2bf2e..069d07e8c6 100644 --- a/level_zero/include/level_zero/zet_intel_gpu_metric.h +++ b/level_zero/include/level_zero/zet_intel_gpu_metric.h @@ -199,7 +199,8 @@ ze_result_t ZE_APICALL zetIntelMetricTracerDecodeExp( typedef enum _zet_intel_metric_calculate_exp_version_t { ZET_INTEL_METRIC_CALCULATE_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0), ///< version 1.0 ZET_INTEL_METRIC_CALCULATE_EXP_VERSION_2_0 = ZE_MAKE_VERSION(2, 0), - ZET_INTEL_METRIC_CALCULATE_EXP_VERSION_CURRENT = ZET_INTEL_METRIC_CALCULATE_EXP_VERSION_2_0, ///< latest known version + ZET_INTEL_METRIC_CALCULATE_EXP_VERSION_3_0 = ZE_MAKE_VERSION(3, 0), + ZET_INTEL_METRIC_CALCULATE_EXP_VERSION_CURRENT = ZET_INTEL_METRIC_CALCULATE_EXP_VERSION_3_0, ///< latest known version ZET_INTEL_METRIC_CALCULATE_EXP_VERSION_FORCE_UINT32 = 0x7fffffff } zet_intel_metric_calculate_exp_version_t; @@ -285,17 +286,13 @@ zetIntelMetricCalculateOperationCreateExp( zet_device_handle_t hDevice, ///< [in] handle of the device zet_intel_metric_calculate_exp_desc_t *pCalculateDesc, ///< [in] pointer to structure with filters and operations to perform ///< at calculation time. - uint32_t *pExcludedMetricCount, ///< [out] pointer to number of excluded metrics. These are metrics in the - ///< input list in pcalculateDesc that do not allow calculation - zet_metric_handle_t *phExcludedMetrics, ///< [in,out] [range(0, *pCount)] array of handles of excluded metrics - ///< from the phCalculateOperation handle. zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation); ///< [out] Calculate operation handle ze_result_t ZE_APICALL zetIntelMetricCalculateOperationDestroyExp( zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation); ///< [in] Calculate operation handle -ze_result_t ZE_APICALL zetIntelMetricCalculateGetReportFormatExp( +ze_result_t ZE_APICALL zetIntelMetricCalculateOperationGetReportFormatExp( zet_intel_metric_calculate_operation_exp_handle_t phCalculateOperation, ///< [in] Calculate operation handle uint32_t *pCount, ///< [in,out] pointer to the number of metrics in the output report from ///< calculate operations. If set to zero, then the driver shall update @@ -310,7 +307,17 @@ ze_result_t ZE_APICALL zetIntelMetricCalculateGetReportFormatExp( zet_metric_handle_t *phMetrics); ///< [out][optional] [range(0, pMetricsCount)] array of metrics handles ///< with the order in which results will be found in output report of ///< calculate operations - +ze_result_t ZE_APICALL zetIntelMetricCalculateOperationGetExcludedMetricsExp( + zet_intel_metric_calculate_operation_exp_handle_t phCalculateOperation, ///< [in] Calculate operation handle + uint32_t *pCount, ///< [in,out] pointer to the number of metrics excluded from the output report. + ///< If set to zero, then the driver shall update the value with the total number + ///< of metrics excluded. If count is greater than the total number + ///< of metrics excluded, then the driver shall update the value with the + ///< actual number. If count is smaller than the total number of metrics + ///< excluded then ZE_RESULT_ERROR_INVALID_ARGUMENT will be returned + ///< since this parameter is not intended for filtering metrics. + zet_metric_handle_t *phMetrics); ///< [out][optional] [range(0, pMetricsCount)] array of metrics handles + ///< excluded from the output report of calculate operations ze_result_t ZE_APICALL zetIntelMetricDecodeCalculateMultipleValuesExp( zet_metric_decoder_exp_handle_t hMetricDecoder, ///< [in] handle of the metric decoder object diff --git a/level_zero/tools/source/metrics/metric.cpp b/level_zero/tools/source/metrics/metric.cpp index 06304f5b51..ee4a219e7b 100644 --- a/level_zero/tools/source/metrics/metric.cpp +++ b/level_zero/tools/source/metrics/metric.cpp @@ -590,8 +590,6 @@ bool MetricDeviceContext::areMetricsFromSameSource(uint32_t count, zet_metric_ha ze_result_t MetricDeviceContext::calcOperationCreate(zet_context_handle_t hContext, zet_intel_metric_calculate_exp_desc_t *pCalculateDesc, - uint32_t *pExcludedMetricCount, - zet_metric_handle_t *phExcludedMetrics, zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation) { if (pCalculateDesc->timeAggregationWindow == 0) { @@ -642,7 +640,7 @@ ze_result_t MetricDeviceContext::calcOperationCreate(zet_context_handle_t hConte } MetricSource &metricSource = (metricGroupImp) ? metricGroupImp->getMetricSource() : metricImp->getMetricSource(); // NOLINT(clang-analyzer-core.CallAndMessage) - return metricSource.calcOperationCreate(*this, pCalculateDesc, pExcludedMetricCount, phExcludedMetrics, phCalculateOperation); + return metricSource.calcOperationCreate(*this, pCalculateDesc, phCalculateOperation); } std::unique_ptr MetricScopeImp::create(zet_intel_metric_scope_properties_exp_t &scopeProperties) { @@ -966,6 +964,32 @@ MetricImp *HomogeneousMultiDeviceMetricCreated::create(MetricSource &metricSourc return new (std::nothrow) HomogeneousMultiDeviceMetricCreated(metricSource, subDeviceMetrics); } +ze_result_t MetricCalcOpImp::getMetricsFromCalcOp(uint32_t *pCount, zet_metric_handle_t *phMetrics, bool isExcludedMetrics) { + if (*pCount == 0) { + *pCount = isExcludedMetrics ? excludedMetricCount : metricInReportCount; + return ZE_RESULT_SUCCESS; + } else if (*pCount < (isExcludedMetrics ? excludedMetricCount : metricInReportCount)) { + METRICS_LOG_ERR("%s", "Metric can't be smaller than report size"); + *pCount = 0; + return ZE_RESULT_ERROR_INVALID_ARGUMENT; + } + + *pCount = isExcludedMetrics ? excludedMetricCount : metricInReportCount; + for (uint32_t index = 0; index < *pCount; index++) { + phMetrics[index] = isExcludedMetrics ? excludedMetrics[index]->toHandle() : metricsInReport[index]->toHandle(); + } + + return ZE_RESULT_SUCCESS; +} + +ze_result_t MetricCalcOpImp::getReportFormat(uint32_t *pCount, zet_metric_handle_t *phMetrics) { + return getMetricsFromCalcOp(pCount, phMetrics, false); +} + +ze_result_t MetricCalcOpImp::getExcludedMetrics(uint32_t *pCount, zet_metric_handle_t *phMetrics) { + return getMetricsFromCalcOp(pCount, phMetrics, true); +} + ze_result_t metricProgrammableGet(zet_device_handle_t hDevice, uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables) { auto device = Device::fromHandle(hDevice); return static_cast(device->getMetricDeviceContext()).metricProgrammableGet(pCount, phMetricProgrammables); @@ -1007,12 +1031,10 @@ ze_result_t metricCalculateOperationCreate( zet_context_handle_t hContext, zet_device_handle_t hDevice, zet_intel_metric_calculate_exp_desc_t *pCalculateDesc, - uint32_t *pExcludedMetricCount, - zet_metric_handle_t *phExcludedMetrics, zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation) { DeviceImp *deviceImp = static_cast(L0::Device::fromHandle(hDevice)); - return deviceImp->getMetricDeviceContext().calcOperationCreate(hContext, pCalculateDesc, pExcludedMetricCount, phExcludedMetrics, phCalculateOperation); + return deviceImp->getMetricDeviceContext().calcOperationCreate(hContext, pCalculateDesc, phCalculateOperation); } ze_result_t metricCalculateOperationDestroy( @@ -1027,6 +1049,13 @@ ze_result_t metricCalculateGetReportFormat( return MetricCalcOp::fromHandle(hCalculateOperation)->getReportFormat(pCount, phMetrics); } +ze_result_t metricCalculateGetExcludedMetrics( + zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation, + uint32_t *pCount, + zet_metric_handle_t *phMetrics) { + return MetricCalcOp::fromHandle(hCalculateOperation)->getExcludedMetrics(pCount, phMetrics); +} + ze_result_t metricCalculateValues( const size_t rawDataSize, size_t *pOffset, diff --git a/level_zero/tools/source/metrics/metric.h b/level_zero/tools/source/metrics/metric.h index 4787bf4f6d..0752632856 100644 --- a/level_zero/tools/source/metrics/metric.h +++ b/level_zero/tools/source/metrics/metric.h @@ -106,8 +106,6 @@ 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_calculate_exp_desc_t *pCalculateDesc, - uint32_t *pCount, - zet_metric_handle_t *phExcludedMetrics, zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation) = 0; virtual bool canDisable() = 0; virtual void initMetricScopes(MetricDeviceContext &metricDeviceContext) = 0; @@ -177,8 +175,6 @@ class MetricDeviceContext { zet_metric_group_handle_t *phMetricGroups); ze_result_t calcOperationCreate(zet_context_handle_t hContext, zet_intel_metric_calculate_exp_desc_t *pCalculateDesc, - uint32_t *pExcludedMetricCount, - zet_metric_handle_t *phExcludedMetrics, zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation); ze_result_t metricScopesGet(zet_context_handle_t hContext, uint32_t *pMetricScopesCount, @@ -470,6 +466,7 @@ struct MetricCalcOp : _zet_intel_metric_calculate_operation_exp_handle_t { virtual ze_result_t destroy() = 0; virtual ze_result_t getReportFormat(uint32_t *pCount, zet_metric_handle_t *phMetrics) = 0; + virtual ze_result_t getExcludedMetrics(uint32_t *pCount, zet_metric_handle_t *phMetrics) = 0; virtual ze_result_t metricCalculateMultipleValues(const size_t rawDataSize, size_t *offset, const uint8_t *pRawData, uint32_t *pSetCount, uint32_t *pMetricsReportCountPerSet, uint32_t *pTotalMetricReportCount, @@ -481,11 +478,24 @@ struct MetricCalcOp : _zet_intel_metric_calculate_operation_exp_handle_t { struct MetricCalcOpImp : public MetricCalcOp { ~MetricCalcOpImp() override = default; - MetricCalcOpImp(bool multiDevice) : isMultiDevice(multiDevice) {} + 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) {} + 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; }; 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 metricsInReport{}; + uint32_t excludedMetricCount = 0; + std::vector excludedMetrics{}; }; struct MetricScope : _zet_intel_metric_scope_exp_handle_t { @@ -562,13 +572,16 @@ ze_result_t metricTracerDecode(zet_metric_decoder_exp_handle_t hMetricDecoder, s uint32_t *pMetricEntriesCount, zet_metric_entry_exp_t *pMetricEntries); ze_result_t metricCalculateOperationCreate(zet_context_handle_t hContext, zet_device_handle_t hDevice, 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); + zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation); ze_result_t metricCalculateOperationDestroy(zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation); ze_result_t metricCalculateGetReportFormat(zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation, uint32_t *pCount, zet_metric_handle_t *phMetrics); +ze_result_t metricCalculateGetExcludedMetrics(zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation, + uint32_t *pCount, zet_metric_handle_t *phMetrics); + ze_result_t metricCalculateValues(const size_t rawDataSize, size_t *pOffset, const uint8_t *pRawData, zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation, uint32_t *pTotalMetricReportsCount, zet_intel_metric_result_exp_t *pMetricResults); 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 d037e920d5..c04ee85c2b 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_source.cpp +++ b/level_zero/tools/source/metrics/metric_ip_sampling_source.cpp @@ -267,14 +267,9 @@ ze_result_t IpSamplingMetricSourceImp::handleMetricGroupExtendedProperties(zet_m ze_result_t IpSamplingMetricSourceImp::calcOperationCreate(MetricDeviceContext &metricDeviceContext, zet_intel_metric_calculate_exp_desc_t *pCalculateDesc, - uint32_t *pExcludedMetricCount, - 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 - *pExcludedMetricCount = 0; - bool isMultiDevice = (metricDeviceContext.isImplicitScalingCapable()) ? true : false; status = IpSamplingMetricCalcOpImp::create(*this, pCalculateDesc, isMultiDevice, phCalculateOperation); 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 628c3d1214..f34696152c 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_source.h +++ b/level_zero/tools/source/metrics/metric_ip_sampling_source.h @@ -59,8 +59,6 @@ class IpSamplingMetricSourceImp : public MetricSource { } ze_result_t calcOperationCreate(MetricDeviceContext &metricDeviceContext, zet_intel_metric_calculate_exp_desc_t *pCalculateDesc, - uint32_t *pExcludedMetricCount, - zet_metric_handle_t *phExcludedMetrics, 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 5e30f51aad..38f8091022 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_streamer.cpp +++ b/level_zero/tools/source/metrics/metric_ip_sampling_streamer.cpp @@ -118,24 +118,25 @@ ze_result_t IpSamplingMetricCalcOpImp::create(IpSamplingMetricSourceImp &metricS MetricGroup::fromHandle(hMetricGroup)->metricGet(&metricCount, nullptr); std::vector hMetrics(metricCount); MetricGroup::fromHandle(hMetricGroup)->metricGet(&metricCount, hMetrics.data()); - std::vector inputMetricsInReport = {}; + std::vector metricsInReport = {}; std::vector includedMetricIndexes = {}; for (uint32_t i = 0; i < metricCount; i++) { auto metric = static_cast(Metric::fromHandle(hMetrics[i])); if (pCalculateDesc->metricGroupCount > 0) { - inputMetricsInReport.push_back(metric); + metricsInReport.push_back(metric); includedMetricIndexes.push_back(i); } else { if (uniqueMetricHandles.find(hMetrics[i]) != uniqueMetricHandles.end()) { - inputMetricsInReport.push_back(metric); + metricsInReport.push_back(metric); includedMetricIndexes.push_back(i); } } } auto calcOp = new IpSamplingMetricCalcOpImp(static_cast(hMetrics.size()), - inputMetricsInReport, includedMetricIndexes, isMultiDevice); + metricsInReport, includedMetricIndexes, + isMultiDevice); *phCalculateOperation = calcOp->toHandle(); return ZE_RESULT_SUCCESS; } @@ -145,25 +146,6 @@ ze_result_t IpSamplingMetricCalcOpImp::destroy() { return ZE_RESULT_SUCCESS; } -ze_result_t IpSamplingMetricCalcOpImp::getReportFormat(uint32_t *pCount, zet_metric_handle_t *phMetrics) { - - if (*pCount == 0) { - *pCount = metricsInReportCount; - return ZE_RESULT_SUCCESS; - } else if (*pCount < metricsInReportCount) { - METRICS_LOG_ERR("%s", "Metric can't be smaller than report size"); - *pCount = 0; - return ZE_RESULT_ERROR_INVALID_ARGUMENT; - } - - *pCount = metricsInReportCount; - for (uint32_t index = 0; index < metricsInReportCount; index++) { - phMetrics[index] = metricsInReport[index]->toHandle(); - } - - return ZE_RESULT_SUCCESS; -} - void IpSamplingMetricCalcOpImp::fillStallDataMap(const size_t rawDataSize, const uint8_t *pRawData, size_t *processedSize, L0::L0GfxCoreHelper &l0GfxCoreHelper, std::map &stallReportDataMap, 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 2f5c26f6c4..f1b8196880 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_streamer.h +++ b/level_zero/tools/source/metrics/metric_ip_sampling_streamer.h @@ -48,12 +48,11 @@ struct MultiDeviceIpSamplingMetricStreamerImp : public IpSamplingMetricStreamerB }; struct IpSamplingMetricCalcOpImp : public MetricCalcOpImp { - IpSamplingMetricCalcOpImp(uint32_t inputCachedMetricsCount, std::vector &inputMetricsInReport, + IpSamplingMetricCalcOpImp(uint32_t inCachedMetricsCount, + std::vector &metricsInReport, std::vector &inputIncludedMetricIndexes, bool multidevice) - : MetricCalcOpImp(multidevice), - cachedMetricsCount(inputCachedMetricsCount), - metricsInReportCount(static_cast(inputMetricsInReport.size())), - metricsInReport(inputMetricsInReport), + : MetricCalcOpImp(multidevice, metricsInReport), + cachedMetricsCount(inCachedMetricsCount), includedMetricIndexes(inputIncludedMetricIndexes) {} ~IpSamplingMetricCalcOpImp() override{}; @@ -62,7 +61,6 @@ struct IpSamplingMetricCalcOpImp : public MetricCalcOpImp { 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; ze_result_t metricCalculateMultipleValues(const size_t rawDataSize, size_t *offset, const uint8_t *pRawData, uint32_t *pSetCount, uint32_t *pMetricsReportCountPerSet, uint32_t *pTotalMetricReportCount, @@ -98,8 +96,6 @@ struct IpSamplingMetricCalcOpImp : public MetricCalcOpImp { std::map &stallReportDataMap); uint32_t cachedMetricsCount = 0; - uint32_t metricsInReportCount = 0; - std::vector metricsInReport{}; std::vector includedMetricIndexes{}; }; diff --git a/level_zero/tools/source/metrics/metric_oa_source.h b/level_zero/tools/source/metrics/metric_oa_source.h index 389dd96f18..a1dc9d93d8 100644 --- a/level_zero/tools/source/metrics/metric_oa_source.h +++ b/level_zero/tools/source/metrics/metric_oa_source.h @@ -66,8 +66,6 @@ class OaMetricSourceImp : public MetricSource { zet_metric_group_handle_t *pMetricGroupHandle); ze_result_t calcOperationCreate(MetricDeviceContext &metricDeviceContext, zet_intel_metric_calculate_exp_desc_t *pCalculateDesc, - uint32_t *pExcludedMetricCount, - zet_metric_handle_t *phExcludedMetrics, zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation) override { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } diff --git a/level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics.h b/level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics.h index 5abff363bf..7e66beb8f3 100644 --- a/level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics.h +++ b/level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2022-2024 Intel Corporation + * Copyright (C) 2022-2025 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -16,17 +16,18 @@ #include #include -#define VALIDATECALL(myZeCall) \ - do { \ - if ((myZeCall) != ZE_RESULT_SUCCESS) { \ - std::cout << "Validate Error: " \ - << static_cast(myZeCall) \ - << " at " \ - << #myZeCall << ": " \ - << __FILE__ << ": " \ - << __LINE__ << std::endl; \ - std::terminate(); \ - } \ +#define VALIDATECALL(myZeCall) \ + do { \ + if (((myZeCall) != ZE_RESULT_SUCCESS) && \ + ((myZeCall) != ZE_RESULT_WARNING_ACTION_REQUIRED)) { \ + std::cout << "Validate Error: " \ + << static_cast(myZeCall) \ + << " at " \ + << #myZeCall << ": " \ + << __FILE__ << ": " \ + << __LINE__ << std::endl; \ + std::terminate(); \ + } \ } while (0); #define EXPECT(cond) \ diff --git a/level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_util.cpp b/level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_util.cpp index 4bc441c8dd..22ae45296e 100644 --- a/level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_util.cpp +++ b/level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_util.cpp @@ -70,6 +70,19 @@ bool getTestMachineConfiguration(TestMachineConfiguration &machineConfig) { deviceProperties.pNext = nullptr; VALIDATECALL(zeDeviceGetProperties(devices[0], &deviceProperties)); machineConfig.deviceId = deviceProperties.deviceId; + + uint32_t extensionsCount = 0; + VALIDATECALL(zeDriverGetExtensionProperties(driverHandle, &extensionsCount, nullptr)); + if (extensionsCount != 0) { + machineConfig.driverExtensionsProperties.resize(extensionsCount); + VALIDATECALL(zeDriverGetExtensionProperties(driverHandle, &extensionsCount, machineConfig.driverExtensionsProperties.data())); + + for (uint32_t i = 0; i < extensionsCount; i++) { + uint32_t supportedVersion = machineConfig.driverExtensionsProperties[i].version; + LOG(LogLevel::DEBUG) << "Extension #" << i << " name: " << machineConfig.driverExtensionsProperties[i].name << " version: " << ZE_MAJOR_VERSION(supportedVersion) << "." << ZE_MINOR_VERSION(supportedVersion) << std::endl; + } + } + return true; } diff --git a/level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_util.h b/level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_util.h index 6f81441125..44c91acea9 100644 --- a/level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_util.h +++ b/level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_util.h @@ -26,6 +26,7 @@ struct TestMachineConfiguration { } devices[MAX_DEVICES_IN_MACHINE]; uint32_t deviceCount = 0; uint32_t deviceId; + std::vector driverExtensionsProperties{}; }; template 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 356a73ebf8..50f1a51d52 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,8 +51,6 @@ class MockMetricSource : public L0::MetricSource { ze_result_t 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) override { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } @@ -163,13 +161,13 @@ class MockMetric : public L0::MetricImp { class MockMetricCalcOp : public MetricCalcOpImp { public: ~MockMetricCalcOp() override = default; - MockMetricCalcOp() : MetricCalcOpImp(false){}; + MockMetricCalcOp(bool multiDevice, const std::vector &inMetricsInReport, + uint32_t inExcludedMetricsCount, const std::vector &inExcludedMetrics) + : MetricCalcOpImp(multiDevice, inMetricsInReport, inExcludedMetricsCount, inExcludedMetrics) {} + ze_result_t destroy() override { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; }; - ze_result_t getReportFormat(uint32_t *pCount, zet_metric_handle_t *phMetrics) override { - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; - }; ze_result_t metricCalculateMultipleValues(const size_t rawDataSize, size_t *offset, const uint8_t *pRawData, uint32_t *pSetCount, uint32_t *pMetricReportCountPerSet, uint32_t *pTotalMetricReportCount, 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 b62ffc6270..7b282fb280 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 @@ -51,8 +51,6 @@ class CalcOperationFixture : public DeviceFixture, MockMetricSource mockMetricSource{}; MockMetricGroup *mockMetricGroup; zet_metric_group_handle_t phMetricGroup = nullptr; - uint32_t excludedMetricsCount = 0; - zet_metric_handle_t *phExcludedMetrics = nullptr; DebugManagerStateRestore restorer; }; @@ -86,7 +84,6 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpAndInvalidParamsPassedThenErrorIs zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation; EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateOperationCreateExp(context->toHandle(), device->toHandle(), &calculateDesc, - &excludedMetricsCount, phExcludedMetrics, &hCalculateOperation)); // No metric groups or metrics @@ -94,7 +91,6 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpAndInvalidParamsPassedThenErrorIs calculateDesc.metricGroupCount = 0; EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateOperationCreateExp(context->toHandle(), device->toHandle(), &calculateDesc, - &excludedMetricsCount, phExcludedMetrics, &hCalculateOperation)); } @@ -121,7 +117,6 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpWithMixedSourcesThenErrorIsReturn zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation; EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateOperationCreateExp(context, device->toHandle(), &calculateDesc, - &excludedMetricsCount, phExcludedMetrics, &hCalculateOperation)); // metrics from different source @@ -135,7 +130,6 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpWithMixedSourcesThenErrorIsReturn calculateDesc.phMetrics = metrics.data(); EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateOperationCreateExp(context, device->toHandle(), &calculateDesc, - &excludedMetricsCount, phExcludedMetrics, &hCalculateOperation)); // metrics and metric group from different source @@ -143,7 +137,6 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpWithMixedSourcesThenErrorIsReturn calculateDesc.phMetrics = &metrics[1]; EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateOperationCreateExp(context, device->toHandle(), &calculateDesc, - &excludedMetricsCount, phExcludedMetrics, &hCalculateOperation)); } @@ -168,7 +161,6 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpWithMixedHierarchiesThenErrorIsRe zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation; EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateOperationCreateExp(context, device->toHandle(), &calculateDesc, - &excludedMetricsCount, phExcludedMetrics, &hCalculateOperation)); MockMetric mockMetric(mockMetricSource), mockMetric2(mockMetricSource); @@ -182,7 +174,6 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpWithMixedHierarchiesThenErrorIsRe calculateDesc.phMetrics = metrics.data(); EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateOperationCreateExp(context, device->toHandle(), &calculateDesc, - &excludedMetricsCount, phExcludedMetrics, &hCalculateOperation)); } @@ -206,7 +197,6 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpUseTheSourceFromMetricGroupOrMetr zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation; EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetIntelMetricCalculateOperationCreateExp(context, device->toHandle(), &calculateDesc, - &excludedMetricsCount, phExcludedMetrics, &hCalculateOperation)); MockMetric mockMetric(mockMetricSource), mockMetric2(mockMetricSource); @@ -218,12 +208,15 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpUseTheSourceFromMetricGroupOrMetr calculateDesc.phMetrics = metrics.data(); EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetIntelMetricCalculateOperationCreateExp(context, device->toHandle(), &calculateDesc, - &excludedMetricsCount, phExcludedMetrics, &hCalculateOperation)); } TEST_F(CalcOperationFixture, WhenCreatingCalcOpObjectToAndFromHandleBaseClassWorkAsExpected) { - MockMetricCalcOp mockMetricCalcOp{}; + std::vector mockMetricsInReport{}; + uint32_t mockExcludedMetricCount = 0; + std::vector mockExcludedMetrics{}; + + MockMetricCalcOp mockMetricCalcOp(false, mockMetricsInReport, mockExcludedMetricCount, mockExcludedMetrics); auto hMockCalcOp = mockMetricCalcOp.toHandle(); EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetIntelMetricCalculateOperationDestroyExp(hMockCalcOp)); @@ -232,6 +225,37 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpObjectToAndFromHandleBaseClassWor EXPECT_NE(nullptr, mockCalcOp); } +TEST_F(CalcOperationFixture, WhenGettingMetricsInReportAndExcludedMetricsThenTheyAreReturnedCorrectly) { + std::vector mockMetricsInReport{}; + MockMetric mockMetricInReport(mockMetricSource); + mockMetricsInReport.push_back(&mockMetricInReport); + + std::vector mockExcludedMetrics{}; + uint32_t mockExcludedMetricCount = 1; + MockMetric mockExcludedMetric(mockMetricSource); + mockExcludedMetrics.push_back(&mockExcludedMetric); + + MockMetricCalcOp mockMetricCalcOp(false, mockMetricsInReport, mockExcludedMetricCount, mockExcludedMetrics); + uint32_t metricCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationGetReportFormatExp(mockMetricCalcOp.toHandle(), &metricCount, nullptr)); + EXPECT_EQ(metricCount, 1U); + zet_metric_handle_t metricHandle = nullptr; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationGetReportFormatExp(mockMetricCalcOp.toHandle(), &metricCount, &metricHandle)); + EXPECT_EQ(metricCount, 1U); + EXPECT_EQ(metricHandle, mockMetricInReport.toHandle()); + EXPECT_EQ(metricCount, mockMetricCalcOp.getMetricsInReportCount()); + + metricCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationGetExcludedMetricsExp(mockMetricCalcOp.toHandle(), &metricCount, nullptr)); + EXPECT_EQ(metricCount, 1U); + + zet_metric_handle_t excludedMetricHandle = nullptr; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationGetExcludedMetricsExp(mockMetricCalcOp.toHandle(), &metricCount, &excludedMetricHandle)); + EXPECT_EQ(metricCount, 1U); + EXPECT_EQ(excludedMetricHandle, mockExcludedMetric.toHandle()); + EXPECT_NE(excludedMetricHandle, metricHandle); +} + using MetricRuntimeFixture = Test; TEST_F(MetricRuntimeFixture, WhenRunTimeEnableIsDoneThenReturnSuccess) { 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 7210548902..d0da21fa40 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 @@ -577,11 +577,8 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingMetricGroupThenCrea }; 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)); @@ -597,7 +594,6 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingMetricGroupThenCrea calculateDesc.phMetrics = &phMetric; EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationCreateExp(context->toHandle(), device->toHandle(), &calculateDesc, - &excludedMetricsCount, &phExcludedMetrics, &hCalculateOperation)); EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation)); } @@ -628,19 +624,17 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingCalcOpCanGetReportF }; 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)); uint32_t metricsInReportCount = 0; - EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation, &metricsInReportCount, nullptr)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationGetReportFormatExp(hCalculateOperation, &metricsInReportCount, nullptr)); EXPECT_EQ(metricsInReportCount, 10u); std::vector metricsInReport(metricsInReportCount); - EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation, &metricsInReportCount, metricsInReport.data())); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationGetReportFormatExp(hCalculateOperation, &metricsInReportCount, metricsInReport.data())); EXPECT_EQ(metricsInReportCount, 10u); zet_metric_properties_t ipSamplingMetricProperties = {}; @@ -652,7 +646,7 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingCalcOpCanGetReportF // Can't filter metrics in report metricsInReportCount = 1; - EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation, &metricsInReportCount, metricsInReport.data())); + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateOperationGetReportFormatExp(hCalculateOperation, &metricsInReportCount, metricsInReport.data())); EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation)); } @@ -701,19 +695,16 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingCalcOpGetReportForm }; 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)); uint32_t metricsInReportCount = 0; - EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation, &metricsInReportCount, nullptr)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationGetReportFormatExp(hCalculateOperation, &metricsInReportCount, nullptr)); EXPECT_EQ(metricsInReportCount, 5u); std::vector metricsInReport(metricsInReportCount); - EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation, &metricsInReportCount, metricsInReport.data())); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationGetReportFormatExp(hCalculateOperation, &metricsInReportCount, metricsInReport.data())); EXPECT_EQ(metricsInReportCount, 5u); // Metrics must be in the report but can be in different order @@ -726,6 +717,44 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingCalcOpGetReportForm } } +HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingCalcOpCanGetExcludedMetricsAreZero, 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; + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationCreateExp(context->toHandle(), + device->toHandle(), &calculateDesc, + &hCalculateOperation)); + + uint32_t excludedMetricsCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationGetExcludedMetricsExp(hCalculateOperation, &excludedMetricsCount, nullptr)); + EXPECT_EQ(excludedMetricsCount, 0u); + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation)); + } +} + HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, WhenReadingMetricGroupTimeCalculateFilterThenCorrectValueIsReturned, EustallSupportedPlatforms) { EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi()); @@ -782,17 +811,14 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat }; 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)); uint32_t metricsInReportCount = 10; std::vector metricsInReport(metricsInReportCount); - EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation, - &metricsInReportCount, - metricsInReport.data())); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationGetReportFormatExp(hCalculateOperation, + &metricsInReportCount, + metricsInReport.data())); EXPECT_EQ(metricsInReportCount, 10u); std::vector metricProperties(metricsInReportCount); @@ -849,17 +875,14 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat }; 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)); uint32_t metricsInReportCount = 10; std::vector metricsInReport(metricsInReportCount); - EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation, - &metricsInReportCount, - metricsInReport.data())); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationGetReportFormatExp(hCalculateOperation, + &metricsInReportCount, + metricsInReport.data())); EXPECT_EQ(metricsInReportCount, 10u); std::vector metricProperties(metricsInReportCount); @@ -963,11 +986,8 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCoverBoundaryConditio }; 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)); uint32_t totalMetricReportCount = 0; size_t offset = 0; @@ -1034,12 +1054,11 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat }; 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)); + std::vector rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader)); addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast(rawDataVector.data()), rawDataVectorSize, 0); @@ -1081,11 +1100,8 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat }; 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)); uint32_t totalMetricReportCount = 2; size_t offset = 0; @@ -1142,14 +1158,12 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat }; 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)); uint32_t metricsInReportCount = 0; - EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation, &metricsInReportCount, nullptr)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationGetReportFormatExp(hCalculateOperation, &metricsInReportCount, nullptr)); EXPECT_EQ(metricsInReportCount, 5u); // calculate only one report and expect results follow the order of rawDataVector @@ -1198,11 +1212,9 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, GivenIpSamplingCalcOpCallingMetric }; 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)); std::vector rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader)); 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 c659d23509..59ce4dac9c 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 @@ -3702,11 +3702,9 @@ TEST_F(MetricEnumerationTest, givenValidOAMetricGroupThenOASourceCalcOperationIs }; 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(), device->toHandle(), &calculateDesc, - &excludedMetricsCount, phExcludedMetrics, &hCalculateOperation)); }