← Back to branch summary

~ubuntu-branches/ubuntu/precise/mesa-lts-quantal/precise-updates

« back to all changes in this revision

Viewing changes to src/mapi/mapi/u_current.c

  • Committer: Package Import Robot
  • Author(s): Maarten Lankhorst
  • Date: 2012-11-30 20:58:34 UTC
  • Revision ID: package-import@ubuntu.com-20121130205834-gazuvne3fpwlf012
Tags: upstream-9.0
Import upstream version 9.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mapi/mapi/u_current.c
 
1
/*
 
2
 * Mesa 3-D graphics library
 
3
 * Version:  7.1
 
4
 *
 
5
 * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
 
6
 *
 
7
 * Permission is hereby granted, free of charge, to any person obtaining a
 
8
 * copy of this software and associated documentation files (the "Software"),
 
9
 * to deal in the Software without restriction, including without limitation
 
10
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 
11
 * and/or sell copies of the Software, and to permit persons to whom the
 
12
 * Software is furnished to do so, subject to the following conditions:
 
13
 *
 
14
 * The above copyright notice and this permission notice shall be included
 
15
 * in all copies or substantial portions of the Software.
 
16
 *
 
17
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 
18
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
19
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 
20
 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
 
21
 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 
22
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
23
 */
 
24
 
 
25
 
 
26
/*
 
27
 * This file manages the OpenGL API dispatch layer.
 
28
 * The dispatch table (struct _glapi_table) is basically just a list
 
29
 * of function pointers.
 
30
 * There are functions to set/get the current dispatch table for the
 
31
 * current thread and to manage registration/dispatch of dynamically
 
32
 * added extension functions.
 
33
 *
 
34
 * It's intended that this file and the other glapi*.[ch] files are
 
35
 * flexible enough to be reused in several places:  XFree86, DRI-
 
36
 * based libGL.so, and perhaps the SGI SI.
 
37
 *
 
38
 * NOTE: There are no dependencies on Mesa in this code.
 
39
 *
 
40
 * Versions (API changes):
 
41
 *   2000/02/23  - original version for Mesa 3.3 and XFree86 4.0
 
42
 *   2001/01/16  - added dispatch override feature for Mesa 3.5
 
43
 *   2002/06/28  - added _glapi_set_warning_func(), Mesa 4.1.
 
44
 *   2002/10/01  - _glapi_get_proc_address() will now generate new entrypoints
 
45
 *                 itself (using offset ~0).  _glapi_add_entrypoint() can be
 
46
 *                 called afterward and it'll fill in the correct dispatch
 
47
 *                 offset.  This allows DRI libGL to avoid probing for DRI
 
48
 *                 drivers!  No changes to the public glapi interface.
 
49
 */
 
50
 
 
51
#include "u_current.h"
 
52
#include "u_thread.h"
 
53
 
 
54
#ifndef MAPI_MODE_UTIL
 
55
 
 
56
#include "table.h"
 
57
#include "stub.h"
 
58
 
 
59
#else
 
60
 
 
61
extern void init_glapi_relocs_once(void);
 
62
extern void (*__glapi_noop_table[])(void);
 
63
 
 
64
#define table_noop_array __glapi_noop_table
 
65
#define stub_init_once() init_glapi_relocs_once()
 
66
 
 
67
#endif
 
68
 
 
69
/**
 
70
 * \name Current dispatch and current context control variables
 
71
 *
 
72
 * Depending on whether or not multithreading is support, and the type of
 
73
 * support available, several variables are used to store the current context
 
74
 * pointer and the current dispatch table pointer.  In the non-threaded case,
 
75
 * the variables \c _glapi_Dispatch and \c _glapi_Context are used for this
 
76
 * purpose.
 
77
 *
 
78
 * In the "normal" threaded case, the variables \c _glapi_Dispatch and
 
79
 * \c _glapi_Context will be \c NULL if an application is detected as being
 
80
 * multithreaded.  Single-threaded applications will use \c _glapi_Dispatch
 
81
 * and \c _glapi_Context just like the case without any threading support.
 
82
 * When \c _glapi_Dispatch and \c _glapi_Context are \c NULL, the thread state
 
83
 * data \c _gl_DispatchTSD and \c ContextTSD are used.  Drivers and the
 
84
 * static dispatch functions access these variables via \c _glapi_get_dispatch
 
85
 * and \c _glapi_get_context.
 
86
 *
 
87
 * There is a race condition in setting \c _glapi_Dispatch to \c NULL.  It is
 
88
 * possible for the original thread to be setting it at the same instant a new
 
89
 * thread, perhaps running on a different processor, is clearing it.  Because
 
90
 * of that, \c ThreadSafe, which can only ever be changed to \c GL_TRUE, is
 
91
 * used to determine whether or not the application is multithreaded.
 
92
 * 
 
93
 * In the TLS case, the variables \c _glapi_Dispatch and \c _glapi_Context are
 
94
 * hardcoded to \c NULL.  Instead the TLS variables \c _glapi_tls_Dispatch and
 
95
 * \c _glapi_tls_Context are used.  Having \c _glapi_Dispatch and
 
96
 * \c _glapi_Context be hardcoded to \c NULL maintains binary compatability
 
97
 * between TLS enabled loaders and non-TLS DRI drivers.
 
98
 */
 
99
/*@{*/
 
100
#if defined(GLX_USE_TLS)
 
101
 
 
102
__thread struct mapi_table *u_current_table
 
103
    __attribute__((tls_model("initial-exec")))
 
104
    = (struct mapi_table *) table_noop_array;
 
105
 
 
106
__thread void *u_current_user
 
107
    __attribute__((tls_model("initial-exec")));
 
108
 
 
109
#else
 
110
 
 
111
struct mapi_table *u_current_table =
 
112
   (struct mapi_table *) table_noop_array;
 
113
void *u_current_user;
 
114
 
 
115
#ifdef THREADS
 
116
struct u_tsd u_current_table_tsd;
 
117
static struct u_tsd u_current_user_tsd;
 
118
static int ThreadSafe;
 
119
#endif /* THREADS */
 
120
 
 
121
#endif /* defined(GLX_USE_TLS) */
 
122
/*@}*/
 
123
 
 
124
 
 
125
void
 
126
u_current_destroy(void)
 
127
{
 
128
#if defined(THREADS) && defined(WIN32)
 
129
   u_tsd_destroy(&u_current_table_tsd);
 
130
   u_tsd_destroy(&u_current_user_tsd);
 
131
#endif
 
132
}
 
133
 
 
134
 
 
135
#if defined(THREADS) && !defined(GLX_USE_TLS)
 
136
 
 
137
static void
 
138
u_current_init_tsd(void)
 
139
{
 
140
   u_tsd_init(&u_current_table_tsd);
 
141
   u_tsd_init(&u_current_user_tsd);
 
142
}
 
143
 
 
144
/**
 
145
 * Mutex for multithread check.
 
146
 */
 
147
u_mutex_declare_static(ThreadCheckMutex);
 
148
 
 
149
/**
 
150
 * We should call this periodically from a function such as glXMakeCurrent
 
151
 * in order to test if multiple threads are being used.
 
152
 */
 
153
void
 
154
u_current_init(void)
 
155
{
 
156
   static unsigned long knownID;
 
157
   static int firstCall = 1;
 
158
 
 
159
   if (ThreadSafe)
 
160
      return;
 
161
 
 
162
   u_mutex_lock(ThreadCheckMutex);
 
163
   if (firstCall) {
 
164
      u_current_init_tsd();
 
165
 
 
166
      knownID = u_thread_self();
 
167
      firstCall = 0;
 
168
   }
 
169
   else if (knownID != u_thread_self()) {
 
170
      ThreadSafe = 1;
 
171
      u_current_set(NULL);
 
172
      u_current_set_user(NULL);
 
173
   }
 
174
   u_mutex_unlock(ThreadCheckMutex);
 
175
}
 
176
 
 
177
#else
 
178
 
 
179
void
 
180
u_current_init(void)
 
181
{
 
182
}
 
183
 
 
184
#endif
 
185
 
 
186
 
 
187
 
 
188
/**
 
189
 * Set the current context pointer for this thread.
 
190
 * The context pointer is an opaque type which should be cast to
 
191
 * void from the real context pointer type.
 
192
 */
 
193
void
 
194
u_current_set_user(const void *ptr)
 
195
{
 
196
   u_current_init();
 
197
 
 
198
#if defined(GLX_USE_TLS)
 
199
   u_current_user = (void *) ptr;
 
200
#elif defined(THREADS)
 
201
   u_tsd_set(&u_current_user_tsd, (void *) ptr);
 
202
   u_current_user = (ThreadSafe) ? NULL : (void *) ptr;
 
203
#else
 
204
   u_current_user = (void *) ptr;
 
205
#endif
 
206
}
 
207
 
 
208
/**
 
209
 * Get the current context pointer for this thread.
 
210
 * The context pointer is an opaque type which should be cast from
 
211
 * void to the real context pointer type.
 
212
 */
 
213
void *
 
214
u_current_get_user_internal(void)
 
215
{
 
216
#if defined(GLX_USE_TLS)
 
217
   return u_current_user;
 
218
#elif defined(THREADS)
 
219
   return (ThreadSafe)
 
220
      ? u_tsd_get(&u_current_user_tsd)
 
221
      : u_current_user;
 
222
#else
 
223
   return u_current_user;
 
224
#endif
 
225
}
 
226
 
 
227
/**
 
228
 * Set the global or per-thread dispatch table pointer.
 
229
 * If the dispatch parameter is NULL we'll plug in the no-op dispatch
 
230
 * table (__glapi_noop_table).
 
231
 */
 
232
void
 
233
u_current_set(const struct mapi_table *tbl)
 
234
{
 
235
   u_current_init();
 
236
 
 
237
   stub_init_once();
 
238
 
 
239
   if (!tbl)
 
240
      tbl = (const struct mapi_table *) table_noop_array;
 
241
 
 
242
#if defined(GLX_USE_TLS)
 
243
   u_current_table = (struct mapi_table *) tbl;
 
244
#elif defined(THREADS)
 
245
   u_tsd_set(&u_current_table_tsd, (void *) tbl);
 
246
   u_current_table = (ThreadSafe) ? NULL : (void *) tbl;
 
247
#else
 
248
   u_current_table = (struct mapi_table *) tbl;
 
249
#endif
 
250
}
 
251
 
 
252
/**
 
253
 * Return pointer to current dispatch table for calling thread.
 
254
 */
 
255
struct mapi_table *
 
256
u_current_get_internal(void)
 
257
{
 
258
#if defined(GLX_USE_TLS)
 
259
   return u_current_table;
 
260
#elif defined(THREADS)
 
261
   return (struct mapi_table *) ((ThreadSafe) ?
 
262
         u_tsd_get(&u_current_table_tsd) : (void *) u_current_table);
 
263
#else
 
264
   return u_current_table;
 
265
#endif
 
266
}