【MySQL】SHOW ENGINE INNODB STATUS \G之Pages flushed up to的理解

1)前言以及問題：
我們現在先看截圖


Log sequence number --內存中日志產生的序列號
Log flushed up to --刷入redo日志的值，字節數
Pages flushed up to --這里正是我要講的問題，后面詳述
Last checkpoint at --最后一次檢查點的位置

這里Pages flushed up to到底是什么？而且數據庫沒有寫數據的情況下，總是Pages flushed up to 不等于 Last checkpoint at，這又是為何，并且Pages flushed up to - Last checkpoint at=9(這里你們可以仔細去觀察)？
查過網上資料，也問過一些大佬，答案真的是五花八門
他們中有兩種最主要的答案，一種是顧名思義，臟頁刷新到的LSN；另外一種是：new_modification LSN


2）分析：
對于第一種，說臟頁刷新到磁盤的lsn的，明顯就不成立。其實檢查點的意思就是LSN之前的數據已經落盤，這里檢查點的數據落盤就包含了臟頁的落盤；實際測試過程中Pages flushed up to 明顯大于檢查點的LSN，而且檢查點之后，就不能保證所有數據是落盤的，那么如果說Pages flushed up to 是臟頁刷新到磁盤的lsn，那么就會出現一種情況，lsn1=3000臟頁刷盤了（pages flushed up to是3000），lsn=2800的臟頁沒刷盤，那么你認為這個值有意義嗎？


對于第二種：說是flush list做檢查點的頁的new modification lsn（即一個內存page包含兩個lsn，flush list是按照頁的第一次修改的lsn排序的，只要一個頁修改就加入flush list，而new modification lsn是寫了多少字節數據，new modification lsn 就加多少）；為什么數據庫最后沒做修改了，Pages flushed up to 不等于 Last checkpoint at？他們給出的答復是一個頁被多次修改。

為了更清楚，我把這些數據結構貼出來：

每個buffer pool都包含flush list
struct buf_pool_t{
    ...
    UT_LIST_BASE_NODE_T(buf_page_t) flush_list;
    UT_LIST_BASE_NODE_T(buf_page_t) free;
    ...
}

class buf_page_t {
public:
        ...
        //這個值是只要做了修改，lsn就會增加，如果一個頁在內存中沒有修改，就一直是0，也不會加入flush list
        lsn_t           newest_modification;
                                        /*!< log sequence number of
                                        the youngest modification to
                                        this block, zero if not
                                        modified. Protected by block
                                        mutex */
        //這個值，只要當前頁被刷入了磁盤，他的值就會置為0，第一次對頁的修改，就會加入flush list，第二次對該頁修改，此值不會增加，因為flush list 是推進檢查點的。
        lsn_t           oldest_modification;
                                        /*!< log sequence number of
                                        the START of the log entry
                                        written of the oldest
                                        modification to this block
                                        which has not yet been flushed
                                        on disk; zero if all
                                        modifications are on disk.
                                        Writes to this field must be
                                        covered by both block->mutex
                                        and buf_pool->flush_list_mutex. Hence
                                        reads can happen while holding
                                        any one of the two mutexes */
        ...
}

按照這種說法，我先繪制一個圖：
    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">

圖中flush list中，page no為3并且oldest modification lsn =400的時候，做了checkpoint了，那么按照第二種說法（Pages flushed up to的值為new modification lsn），則此時的Pages flushed lsn to的值為800；但圖中page no為4的頁的new modification lsn還沒有刷盤；這樣的話，其實Pages flushed up to這值就沒有什么意義了。


3）要想了解真相，我們就得從源碼探究

    ①首先找到源碼中show engine innodb status \G  pages flushed up to的位置，我們發現，他調用了log_buf_pool_get_oldest_modification；從字面意思來說貌似是取buffer pool頁的oldest modification lsn，究竟是哪些頁呢，還需要探究。
   log_print(
/*======*/
        FILE*   file)   /*!< in: file where to print */
{
        double  time_elapsed;
        time_t  current_time;

        log_mutex_enter();

        fprintf(file,
                "Log sequence number " LSN_PF "\n"
                "Log flushed up to   " LSN_PF "\n"
                "Pages flushed up to " LSN_PF "\n"
                "Last checkpoint at  " LSN_PF "\n",
                log_sys->lsn,
                log_sys->flushed_to_disk_lsn,
                log_buf_pool_get_oldest_modification(),
                log_sys->last_checkpoint_lsn);

                ...
}

    ②查看log_buf_pool_get_oldest_modification源代碼

static lsn_t
log_buf_pool_get_oldest_modification(void)
/*======================================*/
{
        lsn_t   lsn;

        ut_ad(log_mutex_own());

        lsn = buf_pool_get_oldest_modification();
        //這里如果buf_pool_get_oldest_modification返回LSN為0（這里的言下之意是oldest lsn為0，即數據都刷入了磁盤），則取log_sys->lsn
        if (!lsn) {

                lsn = log_sys->lsn;
        }

        return(lsn);
}
   從這個函數我們可以看出，如果這時候buffer pool中數據臟頁都刷入了磁盤（同時這時候頁沒數據寫入），那么取的就是最大的LSN（log_sys->lsn）,也即：show engineinnodb status顯示的Log sequence number。


    ③但是這里我們任然不知道oldest modification lsn是怎么取的，這就需要查看buf_pool_get_oldest_modification的源代碼：
    buf_pool_get_oldest_modification(void)
/*==================================*/
{
        lsn_t           lsn = 0;
        lsn_t           oldest_lsn = 0;

        /* When we traverse all the flush lists we don't want another
        thread to add a dirty page to any flush list. */
        log_flush_order_mutex_enter();

        //遍歷所有的buffer pool
        for (ulint i = 0; i < srv_buf_pool_instances; i++) {
                buf_pool_t*     buf_pool;

                buf_pool = buf_pool_from_array(i);

                buf_flush_list_mutex_enter(buf_pool);

                buf_page_t*     bpage;

                /* We don't let log-checkpoint halt because pages from system
                temporary are not yet flushed to the disk. Anyway, object
                residing in system temporary doesn't generate REDO logging. */

                //從這里我們可以看出bpage是取flush list中最大的oldest modifcation LSN(注意這里的邏輯，如果是系統臨時表空間，就不應該算在內)
                for (bpage = UT_LIST_GET_LAST(buf_pool->flush_list);
                     bpage != NULL
                        && fsp_is_system_temporary(bpage->id.space());
                     bpage = UT_LIST_GET_PREV(list, bpage)) {
                        /* Do nothing. */
                }

                if (bpage != NULL) {
                        ut_ad(bpage->in_flush_list);
                        lsn = bpage->oldest_modification;
                }

                buf_flush_list_mutex_exit(buf_pool);
                //上面是從buffer pool中的flush list取最大oldest modication lsn的page，而這里是從每個buffer pool 的最大oldest modification lsn中取最小的oldest modification lsn 的page。
                if (!oldest_lsn || oldest_lsn > lsn) {
                        oldest_lsn = lsn;
                }
        }

        log_flush_order_mutex_exit();

        /* The returned answer may be out of date: the flush_list can
        change after the mutex has been released. */

        return(oldest_lsn);
}
 
④到這里，我們整個流程就明朗了，pages flushed up to 取的是所有buffer pool中最大oldest modification lsn頁中的帶有最小的 oldest modification lsn的值，如果去到的oldest modification lsn為0，意味著沒有臟頁，那么我們就取log_sys->lsn的值，即show engineinnodb status顯示的Log sequence number。
舉個例子：我們的buffer pool 設置為4個；第一個buffer pool，我們取flush list 中頁帶oldest modification lsn最大值為100
第二個buffer pool，我們取flush list 中頁帶oldest modification lsn最大值為140；第三個buffer pool，我們取flush list 中頁帶oldest modification lsn最大值為98；第四個buffer pool，我們取flush list 中頁帶oldest modification lsn最大值為130；那么我們得到的pages flushed up to 就是98；


⑤我們知道了這個Pages flushed up to從哪里取的值，但是現在我并不知道這個值的含義啊

我們來看一個函數
/** Make a checkpoint. Note that this function does not flush dirty
blocks from the buffer pool: it only checks what is lsn of the oldest
modification in the pool, and writes information about the lsn in
log files. Use log_make_checkpoint_at() to flush also the pool.
**/
//從這個函數的注釋我們可以明顯知道，這個函數是用來做檢查點的
log_checkpoint(
        bool    sync,
        bool    write_always)
{
        lsn_t   oldest_lsn;

        ut_ad(!srv_read_only_mode);

        if (recv_recovery_is_on()) {
                recv_apply_hashed_log_recs(TRUE);
        }

#ifndef _WIN32
        switch (srv_unix_file_flush_method) {
        case SRV_UNIX_NOSYNC:
                break;
        case SRV_UNIX_O_DSYNC:
        case SRV_UNIX_FSYNC:
        case SRV_UNIX_LITTLESYNC:
        case SRV_UNIX_O_DIRECT:
        case SRV_UNIX_O_DIRECT_NO_FSYNC:
                fil_flush_file_spaces(FIL_TYPE_TABLESPACE);
        }
#endif /* !_WIN32 */

        log_mutex_enter();

        ut_ad(!recv_no_log_write);
        //取得oldest LSN
        oldest_lsn = log_buf_pool_get_oldest_modification();

        /* Because log also contains headers and dummy log records,
        log_buf_pool_get_oldest_modification() will return log_sys->lsn
        if the buffer pool contains no dirty buffers.
        We must make sure that the log is flushed up to that lsn.
        If there are dirty buffers in the buffer pool, then our
        write-ahead-logging algorithm ensures that the log has been
        flushed up to oldest_lsn. */

       //從這里我們可以知道為什么last checkpoint lsn跟pages flushed up to不相等了，因為在mysql做檢查點的時候，還要打上MLOG_CHECKPOINT redo 日志，而這個MLOG_CHECKPOINT恰好占用9個字節，所以就有了在臟頁都刷盤之后，pages flushed up to-last checkpoint lsn=9
        ut_ad(oldest_lsn >= log_sys->last_checkpoint_lsn);
        if (!write_always
            && oldest_lsn
            <= log_sys->last_checkpoint_lsn + SIZE_OF_MLOG_CHECKPOINT) {
                /* Do nothing, because nothing was logged (other than
                a MLOG_CHECKPOINT marker) since the previous checkpoint. */
                log_mutex_exit();
                return(true);
        }


        lsn_t           flush_lsn       = oldest_lsn;
        const bool      do_write
                = srv_shutdown_state == SRV_SHUTDOWN_NONE
                || flush_lsn != log_sys->lsn;

        if (fil_names_clear(flush_lsn, do_write)) {
                ut_ad(log_sys->lsn >= flush_lsn + SIZE_OF_MLOG_CHECKPOINT);
                flush_lsn = log_sys->lsn;
        }

        log_mutex_exit();

        log_write_up_to(flush_lsn, true);

        DBUG_EXECUTE_IF(
                "using_wa_checkpoint_middle",
                if (write_always) {
                        DEBUG_SYNC_C("wa_checkpoint_middle");

                        const my_bool b = TRUE;
                        buf_flush_page_cleaner_disabled_debug_update(
                                NULL, NULL, NULL, &b);
                        dict_stats_disabled_debug_update(
                                NULL, NULL, NULL, &b);
                        srv_master_thread_disabled_debug_update(
                                NULL, NULL, NULL, &b);
                });

        log_mutex_enter();

        ut_ad(log_sys->flushed_to_disk_lsn >= flush_lsn);
        ut_ad(flush_lsn >= oldest_lsn);
        //檢查點大于等于oldest_lsn說明已經刷盤
        if (log_sys->last_checkpoint_lsn >= oldest_lsn) {
                log_mutex_exit();
                return(true);
        }

        if (log_sys->n_pending_checkpoint_writes > 0) {
                /* A checkpoint write is running */
                log_mutex_exit();

                if (sync) {
                        /* Wait for the checkpoint write to complete */
                        rw_lock_s_lock(&log_sys->checkpoint_lock);
                        rw_lock_s_unlock(&log_sys->checkpoint_lock);
                }

                return(false);
        }
       //下一次LSN的位置
        log_sys->next_checkpoint_lsn = oldest_lsn;
        log_write_checkpoint_info(sync);
        ut_ad(!log_mutex_own());

        return(true);
}


4）總結：

pages flushed up to指的是下一次即將做checkpoint lsn 的位置；在沒有新數據的寫入的情況下，
pages flushed up to取的是Log sequence number（log_sys->lsn）；在沒數據寫入的情況下，為什么last checkpoint point不等于pages flushed up to？是因為做checkpoint是同時redo日志會寫MLOG_CHECKPOINT，而MLOG_CHECKPOINT占用九個字節，所以會出現pages flushed up to-last checkpoint point=9；