A PostgreSQL optimal performance depends on correctly defined operating system parameters. Poorly configured OS kernel parameters can lead to a decrease in database server performance. Therefore, it is essential that these parameters are configured in accordance with the database server and its workload. In this post, we will discuss some important Linux kernel parameters that can affect database server performance and how to configure them.
SHMMAX / SHMALL
SHMMAX — this is a kernel parameter used to determine the maximum size of a single segment of shared memory that a Linux process can allocate. Before version 9.2, PostgreSQL used System V (SysV), which required the configuration of SHMMAX. After version 9.2, PostgreSQL switched to POSIX shared memory. Therefore, now fewer bytes of System V shared memory are required.
Before version 9.3, SHMMAX was the most critical kernel parameter. The value of SHMMAX is set in bytes.
Similarly, SHMALL — this is another kernel parameter used to determine
the total volume of shared memory pages. To view the current values of SHMMAX, SHMALL, or SHMMIN, use the command ipcs.
SHM* Details — Linux
$ ipcs -lm
------ Shared Memory Limits --------
max number of segments = 4096
max seg size (kbytes) = 1073741824
max total shared memory (kbytes) = 17179869184
min seg size (bytes) = 1SHM* Details — MacOS X
$ ipcs -M
IPC status from as of Thu Aug 16 22:20:35 PKT 2018
shminfo:
shmmax: 16777216 (max shared memory segment size)
shmmin: 1 (min shared memory segment size)
shmmni: 32 (max number of shared memory identifiers)
shmseg: 8 (max shared memory segments per process)
shmall: 1024 (max amount of shared memory in pages)
PostgreSQL uses System V IPC for allocating shared memory. This parameter is one of the most important kernel parameters. Whenever you receive the following error messages, it means that you have an older version of PostgreSQL and a very low SHMMAX value. Users are expected to adjust and increase the value in accordance with the shared memory they intend to use.
Possible misconfiguration errors
If SHMMAX is configured incorrectly, you may receive an error when trying to initialize the PostgreSQL cluster using the command initdb.
initdb Failure
DETAIL: Failed system call was shmget(key=1, size=2072576, 03600).
HINT: This error usually means that PostgreSQL's request for a shared memory segment exceeded your kernel's SHMMAX parameter.
Két lehetőség van: csökkentheti a kérés méretét, vagy újrakonfigurálhatja a kernelt nagyobb SHMMAX értékkel. A kérés méretének csökkentéséhez (jelenleg 2072576 bájt),
csökkentse a PostgreSQL megosztott memóriahasználatát, például a shared_buffers vagy a max_connections csökkentésével.
Ha a kérés mérete már kicsi, lehetséges, hogy az kisebb, mint a kernel SHMMIN paramétere,
ebben az esetben a kérés méretének növelése vagy a SHMMIN újrakonfigurálása szükséges.
A PostgreSQL dokumentáció részletesebb információkat tartalmaz a megosztott memória konfigurációjáról. A gyermekfolyamat kilépett a 1-es kódal.
Hasonlóképpen, hibát kaphat a PostgreSQL szerver indításakor a következő parancs használatával: pg_ctl.
pg_ctl hiba
RÉSZLET: A sikertelen rendszerhívás: shmget(key=5432001, size=14385152, 03600).
HINT: This error usually means that PostgreSQL's request for a shared memory segment exceeded your kernel's SHMMAX parameter.
Két lehetőség van: csökkentheti a kérés méretét, vagy újrakonfigurálhatja a kernelt nagyobb SHMMAX értékkel. A kérés méretének csökkentéséhez (jelenleg 14385152 bájt) csökkentse a PostgreSQL megosztott memória használatát, például a shared_buffers vagy a max_connections csökkentésével.
Ha a kérés mérete már kicsi, lehetséges, hogy az kisebb, mint a kernel SHMMIN paramétere,
ebben az esetben a kérés méretének növelése vagy a SHMMIN újrakonfigurálása szükséges.
A PostgreSQL dokumentáció részletesebb információkat tartalmaz a megosztott memória konfigurációjáról.
A meghatározások közötti különbségek megértése
A SHMMAX/SHMALL paraméterek meghatározása kissé eltér a Linux és a MacOS X rendszerekben:
- Linux: kernel.shmmax, kernel.shmall
- MacOS X: kern.sysv.shmmax, kern.sysv.shmall
A parancs sysctl használható az érték ideiglenes megváltoztatására. A tartós értékek beállításához add hozzá a bejegyzést a /etc/sysctl.conf. További részletek lent találhatók.
Kernel paraméterek módosítása MacOS X-en
# Get the value of SHMMAX
sudo sysctl kern.sysv.shmmax
kern.sysv.shmmax: 4096
# Get the value of SHMALL
sudo sysctl kern.sysv.shmall
kern.sysv.shmall: 4096
# Set the value of SHMMAX
sudo sysctl -w kern.sysv.shmmax=16777216
kern.sysv.shmmax: 4096 -> 16777216
# Set the value of SHMALL
sudo sysctl -w kern.sysv.shmall=16777216
kern.sysv.shmall: 4096 -> 16777216Kernel paraméterek módosítása Linux-on
# Get the value of SHMMAX
sudo sysctl kernel.shmmax
kernel.shmmax: 4096
# Get the value of SHMALL
sudo sysctl kernel.shmall
kernel.shmall: 4096
# Set the value of SHMMAX
sudo sysctl -w kernel.shmmax=16777216
kernel.shmmax: 4096 -> 16777216
# Set the value of SHMALL
sudo sysctl -w kernel.shmall=16777216
kernel.shmall: 4096 -> 16777216Ne felejtsd el: a változtatások tartós megvalósításához add hozzá ezeket az értékeket a /etc/sysctl.conf fájlhoz
Nagy oldalak (Huge Pages)
Linux alatt alapértelmezés szerint 4 KB memóriáványok használatosak, a BSD rendszerekben — Super Pages, Windows alatt pedig — Large Pages. Az oldal egy része a RAM-ból, amit a folyamat kap. A folyamat rendelkezhet több oldallal a memóriaigények függvényében. Minél több memória szükséges a folyamat számára, annál több oldalt fog kapni. Az operációs rendszer egy lapfoglalási táblát tart fenn a folyamatok számára. Minél kisebb az oldal mérete, annál nagyobb a táblázat, annál több időt igényel az oldal keresése a lapok táblájában. Ezért a nagy oldalak lehetővé teszik nagy mennyiségű memória használatát csökkentett költségekkel; kevesebb oldalmegtekintés, kevesebb oldalbeli hiba, gyorsabb írás/olvasás műveletek nagyobb puffereken keresztül. Ennek eredményeként javul a teljesítmény.
A PostgreSQL csak Linux alatt támogatja a nagy oldalakat. Alapértelmezés szerint a Linux 4 KB memóriákat használ, ezért ha túl sok memória-kezelési művelet van, szükséges nagyobb méretű oldalakat beállítani. Teljesítménynövekedés észlelhető 2 MB-os és akár 1 GB-os nagy oldalak használatakor. A nagy oldal mérete a rendszerindításkor beállítható. A nagy oldalak paramétereit és használatát egyszerűen ellenőrizheti Linux számítógépén a következő parancs használatával cat /proc/meminfo | grep -i huge.
Nagy oldalak információinak megszerzése (csak Linuxon)
Megjegyzés: Ez csak Linuxra vonatkozik, más operációs rendszerek esetén ez a művelet figyelmen kívül hagyható$ cat /proc/meminfo | grep -i huge
AnonHugePages: 0 kB
ShmemHugePages: 0 kB
HugePages_Total: 0
HugePages_Free: 0
HugePages_Rsvd: 0
HugePages_Surp: 0
Hugepagesize: 2048 kBEbben a példában, bár a nagy oldal mérete 2048 (2 MB) beállításra került, a nagy oldalak összesített száma 0. Ez azt jelenti, hogy a nagy oldalak ki vannak kapcsolva.
Nagy oldalak számának meghatározására szolgáló script
Ez egy egyszerű script, amely visszaadja a szükséges nagy oldalak számát. Futassa a scriptet Linux szerverén, miközben a PostgreSQL fut. Győződjön meg róla, hogy a környezeti változó $PGDATA a PostgreSQL adatkönyvtárra van beállítva.
A szükséges nagy oldalak számának meghatározása
#!/bin/bash
pid=`head -1 $PGDATA/postmaster.pid`
echo "Pid: $pid"
peak=`grep ^VmPeak /proc/$pid/status | awk '{ print $2 }'`
echo "VmPeak: $peak kB"
hps=`grep ^Hugepagesize /proc/meminfo | awk '{ print $2 }'`
echo "Hugepagesize: $hps kB"
hp=$((peak/hps))
echo Set Huge Pages: $hpA script kimenete a következőképpen néz ki:
A script kimenete
Pid: 12737
VmPeak: 180932 kB
Hugepagesize: 2048 kB
Set Huge Pages: 88A javasolt nagy oldalak száma 88, ezért ezt az értéket 88-ra kell beállítania.
Nagy oldalak beállítása
sysctl -w vm.nr_hugepages=88Ellenőrizze a nagy oldalakat most, látni fogja, hogy a nagy oldalak nincsenek használatban (HugePages_Free = HugePages_Total).
Ismét információ a nagy oldalakról (csak Linuxon)
$ cat /proc/meminfo | grep -i huge
AnonHugePages: 0 kB
ShmemHugePages: 0 kB
HugePages_Total: 88
HugePages_Free: 88
HugePages_Rsvd: 0
HugePages_Surp: 0
Hugepagesize: 2048 kBMost állítsa be a huge_pages paramétert "on" értékre a $PGDATA/postgresql.conf fájlban, majd indítsa újra a szervert.
És ismét információ a nagy oldalakról (csak Linuxon)
$ cat /proc/meminfo | grep -i huge
AnonHugePages: 0 kB
ShmemHugePages: 0 kB
HugePages_Total: 88
HugePages_Free: 81
HugePages_Rsvd: 64
HugePages_Surp: 0
Hugepagesize: 2048 kBMost láthatja, hogy nagyon kevés nagy oldal van használatban. Most próbáljunk meg néhány adatot hozzáadni az adatbázishoz.
Néhány adatbázis művelet a nagy oldalak kihelyezéséhez
postgres=# CREATE TABLE foo(a INTEGER);
CREATE TABLE
postgres=# INSERT INTO foo VALUES(generate_Series(1,10000000));
INSERT 0 10000000Nézzük meg, használunk-e jelenleg több nagy oldalt, mint korábban.
Még egyszer információ a nagy oldalakról (csak Linuxon)
$ cat /proc/meminfo | grep -i huge
AnonHugePages: 0 kB
ShmemHugePages: 0 kB
HugePages_Total: 88
HugePages_Free: 18
HugePages_Rsvd: 1
HugePages_Surp: 0
Hugepagesize: 2048 kBMost már láthatja, hogy a legtöbb nagy oldal használatban van.
Megjegyzés: A HugePages-hez használt becsült érték itt nagyon alacsony, ami nem normális érték egy termelési környezetben. Kérjük, értékelje, hogy hány oldalra van szüksége a rendszeréhez, és állítsa be azokat megfelelően a terhelés és az erőforrások függvényében.
vm.swappiness
vm.swappiness — ez egy másik kernel paraméter, amely befolyásolhatja az adatbázis teljesítményét. Ez a paraméter a lapozás (swappiness) viselkedésének kezelésére szolgál (lapok betöltése és eltávolítása a memóriából) Linuxon. Az érték 0 és 100 között változik. Meghatározza, hogy mennyi memória kerül kiürítésre vagy felhasználásra. A nulla letiltja a swap-ot, míg a 100 agresszív swap-ot jelent.
Jó teljesítményt érhet el, ha alacsonyabb értékeket állít be.
A 0 érték beállítása az újabb kernelben OOM Killer-t (memória tisztító folyamatot Linuxon) okozhat, amely megölheti a folyamatot. Így biztonságosan beállíthatja az 1 értéket, ha minimalizálni szeretné a swap-ot. Az alapértelmezett érték Linuxon 60. A magasabb érték arra kényszeríti az MMU-t (memóriakezelő egységet), hogy több swap területet használjon, mint a RAM, míg az alacsonyabb érték több adat/kódot tart a memóriában.
Az alacsonyabb érték jó fogadást jelent a PostgreSQL teljesítményének javítására.
vm.overcommit_memory / vm.overcommit_ratio
A programok memóriát kapnak és felszabadítják, amikor már nincs rá szükség. De bizonyos esetekben a program túl sok memóriát kap és nem szabadítja fel. Ez OOM killert okozhat. Íme néhány lehetséges nilai a paraméterhez, vm.overcommit_memory melyek mindegyikének leírása:
- Heurisztikus overcommit (alapértelmezés szerint); kernel alapú heurisztika
- Overcommit engedélyezése minden esetben
- Ne túlozzon, ne haladja meg az overcommit arányt.
Link:
vm.overcommit_ratio — a RAM percentage available for overcommit. A value of 50% in a system with 2 GB of RAM can allocate up to 3 GB of RAM.
A value of 2 for vm.overcommit_memory provides better performance for PostgreSQL. This value maximizes RAM usage for the server process without significant risk of being killed by the OOM killer. The application can restart, but only within the overcommit limit, reducing the risk that the OOM killer will terminate the process. Therefore, a value of 2 gives better performance than the default value of 0. However, reliability can be improved by not overcommitting memory beyond the permitted range. This eliminates the risk of the process being killed by the OOM killer.
In systems without swap, there may be an issue with vm.overcommit_memory set to 2.
vm.dirty_background_ratio / vm.dirty_background_bytes
vm.dirty_background_ratio — is the percentage of memory filled with dirty pages that need to be written to disk. The flushing to disk is done in the background. The value of this parameter ranges from 0 to 100; however, a value below 5 may be ineffective, and some kernels do not support it. 10 is the default value in most Linux systems. You can improve performance for write-intensive operations with a lower ratio, which will mean that Linux will flush dirty pages in the background.
You need to set the value vm.dirty_background_bytes depending on your disk speed.
There are no 'good' values for these two parameters since both depend on hardware. However, setting vm.dirty_background_ratio to 5 and vm.dirty_background_bytes to 25% of the disk speed improves performance by ~ 25% in most cases.
vm.dirty_ratio / dirty_bytes
This is the same as vm.dirty_background_ratio / dirty_background_bytes, except that the flushing occurs in the active session, blocking the application. Therefore, vm.dirty_ratio should be higher than vm.dirty_background_ratio. This ensures that background processes are triggered earlier to avoid maximum application blocking. You can adjust the difference between these two ratios depending on your I/O load.
Result
Más beállításokat is megadhat a teljesítmény javítása érdekében, de a javulás minimális lesz, és különösebb előnyöket nem fog tapasztalni. Emlékezzünk, hogy nem minden paraméter vonatkozik minden alkalmazás típusra. Néhány alkalmazás jobban működik, amikor beállítunk bizonyos paramétereket, míg mások nem. Meg kell találnia a megfelelő egyensúlyt ezeknek a paramétereknek a konfigurációi között az elvárt munkaterhelés és az alkalmazás típusa szerint, és a beállítás során figyelembe kell venni az operációs rendszer viselkedését. A kernel paraméterek beállítása nem olyan egyszerű, mint az adatbázis-paramétereké: itt nehezebb ajánlásokat adni.
Forrás: habr.com
