wal.sgml 15.1 KB
Newer Older
1
<!-- $PostgreSQL: pgsql/doc/src/sgml/wal.sgml,v 1.31 2004/11/15 06:32:14 neilc Exp $ -->
2 3 4 5

<chapter id="wal">
 <title>Write-Ahead Logging (<acronym>WAL</acronym>)</title>

Peter Eisentraut's avatar
Peter Eisentraut committed
6 7 8 9 10 11 12 13 14
 <indexterm zone="wal">
  <primary>WAL</primary>
 </indexterm>

 <indexterm>
  <primary>transaction log</primary>
  <see>WAL</see>
 </indexterm>

15
  <para>
16
   <firstterm>Write-Ahead Logging</firstterm> (<acronym>WAL</acronym>)
17 18 19
   is a standard approach to transaction logging.  Its detailed
   description may be found in most (if not all) books about
   transaction processing. Briefly, <acronym>WAL</acronym>'s central
20
   concept is that changes to data files (where tables and indexes
21
   reside) must be written only after those changes have been logged,
22 23 24 25
   that is, when log records describing the changes have been flushed
   to permanent storage. If we follow this procedure, we do not need
   to flush data pages to disk on every transaction commit, because we
   know that in the event of a crash we will be able to recover the
26
   database using the log: any changes that have not been applied to
27 28
   the data pages can be redone from the log records.  (This is
   roll-forward recovery, also known as REDO.)
29 30
  </para>

31
  <sect1 id="wal-benefits">
32
   <title>Benefits of <acronym>WAL</acronym></title>
33

34
   <indexterm zone="wal-benefits">
Peter Eisentraut's avatar
Peter Eisentraut committed
35 36 37
    <primary>fsync</primary>
   </indexterm>

38
   <para>
39 40
    The first major benefit of using <acronym>WAL</acronym> is a
    significantly reduced number of disk writes, because only the log
41
    file needs to be flushed to disk at the time of transaction
42 43 44
    commit, rather than every data file changed by the transaction.
    In multiuser environments, commits of many transactions
    may be accomplished with a single <function>fsync</function> of
45 46
    the log file. Furthermore, the log file is written sequentially,
    and so the cost of syncing the log is much less than the cost of
47 48 49
    flushing the data pages.   This is especially true for servers
    handling many small transactions touching different parts of the data
    store.
50 51 52 53 54 55 56 57 58 59 60
   </para>

   <para>
    The next benefit is consistency of the data pages. The truth is
    that, before <acronym>WAL</acronym>,
    <productname>PostgreSQL</productname> was never able to guarantee
    consistency in the case of a crash.  Before
    <acronym>WAL</acronym>, any crash during writing could result in:

    <orderedlist>
     <listitem>
61
      <simpara>index rows pointing to nonexistent table rows</simpara>
62 63 64
     </listitem>

     <listitem>
65
      <simpara>index rows lost in split operations</simpara>
66 67 68 69 70 71 72 73
     </listitem>

     <listitem>
      <simpara>totally corrupted table or index page content, because
      of partially written data pages</simpara>
     </listitem>
    </orderedlist>

74
    Problems with indexes (problems 1 and 2) could possibly have been
75
    fixed by additional <function>fsync</function> calls, but it is
76
    not obvious how to handle the last case without
77
    <acronym>WAL</acronym>.  <acronym>WAL</acronym> saves the entire data
78
    page content in the log if that is required to ensure page
79 80
    consistency for after-crash recovery.
   </para>
81 82

   <para>
83 84 85 86 87 88 89
    Finally, <acronym>WAL</acronym> makes it possible to support on-line
    backup and point-in-time recovery, as described in <xref
    linkend="backup-online">.  By archiving the WAL data we can support
    reverting to any time instant covered by the available WAL data:
    we simply install a prior physical backup of the database, and
    replay the WAL log just as far as the desired time.  What's more,
    the physical backup doesn't have to be an instantaneous snapshot
90
    of the database state &mdash; if it is made over some period of time,
91 92
    then replaying the WAL log for that period will fix any internal
    inconsistencies.
93
   </para>
94
  </sect1>
95 96 97 98 99

 <sect1 id="wal-configuration">
  <title><acronym>WAL</acronym> Configuration</title>

  <para>
100
   There are several <acronym>WAL</acronym>-related configuration parameters that
101
   affect database performance. This section explains their use.
102 103
   Consult <xref linkend="runtime-config"> for general information about
   setting server configuration parameters.
104 105 106
  </para>

  <para>
107 108 109 110 111 112 113 114 115 116 117
   <firstterm>Checkpoints</firstterm><indexterm><primary>checkpoint</></>
   are points in the sequence of transactions at which it is guaranteed
   that the data files have been updated with all information logged before
   the checkpoint.  At checkpoint time, all dirty data pages are flushed to
   disk and a special checkpoint record is written to the log file. As a
   result, in the event of a crash, the crash recovery procedure knows from
   what point in the log (known as the redo record) it should start the
   REDO operation, since any changes made to data files before that point
   are already on disk. After a checkpoint has been made, any log segments
   written before the redo record are no longer needed and can be recycled
   or removed. (When <acronym>WAL</acronym> archiving is being done, the
118
   log segments must be archived before being recycled or removed.)
119 120 121
  </para>

  <para>
122 123
   The server's background writer process will automatically perform
   a checkpoint every so often.  A checkpoint is created every <xref
124 125
   linkend="guc-checkpoint-segments"> log segments, or every <xref
   linkend="guc-checkpoint-timeout"> seconds, whichever comes first.
Tom Lane's avatar
Tom Lane committed
126 127
   The default settings are 3 segments and 300 seconds respectively.
   It is also possible to force a checkpoint by using the SQL command
128 129 130
   <command>CHECKPOINT</command>.
  </para>

131
  <para>
132 133
   Reducing <varname>checkpoint_segments</varname> and/or
   <varname>checkpoint_timeout</varname> causes checkpoints to be done
134 135 136 137 138 139
   more often. This allows faster after-crash recovery (since less work
   will need to be redone). However, one must balance this against the
   increased cost of flushing dirty data pages more often. In addition,
   to ensure data page consistency, the first modification of a data
   page after each checkpoint results in logging the entire page
   content. Thus a smaller checkpoint interval increases the volume of
140
   output to the WAL log, partially negating the goal of using a smaller
141
   interval, and in any case causing more disk I/O.
142 143 144
  </para>

  <para>
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160
   Checkpoints are fairly expensive, first because they require writing
   out all currently dirty buffers, and second because they result in
   extra subsequent WAL traffic as discussed above.  It is therefore
   wise to set the checkpointing parameters high enough that checkpoints
   don't happen too often.  As a simple sanity check on your checkpointing
   parameters, you can set the <xref linkend="guc-checkpoint-warning">
   parameter.  If checkpoints happen closer together than
   <varname>checkpoint_warning</> seconds, 
   a message will be output to the server log recommending increasing 
   <varname>checkpoint_segments</varname>.  Occasional appearance of such
   a message is not cause for alarm, but if it appears often then the
   checkpoint control parameters should be increased.
  </para>

  <para>
   There will be at least one WAL segment file, and will normally
161
   not be more than 2 * <varname>checkpoint_segments</varname> + 1
162 163 164
   files.  Each segment file is normally 16 MB (though this size can be
   altered when building the server).  You can use this to estimate space
   requirements for <acronym>WAL</acronym>.
165 166 167 168 169 170
   Ordinarily, when old log segment files are no longer needed, they
   are recycled (renamed to become the next segments in the numbered
   sequence). If, due to a short-term peak of log output rate, there
   are more than 2 * <varname>checkpoint_segments</varname> + 1
   segment files, the unneeded segment files will be deleted instead
   of recycled until the system gets back under this limit.
171 172
  </para>

173 174 175 176 177 178 179 180
  <para>
   There are two commonly used <acronym>WAL</acronym> functions:
   <function>LogInsert</function> and <function>LogFlush</function>.
   <function>LogInsert</function> is used to place a new record into
   the <acronym>WAL</acronym> buffers in shared memory. If there is no
   space for the new record, <function>LogInsert</function> will have
   to write (move to kernel cache) a few filled <acronym>WAL</acronym>
   buffers. This is undesirable because <function>LogInsert</function>
181 182 183 184 185
   is used on every database low level modification (for example, row
   insertion) at a time when an exclusive lock is held on affected
   data pages, so the operation needs to be as fast as possible.  What
   is worse, writing <acronym>WAL</acronym> buffers may also force the
   creation of a new log segment, which takes even more
186 187 188 189 190
   time. Normally, <acronym>WAL</acronym> buffers should be written
   and flushed by a <function>LogFlush</function> request, which is
   made, for the most part, at transaction commit time to ensure that
   transaction records are flushed to permanent storage. On systems
   with high log output, <function>LogFlush</function> requests may
191 192
   not occur often enough to prevent <function>LogInsert</function>
   from having to do writes.  On such systems
193
   one should increase the number of <acronym>WAL</acronym> buffers by
194
   modifying the configuration parameter <xref
195 196 197 198 199
   linkend="guc-wal-buffers">.  The default number of <acronym>WAL</acronym>
   buffers is 8.  Increasing this value will
   correspondingly increase shared memory usage.  (It should be noted
   that there is presently little evidence to suggest that increasing
   <varname>wal_buffers</> beyond the default is worthwhile.)
200 201
  </para>

202
  <para>
203
   The <xref linkend="guc-commit-delay"> parameter defines for how many
204
   microseconds the server process will sleep after writing a commit
205
   record to the log with <function>LogInsert</function> but before
206
   performing a <function>LogFlush</function>. This delay allows other
207
   server processes to add their commit records to the log so as to have all
208
   of them flushed with a single log sync. No sleep will occur if
209 210
   <xref linkend="guc-fsync">
   is not enabled, nor if fewer than <xref linkend="guc-commit-siblings">
211
   other sessions are currently in active transactions; this avoids
212
   sleeping when it's unlikely that any other session will commit soon.
213
   Note that on most platforms, the resolution of a sleep request is
214 215
   ten milliseconds, so that any nonzero <varname>commit_delay</varname>
   setting between 1 and 10000 microseconds would have the same effect.
216 217
   Good values for these parameters are not yet clear; experimentation
   is encouraged.
218
  </para>
219 220

  <para>
221
   The <xref linkend="guc-wal-sync-method"> parameter determines how
222
   <productname>PostgreSQL</productname> will ask the kernel to force
223
    <acronym>WAL</acronym> updates out to disk. 
224 225
   All the options should be the same as far as reliability goes,
   but it's quite platform-specific which one will be the fastest.
226
   Note that this parameter is irrelevant if <varname>fsync</varname>
227 228 229 230
   has been turned off.
  </para>

  <para>
231 232 233 234 235 236
   Enabling the <xref linkend="guc-wal-debug"> configuration parameter
   (provided that <productname>PostgreSQL</productname> has been
   compiled with support for it) will result in each
   <function>LogInsert</function> and <function>LogFlush</function>
   <acronym>WAL</acronym> call being logged to the server log. This
   option may be replaced by a more general mechanism in the future.
237
  </para>
238
 </sect1>
239 240 241 242 243 244

 <sect1 id="wal-internals">
  <title>Internals</title>

  <para>
   <acronym>WAL</acronym> is automatically enabled; no action is
245 246
   required from the administrator except ensuring that the
   disk-space requirements for the <acronym>WAL</acronym> logs are met,
247 248 249 250 251 252 253
   and that any necessary tuning is done (see <xref
   linkend="wal-configuration">).
  </para>

  <para>
   <acronym>WAL</acronym> logs are stored in the directory
   <filename>pg_xlog</filename> under the data directory, as a set of
254 255
   segment files, normally each 16 MB in size.  Each segment is divided into
   pages, normally 8 KB each.  The log record headers are described in
256 257 258
   <filename>access/xlog.h</filename>; the record content is dependent
   on the type of event that is being logged.  Segment files are given
   ever-increasing numbers as names, starting at
259 260
   <filename>000000010000000000000000</filename>.  The numbers do not wrap, at
   present, but it should take a very very long time to exhaust the
261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283
   available stock of numbers.
  </para>

  <para>
   The <acronym>WAL</acronym> buffers and control structure are in
   shared memory and are handled by the server child processes; they
   are protected by lightweight locks.  The demand on shared memory is
   dependent on the number of buffers.  The default size of the
   <acronym>WAL</acronym> buffers is 8 buffers of 8 kB each, or 64 kB
   total.
  </para>

  <para>
   It is of advantage if the log is located on another disk than the
   main database files.  This may be achieved by moving the directory
   <filename>pg_xlog</filename> to another location (while the server
   is shut down, of course) and creating a symbolic link from the
   original location in the main data directory to the new location.
  </para>

  <para>
   The aim of <acronym>WAL</acronym>, to ensure that the log is
   written before database records are altered, may be subverted by
284 285 286
   disk drives<indexterm><primary>disk drive</></> that falsely report a
   successful write to the kernel, 
   when in fact they have only cached the data and not yet stored it
287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306
   on the disk.  A power failure in such a situation may still lead to
   irrecoverable data corruption.  Administrators should try to ensure
   that disks holding <productname>PostgreSQL</productname>'s
   <acronym>WAL</acronym> log files do not make such false reports.
  </para>

  <para>
   After a checkpoint has been made and the log flushed, the
   checkpoint's position is saved in the file
   <filename>pg_control</filename>. Therefore, when recovery is to be
   done, the server first reads <filename>pg_control</filename> and
   then the checkpoint record; then it performs the REDO operation by
   scanning forward from the log position indicated in the checkpoint
   record.  Because the entire content of data pages is saved in the
   log on the first page modification after a checkpoint, all pages
   changed since the checkpoint will be restored to a consistent
   state.
  </para>

  <para>
307 308
   To deal with the case where <filename>pg_control</filename> is
   corrupted, we should support the possibility of scanning existing log
309
   segments in reverse order &mdash; newest to oldest &mdash; in order to find the
310 311 312 313 314 315 316
   latest checkpoint.  This has not been implemented yet.
   <filename>pg_control</filename> is small enough (less than one disk page)
   that it is not subject to partial-write problems, and as of this writing
   there have been no reports of database failures due solely to inability
   to read <filename>pg_control</filename> itself.  So while it is
   theoretically a weak spot, <filename>pg_control</filename> does not
   seem to be a problem in practice.
317 318
  </para>
 </sect1>
319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336
</chapter>

<!-- Keep this comment at the end of the file
Local variables:
mode:sgml
sgml-omittag:nil
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
sgml-parent-document:nil
sgml-default-dtd-file:"./reference.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:("/usr/lib/sgml/catalog")
sgml-local-ecat-files:nil
End:
-->