ahmed/OpenCL-CTS
1
0
Fork 0
mirror of https://github.com/KhronosGroup/OpenCL-CTS.git synced 2026-03-19 06:09:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

Migrate mem_host_flags suite to the new test registration framework (#2314)

Browse Source 
Contributes to #2181

Signed-off-by: Kévin Petit <kpet@free.fr>
This commit is contained in:
Kévin Petit
2025-03-11 21:47:58 +00:00
committed by GitHub
parent c4179d0f6a
commit 132ba21a3c
5 changed files with 81 additions and 173 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
test_conformance/mem_host_flags/checker.h
View File

@@ -21,7 +21,7 @@
#include <stdio.h>
#include <string.h>
#include "procs.h"
#include "testBase.h"
#include "C_host_memory_block.h"
#define TEST_VALUE 5

19
test_conformance/mem_host_flags/main.cpp
View File

@@ -22,30 +22,17 @@
#include <CL/cl.h>
#endif
#include "procs.h"
#include "harness/testHarness.h"
#include "harness/imageHelpers.h"
#if !defined(_WIN32)
#include <unistd.h>
#endif
test_definition test_list[] = {
ADD_TEST(mem_host_read_only_buffer),
ADD_TEST(mem_host_read_only_subbuffer),
ADD_TEST(mem_host_write_only_buffer),
ADD_TEST(mem_host_write_only_subbuffer),
ADD_TEST(mem_host_no_access_buffer),
ADD_TEST(mem_host_no_access_subbuffer),
ADD_TEST(mem_host_read_only_image),
ADD_TEST(mem_host_write_only_image),
ADD_TEST(mem_host_no_access_image),
};
const int test_num = ARRAY_SIZE(test_list);
int main(int argc, const char *argv[])
{
log_info("1st part, non gl-sharing objects...\n");
gTestRounding = true;
return runTestHarness(argc, argv, test_num, test_list, false, 0);
return runTestHarness(argc, argv, test_registry::getInstance().num_tests(),
test_registry::getInstance().definitions(), false, 0);
}

105
test_conformance/mem_host_flags/mem_host_buffer.cpp
View File

@@ -20,20 +20,18 @@
#include <sys/types.h>
#include <sys/stat.h>
#include "procs.h"
#include "checker_mem_host_read_only.hpp"
#include "checker_mem_host_write_only.hpp"
#include "checker_mem_host_no_access.hpp"
static int test_mem_host_read_only_buffer_RW(
cl_device_id deviceID, cl_context context, cl_command_queue queue,
cl_device_id device, 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)
{
log_info("%s\n", __FUNCTION__);
cBuffer_check_mem_host_read_only<TEST_ELEMENT_TYPE> checker(deviceID,
context, queue);
cBuffer_check_mem_host_read_only<TEST_ELEMENT_TYPE> checker(device, context,
queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
cl_int err;
@@ -55,14 +53,14 @@ static int test_mem_host_read_only_buffer_RW(
}
static int test_mem_host_read_only_buffer_RW_Rect(
cl_device_id deviceID, cl_context context, cl_command_queue queue,
cl_device_id device, 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)
{
log_info("%s\n", __FUNCTION__);
cBuffer_check_mem_host_read_only<TEST_ELEMENT_TYPE> checker(deviceID,
context, queue);
cBuffer_check_mem_host_read_only<TEST_ELEMENT_TYPE> checker(device, context,
queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
cl_int err;
@@ -84,14 +82,14 @@ static int test_mem_host_read_only_buffer_RW_Rect(
}
static int test_mem_host_read_only_buffer_RW_Mapping(
cl_device_id deviceID, cl_context context, cl_command_queue queue,
cl_device_id device, 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)
{
log_info("%s\n", __FUNCTION__);
cBuffer_check_mem_host_read_only<TEST_ELEMENT_TYPE> checker(deviceID,
context, queue);
cBuffer_check_mem_host_read_only<TEST_ELEMENT_TYPE> checker(device, context,
queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
cl_int err;
@@ -112,8 +110,7 @@ static int test_mem_host_read_only_buffer_RW_Mapping(
return err;
}
int test_mem_host_read_only_buffer(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(mem_host_read_only_buffer)
{
cl_mem_flags buffer_mem_flags[2] = {
CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_READ_ONLY,
@@ -128,17 +125,17 @@ int test_mem_host_read_only_buffer(cl_device_id deviceID, cl_context context,
{
err = test_mem_host_read_only_buffer_RW(
deviceID, context, queue, blocking[i], buffer_mem_flags[k], 0,
device, context, queue, blocking[i], buffer_mem_flags[k], 0,
_BUFFER);
test_error(err, __FUNCTION__);
err = test_mem_host_read_only_buffer_RW_Rect(
deviceID, context, queue, blocking[i], buffer_mem_flags[k], 0,
device, context, queue, blocking[i], buffer_mem_flags[k], 0,
_BUFFER);
test_error(err, __FUNCTION__);
err = test_mem_host_read_only_buffer_RW_Mapping(
deviceID, context, queue, blocking[i], buffer_mem_flags[k], 0,
device, context, queue, blocking[i], buffer_mem_flags[k], 0,
_BUFFER);
test_error(err, __FUNCTION__);
}
@@ -146,8 +143,7 @@ int test_mem_host_read_only_buffer(cl_device_id deviceID, cl_context context,
return err;
}
int test_mem_host_read_only_subbuffer(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(mem_host_read_only_subbuffer)
{
cl_mem_flags parent_buffer_mem_flags[1] = { CL_MEM_READ_WRITE
| CL_MEM_USE_HOST_PTR
@@ -169,17 +165,17 @@ int test_mem_host_read_only_subbuffer(cl_device_id deviceID, cl_context context,
for (int i = 0; i < 2; i++)
{
err = test_mem_host_read_only_buffer_RW(
deviceID, context, queue, blocking[i], buffer_mem_flags[k],
device, context, queue, blocking[i], buffer_mem_flags[k],
parent_buffer_mem_flags[p], _Sub_BUFFER);
test_error(err, __FUNCTION__);
err = test_mem_host_read_only_buffer_RW_Rect(
deviceID, context, queue, blocking[i], buffer_mem_flags[k],
device, context, queue, blocking[i], buffer_mem_flags[k],
parent_buffer_mem_flags[p], _Sub_BUFFER);
test_error(err, __FUNCTION__);
err = test_mem_host_read_only_buffer_RW_Mapping(
deviceID, context, queue, blocking[i], buffer_mem_flags[k],
device, context, queue, blocking[i], buffer_mem_flags[k],
parent_buffer_mem_flags[p], _Sub_BUFFER);
test_error(err, __FUNCTION__);
}
@@ -191,14 +187,14 @@ int test_mem_host_read_only_subbuffer(cl_device_id deviceID, cl_context context,
//=============================== Write only
static cl_int test_mem_host_write_only_buffer_RW(
cl_device_id deviceID, cl_context context, cl_command_queue queue,
cl_device_id device, 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)
{
log_info("%s\n", __FUNCTION__);
cBuffer_check_mem_host_write_only<TEST_ELEMENT_TYPE> checker(
deviceID, context, queue);
device, context, queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
@@ -221,14 +217,14 @@ static cl_int test_mem_host_write_only_buffer_RW(
}
static cl_int test_mem_host_write_only_buffer_RW_Rect(
cl_device_id deviceID, cl_context context, cl_command_queue queue,
cl_device_id device, 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)
{
log_info("%s\n", __FUNCTION__);
cBuffer_check_mem_host_write_only<TEST_ELEMENT_TYPE> checker(
deviceID, context, queue);
device, context, queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
cl_int err;
@@ -250,14 +246,14 @@ static cl_int test_mem_host_write_only_buffer_RW_Rect(
}
static cl_int test_mem_host_write_only_buffer_RW_Mapping(
cl_device_id deviceID, cl_context context, cl_command_queue queue,
cl_device_id device, 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)
{
log_info("%s\n", __FUNCTION__);
cBuffer_check_mem_host_write_only<TEST_ELEMENT_TYPE> checker(
deviceID, context, queue);
device, context, queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
cl_int err;
@@ -278,8 +274,7 @@ static cl_int test_mem_host_write_only_buffer_RW_Mapping(
return err;
}
int test_mem_host_write_only_buffer(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(mem_host_write_only_buffer)
{
cl_mem_flags buffer_mem_flags[2] = {
CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_WRITE_ONLY,
@@ -293,17 +288,17 @@ int test_mem_host_write_only_buffer(cl_device_id deviceID, cl_context context,
for (int i = 0; i < 2; i++)
{
err = test_mem_host_write_only_buffer_RW(
deviceID, context, queue, blocking[i], buffer_mem_flags[k], 0,
device, context, queue, blocking[i], buffer_mem_flags[k], 0,
_BUFFER);
test_error(err, __FUNCTION__);
err = test_mem_host_write_only_buffer_RW_Rect(
deviceID, context, queue, blocking[i], buffer_mem_flags[k], 0,
device, context, queue, blocking[i], buffer_mem_flags[k], 0,
_BUFFER);
test_error(err, __FUNCTION__);
err = test_mem_host_write_only_buffer_RW_Mapping(
deviceID, context, queue, blocking[i], buffer_mem_flags[k], 0,
device, context, queue, blocking[i], buffer_mem_flags[k], 0,
_BUFFER);
test_error(err, __FUNCTION__);
}
@@ -311,9 +306,7 @@ int test_mem_host_write_only_buffer(cl_device_id deviceID, cl_context context,
return err;
}
int test_mem_host_write_only_subbuffer(cl_device_id deviceID,
cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(mem_host_write_only_subbuffer)
{
cl_mem_flags parent_buffer_mem_flags[1] = { CL_MEM_READ_WRITE
| CL_MEM_USE_HOST_PTR
@@ -336,17 +329,17 @@ int test_mem_host_write_only_subbuffer(cl_device_id deviceID,
for (int i = 0; i < 2; i++)
{
err = test_mem_host_write_only_buffer_RW(
deviceID, context, queue, blocking[i], buffer_mem_flags[m],
device, context, queue, blocking[i], buffer_mem_flags[m],
parent_buffer_mem_flags[p], _Sub_BUFFER);
test_error(err, __FUNCTION__);
err = test_mem_host_write_only_buffer_RW_Rect(
deviceID, context, queue, blocking[i], buffer_mem_flags[m],
device, context, queue, blocking[i], buffer_mem_flags[m],
parent_buffer_mem_flags[p], _Sub_BUFFER);
test_error(err, __FUNCTION__);
err = test_mem_host_write_only_buffer_RW_Mapping(
deviceID, context, queue, blocking[i], buffer_mem_flags[m],
device, context, queue, blocking[i], buffer_mem_flags[m],
parent_buffer_mem_flags[p], _Sub_BUFFER);
test_error(err, __FUNCTION__);
}
@@ -359,14 +352,14 @@ int test_mem_host_write_only_subbuffer(cl_device_id deviceID,
//===================== NO ACCESS
static cl_int test_mem_host_no_access_buffer_RW(
cl_device_id deviceID, cl_context context, cl_command_queue queue,
cl_device_id device, 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)
{
log_info("%s\n", __FUNCTION__);
cBuffer_check_mem_host_no_access<TEST_ELEMENT_TYPE> checker(deviceID,
context, queue);
cBuffer_check_mem_host_no_access<TEST_ELEMENT_TYPE> checker(device, context,
queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
@@ -389,14 +382,14 @@ static cl_int test_mem_host_no_access_buffer_RW(
}
static cl_int test_mem_host_no_access_buffer_RW_Rect(
cl_device_id deviceID, cl_context context, cl_command_queue queue,
cl_device_id device, 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)
{
log_info("%s\n", __FUNCTION__);
cBuffer_check_mem_host_no_access<TEST_ELEMENT_TYPE> checker(deviceID,
context, queue);
cBuffer_check_mem_host_no_access<TEST_ELEMENT_TYPE> checker(device, context,
queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
cl_int err;
@@ -418,14 +411,14 @@ static cl_int test_mem_host_no_access_buffer_RW_Rect(
}
static cl_int test_mem_host_no_access_buffer_RW_Mapping(
cl_device_id deviceID, cl_context context, cl_command_queue queue,
cl_device_id device, 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)
{
log_info("%s\n", __FUNCTION__);
cBuffer_check_mem_host_no_access<TEST_ELEMENT_TYPE> checker(deviceID,
context, queue);
cBuffer_check_mem_host_no_access<TEST_ELEMENT_TYPE> checker(device, context,
queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
@@ -447,8 +440,7 @@ static cl_int test_mem_host_no_access_buffer_RW_Mapping(
return err;
}
int test_mem_host_no_access_buffer(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(mem_host_no_access_buffer)
{
cl_mem_flags buffer_mem_flag[2] = {
CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_NO_ACCESS,
@@ -462,17 +454,17 @@ int test_mem_host_no_access_buffer(cl_device_id deviceID, cl_context context,
for (int i = 0; i < 2; i++)
{
err = test_mem_host_no_access_buffer_RW(
deviceID, context, queue, blocking[i], buffer_mem_flag[k], 0,
device, context, queue, blocking[i], buffer_mem_flag[k], 0,
_BUFFER);
test_error(err, __FUNCTION__);
err = test_mem_host_no_access_buffer_RW_Rect(
deviceID, context, queue, blocking[i], buffer_mem_flag[k], 0,
device, context, queue, blocking[i], buffer_mem_flag[k], 0,
_BUFFER);
test_error(err, __FUNCTION__);
err = test_mem_host_no_access_buffer_RW_Mapping(
deviceID, context, queue, blocking[i], buffer_mem_flag[k], 0,
device, context, queue, blocking[i], buffer_mem_flag[k], 0,
_BUFFER);
test_error(err, __FUNCTION__);
}
@@ -480,8 +472,7 @@ int test_mem_host_no_access_buffer(cl_device_id deviceID, cl_context context,
return err;
}
int test_mem_host_no_access_subbuffer(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(mem_host_no_access_subbuffer)
{
cl_mem_flags parent_buffer_mem_flags[3] = {
CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_NO_ACCESS,
@@ -505,15 +496,15 @@ int test_mem_host_no_access_subbuffer(cl_device_id deviceID, cl_context context,
for (int i = 0; i < 2; i++)
{
err += test_mem_host_no_access_buffer_RW(
deviceID, context, queue, blocking[i], buffer_mem_flags[k],
device, context, queue, blocking[i], buffer_mem_flags[k],
parent_buffer_mem_flags[p], _Sub_BUFFER);
err += test_mem_host_no_access_buffer_RW_Rect(
deviceID, context, queue, blocking[i], buffer_mem_flags[k],
device, context, queue, blocking[i], buffer_mem_flags[k],
parent_buffer_mem_flags[p], _Sub_BUFFER);
err += test_mem_host_no_access_buffer_RW_Mapping(
deviceID, context, queue, blocking[i], buffer_mem_flags[k],
device, context, queue, blocking[i], buffer_mem_flags[k],
parent_buffer_mem_flags[p], _Sub_BUFFER);
}
}

65
test_conformance/mem_host_flags/mem_host_image.cpp
View File

@@ -20,22 +20,20 @@
#include <sys/types.h>
#include <sys/stat.h>
#include "procs.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 deviceID, cl_context context, cl_command_queue queue,
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(deviceID, context, queue);
cImage_check_mem_host_read_only<int> checker(device, context, queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
@@ -58,14 +56,14 @@ static cl_int test_mem_host_read_only_RW_Image(
}
static cl_int test_mem_host_read_only_RW_Image_Mapping(
cl_device_id deviceID, cl_context context, cl_command_queue queue,
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(deviceID, context, queue);
cImage_check_mem_host_read_only<int> checker(device, context, queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
@@ -87,8 +85,7 @@ static cl_int test_mem_host_read_only_RW_Image_Mapping(
return err;
}
int test_mem_host_read_only_image(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements)
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,
@@ -98,8 +95,8 @@ int test_mem_host_read_only_image(cl_device_id deviceID, cl_context context,
cl_int err = CL_SUCCESS;
cl_bool image_support;
err = clGetDeviceInfo(deviceID, CL_DEVICE_IMAGE_SUPPORT,
sizeof image_support, &image_support, NULL);
err = clGetDeviceInfo(device, CL_DEVICE_IMAGE_SUPPORT, sizeof image_support,
&image_support, NULL);
if (err)
{
test_error(err, __FUNCTION__);
@@ -132,16 +129,14 @@ int test_mem_host_read_only_image(cl_device_id deviceID, cl_context context,
for (int p = 0; p < 3; p++)
{
err = test_mem_host_read_only_RW_Image(
deviceID, context, queue, blocking[i],
buffer_mem_flags[flag], img_type[p], array_size[p],
img_dims[p]);
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(
deviceID, context, queue, blocking[i],
buffer_mem_flags[flag], img_type[p], array_size[p],
img_dims[p]);
device, context, queue, blocking[i], buffer_mem_flags[flag],
img_type[p], array_size[p], img_dims[p]);
test_error(err, __FUNCTION__);
}
@@ -152,14 +147,14 @@ int test_mem_host_read_only_image(cl_device_id deviceID, cl_context context,
//----------------------------
static cl_int test_MEM_HOST_WRITE_ONLY_Image_RW(
cl_device_id deviceID, cl_context context, cl_command_queue queue,
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(deviceID, context, queue);
cImage_check_mem_host_write_only<int> checker(device, context, queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
@@ -185,14 +180,14 @@ static cl_int test_MEM_HOST_WRITE_ONLY_Image_RW(
}
static cl_int test_MEM_HOST_WRITE_ONLY_Image_RW_Mapping(
cl_device_id deviceID, cl_context context, cl_command_queue queue,
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(deviceID, context, queue);
cImage_check_mem_host_write_only<int> checker(device, context, queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
@@ -217,8 +212,7 @@ static cl_int test_MEM_HOST_WRITE_ONLY_Image_RW_Mapping(
return err;
}
int test_mem_host_write_only_image(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements)
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,
@@ -228,8 +222,8 @@ int test_mem_host_write_only_image(cl_device_id deviceID, cl_context context,
cl_int err = CL_SUCCESS;
cl_bool image_support;
err = clGetDeviceInfo(deviceID, CL_DEVICE_IMAGE_SUPPORT,
sizeof image_support, &image_support, NULL);
err = clGetDeviceInfo(device, CL_DEVICE_IMAGE_SUPPORT, sizeof image_support,
&image_support, NULL);
if (err)
{
test_error(err, __FUNCTION__);
@@ -261,12 +255,12 @@ int test_mem_host_write_only_image(cl_device_id deviceID, cl_context context,
for (int p = 0; p < 3; p++)
{
err = test_MEM_HOST_WRITE_ONLY_Image_RW(
deviceID, context, queue, blocking[i], buffer_mem_flags[k],
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(
deviceID, context, queue, blocking[i], buffer_mem_flags[k],
device, context, queue, blocking[i], buffer_mem_flags[k],
img_type[p], array_size[p], img_dims[p]);
test_error(err, __FUNCTION__);
}
@@ -278,14 +272,14 @@ 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, cl_command_queue queue,
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(deviceID, context, queue);
cImage_check_mem_host_no_access<int> checker(device, context, queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
@@ -310,14 +304,14 @@ static cl_int test_mem_host_no_access_Image_RW(
}
static cl_int test_mem_host_no_access_Image_RW_Mapping(
cl_device_id deviceID, cl_context context, cl_command_queue queue,
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(deviceID, context, queue);
cImage_check_mem_host_no_access<int> checker(device, context, queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
@@ -341,8 +335,7 @@ static cl_int test_mem_host_no_access_Image_RW_Mapping(
return err;
}
int test_mem_host_no_access_image(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements)
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,
@@ -352,8 +345,8 @@ int test_mem_host_no_access_image(cl_device_id deviceID, cl_context context,
cl_int err = CL_SUCCESS;
cl_bool image_support;
err = clGetDeviceInfo(deviceID, CL_DEVICE_IMAGE_SUPPORT,
sizeof image_support, &image_support, NULL);
err = clGetDeviceInfo(device, CL_DEVICE_IMAGE_SUPPORT, sizeof image_support,
&image_support, NULL);
if (err)
{
test_error(err, __FUNCTION__);
@@ -385,11 +378,11 @@ int test_mem_host_no_access_image(cl_device_id deviceID, cl_context context,
for (int p = 0; p < 3; p++)
{
err += test_mem_host_no_access_Image_RW(
deviceID, context, queue, blocking[i], buffer_mem_flags[k],
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(
deviceID, context, queue, blocking[i], buffer_mem_flags[k],
device, context, queue, blocking[i], buffer_mem_flags[k],
img_type[p], array_size[p], img_dims[p]);
}
}

63
test_conformance/mem_host_flags/procs.h
View File

@@ -1,63 +0,0 @@
//
// 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.
//
#ifndef __PROCS_H__
#define __PROCS_H__
#include "testBase.h"
#define NUM_FLAGS 4
extern int test_mem_host_read_only_buffer(cl_device_id deviceID,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mem_host_read_only_subbuffer(cl_device_id deviceID,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mem_host_write_only_buffer(cl_device_id deviceID,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mem_host_write_only_subbuffer(cl_device_id deviceID,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mem_host_no_access_buffer(cl_device_id deviceID,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mem_host_no_access_subbuffer(cl_device_id deviceID,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mem_host_read_only_image(cl_device_id deviceID,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mem_host_write_only_image(cl_device_id deviceID,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mem_host_no_access_image(cl_device_id deviceID,
cl_context context,
cl_command_queue queue,
int num_elements);
#endif // #ifndef __PROCS_H__