Error code: 6

I’m sporadically getting this error and I’m wondering what could be the possible explanations :

You hardware configuration does not meet minimum specifications 
needed to run the application. The application must close.

Error code: 6
Would you like to visit
http://nvidia.custhelp.com/cgi-bin/nvidia.cfg/php/enduser/std_adp.php?p_faqid=3008 for help?

The webpage talks about large chunks of memory but in the OpenGL doc, glTexImage2D is supposed to raise a GLError in that case, which I don’t have.

My best guess is that I was calling glTexImage2D repeatedly instead of glTexSubImage2D to update the content of my texture. But I can’t tell for sure since the problem arises sporadically.

I’m using gDEbugger but it does not know what’s going on. I tried glslDevil but it crashes whenever I try to use it.

I’m using the latest drivers ( 320.86 ).

Is it possible that the NVidia driver crashes instead of raising a glError when it cannot allocate a buffer or a texture? Btw my textures sizes are RGBA32UI(128-bits) from 512512to 20482048. And the Quadro 600 has 1Gigs on the graphic card and my pc has 24 gigs on a 64-bit windows 7 system. GPU caps tells me that I should be able to allocate 16384*16384 textures, which I can, so I don’t think that’s a out-of-mem issue.

It works well most of the time. Anyone knows any tool to help me diagnose that problem?

Thank you
Jean-Simon Brochu

EDIT

I’ve modified the Chapter 11-oit(order-independent transparency) example that comes with the opengl red book 8th edition to reallocate texture buffers when the window is resized and the problem occurs systematically upon resetting the atomic counter just after reallocating the linked list and head pointer buffers.

This is very similar to what I get in my application.

Can anyone point me in the right direction?

/* $URL$
   $Rev$
   $Author$
   $Date$
   $Id$
 */

#include "vapp.h"
#include "vutils.h"

#include "vmath.h"

#include "vbm.h"
#include "LoadShaders.h"

#include <stdio.h>
#include <string>

#define MAX_FRAMEBUFFER_WIDTH 2048
#define MAX_FRAMEBUFFER_HEIGHT 2048

namespace vtarga
{
extern unsigned char * load_targa(const char * filename, GLenum &format, int &width, int &height);
};

using namespace vmath;

#define FRUSTUM_DEPTH 2000.0f

BEGIN_APP_DECLARATION(OITDemo)
    // Override functions from base class
    void GenBuffers();
     void ReallocateBuffers();
   virtual void Initialize(const char * title);
    virtual void Display(bool auto_redraw);
    virtual void Finalize(void);
    virtual void Reshape(int width, int height);
    virtual void Keyboard(unsigned char key, int x, int y);

    // Member variables
    float aspect;

    // Program to construct the linked list (renders the transparent objects)
    GLuint  list_build_program;

    // Head pointer image and PBO for clearing it
    GLuint  head_pointer_texture;
    GLuint  head_pointer_clear_buffer;
    // Atomic counter buffer
    GLuint  atomic_counter_buffer;
    // Linked list buffer
    GLuint  linked_list_buffer;
    GLuint  linked_list_texture;

    // Program to render the scene
    GLuint render_scene_prog;
    struct
    {
        GLint aspect;
        GLint time;
        GLint model_matrix;
        GLint view_matrix;
        GLint projection_matrix;
    } render_scene_uniforms;

    // Program to resolve 
    GLuint resolve_program;

    // Full Screen Quad
    GLuint  quad_vbo;
    GLuint  quad_vao;

    GLint current_width;
    GLint current_height;

    VBObject object;

    void DrawScene(void);
    void InitPrograms(void);
END_APP_DECLARATION()

DEFINE_APP(OITDemo, "Order Independent Transparency")

void OITDemo::GenBuffers()
{
    int texUnitOffset = 0;
    glActiveTexture(GL_TEXTURE0+texUnitOffset);

    glGenTextures(1, &head_pointer_texture);
    glGenBuffers(1, &head_pointer_clear_buffer);
    glGenBuffers(1, &atomic_counter_buffer);
    glGenBuffers(1, &linked_list_buffer);
    glGenTextures(1, &linked_list_texture);

    glGenVertexArrays(1, &quad_vao);
    glBindVertexArray(quad_vao);

    static const GLfloat quad_verts[] =
    {
        -1.0f, -1.0f,
         1.0f, -1.0f,
        -1.0f,  1.0f,
         1.0f,  1.0f,
    };

    glGenBuffers(1, &quad_vbo);
    glBindBuffer(GL_ARRAY_BUFFER, quad_vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(quad_verts), quad_verts, GL_STATIC_DRAW);
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, NULL);
    glEnableVertexAttribArray(0);
}

void OITDemo::Initialize(const char * title)
{
    render_scene_prog = -1;

    base::Initialize(title);

    InitPrograms();

    GenBuffers();

    glClearDepth(1.0f);

    object.LoadFromVBM("unit_pipe.vbm", 0, 1, 2);
}

void OITDemo::InitPrograms()
{
    // Create the program for rendering the scene from the viewer's position
    ShaderInfo scene_shaders[] =
    {
        { GL_VERTEX_SHADER, "build_lists.vs.glsl" },
        { GL_FRAGMENT_SHADER, "build_lists.fs.glsl" },
        { GL_NONE }
    };

    if (render_scene_prog != -1)
        glDeleteProgram(render_scene_prog);

    render_scene_prog = LoadShaders(scene_shaders);

    render_scene_uniforms.model_matrix = glGetUniformLocation(render_scene_prog, "model_matrix");
    render_scene_uniforms.view_matrix = glGetUniformLocation(render_scene_prog, "view_matrix");
    render_scene_uniforms.projection_matrix = glGetUniformLocation(render_scene_prog, "projection_matrix");
    render_scene_uniforms.aspect = glGetUniformLocation(render_scene_prog, "aspect");
    render_scene_uniforms.time = glGetUniformLocation(render_scene_prog, "time");

    ShaderInfo resolve_shaders[] =
    {
        { GL_VERTEX_SHADER, "resolve_lists.vs.glsl" },
        { GL_FRAGMENT_SHADER, "resolve_lists.fs.glsl" },
        { GL_NONE }
    };

    resolve_program = LoadShaders(resolve_shaders);
}

void OITDemo::ReallocateBuffers()
{
    GLuint * data;
    // Create head pointer texture
    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
    glBindTexture(GL_TEXTURE_2D, head_pointer_texture);
    glBindImageTexture(0, 0, 0, GL_FALSE, 0, GL_READ_WRITE, GL_R32UI);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_R32UI, current_width, current_height, 0, GL_RED_INTEGER, GL_UNSIGNED_INT, NULL);
    glBindTexture(GL_TEXTURE_2D, 0);

    //glBindImageTexture(0, head_pointer_texture, 0, GL_FALSE, 0, GL_READ_WRITE, GL_R32UI);
    glBindImageTexture(0, head_pointer_texture, 0, GL_TRUE, 0, GL_READ_WRITE, GL_R32UI);

    // Create buffer for clearing the head pointer texture
    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, head_pointer_clear_buffer);
    glBufferData(GL_PIXEL_UNPACK_BUFFER, current_width * current_height * sizeof(GLuint), NULL, GL_STREAM_COPY);
    data = (GLuint *)glMapBuffer(GL_PIXEL_UNPACK_BUFFER, GL_WRITE_ONLY);
    memset(data, 0x00, current_width * current_height * sizeof(GLuint));
    glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);

    // Create the atomic counter buffer
    glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, atomic_counter_buffer);
    glBufferData(GL_ATOMIC_COUNTER_BUFFER, sizeof(GLuint), NULL, GL_STREAM_COPY);

    // Create the linked list storage buffer
    glBindBuffer(GL_TEXTURE_BUFFER, linked_list_buffer);
    glBufferData(GL_TEXTURE_BUFFER, current_width * current_height * 5 * sizeof(vec4), NULL, GL_STREAM_COPY);
    glBindBuffer(GL_TEXTURE_BUFFER, 0);

    // Bind it to a texture (for use as a TBO)
    glBindTexture(GL_TEXTURE_BUFFER, linked_list_texture);
    glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32UI, linked_list_buffer);
    glBindTexture(GL_TEXTURE_BUFFER, 0);

    glBindImageTexture(1, linked_list_texture, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA32UI);
}

void OITDemo::Display(bool auto_redraw)
{
    float t;

    unsigned int current_time = GetTickCount();

    t = (float)(current_time & 0xFFFFF) / (float)0x3FFF;

    GLuint * data;

    glClearColor(1.0f, 1.0f, 1.0f, 0.0f);
    glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);
    
    glUseProgram(0);
    vmath::mat4 projection_matrix = vmath::frustum(-1.0f, 1.0f, aspect, -aspect, 1.0f, 40.f);

    glDisable(GL_DEPTH_TEST);
    glDisable(GL_CULL_FACE);
    glDepthMask(0);

    // Reset atomic counter
    glBindBufferBase(GL_ATOMIC_COUNTER_BUFFER, 0, atomic_counter_buffer);

// DRIVER CRASH OCCURS HERE
// DRIVER CRASH OCCURS HERE
// DRIVER CRASH OCCURS HERE
    data = (GLuint *)glMapBuffer(GL_ATOMIC_COUNTER_BUFFER, GL_WRITE_ONLY);
// DRIVER CRASH OCCURS HERE
// DRIVER CRASH OCCURS HERE
// DRIVER CRASH OCCURS HERE

    data[0] = 0;
    glUnmapBuffer(GL_ATOMIC_COUNTER_BUFFER);

    // Clear head-pointer image
    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, head_pointer_clear_buffer);
    glBindTexture(GL_TEXTURE_2D, head_pointer_texture);
    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, current_width, current_height, GL_RED_INTEGER, GL_UNSIGNED_INT, NULL);
    glBindTexture(GL_TEXTURE_2D, 0);

    // Bind head-pointer image for read-write
    int texUnitOffset = 0;
    glBindImageTexture(texUnitOffset+0, head_pointer_texture, 0, GL_FALSE, 0, GL_READ_WRITE, GL_R32UI);

    // Bind linked-list buffer for write
    glBindImageTexture(texUnitOffset+1, linked_list_texture, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA32UI);

    glUseProgram(render_scene_prog);

    vmath::mat4 model_matrix = vmath::translate(0.0f, 0.0f, -20.0f) *
                               vmath::rotate(t * 360.0f, 0.0f, 0.0f, 1.0f) *
                               vmath::rotate(t * 435.0f, 0.0f, 1.0f, 0.0f) *
                               vmath::rotate(t * 275.0f, 1.0f, 0.0f, 0.0f);
    vmath::mat4 view_matrix = vmath::mat4::identity();

    glUniformMatrix4fv(render_scene_uniforms.model_matrix, 1, GL_FALSE, model_matrix);
    glUniformMatrix4fv(render_scene_uniforms.view_matrix, 1, GL_FALSE, view_matrix);
    glUniformMatrix4fv(render_scene_uniforms.projection_matrix, 1, GL_FALSE, projection_matrix);

    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    object.Render(0, 8 * 8 * 8);

    glEnable(GL_BLEND);
    glDisable(GL_DEPTH_TEST);

    glBindVertexArray(quad_vao);

    // tracing a full-screen quad with the "resolve list" program
    glUseProgram(resolve_program);
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

    // Done
    base::Display();
}

void OITDemo::DrawScene(void)
{
    // Draw the object
    glBindVertexArray(quad_vao);
    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}

void OITDemo::Finalize(void)
{
    glUseProgram(0);
    glDeleteProgram(render_scene_prog);
    glDeleteBuffers(1, &quad_vbo);
    glDeleteVertexArrays(1, &quad_vao);
}

void OITDemo::Reshape(int width, int height)
{
    current_width = width;
    current_height = height;

    aspect = float(height) / float(width);
    glViewport(0, 0, current_width, current_height);

    ReallocateBuffers();
}

void OITDemo::Keyboard(unsigned char key, int x, int y)
{
    switch (key)
    {
        case 'r': InitPrograms();
            break;
        default:
            break;
    }
}

In my real application I only reallocate in chunks of 512 to speed things up. But to reproduce the problem more often, I just need to do the reallocation every time the screen changes size.

It seems to be a bug with the driver, but maybe I’m doing something illegal.

Thank you,
Jean-Simon Brochu

bump. I edited my original post with the source code. For some reason I could not post it in the reply

I’ve added a bunch of glFlush(); The crash seems to occurs when clearing the color and depth buffer when no program is bound.

I have attached a table showing the ram usage when the crash occurs in the driver. It seems to be some kind of limitation of the Quadro 600 card with the 320.86 driver.

Any clue?

Thank you
DriverCrashStats.png

I received the same error a few months ago. I reinstalled Java and it fixed the issue. In your case, if it doesn’t work, you may reinstall graphics driver, restore system settings, etc. More troubleshooting steps provided here: http://reginout.com/nflp/error-code-6.html.

Hi Jean-Simon,

A late addition to this posting, but hope you can help. I’m just relearning OpenGL after many years break. The 8th Edition of OGLPG has only Visual Studio examples with GLUT in the downloadable code, and references a Base class which seems not be included. I’m working on Mac w Mavericks and no version of GLUT (classic, freeglut) will work with OGL 4.1. I have successfully changed to GLFW for the window/event framework with much great info from http://www.tomdalling.com/blog/modern-opengl/01-getting-started-in-xcode-and-visual-cpp/ and got ch01/triangle going as a pure commandline build and code. Now working on ch03. I would like to see what’s in the VS Base class, not much I suspect and I can probably re-invent it, but would be good to check.

So, my question: can you point me to the source of the Base:: class in the OGLPG 8th Edition sample code, which you seem to have judging by your code above. (Strange place to post this question, but lots of Googling for “OGLPG Redbook examples base class” etc. didn’t turn up much).

Many thanks

Oops, cancel that. I realized the base classes are in vapp.h and vutils.h. What a nong.