PostgreSQL ਲਈ ਲੀਨਕਸ ਵਿੱਚ ਆਊਟ-ਆਫ-ਮੈਮੋਰੀ ਕਿਲਰ ਸੈਟ ਅਪ ਕਰਨਾ

ਜਦੋਂ ਇੱਕ ਡਾਟਾਬੇਸ ਸਰਵਰ ਲੀਨਕਸ ਵਿੱਚ ਅਚਾਨਕ ਬੰਦ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਕਾਰਨ ਲੱਭਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਕਈ ਕਾਰਨ ਹੋ ਸਕਦੇ ਹਨ। ਉਦਾਹਰਣ ਲਈ, SIGSEGV — ਬੈਕਐਂਡ ਸਰਵਰ ਵਿੱਚ ਇੱਕ ਬੱਗ ਕਾਰਨ ਅਸਫਲਤਾ। ਪਰ ਇਹ ਦੁਰਲੱਭ ਹੈ. ਅਕਸਰ, ਤੁਹਾਡੀ ਡਿਸਕ ਸਪੇਸ ਜਾਂ ਮੈਮੋਰੀ ਖਤਮ ਹੋ ਜਾਂਦੀ ਹੈ। ਜੇਕਰ ਤੁਹਾਡੀ ਡਿਸਕ ਸਪੇਸ ਖਤਮ ਹੋ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਸਿਰਫ ਇੱਕ ਤਰੀਕਾ ਹੈ - ਸਪੇਸ ਖਾਲੀ ਕਰੋ ਅਤੇ ਡੇਟਾਬੇਸ ਨੂੰ ਰੀਸਟਾਰਟ ਕਰੋ।

ਆਊਟ-ਆਫ-ਮੈਮੋਰੀ ਕਾਤਲ

ਜਦੋਂ ਇੱਕ ਸਰਵਰ ਜਾਂ ਪ੍ਰਕਿਰਿਆ ਮੈਮੋਰੀ ਖਤਮ ਹੋ ਜਾਂਦੀ ਹੈ, ਲੀਨਕਸ 2 ਹੱਲ ਪੇਸ਼ ਕਰਦਾ ਹੈ: ਪੂਰੇ ਸਿਸਟਮ ਨੂੰ ਕਰੈਸ਼ ਕਰੋ ਜਾਂ ਪ੍ਰਕਿਰਿਆ (ਐਪਲੀਕੇਸ਼ਨ) ਨੂੰ ਖਤਮ ਕਰੋ ਜੋ ਮੈਮੋਰੀ ਨੂੰ ਖਾ ਰਹੀ ਹੈ। ਬੇਸ਼ਕ, ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਖਤਮ ਕਰਨਾ ਅਤੇ OS ਨੂੰ ਕਰੈਸ਼ ਹੋਣ ਤੋਂ ਬਚਾਉਣਾ ਬਿਹਤਰ ਹੈ. ਸੰਖੇਪ ਰੂਪ ਵਿੱਚ, ਆਊਟ-ਆਫ-ਮੈਮੋਰੀ ਕਿਲਰ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਹੈ ਜੋ ਕਰਨਲ ਨੂੰ ਕਰੈਸ਼ ਹੋਣ ਤੋਂ ਬਚਾਉਣ ਲਈ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਮਾਰ ਦਿੰਦੀ ਹੈ। ਇਹ OS ਨੂੰ ਚੱਲਦਾ ਰੱਖਣ ਲਈ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਬਲੀ ਦਿੰਦਾ ਹੈ। ਆਉ ਪਹਿਲਾਂ ਚਰਚਾ ਕਰੀਏ ਕਿ OOM ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਕਿਵੇਂ ਨਿਯੰਤਰਿਤ ਕਰਨਾ ਹੈ, ਅਤੇ ਫਿਰ ਦੇਖੋ ਕਿ OOM ਕਿਲਰ ਕਿਸ ਤਰ੍ਹਾਂ ਇਹ ਫੈਸਲਾ ਕਰਦਾ ਹੈ ਕਿ ਕਿਹੜੀ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਖਤਮ ਕਰਨਾ ਹੈ।

ਲੀਨਕਸ ਦੇ ਮੁੱਖ ਕੰਮਾਂ ਵਿੱਚੋਂ ਇੱਕ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਮੈਮੋਰੀ ਨਿਰਧਾਰਤ ਕਰਨਾ ਹੈ ਜਦੋਂ ਉਹ ਇਸਦੀ ਮੰਗ ਕਰਦੇ ਹਨ। ਆਮ ਤੌਰ 'ਤੇ, ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਜਾਂ ਐਪਲੀਕੇਸ਼ਨ 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() ਕੁਝ ਨਿਯਮਾਂ ਅਨੁਸਾਰ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਚੁਣਦਾ ਹੈ।

1. ਕਰਨਲ ਨੂੰ ਆਪਣੇ ਲਈ ਕੁਝ ਘੱਟੋ-ਘੱਟ ਮੈਮੋਰੀ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।
2. ਤੁਹਾਨੂੰ ਬਹੁਤ ਸਾਰੀ ਮੈਮੋਰੀ ਖਾਲੀ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।
3. ਉਹਨਾਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਖਤਮ ਕਰਨ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ ਹੈ ਜੋ ਘੱਟ ਮੈਮੋਰੀ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੀਆਂ ਹਨ.
4. ਘੱਟੋ-ਘੱਟ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।
5. ਗੁੰਝਲਦਾਰ ਐਲਗੋਰਿਦਮ ਜੋ ਉਹਨਾਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਲਈ ਪੂਰਾ ਹੋਣ ਦੀ ਸੰਭਾਵਨਾ ਨੂੰ ਵਧਾਉਂਦੇ ਹਨ ਜੋ ਉਪਭੋਗਤਾ ਖੁਦ ਪੂਰਾ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹੈ।

ਇਹਨਾਂ ਸਾਰੀਆਂ ਜਾਂਚਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਤੋਂ ਬਾਅਦ, 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-Killer ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਬਿਲਕੁਲ ਖਤਮ ਕਰੇ, ਤਾਂ ਇੱਕ ਹੋਰ ਕਰਨਲ ਵਿਕਲਪ ਹੈ: 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() ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਿਗਕਿੱਲ ਸਿਗਨਲ ਭੇਜਣ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ। ਕਰਨਲ ਲੌਗ ਵਿੱਚ ਇੱਕ ਸੁਨੇਹਾ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ।

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

OOM-ਕਿਲਰ ਨੂੰ ਕਿਵੇਂ ਕੰਟਰੋਲ ਕਰਨਾ ਹੈ

ਲੀਨਕਸ 'ਤੇ, ਤੁਸੀਂ OOM-ਕਿਲਰ ਨੂੰ ਸਮਰੱਥ ਜਾਂ ਅਯੋਗ ਕਰ ਸਕਦੇ ਹੋ (ਹਾਲਾਂਕਿ ਬਾਅਦ ਦੀ ਸਿਫ਼ਾਰਸ਼ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ)। ਨੂੰ ਸਮਰੱਥ ਜਾਂ ਅਯੋਗ ਕਰਨ ਲਈ ਪੈਰਾਮੀਟਰ ਦੀ ਵਰਤੋਂ ਕਰੋ vm.oom-kill. ਰਨਟਾਈਮ 'ਤੇ OOM-ਕਿਲਰ ਨੂੰ ਸਮਰੱਥ ਕਰਨ ਲਈ, ਕਮਾਂਡ ਚਲਾਓ sysctl.

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

OOM-Killer ਨੂੰ ਅਯੋਗ ਕਰਨ ਲਈ, ਉਸੇ ਕਮਾਂਡ ਵਿੱਚ ਮੁੱਲ 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-ਕਿਲਰ ਨੂੰ ਸਿਰਫ਼ ਚਾਲੂ ਅਤੇ ਬੰਦ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਕਿਹਾ ਹੈ ਕਿ ਲੀਨਕਸ ਅਸਲ ਵਿੱਚ ਇਸ ਨੂੰ ਨਿਰਧਾਰਤ ਕੀਤੇ ਬਿਨਾਂ ਉਪਲਬਧ ਪ੍ਰਕਿਰਿਆਵਾਂ ਲਈ ਵਧੇਰੇ ਮੈਮੋਰੀ ਰਿਜ਼ਰਵ ਕਰ ਸਕਦਾ ਹੈ, ਅਤੇ ਇਹ ਵਿਵਹਾਰ ਇੱਕ ਲੀਨਕਸ ਕਰਨਲ ਪੈਰਾਮੀਟਰ ਦੁਆਰਾ ਨਿਯੰਤਰਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਵੇਰੀਏਬਲ ਇਸ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਹੈ vm.overcommit_memory.

ਤੁਸੀਂ ਇਸਦੇ ਲਈ ਹੇਠਾਂ ਦਿੱਤੇ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ:

0: ਕਰਨਲ ਖੁਦ ਫੈਸਲਾ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਬਹੁਤ ਜ਼ਿਆਦਾ ਮੈਮੋਰੀ ਰਿਜ਼ਰਵ ਕਰਨੀ ਹੈ। ਇਹ Linux ਦੇ ਜ਼ਿਆਦਾਤਰ ਸੰਸਕਰਣਾਂ 'ਤੇ ਡਿਫੌਲਟ ਹੈ।
1: ਕਰਨਲ ਹਮੇਸ਼ਾ ਵਾਧੂ ਮੈਮੋਰੀ ਰਿਜ਼ਰਵ ਕਰੇਗਾ। ਇਹ ਖ਼ਤਰਨਾਕ ਹੈ, ਕਿਉਂਕਿ ਮੈਮੋਰੀ ਖਤਮ ਹੋ ਸਕਦੀ ਹੈ, ਕਿਉਂਕਿ, ਜ਼ਿਆਦਾਤਰ ਸੰਭਾਵਨਾ ਹੈ, ਇੱਕ ਦਿਨ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਇਸਦੀ ਲੋੜ ਪਵੇਗੀ.
2: ਕਰਨਲ ਪੈਰਾਮੀਟਰ ਵਿੱਚ ਦਰਸਾਏ ਤੋਂ ਵੱਧ ਮੈਮੋਰੀ ਰਾਖਵੀਂ ਨਹੀਂ ਕਰੇਗਾ overcommit_ratio.

ਇਸ ਪੈਰਾਮੀਟਰ ਦੇ ਨਾਲ, ਤੁਸੀਂ ਮੈਮੋਰੀ ਦਾ ਪ੍ਰਤੀਸ਼ਤ ਨਿਸ਼ਚਿਤ ਕਰਦੇ ਹੋ ਜਿਸ ਨੂੰ ਓਵਰ-ਰਿਜ਼ਰਵ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ। ਜੇ ਇਸਦੇ ਲਈ ਕੋਈ ਥਾਂ ਨਹੀਂ ਹੈ, ਤਾਂ ਕੋਈ ਮੈਮੋਰੀ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ, ਅਤੇ ਰਿਜ਼ਰਵੇਸ਼ਨ ਤੋਂ ਇਨਕਾਰ ਕਰ ਦਿੱਤਾ ਜਾਵੇਗਾ। PostgreSQL ਲਈ ਇਹ ਸਭ ਤੋਂ ਸੁਰੱਖਿਅਤ ਵਿਕਲਪ ਹੈ। OOM-ਕਿਲਰ ਇੱਕ ਹੋਰ ਤੱਤ ਦੁਆਰਾ ਪ੍ਰਭਾਵਿਤ ਹੁੰਦਾ ਹੈ - ਸਵੈਪਿੰਗ ਸਮਰੱਥਾ, ਜੋ ਵੇਰੀਏਬਲ ਦੁਆਰਾ ਨਿਯੰਤਰਿਤ ਹੁੰਦੀ ਹੈ cat /proc/sys/vm/swappiness. ਇਹ ਮੁੱਲ ਕਰਨਲ ਨੂੰ ਦੱਸਦੇ ਹਨ ਕਿ ਪੇਜਿੰਗ ਨੂੰ ਕਿਵੇਂ ਸੰਭਾਲਣਾ ਹੈ। ਮੁੱਲ ਜਿੰਨਾ ਉੱਚਾ ਹੋਵੇਗਾ, ਓਨੀ ਹੀ ਘੱਟ ਸੰਭਾਵਨਾ ਹੈ ਕਿ OOM ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਖਤਮ ਕਰ ਦੇਵੇਗਾ, ਪਰ I/O ਓਪਰੇਸ਼ਨਾਂ ਦੇ ਕਾਰਨ ਇਸਦਾ ਡੇਟਾਬੇਸ 'ਤੇ ਮਾੜਾ ਪ੍ਰਭਾਵ ਪੈਂਦਾ ਹੈ। ਅਤੇ ਇਸਦੇ ਉਲਟ - ਮੁੱਲ ਜਿੰਨਾ ਘੱਟ ਹੋਵੇਗਾ, ਓਓਐਮ-ਕਿਲਰ ਦਖਲਅੰਦਾਜ਼ੀ ਦੀ ਸੰਭਾਵਨਾ ਵੱਧ ਹੈ, ਪਰ ਡੇਟਾਬੇਸ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਵੀ ਵੱਧ ਹੈ। ਪੂਰਵ-ਨਿਰਧਾਰਤ ਮੁੱਲ 60 ਹੈ, ਪਰ ਜੇਕਰ ਸਾਰਾ ਡਾਟਾਬੇਸ ਮੈਮੋਰੀ ਵਿੱਚ ਫਿੱਟ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਮੁੱਲ ਨੂੰ 1 'ਤੇ ਸੈੱਟ ਕਰਨਾ ਬਿਹਤਰ ਹੁੰਦਾ ਹੈ।

ਨਤੀਜੇ

OOM-ਕਿਲਰ ਵਿੱਚ "ਕਾਤਲ" ਨੂੰ ਤੁਹਾਨੂੰ ਡਰਾਉਣ ਨਾ ਦਿਓ। ਇਸ ਕੇਸ ਵਿੱਚ, ਕਾਤਲ ਤੁਹਾਡੇ ਸਿਸਟਮ ਦਾ ਮੁਕਤੀਦਾਤਾ ਹੋਵੇਗਾ. ਇਹ ਸਭ ਤੋਂ ਭੈੜੀਆਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ "ਮਾਰਦਾ" ਹੈ ਅਤੇ ਸਿਸਟਮ ਨੂੰ ਕਰੈਸ਼ ਹੋਣ ਤੋਂ ਬਚਾਉਂਦਾ ਹੈ। PostgreSQL ਨੂੰ ਖਤਮ ਕਰਨ ਲਈ OOM-Killer ਦੀ ਵਰਤੋਂ ਕਰਨ ਤੋਂ ਬਚਣ ਲਈ, ਇਸ 'ਤੇ ਸੈੱਟ ਕਰੋ vm.overcommit_memory ਮੁੱਲ 2. ਇਹ ਗਾਰੰਟੀ ਨਹੀਂ ਦਿੰਦਾ ਹੈ ਕਿ OOM-ਕਿਲਰ ਨੂੰ ਦਖਲ ਨਹੀਂ ਦੇਣਾ ਪਵੇਗਾ, ਪਰ ਇਹ PostgreSQL ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਮਾਪਤ ਕਰਨ ਲਈ ਮਜਬੂਰ ਕਰਨ ਦੀ ਸੰਭਾਵਨਾ ਨੂੰ ਘਟਾ ਦੇਵੇਗਾ।

ਸਰੋਤ: www.habr.com