1GL Dispatch 2=========== 3 4Several factors combine to make efficient dispatch of OpenGL functions 5fairly complicated. This document attempts to explain some of the issues 6and introduce the reader to Mesa's implementation. Readers already 7familiar with the issues around GL dispatch can safely skip ahead to the 8:ref:`overview of Mesa's implementation <overview>`. 9 101. Complexity of GL Dispatch 11---------------------------- 12 13Every GL application has at least one object called a GL *context*. This 14object, which is an implicit parameter to every GL function, stores all 15of the GL related state for the application. Every texture, every buffer 16object, every enable, and much, much more is stored in the context. 17Since an application can have more than one context, the context to be 18used is selected by a window-system dependent function such as 19``glXMakeContextCurrent``. 20 21In environments that implement OpenGL with X-Windows using GLX, every GL 22function, including the pointers returned by ``glXGetProcAddress``, are 23*context independent*. This means that no matter what context is 24currently active, the same ``glVertex3fv`` function is used. 25 26This creates the first bit of dispatch complexity. An application can 27have two GL contexts. One context is a direct rendering context where 28function calls are routed directly to a driver loaded within the 29application's address space. The other context is an indirect rendering 30context where function calls are converted to GLX protocol and sent to a 31server. The same ``glVertex3fv`` has to do the right thing depending on 32which context is current. 33 34Highly optimized drivers or GLX protocol implementations may want to 35change the behavior of GL functions depending on current state. For 36example, ``glFogCoordf`` may operate differently depending on whether or 37not fog is enabled. 38 39In multi-threaded environments, it is possible for each thread to have a 40different GL context current. This means that poor old ``glVertex3fv`` 41has to know which GL context is current in the thread where it is being 42called. 43 44.. _overview: 45 462. Overview of Mesa's Implementation 47------------------------------------ 48 49Mesa uses two per-thread pointers. The first pointer stores the address 50of the context current in the thread, and the second pointer stores the 51address of the *dispatch table* associated with that context. The 52dispatch table stores pointers to functions that actually implement 53specific GL functions. Each time a new context is made current in a 54thread, these pointers are updated. 55 56The implementation of functions such as ``glVertex3fv`` becomes 57conceptually simple: 58 59- Fetch the current dispatch table pointer. 60- Fetch the pointer to the real ``glVertex3fv`` function from the 61 table. 62- Call the real function. 63 64This can be implemented in just a few lines of C code. The file 65``src/mesa/glapi/glapitemp.h`` contains code very similar to this. 66 67.. code-block:: c 68 :caption: Sample dispatch function 69 70 void glVertex3f(GLfloat x, GLfloat y, GLfloat z) 71 { 72 const struct _glapi_table * const dispatch = GET_DISPATCH(); 73 74 (*dispatch->Vertex3f)(x, y, z); 75 } 76 77The problem with this simple implementation is the large amount of 78overhead that it adds to every GL function call. 79 80In a multithreaded environment, a naive implementation of 81``GET_DISPATCH`` involves a call to ``pthread_getspecific`` or a similar 82function. Mesa provides a wrapper function called 83``_glapi_get_dispatch`` that is used by default. 84 853. Optimizations 86---------------- 87 88A number of optimizations have been made over the years to diminish the 89performance hit imposed by GL dispatch. This section describes these 90optimizations. The benefits of each optimization and the situations 91where each can or cannot be used are listed. 92 933.1. Dual dispatch table pointers 94~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 95 96The vast majority of OpenGL applications use the API in a single 97threaded manner. That is, the application has only one thread that makes 98calls into the GL. In these cases, not only do the calls to 99``pthread_getspecific`` hurt performance, but they are completely 100unnecessary! It is possible to detect this common case and avoid these 101calls. 102 103Each time a new dispatch table is set, Mesa examines and records the ID 104of the executing thread. If the same thread ID is always seen, Mesa 105knows that the application is, from OpenGL's point of view, single 106threaded. 107 108As long as an application is single threaded, Mesa stores a pointer to 109the dispatch table in a global variable called ``_glapi_Dispatch``. The 110pointer is also stored in a per-thread location via 111``pthread_setspecific``. When Mesa detects that an application has 112become multithreaded, ``NULL`` is stored in ``_glapi_Dispatch``. 113 114Using this simple mechanism the dispatch functions can detect the 115multithreaded case by comparing ``_glapi_Dispatch`` to ``NULL``. The 116resulting implementation of ``GET_DISPATCH`` is slightly more complex, 117but it avoids the expensive ``pthread_getspecific`` call in the common 118case. 119 120.. code-block:: c 121 :caption: Improved ``GET_DISPATCH`` Implementation 122 123 #define GET_DISPATCH() \ 124 (_glapi_Dispatch != NULL) \ 125 ? _glapi_Dispatch : pthread_getspecific(&_glapi_Dispatch_key) 126 1273.2. ELF TLS 128~~~~~~~~~~~~ 129 130Starting with the 2.4.20 Linux kernel, each thread is allocated an area 131of per-thread, global storage. Variables can be put in this area using 132some extensions to GCC. By storing the dispatch table pointer in this 133area, the expensive call to ``pthread_getspecific`` and the test of 134``_glapi_Dispatch`` can be avoided. 135 136The dispatch table pointer is stored in a new variable called 137``_glapi_tls_Dispatch``. A new variable name is used so that a single 138libGL can implement both interfaces. This allows the libGL to operate 139with direct rendering drivers that use either interface. Once the 140pointer is properly declared, ``GET_DISPACH`` becomes a simple variable 141reference. 142 143.. code-block:: c 144 :caption: TLS ``GET_DISPATCH`` Implementation 145 146 extern __THREAD_INITIAL_EXEC struct _glapi_table *_glapi_tls_Dispatch; 147 148 #define GET_DISPATCH() _glapi_tls_Dispatch 149 150Use of this path is controlled by the preprocessor define 151``USE_ELF_TLS``. Any platform capable of using ELF TLS should use this 152as the default dispatch method. 153 154Windows has a similar concept, and beginning with Windows Vista, shared 155libraries can take advantage of compiler-assisted TLS. This TLS data 156has no fixed size and does not compete with API-based TLS (``TlsAlloc``) 157for the limited number of slots available there, and so ``USE_ELF_TLS`` can 158be used on Windows too, even though it's not truly ELF. 159 1603.3. Assembly Language Dispatch Stubs 161~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 162 163Many platforms have difficulty properly optimizing the tail-call in the 164dispatch stubs. Platforms like x86 that pass parameters on the stack 165seem to have even more difficulty optimizing these routines. All of the 166dispatch routines are very short, and it is trivial to create optimal 167assembly language versions. The amount of optimization provided by using 168assembly stubs varies from platform to platform and application to 169application. However, by using the assembly stubs, many platforms can 170use an additional space optimization (see :ref:`below <fixedsize>`). 171 172The biggest hurdle to creating assembly stubs is handling the various 173ways that the dispatch table pointer can be accessed. There are four 174different methods that can be used: 175 176#. Using ``_glapi_Dispatch`` directly in builds for non-multithreaded 177 environments. 178#. Using ``_glapi_Dispatch`` and ``_glapi_get_dispatch`` in 179 multithreaded environments. 180#. Using ``_glapi_Dispatch`` and ``pthread_getspecific`` in 181 multithreaded environments. 182#. Using ``_glapi_tls_Dispatch`` directly in TLS enabled multithreaded 183 environments. 184 185People wishing to implement assembly stubs for new platforms should 186focus on #4 if the new platform supports TLS. Otherwise, implement #2 187followed by #3. Environments that do not support multithreading are 188uncommon and not terribly relevant. 189 190Selection of the dispatch table pointer access method is controlled by a 191few preprocessor defines. 192 193- If ``USE_ELF_TLS`` is defined, method #3 is used. 194- If ``HAVE_PTHREAD`` is defined, method #2 is used. 195- If none of the preceding are defined, method #1 is used. 196 197Two different techniques are used to handle the various different cases. 198On x86 and SPARC, a macro called ``GL_STUB`` is used. In the preamble of 199the assembly source file different implementations of the macro are 200selected based on the defined preprocessor variables. The assembly code 201then consists of a series of invocations of the macros such as: 202 203.. code-block:: c 204 :caption: SPARC Assembly Implementation of ``glColor3fv`` 205 206 GL_STUB(Color3fv, _gloffset_Color3fv) 207 208The benefit of this technique is that changes to the calling pattern 209(i.e., addition of a new dispatch table pointer access method) require 210fewer changed lines in the assembly code. 211 212However, this technique can only be used on platforms where the function 213implementation does not change based on the parameters passed to the 214function. For example, since x86 passes all parameters on the stack, no 215additional code is needed to save and restore function parameters around 216a call to ``pthread_getspecific``. Since x86-64 passes parameters in 217registers, varying amounts of code needs to be inserted around the call 218to ``pthread_getspecific`` to save and restore the GL function's 219parameters. 220 221The other technique, used by platforms like x86-64 that cannot use the 222first technique, is to insert ``#ifdef`` within the assembly 223implementation of each function. This makes the assembly file 224considerably larger (e.g., 29,332 lines for ``glapi_x86-64.S`` versus 2251,155 lines for ``glapi_x86.S``) and causes simple changes to the 226function implementation to generate many lines of diffs. Since the 227assembly files are typically generated by scripts, this isn't a 228significant problem. 229 230Once a new assembly file is created, it must be inserted in the build 231system. There are two steps to this. The file must first be added to 232``src/mesa/sources``. That gets the file built and linked. The second 233step is to add the correct ``#ifdef`` magic to 234``src/mesa/glapi/glapi_dispatch.c`` to prevent the C version of the 235dispatch functions from being built. 236 237.. _fixedsize: 238 2393.4. Fixed-Length Dispatch Stubs 240~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 241 242To implement ``glXGetProcAddress``, Mesa stores a table that associates 243function names with pointers to those functions. This table is stored in 244``src/mesa/glapi/glprocs.h``. For different reasons on different 245platforms, storing all of those pointers is inefficient. On most 246platforms, including all known platforms that support TLS, we can avoid 247this added overhead. 248 249If the assembly stubs are all the same size, the pointer need not be 250stored for every function. The location of the function can instead be 251calculated by multiplying the size of the dispatch stub by the offset of 252the function in the table. This value is then added to the address of 253the first dispatch stub. 254 255This path is activated by adding the correct ``#ifdef`` magic to 256``src/mesa/glapi/glapi.c`` just before ``glprocs.h`` is included. 257