Attachment 48588 Details for Bug 38800 – My test program to demonstrate the performance issues

My test program to demonstrate the performance issues

swapbufferstest.c (text/x-csrc), 10.04 KB, created by Simon Farnsworth on 2011-06-30 03:48:09 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Simon Farnsworth

Created: 2011-06-30 03:48:09 UTC

Size: 10.04 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>
>
>/* Not yet in glxew */
>typedef struct {
>    int type;
>    unsigned long serial;	/* # of last request processed by server */
>    Bool send_event;		/* true if this came from a SendEvent request */
>    Display *display;		/* Display the event was read from */
>    GLXDrawable drawable;	/* drawable on which event was requested in event mask */
>    int event_type;
>    int64_t ust;
>    int64_t msc;
>    int64_t sbc;
>} GLXBufferSwapComplete;
>
>union EventUnion
>{
>    XEvent xev;
>    GLXBufferSwapComplete bsc;
>};
>
>/* 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;
>    double maximum_frame_time = 0;
>    int64_t maximum_delta = 0;
>    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 )
>    {
>        union EventUnion event;
>        XNextEvent( display, &event.xev );
>        if( event.xev.type == (glx_event_base + GLX_INTEL_swap_event) )
>        {
>            int64_t delta_frames = event.bsc.msc - msc;
>            double now;
>            double frame_time;
>
>            msc = event.bsc.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();
>            frame_time = (now - last_frame_time) / delta_frames;
>            if( delta_frames > maximum_delta )
>            {
>                maximum_delta = delta_frames;
>            }
>            if( frame_time > maximum_frame_time )
>            {
>                maximum_frame_time = frame_time;
>            }
>            last_frame_time = now;
>            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( "Longest frame time %lf ms\n", maximum_frame_time * 1000 );
>                printf( "Biggest delta %ld frames, averaging %lf frames per swap\n", (long)maximum_delta, 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.