How to unit test OpenGL on EC2 - c++

Question

Both my local computer and EC2 server is on Ubuntu 14.04. Suppose I am testing a cuda opengl interop code as below.
Test.cu
#include <iostream>
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <cuda_gl_interop.h>
__global__ static void CUDAKernelTEST(float *data){
const int x = blockIdx.x * blockDim.x + threadIdx.x;
const int y = blockIdx.y * blockDim.y + threadIdx.y;
const int mx = gridDim.x * blockDim.x;
data[y * mx + x] = 0.5;
}
GLFWwindow *glfw_window_;
void Setup(){
if (!glfwInit()) exit(EXIT_FAILURE);
glfwWindowHint(GLFW_VISIBLE, GL_FALSE);
glfw_window_ = glfwCreateWindow(10, 10, "", NULL, NULL);
if (!glfw_window_) glfwTerminate();
glfwMakeContextCurrent(glfw_window_);
glewExperimental = GL_TRUE;
if (glewInit() != GLEW_OK) exit(EXIT_FAILURE);
}
void TearDown(){
glfwDestroyWindow(glfw_window_);
glfwTerminate();
}
int main(){
Setup();
GLuint id;
glGenBuffers(1, &id);
glBindBuffer(GL_ARRAY_BUFFER, id);
glBufferData(GL_ARRAY_BUFFER, 3 * 24 * sizeof(GLfloat), 0, GL_STATIC_DRAW);
cudaGraphicsResource *vbo_res;
cudaGraphicsGLRegisterBuffer(&vbo_res, id, cudaGraphicsMapFlagsWriteDiscard);
cudaGraphicsMapResources(1, &vbo_res, 0);
float *test;
size_t size;
cudaGraphicsResourceGetMappedPointer(
reinterpret_cast<void **>(&test), &size, vbo_res);
dim3 blks(1, 1);
dim3 threads(72, 1);
CUDAKernelTEST<<<blks, threads>>>(test);
cudaDeviceSynchronize();
cudaGraphicsUnmapResources(1, &vbo_res, 0);
// do some more with OpenGL
std::cout << "you passed the test" << std::endl;
TearDown();
return 0;
}
The current approach is create a hidden window and a context. The code compiles and runs fine on my local machine. However, glfwInit() returns GL_FALSE when run on EC2. If I log the messages sent to the error callback, it shows "X11: The DISPLAY environment variable is missing", which looks like it needs a display monitor to be connected in order for it work.
I tried replacing the Setup and TearDown section from GLFW into SDL or GLX and it returns similar error seemingly also requiring a display monitor attached.
I also try running the code with Xvfb and Xdummy which is supposedly to faked a monitor but I got error message from Xvfb "Xlib: extension "GLX" missing on display ":99", and from Xdummy "Fatal server error: (EE) no screens found(EE)"
I can't be the first one attempting to unit test opengl related code on EC2, but I can't find any solutions after googling around. Please advice, thank you so much.

Answer 1

The DISPLAY variable has nothing to do with connected monitors. This environment variable tells X11 client programs which X11 server to talk to. In Linux and Unix systems the X11 server is the de-facto standard graphics system and window multiplexer. It is also the host to the GPU driver.
With your program expecting to talk to a X11 server, you must provide it a server with the necessary capabilities. Which in your case means a Xorg server with support for GLX protocol (so that OpenGL can be used) and, because you're using CUDA, it should host the NVidia driver. The only X11 server that can do that is the full blown Xorg server with the nvidia driver loaded. Xvfb or Xdummy can do neither.
So if you really want to talk X11 then you'll have to setup a Xorg server with the nvidia driver. Never mind if there are no displays connected, you can coax the driver into headless operation just fine (it may take some convinving though).
However since recently there's a better way: NVidias latest driver release includes support for creating a fully headless, off-screen OpenGL context on the GPU with full support for CUDA–OpenGL interop: http://devblogs.nvidia.com/parallelforall/egl-eye-opengl-visualization-without-x-server/
It boils down to create the OpenGL context with EGL instead of with X11/GLX using display device configured for headless operation by selecting PBuffer framebuffer attribute. The essential code outline looks like this (taken directly from the NVidia code example):
#include <EGL/egl.h>
static const EGLint configAttribs[] = {
EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, // make this off-screen
EGL_BLUE_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_RED_SIZE, 8,
EGL_DEPTH_SIZE, 8,
EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
EGL_NONE
};
static const int pbufferWidth = 9;
static const int pbufferHeight = 9;
static const EGLint pbufferAttribs[] = {
EGL_WIDTH, pbufferWidth,
EGL_HEIGHT, pbufferHeight,
EGL_NONE,
};
int main(int argc, char *argv[])
{
// 1. Initialize EGL
EGLDisplay eglDpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
EGLint major, minor;
eglInitialize(eglDpy, &major, &minor);
// 2. Select an appropriate configuration
EGLint numConfigs;
EGLConfig eglCfg;
eglChooseConfig(eglDpy, configAttribs, &eglCfg, 1, &numConfigs);
// 3. Create a surface
EGLSurface eglSurf = eglCreatePbufferSurface(eglDpy, eglCfg,
pbufferAttribs);
// 4. Bind the API
eglBindAPI(EGL_OPENGL_API);
// 5. Create a context and make it current
EGLContext eglCtx = eglCreateContext(eglDpy, eglCfg, EGL_NO_CONTEXT,
NULL);
eglMakeCurrent(eglDpy, eglSurf, eglSurf, eglCtx);
// from now on use your OpenGL context
// 6. Terminate EGL when finished
eglTerminate(eglDpy);
return 0;
}

Answer 2

#datenwolf: unfortunately, the nvidia's example you provide above won't run w/o an X11 server running. AFAIK, libEGL-nvidia (either linux or BSD) is linked to libX11:
$ ldd libEGL-NVIDIA.so.1
/usr/X11R6/lib/libEGL-NVIDIA.so.1:
libthr.so.3 => /lib/libthr.so.3 (0x801302000)
librt.so.1 => /usr/lib/librt.so.1 (0x80152a000)
libm.so.5 => /lib/libm.so.5 (0x80172f000)
libc.so.7 => /lib/libc.so.7 (0x800824000)
libnvidia-glsi.so.1 => /usr/X11R6/lib/libnvidia-glsi.so.1 (0x80195a000)
libX11.so.6 => /usr/X11R6/lib/libX11.so.6 (0x801bdf000)
libXext.so.6 => /usr/X11R6/lib/libXext.so.6 (0x801f1f000)
libxcb.so.1 => /usr/X11R6/lib/libxcb.so.1 (0x802130000)
libXau.so.6 => /usr/X11R6/lib/libXau.so.6 (0x802356000)
libXdmcp.so.6 => /usr/X11R6/lib/libXdmcp.so.6 (0x802559000)
and there's no way to change this (nvidia provides its drivers already compiled).
So, if you compile the nvidia's example like that (either with ES or GL API):
$ gcc egltest.c -o egltest -lEGL
you will get this (using GLESx or GL as well):
egltest:
libEGL.so.1 => /usr/X11R6/lib/libEGL-NVIDIA.so.1 (0x800823000)
libc.so.7 => /lib/libc.so.7 (0x800b25000)
libthr.so.3 => /lib/libthr.so.3 (0x800edd000)
librt.so.1 => /usr/lib/librt.so.1 (0x801105000)
libm.so.5 => /lib/libm.so.5 (0x80130a000)
libnvidia-glsi.so.1 => /usr/X11R6/lib/libnvidia-glsi.so.1 (0x801535000)
libX11.so.6 => /usr/X11R6/lib/libX11.so.6 (0x8017ba000)
libXext.so.6 => /usr/X11R6/lib/libXext.so.6 (0x801afa000)
libxcb.so.1 => /usr/X11R6/lib/libxcb.so.1 (0x801d0b000)
libXau.so.6 => /usr/X11R6/lib/libXau.so.6 (0x801f31000)
libXdmcp.so.6 => /usr/X11R6/lib/libXdmcp.so.6 (0x802134000)
Perhaps it could be more accurate to name the nvidia's EGL library EGLX, because it uses X11 and cannot run w/o X.
Caveats: from your example, nvidia EGL could bind to GL API (see attrib EGL_OPENGL_BIT ...) from v355 drivers only. From previous version, you could bind to GLES only (ie use EGL_OPENGL_ESx_BIT instead of EGL_OPENGL_BIT).
The only distro I knew that could run native window/drawable straight on the linux console - meaning w/o any X server or Wayland running - was the raspbian for the RPI-B, from which you will find the 'dispmanx' library that provides an easy way to access to the GPU/Fb through EGL (GLES2 API only supported).
B.R.
V.S.