OpenCL C ++-线程64之后数组的内存管理错误

Question

I have run into this very weird problem while working with openCL C++. The problem is that I have 100 threads that are accessing one element each of a 100 size array. From 0 to 63, there is no problem and each thread is computing and updating value of the array's element properly. But when it gets to thread 64, it messes up and updates the values with some other values...

Here is how I call the kernel:

kernelGA(cl::EnqueueArgs(queue[iter],
                        cl::NDRange(200 / numberOfDevices)),
                        d_value,
                        d_doubleParameters,
                        buf_half_population, and so on...)

At the kernel side, I am accessing each thread using:

__kernel void kernelGA (__global double * value,
                        __global double * doubleParameters,
                        __global double * population,
                        __global double * scores, and so on...)

int idx = get_global_id(0); // This gives me 100 threads for each device. (I have two devices)
int size_a = 50;
double tempValue[size_a];

// Copying the global "value" into local array so each thread has its own copy.
for (int i = 0; i < size_a; i++) {
    tempValue[i] = value[i];
}

At this point, each thread now has its own tempValue[] array with the same values. Then I apply some computations and formulas on the values of tempValue[] array for each thread...

// Applying some computations on tempValue and changing the values for each  copy of tempValue for each thread.
tempValue[i] = some calculations for each thread...

After this, I access each element of the tempValue[] array for each thread and put them back continuously in a bigger array of size (number of threads * size_a). Keeping in mind that the indexing for an array goes like: 0,1, 2, 3,... and so on...

for (int i = 0; i < size_a; i++) {
    totalArray[(idx * size_a) + i] = tempvalue[i];
} 

So when I get the answers of totalArray outside the kernel and print them, the first 64 (from 0-63) threads have properly put their values in the totalArray[]. But 64 onwards, the indexing is messed up. I mean not exactly the indexing, because I printed out only the indexes, and the indexes are properly accesses for all threads. But the values seem to be messed up...

For example: the value of the 3rd, 4th, 5th and 6th elements of thread 0-63 is 50, 60, 70 and 80 respectively. But for thread 64 onwards, the values of the the 3rd, 4th, 5th and 6th elements are 80, 90, 100, 110. As if the values have been shifted a few elements in the backward direction. Why? What is going on here?

Answer 1

There is a problem if multiple devices working on same array,

You put

cl::NDRange(200 / numberOfDevices)

as range

but you are not putting

cl::NDRange((200 / numberOfDevices)*deviceIndex)

as offset for each device.

All devices trying to write to same position instead of neighbouring groups.

Also you are not checking if total threads number less than array length in kernel so some threads may try write out of bounds.

Answer 2

So I found the solution for my problem:

The problem was that even though each thread had its own copy of the value[] array stored in tempValue[] array:

// Copying the global "value" into local array so each thread has its own copy.
for (int i = 0; i < size_a; i++) {
    tempValue[i] = value[i];
}

The values in the array were being messed up after thread 64. So what I did was I created a larger array of the values outside in the host code ( sizeOf(value) * 100 ) and then copied the first part of the array to the rest 99 parts and I sent it to the device . And then I made each thread access its own part of the value[] array using indexing.

It solved the problem!