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