1berry/MariaDB-server
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

MDEV-19747: Deprecate and ignore innodb_log_optimize_ddl

Browse Source 
During native table rebuild or index creation, InnoDB used to skip
redo logging and write MLOG_INDEX_LOAD records to inform crash recovery
and Mariabackup of the gaps in redo log. This is fragile and prohibits
some optimizations, such as skipping the doublewrite buffer for
newly (re)initialized pages (MDEV-19738).

row_merge_write_redo(): Remove. We do not write MLOG_INDEX_LOAD
records any more. Instead, we write full redo log.

FlushObserver: Remove.

fseg_free_page_func(): Remove the parameter log. Redo logging
cannot be disabled.

fil_space_t::redo_skipped_count: Remove.

We cannot remove buf_block_t::skip_flush_check, because PageBulk
will temporarily generate invalid B-tree pages in the buffer pool.
This commit is contained in:
Marko Mäkelä 2020-02-11 18:44:26 +02:00
parent 8ccb3caafb
commit fc2f2fa853
46 changed files with 127 additions and 964 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
mysql-test/suite/innodb/r/innodb_bulk_create_index_flush.result
View File

@ -1,54 +0,0 @@
CREATE PROCEDURE populate_t1()
BEGIN
DECLARE i int DEFAULT 1;
START TRANSACTION;
WHILE (i <= 10000) DO
INSERT INTO t1 VALUES (i, i, CONCAT('a', i));
SET i = i + 1;
END WHILE;
COMMIT;
END|
CREATE TABLE t1(
class INT,
id INT,
title VARCHAR(100)
) ENGINE=InnoDB;
SELECT COUNT(*) FROM t1;
COUNT(*)
10000
SET @saved_dbug= @@SESSION.debug_dbug;
SET debug_dbug='+d,ib_index_build_fail_before_flush';
CREATE INDEX idx_id ON t1(id);
ERROR 70100: Query execution was interrupted
CHECK TABLE t1;
Table Op Msg_type Msg_text
test.t1 check status OK
CREATE INDEX idx_title ON t1(title);
ERROR 70100: Query execution was interrupted
CHECK TABLE t1;
Table Op Msg_type Msg_text
test.t1 check status OK
CREATE FULLTEXT INDEX fidx_title ON t1(title);
ERROR 70100: Query execution was interrupted
CHECK TABLE t1;
Table Op Msg_type Msg_text
test.t1 check status OK
ALTER TABLE t1 ADD COLUMN content TEXT, FORCE;
ERROR 70100: Query execution was interrupted
CHECK TABLE t1;
Table Op Msg_type Msg_text
test.t1 check status OK
SET debug_dbug= @saved_dbug;
INSERT INTO t1 VALUES(10001, 10001, 'a10000');
ALTER TABLE t1 ADD UNIQUE INDEX idx_title(title);
ERROR 23000: Duplicate entry 'a10000' for key 'idx_title'
CHECK TABLE t1;
Table Op Msg_type Msg_text
test.t1 check status OK
ALTER TABLE t1 ADD UNIQUE INDEX idx_id(id), ADD UNIQUE INDEX idx_title(title);
ERROR 23000: Duplicate entry 'a10000' for key 'idx_title'
CHECK TABLE t1;
Table Op Msg_type Msg_text
test.t1 check status OK
DROP TABLE t1;
DROP PROCEDURE populate_t1;

2
mysql-test/suite/innodb/r/log_alter_table.result
View File

@ -13,7 +13,7 @@ ALTER TABLE t1 DROP INDEX b, ADD INDEX (b), LOCK=SHARED;
# Kill the server
# restart: --debug=d,ib_log
FOUND 2 /scan \d+: multi-log rec MLOG_FILE_CREATE2 len \d+ page \d+:0/ in mysqld.1.err
FOUND 3 /scan \d+: log rec MLOG_INDEX_LOAD/ in mysqld.1.err
NOT FOUND /scan \d+: log rec MLOG_INDEX_LOAD/ in mysqld.1.err
CHECK TABLE t1;
Table Op Msg_type Msg_text
test.t1 check status OK

75
mysql-test/suite/innodb/t/innodb_bulk_create_index_flush.test
View File

@ -1,75 +0,0 @@
#
# Test flush on error in bulk load to make sure we do a proper cleanup.
# Note: We flush all dirty pages before applying any online log in bulk load.
#
-- source include/have_innodb.inc
-- source include/have_debug.inc
# Create Insert Procedure
DELIMITER |;
CREATE PROCEDURE populate_t1()
BEGIN
DECLARE i int DEFAULT 1;
START TRANSACTION;
WHILE (i <= 10000) DO
INSERT INTO t1 VALUES (i, i, CONCAT('a', i));
SET i = i + 1;
END WHILE;
COMMIT;
END|
DELIMITER ;|
CREATE TABLE t1(
class INT,
id INT,
title VARCHAR(100)
) ENGINE=InnoDB;
-- disable_query_log
CALL populate_t1();
-- enable_query_log
SELECT COUNT(*) FROM t1;
SET @saved_dbug= @@SESSION.debug_dbug;
SET debug_dbug='+d,ib_index_build_fail_before_flush';
-- error ER_QUERY_INTERRUPTED
CREATE INDEX idx_id ON t1(id);
CHECK TABLE t1;
-- error ER_QUERY_INTERRUPTED
CREATE INDEX idx_title ON t1(title);
CHECK TABLE t1;
-- error ER_QUERY_INTERRUPTED
CREATE FULLTEXT INDEX fidx_title ON t1(title);
CHECK TABLE t1;
-- error ER_QUERY_INTERRUPTED
ALTER TABLE t1 ADD COLUMN content TEXT, FORCE;
CHECK TABLE t1;
SET debug_dbug= @saved_dbug;
INSERT INTO t1 VALUES(10001, 10001, 'a10000');
-- error ER_DUP_ENTRY
ALTER TABLE t1 ADD UNIQUE INDEX idx_title(title);
CHECK TABLE t1;
-- error ER_DUP_ENTRY
ALTER TABLE t1 ADD UNIQUE INDEX idx_id(id), ADD UNIQUE INDEX idx_title(title);
CHECK TABLE t1;
DROP TABLE t1;
DROP PROCEDURE populate_t1;

3
mysql-test/suite/innodb/t/log_alter_table.test
View File

@ -30,11 +30,10 @@ ALTER TABLE t1 DROP INDEX b, ADD INDEX (b), LOCK=SHARED;
--source include/start_mysqld.inc
let SEARCH_FILE = $MYSQLTEST_VARDIR/log/mysqld.1.err;
let SEARCH_ABORT=NOT FOUND;
# ensure that we have exactly 2 records there.
let SEARCH_PATTERN=scan \d+: multi-log rec MLOG_FILE_CREATE2 len \d+ page \d+:0;
--source include/search_pattern_in_file.inc
# ensure that we have exactly 3 records there.
# ensure that we have 0 records there.
let SEARCH_PATTERN=scan \d+: log rec MLOG_INDEX_LOAD;
--source include/search_pattern_in_file.inc

37
mysql-test/suite/mariabackup/innodb_log_optimize_ddl.result
View File

@ -1,37 +0,0 @@
SET GLOBAL innodb_log_optimize_ddl=OFF;
CREATE TABLE tz(id BIGINT PRIMARY KEY, i INT)
ENGINE=InnoDB ROW_FORMAT=COMPRESSED;
INSERT INTO tz(id) select * from seq_1_to_10000;
CREATE TABLE tr(id BIGINT PRIMARY KEY, i INT)
ENGINE=InnoDB ROW_FORMAT=REDUNDANT;
INSERT INTO tr(id) select * from seq_1_to_10000;
CREATE TABLE td(id BIGINT PRIMARY KEY, i INT)
ENGINE=InnoDB;
INSERT INTO td(id) select * from seq_1_to_10000;
CREATE PROCEDURE a()
BEGIN
ALTER TABLE tz ADD INDEX(i);
ALTER TABLE tr ADD INDEX(i);
ALTER TABLE td ADD INDEX(i);
END //
call a();
# shutdown server
# remove datadir
# xtrabackup move back
# restart
DROP PROCEDURE a;
CHECK TABLE tz,tr,td;
Table Op Msg_type Msg_text
test.tz check status OK
test.tr check status OK
test.td check status OK
SELECT COUNT(*) FROM tz;
COUNT(*)
10000
SELECT COUNT(*) FROM tr;
COUNT(*)
10000
SELECT COUNT(*) FROM td;
COUNT(*)
10000
DROP TABLE tz,tr,td;

47
mysql-test/suite/mariabackup/innodb_log_optimize_ddl.test
View File

@ -1,47 +0,0 @@
# see unsupported_redo.test for the opposite (default) case
--source include/have_innodb.inc
--source include/have_sequence.inc
SET GLOBAL innodb_log_optimize_ddl=OFF;
CREATE TABLE tz(id BIGINT PRIMARY KEY, i INT)
ENGINE=InnoDB ROW_FORMAT=COMPRESSED;
INSERT INTO tz(id) select * from seq_1_to_10000;
CREATE TABLE tr(id BIGINT PRIMARY KEY, i INT)
ENGINE=InnoDB ROW_FORMAT=REDUNDANT;
INSERT INTO tr(id) select * from seq_1_to_10000;
CREATE TABLE td(id BIGINT PRIMARY KEY, i INT)
ENGINE=InnoDB;
INSERT INTO td(id) select * from seq_1_to_10000;
DELIMITER //;
CREATE PROCEDURE a()
BEGIN
ALTER TABLE tz ADD INDEX(i);
ALTER TABLE tr ADD INDEX(i);
ALTER TABLE td ADD INDEX(i);
END //
DELIMITER ;//
let $targetdir=$MYSQLTEST_VARDIR/tmp/backup;
send call a();
--disable_result_log
exec $XTRABACKUP --defaults-file=$MYSQLTEST_VARDIR/my.cnf --backup --target-dir=$targetdir;
--enable_result_log
exec $XTRABACKUP --prepare --target-dir=$targetdir;
reap;
-- source include/restart_and_restore.inc
--rmdir $targetdir
DROP PROCEDURE a;
CHECK TABLE tz,tr,td;
SELECT COUNT(*) FROM tz;
SELECT COUNT(*) FROM tr;
SELECT COUNT(*) FROM td;
DROP TABLE tz,tr,td;

15
mysql-test/suite/mariabackup/mlog_index_load.result
View File

@ -1,15 +0,0 @@
CREATE TABLE t1(i INT PRIMARY KEY auto_increment, a int) ENGINE INNODB;
INSERT INTO t1(a) SELECT * from seq_1_to_10000;
# xtrabackup backup
t1.frm
t1.ibd
t1.new
# xtrabackup prepare
# shutdown server
# remove datadir
# xtrabackup move back
# restart
SELECT COUNT(*) from t1;
COUNT(*)
10000
DROP TABLE t1;

27
mysql-test/suite/mariabackup/mlog_index_load.test
View File

@ -1,27 +0,0 @@
--source include/have_debug.inc
CREATE TABLE t1(i INT PRIMARY KEY auto_increment, a int) ENGINE INNODB;
INSERT INTO t1(a) SELECT * from seq_1_to_10000;
let $targetdir=$MYSQLTEST_VARDIR/tmp/backup;
let after_copy_test_t1=CREATE INDEX a_ind ON test.t1(a) ALGORITHM=INPLACE;
echo # xtrabackup backup;
--disable_result_log
exec $XTRABACKUP --defaults-file=$MYSQLTEST_VARDIR/my.cnf --backup --target-dir=$targetdir --dbug=+d,mariabackup_events;
--enable_result_log
--list_files $targetdir/test t1*
--let before_copy_test_t1=
echo # xtrabackup prepare;
--disable_result_log
exec $XTRABACKUP --prepare --target-dir=$targetdir;
-- source include/restart_and_restore.inc
--enable_result_log
# Check that new table is there after restore.
SELECT COUNT(*) from t1;
DROP TABLE t1;
rmdir $targetdir;

6
mysql-test/suite/sys_vars/r/innodb_log_optimize_ddl_basic.result
View File

@ -7,7 +7,11 @@ ERROR HY000: Variable 'innodb_log_optimize_ddl' is a GLOBAL variable
Expected error 'Variable is a GLOBAL variable'
SELECT @@GLOBAL.innodb_log_optimize_ddl INTO @innodb_log_optimize_ddl_save;
SET @@GLOBAL.innodb_log_optimize_ddl = ON;
Warnings:
Warning 138 The parameter innodb_log_optimize_ddl is deprecated and has no effect.
SET @@GLOBAL.innodb_log_optimize_ddl = OFF;
Warnings:
Warning 138 The parameter innodb_log_optimize_ddl is deprecated and has no effect.
SET @@GLOBAL.innodb_log_optimize_ddl = 13;
ERROR 42000: Variable 'innodb_log_optimize_ddl' can't be set to the value of '13'
SET @@GLOBAL.innodb_log_optimize_ddl = 'ABC';
@ -34,3 +38,5 @@ Expected error 'Variable is a GLOBAL variable'
SELECT innodb_log_optimize_ddl;
ERROR 42S22: Unknown column 'innodb_log_optimize_ddl' in 'field list'
SET GLOBAL innodb_log_optimize_ddl = @innodb_log_optimize_ddl_save;
Warnings:
Warning 138 The parameter innodb_log_optimize_ddl is deprecated and has no effect.

4
mysql-test/suite/sys_vars/r/sysvars_innodb.result
View File

@ -1259,10 +1259,10 @@ READ_ONLY YES
COMMAND_LINE_ARGUMENT REQUIRED
VARIABLE_NAME INNODB_LOG_OPTIMIZE_DDL
SESSION_VALUE NULL
DEFAULT_VALUE ON
DEFAULT_VALUE OFF
VARIABLE_SCOPE GLOBAL
VARIABLE_TYPE BOOLEAN
VARIABLE_COMMENT Reduce redo logging when natively creating indexes or rebuilding tables. Setting this OFF avoids delay due to page flushing and allows concurrent backup.
VARIABLE_COMMENT Deprecated parameter with no effect.
NUMERIC_MIN_VALUE NULL
NUMERIC_MAX_VALUE NULL
NUMERIC_BLOCK_SIZE NULL

4
storage/innobase/btr/btr0btr.cc
View File

@ -2,7 +2,7 @@
Copyright (c) 1994, 2016, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2012, Facebook Inc.
Copyright (c) 2014, 2019, MariaDB Corporation.
Copyright (c) 2014, 2020, 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
@ -747,7 +747,7 @@ void btr_page_free(dict_index_t* index, buf_block_t* block, mtr_t* mtr,
: PAGE_HEADER + PAGE_BTR_SEG_TOP];
fseg_free_page(seg_header,
index->table->space, block->page.id.page_no(),
block->index != NULL, !block->page.flush_observer, mtr);
block->index != NULL, mtr);
/* The page was marked free in the allocation bitmap, but it
should remain exclusively latched until mtr_t::commit() or until it

41
storage/innobase/btr/btr0bulk.cc
View File

@ -1,7 +1,7 @@
/*****************************************************************************
Copyright (c) 2014, 2019, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2017, 2019, MariaDB Corporation.
Copyright (c) 2017, 2020, 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
@ -33,8 +33,6 @@ Created 03/11/2014 Shaohua Wang
/** Innodb B-tree index fill factor for bulk load. */
uint innobase_fill_factor;
/** whether to reduce redo logging during ALTER TABLE */
my_bool innodb_log_optimize_ddl;
/** Initialize members, allocate page if needed and start mtr.
Note: we commit all mtrs on failure.
@ -51,13 +49,7 @@ PageBulk::init()
m_heap = mem_heap_create(1000);
m_mtr.start();
if (m_flush_observer) {
m_mtr.set_log_mode(MTR_LOG_NO_REDO);
m_mtr.set_flush_observer(m_flush_observer);
} else {
m_index->set_modified(m_mtr);
}
m_index->set_modified(m_mtr);
if (m_page_no == FIL_NULL) {
mtr_t alloc_mtr;
@ -233,7 +225,7 @@ inline void PageBulk::insertPage(const rec_t *rec, offset_t *offsets)
m_heap_top += rec_size;
m_rec_no += 1;
if (!m_flush_observer && !m_page_zip) {
if (!m_page_zip) {
/* For ROW_FORMAT=COMPRESSED, redo log may be written
in PageBulk::compress(). */
page_cur_insert_rec_write_log(insert_rec, rec_size,
@ -322,7 +314,7 @@ inline void PageBulk::finishPage()
ut_ad(!page_get_instant(m_page));
ut_ad(!mach_read_from_2(PAGE_HEADER + PAGE_N_DIRECTION + m_page));
if (fmt != COMPRESSED && !m_flush_observer) {
if (fmt != COMPRESSED) {
m_mtr.write<2,mtr_t::OPT>(*m_block,
PAGE_HEADER + PAGE_N_DIR_SLOTS
+ m_page, 2 + slot_index);
@ -671,13 +663,7 @@ dberr_t
PageBulk::latch()
{
m_mtr.start();
if (m_flush_observer) {
m_mtr.set_log_mode(MTR_LOG_NO_REDO);
m_mtr.set_flush_observer(m_flush_observer);
} else {
m_index->set_modified(m_mtr);
}
m_index->set_modified(m_mtr);
/* In case the block is S-latched by page_cleaner. */
if (!buf_page_optimistic_get(RW_X_LATCH, m_block, m_modify_clock,
@ -720,7 +706,7 @@ BtrBulk::pageSplit(
/* 2. create a new page. */
PageBulk new_page_bulk(m_index, m_trx->id, FIL_NULL,
page_bulk->getLevel(), m_flush_observer);
page_bulk->getLevel());
dberr_t err = new_page_bulk.init();
if (err != DB_SUCCESS) {
return(err);
@ -855,7 +841,7 @@ BtrBulk::insert(
if (level + 1 > m_page_bulks.size()) {
PageBulk* new_page_bulk
= UT_NEW_NOKEY(PageBulk(m_index, m_trx->id, FIL_NULL,
level, m_flush_observer));
level));
err = new_page_bulk->init();
if (err != DB_SUCCESS) {
UT_DELETE(new_page_bulk);
@ -909,8 +895,7 @@ BtrBulk::insert(
/* Create a sibling page_bulk. */
PageBulk* sibling_page_bulk;
sibling_page_bulk = UT_NEW_NOKEY(PageBulk(m_index, m_trx->id,
FIL_NULL, level,
m_flush_observer));
FIL_NULL, level));
err = sibling_page_bulk->init();
if (err != DB_SUCCESS) {
UT_DELETE(sibling_page_bulk);
@ -935,10 +920,6 @@ BtrBulk::insert(
/* Important: log_free_check whether we need a checkpoint. */
if (page_is_leaf(sibling_page_bulk->getPage())) {
if (trx_is_interrupted(m_trx)) {
if (m_flush_observer) {
m_flush_observer->interrupted();
}
err = DB_INTERRUPTED;
goto func_exit;
}
@ -1032,8 +1013,7 @@ BtrBulk::finish(dberr_t err)
mtr_t mtr;
buf_block_t* last_block;
PageBulk root_page_bulk(m_index, m_trx->id,
m_index->page, m_root_level,
m_flush_observer);
m_index->page, m_root_level);
mtr.start();
m_index->set_modified(mtr);
@ -1057,9 +1037,6 @@ BtrBulk::finish(dberr_t err)
/* Remove last page. */
btr_page_free(m_index, last_block, &mtr);
/* Do not flush the last page. */
last_block->page.flush_observer = NULL;
mtr.commit();
err = pageCommit(&root_page_bulk, NULL, false);

3
storage/innobase/btr/btr0cur.cc
View File

@ -7347,7 +7347,6 @@ struct btr_blob_log_check_t {
dict_index_t* index = m_pcur->index();
ulint offs = 0;
ulint page_no = ULINT_UNDEFINED;
FlushObserver* observer = m_mtr->get_flush_observer();
if (UNIV_UNLIKELY(m_op == BTR_STORE_INSERT_BULK)) {
offs = page_offset(*m_rec);
@ -7368,7 +7367,6 @@ struct btr_blob_log_check_t {
m_mtr->start();
m_mtr->set_log_mode(log_mode);
index->set_modified(*m_mtr);
m_mtr->set_flush_observer(observer);
if (UNIV_UNLIKELY(m_op == BTR_STORE_INSERT_BULK)) {
m_pcur->btr_cur.page_cur.block = btr_block_get(
@ -7563,7 +7561,6 @@ btr_store_big_rec_extern_fields(
mtr.start();
index->set_modified(mtr);
mtr.set_log_mode(btr_mtr->get_log_mode());
mtr.set_flush_observer(btr_mtr->get_flush_observer());
buf_page_get(rec_block->page.id,
rec_block->zip_size(), RW_X_LATCH, &mtr);

2
storage/innobase/buf/buf0buf.cc
View File

@ -1496,7 +1496,6 @@ buf_block_init(
block->page.state = BUF_BLOCK_NOT_USED;
block->page.buf_fix_count = 0;
block->page.io_fix = BUF_IO_NONE;
block->page.flush_observer = NULL;
block->page.init_on_flush = false;
block->page.real_size = 0;
block->page.write_size = 0;
@ -5336,7 +5335,6 @@ buf_page_init_for_read(
bpage->state = BUF_BLOCK_ZIP_PAGE;
bpage->id = page_id;
bpage->flush_observer = NULL;
bpage->init_on_flush = false;
ut_d(bpage->in_page_hash = FALSE);

155
storage/innobase/buf/buf0flu.cc
View File

@ -623,14 +623,6 @@ buf_flush_remove(
ut_a(buf_flush_validate_skip(buf_pool));
#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
/* If there is an observer that want to know if the asynchronous
flushing was done then notify it. */
if (bpage->flush_observer != NULL) {
bpage->flush_observer->notify_remove(buf_pool, bpage);
bpage->flush_observer = NULL;
}
buf_flush_list_mutex_exit(buf_pool);
}
@ -1362,19 +1354,6 @@ buf_flush_page(
rw_lock_sx_lock_gen(rw_lock, BUF_IO_WRITE);
}
/* If there is an observer that want to know if the asynchronous
flushing was sent then notify it.
Note: we set flush observer to a page with x-latch, so we can
guarantee that notify_flush and notify_remove are called in pair
with s-latch on a uncompressed page. */
if (bpage->flush_observer != NULL) {
buf_pool_mutex_enter(buf_pool);
bpage->flush_observer->notify_flush(buf_pool, bpage);
buf_pool_mutex_exit(buf_pool);
}
/* Even though bpage is not protected by any mutex at this
point, it is safe to access bpage, because it is io_fixed and
oldest_modification != 0. Thus, it cannot be relocated in the
@ -3674,9 +3653,7 @@ ulint
buf_pool_get_dirty_pages_count(
/*===========================*/
buf_pool_t* buf_pool, /*!< in: buffer pool */
ulint id, /*!< in: space id to check */
FlushObserver* observer) /*!< in: flush observer to check */
ulint id) /*!< in: space id to check */
{
ulint count = 0;
@ -3693,10 +3670,7 @@ buf_pool_get_dirty_pages_count(
ut_ad(bpage->in_flush_list);
ut_ad(bpage->oldest_modification > 0);
if ((observer != NULL
&& observer == bpage->flush_observer)
|| (observer == NULL
&& id == bpage->id.space())) {
if (id == bpage->id.space()) {
++count;
}
}
@ -3706,128 +3680,3 @@ buf_pool_get_dirty_pages_count(
return(count);
}
/******************************************************************//**
Check if there are any dirty pages that belong to a space id in the flush list.
@return number of dirty pages present in all the buffer pools */
static
ulint
buf_flush_get_dirty_pages_count(
/*============================*/
ulint id, /*!< in: space id to check */
FlushObserver* observer) /*!< in: flush observer to check */
{
ulint count = 0;
for (ulint i = 0; i < srv_buf_pool_instances; ++i) {
buf_pool_t* buf_pool;
buf_pool = buf_pool_from_array(i);
count += buf_pool_get_dirty_pages_count(buf_pool, id, observer);
}
return(count);
}
/** FlushObserver constructor
@param[in] space tablespace
@param[in] trx trx instance
@param[in] stage performance schema accounting object,
used by ALTER TABLE. It is passed to log_preflush_pool_modified_pages()
for accounting. */
FlushObserver::FlushObserver(
fil_space_t* space,
trx_t* trx,
ut_stage_alter_t* stage)
:
m_space(space),
m_trx(trx),
m_stage(stage),
m_interrupted(false)
{
m_flushed = UT_NEW_NOKEY(std::vector<ulint>(srv_buf_pool_instances));
m_removed = UT_NEW_NOKEY(std::vector<ulint>(srv_buf_pool_instances));
for (ulint i = 0; i < srv_buf_pool_instances; i++) {
m_flushed->at(i) = 0;
m_removed->at(i) = 0;
}
DBUG_LOG("flush", "FlushObserver(): trx->id=" << m_trx->id);
}
/** FlushObserver deconstructor */
FlushObserver::~FlushObserver()
{
ut_ad(buf_flush_get_dirty_pages_count(m_space->id, this) == 0);
UT_DELETE(m_flushed);
UT_DELETE(m_removed);
DBUG_LOG("flush", "~FlushObserver(): trx->id=" << m_trx->id);
}
/** Check whether the operation has been interrupted */
void FlushObserver::check_interrupted()
{
if (trx_is_interrupted(m_trx)) {
interrupted();
}
}
/** Notify observer of a flush
@param[in] buf_pool buffer pool instance
@param[in] bpage buffer page to flush */
void
FlushObserver::notify_flush(
buf_pool_t* buf_pool,
buf_page_t* bpage)
{
ut_ad(buf_pool_mutex_own(buf_pool));
m_flushed->at(buf_pool->instance_no)++;
if (m_stage != NULL) {
m_stage->inc();
}
DBUG_LOG("flush", "Flush " << bpage->id);
}
/** Notify observer of a remove
@param[in] buf_pool buffer pool instance
@param[in] bpage buffer page flushed */
void
FlushObserver::notify_remove(
buf_pool_t* buf_pool,
buf_page_t* bpage)
{
ut_ad(buf_pool_mutex_own(buf_pool));
m_removed->at(buf_pool->instance_no)++;
DBUG_LOG("flush", "Remove " << bpage->id);
}
/** Flush dirty pages and wait. */
void
FlushObserver::flush()
{
ut_ad(m_trx);
if (!m_interrupted && m_stage) {
m_stage->begin_phase_flush(buf_flush_get_dirty_pages_count(
m_space->id, this));
}
buf_LRU_flush_or_remove_pages(m_space->id, this);
/* Wait for all dirty pages were flushed. */
for (ulint i = 0; i < srv_buf_pool_instances; i++) {
while (!is_complete(i)) {
os_thread_sleep(2000);
}
}
}

93
storage/innobase/buf/buf0lru.cc
View File

@ -1,7 +1,7 @@
/*****************************************************************************
Copyright (c) 1995, 2016, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2017, 2019, MariaDB Corporation.
Copyright (c) 2017, 2020, 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
@ -466,19 +466,13 @@ buf_flush_try_yield(
return(false);
}
/******************************************************************//**
Removes a single page from a given tablespace inside a specific
buffer pool instance.
/** Remove a single page from flush_list.
@param[in,out] buf_pool buffer pool
@param[in,out] bpage buffer page to remove
@param[in] flush whether to flush the page before removing
@return true if page was removed. */
static MY_ATTRIBUTE((warn_unused_result))
bool
buf_flush_or_remove_page(
/*=====================*/
buf_pool_t* buf_pool, /*!< in/out: buffer pool instance */
buf_page_t* bpage, /*!< in/out: bpage to remove */
bool flush) /*!< in: flush to disk if true but
don't remove else remove without
flushing to disk */
static bool buf_flush_or_remove_page(buf_pool_t* buf_pool, buf_page_t* bpage,
bool flush)
{
ut_ad(buf_pool_mutex_own(buf_pool));
ut_ad(buf_flush_list_mutex_own(buf_pool));
@ -551,17 +545,11 @@ 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[in,out] buf_pool buffer pool
@param[in] id tablespace identifier
@param[in] observer flush observer (to check for interrupt),
or NULL if the files should not be written to
@param[in] flush whether to flush the pages before removing
@param[in] first first page to be flushed or evicted
@return whether all matching dirty pages were removed */
static MY_ATTRIBUTE((warn_unused_result))
bool
buf_flush_or_remove_pages(
buf_pool_t* buf_pool,
ulint id,
FlushObserver* observer,
ulint first)
static bool buf_flush_or_remove_pages(buf_pool_t* buf_pool, ulint id,
bool flush, ulint first)
{
buf_page_t* prev;
buf_page_t* bpage;
@ -583,29 +571,12 @@ rescan:
prev = UT_LIST_GET_PREV(list, bpage);
/* Flush the pages matching space id,
or pages matching the flush observer. */
if (observer && observer->is_partial_flush()) {
if (observer != bpage->flush_observer) {
/* Skip this block. */
} else if (!buf_flush_or_remove_page(
buf_pool, bpage,
!observer->is_interrupted())) {
all_freed = false;
} else if (!observer->is_interrupted()) {
/* The processing was successful. And during the
processing we have released the buf_pool mutex
when calling buf_page_flush(). We cannot trust
prev pointer. */
goto rescan;
}
} else if (id != bpage->id.space()) {
if (id != bpage->id.space()) {
/* Skip this block, because it is for a
different tablespace. */
} else if (bpage->id.page_no() < first) {
/* Skip this block, because it is below the limit. */
} else if (!buf_flush_or_remove_page(
buf_pool, bpage, observer != NULL)) {
} else if (!buf_flush_or_remove_page(buf_pool, bpage, flush)) {
/* Remove was unsuccessful, we have to try again
by scanning the entire list from the end.
@ -628,7 +599,7 @@ rescan:
iteration. */
all_freed = false;
} else if (observer) {
} else if (flush) {
/* The processing was successful. And during the
processing we have released the buf_pool mutex
@ -646,12 +617,6 @@ rescan:
processed = 0;
}
/* The check for trx is interrupted is expensive, we want
to check every N iterations. */
if (!processed && observer) {
observer->check_interrupted();
}
}
buf_flush_list_mutex_exit(buf_pool);
@ -665,21 +630,15 @@ list and will be evicted from the LRU list as they age and move towards
the tail of the LRU list.
@param[in,out] buf_pool buffer pool
@param[in] id tablespace identifier
@param[in] observer flush observer,
or NULL if the files should not be written to
@param[in] flush whether to flush the pages before removing
@param[in] first first page to be flushed or evicted */
static
void
buf_flush_dirty_pages(
buf_pool_t* buf_pool,
ulint id,
FlushObserver* observer,
ulint first)
static void buf_flush_dirty_pages(buf_pool_t* buf_pool, ulint id, bool flush,
ulint first)
{
for (;;) {
buf_pool_mutex_enter(buf_pool);
bool freed = buf_flush_or_remove_pages(buf_pool, id, observer,
bool freed = buf_flush_or_remove_pages(buf_pool, id, flush,
first);
buf_pool_mutex_exit(buf_pool);
@ -694,28 +653,25 @@ buf_flush_dirty_pages(
ut_ad(buf_flush_validate(buf_pool));
}
ut_ad((observer && observer->is_interrupted())
|| first
|| buf_pool_get_dirty_pages_count(buf_pool, id, observer) == 0);
ut_ad(first
|| buf_pool_get_dirty_pages_count(buf_pool, id) == 0);
}
/** Empty the flush list for all pages belonging to a tablespace.
@param[in] id tablespace identifier
@param[in] observer flush observer,
or NULL if nothing is to be written
@param[in] flush whether to write the pages to files
@param[in] first first page to be flushed or evicted */
void buf_LRU_flush_or_remove_pages(ulint id, FlushObserver* observer,
ulint first)
void buf_LRU_flush_or_remove_pages(ulint id, bool flush, ulint first)
{
/* Pages in the system tablespace must never be discarded. */
ut_ad(id || observer);
ut_ad(id || flush);
for (ulint i = 0; i < srv_buf_pool_instances; i++) {
buf_flush_dirty_pages(buf_pool_from_array(i), id, observer,
buf_flush_dirty_pages(buf_pool_from_array(i), id, flush,
first);
}
if (observer && !observer->is_interrupted()) {
if (flush) {
/* Ensure that all asynchronous IO is completed. */
os_aio_wait_until_no_pending_writes();
fil_flush(id);
@ -1105,7 +1061,6 @@ loop:
memset(&block->page.zip, 0, sizeof block->page.zip);
block->skip_flush_check = false;
block->page.flush_observer = NULL;
return(block);
}

6
storage/innobase/fil/fil0fil.cc
View File

@ -2253,11 +2253,7 @@ fil_close_tablespace(
buffer pool. Thus we can clean the tablespace out of the buffer pool
completely and permanently. The flag stop_new_ops also prevents
fil_flush() from being applied to this tablespace. */
{
FlushObserver observer(space, trx, NULL);
buf_LRU_flush_or_remove_pages(id, &observer);
}
buf_LRU_flush_or_remove_pages(id, true);
/* If the free is successful, the X lock will be released before
the space memory data structure is freed. */

34
storage/innobase/fsp/fsp0fsp.cc
View File

@ -1,7 +1,7 @@
/*****************************************************************************
Copyright (c) 1995, 2016, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2017, 2019, MariaDB Corporation.
Copyright (c) 2017, 2020, 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
@ -515,8 +515,7 @@ void fil_space_t::modify_check(const mtr_t& mtr) const
break;
case MTR_LOG_NO_REDO:
ut_ad(purpose == FIL_TYPE_TEMPORARY
|| purpose == FIL_TYPE_IMPORT
|| redo_skipped_count);
|| purpose == FIL_TYPE_IMPORT);
return;
case MTR_LOG_ALL:
/* We may only write redo log for a persistent
@ -1223,10 +1222,8 @@ fsp_alloc_free_page(
The page is marked as free and clean.
@param[in,out] space tablespace
@param[in] offset page number
@param[in] log whether to write MLOG_INIT_FREE_PAGE record
@param[in,out] mtr mini-transaction */
static void fsp_free_page(fil_space_t* space, page_no_t offset,
bool log, mtr_t* mtr)
static void fsp_free_page(fil_space_t* space, page_no_t offset, mtr_t* mtr)
{
xdes_t* descr;
ulint state;
@ -1278,12 +1275,7 @@ static void fsp_free_page(fil_space_t* space, page_no_t offset,
return;
}
if (UNIV_UNLIKELY(!log)) {
/* The last page freed in BtrBulk::finish() must be
written with redo logging disabled for the page
itself. The modifications of the allocation data
structures are covered by redo log. */
} else if (byte* log_ptr = mlog_open(mtr, 11)) {
if (byte* log_ptr = mlog_open(mtr, 11)) {
log_ptr = mlog_write_initial_log_record_low(
MLOG_INIT_FREE_PAGE, space->id, offset, log_ptr, mtr);
mlog_close(mtr, log_ptr);
@ -1532,7 +1524,7 @@ static void fsp_free_seg_inode(
/* There are no other used headers left on the page: free it */
flst_remove(header, FSP_HEADER_OFFSET + FSP_SEG_INODES_FREE,
iblock, FSEG_INODE_PAGE_NODE, mtr);
fsp_free_page(space, iblock->page.id.page_no(), true, mtr);
fsp_free_page(space, iblock->page.id.page_no(), mtr);
}
}
@ -2529,7 +2521,6 @@ try_to_extend:
@param[in] offset page number
@param[in] ahi whether we may need to drop the adaptive
hash index
@param[in] log whether to write MLOG_INIT_FREE_PAGE record
@param[in,out] mtr mini-transaction */
static
void
@ -2541,7 +2532,6 @@ fseg_free_page_low(
#ifdef BTR_CUR_HASH_ADAPT
bool ahi,
#endif /* BTR_CUR_HASH_ADAPT */
bool log,
mtr_t* mtr)
{
ib_id_t descr_id;
@ -2592,7 +2582,7 @@ fseg_free_page_low(
break;
}
fsp_free_page(space, offset, log, mtr);
fsp_free_page(space, offset, mtr);
return;
}
@ -2647,8 +2637,8 @@ fseg_free_page_low(
}
#ifndef BTR_CUR_HASH_ADAPT
# define fseg_free_page_low(inode, space, offset, ahi, log, mtr) \
fseg_free_page_low(inode, space, offset, log, mtr)
# define fseg_free_page_low(inode, space, offset, ahi, mtr) \
fseg_free_page_low(inode, space, offset, mtr)
#endif /* !BTR_CUR_HASH_ADAPT */
/** Free a page in a file segment.
@ -2657,7 +2647,6 @@ fseg_free_page_low(
@param[in] offset page number
@param[in] ahi whether we may need to drop the adaptive
hash index
@param[in] log whether to write MLOG_INIT_FREE_PAGE record
@param[in,out] mtr mini-transaction */
void
fseg_free_page_func(
@ -2667,7 +2656,6 @@ fseg_free_page_func(
#ifdef BTR_CUR_HASH_ADAPT
bool ahi,
#endif /* BTR_CUR_HASH_ADAPT */
bool log,
mtr_t* mtr)
{
DBUG_ENTER("fseg_free_page");
@ -2685,7 +2673,7 @@ fseg_free_page_func(
fil_block_check_type(*iblock, FIL_PAGE_INODE, mtr);
}
fseg_free_page_low(seg_inode, iblock, space, offset, ahi, log, mtr);
fseg_free_page_low(seg_inode, iblock, space, offset, ahi, mtr);
ut_d(buf_page_set_file_page_was_freed(page_id_t(space->id, offset)));
@ -2878,7 +2866,7 @@ fseg_free_step_func(
fseg_free_page_low(
inode, iblock, space,
fseg_get_nth_frag_page_no(inode, n, mtr),
ahi, true, mtr);
ahi, mtr);
n = fseg_find_last_used_frag_page_slot(inode, mtr);
@ -2951,7 +2939,7 @@ fseg_free_step_not_header_func(
return(true);
}
fseg_free_page_low(inode, iblock, space, page_no, ahi, true, mtr);
fseg_free_page_low(inode, iblock, space, page_no, ahi, mtr);
return(false);
}

25
storage/innobase/handler/ha_innodb.cc
View File

@ -3470,6 +3470,11 @@ static my_bool innodb_log_checksums;
/** Deprecation message for innodb_log_checksums */
static const char* innodb_log_checksums_deprecated
= "The parameter innodb_log_checksums is deprecated and has no effect.";
/** Deprecated parameter with no effect */
static my_bool innodb_log_optimize_ddl;
static const char* innodb_log_optimize_ddl_deprecated
= "The parameter innodb_log_optimize_ddl is deprecated and has no effect.";
/** Deprecated parameter with no effect */
static ulong innodb_undo_logs;
/** Deprecation message for innodb_undo_logs */
@ -3779,6 +3784,11 @@ static int innodb_init_params()
innodb_log_checksums = TRUE;
}
if (UNIV_UNLIKELY(innodb_log_optimize_ddl)) {
sql_print_warning(innodb_log_optimize_ddl_deprecated);
innodb_log_optimize_ddl = FALSE;
}
if (UNIV_UNLIKELY(innodb_undo_logs != TRX_SYS_N_RSEGS)) {
sql_print_warning(innodb_undo_logs_deprecated);
innodb_undo_logs = TRX_SYS_N_RSEGS;
@ -18886,6 +18896,16 @@ innodb_log_checksums_warn(THD* thd, st_mysql_sys_var*, void*, const void*)
innodb_log_checksums_deprecated);
}
/** Issue a deprecation warning for SET GLOBAL innodb_log_optimize_ddl.
@param[in,out] thd client connection */
static void
innodb_log_optimize_ddl_warn(THD* thd, st_mysql_sys_var*, void*, const void*)
{
push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
HA_ERR_UNSUPPORTED,
innodb_log_optimize_ddl_deprecated);
}
/** Issue a deprecation warning for SET GLOBAL innodb_undo_logs.
@param[in,out] thd client connection */
static void
@ -19407,10 +19427,7 @@ static MYSQL_SYSVAR_BOOL(log_compressed_pages, page_zip_log_pages,
static MYSQL_SYSVAR_BOOL(log_optimize_ddl, innodb_log_optimize_ddl,
PLUGIN_VAR_OPCMDARG,
"Reduce redo logging when natively creating indexes or rebuilding tables."
" Setting this OFF avoids delay due to page flushing and"
" allows concurrent backup.",
NULL, NULL, TRUE);
innodb_deprecated_ignored, NULL, innodb_log_optimize_ddl_warn, FALSE);
static MYSQL_SYSVAR_ULONG(autoextend_increment,
sys_tablespace_auto_extend_increment,

4
storage/innobase/ibuf/ibuf0ibuf.cc
View File

@ -1,7 +1,7 @@
/*****************************************************************************
Copyright (c) 1997, 2016, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2016, 2019, MariaDB Corporation.
Copyright (c) 2016, 2020, 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
@ -1963,7 +1963,7 @@ ibuf_remove_free_page(void)
compile_time_assert(IBUF_SPACE_ID == 0);
fseg_free_page(header_page + IBUF_HEADER + IBUF_TREE_SEG_HEADER,
fil_system.sys_space, page_no, false, true, &mtr);
fil_system.sys_space, page_no, false, &mtr);
const page_id_t page_id(IBUF_SPACE_ID, page_no);

37
storage/innobase/include/btr0bulk.h
View File

@ -1,7 +1,7 @@
/*****************************************************************************
Copyright (c) 2014, 2015, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2019, MariaDB Corporation.
Copyright (c) 2019, 2020, 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
@ -53,14 +53,12 @@ public:
@param[in] index B-tree index
@param[in] page_no page number
@param[in] level page level
@param[in] trx_id transaction id
@param[in] observer flush observer */
@param[in] trx_id transaction id */
PageBulk(
dict_index_t* index,
trx_id_t trx_id,
ulint page_no,
ulint level,
FlushObserver* observer)
ulint level)
:
m_heap(NULL),
m_index(index),
@ -81,7 +79,6 @@ public:
m_total_data(0),
#endif /* UNIV_DEBUG */
m_modify_clock(0),
m_flush_observer(observer),
m_err(DB_SUCCESS)
{
ut_ad(!dict_index_is_spatial(m_index));
@ -274,9 +271,6 @@ private:
when the block is re-pinned */
ib_uint64_t m_modify_clock;
/** Flush observer, or NULL if redo logging is enabled */
FlushObserver* m_flush_observer;
/** Operation result DB_SUCCESS or error code */
dberr_t m_err;
};
@ -289,31 +283,15 @@ class BtrBulk
public:
/** Constructor
@param[in] index B-tree index
@param[in] trx transaction
@param[in] observer flush observer */
@param[in] trx transaction */
BtrBulk(
dict_index_t* index,
const trx_t* trx,
FlushObserver* observer)
const trx_t* trx)
:
m_index(index),
m_trx(trx),
m_flush_observer(observer)
m_trx(trx)
{
ut_ad(!dict_index_is_spatial(index));
#ifdef UNIV_DEBUG
if (m_flush_observer)
m_index->table->space->redo_skipped_count++;
#endif /* UNIV_DEBUG */
}
/** Destructor */
~BtrBulk()
{
#ifdef UNIV_DEBUG
if (m_flush_observer)
m_index->table->space->redo_skipped_count--;
#endif /* UNIV_DEBUG */
}
/** Insert a tuple
@ -385,9 +363,6 @@ private:
/** Root page level */
ulint m_root_level;
/** Flush observer, or NULL if redo logging is enabled */
FlushObserver*const m_flush_observer;
/** Page cursor vector for all level */
page_bulk_vector m_page_bulks;
};

2
storage/innobase/include/buf0buf.h
View File

@ -1526,8 +1526,6 @@ public:
== (state == BUF_BLOCK_NOT_USED) */
#endif /* UNIV_DEBUG */
FlushObserver* flush_observer; /*!< flush observer */
lsn_t oldest_modification;
/*!< log sequence number of
the START of the log entry

90
storage/innobase/include/buf0flu.h
View File

@ -1,7 +1,7 @@
/*****************************************************************************
Copyright (c) 1995, 2016, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2014, 2018, MariaDB Corporation.
Copyright (c) 2014, 2020, 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
@ -186,9 +186,8 @@ 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
lsn_t end_lsn); /*!< in: end lsn of the last mtr in the
set of mtr's */
FlushObserver* observer); /*!< in: flush observer */
/********************************************************************//**
Returns TRUE if the file page block is immediately suitable for replacement,
i.e., transition FILE_PAGE => NOT_USED allowed.
@ -297,8 +296,7 @@ ulint
buf_pool_get_dirty_pages_count(
/*===========================*/
buf_pool_t* buf_pool, /*!< in: buffer pool */
ulint id, /*!< in: space id to check */
FlushObserver* observer); /*!< in: flush observer to check */
ulint id); /*!< in: space id to check */
/*******************************************************************//**
Synchronously flush dirty blocks from the end of the flush list of all buffer
@ -314,88 +312,6 @@ void
buf_flush_request_force(
lsn_t lsn_limit);
/** We use FlushObserver to track flushing of non-redo logged pages in bulk
create index(BtrBulk.cc).Since we disable redo logging during a index build,
we need to make sure that all dirty pages modifed by the index build are
flushed to disk before any redo logged operations go to the index. */
class FlushObserver {
public:
/** Constructor
@param[in,out] space tablespace
@param[in] trx trx instance
@param[in] stage performance schema accounting object,
used by ALTER TABLE. It is passed to log_preflush_pool_modified_pages()
for accounting. */
FlushObserver(fil_space_t* space, trx_t* trx, ut_stage_alter_t* stage);
/** Deconstructor */
~FlushObserver();
/** Check pages have been flushed and removed from the flush list
in a buffer pool instance.
@param[in] instance_no buffer pool instance no
@return true if the pages were removed from the flush list */
bool is_complete(ulint instance_no)
{
return(m_flushed->at(instance_no) == m_removed->at(instance_no)
|| m_interrupted);
}
/** @return whether to flush only some pages of the tablespace */
bool is_partial_flush() const { return m_stage != NULL; }
/** @return whether the operation was interrupted */
bool is_interrupted() const { return m_interrupted; }
/** Interrupt observer not to wait. */
void interrupted()
{
m_interrupted = true;
}
/** Check whether the operation has been interrupted */
void check_interrupted();
/** Flush dirty pages. */
void flush();
/** Notify observer of flushing a page
@param[in] buf_pool buffer pool instance
@param[in] bpage buffer page to flush */
void notify_flush(
buf_pool_t* buf_pool,
buf_page_t* bpage);
/** Notify observer of removing a page from flush list
@param[in] buf_pool buffer pool instance
@param[in] bpage buffer page flushed */
void notify_remove(
buf_pool_t* buf_pool,
buf_page_t* bpage);
private:
/** Tablespace */
fil_space_t* m_space;
/** Trx instance */
const trx_t* const m_trx;
/** Performance schema accounting object, used by ALTER TABLE.
If not NULL, then stage->begin_phase_flush() will be called initially,
specifying the number of pages to be attempted to be flushed and
subsequently, stage->inc() will be called for each page we attempt to
flush. */
ut_stage_alter_t* m_stage;
/* Flush request sent */
std::vector<ulint>* m_flushed;
/* Flush request finished */
std::vector<ulint>* m_removed;
/* True if the operation was interrupted. */
bool m_interrupted;
};
#include "buf0flu.ic"
#endif

10
storage/innobase/include/buf0flu.ic
View File

@ -1,6 +1,7 @@
/*****************************************************************************
Copyright (c) 1995, 2015, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2019, 2020, 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
@ -48,9 +49,8 @@ buf_flush_note_modification(
buf_block_t* block, /*!< in: block which is modified */
lsn_t start_lsn, /*!< in: start lsn of the mtr that
modified this block */
lsn_t end_lsn, /*!< in: end lsn of the mtr that
lsn_t end_lsn) /*!< in: end lsn of the mtr that
modified this block */
FlushObserver* observer) /*!< in: flush observer */
{
mutex_enter(&block->mutex);
ut_ad(!srv_read_only_mode
@ -67,12 +67,6 @@ buf_flush_note_modification(
+ block->frame);
}
/* Don't allow to set flush observer from non-null to null,
or from one observer to another. */
ut_ad(block->page.flush_observer == NULL
|| block->page.flush_observer == observer);
block->page.flush_observer = observer;
if (block->page.oldest_modification == 0) {
buf_pool_t* buf_pool = buf_pool_from_block(block);

8
storage/innobase/include/buf0lru.h
View File

@ -1,7 +1,7 @@
/*****************************************************************************
Copyright (c) 1995, 2016, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2017, 2019, MariaDB Corporation.
Copyright (c) 2017, 2020, 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
@ -63,11 +63,9 @@ bool buf_LRU_drop_page_hash_for_tablespace(dict_table_t* table)
/** Empty the flush list for all pages belonging to a tablespace.
@param[in] id tablespace identifier
@param[in,out] observer flush observer,
or NULL if nothing is to be written
@param[in] flush whether to write the pages to files
@param[in] first first page to be flushed or evicted */
void buf_LRU_flush_or_remove_pages(ulint id, FlushObserver* observer,
ulint first = 0);
void buf_LRU_flush_or_remove_pages(ulint id, bool flush, ulint first = 0);
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
/********************************************************************//**

2
storage/innobase/include/buf0types.h
View File

@ -44,8 +44,6 @@ struct buf_pool_stat_t;
struct buf_buddy_stat_t;
/** Doublewrite memory struct */
struct buf_dblwr_t;
/** Flush observer for bulk create index */
class FlushObserver;
/** A buffer frame. @see page_t */
typedef byte buf_frame_t;

7
storage/innobase/include/fil0fil.h
View File

@ -42,8 +42,6 @@ Created 10/25/1995 Heikki Tuuri
struct unflushed_spaces_tag_t;
struct rotation_list_tag_t;
/** whether to reduce redo logging during ALTER TABLE */
extern my_bool innodb_log_optimize_ddl;
// Forward declaration
extern my_bool srv_use_doublewrite_buf;
extern struct buf_dblwr_t* buf_dblwr;
@ -114,11 +112,6 @@ struct fil_space_t
bool stop_new_ops;
/** whether undo tablespace truncation is in progress */
bool is_being_truncated;
#ifdef UNIV_DEBUG
/** reference count for operations who want to skip redo log in the
file space in order to make modify_check() pass. */
Atomic_counter<ulint> redo_skipped_count;
#endif
fil_type_t purpose;/*!< purpose */
UT_LIST_BASE_NODE_T(fil_node_t) chain;
/*!< base node for the file chain */

16
storage/innobase/include/fsp0fsp.h
View File

@ -1,7 +1,7 @@
/*****************************************************************************
Copyright (c) 1995, 2016, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2013, 2019, MariaDB Corporation.
Copyright (c) 2013, 2020, 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
@ -494,7 +494,6 @@ fsp_reserve_free_extents(
@param[in] offset page number
@param[in] ahi whether we may need to drop the adaptive
hash index
@param[in] log whether to write MLOG_INIT_FREE_PAGE record
@param[in,out] mtr mini-transaction */
void
fseg_free_page_func(
@ -504,14 +503,13 @@ fseg_free_page_func(
#ifdef BTR_CUR_HASH_ADAPT
bool ahi,
#endif /* BTR_CUR_HASH_ADAPT */
bool log,
mtr_t* mtr);
#ifdef BTR_CUR_HASH_ADAPT
# define fseg_free_page(header, space, offset, ahi, log, mtr) \
fseg_free_page_func(header, space, offset, ahi, log, mtr)
# define fseg_free_page(header, space, offset, ahi, mtr) \
fseg_free_page_func(header, space, offset, ahi, mtr)
#else /* BTR_CUR_HASH_ADAPT */
# define fseg_free_page(header, space, offset, ahi, log, mtr) \
fseg_free_page_func(header, space, offset, log, mtr)
# define fseg_free_page(header, space, offset, ahi, mtr) \
fseg_free_page_func(header, space, offset, mtr)
#endif /* BTR_CUR_HASH_ADAPT */
/** Determine whether a page is free.
@param[in,out] space tablespace
@ -636,9 +634,7 @@ inline void fsp_init_file_page(
block->page.id.space(), block->page.id.page_no(),
log_ptr, mtr);
mlog_close(mtr, log_ptr);
if (!innodb_log_optimize_ddl) {
block->page.init_on_flush = true;
}
block->page.init_on_flush = true;
}
}

3
storage/innobase/include/mtr0log.ic
View File

@ -1,7 +1,7 @@
/*****************************************************************************
Copyright (c) 1995, 2016, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2017, 2019, MariaDB Corporation.
Copyright (c) 2017, 2020, 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
@ -138,7 +138,6 @@ mlog_write_initial_log_record_low(
|| type == MLOG_FILE_DELETE
|| type == MLOG_FILE_CREATE2
|| type == MLOG_FILE_RENAME2
|| type == MLOG_INDEX_LOAD
|| mtr->is_named_space(space_id));
mach_write_to_1(log_ptr, type);

15
storage/innobase/include/mtr0mtr.h
View File

@ -325,18 +325,6 @@ struct mtr_t {
/** @return true if we are inside the change buffer code */
bool is_inside_ibuf() const { return m_inside_ibuf; }
/** Get flush observer
@return flush observer */
FlushObserver* get_flush_observer() const { return m_flush_observer; }
/** Set flush observer
@param[in] observer flush observer */
void set_flush_observer(FlushObserver* observer)
{
ut_ad(observer == NULL || m_log_mode == MTR_LOG_NO_REDO);
m_flush_observer = observer;
}
#ifdef UNIV_DEBUG
/** Check if memo contains the given item.
@param memo memo stack
@ -527,9 +515,6 @@ private:
/** user tablespace that is being modified by the mini-transaction */
fil_space_t* m_user_space;
/** page flush observer for innodb_log_optimize_ddl=ON */
FlushObserver *m_flush_observer;
/** LSN at commit time */
lsn_t m_commit_lsn;
};

8
storage/innobase/include/row0merge.h
View File

@ -1,7 +1,7 @@
/*****************************************************************************
Copyright (c) 2005, 2016, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2015, 2019, MariaDB Corporation.
Copyright (c) 2015, 2020, 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
@ -292,12 +292,6 @@ row_merge_drop_table(
dict_table_t* table) /*!< in: table instance to drop */
MY_ATTRIBUTE((nonnull, warn_unused_result));
/** Write an MLOG_INDEX_LOAD record to indicate in the redo-log
that redo-logging of individual index pages was disabled, and
the flushing of such pages to the data files was completed.
@param[in] index an index tree on which redo logging was disabled */
void row_merge_write_redo(const dict_index_t* index);
/** Build indexes on a table by reading a clustered index, creating a temporary
file containing index entries, merge sorting these index entries and inserting
sorted index entries to indexes.

6
storage/innobase/include/srv0srv.h
View File

@ -3,7 +3,7 @@
Copyright (c) 1995, 2017, Oracle and/or its affiliates. All rights reserved.
Copyright (c) 2008, 2009, Google Inc.
Copyright (c) 2009, Percona Inc.
Copyright (c) 2013, 2019, MariaDB Corporation.
Copyright (c) 2013, 2020, MariaDB Corporation.
Portions of this file contain modifications contributed and copyrighted by
Google, Inc. Those modifications are gratefully acknowledged and are described
@ -598,10 +598,6 @@ do { \
everything after flush log_make_checkpoint(). */
extern PSI_stage_info srv_stage_alter_table_end;
/** Performance schema stage event for monitoring ALTER TABLE progress
log_make_checkpoint(). */
extern PSI_stage_info srv_stage_alter_table_flush;
/** Performance schema stage event for monitoring ALTER TABLE progress
row_merge_insert_index_tuples(). */
extern PSI_stage_info srv_stage_alter_table_insert;

20
storage/innobase/include/trx0trx.h
View File

@ -41,7 +41,6 @@ Created 3/26/1996 Heikki Tuuri
// Forward declaration
struct mtr_t;
class FlushObserver;
struct rw_trx_hash_element_t;
/******************************************************************//**
@ -1044,11 +1043,6 @@ public:
/*------------------------------*/
char* detailed_error; /*!< detailed error message for last
error, or empty. */
private:
/** flush observer used to track flushing of non-redo logged pages
during bulk create index */
FlushObserver* flush_observer;
public:
/* Lock wait statistics */
ulint n_rec_lock_waits;
/*!< Number of record lock waits,
@ -1101,20 +1095,6 @@ public:
return(assign_temp_rseg());
}
/** Set the innodb_log_optimize_ddl page flush observer
@param[in,out] space tablespace
@param[in,out] stage performance_schema accounting */
void set_flush_observer(fil_space_t* space, ut_stage_alter_t* stage);
/** Remove the flush observer */
void remove_flush_observer();
/** @return the flush observer */
FlushObserver* get_flush_observer() const
{
return flush_observer;
}
/** Transition to committed state, to release implicit locks. */
inline void commit_state();

46
storage/innobase/include/ut0stage.h
View File

@ -1,7 +1,7 @@
/*****************************************************************************
Copyright (c) 2014, 2015, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2017, MariaDB Corporation.
Copyright (c) 2017, 2020, 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
@ -62,9 +62,6 @@ if any new indexes are being added, for each one:
being_phase_log_index()
multiple times:
inc() // once per log-block applied
begin_phase_flush()
multiple times:
inc() // once per page flushed
begin_phase_log_table()
multiple times:
inc() // once per log-block applied
@ -86,7 +83,6 @@ public:
m_n_pk_recs(0),
m_n_pk_pages(0),
m_n_recs_processed(0),
m_n_flush_pages(0),
m_cur_phase(NOT_STARTED)
{
}
@ -134,13 +130,6 @@ public:
void
begin_phase_insert();
/** Flag the beginning of the flush phase.
@param[in] n_flush_pages this many pages are going to be
flushed */
void
begin_phase_flush(
ulint n_flush_pages);
/** Flag the beginning of the log index phase. */
void
begin_phase_log_index();
@ -195,16 +184,12 @@ private:
recs-per-page records. */
ulint m_n_recs_processed;
/** Number of pages to flush. */
ulint m_n_flush_pages;
/** Current phase. */
enum {
NOT_STARTED = 0,
READ_PK = 1,
SORT = 2,
INSERT = 3,
FLUSH = 4,
/* JAN: TODO: MySQL 5.7 vrs. MariaDB sql/log.h
LOG_INDEX = 5,
LOG_TABLE = 6, */
@ -317,8 +302,6 @@ ut_stage_alter_t::inc(ulint)
break;
}
case FLUSH:
break;
/* JAN: TODO: MySQL 5.7
case LOG_INDEX:
break;
@ -387,21 +370,6 @@ ut_stage_alter_t::begin_phase_insert()
change_phase(&srv_stage_alter_table_insert);
}
/** Flag the beginning of the flush phase.
@param[in] n_flush_pages this many pages are going to be
flushed */
inline
void
ut_stage_alter_t::begin_phase_flush(
ulint n_flush_pages)
{
m_n_flush_pages = n_flush_pages;
reestimate();
change_phase(&srv_stage_alter_table_flush);
}
/** Flag the beginning of the log index phase. */
inline
void
@ -458,20 +426,12 @@ ut_stage_alter_t::reestimate()
? m_n_pk_pages
: m_pk->stat_n_leaf_pages;
/* If flush phase has not started yet and we do not know how
many pages are to be flushed, then use a wild guess - the
number of pages in the PK / 2. */
if (m_n_flush_pages == 0) {
m_n_flush_pages = n_pk_pages / 2;
}
ulonglong estimate __attribute__((unused))
= n_pk_pages
* (1 /* read PK */
+ m_n_sort_indexes /* row_merge_buf_sort() inside the
read PK per created index */
+ m_n_sort_indexes * 2 /* sort & insert per created index */)
+ m_n_flush_pages
+ row_log_estimate_work(m_pk);
/* Prevent estimate < completed */
@ -500,8 +460,6 @@ ut_stage_alter_t::change_phase(
m_cur_phase = SORT;
} else if (new_stage == &srv_stage_alter_table_insert) {
m_cur_phase = INSERT;
} else if (new_stage == &srv_stage_alter_table_flush) {
m_cur_phase = FLUSH;
/* JAN: TODO: MySQL 5.7 used LOG_INDEX and LOG_TABLE */
} else if (new_stage == &srv_stage_alter_table_log_index) {
m_cur_phase = LOG_INNODB_INDEX;
@ -542,8 +500,6 @@ public:
void begin_phase_insert() {}
void begin_phase_flush(ulint) {}
void begin_phase_log_index() {}
void begin_phase_log_table() {}

2
storage/innobase/log/log0recv.cc
View File

@ -2076,7 +2076,7 @@ static void recv_recover_page(buf_block_t* block, mtr_t& mtr,
if (start_lsn) {
log_flush_order_mutex_enter();
buf_flush_note_modification(block, start_lsn, end_lsn, NULL);
buf_flush_note_modification(block, start_lsn, end_lsn);
log_flush_order_mutex_exit();
} else if (free_page && init) {
/* There have been no operations than MLOG_INIT_FREE_PAGE.

18
storage/innobase/mtr/mtr0mtr.cc
View File

@ -297,11 +297,10 @@ struct DebugCheck {
/** Release a resource acquired by the mini-transaction. */
struct ReleaseBlocks {
/** Release specific object */
ReleaseBlocks(lsn_t start_lsn, lsn_t end_lsn, FlushObserver* observer)
ReleaseBlocks(lsn_t start_lsn, lsn_t end_lsn)
:
m_end_lsn(end_lsn),
m_start_lsn(start_lsn),
m_flush_observer(observer)
m_start_lsn(start_lsn)
{
/* Do nothing */
}
@ -316,8 +315,7 @@ struct ReleaseBlocks {
block = reinterpret_cast<buf_block_t*>(slot->object);
buf_flush_note_modification(block, m_start_lsn,
m_end_lsn, m_flush_observer);
buf_flush_note_modification(block, m_start_lsn, m_end_lsn);
}
/** @return true always. */
@ -340,9 +338,6 @@ struct ReleaseBlocks {
/** Mini-transaction REDO end LSN */
lsn_t m_start_lsn;
/** Flush observer */
FlushObserver* m_flush_observer;
};
/** Write the block contents to the REDO log */
@ -393,7 +388,6 @@ void mtr_t::start()
m_log_mode= MTR_LOG_ALL;
ut_d(m_user_space_id= TRX_SYS_SPACE);
m_user_space= nullptr;
m_flush_observer= nullptr;
m_commit_lsn= 0;
}
@ -437,8 +431,7 @@ void mtr_t::commit()
log_mutex_exit();
m_memo.for_each_block_in_reverse(CIterate<const ReleaseBlocks>
(ReleaseBlocks(start_lsn, m_commit_lsn,
m_flush_observer)));
(ReleaseBlocks(start_lsn, m_commit_lsn)));
if (m_made_dirty)
log_flush_order_mutex_exit();
@ -559,8 +552,7 @@ mtr_t::x_lock_space(ulint space_id, const char* file, unsigned line)
space = fil_space_get(space_id);
ut_ad(get_log_mode() != MTR_LOG_NO_REDO
|| space->purpose == FIL_TYPE_TEMPORARY
|| space->purpose == FIL_TYPE_IMPORT
|| space->redo_skipped_count > 0);
|| space->purpose == FIL_TYPE_IMPORT);
}
ut_ad(space);

4
storage/innobase/page/page0zip.cc
View File

@ -424,9 +424,7 @@ static void page_zip_compress_write_log(buf_block_t* block,
/* Write the uncompressed trailer of the compressed page. */
mlog_catenate_string(mtr, page_zip->data + page_zip_get_size(page_zip)
- trailer_size, trailer_size);
if (!innodb_log_optimize_ddl) {
block->page.init_on_flush = true;
}
block->page.init_on_flush = true;
}
/******************************************************//**

8
storage/innobase/row/row0ftsort.cc
View File

@ -1640,9 +1640,7 @@ row_fts_merge_insert(
== UT_BITS_IN_BYTES(aux_index->n_nullable));
/* Create bulk load instance */
ins_ctx.btr_bulk = UT_NEW_NOKEY(
BtrBulk(aux_index, trx, psort_info[0].psort_common->trx
->get_flush_observer()));
ins_ctx.btr_bulk = UT_NEW_NOKEY(BtrBulk(aux_index, trx));
/* Create tuple for insert */
ins_ctx.tuple = dtuple_create(heap, dict_index_get_n_fields(aux_index));
@ -1775,9 +1773,5 @@ exit:
ib::info() << "InnoDB_FTS: inserted " << count << " records";
}
if (psort_info[0].psort_common->trx->get_flush_observer()) {
row_merge_write_redo(aux_index);
}
return(error);
}

13
storage/innobase/row/row0import.cc
View File

@ -4192,18 +4192,7 @@ row_import_for_mysql(
/* Ensure that all pages dirtied during the IMPORT make it to disk.
The only dirty pages generated should be from the pessimistic purge
of delete marked records that couldn't be purged in Phase I. */
{
FlushObserver observer(prebuilt->table->space, trx, NULL);
buf_LRU_flush_or_remove_pages(prebuilt->table->space_id,
&observer);
if (observer.is_interrupted()) {
ib::info() << "Phase III - Flush interrupted";
return(row_import_error(prebuilt, trx,
DB_INTERRUPTED));
}
}
buf_LRU_flush_or_remove_pages(prebuilt->table->space_id, true);
ib::info() << "Phase IV - Flush complete";
prebuilt->table->space->set_imported();

82
storage/innobase/row/row0merge.cc
View File

@ -2355,15 +2355,6 @@ write_buffers:
conv_heap, &err,
&v_heap, eval_table, trx)))) {
/* Set the page flush observer for the
transaction when buffering the very first
record for a non-redo-logged operation. */
if (file->n_rec == 0 && i == 0
&& innodb_log_optimize_ddl) {
trx->set_flush_observer(
new_table->space, stage);
}
/* If we are creating FTS index,
a single row can generate more
records for tokenized word */
@ -2504,8 +2495,7 @@ write_buffers:
if (clust_btr_bulk == NULL) {
clust_btr_bulk = UT_NEW_NOKEY(
BtrBulk(index[i],
trx,
trx->get_flush_observer()));
trx));
} else {
clust_btr_bulk->latch();
}
@ -2620,9 +2610,7 @@ write_buffers:
trx->error_key_num = i;
goto all_done;);
BtrBulk btr_bulk(
index[i], trx,
trx->get_flush_observer());
BtrBulk btr_bulk(index[i], trx);
err = row_merge_insert_index_tuples(
index[i], old_table,
@ -4475,26 +4463,6 @@ row_merge_drop_table(
trx, SQLCOM_DROP_TABLE, false, false));
}
/** Write an MLOG_INDEX_LOAD record to indicate in the redo-log
that redo-logging of individual index pages was disabled, and
the flushing of such pages to the data files was completed.
@param[in] index an index tree on which redo logging was disabled */
void row_merge_write_redo(const dict_index_t* index)
{
ut_ad(!index->table->is_temporary());
ut_ad(!(index->type & (DICT_SPATIAL | DICT_FTS)));
mtr_t mtr;
mtr.start();
byte* log_ptr = mlog_open(&mtr, 11 + 8);
log_ptr = mlog_write_initial_log_record_low(
MLOG_INDEX_LOAD,
index->table->space_id, index->page, log_ptr, &mtr);
mach_write_to_8(log_ptr, index->id);
mlog_close(&mtr, log_ptr + 8);
mtr.commit();
}
/** Build indexes on a table by reading a clustered index, creating a temporary
file containing index entries, merge sorting these index entries and inserting
sorted index entries to indexes.
@ -4795,8 +4763,7 @@ row_merge_build_indexes(
os_thread_sleep(20000000);); /* 20 sec */
if (error == DB_SUCCESS) {
BtrBulk btr_bulk(sort_idx, trx,
trx->get_flush_observer());
BtrBulk btr_bulk(sort_idx, trx);
pct_cost = (COST_BUILD_INDEX_STATIC +
(total_dynamic_cost * merge_files[k].offset /
@ -4842,21 +4809,10 @@ row_merge_build_indexes(
if (indexes[i]->type & DICT_FTS) {
row_fts_psort_info_destroy(psort_info, merge_info);
fts_psort_initiated = false;
} else if (dict_index_is_spatial(indexes[i])) {
/* We never disable redo logging for
creating SPATIAL INDEX. Avoid writing any
unnecessary MLOG_INDEX_LOAD record. */
} else if (old_table != new_table) {
ut_ad(!sort_idx->online_log);
ut_ad(sort_idx->online_status
== ONLINE_INDEX_COMPLETE);
} else if (FlushObserver* flush_observer =
trx->get_flush_observer()) {
if (error != DB_SUCCESS) {
flush_observer->interrupted();
}
flush_observer->flush();
row_merge_write_redo(indexes[i]);
}
if (old_table != new_table
@ -4958,37 +4914,5 @@ func_exit:
}
DBUG_EXECUTE_IF("ib_index_crash_after_bulk_load", DBUG_SUICIDE(););
if (FlushObserver* flush_observer = trx->get_flush_observer()) {
DBUG_EXECUTE_IF("ib_index_build_fail_before_flush",
error = DB_INTERRUPTED;
);
if (error != DB_SUCCESS) {
flush_observer->interrupted();
}
flush_observer->flush();
if (old_table != new_table) {
for (const dict_index_t* index
= dict_table_get_first_index(new_table);
index != NULL;
index = dict_table_get_next_index(index)) {
if (!(index->type
& (DICT_FTS | DICT_SPATIAL))) {
row_merge_write_redo(index);
}
}
}
trx->remove_flush_observer();
if (trx_is_interrupted(trx)) {
error = DB_INTERRUPTED;
}
}
DBUG_RETURN(error);
}

17
storage/innobase/row/row0quiesce.cc
View File

@ -1,7 +1,7 @@
/*****************************************************************************
Copyright (c) 2012, 2016, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2017, 2019, MariaDB Corporation.
Copyright (c) 2017, 2020, 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
@ -535,19 +535,10 @@ row_quiesce_table_start(
}
if (!trx_is_interrupted(trx)) {
{
FlushObserver observer(table->space, trx, NULL);
buf_LRU_flush_or_remove_pages(table->space_id,
&observer);
}
if (trx_is_interrupted(trx)) {
ib::warn() << "Quiesce aborted!";
} else if (row_quiesce_write_cfg(table, trx->mysql_thd)
!= DB_SUCCESS) {
buf_LRU_flush_or_remove_pages(table->space_id, true);
if (row_quiesce_write_cfg(table, trx->mysql_thd)
!= DB_SUCCESS) {
ib::warn() << "There was an error writing to the"
" meta data file";
} else {

5
storage/innobase/srv/srv0srv.cc
View File

@ -619,11 +619,6 @@ everything after flush log_make_checkpoint(). */
PSI_stage_info srv_stage_alter_table_end
= {0, "alter table (end)", PSI_FLAG_STAGE_PROGRESS};
/** Performance schema stage event for monitoring ALTER TABLE progress
log_make_checkpoint(). */
PSI_stage_info srv_stage_alter_table_flush
= {0, "alter table (flush)", PSI_FLAG_STAGE_PROGRESS};
/** Performance schema stage event for monitoring ALTER TABLE progress
row_merge_insert_index_tuples(). */
PSI_stage_info srv_stage_alter_table_insert

3
storage/innobase/srv/srv0start.cc
View File

@ -3,7 +3,7 @@
Copyright (c) 1996, 2017, Oracle and/or its affiliates. All rights reserved.
Copyright (c) 2008, Google Inc.
Copyright (c) 2009, Percona Inc.
Copyright (c) 2013, 2019, MariaDB Corporation.
Copyright (c) 2013, 2020, MariaDB Corporation.
Portions of this file contain modifications contributed and copyrighted by
Google, Inc. Those modifications are gratefully acknowledged and are described
@ -186,7 +186,6 @@ performance schema. */
static PSI_stage_info* srv_stages[] =
{
&srv_stage_alter_table_end,
&srv_stage_alter_table_flush,
&srv_stage_alter_table_insert,
&srv_stage_alter_table_log_index,
&srv_stage_alter_table_log_table,

9
storage/innobase/trx/trx0purge.cc
View File

@ -671,14 +671,7 @@ not_free:
mini-transaction commit and the server was killed, then
discarding the to-be-trimmed pages without flushing would
break crash recovery. So, we cannot avoid the write. */
{
FlushObserver observer(
purge_sys.truncate.current,
UT_LIST_GET_FIRST(purge_sys.query->thrs)
->graph->trx,
NULL);
buf_LRU_flush_or_remove_pages(space.id, &observer);
}
buf_LRU_flush_or_remove_pages(space.id, true);
log_free_check();

19
storage/innobase/trx/trx0trx.cc
View File

@ -1,7 +1,7 @@
/*****************************************************************************
Copyright (c) 1996, 2016, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2015, 2019, MariaDB Corporation.
Copyright (c) 2015, 2020, 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
@ -161,8 +161,6 @@ trx_init(
trx->lock.rec_cached = 0;
trx->lock.table_cached = 0;
ut_ad(trx->get_flush_observer() == NULL);
}
/** For managing the life-cycle of the trx_t instance that we get
@ -902,21 +900,6 @@ static trx_rseg_t* trx_assign_rseg_low()
return(rseg);
}
/** Set the innodb_log_optimize_ddl page flush observer
@param[in,out] space tablespace
@param[in,out] stage performance_schema accounting */
void trx_t::set_flush_observer(fil_space_t* space, ut_stage_alter_t* stage)
{
flush_observer = UT_NEW_NOKEY(FlushObserver(space, this, stage));
}
/** Remove the flush observer */
void trx_t::remove_flush_observer()
{
UT_DELETE(flush_observer);
flush_observer = NULL;
}
/** Assign a rollback segment for modifying temporary tables.
@return the assigned rollback segment */
trx_rseg_t*

4
storage/innobase/trx/trx0undo.cc
View File

@ -1,7 +1,7 @@
/*****************************************************************************
Copyright (c) 1996, 2016, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2014, 2019, MariaDB Corporation.
Copyright (c) 2014, 2020, 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
@ -752,7 +752,7 @@ trx_undo_free_page(
fseg_free_page(TRX_UNDO_SEG_HDR + TRX_UNDO_FSEG_HEADER
+ header_block->frame,
rseg->space, page_no, false, true, mtr);
rseg->space, page_no, false, mtr);
const fil_addr_t last_addr = flst_get_last(
TRX_UNDO_SEG_HDR + TRX_UNDO_PAGE_LIST + header_block->frame);