OpenCL out of bounds errors - opencl

Question

This kernel works fine:
__kernel void test(__global float* a_Direction, __global float* a_Output, const unsigned int a_Count)
{
int index = get_global_id(0);
if (index < a_Count)
{
a_Output[index * 3 + 0] = a_Direction[index * 3 + 0] * 0.5f + 0.5f;
a_Output[index * 3 + 1] = a_Direction[index * 3 + 1] * 0.5f + 0.5f;
a_Output[index * 3 + 2] = a_Direction[index * 3 + 2] * 0.5f + 0.5f;
}
}
This kernel produces out of bounds errors:
__kernel void test(__global float3* a_Direction, __global float3* a_Output, const unsigned int a_Count)
{
int index = get_global_id(0);
if (index < a_Count)
{
a_Output[index].x = a_Direction[index].x * 0.5f + 0.5f;
a_Output[index].y = a_Direction[index].y * 0.5f + 0.5f;
a_Output[index].z = a_Direction[index].z * 0.5f + 0.5f;
}
}
To me it seems like they should both do the exact same thing.
But for some reason only one of the two works.
Am I missing something obvious?
The exact error is: "CL_OUT_OF_RESOURCES error executing CL_COMMAND_READ_BUFFER on GeForce GTX580M (Device 0).

Answer 1

#arsenm in his/her answer as well as #Darkzeros gave the proper explanation but I feel like it is interesting to develop a bit. The problem is that in the second kernel these is a "hidden" alignment that happens. As the standard states in the section 6.1.5.:
For 3-component vector data types, the size of the data type is 4 *
sizeof(component). This means that a 3-component vector data type will
be aligned to a 4 * sizeof(component) boundary.
Let's illustrate that with an example:
assuming that a_Direction is made of 9 floats and that you use 3 threads/workitems to process these elements. In the first kernel these is no problem: the thread 0 will handle the elements with the indexes 0, 1, 2, the thread 1 the elements 3, 4, 5 and finally, the thread 2 the elements 6, 7, 8: everything is fine.
However for the second kernel, assuming the data structure you use stays the same from the host side point of view (i.e. an array going from 0 to 8), the thread 0 will handle the elements 0, 1, 2 (and will also access the element 4 because the float3 type vector will behave like a float4 type vector without doing anything with it).The second thread i.e. the thread 1 won't access the elements 3, 4, 5 but the elements 4, 5, 6 (and 7 without doing anything with it).
Therefore, and this is where the problem arise, the thread 2 will try to access the elements 8, 9, 10 (and 11), hence out of bounds access.
To summary, a vector of 3 elements behaves like a vector of 4 elements.
Now, if you want to use vectors without changing your data structure in the host side, you can use the vload3 and vstore3 functions as described in the section 3.12.7. of the standard. Like that:
vstore3(vload3(index, a_Direction) * 0.5f + 0.5f, index, a_Output));
BTW, you don't have to bother with statements like (assuming a proper alignment):
a_Output[index].x = a_Direction[index].x * 0.5f + 0.5f;
a_Output[index].y = a_Direction[index].y * 0.5f + 0.5f;
a_Output[index].z = a_Direction[index].z * 0.5f + 0.5f;
This statement is enough (no need to write a line for every elements):
a_Output[index] = a_Direction[index] * 0.5f + 0.5f;

Answer 2

The problem you're probably having is you've allocated a buffer that is n * 3 * sizeof(float) for your float3s, but the size and alignment of float3 is 16, and not 12.