← Back to branch summary

~mmach/netext73/mesa-haswell

« back to all changes in this revision

Viewing changes to docs/dispatch.rst

  • Committer: mmach
  • Date: 2022-09-22 19:56:13 UTC
  • Revision ID: netbit73@gmail.com-20220922195613-wtik9mmy20tmor0i
2022-09-22 21:17:09

Show diffs side-by-side

added added

removed removed

Lines of Context:
docs/dispatch.rst
1
 
GL Dispatch
2
 
===========
3
 
 
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
 
:ref:`overview of Mesa's implementation <overview>`.
9
 
 
10
 
1. Complexity of GL Dispatch
11
 
----------------------------
12
 
 
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``.
20
 
 
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.
25
 
 
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.
33
 
 
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
37
 
not fog is enabled.
38
 
 
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
42
 
called.
43
 
 
44
 
.. _overview:
45
 
 
46
 
2. Overview of Mesa's Implementation
47
 
------------------------------------
48
 
 
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 are updated.
55
 
 
56
 
The implementation of functions such as ``glVertex3fv`` becomes
57
 
conceptually 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
 
 
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.
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
 
 
77
 
The problem with this simple implementation is the large amount of
78
 
overhead that it adds to every GL function call.
79
 
 
80
 
In a multithreaded environment, a naive implementation of
81
 
``GET_DISPATCH`` involves a call to ``pthread_getspecific`` or a similar
82
 
function. Mesa provides a wrapper function called
83
 
``_glapi_get_dispatch`` that is used by default.
84
 
 
85
 
3. Optimizations
86
 
----------------
87
 
 
88
 
A number of optimizations have been made over the years to diminish the
89
 
performance hit imposed by GL dispatch. This section describes these
90
 
optimizations. The benefits of each optimization and the situations
91
 
where each can or cannot be used are listed.
92
 
 
93
 
3.1. Dual dispatch table pointers
94
 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
95
 
 
96
 
The vast majority of OpenGL applications use the API in a single
97
 
threaded manner. That is, the application has only one thread that makes
98
 
calls into the GL. In these cases, not only do the calls to
99
 
``pthread_getspecific`` hurt performance, but they are completely
100
 
unnecessary! It is possible to detect this common case and avoid these
101
 
calls.
102
 
 
103
 
Each time a new dispatch table is set, Mesa examines and records the ID
104
 
of the executing thread. If the same thread ID is always seen, Mesa
105
 
knows that the application is, from OpenGL's point of view, single
106
 
threaded.
107
 
 
108
 
As long as an application is single threaded, Mesa stores a pointer to
109
 
the dispatch table in a global variable called ``_glapi_Dispatch``. The
110
 
pointer is also stored in a per-thread location via
111
 
``pthread_setspecific``. When Mesa detects that an application has
112
 
become multithreaded, ``NULL`` is stored in ``_glapi_Dispatch``.
113
 
 
114
 
Using this simple mechanism the dispatch functions can detect the
115
 
multithreaded case by comparing ``_glapi_Dispatch`` to ``NULL``. The
116
 
resulting implementation of ``GET_DISPATCH`` is slightly more complex,
117
 
but it avoids the expensive ``pthread_getspecific`` call in the common
118
 
case.
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
 
 
127
 
3.2. ELF TLS
128
 
~~~~~~~~~~~~
129
 
 
130
 
Starting with the 2.4.20 Linux kernel, each thread is allocated an area
131
 
of per-thread, global storage. Variables can be put in this area using
132
 
some extensions to GCC. By storing the dispatch table pointer in this
133
 
area, the expensive call to ``pthread_getspecific`` and the test of
134
 
``_glapi_Dispatch`` can be avoided.
135
 
 
136
 
The dispatch table pointer is stored in a new variable called
137
 
``_glapi_tls_Dispatch``. A new variable name is used so that a single
138
 
libGL can implement both interfaces. This allows the libGL to operate
139
 
with direct rendering drivers that use either interface. Once the
140
 
pointer is properly declared, ``GET_DISPACH`` becomes a simple variable
141
 
reference.
142
 
 
143
 
.. code-block:: c
144
 
   :caption: TLS ``GET_DISPATCH`` Implementation
145
 
 
146
 
   extern __thread struct _glapi_table *_glapi_tls_Dispatch
147
 
       __attribute__((tls_model("initial-exec")));
148
 
 
149
 
   #define GET_DISPATCH() _glapi_tls_Dispatch
150
 
 
151
 
Use of this path is controlled by the preprocessor define
152
 
``USE_ELF_TLS``. Any platform capable of using ELF TLS should use this
153
 
as the default dispatch method.
154
 
 
155
 
Windows has a similar concept, and beginning with Windows Vista, shared
156
 
libraries can take advantage of compiler-assisted TLS. This TLS data
157
 
has no fixed size and does not compete with API-based TLS (``TlsAlloc``)
158
 
for the limited number of slots available there, and so ``USE_ELF_TLS`` can
159
 
be used on Windows too, even though it's not truly ELF.
160
 
 
161
 
3.3. Assembly Language Dispatch Stubs
162
 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
163
 
 
164
 
Many platforms have difficulty properly optimizing the tail-call in the
165
 
dispatch stubs. Platforms like x86 that pass parameters on the stack
166
 
seem to have even more difficulty optimizing these routines. All of the
167
 
dispatch routines are very short, and it is trivial to create optimal
168
 
assembly language versions. The amount of optimization provided by using
169
 
assembly stubs varies from platform to platform and application to
170
 
application. However, by using the assembly stubs, many platforms can
171
 
use an additional space optimization (see :ref:`below <fixedsize>`).
172
 
 
173
 
The biggest hurdle to creating assembly stubs is handling the various
174
 
ways that the dispatch table pointer can be accessed. There are four
175
 
different methods that can be used:
176
 
 
177
 
#. Using ``_glapi_Dispatch`` directly in builds for non-multithreaded
178
 
   environments.
179
 
#. Using ``_glapi_Dispatch`` and ``_glapi_get_dispatch`` in
180
 
   multithreaded environments.
181
 
#. Using ``_glapi_Dispatch`` and ``pthread_getspecific`` in
182
 
   multithreaded environments.
183
 
#. Using ``_glapi_tls_Dispatch`` directly in TLS enabled multithreaded
184
 
   environments.
185
 
 
186
 
People wishing to implement assembly stubs for new platforms should
187
 
focus on #4 if the new platform supports TLS. Otherwise, implement #2
188
 
followed by #3. Environments that do not support multithreading are
189
 
uncommon and not terribly relevant.
190
 
 
191
 
Selection of the dispatch table pointer access method is controlled by a
192
 
few preprocessor defines.
193
 
 
194
 
-  If ``USE_ELF_TLS`` is defined, method #3 is used.
195
 
-  If ``HAVE_PTHREAD`` is defined, method #2 is used.
196
 
-  If none of the preceding are defined, method #1 is used.
197
 
 
198
 
Two different techniques are used to handle the various different cases.
199
 
On x86 and SPARC, a macro called ``GL_STUB`` is used. In the preamble of
200
 
the assembly source file different implementations of the macro are
201
 
selected based on the defined preprocessor variables. The assembly code
202
 
then consists of a series of invocations of the macros such as:
203
 
 
204
 
.. code-block:: c
205
 
   :caption: SPARC Assembly Implementation of ``glColor3fv``
206
 
 
207
 
   GL_STUB(Color3fv, _gloffset_Color3fv)
208
 
 
209
 
The benefit of this technique is that changes to the calling pattern
210
 
(i.e., addition of a new dispatch table pointer access method) require
211
 
fewer changed lines in the assembly code.
212
 
 
213
 
However, this technique can only be used on platforms where the function
214
 
implementation does not change based on the parameters passed to the
215
 
function. For example, since x86 passes all parameters on the stack, no
216
 
additional code is needed to save and restore function parameters around
217
 
a call to ``pthread_getspecific``. Since x86-64 passes parameters in
218
 
registers, varying amounts of code needs to be inserted around the call
219
 
to ``pthread_getspecific`` to save and restore the GL function's
220
 
parameters.
221
 
 
222
 
The other technique, used by platforms like x86-64 that cannot use the
223
 
first technique, is to insert ``#ifdef`` within the assembly
224
 
implementation of each function. This makes the assembly file
225
 
considerably larger (e.g., 29,332 lines for ``glapi_x86-64.S`` versus
226
 
1,155 lines for ``glapi_x86.S``) and causes simple changes to the
227
 
function implementation to generate many lines of diffs. Since the
228
 
assembly files are typically generated by scripts, this isn't a
229
 
significant problem.
230
 
 
231
 
Once a new assembly file is created, it must be inserted in the build
232
 
system. There are two steps to this. The file must first be added to
233
 
``src/mesa/sources``. That gets the file built and linked. The second
234
 
step is to add the correct ``#ifdef`` magic to
235
 
``src/mesa/glapi/glapi_dispatch.c`` to prevent the C version of the
236
 
dispatch functions from being built.
237
 
 
238
 
.. _fixedsize:
239
 
 
240
 
3.4. Fixed-Length Dispatch Stubs
241
 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
242
 
 
243
 
To implement ``glXGetProcAddress``, Mesa stores a table that associates
244
 
function names with pointers to those functions. This table is stored in
245
 
``src/mesa/glapi/glprocs.h``. For different reasons on different
246
 
platforms, storing all of those pointers is inefficient. On most
247
 
platforms, including all known platforms that support TLS, we can avoid
248
 
this added overhead.
249
 
 
250
 
If the assembly stubs are all the same size, the pointer need not be
251
 
stored for every function. The location of the function can instead be
252
 
calculated by multiplying the size of the dispatch stub by the offset of
253
 
the function in the table. This value is then added to the address of
254
 
the first dispatch stub.
255
 
 
256
 
This path is activated by adding the correct ``#ifdef`` magic to
257
 
``src/mesa/glapi/glapi.c`` just before ``glprocs.h`` is included.