From 25ed9d1989a903a0f17bc1e4a392da6f70bdfb55 Mon Sep 17 00:00:00 2001 From: Matias Cabral Date: Thu, 10 Apr 2025 00:41:18 +0000 Subject: [PATCH] feature: metrics aggregation for EU Stall Resolves: NEO-13999 Signed-off-by: Matias Cabral --- .../driver_experimental/public/zex_metric.cpp | 56 +- .../driver/extension_function_address.cpp | 8 + .../include/level_zero/zet_intel_gpu_metric.h | 29 +- level_zero/tools/source/metrics/metric.cpp | 22 + level_zero/tools/source/metrics/metric.h | 27 +- .../metrics/metric_device_context_create.cpp | 15 +- .../metrics/metric_ip_sampling_source.cpp | 16 +- .../metrics/metric_ip_sampling_source.h | 9 +- .../metrics/metric_ip_sampling_streamer.cpp | 152 +++- .../metrics/metric_ip_sampling_streamer.h | 46 +- .../metrics/metric_oa_enumeration_imp.cpp | 4 +- .../metrics/metric_ip_sampling_fixture.h | 92 ++- .../sources/metrics/mock_metric_source.h | 11 +- .../test_metric_ip_sampling_enumeration.cpp | 204 +----- .../test_metric_ip_sampling_streamer.cpp | 683 ++++++++++++++++++ .../sources/metrics/test_metric_tracer.cpp | 7 +- 16 files changed, 1144 insertions(+), 237 deletions(-) diff --git a/level_zero/api/driver_experimental/public/zex_metric.cpp b/level_zero/api/driver_experimental/public/zex_metric.cpp index 673ff5742d..3a99f9b227 100644 --- a/level_zero/api/driver_experimental/public/zex_metric.cpp +++ b/level_zero/api/driver_experimental/public/zex_metric.cpp @@ -96,6 +96,29 @@ ze_result_t ZE_APICALL zetIntelMetricCalculateGetReportFormatExp( return L0::metricCalculateGetReportFormat(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) { + return L0::metricCalculateValues(rawDataSize, pOffset, pRawData, hCalculateOperation, pTotalMetricReportsCount, pMetricResults); +} + +ze_result_t ZE_APICALL zetIntelMetricCalculateMultipleValuesExp(const size_t rawDataSize, size_t *offset, const uint8_t *pRawData, + zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation, + uint32_t *pSetCount, uint32_t *pMetricsReportCountPerSet, + uint32_t *pTotalMetricReportCount, zet_intel_metric_result_exp_t *pMetricResults) { + return metricCalculateMultipleValues(rawDataSize, offset, pRawData, hCalculateOperation, + pSetCount, pMetricsReportCountPerSet, pTotalMetricReportCount, pMetricResults); +} + +ze_result_t ZE_APICALL zetIntelMetricDecodeCalculateMultipleValuesExp(zet_intel_metric_decoder_exp_handle_t hMetricDecoder, + const size_t rawDataSize, size_t *offset, const uint8_t *pRawData, + zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation, + uint32_t *pSetCount, uint32_t *pMetricReportCountPerSet, + uint32_t *pTotalMetricReportCount, zet_intel_metric_result_exp_t *pMetricResults) { + return L0::metricDecodeCalculateMultipleValues(hMetricDecoder, rawDataSize, offset, pRawData, hCalculateOperation, + pSetCount, pMetricReportCountPerSet, pTotalMetricReportCount, pMetricResults); +} + } // namespace L0 extern "C" { @@ -108,8 +131,7 @@ ze_result_t ZE_APICALL zetIntelDeviceDisableMetricsExp(zet_device_handle_t hDevi return L0::zetIntelDeviceDisableMetricsExp(hDevice); } -ze_result_t ZE_APICALL -zetIntelCommandListAppendMarkerExp( +ze_result_t ZE_APICALL zetIntelCommandListAppendMarkerExp( zet_command_list_handle_t hCommandList, zet_metric_group_handle_t hMetricGroup, uint32_t value) { @@ -183,7 +205,7 @@ ze_result_t ZE_APICALL zetIntelMetricTracerDecodeExp( pMetricEntriesCountPerSet, pMetricEntriesCount, pMetricEntries); } -ze_result_t zetIntelMetricCalculateOperationCreateExp( +ze_result_t ZE_APICALL zetIntelMetricCalculateOperationCreateExp( zet_context_handle_t hContext, zet_device_handle_t hDevice, zet_intel_metric_calculate_exp_desc_t *pCalculateDesc, @@ -193,16 +215,40 @@ ze_result_t zetIntelMetricCalculateOperationCreateExp( return L0::zetIntelMetricCalculateOperationCreateExp(hContext, hDevice, pCalculateDesc, pCount, phExcludedMetrics, phCalculateOperation); } -ze_result_t zetIntelMetricCalculateOperationDestroyExp( +ze_result_t ZE_APICALL zetIntelMetricCalculateOperationDestroyExp( zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation) { return L0::zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation); } -ze_result_t zetIntelMetricCalculateGetReportFormatExp( +ze_result_t ZE_APICALL zetIntelMetricCalculateGetReportFormatExp( zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation, uint32_t *pCount, zet_metric_handle_t *phMetrics) { return L0::zetIntelMetricCalculateGetReportFormatExp(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) { + + return L0::zetIntelMetricCalculateValuesExp(rawDataSize, pOffset, pRawData, hCalculateOperation, + pTotalMetricReportsCount, pMetricResults); +} + +ze_result_t ZE_APICALL zetIntelMetricCalculateMultipleValuesExp(const size_t rawDataSize, size_t *offset, const uint8_t *pRawData, + zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation, + uint32_t *pSetCount, uint32_t *pMetricsReportCountPerSet, + uint32_t *pTotalMetricReportCount, zet_intel_metric_result_exp_t *pMetricResults) { + return L0::zetIntelMetricCalculateMultipleValuesExp(rawDataSize, offset, pRawData, hCalculateOperation, pSetCount, + pMetricsReportCountPerSet, pTotalMetricReportCount, pMetricResults); +} + +ze_result_t ZE_APICALL zetIntelMetricDecodeCalculateMultipleValuesExp(zet_metric_decoder_exp_handle_t hMetricDecoder, const size_t rawDataSize, + size_t *offset, const uint8_t *pRawData, zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation, + uint32_t *pSetCount, uint32_t *pMetricReportCountPerSet, uint32_t *pTotalMetricReportCount, + zet_intel_metric_result_exp_t *pMetricResults) { + return L0::zetIntelMetricDecodeCalculateMultipleValuesExp( + hMetricDecoder, rawDataSize, offset, pRawData, hCalculateOperation, pSetCount, + pMetricReportCountPerSet, pTotalMetricReportCount, pMetricResults); +} + } // extern "C" diff --git a/level_zero/core/source/driver/extension_function_address.cpp b/level_zero/core/source/driver/extension_function_address.cpp index d537aca4c6..fe40725f13 100644 --- a/level_zero/core/source/driver/extension_function_address.cpp +++ b/level_zero/core/source/driver/extension_function_address.cpp @@ -64,6 +64,8 @@ void *ExtensionFunctionAddressHelper::getExtensionFunctionAddress(const std::str RETURN_FUNC_PTR_IF_EXIST(zetIntelCommandListAppendMarkerExp); RETURN_FUNC_PTR_IF_EXIST(zetIntelDeviceEnableMetricsExp); RETURN_FUNC_PTR_IF_EXIST(zetIntelDeviceDisableMetricsExp); + + // Metrics RETURN_FUNC_PTR_IF_EXIST(zetIntelMetricTracerCreateExp); RETURN_FUNC_PTR_IF_EXIST(zetIntelMetricTracerDestroyExp); RETURN_FUNC_PTR_IF_EXIST(zetIntelMetricTracerEnableExp); @@ -73,6 +75,12 @@ void *ExtensionFunctionAddressHelper::getExtensionFunctionAddress(const std::str RETURN_FUNC_PTR_IF_EXIST(zetIntelMetricDecoderDestroyExp); RETURN_FUNC_PTR_IF_EXIST(zetIntelMetricDecoderGetDecodableMetricsExp); 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(zetIntelMetricDecodeCalculateMultipleValuesExp); + RETURN_FUNC_PTR_IF_EXIST(zetIntelMetricCalculateMultipleValuesExp); + RETURN_FUNC_PTR_IF_EXIST(zetIntelMetricCalculateValuesExp); #undef RETURN_FUNC_PTR_IF_EXIST 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 ac6153d36f..6fd933c41f 100644 --- a/level_zero/include/level_zero/zet_intel_gpu_metric.h +++ b/level_zero/include/level_zero/zet_intel_gpu_metric.h @@ -216,6 +216,7 @@ typedef struct _zet_intel_metric_group_calculate_properties_exp_t { /////////////////////////////////////////////////////////////////////////////// /// @brief Handle of metric calculate operation +struct _zet_intel_metric_calculate_operation_exp_handle_t {}; typedef struct _zet_intel_metric_calculate_operation_exp_handle_t *zet_intel_metric_calculate_operation_exp_handle_t; typedef struct _zet_intel_metric_calculate_time_window_exp_t { @@ -309,9 +310,9 @@ ze_result_t ZE_APICALL zetIntelMetricCalculateGetReportFormatExp( ze_result_t ZE_APICALL zetIntelMetricDecodeCalculateMultipleValuesExp( zet_metric_decoder_exp_handle_t hMetricDecoder, ///< [in] handle of the metric decoder object - size_t rawDataSize, ///< [in] size in bytes of raw data buffer. - size_t *offset, ///< [in,out] On input, the offset from the beginning of the data to decode. On output, - ///< the number raw bytes processed + const size_t rawDataSize, ///< [in] size in bytes of raw data buffer. + size_t *offset, ///< [in,out] On input, the offset from the beginning of pRawData to decode + ///< and calculate. On output, the number raw bytes processed const uint8_t *pRawData, ///< [in,out][range(0, *rawDataSize)] buffer containing tracer ///< data in raw format zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation, ///< [in] Calculate operation handle @@ -359,8 +360,8 @@ zetIntelMetricDecodeToBinaryBufferExp( ze_result_t ZE_APICALL zetIntelMetricCalculateMultipleValuesExp( - size_t rawDataSize, ///< [in] size in bytes of raw data buffer. - size_t *offset, ///< [in,out] On input, the offset from the beginning of the data to decode. On output, + const size_t rawDataSize, ///< [in] size in bytes of raw data buffer. + size_t *offset, ///< [in,out] On input, the offset from the beginning of pRawData calculate. On output, ///< the number raw bytes processed const uint8_t *pRawData, ///< [in,out][range(0, *rawDataSize)] buffer containing tracer ///< data in raw format @@ -385,6 +386,24 @@ zetIntelMetricCalculateMultipleValuesExp( zet_intel_metric_result_exp_t *pMetricResults); ///< [in,out][optional][range(0, *pTotalMetricResultsCount)] buffer of calculated ///< metrics results. +ze_result_t ZE_APICALL +zetIntelMetricCalculateValuesExp( + const size_t rawDataSize, ///< [in] size in bytes of raw data buffer. + size_t *pOffset, ///< [in,out] On input, the offset from the beginning of the pRawData to calculate + ///< On output, the number raw bytes processed + const uint8_t *pRawData, ///< [in,out][range(0, *rawDataSize)] buffer containing tracer + ///< data in raw format + zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation, ///< [in] Calculate operation handle + uint32_t *pTotalMetricReportCount, ///< [in,out] [optional] pointer to the total number of metric reports calculated, + ///< If count is zero, then the driver shall update the value with the total number of + ///< metric reports to be calculated. If count is greater than zero but less than the + ///< total number of reports available in the raw data, then only that number of + ///< reports will be calculated. If count is greater than the number of reports + ///< available in the raw data buffer, then the driver shall update the value with + ///< the actual number of metric reports calculated. + zet_intel_metric_result_exp_t *pMetricResults); ///< [in,out][optional][range(0, *pTotalMetricResultsCount)] buffer of calculated + ///< metrics results. + #ifndef ZET_INTEL_METRICS_RUNTIME_ENABLE_DISABLE_EXP_NAME /// @brief Extension name for query to read the Intel Level Zero Driver Version String #define ZET_INTEL_METRICS_RUNTIME_ENABLE_DISABLE_EXP_NAME "ZET_intel_metrics_runtime_enable_disable" diff --git a/level_zero/tools/source/metrics/metric.cpp b/level_zero/tools/source/metrics/metric.cpp index 125585eed4..6c4c62a82d 100644 --- a/level_zero/tools/source/metrics/metric.cpp +++ b/level_zero/tools/source/metrics/metric.cpp @@ -890,6 +890,28 @@ ze_result_t metricCalculateGetReportFormat( return MetricCalcOp::fromHandle(hCalculateOperation)->getReportFormat(pCount, 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) { + return MetricCalcOp::fromHandle(hCalculateOperation)->metricCalculateValues(rawDataSize, pOffset, pRawData, pTotalMetricReportsCount, pMetricResults); +} + +ze_result_t metricCalculateMultipleValues( + const size_t rawDataSize, + size_t *offset, + const uint8_t *pRawData, + zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation, + uint32_t *pSetCount, + uint32_t *pMetricsReportCountPerSet, + uint32_t *pTotalMetricReportCount, + zet_intel_metric_result_exp_t *pMetricResults) { + return MetricCalcOp::fromHandle(hCalculateOperation)->metricCalculateMultipleValues(rawDataSize, offset, pRawData, pSetCount, pMetricsReportCountPerSet, pTotalMetricReportCount, pMetricResults); +} + ze_result_t metricsEnable(zet_device_handle_t hDevice) { auto isFailed = false; diff --git a/level_zero/tools/source/metrics/metric.h b/level_zero/tools/source/metrics/metric.h index f55360a3c5..46db97f3b0 100644 --- a/level_zero/tools/source/metrics/metric.h +++ b/level_zero/tools/source/metrics/metric.h @@ -36,8 +36,6 @@ static_assert(IsCompliantWithDdiHandlesExt<_zet_metric_query_handle_t>); struct _zet_metric_programmable_exp_handle_t : BaseHandle {}; static_assert(IsCompliantWithDdiHandlesExt<_zet_metric_programmable_exp_handle_t>); -struct _zet_intel_metric_calculate_operation_exp_handle_t {}; - namespace L0 { struct METRICS_LOG_BITMASK { // NOLINT(readability-identifier-naming) @@ -428,16 +426,20 @@ struct HomogeneousMultiDeviceMetricCreated : public MultiDeviceMetricImp { struct MetricCalcOp : _zet_intel_metric_calculate_operation_exp_handle_t { virtual ~MetricCalcOp() = default; MetricCalcOp() {} - virtual ze_result_t destroy() = 0; - virtual ze_result_t getReportFormat(uint32_t *pCount, zet_metric_handle_t *phMetrics) = 0; static MetricCalcOp *fromHandle(zet_intel_metric_calculate_operation_exp_handle_t handle) { return static_cast(handle); } inline zet_intel_metric_calculate_operation_exp_handle_t toHandle() { return this; } - virtual ze_result_t metricCalculateMultipleValues(size_t rawDataSize, size_t *offset, const uint8_t *pRawData, + + virtual ze_result_t destroy() = 0; + virtual ze_result_t getReportFormat(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, zet_intel_metric_result_exp_t *pMetricResults) = 0; + virtual ze_result_t metricCalculateValues(const size_t rawDataSize, size_t *pOffset, const uint8_t *pRawData, + uint32_t *pTotalMetricReportCount, + zet_intel_metric_result_exp_t *pMetricResults) = 0; }; struct MetricCalcOpImp : public MetricCalcOp { @@ -509,6 +511,21 @@ ze_result_t metricCalculateOperationDestroy(zet_intel_metric_calculate_operation ze_result_t metricCalculateGetReportFormat(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); + +ze_result_t metricCalculateMultipleValues(const size_t rawDataSize, size_t *offset, const uint8_t *pRawData, + zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation, + uint32_t *pSetCount, uint32_t *pMetricsReportCountPerSet, + uint32_t *pTotalMetricReportCount, zet_intel_metric_result_exp_t *pMetricResults); + +ze_result_t metricDecodeCalculateMultipleValues(zet_intel_metric_decoder_exp_handle_t hMetricDecoder, + const size_t rawDataSize, size_t *offset, const uint8_t *pRawData, + zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation, + uint32_t *pSetCount, uint32_t *pMetricReportCountPerSet, + uint32_t *pTotalMetricReportCount, zet_intel_metric_result_exp_t *pMetricResults); + ze_result_t metricsEnable(zet_device_handle_t hDevice); } // namespace L0 diff --git a/level_zero/tools/source/metrics/metric_device_context_create.cpp b/level_zero/tools/source/metrics/metric_device_context_create.cpp index e06d4b59d9..16ad96f3d4 100644 --- a/level_zero/tools/source/metrics/metric_device_context_create.cpp +++ b/level_zero/tools/source/metrics/metric_device_context_create.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2023-2024 Intel Corporation + * Copyright (C) 2023-2025 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -82,4 +82,17 @@ ze_result_t metricTracerDecode( return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } +ze_result_t metricDecodeCalculateMultipleValues( + zet_intel_metric_decoder_exp_handle_t hMetricDecoder, + const size_t rawDataSize, + size_t *offset, + const uint8_t *pRawData, + zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation, + uint32_t *pSetCount, + uint32_t *pMetricReportCountPerSet, + uint32_t *pTotalMetricReportCount, + zet_intel_metric_result_exp_t *pMetricResults) { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; +} + } // namespace L0 \ No newline at end of file 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 b8e83bf55e..be9188a1ba 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_source.cpp +++ b/level_zero/tools/source/metrics/metric_ip_sampling_source.cpp @@ -93,7 +93,7 @@ void IpSamplingMetricSourceImp::cacheMetricGroup() { metricProperties.tierNumber = 4; metricProperties.resultType = ZET_VALUE_TYPE_UINT64; - // Preparing properties for IP seperately because of unique values + // Preparing properties for IP separately because of unique values strcpy_s(metricProperties.name, ZET_MAX_METRIC_NAME, "IP"); strcpy_s(metricProperties.description, ZET_MAX_METRIC_DESCRIPTION, "IP address"); metricProperties.metricType = ZET_METRIC_TYPE_IP; @@ -140,6 +140,7 @@ ze_result_t IpSamplingMetricSourceImp::metricGroupGet(uint32_t *pCount, zet_metr } ze_result_t IpSamplingMetricSourceImp::appendMetricMemoryBarrier(CommandList &commandList) { + METRICS_LOG_ERR("%s", "Memory barrier not supported for IP Sampling"); return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } @@ -147,6 +148,7 @@ ze_result_t IpSamplingMetricSourceImp::activateMetricGroupsPreferDeferred(uint32 zet_metric_group_handle_t *phMetricGroups) { auto status = activationTracker->activateMetricGroupsDeferred(count, phMetricGroups); if (!status) { + METRICS_LOG_ERR("%s", "Metric group activation failed"); return ZE_RESULT_ERROR_UNKNOWN; } return ZE_RESULT_SUCCESS; @@ -252,7 +254,6 @@ ze_result_t IpSamplingMetricSourceImp::calcOperationCreate(MetricDeviceContext & // All metrics in Ip sampling allow calculation *pCount = 0; - *phExcludedMetrics = nullptr; bool isMultiDevice = (metricDeviceContext.isImplicitScalingCapable()) ? true : false; status = IpSamplingMetricCalcOpImp::create(*this, pCalculateDesc, isMultiDevice, phCalculateOperation); @@ -305,7 +306,7 @@ ze_result_t IpSamplingMetricGroupImp::metricGet(uint32_t *pCount, zet_metric_han return ZE_RESULT_SUCCESS; } -bool IpSamplingMetricGroupImp::isMultiDeviceCaptureData(const size_t rawDataSize, const uint8_t *pRawData) { +bool IpSamplingMetricGroupBase::isMultiDeviceCaptureData(const size_t rawDataSize, const uint8_t *pRawData) { if (rawDataSize >= sizeof(IpSamplingMetricDataHeader)) { const auto header = reinterpret_cast(pRawData); return header->magic == IpSamplingMetricDataHeader::magicValue; @@ -319,8 +320,8 @@ ze_result_t IpSamplingMetricGroupImp::calculateMetricValues(const zet_metric_gro const bool calculateCountOnly = *pMetricValueCount == 0; if (isMultiDeviceCaptureData(rawDataSize, pRawData)) { - METRICS_LOG_INFO("%s", "The call is not supported for multiple devices"); - METRICS_LOG_INFO("%s", "Please use zetMetricGroupCalculateMultipleMetricValuesExp instead"); + METRICS_LOG_ERR("%s", "The call is not supported for multiple devices"); + METRICS_LOG_ERR("%s", "Please use zetMetricGroupCalculateMultipleMetricValuesExp instead"); return ZE_RESULT_ERROR_INVALID_ARGUMENT; } @@ -404,6 +405,8 @@ ze_result_t IpSamplingMetricGroupImp::getCalculatedMetricCount(const uint8_t *pR constexpr uint32_t rawReportSize = IpSamplingMetricGroupBase::rawReportSize; if ((rawDataSize % rawReportSize) != 0) { + METRICS_LOG_ERR("%s", "Invalid input raw data size"); + metricValueCount = 0; return ZE_RESULT_ERROR_INVALID_SIZE; } @@ -494,6 +497,7 @@ ze_result_t IpSamplingMetricGroupImp::getCalculatedMetricValues(const zet_metric // MAX_METRIC_VALUES is not supported yet. if (type != ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES) { + METRICS_LOG_ERR("%s", "IP sampling only supports ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES"); return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } @@ -502,6 +506,8 @@ ze_result_t IpSamplingMetricGroupImp::getCalculatedMetricValues(const zet_metric const uint32_t rawReportSize = IpSamplingMetricGroupBase::rawReportSize; if ((rawDataSize % rawReportSize) != 0) { + METRICS_LOG_ERR("%s", "Invalid input raw data size"); + metricValueCount = 0; return ZE_RESULT_ERROR_INVALID_SIZE; } 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 3d883d9fb1..7d27dc03bf 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_source.h +++ b/level_zero/tools/source/metrics/metric_ip_sampling_source.h @@ -100,6 +100,9 @@ struct IpSamplingMetricGroupBase : public MetricGroupImp { ze_result_t destroy() override { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } + + static bool isMultiDeviceCaptureData(const size_t rawDataSize, const uint8_t *pRawData); + IpSamplingMetricSourceImp &getMetricSource() { return static_cast(metricSource); } }; struct IpSamplingMetricGroupImp : public IpSamplingMetricGroupBase { @@ -127,20 +130,18 @@ struct IpSamplingMetricGroupImp : public IpSamplingMetricGroupBase { zet_metric_streamer_handle_t *phMetricStreamer) override; static std::unique_ptr create(IpSamplingMetricSourceImp &metricSource, std::vector &ipSamplingMetrics); - IpSamplingMetricSourceImp &getMetricSource() { return static_cast(metricSource); } - ze_result_t getCalculatedMetricCount(const uint8_t *pMultiMetricData, const size_t rawDataSize, uint32_t &metricValueCount, const uint32_t setIndex); ze_result_t getCalculatedMetricValues(const zet_metric_group_calculation_type_t type, const size_t rawDataSize, const uint8_t *pMultiMetricData, uint32_t &metricValueCount, zet_typed_value_t *pCalculatedData, const uint32_t setIndex); + ze_result_t getCalculatedMetricCount(const uint8_t *pRawData, const size_t rawDataSize, uint32_t &metricValueCount); + ze_result_t getCalculatedMetricCount(const uint8_t *pMultiMetricData, const size_t rawDataSize, uint32_t &metricValueCount, const uint32_t setIndex); private: std::vector> metrics = {}; zet_metric_group_properties_t properties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr}; - ze_result_t getCalculatedMetricCount(const uint8_t *pRawData, const size_t rawDataSize, uint32_t &metricValueCount); ze_result_t getCalculatedMetricValues(const zet_metric_group_calculation_type_t type, const size_t rawDataSize, const uint8_t *pRawData, uint32_t &metricValueCount, zet_typed_value_t *pCalculatedData); - bool isMultiDeviceCaptureData(const size_t rawDataSize, const uint8_t *pRawData); }; struct MultiDeviceIpSamplingMetricGroupImp : public IpSamplingMetricGroupBase { 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 ca74effa9f..5e30f51aad 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_streamer.cpp +++ b/level_zero/tools/source/metrics/metric_ip_sampling_streamer.cpp @@ -7,7 +7,11 @@ #include "level_zero/tools/source/metrics/metric_ip_sampling_streamer.h" +#include "shared/source/execution_environment/root_device_environment.h" + #include "level_zero/core/source/device/device.h" +#include "level_zero/core/source/device/device_imp.h" +#include "level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper.h" #include "level_zero/tools/source/metrics/metric.h" #include "level_zero/tools/source/metrics/metric_ip_sampling_source.h" #include "level_zero/tools/source/metrics/os_interface_metric.h" @@ -115,19 +119,23 @@ ze_result_t IpSamplingMetricCalcOpImp::create(IpSamplingMetricSourceImp &metricS std::vector hMetrics(metricCount); MetricGroup::fromHandle(hMetricGroup)->metricGet(&metricCount, hMetrics.data()); std::vector inputMetricsInReport = {}; + 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); + includedMetricIndexes.push_back(i); } else { if (uniqueMetricHandles.find(hMetrics[i]) != uniqueMetricHandles.end()) { inputMetricsInReport.push_back(metric); + includedMetricIndexes.push_back(i); } } } - auto calcOp = new IpSamplingMetricCalcOpImp(inputMetricsInReport, isMultiDevice); + auto calcOp = new IpSamplingMetricCalcOpImp(static_cast(hMetrics.size()), + inputMetricsInReport, includedMetricIndexes, isMultiDevice); *phCalculateOperation = calcOp->toHandle(); return ZE_RESULT_SUCCESS; } @@ -140,22 +148,156 @@ ze_result_t IpSamplingMetricCalcOpImp::destroy() { ze_result_t IpSamplingMetricCalcOpImp::getReportFormat(uint32_t *pCount, zet_metric_handle_t *phMetrics) { if (*pCount == 0) { - *pCount = metricCount; + *pCount = metricsInReportCount; return ZE_RESULT_SUCCESS; - } else if (*pCount < metricCount) { + } 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 = metricCount; - for (uint32_t index = 0; index < metricCount; index++) { + *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, + bool *dataOVerflow, + bool allowInterrupt, + uint32_t requestedReportCount) { + + const uint32_t rawReportSize = IpSamplingMetricGroupBase::rawReportSize; + *processedSize = 0; + + uint32_t processedReportCount = 0; + const uint8_t *dataToProcess = pRawData; + do { + + *dataOVerflow |= l0GfxCoreHelper.stallIpDataMapUpdate(stallReportDataMap, dataToProcess); + *processedSize += rawReportSize; + dataToProcess += rawReportSize; + // Number of reports is defined by the number of IPs in the raw data. + processedReportCount = static_cast(stallReportDataMap.size()); + } while ((*processedSize < rawDataSize) && + (!allowInterrupt || (processedReportCount < requestedReportCount))); + + return; +} + +ze_result_t IpSamplingMetricCalcOpImp::metricCalculateValuesSingle(const size_t rawDataSize, size_t *pOffset, const uint8_t *pRawData, + uint32_t *pTotalMetricReportCount, + L0::L0GfxCoreHelper &l0GfxCoreHelper, + IpSamplingMetricGroupBase *metricGroupBase, + bool getSize, + bool &dataOverflow, + std::map &stallReportDataMap) { + ze_result_t status = ZE_RESULT_ERROR_UNKNOWN; + uint32_t resultCount = 0; + *pOffset = 0; + + status = static_cast(metricGroupBase)->getCalculatedMetricCount(pRawData, rawDataSize, resultCount); + if (status != ZE_RESULT_SUCCESS) { + *pTotalMetricReportCount = 0; + return status; + } + + uint32_t rawDataReportCount = resultCount / cachedMetricsCount; + + if (getSize) { + *pTotalMetricReportCount = rawDataReportCount; + return ZE_RESULT_SUCCESS; + } + + // Only allow interrupting when requesting less reports than available since it affects the bytes + // processed: report count can be reached before processing all data. + bool allowInterrupt = false; + if (*pTotalMetricReportCount < rawDataReportCount) { + allowInterrupt = true; + } + + fillStallDataMap(rawDataSize, pRawData, pOffset, l0GfxCoreHelper, stallReportDataMap, + &dataOverflow, allowInterrupt, *pTotalMetricReportCount); + + *pTotalMetricReportCount = static_cast(stallReportDataMap.size()); + return status; +} + +ze_result_t IpSamplingMetricCalcOpImp::metricCalculateValuesMulti(const size_t rawDataSize, size_t *pOffset, const uint8_t *pRawData, + uint32_t *pTotalMetricReportCount, + L0::L0GfxCoreHelper &l0GfxCoreHelper, + IpSamplingMetricGroupBase *metricGroupBase, + bool getSize, + uint32_t numSubDevices, + bool &dataOverflow, + std::map &stallReportDataMap) { + ze_result_t status = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + return status; +} + +ze_result_t IpSamplingMetricCalcOpImp::metricCalculateValues(const size_t rawDataSize, size_t *pOffset, const uint8_t *pRawData, + uint32_t *pTotalMetricReportCount, + zet_intel_metric_result_exp_t *pMetricResults) { + ze_result_t status = ZE_RESULT_ERROR_UNKNOWN; + bool dataOverflow = false; + uint32_t metricGroupCount = 1; + zet_metric_group_handle_t hMetricGroup = {}; + metricsInReport[0]->getMetricSource().metricGroupGet(&metricGroupCount, &hMetricGroup); + bool isMultiDeviceData = IpSamplingMetricGroupBase::isMultiDeviceCaptureData(rawDataSize, pRawData); + + IpSamplingMetricGroupBase *metricGroupBase = static_cast(MetricGroup::fromHandle(hMetricGroup)); + DeviceImp *deviceImp = static_cast(&metricGroupBase->getMetricSource().getMetricDeviceContext().getDevice()); + L0::L0GfxCoreHelper &l0GfxCoreHelper = deviceImp->getNEODevice()->getRootDeviceEnvironment().getHelper(); + + pRawData += *pOffset; // Input Offset + + bool getSize = (*pTotalMetricReportCount == 0); + std::map stallReportDataMap; + + if (!isMultiDevice) { + if (isMultiDeviceData) { + METRICS_LOG_ERR("%s", "Cannot use root device raw data in a sub-device calculate operation handle"); + return ZE_RESULT_ERROR_INVALID_ARGUMENT; + } + + status = metricCalculateValuesSingle(rawDataSize, pOffset, pRawData, pTotalMetricReportCount, + l0GfxCoreHelper, metricGroupBase, getSize, dataOverflow, stallReportDataMap); + } else { + if (!isMultiDeviceData) { + METRICS_LOG_ERR("%s", "Cannot use sub-device raw data in a root device calculate operation handle"); + return ZE_RESULT_ERROR_INVALID_ARGUMENT; + } + + status = metricCalculateValuesMulti(rawDataSize, pOffset, pRawData, pTotalMetricReportCount, + l0GfxCoreHelper, metricGroupBase, getSize, deviceImp->numSubDevices, + dataOverflow, stallReportDataMap); + } + + if ((status != ZE_RESULT_SUCCESS) || (getSize)) { + return status; + } + + std::vector ipDataValues; + uint32_t i = 0; + for (auto it = stallReportDataMap.begin(); it != stallReportDataMap.end(); ++it) { + l0GfxCoreHelper.stallSumIpDataToTypedValues(it->first, it->second, ipDataValues); + for (uint32_t j = 0; j < includedMetricIndexes.size(); j++) { + (pMetricResults + i)->value = ipDataValues[includedMetricIndexes[j]].value; + (pMetricResults + i)->resultStatus = ZET_INTEL_METRIC_CALCULATE_EXP_RESULT_VALID; + i++; + } + ipDataValues.clear(); + } + l0GfxCoreHelper.stallIpDataMapDelete(stallReportDataMap); + stallReportDataMap.clear(); + + return dataOverflow ? ZE_RESULT_WARNING_DROPPED_DATA : 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 fc6a06ec9f..2f5c26f6c4 100644 --- a/level_zero/tools/source/metrics/metric_ip_sampling_streamer.h +++ b/level_zero/tools/source/metrics/metric_ip_sampling_streamer.h @@ -14,6 +14,9 @@ namespace L0 { class IpSamplingMetricSourceImp; struct IpSamplingMetricImp; +struct IpSamplingMetricGroupBase; +struct IpSamplingMetricGroupImp; +class L0GfxCoreHelper; struct IpSamplingMetricStreamerBase : public MetricStreamer { ze_result_t appendStreamerMarker(CommandList &commandList, uint32_t value) override { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } @@ -45,10 +48,13 @@ struct MultiDeviceIpSamplingMetricStreamerImp : public IpSamplingMetricStreamerB }; struct IpSamplingMetricCalcOpImp : public MetricCalcOpImp { - IpSamplingMetricCalcOpImp(std::vector &inputMetricsInReport, - bool multidevice) : MetricCalcOpImp(multidevice), - metricCount(static_cast(inputMetricsInReport.size())), - metricsInReport(inputMetricsInReport) {} + IpSamplingMetricCalcOpImp(uint32_t inputCachedMetricsCount, std::vector &inputMetricsInReport, + std::vector &inputIncludedMetricIndexes, bool multidevice) + : MetricCalcOpImp(multidevice), + cachedMetricsCount(inputCachedMetricsCount), + metricsInReportCount(static_cast(inputMetricsInReport.size())), + metricsInReport(inputMetricsInReport), + includedMetricIndexes(inputIncludedMetricIndexes) {} ~IpSamplingMetricCalcOpImp() override{}; static ze_result_t create(IpSamplingMetricSourceImp &metricSource, @@ -57,16 +63,44 @@ struct IpSamplingMetricCalcOpImp : public MetricCalcOpImp { 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(size_t rawDataSize, size_t *offset, const uint8_t *pRawData, + ze_result_t metricCalculateMultipleValues(const 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; } + ze_result_t metricCalculateValues(const size_t rawDataSize, size_t *pOffset, const uint8_t *pRawData, + uint32_t *pTotalMetricReportCount, + zet_intel_metric_result_exp_t *pMetricResults) override; + + void fillStallDataMap(const size_t rawDataSize, const uint8_t *pRawData, size_t *processedSize, + L0GfxCoreHelper &l0GfxCoreHelper, + std::map &stallReportDataMap, + bool *dataOVerflow, + bool allowInterrupt, + uint32_t requestedReportCount); protected: - uint32_t metricCount = 0; + ze_result_t metricCalculateValuesSingle(const size_t rawDataSize, size_t *pOffset, const uint8_t *pRawData, + uint32_t *pTotalMetricReportCount, + L0::L0GfxCoreHelper &l0GfxCoreHelper, + IpSamplingMetricGroupBase *metricGroupBase, + bool getSize, + bool &dataOverflow, + std::map &stallReportDataMap); + ze_result_t metricCalculateValuesMulti(const size_t rawDataSize, size_t *pOffset, const uint8_t *pRawData, + uint32_t *pTotalMetricReportCount, + L0::L0GfxCoreHelper &l0GfxCoreHelper, + IpSamplingMetricGroupBase *metricGroupBase, + bool getSize, + uint32_t numSubDevices, + bool &dataOverflow, + std::map &stallReportDataMap); + + uint32_t cachedMetricsCount = 0; + uint32_t metricsInReportCount = 0; std::vector metricsInReport{}; + std::vector includedMetricIndexes{}; }; } // namespace L0 diff --git a/level_zero/tools/source/metrics/metric_oa_enumeration_imp.cpp b/level_zero/tools/source/metrics/metric_oa_enumeration_imp.cpp index f8804097a0..1bb60cb003 100644 --- a/level_zero/tools/source/metrics/metric_oa_enumeration_imp.cpp +++ b/level_zero/tools/source/metrics/metric_oa_enumeration_imp.cpp @@ -855,8 +855,8 @@ ze_result_t OaMetricGroupImp::calculateMetricValues(const zet_metric_group_calcu const MetricGroupCalculateHeader *pRawHeader = reinterpret_cast(pRawData); if (pRawHeader->magic == MetricGroupCalculateHeader::magicValue) { - METRICS_LOG_INFO("%s", "The call is not supported for multiple devices"); - METRICS_LOG_INFO("%s", "Please use zetMetricGroupCalculateMultipleMetricValuesExp instead"); + METRICS_LOG_ERR("%s", "The call is not supported for multiple devices"); + METRICS_LOG_ERR("%s", "Please use zetMetricGroupCalculateMultipleMetricValuesExp instead"); return ZE_RESULT_ERROR_INVALID_ARGUMENT; } 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 a9e4ab2793..f7c6b99882 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 @@ -79,7 +79,7 @@ class MetricIpSamplingFixture : public DeviceFixture, std::vector osInterfaceVector = {}; }; -class MetricIpSamplingCalculateMetricsFixture : public MetricIpSamplingMultiDevFixture { +class MetricIpSamplingCalculateBaseFixture { public: void addHeader(uint8_t *rawDataOut, size_t rawDataOutSize, uint8_t *rawDataIn, size_t rawDataInSize, uint32_t setIndex) { @@ -90,19 +90,26 @@ class MetricIpSamplingCalculateMetricsFixture : public MetricIpSamplingMultiDevF header->magic = IpSamplingMetricDataHeader::magicValue; header->rawDataSize = static_cast(rawDataInSize); header->setIndex = setIndex; - memcpy_s(rawDataOut + sizeof(IpSamplingMetricDataHeader), rawDataOutSize, rawDataIn, rawDataInSize); + memcpy_s(rawDataOut + sizeof(IpSamplingMetricDataHeader), rawDataOutSize - sizeof(IpSamplingMetricDataHeader), + rawDataIn, rawDataInSize); } } std::vector rawDataVector = {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1000, 0x01}, - {1, 9, 8, 7, 6, 5, 4, 3, 2, 1, 1000, 0x02}, {10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 1001, 0x000}, - {10, 90, 80, 70, 60, 50, 40, 30, 20, 10, 1000, 0x3}}; + {1, 9, 8, 7, 6, 5, 4, 3, 2, 1, 1000, 0x02}, + {10, 90, 80, 70, 60, 50, 40, 30, 20, 10, 1000, 0x3}, + {100, 190, 180, 170, 160, 150, 140, 130, 120, 110, 1000, 0x3}, + {100, 20, 30, 40, 50, 60, 70, 80, 90, 100, 1000, 0x3}}; + + std::vector expectedMetricNamesInReport = {"IP", "Active", "ControlStall", "PipeStall", + "SendStall", "DistStall", "SbidStall", "SyncStall", + "InstrFetchStall", "OtherStall"}; size_t rawDataVectorSize = sizeof(rawDataVector[0]) * rawDataVector.size(); std::vector expectedMetricValues = { {ZET_VALUE_TYPE_UINT64, {1}}, - {ZET_VALUE_TYPE_UINT64, {11}}, + {ZET_VALUE_TYPE_UINT64, {11}}, // 1st raw report + 3rd raw report {ZET_VALUE_TYPE_UINT64, {11}}, {ZET_VALUE_TYPE_UINT64, {11}}, {ZET_VALUE_TYPE_UINT64, {11}}, @@ -112,6 +119,7 @@ class MetricIpSamplingCalculateMetricsFixture : public MetricIpSamplingMultiDevF {ZET_VALUE_TYPE_UINT64, {11}}, {ZET_VALUE_TYPE_UINT64, {11}}, {ZET_VALUE_TYPE_UINT64, {10}}, + {ZET_VALUE_TYPE_UINT64, {110}}, // 2nd raw report + 4th raw report {ZET_VALUE_TYPE_UINT64, {110}}, {ZET_VALUE_TYPE_UINT64, {110}}, {ZET_VALUE_TYPE_UINT64, {110}}, @@ -120,7 +128,74 @@ class MetricIpSamplingCalculateMetricsFixture : public MetricIpSamplingMultiDevF {ZET_VALUE_TYPE_UINT64, {110}}, {ZET_VALUE_TYPE_UINT64, {110}}, {ZET_VALUE_TYPE_UINT64, {110}}, - {ZET_VALUE_TYPE_UINT64, {110}}}; + {ZET_VALUE_TYPE_UINT64, {100}}, + {ZET_VALUE_TYPE_UINT64, {210}}, // 5th raw report + 6th raw report + {ZET_VALUE_TYPE_UINT64, {210}}, + {ZET_VALUE_TYPE_UINT64, {210}}, + {ZET_VALUE_TYPE_UINT64, {210}}, + {ZET_VALUE_TYPE_UINT64, {210}}, + {ZET_VALUE_TYPE_UINT64, {210}}, + {ZET_VALUE_TYPE_UINT64, {210}}, + {ZET_VALUE_TYPE_UINT64, {210}}, + {ZET_VALUE_TYPE_UINT64, {210}}}; + + std::vector interruptedExpectedMetricValues12 = { + {ZET_VALUE_TYPE_UINT64, {1}}, + {ZET_VALUE_TYPE_UINT64, {2}}, + {ZET_VALUE_TYPE_UINT64, {4}}, + {ZET_VALUE_TYPE_UINT64, {5}}, + {ZET_VALUE_TYPE_UINT64, {6}}, + {ZET_VALUE_TYPE_UINT64, {7}}, + {ZET_VALUE_TYPE_UINT64, {8}}, + {ZET_VALUE_TYPE_UINT64, {9}}, + {ZET_VALUE_TYPE_UINT64, {10}}, + {ZET_VALUE_TYPE_UINT64, {3}}, // L0GfxCoreHelperHw arranges "OtherStall" to the end + {ZET_VALUE_TYPE_UINT64, {10}}, + {ZET_VALUE_TYPE_UINT64, {20}}, + {ZET_VALUE_TYPE_UINT64, {40}}, + {ZET_VALUE_TYPE_UINT64, {50}}, + {ZET_VALUE_TYPE_UINT64, {60}}, + {ZET_VALUE_TYPE_UINT64, {70}}, + {ZET_VALUE_TYPE_UINT64, {80}}, + {ZET_VALUE_TYPE_UINT64, {90}}, + {ZET_VALUE_TYPE_UINT64, {100}}, + {ZET_VALUE_TYPE_UINT64, {30}} // L0GfxCoreHelperHw arranges "OtherStall" to the end + }; + + std::vector interruptedExpectedMetricValues3 = { + {ZET_VALUE_TYPE_UINT64, {1}}, + {ZET_VALUE_TYPE_UINT64, {9}}, + {ZET_VALUE_TYPE_UINT64, {7}}, + {ZET_VALUE_TYPE_UINT64, {6}}, + {ZET_VALUE_TYPE_UINT64, {5}}, + {ZET_VALUE_TYPE_UINT64, {4}}, + {ZET_VALUE_TYPE_UINT64, {3}}, + {ZET_VALUE_TYPE_UINT64, {2}}, + {ZET_VALUE_TYPE_UINT64, {1}}, + {ZET_VALUE_TYPE_UINT64, {8}} // L0GfxCoreHelperHw arranges "OtherStall" to the end + }; + + std::vector interruptedExpectedMetricValues456 = { + {ZET_VALUE_TYPE_UINT64, {10}}, // 4rd raw report + {ZET_VALUE_TYPE_UINT64, {90}}, + {ZET_VALUE_TYPE_UINT64, {70}}, + {ZET_VALUE_TYPE_UINT64, {60}}, + {ZET_VALUE_TYPE_UINT64, {50}}, + {ZET_VALUE_TYPE_UINT64, {40}}, + {ZET_VALUE_TYPE_UINT64, {30}}, + {ZET_VALUE_TYPE_UINT64, {20}}, + {ZET_VALUE_TYPE_UINT64, {10}}, + {ZET_VALUE_TYPE_UINT64, {80}}, // L0GfxCoreHelperHw arranges "OtherStall" to the end + {ZET_VALUE_TYPE_UINT64, {100}}, + {ZET_VALUE_TYPE_UINT64, {210}}, // 5th raw report + th raw report + {ZET_VALUE_TYPE_UINT64, {210}}, + {ZET_VALUE_TYPE_UINT64, {210}}, + {ZET_VALUE_TYPE_UINT64, {210}}, + {ZET_VALUE_TYPE_UINT64, {210}}, + {ZET_VALUE_TYPE_UINT64, {210}}, + {ZET_VALUE_TYPE_UINT64, {210}}, + {ZET_VALUE_TYPE_UINT64, {210}}, + {ZET_VALUE_TYPE_UINT64, {210}}}; std::vector rawDataVectorOverflow = {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1000, 0x01}, {1, 9, 8, 7, 6, 5, 4, 3, 2, 1, 1000, 0x02}, @@ -151,5 +226,10 @@ class MetricIpSamplingCalculateMetricsFixture : public MetricIpSamplingMultiDevF {ZET_VALUE_TYPE_UINT64, {110}}}; }; +struct MetricIpSamplingCalculateSingleDevFixture : public MetricIpSamplingCalculateBaseFixture, MetricIpSamplingFixture { +}; +struct MetricIpSamplingCalculateMultiDevFixture : public MetricIpSamplingCalculateBaseFixture, MetricIpSamplingMultiDevFixture { +}; + } // namespace ult } // namespace L0 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 81281cf396..a3d1fcf2c2 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 @@ -164,10 +164,17 @@ class MockMetricCalcOp : public MetricCalcOpImp { ze_result_t getReportFormat(uint32_t *pCount, zet_metric_handle_t *phMetrics) override { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; }; - ze_result_t metricCalculateMultipleValues(size_t rawDataSize, size_t *offset, const uint8_t *pRawData, + ze_result_t metricCalculateMultipleValues(const size_t rawDataSize, size_t *offset, const uint8_t *pRawData, uint32_t *pSetCount, uint32_t *pMetricReportCountPerSet, uint32_t *pTotalMetricReportCount, - zet_intel_metric_result_exp_t *pMetricResults) override { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; }; + zet_intel_metric_result_exp_t *pMetricResults) override { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + }; + ze_result_t metricCalculateValues(const size_t rawDataSize, size_t *pOffset, const uint8_t *pRawData, + uint32_t *pTotalMetricReportCount, + zet_intel_metric_result_exp_t *pMetricResults) override { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + }; }; class MockMetricDeviceContext : public MetricDeviceContext { 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 a4472b13a8..268e0073e5 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 @@ -502,7 +502,7 @@ HWTEST2_F(MetricIpSamplingTimestampTest, GivenGetGpuCpuTimeIsFalseWhenReadingMet EXPECT_EQ(metricTimestamp, 0UL); } -using MetricIpSamplingCalculateMetricsTest = MetricIpSamplingCalculateMetricsFixture; +using MetricIpSamplingCalculateMetricsTest = MetricIpSamplingCalculateMultiDevFixture; HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCalculateMultipleMetricValuesExpIsCalledThenValidDataIsReturned, EustallSupportedPlatforms) { EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi()); @@ -541,14 +541,14 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen &setCount, &totalMetricValueCount, metricCounts.data(), nullptr), ZE_RESULT_SUCCESS); EXPECT_EQ(setCount, expectedSetCount); - EXPECT_EQ(totalMetricValueCount, 20u); + EXPECT_EQ(totalMetricValueCount, 30u); // Three IPs plus nine metrics per IP EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size(), reinterpret_cast(rawDataWithHeader.data()), &setCount, &totalMetricValueCount, metricCounts.data(), metricValues.data()), ZE_RESULT_SUCCESS); EXPECT_EQ(setCount, expectedSetCount); - EXPECT_EQ(totalMetricValueCount, 20u); - EXPECT_EQ(metricCounts[0], 20u); + EXPECT_EQ(totalMetricValueCount, 30u); + EXPECT_EQ(metricCounts[0], 30u); for (uint32_t i = 0; i < totalMetricValueCount; i++) { EXPECT_TRUE(expectedMetricValues[i].type == metricValues[i].type); EXPECT_TRUE(expectedMetricValues[i].value.ui64 == metricValues[i].value.ui64); @@ -628,14 +628,14 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen &setCount, &totalMetricValueCount, metricCounts.data(), nullptr), ZE_RESULT_SUCCESS); EXPECT_EQ(setCount, expectedSetCount); - EXPECT_EQ(totalMetricValueCount, 20u); + EXPECT_EQ(totalMetricValueCount, 30u); EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataVectorSize, reinterpret_cast(rawDataVector.data()), &setCount, &totalMetricValueCount, metricCounts.data(), metricValues.data()), ZE_RESULT_SUCCESS); EXPECT_EQ(setCount, expectedSetCount); - EXPECT_EQ(totalMetricValueCount, 20u); - EXPECT_EQ(metricCounts[0], 20u); + EXPECT_EQ(totalMetricValueCount, 30u); + EXPECT_EQ(metricCounts[0], 30u); for (uint32_t i = 0; i < totalMetricValueCount; i++) { EXPECT_TRUE(expectedMetricValues[i].type == metricValues[i].type); EXPECT_TRUE(expectedMetricValues[i].value.ui64 == metricValues[i].value.ui64); @@ -716,7 +716,7 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen &setCount, &totalMetricValueCount, metricCounts.data(), nullptr), ZE_RESULT_SUCCESS); EXPECT_EQ(setCount, expectedSetCount); - EXPECT_EQ(totalMetricValueCount, 40u); + EXPECT_EQ(totalMetricValueCount, 60u); totalMetricValueCount = 10; EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size(), @@ -895,7 +895,7 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen &setCount, &totalMetricValueCount, metricCounts.data(), nullptr), ZE_RESULT_SUCCESS); EXPECT_EQ(setCount, expectedSetCount); - EXPECT_EQ(totalMetricValueCount, 20u); + EXPECT_EQ(totalMetricValueCount, 30u); totalMetricValueCount += 1; EXPECT_EQ(L0::zetMetricGroupCalculateMultipleMetricValuesExp(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataWithHeader.size() + 1, reinterpret_cast(rawDataWithHeader.data()), @@ -926,11 +926,11 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataVectorSize, reinterpret_cast(rawDataVector.data()), &metricValueCount, nullptr), ZE_RESULT_SUCCESS); - EXPECT_TRUE(metricValueCount == 20); + EXPECT_TRUE(metricValueCount == 30); EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataVectorSize, reinterpret_cast(rawDataVector.data()), &metricValueCount, metricValues.data()), ZE_RESULT_SUCCESS); - EXPECT_TRUE(metricValueCount == 20); + EXPECT_TRUE(metricValueCount == 30); for (uint32_t i = 0; i < metricValueCount; i++) { EXPECT_TRUE(expectedMetricValues[i].type == metricValues[i].type); EXPECT_TRUE(expectedMetricValues[i].value.ui64 == metricValues[i].value.ui64); @@ -988,7 +988,7 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataVectorSize, reinterpret_cast(rawDataVector.data()), &metricValueCount, nullptr), ZE_RESULT_SUCCESS); - EXPECT_TRUE(metricValueCount == 20); + EXPECT_TRUE(metricValueCount == 30); metricValueCount = 15; EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataVectorSize, reinterpret_cast(rawDataVector.data()), &metricValueCount, metricValues.data()), @@ -1046,7 +1046,7 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhen EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataVectorSize, reinterpret_cast(rawDataVector.data()), &metricValueCount, nullptr), ZE_RESULT_SUCCESS); - EXPECT_TRUE(metricValueCount == 20); + EXPECT_TRUE(metricValueCount == 30); EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataVectorSize - 1, reinterpret_cast(rawDataVector.data()), &metricValueCount, metricValues.data()), ZE_RESULT_ERROR_INVALID_SIZE); @@ -1125,189 +1125,13 @@ HWTEST2_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWith EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataVectorSize, reinterpret_cast(rawDataVector.data()), &metricValueCount, nullptr), ZE_RESULT_SUCCESS); - EXPECT_TRUE(metricValueCount == 20); + EXPECT_TRUE(metricValueCount == 30); EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroups[0], ZET_METRIC_GROUP_CALCULATION_TYPE_MAX_METRIC_VALUES, rawDataVectorSize, reinterpret_cast(rawDataVector.data()), &metricValueCount, metricValues.data()), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE); } } -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)); - 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, givenIpSamplingCalcOpCanGetReportFormat, 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)); - - uint32_t metricsInReportCount = 0; - EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation, &metricsInReportCount, nullptr)); - EXPECT_EQ(metricsInReportCount, 10u); - - std::vector metricsInReport(metricsInReportCount); - EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation, &metricsInReportCount, metricsInReport.data())); - EXPECT_EQ(metricsInReportCount, 10u); - - zet_metric_properties_t ipSamplingMetricProperties = {}; - EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGetProperties(metricsInReport[0], &ipSamplingMetricProperties)); - EXPECT_EQ(strcmp(ipSamplingMetricProperties.name, "IP"), 0); - - // Can't filter metrics in report - metricsInReportCount = 1; - EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation, &metricsInReportCount, metricsInReport.data())); - - 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()); 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 e5847a28f5..9a883ff443 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 @@ -8,8 +8,11 @@ #include "shared/test/common/test_macros/test_base.h" #include "level_zero/core/source/cmdlist/cmdlist.h" +#include "level_zero/core/source/device/device.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/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/metric_ip_sampling_fixture.h" @@ -545,5 +548,685 @@ TEST_F(MetricIpSamplingStreamerTest, whenGetConcurrentMetricGroupsIsCalledThenCo } } +using MetricIpSamplingCalcOpMultiDevTest = MetricIpSamplingCalculateMultiDevFixture; + +HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, 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(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingCalcOpCanGetReportFormat, 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)); + + uint32_t metricsInReportCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation, &metricsInReportCount, nullptr)); + EXPECT_EQ(metricsInReportCount, 10u); + + std::vector metricsInReport(metricsInReportCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation, &metricsInReportCount, metricsInReport.data())); + EXPECT_EQ(metricsInReportCount, 10u); + + zet_metric_properties_t ipSamplingMetricProperties = {}; + + for (uint32_t i = 0; i < metricsInReportCount; i++) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGetProperties(metricsInReport[i], &ipSamplingMetricProperties)); + EXPECT_EQ(strcmp(ipSamplingMetricProperties.name, expectedMetricNamesInReport[i].c_str()), 0); + } + + // Can't filter metrics in report + metricsInReportCount = 1; + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation, &metricsInReportCount, metricsInReport.data())); + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation)); + } +} + +HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingCalcOpGetReportFormatIncludesSelectedMetrics, 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); + + uint32_t metricCount = 0; + EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, nullptr), ZE_RESULT_SUCCESS); + EXPECT_EQ(metricCount, 10u); + std::vector phMetrics(metricCount); + EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, phMetrics.data()), ZE_RESULT_SUCCESS); + + std::vector metricsToCalculate; + + // select only odd metrics + for (uint32_t i = 0; i < metricCount; i++) { + if (i % 2) { + metricsToCalculate.push_back(phMetrics[i]); + } + } + + uint32_t metricsToCalculateCount = static_cast(metricsToCalculate.size()); + EXPECT_EQ(metricsToCalculateCount, 5u); + + zet_intel_metric_calculate_exp_desc_t calculateDesc{ + ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATE_DESC_EXP, + nullptr, // pNext + 0, // metricGroupCount + nullptr, // phMetricGroups + metricsToCalculateCount, // metricCount + metricsToCalculate.data(), // 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)); + + uint32_t metricsInReportCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation, &metricsInReportCount, nullptr)); + EXPECT_EQ(metricsInReportCount, 5u); + + std::vector metricsInReport(metricsInReportCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation, &metricsInReportCount, metricsInReport.data())); + EXPECT_EQ(metricsInReportCount, 5u); + + // Metrics must be in the report but can be in different order + for (auto metric : metricsToCalculate) { + auto it = std::find(metricsInReport.begin(), metricsInReport.end(), metric); + EXPECT_NE(it, metricsInReport.end()); + } + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation)); + } +} + +HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, 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); + } +} + +using MetricIpSamplingCalcOpTest = MetricIpSamplingCalculateSingleDevFixture; + +HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculateValuesOnSubDeviceThenSuccessIsReturned, 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_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)); + uint32_t metricsInReportCount = 10; + std::vector metricsInReport(metricsInReportCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation, + &metricsInReportCount, + metricsInReport.data())); + EXPECT_EQ(metricsInReportCount, 10u); + std::vector metricProperties(metricsInReportCount); + + for (uint32_t i = 0; i < metricsInReportCount; i++) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGetProperties(metricsInReport[i], &metricProperties[i])); + } + + uint32_t totalMetricReportCount = 0; + size_t offset = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, &offset, + reinterpret_cast(rawDataVector.data()), hCalculateOperation, + &totalMetricReportCount, nullptr)); + EXPECT_EQ(totalMetricReportCount, 3U); + std::vector metricResults(totalMetricReportCount * metricsInReportCount); + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, &offset, + reinterpret_cast(rawDataVector.data()), hCalculateOperation, + &totalMetricReportCount, metricResults.data())); + EXPECT_EQ(totalMetricReportCount, 3U); + EXPECT_EQ(offset, rawDataVectorSize); + + for (uint32_t i = 0; i < totalMetricReportCount; i++) { + for (uint32_t j = 0; j < metricsInReportCount; j++) { + uint32_t resultIndex = i * metricsInReportCount + j; + EXPECT_TRUE(metricProperties[j].resultType == expectedMetricValues[resultIndex].type); + EXPECT_TRUE(metricResults[resultIndex].value.ui64 == expectedMetricValues[resultIndex].value.ui64); + EXPECT_TRUE(metricResults[resultIndex].resultStatus == ZET_INTEL_METRIC_CALCULATE_EXP_RESULT_VALID); + } + } + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation)); +} + +HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculateValuesOnSubDevicedCanInterruptAndContinue, 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_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)); + uint32_t metricsInReportCount = 10; + std::vector metricsInReport(metricsInReportCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation, + &metricsInReportCount, + metricsInReport.data())); + EXPECT_EQ(metricsInReportCount, 10u); + std::vector metricProperties(metricsInReportCount); + + for (uint32_t i = 0; i < metricsInReportCount; i++) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGetProperties(metricsInReport[i], &metricProperties[i])); + } + + uint32_t totalMetricReportCount = 0; + size_t processedSize = 0; + size_t offset = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, &offset, + reinterpret_cast(rawDataVector.data()), hCalculateOperation, + &totalMetricReportCount, nullptr)); + EXPECT_EQ(totalMetricReportCount, 3U); + + // Request number of reports smaller than available + totalMetricReportCount = 2; + std::vector metricResults(totalMetricReportCount * metricsInReportCount); + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, &offset, + reinterpret_cast(rawDataVector.data()), hCalculateOperation, + &totalMetricReportCount, metricResults.data())); + EXPECT_EQ(totalMetricReportCount, 2U); + EXPECT_EQ(offset, IpSamplingMetricGroupBase::rawReportSize * 2); + processedSize += offset; + + for (uint32_t i = 0; i < totalMetricReportCount; i++) { + for (uint32_t j = 0; j < metricsInReportCount; j++) { + uint32_t resultIndex = i * metricsInReportCount + j; + EXPECT_TRUE(metricProperties[j].resultType == interruptedExpectedMetricValues12[resultIndex].type); + EXPECT_TRUE(metricResults[resultIndex].value.ui64 == interruptedExpectedMetricValues12[resultIndex].value.ui64); + EXPECT_TRUE(metricResults[resultIndex].resultStatus == ZET_INTEL_METRIC_CALCULATE_EXP_RESULT_VALID); + } + } + + // calculate one more report form the offset returned + offset = processedSize; + totalMetricReportCount = 1; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize - processedSize, &offset, + reinterpret_cast(rawDataVector.data()), hCalculateOperation, + &totalMetricReportCount, metricResults.data())); + EXPECT_EQ(totalMetricReportCount, 1U); + EXPECT_EQ(offset, IpSamplingMetricGroupBase::rawReportSize); + processedSize += offset; + EXPECT_EQ(processedSize, IpSamplingMetricGroupBase::rawReportSize * 3); + + for (uint32_t i = 0; i < totalMetricReportCount; i++) { + for (uint32_t j = 0; j < metricsInReportCount; j++) { + uint32_t resultIndex = i * metricsInReportCount + j; + EXPECT_TRUE(metricProperties[j].resultType == interruptedExpectedMetricValues3[resultIndex].type); + EXPECT_TRUE(metricResults[resultIndex].value.ui64 == interruptedExpectedMetricValues3[resultIndex].value.ui64); + EXPECT_TRUE(metricResults[resultIndex].resultStatus == ZET_INTEL_METRIC_CALCULATE_EXP_RESULT_VALID); + } + } + + // calculate remaining reports in raw data. + totalMetricReportCount = 4; // intentionally set to more than left available + metricResults.resize(totalMetricReportCount * metricsInReportCount); + + offset = processedSize; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize - processedSize, &offset, + reinterpret_cast(rawDataVector.data()), hCalculateOperation, + &totalMetricReportCount, metricResults.data())); + EXPECT_EQ(totalMetricReportCount, 2U); + EXPECT_EQ(offset, IpSamplingMetricGroupBase::rawReportSize * 3); + processedSize += offset; + EXPECT_EQ(processedSize, rawDataVectorSize); + + for (uint32_t i = 0; i < totalMetricReportCount; i++) { + for (uint32_t j = 0; j < metricsInReportCount; j++) { + uint32_t resultIndex = i * metricsInReportCount + j; + EXPECT_TRUE(metricProperties[j].resultType == interruptedExpectedMetricValues456[resultIndex].type); + EXPECT_TRUE(metricResults[resultIndex].value.ui64 == interruptedExpectedMetricValues456[resultIndex].value.ui64); + EXPECT_TRUE(metricResults[resultIndex].resultStatus == ZET_INTEL_METRIC_CALCULATE_EXP_RESULT_VALID); + } + } + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation)); +} + +HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCoverBoundaryConditionsOfFillStallDataMap, 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_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)); + uint32_t totalMetricReportCount = 0; + size_t offset = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, &offset, + reinterpret_cast(rawDataVector.data()), hCalculateOperation, + &totalMetricReportCount, nullptr)); + EXPECT_EQ(totalMetricReportCount, 3U); + + IpSamplingMetricCalcOpImp *calcop = static_cast(MetricCalcOpImp::fromHandle(hCalculateOperation)); + size_t rawDataSize = 0; + size_t processedSize = 0; + L0::L0GfxCoreHelper &l0GfxCoreHelper = neoDevice->getRootDeviceEnvironment().getHelper(); + std::map stallReportDataMap; + bool dataOverflow = false; + bool allowInterrupt = false; + uint32_t requestedReportCount = 0; + + // Allow interrupting but pass less than needed for the report count requested + rawDataSize = IpSamplingMetricGroupBase::rawReportSize; + allowInterrupt = true; + requestedReportCount = 2; + calcop->fillStallDataMap(rawDataSize, reinterpret_cast(rawDataVector.data()), &processedSize, + l0GfxCoreHelper, stallReportDataMap, &dataOverflow, + allowInterrupt, requestedReportCount); + + EXPECT_EQ(stallReportDataMap.size(), 1u); + EXPECT_EQ(processedSize, IpSamplingMetricGroupBase::rawReportSize); + EXPECT_TRUE(dataOverflow == false); + + // Sames as above but request just one report + requestedReportCount = 1; + calcop->fillStallDataMap(rawDataSize, reinterpret_cast(rawDataVector.data()), &processedSize, + l0GfxCoreHelper, stallReportDataMap, &dataOverflow, + allowInterrupt, requestedReportCount); + + EXPECT_EQ(stallReportDataMap.size(), 1u); + EXPECT_EQ(processedSize, IpSamplingMetricGroupBase::rawReportSize); + EXPECT_TRUE(dataOverflow == false); + + l0GfxCoreHelper.stallIpDataMapDelete(stallReportDataMap); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation)); +} + +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_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)); + 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; + // sub-device cal op does not accept root device data + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateValuesExp(rawDataWithHeader.size(), &offset, + reinterpret_cast(rawDataWithHeader.data()), hCalculateOperation, + &totalMetricReportCount, nullptr)); + + // invalid input raw data size + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_SIZE, zetIntelMetricCalculateValuesExp(rawDataVectorSize / 30, &offset, + reinterpret_cast(rawDataVector.data()), hCalculateOperation, + &totalMetricReportCount, nullptr)); + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation)); +} + +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_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)); + uint32_t totalMetricReportCount = 2; + size_t offset = 0; + std::vector metricResults(totalMetricReportCount * 10); + + EXPECT_EQ(ZE_RESULT_WARNING_DROPPED_DATA, zetIntelMetricCalculateValuesExp(rawDataVectorOverflowSize, &offset, + reinterpret_cast(rawDataVectorOverflow.data()), hCalculateOperation, + &totalMetricReportCount, metricResults.data())); + EXPECT_EQ(totalMetricReportCount, 2U); + EXPECT_EQ(offset, rawDataVectorOverflowSize); + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation)); +} + +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); + std::vector phMetrics(metricCount); + EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, phMetrics.data()), ZE_RESULT_SUCCESS); + + std::vector metricsToCalculate; + + // Select only odd index metrics. According to expectedMetricNamesInReport there are: + // "Active", "PipeStall" "DistStall", "SyncStall", "OtherStall" + for (uint32_t i = 0; i < metricCount; i++) { + if (i % 2) { + metricsToCalculate.push_back(phMetrics[i]); + } + } + + uint32_t metricsToCalculateCount = static_cast(metricsToCalculate.size()); + EXPECT_EQ(metricsToCalculateCount, 5u); + + zet_intel_metric_calculate_exp_desc_t calculateDesc{ + ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATE_DESC_EXP, + nullptr, // pNext + 0, // metricGroupCount + nullptr, // phMetricGroups + metricsToCalculateCount, // metricCount + metricsToCalculate.data(), // 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)); + uint32_t metricsInReportCount = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation, &metricsInReportCount, nullptr)); + EXPECT_EQ(metricsInReportCount, 5u); + + // calculate only one report and expect results follow the order of rawDataVector + uint32_t totalMetricReportCount = 1; + size_t offset = 0; + std::vector metricResults(totalMetricReportCount * metricsInReportCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, &offset, + reinterpret_cast(rawDataVector.data()), hCalculateOperation, + &totalMetricReportCount, metricResults.data())); + EXPECT_EQ(totalMetricReportCount, 1U); + EXPECT_EQ(offset, IpSamplingMetricGroupBase::rawReportSize); + + // Expect only odd index metrics results of the first report + for (uint32_t j = 0; j < metricsInReportCount; j++) { + EXPECT_TRUE(metricResults[j].value.ui64 == interruptedExpectedMetricValues12[j * 2 + 1].value.ui64); + } + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation)); +} + +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_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)); + + 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()), hCalculateOperation, + &totalMetricReportCount, nullptr)); + + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateValuesExp(rawDataVectorSize, &offset, + reinterpret_cast(rawDataVector.data()), hCalculateOperation, + &totalMetricReportCount, nullptr)); + + uint32_t setCount = 0; + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetIntelMetricCalculateMultipleValuesExp(rawDataVectorSize, &offset, + reinterpret_cast(rawDataVector.data()), + hCalculateOperation, &setCount, nullptr, + nullptr, nullptr)); + + EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation)); +} + } // namespace ult } // namespace L0 diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_tracer.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_tracer.cpp index 5115fd3baf..a55f8ae27d 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_tracer.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_tracer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2024 Intel Corporation + * Copyright (C) 2024-2025 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -7,6 +7,7 @@ #include "shared/test/common/test_macros/test.h" +#include "level_zero/include/level_zero/zet_intel_gpu_metric.h" #include #include "gtest/gtest.h" @@ -25,6 +26,10 @@ TEST(MetricTracerTest, WhenTracerRelatedApisAreCalledThenReturnUnsupportedFeatur EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetMetricDecoderDestroyExp(nullptr)); EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetMetricDecoderGetDecodableMetricsExp(nullptr, nullptr, nullptr)); EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetMetricTracerDecodeExp(nullptr, nullptr, nullptr, 0, nullptr, nullptr, nullptr, nullptr, nullptr)); + size_t rawDataSize = 0; + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetIntelMetricDecodeCalculateMultipleValuesExp(nullptr, + rawDataSize, nullptr, nullptr, nullptr, + nullptr, nullptr, nullptr, nullptr)); } } // namespace ult