Optimale PostgreSQL-prestaties zijn afhankelijk van correct gedefinieerde besturingssysteemparameters. Slecht geconfigureerde OS-kernelinstellingen kunnen resulteren in slechte prestaties van de databaseserver. Daarom is het absoluut noodzakelijk dat deze instellingen worden geconfigureerd in overeenstemming met de databaseserver en zijn werklast. In dit bericht bespreken we enkele belangrijke Linux-kernelparameters die de prestaties van de databaseserver kunnen beïnvloeden en hoe we deze kunnen configureren.
SHMMAX / SHMALL
SHMMAX is een kernelparameter die wordt gebruikt om de maximale grootte te bepalen van een enkel gedeeld geheugensegment dat een Linux-proces kan toewijzen. Vóór versie 9.2 gebruikte PostgreSQL System V (SysV), waarvoor de SHMMAX-instelling vereist is. Na 9.2 schakelde PostgreSQL over op gedeeld POSIX-geheugen. Er zijn nu dus minder bytes van het gedeelde System V-geheugen vereist.
Vóór versie 9.3 was SHMMAX de belangrijkste kernelparameter. De SHMMAX-waarde wordt opgegeven in bytes.
Evenzo SCHMAL is een andere kernelparameter die wordt gebruikt om te bepalen
systeembreed volume van gedeelde geheugenpagina's. Gebruik de opdracht om de huidige SHMMAX-, SHMALL- of SHMMIN-waarden te bekijken ipc's.
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 gebruikt Systeem V IPC om gedeeld geheugen toe te wijzen. Deze parameter is een van de belangrijkste kernelparameters. Wanneer u de volgende foutmeldingen ontvangt, betekent dit dat u een oudere versie van PostgreSQL heeft en dat uw SHMMAX-waarde erg laag is. Van gebruikers wordt verwacht dat ze de waarde aanpassen en verhogen op basis van het gedeelde geheugen dat ze willen gebruiken.
Mogelijke configuratiefouten
Als SHMMAX niet correct is geconfigureerd, ontvangt u mogelijk een foutmelding wanneer u probeert een PostgreSQL-cluster te initialiseren met behulp van de opdracht begindb.
initdb-fout
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.
You can either reduce the request size or reconfigure the kernel with larger SHMMAX. To reduce the request size (currently 2072576 bytes),
reduce PostgreSQL's shared memory usage, perhaps by reducing shared_buffers or max_connections.
If the request size is already small, it's possible that it is less than your kernel's SHMMIN parameter,
in which case raising the request size or reconfiguring SHMMIN is called for.
The PostgreSQL documentation contains more information about shared memory configuration. child process exited with exit code 1
Op dezelfde manier kunt u een foutmelding krijgen wanneer u de PostgreSQL-server start met behulp van de opdracht pg_ctl.
pg_ctl Fout
DETAIL: Failed system call was 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.
You can either reduce the request size or reconfigure the kernel with larger SHMMAX.; To reduce the request size (currently 14385152 bytes), reduce PostgreSQL's shared memory usage, perhaps by reducing shared_buffers or max_connections.
If the request size is already small, it's possible that it is less than your kernel's SHMMIN parameter,
in which case raising the request size or reconfiguring SHMMIN is called for.
The PostgreSQL documentation contains more information about shared memory configuration.
De verschillen in definities begrijpen
Het definiëren van de SHMMAX/SHMALL-parameters is enigszins anders op Linux en MacOS X:
- Linux: kernel.shmmax, kernel.shmall
- MacOS X: kern.sysv.shmmax, kern.sysv.shmall
Team sysctl kan worden gebruikt om de waarde tijdelijk te wijzigen. Om constante waarden in te stellen, voegt u een item toe aan /etc/sysctl.conf. Details vindt u hieronder.
Kernelinstellingen wijzigen op MacOS X
# 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 -> 16777216Kernelparameters wijzigen op Linux
# 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 -> 16777216е абудьте: Om wijzigingen permanent te maken, voegt u deze waarden toe aan /etc/sysctl.conf
Enorme pagina's
Linux gebruikt standaard 4 KB geheugenpagina's, BSD gebruikt XNUMX KB geheugenpagina's. Super pagina'sen op Windows - Grote pagina's. Een pagina is een stukje RAM dat aan een proces is toegewezen. Een proces kan meerdere pagina's hebben, afhankelijk van de geheugenvereisten. Hoe meer geheugen een proces nodig heeft, hoe meer pagina's eraan worden toegewezen. Het besturingssysteem houdt een paginatoewijzingstabel bij voor processen. Hoe kleiner het paginaformaat, hoe groter de tabel, hoe langer het duurt om een pagina in die paginatabel te vinden. Grote pagina's maken het daarom mogelijk grote hoeveelheden geheugen te gebruiken met minder overhead; minder paginaweergaven, minder paginafouten, snellere lees-/schrijfbewerkingen over grotere buffers. Het resultaat is een betere prestatie.
PostgreSQL ondersteunt alleen grote pagina's op Linux. Standaard gebruikt Linux 4 KB geheugenpagina's, dus in gevallen waarin er te veel geheugenbewerkingen zijn, is het noodzakelijk om grotere pagina's in te stellen. Prestatieverbeteringen worden waargenomen bij het gebruik van grote pagina's van 2 MB en maximaal 1 GB. Het grote paginaformaat kan tijdens het opstarten worden ingesteld. U kunt eenvoudig de grote paginaparameters en hun gebruik op uw Linux-machine controleren met behulp van de opdracht cat /proc/meminfo | grep -ik enorm.
Informatie verkrijgen over grote pagina's (alleen Linux)
Note: This is only for Linux, for other OS this operation is ignored$ 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 kBHoewel in dit voorbeeld het grote paginaformaat is ingesteld op 2048 (2 MB), is het totale aantal grote pagina's ingesteld op 0. Dit betekent dat grote pagina's zijn uitgeschakeld.
Script voor het bepalen van het aantal grote pagina's
Dit eenvoudige script retourneert het vereiste aantal grote pagina's. Voer het script uit op uw Linux-server terwijl PostgreSQL actief is. Zorg ervoor dat dit voor de omgevingsvariabele is $PGDATA De PostgreSQL-gegevensmap is opgegeven.
Het aantal vereiste grote pagina's verkrijgen
#!/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: $hpDe scriptuitvoer ziet er als volgt uit:
Scriptuitvoer
Pid: 12737
VmPeak: 180932 kB
Hugepagesize: 2048 kB
Set Huge Pages: 88De aanbevolen waarde voor grote pagina's is 88, dus u moet deze instellen op 88.
Grote pagina's installeren
sysctl -w vm.nr_hugepages=88Controleer nu grote pagina's, u zult zien dat er geen grote pagina's worden gebruikt (HugePages_Free = HugePages_Total).
Grote pagina's opnieuw bezocht (alleen Linux)
$ 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 kBStel nu de parameter huge_pages in op "on" in $PGDATA/postgresql.conf en start de server opnieuw op.
Nogmaals informatie over grote pagina's (alleen Linux)
$ 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 kBNu kun je zien dat er maar heel weinig grote pagina's worden gebruikt. Laten we nu proberen wat gegevens aan de database toe te voegen.
Sommige databasebewerkingen om grote pagina's te recyclen
postgres=# CREATE TABLE foo(a INTEGER);
CREATE TABLE
postgres=# INSERT INTO foo VALUES(generate_Series(1,10000000));
INSERT 0 10000000Laten we eens kijken of we nu meer grote pagina's gebruiken dan voorheen.
Meer info over grote pagina's (alleen Linux)
$ 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 kBNu kun je zien dat de meeste grote pagina's worden gebruikt.
Opmerking: de hier gebruikte geschatte waarde voor HugePages is erg laag, wat geen normale waarde is voor een machine waarop een productomgeving draait. Schat het vereiste aantal pagina's voor uw systeem in en stel deze overeenkomstig in op basis van de belasting en de bronnen.
vm.swappiness
vm.swappiness is een andere kernelparameter die de databaseprestaties kan beïnvloeden. Deze optie wordt gebruikt om het gedrag van swappiness (pagina's in en uit het geheugen wisselen) op Linux te regelen. De waarde varieert van 0 tot 100. Deze bepaalt hoeveel geheugen er wordt opgeroepen of uitgewisseld. Nul betekent geen uitwisseling en 100 betekent agressieve uitwisseling.
U kunt goede prestaties verkrijgen door lagere waarden in te stellen.
Als u dit op nieuwere kernels op 0 instelt, kan dit ertoe leiden dat OOM Killer (het geheugenopschoonproces van Linux) het proces beëindigt. Het is dus veilig om deze op 1 in te stellen als u het wisselen wilt minimaliseren. De standaardwaarde in Linux is 60. Een hogere waarde zorgt ervoor dat de MMU (memory management unit) meer swapruimte gebruikt dan RAM, terwijl een lagere waarde meer gegevens/code in het geheugen houdt.
Een lagere waarde is een goede gok voor betere prestaties in PostgreSQL.
vm.overcommit_geheugen / vm.overcommit_ratio
Applicaties verwerven geheugen en geven dit vrij wanneer het niet langer nodig is. Maar in sommige gevallen krijgt de applicatie te veel geheugen en geeft dit niet vrij. Dit kan een OOM-killer veroorzaken. Dit zijn de mogelijke parameterwaarden vm.overcommit_memory met een beschrijving voor elk:
- Heuristische overcommit (standaard); kernel-gebaseerde heuristiek
- Sta overcommit toch toe
- Overdrijf het niet en overschrijd de overcommit-ratio niet.
Ссылка:
vm.overcommit_ratio — percentage RAM beschikbaar voor overbelasting. Een waarde van 50% op een systeem met 2 GB RAM kan maximaal 3 GB RAM toewijzen.
Een waarde van 2 voor vm.overcommit_memory levert betere prestaties voor PostgreSQL. Deze waarde maximaliseert het RAM-gebruik van het serverproces zonder enig significant risico te worden gedood door het OOM killer-proces. De applicatie kan opnieuw worden geladen, maar alleen binnen de grenzen van de overschrijding, waardoor het risico kleiner wordt dat een OOM-killer het proces beëindigt. Daarom geeft een waarde van 2 betere prestaties dan de standaardwaarde van 0. De betrouwbaarheid kan echter worden verbeterd door ervoor te zorgen dat geheugen buiten het bereik niet overbelast wordt. Dit elimineert het risico dat het proces wordt beëindigd door een OOM-killer.
Op systemen zonder swapping kan er een probleem optreden met vm.overcommit_memory gelijk aan 2.
vm.dirty_background_ratio / vm.dirty_background_bytes
vm.dirty_background_ratio is het percentage geheugen dat gevuld is met vuile pagina's die naar de schijf moeten worden geschreven. Het doorspoelen naar schijf vindt op de achtergrond plaats. De waarde van deze parameter varieert van 0 tot 100; een waarde lager dan 5 kan echter ineffectief zijn en sommige kernels ondersteunen dit niet. 10 is de standaard op de meeste Linux-systemen. Je kunt de prestaties voor schrijfintensieve bewerkingen met een kleinere factor verbeteren, wat betekent dat Linux vuile pagina's op de achtergrond zal wegspoelen.
U moet de waarde instellen vm.dirty_background_bytes afhankelijk van de snelheid van uw rit.
Er zijn geen "goede" waarden voor deze twee parameters, omdat beide afhankelijk zijn van de hardware. Als u echter vm.dirty_background_ratio instelt op 5 en vm.dirty_background_bytes op 25% van de schijfsnelheid, worden de prestaties in de meeste gevallen verbeterd tot ~25%.
vm.dirty_ratio/dirty_bytes
Het is hetzelfde als vm.dirty_background_ratio/dirty_background_bytes, behalve dat de reset wordt uitgevoerd in een werksessie, waardoor de toepassing wordt geblokkeerd. Daarom moet vm.dirty_ratio hoger zijn dan vm.dirty_background_ratio. Dit zorgt ervoor dat achtergrondprocessen eerder starten om te voorkomen dat de applicatie zoveel mogelijk wordt geblokkeerd. U kunt het verschil tussen deze twee verhoudingen aanpassen, afhankelijk van de I/O-belasting van de schijf.
Totaal
U kunt andere instellingen aanpassen om de prestaties te verbeteren, maar de verbeteringen zullen minimaal zijn en u zult niet veel voordeel zien. We moeten niet vergeten dat niet alle opties op alle soorten toepassingen van toepassing zijn. Sommige apps werken beter als we sommige instellingen aanpassen, en andere niet. U moet de juiste balans vinden tussen het configureren van deze instellingen voor uw verwachte werklast en toepassingstype, en u moet bij het afstemmen ook rekening houden met het gedrag van het besturingssysteem. Het configureren van kernelparameters is niet zo eenvoudig als het configureren van databaseparameters; het is moeilijker om aanbevelingen te doen.
Bron: www.habr.com