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