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