Back to the Equalizer website

glAsync.h

Go to the documentation of this file.

/* Copyright (c) 2005-2006, Stefan Eilemann <eilemann@gmail.com> 
   All rights reserved. */

#ifndef _GL_ASYNC_H_
#define _GL_ASYNC_H_

#include <list>
#include <vector>
#include <GL/glx.h>
#include <X11/X.h>
#include <X11/Xlib.h>
#include <X11/XUtil.h>

#define GL_GLEXT_PROTOTYPES
#include <GL/glext.h>

#ifdef __GNUC__              // GCC 3.1 and later
#  include <ext/hash_map>
namespace Sgi = ::__gnu_cxx; 
#else                        //  other compilers
#  include <hash_map>
namespace Sgi = std;
#endif


namespace glAsync
{
    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();

    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<ContextKey, ContextInfo, HashContextKey, HashContextKey>
        ContextMap;

        ContextMap            _mappedContexts;
    
        std::list<Command*>   _commands;
        std::vector<Command*> _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

        bool _useAPPLE_fence;
        std::list<GLuint>   _pendingFences;
        std::vector<GLuint> _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_

---