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

Refactor buffer ReadWrite and Copy tests (#2259)

Browse Source 
This change refactors the following tests to use RAII to clean-up
allocated resources on exit, and adds additional changes as mentioned
below:

- test_arrayreadwrite
    - Allow different `cl_mem_flags` to be passed to the test.
- test_bufferreadwriterect:
    - Allow different `cl_mem_flags` to be passed to the test.
    - Customisable copy, read and write functions.
- test_buffer_copy
- Fill the destination buffer with `invalid_ptr` instead of `out_ptr` if
created with `CL_MEM_(USE/COPY)_HOST_PTR`.
- test_buffer_partial_copy
- Fill the destination buffer with `invalid_ptr` instead of `out_ptr` if
created with `CL_MEM_(USE/COPY)_HOST_PTR`.

---------

Signed-off-by: Michael Rizkalla <michael.rizkalla@arm.com>
This commit is contained in:
Michael Rizkalla
2025-06-24 23:27:37 +01:00
committed by GitHub
parent 880bce6047
commit 9265cbb2c2
3 changed files with 241 additions and 150 deletions
Download Patch File Download Diff File Expand all files Collapse all files

59
test_conformance/basic/test_arrayreadwrite.cpp
View File

@@ -20,31 +20,42 @@
#include <string.h> #include <string.h>
#include <sys/types.h> #include <sys/types.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <vector>
#include "testBase.h" #include "testBase.h"
REGISTER_TEST(arrayreadwrite) static int test_arrayreadwrite_impl(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements,
cl_mem_flags flags)
{ {
cl_uint *inptr, *outptr; clMemWrapper buffer;
cl_mem streams[1];
int num_tries = 400; int num_tries = 400;
num_elements = 1024 * 1024 * 4; num_elements = 1024 * 1024 * 4;
int i, j, err; MTdataHolder d(gRandomSeed);
MTdata d;
inptr = (cl_uint*)malloc(num_elements*sizeof(cl_uint)); std::vector<cl_uint> reference_vals(num_elements);
outptr = (cl_uint*)malloc(num_elements*sizeof(cl_uint)); std::vector<cl_uint> inptr(num_elements);
std::vector<cl_uint> outptr(num_elements);
// randomize data // randomize data
d = init_genrand( gRandomSeed ); for (int i = 0; i < num_elements; i++)
for (i=0; i<num_elements; i++) {
inptr[i] = (cl_uint)(genrand_int32(d) & 0x7FFFFFFF); inptr[i] = (cl_uint)(genrand_int32(d) & 0x7FFFFFFF);
reference_vals[i] = (cl_uint)(genrand_int32(d) & 0x7FFFFFFF);
}
streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE, void* host_ptr = nullptr;
sizeof(cl_uint) * num_elements, NULL, &err); if ((flags & CL_MEM_USE_HOST_PTR) || (flags & CL_MEM_COPY_HOST_PTR))
{
host_ptr = inptr.data();
}
cl_int err = CL_SUCCESS;
buffer = clCreateBuffer(context, flags, sizeof(cl_uint) * num_elements,
host_ptr, &err);
test_error(err, "clCreateBuffer failed"); test_error(err, "clCreateBuffer failed");
for (i=0; i<num_tries; i++) for (int i = 0; i < num_tries; i++)
{ {
int offset; int offset;
int cb; int cb;
@@ -58,15 +69,19 @@ REGISTER_TEST(arrayreadwrite)
if (cb > (num_elements - offset)) if (cb > (num_elements - offset))
cb = num_elements - offset; cb = num_elements - offset;
err = clEnqueueWriteBuffer(queue, streams[0], CL_TRUE, offset*sizeof(cl_uint), sizeof(cl_uint)*cb,&inptr[offset], 0, NULL, NULL); err = clEnqueueWriteBuffer(
queue, buffer, CL_TRUE, offset * sizeof(cl_uint),
sizeof(cl_uint) * cb, &reference_vals[offset], 0, nullptr, nullptr);
test_error(err, "clEnqueueWriteBuffer failed"); test_error(err, "clEnqueueWriteBuffer failed");
err = clEnqueueReadBuffer( queue, streams[0], CL_TRUE, offset*sizeof(cl_uint), cb*sizeof(cl_uint), &outptr[offset], 0, NULL, NULL ); err = clEnqueueReadBuffer(
queue, buffer, CL_TRUE, offset * sizeof(cl_uint),
cb * sizeof(cl_uint), &outptr[offset], 0, nullptr, nullptr);
test_error(err, "clEnqueueReadBuffer failed"); test_error(err, "clEnqueueReadBuffer failed");
for (j=offset; j<offset+cb; j++) for (int j = offset; j < offset + cb; j++)
{ {
if (inptr[j] != outptr[j]) if (reference_vals[j] != outptr[j])
{ {
log_error("ARRAY read, write test failed\n"); log_error("ARRAY read, write test failed\n");
err = -1; err = -1;
@@ -78,13 +93,15 @@ REGISTER_TEST(arrayreadwrite)
break; break;
} }
free_mtdata(d);
clReleaseMemObject(streams[0]);
free(inptr);
free(outptr);
if (!err) if (!err)
log_info("ARRAY read, write test passed\n"); log_info("ARRAY read, write test passed\n");
return err; return err;
} }
REGISTER_TEST(arrayreadwrite)
{
return test_arrayreadwrite_impl(device, context, queue, num_elements,
CL_MEM_READ_WRITE);
}

41
test_conformance/basic/test_bufferreadwriterect.cpp
View File

@@ -342,8 +342,21 @@ void CL_CALLBACK mem_obj_destructor_callback( cl_mem, void *data )
free( data ); free( data );
} }
// This is the main test function for the conformance test. using test_fn = int (*)(size_t, size_t[3], size_t[3], size_t, size_t[3],
REGISTER_TEST(bufferreadwriterect) size_t[3]);
struct TestFunctions
{
test_fn copy;
test_fn read;
test_fn write;
};
static int test_bufferreadwriterect_impl(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements,
cl_map_flags buffer_flags,
const TestFunctions& test_functions)
{ {
gQueue = queue; gQueue = queue;
cl_int err; cl_int err;
@@ -434,7 +447,8 @@ REGISTER_TEST(bufferreadwriterect)
memcpy(backing[i], verify[i], size_bytes); memcpy(backing[i], verify[i], size_bytes);
// Create the CL buffer. // Create the CL buffer.
buffer[i] = clCreateBuffer (context, CL_MEM_USE_HOST_PTR | CL_MEM_READ_WRITE, size_bytes, backing[i], &err); buffer[i] =
clCreateBuffer(context, buffer_flags, size_bytes, backing[i], &err);
CL_EXIT_ERROR(err,"clCreateBuffer failed for buffer %u", i); CL_EXIT_ERROR(err,"clCreateBuffer failed for buffer %u", i);
// Make sure buffer is cleaned up appropriately if we encounter an error in the rest of the calls. // Make sure buffer is cleaned up appropriately if we encounter an error in the rest of the calls.
@@ -499,7 +513,8 @@ REGISTER_TEST(bufferreadwriterect)
doffset[0], doffset[1], doffset[2], sregion[0], doffset[0], doffset[1], doffset[2], sregion[0],
sregion[1], sregion[2], sregion[1], sregion[2],
sregion[0] * sregion[1] * sregion[2]); sregion[0] * sregion[1] * sregion[2]);
if ((err = copy_region(src, soffset, sregion, dst, doffset, dregion))) if ((err = test_functions.copy(src, soffset, sregion, dst,
doffset, dregion)))
return err; return err;
break; break;
case 1: case 1:
@@ -509,7 +524,8 @@ REGISTER_TEST(bufferreadwriterect)
doffset[0], doffset[1], doffset[2], sregion[0], doffset[0], doffset[1], doffset[2], sregion[0],
sregion[1], sregion[2], sregion[1], sregion[2],
sregion[0] * sregion[1] * sregion[2]); sregion[0] * sregion[1] * sregion[2]);
if ((err = read_verify_region(src, soffset, sregion, dst, doffset, dregion))) if ((err = test_functions.read(src, soffset, sregion, dst,
doffset, dregion)))
return err; return err;
break; break;
case 2: case 2:
@@ -519,7 +535,8 @@ REGISTER_TEST(bufferreadwriterect)
doffset[0], doffset[1], doffset[2], sregion[0], doffset[0], doffset[1], doffset[2], sregion[0],
sregion[1], sregion[2], sregion[1], sregion[2],
sregion[0] * sregion[1] * sregion[2]); sregion[0] * sregion[1] * sregion[2]);
if ((err = write_region(src, soffset, sregion, dst, doffset, dregion))) if ((err = test_functions.write(src, soffset, sregion, dst,
doffset, dregion)))
return err; return err;
break; break;
} }
@@ -562,3 +579,15 @@ REGISTER_TEST(bufferreadwriterect)
return err; return err;
} }
// This is the main test function for the conformance test.
REGISTER_TEST(bufferreadwriterect)
{
TestFunctions test_functions;
test_functions.copy = copy_region;
test_functions.read = read_verify_region;
test_functions.write = write_region;
return test_bufferreadwriterect_impl(
device, context, queue, num_elements,
CL_MEM_USE_HOST_PTR | CL_MEM_READ_WRITE, test_functions);
}

291
test_conformance/buffers/test_buffer_copy.cpp
View File

@@ -15,6 +15,7 @@
// //
#include "harness/compat.h" #include "harness/compat.h"
#include <memory>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
@@ -36,210 +37,246 @@ static int verify_copy_buffer(int *inptr, int *outptr, int n)
return 0; return 0;
} }
using alignedOwningPtr = std::unique_ptr<cl_int[], decltype(&align_free)>;
static int test_copy( cl_command_queue queue, cl_context context, int num_elements, MTdata d ) static int test_copy( cl_command_queue queue, cl_context context, int num_elements, MTdata d )
{ {
cl_mem buffers[2]; clMemWrapper buffers[2];
cl_int *int_input_ptr, *int_output_ptr; cl_int err = CL_SUCCESS;
cl_int err;
int i;
int src_flag_id, dst_flag_id;
int errors = 0;
size_t min_alignment = get_min_alignment(context); size_t min_alignment = get_min_alignment(context);
int_input_ptr = (cl_int*) align_malloc(sizeof(cl_int) * num_elements, min_alignment); alignedOwningPtr invalid_ptr{
int_output_ptr = (cl_int*)align_malloc(sizeof(cl_int) * num_elements, min_alignment); (cl_int *)align_malloc(sizeof(cl_int) * num_elements, min_alignment),
align_free
};
if (!invalid_ptr)
{
log_error(" unable to allocate %zu bytes of memory\n",
sizeof(cl_int) * num_elements);
return TEST_FAIL;
}
alignedOwningPtr out_ptr{ (cl_int *)align_malloc(
sizeof(cl_int) * num_elements, min_alignment),
align_free };
if (!out_ptr)
{
log_error(" unable to allocate %zu bytes of memory\n",
sizeof(cl_int) * num_elements);
return TEST_FAIL;
}
alignedOwningPtr reference_ptr{
(cl_int *)align_malloc(sizeof(cl_int) * num_elements, min_alignment),
align_free
};
if (!reference_ptr)
{
log_error(" unable to allocate %zu bytes of memory\n",
sizeof(cl_int) * num_elements);
return TEST_FAIL;
}
for (src_flag_id=0; src_flag_id < NUM_FLAGS; src_flag_id++) { for (int src_flag_id = 0; src_flag_id < NUM_FLAGS; src_flag_id++)
for (dst_flag_id=0; dst_flag_id < NUM_FLAGS; dst_flag_id++) { {
for (int dst_flag_id = 0; dst_flag_id < NUM_FLAGS; dst_flag_id++)
{
log_info("Testing with cl_mem_flags src: %s dst: %s\n", flag_set_names[src_flag_id], flag_set_names[dst_flag_id]); log_info("Testing with cl_mem_flags src: %s dst: %s\n", flag_set_names[src_flag_id], flag_set_names[dst_flag_id]);
for (i=0; i<num_elements; i++){ for (int i = 0; i < num_elements; i++)
int_input_ptr[i] = (int)genrand_int32( d ); {
int_output_ptr[i] = 0xdeaddead; // seed with incorrect data invalid_ptr[i] = static_cast<int>(0xdeaddead);
out_ptr[i] = static_cast<int>(0xdeadbeef);
reference_ptr[i] = (int)genrand_int32(d);
} }
if ((flag_set[src_flag_id] & CL_MEM_USE_HOST_PTR) || (flag_set[src_flag_id] & CL_MEM_COPY_HOST_PTR)) if ((flag_set[src_flag_id] & CL_MEM_USE_HOST_PTR) || (flag_set[src_flag_id] & CL_MEM_COPY_HOST_PTR))
buffers[0] = clCreateBuffer(context, flag_set[src_flag_id], sizeof(cl_int) * num_elements, int_input_ptr, &err); buffers[0] = clCreateBuffer(context, flag_set[src_flag_id],
sizeof(cl_int) * num_elements,
reference_ptr.get(), &err);
else else
buffers[0] = clCreateBuffer(context, flag_set[src_flag_id], sizeof(cl_int) * num_elements, NULL, &err); buffers[0] = clCreateBuffer(context, flag_set[src_flag_id],
sizeof(cl_int) * num_elements,
nullptr, &err);
if ( err != CL_SUCCESS ){ if ( err != CL_SUCCESS ){
print_error(err, " clCreateBuffer failed\n" ); print_error(err, "clCreateBuffer failed\n");
align_free( (void *)int_input_ptr ); return TEST_FAIL;
align_free( (void *)int_output_ptr );
return -1;
} }
if ((flag_set[dst_flag_id] & CL_MEM_USE_HOST_PTR) || (flag_set[dst_flag_id] & CL_MEM_COPY_HOST_PTR)) if ((flag_set[dst_flag_id] & CL_MEM_USE_HOST_PTR) || (flag_set[dst_flag_id] & CL_MEM_COPY_HOST_PTR))
buffers[1] = clCreateBuffer(context, flag_set[dst_flag_id], sizeof(cl_int) * num_elements, int_output_ptr, &err); buffers[1] = clCreateBuffer(context, flag_set[dst_flag_id],
sizeof(cl_int) * num_elements,
invalid_ptr.get(), &err);
else else
buffers[1] = clCreateBuffer(context, flag_set[dst_flag_id], sizeof(cl_int) * num_elements, NULL, &err); buffers[1] = clCreateBuffer(context, flag_set[dst_flag_id],
sizeof(cl_int) * num_elements,
nullptr, &err);
if ( err != CL_SUCCESS ){ if ( err != CL_SUCCESS ){
print_error(err, " clCreateBuffer failed\n" ); print_error(err, "clCreateBuffer failed\n");
clReleaseMemObject( buffers[0] ); return TEST_FAIL;
align_free( (void *)int_input_ptr );
align_free( (void *)int_output_ptr );
return -1;
} }
if (!(flag_set[src_flag_id] & CL_MEM_USE_HOST_PTR) && !(flag_set[src_flag_id] & CL_MEM_COPY_HOST_PTR)) { if (!(flag_set[src_flag_id] & CL_MEM_USE_HOST_PTR) && !(flag_set[src_flag_id] & CL_MEM_COPY_HOST_PTR)) {
err = clEnqueueWriteBuffer(queue, buffers[0], CL_TRUE, 0, sizeof(cl_int)*num_elements, (void *)int_input_ptr, 0, NULL, NULL); err = clEnqueueWriteBuffer(queue, buffers[0], CL_TRUE, 0,
sizeof(cl_int) * num_elements,
reference_ptr.get(), 0, nullptr,
nullptr);
if ( err != CL_SUCCESS ){ if ( err != CL_SUCCESS ){
print_error( err, "clEnqueueWriteBuffer failed" ); print_error(err, "clEnqueueWriteBuffer failed\n");
clReleaseMemObject( buffers[0] ); return TEST_FAIL;
clReleaseMemObject( buffers[1] );
align_free( (void *)int_output_ptr );
align_free( (void *)int_input_ptr );
return -1;
} }
} }
err = clEnqueueCopyBuffer(queue, buffers[0], buffers[1], 0, 0, sizeof(cl_int)*num_elements, 0, NULL, NULL); err = clEnqueueCopyBuffer(queue, buffers[0], buffers[1], 0, 0,
sizeof(cl_int) * num_elements, 0, nullptr,
nullptr);
if ( err != CL_SUCCESS ){ if ( err != CL_SUCCESS ){
print_error( err, "clCopyArray failed" ); print_error(err, "clCopyArray failed\n");
clReleaseMemObject( buffers[0] ); return TEST_FAIL;
clReleaseMemObject( buffers[1] );
align_free( (void *)int_output_ptr );
align_free( (void *)int_input_ptr );
return -1;
} }
err = clEnqueueReadBuffer( queue, buffers[1], true, 0, sizeof(int)*num_elements, (void *)int_output_ptr, 0, NULL, NULL ); err = clEnqueueReadBuffer(queue, buffers[1], true, 0,
sizeof(int) * num_elements, out_ptr.get(),
0, nullptr, nullptr);
if ( err != CL_SUCCESS ){ if ( err != CL_SUCCESS ){
print_error( err, "clEnqueueReadBuffer failed" ); print_error(err, "clEnqueueReadBuffer failed\n");
clReleaseMemObject( buffers[0] ); return TEST_FAIL;
clReleaseMemObject( buffers[1] );
align_free( (void *)int_output_ptr );
align_free( (void *)int_input_ptr );
return -1;
} }
if ( verify_copy_buffer(int_input_ptr, int_output_ptr, num_elements) ){ if (verify_copy_buffer(reference_ptr.get(), out_ptr.get(),
num_elements))
{
log_error( " test failed\n" ); log_error( " test failed\n" );
errors++; return TEST_FAIL;
} }
else{ else{
log_info( " test passed\n" ); log_info( " test passed\n" );
} }
// cleanup
clReleaseMemObject( buffers[0] );
clReleaseMemObject( buffers[1] );
} // dst flags } // dst flags
} // src flags } // src flags
// cleanup
align_free( (void *)int_output_ptr );
align_free( (void *)int_input_ptr );
return errors; return TEST_PASS;
} // end test_copy() } // end test_copy()
static int testPartialCopy( cl_command_queue queue, cl_context context, int num_elements, cl_uint srcStart, cl_uint dstStart, int size, MTdata d ) static int testPartialCopy( cl_command_queue queue, cl_context context, int num_elements, cl_uint srcStart, cl_uint dstStart, int size, MTdata d )
{ {
cl_mem buffers[2]; clMemWrapper buffers[2];
int *inptr, *outptr; cl_int err = CL_SUCCESS;
cl_int err;
int i;
int src_flag_id, dst_flag_id;
int errors = 0;
size_t min_alignment = get_min_alignment(context); size_t min_alignment = get_min_alignment(context);
inptr = (int *)align_malloc( sizeof(int) * num_elements, min_alignment); alignedOwningPtr invalid_ptr{
if ( ! inptr ){ (cl_int *)align_malloc(sizeof(cl_int) * num_elements, min_alignment),
log_error( " unable to allocate %d bytes of memory\n", (int)sizeof(int) * num_elements ); align_free
return -1; };
if (!invalid_ptr)
{
log_error(" unable to allocate %zu bytes of memory\n",
sizeof(cl_int) * num_elements);
return TEST_FAIL;
} }
outptr = (int *)align_malloc( sizeof(int) * num_elements, min_alignment); alignedOwningPtr out_ptr{ (cl_int *)align_malloc(
if ( ! outptr ){ sizeof(cl_int) * num_elements, min_alignment),
log_error( " unable to allocate %d bytes of memory\n", (int)sizeof(int) * num_elements ); align_free };
align_free( (void *)inptr ); if (!out_ptr)
return -1; {
log_error(" unable to allocate %zu bytes of memory\n",
sizeof(cl_int) * num_elements);
return TEST_FAIL;
}
alignedOwningPtr reference_ptr{
(cl_int *)align_malloc(sizeof(cl_int) * num_elements, min_alignment),
align_free
};
if (!reference_ptr)
{
log_error(" unable to allocate %zu bytes of memory\n",
sizeof(cl_int) * num_elements);
return TEST_FAIL;
} }
for (src_flag_id=0; src_flag_id < NUM_FLAGS; src_flag_id++) { for (int src_flag_id = 0; src_flag_id < NUM_FLAGS; src_flag_id++)
for (dst_flag_id=0; dst_flag_id < NUM_FLAGS; dst_flag_id++) { {
for (int dst_flag_id = 0; dst_flag_id < NUM_FLAGS; dst_flag_id++)
{
log_info("Testing with cl_mem_flags src: %s dst: %s\n", flag_set_names[src_flag_id], flag_set_names[dst_flag_id]); log_info("Testing with cl_mem_flags src: %s dst: %s\n", flag_set_names[src_flag_id], flag_set_names[dst_flag_id]);
for (i=0; i<num_elements; i++){ for (int i = 0; i < num_elements; i++)
inptr[i] = (int)genrand_int32( d ); {
outptr[i] = (int)0xdeaddead; // seed with incorrect data invalid_ptr[i] = static_cast<int>(0xdeaddead);
out_ptr[i] = static_cast<int>(0xdeadbeef);
reference_ptr[i] = (int)genrand_int32(d);
} }
if ((flag_set[src_flag_id] & CL_MEM_USE_HOST_PTR) || (flag_set[src_flag_id] & CL_MEM_COPY_HOST_PTR)) if ((flag_set[src_flag_id] & CL_MEM_USE_HOST_PTR) || (flag_set[src_flag_id] & CL_MEM_COPY_HOST_PTR))
buffers[0] = clCreateBuffer(context, flag_set[src_flag_id], sizeof(cl_int) * num_elements, inptr, &err); buffers[0] = clCreateBuffer(context, flag_set[src_flag_id],
sizeof(cl_int) * num_elements,
reference_ptr.get(), &err);
else else
buffers[0] = clCreateBuffer(context, flag_set[src_flag_id], sizeof(cl_int) * num_elements, NULL, &err); buffers[0] = clCreateBuffer(context, flag_set[src_flag_id],
sizeof(cl_int) * num_elements,
nullptr, &err);
if ( err != CL_SUCCESS ){ if ( err != CL_SUCCESS ){
print_error(err, " clCreateBuffer failed\n" ) print_error(err, "clCreateBuffer failed\n");
align_free( (void *)outptr ); return TEST_FAIL;
align_free( (void *)inptr );
return -1;
} }
if ((flag_set[dst_flag_id] & CL_MEM_USE_HOST_PTR) || (flag_set[dst_flag_id] & CL_MEM_COPY_HOST_PTR)) if ((flag_set[dst_flag_id] & CL_MEM_USE_HOST_PTR) || (flag_set[dst_flag_id] & CL_MEM_COPY_HOST_PTR))
buffers[1] = clCreateBuffer(context, flag_set[dst_flag_id], sizeof(cl_int) * num_elements, outptr, &err); buffers[1] = clCreateBuffer(context, flag_set[dst_flag_id],
sizeof(cl_int) * num_elements,
invalid_ptr.get(), &err);
else else
buffers[1] = clCreateBuffer(context, flag_set[dst_flag_id], sizeof(cl_int) * num_elements, NULL, &err); buffers[1] = clCreateBuffer(context, flag_set[dst_flag_id],
sizeof(cl_int) * num_elements,
nullptr, &err);
if ( err != CL_SUCCESS ){ if ( err != CL_SUCCESS ){
print_error(err, " clCreateBuffer failed\n" ); print_error(err, "clCreateBuffer failed\n");
clReleaseMemObject( buffers[0] ); return TEST_FAIL;
align_free( (void *)outptr );
align_free( (void *)inptr );
return -1;
} }
if (!(flag_set[src_flag_id] & CL_MEM_USE_HOST_PTR) && !(flag_set[src_flag_id] & CL_MEM_COPY_HOST_PTR)){ if (!(flag_set[src_flag_id] & CL_MEM_USE_HOST_PTR) && !(flag_set[src_flag_id] & CL_MEM_COPY_HOST_PTR)){
err = clEnqueueWriteBuffer(queue, buffers[0], CL_TRUE, 0, sizeof(cl_int)*num_elements, (void *)inptr, 0, NULL, NULL); err = clEnqueueWriteBuffer(queue, buffers[0], CL_TRUE, 0,
sizeof(cl_int) * num_elements,
reference_ptr.get(), 0, nullptr,
nullptr);
if ( err != CL_SUCCESS ){ if ( err != CL_SUCCESS ){
print_error( err, "clEnqueueWriteBuffer failed" ); print_error(err, "clEnqueueWriteBuffer failed\n");
clReleaseMemObject( buffers[1] ); return TEST_FAIL;
clReleaseMemObject( buffers[0] );
align_free( (void *)outptr );
align_free( (void *)inptr );
return -1;
} }
} }
err = clEnqueueCopyBuffer(queue, buffers[0], buffers[1], srcStart*sizeof(cl_int), dstStart*sizeof(cl_int), sizeof(cl_int)*size, 0, NULL, NULL); err = clEnqueueCopyBuffer(
queue, buffers[0], buffers[1], srcStart * sizeof(cl_int),
dstStart * sizeof(cl_int), sizeof(cl_int) * size, 0, nullptr,
nullptr);
if ( err != CL_SUCCESS){ if ( err != CL_SUCCESS){
print_error( err, "clEnqueueCopyBuffer failed" ); print_error(err, "clEnqueueCopyBuffer failed\n");
clReleaseMemObject( buffers[1] ); return TEST_FAIL;
clReleaseMemObject( buffers[0] );
align_free( (void *)outptr );
align_free( (void *)inptr );
return -1;
} }
err = clEnqueueReadBuffer( queue, buffers[1], true, 0, sizeof(int)*num_elements, (void *)outptr, 0, NULL, NULL ); err = clEnqueueReadBuffer(queue, buffers[1], true, 0,
sizeof(int) * num_elements, out_ptr.get(),
0, nullptr, nullptr);
if ( err != CL_SUCCESS){ if ( err != CL_SUCCESS){
print_error( err, "clEnqueueReadBuffer failed" ); print_error(err, "clEnqueueReadBuffer failed\n");
clReleaseMemObject( buffers[1] ); return TEST_FAIL;
clReleaseMemObject( buffers[0] );
align_free( (void *)outptr );
align_free( (void *)inptr );
return -1;
} }
if ( verify_copy_buffer(inptr + srcStart, outptr + dstStart, size) ){ if (verify_copy_buffer(reference_ptr.get() + srcStart,
out_ptr.get() + dstStart, size))
{
log_error("buffer_COPY test failed\n"); log_error("buffer_COPY test failed\n");
errors++; return TEST_FAIL;
} }
else{ else{
log_info("buffer_COPY test passed\n"); log_info("buffer_COPY test passed\n");
} }
// cleanup
clReleaseMemObject( buffers[1] );
clReleaseMemObject( buffers[0] );
} // dst mem flags } // dst mem flags
} // src mem flags } // src mem flags
// cleanup
align_free( (void *)outptr );
align_free( (void *)inptr );
return errors; return TEST_PASS;
} // end testPartialCopy() } // end testPartialCopy()
@@ -252,15 +289,19 @@ REGISTER_TEST(buffer_copy)
// test the preset size // test the preset size
log_info( "set size: %d: ", num_elements ); log_info( "set size: %d: ", num_elements );
if (test_copy( queue, context, num_elements, d )) if (test_copy(queue, context, num_elements, d) != TEST_PASS)
{
err++; err++;
}
// now test random sizes // now test random sizes
for ( i = 0; i < 8; i++ ){ for ( i = 0; i < 8; i++ ){
size = (int)get_random_float(2.f,131072.f, d); size = (int)get_random_float(2.f,131072.f, d);
log_info( "random size: %d: ", size ); log_info( "random size: %d: ", size );
if (test_copy( queue, context, size, d )) if (test_copy(queue, context, size, d) != TEST_PASS)
{
err++; err++;
}
} }
free_mtdata(d); free_mtdata(d);
@@ -283,8 +324,12 @@ REGISTER_TEST(buffer_partial_copy)
size = (int)get_random_float( 8.f, (float)(num_elements - srcStart), d ); size = (int)get_random_float( 8.f, (float)(num_elements - srcStart), d );
dstStart = (cl_uint)get_random_float( 0.f, (float)(num_elements - size), d ); dstStart = (cl_uint)get_random_float( 0.f, (float)(num_elements - size), d );
log_info( "random partial copy from %d to %d, size: %d: ", (int)srcStart, (int)dstStart, size ); log_info( "random partial copy from %d to %d, size: %d: ", (int)srcStart, (int)dstStart, size );
if (testPartialCopy( queue, context, num_elements, srcStart, dstStart, size, d )) if (testPartialCopy(queue, context, num_elements, srcStart, dstStart,
size, d)
!= TEST_PASS)
{
err++; err++;
}
} }
free_mtdata(d); free_mtdata(d);