From e72246a74db6a5bda6d6f5dd0bf551c7bcdf08af Mon Sep 17 00:00:00 2001 From: Piotr Maciejewski Date: Tue, 28 Jul 2020 14:23:47 +0200 Subject: [PATCH] Metric Api 1.0 : Max value for zetMetricGroupCalculateMetricValues. Change-Id: Ie9022630e71a4c2e6dadb76ca4ec87b38fd8dfa5 --- level_zero/api/tools/zet_metric.cpp | 13 +- level_zero/tools/source/metrics/metric.h | 2 +- .../source/metrics/metric_enumeration_imp.cpp | 38 ++-- .../source/metrics/metric_enumeration_imp.h | 4 +- .../sources/metrics/mock_metric_enumeration.h | 2 +- .../metrics/test_metric_enumeration.cpp | 171 ++++++++++++++++++ third_party/level_zero/zet_api_ext.h | 44 +++++ 7 files changed, 258 insertions(+), 16 deletions(-) diff --git a/level_zero/api/tools/zet_metric.cpp b/level_zero/api/tools/zet_metric.cpp index b5d7e815ff..0e0957fee9 100644 --- a/level_zero/api/tools/zet_metric.cpp +++ b/level_zero/api/tools/zet_metric.cpp @@ -66,7 +66,18 @@ zetMetricGroupCalculateMetricValues( const uint8_t *pRawData, uint32_t *pMetricValueCount, zet_typed_value_t *pMetricValues) { - return L0::MetricGroup::fromHandle(hMetricGroup)->calculateMetricValues(rawDataSize, pRawData, pMetricValueCount, pMetricValues); + return L0::MetricGroup::fromHandle(hMetricGroup)->calculateMetricValues(ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawDataSize, pRawData, pMetricValueCount, pMetricValues); +} + +__zedllexport ze_result_t __zecall +zetMetricGroupCalculateMetricValuesExt( + zet_metric_group_handle_t hMetricGroup, + zet_metric_group_calculation_type_t type, + size_t rawDataSize, + const uint8_t *pRawData, + uint32_t *pMetricValueCount, + zet_typed_value_t *pMetricValues) { + return L0::MetricGroup::fromHandle(hMetricGroup)->calculateMetricValues(type, rawDataSize, pRawData, pMetricValueCount, pMetricValues); } __zedllexport ze_result_t __zecall diff --git a/level_zero/tools/source/metrics/metric.h b/level_zero/tools/source/metrics/metric.h index 08581944c5..3f6d79c288 100644 --- a/level_zero/tools/source/metrics/metric.h +++ b/level_zero/tools/source/metrics/metric.h @@ -76,7 +76,7 @@ struct MetricGroup : _zet_metric_group_handle_t { virtual ze_result_t getProperties(zet_metric_group_properties_t *pProperties) = 0; virtual ze_result_t getPropertiesExt(zet_metric_group_properties_ext_t *pProperties) = 0; virtual ze_result_t getMetric(uint32_t *pCount, zet_metric_handle_t *phMetrics) = 0; - virtual ze_result_t calculateMetricValues(size_t rawDataSize, + virtual ze_result_t calculateMetricValues(const zet_metric_group_calculation_type_t type, size_t rawDataSize, const uint8_t *pRawData, uint32_t *pMetricValueCount, zet_typed_value_t *pMetricValues) = 0; diff --git a/level_zero/tools/source/metrics/metric_enumeration_imp.cpp b/level_zero/tools/source/metrics/metric_enumeration_imp.cpp index 037535b6e1..9bc0853dfb 100644 --- a/level_zero/tools/source/metrics/metric_enumeration_imp.cpp +++ b/level_zero/tools/source/metrics/metric_enumeration_imp.cpp @@ -487,13 +487,13 @@ ze_result_t MetricGroupImp::closeIoStream() { return (closeResult == MetricsDiscovery::CC_OK) ? ZE_RESULT_SUCCESS : ZE_RESULT_ERROR_UNKNOWN; } -ze_result_t MetricGroupImp::calculateMetricValues(size_t rawDataSize, +ze_result_t MetricGroupImp::calculateMetricValues(const zet_metric_group_calculation_type_t type, size_t rawDataSize, const uint8_t *pRawData, uint32_t *pMetricValueCount, zet_typed_value_t *pMetricValues) { const bool calculateCountOnly = *pMetricValueCount == 0; const bool result = calculateCountOnly ? getCalculatedMetricCount(rawDataSize, *pMetricValueCount) - : getCalculatedMetricValues(rawDataSize, pRawData, *pMetricValueCount, pMetricValues); + : getCalculatedMetricValues(type, rawDataSize, pRawData, *pMetricValueCount, pMetricValues); return result ? ZE_RESULT_SUCCESS : ZE_RESULT_ERROR_UNKNOWN; } @@ -515,7 +515,7 @@ bool MetricGroupImp::getCalculatedMetricCount(const size_t rawDataSize, return true; } -bool MetricGroupImp::getCalculatedMetricValues(const size_t rawDataSize, const uint8_t *pRawData, +bool MetricGroupImp::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) { @@ -530,18 +530,20 @@ bool MetricGroupImp::getCalculatedMetricValues(const size_t rawDataSize, const u return false; } - // Calculated metrics container. + // Calculated metrics / maximum values container. std::vector calculatedMetrics(expectedMetricValueCount); + std::vector maximumValues(expectedMetricValueCount); // Set filtering type. pReferenceMetricSet->SetApiFiltering(MetricGroupImp::getApiMask(properties.samplingType)); // Calculate metrics. - const bool result = pReferenceMetricSet->CalculateMetrics( - reinterpret_cast(const_cast(pRawData)), static_cast(rawDataSize), - calculatedMetrics.data(), - static_cast(calculatedMetrics.size()) * sizeof(MetricsDiscovery::TTypedValue_1_0), - &calculatedReportCount, nullptr, static_cast(0)) == MetricsDiscovery::CC_OK; + const uint32_t outMetricsSize = static_cast(calculatedMetrics.size()) * sizeof(MetricsDiscovery::TTypedValue_1_0); + bool result = pReferenceMetricSet->CalculateMetrics( + reinterpret_cast(const_cast(pRawData)), static_cast(rawDataSize), + calculatedMetrics.data(), + outMetricsSize, + &calculatedReportCount, maximumValues.data(), outMetricsSize) == MetricsDiscovery::CC_OK; if (result) { @@ -549,8 +551,22 @@ bool MetricGroupImp::getCalculatedMetricValues(const size_t rawDataSize, const u metricValueCount = std::min(metricValueCount, calculatedReportCount * properties.metricCount); // Translate metrics from metrics discovery to oneAPI format. - for (size_t i = 0; i < metricValueCount; ++i) { - copyValue(calculatedMetrics[i], pCalculatedData[i]); + switch (type) { + case ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES: + for (size_t i = 0; i < metricValueCount; ++i) { + copyValue(calculatedMetrics[i], pCalculatedData[i]); + } + break; + + case ZET_METRIC_GROUP_CALCULATION_TYPE_MAX_METRIC_VALUES: + for (size_t i = 0; i < metricValueCount; ++i) { + copyValue(maximumValues[i], pCalculatedData[i]); + } + break; + + default: + result = false; + break; } } diff --git a/level_zero/tools/source/metrics/metric_enumeration_imp.h b/level_zero/tools/source/metrics/metric_enumeration_imp.h index af56c90080..3a82ebf8ed 100644 --- a/level_zero/tools/source/metrics/metric_enumeration_imp.h +++ b/level_zero/tools/source/metrics/metric_enumeration_imp.h @@ -75,7 +75,7 @@ struct MetricGroupImp : MetricGroup { ze_result_t getProperties(zet_metric_group_properties_t *pProperties) override; ze_result_t getPropertiesExt(zet_metric_group_properties_ext_t *pProperties) override; ze_result_t getMetric(uint32_t *pCount, zet_metric_handle_t *phMetrics) override; - ze_result_t calculateMetricValues(size_t rawDataSize, const uint8_t *pRawData, + ze_result_t calculateMetricValues(const zet_metric_group_calculation_type_t type, size_t rawDataSize, const uint8_t *pRawData, uint32_t *pMetricValueCount, zet_typed_value_t *pCalculatedData) override; @@ -106,7 +106,7 @@ struct MetricGroupImp : MetricGroup { bool getCalculatedMetricCount(const size_t rawDataSize, uint32_t &metricValueCount); - bool getCalculatedMetricValues(const size_t rawDataSize, const uint8_t *pRawData, + bool getCalculatedMetricValues(const zet_metric_group_calculation_type_t, const size_t rawDataSize, const uint8_t *pRawData, uint32_t &metricValueCount, zet_typed_value_t *pCalculatedData); diff --git a/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_enumeration.h b/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_enumeration.h index 9479d7170a..ed7c1c67ae 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_enumeration.h +++ b/level_zero/tools/test/unit_tests/sources/metrics/mock_metric_enumeration.h @@ -135,7 +135,7 @@ struct Mock : public MetricGroup { Mock() {} MOCK_METHOD(ze_result_t, getMetric, (uint32_t *, zet_metric_handle_t *), (override)); - MOCK_METHOD(ze_result_t, calculateMetricValues, (size_t, const uint8_t *, uint32_t *, zet_typed_value_t *), (override)); + MOCK_METHOD(ze_result_t, calculateMetricValues, (const zet_metric_group_calculation_type_t, size_t, const uint8_t *, uint32_t *, zet_typed_value_t *), (override)); MOCK_METHOD(ze_result_t, getProperties, (zet_metric_group_properties_t * properties), (override)); MOCK_METHOD(ze_result_t, getPropertiesExt, (zet_metric_group_properties_ext_t * properties), (override)); MOCK_METHOD(uint32_t, getRawReportSize, (), (override)); diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_enumeration.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_enumeration.cpp index 065808b438..8cf248fbd9 100644 --- a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_enumeration.cpp +++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_enumeration.cpp @@ -1956,5 +1956,176 @@ TEST_F(MetricEnumerationTest, givenCorrectRawReportSizeAndCorrectCalculatedRepor EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroupHandle, rawResultsSize, rawResults.data(), &calculatedResultsCount, caculatedrawResults.data()), ZE_RESULT_SUCCESS); } +TEST_F(MetricEnumerationTest, givenCorrectRawReportSizeAndCorrectCalculatedReportCountWhenZetMetricGroupCalculateMetricValuesIsCalledThenMaxValuesAreReturned) { + + // Metrics Discovery device. + metricsDeviceParams.ConcurrentGroupsCount = 1; + + // Metrics Discovery concurrent group. + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + metricsConcurrentGroupParams.MetricSetsCount = 1; + metricsConcurrentGroupParams.SymbolName = "OA"; + + // Metrics Discovery: metric set + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; + metricsSetParams.QueryReportSize = 256; + metricsSetParams.MetricsCount = 11; + + // Metrics Discovery: metric + Mock metric; + MetricsDiscovery::TMetricParams_1_0 metricParams = {}; + + // One api: metric group. + zet_metric_group_handle_t metricGroupHandle = {}; + + EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery()) + .Times(0); + + EXPECT_CALL(*mockMetricEnumeration->g_mockApi, MockOpenMetricsDevice(_)) + .Times(1) + .WillOnce(DoAll(::testing::SetArgPointee<0>(&metricsDevice), Return(TCompletionCode::CC_OK))); + + EXPECT_CALL(*mockMetricEnumeration->g_mockApi, MockCloseMetricsDevice(_)) + .Times(1) + .WillOnce(Return(TCompletionCode::CC_OK)); + + EXPECT_CALL(metricsDevice, GetParams()) + .WillRepeatedly(Return(&metricsDeviceParams)); + + EXPECT_CALL(metricsDevice, GetConcurrentGroup(_)) + .Times(1) + .WillOnce(Return(&metricsConcurrentGroup)); + + EXPECT_CALL(metricsConcurrentGroup, GetParams()) + .Times(1) + .WillOnce(Return(&metricsConcurrentGroupParams)); + + EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_)) + .WillRepeatedly(Return(&metricsSet)); + + EXPECT_CALL(metricsSet, GetParams()) + .WillRepeatedly(Return(&metricsSetParams)); + + EXPECT_CALL(metricsSet, GetMetric(_)) + .Times(11) + .WillRepeatedly(Return(&metric)); + + EXPECT_CALL(metricsSet, SetApiFiltering(_)) + .WillRepeatedly(Return(TCompletionCode::CC_OK)); + + EXPECT_CALL(metricsSet, CalculateMetrics(_, _, _, _, _, _, _)) + .Times(1) + .WillOnce(DoAll(::testing::SetArgPointee<4>(metricsSetParams.MetricsCount), Return(TCompletionCode::CC_OK))); + + EXPECT_CALL(metric, GetParams()) + .WillRepeatedly(Return(&metricParams)); + + // Metric group handles. + uint32_t metricGroupCount = 1; + EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS); + EXPECT_EQ(metricGroupCount, 1u); + EXPECT_NE(metricGroupHandle, nullptr); + + // Return correct calculated report count for single raw report. + size_t rawResultsSize = metricsSetParams.QueryReportSize; + std::vector rawResults(rawResultsSize); + uint32_t calculatedResultsCount = 0; + + EXPECT_EQ(zetMetricGroupCalculateMetricValuesExt(metricGroupHandle, ZET_METRIC_GROUP_CALCULATION_TYPE_MAX_METRIC_VALUES, rawResultsSize, rawResults.data(), &calculatedResultsCount, nullptr), ZE_RESULT_SUCCESS); + EXPECT_EQ(calculatedResultsCount, metricsSetParams.MetricsCount); + + // Provide incorrect calculated report buffer. + std::vector caculatedrawResults(calculatedResultsCount); + EXPECT_EQ(zetMetricGroupCalculateMetricValuesExt(metricGroupHandle, ZET_METRIC_GROUP_CALCULATION_TYPE_MAX_METRIC_VALUES, rawResultsSize, rawResults.data(), &calculatedResultsCount, caculatedrawResults.data()), ZE_RESULT_SUCCESS); +} + +TEST_F(MetricEnumerationTest, givenIncorrectCalculationTypeWhenZetMetricGroupCalculateMetricValuesIsCalledThenMaxValuesAreReturned) { + + // Metrics Discovery device. + metricsDeviceParams.ConcurrentGroupsCount = 1; + + // Metrics Discovery concurrent group. + Mock metricsConcurrentGroup; + TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {}; + metricsConcurrentGroupParams.MetricSetsCount = 1; + metricsConcurrentGroupParams.SymbolName = "OA"; + + // Metrics Discovery: metric set + Mock metricsSet; + MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {}; + metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL; + metricsSetParams.QueryReportSize = 256; + metricsSetParams.MetricsCount = 11; + + // Metrics Discovery: metric + Mock metric; + MetricsDiscovery::TMetricParams_1_0 metricParams = {}; + + // One api: metric group. + zet_metric_group_handle_t metricGroupHandle = {}; + + EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery()) + .Times(0); + + EXPECT_CALL(*mockMetricEnumeration->g_mockApi, MockOpenMetricsDevice(_)) + .Times(1) + .WillOnce(DoAll(::testing::SetArgPointee<0>(&metricsDevice), Return(TCompletionCode::CC_OK))); + + EXPECT_CALL(*mockMetricEnumeration->g_mockApi, MockCloseMetricsDevice(_)) + .Times(1) + .WillOnce(Return(TCompletionCode::CC_OK)); + + EXPECT_CALL(metricsDevice, GetParams()) + .WillRepeatedly(Return(&metricsDeviceParams)); + + EXPECT_CALL(metricsDevice, GetConcurrentGroup(_)) + .Times(1) + .WillOnce(Return(&metricsConcurrentGroup)); + + EXPECT_CALL(metricsConcurrentGroup, GetParams()) + .Times(1) + .WillOnce(Return(&metricsConcurrentGroupParams)); + + EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_)) + .WillRepeatedly(Return(&metricsSet)); + + EXPECT_CALL(metricsSet, GetParams()) + .WillRepeatedly(Return(&metricsSetParams)); + + EXPECT_CALL(metricsSet, GetMetric(_)) + .Times(11) + .WillRepeatedly(Return(&metric)); + + EXPECT_CALL(metricsSet, SetApiFiltering(_)) + .WillRepeatedly(Return(TCompletionCode::CC_OK)); + + EXPECT_CALL(metricsSet, CalculateMetrics(_, _, _, _, _, _, _)) + .Times(1) + .WillOnce(Return(TCompletionCode::CC_OK)); + + EXPECT_CALL(metric, GetParams()) + .WillRepeatedly(Return(&metricParams)); + + // Metric group handles. + uint32_t metricGroupCount = 1; + EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS); + EXPECT_EQ(metricGroupCount, 1u); + EXPECT_NE(metricGroupHandle, nullptr); + + // Return correct calculated report count for single raw report. + size_t rawResultsSize = metricsSetParams.QueryReportSize; + std::vector rawResults(rawResultsSize); + uint32_t calculatedResultsCount = 0; + + EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroupHandle, rawResultsSize, rawResults.data(), &calculatedResultsCount, nullptr), ZE_RESULT_SUCCESS); + EXPECT_EQ(calculatedResultsCount, metricsSetParams.MetricsCount); + + // Provide incorrect calculated report buffer. + std::vector caculatedrawResults(calculatedResultsCount); + EXPECT_NE(zetMetricGroupCalculateMetricValuesExt(metricGroupHandle, ZET_METRIC_GROUP_CALCULATION_TYPE_FORCE_UINT32, rawResultsSize, rawResults.data(), &calculatedResultsCount, caculatedrawResults.data()), ZE_RESULT_SUCCESS); +} } // namespace ult } // namespace L0 diff --git a/third_party/level_zero/zet_api_ext.h b/third_party/level_zero/zet_api_ext.h index 683fdbe2a3..b7f87482cf 100644 --- a/third_party/level_zero/zet_api_ext.h +++ b/third_party/level_zero/zet_api_ext.h @@ -376,6 +376,50 @@ zetMetricGetPropertiesExt( zet_metric_properties_ext_t *pProperties ///< [in,out] metric properties ); +/////////////////////////////////////////////////////////////////////////////// +/// @brief Metric group calculation type +typedef enum _zet_metric_group_calculation_type_t { + ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES = 0, ///< Calculated metric values from raw data. + ZET_METRIC_GROUP_CALCULATION_TYPE_MAX_METRIC_VALUES = 1, ///< Maximum metric values. + ZET_METRIC_GROUP_CALCULATION_TYPE_FORCE_UINT32 = 0x7fffffff + +} zet_metric_group_calculation_type_t; + +/////////////////////////////////////////////////////////////////////////////// +/// @brief Calculates metric values from raw data. +/// +/// @details +/// - The application may call this function from simultaneous threads. +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_DEVICE_LOST +/// - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE +/// + `nullptr == hMetricGroup` +/// - ::ZE_RESULT_ERROR_INVALID_ENUMERATION +/// + `::ZET_METRIC_GROUP_CALCULATION_TYPE_MAX_METRIC_VALUES < type` +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// + `nullptr == pRawData` +/// + `nullptr == pMetricValueCount` +ZE_APIEXPORT ze_result_t ZE_APICALL +zetMetricGroupCalculateMetricValuesExt( + zet_metric_group_handle_t hMetricGroup, ///< [in] handle of the metric group + zet_metric_group_calculation_type_t type, ///< [in] calculation type to be applied on raw data + size_t rawDataSize, ///< [in] size in bytes of raw data buffer + const uint8_t *pRawData, ///< [in][range(0, rawDataSize)] buffer of raw data to calculate + uint32_t *pMetricValueCount, ///< [in,out] pointer to number of metric values calculated. + ///< if count is zero, then the driver will update the value with the total + ///< number of metric values to be calculated. + ///< if count is non-zero, then driver will only calculate that number of + ///< metric values. + ///< if count is larger than the number available in the raw data buffer, + ///< then the driver will update the value with the actual number of metric + ///< values to be calculated. + zet_typed_value_t *pMetricValues ///< [in,out][optional][range(0, *pMetricValueCount)] buffer of calculated + ///< metrics +); + /////////////////////////////////////////////////////////////////////////////// /// @brief Supportted profile features typedef uint32_t zet_profile_flagsExt_t;