开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
my_pthread.h
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：20k
源码类别：

MySQL数据库

开发平台：

Visual C++

my_pthread.h：源码内容
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    
  3.    This library is free software; you can redistribute it and/or
  4.    modify it under the terms of the GNU Library General Public
  5.    License as published by the Free Software Foundation; either
  6.    version 2 of the License, or (at your option) any later version.
  7.    
  8.    This library is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11.    Library General Public License for more details.
  12.    
  13.    You should have received a copy of the GNU Library General Public
  14.    License along with this library; if not, write to the Free
  15.    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  16.    MA 02111-1307, USA */
  18. /* Defines to make different thread packages compatible */
  20. #ifndef _my_pthread_h
  21. #define _my_pthread_h
  23. #include <errno.h>
  24. #ifndef ETIME
  25. #define ETIME ETIMEDOUT /* For FreeBSD */
  26. #endif
  28. #if defined(__WIN__)
  30. typedef CRITICAL_SECTION pthread_mutex_t;
  31. typedef HANDLE  pthread_t;
  32. typedef struct thread_attr {
  33.     DWORD dwStackSize ;
  34.     DWORD dwCreatingFlag ;
  35.     int priority ;
  36. } pthread_attr_t ;
  38. typedef struct { int dummy; } pthread_condattr_t;
  40. /* Implementation of posix conditions */
  42. typedef struct st_pthread_link {
  43.   DWORD thread_id;
  44.   struct st_pthread_link *next;
  45. } pthread_link;
  47. typedef struct {
  48.   uint32 waiting;
  49.   HANDLE semaphore;
  50. } pthread_cond_t;
  53. struct timespec { /* For pthread_cond_timedwait() */
  54.     time_t tv_sec;
  55.     long tv_nsec;
  56. };
  58. typedef int pthread_mutexattr_t;
  59. #define win_pthread_self my_thread_var->pthread_self
  60. #define pthread_handler_decl(A,B) void * __cdecl A(void *B)
  61. typedef void * (__cdecl *pthread_handler)(void *);
  63. void win_pthread_init(void);
  64. int win_pthread_setspecific(void *A,void *B,uint length);
  65. int pthread_create(pthread_t *,pthread_attr_t *,pthread_handler,void *);
  66. int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);
  67. int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
  68. int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
  69.    struct timespec *abstime);
  70. int pthread_cond_signal(pthread_cond_t *cond);
  71. int pthread_cond_broadcast(pthread_cond_t *cond);
  72. int pthread_cond_destroy(pthread_cond_t *cond);
  73. int pthread_attr_init(pthread_attr_t *connect_att);
  74. int pthread_attr_setstacksize(pthread_attr_t *connect_att,DWORD stack);
  75. int pthread_attr_setprio(pthread_attr_t *connect_att,int priority);
  76. int pthread_attr_destroy(pthread_attr_t *connect_att);
  77. struct tm *localtime_r(const time_t *timep,struct tm *tmp);
  79. void pthread_exit(void *a);  /* was #define pthread_exit(A) ExitThread(A)*/
  81. #define ETIMEDOUT 145     /* Win32 doesn't have this */
  82. #define getpid() GetCurrentThreadId()
  83. #define pthread_self() win_pthread_self
  84. #define HAVE_LOCALTIME_R
  85. #define _REENTRANT
  86. #define HAVE_PTHREAD_ATTR_SETSTACKSIZE
  88. #ifdef USE_TLS /* For LIBMYSQL.DLL */
  89. #undef SAFE_MUTEX /* This will cause conflicts */
  90. #define pthread_key(T,V)  DWORD V
  91. #define pthread_key_create(A,B) ((*A=TlsAlloc())==0xFFFFFFFF)
  92. #define pthread_getspecific(A) (TlsGetValue(A))
  93. #define my_pthread_getspecific(T,A) ((T) TlsGetValue(A))
  94. #define my_pthread_getspecific_ptr(T,V) ((T) TlsGetValue(V))
  95. #define my_pthread_setspecific_ptr(T,V) (!TlsSetValue((T),(V)))
  96. #define pthread_setspecific(A,B) (!TlsSetValue((A),(B)))
  97. #else
  98. #define pthread_key(T,V) __declspec(thread) T V
  99. #define pthread_key_create(A,B) pthread_dummy(0)
  100. #define pthread_getspecific(A) (&(A))
  101. #define my_pthread_getspecific(T,A) (&(A))
  102. #define my_pthread_getspecific_ptr(T,V) (V)
  103. #define my_pthread_setspecific_ptr(T,V) ((T)=(V),0)
  104. #define pthread_setspecific(A,B) win_pthread_setspecific(&(A),(B),sizeof(A))
  105. #endif /* USE_TLS */
  107. #define pthread_equal(A,B) ((A) == (B))
  108. #define pthread_mutex_init(A,B)  InitializeCriticalSection(A)
  109. #define pthread_mutex_lock(A)  (EnterCriticalSection(A),0)
  110. #define pthread_mutex_unlock(A)  LeaveCriticalSection(A)
  111. #define pthread_mutex_destroy(A) DeleteCriticalSection(A)
  112. #define my_pthread_setprio(A,B)  SetThreadPriority(GetCurrentThread(), (B))
  113. /* Dummy defines for easier code */
  114. #define pthread_kill(A,B) pthread_dummy(0)
  115. #define pthread_attr_setdetachstate(A,B) pthread_dummy(0)
  116. #define my_pthread_attr_setprio(A,B) pthread_attr_setprio(A,B)
  117. #define pthread_attr_setscope(A,B)
  118. #define pthread_detach_this_thread()
  119. #define pthread_condattr_init(A)
  120. #define pthread_condattr_destroy(A)
  122. /*Irena: compiler does not like this: */
  123. /*#define my_pthread_getprio(pthread_t thread_id) pthread_dummy(0) */
  124. #define my_pthread_getprio(thread_id) pthread_dummy(0)
  126. #elif defined(HAVE_UNIXWARE7_THREADS)
  128. #include <thread.h>
  129. #include <synch.h>
  131. #ifndef _REENTRANT
  132. #define _REENTRANT
  133. #endif
  135. #define HAVE_NONPOSIX_SIGWAIT
  136. #define pthread_t thread_t
  137. #define pthread_cond_t cond_t
  138. #define pthread_mutex_t mutex_t
  139. #define pthread_key_t thread_key_t
  140. typedef int pthread_attr_t; /* Needed by Unixware 7.0.0 */
  142. #define pthread_key_create(A,B) thr_keycreate((A),(B))
  144. #define pthread_handler_decl(A,B) void *A(void *B)
  145. #define pthread_key(T,V) pthread_key_t V
  147. void * my_pthread_getspecific_imp(pthread_key_t key);
  148. #define my_pthread_getspecific(A,B) ((A) my_pthread_getspecific_imp(B))
  149. #define my_pthread_getspecific_ptr(T,V) my_pthread_getspecific(T,V)
  151. #define pthread_setspecific(A,B) thr_setspecific(A,B)
  152. #define my_pthread_setspecific_ptr(T,V) pthread_setspecific(T,V)
  154. #define pthread_create(A,B,C,D) thr_create(NULL,65536L,(C),(D),THR_DETACHED,(A))
  155. #define pthread_cond_init(a,b) cond_init((a),USYNC_THREAD,NULL)
  156. #define pthread_cond_destroy(a) cond_destroy(a)
  157. #define pthread_cond_signal(a) cond_signal(a)
  158. #define pthread_cond_wait(a,b) cond_wait((a),(b))
  159. #define pthread_cond_timedwait(a,b,c) cond_timedwait((a),(b),(c))
  160. #define pthread_cond_broadcast(a) cond_broadcast(a)
  162. #define pthread_mutex_init(a,b) mutex_init((a),USYNC_THREAD,NULL)
  163. #define pthread_mutex_lock(a) mutex_lock(a)
  164. #define pthread_mutex_unlock(a) mutex_unlock(a)
  165. #define pthread_mutex_destroy(a) mutex_destroy(a)
  167. #define pthread_self() thr_self()
  168. #define pthread_exit(A) thr_exit(A)
  169. #define pthread_equal(A,B) (((A) == (B)) ? 1 : 0)
  170. #define pthread_kill(A,B) thr_kill((A),(B))
  171. #define HAVE_PTHREAD_KILL
  173. #define pthread_sigmask(A,B,C) thr_sigsetmask((A),(B),(C))
  175. extern int my_sigwait(const sigset_t *set,int *sig);
  177. #define pthread_detach_this_thread() pthread_dummy(0)
  179. #define pthread_attr_init(A) pthread_dummy(0)
  180. #define pthread_attr_destroy(A) pthread_dummy(0)
  181. #define pthread_attr_setscope(A,B) pthread_dummy(0)
  182. #define pthread_attr_setdetachstate(A,B) pthread_dummy(0)
  183. #define my_pthread_setprio(A,B) pthread_dummy (0)
  184. #define my_pthread_getprio(A) pthread_dummy (0)
  185. #define my_pthread_attr_setprio(A,B) pthread_dummy(0)
  187. #else /* Normal threads */
  189. #ifdef HAVE_rts_threads
  190. #define sigwait org_sigwait
  191. #include <signal.h>
  192. #undef sigwait
  193. #endif
  194. #undef _REENTRANT /* Fix if _REENTRANT is in pthread.h */
  195. #include <pthread.h>
  196. #ifndef _REENTRANT
  197. #define _REENTRANT
  198. #endif
  199. #ifdef HAVE_THR_SETCONCURRENCY
  200. #include <thread.h> /* Probably solaris */
  201. #endif
  202. #ifdef HAVE_SCHED_H
  203. #include <sched.h>
  204. #endif
  205. #ifdef HAVE_SYNCH_H
  206. #include <synch.h>
  207. #endif
  208. #if defined(__EMX__) && (!defined(EMX_PTHREAD_REV) || (EMX_PTHREAD_REV < 2))
  209. #error Requires at least rev 2 of EMX pthreads library.
  210. #endif
  212. extern int my_pthread_getprio(pthread_t thread_id);
  214. #define pthread_key(T,V) pthread_key_t V
  215. #define my_pthread_getspecific_ptr(T,V) my_pthread_getspecific(T,(V))
  216. #define my_pthread_setspecific_ptr(T,V) pthread_setspecific(T,(void*) (V))
  217. #define pthread_detach_this_thread()
  218. #define pthread_handler_decl(A,B) void *A(void *B)
  219. typedef void *(* pthread_handler)(void *);
  221. /* Test first for RTS or FSU threads */
  223. #if defined(PTHREAD_SCOPE_GLOBAL) && !defined(PTHREAD_SCOPE_SYSTEM)
  224. #define HAVE_rts_threads
  225. extern int my_pthread_create_detached;
  226. #define pthread_sigmask(A,B,C) sigprocmask((A),(B),(C))
  227. #define PTHREAD_CREATE_DETACHED &my_pthread_create_detached
  228. #define PTHREAD_SCOPE_SYSTEM  PTHREAD_SCOPE_GLOBAL
  229. #define PTHREAD_SCOPE_PROCESS PTHREAD_SCOPE_LOCAL
  230. #define USE_ALARM_THREAD
  231. #elif defined(HAVE_mit_thread)
  232. #define USE_ALARM_THREAD
  233. #undef HAVE_LOCALTIME_R
  234. #define HAVE_LOCALTIME_R
  235. #undef HAVE_PTHREAD_ATTR_SETSCOPE
  236. #define HAVE_PTHREAD_ATTR_SETSCOPE
  237. #undef HAVE_GETHOSTBYNAME_R_GLIBC2_STYLE /* If we are running linux */
  238. #undef HAVE_RWLOCK_T
  239. #undef HAVE_RWLOCK_INIT
  240. #undef HAVE_PTHREAD_RWLOCK_RDLOCK
  241. #undef HAVE_SNPRINTF
  243. #define sigset(A,B) pthread_signal((A),(void (*)(int)) (B))
  244. #define signal(A,B) pthread_signal((A),(void (*)(int)) (B))
  245. #define my_pthread_attr_setprio(A,B)
  246. #endif /* defined(PTHREAD_SCOPE_GLOBAL) && !defined(PTHREAD_SCOPE_SYSTEM) */
  248. #if defined(_BSDI_VERSION) && _BSDI_VERSION < 199910
  249. int sigwait(sigset_t *set, int *sig);
  250. #endif
  252. #if defined(HAVE_UNIXWARE7_POSIX)
  253. #undef HAVE_NONPOSIX_SIGWAIT
  254. #define HAVE_NONPOSIX_SIGWAIT /* sigwait takes only 1 argument */
  255. #endif
  257. #ifndef HAVE_NONPOSIX_SIGWAIT
  258. #define my_sigwait(A,B) sigwait((A),(B))
  259. #else
  260. int my_sigwait(const sigset_t *set,int *sig);
  261. #endif
  263. #ifdef HAVE_NONPOSIX_PTHREAD_MUTEX_INIT
  264. #ifndef SAFE_MUTEX
  265. #define pthread_mutex_init(a,b) my_pthread_mutex_init((a),(b))
  266. extern int my_pthread_mutex_init(pthread_mutex_t *mp,
  267.  const pthread_mutexattr_t *attr);
  268. #endif /* SAFE_MUTEX */
  269. #define pthread_cond_init(a,b) my_pthread_cond_init((a),(b))
  270. extern int my_pthread_cond_init(pthread_cond_t *mp,
  271. const pthread_condattr_t *attr);
  272. #endif /* HAVE_NONPOSIX_PTHREAD_MUTEX_INIT */
  274. #if defined(HAVE_SIGTHREADMASK) && !defined(HAVE_PTHREAD_SIGMASK)
  275. #define pthread_sigmask(A,B,C) sigthreadmask((A),(B),(C))
  276. #endif
  278. #if !defined(HAVE_SIGWAIT) && !defined(HAVE_mit_thread) && !defined(HAVE_rts_threads) && !defined(sigwait) && !defined(alpha_linux_port) && !defined(HAVE_NONPOSIX_SIGWAIT) && !defined(HAVE_DEC_3_2_THREADS) && !defined(_AIX)
  279. int sigwait(sigset_t *setp, int *sigp); /* Use our implemention */
  280. #endif
  281. #if !defined(HAVE_SIGSET) && !defined(HAVE_mit_thread) && !defined(sigset)
  282. #define sigset(A,B) do { struct sigaction s; sigset_t set;              
  283.                          sigemptyset(&set);                             
  284.                          s.sa_handler = (B);                            
  285.                          s.sa_mask    = set;                            
  286.                          s.sa_flags   = 0;                              
  287.                          sigaction((A), &s, (struct sigaction *) NULL); 
  288.                        } while (0)
  289. #endif
  291. #ifndef my_pthread_setprio
  292. #if defined(HAVE_PTHREAD_SETPRIO_NP) /* FSU threads */
  293. #define my_pthread_setprio(A,B) pthread_setprio_np((A),(B))
  294. #elif defined(HAVE_PTHREAD_SETPRIO)
  295. #define my_pthread_setprio(A,B) pthread_setprio((A),(B))
  296. #else
  297. extern void my_pthread_setprio(pthread_t thread_id,int prior);
  298. #endif
  299. #endif
  301. #ifndef my_pthread_attr_setprio
  302. #ifdef HAVE_PTHREAD_ATTR_SETPRIO
  303. #define my_pthread_attr_setprio(A,B) pthread_attr_setprio((A),(B))
  304. #else
  305. extern void my_pthread_attr_setprio(pthread_attr_t *attr, int priority);
  306. #endif
  307. #endif
  309. #if !defined(HAVE_PTHREAD_ATTR_SETSCOPE) || defined(HAVE_DEC_3_2_THREADS)
  310. #define pthread_attr_setscope(A,B)
  311. #undef HAVE_GETHOSTBYADDR_R /* No definition */
  312. #endif
  314. #ifndef HAVE_NONPOSIX_PTHREAD_GETSPECIFIC
  315. #define my_pthread_getspecific(A,B) ((A) pthread_getspecific(B))
  316. #else
  317. #define my_pthread_getspecific(A,B) ((A) my_pthread_getspecific_imp(B))
  318. void *my_pthread_getspecific_imp(pthread_key_t key);
  319. #endif
  321. #ifndef HAVE_LOCALTIME_R
  322. struct tm *localtime_r(const time_t *clock, struct tm *res);
  323. #endif
  325. #ifdef HAVE_PTHREAD_CONDATTR_CREATE
  326. /* DCE threads on HPUX 10.20 */
  327. #define pthread_condattr_init pthread_condattr_create
  328. #define pthread_condattr_destroy pthread_condattr_delete
  329. #endif
  331. #ifdef HAVE_CTHREADS_WRAPPER /* For MacOSX */
  332. #define pthread_cond_destroy(A) pthread_dummy(0)
  333. #define pthread_mutex_destroy(A) pthread_dummy(0)
  334. #define pthread_attr_delete(A) pthread_dummy(0)
  335. #define pthread_condattr_delete(A) pthread_dummy(0)
  336. #define pthread_attr_setstacksize(A,B) pthread_dummy(0)
  337. #define pthread_equal(A,B) ((A) == (B))
  338. #define pthread_cond_timedwait(a,b,c) pthread_cond_wait((a),(b))
  339. #define pthread_attr_init(A) pthread_attr_create(A)
  340. #define pthread_attr_destroy(A) pthread_attr_delete(A)
  341. #define pthread_attr_setdetachstate(A,B) pthread_dummy(0)
  342. #define pthread_create(A,B,C,D) pthread_create((A),*(B),(C),(D))
  343. #define pthread_sigmask(A,B,C) sigprocmask((A),(B),(C))
  344. #define pthread_kill(A,B) pthread_dummy(0)
  345. #undef pthread_detach_this_thread
  346. #define pthread_detach_this_thread() { pthread_t tmp=pthread_self() ; pthread_detach(&tmp); }
  347. #endif
  349. #ifdef HAVE_DARWIN_THREADS
  350. #define pthread_sigmask(A,B,C) sigprocmask((A),(B),(C))
  351. #define pthread_kill(A,B) pthread_dummy(0)
  352. #define pthread_condattr_init(A) pthread_dummy(0)
  353. #define pthread_condattr_destroy(A) pthread_dummy(0)
  354. #define pthread_signal(A,B) pthread_dummy(0)
  355. #undef pthread_detach_this_thread
  356. #define pthread_detach_this_thread() { pthread_t tmp=pthread_self() ; pthread_detach(tmp); }
  357. #undef sigset
  358. #define sigset(A,B) pthread_signal((A),(void (*)(int)) (B))
  359. #endif
  361. #if ((defined(HAVE_PTHREAD_ATTR_CREATE) && !defined(HAVE_SIGWAIT)) || defined(HAVE_DEC_3_2_THREADS)) && !defined(HAVE_CTHREADS_WRAPPER)
  362. /* This is set on AIX_3_2 and Siemens unix (and DEC OSF/1 3.2 too) */
  363. #define pthread_key_create(A,B) 
  364. pthread_keycreate(A,(B) ?
  365.   (pthread_destructor_t) (B) :
  366.   (pthread_destructor_t) pthread_dummy)
  367. #define pthread_attr_init(A) pthread_attr_create(A)
  368. #define pthread_attr_destroy(A) pthread_attr_delete(A)
  369. #define pthread_attr_setdetachstate(A,B) pthread_dummy(0)
  370. #define pthread_create(A,B,C,D) pthread_create((A),*(B),(C),(D))
  371. #ifndef pthread_sigmask
  372. #define pthread_sigmask(A,B,C) sigprocmask((A),(B),(C))
  373. #endif
  374. #define pthread_kill(A,B) pthread_dummy(0)
  375. #undef pthread_detach_this_thread
  376. #define pthread_detach_this_thread() { pthread_t tmp=pthread_self() ; pthread_detach(&tmp); }
  377. #else /* HAVE_PTHREAD_ATTR_CREATE && !HAVE_SIGWAIT */
  378. #define HAVE_PTHREAD_KILL
  379. #endif
  381. #if defined(HAVE_PTHREAD_ATTR_CREATE) || defined(_AIX) || defined(HAVE_GETHOSTBYNAME_R_GLIBC2_STYLE)
  382. #if !defined(HPUX)
  383. struct hostent;
  384. #endif /* HPUX */
  385. struct hostent *my_gethostbyname_r(const char *name,
  386.    struct hostent *result, char *buffer,
  387.    int buflen, int *h_errnop);
  388. #if defined(HAVE_GETHOSTBYNAME_R_GLIBC2_STYLE)
  389. #define GETHOSTBYNAME_BUFF_SIZE 2048
  390. #else
  391. #define GETHOSTBYNAME_BUFF_SIZE sizeof(struct hostent_data)
  392. #endif /* defined(HAVE_GETHOSTBYNAME_R_GLIBC2_STYLE) */
  394. #else
  395. #ifdef HAVE_GETHOSTBYNAME_R_RETURN_INT
  396. #define GETHOSTBYNAME_BUFF_SIZE sizeof(struct hostent_data)
  397. struct hostent *my_gethostbyname_r(const char *name,
  398.    struct hostent *result, char *buffer,
  399.    int buflen, int *h_errnop);
  400. #else
  401. #define GETHOSTBYNAME_BUFF_SIZE 2048
  402. #define my_gethostbyname_r(A,B,C,D,E) gethostbyname_r((A),(B),(C),(D),(E))
  403. #endif /* HAVE_GETHOSTBYNAME_R_RETURN_INT */
  404. #endif /* defined(HAVE_PTHREAD_ATTR_CREATE) || defined(_AIX) || defined(HAVE_GETHOSTBYNAME_R_GLIBC2_STYLE) */
  406. #endif /* defined(__WIN__) */
  408. /* safe_mutex adds checking to mutex for easier debugging */
  410. typedef struct st_safe_mutex_t
  411. {
  412.   pthread_mutex_t global,mutex;
  413.   char *file;
  414.   uint line,count;
  415.   pthread_t thread;
  416. } safe_mutex_t;
  418. int safe_mutex_init(safe_mutex_t *mp, const pthread_mutexattr_t *attr);
  419. int safe_mutex_lock(safe_mutex_t *mp,const char *file, uint line);
  420. int safe_mutex_unlock(safe_mutex_t *mp,const char *file, uint line);
  421. int safe_mutex_destroy(safe_mutex_t *mp,const char *file, uint line);
  422. int safe_cond_wait(pthread_cond_t *cond, safe_mutex_t *mp,const char *file,
  423.    uint line);
  424. int safe_cond_timedwait(pthread_cond_t *cond, safe_mutex_t *mp,
  425. struct timespec *abstime, const char *file, uint line);
  427. /* Wrappers if safe mutex is actually used */
  428. #ifdef SAFE_MUTEX
  429. #undef pthread_mutex_init
  430. #undef pthread_mutex_lock
  431. #undef pthread_mutex_unlock
  432. #undef pthread_mutex_destroy
  433. #undef pthread_mutex_wait
  434. #undef pthread_mutex_timedwait
  435. #undef pthread_mutex_t
  436. #undef pthread_cond_wait
  437. #undef pthread_cond_timedwait
  438. #define pthread_mutex_init(A,B) safe_mutex_init((A),(B))
  439. #define pthread_mutex_lock(A) safe_mutex_lock((A),__FILE__,__LINE__)
  440. #define pthread_mutex_unlock(A) safe_mutex_unlock((A),__FILE__,__LINE__)
  441. #define pthread_mutex_destroy(A) safe_mutex_destroy((A),__FILE__,__LINE__)
  442. #define pthread_cond_wait(A,B) safe_cond_wait((A),(B),__FILE__,__LINE__)
  443. #define pthread_cond_timedwait(A,B,C) safe_cond_timedwait((A),(B),(C),__FILE__,__LINE__)
  444. #define pthread_mutex_trylock(A) pthread_mutex_lock(A)
  445. #define pthread_mutex_t safe_mutex_t
  446. #endif /* SAFE_MUTEX */
  448. /* READ-WRITE thread locking */
  450. #if defined(USE_MUTEX_INSTEAD_OF_RW_LOCKS)
  451. /* use these defs for simple mutex locking */
  452. #define rw_lock_t pthread_mutex_t
  453. #define my_rwlock_init(A,B) pthread_mutex_init((A),(B))
  454. #define rw_rdlock(A) pthread_mutex_lock((A))
  455. #define rw_wrlock(A) pthread_mutex_lock((A))
  456. #define rw_unlock(A) pthread_mutex_unlock((A))
  457. #define rwlock_destroy(A) pthread_mutex_destroy((A))
  458. #elif defined(HAVE_PTHREAD_RWLOCK_RDLOCK)
  459. #define rw_lock_t pthread_rwlock_t
  460. #define my_rwlock_init(A,B) pthread_rwlock_init((A),(B))
  461. #define rw_rdlock(A) pthread_rwlock_rdlock(A)
  462. #define rw_wrlock(A) pthread_rwlock_wrlock(A)
  463. #define rw_unlock(A) pthread_rwlock_unlock(A)
  464. #define rwlock_destroy(A) pthread_rwlock_destroy(A)
  465. #elif defined(HAVE_RWLOCK_INIT)
  466. #ifdef HAVE_RWLOCK_T /* For example Solaris 2.6-> */
  467. #define rw_lock_t rwlock_t
  468. #endif
  469. #define my_rwlock_init(A,B) rwlock_init((A),USYNC_THREAD,0)
  470. #else
  471. /* Use our own version of read/write locks */
  472. typedef struct _my_rw_lock_t {
  473. pthread_mutex_t lock; /* lock for structure */
  474. pthread_cond_t readers; /* waiting readers */
  475. pthread_cond_t writers; /* waiting writers */
  476. int state; /* -1:writer,0:free,>0:readers */
  477. int waiters; /* number of waiting writers */
  478. } my_rw_lock_t;
  480. #define rw_lock_t my_rw_lock_t
  481. #define rw_rdlock(A) my_rw_rdlock((A))
  482. #define rw_wrlock(A) my_rw_wrlock((A))
  483. #define rw_unlock(A) my_rw_unlock((A))
  484. #define rwlock_destroy(A) my_rwlock_destroy((A))
  486. extern int my_rwlock_init( my_rw_lock_t *, void * );
  487. extern int my_rwlock_destroy( my_rw_lock_t * );
  488. extern int my_rw_rdlock( my_rw_lock_t * );
  489. extern int my_rw_wrlock( my_rw_lock_t * );
  490. extern int my_rw_unlock( my_rw_lock_t * );
  491. #endif /* USE_MUTEX_INSTEAD_OF_RW_LOCKS */
  493. #define GETHOSTBYADDR_BUFF_SIZE 2048
  495. #ifndef HAVE_THR_SETCONCURRENCY
  496. #define thr_setconcurrency(A) pthread_dummy(0)
  497. #endif
  498. #if !defined(HAVE_PTHREAD_ATTR_SETSTACKSIZE) && ! defined(pthread_attr_setstacksize)
  499. #define pthread_attr_setstacksize(A,B) pthread_dummy(0)
  500. #endif
  502. extern my_bool my_thread_global_init(void);
  503. extern void my_thread_global_end(void);
  504. extern my_bool my_thread_init(void);
  505. extern void my_thread_end(void);
  506. extern char *my_thread_name(void);
  507. extern long my_thread_id(void);
  508. extern int pthread_no_free(void *);
  509. extern int pthread_dummy(int);
  511. /* All thread specific variables are in the following struct */
  513. #define THREAD_NAME_SIZE 10
  514. #if defined(__ia64__)
  515. #define DEFAULT_THREAD_STACK (128*1024)
  516. #else
  517. #define DEFAULT_THREAD_STACK (64*1024)
  518. #endif
  520. struct st_my_thread_var
  521. {
  522.   int thr_errno;
  523.   pthread_cond_t suspend, *current_cond;
  524.   pthread_mutex_t mutex,  *current_mutex;
  525.   pthread_t pthread_self;
  526.   long id;
  527.   int cmp_length;
  528.   volatile int abort;
  529. #ifndef DBUG_OFF
  530.   gptr dbug;
  531.   char name[THREAD_NAME_SIZE+1];
  532. #endif
  533. };
  535. extern struct st_my_thread_var *_my_thread_var(void) __attribute__ ((const));
  536. #define my_thread_var (_my_thread_var())
  537. #define my_errno my_thread_var->thr_errno
  539. /* statistics_xxx functions are for not essential statistic */
  541. #ifndef thread_safe_increment
  542. #ifdef HAVE_ATOMIC_ADD
  543. #define thread_safe_increment(V,L) atomic_add(1,(atomic_t*) &V);
  544. #define thread_safe_add(V,C,L)     atomic_add((C),(atomic_t*) &V);
  545. #define thread_safe_sub(V,C,L)     atomic_sub((C),(atomic_t*) &V);
  546. #define statistic_increment(V,L)   thread_safe_increment((V),(L))
  547. #define statistic_add(V,C,L)       thread_safe_add((V),(C),(L))
  548. #else
  549. #define thread_safe_increment(V,L) 
  550. pthread_mutex_lock((L)); (V)++; pthread_mutex_unlock((L));
  551. #define thread_safe_add(V,C,L) 
  552. pthread_mutex_lock((L)); (V)+=(C); pthread_mutex_unlock((L));
  553. #define thread_safe_sub(V,C,L) 
  554. pthread_mutex_lock((L)); (V)-=(C); pthread_mutex_unlock((L));
  555. #ifdef SAFE_STATISTICS
  556. #define statistic_increment(V,L)   thread_safe_increment((V),(L))
  557. #define statistic_add(V,C,L)       thread_safe_add((V),(C),(L))
  558. #else
  559. #define statistic_increment(V,L) (V)++
  560. #define statistic_add(V,C,L)     (V)+=(C)
  561. #endif /* SAFE_STATISTICS */
  562. #endif /* HAVE_ATOMIC_ADD */
  563. #endif /* thread_safe_increment */
  564. #endif /* _my_ptread_h */