Getting unknown error when launching large kernel sizes - c++

Question

I am running into a problem when launching a simple kernel when my array size becomes larger than 591 by 591. At a size of 591x591 the array is returned without any error, but as soon as I launch the kernel with grid dimensions of 38x38 blocks with 16x16 threads each, the kernel fails to launch and returns an "unknown error".
The following code is the kernel I am calling and the call to the kernel in my code:
#include <cuda.h>
#include <cuda_runtime.h>
#include <cuda_device_runtime_api.h>
using namespace std;
#define BLOCKSIZE 16
#define gpuErrchk(ans) { gpuAssert((ans), __FILE__,__LINE__);}
inline void gpuAssert(cudaError_t code, char *file, int line, bool abort = true)
{
if (code != cudaSuccess)
{
fprintf(stderr, "GPUassert: %s %s %d\n", cudaGetErrorString(code), file, line);
if(abort) exit(code);
}
}
__global__ void IdentityMatrixKernel(float* identity, int size)
{
int index_x = blockIdx.x * blockDim.x + threadIdx.x;
int index_y = blockIdx.y * blockDim.y + threadIdx.y;
// map the two 2D indices to a single linear, 1D index
int grid_width = gridDim.x * blockDim.x;
int index = index_y * grid_width + index_x;
// map the two 2D block indices to a single linear, 1D block index
//int result = blockIdx.y * gridDim.x + blockIdx.x;
if (index % (size+1))
{
identity[index] = 0;
}
else
{
identity[index] = 1;
}
void foo(float *aArray, int size)
{
float* d_I;
int size2 = size*size*sizeof(float);
gpuErrchk(cudaMalloc(&d_I,size2));
dim3 block_size;
block_size.x = BLOCKSIZE;
block_size.y = BLOCKSIZE;
dim3 grid_size;
grid_size.x = size1/ block_size.x + 1;
grid_size.y = size1/ block_size.y + 1;
IdentityMatrixKernel<<<grid_size,block_size>>>(d_I,size);
gpuErrchk(cudaPeekAtLastError());
gpuErrchk(cudaMemcpy(aArray,d_I,size2,cudaMemcpyDeviceToHost));
cudaFree(d_I);
}
int main()
{
int size = 591;
float *aArray = (float*)malloc(size*size*sizeof(float));
foo(aArray,size);
return 0;
}
For size = 591 no error shows up, outputs identity matrix of size 591x591 but for any larger size it spits out an "unknown error" to console.

Answer 1

One problem seems to be that you are launching a grid of threads that is larger than your actual matrix:
grid_size.x = size1/ block_size.x + 1;
grid_size.y = size1/ block_size.y + 1;
But you are not checking for any out-of-bounds accesses in your kernel. You need to add a thread check such as:
if ((index_x >= size)||(index_y >= size)) return;
near the beginning of your kernel. But that's not enough. Another problem is that your index calculation is not correct:
int index = index_y * grid_width + index_x;
On the surface of it, it appears to be correct, but since your thread array is larger than your data array (potentially), this can give incorrect indexing. Since you're passing size to the kernel anyway, change it to something like this:
int index = index_y * size + index_x;
And you should be able to eliminate the out-of-bounds accesses.

Answer 2

I extend Robert Crovella's answer.
If you define block_size.{x, y} with a big number (in your case 16), then you won't be able to work with arrays of smaller size e.g. 4x4. What you could do is define a small block size:
/* create thread blocks */
dim3 block_size;
block_size.x = 4;
block_size.y = 4;
/* create n x n block grids */
dim3 grid_size;
grid_size.x = size1/block_size.x;
grid_size.y = size1/block_size.y;
/* in case of partial sizes make grid_size 1 x 1 */
if (size1 % block_size.x)
grid_size.x = 1, grid_size.y = 1;