Skip to content

Commit 69c43b4

Browse files
author
Hugh Delaney
committed
Add some tests for local range finding
Dispatch kernels on lots of different configurations
1 parent 7021af9 commit 69c43b4

File tree

2 files changed

+175
-32
lines changed

2 files changed

+175
-32
lines changed

‎test/conformance/enqueue/urEnqueueKernelLaunch.cpp‎

Lines changed: 72 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -77,53 +77,93 @@ TEST_P(urEnqueueKernelLaunchTest, InvalidWorkDimension) {
7777
UR_RESULT_ERROR_INVALID_WORK_DIMENSION);
7878
}
7979

80-
struct urEnqueueKernelLaunch2DTest : uur::urKernelExecutionTest {
81-
void SetUp() override {
82-
program_name = "fill_2d";
83-
UUR_RETURN_ON_FATAL_FAILURE(urKernelExecutionTest::SetUp());
84-
}
85-
86-
uint32_t val = 42;
87-
size_t global_size[2] = {8, 8};
88-
size_t global_offset[2] = {0, 0};
89-
size_t buffer_size = sizeof(val) * global_size[0] * global_size[1];
90-
size_t n_dimensions = 2;
80+
struct testParametersEnqueueKernel {
81+
size_t X, Y, Z;
82+
size_t Dims;
9183
};
92-
UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urEnqueueKernelLaunch2DTest);
9384

94-
TEST_P(urEnqueueKernelLaunch2DTest, Success) {
95-
ur_mem_handle_t buffer = nullptr;
96-
AddBuffer1DArg(buffer_size, &buffer);
97-
AddPodArg(val);
98-
ASSERT_SUCCESS(urEnqueueKernelLaunch(queue, kernel, n_dimensions,
99-
global_offset, global_size, nullptr, 0,
100-
nullptr, nullptr));
101-
ASSERT_SUCCESS(urQueueFinish(queue));
102-
ValidateBuffer(buffer, buffer_size, val);
85+
template <typename T>
86+
inline std::string printKernelLaunchTestString(
87+
const testing::TestParamInfo<typename T::ParamType> &info) {
88+
const auto device_handle = std::get<0>(info.param);
89+
const auto platform_device_name =
90+
uur::GetPlatformAndDeviceName(device_handle);
91+
std::stringstream test_name;
92+
test_name << platform_device_name << "__" << std::get<1>(info.param).Dims
93+
<< "D_" << std::get<1>(info.param).X;
94+
if (std::get<1>(info.param).Dims > 1) {
95+
test_name << "_" << std::get<1>(info.param).Y;
96+
}
97+
if (std::get<1>(info.param).Dims > 2) {
98+
test_name << "_" << std::get<1>(info.param).Z;
99+
}
100+
test_name << "";
101+
return test_name.str();
103102
}
104103

105-
struct urEnqueueKernelLaunch3DTest : uur::urKernelExecutionTest {
104+
struct urEnqueueKernelLaunchTestWithParam
105+
: uur::urBaseKernelExecutionTestWithParam<testParametersEnqueueKernel> {
106106
void SetUp() override {
107-
program_name = "fill_3d";
108-
UUR_RETURN_ON_FATAL_FAILURE(urKernelExecutionTest::SetUp());
107+
global_range[0] = std::get<1>(GetParam()).X;
108+
global_range[1] = std::get<1>(GetParam()).Y;
109+
global_range[2] = std::get<1>(GetParam()).Z;
110+
buffer_size = sizeof(val) * global_range[0];
111+
n_dimensions = std::get<1>(GetParam()).Dims;
112+
if (n_dimensions == 1) {
113+
program_name = "fill";
114+
} else if (n_dimensions == 2) {
115+
program_name = "fill_2d";
116+
buffer_size *= global_range[1];
117+
} else {
118+
assert(n_dimensions == 3);
119+
program_name = "fill_3d";
120+
buffer_size *= global_range[1] * global_range[2];
121+
}
122+
UUR_RETURN_ON_FATAL_FAILURE(
123+
urBaseKernelExecutionTestWithParam::SetUp());
124+
}
125+
126+
void TearDown() override {
127+
UUR_RETURN_ON_FATAL_FAILURE(uur::urBaseKernelExecutionTestWithParam<
128+
testParametersEnqueueKernel>::TearDown());
109129
}
110130

111131
uint32_t val = 42;
112-
size_t global_size[3] = {4, 4, 4};
132+
size_t global_range[3];
113133
size_t global_offset[3] = {0, 0, 0};
114-
size_t buffer_size =
115-
sizeof(val) * global_size[0] * global_size[1] * global_size[2];
116-
size_t n_dimensions = 3;
134+
size_t n_dimensions;
135+
size_t buffer_size;
117136
};
118-
UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urEnqueueKernelLaunch3DTest);
119137

120-
TEST_P(urEnqueueKernelLaunch3DTest, Success) {
138+
static std::vector<testParametersEnqueueKernel> test_cases{// 1D
139+
{1, 1, 1, 1},
140+
{31, 1, 1, 1},
141+
{1027, 1, 1, 1},
142+
{32, 1, 1, 1},
143+
{256, 1, 1, 1},
144+
// 2D
145+
{1, 1, 1, 2},
146+
{31, 7, 1, 2},
147+
{1027, 1, 1, 2},
148+
{1, 32, 1, 2},
149+
{256, 79, 1, 2},
150+
// 3D
151+
{1, 1, 1, 3},
152+
{31, 7, 1, 3},
153+
{1027, 1, 19, 3},
154+
{1, 53, 19, 3},
155+
{256, 79, 8, 3}};
156+
UUR_TEST_SUITE_P(
157+
urEnqueueKernelLaunchTestWithParam, testing::ValuesIn(test_cases),
158+
printKernelLaunchTestString<urEnqueueKernelLaunchTestWithParam>);
159+
160+
TEST_P(urEnqueueKernelLaunchTestWithParam, Success) {
121161
ur_mem_handle_t buffer = nullptr;
122162
AddBuffer1DArg(buffer_size, &buffer);
123163
AddPodArg(val);
124164
ASSERT_SUCCESS(urEnqueueKernelLaunch(queue, kernel, n_dimensions,
125-
global_offset, global_size, nullptr, 0,
126-
nullptr, nullptr));
165+
global_offset, global_range, nullptr,
166+
0, nullptr, nullptr));
127167
ASSERT_SUCCESS(urQueueFinish(queue));
128168
ValidateBuffer(buffer, buffer_size, val);
129169
}

‎test/conformance/testing/include/uur/fixtures.h‎

Lines changed: 103 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1274,6 +1274,109 @@ struct urBaseKernelExecutionTest : urBaseKernelTest {
12741274
uint32_t current_arg_index = 0;
12751275
};
12761276

1277+
template <typename T>
1278+
struct urBaseKernelExecutionTestWithParam : urBaseKernelTestWithParam<T> {
1279+
void SetUp() override {
1280+
UUR_RETURN_ON_FATAL_FAILURE(urBaseKernelTestWithParam<T>::SetUp());
1281+
UUR_RETURN_ON_FATAL_FAILURE(urBaseKernelTestWithParam<T>::Build());
1282+
context = urBaseKernelTestWithParam<T>::context;
1283+
kernel = urBaseKernelTestWithParam<T>::kernel;
1284+
ASSERT_SUCCESS(urQueueCreate(
1285+
context, urBaseKernelTestWithParam<T>::device, 0, &queue));
1286+
}
1287+
1288+
void TearDown() override {
1289+
for (auto &buffer : buffer_args) {
1290+
ASSERT_SUCCESS(urMemRelease(buffer));
1291+
}
1292+
UUR_RETURN_ON_FATAL_FAILURE(urBaseKernelTestWithParam<T>::TearDown());
1293+
if (queue) {
1294+
EXPECT_SUCCESS(urQueueRelease(queue));
1295+
}
1296+
}
1297+
1298+
// Adds a kernel arg representing a sycl buffer constructed with a 1D range.
1299+
void AddBuffer1DArg(size_t size, ur_mem_handle_t *out_buffer) {
1300+
ur_mem_handle_t mem_handle = nullptr;
1301+
ASSERT_SUCCESS(urMemBufferCreate(context, UR_MEM_FLAG_READ_WRITE, size,
1302+
nullptr, &mem_handle));
1303+
char zero = 0;
1304+
ASSERT_SUCCESS(urEnqueueMemBufferFill(queue, mem_handle, &zero,
1305+
sizeof(zero), 0, size, 0, nullptr,
1306+
nullptr));
1307+
ASSERT_SUCCESS(urQueueFinish(queue));
1308+
ASSERT_SUCCESS(urKernelSetArgMemObj(kernel, current_arg_index, nullptr,
1309+
mem_handle));
1310+
1311+
// SYCL device kernels have different interfaces depending on the
1312+
// backend being used. Typically a kernel which takes a buffer argument
1313+
// will take a pointer to the start of the buffer and a sycl::id param
1314+
// which is a struct that encodes the accessor to the buffer. However
1315+
// the AMD backend handles this differently and uses three separate
1316+
// arguments for each of the three dimensions of the accessor.
1317+
1318+
ur_platform_backend_t backend;
1319+
ASSERT_SUCCESS(urPlatformGetInfo(urBaseKernelTestWithParam<T>::platform,
1320+
UR_PLATFORM_INFO_BACKEND,
1321+
sizeof(backend), &backend, nullptr));
1322+
if (backend == UR_PLATFORM_BACKEND_HIP) {
1323+
// this emulates the three offset params for buffer accessor on AMD.
1324+
size_t val = 0;
1325+
ASSERT_SUCCESS(urKernelSetArgValue(kernel, current_arg_index + 1,
1326+
sizeof(size_t), nullptr, &val));
1327+
ASSERT_SUCCESS(urKernelSetArgValue(kernel, current_arg_index + 2,
1328+
sizeof(size_t), nullptr, &val));
1329+
ASSERT_SUCCESS(urKernelSetArgValue(kernel, current_arg_index + 3,
1330+
sizeof(size_t), nullptr, &val));
1331+
current_arg_index += 4;
1332+
} else {
1333+
// This emulates the offset struct sycl adds for a 1D buffer accessor.
1334+
struct {
1335+
size_t offsets[1] = {0};
1336+
} accessor;
1337+
ASSERT_SUCCESS(urKernelSetArgValue(kernel, current_arg_index + 1,
1338+
sizeof(accessor), nullptr,
1339+
&accessor));
1340+
current_arg_index += 2;
1341+
}
1342+
1343+
buffer_args.push_back(mem_handle);
1344+
*out_buffer = mem_handle;
1345+
}
1346+
1347+
template <class U> void AddPodArg(U data) {
1348+
ASSERT_SUCCESS(urKernelSetArgValue(kernel, current_arg_index,
1349+
sizeof(data), nullptr, &data));
1350+
current_arg_index++;
1351+
}
1352+
1353+
// Validate the contents of `buffer` according to the given validator.
1354+
template <class U>
1355+
void ValidateBuffer(ur_mem_handle_t buffer, size_t size,
1356+
std::function<bool(U &)> validator) {
1357+
std::vector<U> read_buffer(size / sizeof(U));
1358+
ASSERT_SUCCESS(urEnqueueMemBufferRead(queue, buffer, true, 0, size,
1359+
read_buffer.data(), 0, nullptr,
1360+
nullptr));
1361+
ASSERT_TRUE(
1362+
std::all_of(read_buffer.begin(), read_buffer.end(), validator));
1363+
}
1364+
1365+
// Helper that uses the generic validate function to check for a given value.
1366+
template <class U>
1367+
void ValidateBuffer(ur_mem_handle_t buffer, size_t size, U value) {
1368+
auto validator = [&value](U result) -> bool { return result == value; };
1369+
1370+
ValidateBuffer<U>(buffer, size, validator);
1371+
}
1372+
1373+
std::vector<ur_mem_handle_t> buffer_args;
1374+
uint32_t current_arg_index = 0;
1375+
ur_context_handle_t context;
1376+
ur_kernel_handle_t kernel;
1377+
ur_queue_handle_t queue;
1378+
};
1379+
12771380
struct urKernelExecutionTest : urBaseKernelExecutionTest {
12781381
void SetUp() {
12791382
UUR_RETURN_ON_FATAL_FAILURE(urBaseKernelExecutionTest::SetUp());

0 commit comments

Comments
 (0)