🥇ನೆನಪಿನ ಕೊರತೆಯ ಕಿಲ್ಲರ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗುತ್ತಿದೆ Linux ಪೋಸ್ಟ್‌ಗ್ರೆಎಸ್‌ಕ್ಯೂಎಲ್‌ಗಾಗಿ

ಯಾವಾಗ ಒಳಗೆ Linux ಡೇಟಾಬೇಸ್ ಸರ್ವರ್ ಅನಿರೀಕ್ಷಿತವಾಗಿ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ, ಮತ್ತು ಕಾರಣವನ್ನು ನಿರ್ಧರಿಸಬೇಕಾಗಿದೆ. ಹಲವಾರು ಕಾರಣಗಳಿರಬಹುದು. ಉದಾಹರಣೆಗೆ, SIGSEGV - ಬ್ಯಾಕೆಂಡ್ ಸರ್ವರ್‌ನಲ್ಲಿನ ದೋಷದಿಂದಾಗಿ ವೈಫಲ್ಯ. ಆದರೆ ಇದು ಅಪರೂಪ. ಹೆಚ್ಚಾಗಿ, ನೀವು ಡಿಸ್ಕ್ ಸ್ಥಳ ಅಥವಾ ಮೆಮೊರಿಯ ಕೊರತೆಯನ್ನು ಹೊಂದಿರುತ್ತೀರಿ. ನಿಮ್ಮ ಡಿಸ್ಕ್ ಸ್ಥಳಾವಕಾಶವಿಲ್ಲದಿದ್ದರೆ, ಒಂದೇ ಒಂದು ಮಾರ್ಗವಿದೆ - ಜಾಗವನ್ನು ಮುಕ್ತಗೊಳಿಸಿ ಮತ್ತು ಡೇಟಾಬೇಸ್ ಅನ್ನು ಮರುಪ್ರಾರಂಭಿಸಿ.

ಔಟ್-ಆಫ್-ಮೆಮೊರಿ ಕಿಲ್ಲರ್

ನೀವು ಯಾವಾಗ ಸರ್ವರ್ ಅಥವಾ ಪ್ರಕ್ರಿಯೆಯು ಮೆಮೊರಿ ಖಾಲಿಯಾಗುತ್ತದೆ, Linux ಮೆಮೊರಿಯಿಂದ ಹೊರಗಿರುವ ಕಿಲ್ಲರ್ ಎರಡು ಪರಿಹಾರಗಳನ್ನು ನೀಡುತ್ತದೆ: ಇಡೀ ವ್ಯವಸ್ಥೆಯನ್ನು ಕ್ರ್ಯಾಶ್ ಮಾಡುವುದು ಅಥವಾ ಮೆಮೊರಿಯನ್ನು ತಿನ್ನುತ್ತಿರುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು (ಅಪ್ಲಿಕೇಶನ್) ಕೊನೆಗೊಳಿಸುವುದು. ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕೊನೆಗೊಳಿಸಿ OS ಅನ್ನು ಕ್ರ್ಯಾಶ್ ಆಗದಂತೆ ಉಳಿಸುವುದು ಉತ್ತಮ. ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಹೇಳುವುದಾದರೆ, ಮೆಮೊರಿಯಿಂದ ಹೊರಗಿರುವ ಕಿಲ್ಲರ್ ಎನ್ನುವುದು ಕರ್ನಲ್ ಕ್ರ್ಯಾಶ್ ಆಗದಂತೆ ಉಳಿಸಲು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಕೊನೆಗೊಳಿಸುವ ಪ್ರಕ್ರಿಯೆಯಾಗಿದೆ. OS ಅನ್ನು ಚಾಲನೆಯಲ್ಲಿಡಲು ಇದು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ತ್ಯಾಗ ಮಾಡುತ್ತದೆ. ಮೊದಲು OOM ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಹೇಗೆ ನಿಯಂತ್ರಿಸುವುದು ಎಂಬುದನ್ನು ಚರ್ಚಿಸೋಣ, ಮತ್ತು ನಂತರ OOM ಕಿಲ್ಲರ್ ಯಾವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಕೊನೆಗೊಳಿಸಬೇಕೆಂದು ನಿರ್ಧರಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನೋಡೋಣ.

ಮುಖ್ಯ ಕಾರ್ಯಗಳಲ್ಲಿ ಒಂದು Linux — ಪ್ರಕ್ರಿಯೆಗಳು ವಿನಂತಿಸಿದಾಗ ಮೆಮೊರಿಯನ್ನು ನಿಯೋಜಿಸಿ. ವಿಶಿಷ್ಟವಾಗಿ, ಒಂದು ಪ್ರಕ್ರಿಯೆ ಅಥವಾ ಅಪ್ಲಿಕೇಶನ್ OS ನಿಂದ ಮೆಮೊರಿಯನ್ನು ವಿನಂತಿಸುತ್ತದೆ ಆದರೆ ಅದನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಬಳಸುವುದಿಲ್ಲ. OS ಅದನ್ನು ವಿನಂತಿಸುವ ಎಲ್ಲರಿಗೂ ಮೆಮೊರಿಯನ್ನು ನಿಯೋಜಿಸಿದರೆ ಆದರೆ ಅದನ್ನು ಬಳಸಲು ಯೋಜಿಸದಿದ್ದರೆ, ಸಿಸ್ಟಮ್ ತ್ವರಿತವಾಗಿ ಮೆಮೊರಿಯನ್ನು ಖಾಲಿ ಮಾಡುತ್ತದೆ ಮತ್ತು ಸಿಸ್ಟಮ್ ಕ್ರ್ಯಾಶ್ ಆಗುತ್ತದೆ. ಇದನ್ನು ತಡೆಯಲು, OS ಒಂದು ಪ್ರಕ್ರಿಯೆಗಾಗಿ ಮೆಮೊರಿಯನ್ನು ಕಾಯ್ದಿರಿಸುತ್ತದೆ ಆದರೆ ವಾಸ್ತವವಾಗಿ ಅದನ್ನು ನಿಯೋಜಿಸುವುದಿಲ್ಲ. ಒಂದು ಪ್ರಕ್ರಿಯೆಯು ನಿಜವಾಗಿಯೂ ಅದನ್ನು ಬಳಸಲು ಉದ್ದೇಶಿಸಿದಾಗ ಮಾತ್ರ ಮೆಮೊರಿಯನ್ನು ಹಂಚಲಾಗುತ್ತದೆ. ಕೆಲವೊಮ್ಮೆ OS ಉಚಿತ ಮೆಮೊರಿಯನ್ನು ಹೊಂದಿಲ್ಲ, ಆದರೆ ಅದು ಒಂದು ಪ್ರಕ್ರಿಯೆಗೆ ಮೆಮೊರಿಯನ್ನು ನಿಯೋಜಿಸುತ್ತದೆ, ಮತ್ತು ಪ್ರಕ್ರಿಯೆಗೆ ಅದು ಅಗತ್ಯವಿದ್ದಾಗ, OS ಸಾಧ್ಯವಾದರೆ ಅದನ್ನು ಹಂಚುತ್ತದೆ. ಅನಾನುಕೂಲವೆಂದರೆ ಕೆಲವೊಮ್ಮೆ OS ಮೆಮೊರಿಯನ್ನು ಕಾಯ್ದಿರಿಸುತ್ತದೆ, ಆದರೆ ಅಗತ್ಯವಿದ್ದಾಗ, ಯಾವುದೇ ಉಚಿತ ಮೆಮೊರಿ ಇರುವುದಿಲ್ಲ, ಇದು ಸಿಸ್ಟಮ್ ಕ್ರ್ಯಾಶ್‌ಗೆ ಕಾರಣವಾಗುತ್ತದೆ. ಈ ಸನ್ನಿವೇಶದಲ್ಲಿ OOM ಪ್ರಮುಖ ಪಾತ್ರ ವಹಿಸುತ್ತದೆ, ಕರ್ನಲ್ ಭಯಭೀತರಾಗುವುದನ್ನು ತಡೆಯಲು ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಕೊನೆಗೊಳಿಸುತ್ತದೆ. PostgreSQL ಪ್ರಕ್ರಿಯೆಯನ್ನು ಬಲವಂತವಾಗಿ ಕೊನೆಗೊಳಿಸಿದಾಗ, ಈ ಕೆಳಗಿನ ಸಂದೇಶವು ಲಾಗ್‌ನಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ:

Out of Memory: Killed process 12345 (postgres).

ಸಿಸ್ಟಮ್ ಮೆಮೊರಿಯಲ್ಲಿ ಕಡಿಮೆಯಿದ್ದರೆ ಮತ್ತು ಅದನ್ನು ಮುಕ್ತಗೊಳಿಸಲಾಗದಿದ್ದರೆ, ಕಾರ್ಯವನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ out_of_memory. ಈ ಹಂತದಲ್ಲಿ, ಅವಳು ಮಾಡಲು ಒಂದೇ ಒಂದು ಕೆಲಸ ಉಳಿದಿದೆ - ಒಂದು ಅಥವಾ ಹೆಚ್ಚಿನ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಪೂರ್ಣಗೊಳಿಸಿ. OOM-ಕಿಲ್ಲರ್ ಪ್ರಕ್ರಿಯೆಯನ್ನು ತಕ್ಷಣವೇ ಕೊನೆಗೊಳಿಸಬೇಕೇ ಅಥವಾ ಅದು ಕಾಯಬಹುದೇ? ನಿಸ್ಸಂಶಯವಾಗಿ, out_of_memory ಎಂದು ಕರೆಯಲ್ಪಟ್ಟಾಗ, ಇದು I/O ಕಾರ್ಯಾಚರಣೆಗಾಗಿ ಅಥವಾ ಡಿಸ್ಕ್‌ಗೆ ಪೇಜಿಂಗ್‌ಗಾಗಿ ಕಾಯುವಿಕೆಯಿಂದ ಉಂಟಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ, OOM ಕೊಲೆಗಾರನು ಮೊದಲು ತಪಾಸಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಬೇಕು ಮತ್ತು ಅವುಗಳ ಆಧಾರದ ಮೇಲೆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕೊನೆಗೊಳಿಸಬೇಕೆಂದು ನಿರ್ಧರಿಸಬೇಕು. ಕೆಳಗಿನ ಎಲ್ಲಾ ತಪಾಸಣೆಗಳು ಧನಾತ್ಮಕವಾಗಿದ್ದರೆ, OOM ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕೊನೆಗೊಳಿಸುತ್ತದೆ.

ಪ್ರಕ್ರಿಯೆ ಆಯ್ಕೆ

ಮೆಮೊರಿ ಖಾಲಿಯಾದಾಗ, ಕಾರ್ಯವನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ out_of_memory(). ಇದು ಒಂದು ಕಾರ್ಯವನ್ನು ಹೊಂದಿದೆ select_bad_process(), ಇದು ಕಾರ್ಯದಿಂದ ಮೌಲ್ಯಮಾಪನವನ್ನು ಪಡೆಯುತ್ತದೆ badness(). "ಕೆಟ್ಟ" ಪ್ರಕ್ರಿಯೆಯನ್ನು ಗುರಿಪಡಿಸಲಾಗುತ್ತದೆ. ಕಾರ್ಯ badness() ಕೆಲವು ನಿಯಮಗಳ ಪ್ರಕಾರ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಆಯ್ಕೆಮಾಡುತ್ತದೆ.

ಕರ್ನಲ್‌ಗೆ ಕೆಲವು ಕನಿಷ್ಟ ಮೆಮೊರಿಯ ಅಗತ್ಯವಿದೆ.
ನೀವು ಸಾಕಷ್ಟು ಮೆಮೊರಿಯನ್ನು ಮುಕ್ತಗೊಳಿಸಬೇಕಾಗಿದೆ.
ಕಡಿಮೆ ಮೆಮೊರಿಯನ್ನು ಬಳಸುವ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಕೊನೆಗೊಳಿಸುವ ಅಗತ್ಯವಿಲ್ಲ.
ಕನಿಷ್ಠ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಪೂರ್ಣಗೊಳಿಸಬೇಕಾಗಿದೆ.
ಬಳಕೆದಾರರು ಸ್ವತಃ ಪೂರ್ಣಗೊಳಿಸಲು ಬಯಸುವ ಪ್ರಕ್ರಿಯೆಗಳಿಗೆ ಪೂರ್ಣಗೊಳ್ಳುವ ಸಾಧ್ಯತೆಗಳನ್ನು ಹೆಚ್ಚಿಸುವ ಸಂಕೀರ್ಣ ಕ್ರಮಾವಳಿಗಳು.

ಈ ಎಲ್ಲಾ ಪರಿಶೀಲನೆಗಳನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ ನಂತರ, OOM ಸ್ಕೋರ್ ಅನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ (oom_score) OOM ನೇಮಿಸುತ್ತದೆ oom_score ಪ್ರತಿ ಪ್ರಕ್ರಿಯೆ, ಮತ್ತು ನಂತರ ಈ ಮೌಲ್ಯವನ್ನು ಮೆಮೊರಿಯ ಪ್ರಮಾಣದಿಂದ ಗುಣಿಸುತ್ತದೆ. ದೊಡ್ಡ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುವ ಪ್ರಕ್ರಿಯೆಗಳು OOM ಕಿಲ್ಲರ್‌ಗೆ ಬಲಿಯಾಗುವ ಸಾಧ್ಯತೆ ಹೆಚ್ಚು. ರೂಟ್ ಬಳಕೆದಾರರೊಂದಿಗೆ ಸಂಯೋಜಿತವಾಗಿರುವ ಪ್ರಕ್ರಿಯೆಗಳು ಕಡಿಮೆ ಸ್ಕೋರ್ ಅನ್ನು ಹೊಂದಿವೆ ಮತ್ತು ಬಲವಂತವಾಗಿ ಕೊನೆಗೊಳ್ಳುವ ಸಾಧ್ಯತೆ ಕಡಿಮೆ.

postgres=# SELECT pg_backend_pid();
pg_backend_pid 
----------------
    3813
(1 row)

ಪೋಸ್ಟ್‌ಗ್ರೆಸ್ ಪ್ರಕ್ರಿಯೆ ID 3813 ಆಗಿದೆ, ಆದ್ದರಿಂದ ಇನ್ನೊಂದು ಶೆಲ್‌ನಲ್ಲಿ ಈ ಕರ್ನಲ್ ಪ್ಯಾರಾಮೀಟರ್ ಬಳಸಿ ಸ್ಕೋರ್ ಪಡೆಯಲು ಸಾಧ್ಯವಿದೆ oom_score:

vagrant@vagrant:~$ sudo cat /proc/3813/oom_score
2

OOM-ಕಿಲ್ಲರ್ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಕೊಲ್ಲಲು ನೀವು ಬಯಸದಿದ್ದರೆ, ಇನ್ನೊಂದು ಕರ್ನಲ್ ಆಯ್ಕೆ ಇದೆ: oom_score_adj. ನೀವು ಮೌಲ್ಯೀಕರಿಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪೂರ್ಣಗೊಳಿಸುವ ಸಾಧ್ಯತೆಗಳನ್ನು ಕಡಿಮೆ ಮಾಡಲು ದೊಡ್ಡ ಋಣಾತ್ಮಕ ಮೌಲ್ಯವನ್ನು ಸೇರಿಸಿ.

sudo echo -100 > /proc/3813/oom_score_adj

ಮೌಲ್ಯವನ್ನು ಹೊಂದಿಸಲು oom_score_adj, ಸೇವಾ ಬ್ಲಾಕ್‌ನಲ್ಲಿ OOMScoreAdjust ಅನ್ನು ಹೊಂದಿಸಿ:

[Service]
OOMScoreAdjust=-1000

ಅಥವಾ ಬಳಸಿ oomprotect ಒಂದು ತಂಡದಲ್ಲಿ rcctl.

rcctl set <i>servicename</i> oomprotect -1000

ಪ್ರಕ್ರಿಯೆಯ ಬಲವಂತದ ಮುಕ್ತಾಯ

ಒಂದು ಅಥವಾ ಹೆಚ್ಚಿನ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಈಗಾಗಲೇ ಆಯ್ಕೆ ಮಾಡಿದಾಗ, OOM-ಕಿಲ್ಲರ್ ಕಾರ್ಯವನ್ನು ಕರೆಯುತ್ತದೆ oom_kill_task(). ಈ ಕಾರ್ಯವು ಪ್ರಕ್ರಿಯೆಗೆ ಮುಕ್ತಾಯ ಸಂಕೇತವನ್ನು ಕಳುಹಿಸುತ್ತದೆ. ಮೆಮೊರಿ ಕೊರತೆಯ ಸಂದರ್ಭದಲ್ಲಿ oom_kill() ಪ್ರಕ್ರಿಯೆಗೆ SIGKILL ಸಂಕೇತವನ್ನು ಕಳುಹಿಸಲು ಈ ಕಾರ್ಯವನ್ನು ಕರೆಯುತ್ತದೆ. ಕರ್ನಲ್ ಲಾಗ್‌ಗೆ ಸಂದೇಶವನ್ನು ಬರೆಯಲಾಗಿದೆ.

Out of Memory: Killed process [pid] [name].

OOM-ಕಿಲ್ಲರ್ ಅನ್ನು ಹೇಗೆ ನಿಯಂತ್ರಿಸುವುದು

В Linux ನೀವು OOM-ಕಿಲ್ಲರ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಬಹುದು ಅಥವಾ ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಬಹುದು (ಎರಡನೆಯದನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗಿಲ್ಲ). ಅದನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲು ಅಥವಾ ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಲು, ನಿಯತಾಂಕವನ್ನು ಬಳಸಿ vm.oom-kill. ರನ್ಟೈಮ್ನಲ್ಲಿ OOM-ಕಿಲ್ಲರ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲು, ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿ sysctl.

sudo -s sysctl -w vm.oom-kill = 1

OOM-ಕಿಲ್ಲರ್ ಅನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಲು, ಅದೇ ಆಜ್ಞೆಯಲ್ಲಿ ಮೌಲ್ಯ 0 ಅನ್ನು ಸೂಚಿಸಿ:

sudo -s sysctl -w vm.oom-kill = 0

ಈ ಆಜ್ಞೆಯ ಫಲಿತಾಂಶವನ್ನು ಶಾಶ್ವತವಾಗಿ ಉಳಿಸಲಾಗುವುದಿಲ್ಲ, ಆದರೆ ಮೊದಲ ರೀಬೂಟ್ ಮಾಡುವವರೆಗೆ ಮಾತ್ರ. ನಿಮಗೆ ಹೆಚ್ಚಿನ ನಿರಂತರತೆಯ ಅಗತ್ಯವಿದ್ದರೆ, ಈ ಸಾಲನ್ನು ಫೈಲ್‌ಗೆ ಸೇರಿಸಿ /etc/sysctl.conf:

echo vm.oom-kill = 1 >>/etc/sysctl.conf

ಸಕ್ರಿಯಗೊಳಿಸಲು ಮತ್ತು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಲು ಇನ್ನೊಂದು ಮಾರ್ಗವೆಂದರೆ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಬರೆಯುವುದು panic_on_oom. ಮೌಲ್ಯವನ್ನು ಯಾವಾಗಲೂ ಪರಿಶೀಲಿಸಬಹುದು /proc.

$ cat /proc/sys/vm/panic_on_oom
0

ನೀವು ಮೌಲ್ಯವನ್ನು 0 ಗೆ ಹೊಂದಿಸಿದರೆ, ಮೆಮೊರಿ ಖಾಲಿಯಾದಾಗ, ಯಾವುದೇ ಕರ್ನಲ್ ಪ್ಯಾನಿಕ್ ಇರುವುದಿಲ್ಲ.

$ echo 0 > /proc/sys/vm/panic_on_oom

ನೀವು ಮೌಲ್ಯವನ್ನು 1 ಕ್ಕೆ ಹೊಂದಿಸಿದರೆ, ಮೆಮೊರಿ ಖಾಲಿಯಾದಾಗ, ಕರ್ನಲ್ ಪ್ಯಾನಿಕ್ ಸಂಭವಿಸುತ್ತದೆ.

echo 1 > /proc/sys/vm/panic_on_oom

ನಾವು ಈಗಾಗಲೇ ಹೇಳಿದಂತೆ OOM-ಕಿಲ್ಲರ್ ಅನ್ನು ಆನ್ ಮತ್ತು ಆಫ್ ಮಾಡಬಹುದು. Linux ಪ್ರಕ್ರಿಯೆಗಳಿಗೆ ಲಭ್ಯವಿರುವ ಮೆಮೊರಿಗಿಂತ ಹೆಚ್ಚಿನ ಮೆಮೊರಿಯನ್ನು ಕಾಯ್ದಿರಿಸಬಹುದು, ಆದರೆ ವಾಸ್ತವವಾಗಿ ಅದನ್ನು ನಿಯೋಜಿಸುವುದಿಲ್ಲ, ಮತ್ತು ಈ ನಡವಳಿಕೆಯನ್ನು ಕರ್ನಲ್ ನಿಯತಾಂಕದಿಂದ ನಿಯಂತ್ರಿಸಲಾಗುತ್ತದೆ. Linuxಇದಕ್ಕೆ ವೇರಿಯೇಬಲ್ ಕಾರಣವಾಗಿದೆ. vm.overcommit_memory.

ಇದಕ್ಕಾಗಿ ನೀವು ಈ ಕೆಳಗಿನ ಮೌಲ್ಯಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು:

0: ಹೆಚ್ಚು ಮೆಮೊರಿಯನ್ನು ಕಾಯ್ದಿರಿಸಬೇಕೆ ಅಥವಾ ಬೇಡವೇ ಎಂಬುದನ್ನು ಕರ್ನಲ್ ಸ್ವತಃ ನಿರ್ಧರಿಸುತ್ತದೆ. ಹೆಚ್ಚಿನ ಆವೃತ್ತಿಗಳಲ್ಲಿ ಇದು ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯವಾಗಿದೆ. Linux.
1: ಕರ್ನಲ್ ಯಾವಾಗಲೂ ಹೆಚ್ಚುವರಿ ಮೆಮೊರಿಯನ್ನು ಕಾಯ್ದಿರಿಸುತ್ತದೆ. ಇದು ಅಪಾಯಕಾರಿಯಾಗಿದೆ, ಏಕೆಂದರೆ ಮೆಮೊರಿ ಖಾಲಿಯಾಗಬಹುದು, ಏಕೆಂದರೆ, ಹೆಚ್ಚಾಗಿ, ಒಂದು ದಿನ ಪ್ರಕ್ರಿಯೆಗಳಿಗೆ ಇದು ಅಗತ್ಯವಿರುತ್ತದೆ.
2: ಪ್ಯಾರಾಮೀಟರ್‌ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ಮೆಮೊರಿಯನ್ನು ಕರ್ನಲ್ ಕಾಯ್ದಿರಿಸುವುದಿಲ್ಲ overcommit_ratio.

ಈ ಪ್ಯಾರಾಮೀಟರ್‌ನೊಂದಿಗೆ, ಅತಿಯಾಗಿ ಕಾಯ್ದಿರಿಸಲು ಅನುಮತಿಸಲಾದ ಮೆಮೊರಿಯ ಶೇಕಡಾವಾರು ಪ್ರಮಾಣವನ್ನು ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತೀರಿ. ಅದಕ್ಕೆ ಸ್ಥಳವಿಲ್ಲದಿದ್ದರೆ, ಯಾವುದೇ ಸ್ಮರಣೆಯನ್ನು ನಿಗದಿಪಡಿಸಲಾಗುವುದಿಲ್ಲ ಮತ್ತು ಮೀಸಲಾತಿಯನ್ನು ನಿರಾಕರಿಸಲಾಗುತ್ತದೆ. ಇದು PostgreSQL ಗೆ ಶಿಫಾರಸು ಮಾಡಲಾದ ಸುರಕ್ಷಿತ ಆಯ್ಕೆಯಾಗಿದೆ. OOM-ಕಿಲ್ಲರ್ ಮತ್ತೊಂದು ಅಂಶದಿಂದ ಪ್ರಭಾವಿತವಾಗಿರುತ್ತದೆ - ವಿನಿಮಯ ಸಾಮರ್ಥ್ಯ, ಇದು ವೇರಿಯೇಬಲ್‌ನಿಂದ ನಿಯಂತ್ರಿಸಲ್ಪಡುತ್ತದೆ cat /proc/sys/vm/swappiness. ಈ ಮೌಲ್ಯಗಳು ಪೇಜಿಂಗ್ ಅನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸಬೇಕೆಂದು ಕರ್ನಲ್‌ಗೆ ತಿಳಿಸುತ್ತದೆ. ಹೆಚ್ಚಿನ ಮೌಲ್ಯ, OOM ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕೊನೆಗೊಳಿಸುವ ಸಾಧ್ಯತೆ ಕಡಿಮೆ, ಆದರೆ I/O ಕಾರ್ಯಾಚರಣೆಗಳ ಕಾರಣದಿಂದಾಗಿ ಅದು ಡೇಟಾಬೇಸ್ ಮೇಲೆ ನಕಾರಾತ್ಮಕ ಪರಿಣಾಮ ಬೀರುತ್ತದೆ. ಮತ್ತು ಪ್ರತಿಕ್ರಮದಲ್ಲಿ - ಕಡಿಮೆ ಮೌಲ್ಯ, OOM-ಕಿಲ್ಲರ್ ಹಸ್ತಕ್ಷೇಪದ ಹೆಚ್ಚಿನ ಸಂಭವನೀಯತೆ, ಆದರೆ ಡೇಟಾಬೇಸ್ ಕಾರ್ಯಕ್ಷಮತೆ ಕೂಡ ಹೆಚ್ಚಾಗಿರುತ್ತದೆ. ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯವು 60 ಆಗಿದೆ, ಆದರೆ ಸಂಪೂರ್ಣ ಡೇಟಾಬೇಸ್ ಮೆಮೊರಿಗೆ ಸರಿಹೊಂದಿದರೆ, ಮೌಲ್ಯವನ್ನು 1 ಗೆ ಹೊಂದಿಸುವುದು ಉತ್ತಮ.

ಫಲಿತಾಂಶಗಳು

OOM-ಕಿಲ್ಲರ್‌ನಲ್ಲಿರುವ "ಕೊಲೆಗಾರ" ನಿಮ್ಮನ್ನು ಹೆದರಿಸಲು ಬಿಡಬೇಡಿ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಕೊಲೆಗಾರ ನಿಮ್ಮ ವ್ಯವಸ್ಥೆಯ ಸಂರಕ್ಷಕನಾಗಿರುತ್ತಾನೆ. ಇದು ಕೆಟ್ಟ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು "ಕೊಲ್ಲುತ್ತದೆ" ಮತ್ತು ಕ್ರ್ಯಾಶಿಂಗ್ನಿಂದ ಸಿಸ್ಟಮ್ ಅನ್ನು ಉಳಿಸುತ್ತದೆ. PostgreSQL ಅನ್ನು ಅಂತ್ಯಗೊಳಿಸಲು OOM-ಕಿಲ್ಲರ್ ಅನ್ನು ಬಳಸುವುದನ್ನು ತಪ್ಪಿಸಲು, ಹೊಂದಿಸಿ vm.overcommit_memory ಮೌಲ್ಯ 2. OOM-ಕಿಲ್ಲರ್ ಮಧ್ಯಪ್ರವೇಶಿಸಬೇಕಾಗಿಲ್ಲ ಎಂದು ಇದು ಖಾತರಿ ನೀಡುವುದಿಲ್ಲ, ಆದರೆ ಇದು PostgreSQL ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕೊನೆಗೊಳಿಸಲು ಒತ್ತಾಯಿಸುವ ಸಾಧ್ಯತೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.

ಮೂಲ: www.habr.com