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