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

ਜਦੋਂ ਵਿੱਚ Linux сервер базы данных непредвиденно завершает работу, нужно найти причину. Причин может быть несколько. Например, SIGSEGV — ਬੈਕਐਂਡ ਸਰਵਰ ਵਿੱਚ ਇੱਕ ਬੱਗ ਕਾਰਨ ਅਸਫਲਤਾ। ਪਰ ਇਹ ਦੁਰਲੱਭ ਹੈ. ਅਕਸਰ, ਤੁਹਾਡੀ ਡਿਸਕ ਸਪੇਸ ਜਾਂ ਮੈਮੋਰੀ ਖਤਮ ਹੋ ਜਾਂਦੀ ਹੈ। ਜੇਕਰ ਤੁਹਾਡੀ ਡਿਸਕ ਸਪੇਸ ਖਤਮ ਹੋ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਸਿਰਫ ਇੱਕ ਤਰੀਕਾ ਹੈ - ਸਪੇਸ ਖਾਲੀ ਕਰੋ ਅਤੇ ਡੇਟਾਬੇਸ ਨੂੰ ਰੀਸਟਾਰਟ ਕਰੋ।

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

ਜਦੋਂ ਤੁਸੀਂ ਸਰਵਰ или процесса заканчивается память, Linux предлагает 2 пути решения: обрушить всю систему или завершить процесс (приложение), который съедает память. Лучше, конечно, завершить процесс и спасти ОС от аварийного завершения. В двух словах, Out-Of-Memory Killer — это процесс, который завершает приложение, чтобы спасти ядро от сбоя. Он жертвует приложением, чтобы сохранить работу ОС. Давайте сначала обсудим, как работает OOM и как его контролировать, а потом посмотрим, как OOM Killer решает, какое приложение завершить.

Одна из главных задач Linux — выделять память процессам, когда они ее просят. Обычно процесс или приложение запрашивают у ОС память, а сами используют ее не полностью. Если ОС будет выдавать память всем, кто ее просит, но не планирует использовать, очень скоро память закончится, и система откажет. Чтобы этого избежать, ОС резервирует память за процессом, но фактически не выдает ее. Память выделяется, только когда процесс действительно собирается ее использовать. Случается, что у ОС нет свободной памяти, но она закрепляет память за процессом, и когда процессу она нужна, ОС выделяет ее, если может. Минус в том, что иногда ОС резервирует память, но в нужный момент свободной памяти нет, и происходит сбой системы. 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-ਕਿਲਰ ਨੂੰ ਕਿਵੇਂ ਕੰਟਰੋਲ ਕਰਨਾ ਹੈ

В Linux можно включать и отключать OOM-Killer (хотя последнее не рекомендуется). Для включения и отключения используйте параметр 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-Killer можно не только включать и выключать. Мы уже говорили, что Linux может зарезервировать для процессов больше памяти, чем есть, но не выделять ее по факту, и этим поведением управляет параметр ядра Linux. За это отвечает переменная 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