sync0rw.h
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:18k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /******************************************************
  2. The read-write lock (for threads, not for database transactions)
  3. (c) 1995 Innobase Oy
  4. Created 9/11/1995 Heikki Tuuri
  5. *******************************************************/
  6. #ifndef sync0rw_h
  7. #define sync0rw_h
  8. #include "univ.i"
  9. #include "ut0lst.h"
  10. #include "sync0sync.h"
  11. #include "os0sync.h"
  12. /* The following undef is to prevent a name conflict with a macro
  13. in MySQL: */
  14. #undef rw_lock_t
  15. /* Latch types; these are used also in btr0btr.h: keep the numerical values
  16. smaller than 30 and the order of the numerical values like below! */
  17. #define RW_S_LATCH 1
  18. #define RW_X_LATCH 2
  19. #define RW_NO_LATCH 3
  20. typedef struct rw_lock_struct rw_lock_t;
  21. #ifdef UNIV_SYNC_DEBUG
  22. typedef struct rw_lock_debug_struct rw_lock_debug_t;
  23. #endif /* UNIV_SYNC_DEBUG */
  24. typedef UT_LIST_BASE_NODE_T(rw_lock_t) rw_lock_list_t;
  25. extern rw_lock_list_t  rw_lock_list;
  26. extern mutex_t rw_lock_list_mutex;
  27. #ifdef UNIV_SYNC_DEBUG
  28. /* The global mutex which protects debug info lists of all rw-locks.
  29. To modify the debug info list of an rw-lock, this mutex has to be
  30. acquired in addition to the mutex protecting the lock. */
  31. extern mutex_t rw_lock_debug_mutex;
  32. extern os_event_t rw_lock_debug_event; /* If deadlock detection does
  33. not get immediately the mutex it
  34. may wait for this event */
  35. extern ibool rw_lock_debug_waiters; /* This is set to TRUE, if
  36. there may be waiters for the event */
  37. #endif /* UNIV_SYNC_DEBUG */
  38. extern ulint rw_s_system_call_count;
  39. extern ulint rw_s_spin_wait_count;
  40. extern ulint rw_s_exit_count;
  41. extern ulint rw_s_os_wait_count;
  42. extern ulint rw_x_system_call_count;
  43. extern ulint rw_x_spin_wait_count;
  44. extern ulint rw_x_os_wait_count;
  45. extern ulint rw_x_exit_count;
  46. /**********************************************************************
  47. Creates, or rather, initializes an rw-lock object in a specified memory
  48. location (which must be appropriately aligned). The rw-lock is initialized
  49. to the non-locked state. Explicit freeing of the rw-lock with rw_lock_free
  50. is necessary only if the memory block containing it is freed. */
  51. #define rw_lock_create(L) rw_lock_create_func((L), __FILE__, __LINE__)
  52. /*=====================*/
  53. /**********************************************************************
  54. Creates, or rather, initializes an rw-lock object in a specified memory
  55. location (which must be appropriately aligned). The rw-lock is initialized
  56. to the non-locked state. Explicit freeing of the rw-lock with rw_lock_free
  57. is necessary only if the memory block containing it is freed. */
  58. void
  59. rw_lock_create_func(
  60. /*================*/
  61. rw_lock_t* lock, /* in: pointer to memory */
  62. const char* cfile_name, /* in: file name where created */
  63. ulint cline); /* in: file line where created */
  64. /**********************************************************************
  65. Calling this function is obligatory only if the memory buffer containing
  66. the rw-lock is freed. Removes an rw-lock object from the global list. The
  67. rw-lock is checked to be in the non-locked state. */
  68. void
  69. rw_lock_free(
  70. /*=========*/
  71. rw_lock_t* lock); /* in: rw-lock */
  72. /**********************************************************************
  73. Checks that the rw-lock has been initialized and that there are no
  74. simultaneous shared and exclusive locks. */
  75. ibool
  76. rw_lock_validate(
  77. /*=============*/
  78. rw_lock_t* lock);
  79. /******************************************************************
  80. NOTE! The following macros should be used in rw s-locking, not the
  81. corresponding function. */
  82. #define rw_lock_s_lock(M)    rw_lock_s_lock_func(
  83.   (M), 0, __FILE__, __LINE__)
  84. /******************************************************************
  85. NOTE! The following macros should be used in rw s-locking, not the
  86. corresponding function. */
  87. #define rw_lock_s_lock_gen(M, P)    rw_lock_s_lock_func(
  88.   (M), (P), __FILE__, __LINE__)
  89. /******************************************************************
  90. NOTE! The following macros should be used in rw s-locking, not the
  91. corresponding function. */
  92. #define rw_lock_s_lock_nowait(M)    rw_lock_s_lock_func_nowait(
  93.      (M), __FILE__, __LINE__)
  94. /**********************************************************************
  95. NOTE! Use the corresponding macro, not directly this function, except if
  96. you supply the file name and line number. Lock an rw-lock in shared mode
  97. for the current thread. If the rw-lock is locked in exclusive mode, or
  98. there is an exclusive lock request waiting, the function spins a preset
  99. time (controlled by SYNC_SPIN_ROUNDS), waiting for the lock, before
  100. suspending the thread. */
  101. UNIV_INLINE
  102. void
  103. rw_lock_s_lock_func(
  104. /*================*/
  105.         rw_lock_t*    lock,   /* in: pointer to rw-lock */
  106. ulint pass, /* in: pass value; != 0, if the lock will
  107. be passed to another thread to unlock */
  108. const char* file_name,/* in: file name where lock requested */
  109. ulint line); /* in: line where requested */
  110. /**********************************************************************
  111. NOTE! Use the corresponding macro, not directly this function, except if
  112. you supply the file name and line number. Lock an rw-lock in shared mode
  113. for the current thread if the lock can be acquired immediately. */
  114. UNIV_INLINE
  115. ibool
  116. rw_lock_s_lock_func_nowait(
  117. /*=======================*/
  118. /* out: TRUE if success */
  119.         rw_lock_t*    lock,   /* in: pointer to rw-lock */
  120. const char* file_name,/* in: file name where lock requested */
  121. ulint line); /* in: line where requested */
  122. /**********************************************************************
  123. NOTE! Use the corresponding macro, not directly this function! Lock an
  124. rw-lock in exclusive mode for the current thread if the lock can be
  125. obtained immediately. */
  126. UNIV_INLINE
  127. ibool
  128. rw_lock_x_lock_func_nowait(
  129. /*=======================*/
  130. /* out: TRUE if success */
  131.         rw_lock_t*    lock,   /* in: pointer to rw-lock */
  132. const char* file_name,/* in: file name where lock requested */
  133. ulint line); /* in: line where requested */
  134. /**********************************************************************
  135. Releases a shared mode lock. */
  136. UNIV_INLINE
  137. void
  138. rw_lock_s_unlock_func(
  139. /*==================*/
  140. rw_lock_t* lock /* in: rw-lock */
  141. #ifdef UNIV_SYNC_DEBUG
  142. ,ulint pass /* in: pass value; != 0, if the lock may have
  143. been passed to another thread to unlock */
  144. #endif
  145. );
  146. /***********************************************************************
  147. Releases a shared mode lock. */
  148. #ifdef UNIV_SYNC_DEBUG
  149. #define rw_lock_s_unlock(L)    rw_lock_s_unlock_func(L, 0)
  150. #else
  151. #define rw_lock_s_unlock(L)    rw_lock_s_unlock_func(L)
  152. #endif
  153. /***********************************************************************
  154. Releases a shared mode lock. */
  155. #ifdef UNIV_SYNC_DEBUG
  156. #define rw_lock_s_unlock_gen(L, P)    rw_lock_s_unlock_func(L, P)
  157. #else
  158. #define rw_lock_s_unlock_gen(L, P)    rw_lock_s_unlock_func(L)
  159. #endif
  160. /******************************************************************
  161. NOTE! The following macro should be used in rw x-locking, not the
  162. corresponding function. */
  163. #define rw_lock_x_lock(M)    rw_lock_x_lock_func(
  164.   (M), 0, __FILE__, __LINE__)
  165. /******************************************************************
  166. NOTE! The following macro should be used in rw x-locking, not the
  167. corresponding function. */
  168. #define rw_lock_x_lock_gen(M, P)    rw_lock_x_lock_func(
  169.   (M), (P), __FILE__, __LINE__)
  170. /******************************************************************
  171. NOTE! The following macros should be used in rw x-locking, not the
  172. corresponding function. */
  173. #define rw_lock_x_lock_nowait(M)    rw_lock_x_lock_func_nowait(
  174.      (M), __FILE__, __LINE__)
  175. /**********************************************************************
  176. NOTE! Use the corresponding macro, not directly this function! Lock an
  177. rw-lock in exclusive mode for the current thread. If the rw-lock is locked
  178. in shared or exclusive mode, or there is an exclusive lock request waiting,
  179. the function spins a preset time (controlled by SYNC_SPIN_ROUNDS), waiting
  180. for the lock, before suspending the thread. If the same thread has an x-lock
  181. on the rw-lock, locking succeed, with the following exception: if pass != 0,
  182. only a single x-lock may be taken on the lock. NOTE: If the same thread has
  183. an s-lock, locking does not succeed! */
  184. void
  185. rw_lock_x_lock_func(
  186. /*================*/
  187.         rw_lock_t*    lock,   /* in: pointer to rw-lock */
  188. ulint pass, /* in: pass value; != 0, if the lock will
  189. be passed to another thread to unlock */
  190. const char* file_name,/* in: file name where lock requested */
  191. ulint line); /* in: line where requested */
  192. /**********************************************************************
  193. Releases an exclusive mode lock. */
  194. UNIV_INLINE
  195. void
  196. rw_lock_x_unlock_func(
  197. /*==================*/
  198. rw_lock_t* lock /* in: rw-lock */
  199. #ifdef UNIV_SYNC_DEBUG
  200. ,ulint pass /* in: pass value; != 0, if the lock may have
  201. been passed to another thread to unlock */
  202. #endif
  203. );
  204. /***********************************************************************
  205. Releases an exclusive mode lock. */
  206. #ifdef UNIV_SYNC_DEBUG
  207. #define rw_lock_x_unlock(L)    rw_lock_x_unlock_func(L, 0)
  208. #else
  209. #define rw_lock_x_unlock(L)    rw_lock_x_unlock_func(L)
  210. #endif
  211. /***********************************************************************
  212. Releases an exclusive mode lock. */
  213. #ifdef UNIV_SYNC_DEBUG
  214. #define rw_lock_x_unlock_gen(L, P)    rw_lock_x_unlock_func(L, P)
  215. #else
  216. #define rw_lock_x_unlock_gen(L, P)    rw_lock_x_unlock_func(L)
  217. #endif
  218. /**********************************************************************
  219. Low-level function which locks an rw-lock in s-mode when we know that it
  220. is possible and none else is currently accessing the rw-lock structure.
  221. Then we can do the locking without reserving the mutex. */
  222. UNIV_INLINE
  223. void
  224. rw_lock_s_lock_direct(
  225. /*==================*/
  226. rw_lock_t* lock, /* in: pointer to rw-lock */
  227. const char* file_name, /* in: file name where requested */
  228. ulint line /* in: line where lock requested */
  229. );
  230. /**********************************************************************
  231. Low-level function which locks an rw-lock in x-mode when we know that it
  232. is not locked and none else is currently accessing the rw-lock structure.
  233. Then we can do the locking without reserving the mutex. */
  234. UNIV_INLINE
  235. void
  236. rw_lock_x_lock_direct(
  237. /*==================*/
  238. rw_lock_t* lock, /* in: pointer to rw-lock */
  239. const char* file_name, /* in: file name where requested */
  240. ulint line /* in: line where lock requested */
  241. );
  242. /**********************************************************************
  243. This function is used in the insert buffer to move the ownership of an
  244. x-latch on a buffer frame to the current thread. The x-latch was set by
  245. the buffer read operation and it protected the buffer frame while the
  246. read was done. The ownership is moved because we want that the current
  247. thread is able to acquire a second x-latch which is stored in an mtr.
  248. This, in turn, is needed to pass the debug checks of index page
  249. operations. */
  250. void
  251. rw_lock_x_lock_move_ownership(
  252. /*==========================*/
  253. rw_lock_t* lock); /* in: lock which was x-locked in the
  254. buffer read */
  255. /**********************************************************************
  256. Releases a shared mode lock when we know there are no waiters and none
  257. else will access the lock during the time this function is executed. */
  258. UNIV_INLINE
  259. void
  260. rw_lock_s_unlock_direct(
  261. /*====================*/
  262. rw_lock_t* lock); /* in: rw-lock */
  263. /**********************************************************************
  264. Releases an exclusive mode lock when we know there are no waiters, and
  265. none else will access the lock durint the time this function is executed. */
  266. UNIV_INLINE
  267. void
  268. rw_lock_x_unlock_direct(
  269. /*====================*/
  270. rw_lock_t* lock); /* in: rw-lock */
  271. /**********************************************************************
  272. Sets the rw-lock latching level field. */
  273. void
  274. rw_lock_set_level(
  275. /*==============*/
  276. rw_lock_t* lock, /* in: rw-lock */
  277. ulint level); /* in: level */
  278. /**********************************************************************
  279. Returns the value of writer_count for the lock. Does not reserve the lock
  280. mutex, so the caller must be sure it is not changed during the call. */
  281. UNIV_INLINE
  282. ulint
  283. rw_lock_get_x_lock_count(
  284. /*=====================*/
  285. /* out: value of writer_count */
  286. rw_lock_t* lock); /* in: rw-lock */
  287. /************************************************************************
  288. Accessor functions for rw lock. */
  289. UNIV_INLINE
  290. ulint
  291. rw_lock_get_waiters(
  292. /*================*/
  293. rw_lock_t* lock);
  294. UNIV_INLINE
  295. ulint
  296. rw_lock_get_writer(
  297. /*===============*/
  298. rw_lock_t* lock);
  299. UNIV_INLINE
  300. ulint
  301. rw_lock_get_reader_count(
  302. /*=====================*/
  303. rw_lock_t* lock);
  304. #ifdef UNIV_SYNC_DEBUG
  305. /**********************************************************************
  306. Checks if the thread has locked the rw-lock in the specified mode, with
  307. the pass value == 0. */
  308. ibool
  309. rw_lock_own(
  310. /*========*/
  311. rw_lock_t* lock, /* in: rw-lock */
  312. ulint lock_type); /* in: lock type: RW_LOCK_SHARED,
  313. RW_LOCK_EX */
  314. #endif /* UNIV_SYNC_DEBUG */
  315. /**********************************************************************
  316. Checks if somebody has locked the rw-lock in the specified mode. */
  317. ibool
  318. rw_lock_is_locked(
  319. /*==============*/
  320. rw_lock_t* lock, /* in: rw-lock */
  321. ulint lock_type); /* in: lock type: RW_LOCK_SHARED,
  322. RW_LOCK_EX */
  323. #ifdef UNIV_SYNC_DEBUG
  324. /*******************************************************************
  325. Prints debug info of an rw-lock. */
  326. void
  327. rw_lock_print(
  328. /*==========*/
  329. rw_lock_t* lock); /* in: rw-lock */
  330. /*******************************************************************
  331. Prints debug info of currently locked rw-locks. */
  332. void
  333. rw_lock_list_print_info(void);
  334. /*=========================*/
  335. /*******************************************************************
  336. Returns the number of currently locked rw-locks.
  337. Works only in the debug version. */
  338. ulint
  339. rw_lock_n_locked(void);
  340. /*==================*/
  341. /*#####################################################################*/
  342. /**********************************************************************
  343. Acquires the debug mutex. We cannot use the mutex defined in sync0sync,
  344. because the debug mutex is also acquired in sync0arr while holding the OS
  345. mutex protecting the sync array, and the ordinary mutex_enter might
  346. recursively call routines in sync0arr, leading to a deadlock on the OS
  347. mutex. */
  348. void
  349. rw_lock_debug_mutex_enter(void);
  350. /*==========================*/
  351. /**********************************************************************
  352. Releases the debug mutex. */
  353. void
  354. rw_lock_debug_mutex_exit(void);
  355. /*==========================*/
  356. /*************************************************************************
  357. Prints info of a debug struct. */
  358. void
  359. rw_lock_debug_print(
  360. /*================*/
  361. rw_lock_debug_t* info); /* in: debug struct */
  362. #endif /* UNIV_SYNC_DEBUG */
  363. /* NOTE! The structure appears here only for the compiler to know its size.
  364. Do not use its fields directly! The structure used in the spin lock
  365. implementation of a read-write lock. Several threads may have a shared lock
  366. simultaneously in this lock, but only one writer may have an exclusive lock,
  367. in which case no shared locks are allowed. To prevent starving of a writer
  368. blocked by readers, a writer may queue for the lock by setting the writer
  369. field. Then no new readers are allowed in. */
  370. struct rw_lock_struct {
  371. ulint reader_count; /* Number of readers who have locked this
  372. lock in the shared mode */
  373. ulint writer;  /* This field is set to RW_LOCK_EX if there
  374. is a writer owning the lock (in exclusive
  375. mode), RW_LOCK_WAIT_EX if a writer is
  376. queueing for the lock, and
  377. RW_LOCK_NOT_LOCKED, otherwise. */
  378. os_thread_id_t writer_thread;
  379. /* Thread id of a possible writer thread */
  380. ulint writer_count; /* Number of times the same thread has
  381. recursively locked the lock in the exclusive
  382. mode */
  383. mutex_t mutex; /* The mutex protecting rw_lock_struct */
  384. ulint pass;  /* Default value 0. This is set to some
  385. value != 0 given by the caller of an x-lock
  386. operation, if the x-lock is to be passed to
  387. another thread to unlock (which happens in
  388. asynchronous i/o). */
  389. ulint waiters; /* This ulint is set to 1 if there are
  390. waiters (readers or writers) in the global
  391. wait array, waiting for this rw_lock.
  392. Otherwise, == 0. */
  393. ibool writer_is_wait_ex;
  394. /* This is TRUE if the writer field is
  395. RW_LOCK_WAIT_EX; this field is located far
  396. from the memory update hotspot fields which
  397. are at the start of this struct, thus we can
  398. peek this field without causing much memory
  399. bus traffic */
  400. UT_LIST_NODE_T(rw_lock_t) list;
  401. /* All allocated rw locks are put into a
  402. list */
  403. #ifdef UNIV_SYNC_DEBUG
  404. UT_LIST_BASE_NODE_T(rw_lock_debug_t) debug_list;
  405. /* In the debug version: pointer to the debug
  406. info list of the lock */
  407. #endif /* UNIV_SYNC_DEBUG */
  408. ulint level; /* Level in the global latching
  409. order; default SYNC_LEVEL_NONE */
  410. const char* cfile_name;/* File name where lock created */
  411. ulint cline; /* Line where created */
  412. const char* last_s_file_name;/* File name where last s-locked */
  413. const char* last_x_file_name;/* File name where last x-locked */
  414. ulint last_s_line; /* Line number where last time s-locked */
  415. ulint last_x_line; /* Line number where last time x-locked */
  416. ulint magic_n;
  417. };
  418. #define RW_LOCK_MAGIC_N 22643
  419. #ifdef UNIV_SYNC_DEBUG
  420. /* The structure for storing debug info of an rw-lock */
  421. struct rw_lock_debug_struct {
  422. os_thread_id_t thread_id;  /* The thread id of the thread which
  423. locked the rw-lock */
  424. ulint pass; /* Pass value given in the lock operation */
  425. ulint lock_type; /* Type of the lock: RW_LOCK_EX,
  426. RW_LOCK_SHARED, RW_LOCK_WAIT_EX */
  427. const char* file_name;/* File name where the lock was obtained */
  428. ulint line; /* Line where the rw-lock was locked */
  429. UT_LIST_NODE_T(rw_lock_debug_t) list;
  430. /* Debug structs are linked in a two-way
  431. list */
  432. };
  433. #endif /* UNIV_SYNC_DEBUG */
  434. #ifndef UNIV_NONINL
  435. #include "sync0rw.ic"
  436. #endif
  437. #endif