 |
MySQL
8.0.23
Source Code Documentation
|
Go to the documentation of this file.
110 #define BUF_POOL_WATCH_SIZE (srv_n_purge_threads + 1)
118 #ifdef UNIV_HOTBACKUP
234 #ifndef UNIV_HOTBACKUP
330 #ifndef UNIV_HOTBACKUP
359 #ifndef UNIV_HOTBACKUP
363 #define buf_page_get(ID, SIZE, LA, MTR) \
364 buf_page_get_gen(ID, SIZE, LA, NULL, Page_fetch::NORMAL, __FILE__, __LINE__, \
371 #define buf_page_get_with_no_latch(ID, SIZE, MTR) \
372 buf_page_get_gen(ID, SIZE, RW_NO_LATCH, NULL, Page_fetch::NO_LATCH, \
373 __FILE__, __LINE__, MTR)
387 const char *
file, ulint line,
mtr_t *mtr);
411 const char *
file, ulint line,
420 #define buf_page_try_get(page_id, mtr) \
421 buf_page_try_get_func((page_id), __FILE__, __LINE__, mtr);
451 const char *
file, ulint line,
mtr_t *mtr,
452 bool dirty_with_no_latch =
false);
477 #ifndef UNIV_HOTBACKUP
530 MY_ATTRIBUTE((warn_unused_result));
535 MY_ATTRIBUTE((warn_unused_result));
588 const char *
file, ulint line,
616 #ifndef UNIV_HOTBACKUP
627 #define buf_block_buf_fix_inc(b, f, l) buf_block_buf_fix_inc_func(f, l, b)
633 #define buf_block_buf_fix_inc(b, f, l) buf_block_buf_fix_inc_func(b)
636 #define buf_block_modify_clock_inc(block) ((void)0)
639 #ifndef UNIV_HOTBACKUP
654 MY_ATTRIBUTE((warn_unused_result));
672 #if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
677 #if defined UNIV_DEBUG_PRINT || defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
701 #ifndef UNIV_HOTBACKUP
754 #define buf_block_dbg_add_level(block, level)
767 MY_ATTRIBUTE((warn_unused_result));
786 MY_ATTRIBUTE((warn_unused_result));
787 #ifndef UNIV_HOTBACKUP
793 MY_ATTRIBUTE((warn_unused_result));
800 MY_ATTRIBUTE((warn_unused_result));
807 MY_ATTRIBUTE((warn_unused_result));
826 MY_ATTRIBUTE((warn_unused_result));
832 MY_ATTRIBUTE((warn_unused_result));
866 MY_ATTRIBUTE((warn_unused_result));
873 MY_ATTRIBUTE((warn_unused_result));
886 MY_ATTRIBUTE((warn_unused_result));
900 MY_ATTRIBUTE((warn_unused_result));
907 MY_ATTRIBUTE((warn_unused_result));
909 #define buf_block_get_frame(block) (block)->frame
912 #define buf_block_get_frame(block) (block)->frame
916 #define buf_block_get_page_zip(block) \
917 ((block)->page.zip.data ? &(block)->page.zip : NULL)
941 #ifndef UNIV_HOTBACKUP
993 bool owns_sx_lock =
false) noexcept;
999 MY_ATTRIBUTE((warn_unused_result));
1077 #define buf_page_hash_get_s_locked(b, page_id, l) \
1078 buf_page_hash_get_locked(b, page_id, l, RW_LOCK_S)
1079 #define buf_page_hash_get_x_locked(b, page_id, l) \
1080 buf_page_hash_get_locked(b, page_id, l, RW_LOCK_X)
1081 #define buf_page_hash_get(b, page_id) \
1082 buf_page_hash_get_locked(b, page_id, NULL, 0)
1083 #define buf_page_get_also_watch(b, page_id) \
1084 buf_page_hash_get_locked(b, page_id, NULL, 0, true)
1086 #define buf_block_hash_get_s_locked(b, page_id, l) \
1087 buf_block_hash_get_locked(b, page_id, l, RW_LOCK_S)
1088 #define buf_block_hash_get_x_locked(b, page_id, l) \
1089 buf_block_hash_get_locked(b, page_id, l, RW_LOCK_X)
1090 #define buf_block_hash_get(b, page_id) \
1091 buf_block_hash_get_locked(b, page_id, NULL, 0)
1102 MY_ATTRIBUTE((warn_unused_result));
1115 MY_ATTRIBUTE((warn_unused_result));
1122 ulint *flush_list_len);
1160 bool skip_lsn_check);
1179 MY_ATTRIBUTE((warn_unused_result));
1188 MY_ATTRIBUTE((warn_unused_result));
1194 #define BUF_PAGE_STATE_BITS 3
1199 :
std::atomic<uint32_t>(other.
load()) {}
1214 #ifndef UNIV_HOTBACKUP
1222 #ifndef UNIV_HOTBACKUP
1242 #ifndef UNIV_HOTBACKUP
1247 #ifndef UNIV_HOTBACKUP
1266 return id.page_no();
1277 ut_a(m_version <= m_space->get_current_version());
1300 ut_a(was_not_deleted);
1344 if (
id.
space() != UINT32_UNDEFINED) {
1423 "MAX_BUFFER_POOLS > 64; redefine buf_pool_index");
1426 #ifndef UNIV_HOTBACKUP
1483 #ifndef UNIV_HOTBACKUP
1552 #ifndef UNIV_HOTBACKUP
1633 #if defined UNIV_AHI_DEBUG || defined UNIV_DEBUG
1639 #define assert_block_ahi_empty(block) ut_a((block)->n_pointers.load() == 0)
1640 #define assert_block_ahi_empty_on_init(block) \
1642 UNIV_MEM_VALID(&(block)->n_pointers, sizeof(block)->n_pointers); \
1643 assert_block_ahi_empty(block); \
1646 #define assert_block_ahi_valid(block) \
1647 ut_a((block)->index || (block)->n_pointers.load() == 0)
1649 #define assert_block_ahi_empty(block)
1650 #define assert_block_ahi_empty_on_init(block)
1651 #define assert_block_ahi_valid(block)
1675 #ifndef UNIV_HOTBACKUP
1733 MY_ATTRIBUTE((warn_unused_result));
1739 #define buf_block_state_valid(block) \
1740 (buf_block_get_state(block) >= BUF_BLOCK_NOT_USED && \
1741 (buf_block_get_state(block) <= BUF_BLOCK_REMOVE_HASH))
1745 #define BUF_POOL_ZIP_FOLD_PTR(ptr) ((ulint)(ptr) / UNIV_PAGE_SIZE)
1746 #define BUF_POOL_ZIP_FOLD(b) BUF_POOL_ZIP_FOLD_PTR((b)->frame)
1747 #define BUF_POOL_ZIP_FOLD_BPAGE(b) BUF_POOL_ZIP_FOLD((buf_block_t *)(b))
1760 : m_buf_pool(buf_pool)
1834 void adjust(
const buf_page_t *bpage)
override;
1853 void adjust(
const buf_page_t *bpage)
override;
1943 dst.n_pages_read.store(src.n_pages_read.load());
1945 dst.n_pages_written.store(src.n_pages_written.load());
1947 dst.n_pages_created.store(src.n_pages_created.load());
1949 dst.n_ra_pages_read_rnd.store(src.n_ra_pages_read_rnd.load());
1951 dst.n_ra_pages_read.store(src.n_ra_pages_read.load());
1953 dst.n_ra_pages_evicted = src.n_ra_pages_evicted;
1955 dst.n_pages_made_young = src.n_pages_made_young;
1957 dst.n_pages_not_made_young = src.n_pages_not_made_young;
1959 dst.LRU_bytes = src.LRU_bytes;
1961 dst.flush_list_bytes = src.flush_list_bytes;
1968 n_pages_written = 0;
1969 n_pages_created = 0;
1970 n_ra_pages_read_rnd = 0;
1971 n_ra_pages_read = 0;
1972 n_ra_pages_evicted = 0;
1973 n_pages_made_young = 0;
1974 n_pages_not_made_young = 0;
1976 flush_list_bytes = 0;
1998 return {used.load(), relocated, relocated_usec};
2218 #if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
2240 bool allocate_chunk(
ulonglong mem_size, buf_chunk_t *chunk);
2248 void deallocate_chunk(buf_chunk_t *chunk);
2254 bool madvise_dump();
2260 bool madvise_dont_dump();
2262 #if BUF_BUDDY_LOW > UNIV_ZIP_SIZE_MIN
2263 #error "BUF_BUDDY_LOW > UNIV_ZIP_SIZE_MIN"
2278 #ifndef UNIV_HOTBACKUP
2280 #define buf_flush_list_mutex_own(b) mutex_own(&(b)->flush_list_mutex)
2283 #define buf_flush_list_mutex_enter(b) \
2285 mutex_enter(&(b)->flush_list_mutex); \
2288 #define buf_flush_list_mutex_exit(b) \
2290 mutex_exit(&(b)->flush_list_mutex); \
2294 #define buf_page_mutex_enter(b) \
2296 mutex_enter(&(b)->mutex); \
2300 #define buf_page_mutex_exit(b) \
2302 (b)->mutex.exit(); \
2306 #define buf_page_hash_lock_get(buf_pool, page_id) \
2307 hash_get_lock((buf_pool)->page_hash, (page_id).fold())
2310 #define buf_page_hash_lock_s_confirm(hash_lock, buf_pool, page_id) \
2311 hash_lock_s_confirm(hash_lock, (buf_pool)->page_hash, (page_id).fold())
2313 #define buf_page_hash_lock_x_confirm(hash_lock, buf_pool, page_id) \
2314 hash_lock_x_confirm(hash_lock, (buf_pool)->page_hash, (page_id).fold())
2317 #if defined(UNIV_DEBUG) && !defined(UNIV_HOTBACKUP)
2319 #define buf_page_hash_lock_held_s(buf_pool, bpage) \
2320 rw_lock_own(buf_page_hash_lock_get((buf_pool), (bpage)->id), RW_LOCK_S)
2323 #define buf_page_hash_lock_held_x(buf_pool, bpage) \
2324 rw_lock_own(buf_page_hash_lock_get((buf_pool), (bpage)->id), RW_LOCK_X)
2327 #define buf_page_hash_lock_held_s_or_x(buf_pool, bpage) \
2328 (buf_page_hash_lock_held_s((buf_pool), (bpage)) || \
2329 buf_page_hash_lock_held_x((buf_pool), (bpage)))
2331 #define buf_block_hash_lock_held_s(buf_pool, block) \
2332 buf_page_hash_lock_held_s((buf_pool), &(block)->page)
2334 #define buf_block_hash_lock_held_x(buf_pool, block) \
2335 buf_page_hash_lock_held_x((buf_pool), &(block)->page)
2337 #define buf_block_hash_lock_held_s_or_x(buf_pool, block) \
2338 buf_page_hash_lock_held_s_or_x((buf_pool), &(block)->page)
2340 #define buf_page_hash_lock_held_s(b, p) (TRUE)
2341 #define buf_page_hash_lock_held_x(b, p) (TRUE)
2342 #define buf_page_hash_lock_held_s_or_x(b, p) (TRUE)
2343 #define buf_block_hash_lock_held_s(b, p) (TRUE)
2344 #define buf_block_hash_lock_held_x(b, p) (TRUE)
2345 #define buf_block_hash_lock_held_s_or_x(b, p) (TRUE)
2394 #if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
2395 #ifndef UNIV_HOTBACKUP
2430 #ifndef UNIV_HOTBACKUP
2434 bpage->reset_page_id();
2438 #include "buf0buf.ic"
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:4876
uint32 page_no_t
Page number.
Definition: api0api.h:57
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:941
UNIV_INLINE bool buf_page_belongs_to_unzip_LRU(const buf_page_t *bpage)
Determines if a block should be on unzip_LRU list.
constexpr ulint FIL_PAGE_DATA
start of the data on the page
Definition: fil0types.h:110
LRUItr single_scan_itr
Iterator used to scan the LRU list when searching for single page flushing victim.
Definition: buf0buf.h:2192
uint64_t lsn_t
Type used for all log sequence number storage and arithmetics.
Definition: log0types.h:60
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:2206
buf_page_print_flags
Definition: buf0buf.h:682
@ POSSIBLY_FREED
Like Page_fetch::NORMAL, but do not mind if the file page has been freed.
fil_space_t * get_space() const
Retrieve the tablespace object if one was available during page ID initialization.
Definition: buf0buf.h:1313
UNIV_INLINE buf_io_fix buf_block_get_io_fix_unlocked(const buf_block_t *block)
Gets the io_fix state of a buffer block.
UNIV_INLINE void buf_page_set_sticky(buf_page_t *bpage)
Makes a block sticky.
UNIV_INLINE ibool 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...
static uint64_t lsn
Definition: xcom_base.cc:429
buf_chunk_t * chunks_old
old buffer pool chunks to be freed after resizing buffer pool
Definition: buf0buf.h:2063
virtual void adjust(const buf_page_t *bpage)=0
Adjust the value of hp.
void buf_pool_watch_unset(const page_id_t &page_id)
Stop watching if the page has been read in.
Definition: buf0buf.cc:2909
std::atomic< ulint > n_pend_unzip
number of pending decompressions.
Definition: buf0buf.h:2091
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:1523
ulint LRU_bytes
LRU size in bytes.
Definition: buf0buf.h:229
UNIV_INLINE ulint buf_page_get_freed_page_clock(const buf_page_t *bpage)
Reads the freed_page_clock of a buffer block.
lsn_t buf_pool_get_oldest_modification_lwm(void)
Gets a safe low watermark for oldest_modification.
Definition: buf0buf.cc:410
@ BUF_PAGE_PRINT_NO_FULL
Do not print the full page dump.
Definition: buf0buf.h:686
#define FIL_PAGE_PREV
if there is a 'natural' predecessor of the page, its offset.
Definition: fil0types.h:50
BufListMutex LRU_list_mutex
LRU list mutex.
Definition: buf0buf.h:2019
void operator()(const buf_block_t *elem) const
Definition: buf0buf.h:2417
bool in_withdraw_list
Definition: buf0buf.h:1571
ulint unzip_sum
buf_LRU_stat_sum.unzip
Definition: buf0buf.h:221
#define BUF_BUDDY_SIZES_MAX
Maximum number of buddy sizes based on the max page size.
Definition: buf0types.h:151
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...
HazardPointer(const HazardPointer &)
Disable copying.
@ PEEK_IF_IN_POOL
get if in pool, do not make the block young in the LRU list
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...
double pages_readahead_rnd_rate
random readahead rate in pages per second
Definition: buf0buf.h:207
ulint pool_size
Buffer Pool size in pages.
Definition: buf0buf.h:159
ib_time_monotonic_t last_printout_time
when buf_print_io was last time called.
Definition: buf0buf.h:2094
UNIV_INLINE void buf_block_modify_clock_inc(buf_block_t *block)
Increment the modify clock.
@ 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...
volatile uint32_t n_bytes
Recommended prefix length for hash search: number of bytes in an incomplete last field.
Definition: buf0buf.h:1589
void reset_flush_observer() noexcept
Remove the flush observer.
Definition: buf0buf.h:1369
lsn_t track_page_lsn
Page Tracking start LSN.
Definition: buf0buf.h:2161
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:3007
ut_allocator< unsigned char > allocator
Allocator used for allocating memory for the the "chunks" member.
Definition: buf0buf.h:2051
void buf_get_total_list_len(ulint *LRU_len, ulint *free_len, ulint *flush_list_len)
Get total buffer pool statistics.
Definition: buf0buf.cc:441
uint64_t relocated
Definition: buf0buf.h:1993
buf_chunk_t * chunks
buffer pool chunks
Definition: buf0buf.h:2060
lsn_t oldest_modification
log sequence number of the youngest modification to this block, zero if not modified.
Definition: buf0buf.h:1460
@ BUF_BLOCK_POOL_WATCH
A sentinel for the buffer pool watch, element of buf_pool->watch[].
Definition: buf0buf.h:131
UNIV_INLINE ulint buf_pool_get_curr_size(void)
Gets the current size of buffer buf_pool in bytes.
@ 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.
Class implementing buf_pool->LRU hazard pointer.
Definition: buf0buf.h:1838
#define ut_a(EXPR)
Abort execution if EXPR does not evaluate to nonzero.
Definition: ut0dbg.h:54
UNIV_INLINE 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.
#define ut_ad(EXPR)
Debug assertion.
Definition: ut0dbg.h:66
ulint free_list_len
Length of buf_pool->free list.
Definition: buf0buf.h:162
UNIV_INLINE ulint buf_block_fix(buf_page_t *bpage)
Increments the bufferfix count.
void buf_pool_invalidate(void)
Invalidates the file pages in the buffer pool when an archive recovery is completed.
Definition: buf0buf.cc:5669
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:2152
Shards m_n_page_gets
Number of page gets performed; also successful searches through the adaptive hash index are counted a...
Definition: buf0buf.h:1905
ulint n_pages_created
buf_pool->n_pages_created
Definition: buf0buf.h:178
Data structure for an index.
Definition: dict0mem.h:879
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:1700
uint32_t lock_hash_val
hashed value of the page address in the record lock hash table; protected by buf_block_t::lock (or bu...
Definition: buf0buf.h:1577
BPageLock lock
read-write lock of the buffer frame
Definition: buf0buf.h:1554
Mini-transaction handle and buffer.
Definition: mtr0mtr.h:169
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:6119
snapshot_t take_snapshot()
Definition: buf0buf.h:1997
InnoDB condition variable.
Definition: os0event.cc:66
page_no_t get_next_page_no() const
Get the next page number of the current buffer block.
Definition: buf0buf.h:1714
constexpr ulint MAX_PAGE_HASH_LOCKS
The maximum number of page_hash locks.
Definition: buf0buf.h:113
HazardPointer(const buf_pool_t *buf_pool, const ib_mutex_t *mutex)
Constructor.
Definition: buf0buf.h:1759
void operator()(const buf_page_t *elem) const
Definition: buf0buf.h:2408
UNIV_INLINE 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.
@ BUF_FLUSH_N_TYPES
Index of last element + 1
Definition: buf0types.h:76
ulint n_page_get_delta
num of buffer pool page gets since last printout
Definition: buf0buf.h:188
void buf_pool_free_all()
Frees the buffer pool at shutdown.
Definition: buf0buf.cc:6580
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:4300
UNIV_INLINE enum buf_io_fix buf_page_get_io_fix(const buf_page_t *bpage)
Gets the io_fix state of a block.
#define free(A)
Definition: fts0ast.h:42
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:1666
ulint buddy_n_frames
Number of frames allocated from the buffer pool to the buddy system.
Definition: buf0buf.h:2048
ib_bpmutex_t BPageMutex
Definition: buf0types.h:159
bool is_deleted() const
Definition: fil0fil.cc:12149
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:4396
ulint io_sum
buf_LRU_stat_sum.io
Definition: buf0buf.h:218
buf_page_t * buf_page_init_for_read(dberr_t *err, ulint mode, const page_id_t &page_id, const page_size_t &page_size, ibool unzip)
Inits a page for read to the buffer buf_pool.
Definition: buf0buf.cc:4673
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:5279
void buf_resize_thread()
This is the thread for resizing buffer pool.
Definition: buf0buf.cc:2504
bool old
true if the block is in the old blocks in buf_pool->LRU_old
Definition: buf0buf.h:1509
LRUItr lru_scan_itr
Iterator used to scan the LRU list when searching for replaceable victim.
Definition: buf0buf.h:2188
UNIV_INLINE uint64_t buf_block_get_modify_clock(const buf_block_t *block)
Read the modify clock.
LRUHp lru_hp
"hazard pointer" used during scan of LRU while doing LRU list batch.
Definition: buf0buf.h:2184
UNIV_INLINE 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_gen(const page_id_t &page_id, const page_size_t &page_size, ulint rw_latch, buf_block_t *guess, Page_fetch mode, const char *file, ulint line, 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:4234
double page_made_young_rate
page made young rate in pages per second
Definition: buf0buf.h:192
ulint old_size
Previous pool size in pages.
Definition: buf0buf.h:2069
uint64_t relocated
Number of blocks relocated by the buddy system.
Definition: buf0buf.h:1986
FlushHp oldest_hp
Entry pointer to scan the oldest page except for system temporary.
Definition: buf0buf.h:2122
buf_block_t * buf_block_from_ahi(const byte *ptr)
Get a buffer block from an adaptive hash index pointer.
Definition: buf0buf.cc:3307
Definition: buf0buf.h:1196
dberr_t
Definition: db0err.h:38
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:1493
buf_page_t(const buf_page_t &other)
Copy constructor.
Definition: buf0buf.h:1206
@ IF_IN_POOL
get if in pool
static void validate(const buf_pool_t *buf_pool)
Definition: buf0buf.h:2422
ib_mutex_t BufListMutex
Definition: buf0types.h:160
UNIV_INLINE void buf_page_set_old(buf_page_t *bpage, ibool old)
Flag a block old.
@ SRV_SHUTDOWN_EXIT_THREADS
Exit all threads and free resources.
Definition: srv0shutdown.h:110
FlushObserver * get_flush_observer() noexcept
Definition: buf0buf.h:1357
ulint instance_no
Array index of this buffer pool instance.
Definition: buf0buf.h:2038
Struct that is embedded in the free zip blocks.
Definition: buf0buf.h:1879
buf_page_state
States of a control block.
Definition: buf0buf.h:129
uint64_t n_ra_pages_evicted
Number of read ahead pages that are evicted without being accessed.
Definition: buf0buf.h:1924
The buffer control block structure.
Definition: buf0buf.h:1544
void reset()
Definition: buf0buf.h:1964
ulint curr_size
Current pool size in pages.
Definition: buf0buf.h:2066
lsn_t newest_modification
The flush LSN, LSN when this page was written to the redo log.
Definition: buf0buf.h:1456
UNIV_INLINE uint16_t mach_read_from_2(const byte *b)
The following function is used to fetch data from 2 consecutive bytes.
ulint buf_pool_check_no_pending_io(void)
Checks that there currently are no pending i/o-operations for the buffer pool.
Definition: buf0buf.cc:6471
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:5132
ulint page_read_delta
num of pages read since last printout
Definition: buf0buf.h:199
ulint unzip_cur
buf_LRU_stat_cur.unzip, num pages decompressed in current interval
Definition: buf0buf.h:222
uint64_t LRU_bytes
LRU size in bytes.
Definition: buf0buf.h:1935
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:1681
UNIV_INLINE ibool 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...
UNIV_INLINE void buf_page_unset_sticky(buf_page_t *bpage)
Removes stickiness of a block.
UNIV_INLINE buf_page_t * buf_page_alloc_descriptor(void)
Allocates a buf_page_t descriptor.
#define mutex_own(M)
Checks that the current thread owns the mutex.
Definition: ut0mutex.h:153
const page_id_t & get_page_id() const
Get the page number and space id of the current buffer block.
Definition: buf0buf.h:1706
dberr_t buf_pool_init(ulint total_size, ulint n_instances)
Creates the buffer pool.
Definition: buf0buf.cc:1450
uint16_t m_dblwr_id
Double write instance ordinal value during writes.
Definition: buf0buf.h:1506
ulint unzip_lru_len
length of buf_pool->unzip_LRU list
Definition: buf0buf.h:215
bool curr_left_side
TRUE or FALSE in hash indexing.
Definition: buf0buf.h:1661
buf_flush_t
Flags for flush types.
Definition: buf0types.h:65
FlushHp(const buf_pool_t *buf_pool, const ib_mutex_t *mutex)
Constructor.
Definition: buf0buf.h:1824
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:1109
~LRUHp() override
Destructor.
Definition: buf0buf.h:1847
static Value err()
Create a Value object that represents an error condition.
Definition: json_binary.cc:908
volatile bool left_side
true or false, depending on whether the leftmost record of several records with the same prefix shoul...
Definition: buf0buf.h:1596
const ib_mutex_t * m_mutex
mutex that protects access to the m_hp.
Definition: buf0buf.h:1811
static void start(mysql_harness::PluginFuncEnv *env)
Definition: http_auth_backend_plugin.cc:161
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:357
ulint buf_get_latched_pages_number(void)
Returns the number of latched pages in the buffer pool.
Definition: buf0buf.cc:6086
fil_space_t * m_space
Tablespace instance that this page belongs to.
Definition: buf0buf.h:1488
Tablespace or log data space.
Definition: fil0fil.h:220
lock_mode
Definition: lock0types.h:51
buf_page_t * hash
Node used in chaining to buf_pool->page_hash or buf_pool->zip_hash.
Definition: buf0buf.h:1423
Compressed page descriptor.
Definition: page0types.h:182
Provides atomic access in shared-exclusive modes.
Definition: shared_spin_lock.h:78
int n
Definition: xcom_base.cc:445
ulint young_making_delta
num of pages made young since last printout
Definition: buf0buf.h:201
ulint n_page_gets
buf_pool->n_page_gets
Definition: buf0buf.h:180
ulint LRU_old_ratio
Reserve this much of the buffer pool for "old" blocks.
Definition: buf0buf.h:2044
LRUItr(const buf_pool_t *buf_pool, const ib_mutex_t *mutex)
Constructor.
Definition: buf0buf.h:1865
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:1527
UNIV_INLINE void buf_page_release_latch(buf_block_t *block, ulint rw_latch)
Releases a latch, if specified.
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:1481
#define malloc(A)
Definition: fts0ast.h:41
page_no_t page_no() const noexcept
Retrieve the page number.
Definition: buf0buf.h:1265
ulint curr_pool_size
Current pool size in bytes.
Definition: buf0buf.h:2041
Page_fetch
Definition: buf0buf.h:59
page_no_t get_prev_page_no() const
Get the prev page number of the current buffer block.
Definition: buf0buf.h:1720
buf_page_t * watch
Sentinel records for buffer pool watches.
Definition: buf0buf.h:2229
double pages_read_rate
num of pages read per second
Definition: buf0buf.h:196
UNIV_INLINE 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,...
uint16_t curr_n_fields
prefix length for hash indexing: number of full fields
Definition: buf0buf.h:1655
page_size_t size
Page size.
Definition: buf0buf.h:1404
void inc_ref() noexcept
Increment the page reference count.
Definition: fil0fil.h:267
UNIV_INLINE ibool buf_page_peek(const page_id_t &page_id)
Returns TRUE if the page can be found in the buffer pool hash table.
Definition: buf0buf.h:1202
lsn_t get_oldest_lsn() const noexcept
Definition: buf0buf.h:1377
byte buf_frame_t
A buffer frame.
Definition: buf0types.h:59
UT_LIST_BASE_NODE_T(buf_page_t) withdraw
base node of the withdraw block list.
ulint n_ra_pages_read
buf_pool->n_ra_pages_read, number of pages readahead
Definition: buf0buf.h:183
BufListMutex free_list_mutex
free and withdraw list mutex
Definition: buf0buf.h:2022
void reset_page_id(page_id_t new_page_id)
Sets stored page ID to the new value.
Definition: buf0buf.h:1318
ulint io_cur
buf_LRU_stat_cur.io, num of IO for current interval
Definition: buf0buf.h:219
space_id_t id
Tablespace ID.
Definition: fil0fil.h:306
UNIV_INLINE ulint buf_pool_get_n_pages(void)
Gets the current size of buffer buf_pool in frames.
ulint n_pend_reads
buf_pool->n_pend_reads, pages pending read
Definition: buf0buf.h:166
UNIV_INLINE buf_pool_t * buf_pool_from_array(ulint index)
Returns the buffer pool instance given its array index.
UNIV_INLINE void buf_page_set_accessed(buf_page_t *bpage)
Flag a block accessed.
Definition: hash0hash.h:403
void reset_page_id()
Sets stored value to invalid/empty value.
Definition: buf0buf.h:1334
dict_index_t * index
Index for which the adaptive hash index has been created, or NULL if the page does not exist in the i...
Definition: buf0buf.h:1672
ulint n_pages_read
buf_pool->n_pages_read
Definition: buf0buf.h:177
@ BUF_BLOCK_READY_FOR_USE
When buf_LRU_get_free_block returns a block, it is in this state.
Definition: buf0buf.h:142
Page size descriptor.
Definition: page0size.h:49
static mysql_service_status_t validate(reference_caching_channel channel) noexcept
Definition: component.cc:66
void ut_list_validate(const List &list, Functor &functor)
Checks the consistency of a two-way list.
Definition: ut0lst.h:377
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:1721
UNIV_INLINE void buf_page_set_flush_type(buf_page_t *bpage, buf_flush_t flush_type)
Set the flush type of a page.
ulonglong buf_pool_adjust_chunk_unit(ulonglong size)
Adjust the proposed chunk unit size so that it satisfies all invariants.
Definition: buf0buf.cc:1995
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:1550
buf_page_t * m_hp
hazard pointer.
Definition: buf0buf.h:1815
ulint n_pending_flush_lru
Pages pending flush in LRU.
Definition: buf0buf.h:168
BPageMutex BufPoolZipMutex
Definition: buf0types.h:162
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:1695
uint32_t m_version
Version of fil_space_t when the page was updated.
Definition: buf0buf.h:1502
This structure defines information we will fetch from each buffer pool.
Definition: buf0buf.h:156
UNIV_INLINE uint32_t mach_read_from_4(const byte *b)
The following function is used to fetch data from 4 consecutive bytes.
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:1932
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:3033
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:2078
BufListMutex chunks_mutex
protects (de)allocation of chunks:
Definition: buf0buf.h:2016
bool in_LRU_list
true if the page is in the LRU list; used in debugging
Definition: buf0buf.h:1530
Functor to validate the LRU list.
Definition: buf0buf.h:2407
virtual ~HazardPointer()
Destructor.
Definition: buf0buf.h:1770
UNIV_INLINE ibool buf_page_can_relocate(const buf_page_t *bpage)
Determine if a buffer block can be relocated in memory.
A "Hazard Pointer" class used to iterate over page lists inside the buffer pool.
Definition: buf0buf.h:1754
UNIV_INLINE void buf_page_set_state(buf_page_t *bpage, enum buf_page_state state)
Sets the state of a block.
int page
Definition: ctype-mb.cc:1234
std::atomic< uint64_t > n_pages_written
Number of write operations.
Definition: buf0buf.h:1911
UT_LIST_NODE_T(buf_page_t) LRU
node of the LRU list
fil_space_t * fil_space_get(space_id_t space_id)
Look up a tablespace.
Definition: fil0fil.cc:2323
ulint n_pages_not_made_young
number of pages not made young
Definition: buf0buf.h:176
static void copy(buf_pool_stat_t &dst, const buf_pool_stat_t &src) noexcept
Definition: buf0buf.h:1940
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:169
ulint n_pending_flush_list
Pages pending flush in FLUSH LIST.
Definition: buf0buf.h:173
bool in_page_hash
true if in buf_pool->page_hash
Definition: buf0buf.h:1533
ulint buf_get_free_list_len(void)
Gets the current length of the free list of buffer blocks.
UNIV_INLINE void buf_block_buf_fix_inc_func(const char *file, ulint line, buf_block_t *block)
Increments the bufferfix count.
const buf_pool_t * m_buf_pool
Buffer pool instance.
Definition: buf0buf.h:1807
void set_clean() noexcept
Set page to clean state.
Definition: buf0buf.h:1391
~FlushHp() override
Destructor.
Definition: buf0buf.h:1828
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:306
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:2200
void set_flush_observer(FlushObserver *flush_observer) noexcept
Set the flush observer for the page.
Definition: buf0buf.h:1361
buf_pool_t * buf_pool_ptr
The buffer pools of the database.
Definition: buf0buf.cc:295
std::atomic< ulint > used
Number of blocks allocated from the buddy system.
Definition: buf0buf.h:1983
void buf_print_io(FILE *file)
Prints info of the buffer i/o.
Definition: buf0buf.cc:6386
uint32_t get_current_version() const
Returns current version of the space object.
Definition: fil0fil.cc:12162
ulint n_ra_pages_read_rnd
buf_pool->n_ra_pages_read_rnd, number of pages readahead
Definition: buf0buf.h:181
HazardPointer & operator=(const HazardPointer &)
uint32_t access_time
Time of first access, or 0 if the block was never accessed in the buffer pool.
Definition: buf0buf.h:1498
UT_LIST_BASE_NODE_T(buf_page_t) zip_clean
Unmodified compressed pages.
UNIV_INLINE void buf_block_set_file_page(buf_block_t *block, const page_id_t &page_id)
Map a block to a file page.
uint64_t n_pages_made_young
Number of pages made young, in calls to buf_LRU_make_block_young().
Definition: buf0buf.h:1928
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:1514
ulint lru_len
Length of buf_pool->LRU.
Definition: buf0buf.h:160
UNIV_INLINE buf_pool_t * buf_pool_get(const page_id_t &page_id)
Returns the buffer pool instance given a page id.
UNIV_INLINE void buf_page_set_io_fix(buf_page_t *bpage, enum buf_io_fix io_fix)
Sets the io_fix state of a block.
hash_table_t * zip_hash
Hash table of buf_block_t blocks whose frames are allocated to the zip buddy system,...
Definition: buf0buf.h:2085
page_no_t read_ahead_area
Size in pages of the area which the read-ahead algorithms read if invoked.
Definition: buf0buf.h:2073
uint32_t n_hash_helps
Counter which controls building of a new hash index for the page.
Definition: buf0buf.h:1585
UT_LIST_BASE_NODE_T(buf_page_t) LRU
Base node of the LRU list.
ulint withdraw_target
Target length of withdraw block list, when withdrawing.
Definition: buf0buf.h:2180
uint8_t buf_pool_index
Index number of the buffer pool that this block belongs to.
Definition: buf0buf.h:1420
buf_pool_stat_t old_stat
Old statistics.
Definition: buf0buf.h:2104
#define FIL_PAGE_TYPE
file page type: FIL_PAGE_INDEX,..., 2 bytes.
Definition: fil0types.h:75
const buf_block_t * buf_page_try_get_func(const page_id_t &page_id, const char *file, ulint line, mtr_t *mtr)
Given a tablespace id and page number tries to get that page.
Definition: buf0buf.cc:4488
buf_fix_count_atomic_t buf_fix_count
Count of how many fold this block is currently bufferfixed.
Definition: buf0buf.h:1407
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:5334
void buf_page_prepare_for_free(buf_page_t *bpage) noexcept
Prepare a page before adding to the free list.
Definition: buf0buf.h:2433
double pages_evicted_rate
rate of readahead page evicted without access, in pages per second
Definition: buf0buf.h:211
bool in_unzip_LRU_list
TRUE if the page is in the decompressed LRU list; used in debugging.
Definition: buf0buf.h:1569
flush_type
Definition: my_sys.h:293
const std::string FILE("FILE")
The occupied bytes of lists in all buffer pools.
Definition: buf0buf.h:228
lsn_t get_newest_lsn() const noexcept
Definition: buf0buf.h:1373
const char * get_page_type_str() const noexcept
Get the page type of the current buffer block as string.
Definition: buf0buf.cc:6573
rw_lock_type_t
Definition: sync0rw.h:135
UNIV_INLINE ulint buf_block_unfix(buf_page_t *bpage)
Decrements the bufferfix count.
bool in_zip_hash
true if in buf_pool->zip_hash
Definition: buf0buf.h:1536
@ BUF_PAGE_PRINT_NO_CRASH
Do not crash at the end of buf_page_print().
Definition: buf0buf.h:684
ulint size
size of the block
Definition: buf0buf.h:1881
The buffer pool statistics structure.
Definition: buf0buf.h:1899
UNIV_INLINE 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.
Definition: buf0block_hint.cc:29
@ BUF_BLOCK_MEMORY
Contains some main memory object.
Definition: buf0buf.h:148
UT_LIST_BASE_NODE_T(buf_page_t) flush_list
Base node of the modified block list.
constexpr ulint MAX_BUFFER_POOLS_BITS
Number of bits to representing a buffer pool ID.
Definition: buf0buf.h:104
UNIV_INLINE enum buf_io_fix buf_block_get_io_fix(const buf_block_t *block)
Gets the io_fix state of a block.
@ BUF_BLOCK_REMOVE_HASH
Hash index should be removed before putting to the free list.
Definition: buf0buf.h:151
#define FIL_PAGE_NEXT
if there is a 'natural' successor of the page, its offset.
Definition: fil0types.h:60
uint64_t relocated_usec
Definition: buf0buf.h:1994
Page identifier.
Definition: buf0types.h:168
BufPoolZipMutex zip_mutex
Zip mutex of this buffer pool instance, protects compressed only pages (of type buf_page_t,...
Definition: buf0buf.h:2035
ibool 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:2754
@ SCAN
Same as NORMAL, but hint that the fetch is part of a large scan.
bool buf_page_free_stale(buf_pool_t *buf_pool, buf_page_t *bpage) noexcept
Free a stale page.
Definition: buf0buf.cc:5196
UNIV_INLINE buf_pool_t * buf_pool_from_block(const buf_block_t *block)
Returns the buffer pool instance given a block instance.
@ BUF_BLOCK_ZIP_DIRTY
Contains a compressed page that is in the buf_pool->flush_list.
Definition: buf0buf.h:135
ulint n_pages_made_young
number of pages made young
Definition: buf0buf.h:175
double pages_created_rate
num of pages create per second
Definition: buf0buf.h:197
ulint used
Definition: buf0buf.h:1992
std::atomic< uint64_t > n_pages_read
Number of read operations.
Definition: buf0buf.h:1908
void dec_ref() noexcept
Decrement the page reference count.
Definition: fil0fil.h:273
UNIV_INLINE BPageMutex * buf_page_get_mutex(const buf_page_t *bpage)
Gets the mutex of a block.
BPageMutex mutex
mutex protecting this block: state (also protected by the buffer pool mutex), io_fix,...
Definition: buf0buf.h:1702
UNIV_INLINE buf_frame_t * buf_frame_align(byte *ptr)
uint64_t flush_list_bytes
Flush_list size in bytes.
Definition: buf0buf.h:1938
uint16_t page_type_t
Definition: fil0fil.h:1199
std::atomic< uint64_t > n_pages_created
number of pages created in the pool with no read.
Definition: buf0buf.h:1914
ibool buf_pool_watch_occurred(const page_id_t &page_id)
Check if the page has been read in.
Definition: buf0buf.cc:2936
@ KEEP_OLD
Preserve the current LRU position of the block.
UNIV_INLINE 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.
UNIV_INLINE enum buf_page_state buf_block_get_state(const buf_block_t *block)
Gets the state of a block.
Red black tree instance.
Definition: ut0rbt.h:74
constexpr ulint MAX_BUFFER_POOLS
The maximum number of buffer pools that can be defined.
Definition: buf0buf.h:107
UNIV_INLINE enum buf_page_state buf_page_get_state(const buf_page_t *bpage)
Gets the state of a block.
UNIV_INLINE void buf_block_set_io_fix(buf_block_t *block, enum buf_io_fix io_fix)
Sets the io_fix state of a block.
ulint old_lru_len
buf_pool->LRU_old_len
Definition: buf0buf.h:161
UNIV_INLINE 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.
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:2145
ulint buf_get_n_pending_read_ios(void)
Returns the number of pending buf pool read ios.
Definition: buf0buf.cc:6105
void buf_page_make_young(buf_page_t *bpage)
Moves a page to the start of the buffer pool LRU list.
Definition: buf0buf.cc:2961
std::atomic< uint64_t > n_ra_pages_read
Number of pages read in as part of read ahead.
Definition: buf0buf.h:1920
UNIV_INLINE enum buf_io_fix buf_page_get_io_fix_unlocked(const buf_page_t *bpage)
Gets the io_fix state of a buffer page.
Definition: buf0buf.h:1991
UNIV_INLINE ulint buf_block_get_freed_page_clock(const buf_block_t *block)
Reads the freed_page_clock of a buffer block.
ibool buf_zip_decompress(buf_block_t *block, ibool check)
Decompress a block.
Definition: buf0buf.cc:3238
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:461
constexpr value_type set
Definition: classic_protocol_constants.h:271
UNIV_INLINE ibool buf_page_in_file(const buf_page_t *bpage)
Determines if a block is mapped to a tablespace.
Definition: varlen_sort.h:182
UNIV_INLINE buf_pool_t * buf_pool_from_bpage(const buf_page_t *bpage)
Returns the buffer pool instance given a page instance.
ulint flush_list_len
Length of buf_pool->flush_list.
Definition: buf0buf.h:163
ib_mutex_t flush_state_mutex
Flush state protection mutex.
Definition: buf0buf.h:2031
buf_page_state state
Block state.
Definition: buf0buf.h:1413
static void validate(const buf_pool_t *buf_pool)
Definition: buf0buf.h:2410
UNIV_INLINE unsigned buf_page_is_accessed(const buf_page_t *bpage)
Determine the time of first access of a block in the buffer pool.
uint32_t get_recent_version() const
Returns current version of the space object.
Definition: fil0fil.cc:12166
UNIV_INLINE ulint buf_pool_index(const buf_pool_t *buf_pool)
Calculates the index of a buffer pool to the buf_pool[] array.
bool was_not_deleted() const
Definition: fil0fil.cc:12154
UNIV_INLINE buf_frame_t * buf_block_get_frame(const buf_block_t *block)
Gets a pointer to the memory frame of a block.
UNIV_INLINE ulint buf_block_get_lock_hash_val(const buf_block_t *block)
Gets the hash value of a block.
@ BUF_BLOCK_ZIP_PAGE
Contains a clean compressed page.
Definition: buf0buf.h:133
UNIV_INLINE byte * buf_frame_copy(byte *buf, const buf_frame_t *frame)
Copies contents of a buffer frame to a given buffer.
bool is_dirty() const noexcept
Definition: buf0buf.h:1380
void buf_get_total_stat(buf_pool_stat_t *tot_stat)
Get total buffer pool statistics.
Definition: buf0buf.cc:482
bool is_stale() const
Checks if this space reference saved during last page ID initialization was deleted or truncated sinc...
Definition: buf0buf.h:1274
volatile uint32_t n_fields
Recommended prefix length for hash search: number of full fields.
Definition: buf0buf.h:1592
buf_page_t * get() const
Get current value.
Definition: buf0buf.h:1773
space_id_t space() const noexcept
Retrieve the tablespace id.
Definition: buf0buf.h:1259
uint16_t curr_n_bytes
number of bytes in hash indexing
Definition: buf0buf.h:1658
void set_oldest_lsn(lsn_t lsn) noexcept
Set the LSN when the page is modified for the first time.
UT_LIST_BASE_NODE_T(buf_block_t) unzip_LRU
Base node of the unzip_LRU list.
void buf_must_be_all_freed(void)
Assert that all file pages in the buffer are in a replaceable state.
Definition: buf0buf.cc:6458
double pages_written_rate
num of pages written per second
Definition: buf0buf.h:198
void copy(Shards< COUNT > &dst, const Shards< COUNT > &src) noexcept
Copy the counters, overwrite destination.
Definition: ut0counter.h:353
Cache_hint
Definition: buf0buf.h:92
@ NO_LATCH
get and bufferfix, but set no latch; we have separated this case, because it is error-prone programmi...
void buf_print(void)
Prints info of the buffer pool data structure.
Definition: buf0buf.cc:5989
bool try_LRU_scan
Set to false when an LRU scan for free block fails.
Definition: buf0buf.h:2158
UT_LIST_BASE_NODE_T(buf_buddy_free_t) zip_free[BUF_BUDDY_SIZES_MAX]
Buddy free lists.
ulint not_young_making_delta
num of pages not make young since last printout
Definition: buf0buf.h:203
uint32 space_id_t
Tablespace identifier.
Definition: api0api.h:59
buf_io_fix io_fix
Type of pending I/O operation.
Definition: buf0buf.h:1410
The structure used in the spin lock implementation of a read-write lock.
Definition: sync0rw.h:568
ulint flush_list_bytes
flush_list size in bytes
Definition: buf0buf.h:231
void space_id_changed()
Updates new space reference and acquires "reference count latch" and the current version of the space...
Definition: buf0buf.h:1341
Class implementing buf_pool->flush_list hazard pointer.
Definition: buf0buf.h:1819
double page_not_made_young_rate
page not made young rate in pages per second
Definition: buf0buf.h:194
Statistics of buddy blocks of a given size.
Definition: buf0buf.h:1981
void buf_pool_clear_hash_index(void)
Clears the adaptive hash index on all pages in the buffer pool.
Definition: buf0buf.cc:2529
unsigned long long int ulonglong
Definition: my_inttypes.h:55
~LRUItr() override
Destructor.
Definition: buf0buf.h:1869
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:3094
volatile ulint n_chunks
Number of buffer pool chunks.
Definition: buf0buf.h:2054
byte * frame
pointer to buffer frame which is of size UNIV_PAGE_SIZE, and aligned to an address divisible by UNIV_...
Definition: buf0buf.h:1560
std::atomic< uint64_t > n_ra_pages_read_rnd
Number of pages read in as part of random read ahead.
Definition: buf0buf.h:1917
void buf_page_print(const byte *read_buf, const page_size_t &page_size, ulint flags)
Prints a page to stderr.
Definition: buf0buf.cc:537
UNIV_INLINE 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...
UNIV_INLINE 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...
Definition: buf0buf.h:2416
buf_fix_count_atomic_t(const buf_fix_count_atomic_t &other)
Definition: buf0buf.h:1198
volatile ulint n_chunks_new
New number of buffer pool chunks.
Definition: buf0buf.h:2057
void set_newest_lsn(lsn_t lsn) noexcept
Set the latest modification LSN.
Definition: buf0buf.h:1384
FlushObserver * m_flush_observer
Flush observer instance.
Definition: buf0buf.h:1485
UNIV_INLINE lsn_t buf_page_get_newest_modification(const buf_page_t *bpage)
Gets the youngest modification log sequence number for a frame.
ulint n_pend_unzip
buf_pool->n_pend_unzip, pages pending decompress
Definition: buf0buf.h:164
@ BUF_BLOCK_FILE_PAGE
Contains a buffered file page.
Definition: buf0buf.h:145
void buf_refresh_io_stats_all()
Refresh the statistics used to print per-second averages.
Definition: buf0buf.cc:6447
UT_LIST_BASE_NODE_T(buf_page_t) free
Base node of the free block list.
UNIV_INLINE void buf_page_release_zip(buf_page_t *bpage)
Releases a compressed-only page acquired with buf_page_get_zip().
FlushHp flush_hp
"Hazard pointer" used during scan of flush_list while doing flush list batch.
Definition: buf0buf.h:2119
latch_level_t
Latching order levels.
Definition: sync0types.h:217
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:6188
std::atomic< ulint > n_pend_reads
Number of pending read operations.
Definition: buf0buf.h:2088
ibool buf_validate(void)
Validates the buffer pool data structure.
Definition: buf0buf.cc:5889
ulint unzip_LRU_bytes
unzip_LRU size in bytes
Definition: buf0buf.h:230
page_no_t get_page_no() const
Get the page number of the current buffer block.
Definition: buf0buf.h:1710
buf_flush_t flush_type
If this block is currently being flushed to disk, this tells the flush_type.
Definition: buf0buf.h:1417
lsn_t max_lsn_io
Maximum LSN for which write io has already started.
Definition: buf0buf.h:2164
ulint n_pages_written
buf_pool->n_pages_written
Definition: buf0buf.h:179
uint64_t relocated_usec
Total duration of block relocations, in microseconds.
Definition: buf0buf.h:1989
LRUHp(const buf_pool_t *buf_pool, const ib_mutex_t *mutex)
Constructor.
Definition: buf0buf.h:1843
UNIV_INLINE void buf_block_free(buf_block_t *block)
Frees a buffer block which does not contain a file page.
ulint n_ra_pages_evicted
buf_pool->n_ra_pages_evicted, number of readahead pages evicted without access
Definition: buf0buf.h:185
We use FlushObserver to track flushing of non-redo logged pages in bulk create index(BtrBulk....
Definition: buf0flu.h:266
The buffer pool structure.
Definition: buf0buf.h:2007
buf_pool_stat_t stat
Current statistics.
Definition: buf0buf.h:2101
File space address.
Definition: fil0fil.h:1154
Special purpose iterators to be used when scanning the LRU list.
Definition: buf0buf.h:1860
buf_block_t * buf_block_alloc(buf_pool_t *buf_pool)
Allocates a buffer block.
Definition: buf0buf.cc:508
page_no_t page_no() const
Retrieve the page number.
Definition: buf0types.h:204
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:925
std::ostream & operator<<(std::ostream &out, const buf_pool_t &buf_pool)
Print the given buf_pool_t object.
Definition: buf0buf.cc:6546
int64_t ib_time_monotonic_t
Time stamp read from the monotonic clock (returned by ut_time_monotonic()).
Definition: ut0ut.h:89
UNIV_INLINE buf_flush_t buf_page_get_flush_type(const buf_page_t *bpage)
Get the flush type of a page.
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:2973
@ BUF_BLOCK_NOT_USED
Is in the free list; must be after the BUF_BLOCK_ZIP_ constants for compressed-only pages.
Definition: buf0buf.h:139
BufListMutex zip_hash_mutex
zip_hash mutex
Definition: buf0buf.h:2028
BufListMutex flush_list_mutex
Mutex protecting the flush list access.
Definition: buf0buf.h:2115
hash_table_t * page_hash_old
Old pointer to page_hash to be freed after resizing buffer pool.
Definition: buf0buf.h:2081
UNIV_INLINE ibool buf_page_is_old(const buf_page_t *bpage)
Determine if a block has been flagged old.
ulint pool_unique_id
Buffer Pool ID.
Definition: buf0buf.h:158
std::atomic< ulint > n_pointers
used in debugging: the number of pointers in the adaptive hash index pointing to this frame; protecte...
Definition: buf0buf.h:1637
Functor to validate the LRU list.
Definition: buf0buf.h:2397
bool was_stale() const
Checks if this space reference saved during last page ID initialization was deleted or truncated sinc...
Definition: buf0buf.h:1291
BufListMutex zip_free_mutex
buddy allocator mutex
Definition: buf0buf.h:2025
buf_io_fix
Flags for io_fix types.
Definition: buf0types.h:96
mode
Definition: file_handle.h:59
double pages_readahead_rate
readahead rate in pages per second
Definition: buf0buf.h:209
UT_LIST_NODE_T(buf_buddy_free_t) list
Node of zip_free list.
buf_page_t bpage
Embedded bpage descriptor.
Definition: buf0buf.h:1893
void buf_page_free_descriptor(buf_page_t *bpage)
Free a buf_page_t descriptor.
Definition: buf0buf.cc:1364
void set_dblwr_batch_id(uint16_t batch_id)
Set the doublewrite buffer ID.
Definition: buf0buf.h:1250
page_type_t get_page_type() const
Get the page type of the current buffer block.
Definition: buf0buf.h:1726
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:3343
void clear(Shards< COUNT > &shards) noexcept
Clear the counter - reset to 0.
Definition: ut0counter.h:343
page_id_t id
Page id.
Definition: buf0buf.h:1401
UNIV_INLINE void buf_block_set_state(buf_block_t *block, enum buf_page_state state)
Sets the state of a block.
static int flags[50]
Definition: hp_test1.cc:39
uint16_t get_dblwr_batch_id() const
Definition: buf0buf.h:1253
#define false
Definition: config_static.h:43
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:166