ahmed/OpenCL-CTS
1
0
Fork 0
mirror of https://github.com/KhronosGroup/OpenCL-CTS.git synced 2026-03-26 08:49:02 +00:00
Code Packages Projects Releases Wiki Activity

[NFC] clang-format mem_host_flags/mem_host_image.cpp (#1589)

Browse Source 
Signed-off-by: Sven van Haastregt <sven.vanhaastregt@arm.com>

Signed-off-by: Sven van Haastregt <sven.vanhaastregt@arm.com>
This commit is contained in:
Sven van Haastregt
2022-11-30 15:13:45 +00:00
committed by GitHub
parent 0d24c6f69d
commit ab338569aa
1 changed files with 302 additions and 268 deletions
Download Patch File Download Diff File Expand all files Collapse all files

168
test_conformance/mem_host_flags/mem_host_image.cpp
View File

@@ -27,11 +27,10 @@
#include "checker_image_mem_host_write_only.hpp" #include "checker_image_mem_host_write_only.hpp"
//====================================== //======================================
static cl_int test_mem_host_read_only_RW_Image(cl_device_id deviceID, cl_context context, static cl_int test_mem_host_read_only_RW_Image(
cl_command_queue queue, cl_bool blocking, cl_device_id deviceID, cl_context context, cl_command_queue queue,
cl_mem_flags buffer_mem_flag, cl_bool blocking, cl_mem_flags buffer_mem_flag,
cl_mem_object_type image_type_in, cl_mem_object_type image_type_in, size_t array_size, size_t *img_dim)
size_t array_size, size_t *img_dim)
{ {
log_info("%s ... \n ", __FUNCTION__); log_info("%s ... \n ", __FUNCTION__);
cl_int err = CL_SUCCESS; cl_int err = CL_SUCCESS;
@@ -58,11 +57,10 @@ static cl_int test_mem_host_read_only_RW_Image(cl_device_id deviceID, cl_context
return err; return err;
} }
static cl_int test_mem_host_read_only_RW_Image_Mapping(cl_device_id deviceID, cl_context context, static cl_int test_mem_host_read_only_RW_Image_Mapping(
cl_command_queue queue, cl_bool blocking, cl_device_id deviceID, cl_context context, cl_command_queue queue,
cl_mem_flags buffer_mem_flag, cl_bool blocking, cl_mem_flags buffer_mem_flag,
cl_mem_object_type image_type_in, cl_mem_object_type image_type_in, size_t array_size, size_t *img_dim)
size_t array_size, size_t *img_dim)
{ {
log_info("%s ... \n ", __FUNCTION__); log_info("%s ... \n ", __FUNCTION__);
cl_int err = CL_SUCCESS; cl_int err = CL_SUCCESS;
@@ -92,26 +90,38 @@ static cl_int test_mem_host_read_only_RW_Image_Mapping(cl_device_id deviceID, cl
int test_mem_host_read_only_image(cl_device_id deviceID, cl_context context, int test_mem_host_read_only_image(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements) cl_command_queue queue, int num_elements)
{ {
cl_mem_flags buffer_mem_flags[2] = { CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_READ_ONLY, cl_mem_flags buffer_mem_flags[2] = {
CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR | CL_MEM_HOST_READ_ONLY }; CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_READ_ONLY,
CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR | CL_MEM_HOST_READ_ONLY
};
cl_int err = CL_SUCCESS; cl_int err = CL_SUCCESS;
cl_bool image_support; cl_bool image_support;
err = clGetDeviceInfo(deviceID, CL_DEVICE_IMAGE_SUPPORT, sizeof image_support, &image_support, NULL); err = clGetDeviceInfo(deviceID, CL_DEVICE_IMAGE_SUPPORT,
if (err) { sizeof image_support, &image_support, NULL);
if (err)
{
test_error(err, __FUNCTION__); test_error(err, __FUNCTION__);
return err; return err;
} }
if (!image_support) { if (!image_support)
{
log_info("Images are not supported by the device, skipping test...\n"); log_info("Images are not supported by the device, skipping test...\n");
return 0; return 0;
} }
cl_mem_object_type img_type[5] = {CL_MEM_OBJECT_IMAGE1D, CL_MEM_OBJECT_IMAGE2D, CL_MEM_OBJECT_IMAGE3D,CL_MEM_OBJECT_IMAGE1D_ARRAY, CL_MEM_OBJECT_IMAGE2D_ARRAY}; cl_mem_object_type img_type[5] = {
CL_MEM_OBJECT_IMAGE1D, CL_MEM_OBJECT_IMAGE2D, CL_MEM_OBJECT_IMAGE3D,
CL_MEM_OBJECT_IMAGE1D_ARRAY, CL_MEM_OBJECT_IMAGE2D_ARRAY
};
size_t img_dims[5][3] = {{200, 1, 1}, {200, 80, 1}, {200, 80, 5}, {200, 1, 1}, {200, 80, 10}}; // in elements size_t img_dims[5][3] = { { 200, 1, 1 },
{ 200, 80, 1 },
{ 200, 80, 5 },
{ 200, 1, 1 },
{ 200, 80, 10 } }; // in elements
size_t array_size[5] = { 1, 10, 1, 10, 1 }; size_t array_size[5] = { 1, 10, 1, 10, 1 };
@@ -121,15 +131,17 @@ int test_mem_host_read_only_image(cl_device_id deviceID, cl_context context,
{ {
for (int p = 0; p < 3; p++) for (int p = 0; p < 3; p++)
{ {
err = test_mem_host_read_only_RW_Image(deviceID, context, queue, blocking[i], err = test_mem_host_read_only_RW_Image(
buffer_mem_flags[flag], img_type[p], deviceID, context, queue, blocking[i],
array_size[p], img_dims[p]); buffer_mem_flags[flag], img_type[p], array_size[p],
img_dims[p]);
test_error(err, __FUNCTION__); test_error(err, __FUNCTION__);
err = test_mem_host_read_only_RW_Image_Mapping(deviceID, context, queue, blocking[i], err = test_mem_host_read_only_RW_Image_Mapping(
buffer_mem_flags[flag], img_type[p], deviceID, context, queue, blocking[i],
array_size[p], img_dims[p]); buffer_mem_flags[flag], img_type[p], array_size[p],
img_dims[p]);
test_error(err, __FUNCTION__); test_error(err, __FUNCTION__);
} }
@@ -139,11 +151,10 @@ int test_mem_host_read_only_image(cl_device_id deviceID, cl_context context,
} }
//---------------------------- //----------------------------
static cl_int test_MEM_HOST_WRIE_ONLY_Image_RW (cl_device_id deviceID, cl_context context, static cl_int test_MEM_HOST_WRIE_ONLY_Image_RW(
cl_command_queue queue, cl_bool blocking, cl_device_id deviceID, cl_context context, cl_command_queue queue,
cl_mem_flags buffer_mem_flag, cl_bool blocking, cl_mem_flags buffer_mem_flag,
cl_mem_object_type image_type_in, cl_mem_object_type image_type_in, size_t array_size, size_t *img_dim)
size_t array_size, size_t *img_dim)
{ {
log_info(" %s ... \n ", __FUNCTION__); log_info(" %s ... \n ", __FUNCTION__);
cl_int err = CL_SUCCESS; cl_int err = CL_SUCCESS;
@@ -173,11 +184,10 @@ static cl_int test_MEM_HOST_WRIE_ONLY_Image_RW (cl_device_id deviceID, cl_contex
return err; return err;
} }
static cl_int test_MEM_HOST_WRITE_ONLY_Image_RW_Mapping(cl_device_id deviceID, cl_context context, static cl_int test_MEM_HOST_WRITE_ONLY_Image_RW_Mapping(
cl_command_queue queue, cl_bool blocking, cl_device_id deviceID, cl_context context, cl_command_queue queue,
cl_mem_flags buffer_mem_flag, cl_bool blocking, cl_mem_flags buffer_mem_flag,
cl_mem_object_type image_type_in, cl_mem_object_type image_type_in, size_t array_size, size_t *img_dim)
size_t array_size, size_t *img_dim)
{ {
log_info("%s ... \n ", __FUNCTION__); log_info("%s ... \n ", __FUNCTION__);
cl_int err = CL_SUCCESS; cl_int err = CL_SUCCESS;
@@ -210,26 +220,37 @@ static cl_int test_MEM_HOST_WRITE_ONLY_Image_RW_Mapping(cl_device_id deviceID, c
int test_mem_host_write_only_image(cl_device_id deviceID, cl_context context, int test_mem_host_write_only_image(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements) cl_command_queue queue, int num_elements)
{ {
cl_mem_flags buffer_mem_flags[2] = { CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_WRITE_ONLY, cl_mem_flags buffer_mem_flags[2] = {
CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR | CL_MEM_HOST_WRITE_ONLY }; CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_WRITE_ONLY,
CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR | CL_MEM_HOST_WRITE_ONLY
};
cl_int err = CL_SUCCESS; cl_int err = CL_SUCCESS;
cl_bool image_support; cl_bool image_support;
err = clGetDeviceInfo(deviceID, CL_DEVICE_IMAGE_SUPPORT, sizeof image_support, &image_support, NULL); err = clGetDeviceInfo(deviceID, CL_DEVICE_IMAGE_SUPPORT,
if (err) { sizeof image_support, &image_support, NULL);
if (err)
{
test_error(err, __FUNCTION__); test_error(err, __FUNCTION__);
return err; return err;
} }
if (!image_support) { if (!image_support)
{
log_info("Images are not supported by the device, skipping test...\n"); log_info("Images are not supported by the device, skipping test...\n");
return 0; return 0;
} }
cl_mem_object_type img_type[5]= {CL_MEM_OBJECT_IMAGE1D, CL_MEM_OBJECT_IMAGE2D, CL_MEM_OBJECT_IMAGE3D, cl_mem_object_type img_type[5] = {
CL_MEM_OBJECT_IMAGE1D_ARRAY, CL_MEM_OBJECT_IMAGE2D_ARRAY}; CL_MEM_OBJECT_IMAGE1D, CL_MEM_OBJECT_IMAGE2D, CL_MEM_OBJECT_IMAGE3D,
CL_MEM_OBJECT_IMAGE1D_ARRAY, CL_MEM_OBJECT_IMAGE2D_ARRAY
};
size_t img_dims[5][3]= {{200, 1, 1}, {200, 80, 1}, {200, 80, 5}, {200, 1, 1}, {200, 80, 1} }; // in elements size_t img_dims[5][3] = { { 200, 1, 1 },
{ 200, 80, 1 },
{ 200, 80, 5 },
{ 200, 1, 1 },
{ 200, 80, 1 } }; // in elements
size_t array_size[5] = { 1, 10, 1, 10, 1 }; size_t array_size[5] = { 1, 10, 1, 10, 1 };
@@ -239,12 +260,14 @@ int test_mem_host_write_only_image(cl_device_id deviceID, cl_context context,
{ {
for (int p = 0; p < 3; p++) for (int p = 0; p < 3; p++)
{ {
err = test_MEM_HOST_WRIE_ONLY_Image_RW(deviceID, context, queue, blocking[i], err = test_MEM_HOST_WRIE_ONLY_Image_RW(
buffer_mem_flags[k], img_type[p], array_size[p], img_dims[p]); deviceID, context, queue, blocking[i], buffer_mem_flags[k],
img_type[p], array_size[p], img_dims[p]);
test_error(err, __FUNCTION__); test_error(err, __FUNCTION__);
err = test_MEM_HOST_WRITE_ONLY_Image_RW_Mapping(deviceID, context, queue, blocking[i], err = test_MEM_HOST_WRITE_ONLY_Image_RW_Mapping(
buffer_mem_flags[k], img_type[p], array_size[p], img_dims[p]); deviceID, context, queue, blocking[i], buffer_mem_flags[k],
img_type[p], array_size[p], img_dims[p]);
test_error(err, __FUNCTION__); test_error(err, __FUNCTION__);
} }
} }
@@ -254,11 +277,10 @@ int test_mem_host_write_only_image(cl_device_id deviceID, cl_context context,
//-------- //--------
static cl_int test_mem_host_no_access_Image_RW(cl_device_id deviceID, cl_context context, static cl_int test_mem_host_no_access_Image_RW(
cl_command_queue queue, cl_bool blocking, cl_device_id deviceID, cl_context context, cl_command_queue queue,
cl_mem_flags buffer_mem_flag, cl_bool blocking, cl_mem_flags buffer_mem_flag,
cl_mem_object_type image_type_in, cl_mem_object_type image_type_in, size_t array_size, size_t *img_dim)
size_t array_size, size_t *img_dim)
{ {
log_info("%s ... \n", __FUNCTION__); log_info("%s ... \n", __FUNCTION__);
cl_int err = CL_SUCCESS; cl_int err = CL_SUCCESS;
@@ -287,11 +309,10 @@ static cl_int test_mem_host_no_access_Image_RW(cl_device_id deviceID, cl_context
return err; return err;
} }
static cl_int test_mem_host_no_access_Image_RW_Mapping(cl_device_id deviceID, cl_context context, static cl_int test_mem_host_no_access_Image_RW_Mapping(
cl_command_queue queue, cl_bool blocking, cl_device_id deviceID, cl_context context, cl_command_queue queue,
cl_mem_flags buffer_mem_flag, cl_bool blocking, cl_mem_flags buffer_mem_flag,
cl_mem_object_type image_type_in, cl_mem_object_type image_type_in, size_t array_size, size_t *img_dim)
size_t array_size, size_t *img_dim)
{ {
log_info("%s ... \n ", __FUNCTION__); log_info("%s ... \n ", __FUNCTION__);
cl_int err = CL_SUCCESS; cl_int err = CL_SUCCESS;
@@ -323,26 +344,37 @@ static cl_int test_mem_host_no_access_Image_RW_Mapping(cl_device_id deviceID, cl
int test_mem_host_no_access_image(cl_device_id deviceID, cl_context context, int test_mem_host_no_access_image(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements) cl_command_queue queue, int num_elements)
{ {
cl_mem_flags buffer_mem_flags[2] = {CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_NO_ACCESS, cl_mem_flags buffer_mem_flags[2] = {
CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR | CL_MEM_HOST_NO_ACCESS }; CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_NO_ACCESS,
CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR | CL_MEM_HOST_NO_ACCESS
};
cl_int err = CL_SUCCESS; cl_int err = CL_SUCCESS;
cl_bool image_support; cl_bool image_support;
err = clGetDeviceInfo(deviceID, CL_DEVICE_IMAGE_SUPPORT, sizeof image_support, &image_support, NULL); err = clGetDeviceInfo(deviceID, CL_DEVICE_IMAGE_SUPPORT,
if (err) { sizeof image_support, &image_support, NULL);
if (err)
{
test_error(err, __FUNCTION__); test_error(err, __FUNCTION__);
return err; return err;
} }
if (!image_support) { if (!image_support)
{
log_info("Images are not supported by the device, skipping test...\n"); log_info("Images are not supported by the device, skipping test...\n");
return 0; return 0;
} }
cl_mem_object_type img_type[5] = {CL_MEM_OBJECT_IMAGE1D, CL_MEM_OBJECT_IMAGE2D, CL_MEM_OBJECT_IMAGE3D, cl_mem_object_type img_type[5] = {
CL_MEM_OBJECT_IMAGE1D_ARRAY, CL_MEM_OBJECT_IMAGE2D_ARRAY}; CL_MEM_OBJECT_IMAGE1D, CL_MEM_OBJECT_IMAGE2D, CL_MEM_OBJECT_IMAGE3D,
CL_MEM_OBJECT_IMAGE1D_ARRAY, CL_MEM_OBJECT_IMAGE2D_ARRAY
};
size_t img_dims[5][3]= {{200, 1, 1}, {200, 80, 1}, {100, 80, 5}, {200, 1, 1}, {200, 80, 1}}; // in elements size_t img_dims[5][3] = { { 200, 1, 1 },
{ 200, 80, 1 },
{ 100, 80, 5 },
{ 200, 1, 1 },
{ 200, 80, 1 } }; // in elements
size_t array_size[5] = { 1, 1, 1, 10, 10 }; size_t array_size[5] = { 1, 1, 1, 10, 10 };
@@ -352,11 +384,13 @@ int test_mem_host_no_access_image(cl_device_id deviceID, cl_context context,
{ {
for (int p = 0; p < 3; p++) for (int p = 0; p < 3; p++)
{ {
err += test_mem_host_no_access_Image_RW (deviceID, context, queue, blocking[i], err += test_mem_host_no_access_Image_RW(
buffer_mem_flags[k], img_type[p], array_size[p], img_dims[p]); deviceID, context, queue, blocking[i], buffer_mem_flags[k],
img_type[p], array_size[p], img_dims[p]);
err += test_mem_host_no_access_Image_RW_Mapping(deviceID, context, queue, blocking[i], err += test_mem_host_no_access_Image_RW_Mapping(
buffer_mem_flags[k], img_type[p], array_size[p], img_dims[p]); deviceID, context, queue, blocking[i], buffer_mem_flags[k],
img_type[p], array_size[p], img_dims[p]);
} }
} }