Attachment 48657 Details for Bug 38800 – An adapted test program, showing that it's not the wait for the swap events that slows me down

An adapted test program, showing that it's not the wait for the swap events that slows me down

swapbuffersnowaittest.c (text/x-csrc), 8.60 KB, created by Simon Farnsworth on 2011-07-01 09:54:25 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Simon Farnsworth

Created: 2011-07-01 09:54:25 UTC

Size: 8.60 KB

patch

obsolete

>#include <X11/Xlib.h>
>#include <GL/glew.h>
>#include <GL/glxew.h>
>
>#include <sys/time.h>
>
>#include <stdlib.h>
>#include <stdio.h>
>#include <assert.h>
>
>/* Shared state variables */
>static Display *display;
>static int screen;
>static int glx_event_base;
>static GLXWindow glx_render_window;
>
>/* Functions */
>
>static void dump_gl_errors( unsigned int line )
>{
>    GLenum error;
>    error = glGetError();
>    if( error == 0 )
>    {
>        return;
>    }
>    else
>    {
>        while( error != 0 )
>        {
>            fprintf( stderr, "GL Error 0x%x at line %d\n", error, line );
>            error = glGetError();
>        }
>        exit( 1 );
>    }
>}
>#define check_gl_errors() dump_gl_errors( __LINE__ )
>
>static void draw( double red, double green, double blue )
>{
>    check_gl_errors();
>    glClear( GL_COLOR_BUFFER_BIT );
>    check_gl_errors();
>    glColor4d( red, green, blue, 1.0 );
>    check_gl_errors();
>    glRectd( 0.1, 0.1, 0.8, 0.8 );
>    check_gl_errors();
>    glFinish();
>    check_gl_errors();
>}
>
>typedef Bool ( * PFNGLXGETSYNCVALUESOMLPROC) (Display *dpy, GLXDrawable drawable, int64_t *ust, int64_t *msc, int64_t *sbc);
>PFNGLXGETSYNCVALUESOMLPROC glXGetSyncValuesOML;
>typedef Bool ( * PFNGLXWAITFORSBCOMLPROC) (Display *dpy, GLXDrawable drawable, int64_t target_sbc, int64_t *ust, int64_t *msc, int64_t *sbc);
>PFNGLXWAITFORSBCOMLPROC glXWaitForSbcOML;
>typedef int64_t ( * PFNGLXSWAPBUFFERSMSCOMLPROC) (Display *dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder);
>PFNGLXSWAPBUFFERSMSCOMLPROC glXSwapBuffersMscOML;
>
>static void init_gl( void )
>{
>    int glx_error_base;
>    int major;
>    int minor;
>    GLenum err;
>    const int attrib_list[] = { GLX_DOUBLEBUFFER, True,
>                                GLX_X_VISUAL_TYPE, GLX_TRUE_COLOR,
>                                GLX_RED_SIZE, 8,
>                                GLX_GREEN_SIZE, 8,
>                                GLX_BLUE_SIZE, 8,
>                                GLX_ALPHA_SIZE, 0,
>                                GLX_DEPTH_SIZE, 0,
>                                GLX_STENCIL_SIZE, 0,
>                                GLX_RENDER_TYPE, GLX_RGBA_BIT,
>                                GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
>                                GLX_X_RENDERABLE, True,
>                                None };
>    int num_glx_fb_configs;
>    GLXFBConfig *all_glx_fb_configs;
>    GLXFBConfig glx_fb_config;
>    XVisualInfo *visual_info;
>    Colormap colormap;
>    XSetWindowAttributes attrs;
>    Window render_window;
>    GLXContext gl_context;
>    Screen *screen_ptr;
>
>    glXQueryExtension( display, &glx_error_base, &glx_event_base );
>
>    if( !glXQueryVersion( display, &major, &minor ) )
>    {
>        fprintf( stderr, "No GLX?!?\n" );
>    }
>    if( major != 1 || minor < 3 )
>    {
>        fprintf( stderr, "Bad GLX version %d.%d!\n", major, minor );
>        exit( EXIT_FAILURE );
>    }
>
>    glXChooseFBConfig = (GLXFBConfig*(*)(Display *, int, const int *, int *))glXGetProcAddressARB((GLubyte*)"glXChooseFBConfig");
>    glXGetVisualFromFBConfig = (XVisualInfo*(*)(Display *, GLXFBConfig ))glXGetProcAddressARB((GLubyte*)"glXGetVisualFromFBConfig");
>    glXCreateNewContext = (GLXContext(*)(Display *, GLXFBConfig, int, GLXContext, Bool))glXGetProcAddressARB((GLubyte*)"glXCreateNewContext");
>    glXMakeContextCurrent = (Bool(*)(Display *, GLXDrawable, GLXDrawable, GLXContext))glXGetProcAddressARB((GLubyte*)"glXMakeContextCurrent");
>    glXCreateWindow = (GLXWindow(*)(Display *, GLXFBConfig, Window, const int *))glXGetProcAddressARB((GLubyte*)"glXCreateWindow");
>
>    all_glx_fb_configs = glXChooseFBConfig( display, screen, attrib_list, &num_glx_fb_configs );
>
>    if( !all_glx_fb_configs )
>    {
>        fprintf( stderr, "No GLX FB config!\n" );
>        exit( EXIT_FAILURE );
>    }
>
>    glx_fb_config = all_glx_fb_configs[0];
>    XFree( all_glx_fb_configs );
>
>    visual_info = glXGetVisualFromFBConfig( display, glx_fb_config );
>    colormap = XCreateColormap( display, RootWindow( display, screen ), visual_info->visual, AllocNone );
>
>    attrs.colormap = colormap;
>    attrs.border_pixel = 0;
>
>    screen_ptr = DefaultScreenOfDisplay( display );
>    printf( "Screen is %dx%d\n", WidthOfScreen( screen_ptr ), HeightOfScreen( screen_ptr ) );
>    render_window = XCreateWindow( display, RootWindow( display, screen ),
>                                          0, 0,
>                                          WidthOfScreen( screen_ptr ), HeightOfScreen( screen_ptr ),
>                                          0, visual_info->depth, InputOutput, visual_info->visual,
>                                          CWColormap, &attrs );
>    glx_render_window = glXCreateWindow( display, glx_fb_config, render_window, NULL );
>
>    XMapWindow( display, render_window );
>
>    gl_context = glXCreateNewContext( display, glx_fb_config, GLX_RGBA_TYPE, NULL, GL_TRUE );
>
>    glXMakeContextCurrent( display, glx_render_window, glx_render_window, gl_context );
>
>    err = glewInit();
>    if( err != GLEW_OK )
>    {
>        fprintf( stderr, "GLEW init: %s\n", glewGetErrorString( err ) );
>        exit( EXIT_FAILURE );
>    }
>
>    if( !GLXEW_VERSION_1_3 )
>    {
>        fprintf( stderr, "GLXEW failure\n" );
>        exit( EXIT_FAILURE );
>    }
>
>    if( !GLEW_VERSION_2_0 )
>    {
>        fprintf( stderr, "OpenGL version too old - need 2.0.\n" );
>        exit( EXIT_FAILURE );
>    }
>
>    /* OML_sync_control */
>    glXGetSyncValuesOML = (PFNGLXGETSYNCVALUESOMLPROC)glXGetProcAddress( (const GLubyte *)"glXGetSyncValuesOML" );
>    glXWaitForSbcOML = (PFNGLXWAITFORSBCOMLPROC)glXGetProcAddress( (const GLubyte *)"glXWaitForSbcOML" );
>    glXSwapBuffersMscOML = (PFNGLXSWAPBUFFERSMSCOMLPROC)glXGetProcAddress( (const GLubyte *)"glXSwapBuffersMscOML" );
>    if( glXGetSyncValuesOML == NULL ||
>        glXWaitForSbcOML == NULL ||
>        glXSwapBuffersMscOML == NULL )
>    {
>        fprintf( stderr, "GLX_OML_sync_control is required.\n" );
>        exit(1);
>    }
>
>    if( !GLXEW_INTEL_swap_event )
>    {
>        fprintf( stderr, "GLX_INTEL_swap_event is required.\n" );
>        exit( EXIT_FAILURE );
>    }
>
>    glXSelectEvent( display, glx_render_window, GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK );
>    glClearColor( 0.0, 0.0, 0.0, 1.0 );
>    glShadeModel( GL_FLAT );
>
>    glMatrixMode( GL_PROJECTION );
>    glLoadIdentity();
>    /* left, right, bottom, top - gets 0,0 at top, left */
>    gluOrtho2D( 0, 1, 1, 0 );
>
>    glMatrixMode( GL_MODELVIEW );
>    glLoadIdentity();
>
>    check_gl_errors();
>}
>
>static double timeOfDay( void )
>{
>    struct timeval tod;
>    gettimeofday( &tod, NULL );
>    return tod.tv_sec + tod.tv_usec / 1000000.0;
>}
>
>int main( int argc, char *argv[] )
>{
>    double last_frame_time;
>    double start_time;
>    int64_t ust;
>    int64_t msc;
>    int64_t sbc;
>    int64_t initial_msc;
>    int64_t initial_sbc;
>
>    display = XOpenDisplay( NULL );
>    screen = DefaultScreen( display );
>
>    init_gl();
>    check_gl_errors();
>
>    glXGetSyncValuesOML( display,
>                         glx_render_window,
>                         &ust,
>                         &msc,
>                         &sbc );
>    initial_msc = msc;
>    initial_sbc = sbc;
>
>    draw( 1.0, 0.0, 0.0 );
>    check_gl_errors();
>    glXSwapBuffersMscOML( display,
>                          glx_render_window,
>                          msc + 1,
>                          0,
>                          0 );
>    check_gl_errors();
>
>    start_time = last_frame_time = timeOfDay();
>    while( 1 )
>    {
>        double now;
>
>        ++msc;
>        if( (msc % 2) == 0 )
>        {
>            draw( 0.0, 0.0, 1.0 );
>        }
>        else
>        {
>            draw( 1.0, 0.0, 0.0 );
>        }
>        check_gl_errors();
>
>        glXSwapBuffersMscOML( display,
>                              glx_render_window,
>                              msc + 1,
>                              0,
>                              0 );
>        check_gl_errors();
>
>        now = timeOfDay();
>        if( (now - start_time) > 2 )
>        {
>            double average_swap_interval;
>            double frames_per_swap;
>            long frames;
>            long swaps;
>
>            glXGetSyncValuesOML( display,
>                                 glx_render_window,
>                                 &ust,
>                                 &msc,
>                                 &sbc );
>            frames = msc - initial_msc;
>            swaps = sbc - initial_sbc;
>            average_swap_interval = (now - start_time) / (double)swaps;
>            frames_per_swap = (double)frames / (double)swaps;
>
>            printf( "Averaging %lf frames per swap\n", frames_per_swap );
>            printf( "Average swap interval %lf ms\n", average_swap_interval * 1000 );
>            printf( "%ld frames, %ld swaps\n", frames, swaps );
>            exit( EXIT_SUCCESS );
>        }
>    }
>}

Actions: View

Attachments on bug 38800: 48588 | 48589 | 48590 | 48657 | 48768 | 48883 | 48888 | 48892 | 48897 | 48898

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.