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

feature: support excluded metrics from calc op

Browse Source 
Resolves: NEO-15492

Signed-off-by: Matias Cabral <matias.a.cabral@intel.com>
This commit is contained in:
Matias Cabral
2025-07-22 17:42:38 +00:00
committed by Compute-Runtime-Automation
parent ad78ea7da4
commit b7f9d55118
17 changed files with 221 additions and 144 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -590,8 +590,6 @@ bool MetricDeviceContext::areMetricsFromSameSource(uint32_t count, zet_metric_ha
ze_result_t MetricDeviceContext::calcOperationCreate(zet_context_handle_t hContext,
zet_intel_metric_calculate_exp_desc_t *pCalculateDesc,
uint32_t *pExcludedMetricCount,
zet_metric_handle_t *phExcludedMetrics,
zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation) {
if (pCalculateDesc->timeAggregationWindow == 0) {
@@ -642,7 +640,7 @@ ze_result_t MetricDeviceContext::calcOperationCreate(zet_context_handle_t hConte
}
MetricSource &metricSource = (metricGroupImp) ? metricGroupImp->getMetricSource() : metricImp->getMetricSource(); // NOLINT(clang-analyzer-core.CallAndMessage)
return metricSource.calcOperationCreate(*this, pCalculateDesc, pExcludedMetricCount, phExcludedMetrics, phCalculateOperation);
return metricSource.calcOperationCreate(*this, pCalculateDesc, phCalculateOperation);
}
std::unique_ptr<MetricScopeImp> MetricScopeImp::create(zet_intel_metric_scope_properties_exp_t &scopeProperties) {
@@ -966,6 +964,32 @@ MetricImp *HomogeneousMultiDeviceMetricCreated::create(MetricSource &metricSourc
return new (std::nothrow) HomogeneousMultiDeviceMetricCreated(metricSource, subDeviceMetrics);
}
ze_result_t MetricCalcOpImp::getMetricsFromCalcOp(uint32_t *pCount, zet_metric_handle_t *phMetrics, bool isExcludedMetrics) {
if (*pCount == 0) {
*pCount = isExcludedMetrics ? excludedMetricCount : metricInReportCount;
return ZE_RESULT_SUCCESS;
} else if (*pCount < (isExcludedMetrics ? excludedMetricCount : metricInReportCount)) {
METRICS_LOG_ERR("%s", "Metric can't be smaller than report size");
*pCount = 0;
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
*pCount = isExcludedMetrics ? excludedMetricCount : metricInReportCount;
for (uint32_t index = 0; index < *pCount; index++) {
phMetrics[index] = isExcludedMetrics ? excludedMetrics[index]->toHandle() : metricsInReport[index]->toHandle();
}
return ZE_RESULT_SUCCESS;
}
ze_result_t MetricCalcOpImp::getReportFormat(uint32_t *pCount, zet_metric_handle_t *phMetrics) {
return getMetricsFromCalcOp(pCount, phMetrics, false);
}
ze_result_t MetricCalcOpImp::getExcludedMetrics(uint32_t *pCount, zet_metric_handle_t *phMetrics) {
return getMetricsFromCalcOp(pCount, phMetrics, true);
}
ze_result_t metricProgrammableGet(zet_device_handle_t hDevice, uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables) {
auto device = Device::fromHandle(hDevice);
return static_cast<MetricDeviceContext &>(device->getMetricDeviceContext()).metricProgrammableGet(pCount, phMetricProgrammables);
@@ -1007,12 +1031,10 @@ ze_result_t metricCalculateOperationCreate(
zet_context_handle_t hContext,
zet_device_handle_t hDevice,
zet_intel_metric_calculate_exp_desc_t *pCalculateDesc,
uint32_t *pExcludedMetricCount,
zet_metric_handle_t *phExcludedMetrics,
zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation) {
DeviceImp *deviceImp = static_cast<DeviceImp *>(L0::Device::fromHandle(hDevice));
return deviceImp->getMetricDeviceContext().calcOperationCreate(hContext, pCalculateDesc, pExcludedMetricCount, phExcludedMetrics, phCalculateOperation);
return deviceImp->getMetricDeviceContext().calcOperationCreate(hContext, pCalculateDesc, phCalculateOperation);
}
ze_result_t metricCalculateOperationDestroy(
@@ -1027,6 +1049,13 @@ ze_result_t metricCalculateGetReportFormat(
return MetricCalcOp::fromHandle(hCalculateOperation)->getReportFormat(pCount, phMetrics);
}
ze_result_t metricCalculateGetExcludedMetrics(
zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation,
uint32_t *pCount,
zet_metric_handle_t *phMetrics) {
return MetricCalcOp::fromHandle(hCalculateOperation)->getExcludedMetrics(pCount, phMetrics);
}
ze_result_t metricCalculateValues(
const size_t rawDataSize,
size_t *pOffset,

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

@@ -106,8 +106,6 @@ class MetricSource {
virtual ze_result_t appendMarker(zet_command_list_handle_t hCommandList, zet_metric_group_handle_t hMetricGroup, uint32_t value) = 0;
virtual ze_result_t calcOperationCreate(MetricDeviceContext &metricDeviceContext,
zet_intel_metric_calculate_exp_desc_t *pCalculateDesc,
uint32_t *pCount,
zet_metric_handle_t *phExcludedMetrics,
zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation) = 0;
virtual bool canDisable() = 0;
virtual void initMetricScopes(MetricDeviceContext &metricDeviceContext) = 0;
@@ -177,8 +175,6 @@ class MetricDeviceContext {
zet_metric_group_handle_t *phMetricGroups);
ze_result_t calcOperationCreate(zet_context_handle_t hContext,
zet_intel_metric_calculate_exp_desc_t *pCalculateDesc,
uint32_t *pExcludedMetricCount,
zet_metric_handle_t *phExcludedMetrics,
zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation);
ze_result_t metricScopesGet(zet_context_handle_t hContext,
uint32_t *pMetricScopesCount,
@@ -470,6 +466,7 @@ struct MetricCalcOp : _zet_intel_metric_calculate_operation_exp_handle_t {
virtual ze_result_t destroy() = 0;
virtual ze_result_t getReportFormat(uint32_t *pCount, zet_metric_handle_t *phMetrics) = 0;
virtual ze_result_t getExcludedMetrics(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,
@@ -481,11 +478,24 @@ struct MetricCalcOp : _zet_intel_metric_calculate_operation_exp_handle_t {
struct MetricCalcOpImp : public MetricCalcOp {
~MetricCalcOpImp() override = default;
MetricCalcOpImp(bool multiDevice) : isMultiDevice(multiDevice) {}
MetricCalcOpImp(bool multiDevice, const std::vector<MetricImp *> &inMetricsInReport,
uint32_t inExcludedMetricsCount = 0, const std::vector<MetricImp *> &inExcludedMetrics = std::vector<MetricImp *>())
: isMultiDevice(multiDevice), metricInReportCount(static_cast<uint32_t>(inMetricsInReport.size())),
metricsInReport(inMetricsInReport), excludedMetricCount(inExcludedMetricsCount),
excludedMetrics(inExcludedMetrics) {}
bool isRootDevice() { return isMultiDevice; }
ze_result_t getReportFormat(uint32_t *pCount, zet_metric_handle_t *phMetrics) override;
ze_result_t getExcludedMetrics(uint32_t *pCount, zet_metric_handle_t *phMetrics) override;
uint32_t getMetricsInReportCount() { return metricInReportCount; };
protected:
ze_result_t getMetricsFromCalcOp(uint32_t *pCount, zet_metric_handle_t *phMetrics, bool isExcludedMetrics = false);
bool isMultiDevice = false;
uint32_t metricInReportCount = 0;
std::vector<MetricImp *> metricsInReport{};
uint32_t excludedMetricCount = 0;
std::vector<MetricImp *> excludedMetrics{};
};
struct MetricScope : _zet_intel_metric_scope_exp_handle_t {
@@ -562,13 +572,16 @@ ze_result_t metricTracerDecode(zet_metric_decoder_exp_handle_t hMetricDecoder, s
uint32_t *pMetricEntriesCount, zet_metric_entry_exp_t *pMetricEntries);
ze_result_t metricCalculateOperationCreate(zet_context_handle_t hContext, zet_device_handle_t hDevice, zet_intel_metric_calculate_exp_desc_t *pCalculateDesc,
uint32_t *pCount, zet_metric_handle_t *phExcludedMetrics, zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation);
zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation);
ze_result_t metricCalculateOperationDestroy(zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation);
ze_result_t metricCalculateGetReportFormat(zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation,
uint32_t *pCount, zet_metric_handle_t *phMetrics);
ze_result_t metricCalculateGetExcludedMetrics(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);

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

@@ -267,14 +267,9 @@ ze_result_t IpSamplingMetricSourceImp::handleMetricGroupExtendedProperties(zet_m
ze_result_t IpSamplingMetricSourceImp::calcOperationCreate(MetricDeviceContext &metricDeviceContext,
zet_intel_metric_calculate_exp_desc_t *pCalculateDesc,
uint32_t *pExcludedMetricCount,
zet_metric_handle_t *phExcludedMetrics,
zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation) {
ze_result_t status = ZE_RESULT_ERROR_UNKNOWN;
// All metrics in Ip sampling allow calculation
*pExcludedMetricCount = 0;
bool isMultiDevice = (metricDeviceContext.isImplicitScalingCapable()) ? true : false;
status = IpSamplingMetricCalcOpImp::create(*this, pCalculateDesc, isMultiDevice, phCalculateOperation);
return status;

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

@@ -59,8 +59,6 @@ class IpSamplingMetricSourceImp : public MetricSource {
}
ze_result_t calcOperationCreate(MetricDeviceContext &metricDeviceContext,
zet_intel_metric_calculate_exp_desc_t *pCalculateDesc,
uint32_t *pExcludedMetricCount,
zet_metric_handle_t *phExcludedMetrics,
zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation) override;
uint32_t metricSourceCount = 0;

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

@@ -118,24 +118,25 @@ ze_result_t IpSamplingMetricCalcOpImp::create(IpSamplingMetricSourceImp &metricS
MetricGroup::fromHandle(hMetricGroup)->metricGet(&metricCount, nullptr);
std::vector<zet_metric_handle_t> hMetrics(metricCount);
MetricGroup::fromHandle(hMetricGroup)->metricGet(&metricCount, hMetrics.data());
std::vector<MetricImp *> inputMetricsInReport = {};
std::vector<MetricImp *> metricsInReport = {};
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);
metricsInReport.push_back(metric);
includedMetricIndexes.push_back(i);
} else {
if (uniqueMetricHandles.find(hMetrics[i]) != uniqueMetricHandles.end()) {
inputMetricsInReport.push_back(metric);
metricsInReport.push_back(metric);
includedMetricIndexes.push_back(i);
}
}
}
auto calcOp = new IpSamplingMetricCalcOpImp(static_cast<uint32_t>(hMetrics.size()),
inputMetricsInReport, includedMetricIndexes, isMultiDevice);
metricsInReport, includedMetricIndexes,
isMultiDevice);
*phCalculateOperation = calcOp->toHandle();
return ZE_RESULT_SUCCESS;
}
@@ -145,25 +146,6 @@ ze_result_t IpSamplingMetricCalcOpImp::destroy() {
return ZE_RESULT_SUCCESS;
}
ze_result_t IpSamplingMetricCalcOpImp::getReportFormat(uint32_t *pCount, zet_metric_handle_t *phMetrics) {
if (*pCount == 0) {
*pCount = metricsInReportCount;
return ZE_RESULT_SUCCESS;
} 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 = 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,

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

@@ -48,12 +48,11 @@ struct MultiDeviceIpSamplingMetricStreamerImp : public IpSamplingMetricStreamerB
};
struct IpSamplingMetricCalcOpImp : public MetricCalcOpImp {
IpSamplingMetricCalcOpImp(uint32_t inputCachedMetricsCount, std::vector<MetricImp *> &inputMetricsInReport,
IpSamplingMetricCalcOpImp(uint32_t inCachedMetricsCount,
std::vector<MetricImp *> &metricsInReport,
std::vector<uint32_t> &inputIncludedMetricIndexes, bool multidevice)
: MetricCalcOpImp(multidevice),
cachedMetricsCount(inputCachedMetricsCount),
metricsInReportCount(static_cast<uint32_t>(inputMetricsInReport.size())),
metricsInReport(inputMetricsInReport),
: MetricCalcOpImp(multidevice, metricsInReport),
cachedMetricsCount(inCachedMetricsCount),
includedMetricIndexes(inputIncludedMetricIndexes) {}
~IpSamplingMetricCalcOpImp() override{};
@@ -62,7 +61,6 @@ struct IpSamplingMetricCalcOpImp : public MetricCalcOpImp {
bool isMultiDevice,
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(const size_t rawDataSize, size_t *offset, const uint8_t *pRawData,
uint32_t *pSetCount, uint32_t *pMetricsReportCountPerSet,
uint32_t *pTotalMetricReportCount,
@@ -98,8 +96,6 @@ struct IpSamplingMetricCalcOpImp : public MetricCalcOpImp {
std::map<uint64_t, void *> &stallReportDataMap);
uint32_t cachedMetricsCount = 0;
uint32_t metricsInReportCount = 0;
std::vector<MetricImp *> metricsInReport{};
std::vector<uint32_t> includedMetricIndexes{};
};

2
level_zero/tools/source/metrics/metric_oa_source.h
View File

@@ -66,8 +66,6 @@ class OaMetricSourceImp : public MetricSource {
zet_metric_group_handle_t *pMetricGroupHandle);
ze_result_t calcOperationCreate(MetricDeviceContext &metricDeviceContext,
zet_intel_metric_calculate_exp_desc_t *pCalculateDesc,
uint32_t *pExcludedMetricCount,
zet_metric_handle_t *phExcludedMetrics,
zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}

25
level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2022-2024 Intel Corporation
* Copyright (C) 2022-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -16,17 +16,18 @@
#include <map>
#include <vector>
#define VALIDATECALL(myZeCall) \
do { \
if ((myZeCall) != ZE_RESULT_SUCCESS) { \
std::cout << "Validate Error: " \
<< static_cast<uint32_t>(myZeCall) \
<< " at " \
<< #myZeCall << ": " \
<< __FILE__ << ": " \
<< __LINE__ << std::endl; \
std::terminate(); \
} \
#define VALIDATECALL(myZeCall) \
do { \
if (((myZeCall) != ZE_RESULT_SUCCESS) && \
((myZeCall) != ZE_RESULT_WARNING_ACTION_REQUIRED)) { \
std::cout << "Validate Error: " \
<< static_cast<uint32_t>(myZeCall) \
<< " at " \
<< #myZeCall << ": " \
<< __FILE__ << ": " \
<< __LINE__ << std::endl; \
std::terminate(); \
} \
} while (0);
#define EXPECT(cond) \

13
level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_util.cpp
View File

@@ -70,6 +70,19 @@ bool getTestMachineConfiguration(TestMachineConfiguration &machineConfig) {
deviceProperties.pNext = nullptr;
VALIDATECALL(zeDeviceGetProperties(devices[0], &deviceProperties));
machineConfig.deviceId = deviceProperties.deviceId;
uint32_t extensionsCount = 0;
VALIDATECALL(zeDriverGetExtensionProperties(driverHandle, &extensionsCount, nullptr));
if (extensionsCount != 0) {
machineConfig.driverExtensionsProperties.resize(extensionsCount);
VALIDATECALL(zeDriverGetExtensionProperties(driverHandle, &extensionsCount, machineConfig.driverExtensionsProperties.data()));
for (uint32_t i = 0; i < extensionsCount; i++) {
uint32_t supportedVersion = machineConfig.driverExtensionsProperties[i].version;
LOG(LogLevel::DEBUG) << "Extension #" << i << " name: " << machineConfig.driverExtensionsProperties[i].name << " version: " << ZE_MAJOR_VERSION(supportedVersion) << "." << ZE_MINOR_VERSION(supportedVersion) << std::endl;
}
}
return true;
}

1
level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_util.h
View File

@@ -26,6 +26,7 @@ struct TestMachineConfiguration {
} devices[MAX_DEVICES_IN_MACHINE];
uint32_t deviceCount = 0;
uint32_t deviceId;
std::vector<ze_driver_extension_properties_t> driverExtensionsProperties{};
};
template <class T>

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

@@ -51,8 +51,6 @@ class MockMetricSource : public L0::MetricSource {
ze_result_t calcOperationCreate(MetricDeviceContext &metricDeviceContext,
zet_intel_metric_calculate_exp_desc_t *pCalculateDesc,
uint32_t *pCount,
zet_metric_handle_t *phExcludedMetrics,
zet_intel_metric_calculate_operation_exp_handle_t *phCalculateOperation) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
@@ -163,13 +161,13 @@ class MockMetric : public L0::MetricImp {
class MockMetricCalcOp : public MetricCalcOpImp {
public:
~MockMetricCalcOp() override = default;
MockMetricCalcOp() : MetricCalcOpImp(false){};
MockMetricCalcOp(bool multiDevice, const std::vector<MetricImp *> &inMetricsInReport,
uint32_t inExcludedMetricsCount, const std::vector<MetricImp *> &inExcludedMetrics)
: MetricCalcOpImp(multiDevice, inMetricsInReport, inExcludedMetricsCount, inExcludedMetrics) {}
ze_result_t destroy() override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
};
ze_result_t getReportFormat(uint32_t *pCount, zet_metric_handle_t *phMetrics) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
};
ze_result_t metricCalculateMultipleValues(const size_t rawDataSize, size_t *offset, const uint8_t *pRawData,
uint32_t *pSetCount, uint32_t *pMetricReportCountPerSet,
uint32_t *pTotalMetricReportCount,

48
level_zero/tools/test/unit_tests/sources/metrics/test_metric.cpp
View File

@@ -51,8 +51,6 @@ class CalcOperationFixture : public DeviceFixture,
MockMetricSource mockMetricSource{};
MockMetricGroup *mockMetricGroup;
zet_metric_group_handle_t phMetricGroup = nullptr;
uint32_t excludedMetricsCount = 0;
zet_metric_handle_t *phExcludedMetrics = nullptr;
DebugManagerStateRestore restorer;
};
@@ -86,7 +84,6 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpAndInvalidParamsPassedThenErrorIs
zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation;
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateOperationCreateExp(context->toHandle(),
device->toHandle(), &calculateDesc,
&excludedMetricsCount, phExcludedMetrics,
&hCalculateOperation));
// No metric groups or metrics
@@ -94,7 +91,6 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpAndInvalidParamsPassedThenErrorIs
calculateDesc.metricGroupCount = 0;
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateOperationCreateExp(context->toHandle(),
device->toHandle(), &calculateDesc,
&excludedMetricsCount, phExcludedMetrics,
&hCalculateOperation));
}
@@ -121,7 +117,6 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpWithMixedSourcesThenErrorIsReturn
zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation;
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateOperationCreateExp(context,
device->toHandle(), &calculateDesc,
&excludedMetricsCount, phExcludedMetrics,
&hCalculateOperation));
// metrics from different source
@@ -135,7 +130,6 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpWithMixedSourcesThenErrorIsReturn
calculateDesc.phMetrics = metrics.data();
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateOperationCreateExp(context,
device->toHandle(), &calculateDesc,
&excludedMetricsCount, phExcludedMetrics,
&hCalculateOperation));
// metrics and metric group from different source
@@ -143,7 +137,6 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpWithMixedSourcesThenErrorIsReturn
calculateDesc.phMetrics = &metrics[1];
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateOperationCreateExp(context,
device->toHandle(), &calculateDesc,
&excludedMetricsCount, phExcludedMetrics,
&hCalculateOperation));
}
@@ -168,7 +161,6 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpWithMixedHierarchiesThenErrorIsRe
zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation;
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateOperationCreateExp(context,
device->toHandle(), &calculateDesc,
&excludedMetricsCount, phExcludedMetrics,
&hCalculateOperation));
MockMetric mockMetric(mockMetricSource), mockMetric2(mockMetricSource);
@@ -182,7 +174,6 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpWithMixedHierarchiesThenErrorIsRe
calculateDesc.phMetrics = metrics.data();
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateOperationCreateExp(context,
device->toHandle(), &calculateDesc,
&excludedMetricsCount, phExcludedMetrics,
&hCalculateOperation));
}
@@ -206,7 +197,6 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpUseTheSourceFromMetricGroupOrMetr
zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetIntelMetricCalculateOperationCreateExp(context,
device->toHandle(), &calculateDesc,
&excludedMetricsCount, phExcludedMetrics,
&hCalculateOperation));
MockMetric mockMetric(mockMetricSource), mockMetric2(mockMetricSource);
@@ -218,12 +208,15 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpUseTheSourceFromMetricGroupOrMetr
calculateDesc.phMetrics = metrics.data();
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetIntelMetricCalculateOperationCreateExp(context,
device->toHandle(), &calculateDesc,
&excludedMetricsCount, phExcludedMetrics,
&hCalculateOperation));
}
TEST_F(CalcOperationFixture, WhenCreatingCalcOpObjectToAndFromHandleBaseClassWorkAsExpected) {
MockMetricCalcOp mockMetricCalcOp{};
std::vector<MetricImp *> mockMetricsInReport{};
uint32_t mockExcludedMetricCount = 0;
std::vector<MetricImp *> mockExcludedMetrics{};
MockMetricCalcOp mockMetricCalcOp(false, mockMetricsInReport, mockExcludedMetricCount, mockExcludedMetrics);
auto hMockCalcOp = mockMetricCalcOp.toHandle();
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetIntelMetricCalculateOperationDestroyExp(hMockCalcOp));
@@ -232,6 +225,37 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpObjectToAndFromHandleBaseClassWor
EXPECT_NE(nullptr, mockCalcOp);
}
TEST_F(CalcOperationFixture, WhenGettingMetricsInReportAndExcludedMetricsThenTheyAreReturnedCorrectly) {
std::vector<MetricImp *> mockMetricsInReport{};
MockMetric mockMetricInReport(mockMetricSource);
mockMetricsInReport.push_back(&mockMetricInReport);
std::vector<MetricImp *> mockExcludedMetrics{};
uint32_t mockExcludedMetricCount = 1;
MockMetric mockExcludedMetric(mockMetricSource);
mockExcludedMetrics.push_back(&mockExcludedMetric);
MockMetricCalcOp mockMetricCalcOp(false, mockMetricsInReport, mockExcludedMetricCount, mockExcludedMetrics);
uint32_t metricCount = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationGetReportFormatExp(mockMetricCalcOp.toHandle(), &metricCount, nullptr));
EXPECT_EQ(metricCount, 1U);
zet_metric_handle_t metricHandle = nullptr;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationGetReportFormatExp(mockMetricCalcOp.toHandle(), &metricCount, &metricHandle));
EXPECT_EQ(metricCount, 1U);
EXPECT_EQ(metricHandle, mockMetricInReport.toHandle());
EXPECT_EQ(metricCount, mockMetricCalcOp.getMetricsInReportCount());
metricCount = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationGetExcludedMetricsExp(mockMetricCalcOp.toHandle(), &metricCount, nullptr));
EXPECT_EQ(metricCount, 1U);
zet_metric_handle_t excludedMetricHandle = nullptr;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationGetExcludedMetricsExp(mockMetricCalcOp.toHandle(), &metricCount, &excludedMetricHandle));
EXPECT_EQ(metricCount, 1U);
EXPECT_EQ(excludedMetricHandle, mockExcludedMetric.toHandle());
EXPECT_NE(excludedMetricHandle, metricHandle);
}
using MetricRuntimeFixture = Test<DeviceFixture>;
TEST_F(MetricRuntimeFixture, WhenRunTimeEnableIsDoneThenReturnSuccess) {

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

@@ -577,11 +577,8 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingMetricGroupThenCrea
};
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));
@@ -597,7 +594,6 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingMetricGroupThenCrea
calculateDesc.phMetrics = &phMetric;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationCreateExp(context->toHandle(),
device->toHandle(), &calculateDesc,
&excludedMetricsCount, &phExcludedMetrics,
&hCalculateOperation));
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation));
}
@@ -628,19 +624,17 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingCalcOpCanGetReportF
};
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(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationGetReportFormatExp(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(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationGetReportFormatExp(hCalculateOperation, &metricsInReportCount, metricsInReport.data()));
EXPECT_EQ(metricsInReportCount, 10u);
zet_metric_properties_t ipSamplingMetricProperties = {};
@@ -652,7 +646,7 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingCalcOpCanGetReportF
// Can't filter metrics in report
metricsInReportCount = 1;
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateGetReportFormatExp(hCalculateOperation, &metricsInReportCount, metricsInReport.data()));
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateOperationGetReportFormatExp(hCalculateOperation, &metricsInReportCount, metricsInReport.data()));
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation));
}
@@ -701,19 +695,16 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingCalcOpGetReportForm
};
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(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationGetReportFormatExp(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(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationGetReportFormatExp(hCalculateOperation, &metricsInReportCount, metricsInReport.data()));
EXPECT_EQ(metricsInReportCount, 5u);
// Metrics must be in the report but can be in different order
@@ -726,6 +717,44 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingCalcOpGetReportForm
}
}
HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingCalcOpCanGetExcludedMetricsAreZero, 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;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationCreateExp(context->toHandle(),
device->toHandle(), &calculateDesc,
&hCalculateOperation));
uint32_t excludedMetricsCount = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationGetExcludedMetricsExp(hCalculateOperation, &excludedMetricsCount, nullptr));
EXPECT_EQ(excludedMetricsCount, 0u);
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationDestroyExp(hCalculateOperation));
}
}
HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, WhenReadingMetricGroupTimeCalculateFilterThenCorrectValueIsReturned, EustallSupportedPlatforms) {
EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
@@ -782,17 +811,14 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat
};
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(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationGetReportFormatExp(hCalculateOperation,
&metricsInReportCount,
metricsInReport.data()));
EXPECT_EQ(metricsInReportCount, 10u);
std::vector<zet_metric_properties_t> metricProperties(metricsInReportCount);
@@ -849,17 +875,14 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat
};
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(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationGetReportFormatExp(hCalculateOperation,
&metricsInReportCount,
metricsInReport.data()));
EXPECT_EQ(metricsInReportCount, 10u);
std::vector<zet_metric_properties_t> metricProperties(metricsInReportCount);
@@ -963,11 +986,8 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCoverBoundaryConditio
};
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;
@@ -1034,12 +1054,11 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat
};
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);
@@ -1081,11 +1100,8 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat
};
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;
@@ -1142,14 +1158,12 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat
};
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(ZE_RESULT_SUCCESS, zetIntelMetricCalculateOperationGetReportFormatExp(hCalculateOperation, &metricsInReportCount, nullptr));
EXPECT_EQ(metricsInReportCount, 5u);
// calculate only one report and expect results follow the order of rawDataVector
@@ -1198,11 +1212,9 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, GivenIpSamplingCalcOpCallingMetric
};
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));

4
level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_1.cpp
View File

@@ -3702,11 +3702,9 @@ TEST_F(MetricEnumerationTest, givenValidOAMetricGroupThenOASourceCalcOperationIs
};
zet_intel_metric_calculate_operation_exp_handle_t hCalculateOperation;
uint32_t excludedMetricsCount = 0;
zet_metric_handle_t *phExcludedMetrics = nullptr;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetIntelMetricCalculateOperationCreateExp(context->toHandle(),
device->toHandle(), &calculateDesc,
&excludedMetricsCount, phExcludedMetrics,
&hCalculateOperation));
}