2010-09-20 22:08:53 +02:00
|
|
|
<!-- doc/src/sgml/wal.sgml -->
|
2001-01-25 00:15:19 +01:00
|
|
|
|
2005-11-05 00:14:02 +01:00
|
|
|
<chapter id="wal">
|
|
|
|
<title>Reliability and the Write-Ahead Log</title>
|
|
|
|
|
|
|
|
<para>
|
2007-08-02 00:45:09 +02:00
|
|
|
This chapter explains how the Write-Ahead Log is used to obtain
|
2005-11-05 00:14:02 +01:00
|
|
|
efficient, reliable operation.
|
|
|
|
</para>
|
|
|
|
|
|
|
|
<sect1 id="wal-reliability">
|
|
|
|
<title>Reliability</title>
|
2001-01-25 00:15:19 +01:00
|
|
|
|
2005-09-28 20:18:02 +02:00
|
|
|
<para>
|
2005-11-05 00:14:02 +01:00
|
|
|
Reliability is an important property of any serious database
|
|
|
|
system, and <productname>PostgreSQL</> does everything possible to
|
|
|
|
guarantee reliable operation. One aspect of reliable operation is
|
|
|
|
that all data recorded by a committed transaction should be stored
|
|
|
|
in a nonvolatile area that is safe from power loss, operating
|
|
|
|
system failure, and hardware failure (except failure of the
|
|
|
|
nonvolatile area itself, of course). Successfully writing the data
|
|
|
|
to the computer's permanent storage (disk drive or equivalent)
|
|
|
|
ordinarily meets this requirement. In fact, even if a computer is
|
|
|
|
fatally damaged, if the disk drives survive they can be moved to
|
|
|
|
another computer with similar hardware and all committed
|
|
|
|
transactions will remain intact.
|
2005-09-28 20:18:02 +02:00
|
|
|
</para>
|
2003-08-31 19:32:24 +02:00
|
|
|
|
2005-09-28 20:18:02 +02:00
|
|
|
<para>
|
2010-12-09 02:01:09 +01:00
|
|
|
While forcing data to the disk platters periodically might seem like
|
2005-09-28 20:18:02 +02:00
|
|
|
a simple operation, it is not. Because disk drives are dramatically
|
|
|
|
slower than main memory and CPUs, several layers of caching exist
|
2005-10-22 23:56:07 +02:00
|
|
|
between the computer's main memory and the disk platters.
|
|
|
|
First, there is the operating system's buffer cache, which caches
|
|
|
|
frequently requested disk blocks and combines disk writes. Fortunately,
|
2005-09-28 20:18:02 +02:00
|
|
|
all operating systems give applications a way to force writes from
|
2005-10-22 23:56:07 +02:00
|
|
|
the buffer cache to disk, and <productname>PostgreSQL</> uses those
|
|
|
|
features. (See the <xref linkend="guc-wal-sync-method"> parameter
|
|
|
|
to adjust how this is done.)
|
2005-09-28 20:18:02 +02:00
|
|
|
</para>
|
2005-10-22 23:56:07 +02:00
|
|
|
|
2005-09-28 20:18:02 +02:00
|
|
|
<para>
|
Update documentation on may/can/might:
Standard English uses "may", "can", and "might" in different ways:
may - permission, "You may borrow my rake."
can - ability, "I can lift that log."
might - possibility, "It might rain today."
Unfortunately, in conversational English, their use is often mixed, as
in, "You may use this variable to do X", when in fact, "can" is a better
choice. Similarly, "It may crash" is better stated, "It might crash".
Also update two error messages mentioned in the documenation to match.
2007-01-31 21:56:20 +01:00
|
|
|
Next, there might be a cache in the disk drive controller; this is
|
2005-10-22 23:56:07 +02:00
|
|
|
particularly common on <acronym>RAID</> controller cards. Some of
|
2010-02-03 18:25:06 +01:00
|
|
|
these caches are <firstterm>write-through</>, meaning writes are sent
|
|
|
|
to the drive as soon as they arrive. Others are
|
|
|
|
<firstterm>write-back</>, meaning data is sent to the drive at
|
2005-10-22 23:56:07 +02:00
|
|
|
some later time. Such caches can be a reliability hazard because the
|
|
|
|
memory in the disk controller cache is volatile, and will lose its
|
|
|
|
contents in a power failure. Better controller cards have
|
2010-12-09 02:01:09 +01:00
|
|
|
<firstterm>battery-backup units</> (<acronym>BBU</>s), meaning
|
2010-07-07 16:42:09 +02:00
|
|
|
the card has a battery that
|
2005-10-22 23:56:07 +02:00
|
|
|
maintains power to the cache in case of system power loss. After power
|
|
|
|
is restored the data will be written to the disk drives.
|
2005-09-28 20:18:02 +02:00
|
|
|
</para>
|
2003-08-31 19:32:24 +02:00
|
|
|
|
2001-01-25 00:15:19 +01:00
|
|
|
<para>
|
2005-09-28 20:18:02 +02:00
|
|
|
And finally, most disk drives have caches. Some are write-through
|
2010-07-07 16:42:09 +02:00
|
|
|
while some are write-back, and the same concerns about data loss
|
2010-12-09 02:01:09 +01:00
|
|
|
exist for write-back drive caches as for disk controller
|
2010-07-07 16:42:09 +02:00
|
|
|
caches. Consumer-grade IDE and SATA drives are particularly likely
|
2010-12-09 02:01:09 +01:00
|
|
|
to have write-back caches that will not survive a power failure. Many
|
|
|
|
solid-state drives (SSD) also have volatile write-back caches.
|
2010-07-07 16:42:09 +02:00
|
|
|
</para>
|
|
|
|
|
|
|
|
<para>
|
2010-10-28 03:19:11 +02:00
|
|
|
These caches can typically be disabled; however, the method for doing
|
|
|
|
this varies by operating system and drive type:
|
2005-10-22 23:56:07 +02:00
|
|
|
</para>
|
|
|
|
|
2010-10-28 03:19:11 +02:00
|
|
|
<itemizedlist>
|
|
|
|
<listitem>
|
|
|
|
<para>
|
2013-04-20 21:56:22 +02:00
|
|
|
On <productname>Linux</>, IDE and SATA drives can be queried using
|
2010-10-28 03:19:11 +02:00
|
|
|
<command>hdparm -I</command>; write caching is enabled if there is
|
2012-02-14 23:41:57 +01:00
|
|
|
a <literal>*</> next to <literal>Write cache</>. <command>hdparm -W 0</>
|
2010-10-28 03:19:11 +02:00
|
|
|
can be used to turn off write caching. SCSI drives can be queried
|
|
|
|
using <ulink url="http://sg.danny.cz/sg/sdparm.html"><application>sdparm</></ulink>.
|
2010-12-09 02:01:09 +01:00
|
|
|
Use <command>sdparm --get=WCE</command> to check
|
2010-10-28 03:19:11 +02:00
|
|
|
whether the write cache is enabled and <command>sdparm --clear=WCE</>
|
|
|
|
to disable it.
|
|
|
|
</para>
|
|
|
|
</listitem>
|
|
|
|
|
|
|
|
<listitem>
|
|
|
|
<para>
|
|
|
|
On <productname>FreeBSD</>, IDE drives can be queried using
|
2011-03-11 17:36:42 +01:00
|
|
|
<command>atacontrol</command> and write caching turned off using
|
|
|
|
<literal>hw.ata.wc=0</> in <filename>/boot/loader.conf</>;
|
2011-10-10 19:21:35 +02:00
|
|
|
SCSI drives can be queried using <command>camcontrol identify</command>,
|
|
|
|
and the write cache both queried and changed using
|
|
|
|
<command>sdparm</command> when available.
|
2010-10-28 03:19:11 +02:00
|
|
|
</para>
|
|
|
|
</listitem>
|
|
|
|
|
|
|
|
<listitem>
|
2010-10-28 16:40:27 +02:00
|
|
|
<para>
|
2010-10-28 03:19:11 +02:00
|
|
|
On <productname>Solaris</>, the disk write cache is controlled by
|
2012-09-02 15:16:26 +02:00
|
|
|
<command>format -e</>.
|
2010-10-28 03:19:11 +02:00
|
|
|
(The Solaris <acronym>ZFS</> file system is safe with disk write-cache
|
|
|
|
enabled because it issues its own disk cache flush commands.)
|
|
|
|
</para>
|
|
|
|
</listitem>
|
|
|
|
|
|
|
|
<listitem>
|
|
|
|
<para>
|
|
|
|
On <productname>Windows</>, if <varname>wal_sync_method</> is
|
2010-12-09 02:01:09 +01:00
|
|
|
<literal>open_datasync</> (the default), write caching can be disabled
|
|
|
|
by unchecking <literal>My Computer\Open\<replaceable>disk drive</>\Properties\Hardware\Properties\Policies\Enable write caching on the disk</>.
|
|
|
|
Alternatively, set <varname>wal_sync_method</varname> to
|
|
|
|
<literal>fsync</> or <literal>fsync_writethrough</>, which prevent
|
|
|
|
write caching.
|
2010-10-28 03:19:11 +02:00
|
|
|
</para>
|
|
|
|
</listitem>
|
|
|
|
|
|
|
|
<listitem>
|
|
|
|
<para>
|
Refer to OS X as "macOS", except for the port name which is still "darwin".
We weren't terribly consistent about whether to call Apple's OS "OS X"
or "Mac OS X", and the former is probably confusing to people who aren't
Apple users. Now that Apple has rebranded it "macOS", follow their lead
to establish a consistent naming pattern. Also, avoid the use of the
ancient project name "Darwin", except as the port code name which does not
seem desirable to change. (In short, this patch touches documentation and
comments, but no actual code.)
I didn't touch contrib/start-scripts/osx/, either. I suspect those are
obsolete and due for a rewrite, anyway.
I dithered about whether to apply this edit to old release notes, but
those were responsible for quite a lot of the inconsistencies, so I ended
up changing them too. Anyway, Apple's being ahistorical about this,
so why shouldn't we be?
2016-09-25 21:40:57 +02:00
|
|
|
On <productname>macOS</productname>, write caching can be prevented by
|
2010-10-28 03:19:11 +02:00
|
|
|
setting <varname>wal_sync_method</> to <literal>fsync_writethrough</>.
|
|
|
|
</para>
|
|
|
|
</listitem>
|
|
|
|
</itemizedlist>
|
|
|
|
|
2010-07-07 16:42:09 +02:00
|
|
|
<para>
|
2010-12-09 02:01:09 +01:00
|
|
|
Recent SATA drives (those following <acronym>ATAPI-6</> or later)
|
|
|
|
offer a drive cache flush command (<command>FLUSH CACHE EXT</>),
|
|
|
|
while SCSI drives have long supported a similar command
|
|
|
|
<command>SYNCHRONIZE CACHE</>. These commands are not directly
|
|
|
|
accessible to <productname>PostgreSQL</>, but some file systems
|
|
|
|
(e.g., <acronym>ZFS</>, <acronym>ext4</>) can use them to flush
|
|
|
|
data to the platters on write-back-enabled drives. Unfortunately, such
|
|
|
|
file systems behave suboptimally when combined with battery-backup unit
|
2010-07-07 16:42:09 +02:00
|
|
|
(<acronym>BBU</>) disk controllers. In such setups, the synchronize
|
2010-12-09 02:01:09 +01:00
|
|
|
command forces all data from the controller cache to the disks,
|
2011-01-26 15:22:21 +01:00
|
|
|
eliminating much of the benefit of the BBU. You can run the
|
2013-03-15 22:41:47 +01:00
|
|
|
<xref linkend="pgtestfsync"> program to see
|
2010-07-08 18:44:12 +02:00
|
|
|
if you are affected. If you are affected, the performance benefits
|
2010-12-09 02:01:09 +01:00
|
|
|
of the BBU can be regained by turning off write barriers in
|
2010-07-07 16:42:09 +02:00
|
|
|
the file system or reconfiguring the disk controller, if that is
|
|
|
|
an option. If write barriers are turned off, make sure the battery
|
2010-12-09 02:01:09 +01:00
|
|
|
remains functional; a faulty battery can potentially lead to data loss.
|
2010-07-07 16:42:09 +02:00
|
|
|
Hopefully file system and disk controller designers will eventually
|
|
|
|
address this suboptimal behavior.
|
|
|
|
</para>
|
|
|
|
|
2005-10-22 23:56:07 +02:00
|
|
|
<para>
|
2010-02-03 18:25:06 +01:00
|
|
|
When the operating system sends a write request to the storage hardware,
|
2005-10-22 23:56:07 +02:00
|
|
|
there is little it can do to make sure the data has arrived at a truly
|
|
|
|
non-volatile storage area. Rather, it is the
|
2010-02-03 18:25:06 +01:00
|
|
|
administrator's responsibility to make certain that all storage components
|
2013-05-21 03:13:13 +02:00
|
|
|
ensure integrity for both data and file-system metadata.
|
2013-03-19 09:57:29 +01:00
|
|
|
Avoid disk controllers that have non-battery-backed write caches.
|
|
|
|
At the drive level, disable write-back caching if the
|
2005-10-22 23:56:07 +02:00
|
|
|
drive cannot guarantee the data will be written before shutdown.
|
2010-12-09 02:01:09 +01:00
|
|
|
If you use SSDs, be aware that many of these do not honor cache flush
|
|
|
|
commands by default.
|
2012-07-30 16:15:57 +02:00
|
|
|
You can test for reliable I/O subsystem behavior using <ulink
|
|
|
|
url="http://brad.livejournal.com/2116715.html"><filename>diskchecker.pl</filename></ulink>.
|
2005-09-28 20:18:02 +02:00
|
|
|
</para>
|
2007-08-02 00:45:09 +02:00
|
|
|
|
2005-09-28 20:18:02 +02:00
|
|
|
<para>
|
2005-10-22 23:56:07 +02:00
|
|
|
Another risk of data loss is posed by the disk platter write
|
|
|
|
operations themselves. Disk platters are divided into sectors,
|
|
|
|
commonly 512 bytes each. Every physical read or write operation
|
|
|
|
processes a whole sector.
|
2010-12-09 02:01:09 +01:00
|
|
|
When a write request arrives at the drive, it might be for some multiple
|
|
|
|
of 512 bytes (<productname>PostgreSQL</> typically writes 8192 bytes, or
|
|
|
|
16 sectors, at a time), and the process of writing could fail due
|
2005-09-28 20:18:02 +02:00
|
|
|
to power loss at any time, meaning some of the 512-byte sectors were
|
2010-12-09 02:01:09 +01:00
|
|
|
written while others were not. To guard against such failures,
|
2005-09-28 20:18:02 +02:00
|
|
|
<productname>PostgreSQL</> periodically writes full page images to
|
2010-02-03 18:25:06 +01:00
|
|
|
permanent WAL storage <emphasis>before</> modifying the actual page on
|
2005-10-13 19:32:42 +02:00
|
|
|
disk. By doing this, during crash recovery <productname>PostgreSQL</> can
|
2010-12-23 03:12:00 +01:00
|
|
|
restore partially-written pages from WAL. If you have file-system software
|
|
|
|
that prevents partial page writes (e.g., ZFS), you can turn off
|
|
|
|
this page imaging by turning off the <xref
|
|
|
|
linkend="guc-full-page-writes"> parameter. Battery-Backed Unit
|
|
|
|
(BBU) disk controllers do not prevent partial page writes unless
|
|
|
|
they guarantee that data is written to the BBU as full (8kB) pages.
|
2005-09-28 20:18:02 +02:00
|
|
|
</para>
|
2013-03-18 23:38:07 +01:00
|
|
|
<para>
|
|
|
|
<productname>PostgreSQL</> also protects against some kinds of data corruption
|
|
|
|
on storage devices that may occur because of hardware errors or media failure over time,
|
|
|
|
such as reading/writing garbage data.
|
|
|
|
<itemizedlist>
|
|
|
|
<listitem>
|
|
|
|
<para>
|
|
|
|
Each individual record in a WAL file is protected by a CRC-32 (32-bit) check
|
|
|
|
that allows us to tell if record contents are correct. The CRC value
|
|
|
|
is set when we write each WAL record and checked during crash recovery,
|
|
|
|
archive recovery and replication.
|
|
|
|
</para>
|
|
|
|
</listitem>
|
|
|
|
<listitem>
|
|
|
|
<para>
|
2014-02-01 01:04:37 +01:00
|
|
|
Data pages are not currently checksummed by default, though full page images
|
2014-12-01 12:12:07 +01:00
|
|
|
recorded in WAL records will be protected; see <link
|
2014-02-01 01:04:37 +01:00
|
|
|
linkend="app-initdb-data-checksums"><application>initdb</></link>
|
|
|
|
for details about enabling data page checksums.
|
2013-03-18 23:38:07 +01:00
|
|
|
</para>
|
|
|
|
</listitem>
|
|
|
|
<listitem>
|
|
|
|
<para>
|
2017-03-17 14:46:58 +01:00
|
|
|
Internal data structures such as <filename>pg_xact</filename>, <filename>pg_subtrans</filename>, <filename>pg_multixact</filename>,
|
2013-05-21 03:13:13 +02:00
|
|
|
<filename>pg_serial</filename>, <filename>pg_notify</filename>, <filename>pg_stat</filename>, <filename>pg_snapshots</filename> are not directly
|
2013-03-18 23:38:07 +01:00
|
|
|
checksummed, nor are pages protected by full page writes. However, where
|
|
|
|
such data structures are persistent, WAL records are written that allow
|
|
|
|
recent changes to be accurately rebuilt at crash recovery and those
|
|
|
|
WAL records are protected as discussed above.
|
|
|
|
</para>
|
|
|
|
</listitem>
|
2013-03-19 09:51:35 +01:00
|
|
|
<listitem>
|
|
|
|
<para>
|
2013-05-21 03:13:13 +02:00
|
|
|
Individual state files in <filename>pg_twophase</filename> are protected by CRC-32.
|
2013-03-19 09:51:35 +01:00
|
|
|
</para>
|
|
|
|
</listitem>
|
2013-03-18 23:38:07 +01:00
|
|
|
<listitem>
|
|
|
|
<para>
|
|
|
|
Temporary data files used in larger SQL queries for sorts,
|
|
|
|
materializations and intermediate results are not currently checksummed,
|
|
|
|
nor will WAL records be written for changes to those files.
|
|
|
|
</para>
|
|
|
|
</listitem>
|
|
|
|
</itemizedlist>
|
|
|
|
</para>
|
|
|
|
<para>
|
|
|
|
<productname>PostgreSQL</> does not protect against correctable memory errors
|
|
|
|
and it is assumed you will operate using RAM that uses industry standard
|
|
|
|
Error Correcting Codes (ECC) or better protection.
|
|
|
|
</para>
|
2005-11-05 00:14:02 +01:00
|
|
|
</sect1>
|
2007-08-02 00:45:09 +02:00
|
|
|
|
2005-11-05 00:14:02 +01:00
|
|
|
<sect1 id="wal-intro">
|
2005-09-28 20:18:02 +02:00
|
|
|
<title>Write-Ahead Logging (<acronym>WAL</acronym>)</title>
|
|
|
|
|
|
|
|
<indexterm zone="wal">
|
|
|
|
<primary>WAL</primary>
|
|
|
|
</indexterm>
|
|
|
|
|
|
|
|
<indexterm>
|
|
|
|
<primary>transaction log</primary>
|
|
|
|
<see>WAL</see>
|
|
|
|
</indexterm>
|
|
|
|
|
|
|
|
<para>
|
|
|
|
<firstterm>Write-Ahead Logging</firstterm> (<acronym>WAL</acronym>)
|
2007-08-02 00:45:09 +02:00
|
|
|
is a standard method for ensuring data integrity. A detailed
|
Update documentation on may/can/might:
Standard English uses "may", "can", and "might" in different ways:
may - permission, "You may borrow my rake."
can - ability, "I can lift that log."
might - possibility, "It might rain today."
Unfortunately, in conversational English, their use is often mixed, as
in, "You may use this variable to do X", when in fact, "can" is a better
choice. Similarly, "It may crash" is better stated, "It might crash".
Also update two error messages mentioned in the documenation to match.
2007-01-31 21:56:20 +01:00
|
|
|
description can be found in most (if not all) books about
|
2005-09-28 20:18:02 +02:00
|
|
|
transaction processing. Briefly, <acronym>WAL</acronym>'s central
|
|
|
|
concept is that changes to data files (where tables and indexes
|
|
|
|
reside) must be written only after those changes have been logged,
|
2007-08-02 00:45:09 +02:00
|
|
|
that is, after log records describing the changes have been flushed
|
2005-09-28 20:18:02 +02:00
|
|
|
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
|
|
|
|
database using the log: any changes that have not been applied to
|
|
|
|
the data pages can be redone from the log records. (This is
|
|
|
|
roll-forward recovery, also known as REDO.)
|
|
|
|
</para>
|
2001-01-25 00:15:19 +01:00
|
|
|
|
2008-12-06 22:34:27 +01:00
|
|
|
<tip>
|
|
|
|
<para>
|
|
|
|
Because <acronym>WAL</acronym> restores database file
|
2010-02-03 18:25:06 +01:00
|
|
|
contents after a crash, journaled file systems are not necessary for
|
2008-12-18 23:21:16 +01:00
|
|
|
reliable storage of the data files or WAL files. In fact, journaling
|
2008-12-10 12:05:49 +01:00
|
|
|
overhead can reduce performance, especially if journaling
|
|
|
|
causes file system <emphasis>data</emphasis> to be flushed
|
|
|
|
to disk. Fortunately, data flushing during journaling can
|
2010-02-03 18:25:06 +01:00
|
|
|
often be disabled with a file system mount option, e.g.
|
2008-12-10 12:05:49 +01:00
|
|
|
<literal>data=writeback</> on a Linux ext3 file system.
|
|
|
|
Journaled file systems do improve boot speed after a crash.
|
2008-12-06 22:34:27 +01:00
|
|
|
</para>
|
|
|
|
</tip>
|
|
|
|
|
|
|
|
|
2005-10-13 19:32:42 +02:00
|
|
|
<para>
|
2007-08-02 00:45:09 +02:00
|
|
|
Using <acronym>WAL</acronym> results in a
|
2004-08-08 06:34:43 +02:00
|
|
|
significantly reduced number of disk writes, because only the log
|
2007-08-02 00:45:09 +02:00
|
|
|
file needs to be flushed to disk to guarantee that a transaction is
|
|
|
|
committed, rather than every data file changed by the transaction.
|
|
|
|
The log file is written sequentially,
|
2001-01-25 00:15:19 +01:00
|
|
|
and so the cost of syncing the log is much less than the cost of
|
2007-08-02 00:45:09 +02:00
|
|
|
flushing the data pages. This is especially true for servers
|
2004-08-08 06:34:43 +02:00
|
|
|
handling many small transactions touching different parts of the data
|
2007-08-02 00:45:09 +02:00
|
|
|
store. Furthermore, when the server is processing many small concurrent
|
|
|
|
transactions, one <function>fsync</function> of the log file may
|
|
|
|
suffice to commit many transactions.
|
2001-01-25 00:15:19 +01:00
|
|
|
</para>
|
|
|
|
|
|
|
|
<para>
|
2005-10-22 23:56:07 +02:00
|
|
|
<acronym>WAL</acronym> also makes it possible to support on-line
|
2004-08-08 06:34:43 +02:00
|
|
|
backup and point-in-time recovery, as described in <xref
|
2006-03-03 23:02:08 +01:00
|
|
|
linkend="continuous-archiving">. By archiving the WAL data we can support
|
2004-08-08 06:34:43 +02:00
|
|
|
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
|
2004-11-15 07:32:15 +01:00
|
|
|
of the database state — if it is made over some period of time,
|
2004-08-08 06:34:43 +02:00
|
|
|
then replaying the WAL log for that period will fix any internal
|
|
|
|
inconsistencies.
|
2001-10-27 01:10:21 +02:00
|
|
|
</para>
|
2003-03-24 15:32:51 +01:00
|
|
|
</sect1>
|
2001-01-25 00:15:19 +01:00
|
|
|
|
2007-08-02 00:45:09 +02:00
|
|
|
<sect1 id="wal-async-commit">
|
|
|
|
<title>Asynchronous Commit</title>
|
|
|
|
|
|
|
|
<indexterm>
|
|
|
|
<primary>synchronous commit</primary>
|
|
|
|
</indexterm>
|
|
|
|
|
|
|
|
<indexterm>
|
|
|
|
<primary>asynchronous commit</primary>
|
|
|
|
</indexterm>
|
|
|
|
|
|
|
|
<para>
|
|
|
|
<firstterm>Asynchronous commit</> is an option that allows transactions
|
|
|
|
to complete more quickly, at the cost that the most recent transactions may
|
|
|
|
be lost if the database should crash. In many applications this is an
|
2007-11-28 16:42:31 +01:00
|
|
|
acceptable trade-off.
|
2007-08-02 00:45:09 +02:00
|
|
|
</para>
|
|
|
|
|
|
|
|
<para>
|
|
|
|
As described in the previous section, transaction commit is normally
|
|
|
|
<firstterm>synchronous</>: the server waits for the transaction's
|
|
|
|
<acronym>WAL</acronym> records to be flushed to permanent storage
|
|
|
|
before returning a success indication to the client. The client is
|
|
|
|
therefore guaranteed that a transaction reported to be committed will
|
|
|
|
be preserved, even in the event of a server crash immediately after.
|
|
|
|
However, for short transactions this delay is a major component of the
|
|
|
|
total transaction time. Selecting asynchronous commit mode means that
|
|
|
|
the server returns success as soon as the transaction is logically
|
|
|
|
completed, before the <acronym>WAL</acronym> records it generated have
|
|
|
|
actually made their way to disk. This can provide a significant boost
|
|
|
|
in throughput for small transactions.
|
|
|
|
</para>
|
|
|
|
|
|
|
|
<para>
|
|
|
|
Asynchronous commit introduces the risk of data loss. There is a short
|
|
|
|
time window between the report of transaction completion to the client
|
|
|
|
and the time that the transaction is truly committed (that is, it is
|
|
|
|
guaranteed not to be lost if the server crashes). Thus asynchronous
|
|
|
|
commit should not be used if the client will take external actions
|
|
|
|
relying on the assumption that the transaction will be remembered.
|
|
|
|
As an example, a bank would certainly not use asynchronous commit for
|
|
|
|
a transaction recording an ATM's dispensing of cash. But in many
|
|
|
|
scenarios, such as event logging, there is no need for a strong
|
|
|
|
guarantee of this kind.
|
|
|
|
</para>
|
|
|
|
|
|
|
|
<para>
|
|
|
|
The risk that is taken by using asynchronous commit is of data loss,
|
|
|
|
not data corruption. If the database should crash, it will recover
|
|
|
|
by replaying <acronym>WAL</acronym> up to the last record that was
|
|
|
|
flushed. The database will therefore be restored to a self-consistent
|
|
|
|
state, but any transactions that were not yet flushed to disk will
|
|
|
|
not be reflected in that state. The net effect is therefore loss of
|
|
|
|
the last few transactions. Because the transactions are replayed in
|
|
|
|
commit order, no inconsistency can be introduced — for example,
|
|
|
|
if transaction B made changes relying on the effects of a previous
|
|
|
|
transaction A, it is not possible for A's effects to be lost while B's
|
|
|
|
effects are preserved.
|
|
|
|
</para>
|
|
|
|
|
|
|
|
<para>
|
|
|
|
The user can select the commit mode of each transaction, so that
|
|
|
|
it is possible to have both synchronous and asynchronous commit
|
2007-11-28 16:42:31 +01:00
|
|
|
transactions running concurrently. This allows flexible trade-offs
|
2007-08-02 00:45:09 +02:00
|
|
|
between performance and certainty of transaction durability.
|
|
|
|
The commit mode is controlled by the user-settable parameter
|
|
|
|
<xref linkend="guc-synchronous-commit">, which can be changed in any of
|
|
|
|
the ways that a configuration parameter can be set. The mode used for
|
|
|
|
any one transaction depends on the value of
|
|
|
|
<varname>synchronous_commit</varname> when transaction commit begins.
|
|
|
|
</para>
|
|
|
|
|
|
|
|
<para>
|
|
|
|
Certain utility commands, for instance <command>DROP TABLE</>, are
|
|
|
|
forced to commit synchronously regardless of the setting of
|
|
|
|
<varname>synchronous_commit</varname>. This is to ensure consistency
|
2007-11-28 16:42:31 +01:00
|
|
|
between the server's file system and the logical state of the database.
|
2007-08-02 00:45:09 +02:00
|
|
|
The commands supporting two-phase commit, such as <command>PREPARE
|
|
|
|
TRANSACTION</>, are also always synchronous.
|
|
|
|
</para>
|
|
|
|
|
|
|
|
<para>
|
|
|
|
If the database crashes during the risk window between an
|
|
|
|
asynchronous commit and the writing of the transaction's
|
|
|
|
<acronym>WAL</acronym> records,
|
|
|
|
then changes made during that transaction <emphasis>will</> be lost.
|
|
|
|
The duration of the
|
2007-11-28 16:42:31 +01:00
|
|
|
risk window is limited because a background process (the <quote>WAL
|
2007-08-02 00:45:09 +02:00
|
|
|
writer</>) flushes unwritten <acronym>WAL</acronym> records to disk
|
|
|
|
every <xref linkend="guc-wal-writer-delay"> milliseconds.
|
|
|
|
The actual maximum duration of the risk window is three times
|
2007-11-28 16:42:31 +01:00
|
|
|
<varname>wal_writer_delay</varname> because the WAL writer is
|
2007-08-02 00:45:09 +02:00
|
|
|
designed to favor writing whole pages at a time during busy periods.
|
|
|
|
</para>
|
|
|
|
|
|
|
|
<caution>
|
|
|
|
<para>
|
|
|
|
An immediate-mode shutdown is equivalent to a server crash, and will
|
|
|
|
therefore cause loss of any unflushed asynchronous commits.
|
|
|
|
</para>
|
|
|
|
</caution>
|
|
|
|
|
|
|
|
<para>
|
|
|
|
Asynchronous commit provides behavior different from setting
|
|
|
|
<xref linkend="guc-fsync"> = off.
|
|
|
|
<varname>fsync</varname> is a server-wide
|
|
|
|
setting that will alter the behavior of all transactions. It disables
|
|
|
|
all logic within <productname>PostgreSQL</> that attempts to synchronize
|
|
|
|
writes to different portions of the database, and therefore a system
|
|
|
|
crash (that is, a hardware or operating system crash, not a failure of
|
|
|
|
<productname>PostgreSQL</> itself) could result in arbitrarily bad
|
|
|
|
corruption of the database state. In many scenarios, asynchronous
|
|
|
|
commit provides most of the performance improvement that could be
|
|
|
|
obtained by turning off <varname>fsync</varname>, but without the risk
|
|
|
|
of data corruption.
|
|
|
|
</para>
|
|
|
|
|
|
|
|
<para>
|
|
|
|
<xref linkend="guc-commit-delay"> also sounds very similar to
|
|
|
|
asynchronous commit, but it is actually a synchronous commit method
|
|
|
|
(in fact, <varname>commit_delay</varname> is ignored during an
|
|
|
|
asynchronous commit). <varname>commit_delay</varname> causes a delay
|
2013-03-15 22:41:47 +01:00
|
|
|
just before a transaction flushes <acronym>WAL</acronym> to disk, in
|
|
|
|
the hope that a single flush executed by one such transaction can also
|
|
|
|
serve other transactions committing at about the same time. The
|
|
|
|
setting can be thought of as a way of increasing the time window in
|
|
|
|
which transactions can join a group about to participate in a single
|
|
|
|
flush, to amortize the cost of the flush among multiple transactions.
|
2007-08-02 00:45:09 +02:00
|
|
|
</para>
|
|
|
|
|
|
|
|
</sect1>
|
|
|
|
|
2001-01-25 00:15:19 +01:00
|
|
|
<sect1 id="wal-configuration">
|
|
|
|
<title><acronym>WAL</acronym> Configuration</title>
|
|
|
|
|
|
|
|
<para>
|
2005-10-22 23:56:07 +02:00
|
|
|
There are several <acronym>WAL</>-related configuration parameters that
|
2001-01-25 00:15:19 +01:00
|
|
|
affect database performance. This section explains their use.
|
2004-08-08 06:34:43 +02:00
|
|
|
Consult <xref linkend="runtime-config"> for general information about
|
|
|
|
setting server configuration parameters.
|
2001-01-25 00:15:19 +01:00
|
|
|
</para>
|
|
|
|
|
|
|
|
<para>
|
2004-11-15 05:35:57 +01:00
|
|
|
<firstterm>Checkpoints</firstterm><indexterm><primary>checkpoint</></>
|
|
|
|
are points in the sequence of transactions at which it is guaranteed
|
2013-03-15 22:41:47 +01:00
|
|
|
that the heap and index data files have been updated with all
|
|
|
|
information written before that checkpoint. At checkpoint time, all
|
|
|
|
dirty data pages are flushed to disk and a special checkpoint record is
|
|
|
|
written to the log file. (The change records were previously flushed
|
|
|
|
to the <acronym>WAL</acronym> files.)
|
2005-10-22 23:56:07 +02:00
|
|
|
In the event of a crash, the crash recovery procedure looks at the latest
|
|
|
|
checkpoint record to determine the point in the log (known as the redo
|
|
|
|
record) from which it should start the REDO operation. Any changes made to
|
2013-03-15 22:41:47 +01:00
|
|
|
data files before that point are guaranteed to be already on disk.
|
|
|
|
Hence, after a checkpoint, log segments preceding the one containing
|
2005-10-22 23:56:07 +02:00
|
|
|
the redo record are no longer needed and can be recycled or removed. (When
|
|
|
|
<acronym>WAL</acronym> archiving is being done, the log segments must be
|
|
|
|
archived before being recycled or removed.)
|
2001-01-25 00:15:19 +01:00
|
|
|
</para>
|
|
|
|
|
2009-04-09 18:20:50 +02:00
|
|
|
<para>
|
|
|
|
The checkpoint requirement of flushing all dirty data pages to disk
|
|
|
|
can cause a significant I/O load. For this reason, checkpoint
|
2013-03-15 22:41:47 +01:00
|
|
|
activity is throttled so that I/O begins at checkpoint start and completes
|
|
|
|
before the next checkpoint is due to start; this minimizes performance
|
2009-04-09 18:20:50 +02:00
|
|
|
degradation during checkpoints.
|
|
|
|
</para>
|
|
|
|
|
2001-01-25 00:15:19 +01:00
|
|
|
<para>
|
2012-01-26 18:08:20 +01:00
|
|
|
The server's checkpointer process automatically performs
|
2013-03-15 22:41:47 +01:00
|
|
|
a checkpoint every so often. A checkpoint is begun every <xref
|
2015-02-23 17:53:02 +01:00
|
|
|
linkend="guc-checkpoint-timeout"> seconds, or if
|
|
|
|
<xref linkend="guc-max-wal-size"> is about to be exceeded,
|
|
|
|
whichever comes first.
|
2016-08-05 20:35:09 +02:00
|
|
|
The default settings are 5 minutes and 1 GB, respectively.
|
2013-03-15 22:41:47 +01:00
|
|
|
If no WAL has been written since the previous checkpoint, new checkpoints
|
|
|
|
will be skipped even if <varname>checkpoint_timeout</> has passed.
|
|
|
|
(If WAL archiving is being used and you want to put a lower limit on how
|
|
|
|
often files are archived in order to bound potential data loss, you should
|
|
|
|
adjust the <xref linkend="guc-archive-timeout"> parameter rather than the
|
|
|
|
checkpoint parameters.)
|
|
|
|
It is also possible to force a checkpoint by using the SQL
|
2011-11-03 09:52:20 +01:00
|
|
|
command <command>CHECKPOINT</command>.
|
2001-01-25 00:15:19 +01:00
|
|
|
</para>
|
|
|
|
|
2001-10-27 01:10:21 +02:00
|
|
|
<para>
|
2015-02-23 17:53:02 +01:00
|
|
|
Reducing <varname>checkpoint_timeout</varname> and/or
|
|
|
|
<varname>max_wal_size</varname> causes checkpoints to occur
|
2013-03-15 22:41:47 +01:00
|
|
|
more often. This allows faster after-crash recovery, since less work
|
|
|
|
will need to be redone. However, one must balance this against the
|
2007-08-02 00:45:09 +02:00
|
|
|
increased cost of flushing dirty data pages more often. If
|
|
|
|
<xref linkend="guc-full-page-writes"> is set (as is the default), there is
|
|
|
|
another factor to consider. To ensure data page consistency,
|
|
|
|
the first modification of a data page after each checkpoint results in
|
2005-10-13 19:32:42 +02:00
|
|
|
logging the entire page content. In that case,
|
|
|
|
a smaller checkpoint interval increases the volume of output to the WAL log,
|
2007-08-02 00:45:09 +02:00
|
|
|
partially negating the goal of using a smaller interval,
|
2005-10-13 19:32:42 +02:00
|
|
|
and in any case causing more disk I/O.
|
2001-10-27 01:10:21 +02:00
|
|
|
</para>
|
|
|
|
|
|
|
|
<para>
|
2004-08-08 06:34:43 +02:00
|
|
|
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
|
2013-03-15 22:41:47 +01:00
|
|
|
wise to set the checkpointing parameters high enough so that checkpoints
|
2004-08-08 06:34:43 +02:00
|
|
|
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
|
2007-08-02 00:45:09 +02:00
|
|
|
<varname>checkpoint_warning</> seconds,
|
|
|
|
a message will be output to the server log recommending increasing
|
2015-02-23 17:53:02 +01:00
|
|
|
<varname>max_wal_size</varname>. Occasional appearance of such
|
2004-08-08 06:34:43 +02:00
|
|
|
a message is not cause for alarm, but if it appears often then the
|
2005-10-13 19:32:42 +02:00
|
|
|
checkpoint control parameters should be increased. Bulk operations such
|
Update documentation on may/can/might:
Standard English uses "may", "can", and "might" in different ways:
may - permission, "You may borrow my rake."
can - ability, "I can lift that log."
might - possibility, "It might rain today."
Unfortunately, in conversational English, their use is often mixed, as
in, "You may use this variable to do X", when in fact, "can" is a better
choice. Similarly, "It may crash" is better stated, "It might crash".
Also update two error messages mentioned in the documenation to match.
2007-01-31 21:56:20 +01:00
|
|
|
as large <command>COPY</> transfers might cause a number of such warnings
|
2015-02-23 17:53:02 +01:00
|
|
|
to appear if you have not set <varname>max_wal_size</> high
|
2005-10-22 23:56:07 +02:00
|
|
|
enough.
|
2004-08-08 06:34:43 +02:00
|
|
|
</para>
|
|
|
|
|
|
|
|
<para>
|
2007-06-28 02:02:40 +02:00
|
|
|
To avoid flooding the I/O system with a burst of page writes,
|
|
|
|
writing dirty buffers during a checkpoint is spread over a period of time.
|
|
|
|
That period is controlled by
|
|
|
|
<xref linkend="guc-checkpoint-completion-target">, which is
|
|
|
|
given as a fraction of the checkpoint interval.
|
|
|
|
The I/O rate is adjusted so that the checkpoint finishes when the
|
2015-02-23 17:53:02 +01:00
|
|
|
given fraction of
|
|
|
|
<varname>checkpoint_timeout</varname> seconds have elapsed, or before
|
|
|
|
<varname>max_wal_size</varname> is exceeded, whichever is sooner.
|
|
|
|
With the default value of 0.5,
|
2007-06-28 02:02:40 +02:00
|
|
|
<productname>PostgreSQL</> can be expected to complete each checkpoint
|
|
|
|
in about half the time before the next checkpoint starts. On a system
|
|
|
|
that's very close to maximum I/O throughput during normal operation,
|
|
|
|
you might want to increase <varname>checkpoint_completion_target</varname>
|
|
|
|
to reduce the I/O load from checkpoints. The disadvantage of this is that
|
|
|
|
prolonging checkpoints affects recovery time, because more WAL segments
|
|
|
|
will need to be kept around for possible use in recovery. Although
|
|
|
|
<varname>checkpoint_completion_target</varname> can be set as high as 1.0,
|
|
|
|
it is best to keep it less than that (perhaps 0.9 at most) since
|
|
|
|
checkpoints include some other activities besides writing dirty buffers.
|
|
|
|
A setting of 1.0 is quite likely to result in checkpoints not being
|
|
|
|
completed on time, which would result in performance loss due to
|
|
|
|
unexpected variation in the number of WAL segments needed.
|
|
|
|
</para>
|
|
|
|
|
Allow to trigger kernel writeback after a configurable number of writes.
Currently writes to the main data files of postgres all go through the
OS page cache. This means that some operating systems can end up
collecting a large number of dirty buffers in their respective page
caches. When these dirty buffers are flushed to storage rapidly, be it
because of fsync(), timeouts, or dirty ratios, latency for other reads
and writes can increase massively. This is the primary reason for
regular massive stalls observed in real world scenarios and artificial
benchmarks; on rotating disks stalls on the order of hundreds of seconds
have been observed.
On linux it is possible to control this by reducing the global dirty
limits significantly, reducing the above problem. But global
configuration is rather problematic because it'll affect other
applications; also PostgreSQL itself doesn't always generally want this
behavior, e.g. for temporary files it's undesirable.
Several operating systems allow some control over the kernel page
cache. Linux has sync_file_range(2), several posix systems have msync(2)
and posix_fadvise(2). sync_file_range(2) is preferable because it
requires no special setup, whereas msync() requires the to-be-flushed
range to be mmap'ed. For the purpose of flushing dirty data
posix_fadvise(2) is the worst alternative, as flushing dirty data is
just a side-effect of POSIX_FADV_DONTNEED, which also removes the pages
from the page cache. Thus the feature is enabled by default only on
linux, but can be enabled on all systems that have any of the above
APIs.
While desirable and likely possible this patch does not contain an
implementation for windows.
With the infrastructure added, writes made via checkpointer, bgwriter
and normal user backends can be flushed after a configurable number of
writes. Each of these sources of writes controlled by a separate GUC,
checkpointer_flush_after, bgwriter_flush_after and backend_flush_after
respectively; they're separate because the number of flushes that are
good are separate, and because the performance considerations of
controlled flushing for each of these are different.
A later patch will add checkpoint sorting - after that flushes from the
ckeckpoint will almost always be desirable. Bgwriter flushes are most of
the time going to be random, which are slow on lots of storage hardware.
Flushing in backends works well if the storage and bgwriter can keep up,
but if not it can have negative consequences. This patch is likely to
have negative performance consequences without checkpoint sorting, but
unfortunately so has sorting without flush control.
Discussion: alpine.DEB.2.10.1506011320000.28433@sto
Author: Fabien Coelho and Andres Freund
2016-02-19 21:13:05 +01:00
|
|
|
<para>
|
|
|
|
On Linux and POSIX platforms <xref linkend="guc-checkpoint-flush-after">
|
|
|
|
allows to force the OS that pages written by the checkpoint should be
|
|
|
|
flushed to disk after a configurable number of bytes. Otherwise, these
|
|
|
|
pages may be kept in the OS's page cache, inducing a stall when
|
|
|
|
<literal>fsync</> is issued at the end of a checkpoint. This setting will
|
|
|
|
often help to reduce transaction latency, but it also can an adverse effect
|
|
|
|
on performance; particularly for workloads that are bigger than
|
|
|
|
<xref linkend="guc-shared-buffers">, but smaller than the OS's page cache.
|
|
|
|
</para>
|
|
|
|
|
2007-06-28 02:02:40 +02:00
|
|
|
<para>
|
2016-10-20 17:24:37 +02:00
|
|
|
The number of WAL segment files in <filename>pg_wal</> directory depends on
|
2015-02-23 17:53:02 +01:00
|
|
|
<varname>min_wal_size</>, <varname>max_wal_size</> and
|
|
|
|
the amount of WAL generated in previous checkpoint cycles. When old log
|
|
|
|
segment files are no longer needed, they are removed or recycled (that is,
|
|
|
|
renamed to become future segments in the numbered sequence). If, due to a
|
|
|
|
short-term peak of log output rate, <varname>max_wal_size</> is
|
|
|
|
exceeded, the unneeded segment files will be removed until the system
|
|
|
|
gets back under this limit. Below that limit, the system recycles enough
|
|
|
|
WAL files to cover the estimated need until the next checkpoint, and
|
|
|
|
removes the rest. The estimate is based on a moving average of the number
|
|
|
|
of WAL files used in previous checkpoint cycles. The moving average
|
|
|
|
is increased immediately if the actual usage exceeds the estimate, so it
|
2017-03-08 04:45:45 +01:00
|
|
|
accommodates peak usage rather than average usage to some extent.
|
2015-02-23 17:53:02 +01:00
|
|
|
<varname>min_wal_size</> puts a minimum on the amount of WAL files
|
|
|
|
recycled for future usage; that much WAL is always recycled for future use,
|
|
|
|
even if the system is idle and the WAL usage estimate suggests that little
|
|
|
|
WAL is needed.
|
|
|
|
</para>
|
|
|
|
|
|
|
|
<para>
|
|
|
|
Independently of <varname>max_wal_size</varname>,
|
|
|
|
<xref linkend="guc-wal-keep-segments"> + 1 most recent WAL files are
|
|
|
|
kept at all times. Also, if WAL archiving is used, old segments can not be
|
|
|
|
removed or recycled until they are archived. If WAL archiving cannot keep up
|
|
|
|
with the pace that WAL is generated, or if <varname>archive_command</varname>
|
2016-10-20 17:24:37 +02:00
|
|
|
fails repeatedly, old WAL files will accumulate in <filename>pg_wal</>
|
2015-02-23 17:53:02 +01:00
|
|
|
until the situation is resolved. A slow or failed standby server that
|
|
|
|
uses a replication slot will have the same effect (see
|
|
|
|
<xref linkend="streaming-replication-slots">).
|
2001-10-27 01:10:21 +02:00
|
|
|
</para>
|
|
|
|
|
2010-07-16 13:20:23 +02:00
|
|
|
<para>
|
|
|
|
In archive recovery or standby mode, the server periodically performs
|
2013-03-15 22:41:47 +01:00
|
|
|
<firstterm>restartpoints</>,<indexterm><primary>restartpoint</></>
|
2010-07-16 13:20:23 +02:00
|
|
|
which are similar to checkpoints in normal operation: the server forces
|
|
|
|
all its state to disk, updates the <filename>pg_control</> file to
|
|
|
|
indicate that the already-processed WAL data need not be scanned again,
|
2016-10-20 17:24:37 +02:00
|
|
|
and then recycles any old log segment files in the <filename>pg_wal</>
|
2013-03-15 22:41:47 +01:00
|
|
|
directory.
|
2010-07-16 13:20:23 +02:00
|
|
|
Restartpoints can't be performed more frequently than checkpoints in the
|
|
|
|
master because restartpoints can only be performed at checkpoint records.
|
2013-03-15 22:41:47 +01:00
|
|
|
A restartpoint is triggered when a checkpoint record is reached if at
|
|
|
|
least <varname>checkpoint_timeout</> seconds have passed since the last
|
2015-02-23 17:53:02 +01:00
|
|
|
restartpoint, or if WAL size is about to exceed
|
Also trigger restartpoints based on max_wal_size on standby.
When archive recovery and restartpoints were initially introduced,
checkpoint_segments was ignored on the grounds that the files restored from
archive don't consume any space in the recovery server. That was changed in
later releases, but even then it was arguably a feature rather than a bug,
as performing restartpoints as often as checkpoints during normal operation
might be excessive, but you might nevertheless not want to waste a lot of
space for pre-allocated WAL by setting checkpoint_segments to a high value.
But now that we have separate min_wal_size and max_wal_size settings, you
can bound WAL usage with max_wal_size, and still avoid consuming excessive
space usage by setting min_wal_size to a lower value, so that argument is
moot.
There are still some issues with actually limiting the space usage to
max_wal_size: restartpoints in recovery can only start after seeing the
checkpoint record, while a checkpoint starts flushing buffers as soon as
the redo-pointer is set. Restartpoint is paced to happen at the same
leisurily speed, determined by checkpoint_completion_target, as checkpoints,
but because they are started later, max_wal_size can be exceeded by upto
one checkpoint cycle's worth of WAL, depending on
checkpoint_completion_target. But that seems better than not trying at all,
and max_wal_size is a soft limit anyway.
The documentation already claimed that max_wal_size is obeyed in recovery,
so this just fixes the behaviour to match the docs. However, add some
weasel-words there to mention that max_wal_size may well be exceeded by
some amount in recovery.
2015-06-28 23:09:10 +02:00
|
|
|
<varname>max_wal_size</>. However, because of limitations on when a
|
|
|
|
restartpoint can be performed, <varname>max_wal_size</> is often exceeded
|
|
|
|
during recovery, by up to one checkpoint cycle's worth of WAL.
|
|
|
|
(<varname>max_wal_size</> is never a hard limit anyway, so you should
|
|
|
|
always leave plenty of headroom to avoid running out of disk space.)
|
2010-07-16 13:20:23 +02:00
|
|
|
</para>
|
|
|
|
|
2002-11-02 23:23:01 +01:00
|
|
|
<para>
|
2005-10-13 19:32:42 +02:00
|
|
|
There are two commonly used internal <acronym>WAL</acronym> functions:
|
2014-11-06 12:52:08 +01:00
|
|
|
<function>XLogInsertRecord</function> and <function>XLogFlush</function>.
|
|
|
|
<function>XLogInsertRecord</function> is used to place a new record into
|
2002-11-02 23:23:01 +01:00
|
|
|
the <acronym>WAL</acronym> buffers in shared memory. If there is no
|
2014-11-06 12:52:08 +01:00
|
|
|
space for the new record, <function>XLogInsertRecord</function> will have
|
2002-11-02 23:23:01 +01:00
|
|
|
to write (move to kernel cache) a few filled <acronym>WAL</acronym>
|
2014-11-06 12:52:08 +01:00
|
|
|
buffers. This is undesirable because <function>XLogInsertRecord</function>
|
2004-03-09 17:57:47 +01:00
|
|
|
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
|
Update documentation on may/can/might:
Standard English uses "may", "can", and "might" in different ways:
may - permission, "You may borrow my rake."
can - ability, "I can lift that log."
might - possibility, "It might rain today."
Unfortunately, in conversational English, their use is often mixed, as
in, "You may use this variable to do X", when in fact, "can" is a better
choice. Similarly, "It may crash" is better stated, "It might crash".
Also update two error messages mentioned in the documenation to match.
2007-01-31 21:56:20 +01:00
|
|
|
is worse, writing <acronym>WAL</acronym> buffers might also force the
|
2004-03-09 17:57:47 +01:00
|
|
|
creation of a new log segment, which takes even more
|
2002-11-02 23:23:01 +01:00
|
|
|
time. Normally, <acronym>WAL</acronym> buffers should be written
|
2013-03-15 22:41:47 +01:00
|
|
|
and flushed by an <function>XLogFlush</function> request, which is
|
2002-11-02 23:23:01 +01:00
|
|
|
made, for the most part, at transaction commit time to ensure that
|
|
|
|
transaction records are flushed to permanent storage. On systems
|
2013-03-15 22:41:47 +01:00
|
|
|
with high log output, <function>XLogFlush</function> requests might
|
2014-11-06 12:52:08 +01:00
|
|
|
not occur often enough to prevent <function>XLogInsertRecord</function>
|
2004-08-08 06:34:43 +02:00
|
|
|
from having to do writes. On such systems
|
2002-11-02 23:23:01 +01:00
|
|
|
one should increase the number of <acronym>WAL</acronym> buffers by
|
2013-03-15 22:41:47 +01:00
|
|
|
modifying the <xref linkend="guc-wal-buffers"> parameter. When
|
2007-08-02 00:45:09 +02:00
|
|
|
<xref linkend="guc-full-page-writes"> is set and the system is very busy,
|
2013-03-15 22:41:47 +01:00
|
|
|
setting <varname>wal_buffers</> higher will help smooth response times
|
|
|
|
during the period immediately following each checkpoint.
|
2002-11-15 03:44:57 +01:00
|
|
|
</para>
|
|
|
|
|
2001-01-25 00:15:19 +01:00
|
|
|
<para>
|
2004-03-09 17:57:47 +01:00
|
|
|
The <xref linkend="guc-commit-delay"> parameter defines for how many
|
2013-03-15 22:41:47 +01:00
|
|
|
microseconds a group commit leader process will sleep after acquiring a
|
|
|
|
lock within <function>XLogFlush</function>, while group commit
|
|
|
|
followers queue up behind the leader. This delay allows other server
|
|
|
|
processes to add their commit records to the WAL buffers so that all of
|
|
|
|
them will be flushed by the leader's eventual sync operation. No sleep
|
|
|
|
will occur if <xref linkend="guc-fsync"> is not enabled, or if fewer
|
|
|
|
than <xref linkend="guc-commit-siblings"> other sessions are currently
|
|
|
|
in active transactions; this avoids sleeping when it's unlikely that
|
|
|
|
any other session will commit soon. Note that on some platforms, the
|
|
|
|
resolution of a sleep request is ten milliseconds, so that any nonzero
|
|
|
|
<varname>commit_delay</varname> setting between 1 and 10000
|
|
|
|
microseconds would have the same effect. Note also that on some
|
|
|
|
platforms, sleep operations may take slightly longer than requested by
|
|
|
|
the parameter.
|
|
|
|
</para>
|
|
|
|
|
|
|
|
<para>
|
|
|
|
Since the purpose of <varname>commit_delay</varname> is to allow the
|
|
|
|
cost of each flush operation to be amortized across concurrently
|
|
|
|
committing transactions (potentially at the expense of transaction
|
|
|
|
latency), it is necessary to quantify that cost before the setting can
|
|
|
|
be chosen intelligently. The higher that cost is, the more effective
|
|
|
|
<varname>commit_delay</varname> is expected to be in increasing
|
|
|
|
transaction throughput, up to a point. The <xref
|
|
|
|
linkend="pgtestfsync"> program can be used to measure the average time
|
|
|
|
in microseconds that a single WAL flush operation takes. A value of
|
|
|
|
half of the average time the program reports it takes to flush after a
|
|
|
|
single 8kB write operation is often the most effective setting for
|
|
|
|
<varname>commit_delay</varname>, so this value is recommended as the
|
|
|
|
starting point to use when optimizing for a particular workload. While
|
|
|
|
tuning <varname>commit_delay</varname> is particularly useful when the
|
|
|
|
WAL log is stored on high-latency rotating disks, benefits can be
|
|
|
|
significant even on storage media with very fast sync times, such as
|
|
|
|
solid-state drives or RAID arrays with a battery-backed write cache;
|
|
|
|
but this should definitely be tested against a representative workload.
|
|
|
|
Higher values of <varname>commit_siblings</varname> should be used in
|
|
|
|
such cases, whereas smaller <varname>commit_siblings</varname> values
|
|
|
|
are often helpful on higher latency media. Note that it is quite
|
|
|
|
possible that a setting of <varname>commit_delay</varname> that is too
|
|
|
|
high can increase transaction latency by so much that total transaction
|
|
|
|
throughput suffers.
|
|
|
|
</para>
|
|
|
|
|
|
|
|
<para>
|
|
|
|
When <varname>commit_delay</varname> is set to zero (the default), it
|
|
|
|
is still possible for a form of group commit to occur, but each group
|
|
|
|
will consist only of sessions that reach the point where they need to
|
|
|
|
flush their commit records during the window in which the previous
|
|
|
|
flush operation (if any) is occurring. At higher client counts a
|
|
|
|
<quote>gangway effect</> tends to occur, so that the effects of group
|
|
|
|
commit become significant even when <varname>commit_delay</varname> is
|
|
|
|
zero, and thus explicitly setting <varname>commit_delay</varname> tends
|
|
|
|
to help less. Setting <varname>commit_delay</varname> can only help
|
|
|
|
when (1) there are some concurrently committing transactions, and (2)
|
|
|
|
throughput is limited to some degree by commit rate; but with high
|
|
|
|
rotational latency this setting can be effective in increasing
|
|
|
|
transaction throughput with as few as two clients (that is, a single
|
|
|
|
committing client with one sibling transaction).
|
2001-01-25 00:15:19 +01:00
|
|
|
</para>
|
2001-03-16 06:44:33 +01:00
|
|
|
|
|
|
|
<para>
|
2004-03-09 17:57:47 +01:00
|
|
|
The <xref linkend="guc-wal-sync-method"> parameter determines how
|
2001-11-21 07:09:45 +01:00
|
|
|
<productname>PostgreSQL</productname> will ask the kernel to force
|
2010-10-19 16:56:33 +02:00
|
|
|
<acronym>WAL</acronym> updates out to disk.
|
|
|
|
All the options should be the same in terms of reliability, with
|
|
|
|
the exception of <literal>fsync_writethrough</>, which can sometimes
|
|
|
|
force a flush of the disk cache even when other options do not do so.
|
2013-03-15 22:41:47 +01:00
|
|
|
However, it's quite platform-specific which one will be the fastest.
|
|
|
|
You can test the speeds of different options using the <xref
|
|
|
|
linkend="pgtestfsync"> program.
|
2003-03-24 15:32:51 +01:00
|
|
|
Note that this parameter is irrelevant if <varname>fsync</varname>
|
2001-03-16 06:44:33 +01:00
|
|
|
has been turned off.
|
|
|
|
</para>
|
|
|
|
|
|
|
|
<para>
|
2004-03-09 17:57:47 +01:00
|
|
|
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
|
2014-11-06 12:52:08 +01:00
|
|
|
<function>XLogInsertRecord</function> and <function>XLogFlush</function>
|
2005-10-22 23:56:07 +02:00
|
|
|
<acronym>WAL</acronym> call being logged to the server log. This
|
Update documentation on may/can/might:
Standard English uses "may", "can", and "might" in different ways:
may - permission, "You may borrow my rake."
can - ability, "I can lift that log."
might - possibility, "It might rain today."
Unfortunately, in conversational English, their use is often mixed, as
in, "You may use this variable to do X", when in fact, "can" is a better
choice. Similarly, "It may crash" is better stated, "It might crash".
Also update two error messages mentioned in the documenation to match.
2007-01-31 21:56:20 +01:00
|
|
|
option might be replaced by a more general mechanism in the future.
|
2001-03-16 06:44:33 +01:00
|
|
|
</para>
|
2001-01-25 00:15:19 +01:00
|
|
|
</sect1>
|
2003-03-24 15:32:51 +01:00
|
|
|
|
|
|
|
<sect1 id="wal-internals">
|
2005-09-28 20:18:02 +02:00
|
|
|
<title>WAL Internals</title>
|
2003-03-24 15:32:51 +01:00
|
|
|
|
2016-09-05 10:47:49 +02:00
|
|
|
<indexterm zone="wal-internals">
|
|
|
|
<primary>LSN</primary>
|
|
|
|
</indexterm>
|
|
|
|
|
2003-03-24 15:32:51 +01:00
|
|
|
<para>
|
|
|
|
<acronym>WAL</acronym> is automatically enabled; no action is
|
2004-08-08 06:34:43 +02:00
|
|
|
required from the administrator except ensuring that the
|
|
|
|
disk-space requirements for the <acronym>WAL</acronym> logs are met,
|
2003-03-24 15:32:51 +01:00
|
|
|
and that any necessary tuning is done (see <xref
|
|
|
|
linkend="wal-configuration">).
|
|
|
|
</para>
|
|
|
|
|
2016-09-05 10:47:49 +02:00
|
|
|
<para>
|
|
|
|
<acronym>WAL</acronym> records are appended to the <acronym>WAL</acronym>
|
|
|
|
logs as each new record is written. The insert position is described by
|
|
|
|
a Log Sequence Number (<acronym>LSN</acronym>) that is a byte offset into
|
|
|
|
the logs, increasing monotonically with each new record.
|
|
|
|
<acronym>LSN</acronym> values are returned as the datatype
|
|
|
|
<link linkend="datatype-pg-lsn"><type>pg_lsn</></link>. Values can be
|
|
|
|
compared to calculate the volume of <acronym>WAL</acronym> data that
|
|
|
|
separates them, so they are used to measure the progress of replication
|
|
|
|
and recovery.
|
|
|
|
</para>
|
|
|
|
|
2003-03-24 15:32:51 +01:00
|
|
|
<para>
|
|
|
|
<acronym>WAL</acronym> logs are stored in the directory
|
2016-10-20 17:24:37 +02:00
|
|
|
<filename>pg_wal</filename> under the data directory, as a set of
|
2016-08-05 20:35:09 +02:00
|
|
|
segment files, normally each 16 MB in size (but the size can be changed
|
2008-05-02 21:52:37 +02:00
|
|
|
by altering the <option>--with-wal-segsize</> configure option when
|
|
|
|
building the server). Each segment is divided into pages, normally
|
2016-08-05 20:35:09 +02:00
|
|
|
8 kB each (this size can be changed via the <option>--with-wal-blocksize</>
|
2008-05-02 21:52:37 +02:00
|
|
|
configure option). The log record headers are described in
|
2014-11-06 12:52:08 +01:00
|
|
|
<filename>access/xlogrecord.h</filename>; the record content is dependent
|
2003-03-24 15:32:51 +01:00
|
|
|
on the type of event that is being logged. Segment files are given
|
|
|
|
ever-increasing numbers as names, starting at
|
2010-02-03 18:25:06 +01:00
|
|
|
<filename>000000010000000000000000</filename>. The numbers do not wrap,
|
|
|
|
but it will take a very, very long time to exhaust the
|
2003-03-24 15:32:51 +01:00
|
|
|
available stock of numbers.
|
|
|
|
</para>
|
|
|
|
|
|
|
|
<para>
|
2010-02-03 18:25:06 +01:00
|
|
|
It is advantageous if the log is located on a different disk from the
|
|
|
|
main database files. This can be achieved by moving the
|
2016-10-20 17:24:37 +02:00
|
|
|
<filename>pg_wal</filename> directory to another location (while the server
|
2003-03-24 15:32:51 +01:00
|
|
|
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>
|
2010-02-03 18:25:06 +01:00
|
|
|
The aim of <acronym>WAL</acronym> is to ensure that the log is
|
|
|
|
written before database records are altered, but this can be subverted by
|
2004-08-08 06:34:43 +02:00
|
|
|
disk drives<indexterm><primary>disk drive</></> that falsely report a
|
2007-08-02 00:45:09 +02:00
|
|
|
successful write to the kernel,
|
2004-08-08 06:34:43 +02:00
|
|
|
when in fact they have only cached the data and not yet stored it
|
2010-02-03 18:25:06 +01:00
|
|
|
on the disk. A power failure in such a situation might lead to
|
2003-03-24 15:32:51 +01:00
|
|
|
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.
|
2010-10-07 18:19:03 +02:00
|
|
|
(See <xref linkend="wal-reliability">.)
|
2003-03-24 15:32:51 +01:00
|
|
|
</para>
|
|
|
|
|
|
|
|
<para>
|
|
|
|
After a checkpoint has been made and the log flushed, the
|
|
|
|
checkpoint's position is saved in the file
|
2010-02-03 18:25:06 +01:00
|
|
|
<filename>pg_control</filename>. Therefore, at the start of recovery,
|
|
|
|
the server first reads <filename>pg_control</filename> and
|
2003-03-24 15:32:51 +01:00
|
|
|
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
|
2009-01-15 01:34:25 +01:00
|
|
|
log on the first page modification after a checkpoint (assuming
|
|
|
|
<xref linkend="guc-full-page-writes"> is not disabled), all pages
|
2003-03-24 15:32:51 +01:00
|
|
|
changed since the checkpoint will be restored to a consistent
|
|
|
|
state.
|
|
|
|
</para>
|
|
|
|
|
|
|
|
<para>
|
2004-08-08 06:34:43 +02:00
|
|
|
To deal with the case where <filename>pg_control</filename> is
|
2010-02-03 18:25:06 +01:00
|
|
|
corrupt, we should support the possibility of scanning existing log
|
2004-11-15 07:32:15 +01:00
|
|
|
segments in reverse order — newest to oldest — in order to find the
|
2004-08-08 06:34:43 +02:00
|
|
|
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
|
2010-02-03 18:25:06 +01:00
|
|
|
there have been no reports of database failures due solely to the inability
|
2004-08-08 06:34:43 +02:00
|
|
|
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.
|
2003-03-24 15:32:51 +01:00
|
|
|
</para>
|
|
|
|
</sect1>
|
2001-01-25 00:15:19 +01:00
|
|
|
</chapter>
|