Skip to content

Commit 5ac77d2

Browse files
narenbagrianarenbagria
authored
fix: assert if metric query pool is absent (#163)
Related to VLCLJ-2425 Signed-off-by: Bagria, Narendra <[email protected]>
1 parent c42bff7 commit 5ac77d2

File tree

1 file changed

+96
-72
lines changed

1 file changed

+96
-72
lines changed

‎conformance_tests/tools/metrics/src/test_metric.cpp‎

Lines changed: 96 additions & 72 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
/*
22
*
3-
* Copyright (C) 2020-2024 Intel Corporation
3+
* Copyright (C) 2020-2025 Intel Corporation
44
*
55
* SPDX-License-Identifier: MIT
66
*
@@ -457,8 +457,8 @@ TEST_F(
457457

458458
class zetMetricQueryTest : public zetMetricGroupTest {
459459
protected:
460-
zet_metric_query_pool_handle_t metricQueryPoolHandle{};
461-
zet_metric_query_handle_t metricQueryHandle{};
460+
zet_metric_query_pool_handle_t metric_query_pool_handle{};
461+
zet_metric_query_handle_t metric_query_handle{};
462462

463463
std::vector<std::string> groupNameList;
464464
zet_metric_group_handle_t matchedGroupHandle{};
@@ -473,40 +473,43 @@ class zetMetricQueryTest : public zetMetricGroupTest {
473473
matchedGroupHandle = lzt::find_metric_group(
474474
device, groupName, ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED);
475475
ASSERT_NE(nullptr, matchedGroupHandle);
476-
metricQueryPoolHandle = lzt::create_metric_query_pool(
476+
metric_query_pool_handle = lzt::create_metric_query_pool(
477477
1000, ZET_METRIC_QUERY_POOL_TYPE_PERFORMANCE, matchedGroupHandle);
478-
ASSERT_NE(nullptr, metricQueryPoolHandle);
479-
metricQueryHandle = lzt::metric_query_create(metricQueryPoolHandle);
478+
ASSERT_NE(nullptr, metric_query_pool_handle)
479+
<< "failed to create metric query pool handle";
480+
metric_query_handle = lzt::metric_query_create(metric_query_pool_handle);
481+
ASSERT_NE(nullptr, metric_query_handle)
482+
<< "failed to create metric query handle";
480483
}
481484

482485
void TearDown() override {
483-
if (metricQueryHandle != nullptr) {
484-
lzt::destroy_metric_query(metricQueryHandle);
486+
if (metric_query_handle != nullptr) {
487+
lzt::destroy_metric_query(metric_query_handle);
485488
}
486-
if (metricQueryPoolHandle != nullptr) {
487-
lzt::destroy_metric_query_pool(metricQueryPoolHandle);
489+
if (metric_query_pool_handle != nullptr) {
490+
lzt::destroy_metric_query_pool(metric_query_pool_handle);
488491
}
489492
}
490493
};
491494

492495
TEST_F(
493496
zetMetricQueryTest,
494497
GivenValidMetricQueryPoolWhenValidMetricGroupIsPassedThenExpectQueryHandle) {
495-
EXPECT_NE(nullptr, metricQueryHandle);
498+
EXPECT_NE(nullptr, metric_query_handle);
496499
}
497500

498501
TEST_F(zetMetricQueryTest,
499502
GivenValidMetricQueryHandleWhenResettingQueryHandleThenExpectSuccess) {
500-
lzt::reset_metric_query(metricQueryHandle);
503+
lzt::reset_metric_query(metric_query_handle);
501504
}
502505

503506
TEST_F(
504507
zetMetricQueryTest,
505508
GivenOnlyMetricQueryWhenCommandListIsCreatedThenExpectCommandListToExecuteSuccessfully) {
506509
zet_command_list_handle_t commandList = lzt::create_command_list();
507510
lzt::activate_metric_groups(device, 1, &matchedGroupHandle);
508-
lzt::append_metric_query_begin(commandList, metricQueryHandle);
509-
lzt::append_metric_query_end(commandList, metricQueryHandle, nullptr);
511+
lzt::append_metric_query_begin(commandList, metric_query_handle);
512+
lzt::append_metric_query_end(commandList, metric_query_handle, nullptr);
510513
lzt::close_command_list(commandList);
511514
ze_command_queue_handle_t commandQueue = lzt::create_command_queue();
512515
lzt::execute_command_lists(commandQueue, 1, &commandList, nullptr);
@@ -521,9 +524,9 @@ TEST_F(
521524
GivenOnlyMetricQueryWithMetricMemoryBarrierWhenCommandListIsCreatedThenExpectCommandListToExecuteSucessfully) {
522525
zet_command_list_handle_t commandList = lzt::create_command_list();
523526
lzt::activate_metric_groups(device, 1, &matchedGroupHandle);
524-
lzt::append_metric_query_begin(commandList, metricQueryHandle);
527+
lzt::append_metric_query_begin(commandList, metric_query_handle);
525528
lzt::append_metric_memory_barrier(commandList);
526-
lzt::append_metric_query_end(commandList, metricQueryHandle, nullptr);
529+
lzt::append_metric_query_end(commandList, metric_query_handle, nullptr);
527530
lzt::close_command_list(commandList);
528531
ze_command_queue_handle_t commandQueue = lzt::create_command_queue();
529532
lzt::execute_command_lists(commandQueue, 1, &commandList, nullptr);
@@ -570,16 +573,19 @@ TEST_F(
570573
for (auto groupInfo : metricGroupInfo) {
571574

572575
LOG_INFO << "test metricGroup name " << groupInfo.metricGroupName;
573-
zet_metric_query_pool_handle_t metricQueryPoolHandle =
576+
zet_metric_query_pool_handle_t metric_query_pool_handle =
574577
lzt::create_metric_query_pool_for_device(
575578
device, 1000, ZET_METRIC_QUERY_POOL_TYPE_PERFORMANCE,
576579
groupInfo.metricGroupHandle);
577-
578-
zet_metric_query_handle_t metricQueryHandle =
579-
lzt::metric_query_create(metricQueryPoolHandle);
580+
ASSERT_NE(nullptr, metric_query_pool_handle)
581+
<< "failed to create metric query pool handle";
582+
zet_metric_query_handle_t metric_query_handle =
583+
lzt::metric_query_create(metric_query_pool_handle);
584+
ASSERT_NE(nullptr, metric_query_handle)
585+
<< "failed to create metric query handle";
580586

581587
lzt::activate_metric_groups(device, 1, &groupInfo.metricGroupHandle);
582-
lzt::append_metric_query_begin(commandList, metricQueryHandle);
588+
lzt::append_metric_query_begin(commandList, metric_query_handle);
583589
lzt::append_barrier(commandList, nullptr, 0, nullptr);
584590
ze_event_handle_t eventHandle;
585591
lzt::zeEventPool eventPool;
@@ -594,7 +600,8 @@ TEST_F(
594600
zeCommandListAppendLaunchKernel(commandList, function, &tg, nullptr, 0,
595601
nullptr);
596602
lzt::append_barrier(commandList, nullptr, 0, nullptr);
597-
lzt::append_metric_query_end(commandList, metricQueryHandle, eventHandle);
603+
lzt::append_metric_query_end(commandList, metric_query_handle,
604+
eventHandle);
598605

599606
lzt::close_command_list(commandList);
600607
lzt::execute_command_lists(commandQueue, 1, &commandList, nullptr);
@@ -604,11 +611,11 @@ TEST_F(
604611
EXPECT_EQ(ZE_RESULT_SUCCESS, zeEventQueryStatus(eventHandle));
605612
std::vector<uint8_t> rawData;
606613

607-
lzt::metric_query_get_data(metricQueryHandle, &rawData);
614+
lzt::metric_query_get_data(metric_query_handle, &rawData);
608615

609616
eventPool.destroy_event(eventHandle);
610-
lzt::destroy_metric_query(metricQueryHandle);
611-
lzt::destroy_metric_query_pool(metricQueryPoolHandle);
617+
lzt::destroy_metric_query(metric_query_handle);
618+
lzt::destroy_metric_query_pool(metric_query_pool_handle);
612619

613620
lzt::deactivate_metric_groups(device);
614621
lzt::destroy_function(function);
@@ -666,16 +673,19 @@ void run_test(const ze_device_handle_t &device,
666673
for (auto groupInfo : metricGroupInfo) {
667674
LOG_INFO << "test metricGroup name " << groupInfo.metricGroupName;
668675

669-
zet_metric_query_pool_handle_t metricQueryPoolHandle =
676+
zet_metric_query_pool_handle_t metric_query_pool_handle =
670677
lzt::create_metric_query_pool_for_device(
671678
device, 1000, ZET_METRIC_QUERY_POOL_TYPE_PERFORMANCE,
672679
groupInfo.metricGroupHandle);
673-
674-
zet_metric_query_handle_t metricQueryHandle =
675-
lzt::metric_query_create(metricQueryPoolHandle);
680+
ASSERT_NE(nullptr, metric_query_pool_handle)
681+
<< "failed to create metric query pool handle";
682+
zet_metric_query_handle_t metric_query_handle =
683+
lzt::metric_query_create(metric_query_pool_handle);
684+
ASSERT_NE(nullptr, metric_query_handle)
685+
<< "failed to create metric query handle";
676686

677687
lzt::activate_metric_groups(device, 1, &groupInfo.metricGroupHandle);
678-
lzt::append_metric_query_begin(commandList, metricQueryHandle);
688+
lzt::append_metric_query_begin(commandList, metric_query_handle);
679689
lzt::append_barrier(commandList, nullptr, 0, nullptr);
680690
ze_event_handle_t eventHandle, wait_event_handle;
681691
lzt::zeEventPool eventPool;
@@ -694,11 +704,12 @@ void run_test(const ze_device_handle_t &device,
694704
nullptr);
695705

696706
if (wait_event) {
697-
lzt::append_metric_query_end(commandList, metricQueryHandle, eventHandle,
698-
1, &wait_event_handle);
707+
lzt::append_metric_query_end(commandList, metric_query_handle,
708+
eventHandle, 1, &wait_event_handle);
699709
} else {
700710
lzt::append_barrier(commandList);
701-
lzt::append_metric_query_end(commandList, metricQueryHandle, eventHandle);
711+
lzt::append_metric_query_end(commandList, metric_query_handle,
712+
eventHandle);
702713
}
703714

704715
lzt::close_command_list(commandList);
@@ -714,15 +725,15 @@ void run_test(const ze_device_handle_t &device,
714725
}
715726

716727
std::vector<uint8_t> rawData;
717-
lzt::metric_query_get_data(metricQueryHandle, &rawData);
728+
lzt::metric_query_get_data(metric_query_handle, &rawData);
718729
lzt::validate_metrics(groupInfo.metricGroupHandle,
719-
lzt::metric_query_get_data_size(metricQueryHandle),
730+
lzt::metric_query_get_data_size(metric_query_handle),
720731
rawData.data());
721732
if (reset && !immediate) {
722-
lzt::reset_metric_query(metricQueryHandle);
733+
lzt::reset_metric_query(metric_query_handle);
723734

724735
lzt::reset_command_list(commandList);
725-
lzt::append_metric_query_begin(commandList, metricQueryHandle);
736+
lzt::append_metric_query_begin(commandList, metric_query_handle);
726737
lzt::append_barrier(commandList, nullptr, 0, nullptr);
727738

728739
// reset buffers
@@ -737,23 +748,24 @@ void run_test(const ze_device_handle_t &device,
737748
zeCommandListAppendLaunchKernel(commandList, function, &tg, nullptr, 0,
738749
nullptr);
739750
lzt::append_barrier(commandList, nullptr, 0, nullptr);
740-
lzt::append_metric_query_end(commandList, metricQueryHandle, eventHandle);
751+
lzt::append_metric_query_end(commandList, metric_query_handle,
752+
eventHandle);
741753
lzt::close_command_list(commandList);
742754
lzt::execute_command_lists(commandQueue, 1, &commandList, nullptr);
743755

744756
lzt::synchronize(commandQueue, UINT64_MAX);
745757

746758
EXPECT_EQ(ZE_RESULT_SUCCESS, zeEventQueryStatus(eventHandle));
747759

748-
lzt::metric_query_get_data(metricQueryHandle, &rawData);
749-
lzt::validate_metrics(groupInfo.metricGroupHandle,
750-
lzt::metric_query_get_data_size(metricQueryHandle),
751-
rawData.data());
760+
lzt::metric_query_get_data(metric_query_handle, &rawData);
761+
lzt::validate_metrics(
762+
groupInfo.metricGroupHandle,
763+
lzt::metric_query_get_data_size(metric_query_handle), rawData.data());
752764
}
753765

754766
eventPool.destroy_event(eventHandle);
755-
lzt::destroy_metric_query(metricQueryHandle);
756-
lzt::destroy_metric_query_pool(metricQueryPoolHandle);
767+
lzt::destroy_metric_query(metric_query_handle);
768+
lzt::destroy_metric_query_pool(metric_query_pool_handle);
757769

758770
lzt::deactivate_metric_groups(device);
759771
lzt::destroy_function(function);
@@ -848,22 +860,30 @@ void run_multi_device_query_load_test(
848860
auto groupInfo_0 = metric_group_info_0[0];
849861
auto groupInfo_1 = metric_group_info_1[0];
850862

851-
auto metricQueryPoolHandle_0 = lzt::create_metric_query_pool_for_device(
863+
auto metric_query_pool_handle_0 = lzt::create_metric_query_pool_for_device(
852864
device_0, 1000, ZET_METRIC_QUERY_POOL_TYPE_PERFORMANCE,
853865
groupInfo_0.metricGroupHandle);
854-
855-
auto metricQueryPoolHandle_1 = lzt::create_metric_query_pool_for_device(
866+
ASSERT_NE(nullptr, metric_query_pool_handle_0)
867+
<< "failed to create metric query pool handle";
868+
auto metric_query_pool_handle_1 = lzt::create_metric_query_pool_for_device(
856869
device_1, 1000, ZET_METRIC_QUERY_POOL_TYPE_PERFORMANCE,
857870
groupInfo_1.metricGroupHandle);
858-
859-
auto metricQueryHandle_0 = lzt::metric_query_create(metricQueryPoolHandle_0);
860-
auto metricQueryHandle_1 = lzt::metric_query_create(metricQueryPoolHandle_1);
871+
ASSERT_NE(nullptr, metric_query_pool_handle_1)
872+
<< "failed to create metric query pool handle";
873+
auto metric_query_handle_0 =
874+
lzt::metric_query_create(metric_query_pool_handle_0);
875+
ASSERT_NE(nullptr, metric_query_handle_0)
876+
<< "failed to create metric query handle 0";
877+
auto metric_query_handle_1 =
878+
lzt::metric_query_create(metric_query_pool_handle_1);
879+
ASSERT_NE(nullptr, metric_query_handle_1)
880+
<< "failed to create metric query handle 1";
861881

862882
lzt::activate_metric_groups(device_0, 1, &groupInfo_0.metricGroupHandle);
863883
lzt::activate_metric_groups(device_1, 1, &groupInfo_1.metricGroupHandle);
864884

865-
lzt::append_metric_query_begin(command_list_0, metricQueryHandle_0);
866-
lzt::append_metric_query_begin(command_list_1, metricQueryHandle_1);
885+
lzt::append_metric_query_begin(command_list_0, metric_query_handle_0);
886+
lzt::append_metric_query_begin(command_list_1, metric_query_handle_1);
867887

868888
lzt::append_barrier(command_list_0, nullptr, 0, nullptr);
869889
lzt::append_barrier(command_list_1, nullptr, 0, nullptr);
@@ -891,13 +911,13 @@ void run_multi_device_query_load_test(
891911
lzt::append_launch_function(command_list_0, function_0, &tg_0, event_handle_0,
892912
0, nullptr);
893913
lzt::append_barrier(command_list_0);
894-
lzt::append_metric_query_end(command_list_0, metricQueryHandle_0,
914+
lzt::append_metric_query_end(command_list_0, metric_query_handle_0,
895915
event_handle_0);
896916

897917
lzt::append_launch_function(command_list_1, function_1, &tg_1, event_handle_1,
898918
0, nullptr);
899919
lzt::append_barrier(command_list_1);
900-
lzt::append_metric_query_end(command_list_1, metricQueryHandle_1,
920+
lzt::append_metric_query_end(command_list_1, metric_query_handle_1,
901921
event_handle_1);
902922

903923
lzt::close_command_list(command_list_0);
@@ -914,23 +934,23 @@ void run_multi_device_query_load_test(
914934

915935
std::vector<uint8_t> raw_data_0, raw_data_1;
916936

917-
lzt::metric_query_get_data(metricQueryHandle_0, &raw_data_0);
918-
lzt::metric_query_get_data(metricQueryHandle_1, &raw_data_1);
937+
lzt::metric_query_get_data(metric_query_handle_0, &raw_data_0);
938+
lzt::metric_query_get_data(metric_query_handle_1, &raw_data_1);
919939

920940
event_pool.destroy_event(event_handle_0);
921941
event_pool.destroy_event(event_handle_1);
922942

923943
lzt::validate_metrics(groupInfo_0.metricGroupHandle,
924-
lzt::metric_query_get_data_size(metricQueryHandle_0),
944+
lzt::metric_query_get_data_size(metric_query_handle_0),
925945
raw_data_0.data());
926946
lzt::validate_metrics(groupInfo_1.metricGroupHandle,
927-
lzt::metric_query_get_data_size(metricQueryHandle_1),
947+
lzt::metric_query_get_data_size(metric_query_handle_1),
928948
raw_data_1.data());
929949

930-
lzt::destroy_metric_query(metricQueryHandle_0);
931-
lzt::destroy_metric_query(metricQueryHandle_1);
932-
lzt::destroy_metric_query_pool(metricQueryPoolHandle_0);
933-
lzt::destroy_metric_query_pool(metricQueryPoolHandle_1);
950+
lzt::destroy_metric_query(metric_query_handle_0);
951+
lzt::destroy_metric_query(metric_query_handle_1);
952+
lzt::destroy_metric_query_pool(metric_query_pool_handle_0);
953+
lzt::destroy_metric_query_pool(metric_query_pool_handle_1);
934954

935955
lzt::deactivate_metric_groups(device_0);
936956
lzt::deactivate_metric_groups(device_1);
@@ -1012,16 +1032,19 @@ TEST_F(
10121032

10131033
LOG_INFO << "test metricGroup name " << groupInfo.metricGroupName;
10141034

1015-
zet_metric_query_pool_handle_t metricQueryPoolHandle =
1035+
zet_metric_query_pool_handle_t metric_query_pool_handle =
10161036
lzt::create_metric_query_pool_for_device(
10171037
device, 1000, ZET_METRIC_QUERY_POOL_TYPE_PERFORMANCE,
10181038
groupInfo.metricGroupHandle);
1019-
1020-
zet_metric_query_handle_t metricQueryHandle =
1021-
lzt::metric_query_create(metricQueryPoolHandle);
1039+
ASSERT_NE(nullptr, metric_query_pool_handle)
1040+
<< "failed to create metric query pool handle";
1041+
zet_metric_query_handle_t metric_query_handle =
1042+
lzt::metric_query_create(metric_query_pool_handle);
1043+
ASSERT_NE(nullptr, metric_query_handle)
1044+
<< "failed to create metric query handle";
10221045

10231046
lzt::activate_metric_groups(device, 1, &groupInfo.metricGroupHandle);
1024-
lzt::append_metric_query_begin(commandList, metricQueryHandle);
1047+
lzt::append_metric_query_begin(commandList, metric_query_handle);
10251048
lzt::append_barrier(commandList, nullptr, 0, nullptr);
10261049
ze_event_handle_t eventHandle;
10271050
lzt::zeEventPool eventPool;
@@ -1036,7 +1059,8 @@ TEST_F(
10361059
zeCommandListAppendLaunchKernel(commandList, function, &tg, nullptr, 0,
10371060
nullptr);
10381061
lzt::append_barrier(commandList, nullptr, 0, nullptr);
1039-
lzt::append_metric_query_end(commandList, metricQueryHandle, eventHandle);
1062+
lzt::append_metric_query_end(commandList, metric_query_handle,
1063+
eventHandle);
10401064

10411065
lzt::close_command_list(commandList);
10421066
lzt::execute_command_lists(commandQueue, 1, &commandList, nullptr);
@@ -1046,14 +1070,14 @@ TEST_F(
10461070
EXPECT_EQ(ZE_RESULT_SUCCESS, zeEventQueryStatus(eventHandle));
10471071

10481072
std::vector<uint8_t> rawData;
1049-
lzt::metric_query_get_data(metricQueryHandle, &rawData);
1073+
lzt::metric_query_get_data(metric_query_handle, &rawData);
10501074
lzt::validate_metrics_std(
10511075
groupInfo.metricGroupHandle,
1052-
lzt::metric_query_get_data_size(metricQueryHandle), rawData.data());
1076+
lzt::metric_query_get_data_size(metric_query_handle), rawData.data());
10531077

10541078
eventPool.destroy_event(eventHandle);
1055-
lzt::destroy_metric_query(metricQueryHandle);
1056-
lzt::destroy_metric_query_pool(metricQueryPoolHandle);
1079+
lzt::destroy_metric_query(metric_query_handle);
1080+
lzt::destroy_metric_query_pool(metric_query_pool_handle);
10571081

10581082
lzt::deactivate_metric_groups(device);
10591083
lzt::destroy_function(function);

0 commit comments

Comments
 (0)