bool
piglit_cl_write_whole_buffer(cl_command_queue command_queue, cl_mem buffer,
const void *ptr)
{
bool success;
size_t* buffer_size;
buffer_size = piglit_cl_get_mem_object_info(buffer, CL_MEM_SIZE);
success = piglit_cl_write_buffer(command_queue, buffer, 0, *buffer_size,
ptr);
free(buffer_size);
return success;
}
enum piglit_result
piglit_cl_test(const int argc,
const char** argv,
const struct piglit_cl_custom_test_config* config,
const struct piglit_cl_custom_test_env* env)
{
enum piglit_result result = PIGLIT_PASS;
size_t global_size = 1;
size_t local_size = 1;
cl_int data = 0;
piglit_cl_context context = NULL;
cl_mem buffer = NULL;
cl_program program = NULL;
cl_kernel kernel = NULL;
/* Create objects up to the kernel */
context = piglit_cl_create_context(env->platform_id, &env->device_id, 1);
buffer = piglit_cl_create_buffer(context, CL_MEM_READ_WRITE,
sizeof(cl_int));
program = piglit_cl_build_program_with_source(context, 1, &source, "");
kernel = piglit_cl_create_kernel(program, "test");
/* Set kernel arguments and run the kernel */
piglit_cl_write_buffer(context->command_queues[0], buffer, 0,
sizeof(cl_int), &data);
piglit_cl_set_kernel_buffer_arg(kernel, 0, &buffer);
piglit_cl_execute_ND_range_kernel(context->command_queues[0], kernel, 1,
NULL, &global_size, &local_size);
/* Read the buffer and check the result */
piglit_cl_read_buffer(context->command_queues[0], buffer, 0,
sizeof(cl_int), &data);
if(data != -1) {
fprintf(stderr,
"Failed to properly execute the kernel.\n");
result = PIGLIT_FAIL;
}
/* Release resources */
clReleaseKernel(kernel);
clReleaseProgram(program);
clReleaseMemObject(buffer);
piglit_cl_release_context(context);
return result;
}
static enum piglit_result
buffer_test(piglit_cl_context *ctx,
cl_program *prg,
cl_mem_flags in_flags,
cl_mem_flags out_flags,
float data)
{
float in_data[BUFFER_SIZE];
float out_data[BUFFER_SIZE];
float *result = out_data;
cl_mem in_buffer = NULL, out_buffer = NULL;
cl_kernel kernel = NULL;
piglit_cl_context context = *ctx;
cl_int errNo;
unsigned i;
size_t global = BUFFER_SIZE;
size_t local = 1;
enum piglit_result ret = PIGLIT_PASS;
const char kernel_name[] = "test";
printf("> Running kernel test: in-0x%x-out-0x%x\n",
(unsigned)in_flags, (unsigned)out_flags);
for (i = 0; i < BUFFER_SIZE; ++i) {
in_data[i] = data;
out_data[i] = 0.0f;
}
printf("Using kernel %s\n", kernel_name);
printf("Creating buffers...\n");
/* Create input buffer */
if ((in_flags & CL_MEM_USE_HOST_PTR) ||
(in_flags & CL_MEM_COPY_HOST_PTR)) {
/* Use host side memory */
in_buffer = clCreateBuffer(context->cl_ctx, in_flags,
sizeof(in_data), in_data, &errNo);
} else {
/* Use device memory and copy */
in_buffer = clCreateBuffer(context->cl_ctx, in_flags,
sizeof(in_data), NULL, &errNo);
if (errNo == CL_SUCCESS && !piglit_cl_write_buffer(
context->command_queues[0], in_buffer, 0,
sizeof(in_data), in_data)) {
ret = PIGLIT_FAIL;
goto cleanup;
}
}
if(!piglit_cl_check_error(errNo, CL_SUCCESS)) {
fprintf(stderr,
"Could not create in buffer with flags %x: %s\n",
(unsigned)in_flags, piglit_cl_get_error_name(errNo));
ret = PIGLIT_FAIL;
goto cleanup;
}
/* Create destination buffer */
if ((out_flags & CL_MEM_USE_HOST_PTR) ||
(out_flags & CL_MEM_COPY_HOST_PTR)) {
out_buffer = clCreateBuffer(context->cl_ctx, out_flags,
sizeof(out_data), out_data, &errNo);
} else {
out_buffer = clCreateBuffer(context->cl_ctx, out_flags,
sizeof(out_data), NULL, &errNo);
}
if(!piglit_cl_check_error(errNo, CL_SUCCESS)) {
fprintf(stderr,
"Could not create out buffer with flags %x: %s\n",
(unsigned)out_flags, piglit_cl_get_error_name(errNo));
ret = PIGLIT_FAIL;
goto cleanup;
}
kernel = piglit_cl_create_kernel(*prg, kernel_name);
printf("Setting kernel arguments...\n");
if (!piglit_cl_set_kernel_arg(kernel, 0, sizeof(cl_mem), &out_buffer)) {
ret = PIGLIT_FAIL;
goto cleanup;
}
if (!piglit_cl_set_kernel_arg(kernel, 1, sizeof(cl_mem), &in_buffer)) {
ret = PIGLIT_FAIL;
goto cleanup;
}
printf("Running the kernel...\n");
if (!piglit_cl_enqueue_ND_range_kernel(context->command_queues[0],
kernel, 1, &global, &local)) {
ret = PIGLIT_FAIL;
goto cleanup;
}
clFlush(context->command_queues[0]);
printf("Retrieving results...\n");
if ((out_flags & CL_MEM_USE_HOST_PTR) ||
(out_flags & CL_MEM_ALLOC_HOST_PTR)) {
/* buffer uses host side memory, map it here,
* map is also a synchronization point */
result = clEnqueueMapBuffer(context->command_queues[0],
out_buffer, true, CL_MAP_READ, 0, sizeof(out_data), 0,
NULL, NULL, &errNo);
if (!piglit_cl_check_error(errNo, CL_SUCCESS)) {
fprintf(stderr,
"Could not map out buffer with flags %x: %s\n",
(unsigned)out_flags,
piglit_cl_get_error_name(errNo));
ret = PIGLIT_FAIL;
goto cleanup;
}
} else {
/* Copy back from device */
if (!piglit_cl_read_buffer(context->command_queues[0],
out_buffer, 0, sizeof(out_data),
out_data)) {
ret = PIGLIT_FAIL;
goto cleanup;
}
}
for (i = 0; i < BUFFER_SIZE; ++i) {
if (!piglit_cl_probe_floating(result[i], in_data[i], 0)) {
printf("Error at float[%u]\n", i);
ret = PIGLIT_FAIL;
goto cleanup;
}
}
/* cleanup */
cleanup:
clReleaseMemObject(in_buffer);
clReleaseMemObject(out_buffer);
clReleaseKernel(kernel);
piglit_report_subtest_result(ret, "in-0x%x-out-0x%x",
(unsigned)in_flags, (unsigned)out_flags);
return ret;
};
