Fix CL_INVALID_VALUE Error in OpenGL-OpenCL Interoperability for Delphi

The CL_INVALID_VALUE error when creating a shared context between OpenGL and OpenCL in Delphi typically occurs due to incorrect property values or missing extension support. This error indicates that one of the parameters passed to clCreateContext is invalid, often related to OpenGL context sharing properties. Fixing this requires proper validation of extension support, correct context sharing parameters, and proper error handling to identify the specific invalid parameter.

Contents

• Understanding the CL_INVALID_VALUE Error
• Common Causes in OpenGL-OpenCL Interoperability
• Proper Setup for Delphi OpenGL-OpenCL Interoperability
• Code Corrections for Your Implementation
• Verification and Debugging Techniques
• Best Practices for OpenGL-OpenCL Interoperability
• Sources
• Conclusion

Understanding the CL_INVALID_VALUE Error

The official OpenCL documentation specifies that CL_INVALID_VALUE occurs when “devices is NULL; if num_devices is equal to zero; or if pfn_notify is NULL but user_data is not NULL.” However, in OpenGL-OpenCL interoperability scenarios, this error most commonly relates to invalid context sharing properties.

When working with OpenGL and OpenCL interoperability in Delphi, the CL_INVALID_VALUE error specifically indicates that one of the properties in your property array is invalid. This typically happens when:

1. The OpenGL context hasn’t been properly created before calling clCreateContext
2. Required OpenGL-OpenCL extensions aren’t supported
3. Context sharing properties are incorrectly formatted
4. Device parameters aren’t properly initialized

Common Causes in OpenGL-OpenCL Interoperability

Missing Extension Support

Before attempting to create a shared context, you must verify that both OpenGL and OpenCL support the necessary extensions. In your Delphi code, you should check for the presence of extensions like cl_khr_gl_sharing and ensure your GPU driver supports them.

Incorrect Property Array Format

Your current implementation uses:

props[0] := CL_GL_CONTEXT_KHR;
props[1] := wglGetCurrentContext();
props[2] := CL_WGL_HDC_KHR;
props[3] := wglGetCurrentDC();
props[4] := 0;

This format might be problematic because:

1. The OpenGL context handle might not be properly cast to the expected type
2. The HDC handle might be invalid or not properly formatted
3. The termination of the property array at index 4 might not be correctly implemented

Context Creation Order

OpenGL context must be fully created and made current before attempting to create the OpenCL context. Your code creates the OpenGL context but doesn’t verify it was successful before proceeding to OpenCL initialization.

Proper Setup for Delphi OpenGL-OpenCL Interoperability

Extension Verification

First, verify that the required extensions are available:

var
  Extensions: PAnsiChar;
begin
  // Check OpenCL extensions
  Extensions := clGetPlatformInfo(CLPlatform, CL_PLATFORM_EXTENSIONS, 0, nil, @Size);
  if not (Pos('cl_khr_gl_sharing', Extensions) > 0) then
    raise Exception.Create('cl_khr_gl_sharing extension not supported');

Correct Context Handling

According to Apple’s OpenCL documentation, “OpenGL sees the data as a VBO and OpenCL sees it as a cl_mem.” This requires proper context sharing setup:

// Make sure OpenGL context is current
if not wglMakeCurrent(glDC, GLContext) then
  raise Exception.Create('Unable to activate OpenGL context');

// Get the current OpenGL context and DC
var GLContext := wglGetCurrentContext();
var GLDC := wglGetCurrentDC();

// Create the property array correctly
var props: array[0..4] of TProperty;
props[0] := CL_GL_CONTEXT_KHR;
props[1] := PtrToInt(GLContext); // Proper casting
props[2] := CL_WGL_HDC_KHR;
props[3] := PtrToInt(GLDC); // Proper casting
props[4] := 0; // Terminate the array

Device Selection

Ensure you’re selecting the correct device that supports OpenGL interoperability:

// Get devices that support OpenGL
var Devices: array[0..0] of cl_device_id;
var NumDevices: cl_uint;
Err := clGetDeviceIDs(CLPlatform, CL_DEVICE_TYPE_GPU, 1, @Devices[0], @NumDevices);

// Verify device supports OpenGL
var DeviceExtensions: PAnsiChar;
GetMem(DeviceExtensions, Size);
clGetDeviceInfo(Devices[0], CL_DEVICE_EXTENSIONS, Size, DeviceExtensions, nil);
if not (Pos('cl_khr_gl_sharing', DeviceExtensions) > 0) then
  raise Exception.Create('Selected device does not support OpenGL interoperability');
FreeMem(DeviceExtensions);

Code Corrections for Your Implementation

Here’s how to correct your implementation:

FillChar(pfd, SizeOf(pfd), 0);

with pfd do
begin
  nSize := SizeOf(pfd);
  nVersion := 1;
  dwFlags := PFD_DRAW_TO_WINDOW or PFD_SUPPORT_OPENGL or PFD_DOUBLEBUFFER;
  iPixelType := PFD_TYPE_RGBA;
  cColorBits := 24;
  cDepthBits := 32;
  cStencilBits := 8;
  iLayerType := PFD_MAIN_PLANE;
end;

glDC := getDC(Self.handle);
FormatIndex := ChoosePixelFormat(glDC, @pfd);
SetPixelFormat(glDC, FormatIndex, @pfd);
GLContext := wglCreateContext(glDC);

if (not wglMakeCurrent(glDC, GLContext)) then
  raise Exception.Create('Unable to activate OpenGL context');

// Verify OpenGL extensions
var Extensions: PAnsiChar;
var Size: SizeUInt;
clGetPlatformInfo(CLPlatform, CL_PLATFORM_EXTENSIONS, 0, nil, @Size);
GetMem(Extensions, Size + 1);
clGetPlatformInfo(CLPlatform, CL_PLATFORM_EXTENSIONS, Size, Extensions, nil);
Extensions[Size] := #0;

if not (Pos('cl_khr_gl_sharing', Extensions) > 0) then
begin
  FreeMem(Extensions);
  raise Exception.Create('cl_khr_gl_sharing extension not supported');
end;
FreeMem(Extensions);

Err := clGetPlatformIDs(1, @CLPlatform, @NumPlatforms);
if Err <> CL_SUCCESS then
  raise Exception.Create('Failed to get platform IDs');

Err := clGetDeviceIDs(CLPlatform, CL_DEVICE_TYPE_GPU, 1, @Device, @NumDevices);
if Err <> CL_SUCCESS then
  raise Exception.Create('Failed to get device IDs');

// Create correct property array
var GLContextHandle := wglGetCurrentContext();
var GLDCHandle := wglGetCurrentDC();

var props: array[0..4] of TProperty;
props[0] := CL_GL_CONTEXT_KHR;
props[1] := PtrToInt(GLContextHandle);
props[2] := CL_WGL_HDC_KHR;
props[3] := PtrToInt(GLDCHandle);
props[4] := 0;

Context := clCreateContext(@props[0], 1, @Device, nil, nil, @Err);
if (Err = CL_INVALID_VALUE) then
begin
  // More detailed error reporting
  raise Exception.CreateFmt('CL_INVALID_VALUE error: Check if OpenGL context is current and extensions are supported. Error code: %d', [Err]);
end
else if (Context = nil) then
  raise Exception.Create('Failed to create OpenCL context');

Verification and Debugging Techniques

Step-by-Step Validation

To identify the specific cause of the CL_INVALID_VALUE error, implement a step-by-step validation process:

1. Verify OpenGL context creation success
2. Check that the OpenGL context is current
3. Validate extension support
4. Inspect device capabilities
5. Validate each property individually

Error Code Analysis

The Stack Overflow discussion notes that “Otherwise it will try to get the next parameter which is a completely unknown value, therefore a CL_INVALID_VALUE error.” This suggests that proper validation of each parameter is crucial.

Device Property Inspection

Before creating the context, inspect the device properties to ensure it supports OpenGL interoperability:

var DeviceType: cl_device_type;
clGetDeviceInfo(Device, CL_DEVICE_TYPE, SizeOf(DeviceType), @DeviceType, nil);

if (DeviceType and CL_DEVICE_TYPE_GPU) = 0 then
  raise Exception.Create('Device is not a GPU');

Best Practices for OpenGL-OpenCL Interoperability

Context Management

Always maintain proper context management:

• Create and activate OpenGL context first
• Verify OpenGL context is current before OpenCL operations
• Use the same device for both OpenGL and OpenCL operations

Memory Management

As explained in the academic paper on OpenCL/OpenGL interoperability, “dPobj = clCreateFromGLBuffer(Context, CL_MEM_READ_WRITE, hPobj, &status);” demonstrates proper VBO creation. Always:

• Use clCreateFromGLBuffer or equivalent functions to create OpenCL memory objects from OpenGL resources
• Synchronize access between OpenGL and OpenCL using clEnqueueAcquireGLObjects and clEnqueueReleaseGLObjects

Error Handling

Implement comprehensive error handling at each step of the initialization process. Log detailed error information to help diagnose issues.

Extension Checking

Always verify the presence of required extensions before attempting interoperability operations. This prevents many common CL_INVALID_VALUE errors.

Sources

• clCreateContext(3) - Official OpenCL Documentation
• Sharing Data Between OpenCL and OpenGL - Apple Developer Documentation
• OpenCL / OpenGL Vertex Buffer Interoperability - Oregon State University
• OpenCL OpenGL interop context creation failing - Stack Overflow
• OpenCL/OpenGL interoperability error - GameDev.net

Conclusion

Fixing the CL_INVALID_VALUE error in Delphi OpenGL-OpenCL interoperability requires careful attention to context creation order, proper extension verification, and correct parameter formatting. The most common issues include attempting to create a shared context before the OpenGL context is current, missing required extensions, or incorrectly formatted property arrays. By implementing proper validation, step-by-step initialization, and comprehensive error handling, you can successfully establish OpenGL-OpenCL interoperability in Delphi and share resources like VBOs between the two APIs. Remember to always verify extension support and ensure proper context management throughout your application’s lifecycle.