int main(int argc, char** argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA); glutCreateWindow("GL interop"); glutIconifyWindow(); glutDisplayFunc(computeVBO); glutIdleFunc(computeVBO); initVBO(); CreateContext(); if(!context) { std::cerr << "Failed to create OpenCL context." << std::endl; return EXIT_FAILURE; } CreateCommandQueue(); if(!commandQueue) { Cleanup(); return EXIT_FAILURE; } CreateProgram(); if(!program) { Cleanup(); return EXIT_FAILURE; } kernel = clCreateKernel(program, "init_vbo_kernel", NULL); if(!kernel) { std::cerr << "Failed to create kernel" << std::endl; Cleanup(); return EXIT_FAILURE; } if (!CreateMemObjects()) { Cleanup(); return EXIT_FAILURE; } glutMainLoop(); std::cout << std::endl; std::cout << "Executed program succesfully." << std::endl; Cleanup(); }
/// // main() for HelloWorld example // int main(int argc, char** argv) { cl_context context = 0; cl_command_queue commandQueue = 0; cl_program program = 0; cl_device_id device = 0; cl_kernel kernels[2] = { 0, 0 }; cl_mem memObjects[3] = { 0, 0, 0 }; cl_int errNum; // Create an OpenCL context on first available platform context = CreateContext(); if (context == NULL) { std::cerr << "Failed to create OpenCL context." << std::endl; return 1; } // Create a command-queue on the first device available // on the created context commandQueue = CreateCommandQueue(context, &device); if (commandQueue == NULL) { Cleanup(context, commandQueue, program, kernels, memObjects); return 1; } // Create OpenCL program from HelloWorld.cl kernel source program = CreateProgram(context, device, "simple.cl"); if (program == NULL) { Cleanup(context, commandQueue, program, kernels, memObjects); return 1; } // Create OpenCL kernel //clCreateKernel(program, "hello_kernel", NULL); cl_uint numberOfKernels = 0; errNum = clCreateKernelsInProgram(program, 0, NULL, &numberOfKernels ); if (errNum != CL_SUCCESS) { std::cerr << "Failed to get number of kernels" << std::endl; Cleanup(context, commandQueue, program, kernels, memObjects); return 1; } else { std::cout << "numberOfKernels is:" << numberOfKernels << std::endl; } assert(numberOfKernels == 2 && "number of kernels was not as expected"); errNum = clCreateKernelsInProgram(program, 2, kernels, NULL ); if (errNum != CL_SUCCESS) { std::cerr << "Failed to retrieve kernels" << std::endl; Cleanup(context, commandQueue, program, kernels, memObjects); return 1; } // Create memory objects that will be used as arguments to // kernels. First create host memory arrays that will be // used to store the arguments to the kernel float result[ARRAY_SIZE]; float a[ARRAY_SIZE]; float b[ARRAY_SIZE]; for (int i = 0; i < ARRAY_SIZE; i++) { a[i] = (float)i; b[i] = (float)(i * 2); } if (!CreateMemObjects(context, memObjects, a, b)) { Cleanup(context, commandQueue, program, kernels, memObjects); return 1; } for (int i = 0; i < numberOfKernels; ++i) { // Set the kernel arguments (result, a, b) errNum = clSetKernelArg(kernels[i], 0, sizeof(cl_mem), &memObjects[0]); errNum |= clSetKernelArg(kernels[i], 1, sizeof(cl_mem), &memObjects[1]); errNum |= clSetKernelArg(kernels[i], 2, sizeof(cl_mem), &memObjects[2]); if (errNum != CL_SUCCESS) { std::cerr << "Error setting kernels[" << i << "] arguments." << std::endl; Cleanup(context, commandQueue, program, kernels, memObjects); return 1; } } size_t globalWorkSize[1] = { ARRAY_SIZE }; size_t localWorkSize[1] = { 1 }; cl_event waitFor = NULL; for (int i = 0; i < numberOfKernels; ++i) { cl_uint numToWaitFor = 0; cl_event waitList[1] = { 0 }; cl_event* waitListP = 0; if (waitFor != NULL) { numToWaitFor = 1; waitList[0] = waitFor; waitListP = waitList; } // Queue the kernel up for execution across the array errNum = clEnqueueNDRangeKernel(commandQueue, kernels[i], 1, NULL, globalWorkSize, localWorkSize, numToWaitFor, waitListP, &waitFor); if (errNum != CL_SUCCESS) { std::cerr << "Error queuing kernel for execution." << std::endl; Cleanup(context, commandQueue, program, kernels, memObjects); return 1; } } // Read the output buffer back to the Host errNum = clEnqueueReadBuffer(commandQueue, memObjects[2], CL_TRUE, 0, ARRAY_SIZE * sizeof(float), result, 0, NULL, NULL); if (errNum != CL_SUCCESS) { std::cerr << "Error reading result buffer." << std::endl; Cleanup(context, commandQueue, program, kernels, memObjects); return 1; } // Output the result buffer for (int i = 0; i < ARRAY_SIZE; i++) { std::cout << result[i] << " "; } std::cout << std::endl; std::cout << "Executed program succesfully." << std::endl; Cleanup(context, commandQueue, program, kernels, memObjects); return 0; }
/// // main() for GLinterop example // int main(int argc, char** argv) { cl_device_id device = 0; imWidth = 256; imHeight = 256; vbolen = imHeight; initGlut(argc, argv, imWidth, imHeight); vbo = initVBO(vbolen); initTexture(imWidth, imHeight); // Create an OpenCL context on first available platform context = CreateContext(); if (context == NULL) { std::cerr << "Failed to create OpenCL context." << std::endl; return 1; } // Create a command-queue on the first device available // on the created context commandQueue = CreateCommandQueue(context, &device); if (commandQueue == NULL) { Cleanup(); return 1; } // Create OpenCL program from GLinterop.cl kernel source program = CreateProgram(context, device, "kernel/GLinterop.cl"); if (program == NULL) { Cleanup(); return 1; } // Create OpenCL kernel kernel = clCreateKernel(program, "init_vbo_kernel", NULL); if (kernel == NULL) { std::cerr << "Failed to create kernel" << std::endl; Cleanup(); return 1; } tex_kernel = clCreateKernel(program, "init_texture_kernel", NULL); if (tex_kernel == NULL) { std::cerr << "Failed to create kernel" << std::endl; Cleanup(); return 1; } // Create memory objects that will be used as arguments to // kernel if (!CreateMemObjects(context, tex, vbo, &cl_vbo_mem, &cl_tex_mem)) { Cleanup(); return 1; } // Perform some queries to get information about the OpenGL objects performQueries(); glutMainLoop(); std::cout << std::endl; std::cout << "Executed program succesfully." << std::endl; Cleanup(); return 0; }
/// // main() for HelloWorld example // int main(int argc, char** argv) { cl_context context = 0; cl_command_queue commandQueue = 0; cl_program program = 0; cl_device_id device = 0; cl_kernel kernel = 0; cl_mem memObjects[2] = {0, 0}; cl_int errNum; assert( (ARRAY_SIZE & (ARRAY_SIZE -1)) == 0 && "Array size must be a power of 2"); int numberOfIterations = (int) ceil(log2(ARRAY_SIZE)); assert( (1 << numberOfIterations) == ARRAY_SIZE && "numberOfIterations calculation is incorrect"); // Create an OpenCL context on first available platform context = CreateContext(); if (context == NULL) { std::cerr << "Failed to create OpenCL context." << std::endl; return 1; } // Create a command-queue on the first device available // on the created context commandQueue = CreateCommandQueue(context, &device); if (commandQueue == NULL) { Cleanup(context, commandQueue, program, kernel, memObjects); return 1; } // Create OpenCL program from HelloWorld.cl kernel source program = CreateProgram(context, device, "SimplePrefixSum.cl"); if (program == NULL) { Cleanup(context, commandQueue, program, kernel, memObjects); return 1; } // Create OpenCL kernel kernel = clCreateKernel(program, "prefix_sum", NULL); if (kernel == NULL) { std::cerr << "Failed to create kernel" << std::endl; Cleanup(context, commandQueue, program, kernel, memObjects); return 1; } // Create memory objects that will be used as arguments to // kernel. First create host memory arrays that will be // used to store the arguments to the kernel cl_int a[ARRAY_SIZE]; cl_int b[ARRAY_SIZE]; for (int i = 0; i < ARRAY_SIZE; i++) { a[i] = i+1; b[i] = 0; } if (!CreateMemObjects(context, memObjects, a, b)) { Cleanup(context, commandQueue, program, kernel, memObjects); return 1; } // Set the kernel arguments (result, a, b) errNum = clSetKernelArg(kernel, 0, sizeof(cl_mem), &memObjects[0]); errNum |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &memObjects[1]); errNum |= clSetKernelArg(kernel, 2, sizeof(int), &numberOfIterations); if (errNum != CL_SUCCESS) { std::cerr << "Error setting kernel arguments." << std::endl; Cleanup(context, commandQueue, program, kernel, memObjects); return 1; } size_t globalWorkSize[1] = { ARRAY_SIZE }; size_t localWorkSize[1] = { ARRAY_SIZE }; // Queue the kernel up for execution across the array errNum = clEnqueueNDRangeKernel(commandQueue, kernel, 1, NULL, globalWorkSize, localWorkSize, 0, NULL, NULL); if (errNum != CL_SUCCESS) { std::cerr << "Error queuing kernel for execution." << std::endl; Cleanup(context, commandQueue, program, kernel, memObjects); return 1; } // The location of the result depends on how many loop iterations were executed. cl_mem returnObject = (numberOfIterations % 2 == 0)? memObjects[0] : memObjects[1]; // Read the output buffer back to the Host errNum = clEnqueueReadBuffer(commandQueue, returnObject, CL_TRUE, 0, ARRAY_SIZE * sizeof(cl_int), a, 0, NULL, NULL); if (errNum != CL_SUCCESS) { std::cerr << "Error reading result buffer." << std::endl; Cleanup(context, commandQueue, program, kernel, memObjects); return 1; } // Output the result buffer std::cout << "Result:" << std::endl; for (int i = 0; i < ARRAY_SIZE; i++) { std::cout << a[i] << " "; } std::cout << std::endl; std::cout << "Executed program succesfully." << std::endl; Cleanup(context, commandQueue, program, kernel, memObjects); return 0; }
void QHoneycombWidget::initializeGL() { cl_device_id device = 0; connect(context(), &QOpenGLContext::aboutToBeDestroyed, this, &QHoneycombWidget::cleanup); initializeOpenGLFunctions(); initTexture(); // Create an OpenCL context on first available platform clcontext = CreateContext(); if (clcontext == NULL) { std::cerr << "Failed to create OpenCL context." << std::endl; return ; } // Create a command-queue on the first device available // on the created context commandQueue = CreateCommandQueue(clcontext, &device); if (commandQueue == NULL) { cleanup(); return ; } // Create OpenCL program from GLinterop.cl kernel source program = CreateProgram(device, "Kelvin.cl"); if (program == NULL) { cleanup(); return; } // Create OpenCL kernel m_KernelCopyIntoTexture = clCreateKernel(program, "copy_texture_kernel", NULL); if (m_KernelCopyIntoTexture == NULL) { std::cerr << "Failed to create kernel" << std::endl; cleanup(); return; } m_KernelCopyIntoTextureBasic = clCreateKernel(program, "copy_texture_kernel_basic", NULL); if (m_KernelCopyIntoTextureBasic == NULL) { std::cerr << "Failed to create kernel" << std::endl; cleanup(); return; } m_KernelIteration = clCreateKernel(program, "KelvinIteration", NULL); if (m_KernelIteration == NULL) { std::cerr << "Failed to create kernel" << std::endl; cleanup(); return; } // Create memory objects that will be used as arguments to // kernel if (!CreateMemObjects()) { cleanup(); return ; } }
int main(int argc, char** argv) { cl_context context = 0; cl_command_queue commandQueue = 0; cl_program program = 0; cl_device_id device = 0; cl_kernel kernel = 0; cl_mem memObjects[3] = { 0, 0, 0 }; cl_int errNum; context = CreateContext(); if (context == NULL) { std::cerr << "Failed to create OpenCL context." << std::endl; return 1; } commandQueue = CreateCommandQueue(context, &device); if (commandQueue == NULL) { Cleanup(context, commandQueue, program, kernel, memObjects); return 1; } program = CreateProgram(context, device, "sun.cl"); if (program == NULL) { Cleanup(context, commandQueue, program, kernel, memObjects); return 1; } kernel = clCreateKernel(program, "hello_kernel", NULL); if (kernel == NULL) { std::cerr << "Failed to create kernel" << std::endl; Cleanup(context, commandQueue, program, kernel, memObjects); return 1; } // Create memory objects that will be used as arguments to // kernel. First create host memory arrays that will be // used to store the arguments to the kernel float result[ARRAY_SIZE]; float a[ARRAY_SIZE]; float b[ARRAY_SIZE]; for (int i = 0; i < ARRAY_SIZE; i++) { a[i] = (float)i; b[i] = (float)(i * 2); } //在设备上创建buffer对象 if (!CreateMemObjects(context, memObjects, a, b)) { Cleanup(context, commandQueue, program, kernel, memObjects); return 1; } // Set the kernel arguments (result, a, b) errNum = clSetKernelArg(kernel, 0, sizeof(cl_mem), &memObjects[0]); errNum |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &memObjects[1]); errNum |= clSetKernelArg(kernel, 2, sizeof(cl_mem), &memObjects[2]); if (errNum != CL_SUCCESS) { std::cerr << "Error setting kernel arguments." << std::endl; Cleanup(context, commandQueue, program, kernel, memObjects); return 1; } size_t globalWorkSize[1] = { ARRAY_SIZE }; size_t localWorkSize[1] = { 1 }; // Queue the kernel up for execution -----opencl runtime errNum = clEnqueueNDRangeKernel(commandQueue, kernel, 1, NULL, globalWorkSize, localWorkSize, 0, NULL, NULL); if (errNum != CL_SUCCESS) { std::cerr << "Error queuing kernel for execution." << std::endl; Cleanup(context, commandQueue, program, kernel, memObjects); return 1; } // Read the output buffer back to the Host errNum = clEnqueueReadBuffer(commandQueue, memObjects[2], CL_TRUE, 0, ARRAY_SIZE * sizeof(float), result, 0, NULL, NULL); if (errNum != CL_SUCCESS) { std::cerr << "Error reading result buffer." << std::endl; Cleanup(context, commandQueue, program, kernel, memObjects); return 1; } // Output the result buffer for (int i = 0; i < ARRAY_SIZE; i++) { std::cout << result[i] << " "; } std::cout << std::endl; std::cout << "Executed program succesfully." << std::endl; Cleanup(context, commandQueue, program, kernel, memObjects); return 0; }