MySQL中Innodb page clean線程分析

這篇文章主要講解了“MySQL中Innodb page clean線程分析”，文中的講解內(nèi)容簡(jiǎn)單清晰，易于學(xué)習(xí)與理解，下面請(qǐng)大家跟著小編的思路慢慢深入，一起來研究和學(xué)習(xí)“MySQL中Innodb page clean線程分析”吧！

一、數(shù)據(jù)結(jié)構(gòu)和入口函數(shù)

1、數(shù)據(jù)結(jié)構(gòu)

• page_cleaner_t：整個(gè)Innodb只有一個(gè)，包含整個(gè)page clean線程相關(guān)信息。其中包含了一個(gè)page_cleaner_slot_t的指針。

• page_cleaner_slot_t：每個(gè)buffer instance都包含一個(gè)這樣的結(jié)構(gòu)體，page clean工作線程刷新的時(shí)候每個(gè)線程都會(huì)輪詢的檢測(cè)每個(gè)槽，知道找到?jīng)]有被其他page clean線程刷新的槽進(jìn)行刷新工作，直到每個(gè)槽（buffer instance ）都刷新完成。參考pc_flush_slot函數(shù)。

2、入口函數(shù)

• 協(xié)調(diào)工作線程入口：buf_flush_page_cleaner_coordinator

• 工作線程入口：buf_flush_page_cleaner_worker

二、主循環(huán)解析

其由函數(shù)buf_flush_page_cleaner_coordinator實(shí)現(xiàn)。實(shí)際正常運(yùn)行情況下的工作都包含在while (srv_shutdown_state == SRV_SHUTDOWN_NONE) 這個(gè)大循環(huán)下。

1、是否需要睡眠1秒判斷

首先如果沒有活躍的change buffer 并且沒有pending的物理塊，并且上次刷新的塊數(shù)量為0
則不需要睡眠1秒：

if (srv_check_activity(last_activity) 
            || buf_get_n_pending_read_ios()            || n_flushed == 0){
            ret_sleep = pc_sleep_if_needed(
                next_loop_time, sig_count);  //睡眠一秒            if (srv_shutdown_state != SRV_SHUTDOWN_NONE) {                break;
            }
        } else if (ut_time_ms() > next_loop_time) { //如果當(dāng)前時(shí)間大于 上次刷新 時(shí)間+1 秒則 設(shè)置為OS_SYNC_TIME_EXCEEDED
            ret_sleep = OS_SYNC_TIME_EXCEEDED; 
        } else {
            ret_sleep = 0;
        }

但是這個(gè)睡眠是可以被喚醒的，比如同步刷新應(yīng)該就會(huì)喚醒它（buf_flush_request_force函數(shù)）。參考函數(shù)os_event::wait_time_low

2、IO能力不足警告

如前文所描述這里產(chǎn)生如下警告：

page_cleaner: 1000ms  intended loop took **ms. The settings might not be optimal.((flushed="**" , during the time.)

源碼片段：

if (curr_time > next_loop_time + 3000) { //如果刷新時(shí)間 大于了 上次時(shí)間 +1 秒+3 秒 則報(bào)info
                if (warn_count == 0) {
                    ib::info() << "page_cleaner: 1000ms"
                        " intended loop took "
                        << 1000 + curr_time
                           - next_loop_time
                        << "ms. The settings might not"
                        " be optimal. (flushed="
                        << n_flushed_last
                        << ", during the time.)";                    if (warn_interval > 300) {
                        warn_interval = 600;
                    } else {
                        warn_interval *= 2;
                    }

3、同步刷新判斷

• 觸發(fā)條件

(ret_sleep != OS_SYNC_TIME_EXCEEDED
            && srv_flush_sync
            && buf_flush_sync_lsn > 0)

同步會(huì)喚醒正在睡眠狀態(tài)的page clean協(xié)調(diào)工作線程那么睡眠應(yīng)該不會(huì)滿足一秒的條件所以不會(huì)被標(biāo)記為OS_SYNC_TIME_EXCEEDED，同時(shí)srv_flush_sync和buf_flush_sync_lsn均會(huì)被設(shè)置接下來就是喚醒工作線程進(jìn)行刷新，同時(shí)本協(xié)調(diào)線程也完成部分任務(wù)。

• 工作代碼

     pc_request(ULINT_MAX, lsn_limit); //喚醒page clean 工作線程干活
            /* Coordinator also treats requests */ //協(xié)調(diào)者同樣要完成部分任務(wù)
            while (pc_flush_slot() > 0) {}

• 喚醒操作

如前文描述在checkpoint或者DML語句執(zhí)行過程中都會(huì)通過log_free_check檢查是否redo log處于安全的狀態(tài)，如果不安全就會(huì)調(diào)用如下代碼（log_preflush_pool_modified_pages函數(shù)中）喚醒page clean線程進(jìn)行同步刷新：

if (srv_flush_sync) {        /* wake page cleaner for IO burst */
        buf_flush_request_force(new_oldest); //設(shè)置全局變量同時(shí)通過broadcast喚醒同步刷新
    }
    buf_flush_wait_flushed(new_oldest); //所有線程等待同步刷新完成

4、活躍刷新

• 觸發(fā)條件

srv_check_activity(last_activity)

這里判斷是否有活躍的線程，所謂活躍就是調(diào)用srv_inc_activity_count函數(shù)進(jìn)行增加的，一般來講DML和DDL會(huì)標(biāo)記為活躍，purge線程及其工作線程工作期間會(huì)標(biāo)記為活躍?？梢詫帱c(diǎn)做到srv_inc_activity_count進(jìn)行debug。所以線上數(shù)據(jù)庫(kù)DML比較多所以一般都會(huì)是活躍刷新。

• 工作代碼

這里涉及到刷新多少個(gè)塊計(jì)算主要函數(shù)為 page_cleaner_flush_pages_recommendation，后面在討論。

n_to_flush = page_cleaner_flush_pages_recommendation(&lsn_limit, last_pages);//此處n_to_flush就是本次需要刷新的塊數(shù)的數(shù)量pc_request(n_to_flush, lsn_limit); //喚醒page clean 工作線程干活/* Coordinator also treats requests */ //工作協(xié)調(diào)線程同樣要完成部分任務(wù)
            while (pc_flush_slot() > 0) {}
pc_wait_finished(&n_flushed_list);//等待其他刷新完成

5、空閑刷新

• 觸發(fā)條件

else if (ret_sleep == OS_SYNC_TIME_EXCEEDED)

當(dāng)睡足了1秒，并且沒有活躍的線程。那么就進(jìn)行空閑刷新，一般來講如果沒有DML/DDL等語句那么應(yīng)該進(jìn)行是空閑刷新。

• 工作代碼

buf_flush_lists(PCT_IO(100), LSN_MAX, &n_flushed); //io能力 刷新到那個(gè)lsn 以及傳出刷新的塊數(shù)量//PCT_IO是一個(gè)宏如下：#define PCT_IO(p) ((ulong) (srv_io_capacity * ((double) (p) / 100.0)))

可以看到這里的百分比直接是100%及按照innodb_io_capacity參數(shù)的設(shè)定進(jìn)行刷新。

當(dāng)然這里只是看了正常期間工作的代碼，如果是Innodb shutdown也會(huì)觸發(fā)同步刷新。可自行參考代碼。

三、page_cleaner_flush_pages_recommendation函數(shù)

前面提過這個(gè)函數(shù)，是活躍刷新刷新塊的計(jì)算函數(shù)，下面直接給出整個(gè)代碼

{
    cur_lsn = log_get_lsn();//獲取當(dāng)前的lsn 在 redo buffer中的
    if (prev_lsn == 0) {       //靜態(tài)變量如果是0則代表是第一次執(zhí)行本函數(shù)
        /* First time around. */
        prev_lsn = cur_lsn;
        prev_time = ut_time(); //獲取當(dāng)前時(shí)間
        return(0);
    }    if (prev_lsn == cur_lsn) { //如果沒有redo日志生成
        return(0);
    }
    sum_pages += last_pages_in;    time_t  curr_time = ut_time();    double  time_elapsed = difftime(curr_time, prev_time);
        avg_page_rate = static_cast<ulint>(
            ((static_cast<double>(sum_pages)
              / time_elapsed)
             + avg_page_rate) / 2); //算出上次刷新每秒刷新的pages數(shù)量，同時(shí)加上次計(jì)算的每秒平均刷新塊數(shù) 然后除以2 得到一個(gè)每秒刷新的pages數(shù)量 ！?。〉谝粋€(gè)計(jì)算條件avg_page_rate 生成
        /* How much LSN we have generated since last call. */
        lsn_rate = static_cast<lsn_t>(            static_cast<double>(cur_lsn - prev_lsn)
            / time_elapsed);//計(jì)算redo lsn生成率
        lsn_avg_rate = (lsn_avg_rate + lsn_rate) / 2;//計(jì)算redo每秒平均生成率
        /* aggregate stats of all slots */
        mutex_enter(&page_cleaner->mutex);
        ulint   flush_tm = page_cleaner->flush_time;
        ulint   flush_pass = page_cleaner->flush_pass;
        page_cleaner->flush_time = 0;
        page_cleaner->flush_pass = 0;
        ulint   list_tm = 0;
        ulint   list_pass = 0;        for (ulint i = 0; i < page_cleaner->n_slots; i++) {//掃描所有的槽
            page_cleaner_slot_t*    slot;
            slot = &page_cleaner->slots[i];
            list_tm   += slot->flush_list_time;
            list_pass += slot->flush_list_pass;
            slot->flush_list_time = 0;
            slot->flush_list_pass = 0;
        }
        mutex_exit(&page_cleaner->mutex);
    oldest_lsn = buf_pool_get_oldest_modification(); //獲取flush list中最老的ls
    ut_ad(oldest_lsn <= log_get_lsn());//斷言
    age = cur_lsn > oldest_lsn ? cur_lsn - oldest_lsn : 0; //獲取當(dāng)前LSN和最老LSN的之間的差值
    pct_for_dirty = af_get_pct_for_dirty(); //計(jì)算出一個(gè)刷新百分比 (比如100) !!!!重點(diǎn)
    pct_for_lsn = af_get_pct_for_lsn(age);//計(jì)算出lsn的比率 百分比(l列如4.5) 
    pct_total = ut_max(pct_for_dirty, pct_for_lsn);//取他們的大值
    
    /* Estimate pages to be flushed for the lsn progress *///計(jì)算target_lsn
    ulint   sum_pages_for_lsn = 0;    lsn_t   target_lsn = oldest_lsn
                 + lsn_avg_rate * buf_flush_lsn_scan_factor; //計(jì)算下一次刷新的  目標(biāo)lsn 及target_lsnbuf_flush_lsn_scan_factor是定值3
    for (ulint i = 0; i < srv_buf_pool_instances; i++) {//循環(huán)整個(gè)buffer instance找到小于target_lsn的臟塊
        buf_pool_t* buf_pool = buf_pool_from_array(i);
        ulint       pages_for_lsn = 0;
        buf_flush_list_mutex_enter(buf_pool);        for (buf_page_t* b = UT_LIST_GET_LAST(buf_pool->flush_list);//每個(gè)innodb buffer的末尾的flush list 進(jìn)行掃描，頭插法?
             b != NULL;
             b = UT_LIST_GET_PREV(list, b)) {            if (b->oldest_modification > target_lsn) {                break;
            }
            ++pages_for_lsn; //某個(gè) innodb buffer 實(shí)例中 flush list 小于這個(gè)  target lsn 的 page計(jì)數(shù)
        }
        buf_flush_list_mutex_exit(buf_pool);
        sum_pages_for_lsn += pages_for_lsn; //這里匯總所有 innodb buffer實(shí)例中  flush list 小于這個(gè)  target lsn 的 page 總數(shù)
        mutex_enter(&page_cleaner->mutex);
        ut_ad(page_cleaner->slots[i].state
              == PAGE_CLEANER_STATE_NONE);//斷言所有的槽處于沒有刷新狀態(tài)
        page_cleaner->slots[i].n_pages_requested
            = pages_for_lsn / buf_flush_lsn_scan_factor + 1; //確認(rèn)槽的n_pages_requested值
        mutex_exit(&page_cleaner->mutex);
    }
    sum_pages_for_lsn /= buf_flush_lsn_scan_factor;//buf_flush_lsn_scan_factor為定值3
    /* Cap the maximum IO capacity that we are going to use by
    max_io_capacity. Limit the value to avoid too quick increase */
    n_pages = PCT_IO(pct_total); //根據(jù) 前面得到的 pct_total 和 srv_io_capacity參數(shù)得到 刷新的塊數(shù) !!!第二個(gè)計(jì)算參數(shù)生成。
    if (age < log_get_max_modified_age_async()) { //如果日質(zhì)量小于 異步刷新的范疇
        ulint   pages_for_lsn =            std::min<ulint>(sum_pages_for_lsn,
                    srv_max_io_capacity * 2); //即便是需要刷新的塊數(shù)很多，最多只能刷max_io_capacity*2的數(shù)量!!!第三個(gè)計(jì)算參數(shù)生成
        n_pages = (n_pages + avg_page_rate + pages_for_lsn) / 3;  // 3部分組成 1、根據(jù)參數(shù)計(jì)算出來的IO能力 2、以往每秒刷新頁的數(shù)量 3、根據(jù)target lsn 計(jì)算出來的一個(gè)需要刷新的塊數(shù)
    }    if (n_pages > srv_max_io_capacity) {
        n_pages = srv_max_io_capacity;
    }    return(n_pages);
}

此函數(shù)最后計(jì)算出了需要刷新的塊，其中刷新比率計(jì)算的的重點(diǎn)函數(shù)為af_get_pct_for_dirty和af_get_pct_for_lsn 下面將給出代碼注釋，其實(shí)前文中的算法就來自af_get_pct_for_dirty。

四、af_get_pct_for_dirty和af_get_pct_for_lsn函數(shù)

• af_get_pct_for_dirty函數(shù)

    double  dirty_pct = buf_get_modified_ratio_pct(); //得到 修改的塊/總的塊的 的百分比 記住臟數(shù)據(jù)比率
    if (dirty_pct == 0.0) {        /* No pages modified */
        return(0);
    }
    ut_a(srv_max_dirty_pages_pct_lwm
         <= srv_max_buf_pool_modified_pct);    if (srv_max_dirty_pages_pct_lwm == 0) {  //如果innodb_max_dirty_pages_pct_lwm沒有設(shè)置
        /* The user has not set the option to preflush dirty
        pages as we approach the high water mark. */
        if (dirty_pct >= srv_max_buf_pool_modified_pct) { //如果臟數(shù)據(jù)比率大于了innodb_max_dirty_pages_pct則返回比率100%
            /* We have crossed the high water mark of dirty
            pages In this case we start flushing at 100% of
            innodb_io_capacity. */
            return(100);
        }
    } else if (dirty_pct >= srv_max_dirty_pages_pct_lwm) { //如果設(shè)置了innodb_max_dirty_pages_pct_lwm 并且臟數(shù)據(jù)比率大于了
        /* We should start flushing pages gradually. */    //innodb_max_dirty_pages_pct_lwm參數(shù)設(shè)置
        return(static_cast<ulint>((dirty_pct * 100)
               / (srv_max_buf_pool_modified_pct + 1)));  //則返回  (臟數(shù)據(jù)比率/(innodb_max_dirty_pages_pct+1))*100 也是一個(gè)比率  如(45/76)*100
    }    return(0);//否則返回0

• af_get_pct_for_lsn函數(shù)：

注意innodb_cleaner_lsn_age_factor參數(shù)默認(rèn)設(shè)置為high_checkpoint，可以看到算法最后是除以700.5，所有前文我說這個(gè)函數(shù)算出來的比率一般比較小。

    lsn_t   af_lwm = (srv_adaptive_flushing_lwm
              * log_get_capacity()) / 100;// srv_adaptive_flushing_lwm=10 那么大約就是 logtotalsize*(9/10)*(1/10) 943349 計(jì)算一個(gè)low water mark
    if (age < af_lwm) {              //如果當(dāng)前生成的redo 小于了 low water master 則返回0 也就是說 redo日志量生成量不高則不需要權(quán)衡
        /* No adaptive flushing. */  //可以看出這里和redo設(shè)置的大小有關(guān)，如果redo文件設(shè)置越大則af_lwm越大，觸發(fā)權(quán)衡的機(jī)率越小
        return(0);
    }
    max_async_age = log_get_max_modified_age_async(); //獲取需要異步刷新的的位置 大約為logtotalsize*(9/10)*(7/8)
    if (age < max_async_age && !srv_adaptive_flushing) { //如果小于異步刷新 且 自適應(yīng)flush 沒有開啟
        /* We have still not reached the max_async point and
        the user has disabled adaptive flushing. */
        return(0);
    }    /* If we are here then we know that either:
    1) User has enabled adaptive flushing
    2) User may have disabled adaptive flushing but we have reached
    max_async_age. */
    lsn_age_factor = (age * 100) / max_async_age; //比率lsn_age_factor = (本次刷新的日志量/(logtotalsize*(9/10)*(7/8)))
    ut_ad(srv_max_io_capacity >= srv_io_capacity); 
    switch ((srv_cleaner_lsn_age_factor_t)srv_cleaner_lsn_age_factor) {    case SRV_CLEANER_LSN_AGE_FACTOR_LEGACY:        return(static_cast<ulint>(
                   ((srv_max_io_capacity / srv_io_capacity)
                * (lsn_age_factor
                   * sqrt((double)lsn_age_factor)))
                   / 7.5));                                 //430
    case SRV_CLEANER_LSN_AGE_FACTOR_HIGH_CHECKPOINT: //innodb_cleaner_lsn_age_factor參數(shù)默認(rèn)設(shè)置為high_checkpoint
        return(static_cast<ulint>(                              
                   ((srv_max_io_capacity / srv_io_capacity)            //  ((max_io_cap /io_cap) * (sqrt(lsn_age_factor)*lsn_age_factor*lsn_age_factor))/700.5
                * (lsn_age_factor * lsn_age_factor                     //(10 * (3.3*10*10))/700 =4.3
                   * sqrt((double)lsn_age_factor)))
                   / 700.5));  //

感謝各位的閱讀，以上就是“MySQL中Innodb page clean線程分析”的內(nèi)容了，經(jīng)過本文的學(xué)習(xí)后，相信大家對(duì)MySQL中Innodb page clean線程分析這一問題有了更深刻的體會(huì)，具體使用情況還需要大家實(shí)踐驗(yàn)證。這里是億速云，小編將為大家推送更多相關(guān)知識(shí)點(diǎn)的文章，歡迎關(guān)注！