【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；