|The PostgreSQL 9.0 Reference Manual - Volume 3 - Server Administration Guide
by The PostgreSQL Global Development Group
Paperback (6"x9"), 274 pages
RRP £9.95 ($14.95)
Sales of this book support the PostgreSQL project! Get a printed copy>>>
3.4.1 Shared Memory and Semaphores
Shared memory and semaphores are collectively referred to as
IPC” (together with message queues, which are not
relevant for PostgreSQL). Almost all modern
operating systems provide these features, but many of them don't have
them turned on or sufficiently sized by default, especially as
available RAM and the demands of database applications grow.
PostgreSQL provides its own replacement
implementation of these facilities, so most of this section
can be disregarded.)
The complete lack of these facilities is usually manifested by an Illegal system call error upon server start. In that case there is no alternative but to reconfigure your kernel. PostgreSQL won't work without them. This situation is rare, however, among modern operating systems.
When PostgreSQL exceeds one of the various hard IPC limits, the server will refuse to start and should leave an instructive error message describing the problem and what to do about it. (See also section 3.3.1 Server Start-up Failures.) The relevant kernel parameters are named consistently across different systems; Table 3-1 gives an overview. The methods to set them, however, vary. Suggestions for some platforms are given below.
|Name||Description|| Reasonable values
||Maximum size of shared memory segment (bytes)|| at least several megabytes (see text)
||Minimum size of shared memory segment (bytes)|| 1
||Total amount of shared memory available (bytes or pages)|| if bytes, same as |
||Maximum number of shared memory segments per process|| only 1 segment is needed, but the default is much higher
||Maximum number of shared memory segments system-wide|| like |
||Maximum number of semaphore identifiers (i.e., sets)|| at least |
||Maximum number of semaphores system-wide|| |
||Maximum number of semaphores per set|| at least 17
||Number of entries in semaphore map|| see text
||Maximum value of semaphore||at least 1000 (The default is often 32767; do not change unless necessary)|
The most important
shared memory parameter is
SHMMAX, the maximum size, in
bytes, of a shared memory segment. If you get an error message from
shmget like “Invalid argument”, it is
likely that this limit has been exceeded. The size of the required
shared memory segment varies depending on several
PostgreSQL configuration parameters, as shown in
Table 3-2. (Any error message you might
get will include the exact size of the failed allocation request.)
You can, as a temporary solution, lower some of those settings to
avoid the failure. While it is possible to get
PostgreSQL to run with
SHMMAX as small as
2 MB, you need considerably more for acceptable performance. Desirable
settings are in the hundreds of megabytes to a few gigabytes.
Some systems also have a limit on the total amount of shared memory in
the system (
SHMALL). Make sure this is large enough
for PostgreSQL plus any other applications that
are using shared memory segments. Note that
is measured in pages rather than bytes on many systems.
Less likely to cause problems is the minimum size for shared
memory segments (
SHMMIN), which should be at most
approximately 500 kB for PostgreSQL (it is
usually just 1). The maximum number of segments system-wide
SHMMNI) or per-process (
SHMSEG) are unlikely
to cause a problem unless your system has them set to zero.
PostgreSQL uses one semaphore per allowed connection
max_connections) and allowed autovacuum worker
autovacuum_max_workers), in sets of 16.
Each such set will
also contain a 17th semaphore which contains a “magic
number”, to detect collision with semaphore sets used by
other applications. The maximum number of semaphores in the system
is set by
SEMMNS, which consequently must be at least
as high as
autovacuum_max_workers, plus one extra for each 16
allowed connections plus workers (see the formula in Table 3-1). The parameter
determines the limit on the number of semaphore sets that can
exist on the system at one time. Hence this parameter must be at
ceil((max_connections + autovacuum_max_workers) / 16).
Lowering the number
of allowed connections is a temporary workaround for failures,
which are usually confusingly worded “No space
left on device”, from the function
In some cases it might also be necessary to increase
SEMMAP to be at least on the order of
SEMMNS. This parameter defines the size of the semaphore
resource map, in which each contiguous block of available semaphores
needs an entry. When a semaphore set is freed it is either added to
an existing entry that is adjacent to the freed block or it is
registered under a new map entry. If the map is full, the freed
semaphores get lost (until reboot). Fragmentation of the semaphore
space could over time lead to fewer available semaphores than there
SEMMSL parameter, which determines how many
semaphores can be in a set, must be at least 17 for
Various other settings related to “semaphore undo”, such as
SEMUME, do not affect
At least as of version 5.1, it should not be necessary to do
any special configuration for such parameters as
SHMMAX, as it appears this is configured to allow all memory to be used as shared memory. That is the sort of configuration commonly used for other databases such as DB/2. It might, however, be necessary to modify the global
ulimitinformation in ‘/etc/security/limits’, as the default hard limits for file sizes (
fsize) and numbers of files (
nofiles) might be too low.
Shared Memory. By default, only 4 MB of shared memory is supported. Keep in
mind that shared memory is not pageable; it is locked in RAM.
To increase the amount of shared memory supported by your
system, add something like the following to your kernel configuration
options "SHMALL=8192" options "SHMMAX=\(SHMALL*PAGE_SIZE\)"
SHMALLis measured in 4 kB pages, so a value of 1024 represents 4 MB of shared memory. Therefore the above increases the maximum shared memory area to 32 MB. For those running 4.3 or later, you will probably also need to increase
KERNEL_VIRTUAL_MBabove the default
248. Once all changes have been made, recompile the kernel, and reboot. Semaphores. You will probably want to increase the number of semaphores as well; the default system total of 60 will only allow about 50 PostgreSQL connections. Set the values you want in your kernel configuration file, e.g.:
options "SEMMNI=40" options "SEMMNS=240"
The default settings are only suitable for small installations
(for example, default
SHMMAXis 32 MB). Changes can be made via the
loaderinterfaces. The following parameters can be set using
$ sysctl -w kern.ipc.shmall=32768 $ sysctl -w kern.ipc.shmmax=134217728 $ sysctl -w kern.ipc.semmap=256To have these settings persist over reboots, modify ‘/etc/sysctl.conf’. The remaining semaphore settings are read-only as far as
sysctlis concerned, but can be changed before boot using the
(loader) set kern.ipc.semmni=256 (loader) set kern.ipc.semmns=512 (loader) set kern.ipc.semmnu=256Similarly these can be saved between reboots in ‘/boot/loader.conf’. You might also want to configure your kernel to lock shared memory into RAM and prevent it from being paged out to swap. This can be accomplished using the
kern.ipc.shm_use_phys. If running in FreeBSD jails by enabling sysctl's
security.jail.sysvipc_allowed, postmasters running in different jails should be run by different operating system users. This improves security because it prevents non-root users from interfering with shared memory or semaphores in different jails, and it allows the PostgreSQL IPC cleanup code to function properly. (In FreeBSD 6.0 and later the IPC cleanup code does not properly detect processes in other jails, preventing the running of postmasters on the same port in different jails.)
FreeBSDversions before 4.0 work like
SYSVSEMneed to be enabled when the kernel is compiled. (They are by default.) The maximum size of shared memory is determined by the option
SHMMAXPGS(in pages). The following shows an example of how to set the various parameters on
options SYSVSHM options SHMMAXPGS=4096 options SHMSEG=256 options SYSVSEM options SEMMNI=256 options SEMMNS=512 options SEMMNU=256 options SEMMAP=256You might also want to configure your kernel to lock shared memory into RAM and prevent it from being paged out to swap. This can be accomplished using the
The default settings tend to suffice for normal installations.
On HP-UX 10, the factory default for
SEMMNSis 128, which might be too low for larger database sites. IPC parameters can be set in the System Administration Manager (SAM) under Kernel Configuration->Configurable Parameters. Choose Create A New Kernel when you're done.
The default maximum segment size is 32 MB, which is only adequate
for very small PostgreSQL
installations. The default maximum total size is 2097152
pages. A page is almost always 4096 bytes except in unusual
kernel configurations with “huge pages”
getconf PAGE_SIZEto verify). That makes a default limit of 8 GB, which is often enough, but not always. The shared memory size settings can be changed via the
sysctlinterface. For example, to allow 16 GB:
$ sysctl -w kernel.shmmax=17179869184 $ sysctl -w kernel.shmall=4194304In addition these settings can be preserved between reboots in the file ‘/etc/sysctl.conf’. Doing that is highly recommended. Ancient distributions might not have the
sysctlprogram, but equivalent changes can be made by manipulating the ‘/proc’ file system:
$ echo 17179869184 >/proc/sys/kernel/shmmax $ echo 4194304 >/proc/sys/kernel/shmallThe remaining defaults are quite generously sized, and usually do not require changes.
The recommended method for configuring shared memory in OS X
is to create a file named ‘/etc/sysctl.conf’,
containing variable assignments such as:
kern.sysv.shmmax=4194304 kern.sysv.shmmin=1 kern.sysv.shmmni=32 kern.sysv.shmseg=8 kern.sysv.shmall=1024Note that in some OS X versions, all five shared-memory parameters must be set in ‘/etc/sysctl.conf’, else the values will be ignored. Beware that recent releases of OS X ignore attempts to set
SHMMAXto a value that isn't an exact multiple of 4096.
SHMALLis measured in 4 kB pages on this platform. In older OS X versions, you will need to reboot to have changes in the shared memory parameters take effect. As of 10.5 it is possible to change all but
SHMMNIon the fly, using sysctl. But it's still best to set up your preferred values via ‘/etc/sysctl.conf’, so that the values will be kept across reboots. The file ‘/etc/sysctl.conf’ is only honored in OS X 10.3.9 and later. If you are running a previous 10.3.x release, you must edit the file ‘/etc/rc’ and change the values in the following commands:
sysctl -w kern.sysv.shmmax sysctl -w kern.sysv.shmmin sysctl -w kern.sysv.shmmni sysctl -w kern.sysv.shmseg sysctl -w kern.sysv.shmallNote that ‘/etc/rc’ is usually overwritten by OS X system updates, so you should expect to have to redo these edits after each update. In OS X 10.2 and earlier, instead edit these commands in the file ‘/System/Library/StartupItems/SystemTuning/SystemTuning’.
In the default configuration, only 512 kB of shared memory per
segment is allowed. To increase the setting, first change to the
directory ‘/etc/conf/cf.d’. To display the current value of
./configure -y SHMMAXTo set a new value for
./configure SHMMAX=valuewhere value is the new value you want to use (in bytes). After setting
SHMMAX, rebuild the kernel:
At least in version 2.6, the default maximum size of a shared
memory segment is too low for PostgreSQL. The
relevant settings can be changed in ‘/etc/system’,
set shmsys:shminfo_shmmax=0x2000000 set shmsys:shminfo_shmmin=1 set shmsys:shminfo_shmmni=256 set shmsys:shminfo_shmseg=256 set semsys:seminfo_semmap=256 set semsys:seminfo_semmni=512 set semsys:seminfo_semmns=512 set semsys:seminfo_semmsl=32You need to reboot for the changes to take effect.
On UnixWare 7, the maximum size for shared
memory segments is only 512 kB in the default configuration.
To display the current value of
/etc/conf/bin/idtune -g SHMMAXwhich displays the current, default, minimum, and maximum values. To set a new value for
/etc/conf/bin/idtune SHMMAX valuewhere value is the new value you want to use (in bytes). After setting
SHMMAX, rebuild the kernel:
/etc/conf/bin/idbuild -Band reboot.
|Usage|| Approximate shared memory bytes required (as of 8.3)
|Connections|| (1800 + 270 * |
|Autovacuum workers|| (1800 + 270 * |
|Prepared transactions|| (770 + 270 * |
|Shared disk buffers|| ( |
|WAL buffers|| ( |
|Fixed space requirements||770 kB|
|ISBN 9781906966072||The PostgreSQL 9.0 Reference Manual - Volume 3 - Server Administration Guide||See the print edition|