1.master 线程的主代码位于
(1)storage/innobase/srv/srv0srv.cc
(2)storage/innobase/buf/buf0flu.cc
srv_master_do_idle_task()每10秒中的操作。
srv_master_do_active_tasks()每秒中的操作。
1秒中的算法做的事情(主循环)：
(1)日志刷新到磁盘，即使这个事务没有提交(总是)
(2)合并插入缓冲(可能)
//(3)至多刷新innodb_io_capacity个innodb的缓冲池中的脏页到磁盘(可能) ---innodb新版本中已经交给了page_cleaner线程
(4)如果没有用户活动，切换到background loop(可能)
10秒中的算法做的事情(主循环):
(1)刷新innodb_io_capacity个脏页到从盘(可能)
(2)合并至多innodb_io_capacity*5%个插入缓冲(总是)
(3)将日志缓冲刷新到磁盘(总是)
//(4)刷新100个或者10个脏页到磁盘(总是)---innodb新版本中已经交给了page_cleaner线程
切换到background loop做的事情：
(1)删除innodb_purge_batch_size个无用的undo页(总是)
(2)合并innodb_io_capacity*5%个插入缓冲(总是)
(3)跳回到主循环(总是)
//(4)不断刷新innodb_io_capacity个页直到符合条件---innodb新版本中已经交给了page_cleaner线程
mysql5.6后台线程:
+-----------+----------------------------------------+------------+
| thread_id | name | type |
+-----------+----------------------------------------+------------+
| 1 | thread/sql/main | BACKGROUND |
| 2 | thread/innodb/io_handler_thread | BACKGROUND |
| 3 | thread/innodb/io_handler_thread | BACKGROUND |
| 4 | thread/innodb/io_handler_thread | BACKGROUND |
| 5 | thread/innodb/io_handler_thread | BACKGROUND |
| 6 | thread/innodb/io_handler_thread | BACKGROUND |
| 7 | thread/innodb/io_handler_thread | BACKGROUND |
| 8 | thread/innodb/io_handler_thread | BACKGROUND |
| 9 | thread/innodb/io_handler_thread | BACKGROUND |
| 10 | thread/innodb/io_handler_thread | BACKGROUND |
| 11 | thread/innodb/io_handler_thread | BACKGROUND |
| 14 | thread/innodb/srv_master_thread | BACKGROUND |
| 15 | thread/innodb/srv_monitor_thread | BACKGROUND |
| 16 | thread/innodb/srv_purge_thread | BACKGROUND | --undo页回收线程
| 17 | thread/innodb/srv_error_monitor_thread | BACKGROUND |
| 18 | thread/innodb/srv_lock_timeout_thread | BACKGROUND |
| 19 | thread/innodb/page_cleaner_thread | BACKGROUND | --刷新脏页线程
| 20 | thread/sql/signal_handler | BACKGROUND |
+-----------+----------------------------------------+------------+
storage/innobase/buf/buf0flu.cc:
/******************************************************************//**
page_cleaner thread tasked with flushing dirty pages from the buffer
pools. As of now we'll have only one instance of this thread.
@return a dummy parameter */
extern "C" UNIV_INTERN
os_thread_ret_t
DECLARE_THREAD(buf_flush_page_cleaner_thread)(
/*==========================================*/
void* arg __attribute__((unused)))
/*!< in: a dummy parameter required by
os_thread_create */
{
ulint next_loop_time = ut_time_ms() + 1000;
ulint n_flushed = 0;
ulint last_activity = srv_get_activity_count();
ut_ad(!srv_read_only_mode);
#ifdef UNIV_PFS_THREAD
pfs_register_thread(buf_page_cleaner_thread_key);
#endif /* UNIV_PFS_THREAD */
#ifdef UNIV_DEBUG_THREAD_CREATION
fprintf(stderr, "InnoDB: page_cleaner thread running, id %lu\n",
os_thread_pf(os_thread_get_curr_id()));
#endif /* UNIV_DEBUG_THREAD_CREATION */
buf_page_cleaner_is_active = TRUE;
while (srv_shutdown_state == SRV_SHUTDOWN_NONE) {
/* The page_cleaner skips sleep if the server is
idle and there are no pending IOs in the buffer pool
and there is work to do. */
if (srv_check_activity(last_activity)
|| buf_get_n_pending_read_ios()
|| n_flushed == 0) {
page_cleaner_sleep_if_needed(next_loop_time);
}
next_loop_time = ut_time_ms() + 1000;
if (srv_check_activity(last_activity)) {
last_activity = srv_get_activity_count();
/* Flush pages from end of LRU if required */
n_flushed = buf_flush_LRU_tail();
/* Flush pages from flush_list if required */
n_flushed += page_cleaner_flush_pages_if_needed();
} else {
n_flushed = page_cleaner_do_flush_batch(
PCT_IO(100),
LSN_MAX);
if (n_flushed) {
MONITOR_INC_VALUE_CUMULATIVE(
MONITOR_FLUSH_BACKGROUND_TOTAL_PAGE,
MONITOR_FLUSH_BACKGROUND_COUNT,
MONITOR_FLUSH_BACKGROUND_PAGES,
n_flushed);
}
}
}
ut_ad(srv_shutdown_state > 0);
if (srv_fast_shutdown == 2) {
/* In very fast shutdown we simulate a crash of
buffer pool. We are not required to do any flushing */
goto thread_exit;
}
/* In case of normal and slow shutdown the page_cleaner thread
must wait for all other activity in the server to die down.
Note that we can start flushing the buffer pool as soon as the
server enters shutdown phase but we must stay alive long enough
to ensure that any work done by the master or purge threads is
also flushed.
During shutdown we pass through two stages. In the first stage,
when SRV_SHUTDOWN_CLEANUP is set other threads like the master
and the purge threads may be working as well. We start flushing
the buffer pool but can't be sure that no new pages are being
dirtied until we enter SRV_SHUTDOWN_FLUSH_PHASE phase. */
do {
n_flushed = page_cleaner_do_flush_batch(PCT_IO(100), LSN_MAX);
/* We sleep only if there are no pages to flush */
if (n_flushed == 0) {
os_thread_sleep(100000);
}
} while (srv_shutdown_state == SRV_SHUTDOWN_CLEANUP);
/* At this point all threads including the master and the purge
thread must have been suspended. */
ut_a(srv_get_active_thread_type() == SRV_NONE);
ut_a(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.
It is important that we wait for any running batch that has
been triggered by us to finish. Otherwise we can end up
considering end of that batch as a finish of our final
sweep and we'll come out of the loop leaving behind dirty pages
in the flush_list */
buf_flush_wait_batch_end(NULL, BUF_FLUSH_LIST);
buf_flush_wait_LRU_batch_end();
bool success;
do {
success = buf_flush_list(PCT_IO(100), LSN_MAX, &n_flushed);
buf_flush_wait_batch_end(NULL, BUF_FLUSH_LIST);
} while (!success || n_flushed > 0);
/* Some sanity checks */
ut_a(srv_get_active_thread_type() == SRV_NONE);
ut_a(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);
ut_a(UT_LIST_GET_LEN(buf_pool->flush_list) == 0);
}
/* We have lived our life. Time to die. */
thread_exit:
buf_page_cleaner_is_active = FALSE;
/* We count the number of threads in os_thread_exit(). A created
thread should always use that to exit and not use return() to exit. */
os_thread_exit(NULL);
OS_THREAD_DUMMY_RETURN;
}
/*********************************************************************//**
This function is called approximately once every second by the
page_cleaner thread. Based on various factors it decides if there is a
need to do flushing. If flushing is needed it is performed and the
number of pages flushed is returned.
@return number of pages flushed */
static
ulint
page_cleaner_flush_pages_if_needed(void)
/*====================================*/
{
static lsn_t lsn_avg_rate = 0;
static lsn_t prev_lsn = 0;
static lsn_t last_lsn = 0;
static ulint sum_pages = 0;
static ulint last_pages = 0;
static ulint prev_pages = 0;
static ulint avg_page_rate = 0;
static ulint n_iterations = 0;
lsn_t oldest_lsn;
lsn_t cur_lsn;
lsn_t age;
lsn_t lsn_rate;
ulint n_pages = 0;
ulint pct_for_dirty = 0;
ulint pct_for_lsn = 0;
ulint pct_total = 0;
int age_factor = 0;
cur_lsn = log_get_lsn();
if (prev_lsn == 0) {
/* First time around. */
prev_lsn = cur_lsn;
return(0);
}
if (prev_lsn == cur_lsn) {
return(0);
}
/* We update our variables every srv_flushing_avg_loops
iterations to smooth out transition in workload. */
if (++n_iterations >= srv_flushing_avg_loops) {
avg_page_rate = ((sum_pages / srv_flushing_avg_loops)
+ avg_page_rate) / 2;
/* How much LSN we have generated since last call. */
lsn_rate = (cur_lsn - prev_lsn) / srv_flushing_avg_loops;
lsn_avg_rate = (lsn_avg_rate + lsn_rate) / 2;
prev_lsn = cur_lsn;
n_iterations = 0;
sum_pages = 0;
}
oldest_lsn = buf_pool_get_oldest_modification();
ut_ad(oldest_lsn <= log_get_lsn());
age = cur_lsn > oldest_lsn ? cur_lsn - oldest_lsn : 0;
pct_for_dirty = af_get_pct_for_dirty();
pct_for_lsn = af_get_pct_for_lsn(age);
pct_total = ut_max(pct_for_dirty, pct_for_lsn);
/* Cap the maximum IO capacity that we are going to use by
max_io_capacity. */
n_pages = (PCT_IO(pct_total) + avg_page_rate) / 2;
if (n_pages > srv_max_io_capacity) {
n_pages = srv_max_io_capacity;
}
if (last_pages && cur_lsn - last_lsn > lsn_avg_rate / 2) {
age_factor = prev_pages / last_pages;
}
MONITOR_SET(MONITOR_FLUSH_N_TO_FLUSH_REQUESTED, n_pages);
prev_pages = n_pages;
n_pages = page_cleaner_do_flush_batch(
n_pages, oldest_lsn + lsn_avg_rate * (age_factor + 1));
last_lsn= cur_lsn;
last_pages= n_pages + 1;
MONITOR_SET(MONITOR_FLUSH_AVG_PAGE_RATE, avg_page_rate);
MONITOR_SET(MONITOR_FLUSH_LSN_AVG_RATE, lsn_avg_rate);
MONITOR_SET(MONITOR_FLUSH_PCT_FOR_DIRTY, pct_for_dirty);
MONITOR_SET(MONITOR_FLUSH_PCT_FOR_LSN, pct_for_lsn);
if (n_pages) {
MONITOR_INC_VALUE_CUMULATIVE(
MONITOR_FLUSH_ADAPTIVE_TOTAL_PAGE,
MONITOR_FLUSH_ADAPTIVE_COUNT,
MONITOR_FLUSH_ADAPTIVE_PAGES,
n_pages);
sum_pages += n_pages;
}
return(n_pages);
}
storage/innobase/srv/srv0srv.c:
/*********************************************************************//**
Perform the tasks that the master thread is supposed to do when the
server is active. There are two types of tasks. The first category is
of such tasks which are performed at each inovcation of this function.
We assume that this function is called roughly every second when the
server is active. The second category is of such tasks which are
performed at some interval e.g.: purge, dict_LRU cleanup etc. */
static
void
srv_master_do_active_tasks(void)
/*============================*/
{
ib_time_t cur_time = ut_time();
ullint counter_time = ut_time_us(NULL);
/* First do the tasks that we are suppose to do at each
invocation of this function. */
++srv_main_active_loops;
MONITOR_INC(MONITOR_MASTER_ACTIVE_LOOPS);
/* ALTER TABLE in MySQL requires on Unix that the table handler
can drop tables lazily after there no longer are SELECT
queries to them. */
srv_main_thread_op_info = "doing background drop tables";
row_drop_tables_for_mysql_in_background();
MONITOR_INC_TIME_IN_MICRO_SECS(
MONITOR_SRV_BACKGROUND_DROP_TABLE_MICROSECOND, counter_time);
if (srv_shutdown_state > 0) {
return;
}
/* make sure that there is enough reusable space in the redo
log files */
srv_main_thread_op_info = "checking free log space";
log_free_check();
/* Do an ibuf merge */
srv_main_thread_op_info = "doing insert buffer merge";
counter_time = ut_time_us(NULL);
ibuf_contract_in_background(0, FALSE);
MONITOR_INC_TIME_IN_MICRO_SECS(
MONITOR_SRV_IBUF_MERGE_MICROSECOND, counter_time);
/* Flush logs if needed */
srv_main_thread_op_info = "flushing log";
srv_sync_log_buffer_in_background();
MONITOR_INC_TIME_IN_MICRO_SECS(
MONITOR_SRV_LOG_FLUSH_MICROSECOND, counter_time);
/* Now see if various tasks that are performed at defined
intervals need to be performed. */
#ifdef MEM_PERIODIC_CHECK
/* Check magic numbers of every allocated mem block once in
SRV_MASTER_MEM_VALIDATE_INTERVAL seconds */
if (cur_time % SRV_MASTER_MEM_VALIDATE_INTERVAL == 0) {
mem_validate_all_blocks();
MONITOR_INC_TIME_IN_MICRO_SECS(
MONITOR_SRV_MEM_VALIDATE_MICROSECOND, counter_time);
}
#endif
if (srv_shutdown_state > 0) {
return;
}
if (srv_shutdown_state > 0) {
return;
}
if (cur_time % SRV_MASTER_DICT_LRU_INTERVAL == 0) {
srv_main_thread_op_info = "enforcing dict cache limit";
srv_master_evict_from_table_cache(50);
MONITOR_INC_TIME_IN_MICRO_SECS(
MONITOR_SRV_DICT_LRU_MICROSECOND, counter_time);
}
if (srv_shutdown_state > 0) {
return;
}
/* Make a new checkpoint */
if (cur_time % SRV_MASTER_CHECKPOINT_INTERVAL == 0) {
srv_main_thread_op_info = "making checkpoint";
log_checkpoint(TRUE, FALSE);
MONITOR_INC_TIME_IN_MICRO_SECS(
MONITOR_SRV_CHECKPOINT_MICROSECOND, counter_time);
}
}
/*********************************************************************//**
Perform the tasks that the master thread is supposed to do whenever the
server is idle. We do check for the server state during this function
and if the server has entered the shutdown phase we may return from
the function without completing the required tasks.
Note that the server can move to active state when we are executing this
function but we don't check for that as we are suppose to perform more
or less same tasks when server is active. */
static
void
srv_master_do_idle_tasks(void)
/*==========================*/
{
ullint counter_time;
++srv_main_idle_loops;
MONITOR_INC(MONITOR_MASTER_IDLE_LOOPS);
/* ALTER TABLE in MySQL requires on Unix that the table handler
can drop tables lazily after there no longer are SELECT
queries to them. */
counter_time = ut_time_us(NULL);
srv_main_thread_op_info = "doing background drop tables";
row_drop_tables_for_mysql_in_background();
MONITOR_INC_TIME_IN_MICRO_SECS(
MONITOR_SRV_BACKGROUND_DROP_TABLE_MICROSECOND,
counter_time);
if (srv_shutdown_state > 0) {
return;
}
/* make sure that there is enough reusable space in the redo
log files */
srv_main_thread_op_info = "checking free log space";
log_free_check();
/* Do an ibuf merge */
counter_time = ut_time_us(NULL);
srv_main_thread_op_info = "doing insert buffer merge";
ibuf_contract_in_background(0, TRUE);
MONITOR_INC_TIME_IN_MICRO_SECS(
MONITOR_SRV_IBUF_MERGE_MICROSECOND, counter_time);
if (srv_shutdown_state > 0) {
return;
}
srv_main_thread_op_info = "enforcing dict cache limit";
srv_master_evict_from_table_cache(100);
MONITOR_INC_TIME_IN_MICRO_SECS(
MONITOR_SRV_DICT_LRU_MICROSECOND, counter_time);
/* Flush logs if needed */
srv_sync_log_buffer_in_background();
MONITOR_INC_TIME_IN_MICRO_SECS(
MONITOR_SRV_LOG_FLUSH_MICROSECOND, counter_time);
if (srv_shutdown_state > 0) {
return;
}
/* Make a new checkpoint */
srv_main_thread_op_info = "making checkpoint";
log_checkpoint(TRUE, FALSE);
MONITOR_INC_TIME_IN_MICRO_SECS(MONITOR_SRV_CHECKPOINT_MICROSECOND,
counter_time);
}
/*********************************************************************//**
Perform the tasks during shutdown. The tasks that we do at shutdown
depend on srv_fast_shutdown:
2 => very fast shutdown => do no book keeping
1 => normal shutdown => clear drop table queue and make checkpoint
0 => slow shutdown => in addition to above do complete purge and ibuf
merge
@return TRUE if some work was done. FALSE otherwise */
static
ibool
srv_master_do_shutdown_tasks(
/*=========================*/
ib_time_t* last_print_time)/*!< last time the function
print the message */
{
ulint n_bytes_merged = 0;
ulint n_tables_to_drop = 0;
ut_ad(!srv_read_only_mode);
++srv_main_shutdown_loops;
ut_a(srv_shutdown_state > 0);
/* In very fast shutdown none of the following is necessary */
if (srv_fast_shutdown == 2) {
return(FALSE);
}
/* ALTER TABLE in MySQL requires on Unix that the table handler
can drop tables lazily after there no longer are SELECT
queries to them. */
srv_main_thread_op_info = "doing background drop tables";
n_tables_to_drop = row_drop_tables_for_mysql_in_background();
/* make sure that there is enough reusable space in the redo
log files */
srv_main_thread_op_info = "checking free log space";
log_free_check();
/* In case of normal shutdown we don't do ibuf merge or purge */
if (srv_fast_shutdown == 1) {
goto func_exit;
}
/* Do an ibuf merge */
srv_main_thread_op_info = "doing insert buffer merge";
n_bytes_merged = ibuf_contract_in_background(0, TRUE);
/* Flush logs if needed */
srv_sync_log_buffer_in_background();
func_exit:
/* Make a new checkpoint about once in 10 seconds */
srv_main_thread_op_info = "making checkpoint";
log_checkpoint(TRUE, FALSE);
/* Print progress message every 60 seconds during shutdown */
if (srv_shutdown_state > 0 && srv_print_verbose_log) {
srv_shutdown_print_master_pending(
last_print_time, n_tables_to_drop, n_bytes_merged);
}
return(n_bytes_merged || n_tables_to_drop);
}
/*********************************************************************//**
Puts master thread to sleep. At this point we are using polling to
service various activities. Master thread sleeps for one second before
checking the state of the server again */
static
void
srv_master_sleep(void)
/*==================*/
{
srv_main_thread_op_info = "sleeping";
os_thread_sleep(1000000);
srv_main_thread_op_info = "";
}
/*********************************************************************//**
The master thread controlling the server.
@return a dummy parameter */
extern "C" UNIV_INTERN
os_thread_ret_t
DECLARE_THREAD(srv_master_thread)(
/*==============================*/
void* arg __attribute__((unused)))
/*!< in: a dummy parameter required by
os_thread_create */
{
srv_slot_t* slot;
ulint old_activity_count = srv_get_activity_count();
ib_time_t last_print_time;
ut_ad(!srv_read_only_mode);
#ifdef UNIV_DEBUG_THREAD_CREATION
fprintf(stderr, "Master thread starts, id %lu\n",
os_thread_pf(os_thread_get_curr_id()));
#endif /* UNIV_DEBUG_THREAD_CREATION */
#ifdef UNIV_PFS_THREAD
pfs_register_thread(srv_master_thread_key);
#endif /* UNIV_PFS_THREAD */
srv_main_thread_process_no = os_proc_get_number();
srv_main_thread_id = os_thread_pf(os_thread_get_curr_id());
slot = srv_reserve_slot(SRV_MASTER);
ut_a(slot == srv_sys->sys_threads);
last_print_time = ut_time();
loop:
if (srv_force_recovery >= SRV_FORCE_NO_BACKGROUND) {
goto suspend_thread;
}
while (srv_shutdown_state == SRV_SHUTDOWN_NONE) {
srv_master_sleep();
MONITOR_INC(MONITOR_MASTER_THREAD_SLEEP);
if (srv_check_activity(old_activity_count)) {
old_activity_count = srv_get_activity_count();
srv_master_do_active_tasks();
} else {
srv_master_do_idle_tasks();
}
}
while (srv_master_do_shutdown_tasks(&last_print_time)) {
/* Shouldn't loop here in case of very fast shutdown */
ut_ad(srv_fast_shutdown < 2);
}
suspend_thread:
srv_main_thread_op_info = "suspending";
srv_suspend_thread(slot);
/* DO NOT CHANGE THIS STRING. innobase_start_or_create_for_mysql()
waits for database activity to die down when converting < 4.1.x
databases, and relies on this string being exactly as it is. InnoDB
manual also mentions this string in several places. */
srv_main_thread_op_info = "waiting for server activity";
os_event_wait(slot->event);
if (srv_shutdown_state == SRV_SHUTDOWN_EXIT_THREADS) {
os_thread_exit(NULL);
}
goto loop;
OS_THREAD_DUMMY_RETURN; /* Not reached, avoid compiler warning */
}
