1 //
2 // Copyright (c) 2022 The Khronos Group Inc.
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 // http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16 #include "basic_command_buffer.h"
17 #include "svm_command_basic.h"
18 #include "harness/typeWrappers.h"
19 #include "procs.h"
20
21 #include <vector>
22
23
24 namespace {
25
26 ////////////////////////////////////////////////////////////////////////////////
27 // Command-buffer copy tests which handles below cases:
28 //
29 // -copy image
30 // -copy buffer
31 // -copy buffer to image
32 // -copy image to buffer
33 // -copy buffer rect
34
35 struct CopyImageKHR : public BasicCommandBufferTest
36 {
37 using BasicCommandBufferTest::BasicCommandBufferTest;
38
Run__anon8153e59f0111::CopyImageKHR39 cl_int Run() override
40 {
41 cl_int error = clCommandFillImageKHR(command_buffer, nullptr, src_image,
42 fill_color_1, origin, region, 0,
43 nullptr, nullptr, nullptr);
44
45 test_error(error, "clCommandFillImageKHR failed");
46
47 error = clCommandCopyImageKHR(command_buffer, nullptr, src_image,
48 dst_image, origin, origin, region, 0, 0,
49 nullptr, nullptr);
50
51 test_error(error, "clCommandCopyImageKHR failed");
52
53 error = clFinalizeCommandBufferKHR(command_buffer);
54 test_error(error, "clFinalizeCommandBufferKHR failed");
55
56 error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
57 nullptr, nullptr);
58 test_error(error, "clEnqueueCommandBufferKHR failed");
59
60 std::vector<cl_char> output_data_1(data_size);
61 error =
62 clEnqueueReadImage(queue, dst_image, CL_TRUE, origin, region, 0, 0,
63 output_data_1.data(), 0, nullptr, nullptr);
64
65 for (size_t i = 0; i < data_size; i++)
66 {
67 CHECK_VERIFICATION_ERROR(pattern_1, output_data_1[i], i);
68 }
69
70 /* Check second enqueue of command buffer */
71
72 error = clEnqueueFillImage(queue, src_image, fill_color_2, origin,
73 region, 0, nullptr, nullptr);
74 test_error(error, "clEnqueueFillImageKHR failed");
75
76 error = clEnqueueFillImage(queue, dst_image, fill_color_2, origin,
77 region, 0, nullptr, nullptr);
78 test_error(error, "clEnqueueFillImageKHR failed");
79
80 error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
81 nullptr, nullptr);
82 test_error(error, "clEnqueueCommandBufferKHR failed");
83
84 std::vector<cl_char> output_data_2(data_size);
85 error =
86 clEnqueueReadImage(queue, dst_image, CL_TRUE, origin, region, 0, 0,
87 output_data_2.data(), 0, nullptr, nullptr);
88
89 for (size_t i = 0; i < data_size; i++)
90 {
91 CHECK_VERIFICATION_ERROR(pattern_1, output_data_2[i], i);
92 }
93
94 return CL_SUCCESS;
95 }
96
SetUp__anon8153e59f0111::CopyImageKHR97 cl_int SetUp(int elements) override
98 {
99 cl_int error = BasicCommandBufferTest::SetUp(elements);
100 test_error(error, "BasicCommandBufferTest::SetUp failed");
101
102 src_image = create_image_2d(context, CL_MEM_READ_ONLY, &formats,
103 img_width, img_height, 0, NULL, &error);
104 test_error(error, "create_image_2d failed");
105
106 dst_image = create_image_2d(context, CL_MEM_WRITE_ONLY, &formats,
107 img_width, img_height, 0, NULL, &error);
108 test_error(error, "create_image_2d failed");
109
110 return CL_SUCCESS;
111 }
112
Skip__anon8153e59f0111::CopyImageKHR113 bool Skip() override
114 {
115 bool imageSupport =
116 checkForImageSupport(device) == CL_IMAGE_FORMAT_NOT_SUPPORTED;
117
118 return imageSupport || BasicCommandBufferTest::Skip();
119 }
120
121 const size_t img_width = 512;
122 const size_t img_height = 512;
123 const size_t data_size = img_width * img_height * 4 * sizeof(cl_char);
124 const size_t origin[3] = { 0, 0, 0 },
125 region[3] = { img_width, img_height, 1 };
126 const cl_uint pattern_1 = 0x05;
127 const cl_uint fill_color_1[4] = { pattern_1, pattern_1, pattern_1,
128 pattern_1 };
129 const cl_uint pattern_2 = 0x1;
130 const cl_uint fill_color_2[4] = { pattern_2, pattern_2, pattern_2,
131 pattern_2 };
132 const cl_image_format formats = { CL_RGBA, CL_UNSIGNED_INT8 };
133 clMemWrapper src_image;
134 clMemWrapper dst_image;
135 };
136
137 struct CopyBufferKHR : public BasicCommandBufferTest
138 {
139 using BasicCommandBufferTest::BasicCommandBufferTest;
140
Run__anon8153e59f0111::CopyBufferKHR141 cl_int Run() override
142 {
143 cl_int error = clCommandFillBufferKHR(
144 command_buffer, nullptr, in_mem, &pattern_1, sizeof(cl_char), 0,
145 data_size(), 0, nullptr, nullptr, nullptr);
146 test_error(error, "clCommandFillBufferKHR failed");
147
148 error = clCommandCopyBufferKHR(command_buffer, nullptr, in_mem, out_mem,
149 0, 0, data_size(), 0, nullptr, nullptr,
150 nullptr);
151 test_error(error, "clCommandCopyBufferKHR failed");
152
153 error = clFinalizeCommandBufferKHR(command_buffer);
154 test_error(error, "clFinalizeCommandBufferKHR failed");
155
156 error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
157 nullptr, nullptr);
158 test_error(error, "clEnqueueCommandBufferKHR failed");
159
160 std::vector<cl_char> output_data_1(data_size());
161 error = clEnqueueReadBuffer(queue, out_mem, CL_TRUE, 0, data_size(),
162 output_data_1.data(), 0, nullptr, nullptr);
163 test_error(error, "clEnqueueReadBuffer failed");
164
165 for (size_t i = 0; i < data_size(); i++)
166 {
167 CHECK_VERIFICATION_ERROR(pattern_1, output_data_1[i], i);
168 }
169
170 /* Check second enqueue of command buffer */
171
172 error = clEnqueueFillBuffer(queue, in_mem, &pattern_2, sizeof(cl_char),
173 0, data_size(), 0, nullptr, nullptr);
174 test_error(error, "clEnqueueFillBufferKHR failed");
175
176 error = clEnqueueFillBuffer(queue, out_mem, &pattern_2, sizeof(cl_char),
177 0, data_size(), 0, nullptr, nullptr);
178 test_error(error, "clEnqueueFillBufferKHR failed");
179
180 error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
181 nullptr, nullptr);
182 test_error(error, "clEnqueueCommandBufferKHR failed");
183
184 std::vector<cl_char> output_data_2(data_size());
185 error = clEnqueueReadBuffer(queue, out_mem, CL_TRUE, 0, data_size(),
186 output_data_2.data(), 0, nullptr, nullptr);
187 test_error(error, "clEnqueueReadBuffer failed");
188
189 for (size_t i = 0; i < data_size(); i++)
190 {
191 CHECK_VERIFICATION_ERROR(pattern_1, output_data_2[i], i);
192 }
193
194 return CL_SUCCESS;
195 }
196
197 const cl_char pattern_1 = 0x14;
198 const cl_char pattern_2 = 0x28;
199 };
200
201 struct CopySVMBufferKHR : public BasicSVMCommandBufferTest
202 {
203 using BasicSVMCommandBufferTest::BasicSVMCommandBufferTest;
204
Run__anon8153e59f0111::CopySVMBufferKHR205 cl_int Run() override
206 {
207 cl_int error = clCommandSVMMemFillKHR(
208 command_buffer, nullptr, svm_in_mem(), &pattern_1, sizeof(cl_char),
209 data_size(), 0, nullptr, nullptr, nullptr);
210 test_error(error, "clCommandSVMMemFillKHR failed");
211
212 error = clCommandSVMMemcpyKHR(command_buffer, nullptr, svm_out_mem(),
213 svm_in_mem(), data_size(), 0, nullptr,
214 nullptr, nullptr);
215 test_error(error, "clCommandSVMMemcpyKHR failed");
216
217 error = clFinalizeCommandBufferKHR(command_buffer);
218 test_error(error, "clFinalizeCommandBufferKHR failed");
219
220 error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
221 nullptr, nullptr);
222 test_error(error, "clEnqueueCommandBufferKHR failed");
223
224 std::vector<cl_char> output_data_1(data_size());
225 error =
226 clEnqueueSVMMemcpy(queue, CL_TRUE, output_data_1.data(),
227 svm_out_mem(), data_size(), 0, nullptr, nullptr);
228 test_error(error, "clEnqueueSVMMemcpy failed");
229
230 for (size_t i = 0; i < data_size(); i++)
231 {
232 CHECK_VERIFICATION_ERROR(pattern_1, output_data_1[i], i);
233 }
234
235 /* Check second enqueue of command buffer */
236 error = clEnqueueSVMMemFill(queue, svm_in_mem(), &pattern_2,
237 sizeof(cl_char), data_size(), 0, nullptr,
238 nullptr);
239 test_error(error, "clEnqueueSVMMemFill failed");
240
241 error = clEnqueueSVMMemFill(queue, svm_out_mem(), &pattern_2,
242 sizeof(cl_char), data_size(), 0, nullptr,
243 nullptr);
244 test_error(error, "clEnqueueSVMMemFill failed");
245
246 error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
247 nullptr, nullptr);
248 test_error(error, "clEnqueueCommandBufferKHR failed");
249
250 std::vector<cl_char> output_data_2(data_size());
251
252 error =
253 clEnqueueSVMMemcpy(queue, CL_TRUE, output_data_2.data(),
254 svm_out_mem(), data_size(), 0, nullptr, nullptr);
255 test_error(error, "clEnqueueSVMMemcpy failed");
256
257 for (size_t i = 0; i < data_size(); i++)
258 {
259 CHECK_VERIFICATION_ERROR(pattern_1, output_data_2[i], i);
260 }
261
262 return CL_SUCCESS;
263 }
264
265 const cl_char pattern_1 = 0x14;
266 const cl_char pattern_2 = 0x28;
267 };
268
269 struct CopyBufferToImageKHR : public BasicCommandBufferTest
270 {
271 using BasicCommandBufferTest::BasicCommandBufferTest;
272
Run__anon8153e59f0111::CopyBufferToImageKHR273 cl_int Run() override
274 {
275 cl_int error = clCommandFillBufferKHR(
276 command_buffer, nullptr, buffer, &pattern_1, sizeof(cl_char), 0,
277 data_size, 0, nullptr, nullptr, nullptr);
278
279 test_error(error, "clCommandFillBufferKHR failed");
280
281 error = clCommandCopyBufferToImageKHR(command_buffer, nullptr, buffer,
282 image, 0, origin, region, 0, 0,
283 nullptr, nullptr);
284
285 test_error(error, "clCommandCopyBufferToImageKHR failed");
286
287 error = clFinalizeCommandBufferKHR(command_buffer);
288 test_error(error, "clFinalizeCommandBufferKHR failed");
289
290 error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
291 nullptr, nullptr);
292 test_error(error, "clEnqueueCommandBufferKHR failed");
293
294 std::vector<cl_char> output_data_1(data_size);
295
296 error = clEnqueueReadImage(queue, image, CL_TRUE, origin, region, 0, 0,
297 output_data_1.data(), 0, nullptr, nullptr);
298 test_error(error, "clEnqueueReadImage failed");
299
300 for (size_t i = 0; i < data_size; i++)
301 {
302 CHECK_VERIFICATION_ERROR(pattern_1, output_data_1[i], i);
303 }
304
305 /* Check second enqueue of command buffer */
306
307 error = clEnqueueFillBuffer(queue, buffer, &pattern_2, sizeof(cl_char),
308 0, data_size, 0, nullptr, nullptr);
309 test_error(error, "clEnqueueFillBuffer failed");
310
311 error = clEnqueueFillImage(queue, image, &fill_color_2, origin, region,
312 0, nullptr, nullptr);
313 test_error(error, "clEnqueueFillImage failed");
314
315 error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
316 nullptr, nullptr);
317 test_error(error, "clEnqueueCommandBufferKHR failed");
318
319 std::vector<cl_char> output_data_2(data_size);
320
321 error = clEnqueueReadImage(queue, image, CL_TRUE, origin, region, 0, 0,
322 output_data_2.data(), 0, nullptr, nullptr);
323 test_error(error, "clEnqueueReadImage failed");
324
325 for (size_t i = 0; i < data_size; i++)
326 {
327 CHECK_VERIFICATION_ERROR(pattern_1, output_data_2[i], i);
328 }
329
330 return CL_SUCCESS;
331 }
332
SetUp__anon8153e59f0111::CopyBufferToImageKHR333 cl_int SetUp(int elements) override
334 {
335 cl_int error = BasicCommandBufferTest::SetUp(elements);
336 test_error(error, "BasicCommandBufferTest::SetUp failed");
337
338 image = create_image_2d(context, CL_MEM_READ_WRITE, &formats, img_width,
339 img_height, 0, NULL, &error);
340 test_error(error, "create_image_2d failed");
341
342 buffer = clCreateBuffer(context, CL_MEM_READ_WRITE, data_size, nullptr,
343 &error);
344 test_error(error, "Unable to create buffer");
345
346 return CL_SUCCESS;
347 }
348
Skip__anon8153e59f0111::CopyBufferToImageKHR349 bool Skip() override
350 {
351 bool imageSupport =
352 checkForImageSupport(device) == CL_IMAGE_FORMAT_NOT_SUPPORTED;
353
354 return imageSupport || BasicCommandBufferTest::Skip();
355 }
356
357 const size_t img_width = 512;
358 const size_t img_height = 512;
359 const size_t data_size = img_width * img_height * 4 * sizeof(cl_char);
360 const size_t origin[3] = { 0, 0, 0 },
361 region[3] = { img_width, img_height, 1 };
362 const cl_char pattern_1 = 0x11;
363 const cl_char pattern_2 = 0x22;
364
365 const cl_uint fill_color_2[4] = { static_cast<cl_uint>(pattern_2),
366 static_cast<cl_uint>(pattern_2),
367 static_cast<cl_uint>(pattern_2),
368 static_cast<cl_uint>(pattern_2) };
369
370 const cl_image_format formats = { CL_RGBA, CL_UNSIGNED_INT8 };
371
372 clMemWrapper buffer;
373 clMemWrapper image;
374 };
375
376 struct CopyImageToBufferKHR : public BasicCommandBufferTest
377 {
378 using BasicCommandBufferTest::BasicCommandBufferTest;
379
Run__anon8153e59f0111::CopyImageToBufferKHR380 cl_int Run() override
381 {
382 cl_int error =
383 clCommandFillImageKHR(command_buffer, nullptr, image, fill_color_1,
384 origin, region, 0, nullptr, nullptr, nullptr);
385
386 test_error(error, "clCommandFillImageKHR failed");
387
388 error = clCommandCopyImageToBufferKHR(command_buffer, nullptr, image,
389 buffer, origin, region, 0, 0,
390 nullptr, nullptr, nullptr);
391
392 test_error(error, "clCommandCopyImageToBufferKHR failed");
393
394 error = clFinalizeCommandBufferKHR(command_buffer);
395 test_error(error, "clFinalizeCommandBufferKHR failed");
396
397 error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
398 nullptr, nullptr);
399 test_error(error, "clEnqueueCommandBufferKHR failed");
400
401 std::vector<cl_char> output_data_1(data_size);
402
403 error = clEnqueueReadBuffer(queue, buffer, CL_TRUE, 0, data_size,
404 output_data_1.data(), 0, nullptr, nullptr);
405 test_error(error, "clEnqueueReadBuffer failed");
406
407 for (size_t i = 0; i < data_size; i++)
408 {
409 CHECK_VERIFICATION_ERROR(static_cast<cl_char>(pattern_1),
410 output_data_1[i], i);
411 }
412
413 error = clEnqueueFillImage(queue, image, fill_color_2, origin, region,
414 0, nullptr, nullptr);
415 test_error(error, "clEnqueueFillImage failed");
416
417 error = clEnqueueFillBuffer(queue, buffer, &pattern_2, sizeof(cl_char),
418 0, data_size, 0, nullptr, nullptr);
419
420 error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
421 nullptr, nullptr);
422 test_error(error, "clEnqueueCommandBufferKHR failed");
423
424 std::vector<cl_char> output_data_2(data_size);
425
426 error = clEnqueueReadBuffer(queue, buffer, CL_TRUE, 0, data_size,
427 output_data_2.data(), 0, nullptr, nullptr);
428 test_error(error, "clEnqueueReadBuffer failed");
429
430 for (size_t i = 0; i < data_size; i++)
431 {
432 CHECK_VERIFICATION_ERROR(static_cast<cl_char>(pattern_1),
433 output_data_2[i], i);
434 }
435
436 return CL_SUCCESS;
437 }
438
SetUp__anon8153e59f0111::CopyImageToBufferKHR439 cl_int SetUp(int elements) override
440 {
441 cl_int error = BasicCommandBufferTest::SetUp(elements);
442 test_error(error, "BasicCommandBufferTest::SetUp failed");
443
444 image = create_image_2d(context, CL_MEM_READ_WRITE, &formats, img_width,
445 img_height, 0, NULL, &error);
446 test_error(error, "create_image_2d failed");
447
448 buffer = clCreateBuffer(context, CL_MEM_READ_WRITE, data_size, nullptr,
449 &error);
450 test_error(error, "Unable to create buffer");
451
452 return CL_SUCCESS;
453 }
454
Skip__anon8153e59f0111::CopyImageToBufferKHR455 bool Skip() override
456 {
457 bool imageSupport =
458 checkForImageSupport(device) == CL_IMAGE_FORMAT_NOT_SUPPORTED;
459
460 return imageSupport || BasicCommandBufferTest::Skip();
461 }
462
463 const size_t img_width = 512;
464 const size_t img_height = 512;
465 const size_t data_size = img_width * img_height * 4 * sizeof(cl_char);
466 const size_t origin[3] = { 0, 0, 0 },
467 region[3] = { img_width, img_height, 1 };
468 const cl_uint pattern_1 = 0x12;
469 const cl_uint fill_color_1[4] = { pattern_1, pattern_1, pattern_1,
470 pattern_1 };
471 const cl_uint pattern_2 = 0x24;
472 const cl_uint fill_color_2[4] = { pattern_2, pattern_2, pattern_2,
473 pattern_2 };
474 const cl_image_format formats = { CL_RGBA, CL_UNSIGNED_INT8 };
475
476 clMemWrapper image;
477 clMemWrapper buffer;
478 };
479
480 struct CopyBufferRectKHR : public BasicCommandBufferTest
481 {
482 using BasicCommandBufferTest::BasicCommandBufferTest;
483
Run__anon8153e59f0111::CopyBufferRectKHR484 cl_int Run() override
485 {
486 cl_int error = clCommandFillBufferKHR(
487 command_buffer, nullptr, in_mem, &pattern_1, sizeof(cl_char), 0,
488 data_size, 0, nullptr, nullptr, nullptr);
489 test_error(error, "clCommandFillBufferKHR failed");
490
491 error = clCommandCopyBufferRectKHR(
492 command_buffer, nullptr, in_mem, out_mem, origin, origin, region, 0,
493 0, 0, 0, 0, nullptr, nullptr, nullptr);
494
495 test_error(error, "clCommandCopyBufferRectKHR failed");
496
497 error = clFinalizeCommandBufferKHR(command_buffer);
498 test_error(error, "clFinalizeCommandBufferKHR failed");
499
500 error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
501 nullptr, nullptr);
502 test_error(error, "clEnqueueCommandBufferKHR failed");
503
504 std::vector<cl_char> output_data_1(data_size);
505 error = clEnqueueReadBuffer(queue, out_mem, CL_TRUE, 0, data_size,
506 output_data_1.data(), 0, nullptr, nullptr);
507 test_error(error, "clEnqueueReadBuffer failed");
508
509 for (size_t i = 0; i < data_size; i++)
510 {
511 CHECK_VERIFICATION_ERROR(pattern_1, output_data_1[i], i);
512 }
513
514 /* Check second enqueue of command buffer */
515
516 error = clEnqueueFillBuffer(queue, in_mem, &pattern_2, sizeof(cl_char),
517 0, data_size, 0, nullptr, nullptr);
518 test_error(error, "clEnqueueFillBuffer failed");
519
520 error = clEnqueueFillBuffer(queue, out_mem, &pattern_2, sizeof(cl_char),
521 0, data_size, 0, nullptr, nullptr);
522 test_error(error, "clEnqueueFillBuffer failed");
523
524 error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
525 nullptr, nullptr);
526 test_error(error, "clEnqueueCommandBufferKHR failed");
527
528 std::vector<cl_char> output_data_2(data_size);
529 error = clEnqueueReadBuffer(queue, out_mem, CL_TRUE, 0, data_size,
530 output_data_2.data(), 0, nullptr, nullptr);
531 test_error(error, "clEnqueueReadBuffer failed");
532
533 for (size_t i = 0; i < data_size; i++)
534 {
535 CHECK_VERIFICATION_ERROR(pattern_1, output_data_2[i], i);
536 }
537
538 return CL_SUCCESS;
539 }
540
SetUp__anon8153e59f0111::CopyBufferRectKHR541 cl_int SetUp(int elements) override
542 {
543 cl_int error = BasicCommandBufferTest::SetUp(elements);
544 test_error(error, "BasicCommandBufferTest::SetUp failed");
545
546 in_mem = clCreateBuffer(context, CL_MEM_READ_WRITE, data_size, nullptr,
547 &error);
548 test_error(error, "clCreateBuffer failed");
549
550 out_mem = clCreateBuffer(context, CL_MEM_READ_WRITE, data_size, nullptr,
551 &error);
552 test_error(error, "Unable to create buffer");
553
554 return CL_SUCCESS;
555 }
556
557 const size_t img_width = 512;
558 const size_t img_height = 512;
559 const size_t data_size = img_width * img_height * sizeof(cl_char);
560 const size_t origin[3] = { 0, 0, 0 },
561 region[3] = { img_width, img_height, 1 };
562 const cl_char pattern_1 = 0x13;
563 const cl_char pattern_2 = 0x26;
564
565 clMemWrapper in_mem;
566 clMemWrapper out_mem;
567 };
568 };
569
test_copy_image(cl_device_id device,cl_context context,cl_command_queue queue,int num_elements)570 int test_copy_image(cl_device_id device, cl_context context,
571 cl_command_queue queue, int num_elements)
572 {
573 return MakeAndRunTest<CopyImageKHR>(device, context, queue, num_elements);
574 }
575
test_copy_buffer(cl_device_id device,cl_context context,cl_command_queue queue,int num_elements)576 int test_copy_buffer(cl_device_id device, cl_context context,
577 cl_command_queue queue, int num_elements)
578 {
579 return MakeAndRunTest<CopyBufferKHR>(device, context, queue, num_elements);
580 }
581
test_copy_svm_buffer(cl_device_id device,cl_context context,cl_command_queue queue,int num_elements)582 int test_copy_svm_buffer(cl_device_id device, cl_context context,
583 cl_command_queue queue, int num_elements)
584 {
585 return MakeAndRunTest<CopySVMBufferKHR>(device, context, queue,
586 num_elements);
587 }
588
589
test_copy_buffer_to_image(cl_device_id device,cl_context context,cl_command_queue queue,int num_elements)590 int test_copy_buffer_to_image(cl_device_id device, cl_context context,
591 cl_command_queue queue, int num_elements)
592 {
593 return MakeAndRunTest<CopyBufferToImageKHR>(device, context, queue,
594 num_elements);
595 }
596
test_copy_image_to_buffer(cl_device_id device,cl_context context,cl_command_queue queue,int num_elements)597 int test_copy_image_to_buffer(cl_device_id device, cl_context context,
598 cl_command_queue queue, int num_elements)
599 {
600 return MakeAndRunTest<CopyImageToBufferKHR>(device, context, queue,
601 num_elements);
602 }
603
test_copy_buffer_rect(cl_device_id device,cl_context context,cl_command_queue queue,int num_elements)604 int test_copy_buffer_rect(cl_device_id device, cl_context context,
605 cl_command_queue queue, int num_elements)
606 {
607 return MakeAndRunTest<CopyBufferRectKHR>(device, context, queue,
608 num_elements);
609 }
610