CUDA operation error: cuGraphicsResourceGetMappedPointer failed: resource not mapped as pointer when pycuda.gl.RegisteredMapping.device_ptr_and_size()

[yyuyulm]

Describe the bug
I have an variable that is <class 'pycuda._driver.RegisteredMapping'> yet when I try to call pycuda.gl.RegisteredMapping.device_ptr_and_size() to get its pointer and size so that I can map it to a GPU array (then to a pytorch tensor for down stream tasks), I got the following error:
CUDA operation error: cuGraphicsResourceGetMappedPointer failed: resource not mapped as pointer

To Reproduce
Steps to reproduce the behavior:

1. go to the notebook code bellow
2. run the whole notebook with an available spout stream matching the names in the notebook
   Expected behavior
   logs:
   <class 'pycuda._driver.RegisteredMapping'>
   CUDA operation error: cuGraphicsResourceGetMappedPointer failed: resource not mapped as pointer

Environment (please complete the following information):

• OS: [e.g. Windows 11]
• CUDA version: [e.g. 12.5]
• CUDA driver version: [e.g. 560.81]
• PyCUDA version: [e.g 2024.1.2]
• Python version: [e.g. 3.12]

Additional context
I had some trouble installing pycuda with OpenGL, had to change siteconf.py to install the pycuda.gl module

Code:

%%

import torch
import numpy as np
import pycuda.driver as cuda
import pycuda.gl as cuda_gl
import pycuda.gpuarray as gpuarray
from pycuda.gl import graphics_map_flags
import pycuda.autoinit
from OpenGL.GL import *
import glfw
from SpoutGL import SpoutReceiver, SpoutSender

%%

def setProjection(width, height):
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
glOrtho(0, width, height, 0, 1, -1)
glMatrixMode(GL_MODELVIEW)

def drawSquare(width, height):
glEnable(GL_TEXTURE_2D)
glBegin(GL_QUADS)
glTexCoord2f(0, 0); glVertex2f(0, 0)
glTexCoord2f(1, 0); glVertex2f(width, 0)
glTexCoord2f(1, 1); glVertex2f(width, height)
glTexCoord2f(0, 1); glVertex2f(0, height)
glEnd()
glDisable(GL_TEXTURE_2D)

def check_gl_error():
err = glGetError()
if err != GL_NO_ERROR:
print(f"OpenGL error: {err}")

class SimpleModel(torch.nn.Module):
def init(self):
super(SimpleModel, self).init()
self.conv = torch.nn.Conv2d(4, 4, 3, padding=1)

def forward(self, x):
    return torch.relu(self.conv(x))

%%

Replace with your parameters

receiverName = 'tdOut'
senderName = 'pythonOut'
displayWidth, displayHeight = 1280, 720

Initialize GLFW and create a window

if not glfw.init():
raise Exception("GLFW initialization failed")

window = glfw.create_window(displayWidth, displayHeight, "Spout Receiver/Sender", None, None)
if not window:
glfw.terminate()
raise Exception("GLFW window creation failed")

glfw.make_context_current(window)

Set up Spout receiver and sender

spout_receiver = SpoutReceiver()
spout_receiver.setReceiverName(receiverName)
spout_sender = SpoutSender()
spout_sender.setSenderName(senderName)

def create_texture(width, height):
tex_id = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, tex_id)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, None)
glBindTexture(GL_TEXTURE_2D, 0)
check_gl_error()
return tex_id

def recreate_textures(new_width, new_height):
global width, height, input_tex_id, output_tex_id, input_image, output_image

# Delete old textures and CUDA mappings
glDeleteTextures([input_tex_id, output_tex_id])
input_image.unregister()
output_image.unregister()

# Create new textures
input_tex_id = create_texture(new_width, new_height)
output_tex_id = create_texture(new_width, new_height)

# Create new CUDA mappings
input_image = cuda_gl.RegisteredImage(int(input_tex_id), GL_TEXTURE_2D)
output_image = cuda_gl.RegisteredImage(int(output_tex_id), GL_TEXTURE_2D)

width, height = new_width, new_height
setProjection(width, height)

Create initial textures

input_tex_id = create_texture(displayWidth, displayHeight)
output_tex_id = create_texture(displayWidth, displayHeight)

setProjection(displayWidth, displayHeight)
glClearColor(0.0, 0.0, 0.0, 1.0)

Create CUDA-OpenGL interop resources

cuda.init()
cuda_gl_context = cuda_gl.make_context(pycuda.autoinit.device)
cuda_gl_context.push()

input_image = cuda_gl.RegisteredImage(int(input_tex_id), GL_TEXTURE_2D)
output_image = cuda_gl.RegisteredImage(int(output_tex_id), GL_TEXTURE_2D)

Define a simple PyTorch model (replace with your actual model)

model = SimpleModel().cuda()

width, height = displayWidth, displayHeight

Main loop

while not glfw.window_should_close(window):
glfw.poll_events()

# Receive frame from Spout into input OpenGL texture
spout_receiver.receiveTexture(input_tex_id, GL_TEXTURE_2D, False, 0)
if spout_receiver.isUpdated():
    new_width = spout_receiver.getSenderWidth()
    new_height = spout_receiver.getSenderHeight()

    # Update texture size if needed
    if new_width != width or new_height != height:
        print(f"Size change detected. Current: {width}x{height}, New: {new_width}x{new_height}")
        recreate_textures(new_width, new_height)

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

if width > 0 and height > 0:
    # Draw received texture
    glBindTexture(GL_TEXTURE_2D, input_tex_id)
    drawSquare(width, height)
    glBindTexture(GL_TEXTURE_2D, 0)

    # Process the texture with the model
    try:
        # Map the input OpenGL texture to CUDA
        input_mapping = input_image.map()
        input_array = input_mapping.array(0,0)
        print(type(input_mapping))
        print(input_mapping.device_ptr_and_size())
        
        # Create a GPUArray from the CUDA array
        gpu_array = gpuarray.empty((height, width, 4), dtype=np.uint8)
        #gpu_array = gpuarray.GPUArray((height, width, 4), dtype=torch.uint8, gpudata=input_array.ptr)
        cuda.memcpy_dtod(gpu_array.ptr, input_mapping.dev_pointer, gpu_array.size)
        print(type(gpu_array))

        # Create a PyTorch tensor from the GPUArray
        input_tensor = torch.as_tensor(gpu_array, device='cuda')
        
        # Reshape and normalize the tensor
        input_tensor = input_tensor.permute(2, 0, 1).unsqueeze(0).float() / 255.0
        '''
        # Run the model
        with torch.no_grad():
            output_tensor = model(input_tensor)

        # Denormalize and reshape the output tensor
        output_tensor = (output_tensor.squeeze(0).permute(1, 2, 0) * 255).byte()
        
        # Map the output OpenGL texture to CUDA
        output_gl_resource = cuda_gl.GraphicsResource(int(output_tex_id), cuda.graphics.TextureTarget.TEXTURE_2D, cuda.graphics.map_flags.WRITE_DISCARD)
        output_mapping = output_gl_resource.map()
        output_array = output_mapping.array(cuda.array_format.UNSIGNED_INT8, 4)
        
        # Copy the output tensor to the CUDA array
        cuda.memcpy_dtod(output_array.gpudata, output_tensor.data_ptr(), output_tensor.numel() * output_tensor.element_size())
        '''
        # Unmap the resources
        input_mapping.unmap()
        # output_gl_resource.unmap()
        
        # Send the processed texture using Spout
        # spout_sender.sendTexture(output_tex_id, GL_TEXTURE_2D, width, height)

    except cuda.LogicError as e:
        print(f"CUDA operation error: {e}")
    except Exception as e:
        print(f"Unexpected error: {e}")
        import traceback
        traceback.print_exc()

glfw.swap_buffers(window)
spout_receiver.waitFrameSync(receiverName, 100)  # Wait for next frame, timeout after 100ms

Cleanup

glDeleteTextures([input_tex_id, output_tex_id])
glfw.terminate()
spout_sender.releaseSender()
cuda_gl_context.pop()