OpenCL Heterogeneous Parallel Computing
Download as PPTX, PDF2 likes663 views
The document details the open standard for heterogeneous parallel programming supported by the Khronos Group, emphasizing the use of OpenCL across multiple programming languages and platforms, including GPUs from various manufacturers. It explains how OpenCL facilitates parallel computing through kernels that perform tasks on devices like GPUs while also considering factors such as memory models and potential limitations in performance. Examples, such as matrix multiplication, illustrate how to implement OpenCL codes in a computational context.
![Matrix Multiplication
• Matrix A[4,2]
• Matrix B[2,3]
• Matrix C[4,3] = A * B](https://image.slidesharecdn.com/opencl-150904195240-lva1-app6891/85/OpenCL-Heterogeneous-Parallel-Computing-15-320.jpg)
![Matrix Multiplication
• For matrices A[128,128] and B[128,128]
• Matrix C will have 16384 elements
• We can launch 16384 work-items (threads)
• The work-group size can be set to [16,16]
• So we end up with 64 groups of 256 elements each](https://image.slidesharecdn.com/opencl-150904195240-lva1-app6891/85/OpenCL-Heterogeneous-Parallel-Computing-16-320.jpg)
![Kernel Code
__kernel
void matrixMultiplication(__global float* A, __global float* B, __global float* C, int
widthA, int widthB )
{
//will range from 0 to 127
int i = get_global_id(0);
//will range from 0 to 127
int j = get_global_id(1);
float value=0;
for ( int k = 0; k < widthA; k++)
{
value = value + A[k + j * widthA] * B[k*widthB + i];
}
C[i + widthA * j] = value;
}](https://image.slidesharecdn.com/opencl-150904195240-lva1-app6891/85/OpenCL-Heterogeneous-Parallel-Computing-17-320.jpg)
![Host Code
/* Create Kernel Program from the source */
program = clCreateProgramWithSource(context, 1, (const char **)&source_str, (const size_t
*)&source_size, &ret);
/* Build Kernel Program */
ret = clBuildProgram(program, 1, &device_id, NULL, NULL, NULL);
/* Create OpenCL Kernel */
kernel = clCreateKernel(program, "matrixMultiplication", &ret);
/* Set OpenCL Kernel Arguments */
ret = clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&memobjA);
ret = clSetKernelArg(kernel, 1, sizeof(cl_mem), (void *)&memobjB);
ret = clSetKernelArg(kernel, 2, sizeof(cl_mem), (void *)&memobjC);
ret = clSetKernelArg(kernel, 3, sizeof(int), (void *)&row);
ret = clSetKernelArg(kernel, 4, sizeof(int), (void *)&col);
/* Execute OpenCL Kernel */
size_t globalThreads[2] = {widthA, heightB};
size_t localThreads[2] = {16,16};
clEnqueueNDRangeKernel(command_queue, kernel, 2, 0, globalThreads, localThreads, 0, 0, 0);
/* Copy results from the memory buffer */
ret = clEnqueueReadBuffer(command_queue, memobjC, CL_TRUE, 0, widthA * heightC *
sizeof(float),Res, 0, NULL, NULL);](https://image.slidesharecdn.com/opencl-150904195240-lva1-app6891/85/OpenCL-Heterogeneous-Parallel-Computing-18-320.jpg)
OpenCL Heterogeneous Parallel Computing
- 1. The Open Standard for Heterogeneous Parallel Programming
- 3. Open means…
- 4. Many languages… • C/C++ - https://www.khronos.org/opencl/ • .NET - http://openclnet.codeplex.com/ • Python - http://mathema.tician.de/software/pyopencl/ • Java - http://www.jocl.org/ • Julia - https://github.com/JuliaGPU/OpenCL.jl
- 5. Many platforms… • AMD - CPUs, APUs, GPUs • NVIDIA - GPUs • INTEL - CPUs, GPUs • APPLE - CPUs • SAMSUMG - ARM processors • OTHERS - https://www.khronos.org/conformance/adopters/conforman t-products#opencl
- 6. Why GPUs? • Designed for Parallelism - Supports thousands of threads with no thread management cost • High Speed • Low Cost • Availability
- 7. How does it work? • Host code - Runs on CPU • Serial code (data pre-processing, sequential algorithms) • Reads data from input (files, databases, streams) • Transfers data from host to device (gpu) • Calls device code (kernels) • Copies data back from device to host • Device code - Runs on GPU • Independent parallel tasks called kernels • Same task acts on different pieces of data - SIMD - Data Parallelism • Different tasks act on different pieces of data - MIMD - Task Parallelism
- 8. Speed up - Amdahl’s Law
- 10. Computing Model • Compute Device = GPU • Compute Unit = Processor • Compute/Processing Element = Processor Core • A GPU can contain from hundreds up to thousands cores
- 11. Memory Model
- 12. Work-items/Work-groups • Work-item = Thread • Work-items are grouped into Work-groups • Work-items in the same Work-group can: • Share Data • Synchronize • Map work-items to better match the data structure
- 15. Matrix Multiplication • Matrix A[4,2] • Matrix B[2,3] • Matrix C[4,3] = A * B
- 16. Matrix Multiplication • For matrices A[128,128] and B[128,128] • Matrix C will have 16384 elements • We can launch 16384 work-items (threads) • The work-group size can be set to [16,16] • So we end up with 64 groups of 256 elements each
- 17. Kernel Code __kernel void matrixMultiplication(__global float* A, __global float* B, __global float* C, int widthA, int widthB ) { //will range from 0 to 127 int i = get_global_id(0); //will range from 0 to 127 int j = get_global_id(1); float value=0; for ( int k = 0; k < widthA; k++) { value = value + A[k + j * widthA] * B[k*widthB + i]; } C[i + widthA * j] = value; }
- 18. Host Code /* Create Kernel Program from the source */ program = clCreateProgramWithSource(context, 1, (const char **)&source_str, (const size_t *)&source_size, &ret); /* Build Kernel Program */ ret = clBuildProgram(program, 1, &device_id, NULL, NULL, NULL); /* Create OpenCL Kernel */ kernel = clCreateKernel(program, "matrixMultiplication", &ret); /* Set OpenCL Kernel Arguments */ ret = clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&memobjA); ret = clSetKernelArg(kernel, 1, sizeof(cl_mem), (void *)&memobjB); ret = clSetKernelArg(kernel, 2, sizeof(cl_mem), (void *)&memobjC); ret = clSetKernelArg(kernel, 3, sizeof(int), (void *)&row); ret = clSetKernelArg(kernel, 4, sizeof(int), (void *)&col); /* Execute OpenCL Kernel */ size_t globalThreads[2] = {widthA, heightB}; size_t localThreads[2] = {16,16}; clEnqueueNDRangeKernel(command_queue, kernel, 2, 0, globalThreads, localThreads, 0, 0, 0); /* Copy results from the memory buffer */ ret = clEnqueueReadBuffer(command_queue, memobjC, CL_TRUE, 0, widthA * heightC * sizeof(float),Res, 0, NULL, NULL);
- 19. Limitations • Number of work-items (threads) • Group size (# of work-items, memory size) • Data transfer bandwidth • Device memory size
- 20. Be careful with… • Uncoalesced memory access • Branch divergence • Access to global memory • Data transfer between host and device
- 21. Demo
- 22. Thanks!