Performa PostgreSQL yang optimal bergantung pada pengaturan sistem operasi yang ditentukan dengan benar. Parameter kernel OS yang dikonfigurasi dengan buruk dapat menyebabkan kinerja server database yang lambat. Oleh karena itu, pengaturan ini harus dikonfigurasi sesuai dengan server database dan beban kerjanya. Dalam posting ini, kita akan membahas beberapa parameter penting kernel Linux yang dapat memengaruhi kinerja server database dan cara menyetelnya.
SHMMAX / SHMALL
SHMMAX adalah parameter kernel yang digunakan untuk menentukan ukuran maksimum dari satu segmen memori bersama yang dapat dialokasikan oleh proses Linux. Sebelum versi 9.2, PostgreSQL menggunakan System V (SysV), yang memerlukan pengaturan SHMMAX. Setelah 9.2 PostgreSQL beralih ke memori bersama POSIX. Jadi sekarang lebih sedikit byte memori bersama System V yang diperlukan.
Sebelum versi 9.3, SHMMAX adalah parameter kernel yang paling penting. Nilai SHMMAX diberikan dalam byte.
Demikian pula KECIL adalah parameter kernel lain yang digunakan untuk menentukan
total ukuran sistem halaman memori bersama. Untuk melihat nilai SHMMAX, SHMALL, atau SHMMIN saat ini, gunakan perintah ipcs.
Detail 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) = 1Detail SHM* - 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 menggunakan Sistem V IPC untuk mengalokasikan memori bersama. Pengaturan ini adalah salah satu opsi kernel yang paling penting. Setiap kali Anda mendapatkan pesan kesalahan berikut, itu berarti Anda memiliki versi PostgreSQL yang lebih lama dan memiliki nilai SHMMAX yang sangat rendah. Pengguna diharapkan menyesuaikan dan meningkatkan nilai sesuai dengan memori bersama yang ingin mereka gunakan.
Kemungkinan Kesalahan Konfigurasi
Jika konfigurasi SHMMAX salah, Anda mungkin mendapatkan kesalahan saat mencoba menginisialisasi cluster PostgreSQL dengan perintah initdb.
kegagalan 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
Demikian pula, Anda mungkin mendapatkan kesalahan saat memulai server PostgreSQL menggunakan perintah hal_ctl.
pg_ctl Kegagalan
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.
Memahami Perbedaan Definisi
Definisi opsi SHMMAX/SHMALL sedikit berbeda di Linux dan MacOS X:
- Linux: kernel.shmmax, kernel.shmall
- MacOS X: kern.sysv.shmmax, kern.sysv.shmall
Tim sysctl dapat digunakan untuk sementara mengubah nilai. Untuk menetapkan nilai konstanta, tambahkan entri ke /etc/sysctl.conf. Detail ada di bawah.
Mengubah Opsi Kernel di 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 -> 16777216Mengubah Opsi Kernel di 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 -> 16777216Jangan lupa: untuk membuat perubahan permanen, tambahkan nilai ini ke /etc/sysctl.conf
Halaman Besar
Linux default ke halaman 4 KB, BSD default ke Halaman Super, dan di Windows Halaman Besar. Halaman adalah bagian dari RAM yang dialokasikan untuk suatu proses. Suatu proses dapat memiliki banyak halaman tergantung pada kebutuhan memori. Semakin banyak memori yang dibutuhkan suatu proses, semakin banyak halaman yang dialokasikan untuknya. OS memelihara tabel alokasi halaman untuk proses. Semakin kecil ukuran halaman, semakin besar tabel, semakin lama waktu yang dibutuhkan untuk mencari halaman di tabel halaman tersebut. Oleh karena itu, halaman besar memungkinkan penggunaan memori dalam jumlah besar dengan pengurangan overhead; tampilan halaman lebih sedikit, kesalahan halaman lebih sedikit, operasi baca/tulis lebih cepat melalui buffer yang lebih besar. Hasilnya adalah peningkatan kinerja.
PostgreSQL hanya mendukung halaman besar di Linux. Secara default, Linux menggunakan halaman memori 4 KB, jadi jika ada terlalu banyak operasi memori, perlu menginstal halaman yang lebih besar. Ada peningkatan performa saat menggunakan halaman besar 2 MB hingga 1 GB. Ukuran halaman besar dapat diatur pada waktu buka. Anda dapat dengan mudah memeriksa opsi halaman besar dan penggunaannya di mesin Linux Anda menggunakan perintah cat /proc/meminfo | grep -i besar.
Mendapatkan informasi tentang halaman besar (khusus 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 kBDalam contoh ini, meskipun ukuran halaman besar diatur ke 2048 (2 MB), jumlah total halaman besar adalah 0. Ini berarti halaman besar dinonaktifkan.
Script untuk menentukan jumlah halaman besar
Skrip sederhana ini mengembalikan jumlah halaman besar yang diperlukan. Jalankan skrip di server Linux Anda saat PostgreSQL sedang berjalan. Pastikan variabel lingkungan diatur ke $PGDATA direktori data PostgreSQL ditentukan.
Mendapatkan Jumlah Halaman Besar yang Diperlukan
#!/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: $hpOutput dari skrip terlihat seperti ini:
Keluaran skrip
Pid: 12737
VmPeak: 180932 kB
Hugepagesize: 2048 kB
Set Huge Pages: 88Nilai yang disarankan untuk halaman besar adalah 88, jadi Anda harus mengaturnya menjadi 88.
Memasang halaman besar
sysctl -w vm.nr_hugepages=88Periksa halaman besar sekarang, Anda akan melihat bahwa tidak ada halaman besar yang digunakan (HugePages_Free = HugePages_Total).
Informasi halaman besar lagi (hanya 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 kBSekarang atur opsi huge_pages ke "on" di $PGDATA/postgresql.conf dan mulai ulang server.
Informasi Halaman Besar Lagi (hanya di 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 kBSekarang Anda dapat melihat bahwa sangat sedikit halaman besar yang digunakan. Sekarang mari kita coba menambahkan beberapa data ke database.
Beberapa operasi basis data untuk mendaur ulang halaman besar
postgres=# CREATE TABLE foo(a INTEGER);
CREATE TABLE
postgres=# INSERT INTO foo VALUES(generate_Series(1,10000000));
INSERT 0 10000000Mari kita lihat apakah kita menggunakan lebih banyak halaman besar sekarang daripada sebelumnya.
Informasi selengkapnya tentang halaman besar (hanya 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 kBSekarang Anda dapat melihat bahwa sebagian besar halaman besar sedang digunakan.
Catatan: Nilai contoh untuk HugePages yang digunakan di sini sangat rendah, yang tidak normal untuk mesin produksi. Harap perkirakan jumlah halaman yang diperlukan untuk sistem Anda dan atur sesuai dengan beban dan sumber daya.
vm.swappiness
vm.swappiness adalah pengaturan kernel lain yang dapat mempengaruhi kinerja database. Pengaturan ini digunakan untuk mengontrol perilaku swappiness (halaman masuk dan keluar dari memori) di Linux. Nilainya berkisar dari 0 hingga 100. Ini menentukan berapa banyak memori yang akan di-page atau di-unload. Nol berarti tidak berbagi, dan 100 berarti berbagi secara agresif.
Anda bisa mendapatkan kinerja yang baik dengan menetapkan nilai yang lebih rendah.
Menyetelnya ke 0 pada kernel yang lebih baru dapat menyebabkan OOM Killer (proses pembersihan memori Linux) mematikan proses. Jadi aman untuk mengatur nilainya menjadi 1 jika Anda ingin meminimalkan paging. Nilai default di Linux adalah 60. Nilai yang lebih tinggi menyebabkan MMU (Memory Management Unit) menggunakan lebih banyak ruang swap daripada RAM, sedangkan nilai yang lebih rendah menyimpan lebih banyak data/kode di memori.
Nilai yang lebih rendah adalah taruhan yang bagus untuk peningkatan kinerja di PostgreSQL.
vm.overcommit_memory / vm.overcommit_ratio
Aplikasi memperoleh memori dan melepaskannya saat tidak lagi diperlukan. Namun dalam beberapa kasus, aplikasi mendapatkan terlalu banyak memori dan tidak melepaskannya. Ini dapat memicu pembunuh OOM. Berikut adalah nilai parameter yang mungkin vm.overcommit_memory dengan keterangan masing-masing:
- Overcommit heuristik (default); heuristik berbasis kernel
- Tetap izinkan overcommit
- Jangan berlebihan, jangan melebihi rasio overcommit.
Π‘ΡΡΠ»ΠΊΠ°:
vm.overcommit_ratio - persentase RAM yang tersedia untuk kelebihan beban. Nilai 50% pada sistem dengan RAM 2 GB dapat mengalokasikan hingga 3 GB RAM.
Mengatur vm.overcommit_memory ke 2 memberikan kinerja terbaik untuk PostgreSQL. Nilai ini memaksimalkan penggunaan RAM dari proses server tanpa risiko yang signifikan untuk dibunuh oleh proses pembunuh OOM. Aplikasi akan dapat melakukan reboot, tetapi hanya dalam batas overrun, yang mengurangi risiko pembunuh OOM akan mematikan proses. Oleh karena itu, nilai 2 memberikan performa yang lebih baik daripada nilai default 0. Namun, keandalan dapat ditingkatkan dengan memastikan bahwa memori di luar rentang yang diizinkan tidak kelebihan beban. Ini menghilangkan risiko proses dimatikan oleh OOM-killer.
Pada sistem non-paging, mungkin ada masalah dengan vm.overcommit_memory yang disetel ke 2.
vm.dirty_background_ratio / vm.dirty_background_bytes
vm.dirty_background_ratio adalah persentase memori yang diisi dengan halaman kotor yang perlu ditulis ke disk. Pembilasan ke disk dilakukan di latar belakang. Nilai parameter ini berkisar dari 0 hingga 100; namun, nilai di bawah 5 mungkin tidak efektif dan beberapa kernel tidak mendukungnya. 10 adalah nilai default pada sebagian besar sistem Linux. Anda dapat meningkatkan kinerja untuk operasi intensif tulis dengan faktor yang lebih kecil, yang berarti bahwa Linux akan menghapus halaman kotor di latar belakang.
Anda perlu mengatur nilainya vm.dirty_background_bytes tergantung pada kecepatan disk Anda.
Tidak ada nilai "baik" untuk kedua parameter ini, karena keduanya bergantung pada perangkat keras. Namun, menyetel vm.dirty_background_ratio ke 5 dan vm.dirty_background_bytes ke 25% dari kecepatan disk meningkatkan kinerja hingga ~25% dalam banyak kasus.
vm.dirty_ratio/dirty_bytes
Ini sama dengan vm.dirty_background_ratio/dirty_background_bytes, kecuali reset dilakukan dalam sesi kerja, memblokir aplikasi. Oleh karena itu vm.dirty_ratio harus lebih tinggi dari vm.dirty_background_ratio. Ini memastikan bahwa proses latar belakang dimulai lebih awal untuk menghindari pemblokiran aplikasi sebanyak mungkin. Anda dapat menyesuaikan perbedaan antara kedua rasio ini berdasarkan beban I/O disk.
Total
Anda dapat men-tweak pengaturan lain untuk meningkatkan performa, tetapi peningkatannya akan minimal dan Anda tidak akan mendapatkan banyak manfaat. Kita harus ingat bahwa tidak semua opsi berlaku untuk semua jenis aplikasi. Beberapa aplikasi berfungsi lebih baik saat kami menyesuaikan beberapa pengaturan dan beberapa tidak. Anda harus menemukan keseimbangan yang tepat antara konfigurasi pengaturan ini untuk beban kerja dan jenis aplikasi yang diharapkan, dan perilaku OS harus diperhitungkan saat mengonfigurasi. Menyetel parameter kernel tidak semudah mengonfigurasi parameter basis data: lebih sulit untuk membuat rekomendasi di sini.
Sumber: www.habr.com