← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/internal/my_pthread.h

  • Committer: Brian Aker
  • Date: 2010-01-27 18:58:12 UTC
  • Revision ID: brian@gaz-20100127185812-n62n0vwetnx8jrjy
Remove dead code.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/internal/my_pthread.h
15
15
 
16
16
/* Defines to make different thread packages compatible */
17
17
 
18
 
#ifndef _my_pthread_h
19
 
#define _my_pthread_h
 
18
#ifndef DRIZZLED_INTERNAL_MY_PTHREAD_H
 
19
#define DRIZZLED_INTERNAL_MY_PTHREAD_H
 
20
 
 
21
#include <stdint.h>
 
22
#include <unistd.h>
 
23
#include <signal.h>
20
24
 
21
25
#ifndef ETIME
22
26
#define ETIME ETIMEDOUT                         /* For FreeBSD */
27
31
extern "C" {
28
32
#else
29
33
#define EXTERNC
30
 
#endif /* __cplusplus */ 
 
34
#endif /* __cplusplus */
31
35
 
32
36
#include <pthread.h>
33
37
#ifndef _REENTRANT
41
45
#endif
42
46
 
43
47
#define pthread_key(T,V) pthread_key_t V
44
 
#define my_pthread_getspecific_ptr(T,V) my_pthread_getspecific(T,(V))
45
 
#define my_pthread_setspecific_ptr(T,V) pthread_setspecific(T,(void*) (V))
46
 
#define pthread_detach_this_thread()
47
 
#define pthread_handler_t EXTERNC void *
 
48
#define pthread_handler_t void *
48
49
typedef void *(* pthread_handler)(void *);
49
50
 
50
 
/* Test first for RTS or FSU threads */
51
 
 
52
 
#if defined(PTHREAD_SCOPE_GLOBAL) && !defined(PTHREAD_SCOPE_SYSTEM)
53
 
#define HAVE_rts_threads
54
 
extern int my_pthread_create_detached;
55
 
#define pthread_sigmask(A,B,C) sigprocmask((A),(B),(C))
56
 
#define PTHREAD_CREATE_DETACHED &my_pthread_create_detached
57
 
#define PTHREAD_SCOPE_SYSTEM  PTHREAD_SCOPE_GLOBAL
58
 
#define PTHREAD_SCOPE_PROCESS PTHREAD_SCOPE_LOCAL
59
 
#define USE_ALARM_THREAD
60
 
#endif /* defined(PTHREAD_SCOPE_GLOBAL) && !defined(PTHREAD_SCOPE_SYSTEM) */
61
 
 
62
 
#ifndef HAVE_NONPOSIX_SIGWAIT
63
 
#define my_sigwait(A,B) sigwait((A),(B))
64
 
#else
65
 
int my_sigwait(const sigset_t *set,int *sig);
66
 
#endif
67
 
 
68
 
#ifdef HAVE_NONPOSIX_PTHREAD_MUTEX_INIT
69
 
#define pthread_mutex_init(a,b) my_pthread_mutex_init((a),(b))
70
 
extern int my_pthread_mutex_init(pthread_mutex_t *mp,
71
 
                                 const pthread_mutexattr_t *attr);
72
 
#define pthread_cond_init(a,b) my_pthread_cond_init((a),(b))
73
 
extern int my_pthread_cond_init(pthread_cond_t *mp,
74
 
                                const pthread_condattr_t *attr);
75
 
#endif /* HAVE_NONPOSIX_PTHREAD_MUTEX_INIT */
76
 
 
77
 
#if defined(HAVE_SIGTHREADMASK) && !defined(HAVE_PTHREAD_SIGMASK)
78
 
#define pthread_sigmask(A,B,C) sigthreadmask((A),(B),(C))
79
 
#endif
80
 
 
81
 
#if !defined(HAVE_SIGWAIT) && !defined(HAVE_rts_threads) && !defined(sigwait) && !defined(alpha_linux_port) && !defined(HAVE_NONPOSIX_SIGWAIT)
82
 
int sigwait(sigset_t *setp, int *sigp);         /* Use our implemention */
83
 
#endif
84
 
 
85
51
 
86
52
/*
87
53
  We define my_sigset() and use that instead of the system sigset() so that
89
55
  as Mac OS X, sigset() results in flags such as SA_RESTART being set, and
90
56
  we want to make sure that no such flags are set.
91
57
*/
92
 
#if defined(HAVE_SIGACTION) && !defined(my_sigset)
 
58
#if !defined(my_sigset)
93
59
#define my_sigset(A,B) do { struct sigaction l_s; sigset_t l_set; int l_rc; \
94
60
                            assert((A) != 0);                          \
95
61
                            sigemptyset(&l_set);                            \
105
71
#define my_sigset(A,B) signal((A),(B))
106
72
#endif
107
73
 
108
 
#ifndef my_pthread_setprio
109
 
#if defined(HAVE_PTHREAD_SETPRIO_NP)            /* FSU threads */
110
 
#define my_pthread_setprio(A,B) pthread_setprio_np((A),(B))
111
 
#elif defined(HAVE_PTHREAD_SETPRIO)
112
 
#define my_pthread_setprio(A,B) pthread_setprio((A),(B))
113
 
#else
114
 
extern void my_pthread_setprio(pthread_t thread_id,int prior);
115
 
#endif
116
 
#endif
117
 
 
118
74
#ifndef my_pthread_attr_setprio
119
75
#ifdef HAVE_PTHREAD_ATTR_SETPRIO
120
76
#define my_pthread_attr_setprio(A,B) pthread_attr_setprio((A),(B))
123
79
#endif
124
80
#endif
125
81
 
126
 
#if !defined(HAVE_PTHREAD_ATTR_SETSCOPE)
127
 
#define pthread_attr_setscope(A,B)
128
 
#endif
129
 
 
130
 
#if defined(HAVE_BROKEN_PTHREAD_COND_TIMEDWAIT)
131
 
extern int my_pthread_cond_timedwait(pthread_cond_t *cond,
132
 
                                     pthread_mutex_t *mutex,
133
 
                                     struct timespec *abstime);
134
 
#define pthread_cond_timedwait(A,B,C) my_pthread_cond_timedwait((A),(B),(C))
135
 
#endif
136
 
 
137
 
/* FSU THREADS */
138
 
#if !defined(HAVE_PTHREAD_KEY_DELETE) && !defined(pthread_key_delete)
139
 
#define pthread_key_delete(A) pthread_dummy(0)
140
 
#endif
141
 
 
142
 
#ifdef HAVE_CTHREADS_WRAPPER                    /* For MacOSX */
143
 
#define pthread_cond_destroy(A) pthread_dummy(0)
144
 
#define pthread_mutex_destroy(A) pthread_dummy(0)
145
 
#define pthread_attr_delete(A) pthread_dummy(0)
146
 
#define pthread_condattr_delete(A) pthread_dummy(0)
147
 
#define pthread_attr_setstacksize(A,B) pthread_dummy(0)
148
 
#define pthread_equal(A,B) ((A) == (B))
149
 
#define pthread_cond_timedwait(a,b,c) pthread_cond_wait((a),(b))
150
 
#define pthread_attr_init(A) pthread_attr_create(A)
151
 
#define pthread_attr_destroy(A) pthread_attr_delete(A)
152
 
#define pthread_attr_setdetachstate(A,B) pthread_dummy(0)
153
 
#define pthread_create(A,B,C,D) pthread_create((A),*(B),(C),(D))
154
 
#define pthread_sigmask(A,B,C) sigprocmask((A),(B),(C))
155
 
#define pthread_kill(A,B) pthread_dummy((A) ? 0 : ESRCH)
156
 
#undef  pthread_detach_this_thread
157
 
#define pthread_detach_this_thread() { pthread_t tmp=pthread_self() ; pthread_detach(&tmp); }
158
 
#endif
159
 
 
160
 
#ifdef HAVE_DARWIN5_THREADS
161
 
#define pthread_sigmask(A,B,C) sigprocmask((A),(B),(C))
162
 
#define pthread_kill(A,B) pthread_dummy((A) ? 0 : ESRCH)
163
 
#define pthread_condattr_init(A) pthread_dummy(0)
164
 
#define pthread_condattr_destroy(A) pthread_dummy(0)
165
 
#undef  pthread_detach_this_thread
166
 
#define pthread_detach_this_thread() { pthread_t tmp=pthread_self() ; pthread_detach(tmp); }
167
 
#endif
168
 
 
169
 
#if (defined(HAVE_PTHREAD_ATTR_CREATE) && !defined(HAVE_SIGWAIT))
170
 
/* This is set on AIX_3_2 and Siemens unix (and DEC OSF/1 3.2 too) */
171
 
#define pthread_key_create(A,B) \
172
 
                pthread_keycreate(A,(B) ?\
173
 
                                  (pthread_destructor_t) (B) :\
174
 
                                  (pthread_destructor_t) pthread_dummy)
175
 
#define pthread_attr_init(A) pthread_attr_create(A)
176
 
#define pthread_attr_destroy(A) pthread_attr_delete(A)
177
 
#define pthread_attr_setdetachstate(A,B) pthread_dummy(0)
178
 
#define pthread_create(A,B,C,D) pthread_create((A),*(B),(C),(D))
179
 
#ifndef pthread_sigmask
180
 
#define pthread_sigmask(A,B,C) sigprocmask((A),(B),(C))
181
 
#endif
182
 
#define pthread_kill(A,B) pthread_dummy((A) ? 0 : ESRCH)
183
 
#undef  pthread_detach_this_thread
184
 
#define pthread_detach_this_thread() { pthread_t tmp=pthread_self() ; pthread_detach(&tmp); }
185
 
#else
186
 
#define HAVE_PTHREAD_KILL
187
 
#endif
188
 
 
189
 
#if defined(HAVE_POSIX1003_4a_MUTEX) && !defined(DONT_REMAP_PTHREAD_FUNCTIONS)
190
 
#undef pthread_mutex_trylock
191
 
#define pthread_mutex_trylock(a) my_pthread_mutex_trylock((a))
192
 
int my_pthread_mutex_trylock(pthread_mutex_t *mutex);
193
 
#endif
194
 
 
195
82
#if !defined(HAVE_PTHREAD_YIELD_ONE_ARG) && !defined(HAVE_PTHREAD_YIELD_ZERO_ARG)
196
83
/* no pthread_yield() available */
197
84
#ifdef HAVE_SCHED_YIELD
206
93
  for calculating an absolute time at which
207
94
  pthread_cond_timedwait should timeout
208
95
*/
209
 
#ifdef HAVE_TIMESPEC_TS_SEC
210
 
#ifndef set_timespec
211
 
#define set_timespec(ABSTIME,SEC) \
212
 
{ \
213
 
  (ABSTIME).ts_sec=time(0) + (time_t) (SEC); \
214
 
  (ABSTIME).ts_nsec=0; \
215
 
}
216
 
#endif /* !set_timespec */
217
 
#ifndef set_timespec_nsec
218
 
#define set_timespec_nsec(ABSTIME,NSEC) \
219
 
{ \
220
 
  uint64_t now= my_getsystime() + (NSEC/100); \
221
 
  (ABSTIME).ts_sec=  (now / 10000000ULL); \
222
 
  (ABSTIME).ts_nsec= (now % 10000000ULL * 100 + ((NSEC) % 100)); \
223
 
}
224
 
#endif /* !set_timespec_nsec */
225
 
#else
226
96
#ifndef set_timespec
227
97
#define set_timespec(ABSTIME,SEC) \
228
98
{\
236
106
#define set_timespec_nsec(ABSTIME,NSEC) \
237
107
{\
238
108
  uint64_t now= my_getsystime() + (NSEC/100); \
239
 
  (ABSTIME).tv_sec=  (time_t) (now / 10000000ULL);                  \
240
 
  (ABSTIME).tv_nsec= (long) (now % 10000000ULL * 100 + ((NSEC) % 100)); \
 
109
  (ABSTIME).tv_sec=  (time_t) (now / 10000000UL);                  \
 
110
  (ABSTIME).tv_nsec= (long) (now % 10000000UL * 100 + ((NSEC) % 100)); \
241
111
}
242
112
#endif /* !set_timespec_nsec */
243
 
#endif /* HAVE_TIMESPEC_TS_SEC */
244
113
 
245
114
        /* safe_mutex adds checking to mutex for easier debugging */
246
115
 
248
117
{
249
118
  pthread_mutex_t global,mutex;
250
119
  const char *file;
251
 
  uint line,count;
 
120
  uint32_t line,count;
252
121
  pthread_t thread;
253
122
} safe_mutex_t;
254
123
 
255
124
int safe_mutex_init(safe_mutex_t *mp, const pthread_mutexattr_t *attr,
256
 
                    const char *file, uint line);
257
 
int safe_mutex_lock(safe_mutex_t *mp, bool try_lock, const char *file, uint line);
258
 
int safe_mutex_unlock(safe_mutex_t *mp,const char *file, uint line);
259
 
int safe_mutex_destroy(safe_mutex_t *mp,const char *file, uint line);
 
125
                    const char *file, uint32_t line);
 
126
int safe_mutex_lock(safe_mutex_t *mp, bool try_lock, const char *file, uint32_t line);
 
127
int safe_mutex_unlock(safe_mutex_t *mp,const char *file, uint32_t line);
 
128
int safe_mutex_destroy(safe_mutex_t *mp,const char *file, uint32_t line);
260
129
int safe_cond_wait(pthread_cond_t *cond, safe_mutex_t *mp,const char *file,
261
 
                   uint line);
 
130
                   uint32_t line);
262
131
int safe_cond_timedwait(pthread_cond_t *cond, safe_mutex_t *mp,
263
 
                        struct timespec *abstime, const char *file, uint line);
 
132
                        struct timespec *abstime, const char *file, uint32_t line);
264
133
void safe_mutex_global_init(void);
265
 
void safe_mutex_end(FILE *file);
 
134
void safe_mutex_end(void);
266
135
 
267
136
        /* Wrappers if safe mutex is actually used */
268
137
#define safe_mutex_assert_owner(mp)
269
138
#define safe_mutex_assert_not_owner(mp)
270
139
 
271
 
#if defined(MY_PTHREAD_FASTMUTEX)
272
 
typedef struct st_my_pthread_fastmutex_t
273
 
{
274
 
  pthread_mutex_t mutex;
275
 
  uint spins;
276
 
} my_pthread_fastmutex_t;
277
 
void fastmutex_global_init(void);
278
 
 
279
 
int my_pthread_fastmutex_init(my_pthread_fastmutex_t *mp, 
280
 
                              const pthread_mutexattr_t *attr);
281
 
int my_pthread_fastmutex_lock(my_pthread_fastmutex_t *mp);
282
 
 
283
 
#undef pthread_mutex_init
284
 
#undef pthread_mutex_lock
285
 
#undef pthread_mutex_unlock
286
 
#undef pthread_mutex_destroy
287
 
#undef pthread_mutex_wait
288
 
#undef pthread_mutex_timedwait
289
 
#undef pthread_mutex_t
290
 
#undef pthread_cond_wait
291
 
#undef pthread_cond_timedwait
292
 
#undef pthread_mutex_trylock
293
 
#define pthread_mutex_init(A,B) my_pthread_fastmutex_init((A),(B))
294
 
#define pthread_mutex_lock(A) my_pthread_fastmutex_lock(A)
295
 
#define pthread_mutex_unlock(A) pthread_mutex_unlock(&(A)->mutex)
296
 
#define pthread_mutex_destroy(A) pthread_mutex_destroy(&(A)->mutex)
297
 
#define pthread_cond_wait(A,B) pthread_cond_wait((A),&(B)->mutex)
298
 
#define pthread_cond_timedwait(A,B,C) pthread_cond_timedwait((A),&(B)->mutex,(C))
299
 
#define pthread_mutex_trylock(A) pthread_mutex_trylock(&(A)->mutex)
300
 
#define pthread_mutex_t my_pthread_fastmutex_t
301
 
#endif /* defined(MY_PTHREAD_FASTMUTEX) */
302
 
 
303
140
        /* READ-WRITE thread locking */
304
141
 
305
 
#ifdef HAVE_BROKEN_RWLOCK                       /* For OpenUnix */
306
 
#undef HAVE_PTHREAD_RWLOCK_RDLOCK
307
 
#undef HAVE_RWLOCK_INIT
308
 
#undef HAVE_RWLOCK_T
309
 
#endif
310
 
 
311
 
#if defined(USE_MUTEX_INSTEAD_OF_RW_LOCKS)
312
 
/* use these defs for simple mutex locking */
313
 
#define rw_lock_t pthread_mutex_t
314
 
#define my_rwlock_init(A,B) pthread_mutex_init((A),(B))
315
 
#define rw_rdlock(A) pthread_mutex_lock((A))
316
 
#define rw_wrlock(A) pthread_mutex_lock((A))
317
 
#define rw_tryrdlock(A) pthread_mutex_trylock((A))
318
 
#define rw_trywrlock(A) pthread_mutex_trylock((A))
319
 
#define rw_unlock(A) pthread_mutex_unlock((A))
320
 
#define rwlock_destroy(A) pthread_mutex_destroy((A))
321
 
#elif defined(HAVE_PTHREAD_RWLOCK_RDLOCK)
322
 
#define rw_lock_t pthread_rwlock_t
323
 
#define my_rwlock_init(A,B) pthread_rwlock_init((A),(B))
324
 
#define rw_rdlock(A) pthread_rwlock_rdlock(A)
325
 
#define rw_wrlock(A) pthread_rwlock_wrlock(A)
326
 
#define rw_tryrdlock(A) pthread_rwlock_tryrdlock((A))
327
 
#define rw_trywrlock(A) pthread_rwlock_trywrlock((A))
328
 
#define rw_unlock(A) pthread_rwlock_unlock(A)
329
 
#define rwlock_destroy(A) pthread_rwlock_destroy(A)
330
 
#elif defined(HAVE_RWLOCK_INIT)
331
 
#ifdef HAVE_RWLOCK_T                            /* For example Solaris 2.6-> */
332
 
#define rw_lock_t rwlock_t
333
 
#endif
334
 
#define my_rwlock_init(A,B) rwlock_init((A),USYNC_THREAD,0)
335
 
#else
336
 
/* Use our own version of read/write locks */
337
 
typedef struct _my_rw_lock_t {
338
 
        pthread_mutex_t lock;           /* lock for structure           */
339
 
        pthread_cond_t  readers;        /* waiting readers              */
340
 
        pthread_cond_t  writers;        /* waiting writers              */
341
 
        int             state;          /* -1:writer,0:free,>0:readers  */
342
 
        int             waiters;        /* number of waiting writers    */
343
 
} my_rw_lock_t;
344
 
 
345
 
#define rw_lock_t my_rw_lock_t
346
 
#define rw_rdlock(A) my_rw_rdlock((A))
347
 
#define rw_wrlock(A) my_rw_wrlock((A))
348
 
#define rw_tryrdlock(A) my_rw_tryrdlock((A))
349
 
#define rw_trywrlock(A) my_rw_trywrlock((A))
350
 
#define rw_unlock(A) my_rw_unlock((A))
351
 
#define rwlock_destroy(A) my_rwlock_destroy((A))
352
 
 
353
 
extern int my_rwlock_init(my_rw_lock_t *, void *);
354
 
extern int my_rwlock_destroy(my_rw_lock_t *);
355
 
extern int my_rw_rdlock(my_rw_lock_t *);
356
 
extern int my_rw_wrlock(my_rw_lock_t *);
357
 
extern int my_rw_unlock(my_rw_lock_t *);
358
 
extern int my_rw_tryrdlock(my_rw_lock_t *);
359
 
extern int my_rw_trywrlock(my_rw_lock_t *);
360
 
#endif /* USE_MUTEX_INSTEAD_OF_RW_LOCKS */
361
 
 
362
 
#ifndef HAVE_THR_SETCONCURRENCY
363
 
#define thr_setconcurrency(A) pthread_dummy(0)
364
 
#endif
365
142
#if !defined(HAVE_PTHREAD_ATTR_SETSTACKSIZE) && ! defined(pthread_attr_setstacksize)
366
143
#define pthread_attr_setstacksize(A,B) pthread_dummy(0)
367
144
#endif
368
145
 
369
146
/* Define mutex types, see my_thr_init.c */
370
 
#define MY_MUTEX_INIT_SLOW   NULL
371
 
#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
 
147
#ifdef THREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
372
148
extern pthread_mutexattr_t my_fast_mutexattr;
373
149
#define MY_MUTEX_INIT_FAST &my_fast_mutexattr
374
150
#else
375
151
#define MY_MUTEX_INIT_FAST   NULL
376
152
#endif
377
 
#ifdef PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
378
 
extern pthread_mutexattr_t my_errorcheck_mutexattr;
379
 
#define MY_MUTEX_INIT_ERRCHK &my_errorcheck_mutexattr
380
 
#else
381
 
#define MY_MUTEX_INIT_ERRCHK   NULL
382
 
#endif
383
153
 
384
154
#ifndef ESRCH
385
155
/* Define it to something */
386
156
#define ESRCH 1
387
157
#endif
388
158
 
389
 
typedef ulong my_thread_id;
390
 
 
391
159
extern bool my_thread_global_init(void);
392
160
extern void my_thread_global_end(void);
393
161
extern bool my_thread_init(void);
394
162
extern void my_thread_end(void);
395
163
extern const char *my_thread_name(void);
396
 
extern my_thread_id my_thread_dbug_id(void);
397
164
 
398
165
/* All thread specific variables are in the following struct */
399
166
 
400
 
#define THREAD_NAME_SIZE 10
401
 
#ifndef DEFAULT_THREAD_STACK
402
 
#if SIZEOF_CHARP > 4
403
167
/*
404
 
  MySQL can survive with 32K, but some glibc libraries require > 128K stack
405
 
  To resolve hostnames. Also recursive stored procedures needs stack.
 
168
  Drizzle can survive with 32K, but some glibc libraries require > 128K stack
 
169
  to resolve hostnames. Also recursive stored procedures needs stack.
406
170
*/
407
 
#define DEFAULT_THREAD_STACK    (256*1024L)
408
 
#else
409
 
#define DEFAULT_THREAD_STACK    (192*1024)
410
 
#endif
411
 
#endif
 
171
#define DEFAULT_THREAD_STACK    (256*INT32_C(1024))
412
172
 
413
173
struct st_my_thread_var
414
174
{
417
177
  pthread_mutex_t * volatile current_mutex;
418
178
  pthread_cond_t * volatile current_cond;
419
179
  pthread_t pthread_self;
420
 
  my_thread_id id;
421
 
  int cmp_length;
 
180
  uint64_t id;
422
181
  int volatile abort;
423
182
  bool init;
424
183
  struct st_my_thread_var *next,**prev;
425
184
  void *opt_info;
426
185
};
427
186
 
428
 
extern struct st_my_thread_var *_my_thread_var(void) __attribute__ ((const));
429
 
extern uint my_thread_end_wait_time;
 
187
extern struct st_my_thread_var *_my_thread_var(void);
430
188
#define my_thread_var (_my_thread_var())
431
189
/*
432
190
  Keep track of shutdown,signal, and main threads so that my_end() will not
439
197
#define THD_LIB_NPTL  2
440
198
#define THD_LIB_LT    4
441
199
 
442
 
extern uint thd_lib_detected;
 
200
extern uint32_t thd_lib_detected;
443
201
 
444
202
/*
445
203
  thread_safe_xxx functions are for critical statistic or counters.
485
243
#ifdef  __cplusplus
486
244
}
487
245
#endif
488
 
#endif /* _my_ptread_h */
 
246
#endif /* DRIZZLED_INTERNAL_MY_PTHREAD_H */