Skip to content

Commit b9d3934

Browse files
shubskmrshubskmr
authored
fix: Enhance streamer tests (#115)
* fix: Enhance streamer tests Related-To: VLCLJ-2365 Signed-off-by: shubham kumar <shubham.kumar@intel.com> * fix: Enhance streamer tests Related-To: VLCLJ-2365 Signed-off-by: shubham kumar <shubham.kumar@intel.com> * fix: Enhance streamer tests Moved streamer open calls just before execute_command_lists. Removed zeEventQueryStatus() check from streamer tests since they have a dedicated test. Adjusted notifyNReport and samplingPeriod values to minimize the test runtimes. Added a new read function in harness to read specific number of reports. Related-To: VLCLJ-2365 Signed-off-by: shubham kumar <shubham.kumar@intel.com> * fix: Enhance streamer tests Moved streamer open calls just before execute_command_lists. Removed zeEventQueryStatus() check from streamer tests since they have a dedicated test. Adjusted notifyNReport and samplingPeriod values to minimize the test runtimes. Added a new read function in harness to read specific number of reports. Related-To: VLCLJ-2365 Signed-off-by: shubham kumar <shubham.kumar@intel.com> * fix: Enhance streamer tests Moved streamer open calls just before execute_command_lists. Removed zeEventQueryStatus() check from streamer tests since they have a dedicated test. Adjusted notifyNReport and samplingPeriod values to minimize the test runtimes. Added a new read function in harness to read specific number of reports. Related-To: VLCLJ-2365 Signed-off-by: shubham kumar <shubham.kumar@intel.com> --------- Signed-off-by: shubham kumar <shubham.kumar@intel.com>
1 parent eae365f commit b9d3934

File tree

3 files changed

+93
-123
lines changed

3 files changed

+93
-123
lines changed

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

Lines changed: 80 additions & 123 deletions
Original file line numberDiff line numberDiff line change
@@ -1094,45 +1094,25 @@ TEST_F(
10941094
eventPool.create_event(eventHandle, ZE_EVENT_SCOPE_FLAG_HOST,
10951095
ZE_EVENT_SCOPE_FLAG_HOST);
10961096

1097-
zet_metric_streamer_handle_t metricStreamerHandle =
1098-
lzt::metric_streamer_open_for_device(
1099-
device, groupInfo.metricGroupHandle, eventHandle,
1100-
notifyEveryNReports, samplingPeriod);
1101-
ASSERT_NE(nullptr, metricStreamerHandle);
1102-
11031097
void *a_buffer, *b_buffer, *c_buffer;
11041098
ze_group_count_t tg;
11051099
ze_kernel_handle_t function = get_matrix_multiplication_kernel(
11061100
device, &tg, &a_buffer, &b_buffer, &c_buffer);
11071101
zeCommandListAppendLaunchKernel(commandList, function, &tg, nullptr, 0,
11081102
nullptr);
1109-
11101103
lzt::close_command_list(commandList);
1111-
lzt::execute_command_lists(commandQueue, 1, &commandList, nullptr);
1112-
lzt::synchronize(commandQueue, std::numeric_limits<uint64_t>::max());
1113-
ze_result_t eventResult;
1114-
eventResult = zeEventQueryStatus(eventHandle);
11151104

1116-
if (ZE_RESULT_SUCCESS == eventResult) {
1117-
size_t oneReportSize, allReportsSize;
1118-
oneReportSize =
1119-
lzt::metric_streamer_read_data_size(metricStreamerHandle, 1);
1120-
allReportsSize = lzt::metric_streamer_read_data_size(
1121-
metricStreamerHandle, UINT32_MAX);
1122-
LOG_DEBUG << "Event triggered. Single report size: " << oneReportSize
1123-
<< ". All reports size:" << allReportsSize;
1124-
1125-
EXPECT_GE(allReportsSize / oneReportSize, notifyEveryNReports);
1105+
zet_metric_streamer_handle_t metricStreamerHandle =
1106+
lzt::metric_streamer_open_for_device(
1107+
device, groupInfo.metricGroupHandle, eventHandle,
1108+
notifyEveryNReports, samplingPeriod);
1109+
ASSERT_NE(nullptr, metricStreamerHandle);
11261110

1127-
} else if (ZE_RESULT_NOT_READY == eventResult) {
1128-
LOG_WARNING << "wait on event returned ZE_RESULT_NOT_READY";
1129-
} else {
1130-
FAIL() << "zeEventQueryStatus() FAILED with " << eventResult;
1131-
}
1111+
lzt::execute_command_lists(commandQueue, 1, &commandList, nullptr);
1112+
lzt::synchronize(commandQueue, std::numeric_limits<uint64_t>::max());
11321113

11331114
std::vector<uint8_t> rawData;
11341115
lzt::metric_streamer_read_data(metricStreamerHandle, &rawData);
1135-
11361116
lzt::metric_streamer_close(metricStreamerHandle);
11371117
lzt::deactivate_metric_groups(device);
11381118
lzt::destroy_function(function);
@@ -1186,28 +1166,30 @@ TEST_F(
11861166
eventPool.create_event(eventHandle, ZE_EVENT_SCOPE_FLAG_HOST,
11871167
ZE_EVENT_SCOPE_FLAG_HOST);
11881168

1189-
zet_metric_streamer_handle_t metricStreamerHandle =
1190-
lzt::metric_streamer_open_for_device(
1191-
device, groupInfo.metricGroupHandle, eventHandle,
1192-
notifyEveryNReports, samplingPeriod);
1193-
ASSERT_NE(nullptr, metricStreamerHandle);
1194-
11951169
void *a_buffer, *b_buffer, *c_buffer;
11961170
ze_group_count_t tg;
11971171

11981172
ze_kernel_handle_t function = get_matrix_multiplication_kernel(
11991173
device, &tg, &a_buffer, &b_buffer, &c_buffer);
12001174
zeCommandListAppendLaunchKernel(commandList, function, &tg, nullptr, 0,
12011175
nullptr);
1202-
12031176
lzt::close_command_list(commandList);
1204-
lzt::execute_command_lists(commandQueue, 1, &commandList, nullptr);
12051177

1178+
zet_metric_streamer_handle_t metricStreamerHandle =
1179+
lzt::metric_streamer_open_for_device(
1180+
device, groupInfo.metricGroupHandle, eventHandle,
1181+
notifyEveryNReports, samplingPeriod);
1182+
ASSERT_NE(nullptr, metricStreamerHandle);
1183+
1184+
lzt::execute_command_lists(commandQueue, 1, &commandList, nullptr);
12061185
lzt::event_host_synchronize(eventHandle, UINT64_MAX);
1186+
size_t rawDataSize = 0;
12071187
std::vector<uint8_t> rawData;
1208-
uint32_t rawDataSize = 0;
1209-
lzt::metric_streamer_read_data(metricStreamerHandle, rawDataSize,
1210-
&rawData);
1188+
rawDataSize = lzt::metric_streamer_read_data_size(metricStreamerHandle, notifyEveryNReports);
1189+
EXPECT_GT(rawDataSize, 0);
1190+
rawData.resize(rawDataSize);
1191+
lzt::metric_streamer_read_data(metricStreamerHandle, notifyEveryNReports,
1192+
rawDataSize, &rawData);
12111193

12121194
LOG_INFO << "raw data size " << rawDataSize;
12131195
EXPECT_GT(rawDataSize, 0);
@@ -1235,7 +1217,9 @@ TEST_F(
12351217
zetMetricStreamerTest,
12361218
GivenValidMetricGroupWhenTimerBasedStreamerIsCreatedThenExpectStreamerToSucceed) {
12371219

1238-
notifyEveryNReports = 9000;
1220+
// The time in seconds for the buffer to overflow would be 2 * (notifyEveryNReports * (samplingPeriod/nanoSecToSeconds)) for this test it will be 512 seconds
1221+
uint32_t notifyEveryNReports = 256;
1222+
uint32_t samplingPeriod = 1000000000;
12391223
for (auto device : devices) {
12401224

12411225
ze_device_properties_t deviceProperties = {
@@ -1258,60 +1242,41 @@ TEST_F(
12581242
metricGroupInfo = lzt::optimize_metric_group_info_list(metricGroupInfo);
12591243

12601244
for (auto groupInfo : metricGroupInfo) {
1261-
12621245
LOG_INFO << "test metricGroup name " << groupInfo.metricGroupName;
1263-
12641246
lzt::activate_metric_groups(device, 1, &groupInfo.metricGroupHandle);
1265-
12661247
ze_event_handle_t eventHandle;
12671248
lzt::zeEventPool eventPool;
12681249
eventPool.create_event(eventHandle, ZE_EVENT_SCOPE_FLAG_HOST,
12691250
ZE_EVENT_SCOPE_FLAG_HOST);
12701251

1271-
zet_metric_streamer_handle_t metricStreamerHandle =
1272-
lzt::metric_streamer_open_for_device(
1273-
device, groupInfo.metricGroupHandle, eventHandle,
1274-
notifyEveryNReports, samplingPeriod);
1275-
ASSERT_NE(nullptr, metricStreamerHandle);
1276-
12771252
void *a_buffer, *b_buffer, *c_buffer;
12781253
ze_group_count_t tg;
12791254
ze_kernel_handle_t function = get_matrix_multiplication_kernel(
12801255
device, &tg, &a_buffer, &b_buffer, &c_buffer, 8192);
12811256
zeCommandListAppendLaunchKernel(commandList, function, &tg, nullptr, 0,
12821257
nullptr);
1283-
12841258
lzt::close_command_list(commandList);
1285-
lzt::execute_command_lists(commandQueue, 1, &commandList, nullptr);
1286-
lzt::synchronize(commandQueue, std::numeric_limits<uint64_t>::max());
1287-
ze_result_t eventResult;
1288-
eventResult = zeEventQueryStatus(eventHandle);
1289-
1290-
if (ZE_RESULT_SUCCESS == eventResult) {
1291-
size_t oneReportSize, allReportsSize;
1292-
oneReportSize =
1293-
lzt::metric_streamer_read_data_size(metricStreamerHandle, 1);
1294-
allReportsSize = lzt::metric_streamer_read_data_size(
1295-
metricStreamerHandle, UINT32_MAX);
1296-
LOG_DEBUG << "Event triggered. Single report size: " << oneReportSize
1297-
<< ". All reports size:" << allReportsSize;
12981259

1299-
EXPECT_GE(allReportsSize / oneReportSize, notifyEveryNReports);
1260+
zet_metric_streamer_handle_t metricStreamerHandle =
1261+
lzt::metric_streamer_open_for_device(
1262+
device, groupInfo.metricGroupHandle, eventHandle,
1263+
notifyEveryNReports, samplingPeriod);
1264+
ASSERT_NE(nullptr, metricStreamerHandle);
13001265

1301-
} else if (ZE_RESULT_NOT_READY == eventResult) {
1302-
LOG_WARNING << "wait on event returned ZE_RESULT_NOT_READY";
1303-
} else {
1304-
FAIL() << "zeEventQueryStatus() FAILED with " << eventResult;
1305-
}
1266+
lzt::execute_command_lists(commandQueue, 1, &commandList, nullptr);
1267+
lzt::synchronize(commandQueue, std::numeric_limits<uint64_t>::max());
13061268

1269+
size_t rawDataSize = 0;
13071270
std::vector<uint8_t> rawData;
1308-
uint32_t rawDataSize = 0;
1309-
lzt::metric_streamer_read_data(metricStreamerHandle, rawDataSize,
1310-
&rawData);
1271+
rawDataSize = lzt::metric_streamer_read_data_size(metricStreamerHandle, notifyEveryNReports);
1272+
EXPECT_GT(rawDataSize, 0);
1273+
rawData.resize(rawDataSize);
1274+
lzt::metric_streamer_read_data(metricStreamerHandle, notifyEveryNReports,
1275+
rawDataSize, &rawData);
1276+
13111277
LOG_INFO << "rawDataSize " << rawDataSize;
13121278
lzt::validate_metrics(groupInfo.metricGroupHandle, rawDataSize,
13131279
rawData.data());
1314-
13151280
lzt::metric_streamer_close(metricStreamerHandle);
13161281
lzt::deactivate_metric_groups(device);
13171282
lzt::destroy_function(function);
@@ -1335,9 +1300,11 @@ TEST_F(
13351300
* ZE_RESULT_NOT_READY. Once the expected time has elapsed it will come out of
13361301
* the loop and expect the event to be generated.
13371302
*/
1338-
1339-
uint32_t notifyEveryNReports = 1000;
1340-
uint32_t samplingPeriod = 50000000;
1303+
1304+
/* The time in seconds for the buffer to overflow would be 2 * (notifyEveryNReports * (samplingPeriod/nanoSecToSeconds))
1305+
* For this test it will be 9 seconds. The execution time between metric_streamer_open_for_device and synchronize observed on average is less than 50% of this
1306+
*/
1307+
uint32_t notifyEveryNReports = 4500;
13411308
for (auto device : devices) {
13421309

13431310
ze_device_properties_t deviceProperties = {
@@ -1435,9 +1402,11 @@ TEST_F(
14351402
TEST_F(
14361403
zetMetricStreamerTest,
14371404
GivenValidMetricGroupWhenTimerBasedStreamerIsCreatedThenExpectStreamerToGenrateCorrectNumberOfReports) {
1438-
1439-
uint32_t notifyEveryNReports = 1000;
1440-
uint32_t samplingPeriod = 50000000;
1405+
1406+
/* The time in seconds for the buffer to overflow would be 2 * (notifyEveryNReports * (samplingPeriod/nanoSecToSeconds))
1407+
* For this test it will be 9 seconds. The execution time between metric_streamer_open_for_device and synchronize observed on average is less than 50% of this
1408+
*/
1409+
uint32_t notifyEveryNReports = 4500;
14411410
for (auto device : devices) {
14421411

14431412
ze_device_properties_t deviceProperties = {
@@ -1759,12 +1728,6 @@ void run_ip_sampling_with_validation(
17591728
eventPool.create_event(eventHandle, ZE_EVENT_SCOPE_FLAG_HOST,
17601729
ZE_EVENT_SCOPE_FLAG_HOST);
17611730

1762-
zet_metric_streamer_handle_t metricStreamerHandle =
1763-
lzt::metric_streamer_open_for_device(
1764-
device, groupInfo.metricGroupHandle, eventHandle,
1765-
notifyEveryNReports, samplingPeriod);
1766-
ASSERT_NE(nullptr, metricStreamerHandle);
1767-
17681731
for (auto &fData : functionDataBuf) {
17691732
fData.function = get_matrix_multiplication_kernel(
17701733
device, &fData.tg, &fData.a_buffer, &fData.b_buffer,
@@ -1774,35 +1737,20 @@ void run_ip_sampling_with_validation(
17741737
}
17751738

17761739
lzt::close_command_list(commandList);
1777-
17781740
std::chrono::steady_clock::time_point startTime =
17791741
std::chrono::steady_clock::now();
17801742

1743+
zet_metric_streamer_handle_t metricStreamerHandle =
1744+
lzt::metric_streamer_open_for_device(
1745+
device, groupInfo.metricGroupHandle, eventHandle,
1746+
notifyEveryNReports, samplingPeriod);
1747+
ASSERT_NE(nullptr, metricStreamerHandle);
1748+
17811749
lzt::execute_command_lists(commandQueue, 1, &commandList, nullptr);
17821750
lzt::synchronize(commandQueue, std::numeric_limits<uint64_t>::max());
1783-
ze_result_t eventResult;
1784-
eventResult = zeEventQueryStatus(eventHandle);
1785-
1786-
if (ZE_RESULT_SUCCESS == eventResult) {
1787-
size_t oneReportSize, allReportsSize;
1788-
oneReportSize =
1789-
lzt::metric_streamer_read_data_size(metricStreamerHandle, 1);
1790-
allReportsSize = lzt::metric_streamer_read_data_size(
1791-
metricStreamerHandle, UINT32_MAX);
1792-
LOG_DEBUG << "Event triggered. Single report size: " << oneReportSize
1793-
<< ". All reports size:" << allReportsSize;
1794-
1795-
EXPECT_GE(allReportsSize / oneReportSize, notifyEveryNReports);
1796-
1797-
} else if (ZE_RESULT_NOT_READY == eventResult) {
1798-
LOG_WARNING << "wait on event returned ZE_RESULT_NOT_READY";
1799-
} else {
1800-
FAIL() << "zeEventQueryStatus() FAILED with " << eventResult;
1801-
}
18021751

18031752
std::chrono::steady_clock::time_point endTime =
18041753
std::chrono::steady_clock::now();
1805-
18061754
uint64_t elapsedTime =
18071755
std::chrono::duration_cast<std::chrono::nanoseconds>(endTime -
18081756
startTime)
@@ -1814,10 +1762,13 @@ void run_ip_sampling_with_validation(
18141762
LOG_WARNING << "elapsed time for workload completion is too short";
18151763
}
18161764

1765+
size_t rawDataSize = 0;
18171766
std::vector<uint8_t> rawData;
1818-
uint32_t rawDataSize = 0;
1819-
lzt::metric_streamer_read_data(metricStreamerHandle, rawDataSize,
1820-
&rawData);
1767+
rawDataSize = lzt::metric_streamer_read_data_size(metricStreamerHandle, notifyEveryNReports);
1768+
EXPECT_GT(rawDataSize, 0);
1769+
rawData.resize(rawDataSize);
1770+
lzt::metric_streamer_read_data(metricStreamerHandle, notifyEveryNReports,
1771+
rawDataSize, &rawData);
18211772
lzt::validate_metrics(groupInfo.metricGroupHandle, rawDataSize,
18221773
rawData.data(), false);
18231774
rawData.resize(rawDataSize);
@@ -1863,15 +1814,13 @@ void run_ip_sampling_with_validation(
18631814
TEST_F(
18641815
zetMetricStreamerTest,
18651816
GivenValidTypeIpMetricGroupWhenTimerBasedStreamerIsCreatedAndOverflowTriggeredThenExpectStreamerValidateError) {
1866-
18671817
run_ip_sampling_with_validation(true, devices, notifyEveryNReports,
18681818
samplingPeriod, TimeForNReportsComplete);
18691819
}
18701820

18711821
TEST_F(
18721822
zetMetricStreamerTest,
18731823
GivenValidTypeIpMetricGroupWhenTimerBasedStreamerIsCreatedWithNoOverflowThenValidateStallSampleData) {
1874-
18751824
run_ip_sampling_with_validation(false, devices, notifyEveryNReports,
18761825
samplingPeriod, TimeForNReportsComplete);
18771826
}
@@ -1917,17 +1866,17 @@ TEST_F(
19171866
eventPool.create_event(eventHandle, ZE_EVENT_SCOPE_FLAG_HOST,
19181867
ZE_EVENT_SCOPE_FLAG_HOST);
19191868

1869+
void *a_buffer, *b_buffer, *c_buffer;
1870+
ze_group_count_t tg{};
1871+
ze_kernel_handle_t function = get_matrix_multiplication_kernel(
1872+
device, &tg, &a_buffer, &b_buffer, &c_buffer);
1873+
19201874
zet_metric_streamer_handle_t metricStreamerHandle =
19211875
lzt::metric_streamer_open_for_device(
19221876
device, groupInfo.metricGroupHandle, eventHandle,
19231877
notifyEveryNReports, samplingPeriod);
19241878
ASSERT_NE(nullptr, metricStreamerHandle);
19251879

1926-
void *a_buffer, *b_buffer, *c_buffer;
1927-
ze_group_count_t tg{};
1928-
ze_kernel_handle_t function = get_matrix_multiplication_kernel(
1929-
device, &tg, &a_buffer, &b_buffer, &c_buffer);
1930-
19311880
uint32_t streamerMarker = 0;
19321881
markerResult = lzt::commandlist_append_streamer_marker(
19331882
commandList, metricStreamerHandle, ++streamerMarker);
@@ -2314,8 +2263,8 @@ TEST(
23142263
eventPool.create_event(eventHandle, ZE_EVENT_SCOPE_FLAG_HOST,
23152264
ZE_EVENT_SCOPE_FLAG_HOST);
23162265

2317-
uint32_t notifyEveryNReports = 3000;
2318-
uint32_t samplingPeriod = 10000;
2266+
uint32_t notifyEveryNReports = 4500;
2267+
uint32_t samplingPeriod = 1000000;
23192268
zet_metric_streamer_handle_t metricStreamerHandle =
23202269
lzt::metric_streamer_open_for_device(device, groupInfo.metricGroupHandle,
23212270
eventHandle, notifyEveryNReports,
@@ -2349,9 +2298,13 @@ TEST(
23492298

23502299
EXPECT_GE(allReportsSize / oneReportSize, notifyEveryNReports);
23512300

2301+
size_t rawDataSize = 0;
23522302
std::vector<uint8_t> rawData;
2353-
uint32_t rawDataSize = 0;
2354-
lzt::metric_streamer_read_data(metricStreamerHandle, rawDataSize, &rawData);
2303+
rawDataSize = lzt::metric_streamer_read_data_size(metricStreamerHandle, notifyEveryNReports);
2304+
EXPECT_GT(rawDataSize, 0);
2305+
rawData.resize(rawDataSize);
2306+
lzt::metric_streamer_read_data(metricStreamerHandle, notifyEveryNReports,
2307+
rawDataSize, &rawData);
23552308
lzt::validate_metrics(groupInfo.metricGroupHandle, rawDataSize,
23562309
rawData.data());
23572310

@@ -2396,8 +2349,8 @@ TEST(
23962349
eventPool.create_event(eventHandle, ZE_EVENT_SCOPE_FLAG_HOST,
23972350
ZE_EVENT_SCOPE_FLAG_HOST);
23982351

2399-
uint32_t notifyEveryNReports = 3000;
2400-
uint32_t samplingPeriod = 10000;
2352+
uint32_t notifyEveryNReports = 4500;
2353+
uint32_t samplingPeriod = 1000000;
24012354
zet_metric_streamer_handle_t metricStreamerHandle =
24022355
lzt::metric_streamer_open_for_device(device, groupInfo.metricGroupHandle,
24032356
eventHandle, notifyEveryNReports,
@@ -2430,9 +2383,13 @@ TEST(
24302383

24312384
EXPECT_GE(allReportsSize / oneReportSize, notifyEveryNReports);
24322385

2386+
size_t rawDataSize = 0;
24332387
std::vector<uint8_t> rawData;
2434-
uint32_t rawDataSize = 0;
2435-
lzt::metric_streamer_read_data(metricStreamerHandle, rawDataSize, &rawData);
2388+
rawDataSize = lzt::metric_streamer_read_data_size(metricStreamerHandle, notifyEveryNReports);
2389+
EXPECT_GT(rawDataSize, 0);
2390+
rawData.resize(rawDataSize);
2391+
lzt::metric_streamer_read_data(metricStreamerHandle, notifyEveryNReports,
2392+
rawDataSize, &rawData);
24362393
lzt::validate_metrics(groupInfo.metricGroupHandle, rawDataSize,
24372394
rawData.data());
24382395

‎utils/test_harness/tools/include/test_harness_metric.hpp‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -141,6 +141,10 @@ void metric_streamer_read_data(
141141
zet_metric_streamer_handle_t metricStreamerHandle, uint32_t &rawDataSize,
142142
std::vector<uint8_t> *metricData);
143143

144+
void metric_streamer_read_data(
145+
zet_metric_streamer_handle_t metricStreamerHandle, uint32_t reports,
146+
size_t &rawDataSize, std::vector<uint8_t> *metricData);
147+
144148
std::vector<zet_metric_group_handle_t>
145149
get_metric_groups_with_different_domains(const ze_device_handle_t device,
146150
uint32_t metric_groups_per_domain);

0 commit comments

Comments
 (0)