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) { cl_int errNo; cl_program program; /*** Normal usage ***/ program = piglit_cl_build_program_with_source(env->context, 1, &dummy_kernel, ""); /* Always returns CL_SUCCESS */ errNo = clUnloadCompiler(); if(!piglit_cl_check_error(errNo, CL_SUCCESS)) { fprintf(stderr, "Failed (error code: %s): Unload compiler.\n", piglit_cl_get_error_name(errNo)); return PIGLIT_FAIL; } /* Building again reloads compiler */ clReleaseProgram(program); program = piglit_cl_build_program_with_source(env->context, 1, &dummy_kernel, ""); clReleaseProgram(program); 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) { 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) { piglit_cl_context context = NULL; cl_program program = NULL; unsigned i, j; static const cl_mem_flags possibilities[] = { #ifdef CL_VERSION_1_2 0, #endif CL_MEM_USE_HOST_PTR, CL_MEM_COPY_HOST_PTR, CL_MEM_ALLOC_HOST_PTR, CL_MEM_COPY_HOST_PTR | CL_MEM_ALLOC_HOST_PTR, }; const size_t nump = ARRAY_SIZE(possibilities); enum piglit_result part_ret, ret = PIGLIT_PASS; float data = 10; context = piglit_cl_create_context(env->platform_id, &env->device_id, 1); program = piglit_cl_build_program_with_source(context, 1, &source, NULL); for (i = 0; i < nump; ++i) for (j = 0; j < nump; ++j) { part_ret = buffer_test(&context, &program, possibilities[i], possibilities[j], ++data); piglit_merge_result(&ret, part_ret); } clReleaseProgram(program); piglit_cl_release_context(context); return ret; }
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; }
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; }