ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦੀ ਜਾਣ-ਪਛਾਣ

ਹੇ ਹਬਰ! ਮੈਂ ਤੁਹਾਡੇ ਧਿਆਨ ਵਿੱਚ ਲੇਖਾਂ ਦੀ ਇੱਕ ਲੜੀ ਲਿਆਉਣਾ ਚਾਹਾਂਗਾ-ਮੇਰੀ ਰਾਏ ਵਿੱਚ ਇੱਕ ਦਿਲਚਸਪ ਸਾਹਿਤ ਦੇ ਅਨੁਵਾਦ - OSTEP। ਇਹ ਸਮੱਗਰੀ ਯੂਨਿਕਸ-ਵਰਗੇ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮਾਂ ਦੇ ਕੰਮ ਦੀ ਡੂੰਘਾਈ ਨਾਲ ਚਰਚਾ ਕਰਦੀ ਹੈ, ਅਰਥਾਤ, ਪ੍ਰਕਿਰਿਆਵਾਂ, ਵੱਖ-ਵੱਖ ਸ਼ਡਿਊਲਰ, ਮੈਮੋਰੀ, ਅਤੇ ਹੋਰ ਸਮਾਨ ਭਾਗਾਂ ਨਾਲ ਕੰਮ ਕਰਨਾ ਜੋ ਇੱਕ ਆਧੁਨਿਕ OS ਬਣਾਉਂਦੇ ਹਨ। ਤੁਸੀਂ ਇੱਥੇ ਸਾਰੀਆਂ ਸਮੱਗਰੀਆਂ ਦਾ ਅਸਲੀ ਦੇਖ ਸਕਦੇ ਹੋ ਇੱਥੇ. ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ ਅਨੁਵਾਦ ਗੈਰ-ਪੇਸ਼ੇਵਰ ਤੌਰ 'ਤੇ ਕੀਤਾ ਗਿਆ ਸੀ (ਕਾਫ਼ੀ ਸੁਤੰਤਰ), ਪਰ ਮੈਨੂੰ ਉਮੀਦ ਹੈ ਕਿ ਮੈਂ ਆਮ ਅਰਥ ਨੂੰ ਬਰਕਰਾਰ ਰੱਖਿਆ ਹੈ।

ਇਸ ਵਿਸ਼ੇ 'ਤੇ ਲੈਬ ਦਾ ਕੰਮ ਇੱਥੇ ਪਾਇਆ ਜਾ ਸਕਦਾ ਹੈ:

• ਮੂਲ: pages.cs.wisc.edu/~remzi/OSTEP/Homework/homework.html
• ਮੂਲ: github.com/remzi-arpacidusseau/ostep-code
• ਮੇਰਾ ਨਿੱਜੀ ਅਨੁਕੂਲਨ: github.com/bykvaadm/OS/tree/master/ostep

ਹੋਰ ਹਿੱਸੇ:

• ਭਾਗ 1: ਜਾਣ-ਪਛਾਣ

ਤੁਸੀਂ ਮੇਰੇ ਚੈਨਲ 'ਤੇ ਵੀ ਦੇਖ ਸਕਦੇ ਹੋ ਤਾਰ =)

ਆਉ ਸਭ ਤੋਂ ਬੁਨਿਆਦੀ ਐਬਸਟਰੈਕਸ਼ਨ ਨੂੰ ਵੇਖੀਏ ਜੋ OS ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ: ਪ੍ਰਕਿਰਿਆ। ਪ੍ਰਕਿਰਿਆ ਦੀ ਪਰਿਭਾਸ਼ਾ ਕਾਫ਼ੀ ਸਧਾਰਨ ਹੈ - ਇਹ ਹੈ ਚੱਲ ਰਹੇ ਪ੍ਰੋਗਰਾਮ. ਪ੍ਰੋਗਰਾਮ ਆਪਣੇ ਆਪ ਵਿੱਚ ਡਿਸਕ 'ਤੇ ਸਥਿਤ ਇੱਕ ਬੇਜਾਨ ਚੀਜ਼ ਹੈ - ਇਹ ਨਿਰਦੇਸ਼ਾਂ ਦਾ ਇੱਕ ਸਮੂਹ ਹੈ ਅਤੇ ਸੰਭਵ ਤੌਰ 'ਤੇ ਲਾਂਚ ਕੀਤੇ ਜਾਣ ਦੀ ਉਡੀਕ ਵਿੱਚ ਕੁਝ ਸਥਿਰ ਡੇਟਾ ਹੈ। ਇਹ OS ਹੈ ਜੋ ਉਹਨਾਂ ਬਾਈਟਾਂ ਨੂੰ ਲੈਂਦਾ ਹੈ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਚਲਾਉਂਦਾ ਹੈ, ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕਿਸੇ ਉਪਯੋਗੀ ਚੀਜ਼ ਵਿੱਚ ਬਦਲਦਾ ਹੈ।
ਬਹੁਤੇ ਅਕਸਰ, ਉਪਭੋਗਤਾ ਇੱਕੋ ਸਮੇਂ ਇੱਕ ਤੋਂ ਵੱਧ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਚਲਾਉਣਾ ਚਾਹੁੰਦੇ ਹਨ, ਉਦਾਹਰਨ ਲਈ, ਤੁਸੀਂ ਆਪਣੇ ਲੈਪਟਾਪ 'ਤੇ ਇੱਕ ਬ੍ਰਾਊਜ਼ਰ, ਗੇਮ, ਮੀਡੀਆ ਪਲੇਅਰ, ਟੈਕਸਟ ਐਡੀਟਰ, ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਦੇ ਹੋਰ ਨੂੰ ਚਲਾ ਸਕਦੇ ਹੋ। ਵਾਸਤਵ ਵਿੱਚ, ਇੱਕ ਆਮ ਸਿਸਟਮ ਇੱਕੋ ਸਮੇਂ ਦਸਾਂ ਜਾਂ ਸੈਂਕੜੇ ਪ੍ਰਕਿਰਿਆਵਾਂ ਚਲਾ ਸਕਦਾ ਹੈ। ਇਹ ਤੱਥ ਸਿਸਟਮ ਨੂੰ ਵਰਤਣ ਲਈ ਸੌਖਾ ਬਣਾਉਂਦਾ ਹੈ, ਤੁਹਾਨੂੰ ਕਦੇ ਵੀ ਇਸ ਬਾਰੇ ਚਿੰਤਾ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ ਕਿ ਕੀ CPU ਮੁਫ਼ਤ ਹੈ, ਤੁਸੀਂ ਸਿਰਫ਼ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਚਲਾਉਂਦੇ ਹੋ।

ਇਹ ਸਮੱਸਿਆ ਪੈਦਾ ਕਰਦਾ ਹੈ: ਬਹੁਤ ਸਾਰੇ CPUs ਦਾ ਭਰਮ ਕਿਵੇਂ ਪ੍ਰਦਾਨ ਕਰਨਾ ਹੈ? OS ਲਗਭਗ ਬੇਅੰਤ CPUs ਦਾ ਭਰਮ ਕਿਵੇਂ ਪੈਦਾ ਕਰ ਸਕਦਾ ਹੈ, ਭਾਵੇਂ ਤੁਹਾਡੇ ਕੋਲ ਸਿਰਫ ਇੱਕ ਭੌਤਿਕ CPU ਹੈ?

OS CPU ਵਰਚੁਅਲਾਈਜੇਸ਼ਨ ਦੁਆਰਾ ਇਹ ਭਰਮ ਪੈਦਾ ਕਰਦਾ ਹੈ। ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਸ਼ੁਰੂ ਕਰਨ ਨਾਲ, ਫਿਰ ਇਸਨੂੰ ਰੋਕਣਾ, ਦੂਜੀ ਪ੍ਰਕਿਰਿਆ ਸ਼ੁਰੂ ਕਰਨਾ, ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ, OS ਇਹ ਭਰਮ ਬਰਕਰਾਰ ਰੱਖ ਸਕਦਾ ਹੈ ਕਿ ਇੱਥੇ ਬਹੁਤ ਸਾਰੇ ਵਰਚੁਅਲ CPU ਹਨ, ਜਦੋਂ ਅਸਲ ਵਿੱਚ ਇੱਕ ਜਾਂ ਇੱਕ ਤੋਂ ਵੱਧ ਭੌਤਿਕ ਪ੍ਰੋਸੈਸਰ ਹੋਣਗੇ। ਇਸ ਤਕਨੀਕ ਨੂੰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਸਮੇਂ ਅਨੁਸਾਰ CPU ਸਰੋਤਾਂ ਦੀ ਵੰਡ. ਇਹ ਤਕਨੀਕ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਜਿੰਨੀਆਂ ਮਰਜ਼ੀ ਸਮਕਾਲੀ ਪ੍ਰਕਿਰਿਆਵਾਂ ਚਲਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ. ਇਸ ਹੱਲ ਦੀ ਕੀਮਤ ਪ੍ਰਦਰਸ਼ਨ ਹੈ - ਕਿਉਂਕਿ ਜੇਕਰ CPU ਨੂੰ ਕਈ ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੁਆਰਾ ਸਾਂਝਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਹਰੇਕ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਹੌਲੀ ਹੌਲੀ ਪ੍ਰਕਿਰਿਆ ਕੀਤੀ ਜਾਵੇਗੀ।
CPU ਵਰਚੁਅਲਾਈਜੇਸ਼ਨ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ, ਅਤੇ ਖਾਸ ਤੌਰ 'ਤੇ ਇਸ ਨੂੰ ਵਧੀਆ ਢੰਗ ਨਾਲ ਕਰਨ ਲਈ, OS ਨੂੰ ਹੇਠਲੇ-ਪੱਧਰ ਅਤੇ ਉੱਚ-ਪੱਧਰ ਦੀ ਸਹਾਇਤਾ ਦੀ ਲੋੜ ਹੈ। ਨੀਵੇਂ ਪੱਧਰ ਦਾ ਸਮਰਥਨ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਵਿਧੀ ਹੇਠਲੇ ਪੱਧਰ ਦੇ ਢੰਗ ਜਾਂ ਪ੍ਰੋਟੋਕੋਲ ਹਨ ਜੋ ਕਾਰਜਸ਼ੀਲਤਾ ਦੇ ਲੋੜੀਂਦੇ ਹਿੱਸੇ ਨੂੰ ਲਾਗੂ ਕਰਦੇ ਹਨ। ਅਜਿਹੀ ਕਾਰਜਸ਼ੀਲਤਾ ਦੀ ਇੱਕ ਉਦਾਹਰਨ ਪ੍ਰਸੰਗ ਸਵਿਚਿੰਗ ਹੈ, ਜੋ OS ਨੂੰ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਰੋਕਣ ਅਤੇ ਪ੍ਰੋਸੈਸਰ 'ਤੇ ਦੂਜੇ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਚਲਾਉਣ ਦੀ ਸਮਰੱਥਾ ਦਿੰਦੀ ਹੈ। ਇਹ ਸਮਾਂ ਵੰਡ ਸਾਰੇ ਆਧੁਨਿਕ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮਾਂ ਵਿੱਚ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ।
ਇਹਨਾਂ ਵਿਧੀਆਂ ਦੇ ਸਿਖਰ 'ਤੇ "ਨੀਤੀਆਂ" ਦੇ ਰੂਪ ਵਿੱਚ, OS ਵਿੱਚ ਬਣਾਇਆ ਗਿਆ ਕੁਝ ਤਰਕ ਹੈ। ਨੀਤੀ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਲਈ ਇੱਕ ਖਾਸ ਫੈਸਲਾ ਲੈਣ ਵਾਲਾ ਐਲਗੋਰਿਦਮ ਹੈ। ਅਜਿਹੀਆਂ ਨੀਤੀਆਂ, ਉਦਾਹਰਨ ਲਈ, ਇਹ ਫੈਸਲਾ ਕਰਦੀਆਂ ਹਨ ਕਿ ਕਿਹੜਾ ਪ੍ਰੋਗਰਾਮ ਪਹਿਲਾਂ ਲਾਂਚ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ (ਕਮਾਂਡਾਂ ਦੀ ਸੂਚੀ ਤੋਂ)। ਇਸ ਲਈ, ਉਦਾਹਰਨ ਲਈ, ਇਸ ਸਮੱਸਿਆ ਨੂੰ ਇੱਕ ਨੀਤੀ ਦੁਆਰਾ ਹੱਲ ਕੀਤਾ ਜਾਵੇਗਾ ਸ਼ਡਿਊਲਰ (ਤਹਿ ਨੀਤੀ) ਅਤੇ ਜਦੋਂ ਕੋਈ ਹੱਲ ਚੁਣਦੇ ਹੋ, ਤਾਂ ਇਸ ਨੂੰ ਅਜਿਹੇ ਡੇਟਾ ਦੁਆਰਾ ਸੇਧਿਤ ਕੀਤਾ ਜਾਵੇਗਾ ਜਿਵੇਂ ਕਿ: ਸਟਾਰਟਅਪ ਇਤਿਹਾਸ (ਕਿਹੜਾ ਪ੍ਰੋਗਰਾਮ ਆਖਰੀ ਮਿੰਟਾਂ ਵਿੱਚ ਸਭ ਤੋਂ ਲੰਬਾ ਲਾਂਚ ਕੀਤਾ ਗਿਆ ਸੀ), ਇਸ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਕੀ ਲੋਡ ਹੁੰਦਾ ਹੈ (ਕਿਹੋ ਜਿਹੇ ਪ੍ਰੋਗਰਾਮ ਲਾਂਚ ਕੀਤੇ ਗਏ ਸਨ), ਪ੍ਰਦਰਸ਼ਨ ਮੈਟ੍ਰਿਕਸ (ਕੀ ਸਿਸਟਮ ਇੰਟਰਐਕਟਿਵ ਪਰਸਪਰ ਕ੍ਰਿਆ ਲਈ ਜਾਂ ਥ੍ਰੁਪੁੱਟ ਲਈ ਅਨੁਕੂਲਿਤ ਹੈ) ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਦੇ ਹੋਰ।

ਐਬਸਟਰੈਕਸ਼ਨ: ਪ੍ਰਕਿਰਿਆ

ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦੁਆਰਾ ਚਲਾਏ ਗਏ ਇੱਕ ਚੱਲ ਰਹੇ ਪ੍ਰੋਗਰਾਮ ਦਾ ਐਬਸਟਰੈਕਸ਼ਨ ਉਹ ਹੈ ਜਿਸਨੂੰ ਅਸੀਂ ਕਹਿੰਦੇ ਹਾਂ ਕਾਰਜ ਨੂੰ. ਜਿਵੇਂ ਕਿ ਪਹਿਲਾਂ ਦੱਸਿਆ ਗਿਆ ਹੈ, ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਸਿਰਫ਼ ਇੱਕ ਚੱਲ ਰਿਹਾ ਪ੍ਰੋਗਰਾਮ ਹੈ, ਸਮੇਂ ਦੇ ਕਿਸੇ ਵੀ ਤਤਕਾਲ ਸਮੇਂ ਵਿੱਚ। ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਜਿਸ ਨਾਲ ਅਸੀਂ ਵੱਖ-ਵੱਖ ਸਿਸਟਮ ਸਰੋਤਾਂ ਤੋਂ ਸੰਖੇਪ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹਾਂ ਜੋ ਇਹ ਪ੍ਰੋਗਰਾਮ ਇਸ ਦੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦੌਰਾਨ ਪਹੁੰਚਦਾ ਹੈ ਜਾਂ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ।
ਪ੍ਰਕਿਰਿਆ ਦੇ ਭਾਗਾਂ ਨੂੰ ਸਮਝਣ ਲਈ, ਤੁਹਾਨੂੰ ਸਿਸਟਮ ਦੀਆਂ ਸਥਿਤੀਆਂ ਨੂੰ ਸਮਝਣ ਦੀ ਲੋੜ ਹੈ: ਪ੍ਰੋਗਰਾਮ ਇਸ ਦੇ ਕੰਮ ਦੌਰਾਨ ਕੀ ਪੜ੍ਹ ਸਕਦਾ ਹੈ ਜਾਂ ਬਦਲ ਸਕਦਾ ਹੈ। ਕਿਸੇ ਵੀ ਸਮੇਂ, ਤੁਹਾਨੂੰ ਇਹ ਸਮਝਣ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ ਕਿ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਚਲਾਉਣ ਲਈ ਸਿਸਟਮ ਦੇ ਕਿਹੜੇ ਤੱਤ ਮਹੱਤਵਪੂਰਨ ਹਨ.
ਸਿਸਟਮ ਦੇ ਸਪੱਸ਼ਟ ਤੱਤਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ ਜੋ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਸ਼ਾਮਲ ਹੈ ਮੈਮੋਰੀ. ਨਿਰਦੇਸ਼ ਮੈਮੋਰੀ ਵਿੱਚ ਸਥਿਤ ਹਨ. ਪ੍ਰੋਗਰਾਮ ਜੋ ਡਾਟਾ ਪੜ੍ਹਦਾ ਜਾਂ ਲਿਖਦਾ ਹੈ ਉਹ ਵੀ ਮੈਮੋਰੀ ਵਿੱਚ ਸਥਿਤ ਹੁੰਦਾ ਹੈ। ਇਸ ਤਰ੍ਹਾਂ, ਮੈਮੋਰੀ ਜਿਸ ਨੂੰ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਸੰਬੋਧਿਤ ਕਰ ਸਕਦੀ ਹੈ (ਜਿਸ ਨੂੰ ਐਡਰੈੱਸ ਸਪੇਸ ਕਿਹਾ ਜਾਂਦਾ ਹੈ) ਪ੍ਰਕਿਰਿਆ ਦਾ ਹਿੱਸਾ ਹੈ।
ਸਿਸਟਮ ਰਾਜ ਦਾ ਹਿੱਸਾ ਵੀ ਰਜਿਸਟਰ ਹਨ। ਬਹੁਤ ਸਾਰੀਆਂ ਹਦਾਇਤਾਂ ਦਾ ਉਦੇਸ਼ ਰਜਿਸਟਰਾਂ ਦੇ ਮੁੱਲ ਨੂੰ ਬਦਲਣ ਜਾਂ ਉਹਨਾਂ ਦੇ ਮੁੱਲ ਨੂੰ ਪੜ੍ਹਨਾ ਹੈ, ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਰਜਿਸਟਰ ਵੀ ਪ੍ਰਕਿਰਿਆ ਦੇ ਸੰਚਾਲਨ ਦਾ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਹਿੱਸਾ ਬਣ ਜਾਂਦੇ ਹਨ।
ਇਹ ਨੋਟ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਮਸ਼ੀਨ ਰਾਜ ਕੁਝ ਵਿਸ਼ੇਸ਼ ਰਜਿਸਟਰਾਂ ਤੋਂ ਵੀ ਬਣਦਾ ਹੈ. ਉਦਾਹਰਣ ਲਈ, IP - ਹਦਾਇਤ ਪੁਆਇੰਟਰ - ਨਿਰਦੇਸ਼ ਲਈ ਇੱਕ ਪੁਆਇੰਟਰ ਜੋ ਪ੍ਰੋਗਰਾਮ ਇਸ ਸਮੇਂ ਚੱਲ ਰਿਹਾ ਹੈ। ਵੀ ਹੈ ਸਟੈਕ ਪੁਆਇੰਟਰ ਅਤੇ ਇਸ ਨਾਲ ਸਬੰਧਤ ਫਰੇਮ ਪੁਆਇੰਟਰ, ਜੋ ਪ੍ਰਬੰਧਨ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ: ਫੰਕਸ਼ਨ ਪੈਰਾਮੀਟਰ, ਸਥਾਨਕ ਵੇਰੀਏਬਲ ਅਤੇ ਵਾਪਸੀ ਪਤੇ।
ਅੰਤ ਵਿੱਚ, ਪ੍ਰੋਗਰਾਮ ਅਕਸਰ ROM (ਸਿਰਫ਼ ਪੜ੍ਹਨ ਲਈ ਮੈਮੋਰੀ) ਤੱਕ ਪਹੁੰਚ ਕਰਦੇ ਹਨ। ਇਸ "I/O" (ਇਨਪੁਟ/ਆਊਟਪੁੱਟ) ਜਾਣਕਾਰੀ ਵਿੱਚ ਵਰਤਮਾਨ ਵਿੱਚ ਪ੍ਰਕਿਰਿਆ ਦੁਆਰਾ ਖੁੱਲ੍ਹੀਆਂ ਫਾਈਲਾਂ ਦੀ ਸੂਚੀ ਸ਼ਾਮਲ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ।

ਪ੍ਰਕਿਰਿਆ API

ਪ੍ਰਕਿਰਿਆ ਕਿਵੇਂ ਕੰਮ ਕਰਦੀ ਹੈ ਇਸ ਬਾਰੇ ਸਾਡੀ ਸਮਝ ਨੂੰ ਬਿਹਤਰ ਬਣਾਉਣ ਲਈ, ਆਉ ਸਿਸਟਮ ਕਾਲਾਂ ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਦਾ ਅਧਿਐਨ ਕਰੀਏ ਜੋ ਕਿਸੇ ਵੀ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਇੰਟਰਫੇਸ ਵਿੱਚ ਸ਼ਾਮਲ ਹੋਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ। ਇਹ APIs ਕਿਸੇ ਵੀ OS 'ਤੇ ਇੱਕ ਜਾਂ ਦੂਜੇ ਰੂਪ ਵਿੱਚ ਉਪਲਬਧ ਹਨ।

● ਬਣਾਓ (ਰਚਨਾ): OS ਵਿੱਚ ਕੁਝ ਵਿਧੀ ਸ਼ਾਮਲ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਨਵੀਆਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਬਣਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ। ਜਦੋਂ ਤੁਸੀਂ ਟਰਮੀਨਲ ਵਿੱਚ ਇੱਕ ਕਮਾਂਡ ਦਾਖਲ ਕਰਦੇ ਹੋ ਜਾਂ ਇੱਕ ਆਈਕਨ 'ਤੇ ਡਬਲ-ਕਲਿੱਕ ਕਰਕੇ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਲਾਂਚ ਕਰਦੇ ਹੋ, ਤਾਂ ਇੱਕ ਨਵੀਂ ਪ੍ਰਕਿਰਿਆ ਬਣਾਉਣ ਲਈ OS ਨੂੰ ਇੱਕ ਕਾਲ ਭੇਜੀ ਜਾਂਦੀ ਹੈ ਅਤੇ ਫਿਰ ਨਿਰਧਾਰਤ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਲਾਂਚ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
● ਹਟਾਉਣ: ਕਿਉਂਕਿ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਬਣਾਉਣ ਲਈ ਇੱਕ ਇੰਟਰਫੇਸ ਹੈ, OS ਨੂੰ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਹਟਾਉਣ ਲਈ ਮਜਬੂਰ ਕਰਨ ਦੀ ਯੋਗਤਾ ਵੀ ਪ੍ਰਦਾਨ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ। ਜ਼ਿਆਦਾਤਰ ਪ੍ਰੋਗਰਾਮ ਕੁਦਰਤੀ ਤੌਰ 'ਤੇ ਆਪਣੇ ਆਪ ਸ਼ੁਰੂ ਹੋ ਜਾਂਦੇ ਹਨ ਅਤੇ ਬੰਦ ਹੋ ਜਾਂਦੇ ਹਨ ਜਦੋਂ ਉਹ ਚੱਲਦੇ ਹਨ। ਨਹੀਂ ਤਾਂ ਉਪਭੋਗਤਾ ਉਹਨਾਂ ਨੂੰ ਮਾਰਨ ਦੇ ਯੋਗ ਹੋਣਾ ਚਾਹੇਗਾ ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਰੋਕਣ ਲਈ ਇੱਕ ਇੰਟਰਫੇਸ ਲਾਭਦਾਇਕ ਹੋਵੇਗਾ।
● ਉਡੀਕ ਕਰੋ (ਉਡੀਕ): ਕਈ ਵਾਰ ਕਿਸੇ ਪ੍ਰਕਿਰਿਆ ਦੇ ਪੂਰਾ ਹੋਣ ਦੀ ਉਡੀਕ ਕਰਨਾ ਲਾਭਦਾਇਕ ਹੁੰਦਾ ਹੈ, ਇਸ ਲਈ ਕੁਝ ਇੰਟਰਫੇਸ ਪ੍ਰਦਾਨ ਕੀਤੇ ਜਾਂਦੇ ਹਨ ਜੋ ਉਡੀਕ ਕਰਨ ਦੀ ਯੋਗਤਾ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ।
● ਫੁਟਕਲ ਨਿਯੰਤਰਣ (ਵੱਖ-ਵੱਖ ਨਿਯੰਤਰਣ): ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਮਾਰਨ ਅਤੇ ਉਡੀਕ ਕਰਨ ਤੋਂ ਇਲਾਵਾ, ਹੋਰ ਵੱਖ-ਵੱਖ ਨਿਯੰਤਰਣ ਵਿਧੀਆਂ ਵੀ ਹਨ। ਉਦਾਹਰਨ ਲਈ, ਜ਼ਿਆਦਾਤਰ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਫ੍ਰੀਜ਼ ਕਰਨ ਦੀ ਸਮਰੱਥਾ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ (ਇੱਕ ਨਿਸ਼ਚਤ ਸਮੇਂ ਲਈ ਇਸ ਦੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨੂੰ ਰੋਕਦੇ ਹਨ) ਅਤੇ ਫਿਰ ਇਸਨੂੰ ਦੁਬਾਰਾ ਸ਼ੁਰੂ ਕਰਦੇ ਹਨ (ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਜਾਰੀ ਰੱਖੋ)
● ਸਥਿਤੀ (ਸਟੇਟ): ਕਿਸੇ ਪ੍ਰਕਿਰਿਆ ਦੀ ਸਥਿਤੀ ਬਾਰੇ ਕੁਝ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਕਈ ਇੰਟਰਫੇਸ ਹੁੰਦੇ ਹਨ, ਜਿਵੇਂ ਕਿ ਇਹ ਕਿੰਨੀ ਦੇਰ ਤੋਂ ਚੱਲ ਰਹੀ ਹੈ ਜਾਂ ਇਹ ਵਰਤਮਾਨ ਵਿੱਚ ਕਿਸ ਸਥਿਤੀ ਵਿੱਚ ਹੈ।

ਪ੍ਰਕਿਰਿਆ ਰਚਨਾ: ਵੇਰਵੇ

ਇੱਕ ਦਿਲਚਸਪ ਗੱਲ ਇਹ ਹੈ ਕਿ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਪ੍ਰਕਿਰਿਆਵਾਂ ਵਿੱਚ ਕਿਵੇਂ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ. ਖਾਸ ਤੌਰ 'ਤੇ OS ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕਿਵੇਂ ਚੁੱਕਦਾ ਹੈ ਅਤੇ ਚਲਾਉਂਦਾ ਹੈ। ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਬਿਲਕੁਲ ਕਿਵੇਂ ਬਣਾਇਆ ਗਿਆ ਹੈ.
ਸਭ ਤੋਂ ਪਹਿਲਾਂ, OS ਨੂੰ ਪ੍ਰੋਗਰਾਮ ਕੋਡ ਅਤੇ ਸਥਿਰ ਡੇਟਾ ਨੂੰ ਮੈਮੋਰੀ ਵਿੱਚ ਲੋਡ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ (ਪ੍ਰਕਿਰਿਆ ਐਡਰੈੱਸ ਸਪੇਸ ਵਿੱਚ)। ਪ੍ਰੋਗਰਾਮ ਆਮ ਤੌਰ 'ਤੇ ਕੁਝ ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਫਾਰਮੈਟ ਵਿੱਚ ਡਿਸਕ ਜਾਂ ਸਾਲਿਡ-ਸਟੇਟ ਡਰਾਈਵ 'ਤੇ ਸਥਿਤ ਹੁੰਦੇ ਹਨ। ਇਸ ਤਰ੍ਹਾਂ, ਪ੍ਰੋਗਰਾਮ ਅਤੇ ਸਥਿਰ ਡੇਟਾ ਨੂੰ ਮੈਮੋਰੀ ਵਿੱਚ ਲੋਡ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਲਈ OS ਨੂੰ ਉਹਨਾਂ ਬਾਈਟਾਂ ਨੂੰ ਡਿਸਕ ਤੋਂ ਪੜ੍ਹਨ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਮੈਮੋਰੀ ਵਿੱਚ ਕਿਤੇ ਰੱਖਣ ਦੇ ਯੋਗ ਹੋਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।

ਸ਼ੁਰੂਆਤੀ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮਾਂ ਵਿੱਚ, ਲੋਡਿੰਗ ਪ੍ਰਕਿਰਿਆ ਉਤਸੁਕਤਾ ਨਾਲ ਕੀਤੀ ਜਾਂਦੀ ਸੀ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਪ੍ਰੋਗਰਾਮ ਦੇ ਸ਼ੁਰੂ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਸਾਰਾ ਕੋਡ ਮੈਮੋਰੀ ਵਿੱਚ ਲੋਡ ਕੀਤਾ ਗਿਆ ਸੀ। ਆਧੁਨਿਕ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਇਸ ਨੂੰ ਆਲਸ ਨਾਲ ਕਰਦੇ ਹਨ, ਯਾਨੀ ਕੋਡ ਜਾਂ ਡੇਟਾ ਦੇ ਟੁਕੜਿਆਂ ਨੂੰ ਲੋਡ ਕਰਨਾ ਉਦੋਂ ਹੀ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਇਸਦੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦੌਰਾਨ ਉਹਨਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।

ਇੱਕ ਵਾਰ ਕੋਡ ਅਤੇ ਸਥਿਰ ਡੇਟਾ OS ਮੈਮੋਰੀ ਵਿੱਚ ਲੋਡ ਹੋ ਜਾਣ ਤੋਂ ਬਾਅਦ, ਪ੍ਰਕਿਰਿਆ ਦੇ ਚੱਲਣ ਤੋਂ ਪਹਿਲਾਂ ਕੁਝ ਹੋਰ ਚੀਜ਼ਾਂ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਸਟੈਕ ਲਈ ਮੈਮੋਰੀ ਦੀ ਕੁਝ ਮਾਤਰਾ ਨਿਰਧਾਰਤ ਕੀਤੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ। ਪ੍ਰੋਗਰਾਮ ਸਥਾਨਕ ਵੇਰੀਏਬਲਾਂ, ਫੰਕਸ਼ਨ ਪੈਰਾਮੀਟਰਾਂ ਅਤੇ ਵਾਪਸੀ ਪਤਿਆਂ ਲਈ ਸਟੈਕ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ. OS ਇਸ ਮੈਮੋਰੀ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਦਿੰਦਾ ਹੈ। ਸਟੈਕ ਨੂੰ ਕੁਝ ਆਰਗੂਮੈਂਟਾਂ ਨਾਲ ਵੀ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਇਹ main() ਫੰਕਸ਼ਨ ਦੇ ਪੈਰਾਮੀਟਰਾਂ ਨੂੰ ਭਰਦਾ ਹੈ, ਉਦਾਹਰਨ ਲਈ argc ਅਤੇ argv ਦੀ ਇੱਕ ਐਰੇ ਨਾਲ।

ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਪ੍ਰੋਗਰਾਮ ਹੀਪ ਨੂੰ ਕੁਝ ਮੈਮੋਰੀ ਵੀ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦਾ ਹੈ। ਹੀਪ ਦੀ ਵਰਤੋਂ ਪ੍ਰੋਗਰਾਮਾਂ ਦੁਆਰਾ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਗਤੀਸ਼ੀਲ ਤੌਰ 'ਤੇ ਨਿਰਧਾਰਤ ਡੇਟਾ ਦੀ ਬੇਨਤੀ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ. ਪ੍ਰੋਗਰਾਮ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰਕੇ ਇਸ ਸਪੇਸ ਦੀ ਬੇਨਤੀ ਕਰਦੇ ਹਨ malloc () ਅਤੇ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰਕੇ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਸਾਫ਼ ਕਰਦਾ ਹੈ ਮੁਫ਼ਤ(). ਡਾਟਾ ਸਟ੍ਰਕਚਰ ਜਿਵੇਂ ਕਿ ਲਿੰਕਡ ਸ਼ੀਟਾਂ, ਹੈਸ਼ ਟੇਬਲ, ਟ੍ਰੀ ਅਤੇ ਹੋਰਾਂ ਲਈ ਹੀਪ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਪਹਿਲਾਂ, ਹੀਪ ਨੂੰ ਥੋੜੀ ਜਿਹੀ ਮੈਮੋਰੀ ਨਿਰਧਾਰਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਪਰ ਸਮੇਂ ਦੇ ਨਾਲ, ਜਿਵੇਂ ਕਿ ਪ੍ਰੋਗਰਾਮ ਚੱਲਦਾ ਹੈ, ਹੀਪ ਲਾਇਬ੍ਰੇਰੀ API ਕਾਲ malloc() ਦੁਆਰਾ ਹੋਰ ਮੈਮੋਰੀ ਦੀ ਬੇਨਤੀ ਕਰ ਸਕਦਾ ਹੈ। ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਇਹਨਾਂ ਕਾਲਾਂ ਨੂੰ ਸੰਤੁਸ਼ਟ ਕਰਨ ਵਿੱਚ ਮਦਦ ਲਈ ਹੋਰ ਮੈਮੋਰੀ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਸ਼ਾਮਲ ਹੈ।

ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਸ਼ੁਰੂਆਤੀ ਕਾਰਜ ਵੀ ਕਰੇਗਾ, ਖਾਸ ਤੌਰ 'ਤੇ ਉਹ I/O ਨਾਲ ਸਬੰਧਤ। ਉਦਾਹਰਨ ਲਈ, UNIX ਸਿਸਟਮਾਂ 'ਤੇ, ਮਿਆਰੀ ਇਨਪੁਟ, ਆਉਟਪੁੱਟ, ਅਤੇ ਗਲਤੀ ਲਈ, ਹਰੇਕ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਮੂਲ ਰੂਪ ਵਿੱਚ 3 ਓਪਨ ਫਾਈਲ ਡਿਸਕ੍ਰਿਪਟਰ ਹੁੰਦੇ ਹਨ। ਇਹ ਹੈਂਡਲ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਟਰਮੀਨਲ ਤੋਂ ਇੰਪੁੱਟ ਪੜ੍ਹਨ ਦੇ ਨਾਲ-ਨਾਲ ਸਕ੍ਰੀਨ 'ਤੇ ਜਾਣਕਾਰੀ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੇ ਹਨ।

ਇਸ ਤਰ੍ਹਾਂ, ਕੋਡ ਅਤੇ ਸਟੈਟਿਕ ਡੇਟਾ ਨੂੰ ਮੈਮੋਰੀ ਵਿੱਚ ਲੋਡ ਕਰਕੇ, ਸਟੈਕ ਨੂੰ ਬਣਾਉਣ ਅਤੇ ਸ਼ੁਰੂ ਕਰਨ, ਅਤੇ I/O ਕਾਰਜਾਂ ਨੂੰ ਕਰਨ ਨਾਲ ਸਬੰਧਤ ਹੋਰ ਕੰਮ ਕਰਨ ਦੁਆਰਾ, OS ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਚਲਾਉਣ ਲਈ ਪੜਾਅ ਤਿਆਰ ਕਰਦਾ ਹੈ। ਅੰਤ ਵਿੱਚ, ਇੱਕ ਆਖਰੀ ਕੰਮ ਬਾਕੀ ਹੈ: ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਇਸਦੇ ਐਂਟਰੀ ਪੁਆਇੰਟ ਦੁਆਰਾ ਚਲਾਉਣਾ, ਜਿਸਨੂੰ main() ਫੰਕਸ਼ਨ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਮੇਨ() ਫੰਕਸ਼ਨ ਨੂੰ ਚਲਾਉਣ ਨਾਲ, OS CPU ਨਿਯੰਤਰਣ ਨੂੰ ਨਵੀਂ ਬਣਾਈ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਟ੍ਰਾਂਸਫਰ ਕਰਦਾ ਹੈ, ਇਸ ਤਰ੍ਹਾਂ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਚਲਾਉਣਾ ਸ਼ੁਰੂ ਹੋ ਜਾਂਦਾ ਹੈ।

ਪ੍ਰਕਿਰਿਆ ਸਥਿਤੀ

ਹੁਣ ਜਦੋਂ ਸਾਨੂੰ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਕੀ ਹੁੰਦੀ ਹੈ ਅਤੇ ਇਹ ਕਿਵੇਂ ਬਣਾਈ ਜਾਂਦੀ ਹੈ, ਇਸ ਬਾਰੇ ਕੁਝ ਸਮਝ ਹੈ, ਆਓ ਪ੍ਰਕਿਰਿਆ ਦੇ ਰਾਜਾਂ ਨੂੰ ਸੂਚੀਬੱਧ ਕਰੀਏ ਜਿਸ ਵਿੱਚ ਇਹ ਹੋ ਸਕਦਾ ਹੈ। ਇਸਦੇ ਸਰਲ ਰੂਪ ਵਿੱਚ, ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਇਹਨਾਂ ਰਾਜਾਂ ਵਿੱਚੋਂ ਇੱਕ ਵਿੱਚ ਹੋ ਸਕਦੀ ਹੈ:
● ਚੱਲ ਰਿਹਾ ਹੈ. ਚੱਲਦੇ ਸਮੇਂ, ਪ੍ਰਕਿਰਿਆ ਪ੍ਰੋਸੈਸਰ 'ਤੇ ਚੱਲਦੀ ਹੈ। ਇਸ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਨਿਰਦੇਸ਼ਾਂ ਨੂੰ ਲਾਗੂ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ.
● ਰੈਡੀ. ਤਿਆਰ ਸਥਿਤੀ ਵਿੱਚ, ਪ੍ਰਕਿਰਿਆ ਚੱਲਣ ਲਈ ਤਿਆਰ ਹੈ, ਪਰ ਕਿਸੇ ਕਾਰਨ ਕਰਕੇ OS ਇਸ ਨੂੰ ਨਿਰਧਾਰਤ ਸਮੇਂ 'ਤੇ ਲਾਗੂ ਨਹੀਂ ਕਰਦਾ ਹੈ।
● ਰੋਕੀ. ਬਲੌਕ ਕੀਤੀ ਸਥਿਤੀ ਵਿੱਚ, ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਕੁਝ ਓਪਰੇਸ਼ਨ ਕਰਦੀ ਹੈ ਜੋ ਇਸਨੂੰ ਚਲਾਉਣ ਲਈ ਤਿਆਰ ਹੋਣ ਤੋਂ ਰੋਕਦੀ ਹੈ ਜਦੋਂ ਤੱਕ ਕੋਈ ਘਟਨਾ ਵਾਪਰਦੀ ਹੈ। ਇੱਕ ਆਮ ਉਦਾਹਰਨ ਹੈ ਜਦੋਂ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਇੱਕ IO ਕਾਰਵਾਈ ਸ਼ੁਰੂ ਕਰਦੀ ਹੈ, ਇਹ ਬਲੌਕ ਹੋ ਜਾਂਦੀ ਹੈ ਤਾਂ ਜੋ ਕੋਈ ਹੋਰ ਪ੍ਰਕਿਰਿਆ ਪ੍ਰੋਸੈਸਰ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕੇ।

ਤੁਸੀਂ ਇੱਕ ਗ੍ਰਾਫ ਦੇ ਰੂਪ ਵਿੱਚ ਇਹਨਾਂ ਅਵਸਥਾਵਾਂ ਦੀ ਕਲਪਨਾ ਕਰ ਸਕਦੇ ਹੋ। ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਤਸਵੀਰ ਵਿੱਚ ਦੇਖ ਸਕਦੇ ਹਾਂ, OS ਦੇ ਵਿਵੇਕ 'ਤੇ ਪ੍ਰਕਿਰਿਆ ਸਥਿਤੀ ਰਨਿੰਗ ਅਤੇ READY ਵਿਚਕਾਰ ਬਦਲ ਸਕਦੀ ਹੈ। ਜਦੋਂ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਦੀ ਸਥਿਤੀ READY ਤੋਂ RUNNING ਵਿੱਚ ਬਦਲ ਜਾਂਦੀ ਹੈ, ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਪ੍ਰਕਿਰਿਆ ਨਿਯਤ ਕੀਤੀ ਗਈ ਹੈ। ਉਲਟ ਦਿਸ਼ਾ ਵਿੱਚ - ਲੇਆਉਟ ਤੋਂ ਹਟਾਇਆ ਗਿਆ। ਇਸ ਸਮੇਂ ਜਦੋਂ ਕੋਈ ਪ੍ਰਕਿਰਿਆ ਬਲੌਕ ਹੋ ਜਾਂਦੀ ਹੈ, ਉਦਾਹਰਨ ਲਈ, ਮੈਂ ਇੱਕ IO ਓਪਰੇਸ਼ਨ ਸ਼ੁਰੂ ਕਰਦਾ ਹਾਂ, OS ਇਸਨੂੰ ਇਸ ਸਥਿਤੀ ਵਿੱਚ ਰੱਖੇਗਾ ਜਦੋਂ ਤੱਕ ਕੋਈ ਘਟਨਾ ਨਹੀਂ ਵਾਪਰਦੀ, ਉਦਾਹਰਨ ਲਈ IO ਦਾ ਪੂਰਾ ਹੋਣਾ। ਇਸ ਸਮੇਂ ਰੈਡੀ ਸਟੇਟ ਵਿੱਚ ਤਬਦੀਲੀ ਅਤੇ ਸੰਭਵ ਤੌਰ 'ਤੇ ਤੁਰੰਤ ਚੱਲ ਰਹੀ ਸਥਿਤੀ ਵਿੱਚ ਜੇਕਰ OS ਅਜਿਹਾ ਫੈਸਲਾ ਕਰਦਾ ਹੈ।
ਆਉ ਇੱਕ ਉਦਾਹਰਨ ਵੇਖੀਏ ਕਿ ਕਿਵੇਂ ਦੋ ਪ੍ਰਕਿਰਿਆਵਾਂ ਇਹਨਾਂ ਅਵਸਥਾਵਾਂ ਵਿੱਚੋਂ ਲੰਘਦੀਆਂ ਹਨ। ਸ਼ੁਰੂ ਕਰਨ ਲਈ, ਆਓ ਕਲਪਨਾ ਕਰੀਏ ਕਿ ਦੋਵੇਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਚੱਲ ਰਹੀਆਂ ਹਨ, ਅਤੇ ਹਰ ਇੱਕ ਸਿਰਫ਼ CPU ਦੀ ਵਰਤੋਂ ਕਰ ਰਿਹਾ ਹੈ। ਇਸ ਮਾਮਲੇ ਵਿੱਚ, ਉਨ੍ਹਾਂ ਦੇ ਰਾਜ ਇਸ ਤਰ੍ਹਾਂ ਦੇ ਹੋਣਗੇ.

ਨਿਮਨਲਿਖਤ ਉਦਾਹਰਨ ਵਿੱਚ, ਪਹਿਲੀ ਪ੍ਰਕਿਰਿਆ, ਕੁਝ ਦੇਰ ਚੱਲਣ ਤੋਂ ਬਾਅਦ, IO ਲਈ ਬੇਨਤੀ ਕਰਦੀ ਹੈ ਅਤੇ ਬਲੌਕ ਕੀਤੀ ਸਥਿਤੀ ਵਿੱਚ ਦਾਖਲ ਹੁੰਦੀ ਹੈ, ਇੱਕ ਹੋਰ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਚੱਲਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ (FIG 1.4)। OS ਦੇਖਦਾ ਹੈ ਕਿ ਪ੍ਰਕਿਰਿਆ 0 CPU ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕਰ ਰਹੀ ਹੈ ਅਤੇ ਪ੍ਰਕਿਰਿਆ 1 ਸ਼ੁਰੂ ਕਰਦੀ ਹੈ। ਜਦੋਂ ਪ੍ਰਕਿਰਿਆ 1 ਚੱਲ ਰਹੀ ਹੈ, IO ਪੂਰਾ ਹੋ ਗਿਆ ਹੈ ਅਤੇ ਪ੍ਰਕਿਰਿਆ 0 ਦੀ ਸਥਿਤੀ ਤਿਆਰ ਹੋ ਜਾਂਦੀ ਹੈ। ਅੰਤ ਵਿੱਚ, ਪ੍ਰਕਿਰਿਆ 1 ਪੂਰੀ ਹੋ ਗਈ ਹੈ, ਅਤੇ ਮੁਕੰਮਲ ਹੋਣ 'ਤੇ, ਪ੍ਰਕਿਰਿਆ 0 ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ, ਚਲਾਉਂਦੀ ਹੈ, ਅਤੇ ਆਪਣਾ ਕੰਮ ਪੂਰਾ ਕਰਦੀ ਹੈ।

ਡਾਟਾ ਬਣਤਰ

OS ਆਪਣੇ ਆਪ ਵਿੱਚ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਹੈ, ਅਤੇ ਕਿਸੇ ਵੀ ਹੋਰ ਪ੍ਰੋਗਰਾਮ ਦੀ ਤਰ੍ਹਾਂ, ਇਸ ਵਿੱਚ ਕੁਝ ਮੁੱਖ ਡਾਟਾ ਢਾਂਚੇ ਹਨ ਜੋ ਜਾਣਕਾਰੀ ਦੇ ਵੱਖ-ਵੱਖ ਸੰਬੰਧਿਤ ਹਿੱਸਿਆਂ ਦਾ ਧਿਆਨ ਰੱਖਦੇ ਹਨ। ਹਰੇਕ ਪ੍ਰਕਿਰਿਆ ਦੀ ਸਥਿਤੀ ਨੂੰ ਟਰੈਕ ਕਰਨ ਲਈ, OS ਕੁਝ ਦਾ ਸਮਰਥਨ ਕਰੇਗਾ ਪ੍ਰਕਿਰਿਆ ਸੂਚੀ ਰੈਡੀ ਸਟੇਟ ਵਿੱਚ ਸਾਰੀਆਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਲਈ ਅਤੇ ਵਰਤਮਾਨ ਵਿੱਚ ਚੱਲ ਰਹੀਆਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਟਰੈਕ ਕਰਨ ਲਈ ਕੁਝ ਵਾਧੂ ਜਾਣਕਾਰੀ। ਨਾਲ ਹੀ, OS ਨੂੰ ਬਲੌਕ ਕੀਤੀਆਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੀ ਨਿਗਰਾਨੀ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ। IO ਦੇ ਪੂਰਾ ਹੋਣ ਤੋਂ ਬਾਅਦ, OS ਨੂੰ ਲੋੜੀਂਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਜਗਾਉਣਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਚਲਾਉਣ ਲਈ ਤਿਆਰ ਸਥਿਤੀ ਵਿੱਚ ਰੱਖਣਾ ਚਾਹੀਦਾ ਹੈ।

ਉਦਾਹਰਨ ਲਈ, OS ਨੂੰ ਪ੍ਰੋਸੈਸਰ ਰਜਿਸਟਰਾਂ ਦੀ ਸਥਿਤੀ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਣਾ ਚਾਹੀਦਾ ਹੈ। ਜਿਸ ਸਮੇਂ ਪ੍ਰਕਿਰਿਆ ਰੁਕ ਜਾਂਦੀ ਹੈ, ਰਜਿਸਟਰਾਂ ਦੀ ਸਥਿਤੀ ਪ੍ਰਕਿਰਿਆ ਦੇ ਐਡਰੈੱਸ ਸਪੇਸ ਵਿੱਚ ਸਟੋਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਅਤੇ ਇਸ ਸਮੇਂ ਇਸਦੀ ਕਾਰਵਾਈ ਜਾਰੀ ਰਹਿੰਦੀ ਹੈ, ਰਜਿਸਟਰਾਂ ਦੇ ਮੁੱਲਾਂ ਨੂੰ ਬਹਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਜਾਰੀ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ।

ਤਿਆਰ, ਬਲਾਕ, ਚੱਲ ਰਹੇ ਰਾਜਾਂ ਤੋਂ ਇਲਾਵਾ, ਕੁਝ ਹੋਰ ਰਾਜ ਹਨ. ਕਈ ਵਾਰ, ਰਚਨਾ ਦੇ ਸਮੇਂ, ਇੱਕ ਪ੍ਰਕਿਰਿਆ INIT ਅਵਸਥਾ ਵਿੱਚ ਹੋ ਸਕਦੀ ਹੈ। ਅੰਤ ਵਿੱਚ, ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਅੰਤਿਮ ਅਵਸਥਾ ਵਿੱਚ ਰੱਖਿਆ ਜਾ ਸਕਦਾ ਹੈ ਜਦੋਂ ਇਹ ਪਹਿਲਾਂ ਹੀ ਪੂਰਾ ਹੋ ਗਿਆ ਹੈ, ਪਰ ਇਸਦੀ ਜਾਣਕਾਰੀ ਅਜੇ ਤੱਕ ਸਾਫ਼ ਨਹੀਂ ਕੀਤੀ ਗਈ ਹੈ। UNIX ਸਿਸਟਮਾਂ ਉੱਤੇ ਇਸ ਅਵਸਥਾ ਨੂੰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਜੂਮਬੀਨ ਪ੍ਰਕਿਰਿਆ. ਇਹ ਸਥਿਤੀ ਉਹਨਾਂ ਮਾਮਲਿਆਂ ਲਈ ਲਾਭਦਾਇਕ ਹੈ ਜਿੱਥੇ ਇੱਕ ਮਾਤਾ-ਪਿਤਾ ਪ੍ਰਕਿਰਿਆ ਇੱਕ ਬੱਚੇ ਦੇ ਰਿਟਰਨ ਕੋਡ ਨੂੰ ਜਾਣਨਾ ਚਾਹੁੰਦੀ ਹੈ, ਉਦਾਹਰਨ ਲਈ, ਆਮ ਤੌਰ 'ਤੇ 0 ਸਫਲਤਾ ਅਤੇ 1 ਗਲਤੀ ਦਾ ਸੰਕੇਤ ਦਿੰਦਾ ਹੈ, ਪਰ ਪ੍ਰੋਗਰਾਮਰ ਵੱਖ-ਵੱਖ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਸੰਕੇਤ ਕਰਨ ਲਈ ਵਾਧੂ ਆਉਟਪੁੱਟ ਕੋਡ ਜਾਰੀ ਕਰ ਸਕਦੇ ਹਨ। ਜਦੋਂ ਪੇਰੈਂਟ ਪ੍ਰਕਿਰਿਆ ਸਮਾਪਤ ਹੋ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਇਹ ਇੱਕ ਅੰਤਮ ਸਿਸਟਮ ਕਾਲ ਕਰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ wait(), ਚਾਈਲਡ ਪ੍ਰਕਿਰਿਆ ਦੇ ਸਮਾਪਤ ਹੋਣ ਦੀ ਉਡੀਕ ਕਰਨ ਲਈ ਅਤੇ OS ਨੂੰ ਸੰਕੇਤ ਦਿੰਦਾ ਹੈ ਕਿ ਇਹ ਸਮਾਪਤੀ ਪ੍ਰਕਿਰਿਆ ਨਾਲ ਜੁੜੇ ਕਿਸੇ ਵੀ ਡੇਟਾ ਨੂੰ ਕਲੀਅਰ ਕਰ ਸਕਦਾ ਹੈ।

ਲੈਕਚਰ ਦੇ ਮੁੱਖ ਨੁਕਤੇ:

● ਕਾਰਜ ਨੂੰ — OS ਵਿੱਚ ਚੱਲ ਰਹੇ ਪ੍ਰੋਗਰਾਮ ਦਾ ਮੁੱਖ ਐਬਸਟਰੈਕਸ਼ਨ। ਕਿਸੇ ਵੀ ਸਮੇਂ, ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਉਸਦੀ ਸਥਿਤੀ ਦੁਆਰਾ ਵਰਣਨ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ: ਇਸਦੇ ਐਡਰੈੱਸ ਸਪੇਸ ਵਿੱਚ ਮੈਮੋਰੀ ਦੀ ਸਮੱਗਰੀ, ਪ੍ਰੋਸੈਸਰ ਰਜਿਸਟਰਾਂ ਦੀ ਸਮੱਗਰੀ, ਨਿਰਦੇਸ਼ ਪੁਆਇੰਟਰ ਅਤੇ ਸਟੈਕ ਪੁਆਇੰਟਰ ਸਮੇਤ, ਅਤੇ IO ਜਾਣਕਾਰੀ, ਜਿਵੇਂ ਕਿ ਖੁੱਲ੍ਹੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਪੜ੍ਹਿਆ ਜਾਂ ਲਿਖਿਆ ਜਾ ਰਿਹਾ ਹੈ।
● ਪ੍ਰਕਿਰਿਆ API ਕਾਲਾਂ ਦੇ ਸ਼ਾਮਲ ਹਨ ਜੋ ਪ੍ਰੋਗਰਾਮ ਪ੍ਰਕਿਰਿਆਵਾਂ ਲਈ ਕਰ ਸਕਦੇ ਹਨ। ਆਮ ਤੌਰ 'ਤੇ ਇਹ ਬਣਾਓ, ਮਿਟਾਓ, ਜਾਂ ਹੋਰ ਕਾਲਾਂ ਹੁੰਦੀਆਂ ਹਨ।
● ਪ੍ਰਕਿਰਿਆ ਚੱਲ ਰਹੀ, ਤਿਆਰ, ਬਲੌਕ ਸਮੇਤ ਕਈ ਰਾਜਾਂ ਵਿੱਚੋਂ ਇੱਕ ਵਿੱਚ ਹੈ। ਕਈ ਘਟਨਾਵਾਂ ਜਿਵੇਂ ਕਿ ਸਮਾਂ-ਸਾਰਣੀ, ਸਮਾਂ-ਸੂਚੀ ਤੋਂ ਅਪਵਾਦ, ਜਾਂ ਉਡੀਕ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਦੀ ਸਥਿਤੀ ਨੂੰ ਇੱਕ ਤੋਂ ਦੂਜੇ ਵਿੱਚ ਬਦਲ ਸਕਦੀਆਂ ਹਨ।
● ਪ੍ਰਕਿਰਿਆ ਸੂਚੀ ਸਿਸਟਮ ਵਿੱਚ ਸਾਰੀਆਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਬਾਰੇ ਜਾਣਕਾਰੀ ਰੱਖਦਾ ਹੈ। ਇਸ ਵਿੱਚ ਹਰੇਕ ਪ੍ਰਵੇਸ਼ ਨੂੰ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਨਿਯੰਤਰਣ ਬਲਾਕ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਜੋ ਅਸਲ ਵਿੱਚ ਇੱਕ ਢਾਂਚਾ ਹੈ ਜਿਸ ਵਿੱਚ ਇੱਕ ਖਾਸ ਪ੍ਰਕਿਰਿਆ ਬਾਰੇ ਸਾਰੀਆਂ ਲੋੜੀਂਦੀਆਂ ਜਾਣਕਾਰੀ ਸ਼ਾਮਲ ਹੁੰਦੀ ਹੈ। 

ਸਰੋਤ: www.habr.com