MySQL 9.1.0
Source Code Documentation
log0write.h
Go to the documentation of this file.
1/*****************************************************************************
2
3Copyright (c) 1995, 2024, Oracle and/or its affiliates.
4
5This program is free software; you can redistribute it and/or modify it under
6the terms of the GNU General Public License, version 2.0, as published by the
7Free Software Foundation.
8
9This program is designed to work with certain software (including
10but not limited to OpenSSL) that is licensed under separate terms,
11as designated in a particular file or component or in included license
12documentation. The authors of MySQL hereby grant you an additional
13permission to link the program and your derivative works with the
14separately licensed software that they have either included with
15the program or referenced in the documentation.
16
17This program is distributed in the hope that it will be useful, but WITHOUT
18ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
19FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0,
20for more details.
21
22You should have received a copy of the GNU General Public License along with
23this program; if not, write to the Free Software Foundation, Inc.,
2451 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
25
26*****************************************************************************/
27
28/**************************************************/ /**
29 @file include/log0write.h
30
31 *******************************************************/
32
33#ifndef log0write_h
34#define log0write_h
35
36#ifndef UNIV_HOTBACKUP
37
38/* std::memory_order_X */
39#include <atomic>
40
41/* log.write_to_file_requests_interval */
42#include "log0sys.h"
43
44/* log_t&, lsn_t */
45#include "log0types.h"
46
47/* srv_threads */
48#include "srv0srv.h"
49
50/**************************************************/ /**
51
52 @name Log - waiting for redo written to disk.
53
54 *******************************************************/
55
56/** @{ */
57
58/** Waits until the redo log is written up to a provided lsn.
59@param[in] log redo log
60@param[in] lsn lsn to wait for
61@param[in] flush_to_disk true: wait until it is flushed
62@return statistics about waiting inside */
63Wait_stats log_write_up_to(log_t &log, lsn_t lsn, bool flush_to_disk);
64
65/** Total number of redo log flushes (fsyncs) that have been started since
66the redo log system (log_sys) became initialized (@see log_sys_init).
67@return total number of fsyncs or 0 if the redo log system is uninitialized */
68uint64_t log_total_flushes();
69
70/** Number of currently pending redo log flushes (fsyncs in-progress).
71@return number of pending fsyncs or 0 if the redo log system is uninitialized */
72uint64_t log_pending_flushes();
73
74/** Checks if the redo log writer exited extra margin. To minimize flipping
75of log.m_writer_inside_extra_margin, the check assumes the very pessimistic
76scenario in which a next write of the log_writer thread, would be executed
77up to the current lsn.
78
79Requirement: log.writer_mutex acquired and log.m_writer_inside_extra_margin
80is true, before calling this function.
81
82@remarks
83This method is supposed to be used by the log_checkpointer thread to detect
84situation in which the redo log writer has actually exited the extra_margin,
85because of advanced log.last_checkpoint_lsn, but the log_writer thread didn't
86notice it because it has not been active since then (e.g. because there is
87nothing more to write, ie. log.write_lsn == current lsn).
88
89@param[in,out] log redo log */
91
92/** @} */
93
94/**************************************************/ /**
95
96 @name Log - the log write threads.
97
98 *******************************************************/
99
100/** @{ */
101
102/** Pause / resume the log writer, the log flusher, the log write notifier
103and the log flush notifier threads based on innodb_log_writer_threads value.
104@note Calls to this function should be protected externally by some mutex.
105The caller innodb_log_writer_threads_update() is protected
106by LOCK_global_system_variables in mysqld. */
108
109/** The log writer thread routine.
110@param[in,out] log_ptr pointer to redo log */
111void log_writer(log_t *log_ptr);
112
113/** The log flusher thread routine.
114@param[in,out] log_ptr pointer to redo log */
115void log_flusher(log_t *log_ptr);
116
117/** The log flush notifier thread routine.
118@param[in,out] log_ptr pointer to redo log */
119void log_flush_notifier(log_t *log_ptr);
120
121/** The log write notifier thread routine.
122@param[in,out] log_ptr pointer to redo log */
123void log_write_notifier(log_t *log_ptr);
124
125/** Validates that the log writer thread is active.
126Used only to assert, that the state is correct. */
128
129/** Validates that the log writer, flusher threads are active.
130Used only to assert, that the state is correct.
131@param[in] log redo log */
133
134#define log_flusher_mutex_enter(log) mutex_enter(&((log).flusher_mutex))
135
136#define log_flusher_mutex_enter_nowait(log) \
137 mutex_enter_nowait(&((log).flusher_mutex))
138
139#define log_flusher_mutex_exit(log) mutex_exit(&((log).flusher_mutex))
140
141#define log_flusher_mutex_own(log) \
142 (mutex_own(&((log).flusher_mutex)) || !log_flusher_is_active())
143
144#define log_flush_notifier_mutex_enter(log) \
145 mutex_enter(&((log).flush_notifier_mutex))
146
147#define log_flush_notifier_mutex_exit(log) \
148 mutex_exit(&((log).flush_notifier_mutex))
149
150#define log_flush_notifier_mutex_own(log) \
151 (mutex_own(&((log).flush_notifier_mutex)) || !log_flush_notifier_is_active())
152
153#define log_writer_mutex_enter(log) mutex_enter(&((log).writer_mutex))
154
155#define log_writer_mutex_enter_nowait(log) \
156 mutex_enter_nowait(&((log).writer_mutex))
157
158#define log_writer_mutex_exit(log) mutex_exit(&((log).writer_mutex))
159
160#define log_writer_mutex_own(log) \
161 (mutex_own(&((log).writer_mutex)) || !log_writer_is_active())
162
163#define log_write_notifier_mutex_enter(log) \
164 mutex_enter(&((log).write_notifier_mutex))
165
166#define log_write_notifier_mutex_exit(log) \
167 mutex_exit(&((log).write_notifier_mutex))
168
169#define log_write_notifier_mutex_own(log) \
170 (mutex_own(&((log).write_notifier_mutex)) || !log_write_notifier_is_active())
171
172/** Checks if log writer thread is active.
173@return true if and only if the log writer thread is active */
174inline bool log_writer_is_active() {
176}
177
178/** Checks if log write notifier thread is active.
179@return true if and only if the log write notifier thread is active */
182}
183
184/** Checks if log flusher thread is active.
185@return true if and only if the log flusher thread is active */
188}
189
190/** Checks if log flush notifier thread is active.
191@return true if and only if the log flush notifier thread is active */
194}
195
196/** Checks if requests to write redo log buffer to disk are frequent
197(which means that there is at least one request per 1ms in average).
198@param[in] interval how often in average requests happen
199@return true iff requests are considered frequent */
201 std::chrono::microseconds interval) {
202 return interval < std::chrono::milliseconds{1};
203}
204
205/** Checks if requests to write redo log buffer to disk are frequent
206(which means that there is at least one request per 1ms in average).
207@param[in] log redo log
208@return true iff requests are considered frequent */
211 log.write_to_file_requests_interval.load(std::memory_order_relaxed));
212}
213
214/** @} */
215
216#else
217
218#define log_writer_mutex_own(log) true
219
220#endif /* UNIV_HOTBACKUP */
221
222#endif /* !log0write_h */
Redo log - the log_sys.
Redo log basic types.
uint64_t lsn_t
Type used for all log sequence number storage and arithmetic.
Definition: log0types.h:63
bool log_writer_is_active()
Checks if log writer thread is active.
Definition: log0write.h:174
void log_flusher(log_t *log_ptr)
The log flusher thread routine.
Definition: log0write.cc:2494
bool log_flush_notifier_is_active()
Checks if log flush notifier thread is active.
Definition: log0write.h:192
void log_control_writer_threads(log_t &log)
Pause / resume the log writer, the log flusher, the log write notifier and the log flush notifier thr...
Definition: log0log.cc:1101
void log_write_notifier(log_t *log_ptr)
The log write notifier thread routine.
Definition: log0write.cc:2631
bool log_flusher_is_active()
Checks if log flusher thread is active.
Definition: log0write.h:186
void log_writer_thread_active_validate()
Validates that the log writer thread is active.
Definition: log0log.cc:871
uint64_t log_total_flushes()
Total number of redo log flushes (fsyncs) that have been started since the redo log system (log_sys) ...
Definition: log0write.cc:2416
bool log_write_notifier_is_active()
Checks if log write notifier thread is active.
Definition: log0write.h:180
Wait_stats log_write_up_to(log_t &log, lsn_t lsn, bool flush_to_disk)
Waits until the redo log is written up to a provided lsn.
Definition: log0write.cc:1055
void log_background_write_threads_active_validate(const log_t &log)
Validates that the log writer, flusher threads are active.
Definition: log0log.cc:873
void log_writer_check_if_exited_extra_margin(log_t &log)
Checks if the redo log writer exited extra margin.
Definition: log0write.cc:1869
void log_writer(log_t *log_ptr)
The log writer thread routine.
Definition: log0write.cc:2229
void log_flush_notifier(log_t *log_ptr)
The log flush notifier thread routine.
Definition: log0write.cc:2753
uint64_t log_pending_flushes()
Number of currently pending redo log flushes (fsyncs in-progress).
Definition: log0write.cc:2418
bool log_write_to_file_requests_are_frequent(std::chrono::microseconds interval)
Checks if requests to write redo log buffer to disk are frequent (which means that there is at least ...
Definition: log0write.h:200
static int interval
Definition: mysqladmin.cc:71
The server main program.
bool srv_thread_is_active(const IB_thread &thread)
Check if given thread is still active.
Definition: srv0srv.cc:3261
Srv_threads srv_threads
Structure with state of srv background threads.
Definition: srv0srv.cc:104
IB_thread m_log_flush_notifier
Redo flush notifier thread.
Definition: srv0srv.h:188
IB_thread m_log_flusher
Redo flusher thread.
Definition: srv0srv.h:182
IB_thread m_log_write_notifier
Redo write notifier thread.
Definition: srv0srv.h:185
IB_thread m_log_writer
Redo writer thread.
Definition: srv0srv.h:179
Definition: ut0ut.h:347
Redo log - single data structure with state of the redo log system.
Definition: log0sys.h:77
std::atomic< std::chrono::microseconds > write_to_file_requests_interval
How often redo write/flush is requested in average.
Definition: log0sys.h:191
static uint64_t lsn
Definition: xcom_base.cc:446