~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to include/my_pthread.h

  • Committer: Stewart Smith
  • Date: 2008-07-13 06:56:15 UTC
  • mto: (210.1.1 drizzle)
  • mto: This revision was merged to the branch mainline in revision 211.
  • Revision ID: stewart@flamingspork.com-20080713065615-vzok75kgnnviokl9
Move MD5() into a UDF

Show diffs side-by-side

added added

removed removed

Lines of Context:
15
15
 
16
16
/* Defines to make different thread packages compatible */
17
17
 
18
 
#ifndef DRIZZLED_INTERNAL_MY_PTHREAD_H
19
 
#define DRIZZLED_INTERNAL_MY_PTHREAD_H
20
 
 
21
 
#include <unistd.h>
22
 
#include <signal.h>
 
18
#ifndef _my_pthread_h
 
19
#define _my_pthread_h
23
20
 
24
21
#ifndef ETIME
25
22
#define ETIME ETIMEDOUT                         /* For FreeBSD */
26
23
#endif
27
24
 
 
25
#ifdef  __cplusplus
 
26
#define EXTERNC extern "C"
 
27
extern "C" {
 
28
#else
 
29
#define EXTERNC
 
30
#endif /* __cplusplus */ 
 
31
 
28
32
#include <pthread.h>
29
33
#ifndef _REENTRANT
30
34
#define _REENTRANT
36
40
#include <synch.h>
37
41
#endif
38
42
 
39
 
namespace drizzled
40
 
{
41
 
namespace internal
42
 
{
43
 
 
44
43
#define pthread_key(T,V) pthread_key_t V
45
 
#define pthread_handler_t void *
 
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 *
46
48
typedef void *(* pthread_handler)(void *);
47
49
 
 
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
 
48
85
 
49
86
/*
50
87
  We define my_sigset() and use that instead of the system sigset() so that
52
89
  as Mac OS X, sigset() results in flags such as SA_RESTART being set, and
53
90
  we want to make sure that no such flags are set.
54
91
*/
55
 
#if !defined(my_sigset)
 
92
#if defined(HAVE_SIGACTION) && !defined(my_sigset)
56
93
#define my_sigset(A,B) do { struct sigaction l_s; sigset_t l_set; int l_rc; \
57
 
                            assert((A) != 0);                          \
 
94
                            DBUG_ASSERT((A) != 0);                          \
58
95
                            sigemptyset(&l_set);                            \
59
96
                            l_s.sa_handler = (B);                           \
60
97
                            l_s.sa_mask   = l_set;                          \
61
98
                            l_s.sa_flags   = 0;                             \
62
99
                            l_rc= sigaction((A), &l_s, (struct sigaction *) NULL);\
63
 
                            assert(l_rc == 0);                         \
 
100
                            DBUG_ASSERT(l_rc == 0);                         \
64
101
                          } while (0)
65
102
#elif defined(HAVE_SIGSET) && !defined(my_sigset)
66
103
#define my_sigset(A,B) sigset((A),(B))
68
105
#define my_sigset(A,B) signal((A),(B))
69
106
#endif
70
107
 
 
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
 
71
118
#ifndef my_pthread_attr_setprio
72
119
#ifdef HAVE_PTHREAD_ATTR_SETPRIO
73
120
#define my_pthread_attr_setprio(A,B) pthread_attr_setprio((A),(B))
76
123
#endif
77
124
#endif
78
125
 
 
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
 
79
195
#if !defined(HAVE_PTHREAD_YIELD_ONE_ARG) && !defined(HAVE_PTHREAD_YIELD_ZERO_ARG)
80
196
/* no pthread_yield() available */
81
197
#ifdef HAVE_SCHED_YIELD
90
206
  for calculating an absolute time at which
91
207
  pthread_cond_timedwait should timeout
92
208
*/
 
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
  ulonglong 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
93
226
#ifndef set_timespec
94
227
#define set_timespec(ABSTIME,SEC) \
95
228
{\
102
235
#ifndef set_timespec_nsec
103
236
#define set_timespec_nsec(ABSTIME,NSEC) \
104
237
{\
105
 
  uint64_t now= my_getsystime() + (NSEC/100); \
106
 
  (ABSTIME).tv_sec=  (time_t) (now / 10000000UL);                  \
107
 
  (ABSTIME).tv_nsec= (long) (now % 10000000UL * 100 + ((NSEC) % 100)); \
 
238
  ulonglong now= my_getsystime() + (NSEC/100); \
 
239
  (ABSTIME).tv_sec=  (time_t) (now / 10000000ULL);                  \
 
240
  (ABSTIME).tv_nsec= (long) (now % 10000000ULL * 100 + ((NSEC) % 100)); \
108
241
}
109
242
#endif /* !set_timespec_nsec */
 
243
#endif /* HAVE_TIMESPEC_TS_SEC */
110
244
 
111
245
        /* safe_mutex adds checking to mutex for easier debugging */
112
246
 
114
248
{
115
249
  pthread_mutex_t global,mutex;
116
250
  const char *file;
117
 
  uint32_t line,count;
 
251
  uint line,count;
118
252
  pthread_t thread;
119
253
} safe_mutex_t;
120
254
 
121
255
int safe_mutex_init(safe_mutex_t *mp, const pthread_mutexattr_t *attr,
122
 
                    const char *file, uint32_t line);
123
 
int safe_mutex_lock(safe_mutex_t *mp, bool try_lock, const char *file, uint32_t line);
124
 
int safe_mutex_unlock(safe_mutex_t *mp,const char *file, uint32_t line);
125
 
int safe_mutex_destroy(safe_mutex_t *mp,const char *file, uint32_t line);
 
256
                    const char *file, uint line);
 
257
int safe_mutex_lock(safe_mutex_t *mp, my_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);
126
260
int safe_cond_wait(pthread_cond_t *cond, safe_mutex_t *mp,const char *file,
127
 
                   uint32_t line);
 
261
                   uint line);
128
262
int safe_cond_timedwait(pthread_cond_t *cond, safe_mutex_t *mp,
129
 
                        struct timespec *abstime, const char *file, uint32_t line);
 
263
                        struct timespec *abstime, const char *file, uint line);
130
264
void safe_mutex_global_init(void);
131
 
void safe_mutex_end(void);
 
265
void safe_mutex_end(FILE *file);
132
266
 
133
267
        /* Wrappers if safe mutex is actually used */
134
268
#define safe_mutex_assert_owner(mp)
135
269
#define safe_mutex_assert_not_owner(mp)
136
270
 
 
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
 
137
303
        /* READ-WRITE thread locking */
138
304
 
 
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
139
365
#if !defined(HAVE_PTHREAD_ATTR_SETSTACKSIZE) && ! defined(pthread_attr_setstacksize)
140
366
#define pthread_attr_setstacksize(A,B) pthread_dummy(0)
141
367
#endif
142
368
 
143
369
/* Define mutex types, see my_thr_init.c */
144
 
#ifdef THREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
 
370
#define MY_MUTEX_INIT_SLOW   NULL
 
371
#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
145
372
extern pthread_mutexattr_t my_fast_mutexattr;
146
373
#define MY_MUTEX_INIT_FAST &my_fast_mutexattr
147
374
#else
148
375
#define MY_MUTEX_INIT_FAST   NULL
149
376
#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
150
383
 
151
384
#ifndef ESRCH
152
385
/* Define it to something */
153
386
#define ESRCH 1
154
387
#endif
155
388
 
156
 
extern bool my_thread_global_init(void);
 
389
typedef ulong my_thread_id;
 
390
 
 
391
extern my_bool my_thread_global_init(void);
157
392
extern void my_thread_global_end(void);
158
 
extern bool my_thread_init(void);
 
393
extern my_bool my_thread_init(void);
159
394
extern void my_thread_end(void);
160
395
extern const char *my_thread_name(void);
 
396
extern my_thread_id my_thread_dbug_id(void);
161
397
 
162
398
/* All thread specific variables are in the following struct */
163
399
 
 
400
#define THREAD_NAME_SIZE 10
 
401
#ifndef DEFAULT_THREAD_STACK
 
402
#if SIZEOF_CHARP > 4
164
403
/*
165
 
  Drizzle can survive with 32K, but some glibc libraries require > 128K stack
166
 
  to resolve hostnames. Also recursive stored procedures needs stack.
 
404
  MySQL can survive with 32K, but some glibc libraries require > 128K stack
 
405
  To resolve hostnames. Also recursive stored procedures needs stack.
167
406
*/
168
 
#define DEFAULT_THREAD_STACK    (256*INT32_C(1024))
 
407
#define DEFAULT_THREAD_STACK    (256*1024L)
 
408
#else
 
409
#define DEFAULT_THREAD_STACK    (192*1024)
 
410
#endif
 
411
#endif
169
412
 
170
413
struct st_my_thread_var
171
414
{
174
417
  pthread_mutex_t * volatile current_mutex;
175
418
  pthread_cond_t * volatile current_cond;
176
419
  pthread_t pthread_self;
177
 
  uint64_t id;
 
420
  my_thread_id id;
 
421
  int cmp_length;
178
422
  int volatile abort;
179
 
  bool init;
 
423
  my_bool init;
180
424
  struct st_my_thread_var *next,**prev;
181
425
  void *opt_info;
 
426
#ifndef DBUG_OFF
 
427
  void *dbug;
 
428
  char name[THREAD_NAME_SIZE+1];
 
429
#endif
182
430
};
183
431
 
184
 
extern struct st_my_thread_var *_my_thread_var(void);
185
 
#define my_thread_var (::drizzled::internal::_my_thread_var())
 
432
extern struct st_my_thread_var *_my_thread_var(void) __attribute__ ((const));
 
433
extern uint my_thread_end_wait_time;
 
434
#define my_thread_var (_my_thread_var())
186
435
/*
187
436
  Keep track of shutdown,signal, and main threads so that my_end() will not
188
437
  report errors with them
194
443
#define THD_LIB_NPTL  2
195
444
#define THD_LIB_LT    4
196
445
 
197
 
extern uint32_t thd_lib_detected;
 
446
extern uint thd_lib_detected;
198
447
 
199
448
/*
200
449
  thread_safe_xxx functions are for critical statistic or counters.
237
486
#define status_var_add(V,C)     (V)+=(C)
238
487
#define status_var_sub(V,C)     (V)-=(C)
239
488
 
240
 
} /* namespace internal */
241
 
} /* namespace drizzled */
242
 
 
243
 
#endif /* DRIZZLED_INTERNAL_MY_PTHREAD_H */
 
489
#ifdef  __cplusplus
 
490
}
 
491
#endif
 
492
#endif /* _my_ptread_h */