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

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);
}
}