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

MySQL数据库

开发平台:

Visual C++

  1. /**********************************************************************
  2. File-based list utilities
  3. (c) 1995 Innobase Oy
  4. Created 11/28/1995 Heikki Tuuri
  5. ***********************************************************************/
  6. #include "fut0lst.h"
  7. #ifdef UNIV_NONINL
  8. #include "fut0lst.ic"
  9. #endif
  10. #include "buf0buf.h"
  11. /************************************************************************
  12. Adds a node to an empty list. */
  13. static
  14. void
  15. flst_add_to_empty(
  16. /*==============*/
  17. flst_base_node_t* base, /* in: pointer to base node of
  18. empty list */
  19. flst_node_t* node, /* in: node to add */
  20. mtr_t* mtr) /* in: mini-transaction handle */
  21. {
  22. ulint space;
  23. fil_addr_t node_addr;
  24. ulint len;
  25. ut_ad(mtr && base && node);
  26. ut_ad(base != node);
  27. ut_ad(mtr_memo_contains(mtr, buf_block_align(base),
  28. MTR_MEMO_PAGE_X_FIX));
  29. ut_ad(mtr_memo_contains(mtr, buf_block_align(node),
  30. MTR_MEMO_PAGE_X_FIX));
  31. len = flst_get_len(base, mtr);
  32. ut_a(len == 0);
  33. buf_ptr_get_fsp_addr(node, &space, &node_addr);
  34. /* Update first and last fields of base node */
  35. flst_write_addr(base + FLST_FIRST, node_addr, mtr);
  36. flst_write_addr(base + FLST_LAST, node_addr, mtr);
  37. /* Set prev and next fields of node to add */
  38. flst_write_addr(node + FLST_PREV, fil_addr_null, mtr);
  39. flst_write_addr(node + FLST_NEXT, fil_addr_null, mtr);
  40. /* Update len of base node */
  41. mlog_write_ulint(base + FLST_LEN, len + 1, MLOG_4BYTES, mtr); 
  42. }
  43. /************************************************************************
  44. Adds a node as the last node in a list. */
  45. void
  46. flst_add_last(
  47. /*==========*/
  48. flst_base_node_t* base, /* in: pointer to base node of list */
  49. flst_node_t* node, /* in: node to add */
  50. mtr_t* mtr) /* in: mini-transaction handle */
  51. {
  52. ulint space;
  53. fil_addr_t node_addr;
  54. ulint len;
  55. fil_addr_t last_addr;
  56. flst_node_t* last_node;
  57. ut_ad(mtr && base && node);
  58. ut_ad(base != node);
  59. ut_ad(mtr_memo_contains(mtr, buf_block_align(base),
  60. MTR_MEMO_PAGE_X_FIX));
  61. ut_ad(mtr_memo_contains(mtr, buf_block_align(node),
  62. MTR_MEMO_PAGE_X_FIX));
  63. len = flst_get_len(base, mtr);
  64. last_addr = flst_get_last(base, mtr);
  65. buf_ptr_get_fsp_addr(node, &space, &node_addr);
  66. /* If the list is not empty, call flst_insert_after */
  67. if (len != 0) {
  68. if (last_addr.page == node_addr.page) {
  69. last_node = buf_frame_align(node) + last_addr.boffset;
  70. } else {
  71. last_node = fut_get_ptr(space, last_addr, RW_X_LATCH,
  72. mtr);
  73. }
  74. flst_insert_after(base, last_node, node, mtr); 
  75. } else {
  76. /* else call flst_add_to_empty */
  77. flst_add_to_empty(base, node, mtr); 
  78. }
  79. }
  80. /************************************************************************
  81. Adds a node as the first node in a list. */
  82. void
  83. flst_add_first(
  84. /*===========*/
  85. flst_base_node_t* base, /* in: pointer to base node of list */
  86. flst_node_t* node, /* in: node to add */
  87. mtr_t* mtr) /* in: mini-transaction handle */
  88. {
  89. ulint space;
  90. fil_addr_t node_addr;
  91. ulint len;
  92. fil_addr_t first_addr;
  93. flst_node_t* first_node;
  94. ut_ad(mtr && base && node);
  95. ut_ad(base != node);
  96. ut_ad(mtr_memo_contains(mtr, buf_block_align(base),
  97. MTR_MEMO_PAGE_X_FIX));
  98. ut_ad(mtr_memo_contains(mtr, buf_block_align(node),
  99. MTR_MEMO_PAGE_X_FIX));
  100. len = flst_get_len(base, mtr);
  101. first_addr = flst_get_first(base, mtr);
  102. buf_ptr_get_fsp_addr(node, &space, &node_addr);
  103. /* If the list is not empty, call flst_insert_before */
  104. if (len != 0) {
  105. if (first_addr.page == node_addr.page) {
  106. first_node = buf_frame_align(node)
  107. + first_addr.boffset;
  108. } else {
  109. first_node = fut_get_ptr(space, first_addr,
  110. RW_X_LATCH, mtr);
  111. }
  112. flst_insert_before(base, node, first_node, mtr); 
  113. } else {
  114. /* else call flst_add_to_empty */
  115. flst_add_to_empty(base, node, mtr); 
  116. }
  117. }
  118. /************************************************************************
  119. Inserts a node after another in a list. */
  120. void
  121. flst_insert_after(
  122. /*==============*/
  123. flst_base_node_t* base, /* in: pointer to base node of list */
  124. flst_node_t* node1, /* in: node to insert after */
  125. flst_node_t* node2, /* in: node to add */
  126. mtr_t* mtr) /* in: mini-transaction handle */
  127. {
  128. ulint space;
  129. fil_addr_t node1_addr;
  130. fil_addr_t node2_addr;
  131. flst_node_t* node3;
  132. fil_addr_t node3_addr;
  133. ulint len;
  134. ut_ad(mtr && node1 && node2 && base);
  135. ut_ad(base != node1);
  136. ut_ad(base != node2);
  137. ut_ad(node2 != node1);
  138. ut_ad(mtr_memo_contains(mtr, buf_block_align(base),
  139. MTR_MEMO_PAGE_X_FIX));
  140. ut_ad(mtr_memo_contains(mtr, buf_block_align(node1),
  141. MTR_MEMO_PAGE_X_FIX));
  142. ut_ad(mtr_memo_contains(mtr, buf_block_align(node2),
  143. MTR_MEMO_PAGE_X_FIX));
  144. buf_ptr_get_fsp_addr(node1, &space, &node1_addr);
  145. buf_ptr_get_fsp_addr(node2, &space, &node2_addr);
  146. node3_addr = flst_get_next_addr(node1, mtr);
  147. /* Set prev and next fields of node2 */
  148. flst_write_addr(node2 + FLST_PREV, node1_addr, mtr);
  149. flst_write_addr(node2 + FLST_NEXT, node3_addr, mtr);
  150. if (!fil_addr_is_null(node3_addr)) {
  151. /* Update prev field of node3 */
  152. node3 = fut_get_ptr(space, node3_addr, RW_X_LATCH, mtr);
  153. flst_write_addr(node3 + FLST_PREV, node2_addr, mtr);
  154. } else {
  155. /* node1 was last in list: update last field in base */
  156. flst_write_addr(base + FLST_LAST, node2_addr, mtr);
  157. }
  158. /* Set next field of node1 */
  159. flst_write_addr(node1 + FLST_NEXT, node2_addr, mtr);
  160. /* Update len of base node */
  161. len = flst_get_len(base, mtr);
  162. mlog_write_ulint(base + FLST_LEN, len + 1, MLOG_4BYTES, mtr); 
  163. }
  164. /************************************************************************
  165. Inserts a node before another in a list. */
  166. void
  167. flst_insert_before(
  168. /*===============*/
  169. flst_base_node_t* base, /* in: pointer to base node of list */
  170. flst_node_t* node2, /* in: node to insert */
  171. flst_node_t* node3, /* in: node to insert before */
  172. mtr_t* mtr) /* in: mini-transaction handle */
  173. {
  174. ulint space;
  175. flst_node_t* node1;
  176. fil_addr_t node1_addr;
  177. fil_addr_t node2_addr;
  178. fil_addr_t node3_addr;
  179. ulint len;
  180. ut_ad(mtr && node2 && node3 && base);
  181. ut_ad(base != node2);
  182. ut_ad(base != node3);
  183. ut_ad(node2 != node3);
  184. ut_ad(mtr_memo_contains(mtr, buf_block_align(base),
  185. MTR_MEMO_PAGE_X_FIX));
  186. ut_ad(mtr_memo_contains(mtr, buf_block_align(node2),
  187. MTR_MEMO_PAGE_X_FIX));
  188. ut_ad(mtr_memo_contains(mtr, buf_block_align(node3),
  189. MTR_MEMO_PAGE_X_FIX));
  190. buf_ptr_get_fsp_addr(node2, &space, &node2_addr);
  191. buf_ptr_get_fsp_addr(node3, &space, &node3_addr);
  192. node1_addr = flst_get_prev_addr(node3, mtr);
  193. /* Set prev and next fields of node2 */
  194. flst_write_addr(node2 + FLST_PREV, node1_addr, mtr);
  195. flst_write_addr(node2 + FLST_NEXT, node3_addr, mtr);
  196. if (!fil_addr_is_null(node1_addr)) {
  197. /* Update next field of node1 */
  198. node1 = fut_get_ptr(space, node1_addr, RW_X_LATCH, mtr);
  199. flst_write_addr(node1 + FLST_NEXT, node2_addr, mtr);
  200. } else {
  201. /* node3 was first in list: update first field in base */
  202. flst_write_addr(base + FLST_FIRST, node2_addr, mtr);
  203. }
  204. /* Set prev field of node3 */
  205. flst_write_addr(node3 + FLST_PREV, node2_addr, mtr);
  206. /* Update len of base node */
  207. len = flst_get_len(base, mtr);
  208. mlog_write_ulint(base + FLST_LEN, len + 1, MLOG_4BYTES, mtr); 
  209. }
  210. /************************************************************************
  211. Removes a node. */
  212. void
  213. flst_remove(
  214. /*========*/
  215. flst_base_node_t* base, /* in: pointer to base node of list */
  216. flst_node_t* node2, /* in: node to remove */
  217. mtr_t* mtr) /* in: mini-transaction handle */
  218. {
  219. ulint space;
  220. flst_node_t* node1;
  221. fil_addr_t node1_addr;
  222. fil_addr_t node2_addr;
  223. flst_node_t* node3;
  224. fil_addr_t node3_addr;
  225. ulint len;
  226. ut_ad(mtr && node2 && base);
  227. ut_ad(mtr_memo_contains(mtr, buf_block_align(base),
  228. MTR_MEMO_PAGE_X_FIX));
  229. ut_ad(mtr_memo_contains(mtr, buf_block_align(node2),
  230. MTR_MEMO_PAGE_X_FIX));
  231. buf_ptr_get_fsp_addr(node2, &space, &node2_addr);
  232. node1_addr = flst_get_prev_addr(node2, mtr);
  233. node3_addr = flst_get_next_addr(node2, mtr);
  234. if (!fil_addr_is_null(node1_addr)) {
  235. /* Update next field of node1 */
  236. if (node1_addr.page == node2_addr.page) {
  237. node1 = buf_frame_align(node2) + node1_addr.boffset;
  238. } else {
  239. node1 = fut_get_ptr(space, node1_addr, RW_X_LATCH,
  240. mtr);
  241. }
  242. ut_ad(node1 != node2);
  243. flst_write_addr(node1 + FLST_NEXT, node3_addr, mtr);
  244. } else {
  245. /* node2 was first in list: update first field in base */
  246. flst_write_addr(base + FLST_FIRST, node3_addr, mtr);
  247. }
  248. if (!fil_addr_is_null(node3_addr)) {
  249. /* Update prev field of node3 */
  250. if (node3_addr.page == node2_addr.page) {
  251. node3 = buf_frame_align(node2) + node3_addr.boffset;
  252. } else {
  253. node3 = fut_get_ptr(space, node3_addr, RW_X_LATCH,
  254. mtr);
  255. }
  256. ut_ad(node2 != node3);
  257. flst_write_addr(node3 + FLST_PREV, node1_addr, mtr);
  258. } else {
  259. /* node2 was last in list: update last field in base */
  260. flst_write_addr(base + FLST_LAST, node1_addr, mtr);
  261. }
  262. /* Update len of base node */
  263. len = flst_get_len(base, mtr);
  264. ut_ad(len > 0);
  265. mlog_write_ulint(base + FLST_LEN, len - 1, MLOG_4BYTES, mtr); 
  266. }
  267. /************************************************************************
  268. Cuts off the tail of the list, including the node given. The number of
  269. nodes which will be removed must be provided by the caller, as this function
  270. does not measure the length of the tail. */
  271. void
  272. flst_cut_end(
  273. /*=========*/
  274. flst_base_node_t* base, /* in: pointer to base node of list */
  275. flst_node_t* node2, /* in: first node to remove */
  276. ulint n_nodes,/* in: number of nodes to remove,
  277. must be >= 1 */
  278. mtr_t* mtr) /* in: mini-transaction handle */
  279. {
  280. ulint space;
  281. flst_node_t* node1;
  282. fil_addr_t node1_addr;
  283. fil_addr_t node2_addr;
  284. ulint len;
  285. ut_ad(mtr && node2 && base);
  286. ut_ad(mtr_memo_contains(mtr, buf_block_align(base),
  287. MTR_MEMO_PAGE_X_FIX));
  288. ut_ad(mtr_memo_contains(mtr, buf_block_align(node2),
  289. MTR_MEMO_PAGE_X_FIX));
  290. ut_ad(n_nodes > 0);
  291. buf_ptr_get_fsp_addr(node2, &space, &node2_addr);
  292. node1_addr = flst_get_prev_addr(node2, mtr);
  293. if (!fil_addr_is_null(node1_addr)) {
  294. /* Update next field of node1 */
  295. if (node1_addr.page == node2_addr.page) {
  296. node1 = buf_frame_align(node2) + node1_addr.boffset;
  297. } else {
  298. node1 = fut_get_ptr(space, node1_addr, RW_X_LATCH,
  299. mtr);
  300. }
  301. flst_write_addr(node1 + FLST_NEXT, fil_addr_null, mtr);
  302. } else {
  303. /* node2 was first in list: update the field in base */
  304. flst_write_addr(base + FLST_FIRST, fil_addr_null, mtr);
  305. }
  306. flst_write_addr(base + FLST_LAST, node1_addr, mtr);
  307. /* Update len of base node */
  308. len = flst_get_len(base, mtr);
  309. ut_ad(len >= n_nodes);
  310. mlog_write_ulint(base + FLST_LEN, len - n_nodes, MLOG_4BYTES, mtr); 
  311. }
  312. /************************************************************************
  313. Cuts off the tail of the list, not including the given node. The number of
  314. nodes which will be removed must be provided by the caller, as this function
  315. does not measure the length of the tail. */
  316. void
  317. flst_truncate_end(
  318. /*==============*/
  319. flst_base_node_t* base, /* in: pointer to base node of list */
  320. flst_node_t* node2, /* in: first node not to remove */
  321. ulint n_nodes,/* in: number of nodes to remove */
  322. mtr_t* mtr) /* in: mini-transaction handle */
  323. {
  324. fil_addr_t node2_addr;
  325. ulint len;
  326. ulint space;
  327. ut_ad(mtr && node2 && base);
  328. ut_ad(mtr_memo_contains(mtr, buf_block_align(base),
  329. MTR_MEMO_PAGE_X_FIX));
  330. ut_ad(mtr_memo_contains(mtr, buf_block_align(node2),
  331. MTR_MEMO_PAGE_X_FIX));
  332. if (n_nodes == 0) {
  333. ut_ad(fil_addr_is_null(flst_get_next_addr(node2, mtr)));
  334. return;
  335. }
  336. buf_ptr_get_fsp_addr(node2, &space, &node2_addr);
  337. /* Update next field of node2 */
  338. flst_write_addr(node2 + FLST_NEXT, fil_addr_null, mtr);
  339. flst_write_addr(base + FLST_LAST, node2_addr, mtr);
  340. /* Update len of base node */
  341. len = flst_get_len(base, mtr);
  342. ut_ad(len >= n_nodes);
  343. mlog_write_ulint(base + FLST_LEN, len - n_nodes, MLOG_4BYTES, mtr); 
  344. }
  345. /************************************************************************
  346. Validates a file-based list. */
  347. ibool
  348. flst_validate(
  349. /*==========*/
  350. /* out: TRUE if ok */
  351. flst_base_node_t* base, /* in: pointer to base node of list */
  352. mtr_t* mtr1) /* in: mtr */
  353. {
  354. ulint space;
  355. flst_node_t* node;
  356. fil_addr_t node_addr;
  357. fil_addr_t base_addr;
  358. ulint len;
  359. ulint i;
  360. mtr_t mtr2;
  361. ut_ad(base);
  362. ut_ad(mtr_memo_contains(mtr1, buf_block_align(base),
  363. MTR_MEMO_PAGE_X_FIX));
  364. /* We use two mini-transaction handles: the first is used to
  365. lock the base node, and prevent other threads from modifying the
  366. list. The second is used to traverse the list. We cannot run the
  367. second mtr without committing it at times, because if the list
  368. is long, then the x-locked pages could fill the buffer resulting
  369. in a deadlock. */
  370. /* Find out the space id */
  371. buf_ptr_get_fsp_addr(base, &space, &base_addr);
  372. len = flst_get_len(base, mtr1);
  373. node_addr = flst_get_first(base, mtr1);
  374. for (i = 0; i < len; i++) {
  375. mtr_start(&mtr2);
  376. node = fut_get_ptr(space, node_addr, RW_X_LATCH, &mtr2);
  377. node_addr = flst_get_next_addr(node, &mtr2);
  378. mtr_commit(&mtr2); /* Commit mtr2 each round to prevent buffer
  379.    becoming full */
  380. }
  381. ut_a(fil_addr_is_null(node_addr));
  382. node_addr = flst_get_last(base, mtr1);
  383. for (i = 0; i < len; i++) {
  384. mtr_start(&mtr2);
  385. node = fut_get_ptr(space, node_addr, RW_X_LATCH, &mtr2);
  386. node_addr = flst_get_prev_addr(node, &mtr2);
  387. mtr_commit(&mtr2); /* Commit mtr2 each round to prevent buffer
  388.    becoming full */
  389. }
  390. ut_a(fil_addr_is_null(node_addr));
  391. return(TRUE);
  392. }
  393. /************************************************************************
  394. Prints info of a file-based list. */
  395. void
  396. flst_print(
  397. /*=======*/
  398. flst_base_node_t* base, /* in: pointer to base node of list */
  399. mtr_t* mtr) /* in: mtr */
  400. {
  401. buf_frame_t* frame;
  402. ulint len;
  403. ut_ad(base && mtr);
  404. ut_ad(mtr_memo_contains(mtr, buf_block_align(base),
  405. MTR_MEMO_PAGE_X_FIX));
  406. frame = buf_frame_align(base);
  407. len = flst_get_len(base, mtr);
  408. fprintf(stderr,
  409. "FILE-BASED LIST:n"
  410. "Base node in space %lu page %lu byte offset %lu; len %lun",
  411.        (ulong) buf_frame_get_space_id(frame),
  412.        (ulong) buf_frame_get_page_no(frame),
  413.        (ulong) (base - frame), (ulong) len);
  414. }