← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/my_pthread.h

  • Committer: Monty Taylor
  • Date: 2008-12-24 01:49:53 UTC
  • mto: This revision was merged to the branch mainline in revision 751.
  • Revision ID: mordred@inaugust.com-20081224014953-rc9p7a162p74y889
Fixed connect.test.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/my_pthread.h
18
18
#ifndef _my_pthread_h
19
19
#define _my_pthread_h
20
20
 
 
21
#include <stdint.h>
 
22
#include <unistd.h>
 
23
#include <signal.h>
 
24
 
 
25
#if !defined(__cplusplus)
 
26
# include <stdbool.h>
 
27
#endif
 
28
 
21
29
#ifndef ETIME
22
30
#define ETIME ETIMEDOUT                         /* For FreeBSD */
23
31
#endif
27
35
extern "C" {
28
36
#else
29
37
#define EXTERNC
30
 
#endif /* __cplusplus */ 
 
38
#endif /* __cplusplus */
31
39
 
32
40
#include <pthread.h>
33
41
#ifndef _REENTRANT
41
49
#endif
42
50
 
43
51
#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
52
#define pthread_detach_this_thread()
47
 
#define pthread_handler_t EXTERNC void *
 
53
#define pthread_handler_t void *
48
54
typedef void *(* pthread_handler)(void *);
49
55
 
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
56
#if defined(HAVE_SIGTHREADMASK) && !defined(HAVE_PTHREAD_SIGMASK)
78
57
#define pthread_sigmask(A,B,C) sigthreadmask((A),(B),(C))
79
58
#endif
80
59
 
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
60
 
86
61
/*
87
62
  We define my_sigset() and use that instead of the system sigset() so that
105
80
#define my_sigset(A,B) signal((A),(B))
106
81
#endif
107
82
 
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
83
#ifndef my_pthread_attr_setprio
119
84
#ifdef HAVE_PTHREAD_ATTR_SETPRIO
120
85
#define my_pthread_attr_setprio(A,B) pthread_attr_setprio((A),(B))
123
88
#endif
124
89
#endif
125
90
 
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
91
#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
92
 
195
93
#if !defined(HAVE_PTHREAD_YIELD_ONE_ARG) && !defined(HAVE_PTHREAD_YIELD_ZERO_ARG)
196
94
/* no pthread_yield() available */
218
116
#define set_timespec_nsec(ABSTIME,NSEC) \
219
117
{ \
220
118
  uint64_t now= my_getsystime() + (NSEC/100); \
221
 
  (ABSTIME).ts_sec=  (now / 10000000ULL); \
222
 
  (ABSTIME).ts_nsec= (now % 10000000ULL * 100 + ((NSEC) % 100)); \
 
119
  (ABSTIME).ts_sec=  (now / 10000000UL); \
 
120
  (ABSTIME).ts_nsec= (now % 10000000UL * 100 + ((NSEC) % 100)); \
223
121
}
224
122
#endif /* !set_timespec_nsec */
225
123
#else
236
134
#define set_timespec_nsec(ABSTIME,NSEC) \
237
135
{\
238
136
  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)); \
 
137
  (ABSTIME).tv_sec=  (time_t) (now / 10000000UL);                  \
 
138
  (ABSTIME).tv_nsec= (long) (now % 10000000UL * 100 + ((NSEC) % 100)); \
241
139
}
242
140
#endif /* !set_timespec_nsec */
243
141
#endif /* HAVE_TIMESPEC_TS_SEC */
248
146
{
249
147
  pthread_mutex_t global,mutex;
250
148
  const char *file;
251
 
  uint line,count;
 
149
  uint32_t line,count;
252
150
  pthread_t thread;
253
151
} safe_mutex_t;
254
152
 
255
153
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);
 
154
                    const char *file, uint32_t line);
 
155
int safe_mutex_lock(safe_mutex_t *mp, bool try_lock, const char *file, uint32_t line);
 
156
int safe_mutex_unlock(safe_mutex_t *mp,const char *file, uint32_t line);
 
157
int safe_mutex_destroy(safe_mutex_t *mp,const char *file, uint32_t line);
260
158
int safe_cond_wait(pthread_cond_t *cond, safe_mutex_t *mp,const char *file,
261
 
                   uint line);
 
159
                   uint32_t line);
262
160
int safe_cond_timedwait(pthread_cond_t *cond, safe_mutex_t *mp,
263
 
                        struct timespec *abstime, const char *file, uint line);
 
161
                        struct timespec *abstime, const char *file, uint32_t line);
264
162
void safe_mutex_global_init(void);
265
 
void safe_mutex_end(FILE *file);
 
163
void safe_mutex_end(void);
266
164
 
267
165
        /* Wrappers if safe mutex is actually used */
268
166
#define safe_mutex_assert_owner(mp)
269
167
#define safe_mutex_assert_not_owner(mp)
270
168
 
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
169
        /* READ-WRITE thread locking */
304
170
 
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
171
#ifndef HAVE_THR_SETCONCURRENCY
363
172
#define thr_setconcurrency(A) pthread_dummy(0)
364
173
#endif
386
195
#define ESRCH 1
387
196
#endif
388
197
 
389
 
typedef ulong my_thread_id;
 
198
typedef uint64_t my_thread_id;
390
199
 
391
200
extern bool my_thread_global_init(void);
392
201
extern void my_thread_global_end(void);
398
207
/* All thread specific variables are in the following struct */
399
208
 
400
209
#define THREAD_NAME_SIZE 10
401
 
#ifndef DEFAULT_THREAD_STACK
402
 
#if SIZEOF_CHARP > 4
403
210
/*
404
 
  MySQL can survive with 32K, but some glibc libraries require > 128K stack
405
 
  To resolve hostnames. Also recursive stored procedures needs stack.
 
211
  Drizzle can survive with 32K, but some glibc libraries require > 128K stack
 
212
  to resolve hostnames. Also recursive stored procedures needs stack.
406
213
*/
407
 
#define DEFAULT_THREAD_STACK    (256*1024L)
408
 
#else
409
 
#define DEFAULT_THREAD_STACK    (192*1024)
410
 
#endif
411
 
#endif
 
214
#define DEFAULT_THREAD_STACK    (256*INT32_C(1024))
412
215
 
413
216
struct st_my_thread_var
414
217
{
425
228
  void *opt_info;
426
229
};
427
230
 
428
 
extern struct st_my_thread_var *_my_thread_var(void) __attribute__ ((const));
429
 
extern uint my_thread_end_wait_time;
 
231
extern struct st_my_thread_var *_my_thread_var(void);
 
232
extern uint32_t my_thread_end_wait_time;
430
233
#define my_thread_var (_my_thread_var())
431
234
/*
432
235
  Keep track of shutdown,signal, and main threads so that my_end() will not
439
242
#define THD_LIB_NPTL  2
440
243
#define THD_LIB_LT    4
441
244
 
442
 
extern uint thd_lib_detected;
 
245
extern uint32_t thd_lib_detected;
443
246
 
444
247
/*
445
248
  thread_safe_xxx functions are for critical statistic or counters.