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

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

ਇਸ ਵਿਸ਼ੇ 'ਤੇ ਲੈਬ ਦਾ ਕੰਮ ਇੱਥੇ ਪਾਇਆ ਜਾ ਸਕਦਾ ਹੈ:
- ਅਸਲੀ: pages.cs.wisc.edu/~remzi/OSTEP/Homework/homework.html
- ਅਸਲੀ: github.com/remzi-arpacidusseau/ostep-code
- ਮੇਰਾ ਨਿੱਜੀ ਅਨੁਕੂਲਨ: github.com/bykvaadm/OS/tree/master/ostep

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

ਪ੍ਰੋਗਰਾਮ ਦੀ ਕਾਰਵਾਈ

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

ਗਣਨਾ ਦਾ ਵੌਨ ਨਿਊਮੈਨ ਮਾਡਲ

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

ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ

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

CPU ਵਰਚੁਅਲਾਈਜੇਸ਼ਨ

ਹੇਠ ਦਿੱਤੇ ਪ੍ਰੋਗਰਾਮ 'ਤੇ ਗੌਰ ਕਰੋ:
(https://www.youtube.com/watch?v=zDwT5fUcki4&feature=youtu.be)

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

ਮੈਮੋਰੀ ਵਰਚੁਅਲਾਈਜੇਸ਼ਨ

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

malloc() ਕਾਲ

ਹੇਠਾਂ ਦਿੱਤੇ ਪ੍ਰੋਗਰਾਮ 'ਤੇ ਗੌਰ ਕਰੋ, ਜੋ ਕਾਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮੈਮੋਰੀ ਦਾ ਖੇਤਰ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ malloc () (https://youtu.be/jnlKRnoT1m0):

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

ਨਤੀਜੇ ਵਜੋਂ, ਇਹ ਪਤਾ ਚਲਦਾ ਹੈ ਕਿ ਦੋ ਸੁਤੰਤਰ ਪ੍ਰੋਗਰਾਮ ਆਪਣੇ ਨਿੱਜੀ ਐਡਰੈੱਸ ਸਪੇਸ ਨਾਲ ਕੰਮ ਕਰਦੇ ਹਨ, ਜੋ ਬਦਲੇ ਵਿੱਚ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦੁਆਰਾ ਭੌਤਿਕ ਮੈਮੋਰੀ ਵਿੱਚ ਮੈਪ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।. ਇਸ ਲਈ, ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਦੇ ਅੰਦਰ ਮੈਮੋਰੀ ਪਤਿਆਂ ਦੀ ਵਰਤੋਂ ਕਿਸੇ ਵੀ ਤਰੀਕੇ ਨਾਲ ਦੂਜਿਆਂ ਨੂੰ ਪ੍ਰਭਾਵਤ ਨਹੀਂ ਕਰੇਗੀ, ਅਤੇ ਇਹ ਹਰੇਕ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਜਾਪਦਾ ਹੈ ਕਿ ਇਸਦੀ ਆਪਣੀ ਭੌਤਿਕ ਮੈਮੋਰੀ ਹੈ, ਪੂਰੀ ਤਰ੍ਹਾਂ ਇਸ ਨੂੰ ਦਿੱਤੀ ਗਈ ਹੈ। ਅਸਲੀਅਤ, ਹਾਲਾਂਕਿ, ਇਹ ਹੈ ਕਿ ਭੌਤਿਕ ਮੈਮੋਰੀ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦੁਆਰਾ ਪ੍ਰਬੰਧਿਤ ਇੱਕ ਸਾਂਝਾ ਸਰੋਤ ਹੈ।

ਇਕਸਾਰਤਾ

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

ਹੇਠ ਦਿੱਤੇ ਪ੍ਰੋਗਰਾਮ 'ਤੇ ਗੌਰ ਕਰੋ:

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

ਚਲੋ ਇਸ ਪ੍ਰੋਗਰਾਮ ਨੂੰ 1000 ਦੀ ਦਲੀਲ ਨਾਲ ਚਲਾਉਂਦੇ ਹਾਂ। ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਅਨੁਮਾਨ ਲਗਾਇਆ ਹੋਵੇਗਾ, ਨਤੀਜਾ 2000 ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿਉਂਕਿ ਹਰੇਕ ਥ੍ਰੈਡ ਵੇਰੀਏਬਲ ਨੂੰ 1000 ਵਾਰ ਵਧਾਉਂਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਹਰ ਚੀਜ਼ ਇੰਨੀ ਸਧਾਰਨ ਨਹੀਂ ਹੈ. ਆਉ ਪ੍ਰੋਗ੍ਰਾਮ ਨੂੰ ਹੋਰ ਦੁਹਰਾਓ ਦੇ ਕ੍ਰਮ ਦੇ ਨਾਲ ਚਲਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ।

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

ਸਰੋਤ: www.habr.com