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