ಆಪ್ಟಿಮಲ್ PostgreSQL ಕಾರ್ಯಕ್ಷಮತೆ ಸರಿಯಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ನಿಯತಾಂಕಗಳನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ಕಳಪೆಯಾಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾದ OS ಕರ್ನಲ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳು ಕಳಪೆ ಡೇಟಾಬೇಸ್ ಸರ್ವರ್ ಕಾರ್ಯಕ್ಷಮತೆಗೆ ಕಾರಣವಾಗಬಹುದು. ಆದ್ದರಿಂದ, ಡೇಟಾಬೇಸ್ ಸರ್ವರ್ ಮತ್ತು ಅದರ ಕೆಲಸದ ಹೊರೆಗೆ ಅನುಗುಣವಾಗಿ ಈ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದು ಕಡ್ಡಾಯವಾಗಿದೆ. ಈ ಪೋಸ್ಟ್‌ನಲ್ಲಿ, ಡೇಟಾಬೇಸ್ ಸರ್ವರ್ ಕಾರ್ಯಕ್ಷಮತೆಯ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುವ ಕೆಲವು ಪ್ರಮುಖ ಲಿನಕ್ಸ್ ಕರ್ನಲ್ ನಿಯತಾಂಕಗಳನ್ನು ಮತ್ತು ಅವುಗಳನ್ನು ಹೇಗೆ ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದು ಎಂಬುದರ ಕುರಿತು ನಾವು ಚರ್ಚಿಸುತ್ತೇವೆ.
SHMMAX / SHMALL
SHMMAX ಲಿನಕ್ಸ್ ಪ್ರಕ್ರಿಯೆಯು ನಿಯೋಜಿಸಬಹುದಾದ ಒಂದು ಹಂಚಿಕೆಯ ಮೆಮೊರಿ ವಿಭಾಗದ ಗರಿಷ್ಟ ಗಾತ್ರವನ್ನು ನಿರ್ಧರಿಸಲು ಬಳಸಲಾಗುವ ಕರ್ನಲ್ ನಿಯತಾಂಕವಾಗಿದೆ. ಆವೃತ್ತಿ 9.2 ಕ್ಕಿಂತ ಮೊದಲು, PostgreSQL ಸಿಸ್ಟಮ್ V (SysV) ಅನ್ನು ಬಳಸಿದೆ, ಇದಕ್ಕೆ SHMMAX ಸೆಟ್ಟಿಂಗ್ ಅಗತ್ಯವಿರುತ್ತದೆ. 9.2 ರ ನಂತರ, PostgreSQL POSIX ಹಂಚಿಕೆಯ ಮೆಮೊರಿಗೆ ಬದಲಾಯಿಸಿತು. ಆದ್ದರಿಂದ ಈಗ ಸಿಸ್ಟಮ್ V ಹಂಚಿಕೆಯ ಮೆಮೊರಿಯ ಕಡಿಮೆ ಬೈಟ್‌ಗಳು ಅಗತ್ಯವಿದೆ.
ಆವೃತ್ತಿ 9.3 ಕ್ಕಿಂತ ಮೊದಲು, SHMMAX ಅತ್ಯಂತ ಪ್ರಮುಖವಾದ ಕರ್ನಲ್ ನಿಯತಾಂಕವಾಗಿತ್ತು. SHMMAX ಮೌಲ್ಯವನ್ನು ಬೈಟ್‌ಗಳಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗಿದೆ.
ಅಂತೆಯೇ, SHMALL ನಿರ್ಧರಿಸಲು ಬಳಸಲಾಗುವ ಮತ್ತೊಂದು ಕರ್ನಲ್ ನಿಯತಾಂಕವಾಗಿದೆ
ಹಂಚಿದ ಮೆಮೊರಿ ಪುಟಗಳ ಸಿಸ್ಟಮ್-ವೈಡ್ ವಾಲ್ಯೂಮ್. ಪ್ರಸ್ತುತ SHMMAX, SHMALL, ಅಥವಾ SHMMIN ಮೌಲ್ಯಗಳನ್ನು ವೀಕ್ಷಿಸಲು, ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ ipcs.
SHM* ವಿವರಗಳು - 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* ವಿವರಗಳು - 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 ಬಳಸುತ್ತದೆ ಸಿಸ್ಟಮ್ ವಿ ಐಪಿಸಿ ಹಂಚಿದ ಮೆಮೊರಿಯನ್ನು ನಿಯೋಜಿಸಲು. ಈ ನಿಯತಾಂಕವು ಪ್ರಮುಖ ಕರ್ನಲ್ ನಿಯತಾಂಕಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ನೀವು ಈ ಕೆಳಗಿನ ದೋಷ ಸಂದೇಶಗಳನ್ನು ಸ್ವೀಕರಿಸಿದಾಗಲೆಲ್ಲಾ, ನೀವು PostgreSQL ನ ಹಳೆಯ ಆವೃತ್ತಿಯನ್ನು ಹೊಂದಿರುವಿರಿ ಮತ್ತು ನಿಮ್ಮ SHMMAX ಮೌಲ್ಯವು ತುಂಬಾ ಕಡಿಮೆಯಾಗಿದೆ ಎಂದರ್ಥ. ಬಳಕೆದಾರರು ಅವರು ಬಳಸಲು ಉದ್ದೇಶಿಸಿರುವ ಹಂಚಿಕೆಯ ಮೆಮೊರಿಗೆ ಅನುಗುಣವಾಗಿ ಮೌಲ್ಯವನ್ನು ಸರಿಹೊಂದಿಸಲು ಮತ್ತು ಹೆಚ್ಚಿಸಲು ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ.
ಸಂಭವನೀಯ ತಪ್ಪು ಕಾನ್ಫಿಗರೇಶನ್ ದೋಷಗಳು
SHMMAX ಅನ್ನು ಸರಿಯಾಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡದಿದ್ದರೆ, ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು PostgreSQL ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು ಪ್ರಯತ್ನಿಸುವಾಗ ನೀವು ದೋಷವನ್ನು ಪಡೆಯಬಹುದು initdb.
initdb ವೈಫಲ್ಯ
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
ಅಂತೆಯೇ, ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು PostgreSQL ಸರ್ವರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವಾಗ ನೀವು ದೋಷವನ್ನು ಪಡೆಯಬಹುದು pg_ctl.
pg_ctl ವೈಫಲ್ಯ
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.
ವ್ಯಾಖ್ಯಾನಗಳಲ್ಲಿನ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು
SHMMAX/SHMALL ನಿಯತಾಂಕಗಳನ್ನು ವಿವರಿಸುವುದು Linux ಮತ್ತು MacOS X ನಲ್ಲಿ ಸ್ವಲ್ಪ ವಿಭಿನ್ನವಾಗಿದೆ:
- ಲಿನಕ್ಸ್: kernel.shmmax, kernel.shmall
- MacOS X: kern.sysv.shmmax, kern.sysv.shmall
ತಂಡದ sysctl ಮೌಲ್ಯವನ್ನು ತಾತ್ಕಾಲಿಕವಾಗಿ ಬದಲಾಯಿಸಲು ಬಳಸಬಹುದು. ಸ್ಥಿರ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿಸಲು, ಒಂದು ನಮೂದನ್ನು ಸೇರಿಸಿ /etc/sysctl.conf. ವಿವರಗಳು ಕೆಳಗಿವೆ.
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 -> 16777216Linux ನಲ್ಲಿ ಕರ್ನಲ್ ನಿಯತಾಂಕಗಳನ್ನು ಬದಲಾಯಿಸುವುದು
# 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ಮರೆಯಬೇಡ: ಬದಲಾವಣೆಗಳನ್ನು ಶಾಶ್ವತವಾಗಿ ಮಾಡಲು, ಈ ಮೌಲ್ಯಗಳನ್ನು /etc/sysctl.conf ಗೆ ಸೇರಿಸಿ
ಬೃಹತ್ ಪುಟಗಳು
Linux ಡೀಫಾಲ್ಟ್ ಆಗಿ 4 KB ಮೆಮೊರಿ ಪುಟಗಳನ್ನು ಬಳಸುತ್ತದೆ, BSD XNUMX KB ಮೆಮೊರಿ ಪುಟಗಳನ್ನು ಬಳಸುತ್ತದೆ. ಸೂಪರ್ ಪುಟಗಳು, ಮತ್ತು ವಿಂಡೋಸ್‌ನಲ್ಲಿ - ದೊಡ್ಡ ಪುಟಗಳು. ಪುಟವು ಪ್ರಕ್ರಿಯೆಗೆ ನಿಯೋಜಿಸಲಾದ RAM ನ ಭಾಗವಾಗಿದೆ. ಒಂದು ಪ್ರಕ್ರಿಯೆಯು ಮೆಮೊರಿ ಅವಶ್ಯಕತೆಗಳನ್ನು ಅವಲಂಬಿಸಿ ಬಹು ಪುಟಗಳನ್ನು ಹೊಂದಬಹುದು. ಪ್ರಕ್ರಿಯೆಗೆ ಹೆಚ್ಚು ಮೆಮೊರಿಯ ಅಗತ್ಯವಿರುತ್ತದೆ, ಹೆಚ್ಚು ಪುಟಗಳನ್ನು ಹಂಚಲಾಗುತ್ತದೆ. ಪ್ರಕ್ರಿಯೆಗಳಿಗಾಗಿ OS ಪುಟ ಹಂಚಿಕೆ ಕೋಷ್ಟಕವನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ. ಪುಟದ ಗಾತ್ರವು ಚಿಕ್ಕದಾಗಿದೆ, ಟೇಬಲ್ ದೊಡ್ಡದಾಗಿದೆ, ಆ ಪುಟದ ಕೋಷ್ಟಕದಲ್ಲಿ ಪುಟವನ್ನು ಹುಡುಕಲು ಹೆಚ್ಚು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಆದ್ದರಿಂದ ದೊಡ್ಡ ಪುಟಗಳು ಕಡಿಮೆ ಓವರ್ಹೆಡ್ನೊಂದಿಗೆ ದೊಡ್ಡ ಪ್ರಮಾಣದ ಮೆಮೊರಿಯನ್ನು ಬಳಸಲು ಅನುಮತಿಸುತ್ತದೆ; ಕಡಿಮೆ ಪುಟ ವೀಕ್ಷಣೆಗಳು, ಕಡಿಮೆ ಪುಟ ದೋಷಗಳು, ದೊಡ್ಡ ಬಫರ್‌ಗಳಲ್ಲಿ ವೇಗವಾಗಿ ಓದುವ/ಬರೆಯುವ ಕಾರ್ಯಾಚರಣೆಗಳು. ಫಲಿತಾಂಶವು ಸುಧಾರಿತ ಕಾರ್ಯಕ್ಷಮತೆಯಾಗಿದೆ.
PostgreSQL Linux ನಲ್ಲಿ ದೊಡ್ಡ ಪುಟಗಳನ್ನು ಮಾತ್ರ ಬೆಂಬಲಿಸುತ್ತದೆ. ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, Linux 4 KB ಮೆಮೊರಿ ಪುಟಗಳನ್ನು ಬಳಸುತ್ತದೆ, ಆದ್ದರಿಂದ ಹೆಚ್ಚಿನ ಮೆಮೊರಿ ಕಾರ್ಯಾಚರಣೆಗಳಿರುವ ಸಂದರ್ಭಗಳಲ್ಲಿ, ದೊಡ್ಡ ಪುಟಗಳನ್ನು ಹೊಂದಿಸುವುದು ಅವಶ್ಯಕ. 2 MB ಮತ್ತು 1 GB ವರೆಗಿನ ದೊಡ್ಡ ಪುಟಗಳನ್ನು ಬಳಸುವಾಗ ಕಾರ್ಯಕ್ಷಮತೆಯ ಲಾಭಗಳನ್ನು ಗಮನಿಸಬಹುದು. ದೊಡ್ಡ ಪುಟದ ಗಾತ್ರವನ್ನು ಬೂಟ್ ಸಮಯದಲ್ಲಿ ಹೊಂದಿಸಬಹುದು. ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ನಿಮ್ಮ ಲಿನಕ್ಸ್ ಗಣಕದಲ್ಲಿ ದೊಡ್ಡ ಪುಟದ ನಿಯತಾಂಕಗಳನ್ನು ಮತ್ತು ಅವುಗಳ ಬಳಕೆಯನ್ನು ನೀವು ಸುಲಭವಾಗಿ ಪರಿಶೀಲಿಸಬಹುದು cat /proc/meminfo | grep -ನಾನು ದೊಡ್ಡದು.
ದೊಡ್ಡ ಪುಟಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಪಡೆಯುವುದು (ಲಿನಕ್ಸ್ ಮಾತ್ರ)
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 kBಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ದೊಡ್ಡ ಪುಟದ ಗಾತ್ರವನ್ನು 2048 (2 MB) ಗೆ ಹೊಂದಿಸಿದ್ದರೂ, ದೊಡ್ಡ ಪುಟಗಳ ಒಟ್ಟು ಸಂಖ್ಯೆಯನ್ನು 0 ಗೆ ಹೊಂದಿಸಲಾಗಿದೆ. ಇದರರ್ಥ ದೊಡ್ಡ ಪುಟಗಳನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಲಾಗಿದೆ.
ದೊಡ್ಡ ಪುಟಗಳ ಸಂಖ್ಯೆಯನ್ನು ನಿರ್ಧರಿಸಲು ಸ್ಕ್ರಿಪ್ಟ್
ಈ ಸರಳ ಸ್ಕ್ರಿಪ್ಟ್ ಅಗತ್ಯವಿರುವ ಸಂಖ್ಯೆಯ ದೊಡ್ಡ ಪುಟಗಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. PostgreSQL ಚಾಲನೆಯಲ್ಲಿರುವಾಗ ನಿಮ್ಮ Linux ಸರ್ವರ್‌ನಲ್ಲಿ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ರನ್ ಮಾಡಿ. ಪರಿಸರ ವೇರಿಯಬಲ್‌ಗಾಗಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ $PGDATA PostgreSQL ಡೇಟಾ ಡೈರೆಕ್ಟರಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗಿದೆ.
ಅಗತ್ಯವಿರುವ ದೊಡ್ಡ ಪುಟಗಳ ಸಂಖ್ಯೆಯನ್ನು ಪಡೆಯಲಾಗುತ್ತಿದೆ
#!/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: $hpಸ್ಕ್ರಿಪ್ಟ್ ಔಟ್ಪುಟ್ ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:
ಸ್ಕ್ರಿಪ್ಟ್ ಔಟ್ಪುಟ್
Pid: 12737
VmPeak: 180932 kB
Hugepagesize: 2048 kB
Set Huge Pages: 88ದೊಡ್ಡ ಪುಟಗಳಿಗೆ ಶಿಫಾರಸು ಮಾಡಲಾದ ಮೌಲ್ಯವು 88 ಆಗಿದೆ, ಆದ್ದರಿಂದ ನೀವು ಅದನ್ನು 88 ಕ್ಕೆ ಹೊಂದಿಸಬೇಕು.
ದೊಡ್ಡ ಪುಟಗಳನ್ನು ಸ್ಥಾಪಿಸಲಾಗುತ್ತಿದೆ
sysctl -w vm.nr_hugepages=88ಈಗ ದೊಡ್ಡ ಪುಟಗಳನ್ನು ಪರಿಶೀಲಿಸಿ, ದೊಡ್ಡ ಪುಟಗಳನ್ನು ಬಳಸಲಾಗುವುದಿಲ್ಲ ಎಂದು ನೀವು ನೋಡುತ್ತೀರಿ (HugePages_Free = HugePages_Total).
ದೊಡ್ಡ ಪುಟಗಳನ್ನು ಮರುಪರಿಶೀಲಿಸಲಾಗಿದೆ (ಲಿನಕ್ಸ್ ಮಾತ್ರ)
$ 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 kBಈಗ $PGDATA/postgresql.conf ನಲ್ಲಿ ಬೃಹತ್_ಪುಟಗಳ ನಿಯತಾಂಕವನ್ನು "ಆನ್" ಗೆ ಹೊಂದಿಸಿ ಮತ್ತು ಸರ್ವರ್ ಅನ್ನು ಮರುಪ್ರಾರಂಭಿಸಿ.
ಮತ್ತೊಮ್ಮೆ, ದೊಡ್ಡ ಪುಟಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿ (ಲಿನಕ್ಸ್ ಮಾತ್ರ)
$ 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 kBಈಗ ನೀವು ಬಹಳ ಕಡಿಮೆ ದೊಡ್ಡ ಪುಟಗಳನ್ನು ಬಳಸುತ್ತಿರುವುದನ್ನು ನೋಡಬಹುದು. ಈಗ ಡೇಟಾಬೇಸ್‌ಗೆ ಕೆಲವು ಡೇಟಾವನ್ನು ಸೇರಿಸಲು ಪ್ರಯತ್ನಿಸೋಣ.
ದೊಡ್ಡ ಪುಟಗಳನ್ನು ಮರುಬಳಕೆ ಮಾಡಲು ಕೆಲವು ಡೇಟಾಬೇಸ್ ಕಾರ್ಯಾಚರಣೆಗಳು
postgres=# CREATE TABLE foo(a INTEGER);
CREATE TABLE
postgres=# INSERT INTO foo VALUES(generate_Series(1,10000000));
INSERT 0 10000000ನಾವು ಈಗ ಮೊದಲಿಗಿಂತ ಹೆಚ್ಚು ದೊಡ್ಡ ಪುಟಗಳನ್ನು ಬಳಸುತ್ತಿದ್ದೇವೆಯೇ ಎಂದು ನೋಡೋಣ.
ದೊಡ್ಡ ಪುಟಗಳಲ್ಲಿ ಹೆಚ್ಚಿನ ಮಾಹಿತಿ (ಲಿನಕ್ಸ್ ಮಾತ್ರ)
$ 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 kBಈಗ ನೀವು ಹೆಚ್ಚಿನ ದೊಡ್ಡ ಪುಟಗಳನ್ನು ಬಳಸುತ್ತಿರುವುದನ್ನು ನೋಡಬಹುದು.
ಗಮನಿಸಿ: ಇಲ್ಲಿ ಬಳಸಲಾದ HugePages ಗಾಗಿ ಅಂದಾಜು ಮೌಲ್ಯವು ತುಂಬಾ ಕಡಿಮೆಯಾಗಿದೆ, ಇದು ಉತ್ಪನ್ನ ಪರಿಸರವನ್ನು ಚಾಲನೆ ಮಾಡುವ ಯಂತ್ರಕ್ಕೆ ಸಾಮಾನ್ಯ ಮೌಲ್ಯವಲ್ಲ. ದಯವಿಟ್ಟು ನಿಮ್ಮ ಸಿಸ್ಟಮ್‌ಗೆ ಅಗತ್ಯವಿರುವ ಪುಟಗಳ ಸಂಖ್ಯೆಯನ್ನು ಅಂದಾಜು ಮಾಡಿ ಮತ್ತು ಲೋಡ್ ಮತ್ತು ಸಂಪನ್ಮೂಲಗಳ ಆಧಾರದ ಮೇಲೆ ಅವುಗಳನ್ನು ಹೊಂದಿಸಿ.
vm.swappiness
vm.swappiness ಡೇಟಾಬೇಸ್ ಕಾರ್ಯಕ್ಷಮತೆಯ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುವ ಮತ್ತೊಂದು ಕರ್ನಲ್ ನಿಯತಾಂಕವಾಗಿದೆ. ಈ ಆಯ್ಕೆಯನ್ನು Linux ನಲ್ಲಿ ಸ್ವಾಪ್ಪಿನೆಸ್ (ಪುಟಗಳನ್ನು ಮೆಮೊರಿ ಒಳಗೆ ಮತ್ತು ಹೊರಗೆ ವಿನಿಮಯ) ನಿಯಂತ್ರಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಮೌಲ್ಯವು 0 ರಿಂದ 100 ರ ವರೆಗೆ ಇರುತ್ತದೆ. ಇದು ಎಷ್ಟು ಮೆಮೊರಿಯನ್ನು ಪೇಜ್ ಅಥವಾ ಪೇಜ್ ಔಟ್ ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ. ಶೂನ್ಯ ಎಂದರೆ ವಿನಿಮಯವಿಲ್ಲ ಮತ್ತು 100 ಎಂದರೆ ಆಕ್ರಮಣಕಾರಿ ವಿನಿಮಯ.
ಕಡಿಮೆ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿಸುವ ಮೂಲಕ ನೀವು ಉತ್ತಮ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಪಡೆಯಬಹುದು.
ಹೊಸ ಕರ್ನಲ್‌ಗಳಲ್ಲಿ ಇದನ್ನು 0 ಗೆ ಹೊಂದಿಸುವುದರಿಂದ OOM ಕಿಲ್ಲರ್ (ಲಿನಕ್ಸ್‌ನ ಮೆಮೊರಿ ಕ್ಲೀನಿಂಗ್ ಪ್ರಕ್ರಿಯೆ) ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕೊಲ್ಲಲು ಕಾರಣವಾಗಬಹುದು. ಆದ್ದರಿಂದ ನೀವು ವಿನಿಮಯವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಬಯಸಿದರೆ ಅದನ್ನು 1 ಗೆ ಹೊಂದಿಸುವುದು ಸುರಕ್ಷಿತವಾಗಿದೆ. ಲಿನಕ್ಸ್‌ನಲ್ಲಿ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯವು 60 ಆಗಿದೆ. ಹೆಚ್ಚಿನ ಮೌಲ್ಯವು MMU (ಮೆಮೊರಿ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್ ಯೂನಿಟ್) RAM ಗಿಂತ ಹೆಚ್ಚು ಸ್ವಾಪ್ ಜಾಗವನ್ನು ಬಳಸಲು ಕಾರಣವಾಗುತ್ತದೆ, ಆದರೆ ಕಡಿಮೆ ಮೌಲ್ಯವು ಹೆಚ್ಚಿನ ಡೇಟಾ/ಕೋಡ್ ಅನ್ನು ಮೆಮೊರಿಯಲ್ಲಿ ಇರಿಸುತ್ತದೆ.
PostgreSQL ನಲ್ಲಿ ಸುಧಾರಿತ ಕಾರ್ಯಕ್ಷಮತೆಗಾಗಿ ಕಡಿಮೆ ಮೌಲ್ಯವು ಉತ್ತಮ ಪಂತವಾಗಿದೆ.
vm.overcommit_memory / vm.overcommit_ratio
ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಮೆಮೊರಿಯನ್ನು ಪಡೆದುಕೊಳ್ಳುತ್ತವೆ ಮತ್ತು ಇನ್ನು ಮುಂದೆ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದಾಗ ಅದನ್ನು ಬಿಡುಗಡೆ ಮಾಡುತ್ತವೆ. ಆದರೆ ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ, ಅಪ್ಲಿಕೇಶನ್ ಹೆಚ್ಚು ಮೆಮೊರಿಯನ್ನು ಪಡೆಯುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಬಿಡುಗಡೆ ಮಾಡುವುದಿಲ್ಲ. ಇದು OOM ಕೊಲೆಗಾರನಿಗೆ ಕಾರಣವಾಗಬಹುದು. ಸಂಭವನೀಯ ನಿಯತಾಂಕ ಮೌಲ್ಯಗಳು ಇಲ್ಲಿವೆ vm.overcommit_memory ಪ್ರತಿಯೊಂದಕ್ಕೂ ವಿವರಣೆಯೊಂದಿಗೆ:
- ಹ್ಯೂರಿಸ್ಟಿಕ್ ಓವರ್ಕಮಿಟ್ (ಡೀಫಾಲ್ಟ್); ಕರ್ನಲ್ ಆಧಾರಿತ ಹ್ಯೂರಿಸ್ಟಿಕ್
- ಹೇಗಾದರೂ ಮಿತಿಮೀರಿ ಅನುಮತಿಸಿ
- ಅದನ್ನು ಅತಿಯಾಗಿ ಮಾಡಬೇಡಿ, ಮಿತಿಮೀರಿದ ಅನುಪಾತವನ್ನು ಮೀರಬೇಡಿ.
ಉಲ್ಲೇಖ:
vm.overcommit_ratio - ಓವರ್‌ಲೋಡ್‌ಗೆ ಲಭ್ಯವಿರುವ RAM ನ ಶೇಕಡಾವಾರು. 50 GB RAM ಹೊಂದಿರುವ ಸಿಸ್ಟಮ್‌ನಲ್ಲಿ 2% ಮೌಲ್ಯವು 3 GB RAM ವರೆಗೆ ನಿಯೋಜಿಸಬಹುದು.
vm.overcommit_memory ಗಾಗಿ 2 ರ ಮೌಲ್ಯವು PostgreSQL ಗಾಗಿ ಉತ್ತಮ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ. ಈ ಮೌಲ್ಯವು OOM ಕಿಲ್ಲರ್ ಪ್ರಕ್ರಿಯೆಯಿಂದ ಸಾಯುವ ಯಾವುದೇ ಗಮನಾರ್ಹ ಅಪಾಯವಿಲ್ಲದೆ ಸರ್ವರ್ ಪ್ರಕ್ರಿಯೆಯ RAM ಬಳಕೆಯನ್ನು ಗರಿಷ್ಠಗೊಳಿಸುತ್ತದೆ. ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಮರುಲೋಡ್ ಮಾಡಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ, ಆದರೆ ಮಿತಿಮೀರಿದ ಮಿತಿಯೊಳಗೆ ಮಾತ್ರ, ಇದು OOM ಕೊಲೆಗಾರ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕೊಲ್ಲುವ ಅಪಾಯವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ. ಆದ್ದರಿಂದ, 2 ರ ಮೌಲ್ಯವು 0 ರ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಕ್ಕಿಂತ ಉತ್ತಮ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ನೀಡುತ್ತದೆ. ಆದಾಗ್ಯೂ, ವ್ಯಾಪ್ತಿಯ ಹೊರಗಿನ ಮೆಮೊರಿಯನ್ನು ಓವರ್‌ಲೋಡ್ ಮಾಡದಂತೆ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವ ಮೂಲಕ ವಿಶ್ವಾಸಾರ್ಹತೆಯನ್ನು ಸುಧಾರಿಸಬಹುದು. ಇದು OOM ಕೊಲೆಗಾರನಿಂದ ಕೊಲ್ಲಲ್ಪಡುವ ಪ್ರಕ್ರಿಯೆಯ ಅಪಾಯವನ್ನು ನಿವಾರಿಸುತ್ತದೆ.
ವಿನಿಮಯ ಮಾಡದೆ ಇರುವ ಸಿಸ್ಟಂಗಳಲ್ಲಿ, 2 ಕ್ಕೆ ಸಮನಾದ vm.overcommit_memory ನೊಂದಿಗೆ ಸಮಸ್ಯೆ ಉಂಟಾಗಬಹುದು.
vm.dirty_background_ratio / vm.dirty_background_bytes
vm.dirty_background_ratio ಡಿಸ್ಕ್‌ಗೆ ಬರೆಯಬೇಕಾದ ಕೊಳಕು ಪುಟಗಳಿಂದ ತುಂಬಿದ ಮೆಮೊರಿಯ ಶೇಕಡಾವಾರು ಪ್ರಮಾಣವಾಗಿದೆ. ಡಿಸ್ಕ್‌ಗೆ ಫ್ಲಶ್ ಹಿನ್ನೆಲೆಯಲ್ಲಿ ಸಂಭವಿಸುತ್ತದೆ. ಈ ನಿಯತಾಂಕದ ಮೌಲ್ಯವು 0 ರಿಂದ 100 ರವರೆಗೆ ಇರುತ್ತದೆ; ಆದಾಗ್ಯೂ, 5 ಕ್ಕಿಂತ ಕೆಳಗಿನ ಮೌಲ್ಯವು ನಿಷ್ಪರಿಣಾಮಕಾರಿಯಾಗಿರಬಹುದು ಮತ್ತು ಕೆಲವು ಕರ್ನಲ್‌ಗಳು ಅದನ್ನು ಬೆಂಬಲಿಸುವುದಿಲ್ಲ. ಹೆಚ್ಚಿನ ಲಿನಕ್ಸ್ ಸಿಸ್ಟಮ್‌ಗಳಲ್ಲಿ 10 ಡೀಫಾಲ್ಟ್ ಆಗಿದೆ. ನೀವು ಸಣ್ಣ ಅಂಶದ ಮೂಲಕ ಬರವಣಿಗೆ-ತೀವ್ರ ಕಾರ್ಯಾಚರಣೆಗಳಿಗಾಗಿ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸಬಹುದು, ಇದರರ್ಥ Linux ಹಿನ್ನೆಲೆಯಲ್ಲಿ ಕೊಳಕು ಪುಟಗಳನ್ನು ಫ್ಲಶ್ ಮಾಡುತ್ತದೆ.
ನೀವು ಮೌಲ್ಯವನ್ನು ಹೊಂದಿಸಬೇಕಾಗಿದೆ vm.dirty_background_bytes ನಿಮ್ಮ ಡ್ರೈವ್‌ನ ವೇಗವನ್ನು ಅವಲಂಬಿಸಿ.
ಎರಡೂ ಹಾರ್ಡ್‌ವೇರ್ ಅವಲಂಬಿತವಾಗಿರುವುದರಿಂದ ಈ ಎರಡು ನಿಯತಾಂಕಗಳಿಗೆ ಯಾವುದೇ "ಉತ್ತಮ" ಮೌಲ್ಯಗಳಿಲ್ಲ. ಆದಾಗ್ಯೂ, vm.dirty_background_ratio ಅನ್ನು 5 ಮತ್ತು vm.dirty_background_bytes ಅನ್ನು 25% ಡಿಸ್ಕ್ ವೇಗಕ್ಕೆ ಹೊಂದಿಸುವುದು ಹೆಚ್ಚಿನ ಸಂದರ್ಭಗಳಲ್ಲಿ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ~25% ಗೆ ಸುಧಾರಿಸುತ್ತದೆ.
vm.dirty_ratio/dirty_bytes
ಇದು ಒಂದೇ vm.dirty_background_ratio/dirty_background_bytes, ರೀಸೆಟ್ ಅನ್ನು ವರ್ಕರ್ ಸೆಷನ್‌ನಲ್ಲಿ ನಿರ್ವಹಿಸುವುದನ್ನು ಹೊರತುಪಡಿಸಿ, ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿರ್ಬಂಧಿಸುತ್ತದೆ. ಆದ್ದರಿಂದ vm.dirty_ratio ಗಿಂತ ಹೆಚ್ಚಿರಬೇಕು vm.dirty_background_ratio. ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸಾಧ್ಯವಾದಷ್ಟು ನಿರ್ಬಂಧಿಸುವುದನ್ನು ತಪ್ಪಿಸಲು ಹಿನ್ನೆಲೆ ಪ್ರಕ್ರಿಯೆಗಳು ಮೊದಲೇ ಪ್ರಾರಂಭವಾಗುವುದನ್ನು ಇದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಡಿಸ್ಕ್ I/O ಲೋಡ್ ಅನ್ನು ಅವಲಂಬಿಸಿ ಈ ಎರಡು ಅನುಪಾತಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ನೀವು ಸರಿಹೊಂದಿಸಬಹುದು.
ಫಲಿತಾಂಶ
ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸಲು ನೀವು ಇತರ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ತಿರುಚಬಹುದು, ಆದರೆ ಸುಧಾರಣೆಗಳು ಕಡಿಮೆ ಇರುತ್ತದೆ ಮತ್ತು ನೀವು ಹೆಚ್ಚಿನ ಪ್ರಯೋಜನವನ್ನು ಕಾಣುವುದಿಲ್ಲ. ಎಲ್ಲಾ ಆಯ್ಕೆಗಳು ಎಲ್ಲಾ ರೀತಿಯ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಅನ್ವಯಿಸುವುದಿಲ್ಲ ಎಂದು ನಾವು ನೆನಪಿನಲ್ಲಿಡಬೇಕು. ನಾವು ಕೆಲವು ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಸರಿಹೊಂದಿಸಿದಾಗ ಕೆಲವು ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಮತ್ತು ಕೆಲವು ಇಲ್ಲ. ನಿಮ್ಮ ನಿರೀಕ್ಷಿತ ಕೆಲಸದ ಹೊರೆ ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ಪ್ರಕಾರಕ್ಕಾಗಿ ಈ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುವ ನಡುವೆ ನೀವು ಸರಿಯಾದ ಸಮತೋಲನವನ್ನು ಕಂಡುಹಿಡಿಯಬೇಕು ಮತ್ತು ಶ್ರುತಿ ಮಾಡುವಾಗ ನೀವು OS ನಡವಳಿಕೆಯನ್ನು ಸಹ ಪರಿಗಣಿಸಬೇಕು. ಕರ್ನಲ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದು ಡೇಟಾಬೇಸ್ ನಿಯತಾಂಕಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುವಷ್ಟು ಸುಲಭವಲ್ಲ; ಶಿಫಾರಸುಗಳನ್ನು ಮಾಡುವುದು ಹೆಚ್ಚು ಕಷ್ಟ.
ಮೂಲ: www.habr.com