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

MySQL数据库

开发平台:

Visual C++

  1. /******************************************************
  2. Mutex, the basic synchronization primitive
  3. (c) 1995 Innobase Oy
  4. Created 9/5/1995 Heikki Tuuri
  5. *******************************************************/
  6. #ifndef sync0sync_h
  7. #define sync0sync_h
  8. #include "univ.i"
  9. #include "sync0types.h"
  10. #include "ut0lst.h"
  11. #include "ut0mem.h"
  12. #include "os0thread.h"
  13. #include "os0sync.h"
  14. #include "sync0arr.h"
  15. /**********************************************************************
  16. Initializes the synchronization data structures. */
  17. void
  18. sync_init(void);
  19. /*===========*/
  20. /**********************************************************************
  21. Frees the resources in synchronization data structures. */
  22. void
  23. sync_close(void);
  24. /*===========*/
  25. /**********************************************************************
  26. Creates, or rather, initializes a mutex object to a specified memory
  27. location (which must be appropriately aligned). The mutex is initialized
  28. in the reset state. Explicit freeing of the mutex with mutex_free is
  29. necessary only if the memory block containing it is freed. */
  30. #define mutex_create(M) mutex_create_func((M), __FILE__, __LINE__)
  31. /*===================*/
  32. /**********************************************************************
  33. Creates, or rather, initializes a mutex object in a specified memory
  34. location (which must be appropriately aligned). The mutex is initialized
  35. in the reset state. Explicit freeing of the mutex with mutex_free is
  36. necessary only if the memory block containing it is freed. */
  37. void
  38. mutex_create_func(
  39. /*==============*/
  40. mutex_t* mutex, /* in: pointer to memory */
  41. const char* cfile_name, /* in: file name where created */
  42. ulint cline); /* in: file line where created */
  43. /**********************************************************************
  44. Calling this function is obligatory only if the memory buffer containing
  45. the mutex is freed. Removes a mutex object from the mutex list. The mutex
  46. is checked to be in the reset state. */
  47. #undef mutex_free /* Fix for MacOS X */
  48. void
  49. mutex_free(
  50. /*=======*/
  51. mutex_t* mutex); /* in: mutex */
  52. /******************************************************************
  53. NOTE! The following macro should be used in mutex locking, not the
  54. corresponding function. */
  55. #define mutex_enter(M)    mutex_enter_func((M), __FILE__, __LINE__)
  56. /**********************************************************************
  57. A noninlined function that reserves a mutex. In ha_innodb.cc we have disabled
  58. inlining of InnoDB functions, and no inlined functions should be called from
  59. there. That is why we need to duplicate the inlined function here. */
  60. void
  61. mutex_enter_noninline(
  62. /*==================*/
  63. mutex_t* mutex); /* in: mutex */
  64. /******************************************************************
  65. NOTE! The following macro should be used in mutex locking, not the
  66. corresponding function. */
  67. /* NOTE! currently same as mutex_enter! */
  68. #define mutex_enter_fast(M)     mutex_enter_func((M), __FILE__, __LINE__)
  69. #define mutex_enter_fast_func   mutex_enter_func;
  70. /**********************************************************************
  71. NOTE! Use the corresponding macro in the header file, not this function
  72. directly. Locks a mutex for the current thread. If the mutex is reserved
  73. the function spins a preset time (controlled by SYNC_SPIN_ROUNDS) waiting
  74. for the mutex before suspending the thread. */
  75. UNIV_INLINE
  76. void
  77. mutex_enter_func(
  78. /*=============*/
  79. mutex_t* mutex, /* in: pointer to mutex */
  80. const char* file_name,  /* in: file name where locked */
  81. ulint line); /* in: line where locked */
  82. /************************************************************************
  83. Tries to lock the mutex for the current thread. If the lock is not acquired
  84. immediately, returns with return value 1. */
  85. ulint
  86. mutex_enter_nowait(
  87. /*===============*/
  88. /* out: 0 if succeed, 1 if not */
  89. mutex_t* mutex, /* in: pointer to mutex */
  90. const char* file_name, /* in: file name where mutex
  91. requested */
  92. ulint line); /* in: line where requested */
  93. /**********************************************************************
  94. Unlocks a mutex owned by the current thread. */
  95. UNIV_INLINE
  96. void
  97. mutex_exit(
  98. /*=======*/
  99. mutex_t* mutex); /* in: pointer to mutex */
  100. /**********************************************************************
  101. Releases a mutex. */
  102. void
  103. mutex_exit_noninline(
  104. /*=================*/
  105. mutex_t* mutex); /* in: mutex */
  106. /**********************************************************************
  107. Returns TRUE if no mutex or rw-lock is currently locked.
  108. Works only in the debug version. */
  109. ibool
  110. sync_all_freed(void);
  111. /*================*/
  112. /*#####################################################################
  113. FUNCTION PROTOTYPES FOR DEBUGGING */
  114. /***********************************************************************
  115. Prints wait info of the sync system. */
  116. void
  117. sync_print_wait_info(
  118. /*=================*/
  119. FILE* file); /* in: file where to print */
  120. /***********************************************************************
  121. Prints info of the sync system. */
  122. void
  123. sync_print(
  124. /*=======*/
  125. FILE* file); /* in: file where to print */
  126. /**********************************************************************
  127. Checks that the mutex has been initialized. */
  128. ibool
  129. mutex_validate(
  130. /*===========*/
  131. mutex_t* mutex);
  132. /**********************************************************************
  133. Sets the mutex latching level field. */
  134. void
  135. mutex_set_level(
  136. /*============*/
  137. mutex_t* mutex, /* in: mutex */
  138. ulint level); /* in: level */
  139. /**********************************************************************
  140. Adds a latch and its level in the thread level array. Allocates the memory
  141. for the array if called first time for this OS thread. Makes the checks
  142. against other latch levels stored in the array for this thread. */
  143. void
  144. sync_thread_add_level(
  145. /*==================*/
  146. void* latch, /* in: pointer to a mutex or an rw-lock */
  147. ulint level); /* in: level in the latching order; if SYNC_LEVEL_NONE,
  148. nothing is done */
  149. /**********************************************************************
  150. Removes a latch from the thread level array if it is found there. */
  151. ibool
  152. sync_thread_reset_level(
  153. /*====================*/
  154. /* out: TRUE if found from the array; it is no error
  155. if the latch is not found, as we presently are not
  156. able to determine the level for every latch
  157. reservation the program does */
  158. void* latch); /* in: pointer to a mutex or an rw-lock */
  159. /**********************************************************************
  160. Checks that the level array for the current thread is empty. */
  161. ibool
  162. sync_thread_levels_empty(void);
  163. /*==========================*/
  164. /* out: TRUE if empty */
  165. /**********************************************************************
  166. Checks that the level array for the current thread is empty. */
  167. ibool
  168. sync_thread_levels_empty_gen(
  169. /*=========================*/
  170. /* out: TRUE if empty except the
  171. exceptions specified below */
  172. ibool dict_mutex_allowed); /* in: TRUE if dictionary mutex is
  173. allowed to be owned by the thread,
  174. also purge_is_running mutex is
  175. allowed */
  176. #ifdef UNIV_SYNC_DEBUG
  177. /**********************************************************************
  178. Checks that the current thread owns the mutex. Works only
  179. in the debug version. */
  180. ibool
  181. mutex_own(
  182. /*======*/
  183. /* out: TRUE if owns */
  184. mutex_t* mutex); /* in: mutex */
  185. /**********************************************************************
  186. Gets the debug information for a reserved mutex. */
  187. void
  188. mutex_get_debug_info(
  189. /*=================*/
  190. mutex_t* mutex, /* in: mutex */
  191. const char** file_name, /* out: file where requested */
  192. ulint* line, /* out: line where requested */
  193. os_thread_id_t* thread_id); /* out: id of the thread which owns
  194. the mutex */
  195. /**********************************************************************
  196. Counts currently reserved mutexes. Works only in the debug version. */
  197. ulint
  198. mutex_n_reserved(void);
  199. /*==================*/
  200. /**********************************************************************
  201. Prints debug info of currently reserved mutexes. */
  202. void
  203. mutex_list_print_info(void);
  204. /*========================*/
  205. #endif /* UNIV_SYNC_DEBUG */
  206. /**********************************************************************
  207. NOT to be used outside this module except in debugging! Gets the value
  208. of the lock word. */
  209. UNIV_INLINE
  210. ulint
  211. mutex_get_lock_word(
  212. /*================*/
  213. mutex_t* mutex); /* in: mutex */
  214. #ifdef UNIV_SYNC_DEBUG
  215. /**********************************************************************
  216. NOT to be used outside this module except in debugging! Gets the waiters
  217. field in a mutex. */
  218. UNIV_INLINE
  219. ulint
  220. mutex_get_waiters(
  221. /*==============*/
  222. /* out: value to set */
  223. mutex_t* mutex); /* in: mutex */
  224. #endif /* UNIV_SYNC_DEBUG */
  225. /*
  226. LATCHING ORDER WITHIN THE DATABASE
  227. ==================================
  228. The mutex or latch in the central memory object, for instance, a rollback
  229. segment object, must be acquired before acquiring the latch or latches to
  230. the corresponding file data structure. In the latching order below, these
  231. file page object latches are placed immediately below the corresponding
  232. central memory object latch or mutex.
  233. Synchronization object Notes
  234. ---------------------- -----
  235. Dictionary mutex If we have a pointer to a dictionary
  236. | object, e.g., a table, it can be
  237. | accessed without reserving the
  238. | dictionary mutex. We must have a
  239. | reservation, a memoryfix, to the
  240. | appropriate table object in this case,
  241. | and the table must be explicitly
  242. | released later.
  243. V
  244. Dictionary header
  245. |
  246. V
  247. Secondary index tree latch The tree latch protects also all
  248. | the B-tree non-leaf pages. These
  249. V can be read with the page only
  250. Secondary index non-leaf bufferfixed to save CPU time,
  251. | no s-latch is needed on the page.
  252. | Modification of a page requires an
  253. | x-latch on the page, however. If a
  254. | thread owns an x-latch to the tree,
  255. | it is allowed to latch non-leaf pages
  256. | even after it has acquired the fsp
  257. | latch.
  258. V
  259. Secondary index leaf The latch on the secondary index leaf
  260. | can be kept while accessing the
  261. | clustered index, to save CPU time.
  262. V
  263. Clustered index tree latch To increase concurrency, the tree
  264. | latch is usually released when the
  265. | leaf page latch has been acquired.
  266. V
  267. Clustered index non-leaf
  268. |
  269. V
  270. Clustered index leaf
  271. |
  272. V
  273. Transaction system header
  274. |
  275. V
  276. Transaction undo mutex The undo log entry must be written
  277. | before any index page is modified.
  278. | Transaction undo mutex is for the undo
  279. | logs the analogue of the tree latch
  280. | for a B-tree. If a thread has the
  281. | trx undo mutex reserved, it is allowed
  282. | to latch the undo log pages in any
  283. | order, and also after it has acquired
  284. | the fsp latch. 
  285. V
  286. Rollback segment mutex The rollback segment mutex must be
  287. | reserved, if, e.g., a new page must
  288. | be added to an undo log. The rollback
  289. | segment and the undo logs in its
  290. | history list can be seen as an
  291. | analogue of a B-tree, and the latches
  292. | reserved similarly, using a version of
  293. | lock-coupling. If an undo log must be
  294. | extended by a page when inserting an
  295. | undo log record, this corresponds to
  296. | a pessimistic insert in a B-tree.
  297. V
  298. Rollback segment header
  299. |
  300. V
  301. Purge system latch
  302. |
  303. V
  304. Undo log pages If a thread owns the trx undo mutex,
  305. | or for a log in the history list, the
  306. | rseg mutex, it is allowed to latch
  307. | undo log pages in any order, and even
  308. | after it has acquired the fsp latch.
  309. | If a thread does not have the
  310. | appropriate mutex, it is allowed to
  311. | latch only a single undo log page in
  312. | a mini-transaction.
  313. V
  314. File space management latch If a mini-transaction must allocate
  315. | several file pages, it can do that,
  316. | because it keeps the x-latch to the
  317. | file space management in its memo.
  318. V
  319. File system pages
  320. |
  321. V
  322. Kernel mutex If a kernel operation needs a file
  323. | page allocation, it must reserve the
  324. | fsp x-latch before acquiring the kernel
  325. | mutex.
  326. V
  327. Search system mutex
  328. |
  329. V
  330. Buffer pool mutex
  331. |
  332. V
  333. Log mutex
  334. |
  335. Any other latch
  336. |
  337. V
  338. Memory pool mutex */
  339. /* Latching order levels */
  340. /* User transaction locks are higher than any of the latch levels below:
  341. no latches are allowed when a thread goes to wait for a normal table
  342. or row lock! */
  343. #define SYNC_USER_TRX_LOCK 9999
  344. #define SYNC_NO_ORDER_CHECK 3000 /* this can be used to suppress
  345. latching order checking */
  346. #define SYNC_LEVEL_NONE 2000 /* default: level not defined */
  347. #define SYNC_DICT_OPERATION 1001 /* table create, drop, etc. reserve
  348. this in X-mode, implicit or backround
  349. operations purge, rollback, foreign
  350. key checks reserve this in S-mode */
  351. #define SYNC_DICT 1000
  352. #define SYNC_DICT_AUTOINC_MUTEX 999
  353. #define SYNC_DICT_HEADER 995
  354. #define SYNC_IBUF_HEADER 914
  355. #define SYNC_IBUF_PESS_INSERT_MUTEX 912
  356. #define SYNC_IBUF_MUTEX 910 /* ibuf mutex is really below
  357. SYNC_FSP_PAGE: we assign a value this
  358. high only to make the program to pass
  359. the debug checks */
  360. /*-------------------------------*/
  361. #define SYNC_INDEX_TREE 900
  362. #define SYNC_TREE_NODE_NEW 892
  363. #define SYNC_TREE_NODE_FROM_HASH 891
  364. #define SYNC_TREE_NODE 890
  365. #define SYNC_PURGE_SYS 810
  366. #define SYNC_PURGE_LATCH 800
  367. #define SYNC_TRX_UNDO 700
  368. #define SYNC_RSEG 600
  369. #define SYNC_RSEG_HEADER_NEW 591
  370. #define SYNC_RSEG_HEADER 590
  371. #define SYNC_TRX_UNDO_PAGE 570
  372. #define SYNC_EXTERN_STORAGE 500
  373. #define SYNC_FSP 400
  374. #define SYNC_FSP_PAGE 395
  375. /*------------------------------------- Insert buffer headers */ 
  376. /*------------------------------------- ibuf_mutex */
  377. /*------------------------------------- Insert buffer tree */
  378. #define SYNC_IBUF_BITMAP_MUTEX 351
  379. #define SYNC_IBUF_BITMAP 350
  380. /*-------------------------------*/
  381. #define SYNC_KERNEL 300
  382. #define SYNC_REC_LOCK 299
  383. #define SYNC_TRX_LOCK_HEAP 298
  384. #define SYNC_TRX_SYS_HEADER 290
  385. #define SYNC_LOG 170
  386. #define SYNC_RECV 168
  387. #define SYNC_SEARCH_SYS 160 /* NOTE that if we have a memory
  388. heap that can be extended to the
  389. buffer pool, its logical level is
  390. SYNC_SEARCH_SYS, as memory allocation
  391. can call routines there! Otherwise
  392. the level is SYNC_MEM_HASH. */
  393. #define SYNC_BUF_POOL 150
  394. #define SYNC_BUF_BLOCK 149
  395. #define SYNC_DOUBLEWRITE 140
  396. #define SYNC_ANY_LATCH 135
  397. #define SYNC_THR_LOCAL 133
  398. #define SYNC_MEM_HASH 131
  399. #define SYNC_MEM_POOL 130
  400. /* Codes used to designate lock operations */
  401. #define RW_LOCK_NOT_LOCKED  350
  402. #define RW_LOCK_EX 351
  403. #define RW_LOCK_EXCLUSIVE 351
  404. #define RW_LOCK_SHARED 352
  405. #define RW_LOCK_WAIT_EX 353
  406. #define SYNC_MUTEX 354
  407. /* NOTE! The structure appears here only for the compiler to know its size.
  408. Do not use its fields directly! The structure used in the spin lock
  409. implementation of a mutual exclusion semaphore. */
  410. struct mutex_struct {
  411. ulint lock_word; /* This ulint is the target of the atomic
  412. test-and-set instruction in Win32 */
  413. #if !defined(_WIN32) || !defined(UNIV_CAN_USE_X86_ASSEMBLER)
  414. os_fast_mutex_t
  415. os_fast_mutex; /* In other systems we use this OS mutex
  416. in place of lock_word */
  417. #endif
  418. ulint waiters; /* This ulint is set to 1 if there are (or
  419. may be) threads waiting in the global wait
  420. array for this mutex to be released.
  421. Otherwise, this is 0. */
  422. UT_LIST_NODE_T(mutex_t) list; /* All allocated mutexes are put into
  423. a list. Pointers to the next and prev. */
  424. #ifdef UNIV_SYNC_DEBUG
  425. const char* file_name; /* File where the mutex was locked */
  426. ulint line; /* Line where the mutex was locked */
  427. os_thread_id_t thread_id; /* Debug version: The thread id of the
  428. thread which locked the mutex. */
  429. #endif /* UNIV_SYNC_DEBUG */
  430. ulint level; /* Level in the global latching
  431. order; default SYNC_LEVEL_NONE */
  432. const char* cfile_name;/* File name where mutex created */
  433. ulint cline; /* Line where created */
  434. ulint magic_n;
  435. };
  436. #define MUTEX_MAGIC_N (ulint)979585
  437. /* The global array of wait cells for implementation of the databases own
  438. mutexes and read-write locks. Appears here for debugging purposes only! */
  439. extern sync_array_t* sync_primary_wait_array;
  440. /* Constant determining how long spin wait is continued before suspending
  441. the thread. A value 600 rounds on a 1995 100 MHz Pentium seems to correspond
  442. to 20 microseconds. */
  443. #define SYNC_SPIN_ROUNDS srv_n_spin_wait_rounds
  444. #define SYNC_INFINITE_TIME ((ulint)(-1))
  445. /* Means that a timeout elapsed when waiting */
  446. #define SYNC_TIME_EXCEEDED (ulint)1
  447. /* The number of system calls made in this module. Intended for performance
  448. monitoring. */
  449. extern  ulint mutex_system_call_count;
  450. extern ulint mutex_exit_count;
  451. /* Latching order checks start when this is set TRUE */
  452. extern ibool sync_order_checks_on;
  453. /* This variable is set to TRUE when sync_init is called */
  454. extern ibool sync_initialized;
  455. #ifndef UNIV_NONINL
  456. #include "sync0sync.ic"
  457. #endif
  458. #endif