intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-20 00:24:58 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add implementation for zetMetricGroupCalculateMultipleMetricValuesExp.

Browse Source 
Resolves: LOCI-2409
Signed-off-by: Robert Krzemien <robert.krzemien@intel.com>
This commit is contained in:
Robert Krzemien
2021-08-24 16:41:39 +00:00
committed by Compute-Runtime-Automation
parent 4848c67edd
commit f3ea565121
15 changed files with 1532 additions and 369 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
level_zero/api/extensions/public/CMakeLists.txt
View File

@@ -7,5 +7,6 @@
set(L0_PUBLIC_EXTENSIONS_SRCS_API
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/ze_exp_ext.cpp
${CMAKE_CURRENT_SOURCE_DIR}/zet_exp_ext.cpp
)
set_property(GLOBAL PROPERTY L0_PUBLIC_EXTENSIONS_SRCS_API ${L0_PUBLIC_EXTENSIONS_SRCS_API})

30
level_zero/api/extensions/public/zet_exp_ext.cpp Normal file
View File

@@ -0,0 +1,30 @@
/*
* Copyright (C) 2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/tools/source/metrics/metric.h"
#include <level_zero/zet_api.h>
#if defined(__cplusplus)
extern "C" {
#endif
ZE_APIEXPORT ze_result_t ZE_APICALL
zetMetricGroupCalculateMultipleMetricValuesExp(
zet_metric_group_handle_t hMetricGroup,
zet_metric_group_calculation_type_t type,
size_t rawDataSize,
const uint8_t *pRawData,
uint32_t *pSetCount,
uint32_t *pTotalMetricValueCount,
uint32_t *pMetricCounts,
zet_typed_value_t *pMetricValues) {
return L0::MetricGroup::fromHandle(hMetricGroup)->calculateMetricValuesExp(type, rawDataSize, pRawData, pSetCount, pTotalMetricValueCount, pMetricCounts, pMetricValues);
}
#if defined(__cplusplus)
} // extern "C"
#endif

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

@@ -78,6 +78,10 @@ struct MetricGroup : _zet_metric_group_handle_t {
virtual ze_result_t calculateMetricValues(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
const uint8_t *pRawData, uint32_t *pMetricValueCount,
zet_typed_value_t *pMetricValues) = 0;
virtual ze_result_t calculateMetricValuesExp(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
const uint8_t *pRawData, uint32_t *pSetCount,
uint32_t *pTotalMetricValueCount, uint32_t *pMetricCounts,
zet_typed_value_t *pMetricValues) = 0;
static MetricGroup *create(zet_metric_group_properties_t &properties,
MetricsDiscovery::IMetricSet_1_5 &metricSet,
@@ -101,6 +105,16 @@ struct MetricGroup : _zet_metric_group_handle_t {
virtual ze_result_t closeIoStream() = 0;
};
struct MetricGroupCalculateHeader {
static constexpr uint32_t magicValue = 0xFFFEDCBA;
uint32_t magic;
uint32_t dataCount;
uint32_t rawDataOffsets;
uint32_t rawDataSizes;
uint32_t rawDataOffset;
};
struct MetricStreamer : _zet_metric_streamer_handle_t {
virtual ~MetricStreamer() = default;

93
level_zero/tools/source/metrics/metric_enumeration_imp.cpp
View File

@@ -597,6 +597,99 @@ ze_result_t MetricGroupImp::calculateMetricValues(const zet_metric_group_calcula
return result ? ZE_RESULT_SUCCESS : ZE_RESULT_ERROR_UNKNOWN;
}
ze_result_t MetricGroupImp::calculateMetricValuesExp(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
const uint8_t *pRawData, uint32_t *pSetCount,
uint32_t *pTotalMetricValueCount, uint32_t *pMetricCounts,
zet_typed_value_t *pMetricValues) {
const MetricGroupCalculateHeader *pRawHeader = reinterpret_cast<const MetricGroupCalculateHeader *>(pRawData);
if (pRawHeader->magic != MetricGroupCalculateHeader::magicValue) {
const bool calculationCountOnly = *pTotalMetricValueCount == 0;
ze_result_t result = calculateMetricValues(type, rawDataSize, pRawData, pTotalMetricValueCount, pMetricValues);
if (result == ZE_RESULT_SUCCESS) {
*pSetCount = 1;
if (!calculationCountOnly) {
pMetricCounts[0] = *pTotalMetricValueCount;
}
} else {
if (calculationCountOnly) {
*pSetCount = 0;
*pTotalMetricValueCount = 0;
} else {
pMetricCounts[0] = 0;
}
}
return result;
}
bool result = true;
const size_t metricGroupCount = metricGroups.size();
if (*pSetCount == 0 || *pTotalMetricValueCount == 0) {
const uint32_t *pRawDataSizesUnpacked = reinterpret_cast<const uint32_t *>(pRawData + pRawHeader->rawDataSizes);
if (metricGroupCount == 0) {
result = getCalculatedMetricCount(*pRawDataSizesUnpacked, *pTotalMetricValueCount);
if (result) {
*pSetCount = 1;
} else {
*pSetCount = 0;
*pTotalMetricValueCount = 0;
}
} else {
*pSetCount = static_cast<uint32_t>(metricGroupCount);
*pTotalMetricValueCount = 0;
for (size_t i = 0; i < metricGroupCount; i++) {
uint32_t metricCount = 0;
auto &metricGroup = *static_cast<MetricGroupImp *>(metricGroups[i]);
result = metricGroup.getCalculatedMetricCount(pRawDataSizesUnpacked[i], metricCount);
if (!result) {
*pSetCount = 0;
*pTotalMetricValueCount = 0;
break;
}
*pTotalMetricValueCount += metricCount;
}
}
} else {
const uint32_t *pRawDataSizesUnpacked = reinterpret_cast<const uint32_t *>(pRawData + pRawHeader->rawDataSizes);
const uint32_t *pRawDataOffsetsUnpacked = reinterpret_cast<const uint32_t *>(pRawData + pRawHeader->rawDataOffsets);
const uint8_t *pRawDataOffsetUnpacked = reinterpret_cast<const uint8_t *>(pRawData + pRawHeader->rawDataOffset);
if (metricGroupCount == 0) {
result = getCalculatedMetricValues(type, pRawDataSizesUnpacked[0], pRawDataOffsetUnpacked, *pTotalMetricValueCount, pMetricValues);
pMetricCounts[0] = *pTotalMetricValueCount;
} else {
for (size_t i = 0; i < metricGroupCount; i++) {
auto &metricGroup = *static_cast<MetricGroupImp *>(metricGroups[i]);
const uint32_t dataSize = pRawDataSizesUnpacked[i];
const uint8_t *pRawDataOffset = pRawDataOffsetUnpacked + pRawDataOffsetsUnpacked[i];
pMetricCounts[i] = *pTotalMetricValueCount;
result = metricGroup.getCalculatedMetricValues(type, dataSize, pRawDataOffset, pMetricCounts[i], pMetricValues);
if (!result) {
for (size_t j = 0; j <= i; j++) {
pMetricCounts[j] = 0;
}
break;
}
}
}
}
return result ? ZE_RESULT_SUCCESS : ZE_RESULT_ERROR_UNKNOWN;
}
bool MetricGroupImp::getCalculatedMetricCount(const size_t rawDataSize,
uint32_t &metricValueCount) {
uint32_t rawReportSize = getRawReportSize();

4
level_zero/tools/source/metrics/metric_enumeration_imp.h
View File

@@ -81,6 +81,10 @@ struct MetricGroupImp : MetricGroup {
ze_result_t calculateMetricValues(const zet_metric_group_calculation_type_t type, size_t rawDataSize, const uint8_t *pRawData,
uint32_t *pMetricValueCount,
zet_typed_value_t *pCalculatedData) override;
ze_result_t calculateMetricValuesExp(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
const uint8_t *pRawData, uint32_t *pSetCount,
uint32_t *pTotalMetricValueCount, uint32_t *pMetricCounts,
zet_typed_value_t *pMetricValues) override;
ze_result_t initialize(const zet_metric_group_properties_t &sourceProperties,
MetricsDiscovery::IMetricSet_1_5 &metricSet,

32
level_zero/tools/source/metrics/metric_query_imp.cpp
View File

@@ -664,24 +664,50 @@ ze_result_t MetricQueryImp::getData(size_t *pRawDataSize, uint8_t *pRawData) {
if (calculateSizeOnly) {
const size_t headerSize = sizeof(MetricGroupCalculateHeader);
const size_t rawDataOffsetsRequiredSize = sizeof(uint32_t) * metricQueriesSize;
const size_t rawDataSizesRequiredSize = sizeof(uint32_t) * metricQueriesSize;
auto pMetricQueryImp = static_cast<MetricQueryImp *>(MetricQuery::fromHandle(metricQueries[0]));
result = pMetricQueryImp->metricsLibrary.getMetricQueryReportSize(*pRawDataSize);
*pRawDataSize *= metricQueriesSize;
const size_t rawDataRequiredSize = *pRawDataSize * metricQueriesSize;
*pRawDataSize = headerSize + rawDataOffsetsRequiredSize + rawDataSizesRequiredSize + rawDataRequiredSize;
} else {
size_t sizePerSubDevice = *pRawDataSize / metricQueriesSize;
MetricGroupCalculateHeader *pRawDataHeader = reinterpret_cast<MetricGroupCalculateHeader *>(pRawData);
pRawDataHeader->magic = MetricGroupCalculateHeader::magicValue;
pRawDataHeader->dataCount = static_cast<uint32_t>(metricQueriesSize);
// Relative offsets in the header allow to move/copy the buffer.
pRawDataHeader->rawDataOffsets = sizeof(MetricGroupCalculateHeader);
pRawDataHeader->rawDataSizes = static_cast<uint32_t>(pRawDataHeader->rawDataOffsets + (sizeof(uint32_t) * metricQueriesSize));
pRawDataHeader->rawDataOffset = static_cast<uint32_t>(pRawDataHeader->rawDataSizes + (sizeof(uint32_t) * metricQueriesSize));
size_t sizePerSubDevice = (*pRawDataSize - pRawDataHeader->rawDataOffset) / metricQueriesSize;
DEBUG_BREAK_IF(sizePerSubDevice == 0);
*pRawDataSize = pRawDataHeader->rawDataOffset;
uint32_t *pRawDataOffsetsUnpacked = reinterpret_cast<uint32_t *>(pRawData + pRawDataHeader->rawDataOffsets);
uint32_t *pRawDataSizesUnpacked = reinterpret_cast<uint32_t *>(pRawData + pRawDataHeader->rawDataSizes);
uint8_t *pRawDataUnpacked = reinterpret_cast<uint8_t *>(pRawData + pRawDataHeader->rawDataOffset);
for (size_t i = 0; i < metricQueriesSize; ++i) {
const uint32_t rawDataOffset = (i != 0) ? pRawDataOffsetsUnpacked[i - 1] : 0;
auto pMetricQuery = MetricQuery::fromHandle(metricQueries[i]);
ze_result_t tmpResult = pMetricQuery->getData(&sizePerSubDevice, pRawData + (sizePerSubDevice * i));
ze_result_t tmpResult = pMetricQuery->getData(&sizePerSubDevice, pRawDataUnpacked + rawDataOffset);
if (tmpResult != ZE_RESULT_SUCCESS) {
result = false;
break;
}
pRawDataSizesUnpacked[i] = static_cast<uint32_t>(sizePerSubDevice);
pRawDataOffsetsUnpacked[i] = (i != 0) ? pRawDataOffsetsUnpacked[i - 1] + pRawDataSizesUnpacked[i] : 0;
*pRawDataSize += sizePerSubDevice;
}
}

35
level_zero/tools/source/metrics/metric_streamer_imp.cpp
View File

@@ -18,27 +18,50 @@ namespace L0 {
ze_result_t MetricStreamerImp::readData(uint32_t maxReportCount, size_t *pRawDataSize,
uint8_t *pRawData) {
ze_result_t result = ZE_RESULT_SUCCESS;
const size_t metricStreamerSize = metricStreamers.size();
if (metricStreamers.size() > 0) {
if (metricStreamerSize > 0) {
auto pMetricStreamer = MetricStreamer::fromHandle(metricStreamers[0]);
// Return required size if requested.
if (*pRawDataSize == 0) {
*pRawDataSize = static_cast<MetricStreamerImp *>(pMetricStreamer)->getRequiredBufferSize(maxReportCount) * metricStreamers.size();
const size_t headerSize = sizeof(MetricGroupCalculateHeader);
const size_t rawDataOffsetsRequiredSize = sizeof(uint32_t) * metricStreamerSize;
const size_t rawDataSizesRequiredSize = sizeof(uint32_t) * metricStreamerSize;
const size_t rawDataRequiredSize = static_cast<MetricStreamerImp *>(pMetricStreamer)->getRequiredBufferSize(maxReportCount) * metricStreamerSize;
*pRawDataSize = headerSize + rawDataOffsetsRequiredSize + rawDataSizesRequiredSize + rawDataRequiredSize;
return ZE_RESULT_SUCCESS;
}
size_t sizePerSubDevice = *pRawDataSize / metricStreamers.size();
MetricGroupCalculateHeader *pRawDataHeader = reinterpret_cast<MetricGroupCalculateHeader *>(pRawData);
pRawDataHeader->magic = MetricGroupCalculateHeader::magicValue;
pRawDataHeader->dataCount = static_cast<uint32_t>(metricStreamerSize);
// Relative offsets in the header allow to move/copy the buffer.
pRawDataHeader->rawDataOffsets = sizeof(MetricGroupCalculateHeader);
pRawDataHeader->rawDataSizes = static_cast<uint32_t>(pRawDataHeader->rawDataOffsets + (sizeof(uint32_t) * metricStreamerSize));
pRawDataHeader->rawDataOffset = static_cast<uint32_t>(pRawDataHeader->rawDataSizes + (sizeof(uint32_t) * metricStreamerSize));
const size_t sizePerSubDevice = (*pRawDataSize - pRawDataHeader->rawDataOffset) / metricStreamerSize;
DEBUG_BREAK_IF(sizePerSubDevice == 0);
*pRawDataSize = 0;
for (auto metricStreamerHandle : metricStreamers) {
*pRawDataSize = pRawDataHeader->rawDataOffset;
uint32_t *pRawDataOffsetsUnpacked = reinterpret_cast<uint32_t *>(pRawData + pRawDataHeader->rawDataOffsets);
uint32_t *pRawDataSizesUnpacked = reinterpret_cast<uint32_t *>(pRawData + pRawDataHeader->rawDataSizes);
uint8_t *pRawDataUnpacked = reinterpret_cast<uint8_t *>(pRawData + pRawDataHeader->rawDataOffset);
for (size_t i = 0; i < metricStreamerSize; ++i) {
size_t readSize = sizePerSubDevice;
auto metricStreamerHandle = metricStreamers[i];
const uint32_t rawDataOffset = (i != 0) ? pRawDataOffsetsUnpacked[i - 1] : 0;
pMetricStreamer = MetricStreamer::fromHandle(metricStreamerHandle);
result = pMetricStreamer->readData(maxReportCount, &readSize, pRawData + *pRawDataSize);
result = pMetricStreamer->readData(maxReportCount, &readSize, pRawDataUnpacked + rawDataOffset);
// Return at first error.
if (result != ZE_RESULT_SUCCESS) {
return result;
}
pRawDataSizesUnpacked[i] = static_cast<uint32_t>(readSize);
pRawDataOffsetsUnpacked[i] = (i != 0) ? pRawDataOffsetsUnpacked[i - 1] + pRawDataSizesUnpacked[i] : 0;
*pRawDataSize += readSize;
}
} else {

3
level_zero/tools/test/unit_tests/sources/metrics/CMakeLists.txt
View File

@@ -10,7 +10,8 @@ target_sources(${TARGET_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/mock_metric.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_metric_enumeration.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_metric_enumeration.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_metric_enumeration.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_metric_enumeration_1.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_metric_enumeration_2.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_metric_query_pool_1.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_metric_query_pool_2.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_metric_streamer_1.cpp

111
level_zero/tools/test/unit_tests/sources/metrics/mock_metric.cpp
View File

@@ -122,107 +122,6 @@ void MetricMultiDeviceFixture::SetUp() {
devices[i] = driverHandle->devices[i];
}
auto &metricContext = devices[0]->getMetricContext();
metricContext.setInitializationState(ZE_RESULT_SUCCESS);
mockMetricsLibrary = std::unique_ptr<Mock<MetricsLibrary>>(new (std::nothrow) Mock<MetricsLibrary>(metricContext));
mockMetricsLibrary->setMockedApi(&mockMetricsLibraryApi);
mockMetricsLibrary->handle = new MockOsLibrary();
mockMetricEnumeration = std::unique_ptr<Mock<MetricEnumeration>>(new (std::nothrow) Mock<MetricEnumeration>(metricContext));
mockMetricEnumeration->setMockedApi(&mockMetricsDiscoveryApi);
mockMetricEnumeration->hMetricsDiscovery = std::make_unique<MockOsLibrary>();
// Metrics Discovery device common settings.
metricsDeviceParams.Version.MajorNumber = MetricEnumeration::requiredMetricsDiscoveryMajorVersion;
metricsDeviceParams.Version.MinorNumber = MetricEnumeration::requiredMetricsDiscoveryMinorVersion;
}
void MetricMultiDeviceFixture::TearDown() {
// Restore original metrics library
delete mockMetricsLibrary->handle;
mockMetricsLibrary->setMockedApi(nullptr);
mockMetricsLibrary.reset();
// Restore original metric enumeration.
mockMetricEnumeration->setMockedApi(nullptr);
mockMetricEnumeration.reset();
MultiDeviceFixture::TearDown();
NEO::ImplicitScaling::apiSupport = false;
}
void MetricMultiDeviceFixture::openMetricsAdapter() {
auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
.Times(0);
EXPECT_CALL(*mockMetricEnumeration->g_mockApi, MockOpenAdapterGroup(_))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<0>(&adapterGroup), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(adapter, OpenMetricsSubDevice(_, _))
.Times(subDeviceCount)
.WillRepeatedly(DoAll(::testing::SetArgPointee<1>(&metricsDevice), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(adapter, CloseMetricsDevice(_))
.Times(subDeviceCount)
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(adapterGroup, GetAdapter(_))
.Times(0);
EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
.Times(1)
.WillOnce(Return(&adapter));
EXPECT_CALL(adapterGroup, Close())
.Times(1)
.WillOnce(Return(TCompletionCode::CC_OK));
}
void MetricMultiDeviceFixture::openMetricsAdapterGroup() {
auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
.Times(0);
EXPECT_CALL(*mockMetricEnumeration->g_mockApi, MockOpenAdapterGroup(_))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<0>(&adapterGroup), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(adapter, OpenMetricsSubDevice(_, _))
.Times(subDeviceCount)
.WillRepeatedly(DoAll(::testing::SetArgPointee<1>(&metricsDevice), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(adapter, CloseMetricsDevice(_))
.Times(subDeviceCount)
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(adapterGroup, Close())
.Times(1)
.WillOnce(Return(TCompletionCode::CC_OK));
}
void MetricMultiDeviceContextFixture::SetUp() {
NEO::ImplicitScaling::apiSupport = true;
MultiDeviceFixture::SetUp();
devices.resize(driverHandle->devices.size());
for (uint32_t i = 0; i < driverHandle->devices.size(); i++) {
devices[i] = driverHandle->devices[i];
}
// Initialize metric api.
auto &metricContext = devices[0]->getMetricContext();
@@ -256,7 +155,7 @@ void MetricMultiDeviceContextFixture::SetUp() {
metricsDeviceParams.Version.MinorNumber = MetricEnumeration::requiredMetricsDiscoveryMinorVersion;
}
void MetricMultiDeviceContextFixture::TearDown() {
void MetricMultiDeviceFixture::TearDown() {
auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
@@ -288,7 +187,7 @@ void MetricMultiDeviceContextFixture::TearDown() {
NEO::ImplicitScaling::apiSupport = false;
}
void MetricMultiDeviceContextFixture::openMetricsAdapter() {
void MetricMultiDeviceFixture::openMetricsAdapter() {
EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
.Times(0);
@@ -317,7 +216,7 @@ void MetricMultiDeviceContextFixture::openMetricsAdapter() {
.WillOnce(Return(TCompletionCode::CC_OK));
}
void MetricMultiDeviceContextFixture::openMetricsAdapterSubDevice(uint32_t subDeviceIndex) {
void MetricMultiDeviceFixture::openMetricsAdapterSubDevice(uint32_t subDeviceIndex) {
EXPECT_CALL(*mockMetricEnumerationSubDevices[subDeviceIndex], loadMetricsDiscovery())
.Times(0);
@@ -346,7 +245,7 @@ void MetricMultiDeviceContextFixture::openMetricsAdapterSubDevice(uint32_t subDe
.WillOnce(Return(TCompletionCode::CC_OK));
}
void MetricMultiDeviceContextFixture::openMetricsAdapterGroup() {
void MetricMultiDeviceFixture::openMetricsAdapterGroup() {
EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
.Times(0);
@@ -368,7 +267,7 @@ void MetricMultiDeviceContextFixture::openMetricsAdapterGroup() {
.WillOnce(Return(TCompletionCode::CC_OK));
}
void MetricStreamerMultiDeviceContextFixture::cleanup(zet_device_handle_t &hDevice, zet_metric_streamer_handle_t &hStreamer) {
void MetricStreamerMultiDeviceFixture::cleanup(zet_device_handle_t &hDevice, zet_metric_streamer_handle_t &hStreamer) {
MetricStreamerImp *pStreamerImp = static_cast<MetricStreamerImp *>(MetricStreamer::fromHandle(hStreamer));
auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);

28
level_zero/tools/test/unit_tests/sources/metrics/mock_metric.h
View File

@@ -170,32 +170,6 @@ class MetricContextFixture : public ContextFixture {
class MetricMultiDeviceFixture : public MultiDeviceFixture {
protected:
void SetUp() override;
void TearDown() override;
void openMetricsAdapter();
void openMetricsAdapterGroup();
public:
std::vector<L0::Device *> devices;
// Mocked objects.
std::unique_ptr<Mock<MetricEnumeration>> mockMetricEnumeration = nullptr;
std::unique_ptr<Mock<MetricsLibrary>> mockMetricsLibrary = nullptr;
// Mocked metrics library/discovery APIs.
MockMetricsLibraryApi mockMetricsLibraryApi = {};
MockMetricsDiscoveryApi mockMetricsDiscoveryApi = {};
// Metrics discovery device
Mock<IAdapterGroup_1_9> adapterGroup;
Mock<IAdapter_1_9> adapter;
Mock<IMetricsDevice_1_5> metricsDevice;
MetricsDiscovery::TMetricsDeviceParams_1_2 metricsDeviceParams = {};
};
class MetricMultiDeviceContextFixture : public MultiDeviceFixture {
protected:
void SetUp() override;
void TearDown() override;
@@ -224,7 +198,7 @@ class MetricMultiDeviceContextFixture : public MultiDeviceFixture {
MetricsDiscovery::TMetricsDeviceParams_1_2 metricsDeviceParams = {};
};
class MetricStreamerMultiDeviceContextFixture : public MetricMultiDeviceContextFixture {
class MetricStreamerMultiDeviceFixture : public MetricMultiDeviceFixture {
public:
void cleanup(zet_device_handle_t &hDevice, zet_metric_streamer_handle_t &hStreamer);
};

1
level_zero/tools/test/unit_tests/sources/metrics/mock_metric_enumeration.h
View File

@@ -199,6 +199,7 @@ struct Mock<MetricGroup> : public MetricGroup {
MOCK_METHOD(ze_result_t, getMetric, (uint32_t *, zet_metric_handle_t *), (override));
MOCK_METHOD(ze_result_t, calculateMetricValues, (const zet_metric_group_calculation_type_t, size_t, const uint8_t *, uint32_t *, zet_typed_value_t *), (override));
MOCK_METHOD(ze_result_t, calculateMetricValuesExp, (const zet_metric_group_calculation_type_t, size_t, const uint8_t *, uint32_t *, uint32_t *, uint32_t *, zet_typed_value_t *), (override));
MOCK_METHOD(ze_result_t, getProperties, (zet_metric_group_properties_t * properties), (override));
MOCK_METHOD(uint32_t, getRawReportSize, (), (override));
MOCK_METHOD(bool, activate, (), (override));

619
level_zero/tools/test/unit_tests/sources/metrics/test_metric_enumeration.cpp → level_zero/tools/test/unit_tests/sources/metrics/test_metric_enumeration_1.cpp
View File

@@ -882,7 +882,7 @@ TEST_F(MetricEnumerationTest, givenValidEventBasedMetricGroupWhenzetContextActiv
EXPECT_EQ(zetContextActivateMetricGroups(context->toHandle(), device->toHandle(), 1, &metricGroupHandle), ZE_RESULT_SUCCESS);
}
using MultiDeviceMetricEnumerationTest = Test<MetricMultiDeviceContextFixture>;
using MultiDeviceMetricEnumerationTest = Test<MetricMultiDeviceFixture>;
TEST_F(MultiDeviceMetricEnumerationTest, givenMultipleDevicesAndValidEventBasedMetricGroupWhenzetContextActivateMetricGroupsIsCalledThenReturnsSuccess) {
@@ -1644,6 +1644,403 @@ TEST_F(MetricEnumerationTest, givenIncorrectRawReportSizeWhenZetMetricGroupCalcu
EXPECT_EQ(zetMetricGroupCalculateMetricValues(metricGroupHandle, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawResultsSize, rawResults, &calculatedResults, nullptr), ZE_RESULT_ERROR_UNKNOWN);
}
TEST_F(MetricEnumerationTest, givenIncorrectRawReportSizeWhenZetMetricGroupCalculateMetricValuesExpIsCalledThenReturnsFail) {
// Metrics Discovery device.
metricsDeviceParams.ConcurrentGroupsCount = 1;
// Metrics Discovery concurrent group.
Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
metricsConcurrentGroupParams.MetricSetsCount = 1;
metricsConcurrentGroupParams.SymbolName = "OA";
// Metrics Discovery: metric set
Mock<IMetricSet_1_5> metricsSet;
MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
metricsSetParams.QueryReportSize = 0;
// One api: metric group.
zet_metric_group_handle_t metricGroupHandle = {};
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
.Times(1)
.WillOnce(Return(&metricsConcurrentGroup));
EXPECT_CALL(metricsConcurrentGroup, GetParams())
.Times(1)
.WillOnce(Return(&metricsConcurrentGroupParams));
EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
.Times(1)
.WillOnce(Return(&metricsSet));
EXPECT_CALL(metricsSet, GetParams())
.WillRepeatedly(Return(&metricsSetParams));
EXPECT_CALL(metricsSet, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
// Metric group handles.
uint32_t metricGroupCount = 1;
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
// Raw results.
const size_t rawResultsSize = 300;
uint8_t rawResults[rawResultsSize] = {};
// Invalid raw buffer size provided by the user.
uint32_t dataCount = 0;
uint32_t totalMetricCount = 0;
EXPECT_NE(metricsSetParams.QueryReportSize, rawResultsSize);
EXPECT_EQ(zetMetricGroupCalculateMultipleMetricValuesExp(metricGroupHandle, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawResultsSize, rawResults, &dataCount, &totalMetricCount, nullptr, nullptr), ZE_RESULT_ERROR_UNKNOWN);
EXPECT_EQ(dataCount, 0u);
EXPECT_EQ(totalMetricCount, 0u);
// Invalid raw buffer size provided by the driver.
EXPECT_NE(metricsSetParams.QueryReportSize, rawResultsSize);
EXPECT_EQ(zetMetricGroupCalculateMultipleMetricValuesExp(metricGroupHandle, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawResultsSize, rawResults, &dataCount, &totalMetricCount, nullptr, nullptr), ZE_RESULT_ERROR_UNKNOWN);
EXPECT_EQ(dataCount, 0u);
EXPECT_EQ(totalMetricCount, 0u);
}
TEST_F(MetricEnumerationTest, givenCorrectRawReportSizeWhenZetMetricGroupCalculateMetricValuesExpIsCalledThenReturnsSuccess) {
metricsDeviceParams.ConcurrentGroupsCount = 1;
Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
metricsConcurrentGroupParams.MetricSetsCount = 1;
metricsConcurrentGroupParams.SymbolName = "OA";
Mock<IMetricSet_1_5> metricsSet;
MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
metricsSetParams.QueryReportSize = 256;
metricsSetParams.MetricsCount = 11;
Mock<IMetric_1_0> metric;
MetricsDiscovery::TMetricParams_1_0 metricParams = {};
zet_metric_group_handle_t metricGroupHandle = {};
uint32_t returnedMetricCount = 1;
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
.Times(1)
.WillOnce(Return(&metricsConcurrentGroup));
EXPECT_CALL(metricsConcurrentGroup, GetParams())
.Times(1)
.WillOnce(Return(&metricsConcurrentGroupParams));
EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
.Times(1)
.WillOnce(Return(&metricsSet));
EXPECT_CALL(metricsSet, GetParams())
.WillRepeatedly(Return(&metricsSetParams));
EXPECT_CALL(metricsSet, GetMetric(_))
.Times(metricsSetParams.MetricsCount)
.WillRepeatedly(Return(&metric));
EXPECT_CALL(metricsSet, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metric, GetParams())
.WillRepeatedly(Return(&metricParams));
EXPECT_CALL(metricsSet, CalculateMetrics(_, _, _, _, _, _, _))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<4>(returnedMetricCount), Return(TCompletionCode::CC_OK)));
uint32_t metricGroupCount = 1;
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
// Raw results.
const size_t rawResultsSize = 256;
uint8_t rawResults[rawResultsSize] = {};
// Valid raw buffer size provided by the user.
uint32_t dataCount = 0;
uint32_t totalMetricCount = 0;
EXPECT_EQ(metricsSetParams.QueryReportSize, rawResultsSize);
EXPECT_EQ(zetMetricGroupCalculateMultipleMetricValuesExp(metricGroupHandle, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawResultsSize, rawResults, &dataCount, &totalMetricCount, nullptr, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(dataCount, 1u);
EXPECT_EQ(totalMetricCount, metricsSetParams.MetricsCount);
// Copy calculated metrics.
std::vector<uint32_t> metricCounts(dataCount);
std::vector<zet_typed_value_t> caculatedRawResults(totalMetricCount);
EXPECT_EQ(zetMetricGroupCalculateMultipleMetricValuesExp(metricGroupHandle, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawResultsSize, rawResults, &dataCount, &totalMetricCount, metricCounts.data(), caculatedRawResults.data()), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricCounts[0], totalMetricCount);
}
TEST_F(MetricEnumerationTest, givenFailedCalculateMetricsWhenZetMetricGroupCalculateMetricValuesExpIsCalledThenReturnsFail) {
metricsDeviceParams.ConcurrentGroupsCount = 1;
Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
metricsConcurrentGroupParams.MetricSetsCount = 1;
metricsConcurrentGroupParams.SymbolName = "OA";
Mock<IMetricSet_1_5> metricsSet;
MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
metricsSetParams.QueryReportSize = 256;
metricsSetParams.MetricsCount = 11;
Mock<IMetric_1_0> metric;
MetricsDiscovery::TMetricParams_1_0 metricParams = {};
zet_metric_group_handle_t metricGroupHandle = {};
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
.Times(1)
.WillOnce(Return(&metricsConcurrentGroup));
EXPECT_CALL(metricsConcurrentGroup, GetParams())
.Times(1)
.WillOnce(Return(&metricsConcurrentGroupParams));
EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
.Times(1)
.WillOnce(Return(&metricsSet));
EXPECT_CALL(metricsSet, GetParams())
.WillRepeatedly(Return(&metricsSetParams));
EXPECT_CALL(metricsSet, GetMetric(_))
.Times(metricsSetParams.MetricsCount)
.WillRepeatedly(Return(&metric));
EXPECT_CALL(metricsSet, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metric, GetParams())
.WillRepeatedly(Return(&metricParams));
EXPECT_CALL(metricsSet, CalculateMetrics(_, _, _, _, _, _, _))
.Times(1)
.WillOnce(Return(TCompletionCode::CC_ERROR_GENERAL));
uint32_t metricGroupCount = 1;
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
// Raw results.
const size_t rawResultsSize = 256;
uint8_t rawResults[rawResultsSize] = {};
// Valid raw buffer size provided by the user.
uint32_t dataCount = 0;
uint32_t totalMetricCount = 0;
EXPECT_EQ(metricsSetParams.QueryReportSize, rawResultsSize);
EXPECT_EQ(zetMetricGroupCalculateMultipleMetricValuesExp(metricGroupHandle, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawResultsSize, rawResults, &dataCount, &totalMetricCount, nullptr, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(dataCount, 1u);
EXPECT_EQ(totalMetricCount, metricsSetParams.MetricsCount);
// Copy calculated metrics.
std::vector<uint32_t> metricCounts(dataCount);
std::vector<zet_typed_value_t> caculatedRawResults(totalMetricCount);
EXPECT_EQ(zetMetricGroupCalculateMultipleMetricValuesExp(metricGroupHandle, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawResultsSize, rawResults, &dataCount, &totalMetricCount, metricCounts.data(), caculatedRawResults.data()), ZE_RESULT_ERROR_UNKNOWN);
EXPECT_EQ(metricCounts[0], 0u);
}
TEST_F(MetricEnumerationTest, givenInvalidQueryReportSizeWhenZetMetricGroupCalculateMultipleMetricValuesExpIsCalledTwiceThenReturnsFail) {
metricsDeviceParams.ConcurrentGroupsCount = 1;
Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
metricsConcurrentGroupParams.MetricSetsCount = 1;
metricsConcurrentGroupParams.SymbolName = "OA";
Mock<IMetricSet_1_5> metricsSet;
MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
metricsSetParams.QueryReportSize = 0;
metricsSetParams.MetricsCount = 11;
Mock<IMetric_1_0> metric;
MetricsDiscovery::TMetricParams_1_0 metricParams = {};
zet_metric_group_handle_t metricGroupHandle = {};
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
.Times(1)
.WillOnce(Return(&metricsConcurrentGroup));
EXPECT_CALL(metricsConcurrentGroup, GetParams())
.Times(1)
.WillOnce(Return(&metricsConcurrentGroupParams));
EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
.Times(1)
.WillOnce(Return(&metricsSet));
EXPECT_CALL(metricsSet, GetParams())
.WillRepeatedly(Return(&metricsSetParams));
EXPECT_CALL(metricsSet, GetMetric(_))
.Times(metricsSetParams.MetricsCount)
.WillRepeatedly(Return(&metric));
EXPECT_CALL(metricsSet, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metric, GetParams())
.WillRepeatedly(Return(&metricParams));
// Metric group handles.
uint32_t metricGroupCount = 1;
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
// Raw results.
const size_t rawResultsSize = 284;
uint8_t rawResults[rawResultsSize] = {};
MetricGroupCalculateHeader *pRawHeader = reinterpret_cast<MetricGroupCalculateHeader *>(rawResults);
pRawHeader->magic = MetricGroupCalculateHeader::magicValue;
pRawHeader->dataCount = 1;
pRawHeader->rawDataOffsets = sizeof(MetricGroupCalculateHeader);
pRawHeader->rawDataSizes = pRawHeader->rawDataOffsets + sizeof(uint32_t) * pRawHeader->dataCount;
pRawHeader->rawDataOffset = pRawHeader->rawDataSizes + sizeof(uint32_t) * pRawHeader->dataCount;
uint32_t *pRawDataOffsets = reinterpret_cast<uint32_t *>(rawResults + pRawHeader->rawDataOffsets);
uint32_t *pRawDataSizes = reinterpret_cast<uint32_t *>(rawResults + pRawHeader->rawDataSizes);
pRawDataOffsets[0] = 0;
pRawDataSizes[0] = static_cast<uint32_t>(rawResultsSize - pRawHeader->rawDataOffset);
// Invalid raw buffer size provided by the driver.
uint32_t dataCount = 0;
uint32_t totalMetricCount = 0;
EXPECT_EQ(zetMetricGroupCalculateMultipleMetricValuesExp(metricGroupHandle, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawResultsSize, rawResults, &dataCount, &totalMetricCount, nullptr, nullptr), ZE_RESULT_ERROR_UNKNOWN);
EXPECT_EQ(dataCount, 0u);
EXPECT_EQ(totalMetricCount, 0u);
}
TEST_F(MetricEnumerationTest, givenCorrectRawDataHeaderWhenZetMetricGroupCalculateMultipleMetricValuesExpIsCalledTwiceThenReturnsSuccess) {
metricsDeviceParams.ConcurrentGroupsCount = 1;
Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
metricsConcurrentGroupParams.MetricSetsCount = 1;
metricsConcurrentGroupParams.SymbolName = "OA";
Mock<IMetricSet_1_5> metricsSet;
MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
metricsSetParams.QueryReportSize = 256;
metricsSetParams.MetricsCount = 11;
Mock<IMetric_1_0> metric;
MetricsDiscovery::TMetricParams_1_0 metricParams = {};
zet_metric_group_handle_t metricGroupHandle = {};
uint32_t returnedMetricCount = 1;
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
.Times(1)
.WillOnce(Return(&metricsConcurrentGroup));
EXPECT_CALL(metricsConcurrentGroup, GetParams())
.Times(1)
.WillOnce(Return(&metricsConcurrentGroupParams));
EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
.Times(1)
.WillOnce(Return(&metricsSet));
EXPECT_CALL(metricsSet, GetParams())
.WillRepeatedly(Return(&metricsSetParams));
EXPECT_CALL(metricsSet, GetMetric(_))
.Times(metricsSetParams.MetricsCount)
.WillRepeatedly(Return(&metric));
EXPECT_CALL(metricsSet, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metric, GetParams())
.WillRepeatedly(Return(&metricParams));
EXPECT_CALL(metricsSet, CalculateMetrics(_, _, _, _, _, _, _))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<4>(returnedMetricCount), Return(TCompletionCode::CC_OK)));
// Metric group handles.
uint32_t metricGroupCount = 1;
EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
// Raw results.
const size_t rawResultsSize = 284;
uint8_t rawResults[rawResultsSize] = {};
MetricGroupCalculateHeader *pRawHeader = reinterpret_cast<MetricGroupCalculateHeader *>(rawResults);
pRawHeader->magic = MetricGroupCalculateHeader::magicValue;
pRawHeader->dataCount = 1;
pRawHeader->rawDataOffsets = sizeof(MetricGroupCalculateHeader);
pRawHeader->rawDataSizes = pRawHeader->rawDataOffsets + sizeof(uint32_t) * pRawHeader->dataCount;
pRawHeader->rawDataOffset = pRawHeader->rawDataSizes + sizeof(uint32_t) * pRawHeader->dataCount;
uint32_t *pRawDataOffsets = reinterpret_cast<uint32_t *>(rawResults + pRawHeader->rawDataOffsets);
uint32_t *pRawDataSizes = reinterpret_cast<uint32_t *>(rawResults + pRawHeader->rawDataSizes);
pRawDataOffsets[0] = 0;
pRawDataSizes[0] = static_cast<uint32_t>(rawResultsSize - pRawHeader->rawDataOffset);
// Valid raw buffer.
uint32_t dataCount = 0;
uint32_t totalMetricCount = 0;
EXPECT_NE(metricsSetParams.QueryReportSize, rawResultsSize);
EXPECT_EQ(zetMetricGroupCalculateMultipleMetricValuesExp(metricGroupHandle, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawResultsSize, rawResults, &dataCount, &totalMetricCount, nullptr, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(dataCount, 1u);
EXPECT_EQ(totalMetricCount, metricsSetParams.MetricsCount);
// Copy calculated metrics.
std::vector<uint32_t> metricCounts(dataCount);
std::vector<zet_typed_value_t> caculatedRawResults(totalMetricCount);
EXPECT_EQ(zetMetricGroupCalculateMultipleMetricValuesExp(metricGroupHandle, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawResultsSize, rawResults, &dataCount, &totalMetricCount, metricCounts.data(), caculatedRawResults.data()), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricCounts[0], totalMetricCount);
}
TEST_F(MetricEnumerationTest, givenCorrectRawReportSizeWhenZetMetricGroupCalculateMetricValuesIsCalledThenReturnsCorrectCalculatedReportCount) {
// Metrics Discovery device.
@@ -2273,226 +2670,6 @@ TEST_F(MetricEnumerationTest, givenMetricContextWhenEnablingOrDisablingCollectio
EXPECT_EQ(metricGroupCount, 0u);
}
using MetricEnumerationMultiDeviceTest = Test<MetricMultiDeviceFixture>;
TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesIsCalledThenOpenMetricsSubDeviceWillBeCalled) {
// Use first root device.
auto &metricContext = devices[0]->getMetricContext();
auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
Mock<IAdapterGroup_1_9> mockAdapterGroup;
Mock<IAdapter_1_9> mockAdapter;
Mock<IMetricsDevice_1_5> mockDevice;
EXPECT_CALL(*mockMetricsLibrary, load())
.Times(1)
.WillOnce(Return(true));
EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
.Times(1)
.WillOnce(Return(ZE_RESULT_SUCCESS));
EXPECT_CALL(*Mock<MetricEnumeration>::g_mockApi, MockOpenAdapterGroup(_))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<0>(&mockAdapterGroup), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
.Times(1)
.WillOnce(Return(&mockAdapter));
EXPECT_CALL(mockAdapter, OpenMetricsSubDevice(_, _))
.Times(subDeviceCount)
.WillRepeatedly(DoAll(::testing::SetArgPointee<1>(&mockDevice), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(mockAdapter, CloseMetricsDevice(_))
.Times(subDeviceCount)
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(mockDevice, GetParams())
.Times(subDeviceCount)
.WillRepeatedly(Return(&metricsDeviceParams));
EXPECT_CALL(mockAdapterGroup, Close())
.Times(1)
.WillOnce(Return(TCompletionCode::CC_OK));
// Use root device.
metricContext.setSubDeviceIndex(0);
mockMetricsLibrary->initializationState = ZE_RESULT_SUCCESS;
EXPECT_EQ(metricContext.loadDependencies(), true);
EXPECT_EQ(metricContext.isInitialized(), true);
EXPECT_EQ(mockMetricEnumeration->baseIsInitialized(), true);
EXPECT_EQ(mockMetricEnumeration->cleanupMetricsDiscovery(), ZE_RESULT_SUCCESS);
}
TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesIsCalledThenOpenMetricsSubDeviceWillBeCalledWithoutSuccess) {
// Use first root device.
auto &metricContext = devices[0]->getMetricContext();
Mock<IAdapterGroup_1_9> mockAdapterGroup;
Mock<IAdapter_1_9> mockAdapter;
Mock<IMetricsDevice_1_5> mockDevice;
EXPECT_CALL(*mockMetricsLibrary, load())
.Times(1)
.WillOnce(Return(true));
EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
.Times(1)
.WillOnce(Return(ZE_RESULT_SUCCESS));
EXPECT_CALL(*Mock<MetricEnumeration>::g_mockApi, MockOpenAdapterGroup(_))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<0>(&mockAdapterGroup), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
.Times(1)
.WillOnce(Return(&mockAdapter));
EXPECT_CALL(mockAdapter, OpenMetricsSubDevice(_, _))
.Times(1)
.WillOnce(Return(TCompletionCode::CC_ERROR_GENERAL));
EXPECT_CALL(mockAdapter, CloseMetricsDevice(_))
.Times(0);
EXPECT_CALL(mockDevice, GetParams())
.Times(0);
EXPECT_CALL(mockAdapterGroup, Close())
.Times(1)
.WillOnce(Return(TCompletionCode::CC_OK));
// Use root device.
metricContext.setSubDeviceIndex(0);
mockMetricsLibrary->initializationState = ZE_RESULT_SUCCESS;
EXPECT_EQ(metricContext.loadDependencies(), true);
EXPECT_EQ(metricContext.isInitialized(), true);
EXPECT_EQ(mockMetricEnumeration->baseIsInitialized(), false);
}
TEST_F(MetricEnumerationMultiDeviceTest, givenIncorrectMetricsDiscoveryInterfaceVersionWhenZetGetMetricGroupIsCalledThenReturnsFail) {
metricsDeviceParams.Version.MajorNumber = 0;
metricsDeviceParams.Version.MinorNumber = 1;
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.Times(1)
.WillOnce(Return(&metricsDeviceParams));
uint32_t metricGroupCount = 0;
EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_ERROR_UNKNOWN);
EXPECT_EQ(metricGroupCount, 0u);
}
TEST_F(MetricEnumerationMultiDeviceTest, givenValidArgumentsWhenZetMetricGetPropertiestIsCalledThenReturnSuccess) {
// Use first root device.
auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
// Metrics Discovery device.
metricsDeviceParams.ConcurrentGroupsCount = 1;
// Metrics Discovery concurrent group.
Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
metricsConcurrentGroupParams.MetricSetsCount = 1;
metricsConcurrentGroupParams.SymbolName = "OA";
metricsConcurrentGroupParams.Description = "OA description";
// Metrics Discovery:: metric set.
Mock<MetricsDiscovery::IMetricSet_1_5> metricsSet;
MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
metricsSetParams.MetricsCount = 0;
metricsSetParams.SymbolName = "Metric set name";
metricsSetParams.ShortName = "Metric set description";
metricsSetParams.MetricsCount = 1;
// Metrics Discovery:: metric.
Mock<IMetric_1_0> metric;
TMetricParams_1_0 metricParams = {};
metricParams.SymbolName = "Metric symbol name";
metricParams.ShortName = "Metric short name";
metricParams.LongName = "Metric long name";
metricParams.ResultType = MetricsDiscovery::TMetricResultType::RESULT_UINT64;
metricParams.MetricType = MetricsDiscovery::TMetricType::METRIC_TYPE_RATIO;
zet_metric_properties_t metricProperties = {};
// One api: metric group handle.
zet_metric_group_handle_t metricGroupHandle = {};
zet_metric_group_properties_t metricGroupProperties = {};
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
.Times(subDeviceCount)
.WillRepeatedly(Return(&metricsConcurrentGroup));
EXPECT_CALL(metricsConcurrentGroup, GetParams())
.Times(subDeviceCount)
.WillRepeatedly(Return(&metricsConcurrentGroupParams));
EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
.WillRepeatedly(Return(&metricsSet));
EXPECT_CALL(metricsSet, GetParams())
.WillRepeatedly(Return(&metricsSetParams));
EXPECT_CALL(metricsSet, GetMetric(_))
.Times(subDeviceCount)
.WillRepeatedly(Return(&metric));
EXPECT_CALL(metric, GetParams())
.Times(subDeviceCount)
.WillRepeatedly(Return(&metricParams));
EXPECT_CALL(metricsSet, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
// Metric group count.
uint32_t metricGroupCount = 0;
EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
// Metric group handle.
EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
// Metric group properties.
EXPECT_EQ(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupProperties.domain, 0u);
EXPECT_EQ(metricGroupProperties.samplingType, ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED);
EXPECT_EQ(metricGroupProperties.metricCount, metricsSetParams.MetricsCount);
EXPECT_EQ(strcmp(metricGroupProperties.description, metricsSetParams.ShortName), 0);
EXPECT_EQ(strcmp(metricGroupProperties.name, metricsSetParams.SymbolName), 0);
// Obtain metric.
uint32_t metricCount = 0;
zet_metric_handle_t metricHandle = {};
EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricCount, 1u);
EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, &metricHandle), ZE_RESULT_SUCCESS);
EXPECT_NE(metricHandle, nullptr);
// Obtain metric params.
EXPECT_EQ(zetMetricGetProperties(metricHandle, &metricProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricProperties.name, metricParams.SymbolName), 0);
EXPECT_EQ(strcmp(metricProperties.description, metricParams.LongName), 0);
EXPECT_EQ(metricProperties.metricType, ZET_METRIC_TYPE_RATIO);
EXPECT_EQ(metricProperties.resultType, ZET_VALUE_TYPE_UINT64);
}
class MetricEnumerationTestMetricTypes : public MetricEnumerationTest,
public ::testing::WithParamInterface<MetricsDiscovery::TMetricType> {
public:

620
level_zero/tools/test/unit_tests/sources/metrics/test_metric_enumeration_2.cpp Normal file
View File

@@ -0,0 +1,620 @@
/*
* Copyright (C) 2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "test.h"
#include "level_zero/core/source/device/device_imp.h"
#include "level_zero/core/test/unit_tests/mocks/mock_driver.h"
#include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
using ::testing::_;
using ::testing::Return;
namespace L0 {
namespace ult {
using MetricEnumerationMultiDeviceTest = Test<MetricMultiDeviceFixture>;
TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesIsCalledThenOpenMetricsSubDeviceWillBeCalled) {
// Use first root device.
auto &metricContext = devices[0]->getMetricContext();
auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
Mock<IAdapterGroup_1_9> mockAdapterGroup;
Mock<IAdapter_1_9> mockAdapter;
Mock<IMetricsDevice_1_5> mockDevice;
EXPECT_CALL(*mockMetricsLibrary, load())
.Times(1)
.WillOnce(Return(true));
EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
.Times(1)
.WillOnce(Return(ZE_RESULT_SUCCESS));
EXPECT_CALL(*Mock<MetricEnumeration>::g_mockApi, MockOpenAdapterGroup(_))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<0>(&mockAdapterGroup), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
.Times(1)
.WillOnce(Return(&mockAdapter));
EXPECT_CALL(mockAdapter, OpenMetricsSubDevice(_, _))
.Times(subDeviceCount)
.WillRepeatedly(DoAll(::testing::SetArgPointee<1>(&mockDevice), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(mockAdapter, CloseMetricsDevice(_))
.Times(subDeviceCount)
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(mockDevice, GetParams())
.Times(subDeviceCount)
.WillRepeatedly(Return(&metricsDeviceParams));
EXPECT_CALL(mockAdapterGroup, Close())
.Times(1)
.WillOnce(Return(TCompletionCode::CC_OK));
// Use root device.
metricContext.setSubDeviceIndex(0);
mockMetricsLibrary->initializationState = ZE_RESULT_SUCCESS;
EXPECT_EQ(metricContext.loadDependencies(), true);
EXPECT_EQ(metricContext.isInitialized(), true);
EXPECT_EQ(mockMetricEnumeration->baseIsInitialized(), true);
EXPECT_EQ(mockMetricEnumeration->cleanupMetricsDiscovery(), ZE_RESULT_SUCCESS);
}
TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesIsCalledThenOpenMetricsSubDeviceWillBeCalledWithoutSuccess) {
// Use first root device.
auto &metricContext = devices[0]->getMetricContext();
Mock<IAdapterGroup_1_9> mockAdapterGroup;
Mock<IAdapter_1_9> mockAdapter;
Mock<IMetricsDevice_1_5> mockDevice;
EXPECT_CALL(*mockMetricsLibrary, load())
.Times(1)
.WillOnce(Return(true));
EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
.Times(1)
.WillOnce(Return(ZE_RESULT_SUCCESS));
EXPECT_CALL(*Mock<MetricEnumeration>::g_mockApi, MockOpenAdapterGroup(_))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<0>(&mockAdapterGroup), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
.Times(1)
.WillOnce(Return(&mockAdapter));
EXPECT_CALL(mockAdapter, OpenMetricsSubDevice(_, _))
.Times(1)
.WillOnce(Return(TCompletionCode::CC_ERROR_GENERAL));
EXPECT_CALL(mockAdapter, CloseMetricsDevice(_))
.Times(0);
EXPECT_CALL(mockDevice, GetParams())
.Times(0);
EXPECT_CALL(mockAdapterGroup, Close())
.Times(1)
.WillOnce(Return(TCompletionCode::CC_OK));
// Use root device.
metricContext.setSubDeviceIndex(0);
mockMetricsLibrary->initializationState = ZE_RESULT_SUCCESS;
EXPECT_EQ(metricContext.loadDependencies(), true);
EXPECT_EQ(metricContext.isInitialized(), true);
EXPECT_EQ(mockMetricEnumeration->baseIsInitialized(), false);
}
TEST_F(MetricEnumerationMultiDeviceTest, givenIncorrectMetricsDiscoveryInterfaceVersionWhenZetGetMetricGroupIsCalledThenReturnsFail) {
metricsDeviceParams.Version.MajorNumber = 0;
metricsDeviceParams.Version.MinorNumber = 1;
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.Times(1)
.WillOnce(Return(&metricsDeviceParams));
uint32_t metricGroupCount = 0;
EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_ERROR_UNKNOWN);
EXPECT_EQ(metricGroupCount, 0u);
}
TEST_F(MetricEnumerationMultiDeviceTest, givenValidArgumentsWhenZetMetricGetPropertiestIsCalledThenReturnSuccess) {
// Use first root device.
auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
// Metrics Discovery device.
metricsDeviceParams.ConcurrentGroupsCount = 1;
// Metrics Discovery concurrent group.
Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
metricsConcurrentGroupParams.MetricSetsCount = 1;
metricsConcurrentGroupParams.SymbolName = "OA";
metricsConcurrentGroupParams.Description = "OA description";
// Metrics Discovery:: metric set.
Mock<MetricsDiscovery::IMetricSet_1_5> metricsSet;
MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
metricsSetParams.MetricsCount = 0;
metricsSetParams.SymbolName = "Metric set name";
metricsSetParams.ShortName = "Metric set description";
metricsSetParams.MetricsCount = 1;
// Metrics Discovery:: metric.
Mock<IMetric_1_0> metric;
TMetricParams_1_0 metricParams = {};
metricParams.SymbolName = "Metric symbol name";
metricParams.ShortName = "Metric short name";
metricParams.LongName = "Metric long name";
metricParams.ResultType = MetricsDiscovery::TMetricResultType::RESULT_UINT64;
metricParams.MetricType = MetricsDiscovery::TMetricType::METRIC_TYPE_RATIO;
zet_metric_properties_t metricProperties = {};
// One api: metric group handle.
zet_metric_group_handle_t metricGroupHandle = {};
zet_metric_group_properties_t metricGroupProperties = {};
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
.Times(subDeviceCount)
.WillRepeatedly(Return(&metricsConcurrentGroup));
EXPECT_CALL(metricsConcurrentGroup, GetParams())
.Times(subDeviceCount)
.WillRepeatedly(Return(&metricsConcurrentGroupParams));
EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
.WillRepeatedly(Return(&metricsSet));
EXPECT_CALL(metricsSet, GetParams())
.WillRepeatedly(Return(&metricsSetParams));
EXPECT_CALL(metricsSet, GetMetric(_))
.Times(subDeviceCount)
.WillRepeatedly(Return(&metric));
EXPECT_CALL(metric, GetParams())
.Times(subDeviceCount)
.WillRepeatedly(Return(&metricParams));
EXPECT_CALL(metricsSet, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
// Metric group count.
uint32_t metricGroupCount = 0;
EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
// Metric group handle.
EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
// Metric group properties.
EXPECT_EQ(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupProperties.domain, 0u);
EXPECT_EQ(metricGroupProperties.samplingType, ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED);
EXPECT_EQ(metricGroupProperties.metricCount, metricsSetParams.MetricsCount);
EXPECT_EQ(strcmp(metricGroupProperties.description, metricsSetParams.ShortName), 0);
EXPECT_EQ(strcmp(metricGroupProperties.name, metricsSetParams.SymbolName), 0);
// Obtain metric.
uint32_t metricCount = 0;
zet_metric_handle_t metricHandle = {};
EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricCount, 1u);
EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, &metricHandle), ZE_RESULT_SUCCESS);
EXPECT_NE(metricHandle, nullptr);
// Obtain metric params.
EXPECT_EQ(zetMetricGetProperties(metricHandle, &metricProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(strcmp(metricProperties.name, metricParams.SymbolName), 0);
EXPECT_EQ(strcmp(metricProperties.description, metricParams.LongName), 0);
EXPECT_EQ(metricProperties.metricType, ZET_METRIC_TYPE_RATIO);
EXPECT_EQ(metricProperties.resultType, ZET_VALUE_TYPE_UINT64);
}
TEST_F(MetricEnumerationMultiDeviceTest, givenCorrectRawDataHeaderWhenZetMetricGroupCalculateMetricValuesExpIsCalledTwiceThenReturnsSuccess) {
auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
metricsDeviceParams.ConcurrentGroupsCount = 1;
Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
metricsConcurrentGroupParams.MetricSetsCount = 1;
metricsConcurrentGroupParams.SymbolName = "OA";
Mock<IMetricSet_1_5> metricsSet;
MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
metricsSetParams.QueryReportSize = 256;
metricsSetParams.MetricsCount = 11;
Mock<IMetric_1_0> metric;
MetricsDiscovery::TMetricParams_1_0 metricParams = {};
zet_metric_group_handle_t metricGroupHandle = {};
uint32_t returnedMetricCount = 1;
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
.Times(subDeviceCount)
.WillRepeatedly(Return(&metricsConcurrentGroup));
EXPECT_CALL(metricsConcurrentGroup, GetParams())
.Times(subDeviceCount)
.WillRepeatedly(Return(&metricsConcurrentGroupParams));
EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
.Times(subDeviceCount)
.WillRepeatedly(Return(&metricsSet));
EXPECT_CALL(metricsSet, GetParams())
.WillRepeatedly(Return(&metricsSetParams));
EXPECT_CALL(metricsSet, GetMetric(_))
.Times(metricsSetParams.MetricsCount * subDeviceCount)
.WillRepeatedly(Return(&metric));
EXPECT_CALL(metricsSet, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metric, GetParams())
.WillRepeatedly(Return(&metricParams));
EXPECT_CALL(metricsSet, CalculateMetrics(_, _, _, _, _, _, _))
.Times(subDeviceCount)
.WillRepeatedly(DoAll(::testing::SetArgPointee<4>(returnedMetricCount), Return(TCompletionCode::CC_OK)));
// Metric group handles.
uint32_t metricGroupCount = 1;
EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
// Raw results.
const size_t rawResultsSize = 560;
uint8_t rawResults[rawResultsSize] = {};
MetricGroupCalculateHeader *pRawHeader = reinterpret_cast<MetricGroupCalculateHeader *>(rawResults);
pRawHeader->magic = MetricGroupCalculateHeader::magicValue;
pRawHeader->dataCount = subDeviceCount;
pRawHeader->rawDataOffsets = sizeof(MetricGroupCalculateHeader);
pRawHeader->rawDataSizes = pRawHeader->rawDataOffsets + sizeof(uint32_t) * pRawHeader->dataCount;
pRawHeader->rawDataOffset = pRawHeader->rawDataSizes + sizeof(uint32_t) * pRawHeader->dataCount;
uint32_t *pRawDataOffsets = reinterpret_cast<uint32_t *>(rawResults + pRawHeader->rawDataOffsets);
uint32_t *pRawDataSizes = reinterpret_cast<uint32_t *>(rawResults + pRawHeader->rawDataSizes);
pRawDataOffsets[0] = 0;
pRawDataOffsets[1] = metricsSetParams.QueryReportSize;
pRawDataSizes[0] = metricsSetParams.QueryReportSize;
pRawDataSizes[1] = metricsSetParams.QueryReportSize;
// Valid raw buffer.
uint32_t dataCount = 0;
uint32_t totalMetricCount = 0;
EXPECT_NE(metricsSetParams.QueryReportSize, rawResultsSize);
EXPECT_EQ(zetMetricGroupCalculateMultipleMetricValuesExp(metricGroupHandle, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawResultsSize, rawResults, &dataCount, &totalMetricCount, nullptr, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(dataCount, subDeviceCount);
EXPECT_EQ(totalMetricCount, subDeviceCount * metricsSetParams.MetricsCount);
// Copy calculated metrics.
std::vector<uint32_t> metricCounts(dataCount);
std::vector<zet_typed_value_t> caculatedRawResults(totalMetricCount);
EXPECT_EQ(zetMetricGroupCalculateMultipleMetricValuesExp(metricGroupHandle, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawResultsSize, rawResults, &dataCount, &totalMetricCount, metricCounts.data(), caculatedRawResults.data()), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricCounts[0], metricsSetParams.MetricsCount);
EXPECT_EQ(metricCounts[1], metricsSetParams.MetricsCount);
}
TEST_F(MetricEnumerationMultiDeviceTest, givenInvalidDataCountAndTotalMetricCountWhenZetMetricGroupCalculateMetricValuesExpIsCalledThenReturnsCorrectDataCountAndTotalMetricCount) {
auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
metricsDeviceParams.ConcurrentGroupsCount = 1;
Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
metricsConcurrentGroupParams.MetricSetsCount = 1;
metricsConcurrentGroupParams.SymbolName = "OA";
Mock<IMetricSet_1_5> metricsSet;
MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
metricsSetParams.QueryReportSize = 256;
metricsSetParams.MetricsCount = 11;
Mock<IMetric_1_0> metric;
MetricsDiscovery::TMetricParams_1_0 metricParams = {};
zet_metric_group_handle_t metricGroupHandle = {};
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
.Times(subDeviceCount)
.WillRepeatedly(Return(&metricsConcurrentGroup));
EXPECT_CALL(metricsConcurrentGroup, GetParams())
.Times(subDeviceCount)
.WillRepeatedly(Return(&metricsConcurrentGroupParams));
EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
.Times(subDeviceCount)
.WillRepeatedly(Return(&metricsSet));
EXPECT_CALL(metricsSet, GetParams())
.WillRepeatedly(Return(&metricsSetParams));
EXPECT_CALL(metricsSet, GetMetric(_))
.Times(metricsSetParams.MetricsCount * subDeviceCount)
.WillRepeatedly(Return(&metric));
EXPECT_CALL(metricsSet, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metric, GetParams())
.WillRepeatedly(Return(&metricParams));
// Metric group handles.
uint32_t metricGroupCount = 1;
EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
// Raw results.
const size_t rawResultsSize = 560;
uint8_t rawResults[rawResultsSize] = {};
MetricGroupCalculateHeader *pRawHeader = reinterpret_cast<MetricGroupCalculateHeader *>(rawResults);
pRawHeader->magic = MetricGroupCalculateHeader::magicValue;
pRawHeader->dataCount = subDeviceCount;
pRawHeader->rawDataOffsets = sizeof(MetricGroupCalculateHeader);
pRawHeader->rawDataSizes = pRawHeader->rawDataOffsets + sizeof(uint32_t) * pRawHeader->dataCount;
pRawHeader->rawDataOffset = pRawHeader->rawDataSizes + sizeof(uint32_t) * pRawHeader->dataCount;
uint32_t *pRawDataOffsets = reinterpret_cast<uint32_t *>(rawResults + pRawHeader->rawDataOffsets);
uint32_t *pRawDataSizes = reinterpret_cast<uint32_t *>(rawResults + pRawHeader->rawDataSizes);
pRawDataOffsets[0] = 0;
pRawDataOffsets[1] = metricsSetParams.QueryReportSize;
pRawDataSizes[0] = metricsSetParams.QueryReportSize;
pRawDataSizes[1] = metricsSetParams.QueryReportSize;
// Valid raw buffer. Invalid data count.
uint32_t dataCount = 1000;
uint32_t totalMetricCount = 0;
EXPECT_NE(metricsSetParams.QueryReportSize, rawResultsSize);
EXPECT_EQ(zetMetricGroupCalculateMultipleMetricValuesExp(metricGroupHandle, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawResultsSize, rawResults, &dataCount, &totalMetricCount, nullptr, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(subDeviceCount, dataCount);
EXPECT_EQ(subDeviceCount * metricsSetParams.MetricsCount, totalMetricCount);
// Valid raw buffer. Invalid total metric count.
dataCount = 0;
totalMetricCount = 1000;
EXPECT_NE(metricsSetParams.QueryReportSize, rawResultsSize);
EXPECT_EQ(zetMetricGroupCalculateMultipleMetricValuesExp(metricGroupHandle, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawResultsSize, rawResults, &dataCount, &totalMetricCount, nullptr, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(subDeviceCount, dataCount);
EXPECT_EQ(subDeviceCount * metricsSetParams.MetricsCount, totalMetricCount);
}
TEST_F(MetricEnumerationMultiDeviceTest, givenInvalidQueryReportSizeWhenZetMetricGroupCalculateMetricValuesExpIsCalledThenReturnsFail) {
auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
metricsDeviceParams.ConcurrentGroupsCount = 1;
Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
metricsConcurrentGroupParams.MetricSetsCount = 1;
metricsConcurrentGroupParams.SymbolName = "OA";
Mock<IMetricSet_1_5> metricsSet;
MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
metricsSetParams.QueryReportSize = 0;
metricsSetParams.MetricsCount = 11;
Mock<IMetric_1_0> metric;
MetricsDiscovery::TMetricParams_1_0 metricParams = {};
zet_metric_group_handle_t metricGroupHandle = {};
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
.Times(subDeviceCount)
.WillRepeatedly(Return(&metricsConcurrentGroup));
EXPECT_CALL(metricsConcurrentGroup, GetParams())
.Times(subDeviceCount)
.WillRepeatedly(Return(&metricsConcurrentGroupParams));
EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
.Times(subDeviceCount)
.WillRepeatedly(Return(&metricsSet));
EXPECT_CALL(metricsSet, GetParams())
.WillRepeatedly(Return(&metricsSetParams));
EXPECT_CALL(metricsSet, GetMetric(_))
.Times(metricsSetParams.MetricsCount * subDeviceCount)
.WillRepeatedly(Return(&metric));
EXPECT_CALL(metricsSet, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metric, GetParams())
.WillRepeatedly(Return(&metricParams));
// Metric group handles.
uint32_t metricGroupCount = 1;
EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
// Raw results.
const size_t rawResultsSize = 560;
uint8_t rawResults[rawResultsSize] = {};
MetricGroupCalculateHeader *pRawHeader = reinterpret_cast<MetricGroupCalculateHeader *>(rawResults);
pRawHeader->magic = MetricGroupCalculateHeader::magicValue;
pRawHeader->dataCount = subDeviceCount;
pRawHeader->rawDataOffsets = sizeof(MetricGroupCalculateHeader);
pRawHeader->rawDataSizes = pRawHeader->rawDataOffsets + sizeof(uint32_t) * pRawHeader->dataCount;
pRawHeader->rawDataOffset = pRawHeader->rawDataSizes + sizeof(uint32_t) * pRawHeader->dataCount;
uint32_t *pRawDataOffsets = reinterpret_cast<uint32_t *>(rawResults + pRawHeader->rawDataOffsets);
uint32_t *pRawDataSizes = reinterpret_cast<uint32_t *>(rawResults + pRawHeader->rawDataSizes);
pRawDataOffsets[0] = 0;
pRawDataOffsets[1] = metricsSetParams.QueryReportSize;
pRawDataSizes[0] = metricsSetParams.QueryReportSize;
pRawDataSizes[1] = metricsSetParams.QueryReportSize;
// Valid raw buffer. Invalid query report size.
uint32_t dataCount = 0;
uint32_t totalMetricCount = 0;
EXPECT_NE(metricsSetParams.QueryReportSize, rawResultsSize);
EXPECT_EQ(zetMetricGroupCalculateMultipleMetricValuesExp(metricGroupHandle, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawResultsSize, rawResults, &dataCount, &totalMetricCount, nullptr, nullptr), ZE_RESULT_ERROR_UNKNOWN);
EXPECT_EQ(dataCount, 0u);
EXPECT_EQ(totalMetricCount, 0u);
}
TEST_F(MetricEnumerationMultiDeviceTest, givenErrorGeneralOnCalculateMetricsWhenZetMetricGroupCalculateMetricValuesExpIsCalledThenReturnsFail) {
auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
metricsDeviceParams.ConcurrentGroupsCount = 1;
Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
metricsConcurrentGroupParams.MetricSetsCount = 1;
metricsConcurrentGroupParams.SymbolName = "OA";
Mock<IMetricSet_1_5> metricsSet;
MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
metricsSetParams.QueryReportSize = 256;
metricsSetParams.MetricsCount = 11;
Mock<IMetric_1_0> metric;
MetricsDiscovery::TMetricParams_1_0 metricParams = {};
zet_metric_group_handle_t metricGroupHandle = {};
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
.Times(subDeviceCount)
.WillRepeatedly(Return(&metricsConcurrentGroup));
EXPECT_CALL(metricsConcurrentGroup, GetParams())
.Times(subDeviceCount)
.WillRepeatedly(Return(&metricsConcurrentGroupParams));
EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
.Times(subDeviceCount)
.WillRepeatedly(Return(&metricsSet));
EXPECT_CALL(metricsSet, GetParams())
.WillRepeatedly(Return(&metricsSetParams));
EXPECT_CALL(metricsSet, GetMetric(_))
.Times(metricsSetParams.MetricsCount * subDeviceCount)
.WillRepeatedly(Return(&metric));
EXPECT_CALL(metricsSet, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metric, GetParams())
.WillRepeatedly(Return(&metricParams));
EXPECT_CALL(metricsSet, CalculateMetrics(_, _, _, _, _, _, _))
.Times(1)
.WillOnce(Return(TCompletionCode::CC_ERROR_GENERAL));
// Metric group handles.
uint32_t metricGroupCount = 1;
EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
// Raw results.
const size_t rawResultsSize = 560;
uint8_t rawResults[rawResultsSize] = {};
MetricGroupCalculateHeader *pRawHeader = reinterpret_cast<MetricGroupCalculateHeader *>(rawResults);
pRawHeader->magic = MetricGroupCalculateHeader::magicValue;
pRawHeader->dataCount = subDeviceCount;
pRawHeader->rawDataOffsets = sizeof(MetricGroupCalculateHeader);
pRawHeader->rawDataSizes = pRawHeader->rawDataOffsets + sizeof(uint32_t) * pRawHeader->dataCount;
pRawHeader->rawDataOffset = pRawHeader->rawDataSizes + sizeof(uint32_t) * pRawHeader->dataCount;
uint32_t *pRawDataOffsets = reinterpret_cast<uint32_t *>(rawResults + pRawHeader->rawDataOffsets);
uint32_t *pRawDataSizes = reinterpret_cast<uint32_t *>(rawResults + pRawHeader->rawDataSizes);
pRawDataOffsets[0] = 0;
pRawDataOffsets[1] = metricsSetParams.QueryReportSize;
pRawDataSizes[0] = metricsSetParams.QueryReportSize;
pRawDataSizes[1] = metricsSetParams.QueryReportSize;
// Valid raw buffer.
uint32_t dataCount = 0;
uint32_t totalMetricCount = 0;
EXPECT_NE(metricsSetParams.QueryReportSize, rawResultsSize);
EXPECT_EQ(zetMetricGroupCalculateMultipleMetricValuesExp(metricGroupHandle, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawResultsSize, rawResults, &dataCount, &totalMetricCount, nullptr, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(dataCount, subDeviceCount);
EXPECT_EQ(totalMetricCount, subDeviceCount * metricsSetParams.MetricsCount);
// Copy calculated metrics. CalculateMetrics returns CC_ERROR_GENERAL for first sub device.
std::vector<uint32_t> metricCounts(dataCount);
std::vector<zet_typed_value_t> caculatedRawResults(totalMetricCount);
EXPECT_EQ(zetMetricGroupCalculateMultipleMetricValuesExp(metricGroupHandle, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawResultsSize, rawResults, &dataCount, &totalMetricCount, metricCounts.data(), caculatedRawResults.data()), ZE_RESULT_ERROR_UNKNOWN);
EXPECT_EQ(metricCounts[0], 0u);
EXPECT_EQ(metricCounts[1], 0u);
}
} // namespace ult
} // namespace L0

185
level_zero/tools/test/unit_tests/sources/metrics/test_metric_query_pool_2.cpp
View File

@@ -456,18 +456,18 @@ TEST_F(MetricQueryPoolTest, givenUninitializedMetricEnumerationWhenGetQueryRepor
EXPECT_EQ(invalidSize, 0u);
}
class MultiDeviceMetricQueryPoolTest : public MetricMultiDeviceContextFixture,
class MultiDeviceMetricQueryPoolTest : public MetricMultiDeviceFixture,
public ::testing::Test {
public:
void SetUp() override {
ze_result_t returnValue = ZE_RESULT_SUCCESS;
MetricMultiDeviceContextFixture::SetUp();
MetricMultiDeviceFixture::SetUp();
auto executionEnvironment = new NEO::ExecutionEnvironment();
driverHandle.reset(DriverHandle::create(NEO::DeviceFactory::createDevices(*executionEnvironment), L0EnvVariables{}, &returnValue));
}
void TearDown() override {
MetricMultiDeviceContextFixture::TearDown();
MetricMultiDeviceFixture::TearDown();
driverHandle.reset();
GlobalDriver = nullptr;
}
@@ -1088,7 +1088,8 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenFailedGetDataWhenZetMetricQueryGetDa
// Get desired raw data size.
size_t rawSize = 0;
EXPECT_EQ(zetMetricQueryGetData(queryHandle, &rawSize, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(rawSize, reportSize * subDeviceCount);
const size_t expectedRawSize = (reportSize * subDeviceCount) + sizeof(MetricGroupCalculateHeader) + (2 * sizeof(uint32_t) * subDeviceCount);
EXPECT_EQ(rawSize, expectedRawSize);
// Get data.
std::vector<uint8_t> rawData;
@@ -1604,5 +1605,181 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenUninitializedMetricsLibraryWhenGetGp
EXPECT_EQ(result, false);
}
TEST_F(MultiDeviceMetricQueryPoolTest, givenValidArgumentsWhenZetMetricGroupCalculateMetricValuesExpThenReturnsSuccess) {
zet_device_handle_t metricDevice = devices[0]->toHandle();
auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
metricsDeviceParams.ConcurrentGroupsCount = 1;
Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
metricsConcurrentGroupParams.MetricSetsCount = 1;
metricsConcurrentGroupParams.SymbolName = "OA";
metricsConcurrentGroupParams.Description = "OA description";
Mock<MetricsDiscovery::IMetricSet_1_5> metricsSet;
MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
metricsSetParams.MetricsCount = 0;
metricsSetParams.SymbolName = "Metric set name";
metricsSetParams.ShortName = "Metric set description";
metricsSetParams.QueryReportSize = 256;
metricsSetParams.MetricsCount = 1;
Mock<IMetric_1_0> metric;
TMetricParams_1_0 metricParams = {};
metricParams.SymbolName = "Metric symbol name";
metricParams.ShortName = "Metric short name";
metricParams.LongName = "Metric long name";
metricParams.ResultType = MetricsDiscovery::TMetricResultType::RESULT_UINT64;
metricParams.MetricType = MetricsDiscovery::TMetricType::METRIC_TYPE_RATIO;
zet_metric_group_handle_t metricGroupHandle = {};
zet_metric_group_properties_t metricGroupProperties = {};
metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
zet_metric_query_handle_t queryHandle = {};
zet_metric_query_pool_handle_t poolHandle = {};
zet_metric_query_pool_desc_t poolDesc = {};
poolDesc.stype = ZET_STRUCTURE_TYPE_METRIC_QUERY_POOL_DESC;
poolDesc.count = 1;
poolDesc.type = ZET_METRIC_QUERY_POOL_TYPE_PERFORMANCE;
TypedValue_1_0 value = {};
value.Type = ValueType::Uint32;
value.ValueUInt32 = 64;
QueryHandle_1_0 metricsLibraryQueryHandle = {&value};
ContextHandle_1_0 metricsLibraryContextHandle = {&value};
CommandBufferSize_1_0 commandBufferSize = {};
commandBufferSize.GpuMemorySize = 100;
uint32_t returnedMetricCount = 1;
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
.Times(subDeviceCount)
.WillRepeatedly(Return(&metricsConcurrentGroup));
EXPECT_CALL(metricsConcurrentGroup, GetParams())
.Times(subDeviceCount)
.WillRepeatedly(Return(&metricsConcurrentGroupParams));
EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
.WillRepeatedly(Return(&metricsSet));
EXPECT_CALL(metricsSet, GetParams())
.WillRepeatedly(Return(&metricsSetParams));
EXPECT_CALL(metricsSet, GetMetric(_))
.Times(subDeviceCount)
.WillRepeatedly(Return(&metric));
EXPECT_CALL(metric, GetParams())
.Times(subDeviceCount)
.WillRepeatedly(Return(&metricParams));
EXPECT_CALL(metricsSet, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
for (uint32_t i = 0; i < subDeviceCount; ++i) {
EXPECT_CALL(*mockMetricEnumerationSubDevices[i], isInitialized())
.Times(1)
.WillOnce(Return(true));
EXPECT_CALL(*mockMetricsLibrarySubDevices[i], getContextData(_, _))
.Times(1)
.WillOnce(Return(true));
}
EXPECT_CALL(*mockMetricsLibrarySubDevices[0], getMetricQueryReportSize(_))
.Times(1)
.WillOnce(DoAll(::testing::SetArgReferee<0>(metricsSetParams.QueryReportSize), Return(true)));
EXPECT_CALL(*mockMetricsLibrary, load())
.Times(0);
EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryCreate(_, _))
.Times(subDeviceCount)
.WillRepeatedly(DoAll(::testing::SetArgPointee<1>(metricsLibraryQueryHandle), Return(StatusCode::Success)));
EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryDelete(_))
.Times(subDeviceCount)
.WillRepeatedly(Return(StatusCode::Success));
EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetParameter(_, _, _))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<2>(value), Return(StatusCode::Success)));
EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
.Times(subDeviceCount)
.WillRepeatedly(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetData(_))
.Times(subDeviceCount)
.WillRepeatedly(Return(StatusCode::Success));
EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
.Times(subDeviceCount)
.WillRepeatedly(Return(StatusCode::Success));
EXPECT_CALL(metricsSet, CalculateMetrics(_, _, _, _, _, _, _))
.Times(subDeviceCount)
.WillRepeatedly(DoAll(::testing::SetArgPointee<4>(returnedMetricCount), Return(TCompletionCode::CC_OK)));
// Metric group count.
uint32_t metricGroupCount = 0;
EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
// Metric group handle.
EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
// Create metric query pool.
EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), metricDevice, metricGroupHandle, &poolDesc, &poolHandle), ZE_RESULT_SUCCESS);
EXPECT_NE(poolHandle, nullptr);
// Create metric query.
EXPECT_EQ(zetMetricQueryCreate(poolHandle, 0, &queryHandle), ZE_RESULT_SUCCESS);
EXPECT_NE(queryHandle, nullptr);
// Get desired raw data size.
size_t rawSize = 0;
EXPECT_EQ(zetMetricQueryGetData(queryHandle, &rawSize, nullptr), ZE_RESULT_SUCCESS);
const size_t expectedRawSize = (metricsSetParams.QueryReportSize * subDeviceCount) + sizeof(MetricGroupCalculateHeader) + (2 * sizeof(uint32_t) * subDeviceCount);
EXPECT_EQ(rawSize, expectedRawSize);
// Get data.
std::vector<uint8_t> rawData;
rawData.resize(rawSize);
EXPECT_EQ(zetMetricQueryGetData(queryHandle, &rawSize, rawData.data()), ZE_RESULT_SUCCESS);
uint32_t dataCount = 0;
uint32_t totalMetricCount = 0;
EXPECT_EQ(zetMetricGroupCalculateMultipleMetricValuesExp(metricGroupHandle, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawSize, rawData.data(), &dataCount, &totalMetricCount, nullptr, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(dataCount, subDeviceCount);
EXPECT_EQ(totalMetricCount, subDeviceCount * metricsSetParams.MetricsCount);
std::vector<uint32_t> metricCounts(dataCount);
std::vector<zet_typed_value_t> caculatedRawResults(totalMetricCount);
EXPECT_EQ(zetMetricGroupCalculateMultipleMetricValuesExp(metricGroupHandle, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawSize, rawData.data(), &dataCount, &totalMetricCount, metricCounts.data(), caculatedRawResults.data()), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricCounts[0], metricsSetParams.MetricsCount);
EXPECT_EQ(metricCounts[1], metricsSetParams.MetricsCount);
// Destroy query and its pool.
EXPECT_EQ(zetMetricQueryDestroy(queryHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(zetMetricQueryPoolDestroy(poolHandle), ZE_RESULT_SUCCESS);
}
} // namespace ult
} // namespace L0

125
level_zero/tools/test/unit_tests/sources/metrics/test_metric_streamer_2.cpp
View File

@@ -20,7 +20,7 @@ using ::testing::Return;
namespace L0 {
namespace ult {
using MetricStreamerMultiDeviceTest = Test<MetricStreamerMultiDeviceContextFixture>;
using MetricStreamerMultiDeviceTest = Test<MetricStreamerMultiDeviceFixture>;
TEST_F(MetricStreamerMultiDeviceTest, givenInvalidMetricGroupTypeWhenZetMetricStreamerOpenIsCalledThenReturnsFail) {
@@ -648,6 +648,8 @@ TEST_F(MetricStreamerMultiDeviceTest, givenValidArgumentsWhenZetMetricStreamerRe
size_t rawSize = 0;
uint32_t reportCount = 256;
EXPECT_EQ(zetMetricStreamerReadData(streamerHandle, reportCount, &rawSize, nullptr), ZE_RESULT_SUCCESS);
const size_t expectedRawSize = (metricsSetParams.RawReportSize * reportCount * subDeviceCount) + sizeof(MetricGroupCalculateHeader) + (2 * sizeof(uint32_t) * subDeviceCount);
EXPECT_EQ(rawSize, expectedRawSize);
std::vector<uint8_t> rawData;
rawData.resize(rawSize);
@@ -903,5 +905,126 @@ TEST_F(MetricStreamerMultiDeviceTest, givenEnableWalkerPartitionIsOnWhenZetComma
EXPECT_EQ(zetMetricStreamerClose(streamerHandle), ZE_RESULT_SUCCESS);
}
TEST_F(MetricStreamerMultiDeviceTest, givenValidArgumentsWhenZetMetricGroupCalculateMetricValuesExpThenReturnsSuccess) {
zet_device_handle_t metricDeviceHandle = devices[0]->toHandle();
auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
ze_event_handle_t eventHandle = {};
zet_metric_streamer_handle_t streamerHandle = {};
zet_metric_streamer_desc_t streamerDesc = {};
streamerDesc.stype = ZET_STRUCTURE_TYPE_METRIC_STREAMER_DESC;
streamerDesc.notifyEveryNReports = 32768;
streamerDesc.samplingPeriod = 1000;
Mock<MetricGroup> metricGroup;
zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
metricsDeviceParams.ConcurrentGroupsCount = 1;
Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
metricsConcurrentGroupParams.MetricSetsCount = 1;
metricsConcurrentGroupParams.SymbolName = "OA";
metricsConcurrentGroupParams.Description = "OA description";
Mock<MetricsDiscovery::IMetricSet_1_5> metricsSet;
MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM;
metricsSetParams.SymbolName = "Metric set name";
metricsSetParams.ShortName = "Metric set description";
metricsSetParams.RawReportSize = 256;
metricsSetParams.MetricsCount = 11;
Mock<IMetric_1_0> metric;
MetricsDiscovery::TMetricParams_1_0 metricParams = {};
uint32_t returnedMetricCount = 1;
openMetricsAdapter();
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
.Times(subDeviceCount)
.WillRepeatedly(Return(&metricsConcurrentGroup));
EXPECT_CALL(metricsConcurrentGroup, GetParams())
.Times(subDeviceCount)
.WillRepeatedly(Return(&metricsConcurrentGroupParams));
EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
.WillRepeatedly(Return(&metricsSet));
EXPECT_CALL(metricsSet, GetParams())
.WillRepeatedly(Return(&metricsSetParams));
EXPECT_CALL(metricsSet, GetMetric(_))
.Times(metricsSetParams.MetricsCount * subDeviceCount)
.WillRepeatedly(Return(&metric));
EXPECT_CALL(metricsSet, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metric, GetParams())
.WillRepeatedly(Return(&metricParams));
EXPECT_CALL(metricsConcurrentGroup, OpenIoStream(_, _, _, _))
.Times(subDeviceCount)
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsConcurrentGroup, ReadIoStream(_, _, _))
.Times(subDeviceCount)
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsSet, CalculateMetrics(_, _, _, _, _, _, _))
.Times(subDeviceCount)
.WillRepeatedly(DoAll(::testing::SetArgPointee<4>(returnedMetricCount), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(metricsConcurrentGroup, CloseIoStream())
.Times(subDeviceCount)
.WillRepeatedly(Return(TCompletionCode::CC_OK));
uint32_t metricGroupCount = 0;
EXPECT_EQ(zetMetricGroupGet(metricDeviceHandle, &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_EQ(zetMetricGroupGet(metricDeviceHandle, &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupCount, 1u);
EXPECT_NE(metricGroupHandle, nullptr);
EXPECT_EQ(zetContextActivateMetricGroups(context->toHandle(), metricDeviceHandle, 1, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(zetMetricStreamerOpen(context->toHandle(), metricDeviceHandle, metricGroupHandle, &streamerDesc, eventHandle, &streamerHandle), ZE_RESULT_SUCCESS);
EXPECT_NE(streamerHandle, nullptr);
size_t rawSize = 0;
uint32_t reportCount = 256;
EXPECT_EQ(zetMetricStreamerReadData(streamerHandle, reportCount, &rawSize, nullptr), ZE_RESULT_SUCCESS);
std::vector<uint8_t> rawData;
rawData.resize(rawSize);
size_t rawRequestSize = rawSize;
EXPECT_EQ(zetMetricStreamerReadData(streamerHandle, reportCount, &rawSize, rawData.data()), ZE_RESULT_SUCCESS);
EXPECT_EQ(rawSize, rawRequestSize);
uint32_t dataCount = 0;
uint32_t totalMetricCount = 0;
EXPECT_EQ(zetMetricGroupCalculateMultipleMetricValuesExp(metricGroupHandle, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawSize, rawData.data(), &dataCount, &totalMetricCount, nullptr, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(totalMetricCount, subDeviceCount * metricsSetParams.MetricsCount * reportCount);
std::vector<uint32_t> metricCounts(dataCount);
std::vector<zet_typed_value_t> caculatedRawResults(totalMetricCount);
EXPECT_EQ(zetMetricGroupCalculateMultipleMetricValuesExp(metricGroupHandle, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, rawSize, rawData.data(), &dataCount, &totalMetricCount, metricCounts.data(), caculatedRawResults.data()), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricCounts[0], metricsSetParams.MetricsCount);
EXPECT_EQ(metricCounts[1], metricsSetParams.MetricsCount);
EXPECT_EQ(zetMetricStreamerClose(streamerHandle), ZE_RESULT_SUCCESS);
}
} // namespace ult
} // namespace L0