intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-03 23:03:02 +08:00
Code Issues Packages Projects Releases Wiki Activity

feature: updates to metrics calculate API

Browse Source 
Resolves: NEO-15958

Signed-off-by: Matias Cabral <matias.a.cabral@intel.com>
This commit is contained in:
Matias Cabral
2025-09-10 02:15:57 +00:00
committed by Compute-Runtime-Automation
parent 59f8ad763c
commit f2f86be6c0
8 changed files with 90 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
level_zero/api/driver_experimental/public/zex_metric.cpp
View File

@@ -101,10 +101,13 @@ ze_result_t ZE_APICALL zetIntelMetricCalculationOperationGetExcludedMetricsExp(
return L0::metricCalculationGetExcludedMetrics(hCalculationOperation, pCount, phMetrics);
}
ze_result_t ZE_APICALL zetIntelMetricCalculateValuesExp(const size_t rawDataSize, size_t *pOffset, const uint8_t *pRawData,
ze_result_t ZE_APICALL zetIntelMetricCalculateValuesExp(const size_t rawDataSize, const uint8_t *pRawData,
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation,
uint32_t *pTotalMetricReportsCount, zet_intel_metric_result_exp_t *pMetricResults) {
return L0::metricCalculateValues(rawDataSize, pOffset, pRawData, hCalculationOperation, pTotalMetricReportsCount, pMetricResults);
bool final, size_t *usedSize, uint32_t *pTotalMetricReportsCount,
zet_intel_metric_result_exp_t *pMetricResults) {
return L0::metricCalculateValues(rawDataSize, pRawData, hCalculationOperation,
final, usedSize,
pTotalMetricReportsCount, pMetricResults);
}
ze_result_t ZE_APICALL zetIntelMetricDecodeCalculateMultipleValuesExp(zet_intel_metric_decoder_exp_handle_t hMetricDecoder,
@@ -238,10 +241,14 @@ ze_result_t ZE_APICALL zetIntelMetricCalculationOperationGetExcludedMetricsExp(
return L0::zetIntelMetricCalculationOperationGetExcludedMetricsExp(hCalculationOperation, pCount, phMetrics);
}
ze_result_t ZE_APICALL zetIntelMetricCalculateValuesExp(const size_t rawDataSize, size_t *pOffset, const uint8_t *pRawData, zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation,
uint32_t *pTotalMetricReportsCount, zet_intel_metric_result_exp_t *pMetricResults) {
ze_result_t ZE_APICALL zetIntelMetricCalculateValuesExp(const size_t rawDataSize, const uint8_t *pRawData,
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation,
bool final, size_t *usedSize,
uint32_t *pTotalMetricReportsCount,
zet_intel_metric_result_exp_t *pMetricResults) {
return L0::zetIntelMetricCalculateValuesExp(rawDataSize, pOffset, pRawData, hCalculationOperation,
return L0::zetIntelMetricCalculateValuesExp(rawDataSize, pRawData, hCalculationOperation,
final, usedSize,
pTotalMetricReportsCount, pMetricResults);
}

7
level_zero/include/level_zero/zet_intel_gpu_metric.h
View File

@@ -431,11 +431,14 @@ zetIntelMetricDecodeToBinaryBufferExp(
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.
///< 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_calculation_operation_exp_handle_t hCalculationOperation, ///< [in] Calculation operation handle
bool final, ///< [in] flag to indicate the if the current is the final call for the given data.
///< If false, the driver may cache data as needed for subsequent calls.
///< If true, the driver will finalize the calculations using available data and clear caches.
size_t *usedDataSize, ///< [out] The number raw bytes processed. User is expected to advance pRawData
///< pointer by this amount if calling this function subsequently.
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

5
level_zero/tools/source/metrics/metric.cpp
View File

@@ -1113,12 +1113,13 @@ ze_result_t metricCalculationGetExcludedMetrics(
ze_result_t metricCalculateValues(
const size_t rawDataSize,
size_t *pOffset,
const uint8_t *pRawData,
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation,
bool final,
size_t *usedSize,
uint32_t *pTotalMetricReportsCount,
zet_intel_metric_result_exp_t *pMetricResults) {
return MetricCalcOp::fromHandle(hCalculationOperation)->metricCalculateValues(rawDataSize, pOffset, pRawData, pTotalMetricReportsCount, pMetricResults);
return MetricCalcOp::fromHandle(hCalculationOperation)->metricCalculateValues(rawDataSize, pRawData, final, usedSize, pTotalMetricReportsCount, pMetricResults);
}
ze_result_t metricsEnable(zet_device_handle_t hDevice) {

6
level_zero/tools/source/metrics/metric.h
View File

@@ -473,7 +473,8 @@ struct MetricCalcOp : _zet_intel_metric_calculation_operation_exp_handle_t {
virtual ze_result_t getReportFormat(uint32_t *pCount, zet_metric_handle_t *phMetrics,
zet_intel_metric_scope_exp_handle_t *phMetricScopes) = 0;
virtual ze_result_t getExcludedMetrics(uint32_t *pCount, zet_metric_handle_t *phMetrics) = 0;
virtual ze_result_t metricCalculateValues(const size_t rawDataSize, size_t *pOffset, const uint8_t *pRawData,
virtual ze_result_t metricCalculateValues(const size_t rawDataSize, const uint8_t *pRawData,
bool final, size_t *usedSize,
uint32_t *pTotalMetricReportCount,
zet_intel_metric_result_exp_t *pMetricResults) = 0;
};
@@ -603,8 +604,9 @@ ze_result_t metricCalculationGetReportFormat(zet_intel_metric_calculation_operat
ze_result_t metricCalculationGetExcludedMetrics(zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation,
uint32_t *pCount, zet_metric_handle_t *phMetrics);
ze_result_t metricCalculateValues(const size_t rawDataSize, size_t *pOffset, const uint8_t *pRawData,
ze_result_t metricCalculateValues(const size_t rawDataSize, const uint8_t *pRawData,
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation,
bool final, size_t *usedSize,
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,

23
level_zero/tools/source/metrics/metric_ip_sampling_streamer.cpp
View File

@@ -178,16 +178,17 @@ void IpSamplingMetricCalcOpImp::fillStallDataMap(const size_t rawDataSize, const
return;
}
ze_result_t IpSamplingMetricCalcOpImp::metricCalculateValuesSingle(const size_t rawDataSize, size_t *pOffset, const uint8_t *pRawData,
ze_result_t IpSamplingMetricCalcOpImp::metricCalculateValuesSingle(const size_t rawDataSize, const uint8_t *pRawData,
uint32_t *pTotalMetricReportCount,
L0::L0GfxCoreHelper &l0GfxCoreHelper,
IpSamplingMetricGroupBase *metricGroupBase,
bool getSize,
size_t *usedSize,
bool &dataOverflow,
std::map<uint64_t, void *> &stallReportDataMap) {
ze_result_t status = ZE_RESULT_ERROR_UNKNOWN;
uint32_t resultCount = 0;
*pOffset = 0;
*usedSize = 0;
status = static_cast<IpSamplingMetricGroupImp *>(metricGroupBase)->getCalculatedMetricCount(pRawData, rawDataSize, resultCount);
if (status != ZE_RESULT_SUCCESS) {
@@ -207,26 +208,28 @@ ze_result_t IpSamplingMetricCalcOpImp::metricCalculateValuesSingle(const size_t
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
fillStallDataMap(rawDataSize, pRawData, pOffset, l0GfxCoreHelper, stallReportDataMap,
fillStallDataMap(rawDataSize, pRawData, usedSize, l0GfxCoreHelper, stallReportDataMap,
&dataOverflow);
*pTotalMetricReportCount = static_cast<uint32_t>(stallReportDataMap.size());
return status;
}
ze_result_t IpSamplingMetricCalcOpImp::metricCalculateValuesMulti(const size_t rawDataSize, size_t *pOffset, const uint8_t *pRawData,
ze_result_t IpSamplingMetricCalcOpImp::metricCalculateValuesMulti(const size_t rawDataSize, const uint8_t *pRawData,
uint32_t *pTotalMetricReportCount,
L0::L0GfxCoreHelper &l0GfxCoreHelper,
IpSamplingMetricGroupBase *metricGroupBase,
bool getSize,
uint32_t numSubDevices,
size_t *usedSize,
bool &dataOverflow,
std::map<uint64_t, void *> &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,
ze_result_t IpSamplingMetricCalcOpImp::metricCalculateValues(const size_t rawDataSize, const uint8_t *pRawData,
bool final, size_t *usedSize,
uint32_t *pTotalMetricReportCount,
zet_intel_metric_result_exp_t *pMetricResults) {
ze_result_t status = ZE_RESULT_ERROR_UNKNOWN;
@@ -240,8 +243,6 @@ ze_result_t IpSamplingMetricCalcOpImp::metricCalculateValues(const size_t rawDat
DeviceImp *deviceImp = static_cast<DeviceImp *>(&metricGroupBase->getMetricSource().getMetricDeviceContext().getDevice());
L0::L0GfxCoreHelper &l0GfxCoreHelper = deviceImp->getNEODevice()->getRootDeviceEnvironment().getHelper<L0GfxCoreHelper>();
pRawData += *pOffset; // Input Offset
bool getSize = (*pTotalMetricReportCount == 0);
std::map<uint64_t, void *> stallReportDataMap;
@@ -251,17 +252,17 @@ ze_result_t IpSamplingMetricCalcOpImp::metricCalculateValues(const size_t rawDat
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
status = metricCalculateValuesSingle(rawDataSize, pOffset, pRawData, pTotalMetricReportCount,
l0GfxCoreHelper, metricGroupBase, getSize, dataOverflow, stallReportDataMap);
status = metricCalculateValuesSingle(rawDataSize, pRawData, pTotalMetricReportCount,
l0GfxCoreHelper, metricGroupBase, getSize, usedSize, dataOverflow, stallReportDataMap);
} else {
if (!isMultiDeviceData) {
METRICS_LOG_ERR("%s", "Cannot use sub-device raw data in a root device calculation operation handle");
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
status = metricCalculateValuesMulti(rawDataSize, pOffset, pRawData, pTotalMetricReportCount,
status = metricCalculateValuesMulti(rawDataSize, pRawData, pTotalMetricReportCount,
l0GfxCoreHelper, metricGroupBase, getSize, deviceImp->numSubDevices,
dataOverflow, stallReportDataMap);
usedSize, dataOverflow, stallReportDataMap);
}
if ((status != ZE_RESULT_SUCCESS) || (getSize)) {

9
level_zero/tools/source/metrics/metric_ip_sampling_streamer.h
View File

@@ -65,7 +65,8 @@ struct IpSamplingMetricCalcOpImp : public MetricCalcOpImp {
zet_intel_metric_calculation_operation_exp_handle_t *phCalculationOperation);
ze_result_t destroy() override;
ze_result_t metricCalculateValues(const size_t rawDataSize, size_t *pOffset, const uint8_t *pRawData,
ze_result_t metricCalculateValues(const size_t rawDataSize, const uint8_t *pRawData,
bool final, size_t *usedSize,
uint32_t *pTotalMetricReportCount,
zet_intel_metric_result_exp_t *pMetricResults) override;
@@ -75,19 +76,21 @@ struct IpSamplingMetricCalcOpImp : public MetricCalcOpImp {
bool *dataOverflow);
protected:
ze_result_t metricCalculateValuesSingle(const size_t rawDataSize, size_t *pOffset, const uint8_t *pRawData,
ze_result_t metricCalculateValuesSingle(const size_t rawDataSize, const uint8_t *pRawData,
uint32_t *pTotalMetricReportCount,
L0::L0GfxCoreHelper &l0GfxCoreHelper,
IpSamplingMetricGroupBase *metricGroupBase,
bool getSize,
size_t *usedSize,
bool &dataOverflow,
std::map<uint64_t, void *> &stallReportDataMap);
ze_result_t metricCalculateValuesMulti(const size_t rawDataSize, size_t *pOffset, const uint8_t *pRawData,
ze_result_t metricCalculateValuesMulti(const size_t rawDataSize, const uint8_t *pRawData,
uint32_t *pTotalMetricReportCount,
L0::L0GfxCoreHelper &l0GfxCoreHelper,
IpSamplingMetricGroupBase *metricGroupBase,
bool getSize,
uint32_t numSubDevices,
size_t *usedSize,
bool &dataOverflow,
std::map<uint64_t, void *> &stallReportDataMap);

3
level_zero/tools/test/unit_tests/sources/metrics/mock_metric_source.h
View File

@@ -177,7 +177,8 @@ class MockMetricCalcOp : public MetricCalcOpImp {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
};
ze_result_t metricCalculateValues(const size_t rawDataSize, size_t *pOffset, const uint8_t *pRawData,
ze_result_t metricCalculateValues(const size_t rawDataSize, const uint8_t *pRawData,
bool final, size_t *usedSize,
uint32_t *pTotalMetricReportCount,
zet_intel_metric_result_exp_t *pMetricResults) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;

76
level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_streamer.cpp
View File

@@ -938,13 +938,14 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, GivenIpSamplingCalcOpCallingMetric
addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(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<uint8_t *>(rawDataWithHeader.data()), hCalculationOperation,
bool final = true;
size_t usedSize = 0;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetIntelMetricCalculateValuesExp(rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataWithHeader.data()),
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, nullptr));
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateValuesExp(rawDataVectorSize, &offset,
reinterpret_cast<uint8_t *>(rawDataVector.data()), hCalculationOperation,
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateValuesExp(rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()),
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalculationOperation));
@@ -973,18 +974,19 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat
}
uint32_t totalMetricReportCount = 0;
size_t offset = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, &offset,
reinterpret_cast<uint8_t *>(rawDataVector.data()), hCalculationOperation,
bool final = true;
size_t usedSize = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()),
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, nullptr));
EXPECT_EQ(totalMetricReportCount, 3U);
std::vector<zet_intel_metric_result_exp_t> metricResults(totalMetricReportCount * metricsInReportCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, &offset,
reinterpret_cast<uint8_t *>(rawDataVector.data()), hCalculationOperation,
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()),
hCalculationOperation, final, &usedSize,
&totalMetricReportCount, metricResults.data()));
EXPECT_EQ(totalMetricReportCount, 3U);
EXPECT_EQ(offset, rawDataVectorSize);
EXPECT_EQ(usedSize, rawDataVectorSize);
for (uint32_t i = 0; i < totalMetricReportCount; i++) {
for (uint32_t j = 0; j < metricsInReportCount; j++) {
@@ -1010,15 +1012,18 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat
addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataVector.data()), rawDataVectorSize, 0);
uint32_t totalMetricReportCount = 0;
size_t offset = 0;
bool final = true;
size_t usedSize = 0;
// sub-device cal op does not accept root device data
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateValuesExp(rawDataWithHeader.size(), &offset,
reinterpret_cast<uint8_t *>(rawDataWithHeader.data()), hCalculationOperation,
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateValuesExp(rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(rawDataWithHeader.data()),
hCalculationOperation,
final, &usedSize,
&totalMetricReportCount, nullptr));
// invalid input raw data size
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_SIZE, zetIntelMetricCalculateValuesExp(rawDataVectorSize / 30, &offset,
reinterpret_cast<uint8_t *>(rawDataVector.data()), hCalculationOperation,
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_SIZE, zetIntelMetricCalculateValuesExp(rawDataVectorSize / 30, reinterpret_cast<uint8_t *>(rawDataVector.data()),
hCalculationOperation,
final, &usedSize,
&totalMetricReportCount, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalculationOperation));
@@ -1031,14 +1036,16 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat
device->toHandle(), &calculationDesc,
&hCalculationOperation));
uint32_t totalMetricReportCount = 2;
size_t offset = 0;
bool final = true;
size_t usedSize = 0;
std::vector<zet_intel_metric_result_exp_t> metricResults(totalMetricReportCount * 10);
EXPECT_EQ(ZE_RESULT_WARNING_DROPPED_DATA, zetIntelMetricCalculateValuesExp(rawDataVectorOverflowSize, &offset,
reinterpret_cast<uint8_t *>(rawDataVectorOverflow.data()), hCalculationOperation,
EXPECT_EQ(ZE_RESULT_WARNING_DROPPED_DATA, zetIntelMetricCalculateValuesExp(rawDataVectorOverflowSize, reinterpret_cast<uint8_t *>(rawDataVectorOverflow.data()),
hCalculationOperation,
final, &usedSize,
&totalMetricReportCount, metricResults.data()));
EXPECT_EQ(totalMetricReportCount, 2U);
EXPECT_EQ(offset, rawDataVectorOverflowSize);
EXPECT_EQ(usedSize, rawDataVectorOverflowSize);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalculationOperation));
}
@@ -1079,17 +1086,21 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat
EXPECT_EQ(metricsInReportCount, 5u);
uint32_t totalMetricReportCount = 0;
size_t offset = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, &offset,
reinterpret_cast<uint8_t *>(rawDataVector.data()), hCalculationOperation,
bool final = true;
size_t usedSize = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()),
hCalculationOperation,
final, &usedSize,
&totalMetricReportCount, nullptr));
std::vector<zet_intel_metric_result_exp_t> metricResults(totalMetricReportCount * metricsInReportCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, &offset,
reinterpret_cast<uint8_t *>(rawDataVector.data()), hCalculationOperation,
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()),
hCalculationOperation,
final, &usedSize,
&totalMetricReportCount, metricResults.data()));
EXPECT_EQ(totalMetricReportCount, 3U);
EXPECT_EQ(offset, rawDataVectorSize);
EXPECT_EQ(usedSize, rawDataVectorSize);
// Expect only odd index metrics results of the first report
for (uint32_t j = 0; j < metricsInReportCount; j++) {
@@ -1106,17 +1117,20 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat
device->toHandle(), &calculationDesc,
&hCalculationOperation));
uint32_t totalMetricReportCount = 0;
size_t offset = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, &offset,
reinterpret_cast<uint8_t *>(rawDataVector.data()), hCalculationOperation,
bool final = true;
size_t usedSize = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()),
hCalculationOperation,
final, &usedSize,
&totalMetricReportCount, nullptr));
EXPECT_EQ(totalMetricReportCount, 3U);
// Request fewer reports
totalMetricReportCount = 1;
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateValuesExp(rawDataVectorSize, &offset,
reinterpret_cast<uint8_t *>(rawDataVector.data()), hCalculationOperation,
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateValuesExp(rawDataVectorSize, reinterpret_cast<uint8_t *>(rawDataVector.data()),
hCalculationOperation,
final, &usedSize,
&totalMetricReportCount, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalculationOperation));