← 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-05-27 01:25:56 UTC
  • mfrom: (1567.1.4 new-staging)
  • Revision ID: brian@gaz-20100527012556-5zgkirkl7swbigd6
Merge of Brian, Paul. PBXT compile issue, and test framework cleanup. 

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