mirror of
https://github.com/MariaDB/server.git
synced 2025-02-05 13:22:17 +01:00
b7b9f3ce82
In a Sysbench oltp_update_index workload that involves 1 table,
a serious contention between the workload and the purge of history
was observed. This was the worst when the table contained only 1 record.
This turned out to be fixed by setting innodb_purge_batch_size=128,
which corresponds to the number of usable persistent rollback segments.
When we go above that, there would be contention between row_purge_poss_sec()
and the workload, typically on the clustered index page latch, sometimes
also on a secondary index page latch. It might be that with smaller
batches, trx_sys.history_size() will end up pausing all concurrent
transaction start/commit frequently enough so that purge will be able
to make some progress, so that there would be less contention on the
index page latches between purge and SQL execution.
In commit aa719b5010 (part of MDEV-32050)
the interpretation of the parameter innodb_purge_batch_size was slightly
changed. It would correspond to the maximum desired size of the
purge_sys.pages cache. Before that change, the parameter was referring to
a number of undo log pages, but the accounting might have been inaccurate.
To avoid a regression, we will reduce the default value to
innodb_purge_batch_size=127, which will also be compatible with
innodb_undo_tablespaces>1 (which will disable rollback segment 0).
Additionally, some logic in the purge and MVCC checks is simplified.
The purge tasks will make use of purge_sys.pages when accessing undo
log pages to find out if a secondary index record can be removed.
If an undo page needs to be looked up in buf_pool.page_hash, we will
merely buffer-fix it. This is correct, because the undo pages are
append-only in nature. Holding purge_sys.latch or purge_sys.end_latch
or the fact that the current thread is executing as a part of an
in-progress purge batch will prevent the contents of the undo page from
being freed and subsequently reused. The buffer-fix will prevent the
page from being evicted form the buffer pool. Thanks to this logic,
we can refer to the undo log record directly in the buffer pool page
and avoid copying the record.
buf_pool_t::page_fix(): Look up and buffer-fix a page. This is useful
for accessing undo log pages, which are append-only by nature.
There will be no need to deal with change buffer or ROW_FORMAT=COMPRESSED
in that case.
purge_sys_t::view_guard::view_guard(): Allow the type of guard to be
acquired: end_latch, latch, or no latch (in case we are a purge thread).
purge_sys_t::view_guard::get(): Read-only accessor to purge_sys.pages.
purge_sys_t::get_page(): Invoke buf_pool_t::page_fix().
row_vers_old_has_index_entry(): Replaced with row_purge_is_unsafe()
and row_undo_mod_sec_unsafe().
trx_undo_get_undo_rec(): Merged to trx_undo_prev_version_build().
row_purge_poss_sec(): Add the parameter mtr and remove redundant
or unused parameters sec_pcur, sec_mtr, is_tree. We will use the
caller's mtr object but release any acquired page latches before
returning.
btr_cur_get_page(), page_cur_get_page(): Do not invoke page_align().
row_purge_remove_sec_if_poss_leaf(): Return the value of PAGE_MAX_TRX_ID
to be checked against the page in row_purge_remove_sec_if_poss_tree().
If the secondary index page was not changed meanwhile, it will be
unnecessary to invoke row_purge_poss_sec() again.
trx_undo_prev_version_build(): Access any undo log pages using
the caller's mini-transaction object.
row_purge_vc_matches_cluster(): Moved to the only compilation unit that
needs it.
Reviewed by: Debarun Banerjee
136 lines
4.7 KiB
C++
136 lines
4.7 KiB
C++
/*****************************************************************************
|
|
|
|
Copyright (c) 1997, 2016, Oracle and/or its affiliates. All Rights Reserved.
|
|
Copyright (c) 2017, 2019, 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/row0purge.h
|
|
Purge obsolete records
|
|
|
|
Created 3/14/1997 Heikki Tuuri
|
|
*******************************************************/
|
|
|
|
#pragma once
|
|
|
|
#include "que0types.h"
|
|
#include "btr0types.h"
|
|
#include "btr0pcur.h"
|
|
#include "trx0types.h"
|
|
#include "row0types.h"
|
|
#include "row0mysql.h"
|
|
#include "mysqld.h"
|
|
#include <queue>
|
|
#include <unordered_map>
|
|
|
|
class MDL_ticket;
|
|
/** Determines if it is possible to remove a secondary index entry.
|
|
Removal is possible if the secondary index entry does not refer to any
|
|
not delete marked version of a clustered index record where DB_TRX_ID
|
|
is newer than the purge view.
|
|
|
|
NOTE: This function should only be called by the purge thread, only
|
|
while holding a latch on the leaf page of the secondary index entry
|
|
(or keeping the buffer pool watch on the page). It is possible that
|
|
this function first returns true and then false, if a user transaction
|
|
inserts a record that the secondary index entry would refer to.
|
|
However, in that case, the user transaction would also re-insert the
|
|
secondary index entry after purge has removed it and released the leaf
|
|
page latch.
|
|
@param node row purge node
|
|
@param index secondary index
|
|
@param entry secondary index entry
|
|
@param mtr mini-transaction for looking up clustered index
|
|
@return whether the secondary index record can be purged */
|
|
bool row_purge_poss_sec(purge_node_t *node, dict_index_t *index,
|
|
const dtuple_t *entry, mtr_t *mtr);
|
|
|
|
/***************************************************************
|
|
Does the purge operation.
|
|
@return query thread to run next */
|
|
que_thr_t*
|
|
row_purge_step(
|
|
/*===========*/
|
|
que_thr_t* thr) /*!< in: query thread */
|
|
MY_ATTRIBUTE((nonnull, warn_unused_result));
|
|
|
|
/** Purge worker context */
|
|
struct purge_node_t
|
|
{
|
|
/** node type: QUE_NODE_PURGE */
|
|
que_common_t common;
|
|
|
|
/** DB_TRX_ID of the undo log record */
|
|
trx_id_t trx_id;
|
|
/** DB_ROLL_PTR pointing to undo log record */
|
|
roll_ptr_t roll_ptr;
|
|
|
|
/** undo number of the record */
|
|
undo_no_t undo_no;
|
|
|
|
/** record type: TRX_UNDO_INSERT_REC, ... */
|
|
byte rec_type;
|
|
/** compiler analysis info of an update */
|
|
byte cmpl_info;
|
|
/** whether the clustered index record determined by ref was found
|
|
in the clustered index of the table, and we were able to position
|
|
pcur on it */
|
|
bool found_clust;
|
|
#ifdef UNIV_DEBUG
|
|
/** whether the operation is in progress */
|
|
bool in_progress= false;
|
|
#endif
|
|
/** table where purge is done */
|
|
dict_table_t *table= nullptr;
|
|
/** update vector for a clustered index record */
|
|
upd_t *update;
|
|
/** row reference to the next row to handle, or nullptr */
|
|
const dtuple_t *ref;
|
|
/** nullptr, or a deep copy of the indexed fields of the row to handle */
|
|
dtuple_t *row;
|
|
/** nullptr, or the next index of table whose record should be handled */
|
|
dict_index_t *index;
|
|
/** memory heap used as auxiliary storage; must be emptied between rows */
|
|
mem_heap_t *heap;
|
|
/** persistent cursor to the clustered index record */
|
|
btr_pcur_t pcur;
|
|
|
|
/** Undo recs to purge */
|
|
std::queue<trx_purge_rec_t> undo_recs;
|
|
|
|
/** map of table identifiers to table handles and meta-data locks */
|
|
std::unordered_map<table_id_t, std::pair<dict_table_t*,MDL_ticket*>> tables;
|
|
|
|
/** Constructor */
|
|
explicit purge_node_t(que_thr_t *parent) :
|
|
common(QUE_NODE_PURGE, parent), heap(mem_heap_create(256)),
|
|
tables(TRX_PURGE_TABLE_BUCKETS) {}
|
|
|
|
#ifdef UNIV_DEBUG
|
|
/** Validate the persistent cursor. The purge node has two references
|
|
to the clustered index record: ref and pcur, which must match
|
|
each other if found_clust.
|
|
@return whether pcur is consistent with ref */
|
|
bool validate_pcur();
|
|
#endif
|
|
|
|
/** Start processing an undo log record. */
|
|
inline void start();
|
|
|
|
/** Reset the state at end
|
|
@return the query graph parent */
|
|
inline que_node_t *end(THD *);
|
|
};
|