← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/my_thr_init.cc

  • Committer: Padraig O'Sullivan
  • Date: 2009-06-29 17:24:02 UTC
  • mto: This revision was merged to the branch mainline in revision 1081.
  • Revision ID: osullivan.padraig@gmail.com-20090629172402-9c5n1kr7ry7xgau7
Removed the dependency on knowing the position of an I_S table in the
schema_tables array defined in show.cc. This issue crops up in
prepare_schema_table. An issue with my design is that it increases the time
complexity from O(1) to O(n) in numerous places to determine an I_S table to
work on since we don't have an explicit index into the array and instead
need to search by name. However, as n is the number of I_S tables and this
number is quite small (at the moment n is < 30), we don't see this causing
any issue. This design makes the code much more maintainable and easier to
understand. Previously, modifying anything to do with the I_S tables meant
having to tip-toe around the issue of hard-coded indexes into the
schema_tables array.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/my_thr_init.cc
18
18
  thread variables.
19
19
*/
20
20
 
21
 
#include "mysys_priv.h"
 
21
#include "mysys/mysys_priv.h"
 
22
#include <mysys/my_pthread.h>
22
23
#include <mystrings/m_string.h>
 
24
 
 
25
#include <stdio.h>
23
26
#include <signal.h>
24
27
 
25
 
uint thd_lib_detected= 0;
26
 
 
27
 
#ifdef USE_TLS
28
 
pthread_key(struct st_my_thread_var*, THR_KEY_mysys);
 
28
#if TIME_WITH_SYS_TIME
 
29
# include <sys/time.h>
 
30
# include <time.h>
29
31
#else
30
 
pthread_key(struct st_my_thread_var, THR_KEY_mysys);
31
 
#endif /* USE_TLS */
32
 
pthread_mutex_t THR_LOCK_malloc,THR_LOCK_open,
33
 
                THR_LOCK_lock,THR_LOCK_isam,THR_LOCK_myisam,THR_LOCK_heap,
34
 
                THR_LOCK_net, THR_LOCK_charset, THR_LOCK_threads, THR_LOCK_time;
 
32
# if HAVE_SYS_TIME_H
 
33
#  include <sys/time.h>
 
34
# else
 
35
#  include <time.h>
 
36
# endif
 
37
#endif
 
38
 
 
39
uint32_t thd_lib_detected= 0;
 
40
 
 
41
pthread_key_t THR_KEY_mysys;
 
42
pthread_mutex_t THR_LOCK_lock;
 
43
pthread_mutex_t THR_LOCK_threads;
35
44
pthread_cond_t  THR_COND_threads;
36
 
uint            THR_thread_count= 0;
37
 
uint            my_thread_end_wait_time= 5;
38
 
#if !defined(HAVE_LOCALTIME_R) || !defined(HAVE_GMTIME_R)
39
 
pthread_mutex_t LOCK_localtime_r;
40
 
#endif
41
 
#ifndef HAVE_GETHOSTBYNAME_R
42
 
pthread_mutex_t LOCK_gethostbyname_r;
43
 
#endif
 
45
uint32_t            THR_thread_count= 0;
 
46
uint32_t                my_thread_end_wait_time= 5;
44
47
#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
45
48
pthread_mutexattr_t my_fast_mutexattr;
46
49
#endif
55
58
  race conditions in NPTL pthread_exit code.
56
59
*/
57
60
 
58
 
static pthread_handler_t
 
61
extern "C"
 
62
void *
59
63
nptl_pthread_exit_hack_handler(void *arg __attribute((unused)))
60
64
{
61
65
  /* Do nothing! */
66
70
#endif /* TARGET_OS_LINUX */
67
71
 
68
72
 
69
 
static uint get_thread_lib(void);
 
73
static uint32_t get_thread_lib(void);
70
74
 
71
75
/*
72
76
  initialize thread environment
90
94
    return 1;
91
95
  }
92
96
 
93
 
#ifdef TARGET_OS_LINUX
94
 
  /*
95
 
    BUG#24507: Race conditions inside current NPTL pthread_exit()
96
 
    implementation.
97
 
 
98
 
    To avoid a possible segmentation fault during concurrent
99
 
    executions of pthread_exit(), a dummy thread is spawned which
100
 
    initializes internal variables of pthread lib. See bug description
101
 
    for a full explanation.
102
 
 
103
 
    TODO: Remove this code when fixed versions of glibc6 are in common
104
 
    use.
105
 
  */
106
 
  if (thd_lib_detected == THD_LIB_NPTL)
107
 
  {
108
 
    pthread_t       dummy_thread;
109
 
    pthread_attr_t  dummy_thread_attr;
110
 
 
111
 
    pthread_attr_init(&dummy_thread_attr);
112
 
    pthread_attr_setdetachstate(&dummy_thread_attr, PTHREAD_CREATE_DETACHED);
113
 
 
114
 
    pthread_create(&dummy_thread,&dummy_thread_attr,
115
 
                   nptl_pthread_exit_hack_handler, NULL);
116
 
  }
117
 
#endif /* TARGET_OS_LINUX */
118
 
 
119
97
#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
120
98
  /*
121
99
    Set mutex type to "fast" a.k.a "adaptive"
139
117
                            PTHREAD_MUTEX_ERRORCHECK);
140
118
#endif
141
119
 
142
 
  pthread_mutex_init(&THR_LOCK_malloc,MY_MUTEX_INIT_FAST);
143
 
  pthread_mutex_init(&THR_LOCK_open,MY_MUTEX_INIT_FAST);
144
120
  pthread_mutex_init(&THR_LOCK_lock,MY_MUTEX_INIT_FAST);
145
 
  pthread_mutex_init(&THR_LOCK_isam,MY_MUTEX_INIT_SLOW);
146
 
  pthread_mutex_init(&THR_LOCK_myisam,MY_MUTEX_INIT_SLOW);
147
 
  pthread_mutex_init(&THR_LOCK_heap,MY_MUTEX_INIT_FAST);
148
 
  pthread_mutex_init(&THR_LOCK_net,MY_MUTEX_INIT_FAST);
149
 
  pthread_mutex_init(&THR_LOCK_charset,MY_MUTEX_INIT_FAST);
150
121
  pthread_mutex_init(&THR_LOCK_threads,MY_MUTEX_INIT_FAST);
151
 
  pthread_mutex_init(&THR_LOCK_time,MY_MUTEX_INIT_FAST);
152
122
  pthread_cond_init(&THR_COND_threads, NULL);
153
 
#if !defined(HAVE_LOCALTIME_R) || !defined(HAVE_GMTIME_R)
154
 
  pthread_mutex_init(&LOCK_localtime_r,MY_MUTEX_INIT_SLOW);
155
 
#endif
156
 
#ifndef HAVE_GETHOSTBYNAME_R
157
 
  pthread_mutex_init(&LOCK_gethostbyname_r,MY_MUTEX_INIT_SLOW);
158
 
#endif
159
123
  if (my_thread_init())
160
124
  {
161
125
    my_thread_global_end();                     /* Clean up */
178
142
                                      &abstime);
179
143
    if (error == ETIMEDOUT || error == ETIME)
180
144
    {
181
 
#ifdef HAVE_PTHREAD_KILL
182
145
      /*
183
146
        We shouldn't give an error here, because if we don't have
184
147
        pthread_kill(), programs like mysqld can't ensure that all threads
188
151
        fprintf(stderr,
189
152
                "Error in my_thread_global_end(): %d threads didn't exit\n",
190
153
                THR_thread_count);
191
 
#endif
192
154
      all_threads_killed= 0;
193
155
      break;
194
156
    }
202
164
#ifdef PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
203
165
  pthread_mutexattr_destroy(&my_errorcheck_mutexattr);
204
166
#endif
205
 
  pthread_mutex_destroy(&THR_LOCK_malloc);
206
 
  pthread_mutex_destroy(&THR_LOCK_open);
207
167
  pthread_mutex_destroy(&THR_LOCK_lock);
208
 
  pthread_mutex_destroy(&THR_LOCK_isam);
209
 
  pthread_mutex_destroy(&THR_LOCK_myisam);
210
 
  pthread_mutex_destroy(&THR_LOCK_heap);
211
 
  pthread_mutex_destroy(&THR_LOCK_net);
212
 
  pthread_mutex_destroy(&THR_LOCK_time);
213
 
  pthread_mutex_destroy(&THR_LOCK_charset);
214
168
  if (all_threads_killed)
215
169
  {
216
170
    pthread_mutex_destroy(&THR_LOCK_threads);
217
171
    pthread_cond_destroy(&THR_COND_threads);
218
172
  }
219
 
#if !defined(HAVE_LOCALTIME_R) || !defined(HAVE_GMTIME_R)
220
 
  pthread_mutex_destroy(&LOCK_localtime_r);
221
 
#endif
222
 
#ifndef HAVE_GETHOSTBYNAME_R
223
 
  pthread_mutex_destroy(&LOCK_gethostbyname_r);
224
 
#endif
225
173
}
226
174
 
227
175
static my_thread_id thread_id= 0;
232
180
  SYNOPSIS
233
181
    my_thread_init()
234
182
 
235
 
  NOTES
236
 
    We can't use mutex_locks here if we are using windows as
237
 
    we may have compiled the program with SAFE_MUTEX, in which
238
 
    case the checking of mutex_locks will not work until
239
 
    the pthread_self thread specific variable is initialized.
240
 
 
241
183
  RETURN
242
184
    0  ok
243
185
    1  Fatal error; mysys/dbug functions can't be used
251
193
#ifdef EXTRA_DEBUG_THREADS
252
194
  fprintf(stderr,"my_thread_init(): thread_id: 0x%lx\n",
253
195
          (uint32_t) pthread_self());
254
 
#endif  
 
196
#endif
255
197
 
256
198
  if (pthread_getspecific(THR_KEY_mysys))
257
199
  {
258
200
#ifdef EXTRA_DEBUG_THREADS
259
201
    fprintf(stderr,"my_thread_init() called more than once in thread 0x%lx\n",
260
202
            (long) pthread_self());
261
 
#endif    
 
203
#endif
262
204
    goto end;
263
205
  }
264
206
  if (!(tmp= (struct st_my_thread_var *) calloc(1, sizeof(*tmp))))
302
244
#ifdef EXTRA_DEBUG_THREADS
303
245
  fprintf(stderr,"my_thread_end(): tmp: 0x%lx  pthread_self: 0x%lx  thread_id: %ld\n",
304
246
          (long) tmp, (long) pthread_self(), tmp ? (long) tmp->id : 0L);
305
 
#endif  
 
247
#endif
306
248
  if (tmp && tmp->init)
307
249
  {
308
250
#if !defined(__bsdi__) && !defined(__OpenBSD__)
310
252
    pthread_cond_destroy(&tmp->suspend);
311
253
#endif
312
254
    pthread_mutex_destroy(&tmp->mutex);
313
 
#if defined(USE_TLS)
314
 
    free(tmp);
315
 
#else
316
255
    tmp->init= 0;
317
 
#endif
318
256
 
319
257
    /*
320
258
      Decrement counter for number of running threads. We are using this
321
259
      in my_thread_global_end() to wait until all threads have called
322
260
      my_thread_end and thus freed all memory they have allocated in
323
 
      my_thread_init() 
 
261
      my_thread_init()
324
262
    */
325
263
    pthread_mutex_lock(&THR_LOCK_threads);
326
264
    assert(THR_thread_count != 0);
328
266
      pthread_cond_signal(&THR_COND_threads);
329
267
   pthread_mutex_unlock(&THR_LOCK_threads);
330
268
  }
331
 
  /* The following free has to be done, even if my_thread_var() is 0 */
332
 
#if defined(USE_TLS)
333
 
  pthread_setspecific(THR_KEY_mysys,0);
334
 
#endif
335
269
}
336
270
 
337
271
struct st_my_thread_var *_my_thread_var(void)
338
272
{
339
273
  struct st_my_thread_var *tmp= (struct st_my_thread_var*)pthread_getspecific(THR_KEY_mysys);
340
 
#if defined(USE_TLS)
341
 
  /* This can only happen in a .DLL */
342
 
  if (!tmp)
343
 
  {
344
 
    my_thread_init();
345
 
    tmp=my_pthread_getspecific(struct st_my_thread_var*,THR_KEY_mysys);
346
 
  }
347
 
#endif
348
274
  return tmp;
349
275
}
350
276
 
358
284
  return my_thread_var->id;
359
285
}
360
286
 
361
 
static uint get_thread_lib(void)
 
287
static uint32_t get_thread_lib(void)
362
288
{
363
289
#ifdef _CS_GNU_LIBPTHREAD_VERSION
364
290
  char buff[64];
365
 
    
 
291
 
366
292
  confstr(_CS_GNU_LIBPTHREAD_VERSION, buff, sizeof(buff));
367
293
 
368
294
  if (!strncasecmp(buff, "NPTL", 4))