Kernel fails on launch cause of kernel pararameters - cuda

Question

I made a simple CUDA kernel which fails to launch for some reason I don't understand.
Below you see my global vars.
unsigned int volume[256*256*256];//contains volume data of source
unsigned int target[256*256*256];//contains volume data of target
unsigned int* d_volume=NULL;//source data on device
unsigned int* d_target=NULL;//target data on device
The next function is a kernel launcher.
void launch_kernel(){
cudaMalloc(&d_volume,256*256*256*sizeof(unsigned int));
cudaMemcpy(d_volume, volume, 256*256*256*sizeof(unsigned int),cudaMemcpyHostToDevice);
cudaMalloc(&d_target,256*256*256*sizeof(unsigned int));
cudaMemcpy(d_target, target, 256*256*256*sizeof(unsigned int),cudaMemcpyHostToDevice);
dim3 threads(256,1,1);
dim3 blocks(256,256,1);
simple_kernel<<<blocks,threads>>>(d_volume,d_target);
cudaError_t cudaResult;
cudaResult = cudaGetLastError();
if (cudaResult != cudaSuccess)
{
cout<<"kernel failed"<<endl;
}
cudaMemcpy(volume, d_volume, 256*256*256*sizeof( int),cudaMemcpyDeviceToHost);
cudaFree(d_volume);
cudaMemcpy(target, d_target 256*256*256*sizeof( int),cudaMemcpyDeviceToHost);
cudaFree(d_target);
}
Problem seems to be on d_target cause if I launch the kernel like that:
simple_kernel<<<blocks,threads>>>(d_volume,d_volume);
it is working perfectly (passes on to the device the values that must be passed) and no message appears. Any idea why could that happen?
Kernel declaration follows below.
__global__ void simple_kernel(unsigned int* src,unsigned int* tgt){
//i dont think it matters what it is for.
int x = threadIdx.x;
int y = blockIdx.x;
int z = blockIdx.y;
if(x!=0 || x!=255 || y!=0 || y!=255 || z!=0 || z!=255 ){//in bound of memory allocated
if( src[x*256*256+y*256+z]==tgt[x*256*256+y*256+z])
if(tgt[(x+1)*256*256+y*256+z]==1 || tgt[(x-1)*256*256+y*256+z]==1 || tgt[(x-1)*256*256+(y+1)*256+z] ||tgt[(x-1)*256*256+(y-1)*256+z])
src[x*256*256+y*256+z]=1;
else
src[x*256*256+y*256+z]=0;
}
}

Answer 1

CUDA can return error also in a case of out-of-bounds read access to global memory. You perform this out-of-bounds read access in:
if(tgt[(x+1)*256*256+y*256+z]==1 || ...) e.g. for x = y = z = 255 which go through your out-of-bounds checking.
In a case you launch your kernel as
simple_kernel<<<blocks,threads>>>(d_volume,d_volume);
during out-of-bounds read access you actually access global memory which has already been allocated for d_target as arrays d_volume and d_target are stored consecutively, hence, no error occurs.
Confirm my opinion by further error-checking or launch your program with cuda-memcheck.