/// Links the programs in \p programs with \p options in \p context. /// /// \opencl_version_warning{1,2} /// /// \see_opencl_ref{clLinkProgram} static program link(const std::vector<program> &programs, const context &context, const std::string &options = std::string()) { const char *options_string = 0; if(!options.empty()){ options_string = options.c_str(); } cl_int ret; cl_program program_ = clLinkProgram( context.get(), 0, 0, options_string, static_cast<uint_>(programs.size()), reinterpret_cast<const cl_program*>(&programs[0]), 0, 0, &ret ); if(!program_){ BOOST_THROW_EXCEPTION(opencl_error(ret)); } return program(program_, false); }
JNIEXPORT jlong JNICALL Java_org_lwjgl_opencl_CL12_nclLinkProgram(JNIEnv *env, jclass clazz, jlong context, jint num_devices, jlong device_list, jlong options, jint num_input_programs, jlong input_programs, jlong pfn_notify, jlong user_data, jlong errcode_ret, jlong function_pointer) { const cl_device_id *device_list_address = (const cl_device_id *)(intptr_t)device_list; const cl_char *options_address = (const cl_char *)(intptr_t)options; const cl_program *input_programs_address = (const cl_program *)(intptr_t)input_programs; cl_int *errcode_ret_address = (cl_int *)(intptr_t)errcode_ret; clLinkProgramPROC clLinkProgram = (clLinkProgramPROC)((intptr_t)function_pointer); cl_program __result = clLinkProgram((cl_context)(intptr_t)context, num_devices, device_list_address, options_address, num_input_programs, input_programs_address, (cl_program_callback)(intptr_t)pfn_notify, (void *)(intptr_t)user_data, errcode_ret_address); return (intptr_t)__result; }
static bool test(cl_context context, cl_uint num_devices, const cl_device_id *device_list, const char *options, cl_uint num_input_programs, const cl_program *input_programs, void (CL_CALLBACK *pfn_notify)(cl_program program, void *user_data), void *user_data, cl_program *ret_program, cl_int expected_error, enum piglit_result* result, const char* test_str) { cl_program program; cl_int errNo; program = clLinkProgram(context, num_devices, device_list, options, num_input_programs, input_programs, pfn_notify, user_data, &errNo); if (ret_program) { *ret_program = program; } else { if (program) clReleaseProgram(program); } if(!piglit_cl_check_error(errNo, expected_error)) { fprintf(stderr, "Failed (error code: %s): %s.\n", piglit_cl_get_error_name(errNo), test_str); piglit_merge_result(result, PIGLIT_FAIL); return false; } return true; }
void run_vec_fma(size_t num_elems, size_t buf_size, cl_int* data) { cl_int err; // Query platforms and devices cl_platform_id platform; err = clGetPlatformIDs(1, &platform, NULL); cl_device_id device; err = clGetDeviceIDs(platform, CL_DEVICE_TYPE_ALL, 1, &device, NULL); const cl_context_properties prop[] = { CL_CONTEXT_PLATFORM, (cl_context_properties)platform, 0 }; // Create context cl_context ctx = clCreateContext(prop, 1, &device, NULL, NULL, &err); // Create program unsigned char* program_file = NULL; size_t program_size = 0; cl_program prog[2]; // Comple source - elem.cl read_file(&program_file, &program_size, "elem.cl"); prog[0] = clCreateProgramWithSource(ctx, 1, (const char **)&program_file, &program_size, &err); err = clCompileProgram(prog[0], 1, &device, NULL, 0, NULL, NULL, NULL, NULL); free(program_file); // Compile source - fma.cl read_file(&program_file, &program_size, "fma.cl"); prog[1] = clCreateProgramWithSource(ctx, 1, (const char **)&program_file, &program_size, &err); err = clCompileProgram(prog[1], 1, &device, NULL, 0, NULL, NULL, NULL, NULL); free(program_file); // Link programs cl_program program = clLinkProgram(ctx, 1, &device, NULL, 2, prog, NULL, NULL, &err); // Allocate memory buffers (on the device) cl_mem a = clCreateBuffer(ctx, CL_MEM_READ_ONLY, buf_size, NULL, &err); cl_mem b = clCreateBuffer(ctx, CL_MEM_READ_ONLY, buf_size, NULL, &err); cl_mem c = clCreateBuffer(ctx, CL_MEM_READ_ONLY, buf_size, NULL, &err); cl_mem d = clCreateBuffer(ctx, CL_MEM_WRITE_ONLY, buf_size, NULL, &err); // Create command queue cl_command_queue queue = clCreateCommandQueue(ctx, device, 0, NULL); // Enqueue the write buffer commands cl_event wb_events[2]; err = clEnqueueWriteBuffer(queue, a, CL_FALSE, 0, buf_size, data, 0, NULL, &wb_events[0]); err = clEnqueueWriteBuffer(queue, b, CL_FALSE, 0, buf_size, data, 0, NULL, &wb_events[1]); err = clEnqueueWriteBuffer(queue, c, CL_FALSE, 0, buf_size, data, 0, NULL, &wb_events[1]); // Enqueue the kernel execution command cl_kernel kernel = clCreateKernel(program, "vec_fma", &err); err = clSetKernelArg(kernel, 0, sizeof(cl_mem), &d); err = clSetKernelArg(kernel, 1, sizeof(cl_mem), &a); err = clSetKernelArg(kernel, 2, sizeof(cl_mem), &b); err = clSetKernelArg(kernel, 3, sizeof(cl_mem), &c); const size_t global_offset = 0; cl_event kernel_event; err = clEnqueueNDRangeKernel(queue, kernel, 1, &global_offset, &num_elems, NULL, 2, wb_events, &kernel_event); // Enqueue the read buffer command err = clEnqueueReadBuffer(queue, d, CL_TRUE, 0, buf_size, data, 1, &kernel_event, NULL); // Wait until every commands are finished err = clFinish(queue); // Release the resources clReleaseMemObject(a); clReleaseMemObject(b); clReleaseMemObject(c); clReleaseMemObject(d); clReleaseKernel(kernel); clReleaseProgram(program); clReleaseCommandQueue(queue); clReleaseContext(ctx); clReleaseDevice(device); }