Question

I am trying to write a mutex for OpenCL. The idea is for every single individual work item to be able to proceed atomically. Currently, I believe the problem may be that thread warps are unable to proceed when one thread in a warp gets the lock.

My current simple kernel below, for summing numbers. “numbers” is an array of floats as input. “sum” is a one element array for the result, and “semaphore” is a one element array for holding the semaphore. I based it heavily off the example here.

void acquire(__global int* semaphore) {
    int occupied;
    do {
        occupied = atom_xchg(semaphore, 1);
    } while (occupied>0);
}
void release(__global int* semaphore) {
    atom_xchg(semaphore, 0); //the previous value, which is returned, is ignored
}
__kernel void test_kernel(__global float* numbers, __global float* sum, __global int* semaphore) {
    int i = get_global_id(0);
    acquire(semaphore);
    *sum += numbers[i];
    release(semaphore);
}

I am calling the kernel effectively like:

int numof_dimensions = 1;
size_t offset_global[1] = {0};
size_t size_global[1] = {4000}; //the length of the numbers array
size_t* size_local = NULL;
clEnqueueNDRangeKernel(command_queue, kernel, numof_dimensions,offset_global,size_global,size_local, 0,NULL, NULL);

As above, when running, the graphics card hangs, and the driver restarts itself. How can I fix it so that it doesn’t?

Answer 1

The answer to this might seem obvious in retrospect, but it’s not unless you thought of it.

Basically, the GPU’s prediction of the ideal local group size (size of a thread warp) is greater than 1, and so thread warps lock up. To fix it, you just need to specify it to be 1 (i.e. “size_t size_local[1] = {1};”). Doing this produces a correct result.