Write to GL_ARRAY_TEXTURE_2D OpenGL interop fails - opengl

Question

I need to write to OpenGL GL_ARRAY_TEXTURE_2D using CUDA graphics interop functionality.I use CUDA Driver API, CUDA version 7.5 .My GPU is NVIDIA Quadro K4000 with CC3.0 I create OpenGL array texture like this (5 layers):
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glGenTextures(1, &_glArrayTexHandle);
glBindTexture(GL_TEXTURE_2D_ARRAY, _glArrayTexHandle);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA32F, m_viewportWidth, m_viewportHeight, 5, 0, GL_RGBA, GL_FLOAT, 0);
glBindTexture(GL_TEXTURE_2D_ARRAY, 0);
Then on CUDA side I create graphics image resource for that texture to be used with CUDA surface :
checkCudaErrors(cuGraphicsGLRegisterImage(&m_cudaToGL_TEX_ARRAY_Resource, _glArrayTexHandle, GL_TEXTURE_2D_ARRAY, CU_GRAPHICS_REGISTER_FLAGS_SURFACE_LDST));
assert(m_cudaToGL_TEX_ARRAY_Resource);
checkCudaErrors(cuModuleGetSurfRef(&m_surfGLtexRef, m_module, "surfaceWrite"));
assert(m_surfGLtexRef);
During the renderloop I am mapping the resource and set reference between the array pointer and the surface to write to in the kernel:
checkCudaErrors(cuGraphicsMapResources(1, &m_cudaToGL_TEX_ARRAY_Resource, 0));
//write to layer number 3
checkCudaErrors(cuGraphicsSubResourceGetMappedArray(
&m_cudaOffscreenFBOTextureArrayPtr, m_cudaToGL_TEX_ARRAY_Resource, 3, 0));
assert(m_cudaOffscreenFBOTextureArrayPtr);
checkCudaErrors(cuSurfRefSetArray(m_surfGLtexRef, m_cudaOffscreenFBOTextureArrayPtr, 0));
///launch the kernel:
checkCudaErrors(cuLaunchKernel(function,
blockDimX,
blockDimY,
1,
block_size,
block_size,
1,
0,
NULL,
args,
NULL
));
checkCudaErrors(cuGraphicsUnmapResources(1, &m_cudaToGL_TEX_ARRAY_Resource, 0));
checkCudaErrors(cuCtxSynchronize());
The kernels looks like this:
surface<void, cudaSurfaceType2DLayered> surfaceWrite;
extern "C" __global__ void surfWriteFunc(int xOffset, int yOffset, int Width, int Height)
{
unsigned int x = blockIdx.x * blockDim.x + threadIdx.x;
unsigned int y = blockIdx.y * blockDim.y + threadIdx.y;
if (x >= Width || y >= Height)
{
return;
}
float4 dataOut = make_float4(1.0f, 0.0f, 1.0f, 1.0f);
surf2DLayeredwrite(dataOut, surfaceWrite, x * sizeof(float4), y, 3);
}
I am trying to use CUDA layered surface write.At least that's what I suppose should be used with GL_ARRAY_TEXTURE_2D .Otherwise the NVIDIA docs have zero info on how to do it.The error I am getting is
CUDA_ERROR_LAUNCH_FAILED for every cuda method called during the rendering as seen above.I tried,for example to use cudaSurfaceType3D instead of layered,but it didn't help.It could be nice if anyone could shed some light on GL array textures interop with CUDA.

Answer 1

After many trials & errors I found how it works.First,it seems like CUDA doesn't allow layered surface write when it comes to CUDA array pointer that maps to GL resource.So this code in kernel
surf2DLayeredwrite(dataOut, surfaceWrite, x * sizeof(float4), y, 3);
Is invalid as there is access to the layer zero only of the mapped array.
The valid code is
surf2DLayeredwrite(dataOut, surfaceWrite, x * sizeof(float4), y, 0);
And therefore there is no reason to use surf2DLayeredwrite at all but just usual
2D surface write:
surf2Dwrite(dataOut, surfaceWrite, x * sizeof(float4), y);
Now to the actual answer to the question "How to write to different layers of GL_ARRAY_TEXTURE_2D?
checkCudaErrors(cuGraphicsSubResourceGetMappedArray(
&m_cudaOffscreenFBOTextureArrayPtr, m_cudaToGL_TEX_ARRAY_Resource, **3**, 0));
Where "3" is the index of the layer in the mapped array texture to write to.
I haven't find a way to select layer index from within the kernel.Currently it looks that it is only possible to do on the host.

Answer 2

This ansver comes late, but maybe it helps someone...
I haven't tried GL_ARRAY_TEXTURE_2D, but I can say that at least GL_TEXTURE_3D texel indexing will work dynamically inside a CUDA kernel (starting from compute_20,sm_21 and CUDA 5.0, probably also CUDA 4.1 and CUDA 4.2).
However, there is one gotcha you need to know with three dimensional textures: you have to compile your CUDA program in release mode, not in debug mode.