Redo Log

MySQL版本: 8.0.15

Redo log用来记录每次数据操作,用于Crash之后做恢复操作,而每一条Redo Log都是由mini-transaction原子提交的.

Redo Log的数据结构

这并不是单个Redo Log的数据结构,而是管理Redo Log元信息,Redo Log Buffer等操作的系统单元.(include/log0types.h)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
struct alignas(INNOBASE_CACHE_LINE_SIZE) log_t {
atomic_sn_t sn; // 目前log buffer申请的空间大小
aligned_array_pointer<byte, OS_FILE_LOG_BLOCK_SIZE> buf; // log buffer的内存区
Link_buf<lsn_t> recent_written; // 解决并发插入Redo Log Buffer后刷入ib_logfile存在空洞的问题
Link_buf<lsn_t> recent_closed; // 解决并发插入flush_list后确认checkpoint_lsn的问题
atomic_lsn_t write_lsn; // write_lsn之前的数据已经写入系统的Cache, 但不保证已经Flush
atomic_lsn_t flushed_to_disk_lsn; // 已经被flush到磁盘的数据
size_t buf_size; // log buffer缓冲区的大小
lsn_t available_for_checkpoint_lsn; // 在此lsn之前的所有被添加到buffer pool的flush list的log数据已经被flsuh, 下一次checkpoint可以make在这个lsn. 与last_checkpoint_lsn的区别是该lsn尚未被真正的checkpoint.
lsn_t requested_checkpoint_lsn; // 下次需要进行checkpoint的lsn
atomic_lsn_t last_checkpoint_lsn; // 目前最新的checkpoint的lsn
uint32_t write_ahead_buf_size; // write ahead的Buffer大小
lsn_t current_file_lsn; //
uint64_t current_file_real_offset; //
uint64_t current_file_end_offset; // 当前ib_logfile文件末尾的offset
uint64_t file_size; // 当前ib_logfile的文件大小
}

mini-transaction

mini-transaction具体流程

1
2
3
4
5
6
mtr_t mtr
mtr.start()
...
// 写入数据至mini-transaction的m_log
...
mtr.commit()

mini-transaction的数据结构

1
2
3
4
5
6
7
8
9
10
11
12
struct mtr_t {
// mtr_t 内嵌一个结构体Impl
struct Impl {
mtr_buf_t m_memo; // 一个被加锁的对象以及它加的锁
mtr_buf_t m_log; // mini-transaction的log
bool m_made_dirty; // 是否修改了Buffer Pool中的页为脏页
bool m_modifications; // 是否修改了Buffer Pool中的页
ib_uint32_t m_n_log_recs; // 该mini-transaction包含多少条log.
mtr_log_t m_log_mode; // mini-transaction的操作类型(MTR_LOG_ALL, MTR_LOG_NO_REDO,MTR_LOG_NONE)
mtr_state_t m_state; // mini-transaction的状态: MTR_STATE_INIT, MTR_STATE_ACTIVE, MTR_STATE_COMMITTING, MTR_STATE_COMMITTED
}
}

其中m_memo中元素是mtr_memo_slot_t, 记录加锁的对象和加锁的类型.

1
2
3
4
5
6
/** mini-transaction memo stack slot. */
struct mtr_memo_slot_t {
void *object; // 加锁的对象

ulint type; // 持有的锁类型,W or R
};

mini-transaction的start()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/** Start a mini-transaction.
@param sync true if it is a synchronous mini-transaction
@param read_only true if read only mini-transaction */
void mtr_t::start(bool sync, bool read_only) {
UNIV_MEM_INVALID(this, sizeof(*this));

UNIV_MEM_INVALID(&m_impl, sizeof(m_impl));

m_sync = sync;

m_commit_lsn = 0;

new (&m_impl.m_log) mtr_buf_t(); // 记录Redo log的Buffer
new (&m_impl.m_memo) mtr_buf_t();

// 初始化mini-transaction字段
m_impl.m_mtr = this;
m_impl.m_log_mode = MTR_LOG_ALL;
m_impl.m_inside_ibuf = false;
m_impl.m_modifications = false;
m_impl.m_made_dirty = false;
m_impl.m_n_log_recs = 0;
m_impl.m_state = MTR_STATE_ACTIVE;
m_impl.m_flush_observer = NULL;

ut_d(m_impl.m_magic_n = MTR_MAGIC_N);
}

不同的mini-transaction如何互斥?

在操作数据前,会根据锁类型,加不同类型的锁,之后将object和锁类型存入m_memo:

1
mtr_memo_push(mtr, object, type);

commit完成之后调用release_latches(RELEASE_ALL)将数据上的锁释放.

mini-transaction插入数据

  • byte *mlog_open(mtr_t *mtr, ulint size): 打开mtrm_log
  • mlog_write_initial_log_record_low()函数向m_log中写入typespace idpage no,并增加m_n_log_recs的数量
  • mtr->get_log()->push()按不同的类型写数据
  • mlog_close(): 更新m_log中的位置

mini-transaction的commit过程

commit过程将mini-transaction的m_log数据拷贝到Redo Log Buffer中. 将m_state设置为MTR_STATE_COMMITTING后,调用mtr_t::Command::execute():

mtr_t::Command::execute()

  • prepare_write(): 根据mtr的类型m_impl->m_log_mode, 计算redo log的长度. 假如Log记录数目n_recs为1时,设置Flag为MLOG_SINGLE_REC_FLAG, Log记录不止一条时,Flag置为MLOG_MULTI_REC_END.

  • 假如Redo Log的长度不为0时, log_buffer_reserve():

    • 自增Redo Log Buffer中的snsn代表目前Redo Log Buffer已经预留的空间,由sn_lock锁保护.sn是一个全局维护的递增LSN编号.

    • 获得handler,计算写入Redo Log的start_lsnend_lsn,即实际写入的数据大小, lsnsn的关系其实就是LOG_BLOCK_DATA_SIZEOS_FILE_LOG_BLOCK_SIZE(512字节)是否带LOG_BLOCK_HDR_SIZELOG_BLOCK_TRL_SIZE的转换

    • 假如需要扩展Redo Log Buffer的空间长度, 即end_lsn大于sn_limit_for_end. log_wait_for_space_after_reserving会进行扩展以及一系列的参数检查.

    • 因为Redo Log Buffer是环形的,假如写的长度超过了Redo Log Buffer则需要回环,所以需要log_wait_for_space_in_log_buf(log, start_sn)等待start_sn之前的Redo Log已经被写入.

      1
      2
      3
      4
      // end_sn + OS_FILE_LOG_BLOCK_SIZE - buf_size_sn是回环的sn编号
      lsn = log_translate_sn_to_lsn(end_sn + OS_FILE_LOG_BLOCK_SIZE - buf_size_sn);
      // 等待lsn之前的Redo Log被写入
      wait_stats = log_write_up_to(log, lsn, false);
    • 这里可能会和Redo Log Buffer允许空洞产生歧义,需要注意的是Redo Log Buffer允许的空洞是write_lsn之后的Redo Log Buffer允许空洞,现在的情况是因为一条Redo Log的长度超过了Redo Log Buffer的剩余长度需要回环,所以在此之前的Redo Log必须保证写入完成.*

    • log_write_up_to()需要wait在log_t中的write_events. 当log.write_lsn.load() >= lsn, 即对应于Redo Log Buffer中的slot空间已经完成了写入则被唤醒.

    • log_buffer_resize_low()会Resize设置Redo Log Buffer的长度, 释放旧长度的Redo Log Buffer空间,重新分配新长度的Redo Log Buffer空间,并且重新拷贝Redo Log内容.

    • 对m_log中的每一个512字节的block调用mtr_write_log_t()(需要注意的是mtr_write_log_t()是运算符()的重载)

      • log_buffer_write()使用memcpy()写Redo Log Buffer.
      • log_buffer_write_completed()更新log_t中的recent_written,即(start_lsn, end_lsn)组成的list.
    • 调用add_dirty_blocks_to_flush_list().

  • log_wait_for_space_in_log_recent_closed()查看recent_closed链表是否符合规则的位置留给该条Redo Log.

  • 假如Redo Log的长度为0时:

    • 直接调用add_dirty_blocks_to_flush_list().
  • add_dirty_blocks_to_flush_list():

    • 假如产生了Redo Log,则将Block的newest_modification修改为end_lsn.
    • 假如该Block是第一次被修改,就需要插入Buffer Pool的flush_list. 将涉及修改的Block添加到Buffer Pool的flush_list(buf_flush_insert_into_flush_list()).(利用block->page.oldest_modification来判断是否为第一次修改)
  • log_buffer_close(): 更新log_t中的recent_closed链表.

  • release_resources()释放资源, 将m_state置为MTR_STATE_COMMITTED

Redo Log Buffer

Redo Log Buffer是一段内存区域用来存放需要写入ib_logfile的数据. Redo Log Buffer的大小buf_size可以通过innodb_log_buffer_size来控制, 默认16MB.

Redo Log Buffer的Resize过程

redo_log_buffer_resize

Redo Log Buffer是我们通常所说的回环Buffer, 而在Resize的过程中将log.write_lsnend_lsn直接的Redo Log拷贝至一个临时的Buffer,然后新建一个new_size的Buffer, 将tmp_buf的数据原路拷贝.

Redo Log模块的线程

log_writer

完成Redo Log Buffer的写入, 即写入ib_logfile文件. (log/log0write.cc)

  • log_writer线程wait在一个限定的condition,即直到满足log.write_lsn.load() < log.recent_written.tail()时调用log_writer_write_buffer()进行Redo写入. 指定的condition函数会递增log.recent_written.tail
  • 具体写入流程在log_files_write_buffer(), 首先计算写入在文件的真实偏移:

    1
    2
    3
     /* start_lsn为该次写入的起始lsn */
    const auto real_offset =
    log.current_file_real_offset + (start_lsn - log.current_file_lsn);
  • 计算目前的ib_logfile文件是否有足够的空间满足该条Redo Log的写入:

    • 假如目前的ib_logfile已经写满,则需要调用start_next_file()直接切换下一个文件.
    • 假如目前的ib_logfile还拥有空闲的空间,则需要将Redo Log分两次写入,但本次写入仅填充目前的ib_logfile的剩余空间.
  • MySQL8.0在写入Redo Log的过程中引入了write ahead buffer避免小IO的read on write:
  • write_blocks来调用fil_redo_io()来完成文件写入(写入操作系统的Page Cache), 每次写入都是512 Bytes对齐(OS_FILE_LOG_BLOCK_SIZE)
  • 更新log.write_lsn
  • 调用notify_about_advanced_write_lsn()唤醒对应slot正在wait的线程, 这里其实就是mini-transaction的commit阶段写入Redo Log Buffer中,需要等待log.write_lsn.load() >= lsn的部分.
  • 唤醒Redo Log的Flush线程(os_event_set(log.flusher_event))

    redo_log_buffer

    上图表示Redo Log Buffer,这里需要考虑的是log.recent_written.tail()也是由log_writer线程来更新的,因为mtr的commit过程根据lsn计算拷贝至Redo Log Buffer的位置,这里是允许空洞的,所以为了能Flush至文件时能Batch无空洞写入,这里由log.recent_writtentail来保证之前tail之前的Buffer是不存在空洞的.

log_flusher

将Redo Log Buffer中的日志进行Flush, 这里进行的是Redo Log的刷脏,与数据脏页的Flush无关,数据脏页的Flush由Buffer Pool刷脏线程处理.

  • log_fluser根据srv_flush_log_at_trx_commit来选择不同的wait方式:

    • 假如srv_flush_log_at_trx_commit=1

      1
      os_event_wait_time_low(log.flusher_event, flush_every_us - time_elapsed_us, 0);
    • 否则:

      1
      const auto wait_stats = os_event_wait_for(log.flusher_event, max_spins, srv_log_flusher_timeout, stop_condition);
  • 假如last_flush_lsn < log.write_lsn.load(),即需要进行刷盘.

  • fil_system->flush_file_redo()进行文件刷盘.

  • 更新log.flushed_to_disk_lsn.

  • 唤醒wait在该slot[last_flush_lsn, flush_up_to_lsn]的用户线程.

log_closed

更新log.recent_closedtail.

log_checkpointer

进行checkpoint的线程

  • 更新available_for_checkpoint_lsn, 即目前可以安全进行checkpoint的lsn.

  • 扫描所有Buffer Pool的flush_list,获取最旧的一条Redo Log的lsn(bpage = UT_LIST_GET_LAST(buf_pool->flush_list). 这里最旧的lsn并不代表lsn是最小的,因为插入flush_list是允许并发插入的,所以无法保证flush_list中的Redo Log按照lsn的顺序排列.

  • flush_list中最旧的lsn减去recent_closed的长度,然后与上次checkpoint的lsn进行比较, 选较大的lsn_t lwm_lsn = (std::max(checkpoint_lsn, lsn - lag)).

  • recent_closed.tail比较(const lsn_t dpa_lsn = log.recent_written.tail()),选较小的(lwm_lsn = std::min(lwm_lsn, dpa_lsn).

  • log.flushed_to_disk_lsn比较,选较小的(std::min(lwm_lsn, flushed_lsn)).

  • 更新log.available_for_checkpoint_lsn.

  • 计算current_lsn, 与log.available_for_checkpoint_lsn比较,假如在此期间又有脏页被刷入flush list, 则一并进行预Flush. 之后更新log.available_for_checkpoint_lsn.

  • 检查是否需要checkpoint

  • log_checkpoint(log)进行checkpoint, 其中就是调用接口将checkpoint的信息写入指定的文件.

write_ahead_buffer

下面为compute_how_much_to_write()的代码片段,主要计算需要写入多大write_size的Redo Log:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
/* write_from_log_buffer为bool变量,判断是否需要将Redo Log拷贝至write_ahead_buffer */
write_from_log_buffer = write_size >= OS_FILE_LOG_BLOCK_SIZE;
/* ... */
if (!current_write_ahead_enough(log, real_offset, write_size)) {
/* 假如write_ahead_buffer的剩余空间不满足存放write_size大小的Redo Log */
if (!current_write_ahead_enough(log, real_offset, 1)) {
/* 经过判断write_ahead_buffer已经没有任何剩余空间 */

/* 计算滑动后下一个write_ahead_buffer的结束偏移位置 */
const auto next_wa = compute_next_write_ahead_end(real_offset);

if (!write_ahead_enough(next_wa, real_offset, write_size)) {
/* 下一个write_ahead_buffer仍然不满足存放write_size大小的Redo Log,
即直接从Redo Log Buffer写入,无须拷入write_ahead_buffer,但大小被
限制不能超过srv_log_write_ahead_size,
所以Redo Log的写入最大也就是写srv_log_write_ahead_size */

ut_a(write_from_log_buffer);

/* 需要注意的是,这里不经过write_ahead_buffer的直接写入,但real_offset是通过
log.write_lsn进行OS_FILE_LOG_BLOCK_SIZE对齐计算的,所以Redo Log Buffer的直接
写入依然是OS_FILE_LOG_BLOCK_SIZE对齐的. */
write_size = next_wa - real_offset;

ut_a((real_offset + write_size) % srv_log_write_ahead_size == 0);

ut_a(write_size % OS_FILE_LOG_BLOCK_SIZE == 0);
} else {
/* 滑动后的write_ahead_buffer满足预写write_size大小的Redo Log */
write_from_log_buffer = false;
}
} else {
/* write_ahead_buffer存在剩余空间,则先完成剩余空间大小的写入 */
write_size = static_cast<size_t>(log.write_ahead_end_offset - real_offset);

ut_a(write_size >= OS_FILE_LOG_BLOCK_SIZE);
ut_a(write_size % OS_FILE_LOG_BLOCK_SIZE == 0);
}
} else {
if (write_from_log_buffer) {
/* 假如write_ahead_buffer的剩余空间满足写入write_size大小的Redo Log,
则无须经过write_ahead_buffer的拷贝,直接从Redo Log Buffer对齐后直接写入,
但这部分区域已经被上一次的write_ahead_buffer预写过 */
write_size = ut_uint64_align_down(write_size, OS_FILE_LOG_BLOCK_SIZE);
}
/* 对于write_size小于OS_FILE_LOG_BLOCK_SIZE, 但write_ahead_buffer的剩余空间同样满足的,
后面的copy_to_write_ahead_buffer()会对block进行0x00填充 */
}

return (write_size);

write_ahead_buffer

上图举例write_ahead_buffer的一次写入过程: 假如需要在real_offset34274304位置开始写入buffer_size437大小的数据,假定目前write_ahead_buffer已经被上一次的写入写满,所以本次写入需要重新滑动.

  • real_offset向下取整srv_log_write_ahead_size求得last_wanext_wa的位置, 即last_wanext_wa的区间为本次的write_ahead_buffer.

  • 将数据buffer后面的部分均以0x00填充直到next_wa, 即本次写入的数据为437 + 75 + 512 = 1024大小。75 + 512的部分为log_writer的预写(write ahead).

  • write_ahead_buffer重新滑动后,写入完成后会更新log.write_ahead_end_offset:

1
2
3
4
5
6
7
8
static inline void update_current_write_ahead(log_t &log, uint64_t real_offset, size_t write_size) {
/* 假如write_ahead_buffer经过了滑动, write_size则为数据 + 0x00预写的大小 */
const auto end = real_offset + write_size;

if (end > log.write_ahead_end_offset) {
log.write_ahead_end_offset = ut_uint64_align_down(end, srv_log_write_ahead_size);
}
}

所以log_writer线程的每次写入都是OS_FILE_LOG_BLOCK_SIZE对齐写入,并且大小不会超过srv_log_write_ahead_size.

recent_written与recent_closed的作用

recent_written

  • MySQL 8.0通过直接计算每一条Redo在Redo Log Buffer的offset来并发插入Redo Log Buffer, 这里是允许Redo Log Buffer存在空洞的,而写入ib_logfile不允许,所以利用recent_written.tail来保证在此之前的Redo Log Buffer是不存在空洞的,从而完成ib_logfile的完整写入.

recent_closed

  • MySQL 8.0 允许并发插入flush_list, 为了能安全的进行checkpoint,需要选择一个已经被Flush的lsn,所以选择所有Buffer Pool的flush_list中最旧的一个lsn, 减去recent_closed的长度,可以确认是一个安全的checkpoint_lsn.

Redo Log中Record的格式

MLOG_REC_INSERT的Redo格式

insert_record_format