mirror of
https://github.com/MariaDB/server.git
synced 2025-10-31 10:56:12 +01:00
a3d0d5fc33
This is a 10.5 backport from 10.6
commit 9593cccf28.
Adaptive flushing is enabled by setting innodb_max_dirty_pages_pct_lwm>0
(not default) and innodb_adaptive_flushing=ON (default).
There is also the parameter innodb_adaptive_flushing_lwm
(default: 10 per cent of the log capacity). It should enable some
adaptive flushing even when innodb_max_dirty_pages_pct_lwm=0.
That is not being changed here.
This idea was first presented by Inaam Rana several years ago,
and I discussed it with Jean-François Gagné at FOSDEM 2023.
buf_flush_page_cleaner(): When we are not near the log capacity limit
(neither buf_flush_async_lsn nor buf_flush_sync_lsn are set),
also try to move clean blocks from the buf_pool.LRU list to buf_pool.free
or initiate writes (but not the eviction) of dirty blocks, until
the remaining I/O capacity has been consumed.
buf_flush_LRU_list_batch(): Add the parameter bool evict, to specify
whether dirty least recently used pages (from buf_pool.LRU) should
be evicted immediately after they have been written out. Callers outside
buf_flush_page_cleaner() will pass evict=true, to retain the existing
behaviour.
buf_do_LRU_batch(): Add the parameter bool evict.
Return counts of evicted and flushed pages.
buf_flush_LRU(): Add the parameter bool evict.
Assume that the caller holds buf_pool.mutex and
will invoke buf_dblwr.flush_buffered_writes() afterwards.
buf_flush_list_holding_mutex(): A low-level variant of buf_flush_list()
whose caller must hold buf_pool.mutex and invoke
buf_dblwr.flush_buffered_writes() afterwards.
buf_flush_wait_batch_end_acquiring_mutex(): Remove. It is enough to have
buf_flush_wait_batch_end().
page_cleaner_flush_pages_recommendation(): Avoid some floating-point
arithmetics.
buf_flush_page(), buf_flush_check_neighbor(), buf_flush_check_neighbors(),
buf_flush_try_neighbors(): Rename the parameter "bool lru" to "bool evict".
buf_free_from_unzip_LRU_list_batch(): Remove the parameter.
Only actual page writes will contribute towards the limit.
buf_LRU_free_page(): Evict freed pages of temporary tables.
buf_pool.done_free: Broadcast whenever a block is freed
(and buf_pool.try_LRU_scan is set).
buf_pool_t::io_buf_t::reserve(): Retry indefinitely.
During the test encryption.innochecksum we easily run out of
these buffers for PAGE_COMPRESSED or ENCRYPTED pages.
Tested by Matthias Leich and Axel Schwenke
144 lines
5.4 KiB
C
144 lines
5.4 KiB
C
/*****************************************************************************
|
|
|
|
Copyright (c) 1995, 2016, Oracle and/or its affiliates. All Rights Reserved.
|
|
Copyright (c) 2014, 2021, MariaDB Corporation.
|
|
|
|
This program is free software; you can redistribute it and/or modify it under
|
|
the terms of the GNU General Public License as published by the Free Software
|
|
Foundation; version 2 of the License.
|
|
|
|
This program is distributed in the hope that it will be useful, but WITHOUT
|
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License along with
|
|
this program; if not, write to the Free Software Foundation, Inc.,
|
|
51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA
|
|
|
|
*****************************************************************************/
|
|
|
|
/**************************************************//**
|
|
@file include/buf0flu.h
|
|
The database buffer pool flush algorithm
|
|
|
|
Created 11/5/1995 Heikki Tuuri
|
|
*******************************************************/
|
|
|
|
#ifndef buf0flu_h
|
|
#define buf0flu_h
|
|
|
|
#include "ut0byte.h"
|
|
#include "log0log.h"
|
|
#include "buf0types.h"
|
|
|
|
/** Number of pages flushed. Protected by buf_pool.mutex. */
|
|
extern ulint buf_flush_page_count;
|
|
/** Number of pages flushed via LRU. Protected by buf_pool.mutex.
|
|
Also included in buf_flush_page_count. */
|
|
extern ulint buf_lru_flush_page_count;
|
|
|
|
/** Flag indicating if the page_cleaner is in active state. */
|
|
extern bool buf_page_cleaner_is_active;
|
|
|
|
/** Remove all dirty pages belonging to a given tablespace when we are
|
|
deleting the data file of that tablespace.
|
|
The pages still remain a part of LRU and are evicted from
|
|
the list as they age towards the tail of the LRU.
|
|
@param id tablespace identifier */
|
|
void buf_flush_remove_pages(ulint id);
|
|
|
|
/*******************************************************************//**
|
|
Relocates a buffer control block on the flush_list.
|
|
Note that it is assumed that the contents of bpage has already been
|
|
copied to dpage. */
|
|
ATTRIBUTE_COLD
|
|
void
|
|
buf_flush_relocate_on_flush_list(
|
|
/*=============================*/
|
|
buf_page_t* bpage, /*!< in/out: control block being moved */
|
|
buf_page_t* dpage); /*!< in/out: destination block */
|
|
|
|
/** Complete write of a file page from buf_pool.
|
|
@param request write request */
|
|
void buf_page_write_complete(const IORequest &request);
|
|
|
|
/** Assign the full crc32 checksum for non-compressed page.
|
|
@param[in,out] page page to be updated */
|
|
void buf_flush_assign_full_crc32_checksum(byte* page);
|
|
|
|
/** Initialize a page for writing to the tablespace.
|
|
@param[in] block buffer block; NULL if bypassing the buffer pool
|
|
@param[in,out] page page frame
|
|
@param[in,out] page_zip_ compressed page, or NULL if uncompressed
|
|
@param[in] use_full_checksum whether tablespace uses full checksum */
|
|
void
|
|
buf_flush_init_for_writing(
|
|
const buf_block_t* block,
|
|
byte* page,
|
|
void* page_zip_,
|
|
bool use_full_checksum);
|
|
|
|
/** Try to flush dirty pages that belong to a given tablespace.
|
|
@param space tablespace
|
|
@param n_flushed number of pages written
|
|
@return whether the flush for some pages might not have been initiated */
|
|
bool buf_flush_list_space(fil_space_t *space, ulint *n_flushed= nullptr)
|
|
MY_ATTRIBUTE((warn_unused_result));
|
|
|
|
/** Write out dirty blocks from buf_pool.LRU,
|
|
and move clean blocks to buf_pool.free.
|
|
The caller must invoke buf_dblwr.flush_buffered_writes()
|
|
after releasing buf_pool.mutex.
|
|
@param max_n wished maximum mumber of blocks flushed
|
|
@param evict whether to evict pages after flushing
|
|
@return evict ? number of processed pages : number of pages written
|
|
@retval 0 if a buf_pool.LRU batch is already running */
|
|
ulint buf_flush_LRU(ulint max_n, bool evict);
|
|
|
|
/** Wait until a flush batch ends.
|
|
@param lru true=buf_pool.LRU; false=buf_pool.flush_list */
|
|
void buf_flush_wait_batch_end(bool lru);
|
|
/** Wait until all persistent pages are flushed up to a limit.
|
|
@param sync_lsn buf_pool.get_oldest_modification(LSN_MAX) to wait for */
|
|
ATTRIBUTE_COLD void buf_flush_wait_flushed(lsn_t sync_lsn);
|
|
/** Initiate more eager page flushing if the log checkpoint age is too old.
|
|
@param lsn buf_pool.get_oldest_modification(LSN_MAX) target
|
|
@param furious true=furious flushing, false=limit to innodb_io_capacity */
|
|
ATTRIBUTE_COLD void buf_flush_ahead(lsn_t lsn, bool furious);
|
|
|
|
/********************************************************************//**
|
|
This function should be called at a mini-transaction commit, if a page was
|
|
modified in it. Puts the block to the list of modified blocks, if it not
|
|
already in it. */
|
|
UNIV_INLINE
|
|
void
|
|
buf_flush_note_modification(
|
|
/*========================*/
|
|
buf_block_t* block, /*!< in: block which is modified */
|
|
lsn_t start_lsn, /*!< in: start lsn of the first mtr in a
|
|
set of mtr's */
|
|
lsn_t end_lsn); /*!< in: end lsn of the last mtr in the
|
|
set of mtr's */
|
|
|
|
/** Initialize page_cleaner. */
|
|
ATTRIBUTE_COLD void buf_flush_page_cleaner_init();
|
|
|
|
/** Flush the buffer pool on shutdown. */
|
|
ATTRIBUTE_COLD void buf_flush_buffer_pool();
|
|
|
|
#ifdef UNIV_DEBUG
|
|
/** Validate the flush list. */
|
|
void buf_flush_validate();
|
|
#endif /* UNIV_DEBUG */
|
|
|
|
/** Synchronously flush dirty blocks during recv_sys_t::apply().
|
|
NOTE: The calling thread is not allowed to hold any buffer page latches! */
|
|
void buf_flush_sync_batch(lsn_t lsn);
|
|
|
|
/** Synchronously flush dirty blocks.
|
|
NOTE: The calling thread is not allowed to hold any buffer page latches! */
|
|
void buf_flush_sync();
|
|
|
|
#include "buf0flu.inl"
|
|
|
|
#endif
|