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

[NFC] clang-format mem_host_flags (#1607)

Browse Source 
Signed-off-by: Sven van Haastregt <sven.vanhaastregt@arm.com>
This commit is contained in:
Sven van Haastregt
2023-01-09 16:07:09 +00:00
committed by GitHub
parent 8066e69b11
commit 4278d544dc
11 changed files with 1834 additions and 1695 deletions
Download Patch File Download Diff File Expand all files Collapse all files

705
test_conformance/mem_host_flags/mem_host_buffer.cpp
View File

@@ -1,6 +1,6 @@
//
// 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
@@ -26,463 +26,498 @@
#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_bool blocking,
cl_mem_flags buffer_mem_flag,
cl_mem_flags parent_buffer_flag,
enum BUFFER_TYPE buffer_type)
static int test_mem_host_read_only_buffer_RW(
cl_device_id deviceID, 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);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
cl_int err;
switch (buffer_type) {
case _BUFFER:
err = checker.SetupBuffer();
break;
case _Sub_BUFFER:
err = checker.SetupASSubBuffer(parent_buffer_flag);
break;
}
log_info("%s\n", __FUNCTION__);
cBuffer_check_mem_host_read_only<TEST_ELEMENT_TYPE> checker(deviceID,
context, queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
cl_int err;
switch (buffer_type)
{
case _BUFFER: err = checker.SetupBuffer(); break;
case _Sub_BUFFER:
err = checker.SetupASSubBuffer(parent_buffer_flag);
break;
}
test_error(err, __FUNCTION__);
checker.Setup_Test_Environment();
err= checker.verify_RW_Buffer();
test_error(err, __FUNCTION__);
clFinish(queue);
test_error(err, __FUNCTION__);
checker.Setup_Test_Environment();
err = checker.verify_RW_Buffer();
test_error(err, __FUNCTION__);
clFinish(queue);
return err;
return err;
}
static int test_mem_host_read_only_buffer_RW_Rect(cl_device_id deviceID, 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)
static int test_mem_host_read_only_buffer_RW_Rect(
cl_device_id deviceID, 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__);
log_info("%s\n", __FUNCTION__);
cBuffer_check_mem_host_read_only< TEST_ELEMENT_TYPE > checker(deviceID, context, queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
cl_int err;
switch (buffer_type) {
case _BUFFER:
err= checker.SetupBuffer();
break;
case _Sub_BUFFER:
err= checker.SetupASSubBuffer(parent_buffer_flag);
break;
}
cBuffer_check_mem_host_read_only<TEST_ELEMENT_TYPE> checker(deviceID,
context, queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
cl_int err;
switch (buffer_type)
{
case _BUFFER: err = checker.SetupBuffer(); break;
case _Sub_BUFFER:
err = checker.SetupASSubBuffer(parent_buffer_flag);
break;
}
test_error(err, __FUNCTION__);
checker.Setup_Test_Environment();
err = checker.verify_RW_Buffer_rect();
test_error(err, __FUNCTION__);
clFinish(queue);
test_error(err, __FUNCTION__);
checker.Setup_Test_Environment();
err = checker.verify_RW_Buffer_rect();
test_error(err, __FUNCTION__);
clFinish(queue);
return err;
return err;
}
static int test_mem_host_read_only_buffer_RW_Mapping(cl_device_id deviceID, 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)
static int test_mem_host_read_only_buffer_RW_Mapping(
cl_device_id deviceID, 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__);
log_info("%s\n", __FUNCTION__);
cBuffer_check_mem_host_read_only< TEST_ELEMENT_TYPE > checker(deviceID, context, queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
cl_int err;
switch (buffer_type) {
case _BUFFER:
err= checker.SetupBuffer();
break;
case _Sub_BUFFER:
err= checker.SetupASSubBuffer(parent_buffer_flag);
break;
}
cBuffer_check_mem_host_read_only<TEST_ELEMENT_TYPE> checker(deviceID,
context, queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
cl_int err;
switch (buffer_type)
{
case _BUFFER: err = checker.SetupBuffer(); break;
case _Sub_BUFFER:
err = checker.SetupASSubBuffer(parent_buffer_flag);
break;
}
test_error(err, __FUNCTION__);
checker.Setup_Test_Environment();
err = checker.verify_RW_Buffer_mapping();
test_error(err, __FUNCTION__);
clFinish(queue);
test_error(err, __FUNCTION__);
checker.Setup_Test_Environment();
err = checker.verify_RW_Buffer_mapping();
test_error(err, __FUNCTION__);
clFinish(queue);
return err;
return err;
}
int test_mem_host_read_only_buffer(cl_device_id deviceID, cl_context context,
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_READ_WRITE | CL_MEM_COPY_HOST_PTR | CL_MEM_HOST_READ_ONLY};
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_int err = CL_SUCCESS;
cl_bool blocking[2] = {CL_TRUE, CL_FALSE};
for (int k=0; k<2; k++)
for (int i=0; i< 2; i++)
{
cl_bool blocking[2] = { CL_TRUE, CL_FALSE };
for (int k = 0; k < 2; k++)
for (int i = 0; i < 2; i++)
{
err = test_mem_host_read_only_buffer_RW(deviceID, context, queue, blocking[i],
buffer_mem_flags[k], 0, _BUFFER);
test_error(err, __FUNCTION__);
err = test_mem_host_read_only_buffer_RW(
deviceID, 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, _BUFFER);
test_error(err, __FUNCTION__);
err = test_mem_host_read_only_buffer_RW_Rect(
deviceID, 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, _BUFFER);
test_error(err, __FUNCTION__);
}
err = test_mem_host_read_only_buffer_RW_Mapping(
deviceID, context, queue, blocking[i], buffer_mem_flags[k], 0,
_BUFFER);
test_error(err, __FUNCTION__);
}
return err;
return err;
}
int test_mem_host_read_only_subbuffer(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements)
{
cl_mem_flags parent_buffer_mem_flags[1] = {CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_READ_ONLY};
cl_mem_flags parent_buffer_mem_flags[1] = { CL_MEM_READ_WRITE
| CL_MEM_USE_HOST_PTR
| CL_MEM_HOST_READ_ONLY };
cl_mem_flags buffer_mem_flags[4] = {0, CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR,
CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR,
CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR};
cl_mem_flags buffer_mem_flags[4] = {
0, CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR,
CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR,
CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR
};
cl_int err = CL_SUCCESS;
cl_int err = CL_SUCCESS;
cl_bool blocking[2] = {CL_TRUE, CL_FALSE};
cl_bool blocking[2] = { CL_TRUE, CL_FALSE };
for (int p=0; p<1; p++) {
for (int k=0; k<4; k++)
for (int i=0; i<2; i++)
{
err = test_mem_host_read_only_buffer_RW(deviceID, context, queue, blocking[i],
buffer_mem_flags[k], parent_buffer_mem_flags[p], _Sub_BUFFER);
test_error(err, __FUNCTION__);
for (int p = 0; p < 1; p++)
{
for (int k = 0; k < 4; k++)
for (int i = 0; i < 2; i++)
{
err = test_mem_host_read_only_buffer_RW(
deviceID, 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], 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],
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], 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],
parent_buffer_mem_flags[p], _Sub_BUFFER);
test_error(err, __FUNCTION__);
}
}
return err;
return err;
}
//=============================== Write only
static cl_int test_mem_host_write_only_buffer_RW(cl_device_id deviceID, 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)
static cl_int test_mem_host_write_only_buffer_RW(
cl_device_id deviceID, 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__);
log_info("%s\n", __FUNCTION__);
cBuffer_check_mem_host_write_only< TEST_ELEMENT_TYPE > checker(deviceID, context, queue);
cBuffer_check_mem_host_write_only<TEST_ELEMENT_TYPE> checker(
deviceID, context, queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
cl_int err;
switch (buffer_type) {
case _BUFFER:
err = checker.SetupBuffer();
break;
case _Sub_BUFFER:
err = checker.SetupASSubBuffer( parent_buffer_flag );
break;
}
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
cl_int err;
switch (buffer_type)
{
case _BUFFER: err = checker.SetupBuffer(); break;
case _Sub_BUFFER:
err = checker.SetupASSubBuffer(parent_buffer_flag);
break;
}
test_error(err, __FUNCTION__);
checker.Setup_Test_Environment();
err= checker.verify_RW_Buffer();
test_error(err, __FUNCTION__);
clFinish(queue);
test_error(err, __FUNCTION__);
checker.Setup_Test_Environment();
err = checker.verify_RW_Buffer();
test_error(err, __FUNCTION__);
clFinish(queue);
return err;
return err;
}
static cl_int test_mem_host_write_only_buffer_RW_Rect(cl_device_id deviceID, 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)
static cl_int test_mem_host_write_only_buffer_RW_Rect(
cl_device_id deviceID, 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__);
log_info("%s\n", __FUNCTION__);
cBuffer_check_mem_host_write_only< TEST_ELEMENT_TYPE > checker(deviceID, context, queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
cl_int err;
switch (buffer_type) {
case _BUFFER:
err= checker.SetupBuffer();
break;
case _Sub_BUFFER:
err= checker.SetupASSubBuffer(parent_buffer_flag);
break;
}
cBuffer_check_mem_host_write_only<TEST_ELEMENT_TYPE> checker(
deviceID, context, queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
cl_int err;
switch (buffer_type)
{
case _BUFFER: err = checker.SetupBuffer(); break;
case _Sub_BUFFER:
err = checker.SetupASSubBuffer(parent_buffer_flag);
break;
}
test_error(err, __FUNCTION__);
checker.Setup_Test_Environment();
err= checker.verify_RW_Buffer_rect();
test_error(err, __FUNCTION__);
clFinish(queue);
test_error(err, __FUNCTION__);
checker.Setup_Test_Environment();
err = checker.verify_RW_Buffer_rect();
test_error(err, __FUNCTION__);
clFinish(queue);
return err;
return err;
}
static cl_int test_mem_host_write_only_buffer_RW_Mapping(cl_device_id deviceID, 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)
static cl_int test_mem_host_write_only_buffer_RW_Mapping(
cl_device_id deviceID, 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__);
log_info("%s\n", __FUNCTION__);
cBuffer_check_mem_host_write_only< TEST_ELEMENT_TYPE > checker(deviceID, context, queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
cl_int err;
switch (buffer_type) {
case _BUFFER:
err= checker.SetupBuffer();
break;
case _Sub_BUFFER:
err= checker.SetupASSubBuffer(parent_buffer_flag);
break;
}
cBuffer_check_mem_host_write_only<TEST_ELEMENT_TYPE> checker(
deviceID, context, queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
cl_int err;
switch (buffer_type)
{
case _BUFFER: err = checker.SetupBuffer(); break;
case _Sub_BUFFER:
err = checker.SetupASSubBuffer(parent_buffer_flag);
break;
}
test_error(err, __FUNCTION__);
checker.Setup_Test_Environment();
err= checker.verify_RW_Buffer_mapping();
test_error(err, __FUNCTION__);
clFinish(queue);
test_error(err, __FUNCTION__);
checker.Setup_Test_Environment();
err = checker.verify_RW_Buffer_mapping();
test_error(err, __FUNCTION__);
clFinish(queue);
return err;
return err;
}
int test_mem_host_write_only_buffer(cl_device_id deviceID, cl_context context,
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_READ_WRITE | CL_MEM_COPY_HOST_PTR | CL_MEM_HOST_WRITE_ONLY};
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_int err = CL_SUCCESS;
cl_bool blocking[2] = {CL_TRUE, CL_FALSE};
for (int k=0; k<2; k++)
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, _BUFFER);
test_error(err, __FUNCTION__);
cl_bool blocking[2] = { CL_TRUE, CL_FALSE };
for (int k = 0; k < 2; k++)
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,
_BUFFER);
test_error(err, __FUNCTION__);
err = test_mem_host_write_only_buffer_RW_Rect(deviceID, 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,
_BUFFER);
test_error(err, __FUNCTION__);
err = test_mem_host_write_only_buffer_RW_Mapping(deviceID, 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,
_BUFFER);
test_error(err, __FUNCTION__);
}
return err;
return err;
}
int test_mem_host_write_only_subbuffer(cl_device_id deviceID, cl_context context,
int test_mem_host_write_only_subbuffer(cl_device_id deviceID,
cl_context context,
cl_command_queue queue, int num_elements)
{
cl_mem_flags parent_buffer_mem_flags[1] = {CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_WRITE_ONLY};
cl_mem_flags parent_buffer_mem_flags[1] = { CL_MEM_READ_WRITE
| CL_MEM_USE_HOST_PTR
| CL_MEM_HOST_WRITE_ONLY };
cl_mem_flags buffer_mem_flags[4] = {0, CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR,
CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR,
CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR};
cl_mem_flags buffer_mem_flags[4] = {
0, CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR,
CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR,
CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR
};
cl_int err = CL_SUCCESS;
cl_int err = CL_SUCCESS;
cl_bool blocking[2] = {CL_TRUE, CL_FALSE};
cl_bool blocking[2] = { CL_TRUE, CL_FALSE };
for (int p=0; p<1; p++) {
for (int m=0; m<4; m++) {
for (int i=0; i< 2; i++)
{
err = test_mem_host_write_only_buffer_RW(deviceID, context, queue, blocking[i],
buffer_mem_flags[m], parent_buffer_mem_flags[p], _Sub_BUFFER);
test_error(err, __FUNCTION__);
for (int p = 0; p < 1; p++)
{
for (int m = 0; m < 4; m++)
{
for (int i = 0; i < 2; i++)
{
err = test_mem_host_write_only_buffer_RW(
deviceID, 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], 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],
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] , 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],
parent_buffer_mem_flags[p], _Sub_BUFFER);
test_error(err, __FUNCTION__);
}
}
}
}
return err;
return err;
}
//===================== NO ACCESS
static cl_int test_mem_host_no_access_buffer_RW(cl_device_id deviceID, 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)
static cl_int test_mem_host_no_access_buffer_RW(
cl_device_id deviceID, 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__);
log_info("%s\n", __FUNCTION__);
cBuffer_check_mem_host_no_access< TEST_ELEMENT_TYPE > checker(deviceID, context, queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
cBuffer_check_mem_host_no_access<TEST_ELEMENT_TYPE> checker(deviceID,
context, queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
cl_int err = CL_SUCCESS;
switch (buffer_type) {
case _BUFFER:
err= checker.SetupBuffer();
break;
case _Sub_BUFFER:
err= checker.SetupASSubBuffer(parent_buffer_flag);
break;
}
cl_int err = CL_SUCCESS;
switch (buffer_type)
{
case _BUFFER: err = checker.SetupBuffer(); break;
case _Sub_BUFFER:
err = checker.SetupASSubBuffer(parent_buffer_flag);
break;
}
test_error(err, __FUNCTION__);
checker.Setup_Test_Environment();
err= checker.verify_RW_Buffer_mapping();
test_error(err, __FUNCTION__);
clFinish(queue);
test_error(err, __FUNCTION__);
checker.Setup_Test_Environment();
err = checker.verify_RW_Buffer_mapping();
test_error(err, __FUNCTION__);
clFinish(queue);
return err;
return err;
}
static cl_int test_mem_host_no_access_buffer_RW_Rect(cl_device_id deviceID, 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)
static cl_int test_mem_host_no_access_buffer_RW_Rect(
cl_device_id deviceID, 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__);
log_info("%s\n", __FUNCTION__);
cBuffer_check_mem_host_no_access< TEST_ELEMENT_TYPE > checker(deviceID, context, queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
cl_int err;
switch (buffer_type) {
case _BUFFER:
err= checker.SetupBuffer();
break;
case _Sub_BUFFER:
err= checker.SetupASSubBuffer(parent_buffer_flag);
break;
}
cBuffer_check_mem_host_no_access<TEST_ELEMENT_TYPE> checker(deviceID,
context, queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
cl_int err;
switch (buffer_type)
{
case _BUFFER: err = checker.SetupBuffer(); break;
case _Sub_BUFFER:
err = checker.SetupASSubBuffer(parent_buffer_flag);
break;
}
test_error(err, __FUNCTION__);
checker.Setup_Test_Environment();
err= checker.verify_RW_Buffer_mapping();
test_error(err, __FUNCTION__);
clFinish(queue);
test_error(err, __FUNCTION__);
checker.Setup_Test_Environment();
err = checker.verify_RW_Buffer_mapping();
test_error(err, __FUNCTION__);
clFinish(queue);
return err;
return err;
}
static cl_int test_mem_host_no_access_buffer_RW_Mapping(cl_device_id deviceID, 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)
static cl_int test_mem_host_no_access_buffer_RW_Mapping(
cl_device_id deviceID, 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__);
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(deviceID,
context, queue);
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
cl_int err;
switch (buffer_type) {
case _BUFFER:
err= checker.SetupBuffer();
break;
case _Sub_BUFFER:
err= checker.SetupASSubBuffer(parent_buffer_flag);
break;
}
checker.m_blocking = blocking;
checker.buffer_mem_flag = buffer_mem_flag;
cl_int err;
switch (buffer_type)
{
case _BUFFER: err = checker.SetupBuffer(); break;
case _Sub_BUFFER:
err = checker.SetupASSubBuffer(parent_buffer_flag);
break;
}
test_error(err, __FUNCTION__);
checker.Setup_Test_Environment();
err= checker.verify_RW_Buffer_mapping();
test_error(err, __FUNCTION__);
clFinish(queue);
test_error(err, __FUNCTION__);
checker.Setup_Test_Environment();
err = checker.verify_RW_Buffer_mapping();
test_error(err, __FUNCTION__);
clFinish(queue);
return err;
return err;
}
int test_mem_host_no_access_buffer(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements)
{
cl_mem_flags buffer_mem_flag[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_mem_flags buffer_mem_flag[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_int err = CL_SUCCESS;
cl_bool blocking[2] = {CL_TRUE, CL_FALSE};
for (int k=0; k<2; k++)
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, _BUFFER);
test_error(err, __FUNCTION__);
cl_bool blocking[2] = { CL_TRUE, CL_FALSE };
for (int k = 0; k < 2; k++)
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,
_BUFFER);
test_error(err, __FUNCTION__);
err = test_mem_host_no_access_buffer_RW_Rect(deviceID, 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,
_BUFFER);
test_error(err, __FUNCTION__);
err = test_mem_host_no_access_buffer_RW_Mapping(deviceID, 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,
_BUFFER);
test_error(err, __FUNCTION__);
}
return err;
return err;
}
int test_mem_host_no_access_subbuffer(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements)
{
cl_mem_flags parent_buffer_mem_flags[3] = { CL_MEM_READ_WRITE | CL_MEM_USE_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_USE_HOST_PTR | CL_MEM_HOST_NO_ACCESS};
cl_mem_flags parent_buffer_mem_flags[3] = {
CL_MEM_READ_WRITE | CL_MEM_USE_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_USE_HOST_PTR | CL_MEM_HOST_NO_ACCESS
};
cl_mem_flags buffer_mem_flags[4] = {0, CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR,
CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR,
CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR};
cl_mem_flags buffer_mem_flags[4] = {
0, CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR,
CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR,
CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR
};
cl_int err = CL_SUCCESS;
cl_int err = CL_SUCCESS;
cl_bool blocking[2] = {CL_TRUE, CL_FALSE};
for (int p=0; p<3; p++) {
for (int k=0; k<4; k++) {
for (int i=0; i<2; i++) {
err += test_mem_host_no_access_buffer_RW(deviceID, context, queue, blocking[i],
buffer_mem_flags[k], parent_buffer_mem_flags[p], _Sub_BUFFER);
cl_bool blocking[2] = { CL_TRUE, CL_FALSE };
for (int p = 0; p < 3; p++)
{
for (int k = 0; k < 4; k++)
{
for (int i = 0; i < 2; i++)
{
err += test_mem_host_no_access_buffer_RW(
deviceID, 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], 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],
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], 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],
parent_buffer_mem_flags[p], _Sub_BUFFER);
}
}
}
}
return err;
return err;
}