108#define BUF_POOL_WATCH_SIZE (srv_n_purge_threads + 1)
232#ifndef UNIV_HOTBACKUP
326#ifndef UNIV_HOTBACKUP
354#ifndef UNIV_HOTBACKUP
420 bool dirty_with_no_latch =
false);
467#ifndef UNIV_HOTBACKUP
595#ifndef UNIV_HOTBACKUP
621#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
626#if defined UNIV_DEBUG_PRINT || defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
650#ifndef UNIV_HOTBACKUP
712#define buf_block_dbg_add_level(block, level)
742#ifndef UNIV_HOTBACKUP
823[[nodiscard]]
static inline std::chrono::steady_clock::time_point
843#define buf_block_get_frame(block) (block)->frame
846#define buf_block_get_frame(block) (block)->frame
871#ifndef UNIV_HOTBACKUP
921 bool owns_sx_lock =
false) noexcept;
1063 ulint *flush_list_len);
1099 bool skip_lsn_check);
1116template <
typename T>
1120 :
std::atomic<T>(other.
load(
std::memory_order_relaxed)) {}
1136#ifndef UNIV_HOTBACKUP
1144#ifndef UNIV_HOTBACKUP
1164#ifndef UNIV_HOTBACKUP
1169#ifndef UNIV_HOTBACKUP
1193 ut_a(m_version <= m_space->get_current_version());
1216 ut_a(was_not_deleted);
1438 return io_fix.load(std::memory_order_relaxed);
1540 "MAX_BUFFER_POOLS > 64; redefine buf_pool_index");
1543#ifndef UNIV_HOTBACKUP
1600#ifndef UNIV_HOTBACKUP
1684 return !(*
this == other);
1697#ifndef UNIV_HOTBACKUP
1741 static_assert(
decltype(
prefix_info)::is_always_lock_free);
1758#if defined UNIV_AHI_DEBUG || defined UNIV_DEBUG
1782 ut_a(this->index.load() !=
nullptr || this->n_pointers.load() == 0 ||
1783 this->index.load() !=
nullptr);
1817#ifndef UNIV_HOTBACKUP
1851#if defined(UNIV_DEBUG) && !defined(UNIV_LIBRARY) && !defined(UNIV_HOTBACKUP)
2033 :
LRUHp(buf_pool, mutex) {}
2110 dst.n_pages_read.store(src.n_pages_read.load());
2112 dst.n_pages_written.store(src.n_pages_written.load());
2114 dst.n_pages_created.store(src.n_pages_created.load());
2116 dst.n_ra_pages_read_rnd.store(src.n_ra_pages_read_rnd.load());
2118 dst.n_ra_pages_read.store(src.n_ra_pages_read.load());
2120 dst.n_ra_pages_evicted = src.n_ra_pages_evicted;
2122 dst.n_pages_made_young = src.n_pages_made_young;
2124 dst.n_pages_not_made_young = src.n_pages_not_made_young;
2126 dst.LRU_bytes = src.LRU_bytes;
2128 dst.flush_list_bytes = src.flush_list_bytes;
2380#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
2425 "BUF_BUDDY_LOW > UNIV_ZIP_SIZE_MIN");
2439#ifndef UNIV_HOTBACKUP
2441#define buf_flush_list_mutex_own(b) mutex_own(&(b)->flush_list_mutex)
2444#define buf_flush_list_mutex_enter(b) \
2446 mutex_enter(&(b)->flush_list_mutex); \
2449#define buf_flush_list_mutex_exit(b) \
2451 mutex_exit(&(b)->flush_list_mutex); \
2454#define buf_page_mutex_enter(b) \
2456 mutex_enter(&(b)->mutex); \
2460#define buf_page_mutex_exit(b) \
2462 (b)->mutex.exit(); \
2485#if defined(UNIV_DEBUG) && !defined(UNIV_HOTBACKUP)
2521#define buf_page_hash_lock_held_s(b, p) (true)
2522#define buf_page_hash_lock_held_x(b, p) (true)
2523#define buf_page_hash_lock_held_s_or_x(b, p) (true)
2524#define buf_block_hash_lock_held_s(b, p) (true)
2525#define buf_block_hash_lock_held_x(b, p) (true)
2526#define buf_block_hash_lock_held_s_or_x(b, p) (true)
2575#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
2576#ifndef UNIV_HOTBACKUP
2611#ifndef UNIV_HOTBACKUP
2615 bpage->reset_page_id();
2623 return block->get_page_zip();
2632 return block->get_page_zip();
2647 if (page_type !=
type) {
uint32_t space_id_t
Tablespace identifier.
Definition: api0api.h:50
uint32_t page_no_t
Page number.
Definition: api0api.h:48
Cache_hint
Definition: buf0buf.h:90
@ 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:2511
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:3225
dberr_t buf_pool_init(ulint total_size, ulint n_instances)
Creates the buffer pool.
Definition: buf0buf.cc:1441
void buf_page_print(const byte *read_buf, const page_size_t &page_size, ulint flags)
Prints a page to stderr.
Definition: buf0buf.cc:548
ulint buf_get_n_pending_read_ios(void)
Returns the number of pending buf pool read ios.
Definition: buf0buf.cc:6378
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:2500
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:2493
bool buf_validate(void)
Validates the buffer pool data structure.
Definition: buf0buf.cc:6164
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:955
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:3435
lsn_t buf_pool_get_oldest_modification_lwm(void)
Gets a safe low watermark for oldest_modification.
Definition: buf0buf.cc:421
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:1817
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:953
ulonglong buf_pool_adjust_chunk_unit(ulonglong size)
Adjust the proposed chunk unit size so that it satisfies all invariants.
Definition: buf0buf.cc:2086
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:3138
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:3092
buf_pool_t * buf_pool_ptr
The buffer pools of the database.
Definition: buf0buf.cc:302
void buf_pool_clear_hash_index(void)
Clears the adaptive hash index on all pages in the buffer pool.
Definition: buf0buf.cc:2649
void buf_get_total_stat(buf_pool_stat_t *tot_stat)
Get total buffer pool statistics.
Definition: buf0buf.cc:493
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:2487
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:111
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:4433
void buf_pool_watch_unset(const page_id_t &page_id)
Stop watching if the page has been read in.
Definition: buf0buf.cc:3041
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:3068
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:4797
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:5317
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:1007
bool buf_page_io_complete(buf_page_t *bpage, bool evict)
Completes an asynchronous read or write request of a file page to or from the buffer pool.
Definition: buf0buf.cc:5605
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:6743
size_t buf_pool_pending_io_writes_count()
Computes number of pending I/O write operations for the buffer pool.
Definition: buf0buf.cc:6751
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:5282
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:5400
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:3471
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:2466
std::ostream & operator<<(std::ostream &out, const buf_pool_t &buf_pool)
Print the given buf_pool_t object.
Definition: buf0buf.cc:6824
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:1915
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:2642
void buf_pool_free_all()
Frees the buffer pool at shutdown.
Definition: buf0buf.cc:6858
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:4367
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:2478
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:6359
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:105
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:6660
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:6461
void buf_resize_thread()
This is the thread for resizing buffer pool.
Definition: buf0buf.cc:2622
void buf_print(void)
Prints info of the buffer pool data structure.
Definition: buf0buf.cc:6265
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:4626
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:1796
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:3104
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:368
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:1020
void buf_must_be_all_freed(void)
Assert that all file pages in the buffer are in a replaceable state.
Definition: buf0buf.cc:6733
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...
@ IF_IN_POOL
get if in pool
@ 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:2472
static void buf_page_unset_sticky(buf_page_t *bpage)
Removes stickiness of a block.
buf_page_print_flags
Definition: buf0buf.h:631
@ BUF_PAGE_PRINT_NO_FULL
Do not print the full page dump.
Definition: buf0buf.h:635
@ BUF_PAGE_PRINT_NO_CRASH
Do not crash at the end of buf_page_print().
Definition: buf0buf.h:633
buf_page_t * buf_page_get_also_watch(buf_pool_t *b, const page_id_t &page_id)
Definition: buf0buf.h:1015
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:2886
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:436
constexpr ulint MAX_BUFFER_POOLS_BITS
Number of bits to representing a buffer pool ID.
Definition: buf0buf.h:102
bool buf_block_hash_lock_held_s(const buf_pool_t *buf_pool, const buf_block_t *block)
Definition: buf0buf.h:2506
buf_block_t * buf_block_hash_get(buf_pool_t *b, const page_id_t &page_id)
Definition: buf0buf.h:1030
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:4533
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:1002
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:1919
buf_page_t * buf_page_hash_get(buf_pool_t *b, const page_id_t &page_id)
Definition: buf0buf.h:1012
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:1114
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:127
@ BUF_BLOCK_NOT_USED
Is in the free list; must be after the BUF_BLOCK_ZIP_ constants for compressed-only pages.
Definition: buf0buf.h:137
@ BUF_BLOCK_ZIP_PAGE
Contains a clean compressed page.
Definition: buf0buf.h:131
@ BUF_BLOCK_REMOVE_HASH
Hash index should be removed before putting to the free list.
Definition: buf0buf.h:149
@ BUF_BLOCK_MEMORY
Contains some main memory object.
Definition: buf0buf.h:146
@ BUF_BLOCK_ZIP_DIRTY
Contains a compressed page that is in the buf_pool->flush_list.
Definition: buf0buf.h:133
@ BUF_BLOCK_POOL_WATCH
A sentinel for the buffer pool watch, element of buf_pool->watch[].
Definition: buf0buf.h:129
@ BUF_BLOCK_READY_FOR_USE
When buf_LRU_get_free_block returns a block, it is in this state.
Definition: buf0buf.h:140
@ BUF_BLOCK_FILE_PAGE
Contains a buffered file page.
Definition: buf0buf.h:143
void buf_refresh_io_stats_all()
Refresh the statistics used to print per-second averages.
Definition: buf0buf.cc:6722
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:519
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:425
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:2622
void buf_pool_invalidate(void)
Invalidates the file pages in the buffer pool when an archive recovery is completed.
Definition: buf0buf.cc:5968
void buf_page_free_descriptor(buf_page_t *bpage)
Free a buf_page_t descriptor.
Definition: buf0buf.cc:1356
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:5002
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:6392
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:2614
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:1110
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:6763
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:2516
bool buf_block_state_valid(buf_block_t *block)
Check if a buf_block_t object is in a valid state.
Definition: buf0buf.h:1908
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:1025
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:3164
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:587
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:472
void buf_get_total_list_len(ulint *LRU_len, ulint *free_len, ulint *flush_list_len)
Get total buffer pool statistics.
Definition: buf0buf.cc:452
bool buf_zip_decompress(buf_block_t *block, bool check)
Decompress a block.
Definition: buf0buf.cc:3367
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:1986
~FlushHp() override=default
Destructor.
FlushHp(const buf_pool_t *buf_pool, const ib_mutex_t *mutex)
Constructor.
Definition: buf0buf.h:1991
void adjust(const buf_page_t *bpage) override
Adjust the value of hp.
Definition: buf0buf.cc:2846
We use Flush_observer to track flushing of non-redo logged pages in bulk create index(btr0load....
Definition: buf0flu.h:268
A "Hazard Pointer" class used to iterate over page lists inside the buffer pool.
Definition: buf0buf.h:1928
bool is_hp(const buf_page_t *bpage)
Checks if a bpage is the hp.
Definition: buf0buf.cc:2821
void set(buf_page_t *bpage)
Set current value.
Definition: buf0buf.cc:2808
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:1978
void move(const buf_page_t *bpage, buf_page_t *dpage)
Adjust the value of hp for moving.
Definition: buf0buf.cc:2833
buf_page_t * m_hp
hazard pointer.
Definition: buf0buf.h:1982
virtual ~HazardPointer()=default
Destructor.
const buf_pool_t * m_buf_pool
Buffer pool instance.
Definition: buf0buf.h:1974
HazardPointer(const HazardPointer &)
Disable copying.
buf_page_t * get() const
Get current value.
Definition: buf0buf.h:1940
HazardPointer(const buf_pool_t *buf_pool, const ib_mutex_t *mutex)
Constructor.
Definition: buf0buf.h:1933
HazardPointer & operator=(const HazardPointer &)
Class implementing buf_pool->LRU hazard pointer.
Definition: buf0buf.h:2005
~LRUHp() override=default
Destructor.
void adjust(const buf_page_t *bpage) override
Adjust the value of hp.
Definition: buf0buf.cc:2861
LRUHp(const buf_pool_t *buf_pool, const ib_mutex_t *mutex)
Constructor.
Definition: buf0buf.h:2010
Special purpose iterators to be used when scanning the LRU list.
Definition: buf0buf.h:2027
~LRUItr() override=default
Destructor.
buf_page_t * start()
Selects from where to start a scan.
Definition: buf0buf.cc:2876
LRUItr(const buf_pool_t *buf_pool, const ib_mutex_t *mutex)
Constructor.
Definition: buf0buf.h:2032
The purpose of this class is to hide the knowledge that Buf_io_fix_latching_rules even exists from us...
Definition: buf0buf.cc:5511
Definition: buf0buf.h:1366
bool someone_is_responsible() const
Checks if there is any thread responsible for I/O on this page now.
Definition: buf0buf.h:1374
void release()
Called by the thread responsible for I/O on this page to release its responsibility.
Definition: buf0buf.h:1386
bool current_thread_is_responsible() const
Checks if the current thread is responsible for I/O on this page now.
Definition: buf0buf.h:1380
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:1393
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:1369
Definition: buf0buf.h:1124
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:1610
buf_page_t(const buf_page_t &other)
Copy constructor.
Definition: buf0buf.h:1128
void space_id_changed()
Updates new space reference and acquires "reference count latch" and the current version of the space...
Definition: buf0buf.h:1257
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:1420
bool is_stale() const
Checks if this space reference saved during last page ID initialization was deleted or truncated sinc...
Definition: buf0buf.h:1190
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:1450
void set_io_fix(buf_io_fix io_fix)
Sets io_fix to specified value.
Definition: buf0buf.cc:5585
bool someone_has_io_responsibility() const
Checks if there is any thread responsible for I/O on this page now.
Definition: buf0buf.h:1404
bool has_correct_io_fix_value() const
Checks if io_fix has any of the known enum values.
Definition: buf0buf.h:1353
lsn_t get_newest_lsn() const noexcept
Definition: buf0buf.h:1290
bool current_thread_has_io_responsibility() const
Checks if the current thread is responsible for I/O on this page now.
Definition: buf0buf.h:1410
void set_newest_lsn(lsn_t lsn) noexcept
Set the latest modification LSN.
Definition: buf0buf.h:1301
buf_page_t * hash
Node used in chaining to buf_pool->page_hash or buf_pool->zip_hash.
Definition: buf0buf.h:1540
bool is_io_fix_write() const
Checks if the current value of io_fix is BUF_IO_WRITE.
Definition: buf0buf.cc:5565
Flush_observer * get_flush_observer() noexcept
Definition: buf0buf.h:1274
fil_space_t * get_space() const
Retrieve the tablespace object if one was available during page ID initialization.
Definition: buf0buf.h:1229
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:5577
space_id_t space() const noexcept
Retrieve the tablespace id.
Definition: buf0buf.h:1179
bool in_zip_hash
true if in buf_pool->zip_hash
Definition: buf0buf.h:1655
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:1646
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:1619
Flush_observer * m_flush_observer
Flush observer instance.
Definition: buf0buf.h:1602
buf_fix_count_atomic_t buf_fix_count
Count of how many fold this block is currently bufferfixed.
Definition: buf0buf.h:1324
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:1642
void reset_page_id()
Sets stored value to invalid/empty value.
Definition: buf0buf.h:1250
bool is_dirty() const noexcept
Definition: buf0buf.h:1297
bool old
true if the block is in the old blocks in buf_pool->LRU_old
Definition: buf0buf.h:1628
bool was_io_fix_read() const
Checks if io_fix is BUF_IO_READ without requiring or acquiring any latches.
Definition: buf0buf.h:1510
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:1462
void reset_page_id(page_id_t new_page_id)
Sets stored page ID to the new value.
Definition: buf0buf.h:1234
void set_oldest_lsn(lsn_t lsn) noexcept
Set the LSN when the page is modified for the first time.
Definition: buf0buf.ic:744
uint16_t get_dblwr_batch_id() const
Definition: buf0buf.h:1175
bool was_stale() const
Checks if this space reference saved during last page ID initialization was deleted or truncated sinc...
Definition: buf0buf.h:1207
lsn_t newest_modification
The flush LSN, LSN when this page was written to the redo log.
Definition: buf0buf.h:1573
void release_io_responsibility()
Called by the thread responsible for I/O on this page to release its responsibility.
Definition: buf0buf.h:1416
lsn_t get_oldest_lsn() const noexcept
Definition: buf0buf.h:1294
lsn_t oldest_modification
log sequence number of the youngest modification to this block, zero if not modified.
Definition: buf0buf.h:1577
page_id_t id
Page id.
Definition: buf0buf.h:1318
copyable_atomic_t< buf_io_fix > io_fix
Type of pending I/O operation.
Definition: buf0buf.h:1330
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:1436
page_size_t size
Page size.
Definition: buf0buf.h:1321
io_responsibility_t io_responsibility
Tracks which thread is responsible for I/O on this page.
Definition: buf0buf.h:1399
uint8_t buf_pool_index
Index number of the buffer pool that this block belongs to.
Definition: buf0buf.h:1537
uint16_t m_dblwr_id
Double write instance ordinal value during writes.
Definition: buf0buf.h:1624
bool was_io_fix_none() const
Checks if io_fix is BUF_IO_NONE without requiring or acquiring any latches.
Definition: buf0buf.h:1527
void set_clean() noexcept
Set page to clean state.
Definition: buf0buf.h:1308
buf_io_fix get_io_fix() const
Retrieves the current value of io_fix.
Definition: buf0buf.h:1478
bool is_io_fix_read() const
Checks if the current value of io_fix is BUF_IO_READ.
Definition: buf0buf.cc:5571
uint32_t m_version
Version of fil_space_t when the page was updated.
Definition: buf0buf.h:1615
bool in_LRU_list
true if the page is in the LRU list; used in debugging
Definition: buf0buf.h:1649
void set_flush_observer(Flush_observer *flush_observer) noexcept
Set the flush observer for the page.
Definition: buf0buf.h:1278
buf_page_state state
Block state.
Definition: buf0buf.h:1530
page_no_t page_no() const noexcept
Retrieve the page number.
Definition: buf0buf.h:1183
fil_space_t * m_space
Tablespace instance that this page belongs to.
Definition: buf0buf.h:1605
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:1517
void reset_flush_observer() noexcept
Remove the flush observer.
Definition: buf0buf.h:1286
void set_dblwr_batch_id(uint16_t batch_id)
Set the doublewrite buffer ID.
Definition: buf0buf.h:1172
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:1633
UT_LIST_NODE_T(buf_page_t) LRU
node of the LRU list
friend class Latching_rules_helpers
Definition: buf0buf.h:1358
buf_flush_t flush_type
If this block is currently being flushed to disk, this tells the flush_type.
Definition: buf0buf.h:1534
bool in_page_hash
true if in buf_pool->page_hash
Definition: buf0buf.h:1652
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:1598
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:1338
Definition: buf0buf.h:1117
copyable_atomic_t(const copyable_atomic_t< T > &other)
Definition: buf0buf.h:1119
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
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:8216
The low-level file system.
uint16_t page_type_t
Definition: fil0fil.h:1180
page_type_t fil_page_get_type(const byte *page)
Get the file page type.
Definition: fil0fil.h:1794
constexpr uint32_t FIL_PAGE_TYPE
file page type: FIL_PAGE_INDEX,..., 2 bytes.
Definition: fil0types.h:75
constexpr uint32_t FIL_PAGE_DATA
start of the data on the page
Definition: fil0types.h:110
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:294
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
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.
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
Provides atomic access in shared-exclusive modes.
Definition: shared_spin_lock.h:78
Definition: varlen_sort.h:183
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:217
std::list< T, ut::allocator< T > > list
Specialization of list which uses ut_allocator.
Definition: ut0new.h:2877
The interface to the operating system process control primitives.
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
Functor to validate the LRU list.
Definition: buf0buf.h:2588
static void validate(const buf_pool_t *buf_pool)
Definition: buf0buf.h:2591
void operator()(const buf_page_t *elem) const
Definition: buf0buf.h:2589
Functor to validate the LRU list.
Definition: buf0buf.h:2578
void operator()(const buf_page_t *elem) const
Definition: buf0buf.h:2579
static void validate(const buf_pool_t *buf_pool)
Definition: buf0buf.h:2581
Definition: buf0buf.h:2597
static void validate(const buf_pool_t *buf_pool)
Definition: buf0buf.h:2603
void operator()(const buf_block_t *elem) const
Definition: buf0buf.h:2598
Structure used by AHI to contain information on record prefixes to be considered in hash index subsys...
Definition: buf0buf.h:1664
bool operator==(const btr_search_prefix_info_t &other) const
Definition: buf0buf.h:1678
bool operator!=(const btr_search_prefix_info_t &other) const
Definition: buf0buf.h:1683
bool equals_without_left_side(const btr_search_prefix_info_t &other) const
Definition: buf0buf.h:1674
uint32_t n_bytes
recommended prefix: number of bytes in an incomplete field
Definition: buf0buf.h:1667
uint16_t n_fields
recommended prefix length for hash search: number of full fields
Definition: buf0buf.h:1669
bool left_side
true or false, depending on whether the leftmost record of several records with the same prefix shoul...
Definition: buf0buf.h:1672
Structure that holds most AHI-related fields.
Definition: buf0buf.h:1722
void assert_empty_on_init() const
Definition: buf0buf.h:1788
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:1741
void assert_empty() const
Definition: buf0buf.h:1786
void validate() const
Definition: buf0buf.h:1764
std::atomic< btr_search_prefix_info_t > prefix_info
Prefix info that was used for building hash index.
Definition: buf0buf.h:1740
std::atomic< uint16_t > n_pointers
Used in debugging.
Definition: buf0buf.h:1762
std::atomic< btr_search_prefix_info_t > recommended_prefix_info
Recommended prefix info for hash search.
Definition: buf0buf.h:1729
The buffer control block structure.
Definition: buf0buf.h:1689
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:1823
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:1837
BPageLock lock
read-write lock of the buffer frame
Definition: buf0buf.h:1699
std::atomic< uint32_t > n_hash_helps
Counter which controls how many times the current prefix recommendation would help in searches.
Definition: buf0buf.h:1811
page_type_t get_page_type() const
Get the page type of the current buffer block.
Definition: buf0buf.h:1883
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:1695
page_no_t get_next_page_no() const
Get the next page number of the current buffer block.
Definition: buf0buf.h:1871
page_zip_des_t const * get_page_zip() const noexcept
Const version.
Definition: buf0buf.h:1900
const char * get_page_type_str() const noexcept
Get the page type of the current buffer block as string.
Definition: buf0buf.cc:6851
bool in_withdraw_list
Definition: buf0buf.h:1716
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:1877
uint64_t get_modify_clock(bool single_threaded) const noexcept
Get the modified clock (version) value.
Definition: buf0buf.h:1850
bool in_unzip_LRU_list
true if the page is in the decompressed LRU list; used in debugging
Definition: buf0buf.h:1714
const page_id_t & get_page_id() const
Get the page number and space id of the current buffer block.
Definition: buf0buf.h:1863
BPageMutex mutex
mutex protecting this block: state (also protected by the buffer pool mutex), io_fix,...
Definition: buf0buf.h:1844
byte * frame
pointer to buffer frame which is of size UNIV_PAGE_SIZE, and aligned to an address divisible by UNIV_...
Definition: buf0buf.h:1705
page_no_t get_page_no() const
Get the page number of the current buffer block.
Definition: buf0buf.h:1867
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:1815
page_zip_des_t * get_page_zip() noexcept
Gets the compressed page descriptor corresponding to an uncompressed page if applicable.
Definition: buf0buf.h:1894
Struct that is embedded in the free zip blocks.
Definition: buf0buf.h:2046
UT_LIST_NODE_T(buf_buddy_free_t) list
Node of zip_free list.
union buf_buddy_free_t::@189 stamp
ulint size
size of the block
Definition: buf0buf.h:2048
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:2049
buf_page_t bpage
Embedded bpage descriptor.
Definition: buf0buf.h:2060
Definition: buf0buf.h:2158
uint64_t relocated
Definition: buf0buf.h:2160
ulint used
Definition: buf0buf.h:2159
std::chrono::steady_clock::duration relocated_duration
Definition: buf0buf.h:2161
Statistics of buddy blocks of a given size.
Definition: buf0buf.h:2148
uint64_t relocated
Number of blocks relocated by the buddy system.
Definition: buf0buf.h:2153
snapshot_t take_snapshot()
Definition: buf0buf.h:2164
std::atomic< ulint > used
Number of blocks allocated from the buddy system.
Definition: buf0buf.h:2150
std::chrono::steady_clock::duration relocated_duration
Total duration of block relocations.
Definition: buf0buf.h:2156
A chunk of buffers.
Definition: buf0buf.ic:52
This structure defines information we will fetch from each buffer pool.
Definition: buf0buf.h:154
ulint young_making_delta
num of pages made young since last printout
Definition: buf0buf.h:199
double pages_created_rate
num of pages create per second
Definition: buf0buf.h:195
ulint n_pages_read
buf_pool->n_pages_read
Definition: buf0buf.h:175
ulint pool_unique_id
Buffer Pool ID.
Definition: buf0buf.h:156
ulint n_pend_reads
buf_pool->n_pend_reads, pages pending read
Definition: buf0buf.h:164
ulint n_ra_pages_read_rnd
buf_pool->n_ra_pages_read_rnd, number of pages readahead
Definition: buf0buf.h:179
ulint lru_len
Length of buf_pool->LRU.
Definition: buf0buf.h:158
ulint unzip_cur
buf_LRU_stat_cur.unzip, num pages decompressed in current interval
Definition: buf0buf.h:220
ulint page_read_delta
num of pages read since last printout
Definition: buf0buf.h:197
double pages_written_rate
num of pages written per second
Definition: buf0buf.h:196
double page_made_young_rate
page made young rate in pages per second
Definition: buf0buf.h:190
ulint io_sum
buf_LRU_stat_sum.io
Definition: buf0buf.h:216
ulint io_cur
buf_LRU_stat_cur.io, num of IO for current interval
Definition: buf0buf.h:217
ulint old_lru_len
buf_pool->LRU_old_len
Definition: buf0buf.h:159
double pages_readahead_rnd_rate
random readahead rate in pages per second
Definition: buf0buf.h:205
ulint unzip_sum
buf_LRU_stat_sum.unzip
Definition: buf0buf.h:219
ulint n_pages_made_young
number of pages made young
Definition: buf0buf.h:173
ulint n_ra_pages_read
buf_pool->n_ra_pages_read, number of pages readahead
Definition: buf0buf.h:181
ulint n_pages_not_made_young
number of pages not made young
Definition: buf0buf.h:174
ulint n_ra_pages_evicted
buf_pool->n_ra_pages_evicted, number of readahead pages evicted without access
Definition: buf0buf.h:183
ulint n_pages_created
buf_pool->n_pages_created
Definition: buf0buf.h:176
ulint n_pending_flush_list
Pages pending flush in FLUSH LIST.
Definition: buf0buf.h:171
ulint n_page_get_delta
num of buffer pool page gets since last printout
Definition: buf0buf.h:186
ulint free_list_len
Length of buf_pool->free list.
Definition: buf0buf.h:160
double pages_evicted_rate
rate of readahead page evicted without access, in pages per second
Definition: buf0buf.h:209
ulint n_pending_flush_lru
Pages pending flush in LRU.
Definition: buf0buf.h:166
ulint not_young_making_delta
num of pages not make young since last printout
Definition: buf0buf.h:201
ulint n_pend_unzip
buf_pool->n_pend_unzip, pages pending decompress
Definition: buf0buf.h:162
double pages_readahead_rate
readahead rate in pages per second
Definition: buf0buf.h:207
ulint unzip_lru_len
length of buf_pool->unzip_LRU list
Definition: buf0buf.h:213
ulint pool_size
Buffer Pool size in pages.
Definition: buf0buf.h:157
ulint flush_list_len
Length of buf_pool->flush_list.
Definition: buf0buf.h:161
double page_not_made_young_rate
page not made young rate in pages per second
Definition: buf0buf.h:192
ulint n_page_gets
buf_pool->n_page_gets
Definition: buf0buf.h:178
double pages_read_rate
num of pages read per second
Definition: buf0buf.h:194
ulint n_pages_written
buf_pool->n_pages_written
Definition: buf0buf.h:177
ulint n_pending_flush_single_page
Pages pending to be flushed as part of single page flushes issued by various user threads.
Definition: buf0buf.h:167
The buffer pool statistics structure.
Definition: buf0buf.h:2066
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:2099
std::atomic< uint64_t > n_pages_read
Number of read operations.
Definition: buf0buf.h:2075
std::atomic< uint64_t > n_pages_created
number of pages created in the pool with no read.
Definition: buf0buf.h:2081
uint64_t n_pages_made_young
Number of pages made young, in calls to buf_LRU_make_block_young().
Definition: buf0buf.h:2095
uint64_t n_ra_pages_evicted
Number of read ahead pages that are evicted without being accessed.
Definition: buf0buf.h:2091
std::atomic< uint64_t > n_ra_pages_read_rnd
Number of pages read in as part of random read ahead.
Definition: buf0buf.h:2084
uint64_t flush_list_bytes
Flush_list size in bytes.
Definition: buf0buf.h:2105
std::atomic< uint64_t > n_ra_pages_read
Number of pages read in as part of read ahead.
Definition: buf0buf.h:2087
Shards m_n_page_gets
Number of page gets performed; also successful searches through the adaptive hash index are counted a...
Definition: buf0buf.h:2072
uint64_t LRU_bytes
LRU size in bytes.
Definition: buf0buf.h:2102
void reset()
Definition: buf0buf.h:2131
static void copy(buf_pool_stat_t &dst, const buf_pool_stat_t &src) noexcept
Definition: buf0buf.h:2107
std::atomic< uint64_t > n_pages_written
Number of write operations.
Definition: buf0buf.h:2078
The buffer pool structure.
Definition: buf0buf.h:2174
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:2228
hash_table_t * zip_hash
Hash table of buf_block_t blocks whose frames are allocated to the zip buddy system,...
Definition: buf0buf.h:2247
FlushHp flush_hp
"Hazard pointer" used during scan of flush_list while doing flush list batch.
Definition: buf0buf.h:2281
buf_buddy_stat_t buddy_stat[BUF_BUDDY_SIZES_MAX+1]
Statistics of buddy system, indexed by block size.
Definition: buf0buf.h:2260
LRUItr single_scan_itr
Iterator used to scan the LRU list when searching for single page flushing victim.
Definition: buf0buf.h:2354
buf_pool_stat_t old_stat
Old statistics.
Definition: buf0buf.h:2266
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:916
bool try_LRU_scan
Set to false when an LRU scan for free block fails.
Definition: buf0buf.h:2320
ulint buddy_n_frames
Number of frames allocated from the buffer pool to the buddy system.
Definition: buf0buf.h:2215
std::atomic< ulint > n_pend_reads
Number of pending read operations.
Definition: buf0buf.h:2250
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:2346
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:882
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:2256
ulint LRU_old_ratio
Reserve this much of the buffer pool for "old" blocks.
Definition: buf0buf.h:2211
BufListMutex chunks_mutex
protects (de)allocation of chunks:
Definition: buf0buf.h:2183
lsn_t track_page_lsn
Page Tracking start LSN.
Definition: buf0buf.h:2323
BufListMutex zip_free_mutex
buddy allocator mutex
Definition: buf0buf.h:2192
volatile ulint n_chunks
Number of buffer pool chunks.
Definition: buf0buf.h:2219
LRUItr lru_scan_itr
Iterator used to scan the LRU list when searching for replaceable victim.
Definition: buf0buf.h:2350
bool madvise_dump()
Advices the OS that all chunks in this buffer pool instance can be dumped to a core file.
Definition: buf0buf.cc:927
ulint old_size
Previous pool size in pages.
Definition: buf0buf.h:2234
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:2284
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:2362
buf_page_t * watch
Sentinel records for buffer pool watches.
Definition: buf0buf.h:2391
BufListMutex flush_list_mutex
Mutex protecting the flush list access.
Definition: buf0buf.h:2277
ib_mutex_t flush_state_mutex
Flush state protection mutex.
Definition: buf0buf.h:2198
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:2307
buf_chunk_t * chunks
buffer pool chunks
Definition: buf0buf.h:2225
ulint n_flush[BUF_FLUSH_N_TYPES]
This is the number of pending writes in the given flush type.
Definition: buf0buf.h:2295
BufListMutex LRU_list_mutex
LRU list mutex.
Definition: buf0buf.h:2186
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:2243
ulint withdraw_target
Target length of withdraw block list, when withdrawing.
Definition: buf0buf.h:2342
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:2299
buf_pool_stat_t stat
Current statistics.
Definition: buf0buf.h:2263
page_no_t read_ahead_area
Size in pages of the area which the read-ahead algorithms read if invoked.
Definition: buf0buf.h:2238
ulint curr_pool_size
Current pool size in bytes.
Definition: buf0buf.h:2208
bool init_flush[BUF_FLUSH_N_TYPES]
This is true when a flush of the given type is being initialized.
Definition: buf0buf.h:2291
ulint curr_size
Current pool size in pages.
Definition: buf0buf.h:2231
ulint instance_no
Array index of this buffer pool instance.
Definition: buf0buf.h:2205
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:2368
std::atomic< ulint > n_pend_unzip
number of pending decompressions.
Definition: buf0buf.h:2253
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:2326
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:2314
BufListMutex free_list_mutex
free and withdraw list mutex
Definition: buf0buf.h:2189
BufPoolZipMutex zip_mutex
Zip mutex of this buffer pool instance, protects compressed only pages (of type buf_page_t,...
Definition: buf0buf.h:2202
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:937
volatile ulint n_chunks_new
New number of buffer pool chunks.
Definition: buf0buf.h:2222
BufListMutex zip_hash_mutex
zip_hash mutex
Definition: buf0buf.h:2195
The occupied bytes of lists in all buffer pools.
Definition: buf0buf.h:226
ulint LRU_bytes
LRU size in bytes.
Definition: buf0buf.h:227
ulint unzip_LRU_bytes
unzip_LRU size in bytes
Definition: buf0buf.h:228
ulint flush_list_bytes
flush_list size in bytes
Definition: buf0buf.h:229
File space address.
Definition: fil0fil.h:1135
Tablespace or log data space.
Definition: fil0fil.h:231
space_id_t id
Tablespace ID.
Definition: fil0fil.h:327
void dec_ref() noexcept
Decrement the page reference count.
Definition: fil0fil.h:289
uint32_t get_current_version() const
Returns current version of the space object.
Definition: fil0fil.cc:11717
uint32_t get_recent_version() const
Returns current version of the space object.
Definition: fil0fil.cc:11721
bool was_not_deleted() const
Definition: fil0fil.cc:11709
void inc_ref() noexcept
Increment the page reference count.
Definition: fil0fil.h:278
bool is_deleted() const
Definition: fil0fil.cc:11704
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:199
page_zip_t * data
Compressed page data.
Definition: page0types.h:201
The structure used in the spin lock implementation of a read-write lock.
Definition: sync0rw.h:359
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:93
@ RW_NO_LATCH
Definition: sync0rw.h:97
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:1210
@ RW_LOCK_FLAG_SX
Definition: sync0types.h:1211
@ RW_LOCK_FLAG_S
Definition: sync0types.h:1209
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:68
#define ut_d(EXPR)
Debug statement.
Definition: ut0dbg.h:70
#define ut_a(EXPR)
Abort execution if EXPR does not evaluate to nonzero.
Definition: ut0dbg.h:56
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
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