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_image_mem_host_read_only.hpp"
26 #include "checker_image_mem_host_no_access.hpp"
27 #include "checker_image_mem_host_write_only.hpp"
28
29 //======================================
test_mem_host_read_only_RW_Image(cl_device_id deviceID,cl_context context,cl_command_queue queue,cl_bool blocking,cl_mem_flags buffer_mem_flag,cl_mem_object_type image_type_in,size_t array_size,size_t * img_dim)30 static cl_int test_mem_host_read_only_RW_Image(
31 cl_device_id deviceID, cl_context context, cl_command_queue queue,
32 cl_bool blocking, cl_mem_flags buffer_mem_flag,
33 cl_mem_object_type image_type_in, size_t array_size, size_t *img_dim)
34 {
35 log_info("%s ... \n ", __FUNCTION__);
36 cl_int err = CL_SUCCESS;
37
38 cImage_check_mem_host_read_only<int> checker(deviceID, context, queue);
39 checker.m_blocking = blocking;
40 checker.buffer_mem_flag = buffer_mem_flag;
41
42 checker.m_cl_Image_desc.image_type = image_type_in;
43 checker.m_cl_Image_desc.image_width = img_dim[0];
44 checker.m_cl_Image_desc.image_height = img_dim[1];
45 checker.m_cl_Image_desc.image_depth = img_dim[2];
46 checker.m_cl_Image_desc.image_array_size = array_size;
47 checker.m_cl_Image_desc.image_row_pitch = 0;
48 checker.m_cl_Image_desc.image_slice_pitch = 0;
49 checker.m_cl_Image_desc.num_mip_levels = 0;
50 checker.m_cl_Image_desc.num_samples = 0;
51
52 checker.SetupImage();
53 checker.Init_rect();
54 err = checker.verify_RW_Image();
55 test_error(err, __FUNCTION__);
56 clFinish(queue);
57 return err;
58 }
59
test_mem_host_read_only_RW_Image_Mapping(cl_device_id deviceID,cl_context context,cl_command_queue queue,cl_bool blocking,cl_mem_flags buffer_mem_flag,cl_mem_object_type image_type_in,size_t array_size,size_t * img_dim)60 static cl_int test_mem_host_read_only_RW_Image_Mapping(
61 cl_device_id deviceID, cl_context context, cl_command_queue queue,
62 cl_bool blocking, cl_mem_flags buffer_mem_flag,
63 cl_mem_object_type image_type_in, size_t array_size, size_t *img_dim)
64 {
65 log_info("%s ... \n ", __FUNCTION__);
66 cl_int err = CL_SUCCESS;
67
68 cImage_check_mem_host_read_only<int> checker(deviceID, context, queue);
69 checker.m_blocking = blocking;
70 checker.buffer_mem_flag = buffer_mem_flag;
71
72 checker.m_cl_Image_desc.image_type = image_type_in;
73 checker.m_cl_Image_desc.image_width = img_dim[0];
74 checker.m_cl_Image_desc.image_height = img_dim[1];
75 checker.m_cl_Image_desc.image_depth = img_dim[2];
76 checker.m_cl_Image_desc.image_array_size = array_size;
77 checker.m_cl_Image_desc.image_row_pitch = 0;
78 checker.m_cl_Image_desc.image_slice_pitch = 0;
79 checker.m_cl_Image_desc.num_mip_levels = 0;
80 checker.m_cl_Image_desc.num_samples = 0;
81
82 checker.SetupImage();
83 checker.Init_rect();
84 err = checker.verify_RW_Image_Mapping();
85 test_error(err, __FUNCTION__);
86 clFinish(queue);
87 return err;
88 }
89
test_mem_host_read_only_image(cl_device_id deviceID,cl_context context,cl_command_queue queue,int num_elements)90 int test_mem_host_read_only_image(cl_device_id deviceID, cl_context context,
91 cl_command_queue queue, int num_elements)
92 {
93 cl_mem_flags buffer_mem_flags[2] = {
94 CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_READ_ONLY,
95 CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR | CL_MEM_HOST_READ_ONLY
96 };
97
98 cl_int err = CL_SUCCESS;
99
100 cl_bool image_support;
101 err = clGetDeviceInfo(deviceID, CL_DEVICE_IMAGE_SUPPORT,
102 sizeof image_support, &image_support, NULL);
103 if (err)
104 {
105 test_error(err, __FUNCTION__);
106 return err;
107 }
108 if (!image_support)
109 {
110 log_info("Images are not supported by the device, skipping test...\n");
111 return 0;
112 }
113
114
115 cl_mem_object_type img_type[5] = {
116 CL_MEM_OBJECT_IMAGE1D, CL_MEM_OBJECT_IMAGE2D, CL_MEM_OBJECT_IMAGE3D,
117 CL_MEM_OBJECT_IMAGE1D_ARRAY, CL_MEM_OBJECT_IMAGE2D_ARRAY
118 };
119
120 size_t img_dims[5][3] = { { 200, 1, 1 },
121 { 200, 80, 1 },
122 { 200, 80, 5 },
123 { 200, 1, 1 },
124 { 200, 80, 10 } }; // in elements
125
126 size_t array_size[5] = { 1, 10, 1, 10, 1 };
127
128 cl_bool blocking[2] = { CL_TRUE, CL_FALSE };
129 for (int flag = 0; flag < 2; flag++)
130 for (int i = 0; i < 2; i++) // blocking
131 {
132 for (int p = 0; p < 3; p++)
133 {
134 err = test_mem_host_read_only_RW_Image(
135 deviceID, context, queue, blocking[i],
136 buffer_mem_flags[flag], img_type[p], array_size[p],
137 img_dims[p]);
138
139 test_error(err, __FUNCTION__);
140
141 err = test_mem_host_read_only_RW_Image_Mapping(
142 deviceID, context, queue, blocking[i],
143 buffer_mem_flags[flag], img_type[p], array_size[p],
144 img_dims[p]);
145
146 test_error(err, __FUNCTION__);
147 }
148 }
149
150 return err;
151 }
152
153 //----------------------------
test_MEM_HOST_WRITE_ONLY_Image_RW(cl_device_id deviceID,cl_context context,cl_command_queue queue,cl_bool blocking,cl_mem_flags buffer_mem_flag,cl_mem_object_type image_type_in,size_t array_size,size_t * img_dim)154 static cl_int test_MEM_HOST_WRITE_ONLY_Image_RW(
155 cl_device_id deviceID, cl_context context, cl_command_queue queue,
156 cl_bool blocking, cl_mem_flags buffer_mem_flag,
157 cl_mem_object_type image_type_in, size_t array_size, size_t *img_dim)
158 {
159 log_info(" %s ... \n ", __FUNCTION__);
160 cl_int err = CL_SUCCESS;
161
162 cImage_check_mem_host_write_only<int> checker(deviceID, context, queue);
163 checker.m_blocking = blocking;
164 checker.buffer_mem_flag = buffer_mem_flag;
165
166 checker.m_cl_Image_desc.image_type = image_type_in;
167 checker.m_cl_Image_desc.image_width = img_dim[0];
168 checker.m_cl_Image_desc.image_height = img_dim[1];
169 checker.m_cl_Image_desc.image_depth = img_dim[2];
170 checker.m_cl_Image_desc.image_array_size = array_size;
171 checker.m_cl_Image_desc.image_row_pitch = 0;
172 checker.m_cl_Image_desc.image_slice_pitch = 0;
173 checker.m_cl_Image_desc.num_mip_levels = 0;
174 checker.m_cl_Image_desc.num_samples = 0;
175
176 checker.SetupImage();
177 checker.Init_rect();
178 checker.Setup_Test_Environment();
179
180 err = checker.verify_RW_Image();
181 clFinish(queue);
182 test_error(err, __FUNCTION__);
183
184 return err;
185 }
186
test_MEM_HOST_WRITE_ONLY_Image_RW_Mapping(cl_device_id deviceID,cl_context context,cl_command_queue queue,cl_bool blocking,cl_mem_flags buffer_mem_flag,cl_mem_object_type image_type_in,size_t array_size,size_t * img_dim)187 static cl_int test_MEM_HOST_WRITE_ONLY_Image_RW_Mapping(
188 cl_device_id deviceID, cl_context context, cl_command_queue queue,
189 cl_bool blocking, cl_mem_flags buffer_mem_flag,
190 cl_mem_object_type image_type_in, size_t array_size, size_t *img_dim)
191 {
192 log_info("%s ... \n ", __FUNCTION__);
193 cl_int err = CL_SUCCESS;
194
195 cImage_check_mem_host_write_only<int> checker(deviceID, context, queue);
196 checker.m_blocking = blocking;
197 checker.buffer_mem_flag = buffer_mem_flag;
198
199 checker.m_cl_Image_desc.image_type = image_type_in;
200 checker.m_cl_Image_desc.image_width = img_dim[0];
201 checker.m_cl_Image_desc.image_height = img_dim[1];
202 checker.m_cl_Image_desc.image_depth = img_dim[2];
203 checker.m_cl_Image_desc.image_array_size = array_size;
204 checker.m_cl_Image_desc.image_row_pitch = 0;
205 checker.m_cl_Image_desc.image_slice_pitch = 0;
206 checker.m_cl_Image_desc.num_mip_levels = 0;
207 checker.m_cl_Image_desc.num_samples = 0;
208
209 checker.SetupImage();
210 checker.Init_rect();
211 checker.Setup_Test_Environment();
212
213 err = checker.verify_RW_Image_Mapping();
214 clFinish(queue);
215 test_error(err, __FUNCTION__);
216
217 return err;
218 }
219
test_mem_host_write_only_image(cl_device_id deviceID,cl_context context,cl_command_queue queue,int num_elements)220 int test_mem_host_write_only_image(cl_device_id deviceID, cl_context context,
221 cl_command_queue queue, int num_elements)
222 {
223 cl_mem_flags buffer_mem_flags[2] = {
224 CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_WRITE_ONLY,
225 CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR | CL_MEM_HOST_WRITE_ONLY
226 };
227
228 cl_int err = CL_SUCCESS;
229
230 cl_bool image_support;
231 err = clGetDeviceInfo(deviceID, CL_DEVICE_IMAGE_SUPPORT,
232 sizeof image_support, &image_support, NULL);
233 if (err)
234 {
235 test_error(err, __FUNCTION__);
236 return err;
237 }
238 if (!image_support)
239 {
240 log_info("Images are not supported by the device, skipping test...\n");
241 return 0;
242 }
243
244 cl_mem_object_type img_type[5] = {
245 CL_MEM_OBJECT_IMAGE1D, CL_MEM_OBJECT_IMAGE2D, CL_MEM_OBJECT_IMAGE3D,
246 CL_MEM_OBJECT_IMAGE1D_ARRAY, CL_MEM_OBJECT_IMAGE2D_ARRAY
247 };
248
249 size_t img_dims[5][3] = { { 200, 1, 1 },
250 { 200, 80, 1 },
251 { 200, 80, 5 },
252 { 200, 1, 1 },
253 { 200, 80, 1 } }; // in elements
254
255 size_t array_size[5] = { 1, 10, 1, 10, 1 };
256
257 cl_bool blocking[2] = { CL_TRUE, CL_FALSE };
258 for (int k = 0; k < 2; k++)
259 for (int i = 0; i < 2; i++) // blocking
260 {
261 for (int p = 0; p < 3; p++)
262 {
263 err = test_MEM_HOST_WRITE_ONLY_Image_RW(
264 deviceID, context, queue, blocking[i], buffer_mem_flags[k],
265 img_type[p], array_size[p], img_dims[p]);
266 test_error(err, __FUNCTION__);
267
268 err = test_MEM_HOST_WRITE_ONLY_Image_RW_Mapping(
269 deviceID, context, queue, blocking[i], buffer_mem_flags[k],
270 img_type[p], array_size[p], img_dims[p]);
271 test_error(err, __FUNCTION__);
272 }
273 }
274
275 return err;
276 }
277
278 //--------
279
test_mem_host_no_access_Image_RW(cl_device_id deviceID,cl_context context,cl_command_queue queue,cl_bool blocking,cl_mem_flags buffer_mem_flag,cl_mem_object_type image_type_in,size_t array_size,size_t * img_dim)280 static cl_int test_mem_host_no_access_Image_RW(
281 cl_device_id deviceID, cl_context context, cl_command_queue queue,
282 cl_bool blocking, cl_mem_flags buffer_mem_flag,
283 cl_mem_object_type image_type_in, size_t array_size, size_t *img_dim)
284 {
285 log_info("%s ... \n", __FUNCTION__);
286 cl_int err = CL_SUCCESS;
287
288 cImage_check_mem_host_no_access<int> checker(deviceID, context, queue);
289
290 checker.m_blocking = blocking;
291 checker.buffer_mem_flag = buffer_mem_flag;
292
293 checker.m_cl_Image_desc.image_type = image_type_in;
294 checker.m_cl_Image_desc.image_width = img_dim[0];
295 checker.m_cl_Image_desc.image_height = img_dim[1];
296 checker.m_cl_Image_desc.image_depth = img_dim[2];
297 checker.m_cl_Image_desc.image_array_size = array_size;
298 checker.m_cl_Image_desc.image_row_pitch = 0;
299 checker.m_cl_Image_desc.image_slice_pitch = 0;
300 checker.m_cl_Image_desc.num_mip_levels = 0;
301 checker.m_cl_Image_desc.num_samples = 0;
302
303 checker.SetupImage();
304 checker.Init_rect();
305 checker.Setup_Test_Environment();
306 err = checker.verify_RW_Image();
307 test_error(err, __FUNCTION__);
308 clFinish(queue);
309 return err;
310 }
311
test_mem_host_no_access_Image_RW_Mapping(cl_device_id deviceID,cl_context context,cl_command_queue queue,cl_bool blocking,cl_mem_flags buffer_mem_flag,cl_mem_object_type image_type_in,size_t array_size,size_t * img_dim)312 static cl_int test_mem_host_no_access_Image_RW_Mapping(
313 cl_device_id deviceID, cl_context context, cl_command_queue queue,
314 cl_bool blocking, cl_mem_flags buffer_mem_flag,
315 cl_mem_object_type image_type_in, size_t array_size, size_t *img_dim)
316 {
317 log_info("%s ... \n ", __FUNCTION__);
318 cl_int err = CL_SUCCESS;
319
320 cImage_check_mem_host_no_access<int> checker(deviceID, context, queue);
321
322 checker.m_blocking = blocking;
323 checker.buffer_mem_flag = buffer_mem_flag;
324
325 checker.m_cl_Image_desc.image_type = image_type_in;
326 checker.m_cl_Image_desc.image_width = img_dim[0];
327 checker.m_cl_Image_desc.image_height = img_dim[1];
328 checker.m_cl_Image_desc.image_depth = img_dim[2];
329 checker.m_cl_Image_desc.image_array_size = array_size;
330 checker.m_cl_Image_desc.image_row_pitch = 0;
331 checker.m_cl_Image_desc.image_slice_pitch = 0;
332 checker.m_cl_Image_desc.num_mip_levels = 0;
333 checker.m_cl_Image_desc.num_samples = 0;
334
335 checker.SetupImage();
336 checker.Init_rect();
337 checker.Setup_Test_Environment();
338 err = checker.verify_RW_Image_Mapping();
339 test_error(err, __FUNCTION__);
340 clFinish(queue);
341 return err;
342 }
343
test_mem_host_no_access_image(cl_device_id deviceID,cl_context context,cl_command_queue queue,int num_elements)344 int test_mem_host_no_access_image(cl_device_id deviceID, cl_context context,
345 cl_command_queue queue, int num_elements)
346 {
347 cl_mem_flags buffer_mem_flags[2] = {
348 CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_NO_ACCESS,
349 CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR | CL_MEM_HOST_NO_ACCESS
350 };
351
352 cl_int err = CL_SUCCESS;
353
354 cl_bool image_support;
355 err = clGetDeviceInfo(deviceID, CL_DEVICE_IMAGE_SUPPORT,
356 sizeof image_support, &image_support, NULL);
357 if (err)
358 {
359 test_error(err, __FUNCTION__);
360 return err;
361 }
362 if (!image_support)
363 {
364 log_info("Images are not supported by the device, skipping test...\n");
365 return 0;
366 }
367
368 cl_mem_object_type img_type[5] = {
369 CL_MEM_OBJECT_IMAGE1D, CL_MEM_OBJECT_IMAGE2D, CL_MEM_OBJECT_IMAGE3D,
370 CL_MEM_OBJECT_IMAGE1D_ARRAY, CL_MEM_OBJECT_IMAGE2D_ARRAY
371 };
372
373 size_t img_dims[5][3] = { { 200, 1, 1 },
374 { 200, 80, 1 },
375 { 100, 80, 5 },
376 { 200, 1, 1 },
377 { 200, 80, 1 } }; // in elements
378
379 size_t array_size[5] = { 1, 1, 1, 10, 10 };
380
381 cl_bool blocking[2] = { CL_TRUE, CL_FALSE };
382 for (int k = 0; k < 2; k++)
383 for (int i = 0; i < 2; i++) // blocking
384 {
385 for (int p = 0; p < 3; p++)
386 {
387 err += test_mem_host_no_access_Image_RW(
388 deviceID, context, queue, blocking[i], buffer_mem_flags[k],
389 img_type[p], array_size[p], img_dims[p]);
390
391 err += test_mem_host_no_access_Image_RW_Mapping(
392 deviceID, context, queue, blocking[i], buffer_mem_flags[k],
393 img_type[p], array_size[p], img_dims[p]);
394 }
395 }
396
397 return err;
398 }
399