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

MySQL数据库

开发平台:

Visual C++

  1. /******************************************************
  2. The database buffer read
  3. (c) 1995 Innobase Oy
  4. Created 11/5/1995 Heikki Tuuri
  5. *******************************************************/
  6. #ifndef buf0rea_h
  7. #define buf0rea_h
  8. #include "univ.i"
  9. #include "buf0types.h"
  10. /************************************************************************
  11. High-level function which reads a page asynchronously from a file to the
  12. buffer buf_pool if it is not already there. Sets the io_fix flag and sets
  13. an exclusive lock on the buffer frame. The flag is cleared and the x-lock
  14. released by the i/o-handler thread. Does a random read-ahead if it seems
  15. sensible. */
  16. ulint
  17. buf_read_page(
  18. /*==========*/
  19. /* out: number of page read requests issued: this can
  20. be > 1 if read-ahead occurred */
  21. ulint space, /* in: space id */
  22. ulint offset);/* in: page number */
  23. /************************************************************************
  24. Applies linear read-ahead if in the buf_pool the page is a border page of
  25. a linear read-ahead area and all the pages in the area have been accessed.
  26. Does not read any page if the read-ahead mechanism is not activated. Note
  27. that the the algorithm looks at the 'natural' adjacent successor and
  28. predecessor of the page, which on the leaf level of a B-tree are the next
  29. and previous page in the chain of leaves. To know these, the page specified
  30. in (space, offset) must already be present in the buf_pool. Thus, the
  31. natural way to use this function is to call it when a page in the buf_pool
  32. is accessed the first time, calling this function just after it has been
  33. bufferfixed.
  34. NOTE 1: as this function looks at the natural predecessor and successor
  35. fields on the page, what happens, if these are not initialized to any
  36. sensible value? No problem, before applying read-ahead we check that the
  37. area to read is within the span of the space, if not, read-ahead is not
  38. applied. An uninitialized value may result in a useless read operation, but
  39. only very improbably.
  40. NOTE 2: the calling thread may own latches on pages: to avoid deadlocks this
  41. function must be written such that it cannot end up waiting for these
  42. latches!
  43. NOTE 3: the calling thread must want access to the page given: this rule is
  44. set to prevent unintended read-aheads performed by ibuf routines, a situation
  45. which could result in a deadlock if the OS does not support asynchronous io. */
  46. ulint
  47. buf_read_ahead_linear(
  48. /*==================*/
  49. /* out: number of page read requests issued */
  50. ulint space, /* in: space id */
  51. ulint offset);/* in: page number of a page; NOTE: the current thread
  52. must want access to this page (see NOTE 3 above) */
  53. /************************************************************************
  54. Issues read requests for pages which the ibuf module wants to read in, in
  55. order to contract the insert buffer tree. Technically, this function is like
  56. a read-ahead function. */
  57. void
  58. buf_read_ibuf_merge_pages(
  59. /*======================*/
  60. ibool sync, /* in: TRUE if the caller wants this function
  61. to wait for the highest address page to get
  62. read in, before this function returns */
  63. ulint* space_ids, /* in: array of space ids */
  64. ib_longlong* space_versions,/* in: the spaces must have this version
  65. number (timestamp), otherwise we discard the
  66. read; we use this to cancel reads if
  67. DISCARD + IMPORT may have changed the
  68. tablespace size */
  69. ulint* page_nos, /* in: array of page numbers to read, with the
  70. highest page number the last in the array */
  71. ulint n_stored); /* in: number of page numbers in the array */
  72. /************************************************************************
  73. Issues read requests for pages which recovery wants to read in. */
  74. void
  75. buf_read_recv_pages(
  76. /*================*/
  77. ibool sync, /* in: TRUE if the caller wants this function
  78. to wait for the highest address page to get
  79. read in, before this function returns */
  80. ulint space, /* in: space id */
  81. ulint* page_nos, /* in: array of page numbers to read, with the
  82. highest page number the last in the array */
  83. ulint n_stored); /* in: number of page numbers in the array */
  84. /* The size in pages of the area which the read-ahead algorithms read if
  85. invoked */
  86. #define BUF_READ_AHEAD_AREA ut_min(64, ut_2_power_up(buf_pool->curr_size / 32))
  87. /* Modes used in read-ahead */
  88. #define BUF_READ_IBUF_PAGES_ONLY 131
  89. #define BUF_READ_ANY_PAGE 132
  90. #endif