MySQL 8.3.0
Source Code Documentation
buf0flu.h
Go to the documentation of this file.
1/*****************************************************************************
2
3Copyright (c) 1995, 2023, Oracle and/or its affiliates.
4
5This program is free software; you can redistribute it and/or modify it under
6the terms of the GNU General Public License, version 2.0, as published by the
7Free Software Foundation.
8
9This program is also distributed with certain software (including but not
10limited to OpenSSL) that is licensed under separate terms, as designated in a
11particular file or component or in included license documentation. The authors
12of MySQL hereby grant you an additional permission to link the program and
13your derivative works with the separately licensed software that they have
14included with MySQL.
15
16This program is distributed in the hope that it will be useful, but WITHOUT
17ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
18FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0,
19for more details.
20
21You should have received a copy of the GNU General Public License along with
22this program; if not, write to the Free Software Foundation, Inc.,
2351 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
24
25*****************************************************************************/
26
27/** @file include/buf0flu.h
28 The database buffer pool flush algorithm
29
30 Created 11/5/1995 Heikki Tuuri
31 *******************************************************/
32
33#ifndef buf0flu_h
34#define buf0flu_h
35
36#include "buf0types.h"
37#include "univ.i"
38#include "ut0byte.h"
39
40#ifndef UNIV_HOTBACKUP
41/** Checks if the page_cleaner is in active state. */
43
44#ifdef UNIV_DEBUG
45
46/** Value of MySQL global variable used to disable page cleaner. */
48
49#endif /* UNIV_DEBUG */
50
51/** Event to synchronise with the flushing. */
53
54/** Event to wait for one flushing step */
56
57class Alter_stage;
58
59/** Remove a block from the flush list of modified blocks.
60@param[in] bpage pointer to the block in question */
61void buf_flush_remove(buf_page_t *bpage);
62
63/** Relocates a buffer control block on the flush_list.
64 Note that it is assumed that the contents of bpage has already been
65 copied to dpage. */
67 buf_page_t *bpage, /*!< in/out: control block being moved */
68 buf_page_t *dpage); /*!< in/out: destination block */
69
70/** Updates the flush system data structures when a write is completed.
71@param[in] bpage pointer to the block in question */
73
74#endif /* !UNIV_HOTBACKUP */
75
76/** Check if page type is uncompressed.
77@param[in] page page frame
78@return true if uncompressed page type. */
79bool page_is_uncompressed_type(const byte *page);
80
81/** Initialize a page for writing to the tablespace.
82@param[in] block buffer block; NULL if bypassing the buffer pool
83@param[in,out] page page frame
84@param[in,out] page_zip_ compressed page, or NULL if uncompressed
85@param[in] newest_lsn newest modification LSN to the page
86@param[in] skip_checksum whether to disable the page checksum
87@param[in] skip_lsn_check true to skip check for LSN (in DEBUG) */
88void buf_flush_init_for_writing(const buf_block_t *block, byte *page,
89 void *page_zip_, lsn_t newest_lsn,
90 bool skip_checksum, bool skip_lsn_check);
91
92#ifndef UNIV_HOTBACKUP
93#if defined UNIV_DEBUG || defined UNIV_IBUF_DEBUG
94/** Writes a flushable page asynchronously from the buffer pool to a file.
95NOTE: block and LRU list mutexes must be held upon entering this function, and
96they will be released by this function after flushing. This is loosely based on
97buf_flush_batch() and buf_flush_page().
98@param[in,out] buf_pool buffer pool instance
99@param[in,out] block buffer control block
100@return true if the page was flushed and the mutex released */
101[[nodiscard]] bool buf_flush_page_try(buf_pool_t *buf_pool, buf_block_t *block);
102#endif /* UNIV_DEBUG || UNIV_IBUF_DEBUG */
103
104/** Do flushing batch of a given type.
105NOTE: The calling thread is not allowed to own any latches on pages!
106@param[in,out] buf_pool buffer pool instance
107@param[in] type flush type
108@param[in] min_n wished minimum number of blocks flushed
109(it is not guaranteed that the actual number is that big, though)
110@param[in] lsn_limit in the case BUF_FLUSH_LIST all blocks whose
111oldest_modification is smaller than this should be flushed (if their number
112does not exceed min_n), otherwise ignored
113@param[out] n_processed the number of pages which were processed is
114passed back to caller. Ignored if NULL
115@retval true if a batch was queued successfully.
116@retval false if another batch of same type was already running. */
117bool buf_flush_do_batch(buf_pool_t *buf_pool, buf_flush_t type, ulint min_n,
118 lsn_t lsn_limit, ulint *n_processed);
119
120/** This utility flushes dirty blocks from the end of the flush list of all
121buffer pool instances.
122NOTE: The calling thread is not allowed to own any latches on pages!
123@param[in] min_n wished minimum number of blocks flushed (it is
124not guaranteed that the actual number is that big, though)
125@param[in] lsn_limit in the case BUF_FLUSH_LIST all blocks whose
126oldest_modification is smaller than this should be flushed (if their number
127does not exceed min_n), otherwise ignored
128@param[out] n_processed the number of pages which were processed is
129passed back to caller. Ignored if NULL.
130@return true if a batch was queued successfully for each buffer pool
131instance. false if another batch of same type was already running in
132at least one of the buffer pool instance */
133bool buf_flush_lists(ulint min_n, lsn_t lsn_limit, ulint *n_processed);
134
135/** This function picks up a single page from the tail of the LRU
136list, flushes it (if it is dirty), removes it from page_hash and LRU
137list and puts it on the free list. It is called from user threads when
138they are unable to find a replaceable page at the tail of the LRU
139list i.e.: when the background LRU flushing in the page_cleaner thread
140is not fast enough to keep pace with the workload.
141@param[in,out] buf_pool buffer pool instance
142@return true if success. */
144
145/** Waits until there's no flush of the given type from given BP instance.
146Note that in case of BUF_FLUSH_LIST and BUF_FLUSH_LRU we also make sure there's
147no ongoing batch initialization (which could lead to flushes).
148The BUF_FLUSH_SINGLE_PAGE does not have batch initialization.
149Note, that we return as soon as there is no flush, but in general a new one
150could start right after we've returned (it's up to the caller to prevent this).
151If buf_pool is nullptr, then it will await a moment with no flushes for each
152BP instance in turn, which in general doesn't imply there was a single moment
153when all instances were quiescent - it's up to the caller to ensure that.
154
155@param[in] buf_pool
156 The specific buffer pool instance to check.
157 Can be null, if we want to wait for each buf_pool in turn.
158@param[in] flush_type Flush type. */
160
161/** This function should be called at a mini-transaction commit, if a page was
162modified in it. Puts the block to the list of modified blocks, if it not
163already in it.
164@param[in] block block which is modified
165@param[in] start_lsn start lsn of the first mtr in a set of mtr's
166@param[in] end_lsn end lsn of the last mtr in the set of mtr's
167@param[in] observer flush observer */
168static inline void buf_flush_note_modification(buf_block_t *block,
169 lsn_t start_lsn, lsn_t end_lsn,
170 Flush_observer *observer);
171
172/** This function should be called when recovery has modified a buffer page.
173@param[in] block block which is modified
174@param[in] start_lsn start lsn of the first mtr in a set of mtr's
175@param[in] end_lsn end lsn of the last mtr in the set of mtr's */
177 lsn_t start_lsn,
178 lsn_t end_lsn);
179
180/** Returns true if the file page block is immediately suitable for replacement,
181i.e., the transition FILE_PAGE => NOT_USED allowed. The caller must hold the
182LRU list and block mutexes.
183@param[in] bpage buffer control block, must be buf_page_in_file() and
184 in the LRU list
185@return true if can replace immediately */
187
188#ifdef UNIV_DEBUG
189struct SYS_VAR;
190
191/** Disables page cleaner threads (coordinator and workers).
192It's used by: SET GLOBAL innodb_page_cleaner_disabled_debug = 1 (0).
193@param[in] thd thread handle
194@param[in] var pointer to system variable
195@param[out] var_ptr where the formal string goes
196@param[in] save immediate result from check function */
198 void *var_ptr,
199 const void *save);
200#endif /* UNIV_DEBUG */
201
202/** Initialize page_cleaner. */
204
205#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
206/** Validates the flush list.
207 @return true if ok */
208bool buf_flush_validate(buf_pool_t *buf_pool);
209#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
210
211/** Initialize the red-black tree to speed up insertions into the flush_list
212 during recovery process. Should be called at the start of recovery
213 process before any page has been read/written. */
214void buf_flush_init_flush_rbt(void);
215
216/** Frees up the red-black tree. */
217void buf_flush_free_flush_rbt(void);
218
219/** Writes a flushable page asynchronously from the buffer pool to a file.
220NOTE: 1. in simulated aio we must call os_aio_simulated_wake_handler_threads
221after we have posted a batch of writes! 2. buf_page_get_mutex(bpage) must be
222held upon entering this function. The LRU list mutex must be held if flush_type
223== BUF_FLUSH_SINGLE_PAGE. Both mutexes will be released by this function if it
224returns true.
225@param[in] buf_pool buffer pool instance
226@param[in] bpage buffer control block
227@param[in] flush_type type of flush
228@param[in] sync true if sync IO request
229@return true if page was flushed */
230bool buf_flush_page(buf_pool_t *buf_pool, buf_page_t *bpage,
231 buf_flush_t flush_type, bool sync);
232
233/** Check if the block is modified and ready for flushing.
234Requires buf_page_get_mutex(bpage).
235@param[in] bpage buffer control block, must be buf_page_in_file()
236@param[in] flush_type type of flush
237@return true if can flush immediately */
238[[nodiscard]] bool buf_flush_ready_for_flush(buf_page_t *bpage,
240
241/** Check if there are any dirty pages that belong to a space id in the flush
242 list in a particular buffer pool.
243 @return number of dirty pages present in a single buffer pool */
245 buf_pool_t *buf_pool, /*!< in: buffer pool */
246 space_id_t id, /*!< in: space id to check */
247 Flush_observer *observer); /*!< in: flush observer to check */
248
249/** Executes fsync for all tablespaces, to fsync all pages written to disk. */
250void buf_flush_fsync();
251
252/** Synchronously flush dirty blocks from the end of the flush list of all
253 buffer pool instances. NOTE: The calling thread is not allowed to own any
254 latches on pages! */
256
257/** Checks if all flush lists are empty. It is supposed to be used in
258single thread, during startup or shutdown. Hence it does not acquire
259lock and it is caller's responsibility to guarantee that flush lists
260are not changed in background.
261@return true if all flush lists were empty. */
263
264/** We use Flush_observer to track flushing of non-redo logged pages in bulk
265create index(btr0load.cc).Since we disable redo logging during a index build,
266we need to make sure that all dirty pages modified by the index build are
267flushed to disk before any redo logged operations go to the index. */
268
270 public:
271 /** Constructor
272 @param[in] space_id table space id
273 @param[in] trx trx instance
274 @param[in,out] stage PFS progress monitoring instance, it's used by
275 ALTER TABLE. It is passed to log_preflush_pool_modified_pages() for
276 accounting. */
277 Flush_observer(space_id_t space_id, trx_t *trx, Alter_stage *stage) noexcept;
278
279 /** Destructor */
280 ~Flush_observer() noexcept;
281
282 /** Print information about the current object.
283 @param[in,out] out output stream to be used.
284 @return the output stream. */
285 std::ostream &print(std::ostream &out) const;
286
287 /** Check pages have been flushed and removed from the flush list
288 in a buffer pool instance.
289 @param[in] instance_no buffer pool instance no
290 @return true if the pages were removed from the flush list */
291 bool is_complete(size_t instance_no) {
292 ut_ad(m_flushed[instance_no].load() >= 0);
293 ut_ad(m_removed[instance_no].load() >= 0);
294 return m_interrupted ||
295 (m_flushed[instance_no].load() == m_removed[instance_no].load());
296 }
297
298 /** Interrupt observer not to wait. */
299 void interrupted() { m_interrupted = true; }
300
301 /** Check whether trx is interrupted
302 @return true if trx is interrupted */
303 bool check_interrupted();
304
305 /** Flush dirty pages. */
306 void flush();
307
308 /** Notify observer of flushing a page
309 @param[in] buf_pool buffer pool instance
310 @param[in] bpage buffer page to flush */
311 void notify_flush(buf_pool_t *buf_pool, buf_page_t *bpage);
312
313 /** Notify observer of removing a page from flush list
314 @param[in] buf_pool buffer pool instance
315 @param[in] bpage buffer page flushed */
316 void notify_remove(buf_pool_t *buf_pool, buf_page_t *bpage);
317
318 private:
319 using Counter = std::atomic_int;
320 using Counters = std::vector<Counter, ut::allocator<Counter>>;
321
322#ifdef UNIV_DEBUG
323 [[nodiscard]] bool validate() const noexcept;
324#endif /* UNIV_DEBUG */
325
326 /** Tablespace ID. */
328
329 /** Trx instance */
331
332 /** Performance schema accounting object, used by ALTER TABLE.
333 If not nullptr, then stage->begin_phase_flush() will be called initially,
334 specifying the number of pages to be attempted to be flushed and
335 subsequently, stage->inc() will be called for each page we attempt to
336 flush. */
338
339 /** Flush request sent, per buffer pool. */
341
342 /** Flush request finished, per buffer pool. */
344
345 /** Number of pages using this instance. */
347
348 /** True if the operation was interrupted. */
350};
351
352lsn_t get_flush_sync_lsn() noexcept;
353#endif /* !UNIV_HOTBACKUP */
354
355#include "buf0flu.ic"
356
357#endif
uint32_t space_id_t
Tablespace identifier.
Definition: api0api.h:46
void buf_flush_fsync()
Executes fsync for all tablespaces, to fsync all pages written to disk.
Definition: buf0flu.cc:3573
bool buf_flush_ready_for_replace(buf_page_t *bpage)
Returns true if the file page block is immediately suitable for replacement, i.e.,...
Definition: buf0flu.cc:683
ulint buf_pool_get_dirty_pages_count(buf_pool_t *buf_pool, space_id_t id, Flush_observer *observer)
Check if there are any dirty pages that belong to a space id in the flush list in a particular buffer...
Definition: buf0flu.cc:3705
void buf_flush_write_complete(buf_page_t *bpage)
Updates the flush system data structures when a write is completed.
Definition: buf0flu.cc:915
bool buf_flush_do_batch(buf_pool_t *buf_pool, buf_flush_t type, ulint min_n, lsn_t lsn_limit, ulint *n_processed)
Do flushing batch of a given type.
Definition: buf0flu.cc:2039
void buf_flush_sync_all_buf_pools()
Synchronously flush dirty blocks from the end of the flush list of all buffer pool instances.
Definition: buf0flu.cc:3601
bool buf_flush_single_page_from_LRU(buf_pool_t *buf_pool)
This function picks up a single page from the tail of the LRU list, flushes it (if it is dirty),...
Definition: buf0flu.cc:2124
bool buf_flush_validate(buf_pool_t *buf_pool)
Validates the flush list.
Definition: buf0flu.cc:3691
void buf_flush_init_flush_rbt(void)
Initialize the red-black tree to speed up insertions into the flush_list during recovery process.
Definition: buf0flu.cc:369
bool buf_flush_lists(ulint min_n, lsn_t lsn_limit, ulint *n_processed)
This utility flushes dirty blocks from the end of the flush list of all buffer pool instances.
Definition: buf0flu.cc:2062
static void buf_flush_recv_note_modification(buf_block_t *block, lsn_t start_lsn, lsn_t end_lsn)
This function should be called when recovery has modified a buffer page.
void buf_flush_page_cleaner_disabled_debug_update(THD *thd, SYS_VAR *var, void *var_ptr, const void *save)
Disables page cleaner threads (coordinator and workers).
Definition: buf0flu.cc:3065
bool buf_flush_page(buf_pool_t *buf_pool, buf_page_t *bpage, buf_flush_t flush_type, bool sync)
Writes a flushable page asynchronously from the buffer pool to a file.
Definition: buf0flu.cc:1274
void buf_flush_remove(buf_page_t *bpage)
Remove a block from the flush list of modified blocks.
Definition: buf0flu.cc:782
os_event_t buf_flush_tick_event
Event to wait for one flushing step.
Definition: buf0flu.cc:104
bool buf_flush_page_try(buf_pool_t *buf_pool, buf_block_t *block)
Writes a flushable page asynchronously from the buffer pool to a file.
Definition: buf0flu.cc:1400
os_event_t buf_flush_event
Event to synchronise with the flushing.
Definition: buf0flu.cc:101
void buf_flush_await_no_flushing(buf_pool_t *buf_pool, buf_flush_t flush_type)
Waits until there's no flush of the given type from given BP instance.
Definition: buf0flu.cc:2027
static void buf_flush_note_modification(buf_block_t *block, lsn_t start_lsn, lsn_t end_lsn, Flush_observer *observer)
This function should be called at a mini-transaction commit, if a page was modified in it.
void buf_flush_free_flush_rbt(void)
Frees up the red-black tree.
Definition: buf0flu.cc:389
void buf_flush_relocate_on_flush_list(buf_page_t *bpage, buf_page_t *dpage)
Relocates a buffer control block on the flush_list.
Definition: buf0flu.cc:858
void buf_flush_page_cleaner_init()
Initialize page_cleaner.
Definition: buf0flu.cc:2775
lsn_t get_flush_sync_lsn() noexcept
Get the lsn up to which data pages are to be synchronously flushed.
Definition: buf0flu.cc:92
bool buf_are_flush_lists_empty_validate()
Checks if all flush lists are empty.
Definition: buf0flu.cc:410
bool innodb_page_cleaner_disabled_debug
Value of MySQL global variable used to disable page cleaner.
Definition: buf0flu.cc:202
bool buf_flush_ready_for_flush(buf_page_t *bpage, buf_flush_t flush_type)
Check if the block is modified and ready for flushing.
Definition: buf0flu.cc:776
void buf_flush_init_for_writing(const buf_block_t *block, byte *page, void *page_zip_, lsn_t newest_lsn, bool skip_checksum, bool skip_lsn_check)
Initialize a page for writing to the tablespace.
Definition: buf0flu.cc:986
bool buf_flush_page_cleaner_is_active()
Checks if the page_cleaner is in active state.
Definition: buf0flu.cc:2771
bool page_is_uncompressed_type(const byte *page)
Check if page type is uncompressed.
Definition: buf0flu.cc:962
The database buffer pool flush algorithm.
The database buffer pool global types for the directory.
buf_flush_t
Flags for flush types.
Definition: buf0types.h:67
Class used to report ALTER TABLE progress via performance_schema.
Definition: ut0stage.h:80
We use Flush_observer to track flushing of non-redo logged pages in bulk create index(btr0load....
Definition: buf0flu.h:269
trx_t * m_trx
Trx instance.
Definition: buf0flu.h:330
Counters m_flushed
Flush request sent, per buffer pool.
Definition: buf0flu.h:340
space_id_t m_space_id
Tablespace ID.
Definition: buf0flu.h:327
Flush_observer(space_id_t space_id, trx_t *trx, Alter_stage *stage) noexcept
Constructor.
Definition: buf0flu.cc:3752
void flush()
Flush dirty pages.
Definition: buf0flu.cc:3808
Counters m_removed
Flush request finished, per buffer pool.
Definition: buf0flu.h:343
bool validate() const noexcept
Definition: buf0flu.cc:3844
void interrupted()
Interrupt observer not to wait.
Definition: buf0flu.h:299
std::ostream & print(std::ostream &out) const
Print information about the current object.
Definition: buf0flu.cc:3853
bool check_interrupted()
Check whether trx is interrupted.
Definition: buf0flu.cc:3782
~Flush_observer() noexcept
Destructor.
Definition: buf0flu.cc:3771
void notify_remove(buf_pool_t *buf_pool, buf_page_t *bpage)
Notify observer of removing a page from flush list.
Definition: buf0flu.cc:3802
bool m_interrupted
True if the operation was interrupted.
Definition: buf0flu.h:349
void notify_flush(buf_pool_t *buf_pool, buf_page_t *bpage)
Notify observer of flushing a page.
Definition: buf0flu.cc:3792
std::vector< Counter, ut::allocator< Counter > > Counters
Definition: buf0flu.h:320
Counter m_n_ref_count
Number of pages using this instance.
Definition: buf0flu.h:346
Alter_stage * m_stage
Performance schema accounting object, used by ALTER TABLE.
Definition: buf0flu.h:337
bool is_complete(size_t instance_no)
Check pages have been flushed and removed from the flush list in a buffer pool instance.
Definition: buf0flu.h:291
For each client connection we create a separate thread with THD serving as a thread/connection descri...
Definition: sql_lexer_thd.h:35
Definition: buf0buf.h:1152
int page
Definition: ctype-mb.cc:1233
flush_type
Definition: my_sys.h:296
uint64_t lsn_t
Type used for all log sequence number storage and arithmetic.
Definition: log0types.h:62
Sharded atomic counter.
Definition: ut0counter.h:220
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
required string type
Definition: replication_group_member_actions.proto:33
Definition: plugin.h:68
The buffer control block structure.
Definition: buf0buf.h:1750
The buffer pool structure.
Definition: buf0buf.h:2278
InnoDB condition variable.
Definition: os0event.cc:62
Definition: trx0trx.h:683
Version control for database, common definitions, and include files.
unsigned long int ulint
Definition: univ.i:405
Utilities for byte operations.
#define ut_ad(EXPR)
Debug assertion.
Definition: ut0dbg.h:104