Attachment 143764 Details for Bug 99781 – Improved repo of the bug.

Improved repo of the bug.

main.c (text/x-csrc), 6.90 KB, created by Hal Gentz on 2019-03-24 07:32:05 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Hal Gentz

Created: 2019-03-24 07:32:05 UTC

Size: 6.90 KB

patch

obsolete

>#include <GL/gl.h>
>#include <GL/glx.h>
>
>#include <X11/Xlib.h>
>#include <X11/Xutil.h>
>
>#include <stdio.h>
>#include <stdlib.h>
>#include <stdatomic.h>
>#include <stdbool.h>
>
>#include <pthread.h>
>#include <unistd.h>
>
>#define THREAD_NUM 16
>
>_Atomic bool should_shutdown;
>
>typedef GLXContext (*glXCreateContextAttribsARBProc)(
>    Display*,
>    GLXFBConfig,
>    GLXContext,
>    Bool, const int*
>);
>
>int ctxErrorHandler(Display *dpy, XErrorEvent *ev)
>{
>    return 0;
>}
>
>#define PANIC(ret) panic(); return ret;
>
>void panic() {
>    // Shutdown other threads early.
>    atomic_store(&should_shutdown, true);
>}
>
>void* window_thread(void* ud) {
>    bool to_shutdown = *(bool*)ud;
>    if (atomic_load(&should_shutdown) == true) {
>        return NULL;
>    }
>
>    XInitThreads();
>    Display* display = XOpenDisplay(NULL);
>
>    if (!display) {
>        PANIC(NULL);
>    }
>
>    static int visual_attribs[] = {
>        GLX_X_RENDERABLE, True,
>        GLX_X_VISUAL_TYPE, GLX_TRUE_COLOR,
>        GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
>        GLX_RENDER_TYPE, GLX_RGBA_BIT,
>        GLX_RED_SIZE, 8,
>        GLX_GREEN_SIZE, 8,
>        GLX_BLUE_SIZE, 8,
>        GLX_ALPHA_SIZE, 8,
>        GLX_DEPTH_SIZE, 24,
>        GLX_STENCIL_SIZE,8,
>        GLX_STEREO, False,
>        GLX_SAMPLE_BUFFERS_ARB, 0,
>        GLX_SAMPLES_ARB, 0,
>        None
>    };
>
>    int glx_major, glx_minor;
>
>    if (
>        !glXQueryVersion(display, &glx_major, &glx_minor)
>        || ((glx_major == 1) && (glx_minor < 3)) || (glx_major < 1)
>    ) {
>        PANIC(NULL);
>    }
>
>    const char* glxExts
>        = glXQueryExtensionsString(display, DefaultScreen(display));
>
>    int fbcount;
>    GLXFBConfig* fbc = glXChooseFBConfig(
>        display,
>        DefaultScreen(display),
>        visual_attribs,
>        &fbcount
>    );
>    if (!fbc || fbcount == 0) {
>        PANIC(NULL);
>    }
>
>    XVisualInfo* vi = glXGetVisualFromFBConfig(display, fbc[0]);
>
>    if (atomic_load(&should_shutdown) == true) {
>        XFree(fbc);
>        XCloseDisplay(display);
>        return NULL;
>    }
>
>    XSetWindowAttributes swa;
>    Colormap cmap;
>    swa.colormap = cmap = XCreateColormap(
>        display,
>        RootWindow(display, vi->screen),
>        vi->visual,
>        AllocNone
>    );
>    swa.background_pixmap = None;
>    swa.border_pixel = 0;
>    swa.event_mask = StructureNotifyMask;
>
>    if (atomic_load(&should_shutdown) == true) {
>        XFreeColormap(display, cmap);
>        XFree(fbc);
>        XCloseDisplay(display);
>        return NULL;
>    }
>
>    Window win = XCreateWindow(
>        display,
>        RootWindow(display, vi->screen),
>        0,
>        0,
>        800,
>        600,
>        0,
>        vi->depth,
>        InputOutput,
>        vi->visual,
>        CWBorderPixel | CWColormap | CWEventMask,
>        &swa
>    );
>    if (!win) {
>        PANIC(NULL);
>    }
>
>    // Without this flush, the seq lost will not always happen.
>    // I don't know why.
>    XFlush(display);
>
>    if (atomic_load(&should_shutdown) == true) {
>        XFree(vi);
>        XDestroyWindow(display, win);
>        XFreeColormap(display, cmap);
>        XFree(fbc);
>        XCloseDisplay(display);
>        return NULL;
>    }
>
>    XStoreName(display, win, "GL 3.0 Window");
>    XMapWindow(display, win);
>
>    if (atomic_load(&should_shutdown) == true) {
>        XFree(vi);
>        XDestroyWindow(display, win);
>        XFreeColormap(display, cmap);
>        XFree(fbc);
>        XCloseDisplay(display);
>        return NULL;
>    }
>
>    glXCreateContextAttribsARBProc glXCreateContextAttribsARB = 0;
>    glXCreateContextAttribsARB
>        = (glXCreateContextAttribsARBProc)glXGetProcAddressARB(
>            (const GLubyte*)"glXCreateContextAttribsARB"
>        );
>
>    GLXContext ctx = 0;
>
>    int (*oldHandler)(Display*, XErrorEvent*) = XSetErrorHandler(&ctxErrorHandler);
>
>    int context_attribs[] = {
>        GLX_CONTEXT_MAJOR_VERSION_ARB, 4,
>        GLX_CONTEXT_MINOR_VERSION_ARB, 6,
>        None
>    };
>
>    // On my computer, this does (4, 6), fails, then does (4, 5).
>    //
>    // If one _only_ does (4, 5) without doing (4, 6), the seq lost error
>    // will NOT happen.
>    while (true) {
>        if (atomic_load(&should_shutdown) == true) {
>            XFree(vi);
>            XDestroyWindow(display, win);
>            XFreeColormap(display, cmap);
>            XFree(fbc);
>            XCloseDisplay(display);
>            return NULL;
>        }
>        printf("Cr Context (%i, %i)\n", context_attribs[1], context_attribs[3]);
>        ctx = glXCreateContextAttribsARB(display, fbc[0], 0, True, context_attribs);
>
>        if (!ctx) {
>            if (context_attribs[1] == 4) {
>                if (context_attribs[3] == 0) {
>                    context_attribs[1] = 3;
>                    context_attribs[3] = 3;
>                } else {
>                    --context_attribs[3];
>                }
>            } else if (context_attribs[1] == 3) {
>                if (context_attribs[3] == 0) {
>                    PANIC(NULL);
>                } else {
>                    --context_attribs[3];
>                }
>            }
>        } else {
>            break;
>        }
>    }
>
>    XSync(display, False);
>    XSetErrorHandler( oldHandler );
>
>    if (atomic_load(&should_shutdown) == true) {
>        glXDestroyContext(display, ctx);
>        XFree(vi);
>        XDestroyWindow(display, win);
>        XFreeColormap(display, cmap);
>        XFree(fbc);
>        XCloseDisplay(display);
>        return NULL;
>    }
>
>    glXMakeCurrent(display, win, ctx);
>
>    while (true) {
>        XEvent nev;
>        // These increase chance of seq_lost, don't ask why
>        while (true) {
>            int count = XPending(display);
>            if (count == 0) {
>                break;
>            }
>
>            XNextEvent(display, &nev);
>        }
>
>        if (atomic_load(&should_shutdown) == true || to_shutdown) {
>            break;
>        }
>    }
>
>    glXMakeCurrent(display, 0, 0);
>    glXDestroyContext(display, ctx);
>
>    XFree(vi);
>    XDestroyWindow(display, win);
>    XFreeColormap(display, cmap);
>    XFree(fbc);
>    XCloseDisplay(display);
>
>    return NULL;
>}
>
>int main(int argc, char* argv[])
>{
>    pthread_t threads[THREAD_NUM];
>    bool no_shutdown = false;
>
>    // At least one thread needs to start and shutdown.
>    //
>    // Due to the sheer number of threads we spawn, this will normally happen
>    // by luck 80% of the time, but doesn't hurt to be explicit. (In fact, it
>    // helps!)
>    //
>    // Without this line, timings get thrown off when running this in gdb.
>    bool to_shutdown = true;
>    if (pthread_create(&threads[0], NULL, window_thread, &to_shutdown)) {
>        PANIC(0);
>    }
>
>    if (pthread_join(threads[0], NULL)) {
>        PANIC(0);
>    }
>
>    for (size_t i = 0; i < THREAD_NUM; ++i) {
>        if (pthread_create(&threads[i], NULL, window_thread, &no_shutdown)) {
>            PANIC(0);
>        }
>    }
>
>    sleep(1);
>    atomic_store(&should_shutdown, true);
>
>    for (size_t i = 0; i < THREAD_NUM; ++i) {
>        if (pthread_join(threads[i], NULL)) {
>            PANIC(0);
>        }
>    }
>
>    return 0;
>}

Actions: View

Attachments on bug 99781: 143763 | 143764 | 143765 | 143766 | 143767 | 144685

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.