1 //
2 // Copyright (c) 2017 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 "harness/compat.h"
17
18 #include <stdio.h>
19 #include <string.h>
20 #include <sys/types.h>
21 #include <sys/stat.h>
22
23 #include "procs.h"
24
25 #include "checker_mem_host_read_only.hpp"
26 #include "checker_mem_host_write_only.hpp"
27 #include "checker_mem_host_no_access.hpp"
28
test_mem_host_read_only_buffer_RW(cl_device_id deviceID,cl_context context,cl_command_queue queue,cl_bool blocking,cl_mem_flags buffer_mem_flag,cl_mem_flags parent_buffer_flag,enum BUFFER_TYPE buffer_type)29 static int test_mem_host_read_only_buffer_RW(
30 cl_device_id deviceID, cl_context context, cl_command_queue queue,
31 cl_bool blocking, cl_mem_flags buffer_mem_flag,
32 cl_mem_flags parent_buffer_flag, enum BUFFER_TYPE buffer_type)
33 {
34 log_info("%s\n", __FUNCTION__);
35 cBuffer_check_mem_host_read_only<TEST_ELEMENT_TYPE> checker(deviceID,
36 context, queue);
37 checker.m_blocking = blocking;
38 checker.buffer_mem_flag = buffer_mem_flag;
39 cl_int err;
40 switch (buffer_type)
41 {
42 case _BUFFER: err = checker.SetupBuffer(); break;
43 case _Sub_BUFFER:
44 err = checker.SetupASSubBuffer(parent_buffer_flag);
45 break;
46 }
47
48 test_error(err, __FUNCTION__);
49 checker.Setup_Test_Environment();
50 err = checker.verify_RW_Buffer();
51 test_error(err, __FUNCTION__);
52 clFinish(queue);
53
54 return err;
55 }
56
test_mem_host_read_only_buffer_RW_Rect(cl_device_id deviceID,cl_context context,cl_command_queue queue,cl_bool blocking,cl_mem_flags buffer_mem_flag,cl_mem_flags parent_buffer_flag,enum BUFFER_TYPE buffer_type)57 static int test_mem_host_read_only_buffer_RW_Rect(
58 cl_device_id deviceID, cl_context context, cl_command_queue queue,
59 cl_bool blocking, cl_mem_flags buffer_mem_flag,
60 cl_mem_flags parent_buffer_flag, enum BUFFER_TYPE buffer_type)
61 {
62 log_info("%s\n", __FUNCTION__);
63
64 cBuffer_check_mem_host_read_only<TEST_ELEMENT_TYPE> checker(deviceID,
65 context, queue);
66 checker.m_blocking = blocking;
67 checker.buffer_mem_flag = buffer_mem_flag;
68 cl_int err;
69 switch (buffer_type)
70 {
71 case _BUFFER: err = checker.SetupBuffer(); break;
72 case _Sub_BUFFER:
73 err = checker.SetupASSubBuffer(parent_buffer_flag);
74 break;
75 }
76
77 test_error(err, __FUNCTION__);
78 checker.Setup_Test_Environment();
79 err = checker.verify_RW_Buffer_rect();
80 test_error(err, __FUNCTION__);
81 clFinish(queue);
82
83 return err;
84 }
85
test_mem_host_read_only_buffer_RW_Mapping(cl_device_id deviceID,cl_context context,cl_command_queue queue,cl_bool blocking,cl_mem_flags buffer_mem_flag,cl_mem_flags parent_buffer_flag,enum BUFFER_TYPE buffer_type)86 static int test_mem_host_read_only_buffer_RW_Mapping(
87 cl_device_id deviceID, cl_context context, cl_command_queue queue,
88 cl_bool blocking, cl_mem_flags buffer_mem_flag,
89 cl_mem_flags parent_buffer_flag, enum BUFFER_TYPE buffer_type)
90 {
91 log_info("%s\n", __FUNCTION__);
92
93 cBuffer_check_mem_host_read_only<TEST_ELEMENT_TYPE> checker(deviceID,
94 context, queue);
95 checker.m_blocking = blocking;
96 checker.buffer_mem_flag = buffer_mem_flag;
97 cl_int err;
98 switch (buffer_type)
99 {
100 case _BUFFER: err = checker.SetupBuffer(); break;
101 case _Sub_BUFFER:
102 err = checker.SetupASSubBuffer(parent_buffer_flag);
103 break;
104 }
105
106 test_error(err, __FUNCTION__);
107 checker.Setup_Test_Environment();
108 err = checker.verify_RW_Buffer_mapping();
109 test_error(err, __FUNCTION__);
110 clFinish(queue);
111
112 return err;
113 }
114
test_mem_host_read_only_buffer(cl_device_id deviceID,cl_context context,cl_command_queue queue,int num_elements)115 int test_mem_host_read_only_buffer(cl_device_id deviceID, cl_context context,
116 cl_command_queue queue, int num_elements)
117 {
118 cl_mem_flags buffer_mem_flags[2] = {
119 CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_READ_ONLY,
120 CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR | CL_MEM_HOST_READ_ONLY
121 };
122
123 cl_int err = CL_SUCCESS;
124
125 cl_bool blocking[2] = { CL_TRUE, CL_FALSE };
126 for (int k = 0; k < 2; k++)
127 for (int i = 0; i < 2; i++)
128 {
129
130 err = test_mem_host_read_only_buffer_RW(
131 deviceID, context, queue, blocking[i], buffer_mem_flags[k], 0,
132 _BUFFER);
133 test_error(err, __FUNCTION__);
134
135 err = test_mem_host_read_only_buffer_RW_Rect(
136 deviceID, context, queue, blocking[i], buffer_mem_flags[k], 0,
137 _BUFFER);
138 test_error(err, __FUNCTION__);
139
140 err = test_mem_host_read_only_buffer_RW_Mapping(
141 deviceID, context, queue, blocking[i], buffer_mem_flags[k], 0,
142 _BUFFER);
143 test_error(err, __FUNCTION__);
144 }
145
146 return err;
147 }
148
test_mem_host_read_only_subbuffer(cl_device_id deviceID,cl_context context,cl_command_queue queue,int num_elements)149 int test_mem_host_read_only_subbuffer(cl_device_id deviceID, cl_context context,
150 cl_command_queue queue, int num_elements)
151 {
152 cl_mem_flags parent_buffer_mem_flags[1] = { CL_MEM_READ_WRITE
153 | CL_MEM_USE_HOST_PTR
154 | CL_MEM_HOST_READ_ONLY };
155
156 cl_mem_flags buffer_mem_flags[4] = {
157 0, CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR,
158 CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR,
159 CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR
160 };
161
162 cl_int err = CL_SUCCESS;
163
164 cl_bool blocking[2] = { CL_TRUE, CL_FALSE };
165
166 for (int p = 0; p < 1; p++)
167 {
168 for (int k = 0; k < 4; k++)
169 for (int i = 0; i < 2; i++)
170 {
171 err = test_mem_host_read_only_buffer_RW(
172 deviceID, context, queue, blocking[i], buffer_mem_flags[k],
173 parent_buffer_mem_flags[p], _Sub_BUFFER);
174 test_error(err, __FUNCTION__);
175
176 err = test_mem_host_read_only_buffer_RW_Rect(
177 deviceID, context, queue, blocking[i], buffer_mem_flags[k],
178 parent_buffer_mem_flags[p], _Sub_BUFFER);
179 test_error(err, __FUNCTION__);
180
181 err = test_mem_host_read_only_buffer_RW_Mapping(
182 deviceID, context, queue, blocking[i], buffer_mem_flags[k],
183 parent_buffer_mem_flags[p], _Sub_BUFFER);
184 test_error(err, __FUNCTION__);
185 }
186 }
187
188 return err;
189 }
190
191 //=============================== Write only
192
test_mem_host_write_only_buffer_RW(cl_device_id deviceID,cl_context context,cl_command_queue queue,cl_bool blocking,cl_mem_flags buffer_mem_flag,cl_mem_flags parent_buffer_flag,enum BUFFER_TYPE buffer_type)193 static cl_int test_mem_host_write_only_buffer_RW(
194 cl_device_id deviceID, cl_context context, cl_command_queue queue,
195 cl_bool blocking, cl_mem_flags buffer_mem_flag,
196 cl_mem_flags parent_buffer_flag, enum BUFFER_TYPE buffer_type)
197 {
198 log_info("%s\n", __FUNCTION__);
199
200 cBuffer_check_mem_host_write_only<TEST_ELEMENT_TYPE> checker(
201 deviceID, context, queue);
202
203 checker.m_blocking = blocking;
204 checker.buffer_mem_flag = buffer_mem_flag;
205 cl_int err;
206 switch (buffer_type)
207 {
208 case _BUFFER: err = checker.SetupBuffer(); break;
209 case _Sub_BUFFER:
210 err = checker.SetupASSubBuffer(parent_buffer_flag);
211 break;
212 }
213
214 test_error(err, __FUNCTION__);
215 checker.Setup_Test_Environment();
216 err = checker.verify_RW_Buffer();
217 test_error(err, __FUNCTION__);
218 clFinish(queue);
219
220 return err;
221 }
222
test_mem_host_write_only_buffer_RW_Rect(cl_device_id deviceID,cl_context context,cl_command_queue queue,cl_bool blocking,cl_mem_flags buffer_mem_flag,cl_mem_flags parent_buffer_flag,enum BUFFER_TYPE buffer_type)223 static cl_int test_mem_host_write_only_buffer_RW_Rect(
224 cl_device_id deviceID, cl_context context, cl_command_queue queue,
225 cl_bool blocking, cl_mem_flags buffer_mem_flag,
226 cl_mem_flags parent_buffer_flag, enum BUFFER_TYPE buffer_type)
227 {
228 log_info("%s\n", __FUNCTION__);
229
230 cBuffer_check_mem_host_write_only<TEST_ELEMENT_TYPE> checker(
231 deviceID, context, queue);
232 checker.m_blocking = blocking;
233 checker.buffer_mem_flag = buffer_mem_flag;
234 cl_int err;
235 switch (buffer_type)
236 {
237 case _BUFFER: err = checker.SetupBuffer(); break;
238 case _Sub_BUFFER:
239 err = checker.SetupASSubBuffer(parent_buffer_flag);
240 break;
241 }
242
243 test_error(err, __FUNCTION__);
244 checker.Setup_Test_Environment();
245 err = checker.verify_RW_Buffer_rect();
246 test_error(err, __FUNCTION__);
247 clFinish(queue);
248
249 return err;
250 }
251
test_mem_host_write_only_buffer_RW_Mapping(cl_device_id deviceID,cl_context context,cl_command_queue queue,cl_bool blocking,cl_mem_flags buffer_mem_flag,cl_mem_flags parent_buffer_flag,enum BUFFER_TYPE buffer_type)252 static cl_int test_mem_host_write_only_buffer_RW_Mapping(
253 cl_device_id deviceID, cl_context context, cl_command_queue queue,
254 cl_bool blocking, cl_mem_flags buffer_mem_flag,
255 cl_mem_flags parent_buffer_flag, enum BUFFER_TYPE buffer_type)
256 {
257 log_info("%s\n", __FUNCTION__);
258
259 cBuffer_check_mem_host_write_only<TEST_ELEMENT_TYPE> checker(
260 deviceID, context, queue);
261 checker.m_blocking = blocking;
262 checker.buffer_mem_flag = buffer_mem_flag;
263 cl_int err;
264 switch (buffer_type)
265 {
266 case _BUFFER: err = checker.SetupBuffer(); break;
267 case _Sub_BUFFER:
268 err = checker.SetupASSubBuffer(parent_buffer_flag);
269 break;
270 }
271
272 test_error(err, __FUNCTION__);
273 checker.Setup_Test_Environment();
274 err = checker.verify_RW_Buffer_mapping();
275 test_error(err, __FUNCTION__);
276 clFinish(queue);
277
278 return err;
279 }
280
test_mem_host_write_only_buffer(cl_device_id deviceID,cl_context context,cl_command_queue queue,int num_elements)281 int test_mem_host_write_only_buffer(cl_device_id deviceID, cl_context context,
282 cl_command_queue queue, int num_elements)
283 {
284 cl_mem_flags buffer_mem_flags[2] = {
285 CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_WRITE_ONLY,
286 CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR | CL_MEM_HOST_WRITE_ONLY
287 };
288
289 cl_int err = CL_SUCCESS;
290
291 cl_bool blocking[2] = { CL_TRUE, CL_FALSE };
292 for (int k = 0; k < 2; k++)
293 for (int i = 0; i < 2; i++)
294 {
295 err = test_mem_host_write_only_buffer_RW(
296 deviceID, context, queue, blocking[i], buffer_mem_flags[k], 0,
297 _BUFFER);
298 test_error(err, __FUNCTION__);
299
300 err = test_mem_host_write_only_buffer_RW_Rect(
301 deviceID, context, queue, blocking[i], buffer_mem_flags[k], 0,
302 _BUFFER);
303 test_error(err, __FUNCTION__);
304
305 err = test_mem_host_write_only_buffer_RW_Mapping(
306 deviceID, context, queue, blocking[i], buffer_mem_flags[k], 0,
307 _BUFFER);
308 test_error(err, __FUNCTION__);
309 }
310
311 return err;
312 }
313
test_mem_host_write_only_subbuffer(cl_device_id deviceID,cl_context context,cl_command_queue queue,int num_elements)314 int test_mem_host_write_only_subbuffer(cl_device_id deviceID,
315 cl_context context,
316 cl_command_queue queue, int num_elements)
317 {
318 cl_mem_flags parent_buffer_mem_flags[1] = { CL_MEM_READ_WRITE
319 | CL_MEM_USE_HOST_PTR
320 | CL_MEM_HOST_WRITE_ONLY };
321
322 cl_mem_flags buffer_mem_flags[4] = {
323 0, CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR,
324 CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR,
325 CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR
326 };
327
328 cl_int err = CL_SUCCESS;
329
330 cl_bool blocking[2] = { CL_TRUE, CL_FALSE };
331
332 for (int p = 0; p < 1; p++)
333 {
334 for (int m = 0; m < 4; m++)
335 {
336 for (int i = 0; i < 2; i++)
337 {
338 err = test_mem_host_write_only_buffer_RW(
339 deviceID, context, queue, blocking[i], buffer_mem_flags[m],
340 parent_buffer_mem_flags[p], _Sub_BUFFER);
341 test_error(err, __FUNCTION__);
342
343 err = test_mem_host_write_only_buffer_RW_Rect(
344 deviceID, context, queue, blocking[i], buffer_mem_flags[m],
345 parent_buffer_mem_flags[p], _Sub_BUFFER);
346 test_error(err, __FUNCTION__);
347
348 err = test_mem_host_write_only_buffer_RW_Mapping(
349 deviceID, context, queue, blocking[i], buffer_mem_flags[m],
350 parent_buffer_mem_flags[p], _Sub_BUFFER);
351 test_error(err, __FUNCTION__);
352 }
353 }
354 }
355
356 return err;
357 }
358
359 //===================== NO ACCESS
360
test_mem_host_no_access_buffer_RW(cl_device_id deviceID,cl_context context,cl_command_queue queue,cl_bool blocking,cl_mem_flags buffer_mem_flag,cl_mem_flags parent_buffer_flag,enum BUFFER_TYPE buffer_type)361 static cl_int test_mem_host_no_access_buffer_RW(
362 cl_device_id deviceID, cl_context context, cl_command_queue queue,
363 cl_bool blocking, cl_mem_flags buffer_mem_flag,
364 cl_mem_flags parent_buffer_flag, enum BUFFER_TYPE buffer_type)
365 {
366 log_info("%s\n", __FUNCTION__);
367
368 cBuffer_check_mem_host_no_access<TEST_ELEMENT_TYPE> checker(deviceID,
369 context, queue);
370 checker.m_blocking = blocking;
371 checker.buffer_mem_flag = buffer_mem_flag;
372
373 cl_int err = CL_SUCCESS;
374 switch (buffer_type)
375 {
376 case _BUFFER: err = checker.SetupBuffer(); break;
377 case _Sub_BUFFER:
378 err = checker.SetupASSubBuffer(parent_buffer_flag);
379 break;
380 }
381
382 test_error(err, __FUNCTION__);
383 checker.Setup_Test_Environment();
384 err = checker.verify_RW_Buffer_mapping();
385 test_error(err, __FUNCTION__);
386 clFinish(queue);
387
388 return err;
389 }
390
test_mem_host_no_access_buffer_RW_Rect(cl_device_id deviceID,cl_context context,cl_command_queue queue,cl_bool blocking,cl_mem_flags buffer_mem_flag,cl_mem_flags parent_buffer_flag,enum BUFFER_TYPE buffer_type)391 static cl_int test_mem_host_no_access_buffer_RW_Rect(
392 cl_device_id deviceID, cl_context context, cl_command_queue queue,
393 cl_bool blocking, cl_mem_flags buffer_mem_flag,
394 cl_mem_flags parent_buffer_flag, enum BUFFER_TYPE buffer_type)
395 {
396 log_info("%s\n", __FUNCTION__);
397
398 cBuffer_check_mem_host_no_access<TEST_ELEMENT_TYPE> checker(deviceID,
399 context, queue);
400 checker.m_blocking = blocking;
401 checker.buffer_mem_flag = buffer_mem_flag;
402 cl_int err;
403 switch (buffer_type)
404 {
405 case _BUFFER: err = checker.SetupBuffer(); break;
406 case _Sub_BUFFER:
407 err = checker.SetupASSubBuffer(parent_buffer_flag);
408 break;
409 }
410
411 test_error(err, __FUNCTION__);
412 checker.Setup_Test_Environment();
413 err = checker.verify_RW_Buffer_mapping();
414 test_error(err, __FUNCTION__);
415 clFinish(queue);
416
417 return err;
418 }
419
test_mem_host_no_access_buffer_RW_Mapping(cl_device_id deviceID,cl_context context,cl_command_queue queue,cl_bool blocking,cl_mem_flags buffer_mem_flag,cl_mem_flags parent_buffer_flag,enum BUFFER_TYPE buffer_type)420 static cl_int test_mem_host_no_access_buffer_RW_Mapping(
421 cl_device_id deviceID, cl_context context, cl_command_queue queue,
422 cl_bool blocking, cl_mem_flags buffer_mem_flag,
423 cl_mem_flags parent_buffer_flag, enum BUFFER_TYPE buffer_type)
424 {
425 log_info("%s\n", __FUNCTION__);
426
427 cBuffer_check_mem_host_no_access<TEST_ELEMENT_TYPE> checker(deviceID,
428 context, queue);
429
430 checker.m_blocking = blocking;
431 checker.buffer_mem_flag = buffer_mem_flag;
432 cl_int err;
433 switch (buffer_type)
434 {
435 case _BUFFER: err = checker.SetupBuffer(); break;
436 case _Sub_BUFFER:
437 err = checker.SetupASSubBuffer(parent_buffer_flag);
438 break;
439 }
440
441 test_error(err, __FUNCTION__);
442 checker.Setup_Test_Environment();
443 err = checker.verify_RW_Buffer_mapping();
444 test_error(err, __FUNCTION__);
445 clFinish(queue);
446
447 return err;
448 }
449
test_mem_host_no_access_buffer(cl_device_id deviceID,cl_context context,cl_command_queue queue,int num_elements)450 int test_mem_host_no_access_buffer(cl_device_id deviceID, cl_context context,
451 cl_command_queue queue, int num_elements)
452 {
453 cl_mem_flags buffer_mem_flag[2] = {
454 CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_NO_ACCESS,
455 CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR | CL_MEM_HOST_NO_ACCESS
456 };
457
458 cl_int err = CL_SUCCESS;
459
460 cl_bool blocking[2] = { CL_TRUE, CL_FALSE };
461 for (int k = 0; k < 2; k++)
462 for (int i = 0; i < 2; i++)
463 {
464 err = test_mem_host_no_access_buffer_RW(
465 deviceID, context, queue, blocking[i], buffer_mem_flag[k], 0,
466 _BUFFER);
467 test_error(err, __FUNCTION__);
468
469 err = test_mem_host_no_access_buffer_RW_Rect(
470 deviceID, context, queue, blocking[i], buffer_mem_flag[k], 0,
471 _BUFFER);
472 test_error(err, __FUNCTION__);
473
474 err = test_mem_host_no_access_buffer_RW_Mapping(
475 deviceID, context, queue, blocking[i], buffer_mem_flag[k], 0,
476 _BUFFER);
477 test_error(err, __FUNCTION__);
478 }
479
480 return err;
481 }
482
test_mem_host_no_access_subbuffer(cl_device_id deviceID,cl_context context,cl_command_queue queue,int num_elements)483 int test_mem_host_no_access_subbuffer(cl_device_id deviceID, cl_context context,
484 cl_command_queue queue, int num_elements)
485 {
486 cl_mem_flags parent_buffer_mem_flags[3] = {
487 CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_NO_ACCESS,
488 CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_NO_ACCESS,
489 CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_NO_ACCESS
490 };
491
492 cl_mem_flags buffer_mem_flags[4] = {
493 0, CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR,
494 CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR,
495 CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR
496 };
497
498 cl_int err = CL_SUCCESS;
499
500 cl_bool blocking[2] = { CL_TRUE, CL_FALSE };
501 for (int p = 0; p < 3; p++)
502 {
503 for (int k = 0; k < 4; k++)
504 {
505 for (int i = 0; i < 2; i++)
506 {
507 err += test_mem_host_no_access_buffer_RW(
508 deviceID, context, queue, blocking[i], buffer_mem_flags[k],
509 parent_buffer_mem_flags[p], _Sub_BUFFER);
510
511 err += test_mem_host_no_access_buffer_RW_Rect(
512 deviceID, context, queue, blocking[i], buffer_mem_flags[k],
513 parent_buffer_mem_flags[p], _Sub_BUFFER);
514
515 err += test_mem_host_no_access_buffer_RW_Mapping(
516 deviceID, context, queue, blocking[i], buffer_mem_flags[k],
517 parent_buffer_mem_flags[p], _Sub_BUFFER);
518 }
519 }
520 }
521
522 return err;
523 }
524