diff options
| -rw-r--r-- | .clang-format | 6 | ||||
| -rw-r--r-- | storage/innobase/buf/buf0dump.cc | 69 | ||||
| -rw-r--r-- | storage/innobase/buf/buf0flu.cc | 8 | ||||
| -rw-r--r-- | storage/innobase/dict/dict0crea.cc | 8 | ||||
| -rw-r--r-- | storage/innobase/dict/dict0stats_bg.cc | 37 | ||||
| -rw-r--r-- | storage/innobase/fil/fil0fil.cc | 10 | ||||
| -rw-r--r-- | storage/innobase/fsp/fsp0sysspace.cc | 4 | ||||
| -rw-r--r-- | storage/innobase/fts/fts0opt.cc | 37 | ||||
| -rw-r--r-- | storage/innobase/handler/ha_innodb.cc | 2 | ||||
| -rw-r--r-- | storage/innobase/include/buf0dump.h | 35 | ||||
| -rw-r--r-- | storage/innobase/include/dict0stats_bg.h | 24 | ||||
| -rw-r--r-- | storage/innobase/include/lock0lock.h | 3 | ||||
| -rw-r--r-- | storage/innobase/include/srv0srv.h | 45 | ||||
| -rw-r--r-- | storage/innobase/include/srv0start.h | 2 | ||||
| -rw-r--r-- | storage/innobase/include/trx0purge.h | 18 | ||||
| -rw-r--r-- | storage/innobase/lock/lock0wait.cc | 52 | ||||
| -rw-r--r-- | storage/innobase/log/log0log.cc | 6 | ||||
| -rw-r--r-- | storage/innobase/srv/srv0srv.cc | 280 | ||||
| -rw-r--r-- | storage/innobase/srv/srv0start.cc | 48 | ||||
| -rw-r--r-- | storage/innobase/trx/trx0purge.cc | 39 |
20 files changed, 302 insertions, 431 deletions
diff --git a/.clang-format b/.clang-format index 1ad93ead80a..7ad3d0dbddc 100644 --- a/.clang-format +++ b/.clang-format @@ -7,14 +7,10 @@ AlignConsecutiveDeclarations: false AlignEscapedNewlines: Right AlignOperands: true AlignTrailingComments: true -AllowAllArgumentsOnNextLine: true -AllowAllConstructorInitializersOnNextLine: true AllowAllParametersOfDeclarationOnNextLine: true AllowShortBlocksOnASingleLine: false AllowShortCaseLabelsOnASingleLine: false AllowShortFunctionsOnASingleLine: All -AllowShortLambdasOnASingleLine: All -AllowShortIfStatementsOnASingleLine: Never AllowShortLoopsOnASingleLine: false AlwaysBreakAfterDefinitionReturnType: None AlwaysBreakAfterReturnType: None @@ -23,7 +19,6 @@ AlwaysBreakTemplateDeclarations: MultiLine BinPackArguments: true BinPackParameters: true BraceWrapping: - AfterCaseLabel: true AfterClass: true AfterControlStatement: true AfterEnum: true @@ -93,7 +88,6 @@ ReflowComments: true SortIncludes: true SortUsingDeclarations: true SpaceAfterCStyleCast: true -SpaceAfterLogicalNot: false SpaceAfterTemplateKeyword: true SpaceBeforeAssignmentOperators: false SpaceBeforeCpp11BracedList: false diff --git a/storage/innobase/buf/buf0dump.cc b/storage/innobase/buf/buf0dump.cc index 81909a839d2..ed404055b5e 100644 --- a/storage/innobase/buf/buf0dump.cc +++ b/storage/innobase/buf/buf0dump.cc @@ -1,7 +1,7 @@ /***************************************************************************** Copyright (c) 2011, 2017, Oracle and/or its affiliates. All Rights Reserved. -Copyright (c) 2017, 2018, MariaDB Corporation. +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 @@ -59,7 +59,7 @@ take after being waked up. */ static volatile bool buf_dump_should_start; static volatile bool buf_load_should_start; -static ibool buf_load_abort_flag = FALSE; +static bool buf_load_abort_flag; /* Used to temporary store dump info in order to avoid IO while holding buffer pool mutex during dump and also to sort the contents of the dump @@ -72,30 +72,18 @@ typedef ib_uint64_t buf_dump_t; #define BUF_DUMP_SPACE(a) ((ulint) ((a) >> 32)) #define BUF_DUMP_PAGE(a) ((ulint) ((a) & 0xFFFFFFFFUL)) -/*****************************************************************//** -Wakes up the buffer pool dump/load thread and instructs it to start -a dump. This function is called by MySQL code via buffer_pool_dump_now() -and it should return immediately because the whole MySQL is frozen during -its execution. */ -void -buf_dump_start() -/*============*/ +/** Start the buffer pool dump/load task and instructs it to start a dump. */ +void buf_dump_start() { - buf_dump_should_start = true; - buf_do_load_dump(); + buf_dump_should_start= true; + buf_do_load_dump(); } -/*****************************************************************//** -Wakes up the buffer pool dump/load thread and instructs it to start -a load. This function is called by MySQL code via buffer_pool_load_now() -and it should return immediately because the whole MySQL is frozen during -its execution. */ -void -buf_load_start() -/*============*/ +/** Start the buffer pool dump/load task and instructs it to start a load. */ +void buf_load_start() { - buf_load_should_start = true; - buf_do_load_dump(); + buf_load_should_start= true; + buf_do_load_dump(); } /*****************************************************************//** @@ -536,7 +524,7 @@ buf_load() int fscanf_ret; /* Ignore any leftovers from before */ - buf_load_abort_flag = FALSE; + buf_load_abort_flag = false; buf_dump_generate_path(full_filename, sizeof(full_filename)); @@ -727,7 +715,7 @@ buf_load() if (space != NULL) { space->release(); } - buf_load_abort_flag = FALSE; + buf_load_abort_flag = false; ut_free(dump); buf_load_status( STATUS_INFO, @@ -750,7 +738,7 @@ buf_load() #ifdef UNIV_DEBUG if ((i+1) >= srv_buf_pool_load_pages_abort) { - buf_load_abort_flag = 1; + buf_load_abort_flag = true; } #endif } @@ -789,15 +777,10 @@ buf_load() #endif /* HAVE_PSI_STAGE_INTERFACE */ } -/*****************************************************************//** -Aborts a currently running buffer pool load. This function is called by -MySQL code via buffer_pool_load_abort() and it should return immediately -because the whole MySQL is frozen during its execution. */ -void -buf_load_abort() -/*============*/ +/** Abort a currently running buffer pool load. */ +void buf_load_abort() { - buf_load_abort_flag = TRUE; + buf_load_abort_flag= true; } /*****************************************************************//** @@ -850,30 +833,28 @@ static void buf_dump_load_func(void *) } -/* Execute tak with max.concurrency */ -tpool::task_group tpool_group(1); +/* Execute task with max.concurrency */ +static tpool::task_group tpool_group(1); static tpool::waitable_task buf_dump_load_task(buf_dump_load_func, &tpool_group); static bool load_dump_enabled; /** Start async buffer pool load, if srv_buffer_pool_load_at_startup was set.*/ void buf_load_at_startup() { - load_dump_enabled = true; - if (srv_buffer_pool_load_at_startup) { - buf_do_load_dump(); - } + load_dump_enabled= true; + if (srv_buffer_pool_load_at_startup) + buf_do_load_dump(); } static void buf_do_load_dump() { - if (!load_dump_enabled || buf_dump_load_task.is_running()) - return; - srv_thread_pool->submit_task(&buf_dump_load_task); + if (load_dump_enabled && !buf_dump_load_task.is_running()) + srv_thread_pool->submit_task(&buf_dump_load_task); } /** Wait for currently running load/dumps to finish*/ void buf_load_dump_end() { - ut_ad(SHUTTING_DOWN()); - buf_dump_load_task.wait(); + ut_ad(SHUTTING_DOWN()); + buf_dump_load_task.wait(); } diff --git a/storage/innobase/buf/buf0flu.cc b/storage/innobase/buf/buf0flu.cc index d7d658e25e1..b6f2796f5c9 100644 --- a/storage/innobase/buf/buf0flu.cc +++ b/storage/innobase/buf/buf0flu.cc @@ -3274,8 +3274,8 @@ DECLARE_THREAD(buf_flush_page_cleaner_coordinator)(void*) /* At this point all threads including the master and the purge thread must have been suspended. */ - ut_a(!srv_any_background_activity()); - ut_a(srv_shutdown_state == SRV_SHUTDOWN_FLUSH_PHASE); + ut_ad(!srv_any_background_activity()); + ut_ad(srv_shutdown_state == SRV_SHUTDOWN_FLUSH_PHASE); /* We can now make a final sweep on flushing the buffer pool and exit after we have cleaned the whole buffer pool. @@ -3306,8 +3306,8 @@ DECLARE_THREAD(buf_flush_page_cleaner_coordinator)(void*) } while (!success || n_flushed > 0); /* Some sanity checks */ - ut_a(!srv_any_background_activity()); - ut_a(srv_shutdown_state == SRV_SHUTDOWN_FLUSH_PHASE); + ut_ad(!srv_any_background_activity()); + ut_ad(srv_shutdown_state == SRV_SHUTDOWN_FLUSH_PHASE); for (ulint i = 0; i < srv_buf_pool_instances; i++) { buf_pool_t* buf_pool = buf_pool_from_array(i); diff --git a/storage/innobase/dict/dict0crea.cc b/storage/innobase/dict/dict0crea.cc index 5fceb8d81b8..afb5cf83bda 100644 --- a/storage/innobase/dict/dict0crea.cc +++ b/storage/innobase/dict/dict0crea.cc @@ -1355,7 +1355,7 @@ dict_check_if_system_table_exists( dict_table_t* sys_table; dberr_t error = DB_SUCCESS; - ut_a(!srv_any_background_activity()); + ut_ad(!srv_any_background_activity()); mutex_enter(&dict_sys.mutex); @@ -1395,7 +1395,7 @@ dict_create_or_check_foreign_constraint_tables(void) dberr_t sys_foreign_err; dberr_t sys_foreign_cols_err; - ut_a(!srv_any_background_activity()); + ut_ad(!srv_any_background_activity()); /* Note: The master thread has not been started at this point. */ @@ -1537,7 +1537,7 @@ dict_create_or_check_sys_virtual() my_bool srv_file_per_table_backup; dberr_t err; - ut_a(!srv_any_background_activity()); + ut_ad(!srv_any_background_activity()); /* Note: The master thread has not been started at this point. */ err = dict_check_if_system_table_exists( @@ -2064,7 +2064,7 @@ dict_create_or_check_sys_tablespace(void) dberr_t sys_tablespaces_err; dberr_t sys_datafiles_err; - ut_a(!srv_any_background_activity()); + ut_ad(!srv_any_background_activity()); /* Note: The master thread has not been started at this point. */ diff --git a/storage/innobase/dict/dict0stats_bg.cc b/storage/innobase/dict/dict0stats_bg.cc index b61c52a2f0f..41fafd50da6 100644 --- a/storage/innobase/dict/dict0stats_bg.cc +++ b/storage/innobase/dict/dict0stats_bg.cc @@ -284,11 +284,9 @@ dict_stats_wait_bg_to_stop_using_table( /*****************************************************************//** Initialize global variables needed for the operation of dict_stats_thread() Must be called before dict_stats_thread() is started. */ -void -dict_stats_init() +void dict_stats_init() { - ut_a(!srv_read_only_mode); - + ut_ad(!srv_read_only_mode); /* The recalc_pool_mutex is acquired from: 1) the background stats gathering thread before any other latch @@ -313,15 +311,13 @@ dict_stats_init() /*****************************************************************//** Free resources allocated by dict_stats_init(), must be called after dict_stats task has exited. */ -void -dict_stats_deinit() -/*======================*/ +void dict_stats_deinit() { if (!stats_initialised) { return; } - ut_a(!srv_read_only_mode); + ut_ad(!srv_read_only_mode); stats_initialised = false; dict_stats_recalc_pool_deinit(); @@ -427,7 +423,7 @@ void dict_stats_disabled_debug_update(THD*, st_mysql_sys_var*, void*, #endif /* UNIV_DEBUG */ static tpool::timer* dict_stats_timer; -std::mutex dict_stats_mutex; +static std::mutex dict_stats_mutex; static void dict_stats_func(void*) { @@ -438,31 +434,28 @@ static void dict_stats_func(void*) void dict_stats_start() { - std::lock_guard<std::mutex> lk(dict_stats_mutex); - if (dict_stats_timer) { - return; - } - dict_stats_timer = srv_thread_pool->create_timer(dict_stats_func); + std::lock_guard<std::mutex> lk(dict_stats_mutex); + if (!dict_stats_timer) + dict_stats_timer= srv_thread_pool->create_timer(dict_stats_func); } static void dict_stats_schedule(int ms) { - std::lock_guard<std::mutex> lk(dict_stats_mutex); - if(dict_stats_timer) { - dict_stats_timer->set_time(ms,0); - } + std::lock_guard<std::mutex> lk(dict_stats_mutex); + if (dict_stats_timer) + dict_stats_timer->set_time(ms,0); } void dict_stats_schedule_now() { - dict_stats_schedule(0); + dict_stats_schedule(0); } /** Shut down the dict_stats_thread. */ void dict_stats_shutdown() { - std::lock_guard<std::mutex> lk(dict_stats_mutex); - delete dict_stats_timer; - dict_stats_timer = 0; + std::lock_guard<std::mutex> lk(dict_stats_mutex); + delete dict_stats_timer; + dict_stats_timer= 0; } diff --git a/storage/innobase/fil/fil0fil.cc b/storage/innobase/fil/fil0fil.cc index c59eb0a8efa..72af5872ab6 100644 --- a/storage/innobase/fil/fil0fil.cc +++ b/storage/innobase/fil/fil0fil.cc @@ -4331,13 +4331,11 @@ fil_io( #include <tpool.h> /**********************************************************************/ -/* Callback for AIO completion */ -void -fil_aio_callback(const tpool::aiocb *cb) +/** Callback for AIO completion */ +void fil_aio_callback(const tpool::aiocb *cb) { os_aio_userdata_t *data=(os_aio_userdata_t *)cb->m_userdata; fil_node_t* node= data->node; - IORequest type = data->type; void* message = data->message; ut_ad(fil_validate_skip()); @@ -4351,7 +4349,7 @@ fil_aio_callback(const tpool::aiocb *cb) mutex_enter(&fil_system.mutex); - fil_node_complete_io(node, type); + fil_node_complete_io(node, data->type); ut_ad(node->space->purpose != FIL_TYPE_LOG); const ulint space_id= node->space->id; bool dblwr = node->space->use_doublewrite(); @@ -4384,7 +4382,7 @@ fil_aio_callback(const tpool::aiocb *cb) return; } - ut_ad(type.is_read()); + ut_ad(data->type.is_read()); if (recv_recovery_is_on() && !srv_force_recovery) { recv_sys.found_corrupt_fs = true; } diff --git a/storage/innobase/fsp/fsp0sysspace.cc b/storage/innobase/fsp/fsp0sysspace.cc index c1772c359ea..690328db8b4 100644 --- a/storage/innobase/fsp/fsp0sysspace.cc +++ b/storage/innobase/fsp/fsp0sysspace.cc @@ -390,7 +390,7 @@ dberr_t SysTablespace::set_size( Datafile& file) { - ut_a(!srv_read_only_mode || m_ignore_read_only); + ut_ad(!srv_read_only_mode || m_ignore_read_only); /* We created the data file and now write it full of zeros */ ib::info() << "Setting file '" << file.filepath() << "' size to " @@ -425,7 +425,7 @@ SysTablespace::create_file( dberr_t err = DB_SUCCESS; ut_a(!file.m_exists); - ut_a(!srv_read_only_mode || m_ignore_read_only); + ut_ad(!srv_read_only_mode || m_ignore_read_only); switch (file.m_type) { case SRV_NEW_RAW: diff --git a/storage/innobase/fts/fts0opt.cc b/storage/innobase/fts/fts0opt.cc index 6f3049f39aa..e471c761feb 100644 --- a/storage/innobase/fts/fts0opt.cc +++ b/storage/innobase/fts/fts0opt.cc @@ -2542,20 +2542,19 @@ fts_optimize_create_msg( } /** Add message to wqueue, signal thread pool*/ -void add_msg(fts_msg_t *msg, bool wq_locked = false) +static void add_msg(fts_msg_t *msg, bool wq_locked= false) { - ut_a(fts_optimize_wq); - ib_wqueue_add(fts_optimize_wq,msg, msg->heap,wq_locked); - srv_thread_pool->submit_task(&task); + ib_wqueue_add(fts_optimize_wq, msg, msg->heap, wq_locked); + srv_thread_pool->submit_task(&task); } /** Called by "idle" timer. Submits optimize task, which will only recalculate is_sync_needed, in case the queue is empty. */ -static void timer_callback(void *) +static void timer_callback(void*) { - srv_thread_pool->submit_task(&task); + srv_thread_pool->submit_task(&task); } /** Add the table to add to the OPTIMIZER's list. @@ -2581,7 +2580,7 @@ void fts_optimize_add_table(dict_table_t* table) mutex_enter(&fts_optimize_wq->mutex); - add_msg(msg,true); + add_msg(msg, true); table->fts->in_queue = true; @@ -2808,16 +2807,12 @@ static void fts_optimize_sync_table(dict_table_t* table) /**********************************************************************//** Optimize all FTS tables. @return Dummy return */ -static -void fts_optimize_callback( -/*================*/ - void* arg) /*!< in: work queue*/ +static void fts_optimize_callback(void *) { static ulint current = 0; static ibool done = FALSE; static ulint n_tables = ib_vector_size(fts_slots); static ulint n_optimize = 0; - ib_wqueue_t* wq = fts_optimize_wq; ut_ad(!srv_read_only_mode); @@ -2832,7 +2827,7 @@ void fts_optimize_callback( to optimize then optimize the tables. */ if (!done - && ib_wqueue_is_empty(wq) + && ib_wqueue_is_empty(fts_optimize_wq) && n_tables > 0 && n_optimize > 0) { fts_slot_t* slot = static_cast<fts_slot_t*>( @@ -2850,9 +2845,10 @@ void fts_optimize_callback( current = 0; } - } else if (n_optimize == 0 || !ib_wqueue_is_empty(wq)) { - fts_msg_t* msg; - msg = static_cast<fts_msg_t*>(ib_wqueue_nowait(wq)); + } else if (n_optimize == 0 + || !ib_wqueue_is_empty(fts_optimize_wq)) { + fts_msg_t* msg = static_cast<fts_msg_t*> + (ib_wqueue_nowait(fts_optimize_wq)); /* Timeout ? */ if (msg == NULL) { if (fts_is_sync_needed()) { @@ -2998,18 +2994,17 @@ fts_optimize_shutdown() /* We tell the OPTIMIZE thread to switch to state done, we can't delete the work queue here because the add thread needs deregister the FTS tables. */ - delete timer; - timer = NULL; - task_group.cancel_pending(&task); + delete timer; + timer = NULL; + task_group.cancel_pending(&task); msg = fts_optimize_create_msg(FTS_MSG_STOP, NULL); - add_msg(msg, false); + add_msg(msg); os_event_wait(fts_opt_shutdown_event); os_event_destroy(fts_opt_shutdown_event); ib_wqueue_free(fts_optimize_wq); fts_optimize_wq = NULL; - } diff --git a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc index 925c66d2b16..7e019ab96af 100644 --- a/storage/innobase/handler/ha_innodb.cc +++ b/storage/innobase/handler/ha_innodb.cc @@ -57,7 +57,6 @@ this program; if not, write to the Free Software Foundation, Inc., #include "field.h" #include "srv0srv.h" - // MYSQL_PLUGIN_IMPORT extern my_bool lower_case_file_system; // MYSQL_PLUGIN_IMPORT extern char mysql_unpacked_real_data_home[]; @@ -104,7 +103,6 @@ this program; if not, write to the Free Software Foundation, Inc., #include "row0upd.h" #include "fil0crypt.h" #include "srv0mon.h" -#include "srv0srv.h" #include "srv0start.h" #ifdef UNIV_DEBUG #include "trx0purge.h" diff --git a/storage/innobase/include/buf0dump.h b/storage/innobase/include/buf0dump.h index b8d790d3b13..485869007be 100644 --- a/storage/innobase/include/buf0dump.h +++ b/storage/innobase/include/buf0dump.h @@ -1,6 +1,7 @@ /***************************************************************************** Copyright (c) 2011, 2014, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 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 @@ -26,33 +27,13 @@ Created April 08, 2011 Vasil Dimov #ifndef buf0dump_h #define buf0dump_h -#include "univ.i" - -/*****************************************************************//** -Starts the buffer pool dump/load task dump/load thread and instructs it to start -a dump. This function is called by MySQL code via buffer_pool_dump_now() -and it should return immediately because the whole MySQL is frozen during -its execution. */ -void -buf_dump_start(); -/*============*/ - -/*****************************************************************//** -Starts the buffer pool dump/load task (if not started) and instructs it to start -a load. This function is called by MySQL code via buffer_pool_load_now() -and it should return immediately because the whole MySQL is frozen during -its execution. */ -void -buf_load_start(); -/*============*/ - -/*****************************************************************//** -Aborts a currently running buffer pool load. This function is called by -MySQL code via buffer_pool_load_abort() and it should return immediately -because the whole MySQL is frozen during its execution. */ -void -buf_load_abort(); -/*============*/ +/** Start the buffer pool dump/load task and instructs it to start a dump. */ +void buf_dump_start(); +/** Start the buffer pool dump/load task and instructs it to start a load. */ +void buf_load_start(); + +/** Abort a currently running buffer pool load. */ +void buf_load_abort(); /** Start async buffer pool load, if srv_buffer_pool_load_at_startup was set.*/ void buf_load_at_startup(); diff --git a/storage/innobase/include/dict0stats_bg.h b/storage/innobase/include/dict0stats_bg.h index 14dc38851aa..62746e31021 100644 --- a/storage/innobase/include/dict0stats_bg.h +++ b/storage/innobase/include/dict0stats_bg.h @@ -1,7 +1,7 @@ /***************************************************************************** Copyright (c) 2012, 2017, Oracle and/or its affiliates. All Rights Reserved. -Copyright (c) 2017, 2018, MariaDB Corporation. +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 @@ -97,16 +97,12 @@ dict_stats_wait_bg_to_stop_using_table( /*****************************************************************//** Initialize global variables needed for the operation of dict_stats_thread(). Must be called before dict_stats task is started. */ -void -dict_stats_init(); -/*====================*/ +void dict_stats_init(); /*****************************************************************//** Free resources allocated by dict_stats_thread_init(), must be called after dict_stats task has exited. */ -void -dict_stats_deinit(); -/*======================*/ +void dict_stats_deinit(); #ifdef UNIV_DEBUG /** Disables dict stats thread. It's used by: @@ -116,17 +112,13 @@ void dict_stats_disabled_debug_update(THD*, st_mysql_sys_var*, void*, const void* save); #endif /* UNIV_DEBUG */ - -/** Start the dict stats timer */ -void -dict_stats_start(); +/** Start the dict stats timer. */ +void dict_stats_start(); /** Shut down the dict_stats timer. */ -void -dict_stats_shutdown(); +void dict_stats_shutdown(); -/** reschedule dict stats timer to run now. */ -void -dict_stats_schedule_now(); +/** Reschedule dict stats timer to run now. */ +void dict_stats_schedule_now(); #endif /* dict0stats_bg_h */ diff --git a/storage/innobase/include/lock0lock.h b/storage/innobase/include/lock0lock.h index 67964decf1e..c47c0f6d1a1 100644 --- a/storage/innobase/include/lock0lock.h +++ b/storage/innobase/include/lock0lock.h @@ -646,8 +646,7 @@ lock_table_has_locks( held on records in this table or on the table itself */ -/*********************************************************************//** -A task which wakes up threads whose lock wait may have lasted too long. */ +/** A task which wakes up threads whose lock wait may have lasted too long */ void lock_wait_timeout_task(void*); /********************************************************************//** diff --git a/storage/innobase/include/srv0srv.h b/storage/innobase/include/srv0srv.h index 53c280287f2..d4556640c23 100644 --- a/storage/innobase/include/srv0srv.h +++ b/storage/innobase/include/srv0srv.h @@ -439,10 +439,6 @@ extern uint srv_fast_shutdown; /*!< If this is 1, do not do a InnoDB (but lose no committed transactions). */ -/** Signal to shut down InnoDB (NULL if shutdown was signaled, or if -running in innodb_read_only mode, srv_read_only_mode) */ -extern std::atomic<st_my_thread_var *> srv_running; - extern ibool srv_innodb_status; extern unsigned long long srv_stats_transient_sample_pages; @@ -785,13 +781,10 @@ srv_que_task_enqueue_low( /*=====================*/ que_thr_t* thr); /*!< in: query thread */ -/**********************************************************************//** -Check whether purge or master is active. -@return false if all are are suspended or have exited, true -if any are still active. */ +#ifdef UNIV_DEBUG +/** @return whether purge or master task is active */ bool srv_any_background_activity(); - -/*============================*/ +#endif extern "C" { @@ -801,7 +794,7 @@ void srv_monitor_task(void*); /** The periodic master task controlling the server. */ -void srv_master_callback(void *); +void srv_master_callback(void*); /** @@ -819,17 +812,13 @@ void srv_error_monitor_task(void*); } /* extern "C" */ -/**********************************************************************//** -Get count of tasks in the queue. -@return number of tasks in queue */ -ulint -srv_get_task_queue_length(void); -/*===========================*/ - +#ifdef UNIV_DEBUG +/** @return number of tasks in queue */ +ulint srv_get_task_queue_length(); +#endif /** Wakeup the purge threads. */ -void -srv_purge_wakeup(); +void srv_purge_wakeup(); /** Shut down the purge threads. */ void srv_purge_shutdown(); @@ -837,9 +826,6 @@ void srv_purge_shutdown(); /** Init purge tasks*/ void srv_init_purge_tasks(uint n_max); -/** Shut down purge tasks*/ -void srv_shutdown_purge_tasks(); - #ifdef UNIV_DEBUG /** Disables master thread. It's used by: SET GLOBAL innodb_master_thread_disabled_debug = 1 (0). @@ -1034,18 +1020,15 @@ extern std::unique_ptr<tpool::timer> srv_master_timer; extern std::unique_ptr<tpool::timer> srv_error_monitor_timer; extern std::unique_ptr<tpool::timer> srv_monitor_timer; -#define SRV_MONITOR_TIMER_PERIOD 5000 static inline void srv_monitor_timer_schedule_now() { - srv_monitor_timer->set_time(0, SRV_MONITOR_TIMER_PERIOD); + srv_monitor_timer->set_time(0, 5000); } -static inline void srv_start_periodic_timer( - std::unique_ptr<tpool::timer>& timer, - void (*func)(void*), - int period) +static inline void srv_start_periodic_timer(std::unique_ptr<tpool::timer>& t, + void (*func)(void*), int period) { - timer.reset(srv_thread_pool->create_timer(func)); - timer->set_time(0, period); + t.reset(srv_thread_pool->create_timer(func)); + t->set_time(0, period); } void srv_thread_pool_init(); diff --git a/storage/innobase/include/srv0start.h b/storage/innobase/include/srv0start.h index 79add0b72c3..8b2b94b3394 100644 --- a/storage/innobase/include/srv0start.h +++ b/storage/innobase/include/srv0start.h @@ -50,7 +50,7 @@ dberr_t srv_start(bool create_new_db); /** Shutdown purge to make sure that there is no possibility that we call any - plugin code (e.g audit) inside virtual column computation. + plugin code (e.g., audit) inside virtual column computation. */ void innodb_preshutdown(); diff --git a/storage/innobase/include/trx0purge.h b/storage/innobase/include/trx0purge.h index 9f3438b7f7d..43ae66afeb5 100644 --- a/storage/innobase/include/trx0purge.h +++ b/storage/innobase/include/trx0purge.h @@ -1,7 +1,7 @@ /***************************************************************************** Copyright (c) 1996, 2016, Oracle and/or its affiliates. All Rights Reserved. -Copyright (c) 2017, 2018, MariaDB Corporation. +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 @@ -53,16 +53,12 @@ Remove the undo log segment from the rseg slot if it is too big for reuse. @param[in,out] mtr mini-transaction */ void trx_purge_add_undo_to_history(const trx_t* trx, trx_undo_t*& undo, mtr_t* mtr); -/*******************************************************************//** -This function runs a purge batch. +/** +Run a purge batch. +@param n_tasks number of purge tasks to submit to the queue +@param truncate whether to truncate the history at the end of the batch @return number of undo log pages handled in the batch */ -ulint -trx_purge( -/*======*/ - ulint n_purge_threads, /*!< in: number of purge tasks to - submit to task queue. */ - bool truncate /*!< in: truncate history if true */ -); +ulint trx_purge(ulint n_tasks, bool truncate); /** Rollback segements from a given transaction with trx-no scheduled for purge. */ @@ -224,7 +220,7 @@ public: uninitialised. Real initialisation happens in create(). */ - purge_sys_t():m_initialized(false),m_enabled(false) {} + purge_sys_t(): m_initialized(false), m_enabled(false) {} /** Create the instance */ diff --git a/storage/innobase/lock/lock0wait.cc b/storage/innobase/lock/lock0wait.cc index c98cb299534..a9d0e0f501d 100644 --- a/storage/innobase/lock/lock0wait.cc +++ b/storage/innobase/lock/lock0wait.cc @@ -501,33 +501,31 @@ lock_wait_check_and_cancel( } } -/** Task that is periodically runs in the thread pool*/ +/** A task which wakes up threads whose lock wait may have lasted too long */ void lock_wait_timeout_task(void*) { - lock_wait_mutex_enter(); - - /* Check all slots for user threads that are waiting - on locks, and if they have exceeded the time limit. */ - bool any_slot_in_use = false; - for (srv_slot_t* slot = lock_sys.waiting_threads; - slot < lock_sys.last_slot; - ++slot) { - - /* We are doing a read without the lock mutex - and/or the trx mutex. This is OK because a slot - can't be freed or reserved without the lock wait - mutex. */ - - if (slot->in_use) { - any_slot_in_use = true; - lock_wait_check_and_cancel(slot); - } - } - if (any_slot_in_use) { - lock_sys.timeout_timer->set_time(1000, 0); - } else { - lock_sys.timeout_timer_active = false; - } - lock_wait_mutex_exit(); + lock_wait_mutex_enter(); + + /* Check all slots for user threads that are waiting + on locks, and if they have exceeded the time limit. */ + bool any_slot_in_use= false; + for (srv_slot_t *slot= lock_sys.waiting_threads; + slot < lock_sys.last_slot; ++slot) + { + /* We are doing a read without the lock mutex and/or the trx + mutex. This is OK because a slot can't be freed or reserved + without the lock wait mutex. */ + if (slot->in_use) + { + any_slot_in_use= true; + lock_wait_check_and_cancel(slot); + } + } + + if (any_slot_in_use) + lock_sys.timeout_timer->set_time(1000, 0); + else + lock_sys.timeout_timer_active= false; + + lock_wait_mutex_exit(); } - diff --git a/storage/innobase/log/log0log.cc b/storage/innobase/log/log0log.cc index 609e278e835..9a0abb8853c 100644 --- a/storage/innobase/log/log0log.cc +++ b/storage/innobase/log/log0log.cc @@ -1605,7 +1605,7 @@ wait_suspend_loop: /* Check that the background threads are suspended */ - ut_a(!srv_any_background_activity()); + ut_ad(!srv_any_background_activity()); if (srv_n_fil_crypt_threads_started) { os_event_set(fil_crypt_threads_event); thread_name = "fil_crypt_thread"; @@ -1728,7 +1728,7 @@ wait_suspend_loop: srv_shutdown_state = SRV_SHUTDOWN_LAST_PHASE; /* Make some checks that the server really is quiet */ - ut_a(!srv_any_background_activity()); + ut_ad(!srv_any_background_activity()); service_manager_extend_timeout(INNODB_EXTEND_TIMEOUT_INTERVAL, "Free innodb buffer pool"); @@ -1756,7 +1756,7 @@ wait_suspend_loop: fil_close_all_files(); /* Make some checks that the server really is quiet */ - ut_a(!srv_any_background_activity()); + ut_ad(!srv_any_background_activity()); ut_a(lsn == log_sys.lsn || srv_force_recovery == SRV_FORCE_NO_LOG_REDO); diff --git a/storage/innobase/srv/srv0srv.cc b/storage/innobase/srv/srv0srv.cc index c4e20c973a0..c7823d2e2d8 100644 --- a/storage/innobase/srv/srv0srv.cc +++ b/storage/innobase/srv/srv0srv.cc @@ -586,23 +586,17 @@ static srv_sys_t srv_sys; */ struct purge_coordinator_state { - /* Snapshot of the last history length before the purge call.*/ - uint32 m_history_length; - Atomic_counter<int> m_running; - purge_coordinator_state() : - m_history_length(), m_running(0) - {} + /** Snapshot of the last history length before the purge call.*/ + uint32 m_history_length; + Atomic_counter<int> m_running; + purge_coordinator_state() : m_history_length(), m_running(0) {} }; static purge_coordinator_state purge_state; extern tpool::waitable_task purge_coordinator_task; /** @return whether the purge coordinator thread is active */ -bool purge_sys_t::running() -{ - return purge_coordinator_task.is_running(); -} - +bool purge_sys_t::running() { return purge_coordinator_task.is_running(); } /** threadpool timer for srv_error_monitor_task(). */ std::unique_ptr<tpool::timer> srv_error_monitor_timer; @@ -726,30 +720,29 @@ static void thread_pool_thread_end() void srv_thread_pool_init() { - DBUG_ASSERT(!srv_thread_pool); + DBUG_ASSERT(!srv_thread_pool); #if defined (_WIN32) - srv_thread_pool = tpool::create_thread_pool_win(); + srv_thread_pool= tpool::create_thread_pool_win(); #else - srv_thread_pool = tpool::create_thread_pool_generic(); + srv_thread_pool= tpool::create_thread_pool_generic(); #endif - srv_thread_pool->set_thread_callbacks(thread_pool_thread_init, thread_pool_thread_end); + srv_thread_pool->set_thread_callbacks(thread_pool_thread_init, + thread_pool_thread_end); } void srv_thread_pool_end() { - ut_a(!srv_master_timer); - delete srv_thread_pool; - srv_thread_pool = nullptr; + ut_ad(!srv_master_timer); + delete srv_thread_pool; + srv_thread_pool= nullptr; } static bool need_srv_free; /** Initialize the server. */ -static -void -srv_init() +static void srv_init() { mutex_create(LATCH_ID_SRV_INNODB_MONITOR, &srv_innodb_monitor_mutex); srv_thread_pool_init(); @@ -1407,16 +1400,14 @@ srv_export_innodb_status(void) struct srv_monitor_state_t { - time_t last_monitor_time; - ulint mutex_skipped; - bool last_srv_print_monitor; - srv_monitor_state_t() - { - srv_last_monitor_time = time(NULL); - last_monitor_time = srv_last_monitor_time; - mutex_skipped = 0; - last_srv_print_monitor = false; - } + time_t last_monitor_time; + ulint mutex_skipped; + bool last_srv_print_monitor; + srv_monitor_state_t() : mutex_skipped(0), last_srv_print_monitor(false) + { + srv_last_monitor_time = time(NULL); + last_monitor_time= srv_last_monitor_time; + } }; static srv_monitor_state_t monitor_state; @@ -1558,18 +1549,18 @@ srv_inc_activity_count(void) srv_sys.activity_count.inc(); } -/** -Check whether purge or master are still active. -@return true if something is active, false if not. -*/ +#ifdef UNIV_DEBUG +/** @return whether purge or master task is active */ bool srv_any_background_activity() { - if (purge_sys.enabled() || srv_master_timer.get()) { - ut_ad(!srv_read_only_mode); - return true; - } - return false; + if (purge_sys.enabled() || srv_master_timer.get()) + { + ut_ad(!srv_read_only_mode); + return true; + } + return false; } +#endif /* UNIV_DEBUG */ /** Wake up the InnoDB master thread if it was suspended (not sleeping). */ void @@ -1582,17 +1573,19 @@ srv_active_wake_master_thread_low() } -void purge_worker_callback(void*); -void purge_coordinator_callback(void*); -void purge_coordinator_timer_callback(void*); +static void purge_worker_callback(void*); +static void purge_coordinator_callback(void*); +static void purge_coordinator_timer_callback(void*); -tpool::task_group purge_task_group; -tpool::waitable_task purge_worker_task(purge_worker_callback, nullptr, &purge_task_group); +static tpool::task_group purge_task_group; +tpool::waitable_task purge_worker_task(purge_worker_callback, nullptr, + &purge_task_group); +static tpool::task_group purge_coordinator_task_group(1); +tpool::waitable_task purge_coordinator_task(purge_coordinator_callback, + nullptr, + &purge_coordinator_task_group); -tpool::task_group purge_coordinator_task_group(1); -tpool::waitable_task purge_coordinator_task(purge_coordinator_callback, nullptr, &purge_coordinator_task_group); - -tpool::timer* purge_coordinator_timer; +static tpool::timer *purge_coordinator_timer; /** Wake up the purge threads if there is work to do. */ void @@ -1965,10 +1958,7 @@ srv_shutdown(bool ibuf_merge) } while (n_bytes_merged || n_tables_to_drop); } -/*********************************************************************//** -The periodic master controlling the server. -@return a dummy parameter */ - +/** The periodic master task controlling the server. */ void srv_master_callback(void*) { static ulint old_activity_count; @@ -2117,17 +2107,16 @@ static uint32_t srv_do_purge(ulint* n_total_purged) } -std::queue<THD*> purge_thds; -std::mutex purge_thd_mutex; +static std::queue<THD*> purge_thds; +static std::mutex purge_thd_mutex; -void purge_create_background_thds(int n) +static void purge_create_background_thds(int n) { - THD* thd = current_thd; - std::unique_lock<std::mutex> lk(purge_thd_mutex); - for (int i = 0; i < n; i++) { - purge_thds.push(innobase_create_background_thd("InnoDB purge worker")); - } - set_current_thd(thd); + THD *thd= current_thd; + std::unique_lock<std::mutex> lk(purge_thd_mutex); + while (n--) + purge_thds.push(innobase_create_background_thd("InnoDB purge worker")); + set_current_thd(thd); } extern void* thd_attach_thd(THD*); @@ -2162,103 +2151,98 @@ void release_thd(THD *thd, void *ctx) Called by timer when purge coordinator decides to delay processing of purge records. */ -void purge_coordinator_timer_callback(void *) +static void purge_coordinator_timer_callback(void *) { - if (!purge_sys.enabled() || purge_sys.paused() || - purge_state.m_running || !trx_sys.rseg_history_len) { - return; - } - - if (purge_state.m_history_length < 5000 && - purge_state.m_history_length == trx_sys.rseg_history_len) { - - /* No new records were added since wait started. - Simply wait for new records.The magic number 5000 is an - approximation for the case where we have cached UNDO - log records which prevent truncate of the UNDO segments.*/ - - return; - } - - srv_wake_purge_thread_if_not_active(); + if (!purge_sys.enabled() || purge_sys.paused() || + purge_state.m_running || !trx_sys.rseg_history_len) + return; + + if (purge_state.m_history_length < 5000 && + purge_state.m_history_length == trx_sys.rseg_history_len) + /* No new records were added since wait started. + Simply wait for new records. The magic number 5000 is an + approximation for the case where we have cached UNDO + log records which prevent truncate of the UNDO segments.*/ + return; + srv_wake_purge_thread_if_not_active(); } -void purge_worker_callback(void*) +static void purge_worker_callback(void*) { - ut_ad(!current_thd); - ut_ad(!srv_read_only_mode); - ut_ad(srv_force_recovery < SRV_FORCE_NO_BACKGROUND); - void* ctx; - THD* thd = acquire_thd(&ctx); - while (srv_task_execute()){} - release_thd(thd,ctx); + ut_ad(!current_thd); + ut_ad(!srv_read_only_mode); + ut_ad(srv_force_recovery < SRV_FORCE_NO_BACKGROUND); + void *ctx; + THD *thd= acquire_thd(&ctx); + while (srv_task_execute()) {} + release_thd(thd,ctx); } - -void purge_coordinator_callback_low() +static void purge_coordinator_callback_low() { - ulint n_total_purged = ULINT_UNDEFINED; - purge_state.m_history_length = 0; - - if (!purge_sys.enabled() || purge_sys.paused()) { - return; - } - do { - n_total_purged = 0; - - int sigcount = purge_state.m_running; - - purge_state.m_history_length = srv_do_purge(&n_total_purged); - - /* Check if purge was woken by srv_wake_purge_thread_if_not_active() */ - - bool woken_during_purge = purge_state.m_running > sigcount; - - /*If last purge batch processed less that 1 page and there is still work to do, - delay the next batch by 10ms. Unless someone added work and woke us up. */ - if (n_total_purged == 0){ - - if(trx_sys.rseg_history_len == 0) { - return; - } - - if (!woken_during_purge) { - /* Delay next purge round*/ - purge_coordinator_timer->set_time(10, 0); - return; - } - } - } while((purge_sys.enabled() && !purge_sys.paused()) || !srv_purge_should_exit()); + ulint n_total_purged= ULINT_UNDEFINED; + purge_state.m_history_length= 0; + + if (!purge_sys.enabled() || purge_sys.paused()) + return; + do + { + n_total_purged = 0; + int sigcount= purge_state.m_running; + + purge_state.m_history_length= srv_do_purge(&n_total_purged); + + /* Check if purge was woken by srv_wake_purge_thread_if_not_active() */ + + bool woken_during_purge= purge_state.m_running > sigcount; + + /* If last purge batch processed less than 1 page and there is + still work to do, delay the next batch by 10ms. Unless + someone added work and woke us up. */ + if (n_total_purged == 0) + { + if (trx_sys.rseg_history_len == 0) + return; + if (!woken_during_purge) + { + /* Delay next purge round*/ + purge_coordinator_timer->set_time(10, 0); + return; + } + } + } + while ((purge_sys.enabled() && !purge_sys.paused()) || + !srv_purge_should_exit()); } -void purge_coordinator_callback(void*) +static void purge_coordinator_callback(void*) { - void* ctx; - THD* thd = acquire_thd(&ctx); - purge_coordinator_callback_low(); - release_thd(thd,ctx); - purge_state.m_running = 0; + void *ctx; + THD *thd= acquire_thd(&ctx); + purge_coordinator_callback_low(); + release_thd(thd,ctx); + purge_state.m_running= 0; } void srv_init_purge_tasks(uint n_tasks) { - purge_task_group.set_max_tasks(n_tasks-1); - purge_create_background_thds(n_tasks); - purge_coordinator_timer = - srv_thread_pool->create_timer(purge_coordinator_timer_callback, - nullptr); + purge_task_group.set_max_tasks(n_tasks - 1); + purge_create_background_thds(n_tasks); + purge_coordinator_timer= srv_thread_pool->create_timer + (purge_coordinator_timer_callback, nullptr); } -void srv_shutdown_purge_tasks() +static void srv_shutdown_purge_tasks() { - purge_coordinator_task.wait(); - delete purge_coordinator_timer; - purge_coordinator_timer = nullptr; - purge_worker_task.wait(); - while (!purge_thds.empty()) { - innobase_destroy_background_thd(purge_thds.front()); - purge_thds.pop(); - } + purge_coordinator_task.wait(); + delete purge_coordinator_timer; + purge_coordinator_timer= nullptr; + purge_worker_task.wait(); + while (!purge_thds.empty()) + { + innobase_destroy_background_thd(purge_thds.front()); + purge_thds.pop(); + } } /**********************************************************************//** @@ -2277,12 +2261,9 @@ srv_que_task_enqueue_low( mutex_exit(&srv_sys.tasks_mutex); } -/**********************************************************************//** -Get count of tasks in the queue. -@return number of tasks in queue */ -ulint -srv_get_task_queue_length(void) -/*===========================*/ +#ifdef UNIV_DEBUG +/** @return number of tasks in queue */ +ulint srv_get_task_queue_length() { ulint n_tasks; @@ -2296,6 +2277,7 @@ srv_get_task_queue_length(void) return(n_tasks); } +#endif /** Wake up the purge coordinator. */ void @@ -2324,4 +2306,4 @@ void srv_purge_shutdown() purge_sys.coordinator_shutdown(); srv_shutdown_purge_tasks(); } -}
\ No newline at end of file +} diff --git a/storage/innobase/srv/srv0start.cc b/storage/innobase/srv/srv0start.cc index 20d19520611..1048dc6506f 100644 --- a/storage/innobase/srv/srv0start.cc +++ b/storage/innobase/srv/srv0start.cc @@ -510,11 +510,7 @@ srv_undo_tablespace_create( srv_read_only_mode ? OS_FILE_OPEN : OS_FILE_CREATE, OS_FILE_NORMAL, OS_DATA_FILE, srv_read_only_mode, &ret); - if (srv_read_only_mode && ret) { - - ib::info() << name << " opened in read-only mode"; - - } else if (ret == FALSE) { + if (!ret) { if (os_file_get_last_error(false) != OS_FILE_ALREADY_EXISTS #ifdef UNIV_AIX /* AIX 5.1 after security patch ML7 may have @@ -527,9 +523,9 @@ srv_undo_tablespace_create( << name; } err = DB_ERROR; + } else if (srv_read_only_mode) { + ib::info() << name << " opened in read-only mode"; } else { - ut_a(!srv_read_only_mode); - /* We created the data file and now write it full of zeros */ ib::info() << "Data file " << name << " did not exist: new to" @@ -1691,7 +1687,7 @@ files_checked: trx_sys.create(); if (create_new_db) { - ut_a(!srv_read_only_mode); + ut_ad(!srv_read_only_mode); mtr_start(&mtr); ut_ad(fil_system.sys_space->id == 0); @@ -2282,29 +2278,23 @@ void srv_shutdown_bg_undo_sources() } /** -Perform pre-shutdown task. - -Since purge tasks vall into server (some MDL acqusition, -and compute virtual functions), let them shut down right -after use connections go down while the rest of the server -infrasture is still intact. + Shutdown purge to make sure that there is no possibility that we call any + plugin code (e.g., audit) inside virtual column computation. */ void innodb_preshutdown() { - static bool first_time = true; - if (!first_time) - return; - first_time = false; - - if (!srv_read_only_mode) { - if (!srv_fast_shutdown && srv_operation == SRV_OPERATION_NORMAL) { - while (trx_sys.any_active_transactions()) { - os_thread_sleep(1000); - } - } - srv_shutdown_bg_undo_sources(); - srv_purge_shutdown(); - } + static bool first_time= true; + if (!first_time) + return; + first_time= false; + + if (srv_read_only_mode) + return; + if (!srv_fast_shutdown && srv_operation == SRV_OPERATION_NORMAL) + while (trx_sys.any_active_transactions()) + os_thread_sleep(1000); + srv_shutdown_bg_undo_sources(); + srv_purge_shutdown(); } @@ -2461,5 +2451,3 @@ srv_get_meta_data_filename( ut_free(path); } - - diff --git a/storage/innobase/trx/trx0purge.cc b/storage/innobase/trx/trx0purge.cc index 0cef749fd14..251906a6207 100644 --- a/storage/innobase/trx/trx0purge.cc +++ b/storage/innobase/trx/trx0purge.cc @@ -173,17 +173,16 @@ void purge_sys_t::create() mutex_create(LATCH_ID_PURGE_SYS_PQ, &pq_mutex); truncate.current= NULL; truncate.last= NULL; - m_initialized = true; - + m_initialized= true; } /** Close the purge subsystem on shutdown. */ void purge_sys_t::close() { + ut_ad(this == &purge_sys); if (!m_initialized) return; - ut_ad(this == &purge_sys); ut_ad(!enabled()); trx_t* trx = query->trx; que_graph_free(query); @@ -193,7 +192,7 @@ void purge_sys_t::close() trx_free(trx); rw_lock_free(&latch); mutex_free(&pq_mutex); - m_initialized = false; + m_initialized= false; } /*================ UNDO LOG HISTORY LIST =============================*/ @@ -1252,31 +1251,25 @@ trx_purge_dml_delay(void) extern tpool::waitable_task purge_worker_task; /** Wait for pending purge jobs to complete. */ -static -void -trx_purge_wait_for_workers_to_complete() +static void trx_purge_wait_for_workers_to_complete() { - purge_worker_task.wait(); - /* There should be no outstanding tasks as long - as the worker threads are active. */ - ut_a(srv_get_task_queue_length() == 0); + purge_worker_task.wait(); + /* There should be no outstanding tasks as long + as the worker threads are active. */ + ut_ad(srv_get_task_queue_length() == 0); } -/*******************************************************************//** -This function runs a purge batch. +/** +Run a purge batch. +@param n_tasks number of purge tasks to submit to the queue +@param truncate whether to truncate the history at the end of the batch @return number of undo log pages handled in the batch */ -ulint -trx_purge( -/*======*/ - ulint n_purge_threads, /*!< in: number of purge tasks - to submit to the work queue */ - bool truncate /*!< in: truncate history if true */ -) +ulint trx_purge(ulint n_tasks, bool truncate) { que_thr_t* thr = NULL; ulint n_pages_handled; - ut_a(n_purge_threads > 0); + ut_ad(n_tasks > 0); srv_dml_needed_delay = trx_purge_dml_delay(); @@ -1291,10 +1284,10 @@ trx_purge( #endif /* UNIV_DEBUG */ /* Fetch the UNDO recs that need to be purged. */ - n_pages_handled = trx_purge_attach_undo_recs(n_purge_threads); + n_pages_handled = trx_purge_attach_undo_recs(n_tasks); /* Submit tasks to workers queue if using multi-threaded purge. */ - for (ulint i = 0; i < n_purge_threads-1; i++) { + for (ulint i = n_tasks; --i; ) { thr = que_fork_scheduler_round_robin(purge_sys.query, thr); ut_a(thr); srv_que_task_enqueue_low(thr); |