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

feature: metrics aggregation for EU Stall

Browse Source 
Resolves: NEO-13999

Signed-off-by: Matias Cabral <matias.a.cabral@intel.com>
This commit is contained in:
Matias Cabral
2025-04-10 00:41:18 +00:00
committed by Compute-Runtime-Automation
parent 447b258c65
commit 25ed9d1989
16 changed files with 1144 additions and 237 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -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"

8
level_zero/core/source/driver/extension_function_address.cpp
View File

@@ -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

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

@@ -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"

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

@@ -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;

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

@@ -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<MetricCalcOp *>(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

15
level_zero/tools/source/metrics/metric_device_context_create.cpp
View File

@@ -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

16
level_zero/tools/source/metrics/metric_ip_sampling_source.cpp
View File

@@ -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<const IpSamplingMetricDataHeader *>(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;
}

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

@@ -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<IpSamplingMetricSourceImp &>(metricSource); }
};
struct IpSamplingMetricGroupImp : public IpSamplingMetricGroupBase {
@@ -127,20 +130,18 @@ struct IpSamplingMetricGroupImp : public IpSamplingMetricGroupBase {
zet_metric_streamer_handle_t *phMetricStreamer) override;
static std::unique_ptr<IpSamplingMetricGroupImp> create(IpSamplingMetricSourceImp &metricSource,
std::vector<IpSamplingMetricImp> &ipSamplingMetrics);
IpSamplingMetricSourceImp &getMetricSource() { return static_cast<IpSamplingMetricSourceImp &>(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<std::unique_ptr<IpSamplingMetricImp>> 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 {

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

@@ -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<zet_metric_handle_t> hMetrics(metricCount);
MetricGroup::fromHandle(hMetricGroup)->metricGet(&metricCount, hMetrics.data());
std::vector<MetricImp *> inputMetricsInReport = {};
std::vector<uint32_t> includedMetricIndexes = {};
for (uint32_t i = 0; i < metricCount; i++) {
auto metric = static_cast<MetricImp *>(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<uint32_t>(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<uint64_t, void *> &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<uint32_t>(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<uint64_t, void *> &stallReportDataMap) {
ze_result_t status = ZE_RESULT_ERROR_UNKNOWN;
uint32_t resultCount = 0;
*pOffset = 0;
status = static_cast<IpSamplingMetricGroupImp *>(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<uint32_t>(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<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,
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<IpSamplingMetricGroupBase *>(MetricGroup::fromHandle(hMetricGroup));
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;
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<zet_typed_value_t> 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,

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

@@ -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<MetricImp *> &inputMetricsInReport,
bool multidevice) : MetricCalcOpImp(multidevice),
metricCount(static_cast<uint32_t>(inputMetricsInReport.size())),
metricsInReport(inputMetricsInReport) {}
IpSamplingMetricCalcOpImp(uint32_t inputCachedMetricsCount, std::vector<MetricImp *> &inputMetricsInReport,
std::vector<uint32_t> &inputIncludedMetricIndexes, bool multidevice)
: MetricCalcOpImp(multidevice),
cachedMetricsCount(inputCachedMetricsCount),
metricsInReportCount(static_cast<uint32_t>(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<uint64_t, void *> &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<uint64_t, void *> &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<uint64_t, void *> &stallReportDataMap);
uint32_t cachedMetricsCount = 0;
uint32_t metricsInReportCount = 0;
std::vector<MetricImp *> metricsInReport{};
std::vector<uint32_t> includedMetricIndexes{};
};
} // namespace L0

4
level_zero/tools/source/metrics/metric_oa_enumeration_imp.cpp
View File

@@ -855,8 +855,8 @@ ze_result_t OaMetricGroupImp::calculateMetricValues(const zet_metric_group_calcu
const MetricGroupCalculateHeader *pRawHeader = reinterpret_cast<const MetricGroupCalculateHeader *>(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;
}

92
level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.h
View File

@@ -79,7 +79,7 @@ class MetricIpSamplingFixture : public DeviceFixture,
std::vector<MockMetricIpSamplingOsInterface *> 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<uint32_t>(rawDataInSize);
header->setIndex = setIndex;
memcpy_s(rawDataOut + sizeof(IpSamplingMetricDataHeader), rawDataOutSize, rawDataIn, rawDataInSize);
memcpy_s(rawDataOut + sizeof(IpSamplingMetricDataHeader), rawDataOutSize - sizeof(IpSamplingMetricDataHeader),
rawDataIn, rawDataInSize);
}
}
std::vector<MockStallRawIpData> 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<std::string> expectedMetricNamesInReport = {"IP", "Active", "ControlStall", "PipeStall",
"SendStall", "DistStall", "SbidStall", "SyncStall",
"InstrFetchStall", "OtherStall"};
size_t rawDataVectorSize = sizeof(rawDataVector[0]) * rawDataVector.size();
std::vector<zet_typed_value_t> 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<zet_typed_value_t> 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<zet_typed_value_t> 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<zet_typed_value_t> 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<MockStallRawIpData> 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

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

@@ -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 {

204
level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_enumeration.cpp
View File

@@ -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<uint8_t *>(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<uint8_t *>(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<uint8_t *>(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<uint8_t *>(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<uint8_t *>(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<uint8_t *>(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<uint8_t *>(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<uint8_t *>(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<uint8_t *>(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<uint8_t *>(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<uint8_t *>(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<IpSamplingMetricCalcOpImp *>(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<zet_metric_handle_t> 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<zet_metric_group_handle_t> 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());

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

@@ -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<zet_metric_handle_t> 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<zet_metric_handle_t> phMetrics(metricCount);
EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, phMetrics.data()), ZE_RESULT_SUCCESS);
std::vector<zet_metric_handle_t> 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<uint32_t>(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<zet_metric_handle_t> 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<zet_metric_group_handle_t> 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<zet_metric_handle_t> metricsInReport(metricsInReportCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation,
&metricsInReportCount,
metricsInReport.data()));
EXPECT_EQ(metricsInReportCount, 10u);
std::vector<zet_metric_properties_t> 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<uint8_t *>(rawDataVector.data()), hCalculateOperation,
&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()), 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<zet_metric_handle_t> metricsInReport(metricsInReportCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation,
&metricsInReportCount,
metricsInReport.data()));
EXPECT_EQ(metricsInReportCount, 10u);
std::vector<zet_metric_properties_t> 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<uint8_t *>(rawDataVector.data()), hCalculateOperation,
&totalMetricReportCount, nullptr));
EXPECT_EQ(totalMetricReportCount, 3U);
// Request number of reports smaller than available
totalMetricReportCount = 2;
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()), 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<uint8_t *>(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<uint8_t *>(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<uint8_t *>(rawDataVector.data()), hCalculateOperation,
&totalMetricReportCount, nullptr));
EXPECT_EQ(totalMetricReportCount, 3U);
IpSamplingMetricCalcOpImp *calcop = static_cast<IpSamplingMetricCalcOpImp *>(MetricCalcOpImp::fromHandle(hCalculateOperation));
size_t rawDataSize = 0;
size_t processedSize = 0;
L0::L0GfxCoreHelper &l0GfxCoreHelper = neoDevice->getRootDeviceEnvironment().getHelper<L0GfxCoreHelper>();
std::map<uint64_t, void *> 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<uint8_t *>(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<uint8_t *>(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<uint8_t> rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader));
addHeader(rawDataWithHeader.data(), rawDataWithHeader.size(), reinterpret_cast<uint8_t *>(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<uint8_t *>(rawDataWithHeader.data()), hCalculateOperation,
&totalMetricReportCount, nullptr));
// invalid input raw data size
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_SIZE, zetIntelMetricCalculateValuesExp(rawDataVectorSize / 30, &offset,
reinterpret_cast<uint8_t *>(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<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()), 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<zet_metric_handle_t> phMetrics(metricCount);
EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, phMetrics.data()), ZE_RESULT_SUCCESS);
std::vector<zet_metric_handle_t> 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<uint32_t>(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<zet_intel_metric_result_exp_t> metricResults(totalMetricReportCount * metricsInReportCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateValuesExp(rawDataVectorSize, &offset,
reinterpret_cast<uint8_t *>(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<uint8_t> rawDataWithHeader(rawDataVectorSize + sizeof(IpSamplingMetricDataHeader));
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()), hCalculateOperation,
&totalMetricReportCount, nullptr));
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateValuesExp(rawDataVectorSize, &offset,
reinterpret_cast<uint8_t *>(rawDataVector.data()), hCalculateOperation,
&totalMetricReportCount, nullptr));
uint32_t setCount = 0;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetIntelMetricCalculateMultipleValuesExp(rawDataVectorSize, &offset,
reinterpret_cast<uint8_t *>(rawDataVector.data()),
hCalculateOperation, &setCount, nullptr,
nullptr, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation));
}
} // namespace ult
} // namespace L0

7
level_zero/tools/test/unit_tests/sources/metrics/test_metric_tracer.cpp
View File

@@ -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 <level_zero/zet_api.h>
#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