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