From c1a4e3ad500c7032bdff2e49d23bc3a3eafd0c74 Mon Sep 17 00:00:00 2001
From: Robert Krzemien <robert.krzemien@intel.com>
Date: Fri, 8 Oct 2021 13:52:00 +0000
Subject: [PATCH] Metric Api: Return error on calculate when multi metric
 values header is used.

Resolves: LOCI-2624
Signed-off-by: Robert Krzemien <robert.krzemien@intel.com>
---
 .../source/metrics/metric_enumeration_imp.cpp |  9 ++
 .../metrics/test_metric_enumeration_2.cpp     | 84 +++++++++++++++++++
 2 files changed, 93 insertions(+)

diff --git a/level_zero/tools/source/metrics/metric_enumeration_imp.cpp b/level_zero/tools/source/metrics/metric_enumeration_imp.cpp
index 529cbc180c..409c4fa10c 100644
--- a/level_zero/tools/source/metrics/metric_enumeration_imp.cpp
+++ b/level_zero/tools/source/metrics/metric_enumeration_imp.cpp
@@ -585,6 +585,15 @@ ze_result_t MetricGroupImp::closeIoStream() {
 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 MetricGroupCalculateHeader *pRawHeader = reinterpret_cast<const MetricGroupCalculateHeader *>(pRawData);
+    if (pRawHeader->magic == MetricGroupCalculateHeader::magicValue) {
+        NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "%s",
+                              "INFO: The call is not supported for multiple devices\n"
+                              "INFO: Please use zetMetricGroupCalculateMultipleMetricValuesExp instead\n");
+        return ZE_RESULT_ERROR_UNKNOWN;
+    }
+
     const bool calculateCountOnly = *pMetricValueCount == 0;
     const bool result = calculateCountOnly
                             ? getCalculatedMetricCount(rawDataSize, *pMetricValueCount)
diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_enumeration_2.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_enumeration_2.cpp
index 62e466abf0..baccd634c2 100644
--- a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_enumeration_2.cpp
+++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_enumeration_2.cpp
@@ -616,5 +616,89 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenErrorGeneralOnCalculateMetricsWhen
     EXPECT_EQ(metricCounts[1], 0u);
 }
 
+TEST_F(MetricEnumerationMultiDeviceTest, givenCorrectRawDataHeaderWhenZetMetricGroupCalculateMetricValuesIsCalledThenReturnsFail) {
+
+    auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
+    const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
+
+    metricsDeviceParams.ConcurrentGroupsCount = 1;
+
+    Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
+    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    metricsConcurrentGroupParams.MetricSetsCount = 1;
+    metricsConcurrentGroupParams.SymbolName = "OA";
+
+    Mock<IMetricSet_1_5> metricsSet;
+    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
+    metricsSetParams.QueryReportSize = 256;
+    metricsSetParams.MetricsCount = 11;
+
+    Mock<IMetric_1_0> metric;
+    MetricsDiscovery::TMetricParams_1_0 metricParams = {};
+
+    zet_metric_group_handle_t metricGroupHandle = {};
+
+    openMetricsAdapter();
+
+    EXPECT_CALL(metricsDevice, GetParams())
+        .WillRepeatedly(Return(&metricsDeviceParams));
+
+    EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
+        .Times(subDeviceCount)
+        .WillRepeatedly(Return(&metricsConcurrentGroup));
+
+    EXPECT_CALL(metricsConcurrentGroup, GetParams())
+        .Times(subDeviceCount)
+        .WillRepeatedly(Return(&metricsConcurrentGroupParams));
+
+    EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
+        .Times(subDeviceCount)
+        .WillRepeatedly(Return(&metricsSet));
+
+    EXPECT_CALL(metricsSet, GetParams())
+        .WillRepeatedly(Return(&metricsSetParams));
+
+    EXPECT_CALL(metricsSet, GetMetric(_))
+        .Times(metricsSetParams.MetricsCount * subDeviceCount)
+        .WillRepeatedly(Return(&metric));
+
+    EXPECT_CALL(metricsSet, SetApiFiltering(_))
+        .WillRepeatedly(Return(TCompletionCode::CC_OK));
+
+    EXPECT_CALL(metric, GetParams())
+        .WillRepeatedly(Return(&metricParams));
+
+    // Metric group handles.
+    uint32_t metricGroupCount = 1;
+    EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(metricGroupCount, 1u);
+    EXPECT_NE(metricGroupHandle, nullptr);
+
+    // Raw results.
+    const size_t rawResultsSize = 560;
+    uint8_t rawResults[rawResultsSize] = {};
+    MetricGroupCalculateHeader *pRawHeader = reinterpret_cast<MetricGroupCalculateHeader *>(rawResults);
+
+    pRawHeader->magic = MetricGroupCalculateHeader::magicValue;
+    pRawHeader->dataCount = subDeviceCount;
+    pRawHeader->rawDataOffsets = sizeof(MetricGroupCalculateHeader);
+    pRawHeader->rawDataSizes = pRawHeader->rawDataOffsets + sizeof(uint32_t) * pRawHeader->dataCount;
+    pRawHeader->rawDataOffset = pRawHeader->rawDataSizes + sizeof(uint32_t) * pRawHeader->dataCount;
+
+    uint32_t *pRawDataOffsets = reinterpret_cast<uint32_t *>(rawResults + pRawHeader->rawDataOffsets);
+    uint32_t *pRawDataSizes = reinterpret_cast<uint32_t *>(rawResults + pRawHeader->rawDataSizes);
+    pRawDataOffsets[0] = 0;
+    pRawDataOffsets[1] = metricsSetParams.QueryReportSize;
+    pRawDataSizes[0] = metricsSetParams.QueryReportSize;
+    pRawDataSizes[1] = metricsSetParams.QueryReportSize;
+
+    // Valid raw buffer for zetMetricGroupCalculateMultipleMetricValuesExp.
+    uint32_t metricCount = 0;
+    EXPECT_NE(metricsSetParams.QueryReportSize, rawResultsSize);
+    EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroupHandle, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawResultsSize, rawResults, &metricCount, nullptr), ZE_RESULT_ERROR_UNKNOWN);
+    EXPECT_EQ(metricCount, 0u);
+}
+
 } // namespace ult
 } // namespace L0