← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to include/my_pthread.h

Merged in changes. 
Edited a the comment test case so deal with our version bump.

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/my_pthread.h
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 <stdint.h>
22
 
#include <unistd.h>
23
 
#include <signal.h>
 
18
#ifndef _my_pthread_h
 
19
#define _my_pthread_h
24
20
 
25
21
#ifndef ETIME
26
22
#define ETIME ETIMEDOUT                         /* For FreeBSD */
31
27
extern "C" {
32
28
#else
33
29
#define EXTERNC
34
 
#endif /* __cplusplus */
 
30
#endif /* __cplusplus */ 
35
31
 
36
32
#include <pthread.h>
37
33
#ifndef _REENTRANT
45
41
#endif
46
42
 
47
43
#define pthread_key(T,V) pthread_key_t V
48
 
#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 *
49
48
typedef void *(* pthread_handler)(void *);
50
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
 
51
85
 
52
86
/*
53
87
  We define my_sigset() and use that instead of the system sigset() so that
55
89
  as Mac OS X, sigset() results in flags such as SA_RESTART being set, and
56
90
  we want to make sure that no such flags are set.
57
91
*/
58
 
#if !defined(my_sigset)
 
92
#if defined(HAVE_SIGACTION) && !defined(my_sigset)
59
93
#define my_sigset(A,B) do { struct sigaction l_s; sigset_t l_set; int l_rc; \
60
 
                            assert((A) != 0);                          \
 
94
                            DBUG_ASSERT((A) != 0);                          \
61
95
                            sigemptyset(&l_set);                            \
62
96
                            l_s.sa_handler = (B);                           \
63
97
                            l_s.sa_mask   = l_set;                          \
64
98
                            l_s.sa_flags   = 0;                             \
65
99
                            l_rc= sigaction((A), &l_s, (struct sigaction *) NULL);\
66
 
                            assert(l_rc == 0);                         \
 
100
                            DBUG_ASSERT(l_rc == 0);                         \
67
101
                          } while (0)
68
102
#elif defined(HAVE_SIGSET) && !defined(my_sigset)
69
103
#define my_sigset(A,B) sigset((A),(B))
71
105
#define my_sigset(A,B) signal((A),(B))
72
106
#endif
73
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
 
74
118
#ifndef my_pthread_attr_setprio
75
119
#ifdef HAVE_PTHREAD_ATTR_SETPRIO
76
120
#define my_pthread_attr_setprio(A,B) pthread_attr_setprio((A),(B))
79
123
#endif
80
124
#endif
81
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
 
82
195
#if !defined(HAVE_PTHREAD_YIELD_ONE_ARG) && !defined(HAVE_PTHREAD_YIELD_ZERO_ARG)
83
196
/* no pthread_yield() available */
84
197
#ifdef HAVE_SCHED_YIELD
93
206
  for calculating an absolute time at which
94
207
  pthread_cond_timedwait should timeout
95
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 / ULL(10000000)); \
 
222
  (ABSTIME).ts_nsec= (now % ULL(10000000) * 100 + ((NSEC) % 100)); \
 
223
}
 
224
#endif /* !set_timespec_nsec */
 
225
#else
96
226
#ifndef set_timespec
97
227
#define set_timespec(ABSTIME,SEC) \
98
228
{\
105
235
#ifndef set_timespec_nsec
106
236
#define set_timespec_nsec(ABSTIME,NSEC) \
107
237
{\
108
 
  uint64_t now= my_getsystime() + (NSEC/100); \
109
 
  (ABSTIME).tv_sec=  (time_t) (now / 10000000UL);                  \
110
 
  (ABSTIME).tv_nsec= (long) (now % 10000000UL * 100 + ((NSEC) % 100)); \
 
238
  ulonglong now= my_getsystime() + (NSEC/100); \
 
239
  (ABSTIME).tv_sec=  (time_t) (now / ULL(10000000));                  \
 
240
  (ABSTIME).tv_nsec= (long) (now % ULL(10000000) * 100 + ((NSEC) % 100)); \
111
241
}
112
242
#endif /* !set_timespec_nsec */
 
243
#endif /* HAVE_TIMESPEC_TS_SEC */
113
244
 
114
245
        /* safe_mutex adds checking to mutex for easier debugging */
115
246
 
117
248
{
118
249
  pthread_mutex_t global,mutex;
119
250
  const char *file;
120
 
  uint32_t line,count;
 
251
  uint line,count;
121
252
  pthread_t thread;
122
253
} safe_mutex_t;
123
254
 
124
255
int safe_mutex_init(safe_mutex_t *mp, const pthread_mutexattr_t *attr,
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);
 
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);
129
260
int safe_cond_wait(pthread_cond_t *cond, safe_mutex_t *mp,const char *file,
130
 
                   uint32_t line);
 
261
                   uint line);
131
262
int safe_cond_timedwait(pthread_cond_t *cond, safe_mutex_t *mp,
132
 
                        struct timespec *abstime, const char *file, uint32_t line);
 
263
                        struct timespec *abstime, const char *file, uint line);
133
264
void safe_mutex_global_init(void);
134
 
void safe_mutex_end(void);
 
265
void safe_mutex_end(FILE *file);
135
266
 
136
267
        /* Wrappers if safe mutex is actually used */
137
268
#define safe_mutex_assert_owner(mp)
138
269
#define safe_mutex_assert_not_owner(mp)
139
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
 
140
303
        /* READ-WRITE thread locking */
141
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
142
365
#if !defined(HAVE_PTHREAD_ATTR_SETSTACKSIZE) && ! defined(pthread_attr_setstacksize)
143
366
#define pthread_attr_setstacksize(A,B) pthread_dummy(0)
144
367
#endif
145
368
 
146
369
/* Define mutex types, see my_thr_init.c */
147
 
#ifdef THREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
 
370
#define MY_MUTEX_INIT_SLOW   NULL
 
371
#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
148
372
extern pthread_mutexattr_t my_fast_mutexattr;
149
373
#define MY_MUTEX_INIT_FAST &my_fast_mutexattr
150
374
#else
151
375
#define MY_MUTEX_INIT_FAST   NULL
152
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
153
383
 
154
384
#ifndef ESRCH
155
385
/* Define it to something */
156
386
#define ESRCH 1
157
387
#endif
158
388
 
159
 
extern bool my_thread_global_init(void);
 
389
typedef ulong my_thread_id;
 
390
 
 
391
extern my_bool my_thread_global_init(void);
160
392
extern void my_thread_global_end(void);
161
 
extern bool my_thread_init(void);
 
393
extern my_bool my_thread_init(void);
162
394
extern void my_thread_end(void);
163
395
extern const char *my_thread_name(void);
 
396
extern my_thread_id my_thread_dbug_id(void);
164
397
 
165
398
/* All thread specific variables are in the following struct */
166
399
 
 
400
#define THREAD_NAME_SIZE 10
 
401
#ifndef DEFAULT_THREAD_STACK
 
402
#if SIZEOF_CHARP > 4
167
403
/*
168
 
  Drizzle can survive with 32K, but some glibc libraries require > 128K stack
169
 
  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.
170
406
*/
171
 
#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
172
412
 
173
413
struct st_my_thread_var
174
414
{
177
417
  pthread_mutex_t * volatile current_mutex;
178
418
  pthread_cond_t * volatile current_cond;
179
419
  pthread_t pthread_self;
180
 
  uint64_t id;
 
420
  my_thread_id id;
 
421
  int cmp_length;
181
422
  int volatile abort;
182
 
  bool init;
 
423
  my_bool init;
183
424
  struct st_my_thread_var *next,**prev;
184
425
  void *opt_info;
 
426
#ifndef DBUG_OFF
 
427
  void *dbug;
 
428
  char name[THREAD_NAME_SIZE+1];
 
429
#endif
185
430
};
186
431
 
187
 
extern struct st_my_thread_var *_my_thread_var(void);
 
432
extern struct st_my_thread_var *_my_thread_var(void) __attribute__ ((const));
 
433
extern uint my_thread_end_wait_time;
188
434
#define my_thread_var (_my_thread_var())
189
435
/*
190
436
  Keep track of shutdown,signal, and main threads so that my_end() will not
197
443
#define THD_LIB_NPTL  2
198
444
#define THD_LIB_LT    4
199
445
 
200
 
extern uint32_t thd_lib_detected;
 
446
extern uint thd_lib_detected;
201
447
 
202
448
/*
203
449
  thread_safe_xxx functions are for critical statistic or counters.
207
453
  to use my_atomic operations instead.
208
454
*/
209
455
 
 
456
/*
 
457
  Warning:
 
458
  When compiling without threads, this file is not included.
 
459
  See the *other* declarations of thread_safe_xxx in include/my_global.h
 
460
 
 
461
  Second warning:
 
462
  See include/config-win.h, for yet another implementation.
 
463
*/
 
464
#ifdef THREAD
210
465
#ifndef thread_safe_increment
211
466
#define thread_safe_increment(V,L) \
212
467
        (pthread_mutex_lock((L)), (V)++, pthread_mutex_unlock((L)))
220
475
#define thread_safe_sub(V,C,L) \
221
476
        (pthread_mutex_lock((L)), (V)-=(C), pthread_mutex_unlock((L)))
222
477
#endif
 
478
#endif
223
479
 
224
480
/*
225
481
  statistics_xxx functions are for non critical statistic,
243
499
#ifdef  __cplusplus
244
500
}
245
501
#endif
246
 
#endif /* DRIZZLED_INTERNAL_MY_PTHREAD_H */
 
502
#endif /* _my_ptread_h */