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

MySQL数据库

开发平台:

Visual C++

  1. /*   Innobase relational database engine; Copyright (C) 2001 Innobase Oy
  2.      
  3.      This program is free software; you can redistribute it and/or modify
  4.      it under the terms of the GNU General Public License 2
  5.      as published by the Free Software Foundation in June 1991.
  6.      
  7.      This program is distributed in the hope that it will be useful,
  8.      but WITHOUT ANY WARRANTY; without even the implied warranty of
  9.      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10.      GNU General Public License for more details.
  11.      
  12.      You should have received a copy of the GNU General Public License 2
  13.      along with this program (in file COPYING); if not, write to the Free
  14.      Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
  15. /******************************************************
  16. The database buffer pool high-level routines
  17. (c) 1995 Innobase Oy
  18. Created 11/5/1995 Heikki Tuuri
  19. *******************************************************/
  20. #ifndef buf0buf_h
  21. #define buf0buf_h
  22. #include "univ.i"
  23. #include "fil0fil.h"
  24. #include "mtr0types.h"
  25. #include "buf0types.h"
  26. #include "sync0rw.h"
  27. #include "hash0hash.h"
  28. #include "ut0byte.h"
  29. #include "os0proc.h"
  30. /* Flags for flush types */
  31. #define BUF_FLUSH_LRU 1
  32. #define BUF_FLUSH_SINGLE_PAGE 2
  33. #define BUF_FLUSH_LIST 3 /* An array in the pool struct
  34. has size BUF_FLUSH_LIST + 1: if you
  35. add more flush types, put them in
  36. the middle! */
  37. /* Modes for buf_page_get_gen */
  38. #define BUF_GET 10 /* get always */
  39. #define BUF_GET_IF_IN_POOL 11 /* get if in pool */
  40. #define BUF_GET_NOWAIT 12 /* get if can set the latch without
  41. waiting */
  42. #define BUF_GET_NO_LATCH 14 /* get and bufferfix, but set no latch;
  43. we have separated this case, because
  44. it is error-prone programming not to
  45. set a latch, and it should be used
  46. with care */
  47. /* Modes for buf_page_get_known_nowait */
  48. #define BUF_MAKE_YOUNG 51
  49. #define BUF_KEEP_OLD 52
  50. extern buf_pool_t*  buf_pool;  /* The buffer pool of the database */
  51. extern ibool buf_debug_prints;/* If this is set TRUE, the program
  52. prints info whenever read or flush
  53. occurs */
  54. /************************************************************************
  55. Creates the buffer pool. */
  56. buf_pool_t*
  57. buf_pool_init(
  58. /*==========*/
  59. /* out, own: buf_pool object, NULL if not
  60. enough memory or error */
  61. ulint max_size, /* in: maximum size of the buf_pool in
  62. blocks */
  63. ulint curr_size, /* in: current size to use, must be <=
  64. max_size, currently must be equal to
  65. max_size */
  66. ulint n_frames); /* in: number of frames; if AWE is used,
  67. this is the size of the address space window
  68. where physical memory pages are mapped; if
  69. AWE is not used then this must be the same
  70. as max_size */
  71. /*************************************************************************
  72. Gets the current size of buffer buf_pool in bytes. In the case of AWE, the
  73. size of AWE window (= the frames). */
  74. UNIV_INLINE
  75. ulint
  76. buf_pool_get_curr_size(void);
  77. /*========================*/
  78. /* out: size in bytes */
  79. /*************************************************************************
  80. Gets the maximum size of buffer pool in bytes. In the case of AWE, the
  81. size of AWE window (= the frames). */
  82. UNIV_INLINE
  83. ulint
  84. buf_pool_get_max_size(void);
  85. /*=======================*/
  86. /* out: size in bytes */
  87. /************************************************************************
  88. Gets the smallest oldest_modification lsn for any page in the pool. Returns
  89. ut_dulint_zero if all modified pages have been flushed to disk. */
  90. UNIV_INLINE
  91. dulint
  92. buf_pool_get_oldest_modification(void);
  93. /*==================================*/
  94. /* out: oldest modification in pool,
  95. ut_dulint_zero if none */
  96. /*************************************************************************
  97. Allocates a buffer frame. */
  98. buf_frame_t*
  99. buf_frame_alloc(void);
  100. /*==================*/
  101. /* out: buffer frame */
  102. /*************************************************************************
  103. Frees a buffer frame which does not contain a file page. */
  104. void
  105. buf_frame_free(
  106. /*===========*/
  107. buf_frame_t* frame); /* in: buffer frame */
  108. /*************************************************************************
  109. Copies contents of a buffer frame to a given buffer. */
  110. UNIV_INLINE
  111. byte*
  112. buf_frame_copy(
  113. /*===========*/
  114. /* out: buf */
  115. byte* buf, /* in: buffer to copy to */
  116. buf_frame_t* frame); /* in: buffer frame */
  117. /******************************************************************
  118. NOTE! The following macros should be used instead of buf_page_get_gen,
  119. to improve debugging. Only values RW_S_LATCH and RW_X_LATCH are allowed
  120. in LA! */
  121. #define buf_page_get(SP, OF, LA, MTR)    buf_page_get_gen(
  122. SP, OF, LA, NULL,
  123. BUF_GET, __FILE__, __LINE__, MTR)
  124. /******************************************************************
  125. Use these macros to bufferfix a page with no latching. Remember not to
  126. read the contents of the page unless you know it is safe. Do not modify
  127. the contents of the page! We have separated this case, because it is
  128. error-prone programming not to set a latch, and it should be used
  129. with care. */
  130. #define buf_page_get_with_no_latch(SP, OF, MTR)    buf_page_get_gen(
  131. SP, OF, RW_NO_LATCH, NULL,
  132. BUF_GET_NO_LATCH, __FILE__, __LINE__, MTR)
  133. /******************************************************************
  134. NOTE! The following macros should be used instead of buf_page_get_gen, to
  135. improve debugging. Only values RW_S_LATCH and RW_X_LATCH are allowed as LA! */
  136. #define buf_page_get_nowait(SP, OF, LA, MTR)    buf_page_get_gen(
  137. SP, OF, LA, NULL,
  138. BUF_GET_NOWAIT, __FILE__, __LINE__, MTR)
  139. /******************************************************************
  140. NOTE! The following macros should be used instead of
  141. buf_page_optimistic_get_func, to improve debugging. Only values RW_S_LATCH and
  142. RW_X_LATCH are allowed as LA! */
  143. #define buf_page_optimistic_get(LA, BL, G, MC, MTR) buf_page_optimistic_get_func(
  144. LA, BL, G, MC, __FILE__, __LINE__, MTR)
  145. /************************************************************************
  146. This is the general function used to get optimistic access to a database
  147. page. */
  148. ibool
  149. buf_page_optimistic_get_func(
  150. /*=========================*/
  151. /* out: TRUE if success */
  152. ulint rw_latch,/* in: RW_S_LATCH, RW_X_LATCH */
  153. buf_block_t* block, /* in: guessed block */
  154. buf_frame_t* guess, /* in: guessed frame; note that AWE may move
  155. frames */
  156. dulint modify_clock,/* in: modify clock value if mode is
  157. ..._GUESS_ON_CLOCK */
  158. const char* file, /* in: file name */
  159. ulint line, /* in: line where called */
  160. mtr_t* mtr); /* in: mini-transaction */
  161. /************************************************************************
  162. Tries to get the page, but if file io is required, releases all latches
  163. in mtr down to the given savepoint. If io is required, this function
  164. retrieves the page to buffer buf_pool, but does not bufferfix it or latch
  165. it. */
  166. UNIV_INLINE
  167. buf_frame_t*
  168. buf_page_get_release_on_io(
  169. /*=======================*/
  170. /* out: pointer to the frame, or NULL
  171. if not in buffer buf_pool */
  172. ulint space, /* in: space id */
  173. ulint offset, /* in: offset of the page within space
  174. in units of a page */
  175. buf_frame_t* guess, /* in: guessed frame or NULL */
  176. ulint rw_latch, /* in: RW_X_LATCH, RW_S_LATCH,
  177. or RW_NO_LATCH */
  178. ulint savepoint, /* in: mtr savepoint */
  179. mtr_t* mtr); /* in: mtr */
  180. /************************************************************************
  181. This is used to get access to a known database page, when no waiting can be
  182. done. */
  183. ibool
  184. buf_page_get_known_nowait(
  185. /*======================*/
  186. /* out: TRUE if success */
  187. ulint rw_latch,/* in: RW_S_LATCH, RW_X_LATCH */
  188. buf_frame_t* guess, /* in: the known page frame */
  189. ulint mode, /* in: BUF_MAKE_YOUNG or BUF_KEEP_OLD */
  190. const char* file, /* in: file name */
  191. ulint line, /* in: line where called */
  192. mtr_t* mtr); /* in: mini-transaction */
  193. /************************************************************************
  194. This is the general function used to get access to a database page. */
  195. buf_frame_t*
  196. buf_page_get_gen(
  197. /*=============*/
  198. /* out: pointer to the frame or NULL */
  199. ulint space, /* in: space id */
  200. ulint offset, /* in: page number */
  201. ulint rw_latch,/* in: RW_S_LATCH, RW_X_LATCH, RW_NO_LATCH */
  202. buf_frame_t* guess, /* in: guessed frame or NULL */
  203. ulint mode, /* in: BUF_GET, BUF_GET_IF_IN_POOL,
  204. BUF_GET_NO_LATCH */
  205. const char* file, /* in: file name */
  206. ulint line, /* in: line where called */
  207. mtr_t* mtr); /* in: mini-transaction */
  208. /************************************************************************
  209. Initializes a page to the buffer buf_pool. The page is usually not read
  210. from a file even if it cannot be found in the buffer buf_pool. This is one
  211. of the functions which perform to a block a state transition NOT_USED =>
  212. FILE_PAGE (the other is buf_page_init_for_read above). */
  213. buf_frame_t*
  214. buf_page_create(
  215. /*============*/
  216. /* out: pointer to the frame, page bufferfixed */
  217. ulint space, /* in: space id */
  218. ulint offset, /* in: offset of the page within space in units of
  219. a page */
  220. mtr_t* mtr); /* in: mini-transaction handle */
  221. /************************************************************************
  222. Inits a page to the buffer buf_pool, for use in ibbackup --restore. */
  223. void
  224. buf_page_init_for_backup_restore(
  225. /*=============================*/
  226. ulint space, /* in: space id */
  227. ulint offset, /* in: offset of the page within space
  228. in units of a page */
  229. buf_block_t* block); /* in: block to init */
  230. /************************************************************************
  231. Decrements the bufferfix count of a buffer control block and releases
  232. a latch, if specified. */
  233. UNIV_INLINE
  234. void
  235. buf_page_release(
  236. /*=============*/
  237. buf_block_t* block, /* in: buffer block */
  238. ulint rw_latch, /* in: RW_S_LATCH, RW_X_LATCH,
  239. RW_NO_LATCH */
  240. mtr_t* mtr); /* in: mtr */
  241. /************************************************************************
  242. Moves a page to the start of the buffer pool LRU list. This high-level
  243. function can be used to prevent an important page from from slipping out of
  244. the buffer pool. */
  245. void
  246. buf_page_make_young(
  247. /*=================*/
  248. buf_frame_t* frame); /* in: buffer frame of a file page */
  249. /************************************************************************
  250. Returns TRUE if the page can be found in the buffer pool hash table. NOTE
  251. that it is possible that the page is not yet read from disk, though. */
  252. ibool
  253. buf_page_peek(
  254. /*==========*/
  255. /* out: TRUE if found from page hash table,
  256. NOTE that the page is not necessarily yet read
  257. from disk! */
  258. ulint space, /* in: space id */
  259. ulint offset);/* in: page number */
  260. /************************************************************************
  261. Returns the buffer control block if the page can be found in the buffer
  262. pool. NOTE that it is possible that the page is not yet read
  263. from disk, though. This is a very low-level function: use with care! */
  264. buf_block_t*
  265. buf_page_peek_block(
  266. /*================*/
  267. /* out: control block if found from page hash table,
  268. otherwise NULL; NOTE that the page is not necessarily
  269. yet read from disk! */
  270. ulint space, /* in: space id */
  271. ulint offset);/* in: page number */
  272. /************************************************************************
  273. Resets the check_index_page_at_flush field of a page if found in the buffer
  274. pool. */
  275. void
  276. buf_reset_check_index_page_at_flush(
  277. /*================================*/
  278. ulint space, /* in: space id */
  279. ulint offset);/* in: page number */
  280. /************************************************************************
  281. Sets file_page_was_freed TRUE if the page is found in the buffer pool.
  282. This function should be called when we free a file page and want the
  283. debug version to check that it is not accessed any more unless
  284. reallocated. */
  285. buf_block_t*
  286. buf_page_set_file_page_was_freed(
  287. /*=============================*/
  288. /* out: control block if found from page hash table,
  289. otherwise NULL */
  290. ulint space, /* in: space id */
  291. ulint offset); /* in: page number */
  292. /************************************************************************
  293. Sets file_page_was_freed FALSE if the page is found in the buffer pool.
  294. This function should be called when we free a file page and want the
  295. debug version to check that it is not accessed any more unless
  296. reallocated. */
  297. buf_block_t*
  298. buf_page_reset_file_page_was_freed(
  299. /*===============================*/
  300. /* out: control block if found from page hash table,
  301. otherwise NULL */
  302. ulint space, /* in: space id */
  303. ulint offset); /* in: page number */
  304. /************************************************************************
  305. Recommends a move of a block to the start of the LRU list if there is danger
  306. of dropping from the buffer pool. NOTE: does not reserve the buffer pool
  307. mutex. */
  308. UNIV_INLINE
  309. ibool
  310. buf_block_peek_if_too_old(
  311. /*======================*/
  312. /* out: TRUE if should be made younger */
  313. buf_block_t* block); /* in: block to make younger */
  314. /************************************************************************
  315. Returns the current state of is_hashed of a page. FALSE if the page is
  316. not in the pool. NOTE that this operation does not fix the page in the
  317. pool if it is found there. */
  318. ibool
  319. buf_page_peek_if_search_hashed(
  320. /*===========================*/
  321. /* out: TRUE if page hash index is built in search
  322. system */
  323. ulint space, /* in: space id */
  324. ulint offset);/* in: page number */
  325. /************************************************************************
  326. Gets the youngest modification log sequence number for a frame.
  327. Returns zero if not file page or no modification occurred yet. */
  328. UNIV_INLINE
  329. dulint
  330. buf_frame_get_newest_modification(
  331. /*==============================*/
  332. /* out: newest modification to page */
  333. buf_frame_t* frame); /* in: pointer to a frame */
  334. /************************************************************************
  335. Increments the modify clock of a frame by 1. The caller must (1) own the
  336. pool mutex and block bufferfix count has to be zero, (2) or own an x-lock
  337. on the block. */
  338. UNIV_INLINE
  339. dulint
  340. buf_frame_modify_clock_inc(
  341. /*=======================*/
  342. /* out: new value */
  343. buf_frame_t* frame); /* in: pointer to a frame */
  344. /************************************************************************
  345. Increments the modify clock of a frame by 1. The caller must (1) own the
  346. buf_pool mutex and block bufferfix count has to be zero, (2) or own an x-lock
  347. on the block. */
  348. UNIV_INLINE
  349. dulint
  350. buf_block_modify_clock_inc(
  351. /*=======================*/
  352. /* out: new value */
  353. buf_block_t* block); /* in: block */
  354. /************************************************************************
  355. Returns the value of the modify clock. The caller must have an s-lock 
  356. or x-lock on the block. */
  357. UNIV_INLINE
  358. dulint
  359. buf_frame_get_modify_clock(
  360. /*=======================*/
  361. /* out: value */
  362. buf_frame_t* frame); /* in: pointer to a frame */
  363. /************************************************************************
  364. Calculates a page checksum which is stored to the page when it is written
  365. to a file. Note that we must be careful to calculate the same value
  366. on 32-bit and 64-bit architectures. */
  367. ulint
  368. buf_calc_page_new_checksum(
  369. /*=======================*/
  370.        /* out: checksum */
  371. byte*   page); /* in: buffer page */
  372. /************************************************************************
  373. In versions < 4.0.14 and < 4.1.1 there was a bug that the checksum only
  374. looked at the first few bytes of the page. This calculates that old
  375. checksum. 
  376. NOTE: we must first store the new formula checksum to
  377. FIL_PAGE_SPACE_OR_CHKSUM before calculating and storing this old checksum
  378. because this takes that field as an input! */
  379. ulint
  380. buf_calc_page_old_checksum(
  381. /*=======================*/
  382.        /* out: checksum */
  383. byte*    page); /* in: buffer page */
  384. /************************************************************************
  385. Checks if a page is corrupt. */
  386. ibool
  387. buf_page_is_corrupted(
  388. /*==================*/
  389. /* out: TRUE if corrupted */
  390. byte* read_buf); /* in: a database page */
  391. /**************************************************************************
  392. Gets the page number of a pointer pointing within a buffer frame containing
  393. a file page. */
  394. UNIV_INLINE
  395. ulint
  396. buf_frame_get_page_no(
  397. /*==================*/
  398. /* out: page number */
  399. byte* ptr); /* in: pointer to within a buffer frame */
  400. /**************************************************************************
  401. Gets the space id of a pointer pointing within a buffer frame containing a
  402. file page. */
  403. UNIV_INLINE
  404. ulint
  405. buf_frame_get_space_id(
  406. /*===================*/
  407. /* out: space id */
  408. byte* ptr); /* in: pointer to within a buffer frame */
  409. /**************************************************************************
  410. Gets the space id, page offset, and byte offset within page of a
  411. pointer pointing to a buffer frame containing a file page. */
  412. UNIV_INLINE
  413. void
  414. buf_ptr_get_fsp_addr(
  415. /*=================*/
  416. byte* ptr, /* in: pointer to a buffer frame */
  417. ulint* space, /* out: space id */
  418. fil_addr_t* addr); /* out: page offset and byte offset */
  419. /**************************************************************************
  420. Gets the hash value of the page the pointer is pointing to. This can be used
  421. in searches in the lock hash table. */
  422. UNIV_INLINE
  423. ulint
  424. buf_frame_get_lock_hash_val(
  425. /*========================*/
  426. /* out: lock hash value */
  427. byte* ptr); /* in: pointer to within a buffer frame */
  428. /**************************************************************************
  429. Gets the mutex number protecting the page record lock hash chain in the lock
  430. table. */
  431. UNIV_INLINE
  432. mutex_t*
  433. buf_frame_get_lock_mutex(
  434. /*=====================*/
  435. /* out: mutex */
  436. byte* ptr); /* in: pointer to within a buffer frame */
  437. /***********************************************************************
  438. Gets the frame the pointer is pointing to. */
  439. UNIV_INLINE
  440. buf_frame_t*
  441. buf_frame_align(
  442. /*============*/
  443. /* out: pointer to frame */
  444. byte* ptr); /* in: pointer to a frame */
  445. /***********************************************************************
  446. Checks if a pointer points to the block array of the buffer pool (blocks, not
  447. the frames). */
  448. UNIV_INLINE
  449. ibool
  450. buf_pool_is_block(
  451. /*==============*/
  452. /* out: TRUE if pointer to block */
  453. void* ptr); /* in: pointer to memory */
  454. /*************************************************************************
  455. Validates the buffer pool data structure. */
  456. ibool
  457. buf_validate(void);
  458. /*==============*/
  459. /************************************************************************
  460. Prints a page to stderr. */
  461. void
  462. buf_page_print(
  463. /*===========*/
  464. byte* read_buf); /* in: a database page */
  465. /*************************************************************************
  466. Prints info of the buffer pool data structure. */
  467. void
  468. buf_print(void);
  469. /*============*/
  470. /*************************************************************************
  471. Returns the number of pending buf pool ios. */
  472. ulint
  473. buf_get_n_pending_ios(void);
  474. /*=======================*/
  475. /*************************************************************************
  476. Prints info of the buffer i/o. */
  477. void
  478. buf_print_io(
  479. /*=========*/
  480. FILE* file); /* in: file where to print */
  481. /*************************************************************************
  482. Returns the ratio in percents of modified pages in the buffer pool /
  483. database pages in the buffer pool. */
  484. ulint
  485. buf_get_modified_ratio_pct(void);
  486. /*============================*/
  487. /**************************************************************************
  488. Refreshes the statistics used to print per-second averages. */
  489. void
  490. buf_refresh_io_stats(void);
  491. /*======================*/
  492. /*************************************************************************
  493. Checks that all file pages in the buffer are in a replaceable state. */
  494. ibool
  495. buf_all_freed(void);
  496. /*===============*/
  497. /*************************************************************************
  498. Checks that there currently are no pending i/o-operations for the buffer
  499. pool. */
  500. ibool
  501. buf_pool_check_no_pending_io(void);
  502. /*==============================*/
  503. /* out: TRUE if there is no pending i/o */
  504. /*************************************************************************
  505. Invalidates the file pages in the buffer pool when an archive recovery is
  506. completed. All the file pages buffered must be in a replaceable state when
  507. this function is called: not latched and not modified. */
  508. void
  509. buf_pool_invalidate(void);
  510. /*=====================*/
  511. /*========================================================================
  512. --------------------------- LOWER LEVEL ROUTINES -------------------------
  513. =========================================================================*/
  514. /************************************************************************
  515. Maps the page of block to a frame, if not mapped yet. Unmaps some page
  516. from the end of the awe_LRU_free_mapped. */
  517. void
  518. buf_awe_map_page_to_frame(
  519. /*======================*/
  520. buf_block_t* block, /* in: block whose page should be
  521. mapped to a frame */
  522. ibool add_to_mapped_list);/* in: TRUE if we in the case
  523. we need to map the page should also
  524. add the block to the
  525. awe_LRU_free_mapped list */
  526. #ifdef UNIV_SYNC_DEBUG
  527. /*************************************************************************
  528. Adds latch level info for the rw-lock protecting the buffer frame. This
  529. should be called in the debug version after a successful latching of a
  530. page if we know the latching order level of the acquired latch. */
  531. UNIV_INLINE
  532. void
  533. buf_page_dbg_add_level(
  534. /*===================*/
  535. buf_frame_t* frame, /* in: buffer page where we have acquired
  536. a latch */
  537. ulint level); /* in: latching order level */
  538. #endif /* UNIV_SYNC_DEBUG */
  539. /*************************************************************************
  540. Gets a pointer to the memory frame of a block. */
  541. UNIV_INLINE
  542. buf_frame_t*
  543. buf_block_get_frame(
  544. /*================*/
  545. /* out: pointer to the frame */
  546. buf_block_t* block); /* in: pointer to the control block */
  547. /*************************************************************************
  548. Gets the space id of a block. */
  549. UNIV_INLINE
  550. ulint
  551. buf_block_get_space(
  552. /*================*/
  553. /* out: space id */
  554. buf_block_t* block); /* in: pointer to the control block */
  555. /*************************************************************************
  556. Gets the page number of a block. */
  557. UNIV_INLINE
  558. ulint
  559. buf_block_get_page_no(
  560. /*==================*/
  561. /* out: page number */
  562. buf_block_t* block); /* in: pointer to the control block */
  563. /***********************************************************************
  564. Gets the block to whose frame the pointer is pointing to. */
  565. UNIV_INLINE
  566. buf_block_t*
  567. buf_block_align(
  568. /*============*/
  569. /* out: pointer to block */
  570. byte* ptr); /* in: pointer to a frame */
  571. /************************************************************************
  572. This function is used to get info if there is an io operation
  573. going on on a buffer page. */
  574. UNIV_INLINE
  575. ibool
  576. buf_page_io_query(
  577. /*==============*/
  578. /* out: TRUE if io going on */
  579. buf_block_t* block); /* in: pool block, must be bufferfixed */
  580. /***********************************************************************
  581. Accessor function for block array. */
  582. UNIV_INLINE
  583. buf_block_t*
  584. buf_pool_get_nth_block(
  585. /*===================*/
  586. /* out: pointer to block */
  587. buf_pool_t* pool, /* in: pool */
  588. ulint i); /* in: index of the block */
  589. /************************************************************************
  590. Function which inits a page for read to the buffer buf_pool. If the page is
  591. (1) already in buf_pool, or
  592. (2) if we specify to read only ibuf pages and the page is not an ibuf page, or
  593. (3) if the space is deleted or being deleted,
  594. then this function does nothing.
  595. Sets the io_fix flag to BUF_IO_READ and sets a non-recursive exclusive lock
  596. on the buffer frame. The io-handler must take care that the flag is cleared
  597. and the lock released later. This is one of the functions which perform the
  598. state transition NOT_USED => FILE_PAGE to a block (the other is
  599. buf_page_create). */ 
  600. buf_block_t*
  601. buf_page_init_for_read(
  602. /*===================*/
  603. /* out: pointer to the block or NULL */
  604. ulint* err, /* out: DB_SUCCESS or DB_TABLESPACE_DELETED */
  605. ulint mode, /* in: BUF_READ_IBUF_PAGES_ONLY, ... */
  606. ulint space, /* in: space id */
  607. ib_longlong tablespace_version,/* in: prevents reading from a wrong
  608. version of the tablespace in case we have done
  609. DISCARD + IMPORT */
  610. ulint offset);/* in: page number */
  611. /************************************************************************
  612. Completes an asynchronous read or write request of a file page to or from
  613. the buffer pool. */
  614. void
  615. buf_page_io_complete(
  616. /*=================*/
  617. buf_block_t* block); /* in: pointer to the block in question */
  618. /************************************************************************
  619. Calculates a folded value of a file page address to use in the page hash
  620. table. */
  621. UNIV_INLINE
  622. ulint
  623. buf_page_address_fold(
  624. /*==================*/
  625. /* out: the folded value */
  626. ulint space, /* in: space id */
  627. ulint offset);/* in: offset of the page within space */
  628. /**********************************************************************
  629. Returns the control block of a file page, NULL if not found. */
  630. UNIV_INLINE
  631. buf_block_t*
  632. buf_page_hash_get(
  633. /*==============*/
  634. /* out: block, NULL if not found */
  635. ulint space, /* in: space id */
  636. ulint offset);/* in: offset of the page within space */
  637. /***********************************************************************
  638. Increments the pool clock by one and returns its new value. Remember that
  639. in the 32 bit version the clock wraps around at 4 billion! */
  640. UNIV_INLINE
  641. ulint
  642. buf_pool_clock_tic(void);
  643. /*====================*/
  644. /* out: new clock value */
  645. /*************************************************************************
  646. Gets the current length of the free list of buffer blocks. */
  647. ulint
  648. buf_get_free_list_len(void);
  649. /*=======================*/
  650. /* The buffer control block structure */
  651. struct buf_block_struct{
  652. /* 1. General fields */
  653. ulint magic_n; /* magic number to check */
  654. ulint state; /* state of the control block:
  655. BUF_BLOCK_NOT_USED, ... */
  656. byte* frame; /* pointer to buffer frame which
  657. is of size UNIV_PAGE_SIZE, and
  658. aligned to an address divisible by
  659. UNIV_PAGE_SIZE; if AWE is used, this
  660. will be NULL for the pages which are
  661. currently not mapped into the virtual
  662. address space window of the buffer
  663. pool */
  664. os_awe_t* awe_info; /* if AWE is used, then an array of
  665. awe page infos for
  666. UNIV_PAGE_SIZE / OS_AWE_X86_PAGE_SIZE
  667. (normally = 4) physical memory
  668. pages; otherwise NULL */
  669. ulint space; /* space id of the page */
  670. ulint offset; /* page number within the space */
  671. ulint lock_hash_val; /* hashed value of the page address
  672. in the record lock hash table */
  673. mutex_t* lock_mutex; /* mutex protecting the chain in the
  674. record lock hash table */
  675. rw_lock_t lock; /* read-write lock of the buffer
  676. frame */
  677. buf_block_t* hash; /* node used in chaining to the page
  678. hash table */
  679. ibool check_index_page_at_flush;
  680. /* TRUE if we know that this is
  681. an index page, and want the database
  682. to check its consistency before flush;
  683. note that there may be pages in the
  684. buffer pool which are index pages,
  685. but this flag is not set because
  686. we do not keep track of all pages */
  687. /* 2. Page flushing fields */
  688. UT_LIST_NODE_T(buf_block_t) flush_list;
  689. /* node of the modified, not yet
  690. flushed blocks list */
  691. dulint newest_modification;
  692. /* log sequence number of the youngest
  693. modification to this block, zero if
  694. not modified */
  695. dulint oldest_modification;
  696. /* log sequence number of the START of
  697. the log entry written of the oldest
  698. modification to this block which has
  699. not yet been flushed on disk; zero if
  700. all modifications are on disk */
  701. ulint flush_type; /* if this block is currently being
  702. flushed to disk, this tells the
  703. flush_type: BUF_FLUSH_LRU or
  704. BUF_FLUSH_LIST */
  705. /* 3. LRU replacement algorithm fields */
  706. UT_LIST_NODE_T(buf_block_t) free;
  707. /* node of the free block list */
  708. ibool in_free_list; /* TRUE if in the free list; used in
  709. debugging */
  710. UT_LIST_NODE_T(buf_block_t) LRU;
  711. /* node of the LRU list */
  712. UT_LIST_NODE_T(buf_block_t) awe_LRU_free_mapped;
  713. /* in the AWE version node in the
  714. list of free and LRU blocks which are
  715. mapped to a frame */
  716. ibool in_LRU_list; /* TRUE of the page is in the LRU list;
  717. used in debugging */
  718. ulint LRU_position; /* value which monotonically
  719. decreases (or may stay constant if
  720. the block is in the old blocks) toward
  721. the end of the LRU list, if the pool
  722. ulint_clock has not wrapped around:
  723. NOTE that this value can only be used
  724. in heuristic algorithms, because of
  725. the possibility of a wrap-around! */
  726. ulint freed_page_clock;/* the value of freed_page_clock
  727. buffer pool when this block was
  728. last time put to the head of the
  729. LRU list */
  730. ibool old; /* TRUE if the block is in the old
  731. blocks in the LRU list */
  732. ibool accessed; /* TRUE if the page has been accessed
  733. while in the buffer pool: read-ahead
  734. may read in pages which have not been
  735. accessed yet */
  736. ulint buf_fix_count; /* count of how manyfold this block
  737. is currently bufferfixed */
  738. ulint io_fix; /* if a read is pending to the frame,
  739. io_fix is BUF_IO_READ, in the case
  740. of a write BUF_IO_WRITE, otherwise 0 */
  741. /* 4. Optimistic search field */
  742. dulint modify_clock; /* this clock is incremented every
  743. time a pointer to a record on the
  744. page may become obsolete; this is
  745. used in the optimistic cursor
  746. positioning: if the modify clock has
  747. not changed, we know that the pointer
  748. is still valid; this field may be
  749. changed if the thread (1) owns the
  750. pool mutex and the page is not
  751. bufferfixed, or (2) the thread has an
  752. x-latch on the block */
  753. /* 5. Hash search fields: NOTE that the first 4 fields are NOT
  754. protected by any semaphore! */
  755. ulint n_hash_helps; /* counter which controls building
  756. of a new hash index for the page */
  757. ulint n_fields; /* recommended prefix length for hash
  758. search: number of full fields */
  759. ulint n_bytes; /* recommended prefix: number of bytes
  760. in an incomplete field */
  761. ulint side; /* BTR_SEARCH_LEFT_SIDE or
  762. BTR_SEARCH_RIGHT_SIDE, depending on
  763. whether the leftmost record of several
  764. records with the same prefix should be
  765. indexed in the hash index */
  766. /* The following 4 fields are protected by btr_search_latch: */
  767. ibool is_hashed; /* TRUE if hash index has already been
  768. built on this page; note that it does
  769. not guarantee that the index is
  770. complete, though: there may have been
  771. hash collisions, record deletions,
  772. etc. */
  773. ulint n_pointers; /* used in debugging: the number of
  774. pointers in the adaptive hash index
  775. pointing to this frame */
  776. ulint curr_n_fields; /* prefix length for hash indexing:
  777. number of full fields */
  778. ulint curr_n_bytes; /* number of bytes in hash indexing */
  779. ulint curr_side; /* BTR_SEARCH_LEFT_SIDE or
  780. BTR_SEARCH_RIGHT_SIDE in hash
  781. indexing */
  782. /* 6. Debug fields */
  783. #ifdef UNIV_SYNC_DEBUG
  784. rw_lock_t debug_latch; /* in the debug version, each thread
  785. which bufferfixes the block acquires
  786. an s-latch here; so we can use the
  787. debug utilities in sync0rw */
  788. #endif
  789.         ibool           file_page_was_freed;
  790.                                         /* this is set to TRUE when fsp
  791.                                         frees a page in buffer pool */
  792. };
  793. #define BUF_BLOCK_MAGIC_N 41526563
  794. /* The buffer pool structure. NOTE! The definition appears here only for
  795. other modules of this directory (buf) to see it. Do not use from outside! */
  796. struct buf_pool_struct{
  797. /* 1. General fields */
  798. mutex_t mutex; /* mutex protecting the buffer pool
  799. struct and control blocks, except the
  800. read-write lock in them */
  801. byte* frame_mem; /* pointer to the memory area which
  802. was allocated for the frames; in AWE
  803. this is the virtual address space
  804. window where we map pages stored
  805. in physical memory */
  806. byte* frame_zero; /* pointer to the first buffer frame:
  807. this may differ from frame_mem, because
  808. this is aligned by the frame size */
  809. byte* high_end; /* pointer to the end of the buffer
  810. frames */
  811. ulint n_frames; /* number of frames */
  812. buf_block_t* blocks; /* array of buffer control blocks */
  813. buf_block_t** blocks_of_frames;/* inverse mapping which can be used
  814. to retrieve the buffer control block
  815. of a frame; this is an array which
  816. lists the blocks of frames in the
  817. order frame_zero,
  818. frame_zero + UNIV_PAGE_SIZE, ...
  819. a control block is always assigned
  820. for each frame, even if the frame does
  821. not contain any data; note that in AWE
  822. there are more control blocks than
  823. buffer frames */
  824. os_awe_t* awe_info; /* if AWE is used, AWE info for the
  825. physical 4 kB memory pages associated
  826. with buffer frames */
  827. ulint max_size; /* number of control blocks ==
  828. maximum pool size in pages */
  829. ulint curr_size; /* current pool size in pages;
  830. currently always the same as
  831. max_size */
  832. hash_table_t* page_hash; /* hash table of the file pages */
  833. ulint n_pend_reads; /* number of pending read operations */
  834. time_t last_printout_time; /* when buf_print was last time
  835. called */
  836. ulint n_pages_read; /* number read operations */
  837. ulint n_pages_written;/* number write operations */
  838. ulint n_pages_created;/* number of pages created in the pool
  839. with no read */
  840. ulint n_page_gets; /* number of page gets performed;
  841. also successful searches through
  842. the adaptive hash index are
  843. counted as page gets; this field
  844. is NOT protected by the buffer
  845. pool mutex */
  846. ulint n_pages_awe_remapped; /* if AWE is enabled, the
  847. number of remaps of blocks to
  848. buffer frames */
  849. ulint n_page_gets_old;/* n_page_gets when buf_print was
  850. last time called: used to calculate
  851. hit rate */
  852. ulint n_pages_read_old;/* n_pages_read when buf_print was
  853. last time called */
  854. ulint n_pages_written_old;/* number write operations */
  855. ulint n_pages_created_old;/* number of pages created in
  856. the pool with no read */
  857. ulint n_pages_awe_remapped_old;
  858. /* 2. Page flushing algorithm fields */
  859. UT_LIST_BASE_NODE_T(buf_block_t) flush_list;
  860. /* base node of the modified block
  861. list */
  862. ibool init_flush[BUF_FLUSH_LIST + 1];
  863. /* this is TRUE when a flush of the
  864. given type is being initialized */
  865. ulint n_flush[BUF_FLUSH_LIST + 1];
  866. /* this is the number of pending
  867. writes in the given flush type */
  868. os_event_t no_flush[BUF_FLUSH_LIST + 1];
  869. /* this is in the set state when there
  870. is no flush batch of the given type
  871. running */
  872. ulint ulint_clock; /* a sequence number used to count
  873. time. NOTE! This counter wraps
  874. around at 4 billion (if ulint ==
  875. 32 bits)! */
  876. ulint freed_page_clock;/* a sequence number used to count the
  877. number of buffer blocks removed from
  878. the end of the LRU list; NOTE that
  879. this counter may wrap around at 4
  880. billion! */
  881. ulint LRU_flush_ended;/* when an LRU flush ends for a page,
  882. this is incremented by one; this is
  883. set to zero when a buffer block is
  884. allocated */
  885. /* 3. LRU replacement algorithm fields */
  886. UT_LIST_BASE_NODE_T(buf_block_t) free;
  887. /* base node of the free block list;
  888. in the case of AWE, at the start are
  889. always free blocks for which the
  890. physical memory is mapped to a frame */
  891. UT_LIST_BASE_NODE_T(buf_block_t) LRU;
  892. /* base node of the LRU list */
  893. buf_block_t* LRU_old;  /* pointer to the about 3/8 oldest
  894. blocks in the LRU list; NULL if LRU
  895. length less than BUF_LRU_OLD_MIN_LEN */
  896. ulint LRU_old_len; /* length of the LRU list from
  897. the block to which LRU_old points
  898. onward, including that block;
  899. see buf0lru.c for the restrictions
  900. on this value; not defined if
  901. LRU_old == NULL */
  902. UT_LIST_BASE_NODE_T(buf_block_t) awe_LRU_free_mapped;
  903. /* list of those blocks which are
  904. in the LRU list or the free list, and
  905. where the page is mapped to a frame;
  906. thus, frames allocated, e.g., to the
  907. locki table, are not in this list */
  908. };
  909. /* States of a control block */
  910. #define BUF_BLOCK_NOT_USED 211 /* is in the free list */
  911. #define BUF_BLOCK_READY_FOR_USE 212 /* when buf_get_free_block returns
  912. a block, it is in this state */
  913. #define BUF_BLOCK_FILE_PAGE 213 /* contains a buffered file page */
  914. #define BUF_BLOCK_MEMORY 214 /* contains some main memory object */
  915. #define BUF_BLOCK_REMOVE_HASH 215 /* hash index should be removed
  916. before putting to the free list */
  917. /* Io_fix states of a control block; these must be != 0 */
  918. #define BUF_IO_READ 561
  919. #define BUF_IO_WRITE 562
  920. /************************************************************************
  921. Let us list the consistency conditions for different control block states.
  922. NOT_USED: is in free list, not in LRU list, not in flush list, nor
  923. page hash table
  924. READY_FOR_USE: is not in free list, LRU list, or flush list, nor page
  925. hash table
  926. MEMORY: is not in free list, LRU list, or flush list, nor page
  927. hash table
  928. FILE_PAGE: space and offset are defined, is in page hash table
  929. if io_fix == BUF_IO_WRITE,
  930. pool: no_flush[block->flush_type] is in reset state,
  931. pool: n_flush[block->flush_type] > 0
  932. (1) if buf_fix_count == 0, then
  933. is in LRU list, not in free list
  934. is in flush list,
  935. if and only if oldest_modification > 0
  936. is x-locked,
  937. if and only if io_fix == BUF_IO_READ
  938. is s-locked,
  939. if and only if io_fix == BUF_IO_WRITE
  940. (2) if buf_fix_count > 0, then
  941. is not in LRU list, not in free list
  942. is in flush list,
  943. if and only if oldest_modification > 0
  944. if io_fix == BUF_IO_READ,
  945. is x-locked
  946. if io_fix == BUF_IO_WRITE,
  947. is s-locked
  948. State transitions:
  949. NOT_USED => READY_FOR_USE
  950. READY_FOR_USE => MEMORY
  951. READY_FOR_USE => FILE_PAGE
  952. MEMORY => NOT_USED
  953. FILE_PAGE => NOT_USED NOTE: This transition is allowed if and only if 
  954. (1) buf_fix_count == 0,
  955. (2) oldest_modification == 0, and
  956. (3) io_fix == 0.
  957. */
  958. #ifndef UNIV_NONINL
  959. #include "buf0buf.ic"
  960. #endif
  961. #endif