De optimale prestaties van PostgreSQL zijn afhankelijk van correct gedefinieerde parameters van het besturingssysteem. Slecht geconfigureerde kernparameters kunnen leiden tot een verminderde prestatie van de database server. Het is daarom essentieel dat deze parameters worden afgestemd op de database server en de werklast. In deze post bespreken we enkele belangrijke Linux-kernparameters die van invloed kunnen zijn op de prestaties van de databaseserver en hoe ze te configureren.
SHMMAX / SHMALL
SHMMAX is een kernparameter die wordt gebruikt om de maximale grootte van één segment gedeelde geheugen (shared memory) te bepalen, dat een Linux-proces kan toewijzen. Tot versie 9.2 gebruikte PostgreSQL System V (SysV), waarvoor SHMMAX-configuratie vereist was. Na 9.2 stapte PostgreSQL over naar POSIX gedeeld geheugen. Hierdoor is er nu minder gedeeld geheugen van System V vereist.
Tot versie 9.3 was SHMMAX de belangrijkste kernparameter. De waarde van SHMMAX wordt ingesteld in bytes.
Evenzo, SHMALL is een andere kernparameter die wordt gebruikt om de
totaal aantal pagina's gedeelde geheugen (shared memory) systeemwijd te bepalen. Om de huidige waarden van SHMMAX, SHMALL of SHMMIN te bekijken, gebruikt u de opdracht ipcs.
SHM* Details — Linux
$ ipcs -lm
------ Gedeelde Geheugenlimieten --------
max aantal segmenten = 4096
max seg grootte (kbytes) = 1073741824
max totaal gedeeld geheugen (kbytes) = 17179869184
min seg grootte (bytes) = 1SHM* Details — MacOS X
$ ipcs -M
IPC-status vanaf als van Do Aug 16 22:20:35 PKT 2018
shminfo:
shmmax: 16777216 (max grootte gedeelde geheugensegment)
shmmin: 1 (min grootte gedeelde geheugensegment)
shmmni: 32 (max aantal gedeelde geheugen identifiers)
shmseg: 8 (max aantal gedeelde geheugen segmenten per proces)
shmall: 1024 (max hoeveelheid gedeeld geheugen in pagina's)
PostgreSQL gebruikt System V IPC voor het toewijzen van gedeeld geheugen. Deze parameter is een van de belangrijkste kernparameters. Telkens wanneer u de volgende foutmeldingen ontvangt, betekent dit dat u een oudere versie van PostgreSQL heeft en dat uw SHMMAX-waarde te laag is. Het wordt verwacht dat gebruikers de waarde corrigeren en verhogen in overeenstemming met het gedeelde geheugen dat ze van plan zijn te gebruiken.
Mogelijke configuratiefouten
Als SHMMAX verkeerd is ingesteld, kunt u een fout krijgen bij het proberen een PostgreSQL-cluster te initialiseren met de opdracht initdb.
initdb Fout
DETAIL: De mislukte systeemoproep was shmget(key=1, size=2072576, 03600).
HINT: Deze fout betekent meestal dat de aanvraag van PostgreSQL voor een gedeeld geheugensegment uw kernel's SHMMAX-parameter heeft overschreden.
Je kunt de aanvraaggrootte verkleinen of de kernel opnieuw configureren met een grotere SHMMAX. Om de aanvraaggrootte te verkleinen (momenteel 2072576 bytes),
verlaag je het gedeelde geheugengebruik van PostgreSQL, bijvoorbeeld door shared_buffers of max_connections te verlagen.
Als de aanvraaggrootte al klein is, is het mogelijk dat deze kleiner is dan de SHMMIN-parameter van je kernel,
in welk geval het aanroepen van een grotere aanvraaggrootte of het opnieuw configureren van SHMMIN nodig is.
De documentatie van PostgreSQL bevat meer informatie over de configuratie van gedeeld geheugen. child process exited with exit code 1
Evenzo kun je een fout krijgen bij het starten van de PostgreSQL-server met het commando pg_ctl.
pg_ctl Fout
DETAIL: De mislukte systeemaanroep was shmget(key=5432001, size=14385152, 03600).
HINT: Deze fout betekent meestal dat de aanvraag van PostgreSQL voor een gedeeld geheugensegment uw kernel's SHMMAX-parameter heeft overschreden.
Je kunt de aanvraaggrootte verkleinen of de kernel opnieuw configureren met een grotere SHMMAX.; Om de aanvraaggrootte te verkleinen (momenteel 14385152 bytes), verlaag je het gedeelde geheugengebruik van PostgreSQL, bijvoorbeeld door shared_buffers of max_connections te verlagen.
Als de aanvraaggrootte al klein is, is het mogelijk dat deze kleiner is dan de SHMMIN-parameter van je kernel,
in welk geval het aanroepen van een grotere aanvraaggrootte of het opnieuw configureren van SHMMIN nodig is.
De documentatie van PostgreSQL bevat meer informatie over de configuratie van gedeeld geheugen.
Begrip van de verschillen in definities
De definities van SHMMAX/SHMALL verschillen een beetje tussen Linux en MacOS X:
- Linux: kernel.shmmax, kernel.shmall
- MacOS X: kern.sysv.shmmax, kern.sysv.shmall
Opdracht , beschikbaar zijn voor kan worden gebruikt voor tijdelijke wijziging van waarden. Om permanente waarden in te stellen, voeg je een opname toe aan /etc/sysctl.conf. Details zijn hieronder vermeld.
Wijzigingen van de kernelparameters 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 -> 16777216Wijzigingen van de kernelparameters 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 -> 16777216Vergeet niet: om wijzigingen permanent te maken, voeg deze waarden toe aan /etc/sysctl.conf
Grote pagina's (Huge Pages)
In Linux worden standaard pagina's van 4 KB gebruikt, in BSD — Super Pages, en in Windows — Large Pages. Een pagina is een deel van het RAM dat aan een proces is toegewezen. Een proces kan meerdere pagina's hebben, afhankelijk van de geheugenbehoefte. Hoe meer geheugen een proces nodig heeft, hoe meer pagina's aan het proces worden toegewezen. Het besturingssysteem ondersteunt een pagina-toewijzingstabel voor processen. Hoe kleiner de pagina, hoe groter de tabel, en hoe meer tijd het kost om een pagina in deze paginatabel op te zoeken. Daarom stellen grote pagina's je in staat om een groot volume geheugen met verminderd overhead te gebruiken; minder paginaweergaven, minder paginafouten, snellere lees-/schrijfoperaties via grote buffers. Als resultaat — verbeterde prestaties.
PostgreSQL ondersteunt grote pagina's alleen op Linux. Standaard gebruikt Linux pagina's van 4 KB in het geheugen. Dus in gevallen waarin er veel geheugenbewerkingen zijn, is het noodzakelijk om pagina's van een groter formaat in te stellen. Er is een prestatieverbetering waargenomen bij gebruik van grote pagina's van 2 MB tot 1 GB. De grootte van de grote pagina kan tijdens het opstarten worden ingesteld. U kunt eenvoudig de parameters van grote pagina's en hun gebruik op uw Linux-computer controleren met het commando cat /proc/meminfo | grep -i huge.
Informatie verkrijgen over grote pagina's (alleen op Linux)
Opmerking: Dit geldt alleen voor Linux; voor andere besturingssystemen wordt deze bewerking genegeerd
$ 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 kBIn dit voorbeeld, hoewel de grootte van de grote pagina ingesteld is op 2048 (2 MB), bedraagt het totale aantal grote pagina's 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 draait. Zorg ervoor dat de omgevingsvariabele $PGDATA is ingesteld op de gegevensmap van PostgreSQL.
Verkrijgen van het aantal vereiste grote pagina's
#!/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 uitvoer van het script ziet er als volgt uit:
Uitvoer van het script
Pid: 12737
VmPeak: 180932 kB
Hugepagesize: 2048 kB
Set Huge Pages: 88De aanbevolen waarde voor grote pagina's is 88, dus u moet de waarde op 88 instellen.
Instellen van grote pagina's
sysctl -w vm.nr_hugepages=88Controleer nu grote pagina's, u ziet dat grote pagina's niet worden gebruikt (HugePages_Free = HugePages_Total).
Opnieuw informatie over grote pagina's (alleen op 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.
En opnieuw informatie over grote pagina's (alleen op 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 kunt u zien dat er zeer weinig grote pagina's worden gebruikt. Laten we nu proberen enkele gegevens aan de database toe te voegen.
Sommige databasebewerkingen voor het beheer van grote pagina's
postgres=# CREATE TABLE foo(a INTEGER);
CREATE TABLE
postgres=# INSERT INTO foo VALUES(generate_Series(1,10000000));
INSERT 0 10000000Laten we kijken of we nu meer grote pagina's gebruiken dan eerder.
Nogmaals informatie over grote pagina's (alleen op 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 kunt u zien dat het merendeel van de grote pagina's in gebruik is.
Opmerking: de geschatte waarde voor HugePages die hier wordt gebruikt, is zeer laag, wat niet normaal is voor een productieomgeving. Evalueer alstublieft het benodigde aantal pagina's voor uw systeem en stel deze dienovereenkomstig in, afhankelijk van de belasting en bronnen.
vm.swappiness
vm.swappiness — dit is een andere kernelparameter die de databaseprestaties kan beïnvloeden. Deze parameter wordt gebruikt om het gedrag van swapping (swappiness) te beheren (het in en uit wisselen van pagina's naar en uit het geheugen) in Linux. De waarde varieert van 0 tot 100. Het bepaalt hoeveel geheugen wordt gehuurd of vrijgegeven. Nul betekent uitschakelen van swap, en 100 betekent agressieve swapping.
U kunt goede prestaties behalen door lagere waarden in te stellen.
Het instellen van waarde 0 in nieuwere kernels kan ertoe leiden dat de OOM Killer (geheugenopruimproces in Linux) een proces beëindigt. Daarom kunt u veilig waarde 1 instellen als u de swapping wilt minimaliseren. De standaardwaarde in Linux is 60. Een hogere waarde zorgt ervoor dat de MMU (geheugenbeheerder) meer swapruimte gebruikt dan RAM, terwijl een lagere waarde meer gegevens/code in het geheugen behoudt.
Een lagere waarde is een goede inzet voor het verbeteren van de prestaties in PostgreSQL.
vm.overcommit_memory / vm.overcommit_ratio
Toepassingen krijgen geheugen en geven het vrij wanneer het niet meer nodig is. Maar in sommige gevallen krijgt een toepassing te veel geheugen en geeft het niet vrij. Dit kan de OOM killer activeren. Hier zijn mogelijke waarden voor deze parameter vm.overcommit_memory met een beschrijving voor elk:
- Heuristische overcommit (standaard); kernel-gebaseerde heuristiek
- Sta overcommit in alle gevallen toe
- Overcommit niet overdrijven, overschrijd de overcommit ratio niet.
Link:
vm.overcommit_ratio — percentage of RAM available for overcommitting. 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 setting maximizes memory usage by the server process without a significant risk of being killed by the OOM killer. The application can restart, but only within the overcommit limit, reducing the risk of the OOM killer terminating the process. Therefore, a value of 2 offers better performance than the default value of 0. However, reliability may improve by not overcommitting memory beyond the acceptable range. This removes the risk of the process being killed by the OOM killer.
In systems without swap, there may be an issue with vm.overcommit_memory being set to 2.
vm.dirty_background_ratio / vm.dirty_background_bytes
vm.dirty_background_ratio — this is the percentage of memory occupied by dirty pages that need to be written to disk. The writing to disk occurs in the background. This parameter value ranges from 0 to 100; however, values below 5 may be ineffective, and some kernels do not support them. A default value of 10 is typical in most Linux systems. You may increase performance for write-intensive operations with a lower ratio, which will mean that Linux will flush dirty pages to disk in the background.
You need to set the value vm.dirty_background_bytes based on the speed of your disk.
There are no 'good' values for these two parameters, as both depend on the hardware. However, setting vm.dirty_background_ratio to 5 and vm.dirty_background_bytes to 25% of the disk speed can improve 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 the maximum possible blocking of the application. You can adjust the difference between these two ratios based on disk I/O load.
Conclusie
U kunt andere instellingen configureren om de prestaties te verbeteren, maar de verbeteringen zullen minimaal zijn en u zult er niet veel voordeel van hebben. We moeten ons herinneren dat niet alle instellingen van toepassing zijn op alle soorten applicaties. Sommige applicaties presteren beter wanneer we bepaalde instellingen aanpassen, terwijl andere dat niet doen. U moet de juiste balans vinden tussen de configuraties van deze instellingen, rekening houdend met de verwachte werklast en het type applicatie, evenals met het gedrag van het besturingssysteem tijdens de configuratie. Het instellen van kernelparameters is niet zo eenvoudig als het aanpassen van database-instellingen: hier is het moeilijker om aanbevelingen te doen.
Bron: habr.com
