Redo Log Write and flush

Http://bbs.chinaunix.net/thread-1753130-1-1.html

When a transaction commits, Innobase calls Innobase_commit in ha_innodb.cc, and Innobase_commit calls Trx_commit_complete_for_mysql (TRX0TRX.C) To call Log_write_up_to (LOG0LOG.C), that is, when Innobase commits the transaction, Log_write_up_to is called to write redo log.
In Innobase_commit

1. if (all # if the transaction is committed
2. || (!thd_test_options (THD, Option_not_autocommit | Option_begin)) {

Copy Code

Commit serialization of a transaction through the following code

2. if (innobase_commit_concurrency > 0) {
4. Pthread_mutex_lock (&commit_cond_m);
6. commit_threads++;
10. if (Commit_threads > Innobase_commit_concurrency) {
12. commit_threads--;
14. Pthread_cond_wait (&commit_cond,
16. &COMMIT_COND_M);
18. Pthread_mutex_unlock (&commit_cond_m);
20. Goto retry;
22. }
24. else {
26. Pthread_mutex_unlock (&commit_cond_m);
28. }
30. }

Copy Code

1. Trx->flush_log_later = TRUE; # Prohibit flush Binlog to disk when doing commit operation
2. Innobase_commit_low (TRX);
3. Trx->flush_log_later = FALSE;

Copy Code

Skip the Innobase_commit_low call first, and start calling Trx_commit_complete_for_mysql to do the write log operation

1. Trx_commit_complete_for_mysql (TRX); #开始flush Log
2. Trx->active_trans = 0;

Copy Code

In Trx_commit_complete_for_mysql, the main thing is to judge the system parameter Srv_flush_log_at_trx_commit value to call
Log_write_up_to, or write redo log file or Write&&flush to disk

2. if (!trx->must_flush_log_later) {
4. /* do nothing */
6. } else if (Srv_flush_log_at_trx_commit = = 0) {#flush_log_at_trx_commit = 0, transaction commit does not write redo log
8. /* do nothing */
10. } else if (Srv_flush_log_at_trx_commit = = 1) {#flush_log_at_trx_commit = 1, transaction commits write log and flush disk if flush mode is not srv_unix_nosync (This is not very familiar)
12. if (Srv_unix_file_flush_method = = Srv_unix_nosync) {
14. /* Write the log but don't flush it to disk */
18. Log_write_up_to (LSN, Log_wait_one_group, FALSE);
20. } else {
22. /* Write The log to the log files and flush them to
24. Disk */
28. Log_write_up_to (LSN, Log_wait_one_group, TRUE);
30. }
32. } else if (Srv_flush_log_at_trx_commit = = 2) {#如果是2, write only to redo log
36. /* Write the log but don't flush it to disk */
40. Log_write_up_to (LSN, Log_wait_one_group, FALSE);
42. } else {
44. Ut_error;
46. }

Copy Code

Then look at log_write_up_to.

2. if (Flush_to_disk #如果flush到磁盘, compares whether the LSN of the current commit is greater than the LSN that has been flush to disk
4. && ut_dulint_cmp (LOG_SYS->FLUSHED_TO_DISK_LSN, LSN) >= 0) {
8. Mutex_exit (& (Log_sys->mutex));
12. Return
14. }
18. if (!flush_to_disk #如果不flush磁盘则比较当前commit的lsn是否大于已经写到所有redo the LSN of the log file, or if only one of the group completion conditions is greater than the LSN that has been written to a redo file
20. && (ut_dulint_cmp (LOG_SYS->WRITTEN_TO_ALL_LSN, LSN) >= 0
22. || (UT_DULINT_CMP (LOG_SYS->WRITTEN_TO_SOME_LSN, LSN)
24. >= 0
26. && wait! = log_wait_all_groups))) {
30. Mutex_exit (& (Log_sys->mutex));
34. Return
36. }
38. #下面的代码判断是否log在write, some words await their completion
40. if (Log_sys->n_pending_writes > 0) {
42. if (Flush_to_disk # if required to flush to disk, if the LSN being flushed includes a commit LSN, just wait for the operation to complete
44. && ut_dulint_cmp (LOG_SYS->CURRENT_FLUSH_LSN, LSN)
46. >= 0) {
48. Goto Do_waits;
50. }
54. if (!flush_to_disk # if it is brushed to redo log file then if the LSN of the commit is included in the write LSN, just wait.
56. && ut_dulint_cmp (LOG_SYS->WRITE_LSN, LSN) >= 0) {
58. Goto Do_waits;
60. }
62. ......
64. if (!flush_to_disk # If in the current IO idle case and does not need to flush to disk, then if the next write location has reached Buf_free location Description Wirte operation has been completed, directly return
66. && Log_sys->buf_free = = log_sys->buf_next_to_write) {
68. Mutex_exit (& (Log_sys->mutex));
70. Return
72. }

Copy Code

The following takes the group, sets the relevant write or flush related fields, and gets the block number of the starting and ending positions

2. log_sys->n_pending_writes++;
6. Group = Ut_list_get_first (log_sys->log_groups);
8. group->n_pending_writes++; /* We assume here and we have only
10. One log group! */
14. Os_event_reset (log_sys->no_flush_event);
16. Os_event_reset (log_sys->one_flushed_event);
20. Start_offset = log_sys->buf_next_to_write;
22. End_offset = log_sys->buf_free;
26. Area_start = Ut_calc_align_down (Start_offset, os_file_log_block_size);
28. Area_end = Ut_calc_align (End_offset, os_file_log_block_size);
32. Ut_ad (Area_end-area_start > 0);
36. LOG_SYS->WRITE_LSN = log_sys->lsn;
40. if (Flush_to_disk) {
42. LOG_SYS->CURRENT_FLUSH_LSN = log_sys->lsn;
44. }

Copy Code

Log_block_set_checkpoint_no Call Set End_offset the log_block_checkpoint_no of the block is the next checkpoint number in Log_sys.

1. Log_block_set_flush_bit (Log_sys->buf + Area_start, TRUE); # This doesn't look clear
2. Log_block_set_checkpoint_no (
3. Log_sys->buf + area_end-os_file_log_block_size,
4. LOG_SYS->NEXT_CHECKPOINT_NO);

Copy Code

Save data that is not part of End_offset but in its block to the next free block

1. ut_memcpy (Log_sys->buf + area_end,
2. Log_sys->buf + area_end-os_file_log_block_size,
3. Os_file_log_block_size);

Copy Code

For each group call Log_group_write_buf write redo log buffer

2. while (group) {
4. Log_group_write_buf (
6. Group, Log_sys->buf + Area_start,
8. Area_end-area_start,
10. Ut_dulint_align_down (LOG_SYS->WRITTEN_TO_ALL_LSN,
12. Os_file_log_block_size),
14. Start_offset-area_start);
18. Log_group_set_fields (group, LOG_SYS->WRITE_LSN); # Calculate the LSN and offset for this write to set GROUP->LSN and Group->lsn_offset
22. Group = Ut_list_get_next (log_groups, group);
24. }
26. ......
28. if (Srv_unix_file_flush_method = = Srv_unix_o_dsync) {# What's this stuff?
30. /* O_dsync means the OS did not buffer the log file at all:
32. So we had also flushed to disk and we have written */
36. LOG_SYS->FLUSHED_TO_DISK_LSN = log_sys->write_lsn;
40. } else if (Flush_to_disk) {
44. Group = Ut_list_get_first (log_sys->log_groups);
48. Fil_flush (group->space_id); # Last Call Fil_flush execution flush to disk
50. LOG_SYS->FLUSHED_TO_DISK_LSN = log_sys->write_lsn;
52. }

Copy Code

Next thing you see, Log_group_write_buf did something.

In Log_group_calc_size_offset, the LSN of the last record is taken from the group (note that it is a 1-ring buffer of log files) and the LSN is calculated relative to the last difference

2. # call Log_group_calc_size_offset to calculate Group->lsn_offset to remove the size of multiple log_file head lengths, such as Lsn_offset falls on the 3rd LOG file, then need to subtract 3*log_ Size of the File_hdr_size
4. Gr_lsn_size_offset = (Ib_longlong)
6. Log_group_calc_size_offset (Group->lsn_offset, group);
8. Group_size = (ib_longlong) log_group_get_capacity (group); # calculates the size of the data portion of the group after all log_file_hdr_size lengths are removed
12. # below is a typical differential calculation for ring structures
14. if (ut_dulint_cmp (LSN, GR_LSN) >= 0) {
18. difference = (Ib_longlong) ut_dulint_minus (LSN, GR_LSN);
20. } else {
22. difference = (Ib_longlong) ut_dulint_minus (GR_LSN, LSN);
26. difference = difference% Group_size;
30. difference = group_size-difference;
32. }
36. Offset = (gr_lsn_size_offset + difference)% Group_size;
38. # finally count each log file header size, return the real offset
40. Return (Log_group_calc_real_offset ((ulint) offset, group));

Copy Code

Then look

2. # If you need to write more than one file size
4. if ((next_offset% group->file_size) + len > Group->file_size) {
8. Write_len = group->file_size # writes to the end of file
10. -(next_offset% group->file_size);
12. } else {
14. Write_len = Len; # no one writes Len a block
16. }
20. # Finally the real content is to write buffer, if you cross file, you need to write the file log file head part
24. if ((next_offset% group->file_size = = log_file_hdr_size)
26. && Write_header) {
28. /* We start to write a new log file instance in the group */
32. Log_group_file_header_flush (Group,
34. Next_offset/group->file_size,
36. START_LSN);
38. srv_os_log_written+= os_file_log_block_size;
40. srv_log_writes++;
42. }
46. # call Fil_io to execute buffer write
48. if (log_do_write) {
50. log_sys->n_log_ios++;
54. srv_os_log_pending_writes++;
58. Fil_io (Os_file_write | Os_file_log, TRUE, group->space_id,
60. Next_offset/univ_page_size,
62. Next_offset% univ_page_size, Write_len, buf, group);
66. srv_os_log_pending_writes--;
70. srv_os_log_written+= Write_len;
72. srv_log_writes++;
74. }

Copy Code

Redo Log Write and flush