Skip to content

Commit b7185e3

Browse files
KonstantyMisiakKonstantyMisiak
committed
Add scenarios using BCS to image SVM tests
- Added new scenarios - Refactored code for choosing queue ordinals Signed-off-by: Misiak, Konstanty <[email protected]>
1 parent 9574c98 commit b7185e3

File tree

4 files changed

+180
-69
lines changed

4 files changed

+180
-69
lines changed

‎conformance_tests/core/test_copy/src/test_copy.cpp‎

Lines changed: 66 additions & 59 deletions
Original file line numberDiff line numberDiff line change
@@ -29,29 +29,6 @@ using lzt::to_int;
2929
using lzt::to_u32;
3030
using lzt::to_u8;
3131

32-
void get_copy_and_compute_ordinals(
33-
const std::vector<ze_command_queue_group_properties_t>
34-
&cmd_queue_group_props,
35-
int &compute_ordinal, int &copy_ordinal) {
36-
for (uint32_t i = 0; i < cmd_queue_group_props.size(); i++) {
37-
if (cmd_queue_group_props[i].flags &
38-
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE &&
39-
compute_ordinal < 0) {
40-
compute_ordinal = to_int(i);
41-
}
42-
if (cmd_queue_group_props[i].flags &
43-
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY &&
44-
!(cmd_queue_group_props[i].flags &
45-
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE) &&
46-
copy_ordinal < 0) {
47-
copy_ordinal = to_int(i);
48-
}
49-
if (compute_ordinal >= 0 && copy_ordinal >= 0) {
50-
break;
51-
}
52-
}
53-
}
54-
5532
class zeCommandListAppendMemoryFillTests : public ::testing::Test {
5633
protected:
5734
void RunMaxMemoryFillTest(bool is_immediate, bool is_shared_system);
@@ -69,15 +46,20 @@ void zeCommandListAppendMemoryFillTests::
6946
auto cmd_queue_group_props = get_command_queue_group_properties(
7047
zeDevice::get_instance()->get_device());
7148

72-
int compute_ordinal = -1, copy_ordinal = -1;
73-
get_copy_and_compute_ordinals(cmd_queue_group_props, compute_ordinal,
74-
copy_ordinal);
75-
ASSERT_TRUE((use_copy_engine && copy_ordinal >= 0) ||
76-
(!use_copy_engine && compute_ordinal >= 0));
49+
auto compute_ordinal = lzt::get_queue_ordinal(
50+
cmd_queue_group_props,
51+
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE |
52+
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COOPERATIVE_KERNELS,
53+
0);
54+
auto copy_ordinal = lzt::get_queue_ordinal(
55+
cmd_queue_group_props, ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY,
56+
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE);
57+
ASSERT_TRUE((use_copy_engine && copy_ordinal) ||
58+
(!use_copy_engine && compute_ordinal));
7759

7860
auto cmd_bundle = lzt::create_command_bundle(
7961
lzt::get_default_context(), zeDevice::get_instance()->get_device(), 0,
80-
to_u32(use_copy_engine ? copy_ordinal : compute_ordinal), is_immediate);
62+
use_copy_engine ? *copy_ordinal : *compute_ordinal, is_immediate);
8163
const size_t size = 4096;
8264
void *memory = lzt::allocate_device_memory_with_allocator_selector(
8365
size, is_shared_system);
@@ -212,15 +194,20 @@ void zeCommandListAppendMemoryFillTests::
212194
auto cmd_queue_group_props = get_command_queue_group_properties(
213195
zeDevice::get_instance()->get_device());
214196

215-
int compute_ordinal = -1, copy_ordinal = -1;
216-
get_copy_and_compute_ordinals(cmd_queue_group_props, compute_ordinal,
217-
copy_ordinal);
218-
ASSERT_TRUE((use_copy_engine && copy_ordinal >= 0) ||
219-
(!use_copy_engine && compute_ordinal >= 0));
197+
auto compute_ordinal = lzt::get_queue_ordinal(
198+
cmd_queue_group_props,
199+
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE |
200+
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COOPERATIVE_KERNELS,
201+
0);
202+
auto copy_ordinal = lzt::get_queue_ordinal(
203+
cmd_queue_group_props, ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY,
204+
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE);
205+
ASSERT_TRUE((use_copy_engine && copy_ordinal) ||
206+
(!use_copy_engine && compute_ordinal));
220207

221208
auto cmd_bundle = lzt::create_command_bundle(
222209
lzt::get_default_context(), zeDevice::get_instance()->get_device(), 0,
223-
to_u32(use_copy_engine ? copy_ordinal : compute_ordinal), is_immediate);
210+
use_copy_engine ? *copy_ordinal : *compute_ordinal, is_immediate);
224211
const size_t size = 4096;
225212
void *memory = lzt::allocate_device_memory_with_allocator_selector(
226213
size, is_shared_system);
@@ -307,15 +294,20 @@ void zeCommandListAppendMemoryFillTests::
307294
auto cmd_queue_group_props = get_command_queue_group_properties(
308295
zeDevice::get_instance()->get_device());
309296

310-
int compute_ordinal = -1, copy_ordinal = -1;
311-
get_copy_and_compute_ordinals(cmd_queue_group_props, compute_ordinal,
312-
copy_ordinal);
313-
ASSERT_TRUE((use_copy_engine && copy_ordinal >= 0) ||
314-
(!use_copy_engine && compute_ordinal >= 0));
297+
auto compute_ordinal = lzt::get_queue_ordinal(
298+
cmd_queue_group_props,
299+
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE |
300+
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COOPERATIVE_KERNELS,
301+
0);
302+
auto copy_ordinal = lzt::get_queue_ordinal(
303+
cmd_queue_group_props, ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY,
304+
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE);
305+
ASSERT_TRUE((use_copy_engine && copy_ordinal) ||
306+
(!use_copy_engine && compute_ordinal));
315307

316308
auto cmd_bundle = lzt::create_command_bundle(
317309
lzt::get_default_context(), zeDevice::get_instance()->get_device(), 0,
318-
to_u32(use_copy_engine ? copy_ordinal : compute_ordinal), is_immediate);
310+
use_copy_engine ? *copy_ordinal : *compute_ordinal, is_immediate);
319311
const size_t size = 4096;
320312
void *memory = lzt::allocate_device_memory_with_allocator_selector(
321313
size, is_shared_system);
@@ -1367,15 +1359,20 @@ void zeCommandListAppendMemoryCopyTests::
13671359
auto cmd_queue_group_props = get_command_queue_group_properties(
13681360
zeDevice::get_instance()->get_device());
13691361

1370-
int compute_ordinal = -1, copy_ordinal = -1;
1371-
get_copy_and_compute_ordinals(cmd_queue_group_props, compute_ordinal,
1372-
copy_ordinal);
1373-
ASSERT_TRUE((use_copy_engine && copy_ordinal >= 0) ||
1374-
(!use_copy_engine && compute_ordinal >= 0));
1362+
auto compute_ordinal = lzt::get_queue_ordinal(
1363+
cmd_queue_group_props,
1364+
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE |
1365+
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COOPERATIVE_KERNELS,
1366+
0);
1367+
auto copy_ordinal = lzt::get_queue_ordinal(
1368+
cmd_queue_group_props, ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY,
1369+
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE);
1370+
ASSERT_TRUE((use_copy_engine && copy_ordinal) ||
1371+
(!use_copy_engine && compute_ordinal));
13751372

13761373
auto cmd_bundle = lzt::create_command_bundle(
13771374
lzt::get_default_context(), zeDevice::get_instance()->get_device(), 0,
1378-
to_u32(use_copy_engine ? copy_ordinal : compute_ordinal), is_immediate);
1375+
use_copy_engine ? *copy_ordinal : *compute_ordinal, is_immediate);
13791376

13801377
const size_t size = 16;
13811378
const std::vector<char> host_memory(size, 123);
@@ -1449,15 +1446,20 @@ void zeCommandListAppendMemoryCopyTests::
14491446
auto cmd_queue_group_props = get_command_queue_group_properties(
14501447
zeDevice::get_instance()->get_device());
14511448

1452-
int compute_ordinal = -1, copy_ordinal = -1;
1453-
get_copy_and_compute_ordinals(cmd_queue_group_props, compute_ordinal,
1454-
copy_ordinal);
1455-
ASSERT_TRUE((use_copy_engine && copy_ordinal >= 0) ||
1456-
(!use_copy_engine && compute_ordinal >= 0));
1449+
auto compute_ordinal = lzt::get_queue_ordinal(
1450+
cmd_queue_group_props,
1451+
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE |
1452+
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COOPERATIVE_KERNELS,
1453+
0);
1454+
auto copy_ordinal = lzt::get_queue_ordinal(
1455+
cmd_queue_group_props, ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY,
1456+
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE);
1457+
ASSERT_TRUE((use_copy_engine && copy_ordinal) ||
1458+
(!use_copy_engine && compute_ordinal));
14571459

14581460
auto cmd_bundle = lzt::create_command_bundle(
14591461
lzt::get_default_context(), zeDevice::get_instance()->get_device(), 0,
1460-
to_u32(use_copy_engine ? copy_ordinal : compute_ordinal), is_immediate);
1462+
use_copy_engine ? *copy_ordinal : *compute_ordinal, is_immediate);
14611463

14621464
lzt::zeEventPool ep;
14631465
const size_t size = 16;
@@ -1543,15 +1545,20 @@ void zeCommandListAppendMemoryCopyTests::
15431545
auto cmd_queue_group_props = get_command_queue_group_properties(
15441546
zeDevice::get_instance()->get_device());
15451547

1546-
int compute_ordinal = -1, copy_ordinal = -1;
1547-
get_copy_and_compute_ordinals(cmd_queue_group_props, compute_ordinal,
1548-
copy_ordinal);
1549-
ASSERT_TRUE((use_copy_engine && copy_ordinal >= 0) ||
1550-
(!use_copy_engine && compute_ordinal >= 0));
1548+
auto compute_ordinal = lzt::get_queue_ordinal(
1549+
cmd_queue_group_props,
1550+
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE |
1551+
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COOPERATIVE_KERNELS,
1552+
0);
1553+
auto copy_ordinal = lzt::get_queue_ordinal(
1554+
cmd_queue_group_props, ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY,
1555+
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE);
1556+
ASSERT_TRUE((use_copy_engine && copy_ordinal) ||
1557+
(!use_copy_engine && compute_ordinal));
15511558

15521559
auto cmd_bundle = lzt::create_command_bundle(
15531560
lzt::get_default_context(), zeDevice::get_instance()->get_device(), 0,
1554-
to_u32(use_copy_engine ? copy_ordinal : compute_ordinal), is_immediate);
1561+
use_copy_engine ? *copy_ordinal : *compute_ordinal, is_immediate);
15551562

15561563
lzt::zeEventPool ep;
15571564
const size_t size = 16;

‎conformance_tests/core/test_copy/src/test_copy_image.cpp‎

Lines changed: 92 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,33 @@ using namespace level_zero_tests;
2222

2323
namespace {
2424

25+
/*void get_copy_and_compute_ordinals(
26+
const std::vector<ze_command_queue_group_properties_t>
27+
&cmd_queue_group_props,
28+
int &compute_ordinal, int &copy_ordinal) {
29+
compute_ordinal = -1;
30+
copy_ordinal = -1;
31+
for (uint32_t i = 0; i < cmd_queue_group_props.size(); i++) {
32+
if (cmd_queue_group_props[i].flags &
33+
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE &&
34+
cmd_queue_group_props[i].flags &
35+
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COOPERATIVE_KERNELS &&
36+
compute_ordinal < 0) {
37+
compute_ordinal = i;
38+
}
39+
if (cmd_queue_group_props[i].flags &
40+
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY &&
41+
!(cmd_queue_group_props[i].flags &
42+
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE) &&
43+
copy_ordinal < 0) {
44+
copy_ordinal = i;
45+
}
46+
if (compute_ordinal >= 0 && copy_ordinal >= 0) {
47+
break;
48+
}
49+
}
50+
}*/
51+
2552
class zeCommandListAppendImageCopyTests : public ::testing::Test {
2653
public:
2754
zeCommandListAppendImageCopyTests() {
@@ -240,8 +267,25 @@ class zeCommandListAppendImageCopyTests : public ::testing::Test {
240267
void test_image_mem_copy_use_regions(void *source_buff_bot,
241268
void *source_buff_top,
242269
void *dest_buff_bot, void *dest_buff_top,
243-
bool is_immediate) {
244-
auto cmd_bundle = lzt::create_command_bundle(is_immediate);
270+
bool is_immediate,
271+
bool use_copy_engine) {
272+
auto cmd_queue_group_props = get_command_queue_group_properties(
273+
zeDevice::get_instance()->get_device());
274+
275+
auto compute_ordinal = lzt::get_queue_ordinal(
276+
cmd_queue_group_props,
277+
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE |
278+
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COOPERATIVE_KERNELS,
279+
0);
280+
auto copy_ordinal = lzt::get_queue_ordinal(
281+
cmd_queue_group_props, ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY,
282+
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE);
283+
ASSERT_TRUE((use_copy_engine && copy_ordinal) ||
284+
(!use_copy_engine && compute_ordinal));
285+
286+
auto cmd_bundle = lzt::create_command_bundle(
287+
lzt::get_default_context(), zeDevice::get_instance()->get_device(), 0,
288+
use_copy_engine ? *copy_ordinal : *compute_ordinal, is_immediate);
245289

246290
ze_image_region_t bot_region = {0, 0, 0, image_width, image_height / 2, 1};
247291
ze_image_region_t top_region = {0, image_height / 2, 0,
@@ -509,7 +553,7 @@ LZT_TEST_F(
509553
void *buff_in_bot = lzt::allocate_host_memory(image_size);
510554
void *buff_out_top = lzt::allocate_host_memory(image_size);
511555
test_image_mem_copy_use_regions(buff_in_bot, buff_in_top, buff_out_bot,
512-
buff_out_top, false);
556+
buff_out_top, false, false);
513557
lzt::free_memory(buff_in_bot);
514558
lzt::free_memory(buff_in_top);
515559
lzt::free_memory(buff_out_bot);
@@ -527,7 +571,7 @@ LZT_TEST_F(
527571
void *buff_in_bot = lzt::allocate_host_memory(image_size);
528572
void *buff_out_top = lzt::allocate_host_memory(image_size);
529573
test_image_mem_copy_use_regions(buff_in_bot, buff_in_top, buff_out_bot,
530-
buff_out_top, true);
574+
buff_out_top, true, false);
531575
lzt::free_memory(buff_in_bot);
532576
lzt::free_memory(buff_in_top);
533577
lzt::free_memory(buff_out_bot);
@@ -571,7 +615,7 @@ LZT_TEST_F(
571615
void *buff_in_bot = lzt::allocate_device_memory(image_size);
572616
void *buff_out_top = lzt::allocate_device_memory(image_size);
573617
test_image_mem_copy_use_regions(buff_in_bot, buff_in_top, buff_out_bot,
574-
buff_out_top, false);
618+
buff_out_top, false, false);
575619
lzt::free_memory(buff_in_bot);
576620
lzt::free_memory(buff_in_top);
577621
lzt::free_memory(buff_out_bot);
@@ -589,7 +633,7 @@ LZT_TEST_F(
589633
void *buff_in_bot = lzt::allocate_device_memory(image_size);
590634
void *buff_out_top = lzt::allocate_device_memory(image_size);
591635
test_image_mem_copy_use_regions(buff_in_bot, buff_in_top, buff_out_bot,
592-
buff_out_top, true);
636+
buff_out_top, true, false);
593637
lzt::free_memory(buff_in_bot);
594638
lzt::free_memory(buff_in_top);
595639
lzt::free_memory(buff_out_bot);
@@ -633,7 +677,7 @@ LZT_TEST_F(
633677
void *buff_in_bot = lzt::allocate_shared_memory(image_size);
634678
void *buff_out_top = lzt::allocate_shared_memory(image_size);
635679
test_image_mem_copy_use_regions(buff_in_bot, buff_in_top, buff_out_bot,
636-
buff_out_top, false);
680+
buff_out_top, false, false);
637681
lzt::free_memory(buff_in_bot);
638682
lzt::free_memory(buff_in_top);
639683
lzt::free_memory(buff_out_bot);
@@ -651,7 +695,7 @@ LZT_TEST_F(
651695
void *buff_in_bot = lzt::allocate_shared_memory(image_size);
652696
void *buff_out_top = lzt::allocate_shared_memory(image_size);
653697
test_image_mem_copy_use_regions(buff_in_bot, buff_in_top, buff_out_bot,
654-
buff_out_top, true);
698+
buff_out_top, true, false);
655699
lzt::free_memory(buff_in_bot);
656700
lzt::free_memory(buff_in_top);
657701
lzt::free_memory(buff_out_bot);
@@ -696,7 +740,26 @@ LZT_TEST_F(
696740
void *buff_in_bot = lzt::aligned_malloc(image_size, 1);
697741
void *buff_out_top = lzt::aligned_malloc(image_size, 1);
698742
test_image_mem_copy_use_regions(buff_in_bot, buff_in_top, buff_out_bot,
699-
buff_out_top, false);
743+
buff_out_top, false, false);
744+
lzt::aligned_free(buff_in_bot);
745+
lzt::aligned_free(buff_in_top);
746+
lzt::aligned_free(buff_out_bot);
747+
lzt::aligned_free(buff_out_top);
748+
}
749+
750+
LZT_TEST_F(
751+
zeCommandListAppendImageCopyTests,
752+
GivenDeviceImageAndHostImageWhenAppendingImageCopyFromMemoryUsingCopyEngineAndSharedSystemMemoryWithNonNullRegionsThenImageIsCorrectAndSuccessIsReturnedWithSharedSystemAllocator) {
753+
SKIP_IF_SHARED_SYSTEM_ALLOC_UNSUPPORTED();
754+
if (!(lzt::image_support())) {
755+
GTEST_SKIP();
756+
}
757+
void *buff_in_top = lzt::aligned_malloc(image_size, 1);
758+
void *buff_out_bot = lzt::aligned_malloc(image_size, 1);
759+
void *buff_in_bot = lzt::aligned_malloc(image_size, 1);
760+
void *buff_out_top = lzt::aligned_malloc(image_size, 1);
761+
test_image_mem_copy_use_regions(buff_in_bot, buff_in_top, buff_out_bot,
762+
buff_out_top, false, true);
700763
lzt::aligned_free(buff_in_bot);
701764
lzt::aligned_free(buff_in_top);
702765
lzt::aligned_free(buff_out_bot);
@@ -715,7 +778,26 @@ LZT_TEST_F(
715778
void *buff_in_bot = lzt::aligned_malloc(image_size, 1);
716779
void *buff_out_top = lzt::aligned_malloc(image_size, 1);
717780
test_image_mem_copy_use_regions(buff_in_bot, buff_in_top, buff_out_bot,
718-
buff_out_top, true);
781+
buff_out_top, true, false);
782+
lzt::aligned_free(buff_in_bot);
783+
lzt::aligned_free(buff_in_top);
784+
lzt::aligned_free(buff_out_bot);
785+
lzt::aligned_free(buff_out_top);
786+
}
787+
788+
LZT_TEST_F(
789+
zeCommandListAppendImageCopyTests,
790+
GivenDeviceImageAndHostImageWhenAppendingImageCopyFromMemoryToImmediateCmdListUsingCopyEngineAndSharedSystemMemoryWithNonNullRegionsThenImageIsCorrectAndSuccessIsReturnedWithSharedSystemAllocator) {
791+
SKIP_IF_SHARED_SYSTEM_ALLOC_UNSUPPORTED();
792+
if (!(lzt::image_support())) {
793+
GTEST_SKIP();
794+
}
795+
void *buff_in_top = lzt::aligned_malloc(image_size, 1);
796+
void *buff_out_bot = lzt::aligned_malloc(image_size, 1);
797+
void *buff_in_bot = lzt::aligned_malloc(image_size, 1);
798+
void *buff_out_top = lzt::aligned_malloc(image_size, 1);
799+
test_image_mem_copy_use_regions(buff_in_bot, buff_in_top, buff_out_bot,
800+
buff_out_top, true, true);
719801
lzt::aligned_free(buff_in_bot);
720802
lzt::aligned_free(buff_in_top);
721803
lzt::aligned_free(buff_out_bot);

‎utils/utils/include/utils/utils.hpp‎

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -19,6 +19,8 @@
1919
#include "utils/utils_string.hpp"
2020
#include "utils/utils_gtest_helper.hpp"
2121

22+
#include <boost/core/span.hpp>
23+
2224
namespace level_zero_tests {
2325

2426
template <typename T> inline constexpr uint8_t to_u8(T val) {
@@ -91,6 +93,12 @@ uint32_t get_device_count(ze_driver_handle_t driver);
9193
uint32_t get_driver_handle_count();
9294
uint32_t get_sub_device_count(ze_device_handle_t device);
9395

96+
std::optional<uint32_t>
97+
get_queue_ordinal(boost::span<const ze_command_queue_group_properties_t>
98+
cmd_queue_group_props,
99+
ze_command_queue_group_property_flags_t include_flags,
100+
ze_command_queue_group_property_flags_t exclude_flags);
101+
94102
void print_driver_version();
95103
void print_driver_overview(const ze_driver_handle_t driver);
96104
void print_driver_overview(const std::vector<ze_driver_handle_t> driver);

0 commit comments

Comments
 (0)