Home/ Questions/Q 8109075
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-06-06T01:18:36+00:00

In my OpenCL program, I am going to end up with 60+ global memory

  • 0

In my OpenCL program, I am going to end up with 60+ global memory buffers that each kernel is going to need to be able to access. What’s the recommended way to for letting each kernel know the location of each of these buffers?

The buffers themselves are stable throughout the life of the application — that is, we will allocate the buffers at application start, call multiple kernels, then only deallocate the buffers at application end. Their contents, however, may change as the kernels read/write from them.

In CUDA, the way I did this was to create 60+ program scope global variables in my CUDA code. I would then, on the host, write the address of the device buffers I allocated into these global variables. Then kernels would simply use these global variables to find the buffer it needed to work with.

What would be the best way to do this in OpenCL? It seems that CL’s global variables are a bit different than CUDA’s, but I can’t find a clear answer on if my CUDA method will work, and if so, how to go about transferring the buffer pointers into global variables. If that wont work, what’s the best way otherwise?

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    60 global variables sure is a lot! Are you sure there isn’t a way to refactor your algorithm a bit to use smaller data chunks? Remember, each kernel should be a minimum work unit, not something colossal!

    However, there is one possible solution. Assuming your 60 arrays are of known size, you could store them all into one big buffer, and then use offsets to access various parts of that large array. Here’s a very simple example with three arrays:

    A is 100 elements
B is 200 elements
C is 100 elements

big_array = A[0:100] B[0:200] C[0:100]
offsets = [0, 100, 300]

    Then, you only need to pass big_array and offsets to your kernel, and you can access each array. For example:

    A[50] = big_array[offsets[0] + 50]
B[20] = big_array[offsets[1] + 20]
C[0] = big_array[offsets[2] + 0]

    I’m not sure how this would affect caching on your particular device, but my initial guess is “not well.” This kind of array access is a little nasty, as well. I’m not sure if it would be valid, but you could start each of your kernels with some code that extracts each offset and adds it to a copy of the original pointer.

    On the host side, in order to keep your arrays more accessible, you can use clCreateSubBuffer: http://www.khronos.org/registry/cl/sdk/1.2/docs/man/xhtml/clCreateSubBuffer.html which would also allow you to pass references to specific arrays without the offsets array.

    I don’t think this solution will be any better than passing the 60 kernel arguments, but depending on your OpenCL implementation’s clSetKernelArgs, it might be faster. It will certainly reduce the length of your argument list.

    • 0