数据库内核月报 － 2020 / 01

log_writer
->log_writer_write_buffer
->log_files_write_buffer // redo log的write ahead逻辑发生在这个函数内

//@log_files_write_buffer函数
static void log_files_write_buffer(log_t &log, byte *buffer, size_t buffer_size,
                                   lsn_t start_lsn) {
  ......
  // 该变量为true，表示将redo log直接从log_sys->buf内写入到文件系统；
  // 否则，表示需要先将要写入的redo log拷贝到log_sys->write_ahead_buf,
  // 然后从log_sys->write_ahead_buf，将redo log写入到文件系统中, 对于后者
  // 有两种情况：a. 执行write ahead逻辑；b. 需要对最后一个完整的log block填0。
  bool write_from_log_buffer;
  // 计算本次redo log IO的大小和判断write_from_log_buffer的值。
  // 后面分析其实现。 
  auto write_size = compute_how_much_to_write(log, real_offset, buffer_size,
                                              write_from_log_buffer);

  if (write_size == 0) {
    // 如果本次IO大小的计算值为0，表示当前刚好处在正在写入的redo log文件的结尾,
    // 需要先切换到下一个redo log文件
    start_next_file(log, start_lsn);
    return;
  }

  // 以512个字节为单位，计算并填入每个完整的log block的元信息，
  // 如：该log block的有效数据长度、该log block当前对应的checkpoint no,
  // 该log block的checksum等。
  // note: 这里计算的是完整log block的元信息，不完整的log block后面再做处理。
  prepare_full_blocks(log, buffer, write_size, start_lsn, checkpoint_no);
  ......
  if (write_from_log_buffer) {
    // 从log_sys->buf，将redo log直接写入到文件系统
    // 只需将写入的源端指向log_sys->buf内的正确位置，即
    // buffer所指向的地址。
    ......
    write_buf = buffer;
    .......

  } else {
    // 从log_sys->write_ahead_buf将redo log写入到文件系统,
    // 同样要讲写入的源端指向log_sys->write_ahead_buf
    write_buf = log.write_ahead_buf;
    // 先将要写入的redo log从全局log_sys->buf内拷贝到log_sys->write_ahead_buf
    // 中, 拷完后，将最后一个不完整的block的结尾区域填0，并填上checkpoint no,
    // checksum等元信息。
    copy_to_write_ahead_buffer(log, buffer, write_size, start_lsn,
                               checkpoint_no);
    //执行到这里的逻辑，有两种情况：
    //a. 当前要写入文件偏移量刚好log_sys->write_ahead_buf当前可以覆盖区域的结尾处
    //.  (这个地址一般都是page对齐的), 需要做write ahead操作；
    //b. 本次IO要写入的redo log量太少，小于一个log block的大小，需要一块额外的buffer
    //.  空间，将这块不完整log block的后端区域填0，并计算和填入checksum值等信息。如果直
    //   接在log_sys->buf内原地填0，可能会把mtr刚刚拷贝到该区域的log覆盖掉。
    // 下面的这个分支判断筛选出情况a.
    if (!current_write_ahead_enough(log, real_offset, 1)) {
      // 在执行write ahead的情况下，将log_sys->write_ahead_buf内未被有效redo log
      // 填充的区域都填0；同时更新write_size的值, 即write ahead buffer的大小
      written_ahead = prepare_for_write_ahead(log, real_offset, write_size);
    }
  }
  ......
  // 当刚才完成的写IO的目标范围的结束偏移(不是有效redo log的结束偏移)，不在
  // log_sys->write_ahead_buf的当前覆盖范围内，则往后滑动
  // log_sys->write_ahead_buf的覆盖范围，以便计算后续的redo log写IO，
  // 是否需要执行write ahead，和截断要写入的log数据等操作.
  update_current_write_ahead(log, real_offset, write_size);
}                                              

//@log_files_write_buffer->compute_how_much_to_write
// 该函数主要是为了判断当前的redo log写IO，是否需要write ahead,
// 和计算本次IO应该写入的数据大小。
static inline size_t compute_how_much_to_write(const log_t &log,
                                               uint64_t real_offset,
                                               size_t buffer_size,
                                               bool &write_from_log_buffer) {
  size_t write_size;
  .......
  // 如果需要跨文件，则当前IO只写入当前正在写入的redo log文件可以装下的数据；
  // 这很容易理解，一般的同步IO都是这么操作的。
  if (!current_file_has_space(log, real_offset, buffer_size)) {
    ......
    // 如果已经处在当前正在写入的redo log文件的结尾处，则需要先切换redo log文件；
    // 设置当前IO大小为0，来通知上层调用切换到新的redo log文件
    if (!current_file_has_space(log, real_offset, 1)) {
      .......
      write_from_log_buffer = false;
      return (0);
    } else {
      // 设定本次写入IO的数据量为当前redo log文件可以容纳的最大数据
      write_size =
          static_cast<size_t>(log.current_file_end_offset - real_offset);
      ......
    }
  } else {
    // 如果不需要跨文件(当前redo log文件可以容纳要写入的log), 则暂时设定
    // 写入IO的大小为要写入的log的大小，这个值在后面可能还要受到
    // log_sys->write_ahead_buf能够容纳的数据量的限制，而被截断。
    write_size = buffer_size;
  }
  ......

  // InnoDB的redo log是按照log block进行管理的，一个log block的大小为
  // OS_FILE_LOG_BLOCK_SIZE字节，每个log block都有独立的元信息，如log
  // block no, checksum等。当某次写redo log的IO要写入的log数据不足一个
  // OS_FILE_LOG_BLOCK_SIZE时，该IO准备逻辑需要将该写入数据的对应的log
  // block的后端区域填0，然后计算和填入该block填0后的checksum值；但是这
  // 不能在全局的log_sys->buf原地做，需要一块额外buffer，否则可能会覆盖后
  // 续填入其中的log数据；这里我们将log_sys->write_ahead_buf选为我们
  // 的"额外buffer"，所以这里当write_size小于OS_FILE_LOG_BLOCK_SIZE时，
  // 令'write_from_log_buffer'为false，表示本次写IO数据最后要从
  // log_sys->write_ahead_buf写入到文件系统中。
  write_from_log_buffer = write_size >= OS_FILE_LOG_BLOCK_SIZE;
  ......
  // 判断当前的write ahead区域，是否可以装得下我们这log IO要写入的数据，如
  // 果装不下，则需要截断本次IO要写入的数据；如果当前要写入的文件偏移，刚好处
  // 在log_sys->write_ahead_buf当前覆盖覆盖区域的结束位置(一般也是某个
  // page的起始或者结束地址处），这个时候，需要采用一次write ahead操作，具体
  // 逻辑为：将本次写IO要写入的数据从log_sys->buffer拷贝到
  // log_sys->write_ahead_buf内，将log_sys->write_ahead_buf后
  // 端未被有效数据填充的区域填0，然后将整个log_sys->write_ahead_buf的
  // 内容写入到文件系统中，避免可能出现的一次读IO开销
  // 
  // note. 这里有一个隐藏的假设：
  // a. 当某次写IO的目的偏移地址是与log_sys->write_ahead_buf当前覆盖范围
  //    的结束地址对齐时，则假定该次写IO目标区域在内存没有对应的page cache，需
  //.   要执行一次write ahead操作
  // b. 当执行一次write ahead逻辑后，在接下来的一段时间内，该区域对应的page cache
  //.   会保存在内存中，后续对当前write ahead buffer可以覆盖的文件区域的
  //.   写IO，都可以命中这些page cache, 从而避免额外的读IO开销。
  // 上面的假设a和b，真实情况下并不是百分百成立的。
  if (!current_write_ahead_enough(log, real_offset, write_size)) {
    if (!current_write_ahead_enough(log, real_offset, 1)) {
      // 本次写IO的目的地址不在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)) {
        // log_sys->write_ahead buffer的下一个完整的覆盖区域都容纳不了本次
        // 写IO的log数据，则将本次IO要写入的数据截断到write ahead buffer的
        // 大小；并且不需要再从log_sys->write_ahead_buf写，可以直接从
        // log_sys->buf写入到文件系统，减少了一次内存拷贝的开销。
        ......
        write_size = next_wa - real_offset;
        ......
      } else {
        // 本次写IO执行write ahead逻辑
        write_from_log_buffer = false;
      }
    } else {
      // log_sys->write_ahead_buf的当前覆盖范围容纳不了本次IO要写入的log
      // 数据，将本次IO要写入的log数据按照可以容纳的量阶段。
      write_size =
          static_cast<size_t>(log.write_ahead_end_offset - real_offset);
      ......
    }
  } else {
    if (write_from_log_buffer) {
      // 走到这里，根据上面write_from_log_buffer的赋值逻辑，说明本次IO要写入的log数
      // 据是大于一个OS_FILE_LOG_BLOCK_SIZE的，在这种情况下，将写入的log数据按照向下
      // 对齐OS_FILE_LOG_BLOCK_SIZE进行截断，这样可以一定概率的避免对最后一个不完整
      // block的后面区域填0操作(填0操作，有拷贝到另外一块额外buffer内的开销)，因为等下
      // 一次IO的时候，这个不完整的block可能又有新的log数据填入，变得完整了。
      write_size = ut_uint64_align_down(write_size, OS_FILE_LOG_BLOCK_SIZE);
    }
  }

  return (write_size);
}    

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
#include <stdint.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>

char filepath[128];
uint32_t len_per = 512;
char buf[4096];
char buf2[4096];
const uint64_t file_size = 1024*1024*1024*1ul;
const uint64_t block_size = 4096;

void usage() {
  fprintf(stderr, "usage:\n\t./append_write filepath [len_per]\n");
}
int main(int argc, char* argv[]) {
  if (argc > 3) {
    usage();
    return -1;
  }
  strcpy(filepath, argv[1]);

  if (argc == 3) {
    len_per = atoi(argv[2]);
  }
  int32_t fd = open(filepath, O_RDWR);
  if (fd == -1) {
    fprintf(stderr, "create new file failed, errno: %d\n", errno);
    return -1;
  }
  fprintf(stderr, "start writing...\n");
  for (uint64_t sum = 0; sum < file_size; sum += len_per) {
#ifdef WRITE_AHEAD
    if (sum % block_size == 0) {
      memcpy(buf2, buf, len_per);
      memset(buf2+len_per, 0, block_size - len_per);
      if (pwrite(fd, buf2, block_size, sum) != block_size) {
        fprintf(stderr, "write failed, errno: %d\n", errno);
        close(fd);
        return -1;
      }
    } else if (pwrite(fd, buf, len_per, sum) != len_per) {
      fprintf(stderr, "write failed, errno: %d\n", errno);
      close(fd);
      return -1;
    }
#elif defined(NORMAL_WRITE)
    if (pwrite(fd, buf, len_per, sum) != len_per) {
      fprintf(stderr, "write failed, errno: %d\n", errno);
      close(fd);
      return -1;
    }
#endif
  }
  fprintf(stderr, "finish writing...\n");

  close(fd);
  return 0;
}