ahmed/OpenCL-CTS
1
0
Fork 0
mirror of https://github.com/KhronosGroup/OpenCL-CTS.git synced 2026-03-19 14:09:03 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
395648cfef20c8f4c653d714fc0b07cf847ee39e
OpenCL-CTS/test_conformance/mem_host_flags/mem_host_image.cpp
Kévin Petit 132ba21a3c Migrate mem_host_flags suite to the new test registration framework (#2314) 
Contributes to #2181

Signed-off-by: Kévin Petit <kpet@free.fr>
2025-03-11 21:47:58 +00:00

392 lines
13 KiB
C++
Raw Blame History

//
// Copyright (c) 2017 The Khronos Group Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#include "harness/compat.h"
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "checker_image_mem_host_read_only.hpp"
#include "checker_image_mem_host_no_access.hpp"
#include "checker_image_mem_host_write_only.hpp"
//======================================
static cl_int test_mem_host_read_only_RW_Image(
cl_device_id device, 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)
{
log_info("%s ... \n ", __FUNCTION__);
cl_int err = CL_SUCCESS;
cImage_check_mem_host_read_only<int> checker(device, context, queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
checker.m_cl_Image_desc.image_type = image_type_in;
checker.m_cl_Image_desc.image_width = img_dim[0];
checker.m_cl_Image_desc.image_height = img_dim[1];
checker.m_cl_Image_desc.image_depth = img_dim[2];
checker.m_cl_Image_desc.image_array_size = array_size;
checker.m_cl_Image_desc.image_row_pitch = 0;
checker.m_cl_Image_desc.image_slice_pitch = 0;
checker.m_cl_Image_desc.num_mip_levels = 0;
checker.m_cl_Image_desc.num_samples = 0;
checker.SetupImage();
checker.Init_rect();
err = checker.verify_RW_Image();
test_error(err, __FUNCTION__);
clFinish(queue);
return err;
}
static cl_int test_mem_host_read_only_RW_Image_Mapping(
cl_device_id device, 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)
{
log_info("%s ... \n ", __FUNCTION__);
cl_int err = CL_SUCCESS;
cImage_check_mem_host_read_only<int> checker(device, context, queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
checker.m_cl_Image_desc.image_type = image_type_in;
checker.m_cl_Image_desc.image_width = img_dim[0];
checker.m_cl_Image_desc.image_height = img_dim[1];
checker.m_cl_Image_desc.image_depth = img_dim[2];
checker.m_cl_Image_desc.image_array_size = array_size;
checker.m_cl_Image_desc.image_row_pitch = 0;
checker.m_cl_Image_desc.image_slice_pitch = 0;
checker.m_cl_Image_desc.num_mip_levels = 0;
checker.m_cl_Image_desc.num_samples = 0;
checker.SetupImage();
checker.Init_rect();
err = checker.verify_RW_Image_Mapping();
test_error(err, __FUNCTION__);
clFinish(queue);
return err;
}
REGISTER_TEST(mem_host_read_only_image)
{
cl_mem_flags buffer_mem_flags[2] = {
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_bool image_support;
err = clGetDeviceInfo(device, CL_DEVICE_IMAGE_SUPPORT, sizeof image_support,
&image_support, NULL);
if (err)
{
test_error(err, __FUNCTION__);
return err;
}
if (!image_support)
{
log_info("Images are not supported by the device, skipping test...\n");
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
};
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 };
cl_bool blocking[2] = { CL_TRUE, CL_FALSE };
for (int flag = 0; flag < 2; flag++)
for (int i = 0; i < 2; i++) // blocking
{
for (int p = 0; p < 3; p++)
{
err = test_mem_host_read_only_RW_Image(
device, context, queue, blocking[i], buffer_mem_flags[flag],
img_type[p], array_size[p], img_dims[p]);
test_error(err, __FUNCTION__);
err = test_mem_host_read_only_RW_Image_Mapping(
device, context, queue, blocking[i], buffer_mem_flags[flag],
img_type[p], array_size[p], img_dims[p]);
test_error(err, __FUNCTION__);
}
}
return err;
}
//----------------------------
static cl_int test_MEM_HOST_WRITE_ONLY_Image_RW(
cl_device_id device, 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)
{
log_info(" %s ... \n ", __FUNCTION__);
cl_int err = CL_SUCCESS;
cImage_check_mem_host_write_only<int> checker(device, context, queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
checker.m_cl_Image_desc.image_type = image_type_in;
checker.m_cl_Image_desc.image_width = img_dim[0];
checker.m_cl_Image_desc.image_height = img_dim[1];
checker.m_cl_Image_desc.image_depth = img_dim[2];
checker.m_cl_Image_desc.image_array_size = array_size;
checker.m_cl_Image_desc.image_row_pitch = 0;
checker.m_cl_Image_desc.image_slice_pitch = 0;
checker.m_cl_Image_desc.num_mip_levels = 0;
checker.m_cl_Image_desc.num_samples = 0;
checker.SetupImage();
checker.Init_rect();
checker.Setup_Test_Environment();
err = checker.verify_RW_Image();
clFinish(queue);
test_error(err, __FUNCTION__);
return err;
}
static cl_int test_MEM_HOST_WRITE_ONLY_Image_RW_Mapping(
cl_device_id device, 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)
{
log_info("%s ... \n ", __FUNCTION__);
cl_int err = CL_SUCCESS;
cImage_check_mem_host_write_only<int> checker(device, context, queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
checker.m_cl_Image_desc.image_type = image_type_in;
checker.m_cl_Image_desc.image_width = img_dim[0];
checker.m_cl_Image_desc.image_height = img_dim[1];
checker.m_cl_Image_desc.image_depth = img_dim[2];
checker.m_cl_Image_desc.image_array_size = array_size;
checker.m_cl_Image_desc.image_row_pitch = 0;
checker.m_cl_Image_desc.image_slice_pitch = 0;
checker.m_cl_Image_desc.num_mip_levels = 0;
checker.m_cl_Image_desc.num_samples = 0;
checker.SetupImage();
checker.Init_rect();
checker.Setup_Test_Environment();
err = checker.verify_RW_Image_Mapping();
clFinish(queue);
test_error(err, __FUNCTION__);
return err;
}
REGISTER_TEST(mem_host_write_only_image)
{
cl_mem_flags buffer_mem_flags[2] = {
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_bool image_support;
err = clGetDeviceInfo(device, CL_DEVICE_IMAGE_SUPPORT, sizeof image_support,
&image_support, NULL);
if (err)
{
test_error(err, __FUNCTION__);
return err;
}
if (!image_support)
{
log_info("Images are not supported by the device, skipping test...\n");
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
};
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 };
cl_bool blocking[2] = { CL_TRUE, CL_FALSE };
for (int k = 0; k < 2; k++)
for (int i = 0; i < 2; i++) // blocking
{
for (int p = 0; p < 3; p++)
{
err = test_MEM_HOST_WRITE_ONLY_Image_RW(
device, context, queue, blocking[i], buffer_mem_flags[k],
img_type[p], array_size[p], img_dims[p]);
test_error(err, __FUNCTION__);
err = test_MEM_HOST_WRITE_ONLY_Image_RW_Mapping(
device, context, queue, blocking[i], buffer_mem_flags[k],
img_type[p], array_size[p], img_dims[p]);
test_error(err, __FUNCTION__);
}
}
return err;
}
//--------
static cl_int test_mem_host_no_access_Image_RW(
cl_device_id device, 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)
{
log_info("%s ... \n", __FUNCTION__);
cl_int err = CL_SUCCESS;
cImage_check_mem_host_no_access<int> checker(device, context, queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
checker.m_cl_Image_desc.image_type = image_type_in;
checker.m_cl_Image_desc.image_width = img_dim[0];
checker.m_cl_Image_desc.image_height = img_dim[1];
checker.m_cl_Image_desc.image_depth = img_dim[2];
checker.m_cl_Image_desc.image_array_size = array_size;
checker.m_cl_Image_desc.image_row_pitch = 0;
checker.m_cl_Image_desc.image_slice_pitch = 0;
checker.m_cl_Image_desc.num_mip_levels = 0;
checker.m_cl_Image_desc.num_samples = 0;
checker.SetupImage();
checker.Init_rect();
checker.Setup_Test_Environment();
err = checker.verify_RW_Image();
test_error(err, __FUNCTION__);
clFinish(queue);
return err;
}
static cl_int test_mem_host_no_access_Image_RW_Mapping(
cl_device_id device, 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)
{
log_info("%s ... \n ", __FUNCTION__);
cl_int err = CL_SUCCESS;
cImage_check_mem_host_no_access<int> checker(device, context, queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
checker.m_cl_Image_desc.image_type = image_type_in;
checker.m_cl_Image_desc.image_width = img_dim[0];
checker.m_cl_Image_desc.image_height = img_dim[1];
checker.m_cl_Image_desc.image_depth = img_dim[2];
checker.m_cl_Image_desc.image_array_size = array_size;
checker.m_cl_Image_desc.image_row_pitch = 0;
checker.m_cl_Image_desc.image_slice_pitch = 0;
checker.m_cl_Image_desc.num_mip_levels = 0;
checker.m_cl_Image_desc.num_samples = 0;
checker.SetupImage();
checker.Init_rect();
checker.Setup_Test_Environment();
err = checker.verify_RW_Image_Mapping();
test_error(err, __FUNCTION__);
clFinish(queue);
return err;
}
REGISTER_TEST(mem_host_no_access_image)
{
cl_mem_flags buffer_mem_flags[2] = {
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_bool image_support;
err = clGetDeviceInfo(device, CL_DEVICE_IMAGE_SUPPORT, sizeof image_support,
&image_support, NULL);
if (err)
{
test_error(err, __FUNCTION__);
return err;
}
if (!image_support)
{
log_info("Images are not supported by the device, skipping test...\n");
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
};
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 };
cl_bool blocking[2] = { CL_TRUE, CL_FALSE };
for (int k = 0; k < 2; k++)
for (int i = 0; i < 2; i++) // blocking
{
for (int p = 0; p < 3; p++)
{
err += test_mem_host_no_access_Image_RW(
device, 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(
device, context, queue, blocking[i], buffer_mem_flags[k],
img_type[p], array_size[p], img_dims[p]);
}
}
return err;
}
Reference in New Issue View Git Blame Copy Permalink