Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Metrics MultiDevice Support Add SubDevice Check 

Adding isSubdevice check to support multi devices


Related-To: LOCI-2554

Signed-off-by: Joshua Santosh Ranjan <joshua.santosh.ranjan@intel.com>
This commit is contained in:
Joshua Santosh Ranjan 2021-09-16 11:05:05 +00:00 committed by Compute-Runtime-Automation
parent 3fc497fa5e
commit d6bb9bf0dd
10 changed files with 1085 additions and 663 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
level_zero/core/source/device/device_imp.cpp
View File

@ -639,7 +639,7 @@ ze_result_t DeviceImp::systemBarrier() { return ZE_RESULT_ERROR_UNSUPPORTED_FEAT
ze_result_t DeviceImp::activateMetricGroups(uint32_t count,
zet_metric_group_handle_t *phMetricGroups) {
ze_result_t result = ZE_RESULT_ERROR_UNKNOWN;
if (this->isMultiDeviceCapable()) {
if (!this->isSubdevice && this->isMultiDeviceCapable()) {
for (auto subDevice : this->subDevices) {
result = subDevice->getMetricContext().activateMetricGroupsDeferred(count, phMetricGroups);
if (result != ZE_RESULT_SUCCESS)

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

@ -131,11 +131,10 @@ ze_result_t MetricEnumeration::openMetricsDiscovery() {
}
auto &device = metricContext.getDevice();
if (device.isMultiDeviceCapable()) {
const auto &deviceImp = *static_cast<DeviceImp *>(&device);
if (!deviceImp.isSubdevice && deviceImp.isMultiDeviceCapable()) {
// Open metrics device for each sub device.
const auto &deviceImp = *static_cast<DeviceImp *>(&device);
for (size_t i = 0; i < deviceImp.numSubDevices; i++) {
auto &metricsDevice = deviceImp.subDevices[i]->getMetricContext().getMetricEnumeration().pMetricsDevice;
@ -171,9 +170,9 @@ ze_result_t MetricEnumeration::cleanupMetricsDiscovery() {
if (pAdapter) {
auto &device = metricContext.getDevice();
if (device.isMultiDeviceCapable()) {
const auto &deviceImp = *static_cast<DeviceImp *>(&device);
if (!deviceImp.isSubdevice && deviceImp.isMultiDeviceCapable()) {
const auto &deviceImp = *static_cast<DeviceImp *>(&device);
for (size_t i = 0; i < deviceImp.numSubDevices; i++) {
deviceImp.subDevices[i]->getMetricContext().getMetricEnumeration().cleanupMetricsDiscovery();
}
@ -205,13 +204,12 @@ ze_result_t MetricEnumeration::cleanupMetricsDiscovery() {
ze_result_t MetricEnumeration::cacheMetricInformation() {
auto &device = metricContext.getDevice();
if (device.isMultiDeviceCapable()) {
const auto &deviceImp = *static_cast<DeviceImp *>(&device);
if (!deviceImp.isSubdevice && deviceImp.isMultiDeviceCapable()) {
ze_result_t result = ZE_RESULT_SUCCESS;
// Get metric information from all sub devices.
const auto &deviceImp = *static_cast<DeviceImp *>(&device);
for (auto subDevice : deviceImp.subDevices) {
result = subDevice->getMetricContext().getMetricEnumeration().cacheMetricInformation();
if (ZE_RESULT_SUCCESS != result) {

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

@ -418,7 +418,7 @@ ze_result_t metricQueryPoolCreate(zet_context_handle_t hContext, zet_device_hand
const auto &deviceImp = *static_cast<DeviceImp *>(device);
auto metricPoolImp = new MetricQueryPoolImp(device->getMetricContext(), hMetricGroup, *pDesc);
if (deviceImp.isMultiDeviceCapable()) {
if (!deviceImp.isSubdevice && deviceImp.isMultiDeviceCapable()) {
auto emptyMetricGroups = std::vector<zet_metric_group_handle_t>();
auto &metricGroups = hMetricGroup
@ -530,7 +530,7 @@ bool MetricQueryPoolImp::allocateGpuMemory() {
if (description.type == ZET_METRIC_QUERY_POOL_TYPE_PERFORMANCE) {
// Get allocation size.
const auto &deviceImp = *static_cast<DeviceImp *>(&metricContext.getDevice());
const uint32_t allocationSize = (deviceImp.isMultiDeviceCapable())
const uint32_t allocationSize = (!deviceImp.isSubdevice && deviceImp.isMultiDeviceCapable())
? deviceImp.subDevices[0]->getMetricContext().getMetricsLibrary().getQueryReportGpuSize() * description.count * deviceImp.numSubDevices
: metricsLibrary.getQueryReportGpuSize() * description.count;
@ -771,7 +771,7 @@ ze_result_t MetricQuery::appendStreamerMarker(CommandList &commandList,
DeviceImp *pDeviceImp = static_cast<DeviceImp *>(commandList.device);
if (pDeviceImp->isMultiDeviceCapable()) {
if (!pDeviceImp->isSubdevice && pDeviceImp->isMultiDeviceCapable()) {
// Use one of the sub-device contexts to append to command list.
pDeviceImp = static_cast<DeviceImp *>(pDeviceImp->subDevices[0]);
}

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

@ -270,10 +270,10 @@ ze_result_t MetricStreamer::open(zet_context_handle_t hContext, zet_device_handl
ze_result_t result = ZE_RESULT_SUCCESS;
auto pDevice = Device::fromHandle(hDevice);
const auto pDeviceImp = static_cast<const DeviceImp *>(pDevice);
if (pDevice->isMultiDeviceCapable()) {
const auto deviceImp = static_cast<const DeviceImp *>(pDevice);
const uint32_t subDeviceCount = deviceImp->numSubDevices;
if (!pDeviceImp->isSubdevice && pDeviceImp->isMultiDeviceCapable()) {
const uint32_t subDeviceCount = pDeviceImp->numSubDevices;
auto pMetricStreamer = new MetricStreamerImp();
UNRECOVERABLE_IF(pMetricStreamer == nullptr);
@ -284,7 +284,7 @@ ze_result_t MetricStreamer::open(zet_context_handle_t hContext, zet_device_handl
for (uint32_t i = 0; i < subDeviceCount; i++) {
auto metricGroupsSubDevice = metricGroupRootDevice->getMetricGroups()[i];
result = openForDevice(deviceImp->subDevices[i], metricGroupsSubDevice, desc, &metricStreamers[i]);
result = openForDevice(pDeviceImp->subDevices[i], metricGroupsSubDevice, desc, &metricStreamers[i]);
if (result != ZE_RESULT_SUCCESS) {
for (uint32_t j = 0; j < i; j++) {
auto metricStreamerSubDevice = MetricStreamer::fromHandle(metricStreamers[j]);

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

@ -13,7 +13,8 @@ target_sources(${TARGET_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/test_metric_enumeration.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.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_metric_streamer_1.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_metric_streamer_2.cpp
)
add_subdirectories()

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

@ -317,6 +317,35 @@ void MetricMultiDeviceContextFixture::openMetricsAdapter() {
.WillOnce(Return(TCompletionCode::CC_OK));
}
void MetricMultiDeviceContextFixture::openMetricsAdapterSubDevice(uint32_t subDeviceIndex) {
EXPECT_CALL(*mockMetricEnumerationSubDevices[subDeviceIndex], loadMetricsDiscovery())
.Times(0);
EXPECT_CALL(*mockMetricEnumerationSubDevices[subDeviceIndex]->g_mockApi, MockOpenAdapterGroup(_))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<0>(&adapterGroup), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(adapter, OpenMetricsDevice(_))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<0>(&metricsDevice), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(adapter, CloseMetricsDevice(_))
.Times(1)
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(adapterGroup, GetAdapter(_))
.Times(0);
EXPECT_CALL(*mockMetricEnumerationSubDevices[subDeviceIndex], getMetricsAdapter())
.Times(1)
.WillOnce(Return(&adapter));
EXPECT_CALL(adapterGroup, Close())
.Times(1)
.WillOnce(Return(TCompletionCode::CC_OK));
}
void MetricMultiDeviceContextFixture::openMetricsAdapterGroup() {
EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())

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

@ -200,6 +200,7 @@ class MetricMultiDeviceContextFixture : public MultiDeviceFixture {
void SetUp() override;
void TearDown() override;
void openMetricsAdapter();
void openMetricsAdapterSubDevice(uint32_t subDeviceIndex);
void openMetricsAdapterGroup();
public:

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

@ -610,6 +610,138 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenCorrectArgumentsWhenZetCommandListAp
EXPECT_EQ(zetMetricQueryPoolDestroy(poolHandle), ZE_RESULT_SUCCESS);
}
TEST_F(MultiDeviceMetricQueryPoolTest, givenEnableWalkerPartitionIsOnWhenZetCommandListAppendMetricQueryBeginEndIsCalledForSubDeviceThenReturnsSuccess) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableWalkerPartition.set(1);
auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
zet_device_handle_t metricDeviceHandle = deviceImp.subDevices[0]->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_OCL;
metricsSetParams.MetricsCount = 0;
metricsSetParams.SymbolName = "Metric set name";
metricsSetParams.ShortName = "Metric set description";
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};
openMetricsAdapterSubDevice(0);
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
.Times(1)
.WillRepeatedly(Return(&metricsConcurrentGroup));
EXPECT_CALL(metricsConcurrentGroup, GetParams())
.Times(1)
.WillRepeatedly(Return(&metricsConcurrentGroupParams));
EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
.WillRepeatedly(Return(&metricsSet));
EXPECT_CALL(metricsSet, GetParams())
.WillRepeatedly(Return(&metricsSetParams));
EXPECT_CALL(metricsSet, GetMetric(_))
.Times(1)
.WillRepeatedly(Return(&metric));
EXPECT_CALL(metric, GetParams())
.Times(1)
.WillRepeatedly(Return(&metricParams));
EXPECT_CALL(metricsSet, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(*mockMetricEnumerationSubDevices[0], isInitialized())
.Times(1)
.WillOnce(Return(true));
EXPECT_CALL(*mockMetricsLibrarySubDevices[0], getContextData(_, _))
.Times(1)
.WillOnce(Return(true));
EXPECT_CALL(*mockMetricsLibrary, load())
.Times(0);
EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryCreate(_, _))
.Times(1)
.WillRepeatedly(DoAll(::testing::SetArgPointee<1>(metricsLibraryQueryHandle), Return(StatusCode::Success)));
EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryDelete(_))
.Times(1)
.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(1)
.WillRepeatedly(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
.Times(1)
.WillRepeatedly(Return(StatusCode::Success));
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(zetMetricQueryPoolCreate(context->toHandle(), metricDeviceHandle, metricGroupHandle, &poolDesc, &poolHandle), ZE_RESULT_SUCCESS);
EXPECT_NE(poolHandle, nullptr);
EXPECT_EQ(zetMetricQueryCreate(poolHandle, 0, &queryHandle), ZE_RESULT_SUCCESS);
EXPECT_NE(queryHandle, nullptr);
EXPECT_EQ(zetMetricQueryDestroy(queryHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(zetMetricQueryPoolDestroy(poolHandle), ZE_RESULT_SUCCESS);
}
TEST_F(MultiDeviceMetricQueryPoolTest, givenFailedMetricsLibraryContextWhenZetMetricQueryPoolCreateIsCalledThenReturnFail) {
zet_device_handle_t metricDevice = devices[0]->toHandle();

646
level_zero/tools/test/unit_tests/sources/metrics/test_metric_streamer.cpp → level_zero/tools/test/unit_tests/sources/metrics/test_metric_streamer_1.cpp
View File

@ -1003,651 +1003,5 @@ TEST_F(MetricStreamerTest, givenMultipleMarkerInsertionsWhenZetCommandListAppend
EXPECT_EQ(zetMetricStreamerClose(streamerHandle), ZE_RESULT_SUCCESS);
}
using MetricStreamerMultiDeviceTest = Test<MetricStreamerMultiDeviceContextFixture>;
TEST_F(MetricStreamerMultiDeviceTest, givenInvalidMetricGroupTypeWhenZetMetricStreamerOpenIsCalledThenReturnsFail) {
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();
zet_metric_group_properties_t metricGroupProperties = {};
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.RawReportSize = 256;
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, SetApiFiltering(_))
.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(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);
EXPECT_EQ(zetContextActivateMetricGroups(context->toHandle(), metricDeviceHandle, 1, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(zetMetricStreamerOpen(context->toHandle(), metricDeviceHandle, metricGroupHandle, &streamerDesc, eventHandle, &streamerHandle), ZE_RESULT_ERROR_INVALID_ARGUMENT);
EXPECT_EQ(streamerHandle, nullptr);
}
TEST_F(MetricStreamerMultiDeviceTest, givenValidArgumentsWhenZetMetricStreamerOpenIsCalledThenReturnsSuccess) {
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();
zet_metric_group_properties_t metricGroupProperties = {};
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.MetricsCount = 0;
metricsSetParams.SymbolName = "Metric set name";
metricsSetParams.ShortName = "Metric set description";
metricsSetParams.RawReportSize = 256;
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, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsConcurrentGroup, OpenIoStream(_, _, _, _))
.Times(subDeviceCount)
.WillRepeatedly(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(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupProperties.domain, 0u);
EXPECT_EQ(metricGroupProperties.samplingType, ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED);
EXPECT_EQ(metricGroupProperties.metricCount, metricsSetParams.MetricsCount);
EXPECT_EQ(strcmp(metricGroupProperties.description, metricsSetParams.ShortName), 0);
EXPECT_EQ(strcmp(metricGroupProperties.name, metricsSetParams.SymbolName), 0);
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);
EXPECT_EQ(zetMetricStreamerClose(streamerHandle), ZE_RESULT_SUCCESS);
}
TEST_F(MetricStreamerMultiDeviceTest, givenValidArgumentsWhenZetMetricStreamerOpenIsCalledAndOpenIoStreamFailsThenReturnsFail) {
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.MetricsCount = 0;
metricsSetParams.SymbolName = "Metric set name";
metricsSetParams.ShortName = "Metric set description";
metricsSetParams.RawReportSize = 256;
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, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsConcurrentGroup, OpenIoStream(_, _, _, _))
.Times(subDeviceCount)
.WillOnce(Return(TCompletionCode::CC_OK))
.WillRepeatedly(Return(TCompletionCode::CC_ERROR_GENERAL));
uint32_t metricGroupCount = 0;
EXPECT_EQ(zetMetricGroupGet(metricDeviceHandle, &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(zetMetricGroupGet(metricDeviceHandle, &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(zetContextActivateMetricGroups(context->toHandle(), metricDeviceHandle, 1, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(zetMetricStreamerOpen(context->toHandle(), metricDeviceHandle, metricGroupHandle, &streamerDesc, eventHandle, &streamerHandle), ZE_RESULT_ERROR_UNKNOWN);
EXPECT_EQ(streamerHandle, nullptr);
}
TEST_F(MetricStreamerMultiDeviceTest, givenValidArgumentsAndCloseIoStreamFailsWhenzetMetricStreamerCloseIsCalledThenReturnsFail) {
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();
zet_metric_group_properties_t metricGroupProperties = {};
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.MetricsCount = 0;
metricsSetParams.SymbolName = "Metric set name";
metricsSetParams.ShortName = "Metric set description";
metricsSetParams.RawReportSize = 256;
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, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsConcurrentGroup, OpenIoStream(_, _, _, _))
.Times(subDeviceCount)
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsConcurrentGroup, CloseIoStream())
.Times(subDeviceCount)
.WillRepeatedly(Return(TCompletionCode::CC_ERROR_GENERAL));
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(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupProperties.domain, 0u);
EXPECT_EQ(metricGroupProperties.samplingType, ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED);
EXPECT_EQ(metricGroupProperties.metricCount, metricsSetParams.MetricsCount);
EXPECT_EQ(strcmp(metricGroupProperties.description, metricsSetParams.ShortName), 0);
EXPECT_EQ(strcmp(metricGroupProperties.name, metricsSetParams.SymbolName), 0);
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);
EXPECT_EQ(zetMetricStreamerClose(streamerHandle), ZE_RESULT_ERROR_UNKNOWN);
cleanup(metricDeviceHandle, streamerHandle);
}
TEST_F(MetricStreamerMultiDeviceTest, givenValidArgumentsWhenZetMetricStreamerOpenIsCalledThenVerifyEventQueryStatusIsSuccess) {
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_pool_handle_t eventPoolHandle = {};
ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.count = 1;
eventPoolDesc.flags = 0;
eventPoolDesc.stype = ZE_STRUCTURE_TYPE_EVENT_POOL_DESC;
ze_event_handle_t eventHandle = {};
ze_event_desc_t eventDesc = {};
eventDesc.index = 0;
eventDesc.stype = ZE_STRUCTURE_TYPE_EVENT_DESC;
eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
eventDesc.signal = ZE_EVENT_SCOPE_FLAG_DEVICE;
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.MetricsCount = 0;
metricsSetParams.SymbolName = "Metric set name";
metricsSetParams.ShortName = "Metric set description";
metricsSetParams.RawReportSize = 256;
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, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsConcurrentGroup, OpenIoStream(_, _, _, _))
.Times(subDeviceCount)
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsConcurrentGroup, CloseIoStream())
.Times(subDeviceCount)
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsConcurrentGroup, WaitForReports(_))
.Times(subDeviceCount)
.WillOnce(Return(TCompletionCode::CC_ERROR_GENERAL))
.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(zeEventPoolCreate(context->toHandle(), &eventPoolDesc, 1, &metricDeviceHandle, &eventPoolHandle), ZE_RESULT_SUCCESS);
EXPECT_NE(eventPoolHandle, nullptr);
EXPECT_EQ(zeEventCreate(eventPoolHandle, &eventDesc, &eventHandle), ZE_RESULT_SUCCESS);
EXPECT_NE(eventHandle, nullptr);
EXPECT_EQ(zetMetricStreamerOpen(context->toHandle(), metricDeviceHandle, metricGroupHandle, &streamerDesc, eventHandle, &streamerHandle), ZE_RESULT_SUCCESS);
EXPECT_NE(streamerHandle, nullptr);
EXPECT_EQ(zeEventQueryStatus(eventHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(zetMetricStreamerClose(streamerHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(zeEventDestroy(eventHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(zeEventPoolDestroy(eventPoolHandle), ZE_RESULT_SUCCESS);
}
TEST_F(MetricStreamerMultiDeviceTest, givenValidArgumentsWhenZetMetricStreamerReadDataIsCalledThenReturnsSuccess) {
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.MetricsCount = 0;
metricsSetParams.SymbolName = "Metric set name";
metricsSetParams.ShortName = "Metric set description";
metricsSetParams.RawReportSize = 256;
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, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsConcurrentGroup, OpenIoStream(_, _, _, _))
.Times(subDeviceCount)
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsConcurrentGroup, ReadIoStream(_, _, _))
.Times(subDeviceCount)
.WillRepeatedly(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);
EXPECT_EQ(zetMetricStreamerClose(streamerHandle), ZE_RESULT_SUCCESS);
}
TEST_F(MetricStreamerMultiDeviceTest, givenMultipleMarkerInsertionsWhenZetCommandListAppendMetricStreamerMarkerIsCalledThenReturnsSuccess) {
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 = {};
ze_result_t returnValue;
std::unique_ptr<L0::CommandList> commandList(CommandList::create(productFamily, devices[0], NEO::EngineGroupType::RenderCompute, 0u, returnValue));
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();
zet_metric_group_properties_t metricGroupProperties = {};
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.MetricsCount = 0;
metricsSetParams.SymbolName = "Metric set name";
metricsSetParams.ShortName = "Metric set description";
metricsSetParams.RawReportSize = 256;
TypedValue_1_0 value = {};
value.Type = ValueType::Uint32;
value.ValueUInt32 = 64;
ContextHandle_1_0 contextHandle = {&value};
CommandBufferSize_1_0 commandBufferSize = {};
commandBufferSize.GpuMemorySize = 100;
openMetricsAdapter();
EXPECT_CALL(*mockMetricEnumerationSubDevices[0], isInitialized())
.Times(1)
.WillOnce(Return(true));
EXPECT_CALL(*mockMetricsLibrarySubDevices[0]->g_mockApi, MockCommandBufferGetSize(_, _))
.Times(10)
.WillRepeatedly(DoAll(::testing::SetArgPointee<1>(::testing::ByRef(commandBufferSize)), Return(StatusCode::Success)));
EXPECT_CALL(*mockMetricsLibrarySubDevices[0]->g_mockApi, MockCommandBufferGet(_))
.Times(10)
.WillRepeatedly(Return(StatusCode::Success));
EXPECT_CALL(*mockMetricsLibrarySubDevices[0], getContextData(_, _))
.Times(1)
.WillOnce(Return(true));
EXPECT_CALL(*mockMetricsLibrarySubDevices[0]->g_mockApi, MockContextCreate(_, _, _))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<2>(contextHandle), Return(StatusCode::Success)));
EXPECT_CALL(*mockMetricsLibrarySubDevices[0]->g_mockApi, MockContextDelete(_))
.Times(1)
.WillOnce(Return(StatusCode::Success));
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, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsConcurrentGroup, OpenIoStream(_, _, _, _))
.Times(subDeviceCount)
.WillRepeatedly(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(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_SUCCESS);
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);
std::array<uint32_t, 10> markerValues = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
for (auto &markerValue : markerValues) {
EXPECT_EQ(zetCommandListAppendMetricStreamerMarker(commandList->toHandle(), streamerHandle, markerValue), ZE_RESULT_SUCCESS);
}
EXPECT_EQ(zetMetricStreamerClose(streamerHandle), ZE_RESULT_SUCCESS);
}
} // namespace ult
} // namespace L0

907
level_zero/tools/test/unit_tests/sources/metrics/test_metric_streamer_2.cpp Normal file
View File

@ -0,0 +1,907 @@
/*
* Copyright (C) 2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "test.h"
#include "level_zero/core/test/unit_tests/mocks/mock_cmdlist.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 MetricStreamerMultiDeviceTest = Test<MetricStreamerMultiDeviceContextFixture>;
TEST_F(MetricStreamerMultiDeviceTest, givenInvalidMetricGroupTypeWhenZetMetricStreamerOpenIsCalledThenReturnsFail) {
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();
zet_metric_group_properties_t metricGroupProperties = {};
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.RawReportSize = 256;
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, SetApiFiltering(_))
.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(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);
EXPECT_EQ(zetContextActivateMetricGroups(context->toHandle(), metricDeviceHandle, 1, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(zetMetricStreamerOpen(context->toHandle(), metricDeviceHandle, metricGroupHandle, &streamerDesc, eventHandle, &streamerHandle), ZE_RESULT_ERROR_INVALID_ARGUMENT);
EXPECT_EQ(streamerHandle, nullptr);
}
TEST_F(MetricStreamerMultiDeviceTest, givenValidArgumentsWhenZetMetricStreamerOpenIsCalledThenReturnsSuccess) {
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();
zet_metric_group_properties_t metricGroupProperties = {};
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.MetricsCount = 0;
metricsSetParams.SymbolName = "Metric set name";
metricsSetParams.ShortName = "Metric set description";
metricsSetParams.RawReportSize = 256;
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, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsConcurrentGroup, OpenIoStream(_, _, _, _))
.Times(subDeviceCount)
.WillRepeatedly(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(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupProperties.domain, 0u);
EXPECT_EQ(metricGroupProperties.samplingType, ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED);
EXPECT_EQ(metricGroupProperties.metricCount, metricsSetParams.MetricsCount);
EXPECT_EQ(strcmp(metricGroupProperties.description, metricsSetParams.ShortName), 0);
EXPECT_EQ(strcmp(metricGroupProperties.name, metricsSetParams.SymbolName), 0);
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);
EXPECT_EQ(zetMetricStreamerClose(streamerHandle), ZE_RESULT_SUCCESS);
}
TEST_F(MetricStreamerMultiDeviceTest, givenEnableWalkerPartitionIsOnWhenZetMetricStreamerOpenIsCalledThenReturnsSuccess) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableWalkerPartition.set(1);
auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
zet_device_handle_t metricDeviceHandle = deviceImp.subDevices[0]->toHandle();
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();
zet_metric_group_properties_t metricGroupProperties = {};
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.MetricsCount = 0;
metricsSetParams.SymbolName = "Metric set name";
metricsSetParams.ShortName = "Metric set description";
metricsSetParams.RawReportSize = 256;
EXPECT_CALL(*mockMetricEnumerationSubDevices[0], loadMetricsDiscovery())
.Times(0);
EXPECT_CALL(*mockMetricEnumerationSubDevices[0]->g_mockApi, MockOpenAdapterGroup(_))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<0>(&adapterGroup), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(adapter, OpenMetricsDevice(_))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<0>(&metricsDevice), Return(TCompletionCode::CC_OK)));
EXPECT_CALL(adapter, CloseMetricsDevice(_))
.Times(1)
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(adapterGroup, GetAdapter(_))
.Times(0);
EXPECT_CALL(*mockMetricEnumerationSubDevices[0], getMetricsAdapter())
.Times(1)
.WillOnce(Return(&adapter));
EXPECT_CALL(adapterGroup, Close())
.Times(1)
.WillOnce(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
.Times(1)
.WillRepeatedly(Return(&metricsConcurrentGroup));
EXPECT_CALL(metricsConcurrentGroup, GetParams())
.Times(1)
.WillRepeatedly(Return(&metricsConcurrentGroupParams));
EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
.WillRepeatedly(Return(&metricsSet));
EXPECT_CALL(metricsSet, GetParams())
.WillRepeatedly(Return(&metricsSetParams));
EXPECT_CALL(metricsSet, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsConcurrentGroup, OpenIoStream(_, _, _, _))
.Times(1)
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsConcurrentGroup, CloseIoStream())
.Times(1)
.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(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupProperties.domain, 0u);
EXPECT_EQ(metricGroupProperties.samplingType, ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED);
EXPECT_EQ(metricGroupProperties.metricCount, metricsSetParams.MetricsCount);
EXPECT_EQ(strcmp(metricGroupProperties.description, metricsSetParams.ShortName), 0);
EXPECT_EQ(strcmp(metricGroupProperties.name, metricsSetParams.SymbolName), 0);
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);
EXPECT_EQ(zetMetricStreamerClose(streamerHandle), ZE_RESULT_SUCCESS);
}
TEST_F(MetricStreamerMultiDeviceTest, givenValidArgumentsWhenZetMetricStreamerOpenIsCalledAndOpenIoStreamFailsThenReturnsFail) {
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.MetricsCount = 0;
metricsSetParams.SymbolName = "Metric set name";
metricsSetParams.ShortName = "Metric set description";
metricsSetParams.RawReportSize = 256;
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, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsConcurrentGroup, OpenIoStream(_, _, _, _))
.Times(subDeviceCount)
.WillOnce(Return(TCompletionCode::CC_OK))
.WillRepeatedly(Return(TCompletionCode::CC_ERROR_GENERAL));
uint32_t metricGroupCount = 0;
EXPECT_EQ(zetMetricGroupGet(metricDeviceHandle, &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(zetMetricGroupGet(metricDeviceHandle, &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(zetContextActivateMetricGroups(context->toHandle(), metricDeviceHandle, 1, &metricGroupHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(zetMetricStreamerOpen(context->toHandle(), metricDeviceHandle, metricGroupHandle, &streamerDesc, eventHandle, &streamerHandle), ZE_RESULT_ERROR_UNKNOWN);
EXPECT_EQ(streamerHandle, nullptr);
}
TEST_F(MetricStreamerMultiDeviceTest, givenValidArgumentsAndCloseIoStreamFailsWhenzetMetricStreamerCloseIsCalledThenReturnsFail) {
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();
zet_metric_group_properties_t metricGroupProperties = {};
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.MetricsCount = 0;
metricsSetParams.SymbolName = "Metric set name";
metricsSetParams.ShortName = "Metric set description";
metricsSetParams.RawReportSize = 256;
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, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsConcurrentGroup, OpenIoStream(_, _, _, _))
.Times(subDeviceCount)
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsConcurrentGroup, CloseIoStream())
.Times(subDeviceCount)
.WillRepeatedly(Return(TCompletionCode::CC_ERROR_GENERAL));
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(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_SUCCESS);
EXPECT_EQ(metricGroupProperties.domain, 0u);
EXPECT_EQ(metricGroupProperties.samplingType, ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED);
EXPECT_EQ(metricGroupProperties.metricCount, metricsSetParams.MetricsCount);
EXPECT_EQ(strcmp(metricGroupProperties.description, metricsSetParams.ShortName), 0);
EXPECT_EQ(strcmp(metricGroupProperties.name, metricsSetParams.SymbolName), 0);
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);
EXPECT_EQ(zetMetricStreamerClose(streamerHandle), ZE_RESULT_ERROR_UNKNOWN);
cleanup(metricDeviceHandle, streamerHandle);
}
TEST_F(MetricStreamerMultiDeviceTest, givenValidArgumentsWhenZetMetricStreamerOpenIsCalledThenVerifyEventQueryStatusIsSuccess) {
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_pool_handle_t eventPoolHandle = {};
ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.count = 1;
eventPoolDesc.flags = 0;
eventPoolDesc.stype = ZE_STRUCTURE_TYPE_EVENT_POOL_DESC;
ze_event_handle_t eventHandle = {};
ze_event_desc_t eventDesc = {};
eventDesc.index = 0;
eventDesc.stype = ZE_STRUCTURE_TYPE_EVENT_DESC;
eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
eventDesc.signal = ZE_EVENT_SCOPE_FLAG_DEVICE;
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.MetricsCount = 0;
metricsSetParams.SymbolName = "Metric set name";
metricsSetParams.ShortName = "Metric set description";
metricsSetParams.RawReportSize = 256;
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, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsConcurrentGroup, OpenIoStream(_, _, _, _))
.Times(subDeviceCount)
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsConcurrentGroup, CloseIoStream())
.Times(subDeviceCount)
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsConcurrentGroup, WaitForReports(_))
.Times(subDeviceCount)
.WillOnce(Return(TCompletionCode::CC_ERROR_GENERAL))
.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(zeEventPoolCreate(context->toHandle(), &eventPoolDesc, 1, &metricDeviceHandle, &eventPoolHandle), ZE_RESULT_SUCCESS);
EXPECT_NE(eventPoolHandle, nullptr);
EXPECT_EQ(zeEventCreate(eventPoolHandle, &eventDesc, &eventHandle), ZE_RESULT_SUCCESS);
EXPECT_NE(eventHandle, nullptr);
EXPECT_EQ(zetMetricStreamerOpen(context->toHandle(), metricDeviceHandle, metricGroupHandle, &streamerDesc, eventHandle, &streamerHandle), ZE_RESULT_SUCCESS);
EXPECT_NE(streamerHandle, nullptr);
EXPECT_EQ(zeEventQueryStatus(eventHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(zetMetricStreamerClose(streamerHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(zeEventDestroy(eventHandle), ZE_RESULT_SUCCESS);
EXPECT_EQ(zeEventPoolDestroy(eventPoolHandle), ZE_RESULT_SUCCESS);
}
TEST_F(MetricStreamerMultiDeviceTest, givenValidArgumentsWhenZetMetricStreamerReadDataIsCalledThenReturnsSuccess) {
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.MetricsCount = 0;
metricsSetParams.SymbolName = "Metric set name";
metricsSetParams.ShortName = "Metric set description";
metricsSetParams.RawReportSize = 256;
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, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsConcurrentGroup, OpenIoStream(_, _, _, _))
.Times(subDeviceCount)
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsConcurrentGroup, ReadIoStream(_, _, _))
.Times(subDeviceCount)
.WillRepeatedly(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);
EXPECT_EQ(zetMetricStreamerClose(streamerHandle), ZE_RESULT_SUCCESS);
}
TEST_F(MetricStreamerMultiDeviceTest, givenMultipleMarkerInsertionsWhenZetCommandListAppendMetricStreamerMarkerIsCalledThenReturnsSuccess) {
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 = {};
ze_result_t returnValue;
std::unique_ptr<L0::CommandList> commandList(CommandList::create(productFamily, devices[0], NEO::EngineGroupType::RenderCompute, 0u, returnValue));
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();
zet_metric_group_properties_t metricGroupProperties = {};
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.MetricsCount = 0;
metricsSetParams.SymbolName = "Metric set name";
metricsSetParams.ShortName = "Metric set description";
metricsSetParams.RawReportSize = 256;
TypedValue_1_0 value = {};
value.Type = ValueType::Uint32;
value.ValueUInt32 = 64;
ContextHandle_1_0 contextHandle = {&value};
CommandBufferSize_1_0 commandBufferSize = {};
commandBufferSize.GpuMemorySize = 100;
openMetricsAdapter();
EXPECT_CALL(*mockMetricEnumerationSubDevices[0], isInitialized())
.Times(1)
.WillOnce(Return(true));
EXPECT_CALL(*mockMetricsLibrarySubDevices[0]->g_mockApi, MockCommandBufferGetSize(_, _))
.Times(10)
.WillRepeatedly(DoAll(::testing::SetArgPointee<1>(::testing::ByRef(commandBufferSize)), Return(StatusCode::Success)));
EXPECT_CALL(*mockMetricsLibrarySubDevices[0]->g_mockApi, MockCommandBufferGet(_))
.Times(10)
.WillRepeatedly(Return(StatusCode::Success));
EXPECT_CALL(*mockMetricsLibrarySubDevices[0], getContextData(_, _))
.Times(1)
.WillOnce(Return(true));
EXPECT_CALL(*mockMetricsLibrarySubDevices[0]->g_mockApi, MockContextCreate(_, _, _))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<2>(contextHandle), Return(StatusCode::Success)));
EXPECT_CALL(*mockMetricsLibrarySubDevices[0]->g_mockApi, MockContextDelete(_))
.Times(1)
.WillOnce(Return(StatusCode::Success));
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, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsConcurrentGroup, OpenIoStream(_, _, _, _))
.Times(subDeviceCount)
.WillRepeatedly(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(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_SUCCESS);
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);
std::array<uint32_t, 10> markerValues = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
for (auto &markerValue : markerValues) {
EXPECT_EQ(zetCommandListAppendMetricStreamerMarker(commandList->toHandle(), streamerHandle, markerValue), ZE_RESULT_SUCCESS);
}
EXPECT_EQ(zetMetricStreamerClose(streamerHandle), ZE_RESULT_SUCCESS);
}
TEST_F(MetricStreamerMultiDeviceTest, givenEnableWalkerPartitionIsOnWhenZetCommandListAppendMetricStreamerMarkerIsCalledForSubDeviceThenReturnsSuccess) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableWalkerPartition.set(1);
auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
zet_device_handle_t metricDeviceHandle = deviceImp.subDevices[0]->toHandle();
ze_event_handle_t eventHandle = {};
ze_result_t returnValue;
std::unique_ptr<L0::CommandList> commandList(CommandList::create(productFamily, deviceImp.subDevices[0], NEO::EngineGroupType::RenderCompute, 0u, returnValue));
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();
zet_metric_group_properties_t metricGroupProperties = {};
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.MetricsCount = 0;
metricsSetParams.SymbolName = "Metric set name";
metricsSetParams.ShortName = "Metric set description";
metricsSetParams.RawReportSize = 256;
TypedValue_1_0 value = {};
value.Type = ValueType::Uint32;
value.ValueUInt32 = 64;
ContextHandle_1_0 contextHandle = {&value};
CommandBufferSize_1_0 commandBufferSize = {};
commandBufferSize.GpuMemorySize = 100;
openMetricsAdapterSubDevice(0);
EXPECT_CALL(*mockMetricEnumerationSubDevices[0], isInitialized())
.Times(1)
.WillOnce(Return(true));
EXPECT_CALL(*mockMetricsLibrarySubDevices[0]->g_mockApi, MockCommandBufferGetSize(_, _))
.Times(10)
.WillRepeatedly(DoAll(::testing::SetArgPointee<1>(::testing::ByRef(commandBufferSize)), Return(StatusCode::Success)));
EXPECT_CALL(*mockMetricsLibrarySubDevices[0]->g_mockApi, MockCommandBufferGet(_))
.Times(10)
.WillRepeatedly(Return(StatusCode::Success));
EXPECT_CALL(*mockMetricsLibrarySubDevices[0], getContextData(_, _))
.Times(1)
.WillOnce(Return(true));
EXPECT_CALL(*mockMetricsLibrarySubDevices[0]->g_mockApi, MockContextCreate(_, _, _))
.Times(1)
.WillOnce(DoAll(::testing::SetArgPointee<2>(contextHandle), Return(StatusCode::Success)));
EXPECT_CALL(*mockMetricsLibrarySubDevices[0]->g_mockApi, MockContextDelete(_))
.Times(1)
.WillOnce(Return(StatusCode::Success));
EXPECT_CALL(metricsDevice, GetParams())
.WillRepeatedly(Return(&metricsDeviceParams));
EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
.Times(1)
.WillRepeatedly(Return(&metricsConcurrentGroup));
EXPECT_CALL(metricsConcurrentGroup, GetParams())
.Times(1)
.WillRepeatedly(Return(&metricsConcurrentGroupParams));
EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
.WillRepeatedly(Return(&metricsSet));
EXPECT_CALL(metricsSet, GetParams())
.WillRepeatedly(Return(&metricsSetParams));
EXPECT_CALL(metricsSet, SetApiFiltering(_))
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsConcurrentGroup, OpenIoStream(_, _, _, _))
.Times(1)
.WillRepeatedly(Return(TCompletionCode::CC_OK));
EXPECT_CALL(metricsConcurrentGroup, CloseIoStream())
.Times(1)
.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(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_SUCCESS);
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);
std::array<uint32_t, 10> markerValues = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
for (auto &markerValue : markerValues) {
EXPECT_EQ(zetCommandListAppendMetricStreamerMarker(commandList->toHandle(), streamerHandle, markerValue), ZE_RESULT_SUCCESS);
}
EXPECT_EQ(zetMetricStreamerClose(streamerHandle), ZE_RESULT_SUCCESS);
}
} // namespace ult
} // namespace L0