MySQL 8.3.0
Source Code Documentation
buf0buf.h
Go to the documentation of this file.
1/*****************************************************************************
2
3Copyright (c) 1995, 2023, Oracle and/or its affiliates.
4
5This program is free software; you can redistribute it and/or modify it under
6the terms of the GNU General Public License, version 2.0, as published by the
7Free Software Foundation.
8
9This program is also distributed with certain software (including but not
10limited to OpenSSL) that is licensed under separate terms, as designated in a
11particular file or component or in included license documentation. The authors
12of MySQL hereby grant you an additional permission to link the program and
13your derivative works with the separately licensed software that they have
14included with MySQL.
15
16This program is distributed in the hope that it will be useful, but WITHOUT
17ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
18FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0,
19for more details.
20
21You should have received a copy of the GNU General Public License along with
22this program; if not, write to the Free Software Foundation, Inc.,
2351 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
24
25*****************************************************************************/
26
27/** @file include/buf0buf.h
28 The database buffer pool high-level routines
29
30 Created 11/5/1995 Heikki Tuuri
31 *******************************************************/
32
33#ifndef buf0buf_h
34#define buf0buf_h
35
36#include "buf0types.h"
37#include "fil0fil.h"
38#include "hash0hash.h"
39#include "mtr0types.h"
40#include "os0proc.h"
41#include "page0types.h"
42#include "srv0shutdown.h"
43#include "srv0srv.h"
44#include "univ.i"
45#include "ut0byte.h"
46#include "ut0rbt.h"
47
48#include "buf/buf.h"
49
50#include <ostream>
51
52// Forward declaration
53struct fil_addr_t;
54
55/** @name Modes for buf_page_get_gen */
56/** @{ */
57enum class Page_fetch {
58 /** Get always */
59 NORMAL,
60
61 /** Same as NORMAL, but hint that the fetch is part of a large scan.
62 Try not to flood the buffer pool with pages that may not be accessed again
63 any time soon. */
64 SCAN,
65
66 /** get if in pool */
68
69 /** get if in pool, do not make the block young in the LRU list */
71
72 /** get and bufferfix, but set no latch; we have separated this case, because
73 it is error-prone programming not to set a latch, and it should be used with
74 care */
76
77 /** Get the page only if it's in the buffer pool, if not then set a watch on
78 the page. */
80
81 /** Like Page_fetch::NORMAL, but do not mind if the file page has been
82 freed. */
84
85 /** Like Page_fetch::POSSIBLY_FREED, but do not initiate read ahead. */
87};
88/** @} */
89
90/** @name Modes for buf_page_get_known_nowait */
91
92/** @{ */
93enum class Cache_hint {
94 /** Move the block to the start of the LRU list if there is a danger that the
95 block would drift out of the buffer pool*/
96 MAKE_YOUNG = 51,
97
98 /** Preserve the current LRU position of the block. */
99 KEEP_OLD = 52
100};
101
102/** @} */
103
104/** Number of bits to representing a buffer pool ID */
106
107/** The maximum number of buffer pools that can be defined */
109
110/** Maximum number of concurrent buffer pool watches */
111#define BUF_POOL_WATCH_SIZE (srv_n_purge_threads + 1)
112
113/** The maximum number of page_hash locks */
114constexpr ulint MAX_PAGE_HASH_LOCKS = 1024;
115
116/** The buffer pools of the database */
118
119#ifdef UNIV_HOTBACKUP
120/** first block, for --apply-log */
121extern buf_block_t *back_block1;
122/** second block, for page reorganize */
123extern buf_block_t *back_block2;
124#endif /* UNIV_HOTBACKUP */
125
126/** @brief States of a control block
127@see buf_page_t
128
129The enumeration values must be 0..7. */
130enum buf_page_state : uint8_t {
131 /** A sentinel for the buffer pool watch, element of buf_pool->watch[] */
133 /** Contains a clean compressed page */
135 /** Contains a compressed page that is in the buf_pool->flush_list */
137
138 /** Is in the free list; must be after the BUF_BLOCK_ZIP_ constants for
139 compressed-only pages @see buf_block_state_valid() */
141
142 /** When buf_LRU_get_free_block returns a block, it is in this state */
144
145 /** Contains a buffered file page */
147
148 /** Contains some main memory object */
150
151 /** Hash index should be removed before putting to the free list */
154
155/** This structure defines information we will fetch from each buffer pool. It
156will be used to print table IO stats */
158 /* General buffer pool info */
159
160 /** Buffer Pool ID */
162 /** Buffer Pool size in pages */
164 /** Length of buf_pool->LRU */
166 /** buf_pool->LRU_old_len */
168 /** Length of buf_pool->free list */
170 /** Length of buf_pool->flush_list */
172 /** buf_pool->n_pend_unzip, pages pending decompress */
174 /** buf_pool->n_pend_reads, pages pending read */
176 /** Number of pages pending flush of given type */
177 std::array<size_t, BUF_FLUSH_N_TYPES> n_pending_flush;
178 /** number of pages made young */
180 /** number of pages not made young */
182 /** buf_pool->n_pages_read */
184 /** buf_pool->n_pages_created */
186 /** buf_pool->n_pages_written */
188 /** buf_pool->n_page_gets */
190 /** buf_pool->n_ra_pages_read_rnd, number of pages readahead */
192 /** buf_pool->n_ra_pages_read, number of pages readahead */
194 /** buf_pool->n_ra_pages_evicted, number of readahead pages evicted without
195 access */
197 /** num of buffer pool page gets since last printout */
199
200 /* Buffer pool access stats */
201 double page_made_young_rate; /*!< page made young rate in pages
202 per second */
203 double page_not_made_young_rate; /*!< page not made young rate
204 in pages per second */
205 double pages_read_rate; /*!< num of pages read per second */
206 double pages_created_rate; /*!< num of pages create per second */
207 double pages_written_rate; /*!< num of pages written per second */
208 ulint page_read_delta; /*!< num of pages read since last
209 printout */
210 ulint young_making_delta; /*!< num of pages made young since
211 last printout */
212 ulint not_young_making_delta; /*!< num of pages not make young since
213 last printout */
214
215 /* Statistics about read ahead algorithm. */
216 double pages_readahead_rnd_rate; /*!< random readahead rate in pages per
217 second */
218 double pages_readahead_rate; /*!< readahead rate in pages per
219 second */
220 double pages_evicted_rate; /*!< rate of readahead page evicted
221 without access, in pages per second */
222
223 /* Stats about LRU eviction */
224 ulint unzip_lru_len; /*!< length of buf_pool->unzip_LRU
225 list */
226 /* Counters for LRU policy */
227 ulint io_sum; /*!< buf_LRU_stat_sum.io */
228 ulint io_cur; /*!< buf_LRU_stat_cur.io, num of IO
229 for current interval */
230 ulint unzip_sum; /*!< buf_LRU_stat_sum.unzip */
231 ulint unzip_cur; /*!< buf_LRU_stat_cur.unzip, num
232 pages decompressed in current
233 interval */
234};
235
236/** The occupied bytes of lists in all buffer pools */
238 ulint LRU_bytes; /*!< LRU size in bytes */
239 ulint unzip_LRU_bytes; /*!< unzip_LRU size in bytes */
240 ulint flush_list_bytes; /*!< flush_list size in bytes */
241};
242
243#ifndef UNIV_HOTBACKUP
244/** Creates the buffer pool.
245@param[in] total_size Size of the total pool in bytes.
246@param[in] n_instances Number of buffer pool instances to create.
247@return DB_SUCCESS if success, DB_ERROR if not enough memory or error */
248dberr_t buf_pool_init(ulint total_size, ulint n_instances);
249
250/** Frees the buffer pool at shutdown. This must not be invoked before
251 freeing all mutexes. */
252void buf_pool_free_all();
253
254/** Determines if a block is intended to be withdrawn. The caller must ensure
255that there was a sufficient memory barrier to read curr_size and old_size.
256@param[in] buf_pool buffer pool instance
257@param[in] block pointer to control block
258@retval true if will be withdrawn */
259bool buf_block_will_withdrawn(buf_pool_t *buf_pool, const buf_block_t *block);
260
261/** Determines if a frame is intended to be withdrawn. The caller must ensure
262that there was a sufficient memory barrier to read curr_size and old_size.
263@param[in] buf_pool buffer pool instance
264@param[in] ptr pointer to a frame
265@retval true if will be withdrawn */
266bool buf_frame_will_withdrawn(buf_pool_t *buf_pool, const byte *ptr);
267
268/** This is the thread for resizing buffer pool. It waits for an event and
269when waked up either performs a resizing and sleeps again. */
270void buf_resize_thread();
271
272/** Checks if innobase_should_madvise_buf_pool() value has changed since we've
273last check and if so, then updates buf_pool_should_madvise and calls madvise
274for all chunks in all srv_buf_pool_instances.
275@see buf_pool_should_madvise comment for a longer explanation. */
277
278/** Clears the adaptive hash index on all pages in the buffer pool. */
280
281/** Gets the current size of buffer buf_pool in bytes.
282 @return size in bytes */
283static inline ulint buf_pool_get_curr_size(void);
284/** Gets the current size of buffer buf_pool in frames.
285 @return size in pages */
286static inline ulint buf_pool_get_n_pages(void);
287
288/** @return true if buffer pool resize is in progress. */
290
291#endif /* !UNIV_HOTBACKUP */
292
293/** Gets the smallest oldest_modification lsn among all of the earliest
294added pages in flush lists. In other words - takes the last dirty page
295from each flush list, and calculates minimum oldest_modification among
296all of them. Does not acquire global lock for the whole process, so the
297result might come from inconsistent view on flush lists.
298
299@note Note that because of the relaxed order in each flush list, this
300functions no longer returns the smallest oldest_modification among all
301of the dirty pages. If you wanted to have a safe lsn, which is smaller
302than every oldest_modification, you would need to use another function:
303 buf_pool_get_oldest_modification_lwm().
304
305Returns zero if there were no dirty pages (flush lists were empty).
306
307@return minimum oldest_modification of last pages from flush lists,
308 zero if flush lists were empty */
310
311/** Gets a safe low watermark for oldest_modification. It's guaranteed
312that there were no dirty pages with smaller oldest_modification in the
313whole flush lists.
314
315Returns zero if flush lists were empty, be careful in such case, because
316taking the newest lsn is probably not a good idea. If you wanted to rely
317on some lsn in such case, you would need to follow pattern:
318
319 dpa_lsn = log_buffer_dirty_pages_added_up_to_lsn(*log_sys);
320
321 lwm_lsn = buf_pool_get_oldest_modification_lwm();
322
323 if (lwm_lsn == 0) lwm_lsn = dpa_lsn;
324
325The order is important to avoid race conditions.
326
327@remarks
328It's guaranteed that the returned value will not be smaller than the
329last checkpoint lsn. It's not guaranteed that the returned value is
330the maximum possible. It's just the best effort for the low cost.
331It basically takes result of buf_pool_get_oldest_modification_approx()
332and subtracts maximum possible lag introduced by relaxed order in
333flush lists (srv_log_recent_closed_size).
334
335@return safe low watermark for oldest_modification of dirty pages,
336 or zero if flush lists were empty; if non-zero, it is then
337 guaranteed not to be at block boundary (and it points to lsn
338 inside data fragment of block) */
340
341#ifndef UNIV_HOTBACKUP
342
343/** Allocates a buf_page_t descriptor. This function must succeed. In case
344 of failure we assert in this function. */
346 MY_ATTRIBUTE((malloc));
347
348/** Free a buf_page_t descriptor.
349@param[in] bpage bpage descriptor to free */
351
352/** Allocates a buffer block.
353 @return own: the allocated block, in state BUF_BLOCK_MEMORY */
355 buf_pool_t *buf_pool); /*!< in: buffer pool instance,
356 or NULL for round-robin selection
357 of the buffer pool */
358/** Frees a buffer block which does not contain a file page. */
359static inline void buf_block_free(
360 buf_block_t *block); /*!< in, own: block to be freed */
361#endif /* !UNIV_HOTBACKUP */
362
363/** Copies contents of a buffer frame to a given buffer.
364@param[in] buf buffer to copy to
365@param[in] frame buffer frame
366@return buf */
367static inline byte *buf_frame_copy(byte *buf, const buf_frame_t *frame);
368
369#ifndef UNIV_HOTBACKUP
370/** This is the general function used to get optimistic access to a database
371page.
372@param[in] rw_latch RW_S_LATCH, RW_X_LATCH
373@param[in,out] block Guessed block
374@param[in] modify_clock Modify clock value
375@param[in] fetch_mode Fetch mode
376@param[in] file File name
377@param[in] line Line where called
378@param[in,out] mtr Mini-transaction
379@return true if success */
380bool buf_page_optimistic_get(ulint rw_latch, buf_block_t *block,
381 uint64_t modify_clock, Page_fetch fetch_mode,
382 const char *file, ulint line, mtr_t *mtr);
383
384/** This is used to get access to a known database page, when no waiting can be
385done.
386@param[in] rw_latch RW_S_LATCH or RW_X_LATCH.
387@param[in] block The known page.
388@param[in] hint Cache_hint::MAKE_YOUNG or Cache_hint::KEEP_OLD
389@param[in] file File name from where it was called.
390@param[in] line Line from where it was called.
391@param[in,out] mtr Mini-transaction covering the fetch
392@return true if success */
393bool buf_page_get_known_nowait(ulint rw_latch, buf_block_t *block,
394 Cache_hint hint, const char *file, ulint line,
395 mtr_t *mtr);
396
397/** Given a tablespace id and page number tries to get that page. If the
398page is not in the buffer pool it is not loaded and NULL is returned.
399Suitable for using when holding the lock_sys latches (as it avoids deadlock).
400@param[in] page_id page Id
401@param[in] location Location where called
402@param[in] mtr Mini-transaction
403@return pointer to a page or NULL */
404const buf_block_t *buf_page_try_get(const page_id_t &page_id,
405 ut::Location location, mtr_t *mtr);
406
407/** Get read access to a compressed page (usually of type
408FIL_PAGE_TYPE_ZBLOB or FIL_PAGE_TYPE_ZBLOB2).
409The page must be released with buf_page_release_zip().
410NOTE: the page is not protected by any latch. Mutual exclusion has to
411be implemented at a higher level. In other words, all possible
412accesses to a given page through this function must be protected by
413the same set of mutexes or latches.
414@param[in] page_id page id
415@param[in] page_size page size
416@return pointer to the block */
418 const page_size_t &page_size);
419
420/** This is the general function used to get access to a database page.
421@param[in] page_id Page id
422@param[in] page_size Page size
423@param[in] rw_latch RW_S_LATCH, RW_X_LATCH, RW_NO_LATCH
424@param[in] guess Guessed block or NULL
425@param[in] mode Fetch mode.
426@param[in] location Location from where this method was called.
427@param[in] mtr Mini-transaction
428@param[in] dirty_with_no_latch Mark page as dirty even if page is being
429 pinned without any latch
430@return pointer to the block or NULL */
432 const page_size_t &page_size, ulint rw_latch,
434 ut::Location location, mtr_t *mtr,
435 bool dirty_with_no_latch = false);
436
437/** NOTE! The following macros should be used instead of buf_page_get_gen,
438 to improve debugging. Only values RW_S_LATCH and RW_X_LATCH are allowed
439 in LA! */
440inline buf_block_t *buf_page_get(const page_id_t &id, const page_size_t &size,
441 ulint latch, ut::Location location,
442 mtr_t *mtr) {
443 return buf_page_get_gen(id, size, latch, nullptr, Page_fetch::NORMAL,
444 location, mtr);
445}
446/** Use these macros to bufferfix a page with no latching. Remember not to
447 read the contents of the page unless you know it is safe. Do not modify
448 the contents of the page! We have separated this case, because it is
449 error-prone programming not to set a latch, and it should be used
450 with care. */
452 const page_size_t &size,
453 ut::Location location,
454 mtr_t *mtr) {
455 return buf_page_get_gen(id, size, RW_NO_LATCH, nullptr, Page_fetch::NO_LATCH,
456 location, mtr);
457}
458
459/** Initializes a page to the buffer buf_pool. The page is usually not read
460from a file even if it cannot be found in the buffer buf_pool. This is one
461of the functions which perform to a block a state transition NOT_USED =>
462FILE_PAGE (the other is buf_page_get_gen). The page is latched by passed mtr.
463@param[in] page_id Page id
464@param[in] page_size Page size
465@param[in] rw_latch RW_SX_LATCH, RW_X_LATCH
466@param[in] mtr Mini-transaction
467@return pointer to the block, page bufferfixed */
469 const page_size_t &page_size,
470 rw_lock_type_t rw_latch, mtr_t *mtr);
471
472#else /* !UNIV_HOTBACKUP */
473
474/** Inits a page to the buffer buf_pool, for use in mysqlbackup --restore.
475@param[in] page_id page id
476@param[in] page_size page size
477@param[in,out] block block to init */
478void meb_page_init(const page_id_t &page_id, const page_size_t &page_size,
479 buf_block_t *block);
480#endif /* !UNIV_HOTBACKUP */
481
482#ifndef UNIV_HOTBACKUP
483/** Releases a compressed-only page acquired with buf_page_get_zip(). */
484static inline void buf_page_release_zip(
485 buf_page_t *bpage); /*!< in: buffer block */
486
487/** Releases a latch, if specified.
488@param[in] block buffer block
489@param[in] rw_latch RW_S_LATCH, RW_X_LATCH, RW_NO_LATCH */
490static inline void buf_page_release_latch(buf_block_t *block, ulint rw_latch);
491
492/** Moves a page to the start of the buffer pool LRU list. This high-level
493function can be used to prevent an important page from slipping out of
494the buffer pool.
495@param[in,out] bpage buffer block of a file page */
497
498/** Moved a page to the end of the buffer pool LRU list so that it can be
499flushed out at the earliest.
500@param[in] bpage buffer block of a file page */
501void buf_page_make_old(buf_page_t *bpage);
502
503/** Returns true if the page can be found in the buffer pool hash table.
504NOTE that it is possible that the page is not yet read from disk,
505though.
506@param[in] page_id page id
507@return true if found in the page hash table */
508static inline bool buf_page_peek(const page_id_t &page_id);
509
510#ifdef UNIV_DEBUG
511
512/** Sets file_page_was_freed true if the page is found in the buffer pool.
513This function should be called when we free a file page and want the
514debug version to check that it is not accessed any more unless
515reallocated.
516@param[in] page_id page id
517@return control block if found in page hash table, otherwise NULL */
519
520/** Sets file_page_was_freed false if the page is found in the buffer pool.
521This function should be called when we free a file page and want the
522debug version to check that it is not accessed any more unless
523reallocated.
524@param[in] page_id page id
525@return control block if found in page hash table, otherwise NULL */
527
528#endif /* UNIV_DEBUG */
529/** Reads the freed_page_clock of a buffer block.
530 @return freed_page_clock */
531[[nodiscard]] static inline ulint buf_page_get_freed_page_clock(
532 const buf_page_t *bpage); /*!< in: block */
533/** Reads the freed_page_clock of a buffer block.
534 @return freed_page_clock */
535[[nodiscard]] static inline ulint buf_block_get_freed_page_clock(
536 const buf_block_t *block); /*!< in: block */
537
538/** Tells, for heuristics, if a block is still close enough to the MRU end of
539the LRU list meaning that it is not in danger of getting evicted and also
540implying that it has been accessed recently.
541The page must be either buffer-fixed, either its page hash must be locked.
542@param[in] bpage block
543@return true if block is close to MRU end of LRU */
544static inline bool buf_page_peek_if_young(const buf_page_t *bpage);
545
546/** Recommends a move of a block to the start of the LRU list if there is
547danger of dropping from the buffer pool.
548NOTE: does not reserve the LRU list mutex.
549@param[in] bpage block to make younger
550@return true if should be made younger */
551static inline bool buf_page_peek_if_too_old(const buf_page_t *bpage);
552
553/** Gets the youngest modification log sequence number for a frame.
554 Returns zero if not file page or no modification occurred yet.
555 @return newest modification to page */
557 const buf_page_t *bpage); /*!< in: block containing the
558 page frame */
559
560/** Increment the modify clock.
561The caller must
562(1) own the buf_pool->mutex and block bufferfix count has to be zero,
563(2) own X or SX latch on the block->lock, or
564(3) operate on a thread-private temporary table
565@param[in,out] block buffer block */
566static inline void buf_block_modify_clock_inc(buf_block_t *block);
567
568/** Increments the bufferfix count.
569@param[in] location location
570@param[in,out] block block to bufferfix */
572 buf_block_t *block);
573
574/** Increments the bufferfix count.
575@param[in,out] bpage block to bufferfix
576@return the count */
577static inline ulint buf_block_fix(buf_page_t *bpage);
578
579/** Increments the bufferfix count.
580@param[in,out] block block to bufferfix
581@return the count */
582static inline ulint buf_block_fix(buf_block_t *block);
583
584/** Decrements the bufferfix count.
585@param[in,out] bpage block to bufferunfix
586@return the remaining buffer-fix count */
587static inline ulint buf_block_unfix(buf_page_t *bpage);
588
589/** Decrements the bufferfix count.
590@param[in,out] block block to bufferunfix
591@return the remaining buffer-fix count */
592static inline ulint buf_block_unfix(buf_block_t *block);
593
594/** Unfixes the page, unlatches the page,
595removes it from page_hash and removes it from LRU.
596@param[in,out] bpage pointer to the block */
598
599/** Increments the bufferfix count.
600@param[in,out] b block to bufferfix
601@param[in] l location where requested */
603 ut::Location l [[maybe_unused]]) {
605}
606#else /* !UNIV_HOTBACKUP */
607static inline void buf_block_modify_clock_inc(buf_block_t *block) {}
608#endif /* !UNIV_HOTBACKUP */
609
610#ifndef UNIV_HOTBACKUP
611
612/** Gets the space id, page offset, and byte offset within page of a pointer
613pointing to a buffer frame containing a file page.
614@param[in] ptr pointer to a buffer frame
615@param[out] space space id
616@param[out] addr page offset and byte offset */
617static inline void buf_ptr_get_fsp_addr(const void *ptr, space_id_t *space,
618 fil_addr_t *addr);
619
620#ifdef UNIV_DEBUG
621/** Finds a block in the buffer pool that points to a
622given compressed page. Used only to confirm that buffer pool does not contain a
623given pointer, thus protected by zip_free_mutex.
624@param[in] buf_pool buffer pool instance
625@param[in] data pointer to compressed page
626@return buffer block pointing to the compressed page, or NULL */
627buf_block_t *buf_pool_contains_zip(buf_pool_t *buf_pool, const void *data);
628#endif /* UNIV_DEBUG */
629
630/***********************************************************************
631FIXME_FTS: Gets the frame the pointer is pointing to. */
633 /* out: pointer to frame */
634 byte *ptr); /* in: pointer to a frame */
635
636#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
637/** Validates the buffer pool data structure.
638 @return true */
639bool buf_validate(void);
640#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
641#if defined UNIV_DEBUG_PRINT || defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
642/** Prints info of the buffer pool data structure. */
643void buf_print(void);
644#endif /* UNIV_DEBUG_PRINT || UNIV_DEBUG || UNIV_BUF_DEBUG */
645#endif /* !UNIV_HOTBACKUP */
647 /** Do not crash at the end of buf_page_print(). */
649 /** Do not print the full page dump. */
652
653/** Prints a page to stderr.
654@param[in] read_buf a database page
655@param[in] page_size page size
656@param[in] flags 0 or BUF_PAGE_PRINT_NO_CRASH or
657BUF_PAGE_PRINT_NO_FULL */
658void buf_page_print(const byte *read_buf, const page_size_t &page_size,
659 ulint flags);
660
661/** Decompress a block.
662 @return true if successful */
663bool buf_zip_decompress(buf_block_t *block, /*!< in/out: block */
664 bool check); /*!< in: true=verify the page checksum */
665#ifndef UNIV_HOTBACKUP
666#ifdef UNIV_DEBUG
667/** Returns the number of latched pages in the buffer pool.
668 @return number of latched pages */
670#endif /* UNIV_DEBUG */
671/** Returns the number of pending buf pool read ios.
672 @return number of pending read I/O operations */
674/** Prints info of the buffer i/o. */
675void buf_print_io(FILE *file); /*!< in: file where to print */
676/** Collect buffer pool stats information for a buffer pool. Also
677 record aggregated stats if there are more than one buffer pool
678 in the server */
680 buf_pool_t *buf_pool, /*!< in: buffer pool */
681 ulint pool_id, /*!< in: buffer pool ID */
682 buf_pool_info_t *all_pool_info); /*!< in/out: buffer pool info
683 to fill */
684/** Return the ratio in percents of modified pages in the buffer pool /
685database pages in the buffer pool.
686@return modified page percentage ratio */
687double buf_get_modified_ratio_pct(void);
688/** Refresh the statistics used to print per-second averages. */
690
691/** Assert that all file pages in the buffer are in a replaceable state. */
692void buf_must_be_all_freed(void);
693
694/** Computes number of pending I/O read operations for the buffer pool.
695@return number of pending i/o reads */
697
698/** Computes number of pending I/O write operations for the buffer pool.
699@return number of pending i/o writes */
701
702/** Waits until there are no pending I/O operations for the buffer pool.
703Keep waiting in loop with sleeps, emitting information every minute.
704This is used to avoid risk of some pending async IO (e.g. enqueued by
705the linear read-ahead), which would involve ibuf merge and create new
706redo records. */
708
709/** Invalidates the file pages in the buffer pool when an archive recovery is
710 completed. All the file pages buffered must be in a replaceable state when
711 this function is called: not latched and not modified. */
712void buf_pool_invalidate(void);
713
714/*========================================================================
715--------------------------- LOWER LEVEL ROUTINES -------------------------
716=========================================================================*/
717
718#ifdef UNIV_DEBUG
719/** Adds latch level info for the rw-lock protecting the buffer frame. This
720should be called in the debug version after a successful latching of a page if
721we know the latching order level of the acquired latch.
722@param[in] block buffer page where we have acquired latch
723@param[in] level latching order level */
724static inline void buf_block_dbg_add_level(buf_block_t *block,
725 latch_level_t level);
726#else /* UNIV_DEBUG */
727#define buf_block_dbg_add_level(block, level) /* nothing */
728#endif /* UNIV_DEBUG */
729
730#endif /* !UNIV_HOTBACKUP */
731
732/** Gets the state of a block.
733 @return state */
735 const buf_page_t *bpage); /*!< in: pointer to the control block */
736/** Gets the state of a block.
737 @return state */
738[[nodiscard]] static inline enum buf_page_state buf_block_get_state(
739 const buf_block_t *block); /*!< in: pointer to the control block */
740
741/** Sets the state of a block.
742@param[in,out] bpage pointer to control block
743@param[in] state state */
744static inline void buf_page_set_state(buf_page_t *bpage,
745 enum buf_page_state state);
746
747/** Sets the state of a block.
748@param[in,out] block pointer to control block
749@param[in] state state */
750static inline void buf_block_set_state(buf_block_t *block,
751 enum buf_page_state state);
752
753/** Determines if a block is mapped to a tablespace.
754 @return true if mapped */
755[[nodiscard]] static inline bool buf_page_in_file(
756 const buf_page_t *bpage); /*!< in: pointer to control block */
757#ifndef UNIV_HOTBACKUP
758/** Determines if a block should be on unzip_LRU list.
759 @return true if block belongs to unzip_LRU */
760[[nodiscard]] static inline bool buf_page_belongs_to_unzip_LRU(
761 const buf_page_t *bpage); /*!< in: pointer to control block */
762
763/** Gets the mutex of a block.
764 @return pointer to mutex protecting bpage */
765[[nodiscard]] static inline BPageMutex *buf_page_get_mutex(
766 const buf_page_t *bpage); /*!< in: pointer to control block */
767
768/** Get the flush type of a page.
769 @return flush type */
770[[nodiscard]] static inline buf_flush_t buf_page_get_flush_type(
771 const buf_page_t *bpage); /*!< in: buffer page */
772
773/** Set the flush type of a page.
774@param[in] bpage buffer page
775@param[in] flush_type flush type */
776static inline void buf_page_set_flush_type(buf_page_t *bpage,
778
779/** Map a block to a file page.
780@param[in,out] block pointer to control block
781@param[in] page_id page id */
782static inline void buf_block_set_file_page(buf_block_t *block,
783 const page_id_t &page_id);
784
785/** Gets the io_fix state of a block.
786 @return io_fix state */
787[[nodiscard]] static inline enum buf_io_fix buf_page_get_io_fix(
788 const buf_page_t *bpage); /*!< in: pointer to the control block */
789/** Gets the io_fix state of a block.
790 @return io_fix state */
791[[nodiscard]] static inline enum buf_io_fix buf_block_get_io_fix(
792 const buf_block_t *block); /*!< in: pointer to the control block */
793
794/** Sets the io_fix state of a block.
795@param[in,out] bpage control block
796@param[in] io_fix io_fix state */
797static inline void buf_page_set_io_fix(buf_page_t *bpage,
798 enum buf_io_fix io_fix);
799
800/** Sets the io_fix state of a block.
801@param[in,out] block control block
802@param[in] io_fix io_fix state */
803static inline void buf_block_set_io_fix(buf_block_t *block,
804 enum buf_io_fix io_fix);
805
806/** Makes a block sticky. A sticky block implies that even after we release
807the buf_pool->LRU_list_mutex and the block->mutex:
808* it cannot be removed from the flush_list
809* the block descriptor cannot be relocated
810* it cannot be removed from the LRU list
811Note that:
812* the block can still change its position in the LRU list
813* the next and previous pointers can change.
814@param[in,out] bpage control block */
815static inline void buf_page_set_sticky(buf_page_t *bpage);
816
817/** Removes stickiness of a block. */
818static inline void buf_page_unset_sticky(
819 buf_page_t *bpage); /*!< in/out: control block */
820/** Determine if a buffer block can be relocated in memory. The block
821 can be dirty, but it must not be I/O-fixed or bufferfixed. */
822[[nodiscard]] static inline bool buf_page_can_relocate(
823 const buf_page_t *bpage); /*!< control block being relocated */
824
825/** Determine if a block has been flagged old.
826@param[in] bpage control block
827@return true if old */
828[[nodiscard]] static inline bool buf_page_is_old(const buf_page_t *bpage);
829
830/** Flag a block old.
831@param[in,out] bpage control block
832@param[in] old old */
833static inline void buf_page_set_old(buf_page_t *bpage, bool old);
834
835/** Determine the time of first access of a block in the buffer pool.
836 @return Time of first access, zero if not accessed
837 */
838[[nodiscard]] static inline std::chrono::steady_clock::time_point
839buf_page_is_accessed(const buf_page_t *bpage); /*!< in: control block */
840/** Flag a block accessed. */
841static inline void buf_page_set_accessed(
842 buf_page_t *bpage); /*!< in/out: control block */
843
844/** Gets the buf_block_t handle of a buffered file block if an uncompressed
845page frame exists, or NULL. page frame exists, or NULL. The caller must hold
846either the appropriate hash lock in any mode, either the LRU list mutex. Note:
847even though bpage is not declared a const we don't update its value. It is safe
848to make this pure.
849@param[in] bpage control block, or NULL
850@return control block, or NULL */
851[[nodiscard]] static inline buf_block_t *buf_page_get_block(buf_page_t *bpage);
852#ifdef UNIV_DEBUG
853/** Gets a pointer to the memory frame of a block.
854 @return pointer to the frame */
855[[nodiscard]] static inline buf_frame_t *buf_block_get_frame(
856 const buf_block_t *block); /*!< in: pointer to the control block */
857#else /* UNIV_DEBUG */
858#define buf_block_get_frame(block) (block)->frame
859#endif /* UNIV_DEBUG */
860#else /* !UNIV_HOTBACKUP */
861#define buf_block_get_frame(block) (block)->frame
862#endif /* !UNIV_HOTBACKUP */
863
864/** Get a buffer block from an adaptive hash index pointer.
865This function does not return if the block is not identified.
866@param[in] ptr pointer to within a page frame
867@return pointer to block, never NULL */
868buf_block_t *buf_block_from_ahi(const byte *ptr);
869
870/** Find out if a block pointer points into one of currently used chunks of
871the buffer pool. This is useful if you stored the pointer some time ago, and
872want to dereference it now, and are afraid that buffer pool resize could free
873the memory pointed by it. Thus calling this function requires holding at least
874one of the latches which prevent freeing memory from buffer pool for the
875duration of the call and until you pin the block in some other way, as otherwise
876the result of this function might be obsolete by the time you dereference the
877block (an s-latch on buf_page_hash_lock_get for any hash cell is enough).
878@param buf_pool The buffer pool instance to search in.
879@param ptr A pointer which you want to check. This function will not
880 dereference it.
881@return true iff `block` points inside one of the chunks of the `buf_pool`
882*/
883bool buf_is_block_in_instance(const buf_pool_t *buf_pool,
884 const buf_block_t *ptr);
885
886#ifndef UNIV_HOTBACKUP
887
888/** Inits a page for read to the buffer buf_pool. If the page is
889(1) already in buf_pool, or
890(2) if we specify to read only ibuf pages and the page is not an ibuf page, or
891(3) if the space is deleted or being deleted,
892then this function does nothing.
893Sets the io_fix flag to BUF_IO_READ and sets a non-recursive exclusive lock
894on the buffer frame. The io-handler must take care that the flag is cleared
895and the lock released later.
896@param[in] mode BUF_READ_IBUF_PAGES_ONLY, ...
897@param[in] page_id page id
898@param[in] page_size page size
899@param[in] unzip true=request uncompressed page
900@return pointer to the block or NULL */
902 const page_size_t &page_size, bool unzip);
903
904/** Completes an asynchronous read or write request of a file page to or from
905the buffer pool.
906@param[in] bpage pointer to the block in question
907@param[in] evict whether or not to evict the page from LRU list
908@param[in] type i/o request type for which this completion routine is
909 called.
910@param[in] node file node in which the disk copy of the page exists.
911@return true if successful */
912bool buf_page_io_complete(buf_page_t *bpage, bool evict,
913 IORequest *type = nullptr,
914 fil_node_t *node = nullptr);
915
916/** Free a stale page. Caller must hold the LRU mutex. Upon successful page
917free the LRU mutex will be released.
918@param[in,out] buf_pool Buffer pool the page belongs to.
919@param[in,out] bpage Page to free.
920@return true if page was freed. */
921bool buf_page_free_stale(buf_pool_t *buf_pool, buf_page_t *bpage) noexcept;
922
923/** Evict a page from the buffer pool.
924@param[in] page_id page to be evicted.
925@param[in] page_size page size of the tablespace.
926@param[in] dirty_is_ok if true, it is OK for the page to be dirty. */
927void buf_page_force_evict(const page_id_t &page_id,
928 const page_size_t &page_size,
929 const bool dirty_is_ok = true) noexcept;
930
931/** Free a stale page. Caller must be holding the hash_lock in S mode if
932hash_lock parameter is not nullptr. The hash lock will be released upon return
933always. Caller must hold the LRU mutex if and only if the hash_lock parameter
934is nullptr. Upon unsuccessful page free the LRU mutex will not be released if
935hash_lock is nullptr.
936@param[in,out] buf_pool Buffer pool the page belongs to.
937@param[in,out] bpage Page to free.
938@param[in,out] hash_lock Hash lock covering the fetch from the hash table if
939latched in S mode. nullptr otherwise.
940@return true if page was freed. */
941bool buf_page_free_stale(buf_pool_t *buf_pool, buf_page_t *bpage,
942 rw_lock_t *hash_lock) noexcept;
943
944/** Free a stale page that is being written. The caller must be within the
945page's write code path.
946@param[in,out] bpage Page to free.
947@param[in] owns_sx_lock SX lock on block->lock is set. */
949 bool owns_sx_lock = false) noexcept;
950
951/** Calculates the index of a buffer pool to the buf_pool[] array.
952 @return the position of the buffer pool in buf_pool[] */
953[[nodiscard]] static inline ulint buf_pool_index(
954 const buf_pool_t *buf_pool); /*!< in: buffer pool */
955/** Returns the buffer pool instance given a page instance
956 @return buf_pool */
958 const buf_page_t *bpage); /*!< in: buffer pool page */
959/** Returns the buffer pool instance given a block instance
960 @return buf_pool */
962 const buf_block_t *block); /*!< in: block */
963
964/** Returns the buffer pool instance given a page id.
965@param[in] page_id page id
966@return buffer pool */
967static inline buf_pool_t *buf_pool_get(const page_id_t &page_id);
968
969/** Returns the buffer pool instance given its array index
970 @return buffer pool */
972 ulint index); /*!< in: array index to get
973 buffer pool instance from */
974
975/** Returns the control block of a file page, NULL if not found.
976@param[in] buf_pool buffer pool instance
977@param[in] page_id page id
978@return block, NULL if not found */
980 const page_id_t &page_id);
981
982/** Returns the control block of a file page, NULL if not found.
983If the block is found and lock is not NULL then the appropriate
984page_hash lock is acquired in the specified lock mode. Otherwise,
985mode value is ignored. It is up to the caller to release the
986lock. If the block is found and the lock is NULL then the page_hash
987lock is released by this function.
988@param[in] buf_pool buffer pool instance
989@param[in] page_id page id
990@param[in,out] lock lock of the page hash acquired if bpage is
991found, NULL otherwise. If NULL is passed then the hash_lock is released by
992this function.
993@param[in] lock_mode RW_LOCK_X or RW_LOCK_S. Ignored if
994lock == NULL
995@param[in] watch if true, return watch sentinel also.
996@return pointer to the bpage or NULL; if NULL, lock is also NULL or
997a watch sentinel. */
999 const page_id_t &page_id,
1000 rw_lock_t **lock,
1002 bool watch = false);
1003
1004/** Returns the control block of a file page, NULL if not found.
1005If the block is found and lock is not NULL then the appropriate
1006page_hash lock is acquired in the specified lock mode. Otherwise,
1007mode value is ignored. It is up to the caller to release the
1008lock. If the block is found and the lock is NULL then the page_hash
1009lock is released by this function.
1010@param[in] buf_pool buffer pool instance
1011@param[in] page_id page id
1012@param[in,out] lock lock of the page hash acquired if bpage is
1013found, NULL otherwise. If NULL is passed then the hash_lock is released by
1014this function.
1015@param[in] lock_mode RW_LOCK_X or RW_LOCK_S. Ignored if
1016lock == NULL
1017@return pointer to the block or NULL; if NULL, lock is also NULL. */
1019 const page_id_t &page_id,
1020 rw_lock_t **lock,
1022
1023/* There are four different ways we can try to get a bpage or block
1024from the page hash:
10251) Caller already holds the appropriate page hash lock: in the case call
1026buf_page_hash_get_low() function.
10272) Caller wants to hold page hash lock in x-mode
10283) Caller wants to hold page hash lock in s-mode
10294) Caller doesn't want to hold page hash lock */
1031 const page_id_t &page_id,
1032 rw_lock_t **l) {
1033 return buf_page_hash_get_locked(b, page_id, l, RW_LOCK_S);
1034}
1036 const page_id_t &page_id,
1037 rw_lock_t **l) {
1038 return buf_page_hash_get_locked(b, page_id, l, RW_LOCK_X);
1039}
1041 return buf_page_hash_get_locked(b, page_id, nullptr, 0);
1042}
1044 const page_id_t &page_id) {
1045 return buf_page_hash_get_locked(b, page_id, nullptr, 0, true);
1046}
1047
1049 const page_id_t &page_id,
1050 rw_lock_t **l) {
1051 return buf_block_hash_get_locked(b, page_id, l, RW_LOCK_S);
1052}
1054 const page_id_t &page_id,
1055 rw_lock_t **l) {
1056 return buf_block_hash_get_locked(b, page_id, l, RW_LOCK_X);
1057}
1059 const page_id_t &page_id) {
1060 return buf_block_hash_get_locked(b, page_id, nullptr, 0);
1061}
1062
1063/** Gets the current length of the free list of buffer blocks.
1064 @return length of the free list */
1066
1067/** Determine if a block is a sentinel for a buffer pool watch.
1068@param[in] buf_pool buffer pool instance
1069@param[in] bpage block
1070@return true if a sentinel for a buffer pool watch, false if not */
1071[[nodiscard]] bool buf_pool_watch_is_sentinel(const buf_pool_t *buf_pool,
1072 const buf_page_t *bpage);
1073
1074/** Stop watching if the page has been read in.
1075buf_pool_watch_set(same_page_id) must have returned NULL before.
1076@param[in] page_id page id */
1077void buf_pool_watch_unset(const page_id_t &page_id);
1078
1079/** Check if the page has been read in.
1080This may only be called after buf_pool_watch_set(same_page_id)
1081has returned NULL and before invoking buf_pool_watch_unset(same_page_id).
1082@param[in] page_id page id
1083@return false if the given page was not read in, true if it was */
1084[[nodiscard]] bool buf_pool_watch_occurred(const page_id_t &page_id);
1085
1086/** Get total buffer pool statistics.
1087@param[out] LRU_len Length of all lru lists
1088@param[out] free_len Length of all free lists
1089@param[out] flush_list_len Length of all flush lists */
1090void buf_get_total_list_len(ulint *LRU_len, ulint *free_len,
1091 ulint *flush_list_len);
1092
1093/** Get total list size in bytes from all buffer pools. */
1095 buf_pools_list_size_t *buf_pools_list_size); /*!< out: list sizes
1096 in all buffer pools */
1097/** Get total buffer pool statistics. */
1099 buf_pool_stat_t *tot_stat); /*!< out: buffer pool stats */
1100
1101/** Get the nth chunk's buffer block in the specified buffer pool.
1102@param[in] buf_pool buffer pool instance
1103@param[in] n nth chunk in the buffer pool
1104@param[in] chunk_size chunk_size
1105@return the nth chunk's buffer block. */
1106static inline buf_block_t *buf_get_nth_chunk_block(const buf_pool_t *buf_pool,
1107 ulint n, ulint *chunk_size);
1108
1109/** Calculate aligned buffer pool size based on srv_buf_pool_chunk_unit,
1110if needed.
1111@param[in] size size in bytes
1112@return aligned size */
1113static inline ulint buf_pool_size_align(ulint size);
1114
1115/** Adjust the proposed chunk unit size so that it satisfies all invariants
1116@param[in] size proposed size of buffer pool chunk unit in bytes
1117@return adjusted size which meets invariants */
1119
1120/** Calculate the checksum of a page from compressed table and update the
1121page.
1122@param[in,out] page page to update
1123@param[in] size compressed page size
1124@param[in] lsn LSN to stamp on the page
1125@param[in] skip_lsn_check true to skip check for lsn (in DEBUG) */
1127 bool skip_lsn_check);
1128
1129/** Return how many more pages must be added to the withdraw list to reach the
1130withdraw target of the currently ongoing buffer pool resize.
1131@param[in] buf_pool buffer pool instance
1132@return page count to be withdrawn or zero if the target is already achieved or
1133if the buffer pool is not currently being resized. */
1134static inline ulint buf_get_withdraw_depth(buf_pool_t *buf_pool);
1135
1136#endif /* !UNIV_HOTBACKUP */
1137
1138/** The common buffer control block structure
1139for compressed and uncompressed frames */
1140
1141/** Number of bits used for buffer page states. */
1142constexpr uint32_t BUF_PAGE_STATE_BITS = 3;
1143
1144template <typename T>
1145class copyable_atomic_t : public std::atomic<T> {
1146 public:
1148 : std::atomic<T>(other.load(std::memory_order_relaxed)) {}
1149};
1150
1153 public:
1154 /** Copy constructor.
1155 @param[in] other Instance to copy from. */
1157 : id(other.id),
1158 size(other.size),
1160 io_fix(other.io_fix),
1161 state(other.state),
1162 flush_type(other.flush_type),
1164#ifndef UNIV_HOTBACKUP
1165 hash(other.hash),
1166#endif /* !UNIV_HOTBACKUP */
1167 list(other.list),
1170 LRU(other.LRU),
1171 zip(other.zip)
1172#ifndef UNIV_HOTBACKUP
1173 ,
1175 m_space(other.m_space),
1177 m_version(other.m_version),
1178 access_time(other.access_time),
1179 m_dblwr_id(other.m_dblwr_id),
1180 old(other.old)
1181#ifdef UNIV_DEBUG
1182 ,
1186 in_LRU_list(other.in_LRU_list),
1189#endif /* UNIV_DEBUG */
1190#endif /* !UNIV_HOTBACKUP */
1191 {
1192#ifndef UNIV_HOTBACKUP
1193 m_space->inc_ref();
1194#endif /* !UNIV_HOTBACKUP */
1195 }
1196
1197 public:
1198 /** Check if the given ptr lies in a memory block of type BUF_BLOCK_MEMORY.
1199 This is checked by looking at the FIL_PAGE_LSN. If the FIL_PAGE_LSN is zero,
1200 then the block state is assumed to be BUF_BLOCK_MEMORY.
1201 @return true if the FIL_PAGE_LSN is zero, false otherwise. */
1202 [[nodiscard]] static bool is_memory(const page_t *const ptr) noexcept;
1203
1204 /** Check if the given buffer is full of zeroes. */
1205 [[nodiscard]] static bool is_zeroes(const page_t *const ptr,
1206 const size_t len) noexcept;
1207
1208 /** Check if the state of this page is BUF_BLOCK_MEMORY.
1209 @return true if the state is BUF_BLOCK_MEMORY, or false. */
1210 [[nodiscard]] bool is_memory() const noexcept {
1211 return state == BUF_BLOCK_MEMORY;
1212 }
1213
1214#ifndef UNIV_HOTBACKUP
1215 /** Set the doublewrite buffer ID.
1216 @param[in] batch_id Double write batch ID that flushed the page. */
1217 void set_dblwr_batch_id(uint16_t batch_id) { m_dblwr_id = batch_id; }
1218
1219 /** @return the double write batch id, or uint16_t max if undefined. */
1220 [[nodiscard]] uint16_t get_dblwr_batch_id() const { return (m_dblwr_id); }
1221
1222 /** Retrieve the tablespace id.
1223 @return tablespace id */
1224 [[nodiscard]] space_id_t space() const noexcept { return id.space(); }
1225
1226 /** Retrieve the page number.
1227 @return page number */
1228 [[nodiscard]] page_no_t page_no() const noexcept { return id.page_no(); }
1229
1230 /** Checks if this space reference saved during last page ID initialization
1231 was deleted or truncated since.
1232 @return true when space reference stored leads was deleted or truncated and
1233 this page should be discarded. Result is up to date until the fil_shard mutex
1234 is released. */
1235 inline bool is_stale() const {
1236 ut_a(m_space != nullptr);
1237 ut_a(id.space() == m_space->id);
1238 ut_a(m_version <= m_space->get_current_version());
1240 ut_a(!m_space->is_deleted());
1241 return false;
1242 } else {
1243 return true;
1244 }
1245 }
1246
1247 /** Checks if this space reference saved during last page ID initialization
1248 was deleted or truncated since.
1249 @return true when space reference stored leads was deleted or truncated and
1250 this page should be discarded. When false is returned, the status of stale is
1251 checked to be guaranteed. */
1252 inline bool was_stale() const {
1253 ut_a(m_space != nullptr);
1254 ut_a(id.space() == m_space->id);
1255 /* If the the version is OK, then the space must not be deleted.
1256 However, version is modified before the deletion flag is set, so reading
1257 these values need to be executed in reversed order. The atomic reads
1258 cannot be relaxed for it to work. */
1259 bool was_not_deleted = m_space->was_not_deleted();
1261 ut_a(was_not_deleted);
1262 return false;
1263 } else {
1264 return true;
1265 }
1266 }
1267
1268 /** Retrieve the tablespace object if one was available during page ID
1269 initialization. The returned object is safe to use as long as this buf_page_t
1270 object is not changed. Caller should have a IO fix, buffer fix, mutex or any
1271 other mean to assure the page will not be freed. After that is released the
1272 space object may be freed.
1273 @return tablespace object */
1274 inline fil_space_t *get_space() const { return m_space; }
1275
1276 /** Set the stored page id to a new value. This is used only on a buffer
1277 block with BUF_BLOCK_MEMORY state.
1278 @param[in] page_id the new value of the page id. */
1279 void set_page_id(const page_id_t page_id) {
1281 id = page_id;
1282 }
1283
1284 /** Set the page size to a new value. This can be used during initialization
1285 of a newly allocated buffer page.
1286 @param[in] page_size the new value of the page size. */
1287 void set_page_size(const page_size_t &page_size) {
1289 size = page_size;
1290 }
1291
1292 /** Sets stored page ID to the new value. Handles space object reference
1293 count.
1294 @param[in] new_page_id new page ID to be set. */
1295 inline void reset_page_id(page_id_t new_page_id) {
1296 if (m_space != nullptr) {
1297 /* If we reach this line through a call chain:
1298 srv_shutdown -> buf_pool_free_all -> buf_pool_free_instance ->
1299 buf_page_free_descriptor, then we are already past the fil system
1300 shutdown, and all fil_space_t objects were already freed. */
1302 m_space->dec_ref();
1303 }
1304 }
1305 id = new_page_id;
1307 }
1308
1309 /** Sets stored value to invalid/empty value. Handles space object reference
1310 count. */
1311 inline void reset_page_id() {
1313 }
1314
1315 private:
1316 /** Updates new space reference and acquires "reference count latch" and the
1317 current version of the space object. */
1318 inline void space_id_changed() {
1319 m_space = nullptr;
1320 m_version = 0;
1321 if (id.space() != UINT32_UNDEFINED) {
1322 m_space = fil_space_get(id.space());
1323 /* There could be non-existent tablespace while importing it */
1324 if (m_space) {
1325 m_space->inc_ref();
1326 /* We don't have a way to check the MDL locks, which are guarding the
1327 version number, so we don't use get_current_version(). */
1329 }
1330 }
1331 }
1332
1333 public:
1334 /** @return the flush observer instance. */
1336
1337 /** Set the flush observer for the page.
1338 @param[in] flush_observer The flush observer to set. */
1339 void set_flush_observer(Flush_observer *flush_observer) noexcept {
1340 /* Don't allow to set flush observer from non-null to null, or from one
1341 observer to another. */
1342 ut_a(m_flush_observer == nullptr || m_flush_observer == flush_observer);
1343 m_flush_observer = flush_observer;
1344 }
1345
1346 /** Remove the flush observer. */
1347 void reset_flush_observer() noexcept { m_flush_observer = nullptr; }
1348#endif /* !UNIV_HOTBACKUP */
1349
1350 /** @return the LSN of the latest modification. */
1351 lsn_t get_newest_lsn() const noexcept { return newest_modification; }
1352
1353 /** @return the LSN of the first modification since the last time
1354 it was clean. */
1355 lsn_t get_oldest_lsn() const noexcept { return oldest_modification; }
1356
1357 /** @return true if the page is dirty. */
1358 bool is_dirty() const noexcept { return get_oldest_lsn() > 0; }
1359
1360 /** Set the latest modification LSN.
1361 @param[in] lsn Latest modification lSN. */
1363
1364 /** Set the LSN when the page is modified for the first time.
1365 @param[in] lsn First modification LSN. */
1366 void set_oldest_lsn(lsn_t lsn) noexcept;
1367
1368 /** Set page to clean state. */
1369 void set_clean() noexcept { set_oldest_lsn(0); }
1370
1371 /** @name General fields
1372 None of these bit-fields must be modified without holding
1373 buf_page_get_mutex() [buf_block_t::mutex or
1374 buf_pool->zip_mutex], since they can be stored in the same
1375 machine word. */
1376 /** @{ */
1377
1378 /** Page id. */
1380
1381 /** Page size. */
1383
1384 /** Count of how many fold this block is currently bufferfixed. */
1386
1387 private:
1388 /** Type of pending I/O operation.
1389 Modified under protection of buf_page_get_mutex(this).
1390 Read under protection of rules described in @see Buf_io_fix_latching_rules */
1392
1393#ifdef UNIV_DEBUG
1394 public:
1395 /** Checks if io_fix has any of the known enum values.
1396 @param[in] io_fix the value to test
1397 @return true iff io_fix has any of the known enum values
1398 */
1400 switch (io_fix) {
1401 case BUF_IO_NONE:
1402 case BUF_IO_READ:
1403 case BUF_IO_WRITE:
1404 case BUF_IO_PIN:
1405 return true;
1406 }
1407 return false;
1408 }
1409
1410 private:
1411 /** Checks if io_fix has any of the known enum values.
1412 @return true iff io_fix has any of the known enum values
1413 */
1416 }
1417 /* Helper debug-only functions related latching rules are moved to a separate
1418 class so that this header doesn't have to pull in Stateful_latching_rules.*/
1421
1422 /* Helper debug-only class used to track which thread is currently responsible
1423 for performing I/O operation on this page. There's at most one such thread and
1424 the responsibility might be passed from one to another during async I/O. This
1425 is used to prove correctness of io_fix state transitions and checking it
1426 without a latch in the io_completion threads. */
1428 /** The thread responsible for I/O on this page, or an impossible value if
1429 no thread is currently responsible for I/O*/
1430 std::thread::id responsible_thread{std::thread().get_id()};
1431
1432 public:
1433 /** Checks if there is any thread responsible for I/O on this page now.
1434 @return true iff there is a thread responsible for I/O on this page.*/
1436 return responsible_thread != std::thread().get_id();
1437 }
1438
1439 /** Checks if the current thread is responsible for I/O on this page now.
1440 @return true iff the current thread is responsible for I/O on this page.*/
1443 }
1444
1445 /** Called by the thread responsible for I/O on this page to release its
1446 responsibility. */
1447 void release() {
1449 responsible_thread = std::thread().get_id();
1450 }
1451
1452 /** Called by the thread which becomes responsible for I/O on this page to
1453 indicate that it takes the responsibility. */
1454 void take() {
1457 }
1458 };
1459 /** Tracks which thread is responsible for I/O on this page. */
1461
1462 public:
1463 /** Checks if there is any thread responsible for I/O on this page now.
1464 @return true iff there is a thread responsible for I/O on this page.*/
1467 }
1468
1469 /** Checks if the current thread is responsible for I/O on this page now.
1470 @return true iff the current thread is responsible for I/O on this page.*/
1473 }
1474
1475 /** Called by the thread responsible for I/O on this page to release its
1476 responsibility. */
1478
1479 /** Called by the thread which becomes responsible for I/O on this page to
1480 indicate that it takes the responsibility. */
1483 io_fix.load(std::memory_order_relaxed) == BUF_IO_WRITE ||
1484 io_fix.load(std::memory_order_relaxed) == BUF_IO_READ);
1486 }
1487#endif /* UNIV_DEBUG */
1488 private:
1489 /** Retrieves a value of io_fix without requiring or acquiring any latches.
1490 Note that this implies that the value might be stale unless caller establishes
1491 happens-before relation in some other way.
1492 This is a low-level function which shouldn't be used directly, but
1493 rather via wrapper methods which check if proper latches are taken or via one
1494 of the many `was_io_fix_something()` methods with name explicitly warning the
1495 developer about the uncertainty involved.
1496 @return the value of io_fix at some moment "during" the call */
1499 return io_fix.load(std::memory_order_relaxed);
1500 }
1501
1502 public:
1503 /** This is called only when having full ownership of the page object and no
1504 other thread can reach it. This currently happens during buf_pool_create(),
1505 buf_pool_resize() (which latch quite a lot) or from fil_tablespace_iterate()
1506 which creates a fake, private block which is not really a part of the buffer
1507 pool.
1508 Therefore we allow this function to set io_fix without checking for any
1509 latches.
1510 Please use set_io_fix(BUF_IO_NONE) to change state in a regular situation. */
1512 io_fix.store(BUF_IO_NONE, std::memory_order_relaxed);
1513 /* This is only needed because places which call init_io_fix() do not call
1514 buf_page_t's constructor */
1516 }
1517
1518 /** This is called only when having full ownership of the page object and no
1519 other thread can reach it. This currently happens during buf_page_init_low()
1520 under buf_page_get_mutex(this), on a previously initialized page for reuse,
1521 yet should be treated as initialization of the field, not a state transition.
1522 Please use set_io_fix(BUF_IO_NONE) to change state in a regular situation. */
1524 ut_ad(io_fix.load(std::memory_order_relaxed) == BUF_IO_NONE);
1526 io_fix.store(BUF_IO_NONE, std::memory_order_relaxed);
1527 }
1528
1529 /** Sets io_fix to specified value.
1530 Assumes the caller holds buf_page_get_mutex(this).
1531 Might require additional latches depending on particular state transition.
1532 Calls take_io_responsibility() or release_io_responsibility() as needed.
1533 @see Buf_io_fix_latching_rules for specific rules. */
1535
1536 /** Retrieves the current value of io_fix.
1537 Assumes the caller holds buf_page_get_mutex(this).
1538 @return the current value of io_fix */
1541 return get_io_fix_snapshot();
1542 }
1543
1544 /** Checks if the current value of io_fix is BUF_IO_WRITE.
1545 Assumes the caller holds buf_page_get_mutex(this) or some other latches which
1546 prevent state transition from/to BUF_IO_WRITE.
1547 @see Buf_io_fix_latching_rules for specific rules.
1548 @return true iff the current value of io_fix == BUF_IO_WRITE */
1549 bool is_io_fix_write() const;
1550
1551 /** Checks if the current value of io_fix is BUF_IO_READ.
1552 Assumes the caller holds buf_page_get_mutex(this) or some other latches which
1553 prevent state transition from/to BUF_IO_READ.
1554 @see Buf_io_fix_latching_rules for specific rules.
1555 @return true iff the current value of io_fix == BUF_IO_READ */
1556 bool is_io_fix_read() const;
1557
1558 /** Assuming that io_fix is either BUF_IO_READ or BUF_IO_WRITE determines
1559 which of the two it is. Additionally it assumes the caller holds
1560 buf_page_get_mutex(this) or some other latches which prevent state transition
1561 from BUF_IO_READ or from BUF_IO_WRITE to another state.
1562 @see Buf_io_fix_latching_rules for specific rules.
1563 @return true iff the current value of io_fix == BUF_IO_READ */
1565
1566 /** Checks if io_fix is BUF_IO_READ without requiring or acquiring any
1567 latches.
1568 Note that this implies calling this function twice in a row could produce
1569 different results.
1570 @return true iff io_fix equal to BUF_IO_READ was noticed*/
1572
1573 /** Checks if io_fix is BUF_IO_FIX or BUF_IO_READ or BUF_IO_WRITE without
1574 requiring or acquiring any latches.
1575 Note that this implies calling this function twice in a row could produce
1576 different results.
1577 @return true iff io_fix not equal to BUF_IO_NONE was noticed */
1578 bool was_io_fixed() const { return get_io_fix_snapshot() != BUF_IO_NONE; }
1579
1580 /** Checks if io_fix is BUF_IO_NONE without requiring or acquiring any
1581 latches.
1582 Note that this implies calling this function twice in a row could produce
1583 different results.
1584 Please, prefer this function over !was_io_fixed() to avoid the misleading
1585 interpretation as "not(Exists time such that io_fix(time))", while in fact we
1586 want and get "Exists time such that !io_fix(time)".
1587 @return true iff io_fix equal to BUF_IO_NONE was noticed */
1589
1590 /** Block state. @see buf_page_in_file */
1592
1593 /** If this block is currently being flushed to disk, this tells
1594 the flush_type. @see buf_flush_t */
1596
1597 /** Index number of the buffer pool that this block belongs to */
1599
1600 static_assert(MAX_BUFFER_POOLS <= 64,
1601 "MAX_BUFFER_POOLS > 64; redefine buf_pool_index");
1602
1603 /** @} */
1604#ifndef UNIV_HOTBACKUP
1605 /** Node used in chaining to buf_pool->page_hash or buf_pool->zip_hash */
1607#endif /* !UNIV_HOTBACKUP */
1608
1609 /** @name Page flushing fields
1610 All these are protected by buf_pool->mutex. */
1611 /** @{ */
1612
1613 /** Based on state, this is a list node, protected by the corresponding list
1614 mutex, in one of the following lists in buf_pool:
1615
1616 - BUF_BLOCK_NOT_USED: free, withdraw
1617 - BUF_BLOCK_FILE_PAGE: flush_list
1618 - BUF_BLOCK_ZIP_DIRTY: flush_list
1619 - BUF_BLOCK_ZIP_PAGE: zip_clean
1620
1621 The node pointers are protected by the corresponding list mutex.
1622
1623 The contents of the list node is undefined if !in_flush_list &&
1624 state == BUF_BLOCK_FILE_PAGE, or if state is one of
1625 BUF_BLOCK_MEMORY,
1626 BUF_BLOCK_REMOVE_HASH or
1627 BUF_BLOCK_READY_IN_USE. */
1628
1630
1631 private:
1632 /** The flush LSN, LSN when this page was written to the redo log. For
1633 non redo logged pages this is set using: buf_flush_borrow_lsn() */
1635
1636 /** log sequence number of the youngest modification to this block, zero
1637 if not modified. Protected by block mutex */
1639
1640 public:
1641 /** log sequence number of the START of the log entry written of the oldest
1642 modification to this block which has not yet been flushed on disk; zero if
1643 all modifications are on disk. Writes to this field must be covered by both
1644 block->mutex and buf_pool->flush_list_mutex. Hence reads can happen while
1645 holding any one of the two mutexes */
1646 /** @} */
1647
1648 /** @name LRU replacement algorithm fields
1649 These fields are protected by both buf_pool->LRU_list_mutex and the
1650 block mutex. */
1651 /** @{ */
1652
1653 /** node of the LRU list */
1655
1656 /** compressed page; zip.data (but not the data it points to) is
1657 protected by buf_pool->zip_mutex; state == BUF_BLOCK_ZIP_PAGE and
1658 zip.data == NULL means an active buf_pool->watch */
1660
1661#ifndef UNIV_HOTBACKUP
1662 /** Flush observer instance. */
1664
1665 /** Tablespace instance that this page belongs to. */
1667
1668 /** The value of buf_pool->freed_page_clock when this block was the last
1669 time put to the head of the LRU list; a thread is allowed to read this
1670 for heuristic purposes without holding any mutex or latch */
1672
1673 /** @} */
1674 /** Version of fil_space_t when the page was updated. It can also be viewed as
1675 the truncation number. */
1676 uint32_t m_version{};
1677
1678 /** Time of first access, or 0 if the block was never accessed in the
1679 buffer pool. Protected by block mutex */
1680 std::chrono::steady_clock::time_point access_time;
1681
1682 private:
1683 /** Double write instance ordinal value during writes. This is used
1684 by IO completion (writes) to select the double write instance.*/
1685 uint16_t m_dblwr_id{};
1686
1687 public:
1688 /** true if the block is in the old blocks in buf_pool->LRU_old */
1689 bool old;
1690
1691#ifdef UNIV_DEBUG
1692 /** This is set to true when fsp frees a page in buffer pool;
1693 protected by buf_pool->zip_mutex or buf_block_t::mutex. */
1695
1696 /** true if in buf_pool->flush_list; when buf_pool->flush_list_mutex
1697 is free, the following should hold:
1698 in_flush_list == (state == BUF_BLOCK_FILE_PAGE ||
1699 state == BUF_BLOCK_ZIP_DIRTY)
1700 Writes to this field must be covered by both buf_pool->flush_list_mutex
1701 and block->mutex. Hence reads can happen while holding any one of the
1702 two mutexes */
1704
1705 /** true if in buf_pool->free; when buf_pool->free_list_mutex is free, the
1706 following should hold: in_free_list == (state == BUF_BLOCK_NOT_USED) */
1708
1709 /** true if the page is in the LRU list; used in debugging */
1711
1712 /** true if in buf_pool->page_hash */
1714
1715 /** true if in buf_pool->zip_hash */
1717#endif /* UNIV_DEBUG */
1718
1719#endif /* !UNIV_HOTBACKUP */
1720};
1721
1722/** Structure used by AHI to contain information on record prefixes to be
1723considered in hash index subsystem. It is meant for using as a single 64bit
1724atomic value, thus it needs to be aligned properly. */
1725struct alignas(alignof(uint64_t)) btr_search_prefix_info_t {
1726 /** recommended prefix: number of bytes in an incomplete field
1727 @see BTR_PAGE_MAX_REC_SIZE */
1728 uint32_t n_bytes;
1729 /** recommended prefix length for hash search: number of full fields */
1730 uint16_t n_fields;
1731 /** true or false, depending on whether the leftmost record of several records
1732 with the same prefix should be indexed in the hash index */
1734
1736 return n_bytes == other.n_bytes && n_fields == other.n_fields;
1737 }
1738
1739 bool operator==(const btr_search_prefix_info_t &other) const {
1740 return n_bytes == other.n_bytes && n_fields == other.n_fields &&
1741 left_side == other.left_side;
1742 }
1743
1744 bool operator!=(const btr_search_prefix_info_t &other) const {
1745 return !(*this == other);
1746 }
1747};
1748
1749/** The buffer control block structure */
1751 /** @name General fields */
1752 /** @{ */
1753
1754 /** page information; this must be the first field, so
1755 that buf_pool->page_hash can point to buf_page_t or buf_block_t */
1757
1758#ifndef UNIV_HOTBACKUP
1759 /** read-write lock of the buffer frame */
1761
1762#ifdef UNIV_DEBUG
1763 /** Check if the buffer block was freed.
1764 @return true if the block was freed, false otherwise. */
1765 bool was_freed() const { return page.file_page_was_freed; }
1766#endif /* UNIV_DEBUG */
1767
1768#endif /* UNIV_HOTBACKUP */
1769
1770 /** pointer to buffer frame which is of size UNIV_PAGE_SIZE, and aligned
1771 to an address divisible by UNIV_PAGE_SIZE */
1772 byte *frame;
1773
1774 /** Determine whether the page is in new-style compact format.
1775 @return true if the page is in compact format
1776 @return false if it is in old-style format */
1777 bool is_compact() const;
1778
1779 /** node of the decompressed LRU list; a block is in the unzip_LRU list if
1780 page.state == BUF_BLOCK_FILE_PAGE and page.zip.data != NULL. Protected by
1781 both LRU_list_mutex and the block mutex. */
1783#ifdef UNIV_DEBUG
1784 /** true if the page is in the decompressed LRU list; used in debugging */
1786
1788#endif /* UNIV_DEBUG */
1789
1790 /** @} */
1791
1792 /** Structure that holds most AHI-related fields. */
1793 struct ahi_t {
1794 public:
1795 /** Recommended prefix info for hash search. It is atomically copied
1796 from the index's current recommendation for the prefix info and should
1797 eventually get to the block's actual prefix info used. It is used to decide
1798 when the n_hash_helps should be reset. It is modified only while having S-
1799 or X- latch on block's lock. */
1800 std::atomic<btr_search_prefix_info_t> recommended_prefix_info;
1801 /** Prefix info that was used for building hash index. It cannot be modified
1802 while there are any record entries added in the AHI. It's invariant that all
1803 records added to AHI from this block were folded using this prefix info. It
1804 may only be modified when we are holding the appropriate X-latch in
1805 btr_search_sys->parts[]->latch. Also, it happens that it is modified
1806 to not-empty value only when the block is held in private or the block's
1807 lock is S- or X-latched. This implies that the field's non-empty value may
1808 be read and use reliably when the appropriate
1809 btr_search_sys->parts[]->latch S-latch or X-latch is being held, or
1810 the block's lock is X-latched. */
1811 std::atomic<btr_search_prefix_info_t> prefix_info;
1812 static_assert(decltype(prefix_info)::is_always_lock_free);
1813
1814 /** Index for which the adaptive hash index has been created, or nullptr if
1815 the page does not exist in the index. Note that it does not guarantee that
1816 the AHI index is complete, though: there may have been hash collisions etc.
1817 It may be modified:
1818 - to nullptr if btr_search_enabled is false and block's mutex is held and
1819 block's state is BUF_BLOCK_FILE_PAGE and btr_search_enabled_mutex is
1820 owned, protecting the btr_search_enabled from being changed,
1821 - to nullptr if btr_search_enabled is false and block is held in private in
1822 BUF_BLOCK_REMOVE_HASH state in buf_LRU_free_page().
1823 - to any value under appropriate X-latch in btr_search_sys->parts[]->latch
1824 if btr_search_enabled is true (and setting btr_search_enabled to false in
1825 turn is protected by having all btr_search_sys->parts[]->latch X-latched).
1826 */
1827 std::atomic<dict_index_t *> index;
1828
1829#if defined UNIV_AHI_DEBUG || defined UNIV_DEBUG
1830 /** Used in debugging. The number of pointers in the adaptive hash index
1831 pointing to this frame; Modified under appropriate X-latch in
1832 btr_search_sys->parts[]->latch. */
1833 std::atomic<uint16_t> n_pointers;
1834
1835 inline void validate() const {
1836 /* These fields are read without holding any AHI latches. Adding or
1837 removing a block from AHI requires having only an appropriate AHI part
1838 X-latched. If we have at least S-latched the correct AHI part (for which
1839 we would need at least S-latch on block for the block's index to not be
1840 changed in meantime) this check is certain. If we don't have necessary AHI
1841 latches, then:
1842 - it can't happen that the check fails while the block is removed from
1843 AHI. Both btr_search_drop_page_hash_index() and
1844 buf_pool_clear_hash_index() will first make the n_pointers be 0 and then
1845 set index to nullptr. As the index is an atomic variable, so if we
1846 synchronize with a reset to nullptr which is sequenced after the reset of
1847 n_pointers, we should see the n_pointers set to 0 here.
1848 - it can happen that the check fails while the block is added to the AHI
1849 right after we read the index is nullptr. In such case, if the n_pointers
1850 is not 0, we double check the index member. It can still be nullptr, if
1851 the block is removed after reading the n_pointers, but that should be near
1852 impossible. */
1853 ut_a(this->index.load() != nullptr || this->n_pointers.load() == 0 ||
1854 this->index.load() != nullptr);
1855 }
1856
1857 inline void assert_empty() const { ut_a(this->n_pointers.load() == 0); }
1858
1859 inline void assert_empty_on_init() const {
1860 UNIV_MEM_VALID(&this->n_pointers, sizeof(this->n_pointers));
1861 assert_empty();
1862 }
1863#else
1864 inline void validate() const {}
1865
1866 inline void assert_empty() const {}
1867
1868 inline void assert_empty_on_init() const {}
1869#endif /* UNIV_AHI_DEBUG || UNIV_DEBUG */
1871
1872 /** Counter which controls how many times the current prefix recommendation
1873 would help in searches. If it is helpful enough, it will be used as the
1874 actual prefix to build hash for this block. It is modified similarly as
1875 recommended_prefix_info, that is only while having S- or X- latch on block's
1876 lock. Because it is modified concurrently, it may not have fully reliable
1877 count, but it is enough for this use case.
1878 Mind the n_hash_helps is AHI-related, and should be in the ahi_t struct above,
1879 but having it outside causes the made_dirty_with_no_latch to occupy the common
1880 8byte aligned 8byte long space, so basically it saves us 8bytes of the object
1881 that is used in high volumes. */
1882 std::atomic<uint32_t> n_hash_helps;
1883 /** true if block has been made dirty without acquiring X/SX latch as the
1884 block belongs to temporary tablespace and block is always accessed by a
1885 single thread. */
1887
1888#ifndef UNIV_HOTBACKUP
1889#ifdef UNIV_DEBUG
1890 /** @name Debug fields */
1891 /** @{ */
1892 /** In the debug version, each thread which bufferfixes the block acquires
1893 an s-latch here; so we can use the debug utilities in sync0rw */
1895 /** @} */
1896#endif /* UNIV_DEBUG */
1897#endif /* !UNIV_HOTBACKUP */
1898
1899 /** @name Optimistic search field */
1900 /** @{ */
1901
1902 /** This clock is incremented every time a pointer to a record on the page
1903 may become obsolete; this is used in the optimistic cursor positioning: if
1904 the modify clock has not changed, we know that the pointer is still valid;
1905 this field may be changed if the thread (1) owns the LRU list mutex and the
1906 page is not bufferfixed, or (2) the thread has an x-latch on the block,
1907 or (3) the block must belong to an intrinsic table */
1909
1910 /** @} */
1911
1912 /** mutex protecting this block: state (also protected by the buffer
1913 pool mutex), io_fix, buf_fix_count, and accessed; we introduce this
1914 new mutex in InnoDB-5.1 to relieve contention on the buffer pool mutex */
1916
1917 /** Get the modified clock (version) value.
1918 @param[in] single_threaded Thread can only be written to or read by a
1919 single thread
1920 @return the modified clock vlue. */
1921 uint64_t get_modify_clock(IF_DEBUG(bool single_threaded)) const noexcept {
1922#if defined(UNIV_DEBUG) && !defined(UNIV_LIBRARY) && !defined(UNIV_HOTBACKUP)
1923 /* No block latch is acquired when blocks access is guaranteed to be
1924 in single threaded mode. */
1926 ut_ad(single_threaded || rw_lock_own_flagged(&lock, mode));
1927#endif /* UNIV_DEBUG && !UNIV_LIBRARY */
1928
1929 return modify_clock;
1930 }
1931
1932 /** Get the page number and space id of the current buffer block.
1933 @return page number of the current buffer block. */
1934 const page_id_t &get_page_id() const { return page.id; }
1935
1936 /** Get the page number of the current buffer block.
1937 @return page number of the current buffer block. */
1938 page_no_t get_page_no() const { return (page.id.page_no()); }
1939
1940 /** Get the next page number of the current buffer block.
1941 @return next page number of the current buffer block. */
1944 }
1945
1946 /** Get the prev page number of the current buffer block.
1947 @return prev page number of the current buffer block. */
1950 }
1951
1952 /** Get the page type of the current buffer block.
1953 @return page type of the current buffer block. */
1956 }
1957
1958#ifndef UNIV_HOTBACKUP
1959 /** Mark the frame with jumbled page_id, while initiating i/o read
1960 (BUF_IO_READ).*/
1962 memset(frame, 0x00, page.size.logical());
1965 }
1966#endif /* UNIV_HOTBACKUP */
1967
1968 uint16_t get_page_level() const;
1969 bool is_leaf() const;
1970 bool is_root() const;
1971 bool is_index_page() const;
1972
1973 /** Check if this index page is empty. An index page is considered empty
1974 if the next record of an infimum record is supremum record. Presence of
1975 del-marked records will make the page non-empty.
1976 @return true if this index page is empty. */
1977 bool is_empty() const;
1978
1979 /** Get the page type of the current buffer block as string.
1980 @return page type of the current buffer block as string. */
1981 [[nodiscard]] const char *get_page_type_str() const noexcept;
1982
1983 /** Gets the compressed page descriptor corresponding to an uncompressed page
1984 if applicable.
1985 @return page descriptor or nullptr. */
1987 return page.zip.data != nullptr ? &page.zip : nullptr;
1988 }
1989
1990 /** Const version.
1991 @return page descriptor or nullptr. */
1992 page_zip_des_t const *get_page_zip() const noexcept {
1993 return page.zip.data != nullptr ? &page.zip : nullptr;
1994 }
1995
1996 [[nodiscard]] bool is_memory() const noexcept { return page.is_memory(); }
1997};
1998
1999inline bool buf_block_t::is_root() const {
2000 return ((get_next_page_no() == FIL_NULL) && (get_prev_page_no() == FIL_NULL));
2001}
2002
2003inline bool buf_block_t::is_leaf() const { return get_page_level() == 0; }
2004
2005inline bool buf_block_t::is_index_page() const {
2006 return get_page_type() == FIL_PAGE_INDEX;
2007}
2008
2009/** Check if a buf_block_t object is in a valid state
2010@param block buffer block
2011@return true if valid */
2013 return buf_block_get_state(block) >= BUF_BLOCK_NOT_USED &&
2015}
2016
2017/** Compute the hash value for blocks in buf_pool->zip_hash. */
2018/** @{ */
2019static inline uint64_t buf_pool_hash_zip_frame(void *ptr) {
2020 return ut::hash_uint64(reinterpret_cast<uintptr_t>(ptr) >>
2022}
2023static inline uint64_t buf_pool_hash_zip(buf_block_t *b) {
2024 return buf_pool_hash_zip_frame(b->frame);
2025}
2026/** @} */
2027
2028/** A "Hazard Pointer" class used to iterate over page lists
2029inside the buffer pool. A hazard pointer is a buf_page_t pointer
2030which we intend to iterate over next and we want it remain valid
2031even after we release the buffer pool mutex. */
2033 public:
2034 /** Constructor
2035 @param buf_pool buffer pool instance
2036 @param mutex mutex that is protecting the hp. */
2037 HazardPointer(const buf_pool_t *buf_pool, const ib_mutex_t *mutex)
2038 : m_buf_pool(buf_pool) IF_DEBUG(, m_mutex(mutex)), m_hp() {}
2039
2040 /** Destructor */
2041 virtual ~HazardPointer() = default;
2042
2043 /** Get current value */
2044 buf_page_t *get() const {
2046 return (m_hp);
2047 }
2048
2049 /** Set current value
2050 @param bpage buffer block to be set as hp */
2051 void set(buf_page_t *bpage);
2052
2053 /** Checks if a bpage is the hp
2054 @param bpage buffer block to be compared
2055 @return true if it is hp */
2056 bool is_hp(const buf_page_t *bpage);
2057
2058 /** Adjust the value of hp. This happens when some
2059 other thread working on the same list attempts to
2060 remove the hp from the list. Must be implemented
2061 by the derived classes.
2062 @param bpage buffer block to be compared */
2063 virtual void adjust(const buf_page_t *bpage) = 0;
2064
2065 /** Adjust the value of hp for moving. This happens
2066 when some other thread working on the same list
2067 attempts to relocate the hp of the page.
2068 @param bpage buffer block to be compared
2069 @param dpage buffer block to be moved to */
2070 void move(const buf_page_t *bpage, buf_page_t *dpage);
2071
2072 protected:
2073 /** Disable copying */
2076
2077 /** Buffer pool instance */
2079
2080#ifdef UNIV_DEBUG
2081 /** mutex that protects access to the m_hp. */
2082 const ib_mutex_t *m_mutex;
2083#endif /* UNIV_DEBUG */
2084
2085 /** hazard pointer. */
2087};
2088
2089/** Class implementing buf_pool->flush_list hazard pointer */
2090class FlushHp : public HazardPointer {
2091 public:
2092 /** Constructor
2093 @param buf_pool buffer pool instance
2094 @param mutex mutex that is protecting the hp. */
2095 FlushHp(const buf_pool_t *buf_pool, const ib_mutex_t *mutex)
2096 : HazardPointer(buf_pool, mutex) {}
2097
2098 /** Destructor */
2099 ~FlushHp() override = default;
2100
2101 /** Adjust the value of hp. This happens when some
2102 other thread working on the same list attempts to
2103 remove the hp from the list.
2104 @param bpage buffer block to be compared */
2105 void adjust(const buf_page_t *bpage) override;
2106};
2107
2108/** Class implementing buf_pool->LRU hazard pointer */
2109class LRUHp : public HazardPointer {
2110 public:
2111 /** Constructor
2112 @param buf_pool buffer pool instance
2113 @param mutex mutex that is protecting the hp. */
2114 LRUHp(const buf_pool_t *buf_pool, const ib_mutex_t *mutex)
2115 : HazardPointer(buf_pool, mutex) {}
2116
2117 /** Destructor */
2118 ~LRUHp() override = default;
2119
2120 /** Adjust the value of hp. This happens when some
2121 other thread working on the same list attempts to
2122 remove the hp from the list.
2123 @param bpage buffer block to be compared */
2124 void adjust(const buf_page_t *bpage) override;
2125};
2126
2127/** Special purpose iterators to be used when scanning the LRU list.
2128The idea is that when one thread finishes the scan it leaves the
2129itr in that position and the other thread can start scan from
2130there */
2131class LRUItr : public LRUHp {
2132 public:
2133 /** Constructor
2134 @param buf_pool buffer pool instance
2135 @param mutex mutex that is protecting the hp. */
2136 LRUItr(const buf_pool_t *buf_pool, const ib_mutex_t *mutex)
2137 : LRUHp(buf_pool, mutex) {}
2138
2139 /** Destructor */
2140 ~LRUItr() override = default;
2141
2142 /** Selects from where to start a scan. If we have scanned
2143 too deep into the LRU list it resets the value to the tail
2144 of the LRU list.
2145 @return buf_page_t from where to start scan. */
2146 buf_page_t *start();
2147};
2148
2149/** Struct that is embedded in the free zip blocks */
2151 union {
2152 ulint size; /*!< size of the block */
2154 /*!< stamp[FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID]
2155 == BUF_BUDDY_FREE_STAMP denotes a free
2156 block. If the space_id field of buddy
2157 block != BUF_BUDDY_FREE_STAMP, the block
2158 is not in any zip_free list. If the
2159 space_id is BUF_BUDDY_FREE_STAMP then
2160 stamp[0] will contain the
2161 buddy block size. */
2163
2164 buf_page_t bpage; /*!< Embedded bpage descriptor */
2166 /*!< Node of zip_free list */
2167};
2168
2169/** @brief The buffer pool statistics structure. */
2172
2173 /** Number of page gets performed; also successful searches through the
2174 adaptive hash index are counted as page gets; this field is NOT protected
2175 by the buffer pool mutex */
2177
2178 /** Number of read operations. */
2179 std::atomic<uint64_t> n_pages_read;
2180
2181 /** Number of write operations. */
2182 std::atomic<uint64_t> n_pages_written;
2183
2184 /** number of pages created in the pool with no read. */
2185 std::atomic<uint64_t> n_pages_created;
2186
2187 /** Number of pages read in as part of random read ahead. */
2188 std::atomic<uint64_t> n_ra_pages_read_rnd;
2189
2190 /** Number of pages read in as part of read ahead. */
2191 std::atomic<uint64_t> n_ra_pages_read;
2192
2193 /** Number of read ahead pages that are evicted without being accessed.
2194 Protected by LRU_list_mutex. */
2196
2197 /** Number of pages made young, in calls to buf_LRU_make_block_young().
2198 Protected by LRU_list_mutex. */
2200
2201 /** Number of pages not made young because the first access was not long
2202 enough ago, in buf_page_peek_if_too_old(). Not protected. */
2204
2205 /** LRU size in bytes. Protected by LRU_list_mutex. */
2206 uint64_t LRU_bytes;
2207
2208 /** Flush_list size in bytes. Protected by flush_list_mutex */
2210
2211 static void copy(buf_pool_stat_t &dst, const buf_pool_stat_t &src) noexcept {
2212 Counter::copy(dst.m_n_page_gets, src.m_n_page_gets);
2213
2214 dst.n_pages_read.store(src.n_pages_read.load());
2215
2216 dst.n_pages_written.store(src.n_pages_written.load());
2217
2218 dst.n_pages_created.store(src.n_pages_created.load());
2219
2220 dst.n_ra_pages_read_rnd.store(src.n_ra_pages_read_rnd.load());
2221
2222 dst.n_ra_pages_read.store(src.n_ra_pages_read.load());
2223
2224 dst.n_ra_pages_evicted = src.n_ra_pages_evicted;
2225
2226 dst.n_pages_made_young = src.n_pages_made_young;
2227
2228 dst.n_pages_not_made_young = src.n_pages_not_made_young;
2229
2230 dst.LRU_bytes = src.LRU_bytes;
2231
2232 dst.flush_list_bytes = src.flush_list_bytes;
2233 }
2234
2235 void reset() {
2237
2238 n_pages_read = 0;
2239 n_pages_written = 0;
2240 n_pages_created = 0;
2242 n_ra_pages_read = 0;
2246 LRU_bytes = 0;
2247 flush_list_bytes = 0;
2248 }
2249};
2250
2251/** Statistics of buddy blocks of a given size. */
2253 /** Number of blocks allocated from the buddy system. */
2254 std::atomic<ulint> used;
2255 /** Number of blocks relocated by the buddy system.
2256 Protected by buf_pool zip_free_mutex. */
2257 uint64_t relocated;
2258 /** Total duration of block relocations.
2259 Protected by buf_pool zip_free_mutex. */
2260 std::chrono::steady_clock::duration relocated_duration;
2261
2262 struct snapshot_t {
2264 uint64_t relocated;
2265 std::chrono::steady_clock::duration relocated_duration;
2266 };
2267
2269 return {used.load(), relocated, relocated_duration};
2270 }
2271};
2272
2273/** @brief The buffer pool structure.
2274
2275NOTE! The definition appears here only for other modules of this
2276directory (buf) to see it. Do not use from outside! */
2277
2279 /** @name General fields */
2280 /** @{ */
2281 /** protects (de)allocation of chunks:
2282 - changes to chunks, n_chunks are performed while holding this latch,
2283 - reading buf_pool_should_madvise requires holding this latch for any
2284 buf_pool_t
2285 - writing to buf_pool_should_madvise requires holding these latches
2286 for all buf_pool_t-s */
2288
2289 /** LRU list mutex */
2291
2292 /** free and withdraw list mutex */
2294
2295 /** buddy allocator mutex */
2297
2298 /** zip_hash mutex */
2300
2301 /** Flush state protection mutex */
2303
2304 /** Zip mutex of this buffer pool instance, protects compressed only pages (of
2305 type buf_page_t, not buf_block_t */
2307
2308 /** Array index of this buffer pool instance */
2310
2311 /** Current pool size in bytes */
2313
2314 /** Reserve this much of the buffer pool for "old" blocks */
2316#ifdef UNIV_DEBUG
2317 /** Number of frames allocated from the buffer pool to the buddy system.
2318 Protected by zip_hash_mutex. */
2320#endif
2321
2322 /** Number of buffer pool chunks */
2323 volatile ulint n_chunks;
2324
2325 /** New number of buffer pool chunks */
2327
2328 /** buffer pool chunks */
2330
2331 /** old buffer pool chunks to be freed after resizing buffer pool */
2333
2334 /** Current pool size in pages */
2336
2337 /** Previous pool size in pages */
2339
2340 /** Size in pages of the area which the read-ahead algorithms read
2341 if invoked */
2343
2344 /** Hash table of buf_page_t or buf_block_t file pages, buf_page_in_file() ==
2345 true, indexed by (space_id, offset). page_hash is protected by an array of
2346 mutexes. */
2348
2349 /** Hash table of buf_block_t blocks whose frames are allocated to the zip
2350 buddy system, indexed by block->frame */
2352
2353 /** Number of pending read operations. Accessed atomically */
2354 std::atomic<ulint> n_pend_reads;
2355
2356 /** number of pending decompressions. Accessed atomically. */
2357 std::atomic<ulint> n_pend_unzip;
2358
2359 /** when buf_print_io was last time called. Accesses not protected. */
2360 std::chrono::steady_clock::time_point last_printout_time;
2361
2362 /** Statistics of buddy system, indexed by block size. Protected by zip_free
2363 mutex, except for the used field, which is also accessed atomically */
2365
2366 /** Current statistics */
2368
2369 /** Old statistics */
2371
2372 /** @} */
2373
2374 /** @name Page flushing algorithm fields */
2375
2376 /** @{ */
2377
2378 /** Mutex protecting the flush list access. This mutex protects flush_list,
2379 flush_rbt and bpage::list pointers when the bpage is on flush_list. It also
2380 protects writes to bpage::oldest_modification and flush_list_hp */
2382
2383 /** "Hazard pointer" used during scan of flush_list while doing flush list
2384 batch. Protected by flush_list_mutex */
2386
2387 /** Entry pointer to scan the oldest page except for system temporary */
2389
2390 /** Base node of the modified block list */
2392
2393 /** This is true when a flush of the given type is being initialized.
2394 Protected by flush_state_mutex. */
2396
2397 /** This is the number of pending writes in the given flush type. Protected
2398 by flush_state_mutex. */
2399 std::array<size_t, BUF_FLUSH_N_TYPES> n_flush;
2400
2401 /** This is in the set state when there is no flush batch of the given type
2402 running. Protected by flush_state_mutex. */
2404
2405 /** A red-black tree is used exclusively during recovery to speed up
2406 insertions in the flush_list. This tree contains blocks in order of
2407 oldest_modification LSN and is kept in sync with the flush_list. Each
2408 member of the tree MUST also be on the flush_list. This tree is relevant
2409 only in recovery and is set to NULL once the recovery is over. Protected
2410 by flush_list_mutex */
2412
2413 /** A sequence number used to count the number of buffer blocks removed from
2414 the end of the LRU list; NOTE that this counter may wrap around at 4
2415 billion! A thread is allowed to read this for heuristic purposes without
2416 holding any mutex or latch. For non-heuristic purposes protected by
2417 LRU_list_mutex */
2419
2420 /** Set to false when an LRU scan for free block fails. This flag is used to
2421 avoid repeated scans of LRU list when we know that there is no free block
2422 available in the scan depth for eviction. Set to true whenever we flush a
2423 batch from the buffer pool. Accessed protected by memory barriers. */
2425
2426 /** Page Tracking start LSN. */
2428
2429 /** Check if the page modifications are tracked.
2430 @return true if page modifications are tracked, false otherwise. */
2431 bool is_tracking() { return track_page_lsn != LSN_MAX; }
2432
2433 /** Maximum LSN for which write io has already started. */
2435
2436 /** @} */
2437
2438 /** @name LRU replacement algorithm fields */
2439 /** @{ */
2440
2441 /** Base node of the free block list */
2443
2444 /** base node of the withdraw block list. It is only used during shrinking
2445 buffer pool size, not to reuse the blocks will be removed. Protected by
2446 free_list_mutex */
2448
2449 /** Target length of withdraw block list, when withdrawing */
2451
2452 /** "hazard pointer" used during scan of LRU while doing
2453 LRU list batch. Protected by buf_pool::LRU_list_mutex */
2455
2456 /** Iterator used to scan the LRU list when searching for
2457 replaceable victim. Protected by buf_pool::LRU_list_mutex. */
2459
2460 /** Iterator used to scan the LRU list when searching for
2461 single page flushing victim. Protected by buf_pool::LRU_list_mutex. */
2463
2464 /** Base node of the LRU list */
2466
2467 /** Pointer to the about LRU_old_ratio/BUF_LRU_OLD_RATIO_DIV oldest blocks in
2468 the LRU list; NULL if LRU length less than BUF_LRU_OLD_MIN_LEN; NOTE: when
2469 LRU_old != NULL, its length should always equal LRU_old_len */
2471
2472 /** Length of the LRU list from the block to which LRU_old points onward,
2473 including that block; see buf0lru.cc for the restrictions on this value; 0
2474 if LRU_old == NULL; NOTE: LRU_old_len must be adjusted whenever LRU_old
2475 shrinks or grows! */
2477
2478 /** Base node of the unzip_LRU list. The list is protected by the
2479 LRU_list_mutex. */
2480 UT_LIST_BASE_NODE_T(buf_block_t, unzip_LRU) unzip_LRU;
2481
2482 /** @} */
2483 /** @name Buddy allocator fields
2484 The buddy allocator is used for allocating compressed page
2485 frames and buf_page_t descriptors of blocks that exist
2486 in the buffer pool only in compressed form. */
2487 /** @{ */
2488#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
2489 /** Unmodified compressed pages */
2491#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
2492
2493 /** Buddy free lists */
2495
2496 /** Sentinel records for buffer pool watches. Scanning the array is protected
2497 by taking all page_hash latches in X. Updating or reading an individual
2498 watch page is protected by a corresponding individual page_hash latch. */
2500
2501 /** A wrapper for buf_pool_t::allocator.alocate_large which also advices the
2502 OS that this chunk should not be dumped to a core file if that was requested.
2503 Emits a warning to the log and disables @@global.core_file if advising was
2504 requested but could not be performed, but still return true as the allocation
2505 itself succeeded.
2506 @param[in] mem_size number of bytes to allocate
2507 @param[in,out] chunk mem and mem_pfx fields of this chunk will be updated
2508 to contain information about allocated memory region
2509 @return true iff allocated successfully */
2510 bool allocate_chunk(ulonglong mem_size, buf_chunk_t *chunk);
2511
2512 /** A wrapper for buf_pool_t::allocator.deallocate_large which also advices
2513 the OS that this chunk can be dumped to a core file.
2514 Emits a warning to the log and disables @@global.core_file if advising was
2515 requested but could not be performed.
2516 @param[in] chunk mem and mem_pfx fields of this chunk will be used to
2517 locate the memory region to free */
2518 void deallocate_chunk(buf_chunk_t *chunk);
2519
2520 /** Advices the OS that all chunks in this buffer pool instance can be dumped
2521 to a core file.
2522 Emits a warning to the log if could not succeed.
2523 @return true iff succeeded, false if no OS support or failed */
2524 bool madvise_dump();
2525
2526 /** Advices the OS that all chunks in this buffer pool instance should not
2527 be dumped to a core file.
2528 Emits a warning to the log if could not succeed.
2529 @return true iff succeeded, false if no OS support or failed */
2530 bool madvise_dont_dump();
2531
2532 /** Checks if the batch is running, which is basically equivalent to
2533 !os_event_is_set(no_flush[type]) if you hold flush_state_mutex.
2534 It is used as source of truth to know when to set or reset this event.
2535 Caller should hold flush_state_mutex.
2536 @param[in] flush_type The type of the flush we are interested in
2537 @return Should no_flush[type] be in the "unset" state? */
2540 return init_flush[flush_type] || 0 < n_flush[flush_type];
2541 }
2542
2543#ifndef UNIV_HOTBACKUP
2544 /** Executes change() which modifies fields protected by flush_state_mutex.
2545 If it caused a change to is_flushing(flush_type) then it sets or resets the
2546 no_flush[flush_type] to keep it in sync.
2547 @param[in] flush_type The type of the flush this change of state concerns
2548 @param[in] change A callback to execute within flush_state_mutex
2549 */
2550 template <typename F>
2553 const bool was_set = !is_flushing(flush_type);
2555 std::forward<F>(change)();
2556 const bool should_be_set = !is_flushing(flush_type);
2557 if (was_set && !should_be_set) {
2559 } else if (!was_set && should_be_set) {
2561 }
2562 ut_ad(should_be_set == os_event_is_set(no_flush[flush_type]));
2564 }
2565#endif /*! UNIV_HOTBACKUP */
2566
2567 static_assert(BUF_BUDDY_LOW <= UNIV_ZIP_SIZE_MIN,
2568 "BUF_BUDDY_LOW > UNIV_ZIP_SIZE_MIN");
2569 /** @} */
2570};
2571
2572/** Print the given buf_pool_t object.
2573@param[in,out] out the output stream
2574@param[in] buf_pool the buf_pool_t object to be printed
2575@return the output stream */
2576std::ostream &operator<<(std::ostream &out, const buf_pool_t &buf_pool);
2577
2578/** @name Accessors for buffer pool mutexes
2579Use these instead of accessing buffer pool mutexes directly. */
2580/** @{ */
2581
2582#ifndef UNIV_HOTBACKUP
2583/** Test if flush list mutex is owned. */
2584#define buf_flush_list_mutex_own(b) mutex_own(&(b)->flush_list_mutex)
2585
2586/** Acquire the flush list mutex. */
2587#define buf_flush_list_mutex_enter(b) \
2588 do { \
2589 mutex_enter(&(b)->flush_list_mutex); \
2590 } while (0)
2591/** Release the flush list mutex. */
2592#define buf_flush_list_mutex_exit(b) \
2593 do { \
2594 mutex_exit(&(b)->flush_list_mutex); \
2595 } while (0)
2596/** Acquire the block->mutex. */
2597#define buf_page_mutex_enter(b) \
2598 do { \
2599 mutex_enter(&(b)->mutex); \
2600 } while (0)
2601
2602/** Release the block->mutex. */
2603#define buf_page_mutex_exit(b) \
2604 do { \
2605 (b)->mutex.exit(); \
2606 } while (0)
2607
2608/** Get appropriate page_hash_lock. */
2610 const page_id_t page_id) {
2611 return hash_get_lock(buf_pool->page_hash, page_id.hash());
2612}
2613
2614/** If not appropriate page_hash_lock, relock until appropriate. */
2616 const buf_pool_t *buf_pool,
2617 const page_id_t page_id) {
2618 return hash_lock_s_confirm(hash_lock, buf_pool->page_hash, page_id.hash());
2619}
2620
2622 buf_pool_t *buf_pool,
2623 const page_id_t &page_id) {
2624 return hash_lock_x_confirm(hash_lock, buf_pool->page_hash, page_id.hash());
2625}
2626#endif /* !UNIV_HOTBACKUP */
2627
2628#if defined(UNIV_DEBUG) && !defined(UNIV_HOTBACKUP)
2629/** Test if page_hash lock is held in s-mode. */
2631 const buf_page_t *bpage) {
2632 return rw_lock_own(buf_page_hash_lock_get(buf_pool, bpage->id), RW_LOCK_S);
2633}
2634
2635/** Test if page_hash lock is held in x-mode. */
2637 const buf_page_t *bpage) {
2638 return rw_lock_own(buf_page_hash_lock_get((buf_pool), (bpage)->id),
2639 RW_LOCK_X);
2640}
2641
2642/** Test if page_hash lock is held in x or s-mode. */
2643inline bool buf_page_hash_lock_held_s_or_x(const buf_pool_t *buf_pool,
2644 const buf_page_t *bpage) {
2645 return buf_page_hash_lock_held_s(buf_pool, bpage) ||
2646 buf_page_hash_lock_held_x(buf_pool, bpage);
2647}
2648
2649inline bool buf_block_hash_lock_held_s(const buf_pool_t *buf_pool,
2650 const buf_block_t *block) {
2651 return buf_page_hash_lock_held_s(buf_pool, &block->page);
2652}
2653
2654inline bool buf_block_hash_lock_held_x(const buf_pool_t *buf_pool,
2655 const buf_block_t *block) {
2656 return buf_page_hash_lock_held_x(buf_pool, &block->page);
2657}
2658
2660 const buf_block_t *block) {
2661 return buf_page_hash_lock_held_s_or_x(buf_pool, &block->page);
2662}
2663#else /* UNIV_DEBUG && !UNIV_HOTBACKUP */
2664#define buf_page_hash_lock_held_s(b, p) (true)
2665#define buf_page_hash_lock_held_x(b, p) (true)
2666#define buf_page_hash_lock_held_s_or_x(b, p) (true)
2667#define buf_block_hash_lock_held_s(b, p) (true)
2668#define buf_block_hash_lock_held_x(b, p) (true)
2669#define buf_block_hash_lock_held_s_or_x(b, p) (true)
2670#endif /* UNIV_DEBUG && !UNIV_HOTBACKUP */
2671
2672/** @} */
2673
2674/**********************************************************************
2675Let us list the consistency conditions for different control block states.
2676
2677NOT_USED: is in free list, not in LRU list, not in flush list, nor
2678 page hash table
2679READY_FOR_USE: is not in free list, LRU list, or flush list, nor page
2680 hash table
2681MEMORY: is not in free list, LRU list, or flush list, nor page
2682 hash table
2683FILE_PAGE: space and offset are defined, is in page hash table
2684 if io_fix == BUF_IO_WRITE,
2685 pool: no_flush[flush_type] is in reset state,
2686 pool: n_flush[flush_type] > 0
2687
2688 (1) if buf_fix_count == 0, then
2689 is in LRU list, not in free list
2690 is in flush list,
2691 if and only if oldest_modification > 0
2692 is x-locked,
2693 if and only if io_fix == BUF_IO_READ
2694 is s-locked,
2695 if and only if io_fix == BUF_IO_WRITE
2696
2697 (2) if buf_fix_count > 0, then
2698 is not in LRU list, not in free list
2699 is in flush list,
2700 if and only if oldest_modification > 0
2701 if io_fix == BUF_IO_READ,
2702 is x-locked
2703 if io_fix == BUF_IO_WRITE,
2704 is s-locked
2705
2706State transitions:
2707
2708NOT_USED => READY_FOR_USE
2709READY_FOR_USE => MEMORY
2710READY_FOR_USE => FILE_PAGE
2711MEMORY => NOT_USED
2712FILE_PAGE => NOT_USED NOTE: This transition is allowed if and only if
2713 (1) buf_fix_count == 0,
2714 (2) oldest_modification == 0, and
2715 (3) io_fix == 0.
2716*/
2717
2718#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
2719#ifndef UNIV_HOTBACKUP
2720/** Functor to validate the LRU list. */
2722 void operator()(const buf_page_t *elem) const { ut_a(elem->in_LRU_list); }
2723
2724 static void validate(const buf_pool_t *buf_pool) {
2725 CheckInLRUList check;
2726 ut_list_validate(buf_pool->LRU, check);
2727 }
2728};
2729
2730/** Functor to validate the LRU list. */
2732 void operator()(const buf_page_t *elem) const { ut_a(elem->in_free_list); }
2733
2734 static void validate(const buf_pool_t *buf_pool) {
2735 CheckInFreeList check;
2736 ut_list_validate(buf_pool->free, check);
2737 }
2738};
2739
2741 void operator()(const buf_block_t *elem) const {
2742 ut_a(elem->page.in_LRU_list);
2743 ut_a(elem->in_unzip_LRU_list);
2744 }
2745
2746 static void validate(const buf_pool_t *buf_pool) {
2748 ut_list_validate(buf_pool->unzip_LRU, check);
2749 }
2750};
2751#endif /* !UNIV_HOTBACKUP */
2752#endif /* UNIV_DEBUG || defined UNIV_BUF_DEBUG */
2753
2754#ifndef UNIV_HOTBACKUP
2755/** Prepare a page before adding to the free list.
2756@param[in,out] bpage Buffer page to prepare for freeing. */
2757inline void buf_page_prepare_for_free(buf_page_t *bpage) noexcept {
2758 bpage->reset_page_id();
2759}
2760#endif /* !UNIV_HOTBACKUP */
2761
2762/** Gets the compressed page descriptor corresponding to an uncompressed
2763page if applicable.
2764@param[in] block Get the zip descriptor for this block. */
2766 return block->get_page_zip();
2767}
2768
2769/** Gets the compressed page descriptor corresponding to an uncompressed
2770page if applicable. Const version.
2771@param[in] block Get the zip descriptor for this block.
2772@return page descriptor or nullptr. */
2774 const buf_block_t *block) noexcept {
2775 return block->get_page_zip();
2776}
2777
2778inline bool buf_page_in_memory(const buf_page_t *bpage) {
2779 switch (buf_page_get_state(bpage)) {
2780 case BUF_BLOCK_MEMORY:
2781 return true;
2782 default:
2783 break;
2784 }
2785 return false;
2786}
2787
2788/** Verify the page contained by the block. If there is page type
2789mismatch then reset it to expected page type. Data files created
2790before MySQL 5.7 GA may contain garbage in the FIL_PAGE_TYPE field.
2791@param[in,out] block block that may possibly have invalid
2792 FIL_PAGE_TYPE
2793@param[in] type Expected page type
2794@param[in,out] mtr Mini-transaction */
2797 mtr_t &mtr) {
2798 byte *page = block.frame;
2799 page_type_t page_type = fil_page_get_type(page);
2800 if (page_type != type) {
2801 const page_id_t &page_id = block.page.id;
2802 fil_page_reset_type(page_id, page, type, &mtr);
2803 }
2804}
2805
2806#include "buf0buf.ic"
2807
2808#endif /* !buf0buf_h */
uint32_t space_id_t
Tablespace identifier.
Definition: api0api.h:46
uint32_t page_no_t
Page number.
Definition: api0api.h:44
Cache_hint
Definition: buf0buf.h:93
@ MAKE_YOUNG
Move the block to the start of the LRU list if there is a danger that the block would drift out of th...
@ KEEP_OLD
Preserve the current LRU position of the block.
static void buf_block_dbg_add_level(buf_block_t *block, latch_level_t level)
Adds latch level info for the rw-lock protecting the buffer frame.
bool buf_block_hash_lock_held_x(const buf_pool_t *buf_pool, const buf_block_t *block)
Definition: buf0buf.h:2654
static buf_block_t * buf_page_get_block(buf_page_t *bpage)
Gets the buf_block_t handle of a buffered file block if an uncompressed page frame exists,...
static bool buf_page_belongs_to_unzip_LRU(const buf_page_t *bpage)
Determines if a block should be on unzip_LRU list.
static bool buf_page_can_relocate(const buf_page_t *bpage)
Determine if a buffer block can be relocated in memory.
buf_page_t * buf_page_get_zip(const page_id_t &page_id, const page_size_t &page_size)
Get read access to a compressed page (usually of type FIL_PAGE_TYPE_ZBLOB or FIL_PAGE_TYPE_ZBLOB2).
Definition: buf0buf.cc:3247
dberr_t buf_pool_init(ulint total_size, ulint n_instances)
Creates the buffer pool.
Definition: buf0buf.cc:1444
void buf_page_print(const byte *read_buf, const page_size_t &page_size, ulint flags)
Prints a page to stderr.
Definition: buf0buf.cc:549
ulint buf_get_n_pending_read_ios(void)
Returns the number of pending buf pool read ios.
Definition: buf0buf.cc:6533
bool buf_page_hash_lock_held_s_or_x(const buf_pool_t *buf_pool, const buf_page_t *bpage)
Test if page_hash lock is held in x or s-mode.
Definition: buf0buf.h:2643
static ulint buf_pool_get_curr_size(void)
Gets the current size of buffer buf_pool in bytes.
ulint buf_page_hash_lock_held_x(const buf_pool_t *buf_pool, const buf_page_t *bpage)
Test if page_hash lock is held in x-mode.
Definition: buf0buf.h:2636
void buf_page_force_evict(const page_id_t &page_id, const page_size_t &page_size, const bool dirty_is_ok=true) noexcept
Evict a page from the buffer pool.
Definition: buf0buf.cc:5385
bool buf_validate(void)
Validates the buffer pool data structure.
Definition: buf0buf.cc:6319
void buf_flush_update_zip_checksum(buf_frame_t *page, ulint size, lsn_t lsn, bool skip_lsn_check)
Calculate the checksum of a page from compressed table and update the page.
Definition: buf0flu.cc:943
static enum buf_page_state buf_block_get_state(const buf_block_t *block)
Gets the state of a block.
static void buf_page_set_state(buf_page_t *bpage, enum buf_page_state state)
Sets the state of a block.
buf_block_t * buf_block_from_ahi(const byte *ptr)
Get a buffer block from an adaptive hash index pointer.
Definition: buf0buf.cc:3457
bool buf_page_io_complete(buf_page_t *bpage, bool evict, IORequest *type=nullptr, fil_node_t *node=nullptr)
Completes an asynchronous read or write request of a file page to or from the buffer pool.
Definition: buf0buf.cc:5761
lsn_t buf_pool_get_oldest_modification_lwm(void)
Gets a safe low watermark for oldest_modification.
Definition: buf0buf.cc:422
bool buf_frame_will_withdrawn(buf_pool_t *buf_pool, const byte *ptr)
Determines if a frame is intended to be withdrawn.
Definition: buf0buf.cc:1820
void buf_pool_update_madvise()
Checks if innobase_should_madvise_buf_pool() value has changed since we've last check and if so,...
Definition: buf0buf.cc:954
ulonglong buf_pool_adjust_chunk_unit(ulonglong size)
Adjust the proposed chunk unit size so that it satisfies all invariants.
Definition: buf0buf.cc:2089
static buf_page_t * buf_page_hash_get_locked(buf_pool_t *buf_pool, const page_id_t &page_id, rw_lock_t **lock, ulint lock_mode, bool watch=false)
Returns the control block of a file page, NULL if not found.
static enum buf_io_fix buf_page_get_io_fix(const buf_page_t *bpage)
Gets the io_fix state of a block.
static void buf_page_set_io_fix(buf_page_t *bpage, enum buf_io_fix io_fix)
Sets the io_fix state of a block.
buf_page_t * buf_page_set_file_page_was_freed(const page_id_t &page_id)
Sets file_page_was_freed true if the page is found in the buffer pool.
Definition: buf0buf.cc:3160
static void buf_page_set_accessed(buf_page_t *bpage)
Flag a block accessed.
static void buf_block_set_io_fix(buf_block_t *block, enum buf_io_fix io_fix)
Sets the io_fix state of a block.
void buf_page_make_young(buf_page_t *bpage)
Moves a page to the start of the buffer pool LRU list.
Definition: buf0buf.cc:3114
buf_pool_t * buf_pool_ptr
The buffer pools of the database.
Definition: buf0buf.cc:303
void buf_pool_clear_hash_index(void)
Clears the adaptive hash index on all pages in the buffer pool.
Definition: buf0buf.cc:2652
void buf_get_total_stat(buf_pool_stat_t *tot_stat)
Get total buffer pool statistics.
Definition: buf0buf.cc:494
static buf_pool_t * buf_pool_from_bpage(const buf_page_t *bpage)
Returns the buffer pool instance given a page instance.
static buf_flush_t buf_page_get_flush_type(const buf_page_t *bpage)
Get the flush type of a page.
static ulint buf_page_get_freed_page_clock(const buf_page_t *bpage)
Reads the freed_page_clock of a buffer block.
ulint buf_page_hash_lock_held_s(const buf_pool_t *buf_pool, const buf_page_t *bpage)
Test if page_hash lock is held in s-mode.
Definition: buf0buf.h:2630
static std::chrono::steady_clock::time_point buf_page_is_accessed(const buf_page_t *bpage)
Determine the time of first access of a block in the buffer pool.
constexpr ulint MAX_PAGE_HASH_LOCKS
The maximum number of page_hash locks.
Definition: buf0buf.h:114
bool buf_page_optimistic_get(ulint rw_latch, buf_block_t *block, uint64_t modify_clock, Page_fetch fetch_mode, const char *file, ulint line, mtr_t *mtr)
This is the general function used to get optimistic access to a database page.
Definition: buf0buf.cc:4467
void buf_pool_watch_unset(const page_id_t &page_id)
Stop watching if the page has been read in.
Definition: buf0buf.cc:3063
static byte * buf_frame_copy(byte *buf, const buf_frame_t *frame)
Copies contents of a buffer frame to a given buffer.
bool buf_pool_watch_occurred(const page_id_t &page_id)
Check if the page has been read in.
Definition: buf0buf.cc:3090
buf_page_t * buf_page_init_for_read(ulint mode, const page_id_t &page_id, const page_size_t &page_size, bool unzip)
Inits a page for read to the buffer buf_pool.
Definition: buf0buf.cc:4831
static bool buf_page_peek_if_young(const buf_page_t *bpage)
Tells, for heuristics, if a block is still close enough to the MRU end of the LRU list meaning that i...
bool buf_page_free_stale(buf_pool_t *buf_pool, buf_page_t *bpage) noexcept
Free a stale page.
Definition: buf0buf.cc:5352
buf_page_t * buf_page_hash_get_x_locked(buf_pool_t *b, const page_id_t &page_id, rw_lock_t **l)
Definition: buf0buf.h:1035
static void buf_page_set_old(buf_page_t *bpage, bool old)
Flag a block old.
size_t buf_pool_pending_io_reads_count()
Computes number of pending I/O read operations for the buffer pool.
Definition: buf0buf.cc:6893
size_t buf_pool_pending_io_writes_count()
Computes number of pending I/O write operations for the buffer pool.
Definition: buf0buf.cc:6901
void buf_read_page_handle_error(buf_page_t *bpage)
Unfixes the page, unlatches the page, removes it from page_hash and removes it from LRU.
Definition: buf0buf.cc:5317
static ulint buf_block_unfix(buf_page_t *bpage)
Decrements the bufferfix count.
static void buf_page_set_flush_type(buf_page_t *bpage, buf_flush_t flush_type)
Set the flush type of a page.
void buf_page_free_stale_during_write(buf_page_t *bpage, bool owns_sx_lock=false) noexcept
Free a stale page that is being written.
Definition: buf0buf.cc:5493
static buf_pool_t * buf_pool_from_block(const buf_block_t *block)
Returns the buffer pool instance given a block instance.
bool buf_is_block_in_instance(const buf_pool_t *buf_pool, const buf_block_t *ptr)
Find out if a block pointer points into one of currently used chunks of the buffer pool.
Definition: buf0buf.cc:3493
rw_lock_t * buf_page_hash_lock_get(const buf_pool_t *buf_pool, const page_id_t page_id)
Get appropriate page_hash_lock.
Definition: buf0buf.h:2609
std::ostream & operator<<(std::ostream &out, const buf_pool_t &buf_pool)
Print the given buf_pool_t object.
Definition: buf0buf.cc:6974
static BPageMutex * buf_page_get_mutex(const buf_page_t *bpage)
Gets the mutex of a block.
static uint64_t buf_pool_hash_zip_frame(void *ptr)
Compute the hash value for blocks in buf_pool->zip_hash.
Definition: buf0buf.h:2019
static buf_frame_t * buf_block_get_frame(const buf_block_t *block)
Gets a pointer to the memory frame of a block.
void buf_block_reset_page_type_on_mismatch(buf_block_t &block, page_type_t type, mtr_t &mtr)
Verify the page contained by the block.
Definition: buf0buf.h:2795
void buf_pool_free_all()
Frees the buffer pool at shutdown.
Definition: buf0buf.cc:7008
static enum buf_page_state buf_page_get_state(const buf_page_t *bpage)
Gets the state of a block.
static ulint buf_pool_index(const buf_pool_t *buf_pool)
Calculates the index of a buffer pool to the buf_pool[] array.
buf_block_t * buf_page_get_gen(const page_id_t &page_id, const page_size_t &page_size, ulint rw_latch, buf_block_t *guess, Page_fetch mode, ut::Location location, mtr_t *mtr, bool dirty_with_no_latch=false)
This is the general function used to get access to a database page.
Definition: buf0buf.cc:4400
ulint buf_get_free_list_len(void)
Gets the current length of the free list of buffer blocks.
rw_lock_t * buf_page_hash_lock_x_confirm(rw_lock_t *hash_lock, buf_pool_t *buf_pool, const page_id_t &page_id)
Definition: buf0buf.h:2621
static lsn_t buf_page_get_newest_modification(const buf_page_t *bpage)
Gets the youngest modification log sequence number for a frame.
ulint buf_get_latched_pages_number(void)
Returns the number of latched pages in the buffer pool.
Definition: buf0buf.cc:6514
static buf_page_t * buf_page_hash_get_low(buf_pool_t *buf_pool, const page_id_t &page_id)
Returns the control block of a file page, NULL if not found.
static ulint buf_block_fix(buf_page_t *bpage)
Increments the bufferfix count.
constexpr ulint MAX_BUFFER_POOLS
The maximum number of buffer pools that can be defined.
Definition: buf0buf.h:108
static buf_block_t * buf_block_hash_get_locked(buf_pool_t *buf_pool, const page_id_t &page_id, rw_lock_t **lock, ulint lock_mode)
Returns the control block of a file page, NULL if not found.
void buf_print_io(FILE *file)
Prints info of the buffer i/o.
Definition: buf0buf.cc:6810
static buf_pool_t * buf_pool_from_array(ulint index)
Returns the buffer pool instance given its array index.
static void buf_page_release_latch(buf_block_t *block, ulint rw_latch)
Releases a latch, if specified.
void buf_stats_get_pool_info(buf_pool_t *buf_pool, ulint pool_id, buf_pool_info_t *all_pool_info)
Collect buffer pool stats information for a buffer pool.
Definition: buf0buf.cc:6617
void buf_resize_thread()
This is the thread for resizing buffer pool.
Definition: buf0buf.cc:2625
void buf_print(void)
Prints info of the buffer pool data structure.
Definition: buf0buf.cc:6420
const buf_block_t * buf_page_try_get(const page_id_t &page_id, ut::Location location, mtr_t *mtr)
Given a tablespace id and page number tries to get that page.
Definition: buf0buf.cc:4660
static ulint buf_block_get_freed_page_clock(const buf_block_t *block)
Reads the freed_page_clock of a buffer block.
static void buf_ptr_get_fsp_addr(const void *ptr, space_id_t *space, fil_addr_t *addr)
Gets the space id, page offset, and byte offset within page of a pointer pointing to a buffer frame c...
static bool buf_page_peek_if_too_old(const buf_page_t *bpage)
Recommends a move of a block to the start of the LRU list if there is danger of dropping from the buf...
bool buf_block_will_withdrawn(buf_pool_t *buf_pool, const buf_block_t *block)
Determines if a block is intended to be withdrawn.
Definition: buf0buf.cc:1799
void buf_page_make_old(buf_page_t *bpage)
Moved a page to the end of the buffer pool LRU list so that it can be flushed out at the earliest.
Definition: buf0buf.cc:3126
lsn_t buf_pool_get_oldest_modification_approx(void)
Gets the smallest oldest_modification lsn among all of the earliest added pages in flush lists.
Definition: buf0buf.cc:369
buf_block_t * buf_block_hash_get_s_locked(buf_pool_t *b, const page_id_t &page_id, rw_lock_t **l)
Definition: buf0buf.h:1048
void buf_must_be_all_freed(void)
Assert that all file pages in the buffer are in a replaceable state.
Definition: buf0buf.cc:6883
Page_fetch
Definition: buf0buf.h:57
@ NO_LATCH
get and bufferfix, but set no latch; we have separated this case, because it is error-prone programmi...
@ NORMAL
Get always.
@ IF_IN_POOL
get if in pool
@ POSSIBLY_FREED_NO_READ_AHEAD
Like Page_fetch::POSSIBLY_FREED, but do not initiate read ahead.
@ IF_IN_POOL_OR_WATCH
Get the page only if it's in the buffer pool, if not then set a watch on the page.
@ PEEK_IF_IN_POOL
get if in pool, do not make the block young in the LRU list
@ POSSIBLY_FREED
Like Page_fetch::NORMAL, but do not mind if the file page has been freed.
@ SCAN
Same as NORMAL, but hint that the fetch is part of a large scan.
rw_lock_t * buf_page_hash_lock_s_confirm(rw_lock_t *hash_lock, const buf_pool_t *buf_pool, const page_id_t page_id)
If not appropriate page_hash_lock, relock until appropriate.
Definition: buf0buf.h:2615
static void buf_page_unset_sticky(buf_page_t *bpage)
Removes stickiness of a block.
buf_page_print_flags
Definition: buf0buf.h:646
@ BUF_PAGE_PRINT_NO_FULL
Do not print the full page dump.
Definition: buf0buf.h:650
@ BUF_PAGE_PRINT_NO_CRASH
Do not crash at the end of buf_page_print().
Definition: buf0buf.h:648
buf_page_t * buf_page_get_also_watch(buf_pool_t *b, const page_id_t &page_id)
Definition: buf0buf.h:1043
bool buf_pool_watch_is_sentinel(const buf_pool_t *buf_pool, const buf_page_t *bpage)
Determine if a block is a sentinel for a buffer pool watch.
Definition: buf0buf.cc:2908
buf_block_t * buf_page_get_with_no_latch(const page_id_t &id, const page_size_t &size, ut::Location location, mtr_t *mtr)
Use these macros to bufferfix a page with no latching.
Definition: buf0buf.h:451
constexpr ulint MAX_BUFFER_POOLS_BITS
Number of bits to representing a buffer pool ID.
Definition: buf0buf.h:105
bool buf_block_hash_lock_held_s(const buf_pool_t *buf_pool, const buf_block_t *block)
Definition: buf0buf.h:2649
buf_block_t * buf_block_hash_get(buf_pool_t *b, const page_id_t &page_id)
Definition: buf0buf.h:1058
bool buf_page_in_memory(const buf_page_t *bpage)
Definition: buf0buf.h:2778
bool is_buffer_pool_resize_in_progress()
Definition: buf0buf.cc:7018
static bool buf_page_peek(const page_id_t &page_id)
Returns true if the page can be found in the buffer pool hash table.
bool buf_page_get_known_nowait(ulint rw_latch, buf_block_t *block, Cache_hint hint, const char *file, ulint line, mtr_t *mtr)
This is used to get access to a known database page, when no waiting can be done.
Definition: buf0buf.cc:4567
buf_page_t * buf_page_hash_get_s_locked(buf_pool_t *b, const page_id_t &page_id, rw_lock_t **l)
Definition: buf0buf.h:1030
static void buf_page_release_zip(buf_page_t *bpage)
Releases a compressed-only page acquired with buf_page_get_zip().
static void buf_block_free(buf_block_t *block)
Frees a buffer block which does not contain a file page.
static uint64_t buf_pool_hash_zip(buf_block_t *b)
Definition: buf0buf.h:2023
buf_page_t * buf_page_hash_get(buf_pool_t *b, const page_id_t &page_id)
Definition: buf0buf.h:1040
static void buf_block_set_state(buf_block_t *block, enum buf_page_state state)
Sets the state of a block.
constexpr uint32_t BUF_PAGE_STATE_BITS
The common buffer control block structure for compressed and uncompressed frames.
Definition: buf0buf.h:1142
static void buf_block_buf_fix_inc_func(ut::Location location, buf_block_t *block)
Increments the bufferfix count.
static buf_pool_t * buf_pool_get(const page_id_t &page_id)
Returns the buffer pool instance given a page id.
static ulint buf_get_withdraw_depth(buf_pool_t *buf_pool)
Return how many more pages must be added to the withdraw list to reach the withdraw target of the cur...
buf_page_state
States of a control block.
Definition: buf0buf.h:130
@ BUF_BLOCK_NOT_USED
Is in the free list; must be after the BUF_BLOCK_ZIP_ constants for compressed-only pages.
Definition: buf0buf.h:140
@ BUF_BLOCK_ZIP_PAGE
Contains a clean compressed page.
Definition: buf0buf.h:134
@ BUF_BLOCK_REMOVE_HASH
Hash index should be removed before putting to the free list.
Definition: buf0buf.h:152
@ BUF_BLOCK_MEMORY
Contains some main memory object.
Definition: buf0buf.h:149
@ BUF_BLOCK_ZIP_DIRTY
Contains a compressed page that is in the buf_pool->flush_list.
Definition: buf0buf.h:136
@ BUF_BLOCK_POOL_WATCH
A sentinel for the buffer pool watch, element of buf_pool->watch[].
Definition: buf0buf.h:132
@ BUF_BLOCK_READY_FOR_USE
When buf_LRU_get_free_block returns a block, it is in this state.
Definition: buf0buf.h:143
@ BUF_BLOCK_FILE_PAGE
Contains a buffered file page.
Definition: buf0buf.h:146
void buf_refresh_io_stats_all()
Refresh the statistics used to print per-second averages.
Definition: buf0buf.cc:6872
static ulint buf_pool_get_n_pages(void)
Gets the current size of buffer buf_pool in frames.
buf_block_t * buf_block_alloc(buf_pool_t *buf_pool)
Allocates a buffer block.
Definition: buf0buf.cc:520
static buf_block_t * buf_get_nth_chunk_block(const buf_pool_t *buf_pool, ulint n, ulint *chunk_size)
Get the nth chunk's buffer block in the specified buffer pool.
static ulint buf_pool_size_align(ulint size)
Calculate aligned buffer pool size based on srv_buf_pool_chunk_unit, if needed.
buf_block_t * buf_page_get(const page_id_t &id, const page_size_t &size, ulint latch, ut::Location location, mtr_t *mtr)
NOTE! The following macros should be used instead of buf_page_get_gen, to improve debugging.
Definition: buf0buf.h:440
static void buf_block_modify_clock_inc(buf_block_t *block)
Increment the modify clock.
static bool buf_page_in_file(const buf_page_t *bpage)
Determines if a block is mapped to a tablespace.
page_zip_des_t * buf_block_get_page_zip(buf_block_t *block) noexcept
Gets the compressed page descriptor corresponding to an uncompressed page if applicable.
Definition: buf0buf.h:2765
void buf_pool_invalidate(void)
Invalidates the file pages in the buffer pool when an archive recovery is completed.
Definition: buf0buf.cc:6125
void buf_page_free_descriptor(buf_page_t *bpage)
Free a buf_page_t descriptor.
Definition: buf0buf.cc:1359
buf_block_t * buf_page_create(const page_id_t &page_id, const page_size_t &page_size, rw_lock_type_t rw_latch, mtr_t *mtr)
Initializes a page to the buffer buf_pool.
Definition: buf0buf.cc:5037
double buf_get_modified_ratio_pct(void)
Return the ratio in percents of modified pages in the buffer pool / database pages in the buffer pool...
Definition: buf0buf.cc:6547
static buf_frame_t * buf_frame_align(byte *ptr)
void buf_page_prepare_for_free(buf_page_t *bpage) noexcept
Prepare a page before adding to the free list.
Definition: buf0buf.h:2757
buf_block_t * buf_pool_contains_zip(buf_pool_t *buf_pool, const void *data)
Finds a block in the buffer pool that points to a given compressed page.
Definition: buf0buf.cc:1111
static void buf_block_set_file_page(buf_block_t *block, const page_id_t &page_id)
Map a block to a file page.
void buf_pool_wait_for_no_pending_io()
Waits until there are no pending I/O operations for the buffer pool.
Definition: buf0buf.cc:6913
static buf_page_t * buf_page_alloc_descriptor(void)
Allocates a buf_page_t descriptor.
static enum buf_io_fix buf_block_get_io_fix(const buf_block_t *block)
Gets the io_fix state of a block.
bool buf_block_hash_lock_held_s_or_x(const buf_pool_t *buf_pool, const buf_block_t *block)
Definition: buf0buf.h:2659
bool buf_block_state_valid(buf_block_t *block)
Check if a buf_block_t object is in a valid state.
Definition: buf0buf.h:2012
buf_block_t * buf_block_hash_get_x_locked(buf_pool_t *b, const page_id_t &page_id, rw_lock_t **l)
Definition: buf0buf.h:1053
buf_page_t * buf_page_reset_file_page_was_freed(const page_id_t &page_id)
Sets file_page_was_freed false if the page is found in the buffer pool.
Definition: buf0buf.cc:3186
static bool buf_page_is_old(const buf_page_t *bpage)
Determine if a block has been flagged old.
void buf_block_buf_fix_inc(buf_block_t *b, ut::Location l)
Increments the bufferfix count.
Definition: buf0buf.h:602
static void buf_page_set_sticky(buf_page_t *bpage)
Makes a block sticky.
void buf_get_total_list_size_in_bytes(buf_pools_list_size_t *buf_pools_list_size)
Get total list size in bytes from all buffer pools.
Definition: buf0buf.cc:473
void buf_get_total_list_len(ulint *LRU_len, ulint *free_len, ulint *flush_list_len)
Get total buffer pool statistics.
Definition: buf0buf.cc:453
bool buf_zip_decompress(buf_block_t *block, bool check)
Decompress a block.
Definition: buf0buf.cc:3389
The database buffer buf_pool.
The database buffer pool global types for the directory.
byte buf_frame_t
A buffer frame.
Definition: buf0types.h:61
BPageMutex BufPoolZipMutex
Definition: buf0types.h:200
constexpr uint32_t BUF_BUDDY_LOW
Smallest buddy page size.
Definition: buf0types.h:182
constexpr uint32_t BUF_BUDDY_SIZES_MAX
Maximum number of buddy sizes based on the max page size.
Definition: buf0types.h:188
buf_flush_t
Flags for flush types.
Definition: buf0types.h:67
@ BUF_FLUSH_N_TYPES
Index of last element + 1
Definition: buf0types.h:78
ib_mutex_t BufListMutex
Definition: buf0types.h:198
ib_bpmutex_t BPageMutex
Definition: buf0types.h:197
buf_io_fix
Flags for io_fix types.
Definition: buf0types.h:98
@ BUF_IO_NONE
no pending I/O
Definition: buf0types.h:100
@ BUF_IO_WRITE
write pending
Definition: buf0types.h:106
@ BUF_IO_READ
read pending
Definition: buf0types.h:103
@ BUF_IO_PIN
disallow relocation of block and its removal from the flush_list
Definition: buf0types.h:109
The database buffer pool high-level routines.
Class implementing buf_pool->flush_list hazard pointer.
Definition: buf0buf.h:2090
~FlushHp() override=default
Destructor.
FlushHp(const buf_pool_t *buf_pool, const ib_mutex_t *mutex)
Constructor.
Definition: buf0buf.h:2095
void adjust(const buf_page_t *bpage) override
Adjust the value of hp.
Definition: buf0buf.cc:2868
We use Flush_observer to track flushing of non-redo logged pages in bulk create index(btr0load....
Definition: buf0flu.h:269
A "Hazard Pointer" class used to iterate over page lists inside the buffer pool.
Definition: buf0buf.h:2032
bool is_hp(const buf_page_t *bpage)
Checks if a bpage is the hp.
Definition: buf0buf.cc:2843
void set(buf_page_t *bpage)
Set current value.
Definition: buf0buf.cc:2830
virtual void adjust(const buf_page_t *bpage)=0
Adjust the value of hp.
const ib_mutex_t * m_mutex
mutex that protects access to the m_hp.
Definition: buf0buf.h:2082
void move(const buf_page_t *bpage, buf_page_t *dpage)
Adjust the value of hp for moving.
Definition: buf0buf.cc:2855
buf_page_t * m_hp
hazard pointer.
Definition: buf0buf.h:2086
virtual ~HazardPointer()=default
Destructor.
const buf_pool_t * m_buf_pool
Buffer pool instance.
Definition: buf0buf.h:2078
HazardPointer(const HazardPointer &)
Disable copying.
buf_page_t * get() const
Get current value.
Definition: buf0buf.h:2044
HazardPointer(const buf_pool_t *buf_pool, const ib_mutex_t *mutex)
Constructor.
Definition: buf0buf.h:2037
HazardPointer & operator=(const HazardPointer &)
The IO Context that is passed down to the low level IO code.
Definition: os0file.h:277
Class implementing buf_pool->LRU hazard pointer.
Definition: buf0buf.h:2109
~LRUHp() override=default
Destructor.
void adjust(const buf_page_t *bpage) override
Adjust the value of hp.
Definition: buf0buf.cc:2883
LRUHp(const buf_pool_t *buf_pool, const ib_mutex_t *mutex)
Constructor.
Definition: buf0buf.h:2114
Special purpose iterators to be used when scanning the LRU list.
Definition: buf0buf.h:2131
~LRUItr() override=default
Destructor.
buf_page_t * start()
Selects from where to start a scan.
Definition: buf0buf.cc:2898
LRUItr(const buf_pool_t *buf_pool, const ib_mutex_t *mutex)
Constructor.
Definition: buf0buf.h:2136
The purpose of this class is to hide the knowledge that Buf_io_fix_latching_rules even exists from us...
Definition: buf0buf.cc:5602
Definition: buf0buf.h:1427
bool someone_is_responsible() const
Checks if there is any thread responsible for I/O on this page now.
Definition: buf0buf.h:1435
void release()
Called by the thread responsible for I/O on this page to release its responsibility.
Definition: buf0buf.h:1447
bool current_thread_is_responsible() const
Checks if the current thread is responsible for I/O on this page now.
Definition: buf0buf.h:1441
void take()
Called by the thread which becomes responsible for I/O on this page to indicate that it takes the res...
Definition: buf0buf.h:1454
std::thread::id responsible_thread
The thread responsible for I/O on this page, or an impossible value if no thread is currently respons...
Definition: buf0buf.h:1430
Definition: buf0buf.h:1152
uint32_t freed_page_clock
The value of buf_pool->freed_page_clock when this block was the last time put to the head of the LRU ...
Definition: buf0buf.h:1671
buf_page_t(const buf_page_t &other)
Copy constructor.
Definition: buf0buf.h:1156
void space_id_changed()
Updates new space reference and acquires "reference count latch" and the current version of the space...
Definition: buf0buf.h:1318
void take_io_responsibility()
Called by the thread which becomes responsible for I/O on this page to indicate that it takes the res...
Definition: buf0buf.h:1481
bool is_stale() const
Checks if this space reference saved during last page ID initialization was deleted or truncated sinc...
Definition: buf0buf.h:1235
void init_io_fix()
This is called only when having full ownership of the page object and no other thread can reach it.
Definition: buf0buf.h:1511
void set_io_fix(buf_io_fix io_fix)
Sets io_fix to specified value.
Definition: buf0buf.cc:5676
bool someone_has_io_responsibility() const
Checks if there is any thread responsible for I/O on this page now.
Definition: buf0buf.h:1465
bool has_correct_io_fix_value() const
Checks if io_fix has any of the known enum values.
Definition: buf0buf.h:1414
lsn_t get_newest_lsn() const noexcept
Definition: buf0buf.h:1351
bool current_thread_has_io_responsibility() const
Checks if the current thread is responsible for I/O on this page now.
Definition: buf0buf.h:1471
void set_newest_lsn(lsn_t lsn) noexcept
Set the latest modification LSN.
Definition: buf0buf.h:1362
buf_page_t * hash
Node used in chaining to buf_pool->page_hash or buf_pool->zip_hash.
Definition: buf0buf.h:1601
bool is_io_fix_write() const
Checks if the current value of io_fix is BUF_IO_WRITE.
Definition: buf0buf.cc:5656
Flush_observer * get_flush_observer() noexcept
Definition: buf0buf.h:1335
fil_space_t * get_space() const
Retrieve the tablespace object if one was available during page ID initialization.
Definition: buf0buf.h:1274
bool is_io_fix_read_as_opposed_to_write() const
Assuming that io_fix is either BUF_IO_READ or BUF_IO_WRITE determines which of the two it is.
Definition: buf0buf.cc:5668
space_id_t space() const noexcept
Retrieve the tablespace id.
Definition: buf0buf.h:1224
bool in_zip_hash
true if in buf_pool->zip_hash
Definition: buf0buf.h:1716
bool in_free_list
true if in buf_pool->free; when buf_pool->free_list_mutex is free, the following should hold: in_free...
Definition: buf0buf.h:1707
std::chrono::steady_clock::time_point access_time
Time of first access, or 0 if the block was never accessed in the buffer pool.
Definition: buf0buf.h:1680
Flush_observer * m_flush_observer
Flush observer instance.
Definition: buf0buf.h:1663
buf_fix_count_atomic_t buf_fix_count
Count of how many fold this block is currently bufferfixed.
Definition: buf0buf.h:1385
bool in_flush_list
true if in buf_pool->flush_list; when buf_pool->flush_list_mutex is free, the following should hold: ...
Definition: buf0buf.h:1703
void reset_page_id()
Sets stored value to invalid/empty value.
Definition: buf0buf.h:1311
bool is_dirty() const noexcept
Definition: buf0buf.h:1358
bool old
true if the block is in the old blocks in buf_pool->LRU_old
Definition: buf0buf.h:1689
bool was_io_fix_read() const
Checks if io_fix is BUF_IO_READ without requiring or acquiring any latches.
Definition: buf0buf.h:1571
void reinit_io_fix()
This is called only when having full ownership of the page object and no other thread can reach it.
Definition: buf0buf.h:1523
static bool is_zeroes(const page_t *const ptr, const size_t len) noexcept
Check if the given buffer is full of zeroes.
Definition: buf0buf.cc:7025
void reset_page_id(page_id_t new_page_id)
Sets stored page ID to the new value.
Definition: buf0buf.h:1295
void set_oldest_lsn(lsn_t lsn) noexcept
Set the LSN when the page is modified for the first time.
Definition: buf0buf.ic:745
uint16_t get_dblwr_batch_id() const
Definition: buf0buf.h:1220
bool was_stale() const
Checks if this space reference saved during last page ID initialization was deleted or truncated sinc...
Definition: buf0buf.h:1252
void set_page_id(const page_id_t page_id)
Set the stored page id to a new value.
Definition: buf0buf.h:1279
lsn_t newest_modification
The flush LSN, LSN when this page was written to the redo log.
Definition: buf0buf.h:1634
void release_io_responsibility()
Called by the thread responsible for I/O on this page to release its responsibility.
Definition: buf0buf.h:1477
static bool is_memory(const page_t *const ptr) noexcept
Check if the given ptr lies in a memory block of type BUF_BLOCK_MEMORY.
Definition: buf0buf.cc:7037
lsn_t get_oldest_lsn() const noexcept
Definition: buf0buf.h:1355
lsn_t oldest_modification
log sequence number of the youngest modification to this block, zero if not modified.
Definition: buf0buf.h:1638
page_id_t id
Page id.
Definition: buf0buf.h:1379
copyable_atomic_t< buf_io_fix > io_fix
Type of pending I/O operation.
Definition: buf0buf.h:1391
UT_LIST_NODE_T(buf_page_t) list
Based on state, this is a list node, protected by the corresponding list mutex, in one of the followi...
buf_io_fix get_io_fix_snapshot() const
Retrieves a value of io_fix without requiring or acquiring any latches.
Definition: buf0buf.h:1497
page_size_t size
Page size.
Definition: buf0buf.h:1382
io_responsibility_t io_responsibility
Tracks which thread is responsible for I/O on this page.
Definition: buf0buf.h:1460
uint8_t buf_pool_index
Index number of the buffer pool that this block belongs to.
Definition: buf0buf.h:1598
uint16_t m_dblwr_id
Double write instance ordinal value during writes.
Definition: buf0buf.h:1685
bool was_io_fix_none() const
Checks if io_fix is BUF_IO_NONE without requiring or acquiring any latches.
Definition: buf0buf.h:1588
void set_clean() noexcept
Set page to clean state.
Definition: buf0buf.h:1369
buf_io_fix get_io_fix() const
Retrieves the current value of io_fix.
Definition: buf0buf.h:1539
bool is_io_fix_read() const
Checks if the current value of io_fix is BUF_IO_READ.
Definition: buf0buf.cc:5662
uint32_t m_version
Version of fil_space_t when the page was updated.
Definition: buf0buf.h:1676
bool in_LRU_list
true if the page is in the LRU list; used in debugging
Definition: buf0buf.h:1710
void set_flush_observer(Flush_observer *flush_observer) noexcept
Set the flush observer for the page.
Definition: buf0buf.h:1339
buf_page_state state
Block state.
Definition: buf0buf.h:1591
page_no_t page_no() const noexcept
Retrieve the page number.
Definition: buf0buf.h:1228
fil_space_t * m_space
Tablespace instance that this page belongs to.
Definition: buf0buf.h:1666
bool was_io_fixed() const
Checks if io_fix is BUF_IO_FIX or BUF_IO_READ or BUF_IO_WRITE without requiring or acquiring any latc...
Definition: buf0buf.h:1578
void reset_flush_observer() noexcept
Remove the flush observer.
Definition: buf0buf.h:1347
void set_dblwr_batch_id(uint16_t batch_id)
Set the doublewrite buffer ID.
Definition: buf0buf.h:1217
bool file_page_was_freed
This is set to true when fsp frees a page in buffer pool; protected by buf_pool->zip_mutex or buf_blo...
Definition: buf0buf.h:1694
UT_LIST_NODE_T(buf_page_t) LRU
node of the LRU list
friend class Latching_rules_helpers
Definition: buf0buf.h:1419
bool is_memory() const noexcept
Check if the state of this page is BUF_BLOCK_MEMORY.
Definition: buf0buf.h:1210
buf_flush_t flush_type
If this block is currently being flushed to disk, this tells the flush_type.
Definition: buf0buf.h:1595
void set_page_size(const page_size_t &page_size)
Set the page size to a new value.
Definition: buf0buf.h:1287
bool in_page_hash
true if in buf_pool->page_hash
Definition: buf0buf.h:1713
page_zip_des_t zip
compressed page; zip.data (but not the data it points to) is protected by buf_pool->zip_mutex; state ...
Definition: buf0buf.h:1659
static bool is_correct_io_fix_value(buf_io_fix io_fix)
Checks if io_fix has any of the known enum values.
Definition: buf0buf.h:1399
Definition: buf0buf.h:1145
copyable_atomic_t(const copyable_atomic_t< T > &other)
Definition: buf0buf.h:1147
Definition: hash0hash.h:373
Page identifier.
Definition: buf0types.h:206
uint64_t hash() const
Retrieve the hash value.
Definition: buf0types.h:246
page_no_t page_no() const
Retrieve the page number.
Definition: buf0types.h:242
Page size descriptor.
Definition: page0size.h:49
size_t logical() const
Retrieve the logical page size (in-memory).
Definition: page0size.h:128
int page
Definition: ctype-mb.cc:1233
dberr_t
Definition: db0err.h:38
fil_space_t * fil_space_get(space_id_t space_id)
Look up a tablespace.
Definition: fil0fil.cc:2216
void fil_page_reset_type(const page_id_t &page_id, byte *page, ulint type, mtr_t *mtr)
Reset the page type.
Definition: fil0fil.cc:8224
The low-level file system.
uint16_t page_type_t
Definition: fil0fil.h:1208
constexpr page_type_t FIL_PAGE_INDEX
File page types (values of FIL_PAGE_TYPE)
Definition: fil0fil.h:1212
constexpr page_no_t FIL_NULL
'null' (undefined) page offset in the context of file spaces
Definition: fil0fil.h:1146
page_type_t fil_page_get_type(const byte *page)
Get the file page type.
Definition: fil0fil.h:1325
constexpr uint32_t FIL_PAGE_TYPE
file page type: FIL_PAGE_INDEX,..., 2 bytes.
Definition: fil0types.h:75
constexpr uint32_t FIL_PAGE_OFFSET
page offset inside space
Definition: fil0types.h:45
constexpr uint32_t FIL_PAGE_DATA
start of the data on the page
Definition: fil0types.h:110
constexpr uint32_t FIL_PAGE_SPACE_ID
alias for space id
Definition: fil0types.h:107
constexpr uint32_t FIL_PAGE_NEXT
if there is a 'natural' successor of the page, its offset.
Definition: fil0types.h:60
constexpr uint32_t FIL_PAGE_PREV
if there is a 'natural' predecessor of the page, its offset.
Definition: fil0types.h:50
flush_type
Definition: my_sys.h:296
The simple hash table utility.
static rw_lock_t * hash_lock_s_confirm(rw_lock_t *hash_lock, hash_table_t *table, uint64_t hash_value)
If not appropriate rw_lock for a hash value in a hash table, relock S-lock the another rw_lock until ...
static rw_lock_t * hash_lock_x_confirm(rw_lock_t *hash_lock, hash_table_t *table, uint64_t hash_value)
If not appropriate rw_lock for a hash value in a hash table, relock X-lock the another rw_lock until ...
static rw_lock_t * hash_get_lock(hash_table_t *table, uint64_t hash_value)
Gets the rw_lock for a hash value in a hash table.
static int flags[50]
Definition: hp_test1.cc:39
#define malloc(A)
Definition: lexyy.cc:914
#define free(A)
Definition: lexyy.cc:915
lock_mode
Definition: lock0types.h:51
constexpr lsn_t LSN_MAX
Maximum possible lsn value is slightly higher than the maximum sn value, because lsn sequence enumera...
Definition: log0constants.h:155
uint64_t lsn_t
Type used for all log sequence number storage and arithmetic.
Definition: log0types.h:62
static uint16_t mach_read_from_2(const byte *b)
The following function is used to fetch data from 2 consecutive bytes.
static uint32_t mach_read_from_4(const byte *b)
The following function is used to fetch data from 4 consecutive bytes.
static void mach_write_to_4(byte *b, ulint n)
The following function is used to store data in 4 consecutive bytes.
Mini-transaction buffer global types.
unsigned long long int ulonglong
Definition: my_inttypes.h:55
void copy(Shards< COUNT > &dst, const Shards< COUNT > &src) noexcept
Copy the counters, overwrite destination.
Definition: ut0counter.h:353
void clear(Shards< COUNT > &shards) noexcept
Clear the counter - reset to 0.
Definition: ut0counter.h:343
Definition: buf0block_hint.cc:29
const std::string FILE("FILE")
bool load(THD *, const dd::String_type &fname, dd::String_type *buf)
Read an sdi file from disk and store in a buffer.
Definition: sdi_file.cc:307
Definition: os0file.h:88
Provides atomic access in shared-exclusive modes.
Definition: shared_spin_lock.h:78
Definition: varlen_sort.h:174
mode
Definition: file_handle.h:59
pid_type get_id()
Definition: process.h:47
static uint64_t hash_uint64(uint64_t value)
Hashes a 64-bit integer.
Definition: ut0rnd.h:188
std::list< T, ut::allocator< T > > list
Specialization of list which uses ut_allocator.
Definition: ut0new.h:2877
void os_event_set(os_event_t event)
Sets an event semaphore to the signaled state: lets waiting threads proceed.
Definition: os0event.cc:552
bool os_event_is_set(const os_event_t event)
Check if the event is set.
Definition: os0event.cc:544
int64_t os_event_reset(os_event_t event)
Resets an event semaphore to the non-signaled state.
Definition: os0event.cc:567
The interface to the operating system process control primitives.
Index page routines.
byte page_t
Type of the index page.
Definition: page0types.h:151
required string type
Definition: replication_group_member_actions.proto:33
Shutdowns the Innobase database server.
std::atomic< enum srv_shutdown_t > srv_shutdown_state
At a shutdown this value climbs from SRV_SHUTDOWN_NONE to SRV_SHUTDOWN_EXIT_THREADS.
Definition: srv0start.cc:161
@ SRV_SHUTDOWN_EXIT_THREADS
Exit all threads and free resources.
Definition: srv0shutdown.h:110
The server main program.
Functor to validate the LRU list.
Definition: buf0buf.h:2731
static void validate(const buf_pool_t *buf_pool)
Definition: buf0buf.h:2734
void operator()(const buf_page_t *elem) const
Definition: buf0buf.h:2732
Functor to validate the LRU list.
Definition: buf0buf.h:2721
void operator()(const buf_page_t *elem) const
Definition: buf0buf.h:2722
static void validate(const buf_pool_t *buf_pool)
Definition: buf0buf.h:2724
Definition: buf0buf.h:2740
static void validate(const buf_pool_t *buf_pool)
Definition: buf0buf.h:2746
void operator()(const buf_block_t *elem) const
Definition: buf0buf.h:2741
Structure used by AHI to contain information on record prefixes to be considered in hash index subsys...
Definition: buf0buf.h:1725
bool operator==(const btr_search_prefix_info_t &other) const
Definition: buf0buf.h:1739
bool operator!=(const btr_search_prefix_info_t &other) const
Definition: buf0buf.h:1744
bool equals_without_left_side(const btr_search_prefix_info_t &other) const
Definition: buf0buf.h:1735
uint32_t n_bytes
recommended prefix: number of bytes in an incomplete field
Definition: buf0buf.h:1728
uint16_t n_fields
recommended prefix length for hash search: number of full fields
Definition: buf0buf.h:1730
bool left_side
true or false, depending on whether the leftmost record of several records with the same prefix shoul...
Definition: buf0buf.h:1733
Structure that holds most AHI-related fields.
Definition: buf0buf.h:1793
void assert_empty_on_init() const
Definition: buf0buf.h:1859
std::atomic< dict_index_t * > index
Index for which the adaptive hash index has been created, or nullptr if the page does not exist in th...
Definition: buf0buf.h:1812
void assert_empty() const
Definition: buf0buf.h:1857
void validate() const
Definition: buf0buf.h:1835
std::atomic< btr_search_prefix_info_t > prefix_info
Prefix info that was used for building hash index.
Definition: buf0buf.h:1811
std::atomic< uint16_t > n_pointers
Used in debugging.
Definition: buf0buf.h:1833
std::atomic< btr_search_prefix_info_t > recommended_prefix_info
Recommended prefix info for hash search.
Definition: buf0buf.h:1800
The buffer control block structure.
Definition: buf0buf.h:1750
rw_lock_t debug_latch
In the debug version, each thread which bufferfixes the block acquires an s-latch here; so we can use...
Definition: buf0buf.h:1894
uint64_t modify_clock
This clock is incremented every time a pointer to a record on the page may become obsolete; this is u...
Definition: buf0buf.h:1908
BPageLock lock
read-write lock of the buffer frame
Definition: buf0buf.h:1760
std::atomic< uint32_t > n_hash_helps
Counter which controls how many times the current prefix recommendation would help in searches.
Definition: buf0buf.h:1882
page_type_t get_page_type() const
Get the page type of the current buffer block.
Definition: buf0buf.h:1954
struct buf_block_t::ahi_t ahi
buf_page_t page
page information; this must be the first field, so that buf_pool->page_hash can point to buf_page_t o...
Definition: buf0buf.h:1756
page_no_t get_next_page_no() const
Get the next page number of the current buffer block.
Definition: buf0buf.h:1942
page_zip_des_t const * get_page_zip() const noexcept
Const version.
Definition: buf0buf.h:1992
const char * get_page_type_str() const noexcept
Get the page type of the current buffer block as string.
Definition: buf0buf.cc:7001
bool in_withdraw_list
Definition: buf0buf.h:1787
UT_LIST_NODE_T(buf_block_t) unzip_LRU
node of the decompressed LRU list; a block is in the unzip_LRU list if page.state == BUF_BLOCK_FILE_P...
page_no_t get_prev_page_no() const
Get the prev page number of the current buffer block.
Definition: buf0buf.h:1948
bool is_leaf() const
Definition: buf0buf.h:2003
void mark_for_read_io()
Mark the frame with jumbled page_id, while initiating i/o read (BUF_IO_READ).
Definition: buf0buf.h:1961
uint64_t get_modify_clock(bool single_threaded) const noexcept
Get the modified clock (version) value.
Definition: buf0buf.h:1921
bool in_unzip_LRU_list
true if the page is in the decompressed LRU list; used in debugging
Definition: buf0buf.h:1785
bool is_empty() const
Check if this index page is empty.
Definition: buf0buf.cc:7050
const page_id_t & get_page_id() const
Get the page number and space id of the current buffer block.
Definition: buf0buf.h:1934
BPageMutex mutex
mutex protecting this block: state (also protected by the buffer pool mutex), io_fix,...
Definition: buf0buf.h:1915
byte * frame
pointer to buffer frame which is of size UNIV_PAGE_SIZE, and aligned to an address divisible by UNIV_...
Definition: buf0buf.h:1772
page_no_t get_page_no() const
Get the page number of the current buffer block.
Definition: buf0buf.h:1938
bool is_index_page() const
Definition: buf0buf.h:2005
bool is_root() const
Definition: buf0buf.h:1999
bool was_freed() const
Check if the buffer block was freed.
Definition: buf0buf.h:1765
bool made_dirty_with_no_latch
true if block has been made dirty without acquiring X/SX latch as the block belongs to temporary tabl...
Definition: buf0buf.h:1886
page_zip_des_t * get_page_zip() noexcept
Gets the compressed page descriptor corresponding to an uncompressed page if applicable.
Definition: buf0buf.h:1986
bool is_memory() const noexcept
Definition: buf0buf.h:1996
uint16_t get_page_level() const
Definition: buf0buf.cc:7042
bool is_compact() const
Determine whether the page is in new-style compact format.
Definition: buf0buf.cc:7054
Struct that is embedded in the free zip blocks.
Definition: buf0buf.h:2150
UT_LIST_NODE_T(buf_buddy_free_t) list
Node of zip_free list.
ulint size
size of the block
Definition: buf0buf.h:2152
union buf_buddy_free_t::@192 stamp
byte bytes[FIL_PAGE_DATA]
stamp[FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID] == BUF_BUDDY_FREE_STAMP denotes a free block.
Definition: buf0buf.h:2153
buf_page_t bpage
Embedded bpage descriptor.
Definition: buf0buf.h:2164
Definition: buf0buf.h:2262
uint64_t relocated
Definition: buf0buf.h:2264
ulint used
Definition: buf0buf.h:2263
std::chrono::steady_clock::duration relocated_duration
Definition: buf0buf.h:2265
Statistics of buddy blocks of a given size.
Definition: buf0buf.h:2252
uint64_t relocated
Number of blocks relocated by the buddy system.
Definition: buf0buf.h:2257
snapshot_t take_snapshot()
Definition: buf0buf.h:2268
std::atomic< ulint > used
Number of blocks allocated from the buddy system.
Definition: buf0buf.h:2254
std::chrono::steady_clock::duration relocated_duration
Total duration of block relocations.
Definition: buf0buf.h:2260
A chunk of buffers.
Definition: buf0buf.ic:52
This structure defines information we will fetch from each buffer pool.
Definition: buf0buf.h:157
ulint young_making_delta
num of pages made young since last printout
Definition: buf0buf.h:210
std::array< size_t, BUF_FLUSH_N_TYPES > n_pending_flush
Number of pages pending flush of given type.
Definition: buf0buf.h:177
double pages_created_rate
num of pages create per second
Definition: buf0buf.h:206
ulint n_pages_read
buf_pool->n_pages_read
Definition: buf0buf.h:183
ulint pool_unique_id
Buffer Pool ID.
Definition: buf0buf.h:161
ulint n_pend_reads
buf_pool->n_pend_reads, pages pending read
Definition: buf0buf.h:175
ulint n_ra_pages_read_rnd
buf_pool->n_ra_pages_read_rnd, number of pages readahead
Definition: buf0buf.h:191
ulint lru_len
Length of buf_pool->LRU.
Definition: buf0buf.h:165
ulint unzip_cur
buf_LRU_stat_cur.unzip, num pages decompressed in current interval
Definition: buf0buf.h:231
ulint page_read_delta
num of pages read since last printout
Definition: buf0buf.h:208
double pages_written_rate
num of pages written per second
Definition: buf0buf.h:207
double page_made_young_rate
page made young rate in pages per second
Definition: buf0buf.h:201
ulint io_sum
buf_LRU_stat_sum.io
Definition: buf0buf.h:227
ulint io_cur
buf_LRU_stat_cur.io, num of IO for current interval
Definition: buf0buf.h:228
ulint old_lru_len
buf_pool->LRU_old_len
Definition: buf0buf.h:167
double pages_readahead_rnd_rate
random readahead rate in pages per second
Definition: buf0buf.h:216
ulint unzip_sum
buf_LRU_stat_sum.unzip
Definition: buf0buf.h:230
ulint n_pages_made_young
number of pages made young
Definition: buf0buf.h:179
ulint n_ra_pages_read
buf_pool->n_ra_pages_read, number of pages readahead
Definition: buf0buf.h:193
ulint n_pages_not_made_young
number of pages not made young
Definition: buf0buf.h:181
ulint n_ra_pages_evicted
buf_pool->n_ra_pages_evicted, number of readahead pages evicted without access
Definition: buf0buf.h:196
ulint n_pages_created
buf_pool->n_pages_created
Definition: buf0buf.h:185
ulint n_page_get_delta
num of buffer pool page gets since last printout
Definition: buf0buf.h:198
ulint free_list_len
Length of buf_pool->free list.
Definition: buf0buf.h:169
double pages_evicted_rate
rate of readahead page evicted without access, in pages per second
Definition: buf0buf.h:220
ulint not_young_making_delta
num of pages not make young since last printout
Definition: buf0buf.h:212
ulint n_pend_unzip
buf_pool->n_pend_unzip, pages pending decompress
Definition: buf0buf.h:173
double pages_readahead_rate
readahead rate in pages per second
Definition: buf0buf.h:218
ulint unzip_lru_len
length of buf_pool->unzip_LRU list
Definition: buf0buf.h:224
ulint pool_size
Buffer Pool size in pages.
Definition: buf0buf.h:163
ulint flush_list_len
Length of buf_pool->flush_list.
Definition: buf0buf.h:171
double page_not_made_young_rate
page not made young rate in pages per second
Definition: buf0buf.h:203
ulint n_page_gets
buf_pool->n_page_gets
Definition: buf0buf.h:189
double pages_read_rate
num of pages read per second
Definition: buf0buf.h:205
ulint n_pages_written
buf_pool->n_pages_written
Definition: buf0buf.h:187
The buffer pool statistics structure.
Definition: buf0buf.h:2170
uint64_t n_pages_not_made_young
Number of pages not made young because the first access was not long enough ago, in buf_page_peek_if_...
Definition: buf0buf.h:2203
std::atomic< uint64_t > n_pages_read
Number of read operations.
Definition: buf0buf.h:2179
std::atomic< uint64_t > n_pages_created
number of pages created in the pool with no read.
Definition: buf0buf.h:2185
uint64_t n_pages_made_young
Number of pages made young, in calls to buf_LRU_make_block_young().
Definition: buf0buf.h:2199
uint64_t n_ra_pages_evicted
Number of read ahead pages that are evicted without being accessed.
Definition: buf0buf.h:2195
std::atomic< uint64_t > n_ra_pages_read_rnd
Number of pages read in as part of random read ahead.
Definition: buf0buf.h:2188
uint64_t flush_list_bytes
Flush_list size in bytes.
Definition: buf0buf.h:2209
std::atomic< uint64_t > n_ra_pages_read
Number of pages read in as part of read ahead.
Definition: buf0buf.h:2191
Shards m_n_page_gets
Number of page gets performed; also successful searches through the adaptive hash index are counted a...
Definition: buf0buf.h:2176
uint64_t LRU_bytes
LRU size in bytes.
Definition: buf0buf.h:2206
void reset()
Definition: buf0buf.h:2235
static void copy(buf_pool_stat_t &dst, const buf_pool_stat_t &src) noexcept
Definition: buf0buf.h:2211
std::atomic< uint64_t > n_pages_written
Number of write operations.
Definition: buf0buf.h:2182
The buffer pool structure.
Definition: buf0buf.h:2278
UT_LIST_BASE_NODE_T(buf_buddy_free_t, list) zip_free[BUF_BUDDY_SIZES_MAX]
Buddy free lists.
UT_LIST_BASE_NODE_T(buf_page_t, list) free
Base node of the free block list.
buf_chunk_t * chunks_old
old buffer pool chunks to be freed after resizing buffer pool
Definition: buf0buf.h:2332
void change_flush_state(buf_flush_t flush_type, F &&change)
Executes change() which modifies fields protected by flush_state_mutex.
Definition: buf0buf.h:2551
hash_table_t * zip_hash
Hash table of buf_block_t blocks whose frames are allocated to the zip buddy system,...
Definition: buf0buf.h:2351
FlushHp flush_hp
"Hazard pointer" used during scan of flush_list while doing flush list batch.
Definition: buf0buf.h:2385
buf_buddy_stat_t buddy_stat[BUF_BUDDY_SIZES_MAX+1]
Statistics of buddy system, indexed by block size.
Definition: buf0buf.h:2364
LRUItr single_scan_itr
Iterator used to scan the LRU list when searching for single page flushing victim.
Definition: buf0buf.h:2462
buf_pool_stat_t old_stat
Old statistics.
Definition: buf0buf.h:2370
void deallocate_chunk(buf_chunk_t *chunk)
A wrapper for buf_pool_t::allocator.deallocate_large which also advices the OS that this chunk can be...
Definition: buf0buf.cc:917
bool try_LRU_scan
Set to false when an LRU scan for free block fails.
Definition: buf0buf.h:2424
ulint buddy_n_frames
Number of frames allocated from the buffer pool to the buddy system.
Definition: buf0buf.h:2319
std::atomic< ulint > n_pend_reads
Number of pending read operations.
Definition: buf0buf.h:2354
UT_LIST_BASE_NODE_T(buf_page_t, list) zip_clean
Unmodified compressed pages.
UT_LIST_BASE_NODE_T(buf_page_t, list) flush_list
Base node of the modified block list.
LRUHp lru_hp
"hazard pointer" used during scan of LRU while doing LRU list batch.
Definition: buf0buf.h:2454
bool allocate_chunk(ulonglong mem_size, buf_chunk_t *chunk)
A wrapper for buf_pool_t::allocator.alocate_large which also advices the OS that this chunk should no...
Definition: buf0buf.cc:883
bool is_tracking()
Check if the page modifications are tracked.
Definition: buf0buf.h:2431
UT_LIST_BASE_NODE_T(buf_block_t, unzip_LRU) unzip_LRU
Base node of the unzip_LRU list.
std::chrono::steady_clock::time_point last_printout_time
when buf_print_io was last time called.
Definition: buf0buf.h:2360
ulint LRU_old_ratio
Reserve this much of the buffer pool for "old" blocks.
Definition: buf0buf.h:2315
BufListMutex chunks_mutex
protects (de)allocation of chunks:
Definition: buf0buf.h:2287
lsn_t track_page_lsn
Page Tracking start LSN.
Definition: buf0buf.h:2427
BufListMutex zip_free_mutex
buddy allocator mutex
Definition: buf0buf.h:2296
volatile ulint n_chunks
Number of buffer pool chunks.
Definition: buf0buf.h:2323
LRUItr lru_scan_itr
Iterator used to scan the LRU list when searching for replaceable victim.
Definition: buf0buf.h:2458
bool madvise_dump()
Advices the OS that all chunks in this buffer pool instance can be dumped to a core file.
Definition: buf0buf.cc:928
ulint old_size
Previous pool size in pages.
Definition: buf0buf.h:2338
UT_LIST_BASE_NODE_T(buf_page_t, LRU) LRU
Base node of the LRU list.
FlushHp oldest_hp
Entry pointer to scan the oldest page except for system temporary.
Definition: buf0buf.h:2388
buf_page_t * LRU_old
Pointer to the about LRU_old_ratio/BUF_LRU_OLD_RATIO_DIV oldest blocks in the LRU list; NULL if LRU l...
Definition: buf0buf.h:2470
buf_page_t * watch
Sentinel records for buffer pool watches.
Definition: buf0buf.h:2499
BufListMutex flush_list_mutex
Mutex protecting the flush list access.
Definition: buf0buf.h:2381
ib_mutex_t flush_state_mutex
Flush state protection mutex.
Definition: buf0buf.h:2302
ib_rbt_t * flush_rbt
A red-black tree is used exclusively during recovery to speed up insertions in the flush_list.
Definition: buf0buf.h:2411
buf_chunk_t * chunks
buffer pool chunks
Definition: buf0buf.h:2329
BufListMutex LRU_list_mutex
LRU list mutex.
Definition: buf0buf.h:2290
hash_table_t * page_hash
Hash table of buf_page_t or buf_block_t file pages, buf_page_in_file() == true, indexed by (space_id,...
Definition: buf0buf.h:2347
ulint withdraw_target
Target length of withdraw block list, when withdrawing.
Definition: buf0buf.h:2450
os_event_t no_flush[BUF_FLUSH_N_TYPES]
This is in the set state when there is no flush batch of the given type running.
Definition: buf0buf.h:2403
buf_pool_stat_t stat
Current statistics.
Definition: buf0buf.h:2367
page_no_t read_ahead_area
Size in pages of the area which the read-ahead algorithms read if invoked.
Definition: buf0buf.h:2342
ulint curr_pool_size
Current pool size in bytes.
Definition: buf0buf.h:2312
bool init_flush[BUF_FLUSH_N_TYPES]
This is true when a flush of the given type is being initialized.
Definition: buf0buf.h:2395
ulint curr_size
Current pool size in pages.
Definition: buf0buf.h:2335
ulint instance_no
Array index of this buffer pool instance.
Definition: buf0buf.h:2309
ulint LRU_old_len
Length of the LRU list from the block to which LRU_old points onward, including that block; see buf0l...
Definition: buf0buf.h:2476
std::array< size_t, BUF_FLUSH_N_TYPES > n_flush
This is the number of pending writes in the given flush type.
Definition: buf0buf.h:2399
std::atomic< ulint > n_pend_unzip
number of pending decompressions.
Definition: buf0buf.h:2357
UT_LIST_BASE_NODE_T(buf_page_t, list) withdraw
base node of the withdraw block list.
lsn_t max_lsn_io
Maximum LSN for which write io has already started.
Definition: buf0buf.h:2434
ulint freed_page_clock
A sequence number used to count the number of buffer blocks removed from the end of the LRU list; NOT...
Definition: buf0buf.h:2418
BufListMutex free_list_mutex
free and withdraw list mutex
Definition: buf0buf.h:2293
BufPoolZipMutex zip_mutex
Zip mutex of this buffer pool instance, protects compressed only pages (of type buf_page_t,...
Definition: buf0buf.h:2306
bool madvise_dont_dump()
Advices the OS that all chunks in this buffer pool instance should not be dumped to a core file.
Definition: buf0buf.cc:938
volatile ulint n_chunks_new
New number of buffer pool chunks.
Definition: buf0buf.h:2326
BufListMutex zip_hash_mutex
zip_hash mutex
Definition: buf0buf.h:2299
bool is_flushing(buf_flush_t flush_type) const
Checks if the batch is running, which is basically equivalent to !os_event_is_set(no_flush[type]) if ...
Definition: buf0buf.h:2538
The occupied bytes of lists in all buffer pools.
Definition: buf0buf.h:237
ulint LRU_bytes
LRU size in bytes.
Definition: buf0buf.h:238
ulint unzip_LRU_bytes
unzip_LRU size in bytes
Definition: buf0buf.h:239
ulint flush_list_bytes
flush_list size in bytes
Definition: buf0buf.h:240
File space address.
Definition: fil0fil.h:1163
File node of a tablespace or the log data space.
Definition: fil0fil.h:150
Tablespace or log data space.
Definition: fil0fil.h:233
space_id_t id
Tablespace ID.
Definition: fil0fil.h:329
void dec_ref() noexcept
Decrement the page reference count.
Definition: fil0fil.h:291
uint32_t get_current_version() const
Returns current version of the space object.
Definition: fil0fil.cc:11737
uint32_t get_recent_version() const
Returns current version of the space object.
Definition: fil0fil.cc:11741
bool was_not_deleted() const
Definition: fil0fil.cc:11729
void inc_ref() noexcept
Increment the page reference count.
Definition: fil0fil.h:280
bool is_deleted() const
Definition: fil0fil.cc:11724
Red black tree instance.
Definition: ut0rbt.h:71
Mini-transaction handle and buffer.
Definition: mtr0mtr.h:176
InnoDB condition variable.
Definition: os0event.cc:62
Compressed page descriptor.
Definition: page0types.h:200
page_zip_t * data
Compressed page data.
Definition: page0types.h:202
The structure used in the spin lock implementation of a read-write lock.
Definition: sync0rw.h:362
Definition: ut0core.h:35
bool rw_lock_own(const rw_lock_t *lock, ulint lock_type)
Checks if the thread has locked the rw-lock in the specified mode, with the pass value == 0.
Definition: sync0rw.cc:857
rw_lock_type_t
Definition: sync0rw.h:96
@ RW_NO_LATCH
Definition: sync0rw.h:100
bool rw_lock_own_flagged(const rw_lock_t *lock, rw_lock_flags_t flags)
Checks if the thread has locked the rw-lock in the specified mode, with the pass value == 0.
Definition: sync0rw.cc:897
latch_level_t
Latching order levels.
Definition: sync0types.h:200
@ RW_LOCK_S
Definition: sync0types.h:207
@ RW_LOCK_X
Definition: sync0types.h:208
@ RW_LOCK_FLAG_X
Definition: sync0types.h:1212
@ RW_LOCK_FLAG_SX
Definition: sync0types.h:1213
@ RW_LOCK_FLAG_S
Definition: sync0types.h:1211
Version control for database, common definitions, and include files.
constexpr uint32_t UINT32_UNDEFINED
The 'undefined' value for a 32-bit unsigned integer.
Definition: univ.i:427
#define UNIV_PAGE_SIZE_SHIFT
The 2-logarithm of UNIV_PAGE_SIZE:
Definition: univ.i:290
#define IF_DEBUG(...)
Definition: univ.i:673
unsigned long int ulint
Definition: univ.i:405
#define UNIV_MEM_VALID(addr, size)
Definition: univ.i:590
constexpr uint32_t UNIV_ZIP_SIZE_MIN
Smallest compressed page size.
Definition: univ.i:329
Utilities for byte operations.
#define ut_ad(EXPR)
Debug assertion.
Definition: ut0dbg.h:104
#define ut_d(EXPR)
Debug statement.
Definition: ut0dbg.h:106
#define ut_a(EXPR)
Abort execution if EXPR does not evaluate to nonzero.
Definition: ut0dbg.h:92
void ut_list_validate(const List &list, Functor &functor)
Checks the consistency of a two-way list.
Definition: ut0lst.h:492
#define mutex_own(M)
Checks that the current thread owns the mutex.
Definition: ut0mutex.h:164
#define mutex_exit(M)
Definition: ut0mutex.h:122
#define mutex_enter(M)
Definition: ut0mutex.h:116
Various utilities.
static uint64_t lsn
Definition: xcom_base.cc:445
unsigned long id[MAX_DEAD]
Definition: xcom_base.cc:509
int n
Definition: xcom_base.cc:508