How add element (cv::Point) into shared array - CUDA - c

Question

I'm new in Cuda technology. I need help a CUDA find in binary (monochromatic) image only pixels, that have value white (255). Pixels are then required to sort the output array. My solution is based on critical section. However, it gives incorrect results.
//----- call kernel: -----
{
const dim3 block(16,16);
const dim3 grid(divUp(_binImg.cols, block.x), divUp(_binImg.rows, block.y));
// others allocations, declarations ...
cudaCalcWhitePixels<<<grid, block>>>(_binImg, _index, _pointsX, _pointsY);
}
__device__ int lock = 0;
__global__ void cudaCalcWhitePixels(cv::gpu::PtrStepSzb _binImg, int *_index, int *_pointsX, int *_pointsY)
{
extern int lock;
const int x = blockIdx.x * blockDim.x + threadIdx.x;
const int y = blockIdx.y * blockDim.y + threadIdx.y;
__syncthreads();
if(x < _binImg.cols && y < _binImg.rows)
{
if(_binImg.ptr(y)[x] == 255)
{
do{} while(atomicCAS(&lock, 0, 1) != 0)
//----- critical section ------
_pointsX[*_index] = x;
_pointsY[*_index] = y;
(*_index)++;
lock = 0;
//----- end CS ------
}
}
}
It seems to me that the critical section is not working properly. White pixels in the image will be represented approximately 1%.
Could you please advise me? Thank you and have a nice day :)
EDIT:
solution:
__global__ void cudaCalcWhitePixels(cv::gpu::PtrStepSzb _binImg, int *_index, int *_pointsX, int *_pointsY)
{
int myIndex = 0;
const int x = blockIdx.x * blockDim.x + threadIdx.x;
const int y = blockIdx.y * blockDim.y + threadIdx.y;
__syncthreads();
if(x < _binImg.cols && y < _binImg.rows)
{
if(_binImg.ptr(y)[x] == 255)
{
//----- critical section ------
myIndex = atomicAdd(_index, 1);
_pointsX[myIndex] = x;
_pointsY[myIndex] = y;
//----- end CS ------
}
}
}

Answer 1

This code from the following URL may assist you understand how to use atomicCAS() to create a critical section.
https://github.com/ArchaeaSoftware/cudahandbook/blob/master/memory/spinlockReduction.cu
class cudaSpinlock {
public:
cudaSpinlock( int *p );
void acquire();
void release();
private:
int *m_p;
};
inline __device__
cudaSpinlock::cudaSpinlock( int *p )
{
m_p = p;
}
inline __device__ void
cudaSpinlock::acquire( )
{
while ( atomicCAS( m_p, 0, 1 ) );
}
inline __device__ void
cudaSpinlock::release( )
{
atomicExch( m_p, 0 );
}
Since (*_index)++; is the only atomic operation you do in CS, you could consider use atomicAdd() instead.
http://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#atomicadd
On the other hand, you could try to use thrust::copy_if() to simplify the coding.