glAsync/LICENSE0000644000076500007650000000265710465400167012130 0ustar eileeileCopyright (c) 2005-2006, Stefan Eilemann All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. The names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. glAsync/glAsync.h0000644000076500007650000002402010465400101012644 0ustar eileeile /* Copyright (c) 2005-2006, Stefan Eilemann All rights reserved. */ #ifndef _GL_ASYNC_H_ #define _GL_ASYNC_H_ #include #include #include #include #include #include #define GL_GLEXT_PROTOTYPES #include #ifdef __GNUC__ // GCC 3.1 and later # include namespace Sgi = ::__gnu_cxx; #else // other compilers # include namespace Sgi = std; #endif /** * @namespace glAsync * @brief Provides asynchronous OpenGL functions * * The glAsync functions deliver asynchronous OpenGL downloads in the spirit of * the SGIX_async extension. The asynchronous execution of certain rendering * commands can improve the overall performance of the application. * * A second thread uses a shared context to the main context for asynchronous * downloads. The application can map more than one context, but only one * context can be current at a given time. All commands are executed in the * order they are submitted. The asynchronous helper thread is only running when * at least one context is mapped. * * The functions are not thread-safe. For thread-safety and performance * multi-threaded rendering codes are advised to use one glAsync::Thread * instance per rendering thread. */ namespace glAsync { /** * Map a context to be used for asynchronous functions. * * This function creates a hidden shared context and drawable to be used the * asynchronous functions. * * @param display the connection to the X server. * @param visInfo the visual information. * @param context the GLX rendering context. * @return True on success, False otherwise. */ Bool XMapContext( Display* display, XVisualInfo* visInfo, GLXContext context ); /** * Unmap a context to be used for asynchronous functions. * * This function deregisters the context from the glAsync library and * deallocates all associated resources. For performance reasons it does not * check that all outstanding commands for this context have been * executed. The application has to explicitly wait for the commands to be * finished before calling the function. * * @param display the connection to the X server. * @param context the GLX rendering context. * @sa finish(), finishAll() */ void XUnmapContext( Display* display, GLXContext context ); /** * Attach a rendering context to the asynchronous thread. * * @param display the connection to the X server. * @param context the GLX rendering context. * @return True if successful, False otherwise. * @sa glXMakeCurrent */ Bool XMakeCurrent( Display* display, GLXContext context ); /** * Bind a named texture to a texturing target for the following asynchronous * texture operations on the target. * * @sa glBindTexture */ void bindTexture( GLenum target, GLuint texture ); /** * Specify a two-dimensional texture image. * * @return the marker associated with the asynchronous operation. * @sa glTexImage2D */ GLuint texImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels ); /** * Specify a three-dimensional texture image. * * @return the marker associated with the asynchronous operation. * @sa glTexImage3D */ GLuint texImage3D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels ); /** * Poll for the completion of an operation. * * @param marker the marker of the operation. * @return True if the operation has completed, * False if it is in progress. */ Bool poll( GLuint marker ); /** * Poll for the completion of all operations. * * @return True if the helper thread is idle, i.e. all * operations have completed, False if there are still * outstanding operations. */ Bool isIdle(); /** * Finish an operation. * * Finish blocks until the operation has completed. * * @param marker the marker of the operation. */ void finish( GLuint marker ); /** * Finish all pending operations. */ void finishAll(); /** * For multi-threaded rendering, use one instance of this class for each * rendering thread. * * Please refer to the static functions in the glAsync namespace for * documentation. */ class Thread { public: Bool XMapContext( Display* display, XVisualInfo* visInfo, GLXContext context ); void XUnmapContext( Display* display, GLXContext context ); Bool XMakeCurrent( Display* display, GLXContext context ); void bindTexture( GLenum target, GLuint texture ); GLuint texImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels ); GLuint texImage3D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels ); Bool poll( GLuint marker ); Bool isIdle(); void finish( GLuint marker ); void finishAll(); private: pthread_t _thread; GLuint _marker; GLuint _markerCompleted; struct ContextInfo { Display* display; GLXContext context; XID drawable; }; struct ContextKey { Display* display; GLXContext context; }; struct HashContextKey { size_t operator()(const ContextKey& ctx) const { return ((size_t)(ctx.context)); } bool operator()(const ContextKey& ctx1,const ContextKey& ctx2) const { return ( ctx1.display == ctx2.display && ctx1.context == ctx2.context ); } }; struct Command { public: enum ID { ID_XMAKECURRENT, ID_BINDTEXTURE, ID_TEXIMAGE2D, ID_TEXIMAGE3D, ID_ALL }; Command( ID commandID ) : id(commandID) {} ID id; GLuint marker; union { struct { ContextKey key; } XMakeCurrent; struct { GLenum target; GLuint texture; } bindTexture; struct { GLuint texture; GLenum target; GLint level; GLint internalformat; GLsizei width; GLsizei height; GLint border; GLenum format; GLenum type; const GLvoid *pixels; } texImage2D; struct { GLuint texture; GLenum target; GLint level; GLint internalformat; GLsizei width; GLsizei height; GLsizei depth; GLint border; GLenum format; GLenum type; const GLvoid *pixels; } texImage3D; } data; }; typedef Sgi::hash_map ContextMap; ContextMap _mappedContexts; std::list _commands; std::vector _commandCache; class Sync { public: Sync() { pthread_mutex_init( &mutex, NULL ); pthread_cond_init( &cond, NULL ); } ~Sync() { pthread_cond_destroy( &cond ); pthread_mutex_destroy( &mutex ); } pthread_mutex_t mutex; pthread_cond_t cond; }; Sync _commandSync, _markerSync; #ifdef GL_APPLE_fence /** GL_APPLE_fence supported by current context. */ bool _useAPPLE_fence; /** The list of outstanding commands. */ std::list _pendingFences; /** Reusable fences. */ std::vector _fenceCache; #endif Command* _newCommand( Command::ID commandID ); // helper thread static void* _childEntry( void* arg ); void* _child(); void _initChild(); void _syncCommand( const uint currentMarker ); #ifdef GL_APPLE_fence GLuint _newFence(); void _finishAllFences(); #endif void _XMakeCurrent( Command* command ); void _bindTexture( Command* command ); void _texImage2D( Command* command ); void _texImage3D( Command* command ); void (glAsync::Thread::*_cmdHandler[Command::ID_ALL])( Command* command ); }; } #endif // _GL_ASYNC_H_ glAsync/glAsync.cpp0000644000076500007650000004041310465401577013225 0ustar eileeile /* Copyright (c) 2005-2006, Stefan Eilemann All rights reserved. */ // $Revision: 12 $ // TODO NV_fence support // If your OpenGL implementation supports GL_ARB_async, you will most likely // be better of this. #include "glAsync.h" #include #include using namespace glAsync; using namespace std; /** The Thread instance used by the glAsync functions. */ static glAsync::Thread _thread; // OpenGL extensions static bool isExtensionSupported(const char *extension); //=========================================================================== // Implementation - Application thread //=========================================================================== //--------------------------------------------------------------------------- // Context management //--------------------------------------------------------------------------- Bool glAsync::XMapContext( Display* display, XVisualInfo* visInfo, GLXContext context ) { return _thread.XMapContext( display, visInfo, context ); } Bool Thread::XMapContext( Display* display, XVisualInfo* visInfo, GLXContext context ) { const char* displayName = DisplayString( display ); Display* display2 = XOpenDisplay( displayName ); if( display2 == NULL ) { cerr << "Can't open display: " << XDisplayName( displayName ) << endl; return False; } const Bool direct = glXIsDirect( display, context ); GLXContext context2 = glXCreateContext( display2, visInfo, context, direct); if( context2 == NULL ) { XCloseDisplay( display2 ); cerr << "Can't create context" << endl; return False; } int screen2 = DefaultScreen( display2 ); XID drawable2 = XCreateSimpleWindow( display2, DefaultRootWindow( display2 ), 0, 0, DisplayWidth( display2, screen2 ), DisplayHeight( display2, screen2 ), 0, 0, 0 ); if( !drawable2 ) { XCloseDisplay( display2 ); cerr << "Can't create drawable" << endl; return False; } if( _mappedContexts.empty( )) { _marker = 0; #ifdef GL_APPLE_fence _useAPPLE_fence = false; #endif pthread_attr_t attributes; pthread_attr_init( &attributes ); pthread_attr_setscope( &attributes, PTHREAD_SCOPE_SYSTEM ); const int error = pthread_create( &_thread, &attributes, _childEntry, &_thread ); if( error ) { XCloseDisplay( display2 ); cerr << "Error creating pthread: " << strerror( error ) << endl; return False; } } ContextKey key = { display, context }; ContextInfo info = { display2, context2, drawable2 }; _mappedContexts[key] = info; return True; } void glAsync::XUnmapContext( Display* display, GLXContext context ) { _thread.XUnmapContext( display, context ); } void Thread::XUnmapContext( Display* display, GLXContext context ) { ContextKey key = { display, context }; ContextMap::iterator iter = _mappedContexts.find(key); if( iter == _mappedContexts.end( )) return; _mappedContexts.erase( iter ); ContextInfo& info = (*iter).second; XCloseDisplay( info.display ); if( _mappedContexts.empty( )) // stop thread & cleanup { // stop thread pthread_mutex_lock( &_commandSync.mutex ); _commands.push_back( NULL ); pthread_cond_signal( &_commandSync.cond ); pthread_mutex_unlock( &_commandSync.mutex ); pthread_join( _thread, NULL ); // cleanup const size_t nCommands = _commandCache.size(); for( size_t i=0; iid = commandID; command->marker = ++_marker; // in reality _marker never overflows, therefore don't check it by default #ifdef GLASYNC_CHECK_OVERFLOW if( _marker > 1 ) return command; // overflow of marker occured finish( _marker - 1 ); _marker = 1; command->marker = 1; #endif return command; } Bool glAsync::XMakeCurrent( Display* display, GLXContext context ) { return _thread.XMakeCurrent( display, context ); } Bool Thread::XMakeCurrent( Display* display, GLXContext context ) { ContextKey key = { display, context }; if( _mappedContexts.find( key ) == _mappedContexts.end() ) return False; pthread_mutex_lock( &_commandSync.mutex ); Command* command = _newCommand( Command::ID_XMAKECURRENT ); command->data.XMakeCurrent.key = key; _commands.push_back( command ); pthread_cond_signal( &_commandSync.cond ); pthread_mutex_unlock( &_commandSync.mutex ); return True; } //--------------------------------------------------------------------------- // state queries //--------------------------------------------------------------------------- Bool glAsync::poll( GLuint marker ) { return _thread.poll( marker ); } Bool Thread::poll( GLuint marker ) { if( _markerCompleted >= marker ) return true; return false; } Bool glAsync::isIdle() { return _thread.isIdle(); } Bool Thread::isIdle() { return ( _markerCompleted >= _marker ); } void glAsync::finish( GLuint marker ) { _thread.finish( marker ); } void Thread::finish( GLuint marker ) { if( _markerCompleted >= marker ) return; pthread_mutex_lock( &_markerSync.mutex ); while( true ) { if( _markerCompleted >= marker ) { pthread_mutex_unlock( &_markerSync.mutex ); return; } pthread_cond_wait( &_markerSync.cond, &_markerSync.mutex ); } } void glAsync::finishAll() { _thread.finishAll(); } void Thread::finishAll() { finish( _marker ); } //--------------------------------------------------------------------------- // texture downloads //--------------------------------------------------------------------------- void glAsync::bindTexture( GLenum target, GLuint texture ) { _thread.bindTexture( target, texture ); } void Thread::bindTexture( GLenum target, GLuint texture ) { pthread_mutex_lock( &_commandSync.mutex ); Command* command = _newCommand( Command::ID_BINDTEXTURE ); command->data.bindTexture.target = target; command->data.bindTexture.texture = texture; _commands.push_back( command ); pthread_cond_signal( &_commandSync.cond ); pthread_mutex_unlock( &_commandSync.mutex ); } GLuint glAsync::texImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels ) { return _thread.texImage2D( target, level, internalformat, width, height, border, format, type, pixels ); } GLuint Thread::texImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels ) { pthread_mutex_lock( &_commandSync.mutex ); Command* command = _newCommand( Command::ID_TEXIMAGE2D ); command->data.texImage2D.target = target; command->data.texImage2D.level = level; command->data.texImage2D.internalformat = internalformat; command->data.texImage2D.width = width; command->data.texImage2D.height = height; command->data.texImage2D.border = border; command->data.texImage2D.format = format; command->data.texImage2D.type = type; command->data.texImage2D.pixels = pixels; _commands.push_back( command ); pthread_cond_signal( &_commandSync.cond ); pthread_mutex_unlock( &_commandSync.mutex ); return command->marker; } GLuint glAsync::texImage3D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels ) { return _thread.texImage3D( target, level, internalformat, width, height, depth, border, format, type, pixels ); } GLuint Thread::texImage3D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels ) { pthread_mutex_lock( &_commandSync.mutex ); Command* command = _newCommand( Command::ID_TEXIMAGE3D ); command->data.texImage3D.target = target; command->data.texImage3D.level = level; command->data.texImage3D.internalformat = internalformat; command->data.texImage3D.width = width; command->data.texImage3D.height = height; command->data.texImage3D.depth = depth; command->data.texImage3D.border = border; command->data.texImage3D.format = format; command->data.texImage3D.type = type; command->data.texImage3D.pixels = pixels; _commands.push_back( command ); pthread_cond_signal( &_commandSync.cond ); pthread_mutex_unlock( &_commandSync.mutex ); return command->marker; } //=========================================================================== // Implementation - Helper Thread //=========================================================================== void Thread::_initChild() { _cmdHandler[Command::ID_XMAKECURRENT] = &glAsync::Thread::_XMakeCurrent; _cmdHandler[Command::ID_BINDTEXTURE] = &glAsync::Thread::_bindTexture; _cmdHandler[Command::ID_TEXIMAGE2D] = &glAsync::Thread::_texImage2D; _cmdHandler[Command::ID_TEXIMAGE3D] = &glAsync::Thread::_texImage3D; } void* Thread::_childEntry( void* arg ) { return ((Thread*)(arg))->_child(); } void* Thread::_child() { _initChild(); // get first command pthread_mutex_lock( &_commandSync.mutex ); while( _commands.empty() ) pthread_cond_wait( &_commandSync.cond, &_commandSync.mutex ); Command* command = _commands.front(); _commands.pop_front(); pthread_mutex_unlock( &_commandSync.mutex ); while( command ) { // execute command (this->*_cmdHandler[command->id])(command); _syncCommand( command->marker ); // recycle command and retrieve next command pthread_mutex_lock( &_commandSync.mutex ); _commandCache.push_back( command ); while( _commands.empty() ) pthread_cond_wait( &_commandSync.cond, &_commandSync.mutex ); command = _commands.front(); _commands.pop_front(); pthread_mutex_unlock( &_commandSync.mutex ); } assert( _mappedContexts.empty( )); return NULL; } // C&P from opengl.org bool isExtensionSupported(const char *extension) { /* Extension names should not have spaces. */ GLubyte *where = (GLubyte *)strchr(extension, ' '); if (where || *extension == '\0') return false; const GLubyte *extensions = glGetString(GL_EXTENSIONS); /* It takes a bit of care to be fool-proof about parsing the OpenGL * extensions string. Don't be fooled by sub-strings, etc. */ const GLubyte *start = extensions; while( true ) { where = (GLubyte *) strstr((const char *) start, extension); if (!where) break; GLubyte *terminator = where + strlen(extension); if (where == start || *(where - 1) == ' ') if (*terminator == ' ' || *terminator == '\0') return true; start = terminator; } return false; } #ifdef GL_APPLE_fence GLuint Thread::_newFence() { if( _fenceCache.empty( )) { GLuint fences[10]; glGenFencesAPPLE( 10, fences ); for( int i=1; i<10; ++i ) _fenceCache.push_back( fences[i] ); return fences[0]; } const int last = _fenceCache.size() - 1; GLuint fence = _fenceCache[last]; _fenceCache.resize( last, 0 ); return fence; } void Thread::_finishAllFences() { for( list::iterator iter = _pendingFences.begin(); iter != _pendingFences.end(); ++iter ) { glFinishFenceAPPLE( *iter ); _fenceCache.push_back( *iter ); } _pendingFences.clear(); } #endif void Thread::_syncCommand( const uint currentMarker ) { GLuint markerCompleted; #ifdef GL_APPLE_fence if( _useAPPLE_fence ) { // mark current command GLuint fence = _newFence(); glSetFenceAPPLE( fence ); _pendingFences.push_back( fence ); // see what is finished markerCompleted = currentMarker - _pendingFences.size(); for( list::iterator iter = _pendingFences.begin(); iter != _pendingFences.end(); ) { if( !glTestFenceAPPLE( *iter )) break; _fenceCache.push_back( *iter ); ++iter; // We are removing the front item next! ++markerCompleted; _pendingFences.pop_front(); } // Finish everything if no other pending commands // TODO: spin for command or fence completion before hard finish if( _commands.empty() && markerCompleted != currentMarker ) { _finishAllFences(); markerCompleted = currentMarker; } else if( _markerCompleted == markerCompleted ) return; } else #endif { if( !_commands.empty( )) // If the app completely satures this thread, we never signal // completion. Should introduce command to force a finish return; markerCompleted = currentMarker; glFinish(); } pthread_mutex_lock( &_markerSync.mutex ); _markerCompleted = markerCompleted; pthread_cond_signal( &_markerSync.cond ); pthread_mutex_unlock( &_markerSync.mutex ); } void Thread::_XMakeCurrent( Command* command ) { ContextInfo& info = _mappedContexts[command->data.XMakeCurrent.key]; glXMakeCurrent( info.display, info.drawable, info.context ); #ifdef GL_APPLE_fence if( _useAPPLE_fence && !_pendingFences.empty( )) { _finishAllFences(); pthread_mutex_lock( &_markerSync.mutex ); _markerCompleted = command->marker-1; pthread_cond_signal( &_markerSync.cond ); pthread_mutex_unlock( &_markerSync.mutex ); glDeleteFencesAPPLE( _fenceCache.size(), &_fenceCache[0] ); _fenceCache.clear(); } _useAPPLE_fence = isExtensionSupported( "GL_APPLE_fence" ); #endif } void Thread::_bindTexture( Command* command ) { glBindTexture( command->data.bindTexture.target, command->data.bindTexture.texture ); } void Thread::_texImage2D( Command* command ) { glTexImage2D( command->data.texImage2D.target, command->data.texImage2D.level, command->data.texImage2D.internalformat, command->data.texImage2D.width, command->data.texImage2D.height, command->data.texImage2D.border, command->data.texImage2D.format, command->data.texImage2D.type, command->data.texImage2D.pixels ); } void Thread::_texImage3D( Command* command ) { glTexImage3D( command->data.texImage3D.target, command->data.texImage3D.level, command->data.texImage3D.internalformat, command->data.texImage3D.width, command->data.texImage3D.height, command->data.texImage3D.depth, command->data.texImage3D.border, command->data.texImage3D.format, command->data.texImage3D.type, command->data.texImage3D.pixels ); } glAsync/test.cpp0000644000076500007650000001643510432633156012605 0ustar eileeile// // A very simple test application illustrating the use of the glAsync // functions. This test case may not deliver any speedup due to its simplicity, // instead try the performance on your application. I would appreciate feedback // about your experiences with glAsync. // // Compile with: // g++ -o test -I/usr/X11R6/include test.cpp glAsync.cpp -L/usr/X11R6/lib -lGL -lX11 #include "glAsync.h" #include #include #include #include #include #include #include #define TEXTURE_SIZE (1024) #define TD( base, time ) \ (((double)(time.tv_sec) - (double)(base.tv_sec)) * 1000. + \ ((double)(time.tv_usec) - (double)(base.tv_usec)) / 1000. ) static Bool WaitForNotify(Display *, XEvent *e, char *arg) { return (e->type == MapNotify) && (e->xmap.window == (::Window)arg); } XID createWindow( Display* display, int size[4] ) { int screen = DefaultScreen( display ); XID parent = RootWindow( display, screen ); if( size[2] == -1 ) size[2] = DisplayWidth( display, screen ) - size[0]; if( size[3] == -1 ) size[3] = DisplayHeight( display, screen ) - size[1]; int attributes[100], *aptr=attributes; *aptr++ = GLX_RGBA; *aptr++ = 1; *aptr++ = GLX_RED_SIZE; *aptr++ = 8; //*aptr++ = GLX_ALPHA_SIZE; //*aptr++ = 1; *aptr++ = GLX_DEPTH_SIZE; *aptr++ = 1; *aptr++ = GLX_STENCIL_SIZE; *aptr++ = 8; *aptr++ = GLX_DOUBLEBUFFER; *aptr = None; XVisualInfo *visInfo = glXChooseVisual( display, screen, attributes ); if ( !visInfo ) fprintf( stderr, "Error: can't allocate GLX-resources\n" ); XSetWindowAttributes wa; wa.colormap = XCreateColormap( display, parent, visInfo->visual, AllocNone ); wa.background_pixmap = None; wa.border_pixel = 0; wa.event_mask = StructureNotifyMask | VisibilityChangeMask; wa.override_redirect = True; XID drawable = XCreateWindow( display, parent, size[0], size[1], size[2], size[3], 0, visInfo->depth, InputOutput, visInfo->visual, CWBackPixmap|CWBorderPixel|CWEventMask|CWColormap, &wa ); XMapWindow( display, drawable ); // wait for MapNotify event XEvent event; XIfEvent( display, &event, WaitForNotify, (XPointer)drawable ); XFlush( display ); GLXContext context = NULL; while ( !context ) context = glXCreateContext( display, visInfo, NULL, True ); glXMakeCurrent( display, drawable, context ); // get window size glGetIntegerv(GL_VIEWPORT, size); // init glAsync library bool ret = glAsync::XMapContext( display, visInfo, context ); assert( ret ); ret = glAsync::XMakeCurrent( display, context ); assert( ret ); return drawable; } void draw() { int nQuads = 100; while( nQuads-- ) { glBegin( GL_QUADS ); glTexCoord2f( 0., 0. ); glVertex3f( .1, .1, -.5 ); glTexCoord2f( 1., 0. ); glVertex3f( .9, .1, -.5 ); glTexCoord2f( 1., 1. ); glVertex3f( .9, .9, -.5 ); glTexCoord2f( 0., 1. ); glVertex3f( .1, .9, -.5 ); glEnd(); glFlush(); int x; for( int i=0; i<100000; ++i ) x = i*i; } } int main( int argc, char *argv[] ) { int windowSize[] = { 0, 0, -1, -1 }; Display *display = XOpenDisplay( NULL ); XID drawable = createWindow( display, windowSize ); // memory buffer for textures char *buffer[2]; const size_t size = TEXTURE_SIZE * TEXTURE_SIZE * 4; buffer[0] = (char *)malloc( size ); buffer[1] = (char *)malloc( size ); memset( buffer[0], 64, size ); memset( buffer[1], 192, size ); fprintf( stderr, "\n OpenGL renderer string: %s\n", glGetString( GL_RENDERER ) ); fprintf( stderr, " Window Geometry: %dx%d+%d+%d\n\n", windowSize[2], windowSize[3], windowSize[0], windowSize[1] ); glMatrixMode( GL_PROJECTION ); glLoadIdentity(); glOrtho( 0, 1, 0, 1, 0.1, 1 ); glMatrixMode( GL_MODELVIEW ); glLoadIdentity(); glClearColor( 1, 0, 0, 1 ); glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); glXSwapBuffers( display, drawable ); GLuint textures[2]; GLuint markers[2] = { 0, 0 }; int which = 0; glGenTextures( 2, textures ); glEnable( GL_TEXTURE_2D ); glDisable( GL_LIGHTING ); glDisable( GL_DEPTH_TEST ); glColor3f( 0, 1, 0 ); glBindTexture( GL_TEXTURE_2D, textures[0] ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); glBindTexture( GL_TEXTURE_2D, textures[1] ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); struct timeval res; struct timeval base; size_t nFrames = 0; gettimeofday(&base,0); gettimeofday(&res,0); // synchronous texture download pass while( TD( base, res ) < 10000. ) { which = !which; glBindTexture( GL_TEXTURE_2D, textures[which] ); glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA8, TEXTURE_SIZE, TEXTURE_SIZE, 0, GL_RGBA, GL_UNSIGNED_BYTE, buffer[which] ); glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); draw(); glXSwapBuffers( display, drawable ); gettimeofday(&res,0); nFrames++; } const float syncFPS = nFrames * 1000. / TD( base, res ); nFrames = 0; gettimeofday(&base,0); gettimeofday(&res,0); // asynchronous texture download glAsync::bindTexture( GL_TEXTURE_2D, textures[which] ); markers[which] = glAsync::texImage2D( GL_TEXTURE_2D, 0, GL_RGBA8, TEXTURE_SIZE, TEXTURE_SIZE, 0, GL_RGBA, GL_UNSIGNED_BYTE, buffer[which] ); while( TD( base, res ) < 10000. ) { which = !which; glAsync::bindTexture( GL_TEXTURE_2D, textures[which] ); markers[which] = glAsync::texImage2D( GL_TEXTURE_2D, 0, GL_RGBA8, TEXTURE_SIZE, TEXTURE_SIZE, 0, GL_RGBA, GL_UNSIGNED_BYTE, buffer[which] ); glAsync::finish( markers[!which] ); glBindTexture( GL_TEXTURE_2D, textures[!which] ); glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); draw(); glXSwapBuffers( display, drawable ); gettimeofday(&res,0); nFrames++; } // since we have one texture download pending, draw an additional frame // to get a fair comparison to the synchronous case glAsync::finish( markers[which] ); glBindTexture( GL_TEXTURE_2D, textures[which] ); glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); draw(); glXSwapBuffers( display, drawable ); gettimeofday(&res,0); nFrames++; const float asyncFPS = nFrames * 1000. / TD( base, res ); fprintf( stderr, " synchronous %f fps, async %f fps, speedup %d%%\n", syncFPS, asyncFPS, (int)(asyncFPS/syncFPS * 100 - 100) ); exit( EXIT_SUCCESS ); } glAsync/CHANGELOG0000644000076500007650000000114210465402732012321 0ustar eileeile Version 0.12 Change email address in the LICENSE file, tweak documentation, auto-generate CHANGELOG from subversion Version 0.11 Added correct finish semantics, added support for GL_APPLE_fence extension Version 0.10 some code cleanup and optimisations Version 0.9 remove google analytics Version 0.8 remove Id from glAsync.h Version 0.7 added custom html header Version 0.6 enable revision on glAsync.cpp Version 0.5 add revision to glAsync.cpp Version 0.4 refactored to allow multithreaded use Version 0.3 doc update Version 0.2 first version of OpenGL async library Version 0.1 stub repository