Why Is OpenGL Window Creation Slow When Using GPU

Hi!

I noticed a significant performance hit when creating an OpenGL window when using the GPU instead of the integrated graphics card. When I turn on NvOptimusEnablement I get roughly an 800 ms penalty for simple window creation. It seems like all the time is spent in ChoosePixelFormat. Not sure if there's a way to speed this up? Any advice would be awesome

Here's the benchmark:

Running with integrated graphics:

λ .\opengl.exe |cat
RegisterClassA: 0.08 ms
CreateWindow: 4.64 ms
ChoosePixelFormat: 36.78 ms
SetPixelFormat: 36.94 ms
CreateOpenGLWindow: 36.95 ms
wglCreateContext: 45.76 ms
wglMakeCurrent: 48.87 ms
ShowWindow: 63.41 ms

Running with GPU:

λ .\opengl.exe |cat
RegisterClassA: 0.12 ms
CreateWindow: 5.28 ms
ChoosePixelFormat: 831.04 ms
SetPixelFormat: 831.19 ms
CreateOpenGLWindow: 831.20 ms
wglCreateContext: 831.81 ms
wglMakeCurrent: 877.83 ms
ShowWindow: 901.59 ms

And here's the test file:

// File: opengl.cpp

// Build command (integrated graphics):
// cl -Zi /I /MD opengl.cpp /link user32.lib opengl32.lib gdi32.lib

// Build command (with GPU):
// cl -Zi /I /MD -DUSE_GPU opengl.cpp /link user32.lib opengl32.lib gdi32.lib

// Run:
// .\opengl.exe | cat

#include <windows.h>
#include <gl/gl.h>
#include <stdio.h>

#ifdef USE_GPU
#ifdef __cplusplus
extern "C" {
#endif
__declspec(dllexport) DWORD NvOptimusEnablement = 0x01;
__declspec(dllexport) DWORD AmdPowerXpressRequestHighPerformance = 0x01;
#ifdef __cplusplus
}
#endif
#endif

static unsigned long long GlobalPerfCountFrequency;
static LARGE_INTEGER GameInitClock;

#define DebugTime(name) printf("%s: %.2f ms\n", #name, Win32GetSecondsElapsed(GameInitClock, Win32GetWallClock()) * 1000)

LARGE_INTEGER Win32GetWallClock(void) {
  LARGE_INTEGER Result;
  QueryPerformanceCounter(&Result);
  return Result;
}

double Win32GetSecondsElapsed(LARGE_INTEGER Start, LARGE_INTEGER End) {
  double Result = ((double)(End.QuadPart - Start.QuadPart) / (double)GlobalPerfCountFrequency);
  return Result;
}

void display() {
  glClear(GL_COLOR_BUFFER_BIT);
  glBegin(GL_TRIANGLES);
  glColor3f(1.0f, 0.0f, 0.0f);
  glVertex2i(0,  1);
  glColor3f(0.0f, 1.0f, 0.0f);
  glVertex2i(-1, -1);
  glColor3f(0.0f, 0.0f, 1.0f);
  glVertex2i(1, -1);
  glEnd();
  glFlush();
}


LONG WINAPI WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
  static PAINTSTRUCT ps;

  switch(uMsg) {
  case WM_PAINT:
    display();
    BeginPaint(hWnd, &ps);
    EndPaint(hWnd, &ps);
    return 0;

  case WM_SIZE:
    glViewport(0, 0, LOWORD(lParam), HIWORD(lParam));
    PostMessage(hWnd, WM_PAINT, 0, 0);
    return 0;

  case WM_CHAR:
    switch (wParam) {
      case 27: {
        ExitProcess(0);
      } break;
    }
    return 0;

  case WM_CLOSE:
    ExitProcess(0);
    return 0;
  }

  return DefWindowProc(hWnd, uMsg, wParam, lParam);
}

HWND CreateOpenGLWindow(char* title, int x, int y, int width, int height, BYTE type, DWORD flags) {
    static HINSTANCE hInstance = 0;

    if (!hInstance) {
        hInstance = GetModuleHandle(NULL);
        WNDCLASS wc;
        wc.style         = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
        wc.lpfnWndProc   = (WNDPROC)WindowProc;
        wc.cbClsExtra    = 0;
        wc.cbWndExtra    = 0;
        wc.hInstance     = hInstance;
        wc.hIcon         = LoadIcon(NULL, IDI_WINLOGO);
        wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
        wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
        wc.lpszMenuName  = NULL;
        wc.lpszClassName = "OpenGL";

        if (!RegisterClassA(&wc)) {
            MessageBox(NULL, "RegisterClass() failed:  "
                "Cannot register window class.", "Error", MB_OK);
            return NULL;
        }
        DebugTime(RegisterClassA);
    }

    HWND hWnd = CreateWindow(
      "OpenGL", title, WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
      x, y, width, height, NULL, NULL, hInstance, NULL);
    DebugTime(CreateWindow);

    if (hWnd == NULL) {
        MessageBox(NULL, "CreateWindow() failed:  Cannot create a window.",
            "Error", MB_OK);
        return NULL;
    }

    HDC hDC = GetDC(hWnd);

    PIXELFORMATDESCRIPTOR pfd;
    memset(&pfd, 0, sizeof(pfd));
    pfd.nSize        = sizeof(pfd);
    pfd.nVersion     = 1;
    pfd.dwFlags      = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | flags;
    pfd.iPixelType   = type;
    pfd.cColorBits   = 32;

    int pf = ChoosePixelFormat(hDC, &pfd);
    DebugTime(ChoosePixelFormat);
    if (pf == 0) {
        MessageBox(NULL, "ChoosePixelFormat() failed:  "
            "Cannot find a suitable pixel format.", "Error", MB_OK);
        return 0;
    }

    if (SetPixelFormat(hDC, pf, &pfd) == FALSE) {
        MessageBox(NULL, "SetPixelFormat() failed:  "
            "Cannot set format specified.", "Error", MB_OK);
        return 0;
    }
    DebugTime(SetPixelFormat);

    ReleaseDC(hWnd, hDC);

    return hWnd;
}

int APIENTRY WinMain(HINSTANCE hCurrentInst, HINSTANCE hPreviousInst, LPSTR lpszCmdLine, int nCmdShow) {
  GameInitClock = Win32GetWallClock();

  {
    LARGE_INTEGER PerfCountFrequencyResult;
    QueryPerformanceFrequency(&PerfCountFrequencyResult);
    GlobalPerfCountFrequency = PerfCountFrequencyResult.QuadPart;
  }

    HWND hWnd = CreateOpenGLWindow("minimal", 0, 0, 1280, 720, PFD_TYPE_RGBA, 0);
    DebugTime(CreateOpenGLWindow);

    if (hWnd == NULL) exit(1);

    HDC hDC = GetDC(hWnd);
    HGLRC hRC = wglCreateContext(hDC);
    DebugTime(wglCreateContext);

    wglMakeCurrent(hDC, hRC);
    DebugTime(wglMakeCurrent);

    ShowWindow(hWnd, nCmdShow);
    DebugTime(ShowWindow);

    fflush(stdout);

    MSG msg;
    while (GetMessage(&msg, hWnd, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    return 0;
}

For context this is the graphics card I'm using: NVIDIA Corporation GeForce MX150/PCIe/SSE2

Also wondering if it's possible to call a function during program run-time that has a similar effect to NvOptimusEnablement? That way I could at least shift the perceived startup latency to a different point (e.g. after showing a loading screen). The only thing I can think of is to have two programs: one launcher that quickly displays a splash screen and then calls out to the main program executable. Ideally I would like these to be one executable (for simplicity)!

Thanks,

- Nick