Question

I am trying to call a device function from global function. This function is only declaring an array to be used by all threads. But my problem when I printed the array its elements are not in the same order as declared. Is it because of all threads are creating the array again ? I confused about threads. If it is , Can I learn which thread is run first in global function and can I only allow it to declare the array for the others. Thanks.
Here my function to create array :

__device__ float myArray[20][20];

__device__ void calculation(int no){
filterWidth = 3+(2*no);
filterHeight = 3+(2*no);
int arraySize = filterWidth;
int middle = (arraySize - 1) / 2;
int startIndex = middle;
int stopIndex = middle;

// at first , all values of array are 0
for(int i=0; i<arraySize; i++)
    for (int j = 0; j < arraySize; j++)
    {
        myArray[i][j] = 0;
    }

//  until middle line of the array, required indexes are 1
for (int i = 0; i < middle; i++)
{
    for (int j = startIndex; j <= stopIndex; j++)
    { myArray[i][j] = 1; sum+=1; }
    startIndex -= 1;
    stopIndex += 1;
}

// for middle line
for (int i = 0; i < arraySize; i++)
{myArray[middle][i] = 1; sum+=1;}

// after middle line of the array, required indexes are 1
startIndex += 1;
stopIndex -= 1;
for (int i = (middle + 1); i < arraySize; i++)
{
    for (int j = startIndex; j <= stopIndex; j++)
    { myArray[i][j] = 1; sum+=1; }
    startIndex +=1 ;
    stopIndex -= 1;
}


filterFactor = 1.0f / sum;
  } 

And global function :

__global__ void FilterKernel(Format24bppRgb* imageData)
  {
int tidX = threadIdx.x + blockIdx.x * blockDim.x;
int tidY = threadIdx.y + blockIdx.y * blockDim.y;

Colour Cpixel = Colour (imageData[tidX + tidY*imageWidth] );
float depthPixel =  Colour(depthData[tidX + tidY*imageWidth]).Red;
float absoluteDistanceFromFocus = fabs (depthPixel - focusDepth);


if(depthPixel == 0)
    return;

Colour Cresult = Cpixel;
for (int i=0;i<8;i++)
{
    calculation(i);
     ...
     ...
    }
 }

Answer 1

If you really want to select and force one thread to call the function and the rest to wait for it to do so, use __shared__ memory for the array created by the device function so that all threads in a block see the same one, and you can call it with:

for (int i=0;i<8;i++)
{
    if (threadIdx.x == 0 && threadIdx.y == 0)
        calculation(i);
    __syncthreads();
    ...
}

Of course, this won’t work between blocks – in a globally defined function, you have no control over the order in which blocks are computed.

Instead, if you can, you should do the initialization calculation (that only 1 thread needs to do) on the CPU and memcpy it to the GPU before launching your kernel. It looks like you’ll use 8x the memory for your myArray’s, but it’ll dramatically speed up your computation.