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;
}
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)
{
size_t global_size = 1, local_size = 1;
piglit_cl_context context = NULL;
cl_command_queue queue = NULL;
cl_mem buffer0 = NULL, buffer1 = NULL, buffer2 = NULL, buffer3 = NULL;
cl_program program = NULL;
cl_kernel kernel = NULL;
int data[BUFFER_SIZE / sizeof(int)];
unsigned i;
context = piglit_cl_create_context(env->platform_id, &env->device_id, 1);
queue = context->command_queues[0];
buffer0 = piglit_cl_create_buffer(context, CL_MEM_WRITE_ONLY, BUFFER_SIZE);
buffer1 = piglit_cl_create_buffer(context, CL_MEM_WRITE_ONLY, BUFFER_SIZE);
program = piglit_cl_build_program_with_source(context, 1, &source, "");
kernel = piglit_cl_create_kernel(program, "test");
/* Use the first buffer */
if (!piglit_cl_set_kernel_arg(kernel, 0, sizeof(cl_mem), &buffer0)) {
return PIGLIT_FAIL;
}
if (!piglit_cl_enqueue_ND_range_kernel(queue, kernel, 1, &global_size,
&local_size)) {
return PIGLIT_FAIL;
}
/* Use the second buffer */
if (!piglit_cl_set_kernel_arg(kernel, 0, sizeof(cl_mem), &buffer1)) {
return PIGLIT_FAIL;
}
if (!piglit_cl_enqueue_ND_range_kernel(queue, kernel, 1, &global_size,
&local_size)) {
return PIGLIT_FAIL;
}
/* Delete the first buffer */
clReleaseMemObject(buffer0);
/* Create and use the third buffer */
buffer2 = piglit_cl_create_buffer(context, CL_MEM_WRITE_ONLY, BUFFER_SIZE);
if (!piglit_cl_set_kernel_arg(kernel, 0, sizeof(cl_mem), &buffer2)) {
return PIGLIT_FAIL;
}
if (!piglit_cl_enqueue_ND_range_kernel(queue, kernel, 1, &global_size,
&local_size)) {
return PIGLIT_FAIL;
}
/* Create the fourth buffer. */
buffer3 = piglit_cl_create_buffer(context, CL_MEM_WRITE_ONLY, BUFFER_SIZE);
/* At this point, the bug in r600g will cause buffer3 and buffer1 to
* have the same offset, so if we write to buffer3, then the data
* will appear in buffer1.
*/
/* Clear both buffers */
memset(data, 0, sizeof(data));
piglit_cl_write_whole_buffer(queue, buffer1, data);
piglit_cl_write_whole_buffer(queue, buffer3, data);
/* Write data to buffer1 */
memset(data, 0xff, sizeof(data));
piglit_cl_write_whole_buffer(queue, buffer3, data);
/* Check that the data wasn't also written to buffer1 */
memset(data, 0, sizeof(data));
if (!piglit_cl_read_whole_buffer(queue, buffer1, data)) {
return PIGLIT_FAIL;
}
for (i = 0; i < BUFFER_SIZE / sizeof(int); i++) {
if (data[i]) {
fprintf(stderr, "Error at data[%u]\n", i);
return PIGLIT_FAIL;
}
}
return PIGLIT_PASS;
}
PIGLIT_CL_API_TEST_CONFIG_END
enum piglit_result
piglit_cl_test(const int argc,
const char **argv,
const struct piglit_cl_api_test_config* config,
const struct piglit_cl_api_test_env* env)
{
int host_src_buffer[4] = {1, 2, 3, 4};
int host_dst_buffer[4] = {0, 0, 0, 0};
cl_mem device_src_buffer, device_dst_buffer;
cl_command_queue queue = env->context->command_queues[0];
cl_int err;
cl_int *mapped_buffer;
int i;
device_src_buffer = piglit_cl_create_buffer(
env->context, CL_MEM_READ_WRITE, sizeof(host_src_buffer));
device_dst_buffer = piglit_cl_create_buffer(
env->context, CL_MEM_READ_WRITE, sizeof(host_dst_buffer));
//Map source buffer
mapped_buffer = clEnqueueMapBuffer(queue, device_src_buffer, CL_TRUE,
CL_MAP_WRITE, 0, sizeof(host_src_buffer), 0, NULL, NULL, &err);
if (!piglit_cl_check_error(err, CL_SUCCESS)) {
return PIGLIT_FAIL;
}
//memcpy to it
memcpy(mapped_buffer, host_src_buffer, sizeof(host_src_buffer));
//Unmap source buffer
err = clEnqueueUnmapMemObject(queue, device_src_buffer, mapped_buffer,
0, NULL, NULL);
if (!piglit_cl_check_error(err, CL_SUCCESS)) {
return PIGLIT_FAIL;
}
//enqueueCopyBuffer from device src to device dst
err = clEnqueueCopyBuffer(queue, device_src_buffer, device_dst_buffer,
0, 0, sizeof(host_src_buffer), 0, NULL, NULL);
if (!piglit_cl_check_error(err, CL_SUCCESS)) {
return PIGLIT_FAIL;
}
//Map dest buffer
mapped_buffer = clEnqueueMapBuffer(queue, device_dst_buffer, CL_TRUE,
CL_MAP_READ, 0, sizeof(host_src_buffer), 0, NULL, NULL, &err);
if (!piglit_cl_check_error(err, CL_SUCCESS)) {
return PIGLIT_FAIL;
}
//Memcpy back
memcpy(host_dst_buffer, mapped_buffer, sizeof(host_dst_buffer));
//Unmap
err = clEnqueueUnmapMemObject(queue, device_dst_buffer, mapped_buffer,
0, NULL, NULL);
if (!piglit_cl_check_error(err, CL_SUCCESS)) {
return PIGLIT_FAIL;
}
//Do comparison of host src/dest
for (i = 0; i < sizeof(host_src_buffer) / sizeof(host_src_buffer[0]);
i++) {
if (!piglit_cl_probe_integer(host_dst_buffer[i],
host_src_buffer[i], 0)) {
fprintf(stderr, "Error at %d\n", i);
return PIGLIT_FAIL;
}
}
err = clReleaseMemObject(device_src_buffer);
if (!piglit_cl_check_error(err, CL_SUCCESS)) {
return PIGLIT_FAIL;
}
err = clReleaseMemObject(device_dst_buffer);
if (!piglit_cl_check_error(err, CL_SUCCESS)) {
return PIGLIT_FAIL;
}
return PIGLIT_PASS;
}
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)
{
piglit_cl_context piglit_cl_context = NULL;
cl_command_queue queue = NULL;
cl_mem buffer = NULL, sub_buffer = NULL;
cl_program program = NULL;
cl_kernel kernel = NULL;
unsigned i;
size_t global_size = 1, local_size = 1;
cl_buffer_region region = {PAD_SIZE, SUB_BUFFER_SIZE };
cl_int err;
char *sub_data = malloc(BUFFER_SIZE);
char *padding = malloc(PAD_SIZE);
char data_byte = (char)DATA_BYTE;
char pad_byte = 0xcd;
char *out_data = malloc(BUFFER_SIZE);
assert(SUB_BUFFER_SIZE % 4 == 0);
memset(sub_data, data_byte, SUB_BUFFER_SIZE);
memset(padding, pad_byte, PAD_SIZE);
piglit_cl_context = piglit_cl_create_context(env->platform_id,
&env->device_id, 1);
queue = piglit_cl_context->command_queues[0];
buffer = piglit_cl_create_buffer(piglit_cl_context, CL_MEM_READ_WRITE,
BUFFER_SIZE);
sub_buffer = clCreateSubBuffer(buffer, CL_MEM_READ_WRITE,
CL_BUFFER_CREATE_TYPE_REGION,
®ion, &err);
if (err != CL_SUCCESS) {
fprintf(stderr, "clCreateSubBuffer() failed.");
return PIGLIT_FAIL;
}
clEnqueueWriteBuffer(queue, buffer, CL_FALSE, 0, PAD_SIZE, padding,
0, NULL, NULL);
clEnqueueWriteBuffer(queue, buffer, CL_FALSE, BUFFER_SIZE - PAD_SIZE,
PAD_SIZE, padding, 0, NULL, NULL);
clFinish(queue);
program = piglit_cl_build_program_with_source(piglit_cl_context, 1,
&source, "");
kernel = piglit_cl_create_kernel(program, "test");
if (!piglit_cl_set_kernel_arg(kernel, 0, sizeof(cl_mem), &sub_buffer)) {
return PIGLIT_FAIL;
}
if (!piglit_cl_enqueue_ND_range_kernel(queue, kernel, 1, &global_size,
&local_size)) {
return PIGLIT_FAIL;
}
clFinish(queue);
clEnqueueReadBuffer(queue, buffer, CL_TRUE, 0, BUFFER_SIZE, out_data,
0, NULL, NULL);
for (i = 0; i < PAD_SIZE; i++) {
if (!piglit_cl_probe_integer(out_data[i], pad_byte, 0)) {
fprintf(stderr, "Failed at offset %u\n", i);
return PIGLIT_FAIL;
}
}
for (i = BUFFER_SIZE - PAD_SIZE; i < BUFFER_SIZE; i++) {
if (!piglit_cl_probe_integer(out_data[i], pad_byte, 0)) {
fprintf(stderr, "Failed at offset %u\n", i);
return PIGLIT_FAIL;
}
}
for (i = PAD_SIZE; i < BUFFER_SIZE - PAD_SIZE; i++) {
if (!piglit_cl_probe_integer(out_data[i], data_byte, 0)) {
fprintf(stderr, "Failed at offset %u\n", i);
return PIGLIT_FAIL;
}
}
return PIGLIT_PASS;
}
