IT评测·应用市场-qidao123.com

标题: 海山数据库(He3DB)源码详解：海山MySQL redo日志-写入过程 [打印本页]

---

作者: 李优秀    时间: 2024-12-23 05:34
标题: 海山数据库(He3DB)源码详解：海山MySQL redo日志-写入过程
# 一、redo log block
设计InnoDB时为了更好的举行系统奔溃恢复，将通过mtr生成的redo日志放在巨细为512字节的页中。为了和表空间中的页做区别，于是把用来存储redo日志的页称为block。一个redo log block的表示图如下：

真正的redo日志都是存储到占用496字节巨细的log block body中。另外，log block header占12个字节，log block trailer占4个字节，存储的是一些管理信息。
此中，log block header中包含以下属性字段：

• LOG_BLOCK_HDR_NO(4B)：每一个block都有一个大于0的唯一标号，该属性就表示该标号值。
  
• LOG_BLOCK_HDR_DATA_LEN(2B)：表示block中已经使用了多少字节，初始值为12。随着往block中写入的redo日志越来也多，该值也跟着增长。假如log block body已经被全部写满，那么值被设置为512。
  
• LOG_BLOCK_FIRST_REC_GROUP(2B)：一条redo日志也可以称之为一条redo日志记录，一个mtr会生产多条redo日志记录，这些redo日志记录被称之为一个redo日志记录组（redo log record group）。LOG_BLOCK_FIRST_REC_GROUP就代表该block中第一个mtr生成的redo日志记录组的偏移量，即这个block里第一个mtr生成的第一条redo日志的偏移量。
  
• LOG_BLOCK_CHECKPOINT_NO(4B)：表示checkpoint的序号。
  

log block trailer中包含的属性字段为：

• LOG_BLOCK_CHECKSUM(4B)：表示block的校验值，用于正确性校验。
  

二、redo日志缓冲区

与为相识决磁盘速度过慢的问题而引入了Buffer Pool的头脑类似，写入redo日志时也不能直接直接写到磁盘上。实际上在服务器启动时就向操纵系统申请了一大⽚称之为redo log buffer的一连内存空间，即redo日志缓冲区，也可以简称为log buffer。这⽚内存空间被分别成多少个一连的redo log block，如图所示：

三、redo日志写入log buffer

向log buffer中写入redo日志的过程是顺序的，也就是先往前边的block中写，当该block的空闲空间用完之后再往下一个block中写。因此，当往log buffer中写入redo日志时，第一个遇到的问题就是应该写在哪个block的哪个偏移量处，所以InnoDB的特意提供了一个称之为buf_free的全局变量，该变量指明后续写入的redo日志应该写入到log buffer中的哪个位置。

由于一个mtr实行过程中可能产生多少条redo日志，这些redo日志是一个不可分割的组，所以其实并不是每生成一条redo日志，就将其插入到log buffer中，而是每个mtr运行过程中产生的日志先暂时存到一个地方，当该mtr竣事的时间，将过程中产生的一组redo日志再全部复制到log buffer中。
四、源码剖析

4.1 log buffer布局体

1. /** Redo log buffer */
2. struct log_t{
3.         char                pad1[CACHE_LINE_SIZE];
4.                                         /*!< Padding to prevent other memory
5.                                         update hotspots from residing on the
6.                                         same memory cache line */
7.         lsn_t                lsn;                /*!< log sequence number */
8.         ulint                buf_free;        /*!< first free offset within the log
9.                                         buffer in use */
10.         byte*                buf_ptr;        /*!< unaligned log buffer, which should
11.                                         be of double of buf_size */
12.         byte*                buf;                /*!< log buffer currently in use;
13.                                         this could point to either the first
14.                                         half of the aligned(buf_ptr) or the
15.                                         second half in turns, so that log
16.                                         write/flush to disk don't block
17.                                         concurrent mtrs which will write
18.                                         log to this buffer */
19.         bool                first_in_use;        /*!< true if buf points to the first
20.                                         half of the aligned(buf_ptr), false
21.                                         if the second half */
22.         ulint                buf_size;        /*!< log buffer size of each in bytes */
23.         ulint                max_buf_free;        /*!< recommended maximum value of
24.                                         buf_free for the buffer in use, after
25.                                         which the buffer is flushed */
26.         bool                check_flush_or_checkpoint;
27.                                         /*!< this is set when there may
28.                                         be need to flush the log buffer, or
29.                                         preflush buffer pool pages, or make
30.                                         a checkpoint; this MUST be TRUE when
31.                                         lsn - last_checkpoint_lsn >
32.                                         max_checkpoint_age; this flag is
33.                                         peeked at by log_free_check(), which
34.                                         does not reserve the log mutex */
35.         UT_LIST_BASE_NODE_T(log_group_t)
36.                         log_groups;        /*!< log groups */
38. #ifndef UNIV_HOTBACKUP
39.         /** The fields involved in the log buffer flush @{ */
41.         ulint                buf_next_to_write;/*!< first offset in the log buffer
42.                                         where the byte content may not exist
43.                                         written to file, e.g., the start
44.                                         offset of a log record catenated
45.                                         later; this is advanced when a flush
46.                                         operation is completed to all the log
47.                                         groups */
48.         volatile bool        is_extending;        /*!< this is set to true during extend
49.                                         the log buffer size */
50.         lsn_t                write_lsn;        /*!< last written lsn */
51.         lsn_t                current_flush_lsn;/*!< end lsn for the current running
52.                                         write + flush operation */
53.         lsn_t                flushed_to_disk_lsn;
54.                                         /*!< how far we have written the log
55.                                         AND flushed to disk */
56.         ulint                n_pending_flushes;/*!< number of currently
57.                                         pending flushes; incrementing is
58.                                         protected by the log mutex;
59.                                         may be decremented between
60.                                         resetting and setting flush_event */
61.         os_event_t        flush_event;        /*!< this event is in the reset state
62.                                         when a flush is running; a thread
63.                                         should wait for this without
64.                                         owning the log mutex, but NOTE that
65.                                         to set this event, the
66.                                         thread MUST own the log mutex! */
67.         ulint                n_log_ios;        /*!< number of log i/os initiated thus
68.                                         far */
69.         ulint                n_log_ios_old;        /*!< number of log i/o's at the
70.                                         previous printout */
71.         time_t                last_printout_time;/*!< when log_print was last time
72.                                         called */
73.         /* @} */
75.         /** Fields involved in checkpoints @{ */
76.         lsn_t                log_group_capacity; /*!< capacity of the log group; if
77.                                         the checkpoint age exceeds this, it is
78.                                         a serious error because it is possible
79.                                         we will then overwrite log and spoil
80.                                         crash recovery */
81.         lsn_t                max_modified_age_async;
82.                                         /*!< when this recommended
83.                                         value for lsn -
84.                                         buf_pool_get_oldest_modification()
85.                                         is exceeded, we start an
86.                                         asynchronous preflush of pool pages */
87.         lsn_t                max_modified_age_sync;
88.                                         /*!< when this recommended
89.                                         value for lsn -
90.                                         buf_pool_get_oldest_modification()
91.                                         is exceeded, we start a
92.                                         synchronous preflush of pool pages */
93.         lsn_t                max_checkpoint_age_async;
94.                                         /*!< when this checkpoint age
95.                                         is exceeded we start an
96.                                         asynchronous writing of a new
97.                                         checkpoint */
98.         lsn_t                max_checkpoint_age;
99.                                         /*!< this is the maximum allowed value
100.                                         for lsn - last_checkpoint_lsn when a
101.                                         new query step is started */
102.         ib_uint64_t        next_checkpoint_no;
103.                                         /*!< next checkpoint number */
104.         lsn_t                last_checkpoint_lsn;
105.                                         /*!< latest checkpoint lsn */
106.         lsn_t                next_checkpoint_lsn;
107.                                         /*!< next checkpoint lsn */
108.         mtr_buf_t*        append_on_checkpoint;
109.                                         /*!< extra redo log records to write
110.                                         during a checkpoint, or NULL if none.
111.                                         The pointer is protected by
112.                                         log_sys->mutex, and the data must
113.                                         remain constant as long as this
114.                                         pointer is not NULL. */
115.         ulint                n_pending_checkpoint_writes;
116.                                         /*!< number of currently pending
117.                                         checkpoint writes */
118.         rw_lock_t        checkpoint_lock;/*!< this latch is x-locked when a
119.                                         checkpoint write is running; a thread
120.                                         should wait for this without owning
121.                                         the log mutex */
122. #endif /* !UNIV_HOTBACKUP */
123.         byte*                checkpoint_buf_ptr;/* unaligned checkpoint header */
124.         byte*                checkpoint_buf;        /*!< checkpoint header is read to this
125.                                         buffer */
126.         /* @} */
127. };

复制代码

此中，比力重要的几个字段如下：

• lsn_t lsn : 日志序列号
  
• ulint buf_free : 日志缓冲区中可以使用的第一个空闲偏移量
  
• byte* buf_ptr : 未对齐的日志缓冲区指针
  
• byte* buf : 当前正在使用的日志缓冲区
  
• bool first_in_use : true : buf指针指向前半个buf
  false: buf指针指向后半个buf
  
• ulint buf_next_to_write : 尚未写入文件的日志在缓冲区中的起始偏移量
  
• lsn_t write_lsn : 被写入操纵系统缓冲区但未刷新到磁盘的起始日志的lsn
  
• lsn_t flushed_to_disk_lsn : 被刷新到磁盘的日志lsn
  

4.2 redo日志写入log buffer的过程

4.2.1、团体流程

4.2.2、源码剖析

• 1、由于redo日志写入log buffer中要先举行事务的提交，因此起首会调用mtr_t::commit()函数。
  

1. /** Commit a mini-transaction. */
2. void
3. mtr_t::commit()
4. {
5.    ut_ad(is_active());
6.    ut_ad(!is_inside_ibuf());
7.    ut_ad(m_impl.m_magic_n == MTR_MAGIC_N);
8.    m_impl.m_state = MTR_STATE_COMMITTING;
10.    /* This is a dirty read, for debugging. */
11.    ut_ad(!recv_no_log_write);
13.    Command        cmd(this);
15.    if (m_impl.m_modifications
16.        && (m_impl.m_n_log_recs > 0
17.            || m_impl.m_log_mode == MTR_LOG_NO_REDO)) {
19.            ut_ad(!srv_read_only_mode
20.                  || m_impl.m_log_mode == MTR_LOG_NO_REDO);
22.            cmd.execute();
23.    } else {
24.            cmd.release_all();
25.            cmd.release_resources();
26.    }
27. }

复制代码

（1）断言检查

1.         ut_ad(is_active());  // 确保当前事务是活跃的
2.         ut_ad(!is_inside_ibuf());  // 确保事务不在插入缓冲区内部执行
3.         ut_ad(m_impl.m_magic_n == MTR_MAGIC_N);  // 验证事务内部结构的完整性
4.         m_impl.m_state = MTR_STATE_COMMITTING;   // 将事务状态设置为正在提交
6.         ut_ad(!recv_no_log_write);  // 确保没有设置禁止日志写入的标志

复制代码

（2）创建命令对象

1.         Command        cmd(this);       

复制代码

（3）根据条件实行或开释资源

1.         if (m_impl.m_modifications
2.             && (m_impl.m_n_log_recs > 0
3.                 || m_impl.m_log_mode == MTR_LOG_NO_REDO)) {
5.                 ut_ad(!srv_read_only_mode
6.                       || m_impl.m_log_mode == MTR_LOG_NO_REDO);
8.                 cmd.execute();
9.         } else {
10.                 cmd.release_all();
11.                 cmd.release_resources();
12.         }

复制代码

  

• 判断条件：事务有修改且要么有日志记录，要么设置为不重做日志模式；
  
• 确保不在只读模式下，大概日志模式是不重做；
  
• 调用写入redo日志记录的函数execute()；
  
• 假如没有修改或不需要持久化日志记录，则开释全部锁和资源。
  

  

• 2、在mtr_t::commit中调用execute()函数实行一系列与事务相干的操纵，包罗写入重做日志记录、将脏页添加到刷新列表，并开释相干资源。
  

1. /** Write the redo log record, add dirty pages to the flush list and release
2. the resources. */
3. void mtr_t::Command::execute() {
4.   ut_ad(m_impl->m_log_mode != MTR_LOG_NONE);
6.   if (const ulint len = prepare_write()) {
7.     finish_write(len);
8.   }
10.   if (m_impl->m_made_dirty) {
11.     log_flush_order_mutex_enter();
12.   }
14.   /* It is now safe to release the log mutex because the
15.   flush_order mutex will ensure that we are the first one
16.   to insert into the flush list. */
17.   log_mutex_exit();
19.   m_impl->m_mtr->m_commit_lsn = m_end_lsn;
21.   release_blocks();
24.   if (m_impl->m_made_dirty) {
25.     log_flush_order_mutex_exit();
26.   }
28.   release_all();
30.   release_resources();
31. }

复制代码

（1）检查前置条件

1. ut_ad(m_impl->m_log_mode != MTR_LOG_NONE);

复制代码

  

• 使用ut_ad调试宏，用于在开发过程中捕捉逻辑错误。
  
• 这里用于检查日志模式是否是MTR_LOG_NONE，确保在尝试写入日志之前，日志模式是有效的。
  （2）准备写入日志
  

1. if (const ulint len = prepare_write()) {
2.     finish_write(len);
3.   }

复制代码

  

• 起首调用prepare_write函数准备写入日志，并获取要写入的日志长度。
  
• 假如返回长度不为0，则表示有日志需要写入，调用finish_write函数完成日志的写入。
  

  （3）处置惩罚脏页

1. if (m_impl->m_made_dirty) {
2.     log_flush_order_mutex_enter();
3.   }

复制代码

  

• 假如事务过程中产生了脏页，则需要进入log_flush_order_mutex互斥锁。
  
• 这个锁用于确保在将脏页添加到刷新列表时，没有其他线程同时修改这个列表。
  

  （4）开释日志互斥锁

1. release_blocks();

复制代码

  

• 在确保脏页将被安全处置惩罚后，可以开释log_mutex。
  

  （5）更新提交日志序列号

1. m_impl->m_mtr->m_commit_lsn = m_end_lsn;

复制代码

  

• 更新事务的提交日志序列号（LSN）为当前操纵的竣事LSN。
  

  （6）开释资源并退出锁

1.   release_blocks();
2.   // 开释数据块  if (m_impl->m_made_dirty) {    log_flush_order_mutex_exit();   // 退出互斥锁  }  release_all();   // 开释全部资源  release_resources();  // 开释额外资源

复制代码

• 3、在函数mtr_t::Command::execute中调用finish_write函数完成日志的写入。
  

1. /** Append the redo log records to the redo log buffer
2. @param[in] len        number of bytes to write */
3. void
4. mtr_t::Command::finish_write(
5.         ulint        len)
6. {
7.         ut_ad(m_impl->m_log_mode == MTR_LOG_ALL);
8.         ut_ad(log_mutex_own());
9.         ut_ad(m_impl->m_log.size() == len);
10.         ut_ad(len > 0);
12.         if (m_impl->m_log.is_small()) {
13.                 const mtr_buf_t::block_t*        front = m_impl->m_log.front();
14.                 ut_ad(len <= front->used());
16.                 m_end_lsn = log_reserve_and_write_fast(
17.                         front->begin(), len, &m_start_lsn);
19.                 if (m_end_lsn > 0) {
20.                         return;
21.                 }
22.         }
24.         /* Open the database log for log_write_low */
25.         m_start_lsn = log_reserve_and_open(len);
27.         mtr_write_log_t        write_log;
28.         m_impl->m_log.for_each_block(write_log);
30.         m_end_lsn = log_close();
31. }

复制代码

（1）断言检查

1.     ut_ad(m_impl->m_log_mode == MTR_LOG_ALL);  // 确保当前的日志模式是记录所有更改
2.         ut_ad(log_mutex_own());  // 确保当前线程持有日志互斥锁
3.         ut_ad(m_impl->m_log.size() == len);  // 确保redo日志缓冲区中的日志记录大小与要写入的大小相同
4.         ut_ad(len > 0);  // 确保要写入的长度大于0

复制代码

（2）快速写入检查

1. if (m_impl->m_log.is_small()) {
2.                 const mtr_buf_t::block_t*        front = m_impl->m_log.front();
3.                 ut_ad(len <= front->used());
5.                 m_end_lsn = log_reserve_and_write_fast(
6.                         front->begin(), len, &m_start_lsn);
8.                 if (m_end_lsn > 0) {
9.                         return;
10.                 }
11.         }

复制代码

  

• 假如redo日志缓冲区中的日志记录较小，则使用快速写入路径。
  
• 获取缓冲区的前端块(front)，并检查要写入的长度是否小于或等于该块已使用的空间。
  
• 调用log_reserve_and_write_fast函数尝试快速写入。成功则直接返回。
  

  （3）常规写入路径

1.     m_start_lsn = log_reserve_and_open(len);
3.         mtr_write_log_t        write_log;
4.         m_impl->m_log.for_each_block(write_log);
6.         m_end_lsn = log_close();

复制代码

  

• 假如快速写入失败或不适用于当前情况，则进入常规写入路径。
  
• 调用log_reserve_and_open函数为日志写入预留空间，并获取起始日志序列号。
  
• 使用m_impl->m_log.for_each_block(write_log);遍历redo日志缓冲区中的每个块，并准备将它们写入到日志文件中。
  
• 调用log_close函数完成日志写入，并获取竣事日志序列号。
  

  

• 4、在函数mtr_t::Command::finish_write中的关键核心函数为log_reserve_and_write_fast，该函数用于在日志系统中快速保留空间并写入一个字符串。
  

1. /** Append a string to the log.
2. @param[in]        str                string
3. @param[in]        len                string length
4. @param[out]        start_lsn        start LSN of the log record
5. @return end lsn of the log record, zero if did not succeed */
6. UNIV_INLINE
7. lsn_t
8. log_reserve_and_write_fast(
9.         const void*        str,
10.         ulint                len,
11.         lsn_t*                start_lsn)
12. {
13.         ut_ad(log_mutex_own());
14.         ut_ad(len > 0);
16.         const ulint        data_len = len
17.                 + log_sys->buf_free % OS_FILE_LOG_BLOCK_SIZE;
19.         if (data_len >= OS_FILE_LOG_BLOCK_SIZE - LOG_BLOCK_TRL_SIZE) {
21.                 /* The string does not fit within the current log block
22.                 or the log block would become full */
24.                 return(0);
25.         }
27.         *start_lsn = log_sys->lsn;
29.         memcpy(log_sys->buf + log_sys->buf_free, str, len);
31.         log_block_set_data_len(
32.                 reinterpret_cast<byte*>(ut_align_down(
33.                         log_sys->buf + log_sys->buf_free,
34.                         OS_FILE_LOG_BLOCK_SIZE)),
35.                 data_len);
37.         log_sys->buf_free += len;
39.         ut_ad(log_sys->buf_free <= log_sys->buf_size);
41.         log_sys->lsn += len;
43.         MONITOR_SET(MONITOR_LSN_CHECKPOINT_AGE,
44.                     log_sys->lsn - log_sys->last_checkpoint_lsn);
46.         return(log_sys->lsn);
47. }

复制代码

（1）断言检查

1. ut_ad(log_mutex_own());  // 确保当前线程持有日志系统的互斥锁
2. ut_ad(len > 0);  // 确保字符串长度大于0

复制代码

（2）盘算并检查数据长度

1. const ulint        data_len = len
2.         + log_sys->buf_free % OS_FILE_LOG_BLOCK_SIZE;  // 计算包括字符串长度和日志缓冲区当前空闲空间的对齐填充在内的总数据长度
4. if (data_len >= OS_FILE_LOG_BLOCK_SIZE - LOG_BLOCK_TRL_SIZE) {
6.         /* 如果data_len大于或等于日志块大小减去日志块尾部大小，则字符串无法在当前日志块中容纳，或者会使日志块变满，函数返回0 */
8.         return(0);
9. }

复制代码

（3）写入字符串

1. *start_lsn = log_sys->lsn;  // 将当前日志序列号保存到start_lsn指向的变量中
3. memcpy(log_sys->buf + log_sys->buf_free, str, len);  // 将当前日志序列号保存到start_lsn指向的变量中

复制代码

（4）更新相干数据

1. log_block_set_data_len(
2.                         reinterpret_cast<byte*>(ut_align_down(
3.                                         log_sys->buf + log_sys->buf_free,
4.                                         OS_FILE_LOG_BLOCK_SIZE)),
5.                         data_len);
7. log_sys->buf_free += len;
9. ut_ad(log_sys->buf_free <= log_sys->buf_size);
11. log_sys->lsn += len;

复制代码

  

• 调用log_block_set_data_len函数，根据写入的数据长度更新日志块的数据长度；
  
• 更新日志缓冲区的空闲位置，并更新日志序列号，以反映新写入的字符串长度；
  
• 确保日志缓冲区的空闲位置不会凌驾其巨细。
  

  （5）竣事操纵

1. MONITOR_SET(MONITOR_LSN_CHECKPOINT_AGE,
2.                 log_sys->lsn - log_sys->last_checkpoint_lsn);  // 更新监控指标，反映当前LSN与最后一个检查点LSN之间的差值
4. return(log_sys->lsn);  // 返回写入操作结束时的LSN

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

---

欢迎光临 IT评测·应用市场-qidao123.com (https://dis.qidao123.com/)

Powered by Discuz! X3.4