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

feature: calcOp supports metric scopes

Browse Source 
Resolves: NEO-14417

Signed-off-by: Matias Cabral <matias.a.cabral@intel.com>
This commit is contained in:
Matias Cabral
2025-08-20 23:32:59 +00:00
committed by Compute-Runtime-Automation
parent 88b2fb60a6
commit 1197ec47bc
13 changed files with 353 additions and 259 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -34,13 +34,13 @@ void MetricSource::getMetricGroupSourceIdProperty(zet_base_properties_t *propert
void MetricSource::initComputeMetricScopes(MetricDeviceContext &metricDeviceContext) {
auto createScope = [&metricDeviceContext](const std::string &name, const std::string &desc, uint32_t id) {
auto createScope = [&metricDeviceContext](const std::string &name, const std::string &desc, uint32_t id, bool aggregated) {
zet_intel_metric_scope_properties_exp_t scopeProperties = {ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP, nullptr};
scopeProperties.iD = id;
snprintf(scopeProperties.name, ZET_INTEL_MAX_METRIC_SCOPE_NAME_EXP, "%s", name.c_str());
snprintf(scopeProperties.description, ZET_INTEL_MAX_METRIC_SCOPE_NAME_EXP, "%s", desc.c_str());
auto metricScopeImp = MetricScopeImp::create(scopeProperties);
auto metricScopeImp = MetricScopeImp::create(scopeProperties, aggregated);
DEBUG_BREAK_IF(metricScopeImp == nullptr);
metricDeviceContext.addMetricScope(std::move(metricScopeImp));
};
@@ -50,25 +50,25 @@ void MetricSource::initComputeMetricScopes(MetricDeviceContext &metricDeviceCont
auto deviceImp = static_cast<DeviceImp *>(&metricDeviceContext.getDevice());
uint32_t subDeviceCount = deviceImp->numSubDevices;
for (uint32_t i = 0; i < subDeviceCount; i++) {
std::string scopeName = "COMPUTE_TILE_" + std::to_string(i);
std::string scopeDesc = "Metrics results for tile " + std::to_string(i);
std::string scopeName = std::string(computeScopeNamePrefix) + std::to_string(i);
std::string scopeDesc = std::string(computeScopeDescriptionPrefix) + std::to_string(i);
createScope(scopeName, scopeDesc, i);
createScope(scopeName, scopeDesc, i, false);
}
auto &l0GfxCoreHelper = metricDeviceContext.getDevice().getNEODevice()->getRootDeviceEnvironment().getHelper<L0GfxCoreHelper>();
if (l0GfxCoreHelper.supportMetricsAggregation()) {
std::string scopeName = "DEVICE_AGGREGATED";
std::string scopeDesc = "Metrics results aggregated at device level";
std::string scopeName(aggregatedScopeName);
std::string scopeDesc(aggregatedScopeDescription);
createScope(scopeName, scopeDesc, subDeviceCount);
createScope(scopeName, scopeDesc, subDeviceCount, true);
}
} else {
auto subDeviceIndex = metricDeviceContext.getSubDeviceIndex();
std::string scopeName = "COMPUTE_TILE_" + std::to_string(subDeviceIndex);
std::string scopeDesc = "Metrics results for tile " + std::to_string(subDeviceIndex);
std::string scopeName = std::string(computeScopeNamePrefix) + std::to_string(subDeviceIndex);
std::string scopeDesc = std::string(computeScopeDescriptionPrefix) + std::to_string(subDeviceIndex);
createScope(scopeName, scopeDesc, subDeviceIndex);
createScope(scopeName, scopeDesc, subDeviceIndex, false);
}
metricDeviceContext.setComputeMetricScopeInitialized();
@@ -646,12 +646,38 @@ ze_result_t MetricDeviceContext::calcOperationCreate(zet_context_handle_t hConte
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
if (pCalculationDesc->metricScopesCount == 0) {
METRICS_LOG_ERR("%s", "Must define at least one metric scope");
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
std::vector<MetricScopeImp *> metricScopes;
bool aggregatedScopeProvided = false;
for (uint32_t i = 0; i < pCalculationDesc->metricScopesCount; i++) {
metricScopes.push_back(static_cast<MetricScopeImp *>(MetricScope::fromHandle(pCalculationDesc->phMetricScopes[i])));
if (metricScopes.back()->isAggregated()) {
aggregatedScopeProvided = true;
}
}
std::sort(metricScopes.begin(), metricScopes.end());
metricScopes.erase(std::unique(metricScopes.begin(), metricScopes.end()), metricScopes.end());
// If aggregated scope is provided, make it be listed first.
if (aggregatedScopeProvided) {
auto aggregatedScopeIt = std::find_if(metricScopes.begin(), metricScopes.end(),
[](const zet_intel_metric_scope_exp_handle_t &scope) {
return static_cast<MetricScopeImp *>(MetricScope::fromHandle(scope))->isAggregated();
});
std::swap(metricScopes[0], *aggregatedScopeIt);
}
MetricSource &metricSource = (metricGroupImp) ? metricGroupImp->getMetricSource() : metricImp->getMetricSource(); // NOLINT(clang-analyzer-core.CallAndMessage)
return metricSource.calcOperationCreate(*this, pCalculationDesc, phCalculationOperation);
return metricSource.calcOperationCreate(*this, pCalculationDesc, metricScopes, phCalculationOperation);
}
std::unique_ptr<MetricScopeImp> MetricScopeImp::create(zet_intel_metric_scope_properties_exp_t &scopeProperties) {
return std::make_unique<MetricScopeImp>(scopeProperties);
std::unique_ptr<MetricScopeImp> MetricScopeImp::create(zet_intel_metric_scope_properties_exp_t &scopeProperties, bool aggregated) {
return std::make_unique<MetricScopeImp>(scopeProperties, aggregated);
}
void MetricDeviceContext::initMetricScopes() {
@@ -973,15 +999,15 @@ MetricImp *HomogeneousMultiDeviceMetricCreated::create(MetricSource &metricSourc
ze_result_t MetricCalcOpImp::getMetricsFromCalcOp(uint32_t *pCount, zet_metric_handle_t *phMetrics, bool isExcludedMetrics) {
if (*pCount == 0) {
*pCount = isExcludedMetrics ? excludedMetricCount : metricInReportCount;
*pCount = isExcludedMetrics ? getExcludedMetricsCount() : getMetricsInReportCount();
return ZE_RESULT_SUCCESS;
} else if (*pCount < (isExcludedMetrics ? excludedMetricCount : metricInReportCount)) {
} else if (*pCount < (isExcludedMetrics ? getExcludedMetricsCount() : getMetricsInReportCount())) {
METRICS_LOG_ERR("%s", "Metric can't be smaller than report size");
*pCount = 0;
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
*pCount = isExcludedMetrics ? excludedMetricCount : metricInReportCount;
*pCount = isExcludedMetrics ? getExcludedMetricsCount() : getMetricsInReportCount();
for (uint32_t index = 0; index < *pCount; index++) {
phMetrics[index] = isExcludedMetrics ? excludedMetrics[index]->toHandle() : metricsInReport[index]->toHandle();
}

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

@@ -107,6 +107,7 @@ 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_calculation_exp_desc_t *pCalculationDesc,
const std::vector<MetricScopeImp *> &metricScopes,
zet_intel_metric_calculation_operation_exp_handle_t *phCalculationOperation) = 0;
virtual bool canDisable() = 0;
virtual void initMetricScopes(MetricDeviceContext &metricDeviceContext) = 0;
@@ -479,26 +480,33 @@ struct MetricCalcOp : _zet_intel_metric_calculation_operation_exp_handle_t {
struct MetricCalcOpImp : public MetricCalcOp {
~MetricCalcOpImp() override = default;
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) {}
MetricCalcOpImp(bool multiDevice,
const std::vector<MetricScopeImp *> &metricScopes,
const std::vector<MetricImp *> &metricsInReport,
const std::vector<MetricImp *> &excludedMetrics = std::vector<MetricImp *>())
: isMultiDevice(multiDevice),
metricScopes(metricScopes),
metricsInReport(metricsInReport),
excludedMetrics(excludedMetrics) {}
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; };
uint32_t getMetricsInReportCount() { return static_cast<uint32_t>(metricsInReport.size()); };
uint32_t getExcludedMetricsCount() { return static_cast<uint32_t>(excludedMetrics.size()); };
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<MetricScopeImp *> metricScopes{};
std::vector<MetricImp *> metricsInReport{};
uint32_t excludedMetricCount = 0;
std::vector<MetricImp *> excludedMetrics{};
};
static constexpr std::string_view computeScopeNamePrefix = "COMPUTE_TILE_";
static constexpr std::string_view computeScopeDescriptionPrefix = "Metrics results for tile ";
static constexpr std::string_view aggregatedScopeName = "DEVICE_AGGREGATED";
static constexpr std::string_view aggregatedScopeDescription = "Metrics results aggregated at device level";
struct MetricScope : _zet_intel_metric_scope_exp_handle_t {
virtual ~MetricScope() = default;
MetricScope() {}
@@ -511,13 +519,15 @@ struct MetricScope : _zet_intel_metric_scope_exp_handle_t {
struct MetricScopeImp : public MetricScope {
~MetricScopeImp() override = default;
MetricScopeImp(zet_intel_metric_scope_properties_exp_t &properties) : properties(properties){};
MetricScopeImp(zet_intel_metric_scope_properties_exp_t &properties, bool aggregated) : properties(properties), aggregated(aggregated) {}
virtual ze_result_t getProperties(zet_intel_metric_scope_properties_exp_t *pProperties);
static std::unique_ptr<MetricScopeImp> create(zet_intel_metric_scope_properties_exp_t &scopeProperties);
static std::unique_ptr<MetricScopeImp> create(zet_intel_metric_scope_properties_exp_t &scopeProperties, bool aggregated);
bool isAggregated() const { return aggregated; }
private:
zet_intel_metric_scope_properties_exp_t properties;
bool aggregated = false;
};
// MetricGroup.

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

@@ -274,11 +274,12 @@ ze_result_t IpSamplingMetricSourceImp::handleMetricGroupExtendedProperties(zet_m
ze_result_t IpSamplingMetricSourceImp::calcOperationCreate(MetricDeviceContext &metricDeviceContext,
zet_intel_metric_calculation_exp_desc_t *pCalculationDesc,
const std::vector<MetricScopeImp *> &metricScopes,
zet_intel_metric_calculation_operation_exp_handle_t *phCalculationOperation) {
ze_result_t status = ZE_RESULT_ERROR_UNKNOWN;
bool isMultiDevice = (metricDeviceContext.isImplicitScalingCapable()) ? true : false;
status = IpSamplingMetricCalcOpImp::create(*this, pCalculationDesc, isMultiDevice, phCalculationOperation);
status = IpSamplingMetricCalcOpImp::create(isMultiDevice, metricScopes, *this, pCalculationDesc, phCalculationOperation);
return status;
}

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

@@ -59,6 +59,7 @@ class IpSamplingMetricSourceImp : public MetricSource {
}
ze_result_t calcOperationCreate(MetricDeviceContext &metricDeviceContext,
zet_intel_metric_calculation_exp_desc_t *pCalculationDesc,
const std::vector<MetricScopeImp *> &metricScopes,
zet_intel_metric_calculation_operation_exp_handle_t *phCalculationOperation) override;
uint32_t metricSourceCount = 0;

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

@@ -105,9 +105,10 @@ uint32_t IpSamplingMetricStreamerImp::getMaxSupportedReportCount() {
return ipSamplingSource.getMetricOsInterface()->getRequiredBufferSize(UINT32_MAX) / unitReportSize;
}
ze_result_t IpSamplingMetricCalcOpImp::create(IpSamplingMetricSourceImp &metricSource,
ze_result_t IpSamplingMetricCalcOpImp::create(bool isMultiDevice,
const std::vector<MetricScopeImp *> &metricScopes,
IpSamplingMetricSourceImp &metricSource,
zet_intel_metric_calculation_exp_desc_t *pCalculationDesc,
bool isMultiDevice,
zet_intel_metric_calculation_operation_exp_handle_t *phCalculationOperation) {
// There is only one valid metric group in IP sampling and time filtering is not supported
@@ -140,9 +141,8 @@ ze_result_t IpSamplingMetricCalcOpImp::create(IpSamplingMetricSourceImp &metricS
}
}
auto calcOp = new IpSamplingMetricCalcOpImp(static_cast<uint32_t>(hMetrics.size()),
metricsInReport, includedMetricIndexes,
isMultiDevice);
auto calcOp = new IpSamplingMetricCalcOpImp(isMultiDevice, metricScopes, static_cast<uint32_t>(hMetrics.size()),
metricsInReport, includedMetricIndexes);
*phCalculationOperation = calcOp->toHandle();
ze_result_t status = ZE_RESULT_SUCCESS;
if ((pCalculationDesc->timeWindowsCount > 0) || (pCalculationDesc->timeAggregationWindow != 0)) {

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

@@ -48,17 +48,20 @@ struct MultiDeviceIpSamplingMetricStreamerImp : public IpSamplingMetricStreamerB
};
struct IpSamplingMetricCalcOpImp : public MetricCalcOpImp {
IpSamplingMetricCalcOpImp(uint32_t inCachedMetricsCount,
IpSamplingMetricCalcOpImp(bool multidevice,
const std::vector<MetricScopeImp *> &metricScopes,
uint32_t cachedMetricsCount,
std::vector<MetricImp *> &metricsInReport,
std::vector<uint32_t> &inputIncludedMetricIndexes, bool multidevice)
: MetricCalcOpImp(multidevice, metricsInReport),
cachedMetricsCount(inCachedMetricsCount),
includedMetricIndexes(inputIncludedMetricIndexes) {}
std::vector<uint32_t> &includedMetricIndexes)
: MetricCalcOpImp(multidevice, metricScopes, metricsInReport, std::vector<MetricImp *>()),
cachedMetricsCount(cachedMetricsCount),
includedMetricIndexes(includedMetricIndexes) {}
~IpSamplingMetricCalcOpImp() override{};
static ze_result_t create(IpSamplingMetricSourceImp &metricSource,
static ze_result_t create(bool isMultiDevice,
const std::vector<MetricScopeImp *> &metricScopes,
IpSamplingMetricSourceImp &metricSource,
zet_intel_metric_calculation_exp_desc_t *pCalculationDesc,
bool isMultiDevice,
zet_intel_metric_calculation_operation_exp_handle_t *phCalculationOperation);
ze_result_t destroy() override;

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

@@ -66,6 +66,7 @@ class OaMetricSourceImp : public MetricSource {
zet_metric_group_handle_t *pMetricGroupHandle);
ze_result_t calcOperationCreate(MetricDeviceContext &metricDeviceContext,
zet_intel_metric_calculation_exp_desc_t *pCalculationDesc,
const std::vector<MetricScopeImp *> &metricScopes,
zet_intel_metric_calculation_operation_exp_handle_t *phCalculationOperation) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}

53
level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.cpp
View File

@@ -76,5 +76,58 @@ void MetricIpSamplingFixture::TearDown() {
globalDriverHandles->clear();
}
void MetricIpSamplingCalculateBaseFixture::initCalcDescriptor() {
zet_intel_metric_scope_properties_exp_t scopeProperties{};
scopeProperties.stype = ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP;
scopeProperties.pNext = nullptr;
mockMetricScope = new MockMetricScope(scopeProperties, false);
hMockScope = mockMetricScope->toHandle();
calculationDesc.stype = ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP;
calculationDesc.pNext = nullptr; // pNext
calculationDesc.metricGroupCount = 0; // metricGroupCount
calculationDesc.phMetricGroups = nullptr; // phMetricGroups
calculationDesc.metricCount = 0; // metricCount
calculationDesc.phMetrics = nullptr; // phMetrics
calculationDesc.timeWindowsCount = 0; // timeWindowsCount
calculationDesc.pCalculationTimeWindows = nullptr; // pCalculationTimeWindows
calculationDesc.timeAggregationWindow = 0; // timeAggregationWindow
calculationDesc.metricScopesCount = 1; // metricScopesCount
calculationDesc.phMetricScopes = &hMockScope; // phMetricScopes
}
void MetricIpSamplingCalculateBaseFixture::cleanupCalcDescriptor() {
delete mockMetricScope;
hMockScope = nullptr;
}
void MetricIpSamplingCalculateMultiDevFixture::SetUp() {
MetricIpSamplingMultiDevFixture::SetUp();
initCalcDescriptor();
}
void MetricIpSamplingCalculateMultiDevFixture::TearDown() {
MetricIpSamplingMultiDevFixture::TearDown();
cleanupCalcDescriptor();
}
void MetricIpSamplingCalculateSingleDevFixture::SetUp() {
MetricIpSamplingFixture::SetUp();
initCalcDescriptor();
device->getMetricDeviceContext().enableMetricApi();
uint32_t metricGroupCount = 1;
zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle);
calculationDesc.metricGroupCount = 1;
calculationDesc.phMetricGroups = &metricGroupHandle;
}
void MetricIpSamplingCalculateSingleDevFixture::TearDown() {
MetricIpSamplingFixture::TearDown();
cleanupCalcDescriptor();
}
} // namespace ult
} // namespace L0

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

@@ -10,6 +10,7 @@
#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/test/unit_tests/sources/metrics/mock_metric_source.h"
#include <level_zero/zet_api.h>
#include "gtest/gtest.h"
@@ -223,11 +224,25 @@ class MetricIpSamplingCalculateBaseFixture {
{ZET_VALUE_TYPE_UINT64, {110}},
{ZET_VALUE_TYPE_UINT64, {110}},
{ZET_VALUE_TYPE_UINT64, {110}}};
MockMetricScope *mockMetricScope;
zet_intel_metric_scope_exp_handle_t hMockScope = nullptr;
zet_intel_metric_calculation_exp_desc_t calculationDesc{};
zet_metric_group_handle_t metricGroupHandle = nullptr;
void initCalcDescriptor();
void cleanupCalcDescriptor();
};
struct MetricIpSamplingCalculateSingleDevFixture : public MetricIpSamplingCalculateBaseFixture, MetricIpSamplingFixture {
public:
void SetUp() override;
void TearDown() override;
};
struct MetricIpSamplingCalculateMultiDevFixture : public MetricIpSamplingCalculateBaseFixture, MetricIpSamplingMultiDevFixture {
public:
void SetUp() override;
void TearDown() override;
};
} // namespace ult

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

@@ -51,6 +51,7 @@ class MockMetricSource : public L0::MetricSource {
ze_result_t calcOperationCreate(MetricDeviceContext &metricDeviceContext,
zet_intel_metric_calculation_exp_desc_t *pCalculationDesc,
const std::vector<MetricScopeImp *> &metricScopes,
zet_intel_metric_calculation_operation_exp_handle_t *phCalculationOperation) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
@@ -161,9 +162,10 @@ class MockMetric : public L0::MetricImp {
class MockMetricCalcOp : public MetricCalcOpImp {
public:
~MockMetricCalcOp() override = default;
MockMetricCalcOp(bool multiDevice, const std::vector<MetricImp *> &inMetricsInReport,
uint32_t inExcludedMetricsCount, const std::vector<MetricImp *> &inExcludedMetrics)
: MetricCalcOpImp(multiDevice, inMetricsInReport, inExcludedMetricsCount, inExcludedMetrics) {}
MockMetricCalcOp(bool multiDevice, const std::vector<MetricScopeImp *> &metricScopes,
const std::vector<MetricImp *> &metricsInReport,
const std::vector<MetricImp *> &excludedMetrics)
: MetricCalcOpImp(multiDevice, metricScopes, metricsInReport, excludedMetrics) {}
ze_result_t destroy() override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
@@ -199,8 +201,8 @@ class MockMetricDeviceContext : public MetricDeviceContext {
class MockMetricScope : public MetricScopeImp {
public:
~MockMetricScope() override = default;
MockMetricScope(zet_intel_metric_scope_properties_exp_t &properties)
: MetricScopeImp(properties) {}
MockMetricScope(zet_intel_metric_scope_properties_exp_t &properties, bool aggregated)
: MetricScopeImp(properties, aggregated) {}
ze_result_t getProperties(zet_intel_metric_scope_properties_exp_t *pProperties) override {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}

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

@@ -5,9 +5,11 @@
*
*/
#include "shared/test/common/test_macros/hw_test.h"
#include "shared/test/common/test_macros/test.h"
#include "shared/test/common/test_macros/test_base.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/include/level_zero/zet_intel_gpu_metric.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_source.h"
@@ -50,7 +52,10 @@ class CalcOperationFixture : public DeviceFixture,
void TearDown() override;
MockMetricSource mockMetricSource{};
MockMetricGroup *mockMetricGroup;
zet_metric_group_handle_t phMetricGroup = nullptr;
zet_metric_group_handle_t hMetricGroup = nullptr;
MockMetricScope *mockMetricScope;
zet_intel_metric_scope_exp_handle_t hMetricScope = nullptr;
DebugManagerStateRestore restorer;
};
@@ -58,12 +63,22 @@ class CalcOperationFixture : public DeviceFixture,
void CalcOperationFixture::SetUp() {
DeviceFixture::setUp();
mockMetricGroup = new MockMetricGroup(mockMetricSource);
phMetricGroup = mockMetricGroup->toHandle();
hMetricGroup = mockMetricGroup->toHandle();
zet_intel_metric_scope_properties_exp_t scopeProperties{};
scopeProperties.stype = ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP;
scopeProperties.pNext = nullptr;
mockMetricScope = new MockMetricScope(scopeProperties, false);
hMetricScope = mockMetricScope->toHandle();
}
void CalcOperationFixture::TearDown() {
DeviceFixture::tearDown();
delete mockMetricGroup;
delete mockMetricScope;
hMetricGroup = nullptr;
hMetricScope = nullptr;
}
TEST_F(CalcOperationFixture, WhenCreatingCalcOpAndInvalidParamsPassedThenErrorIsHandled) {
@@ -71,14 +86,16 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpAndInvalidParamsPassedThenErrorIs
// Aggregation window is zero
zet_intel_metric_calculation_exp_desc_t calculationDesc{
ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP,
nullptr, // pNext
0, // metricGroupCount
nullptr, // phMetricGroups
0, // metricCount
nullptr, // phMetrics
0, // timeWindowsCount
nullptr, // pCalculationTimeWindows
0, // timeAggregationWindow
nullptr, // pNext
1, // metricGroupCount
&hMetricGroup, // phMetricGroups
0, // metricCount
nullptr, // phMetrics
0, // timeWindowsCount
nullptr, // pCalculationTimeWindows
0, // timeAggregationWindow
1, // metricScopesCount
&hMetricScope, // phMetricScopes
};
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
@@ -98,7 +115,7 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpWithMixedSourcesThenErrorIsReturn
MockMetricGroup mockMetricGroup2(mockMetricSource2);
// metric groups from different source
std::vector<zet_metric_group_handle_t> metricGroups{phMetricGroup, mockMetricGroup2.toHandle()};
std::vector<zet_metric_group_handle_t> metricGroups{hMetricGroup, mockMetricGroup2.toHandle()};
zet_intel_metric_calculation_exp_desc_t calculationDesc{
ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP,
nullptr, // pNext
@@ -109,6 +126,8 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpWithMixedSourcesThenErrorIsReturn
0, // timeWindowsCount
nullptr, // pCalculationTimeWindows
1000, // timeAggregationWindow
1, // metricScopesCount
&hMetricScope, // phMetricScopes
};
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
@@ -122,7 +141,7 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpWithMixedSourcesThenErrorIsReturn
std::vector<zet_metric_handle_t> metrics{mockMetric.toHandle(), mockMetric2.toHandle()};
calculationDesc.metricGroupCount = 1;
calculationDesc.phMetricGroups = &phMetricGroup;
calculationDesc.phMetricGroups = &hMetricGroup;
calculationDesc.metricCount = 2;
calculationDesc.phMetrics = metrics.data();
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculationOperationCreateExp(context,
@@ -142,7 +161,7 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpWithMixedHierarchiesThenErrorIsRe
mockMetricGroup2.isMultiDevice = true;
// metric groups from different hierarchy
std::vector<zet_metric_group_handle_t> metricGroups{phMetricGroup, mockMetricGroup2.toHandle()};
std::vector<zet_metric_group_handle_t> metricGroups{hMetricGroup, mockMetricGroup2.toHandle()};
zet_intel_metric_calculation_exp_desc_t calculationDesc{
ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP,
nullptr, // pNext
@@ -153,6 +172,8 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpWithMixedHierarchiesThenErrorIsRe
0, // timeWindowsCount
nullptr, // pCalculationTimeWindows
1000, // timeAggregationWindow
1, // metricScopesCount
&hMetricScope, // phMetricScopes
};
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
@@ -166,7 +187,7 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpWithMixedHierarchiesThenErrorIsRe
std::vector<zet_metric_handle_t> metrics{mockMetric.toHandle(), mockMetric2.toHandle()};
calculationDesc.metricGroupCount = 1;
calculationDesc.phMetricGroups = &phMetricGroup;
calculationDesc.phMetricGroups = &hMetricGroup;
calculationDesc.metricCount = 2;
calculationDesc.phMetrics = metrics.data();
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculationOperationCreateExp(context,
@@ -178,7 +199,7 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpUseTheSourceFromMetricGroupOrMetr
MockMetricGroup mockMetricGroup2(mockMetricSource);
std::vector<zet_metric_group_handle_t> metricGroups{phMetricGroup, mockMetricGroup2.toHandle()};
std::vector<zet_metric_group_handle_t> metricGroups{hMetricGroup, mockMetricGroup2.toHandle()};
zet_intel_metric_calculation_exp_desc_t calculationDesc{
ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP,
nullptr, // pNext
@@ -189,6 +210,8 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpUseTheSourceFromMetricGroupOrMetr
0, // timeWindowsCount
nullptr, // pCalculationTimeWindows
1000, // timeAggregationWindow
1, // metricScopesCount
&hMetricScope, // phMetricScopes
};
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
@@ -210,10 +233,11 @@ TEST_F(CalcOperationFixture, WhenCreatingCalcOpUseTheSourceFromMetricGroupOrMetr
TEST_F(CalcOperationFixture, WhenCreatingCalcOpObjectToAndFromHandleBaseClassWorkAsExpected) {
std::vector<MetricImp *> mockMetricsInReport{};
uint32_t mockExcludedMetricCount = 0;
std::vector<MetricImp *> mockExcludedMetrics{};
MockMetricCalcOp mockMetricCalcOp(false, mockMetricsInReport, mockExcludedMetricCount, mockExcludedMetrics);
std::vector<MetricScopeImp *> metricScopes{mockMetricScope};
MockMetricCalcOp mockMetricCalcOp(false, metricScopes, mockMetricsInReport, mockExcludedMetrics);
auto hMockCalcOp = mockMetricCalcOp.toHandle();
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetIntelMetricCalculationOperationDestroyExp(hMockCalcOp));
@@ -228,11 +252,12 @@ TEST_F(CalcOperationFixture, WhenGettingMetricsInReportAndExcludedMetricsThenThe
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);
std::vector<MetricScopeImp *> metricScopes{mockMetricScope};
MockMetricCalcOp mockMetricCalcOp(false, metricScopes, mockMetricsInReport, mockExcludedMetrics);
uint32_t metricCount = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationGetReportFormatExp(mockMetricCalcOp.toHandle(), &metricCount, nullptr));
EXPECT_EQ(metricCount, 1U);
@@ -390,7 +415,7 @@ TEST_F(MetricScopesFixture, MetricScopeObjectToAndFromHandleBaseClassWorkAsExpec
scopeProperties.stype = ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP;
scopeProperties.pNext = nullptr;
MockMetricScope mockMetricScope(scopeProperties);
MockMetricScope mockMetricScope(scopeProperties, false);
auto hMockScope = mockMetricScope.toHandle();
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetIntelMetricScopeGetPropertiesExp(hMockScope,
@@ -399,5 +424,98 @@ TEST_F(MetricScopesFixture, MetricScopeObjectToAndFromHandleBaseClassWorkAsExpec
EXPECT_NE(nullptr, mockScope);
}
template <typename GfxFamily>
struct MockL0GfxCoreHelperSupportMetricsAggregation : L0::L0GfxCoreHelperHw<GfxFamily> {
bool supportMetricsAggregation() const override { return true; }
};
HWTEST_F(MetricScopesFixture, GivenMetricsAggregationIsSupportedConfirmAggregatedMetricScopeIsCreated) {
MockL0GfxCoreHelperSupportMetricsAggregation<FamilyType> mockL0GfxCoreHelper;
std::unique_ptr<ApiGfxCoreHelper> l0GfxCoreHelperBackup(static_cast<ApiGfxCoreHelper *>(&mockL0GfxCoreHelper));
device->getNEODevice()->getRootDeviceEnvironmentRef().apiGfxCoreHelper.swap(l0GfxCoreHelperBackup);
auto mockDeviceContext = new MockMetricDeviceContext(*device);
mockDeviceContext->clearAllSources();
auto metricSource = new MockMetricSource();
metricSource->isAvailableReturn = true;
mockDeviceContext->setMockMetricSource(metricSource);
auto deviceImp = static_cast<DeviceImp *>(device);
deviceImp->metricContext.reset(mockDeviceContext);
mockDeviceContext->setMultiDeviceCapable(true);
uint32_t metricScopesCount = 1;
zet_intel_metric_scope_exp_handle_t metricScope;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricScopesGetExp(context->toHandle(),
device->toHandle(),
&metricScopesCount,
&metricScope));
EXPECT_EQ(metricScopesCount, 1u);
zet_intel_metric_scope_properties_exp_t scopeProperties{};
scopeProperties.stype = ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP;
scopeProperties.pNext = nullptr;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricScopeGetPropertiesExp(metricScope,
&scopeProperties));
EXPECT_EQ(scopeProperties.iD, 0u);
EXPECT_STREQ(scopeProperties.name, "DEVICE_AGGREGATED");
EXPECT_STREQ(scopeProperties.description, "Metrics results aggregated at device level");
device->getNEODevice()->getRootDeviceEnvironmentRef().apiGfxCoreHelper.swap(l0GfxCoreHelperBackup);
l0GfxCoreHelperBackup.release();
}
HWTEST_F(MetricScopesFixture, GivenMetricsAggregationIsSupportedWhenCreatingCalcOpAggregatedScopeShouldBeFirst) {
MockL0GfxCoreHelperSupportMetricsAggregation<FamilyType> mockL0GfxCoreHelper;
std::unique_ptr<ApiGfxCoreHelper> l0GfxCoreHelperBackup(static_cast<ApiGfxCoreHelper *>(&mockL0GfxCoreHelper));
device->getNEODevice()->getRootDeviceEnvironmentRef().apiGfxCoreHelper.swap(l0GfxCoreHelperBackup);
auto mockDeviceContext = new MockMetricDeviceContext(*device);
mockDeviceContext->clearAllSources();
auto metricSource = new MockMetricSource();
metricSource->isAvailableReturn = true;
mockDeviceContext->setMockMetricSource(metricSource);
auto deviceImp = static_cast<DeviceImp *>(device);
deviceImp->metricContext.reset(mockDeviceContext);
mockDeviceContext->setMultiDeviceCapable(true);
uint32_t metricScopesCount = 1;
zet_intel_metric_scope_exp_handle_t metricScope;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricScopesGetExp(context->toHandle(),
device->toHandle(),
&metricScopesCount,
&metricScope));
MockMetricGroup mockMetricGroup(*metricSource);
mockMetricGroup.isMultiDevice = true;
zet_metric_group_handle_t hMetricGroup = mockMetricGroup.toHandle();
// Aggregation window is zero
zet_intel_metric_calculation_exp_desc_t calculationDesc{
ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP,
nullptr, // pNext
1, // metricGroupCount
&hMetricGroup, // phMetricGroups
0, // metricCount
nullptr, // phMetrics
0, // timeWindowsCount
nullptr, // pCalculationTimeWindows
100, // timeAggregationWindow
1, // metricScopesCount
&metricScope, // phMetricScopes
};
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zetIntelMetricCalculationOperationCreateExp(context->toHandle(),
device->toHandle(), &calculationDesc,
&hCalculationOperation));
device->getNEODevice()->getRootDeviceEnvironmentRef().apiGfxCoreHelper.swap(l0GfxCoreHelperBackup);
l0GfxCoreHelperBackup.release();
}
} // namespace ult
} // namespace L0

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

@@ -17,6 +17,7 @@
#include "level_zero/tools/source/metrics/os_interface_metric.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_ip_sampling.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_source.h"
#include <level_zero/zet_api.h>
namespace L0 {
@@ -597,17 +598,8 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingMetricGroupThenCrea
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
zet_intel_metric_calculation_exp_desc_t calculationDesc{
ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP,
nullptr, // pNext
1, // metricGroupCount
&metricGroupHandle, // phMetricGroups
0, // metricCount
nullptr, // phMetrics
0, // timeWindowsCount
nullptr, // pCalculationTimeWindows
0, // timeAggregationWindow
};
calculationDesc.metricGroupCount = 1;
calculationDesc.phMetricGroups = &metricGroupHandle;
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(),
@@ -647,17 +639,9 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingMetricGroupCreating
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
zet_intel_metric_calculation_exp_desc_t calculationDesc{
ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP,
nullptr, // pNext
1, // metricGroupCount
&metricGroupHandle, // phMetricGroups
0, // metricCount
nullptr, // phMetrics
0, // timeWindowsCount
nullptr, // pCalculationTimeWindows
100, // timeAggregationWindow, ip samping ingores it.
};
calculationDesc.metricGroupCount = 1;
calculationDesc.phMetricGroups = &metricGroupHandle;
calculationDesc.timeAggregationWindow = 1000;
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
EXPECT_EQ(ZE_INTEL_RESULT_WARNING_TIME_PARAMS_IGNORED_EXP,
@@ -694,17 +678,8 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingCalcOpCanGetReportF
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
zet_intel_metric_calculation_exp_desc_t calculationDesc{
ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP,
nullptr, // pNext
1, // metricGroupCount
&metricGroupHandle, // phMetricGroups
0, // metricCount
nullptr, // phMetrics
0, // timeWindowsCount
nullptr, // pCalculationTimeWindows
0, // timeAggregationWindow
};
calculationDesc.metricGroupCount = 1;
calculationDesc.phMetricGroups = &metricGroupHandle;
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
@@ -765,17 +740,8 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingCalcOpGetReportForm
uint32_t metricsToCalculateCount = static_cast<uint32_t>(metricsToCalculate.size());
EXPECT_EQ(metricsToCalculateCount, 5u);
zet_intel_metric_calculation_exp_desc_t calculationDesc{
ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP,
nullptr, // pNext
0, // metricGroupCount
nullptr, // phMetricGroups
metricsToCalculateCount, // metricCount
metricsToCalculate.data(), // phMetrics
0, // timeWindowsCount
nullptr, // pCalculationTimeWindows
0, // timeAggregationWindow
};
calculationDesc.metricCount = metricsToCalculateCount;
calculationDesc.phMetrics = metricsToCalculate.data();
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(),
@@ -812,17 +778,8 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, givenIpSamplingCalcOpCanGetExclude
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
zet_intel_metric_calculation_exp_desc_t calculationDesc{
ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP,
nullptr, // pNext
1, // metricGroupCount
&metricGroupHandle, // phMetricGroups
0, // metricCount
nullptr, // phMetrics
0, // timeWindowsCount
nullptr, // pCalculationTimeWindows
0, // timeAggregationWindow
};
calculationDesc.metricGroupCount = 1;
calculationDesc.phMetricGroups = &metricGroupHandle;
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
@@ -869,9 +826,12 @@ HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, WhenReadingMetricGroupTimeCalculat
}
}
using MetricIpSamplingCalcOpTest = MetricIpSamplingCalculateSingleDevFixture;
HWTEST2_F(MetricIpSamplingCalcOpMultiDevTest, GivenIpSamplingCalcOpCallingMetricCalculateValuesOnRootDeviceExpectSuccess, EustallSupportedPlatforms) {
HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculateValuesOnSubDeviceThenSuccessIsReturned, 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());
@@ -881,17 +841,34 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
zet_intel_metric_calculation_exp_desc_t calculationDesc{
ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP,
nullptr, // pNext
1, // metricGroupCount
&metricGroupHandle, // phMetricGroups
0, // metricCount
nullptr, // phMetrics
0, // timeWindowsCount
nullptr, // pCalculationTimeWindows
0, // timeAggregationWindow
};
calculationDesc.metricGroupCount = 1;
calculationDesc.phMetricGroups = &metricGroupHandle;
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(),
device->toHandle(), &calculationDesc,
&hCalculationOperation));
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()), hCalculationOperation,
&totalMetricReportCount, nullptr));
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateValuesExp(rawDataVectorSize, &offset,
reinterpret_cast<uint8_t *>(rawDataVector.data()), hCalculationOperation,
&totalMetricReportCount, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalculationOperation));
}
using MetricIpSamplingCalcOpTest = MetricIpSamplingCalculateSingleDevFixture;
HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculateValuesOnSubDeviceThenSuccessIsReturned, EustallSupportedPlatforms) {
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(),
@@ -937,26 +914,6 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat
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_calculation_exp_desc_t calculationDesc{
ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP,
nullptr, // pNext
1, // metricGroupCount
&metricGroupHandle, // phMetricGroups
0, // metricCount
nullptr, // phMetrics
0, // timeWindowsCount
nullptr, // pCalculationTimeWindows
0, // timeAggregationWindow
};
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(),
@@ -983,26 +940,6 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat
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_calculation_exp_desc_t calculationDesc{
ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP,
nullptr, // pNext
1, // metricGroupCount
&metricGroupHandle, // phMetricGroups
0, // metricCount
nullptr, // phMetrics
0, // timeWindowsCount
nullptr, // pCalculationTimeWindows
0, // timeAggregationWindow
};
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(),
device->toHandle(), &calculationDesc,
@@ -1022,14 +959,6 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat
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);
@@ -1049,17 +978,10 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat
uint32_t metricsToCalculateCount = static_cast<uint32_t>(metricsToCalculate.size());
EXPECT_EQ(metricsToCalculateCount, 5u);
zet_intel_metric_calculation_exp_desc_t calculationDesc{
ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP,
nullptr, // pNext
0, // metricGroupCount
nullptr, // phMetricGroups
metricsToCalculateCount, // metricCount
metricsToCalculate.data(), // phMetrics
0, // timeWindowsCount
nullptr, // pCalculationTimeWindows
0, // timeAggregationWindow
};
calculationDesc.metricGroupCount = 0;
calculationDesc.phMetricGroups = nullptr;
calculationDesc.metricCount = metricsToCalculateCount;
calculationDesc.phMetrics = metricsToCalculate.data();
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
@@ -1093,24 +1015,6 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat
HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculateValuesDoesNotAllowLimitingResults, 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);
zet_intel_metric_calculation_exp_desc_t calculationDesc{
ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP,
nullptr, // pNext
metricGroupCount, // metricGroupCount
&metricGroupHandle, // phMetricGroups
0, // metricCount
nullptr, // phMetrics
0, // timeWindowsCount
nullptr, // pCalculationTimeWindows
0, // timeAggregationWindow
};
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(),
device->toHandle(), &calculationDesc,
@@ -1132,54 +1036,5 @@ HWTEST2_F(MetricIpSamplingCalcOpTest, GivenIpSamplingCalcOpCallingMetricCalculat
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalculationOperation));
}
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_calculation_exp_desc_t calculationDesc{
ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP,
nullptr, // pNext
1, // metricGroupCount
&metricGroupHandle, // phMetricGroups
0, // metricCount
nullptr, // phMetrics
0, // timeWindowsCount
nullptr, // pCalculationTimeWindows
0, // timeAggregationWindow
};
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationCreateExp(context->toHandle(),
device->toHandle(), &calculationDesc,
&hCalculationOperation));
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()), hCalculationOperation,
&totalMetricReportCount, nullptr));
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetIntelMetricCalculateValuesExp(rawDataVectorSize, &offset,
reinterpret_cast<uint8_t *>(rawDataVector.data()), hCalculationOperation,
&totalMetricReportCount, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, zetIntelMetricCalculationOperationDestroyExp(hCalculationOperation));
}
} // namespace ult
} // namespace L0

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

@@ -3688,6 +3688,13 @@ TEST_F(MetricEnumerationTest, givenValidOAMetricGroupThenOASourceCalcOperationIs
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
zet_intel_metric_scope_properties_exp_t scopeProperties{};
scopeProperties.stype = ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP;
scopeProperties.pNext = nullptr;
MockMetricScope mockMetricScope(scopeProperties, false);
auto hMockScope = mockMetricScope.toHandle();
// metric groups from different source
zet_intel_metric_calculation_exp_desc_t calculationDesc{
ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP,
@@ -3699,6 +3706,8 @@ TEST_F(MetricEnumerationTest, givenValidOAMetricGroupThenOASourceCalcOperationIs
0, // timeWindowsCount
nullptr, // pCalculationTimeWindows
1000, // timeAggregationWindow
1, // metricScopesCount
&hMockScope, // phMetricScopes
};
zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation;