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

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

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

• ਅਸਲੀ
• ਅਸਲੀ
• ਮੇਰਾ ਨਿੱਜੀ ਅਨੁਕੂਲਨ

ਹੋਰ ਹਿੱਸੇ:

• ਭਾਗ 1: ਜਾਣ-ਪਛਾਣ
• ਭਾਗ 2: ਐਬਸਟਰੈਕਸ਼ਨ: ਪ੍ਰਕਿਰਿਆ
• ਭਾਗ 3: ਪ੍ਰਕਿਰਿਆ API ਦੀ ਜਾਣ-ਪਛਾਣ
• ਭਾਗ 4: ਸ਼ਡਿਊਲਰ ਨਾਲ ਜਾਣ-ਪਛਾਣ

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

ਸ਼ਡਿਊਲਰ ਨਾਲ ਜਾਣ-ਪਛਾਣ

ਸਮੱਸਿਆ ਦਾ ਸਾਰ: ਇੱਕ ਸ਼ਡਿਊਲਰ ਨੀਤੀ ਕਿਵੇਂ ਵਿਕਸਿਤ ਕਰਨੀ ਹੈ
ਅੰਡਰਲਾਈੰਗ ਸ਼ਡਿਊਲਰ ਨੀਤੀ ਫਰੇਮਵਰਕ ਨੂੰ ਕਿਵੇਂ ਤਿਆਰ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ? ਮੁੱਖ ਧਾਰਨਾਵਾਂ ਕੀ ਹੋਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ? ਕਿਹੜੇ ਮਾਪਦੰਡ ਮਹੱਤਵਪੂਰਨ ਹਨ? ਸ਼ੁਰੂਆਤੀ ਕੰਪਿਊਟਿੰਗ ਪ੍ਰਣਾਲੀਆਂ ਵਿੱਚ ਕਿਹੜੀਆਂ ਬੁਨਿਆਦੀ ਤਕਨੀਕਾਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਗਈ ਸੀ?

ਵਰਕਲੋਡ ਧਾਰਨਾਵਾਂ

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

ਆਉ ਸਿਸਟਮ ਵਿੱਚ ਚੱਲ ਰਹੀਆਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਬਾਰੇ ਹੇਠ ਲਿਖੀਆਂ ਧਾਰਨਾਵਾਂ ਕਰੀਏ, ਕਈ ਵਾਰ ਇਸਨੂੰ ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਨੌਕਰੀ (ਕਾਰਜ)। ਲਗਭਗ ਇਹ ਸਾਰੀਆਂ ਧਾਰਨਾਵਾਂ ਯਥਾਰਥਵਾਦੀ ਨਹੀਂ ਹਨ, ਪਰ ਵਿਚਾਰ ਦੇ ਵਿਕਾਸ ਲਈ ਜ਼ਰੂਰੀ ਹਨ।

1. ਹਰ ਕੰਮ ਉਸੇ ਸਮੇਂ ਲਈ ਚੱਲਦਾ ਹੈ,
2. ਸਾਰੇ ਕੰਮ ਇੱਕੋ ਸਮੇਂ ਸੈੱਟ ਕੀਤੇ ਜਾਂਦੇ ਹਨ,
3. ਨਿਰਧਾਰਤ ਕੰਮ ਇਸ ਦੇ ਪੂਰਾ ਹੋਣ ਤੱਕ ਕੰਮ ਕਰਦਾ ਹੈ,
4. ਸਾਰੇ ਕੰਮ ਸਿਰਫ CPU ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ,
5. ਹਰ ਕੰਮ ਦਾ ਚੱਲਣ ਦਾ ਸਮਾਂ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ।

ਸ਼ਡਿਊਲਰ ਮੈਟ੍ਰਿਕਸ

ਲੋਡ ਬਾਰੇ ਕੁਝ ਧਾਰਨਾਵਾਂ ਤੋਂ ਇਲਾਵਾ, ਵੱਖ-ਵੱਖ ਸਮਾਂ-ਸਾਰਣੀ ਨੀਤੀਆਂ ਦੀ ਤੁਲਨਾ ਕਰਨ ਲਈ ਇੱਕ ਹੋਰ ਸਾਧਨ ਦੀ ਲੋੜ ਹੈ: ਸ਼ਡਿਊਲਰ ਮੈਟ੍ਰਿਕਸ। ਇੱਕ ਮੈਟ੍ਰਿਕ ਕਿਸੇ ਚੀਜ਼ ਦਾ ਕੁਝ ਮਾਪ ਹੈ। ਇੱਥੇ ਬਹੁਤ ਸਾਰੇ ਮੈਟ੍ਰਿਕਸ ਹਨ ਜੋ ਸ਼ਡਿਊਲਰ ਦੀ ਤੁਲਨਾ ਕਰਨ ਲਈ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ।

ਉਦਾਹਰਨ ਲਈ, ਅਸੀਂ ਇੱਕ ਮੀਟ੍ਰਿਕ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ ਜਿਸ ਨੂੰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਬਦਲਣ ਦਾ ਸਮਾਂ (ਟਰਨਅਰਾਊਂਡ ਟਾਈਮ) ਟਾਸਕ ਟਰਨਅਰਾਉਂਡ ਟਾਈਮ ਨੂੰ ਸਿਸਟਮ ਵਿੱਚ ਟਾਸਕ ਪੂਰਾ ਕਰਨ ਦੇ ਸਮੇਂ ਅਤੇ ਟਾਸਕ ਆਗਮਨ ਸਮੇਂ ਵਿੱਚ ਅੰਤਰ ਦੇ ਤੌਰ ਤੇ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ।

Tturnaround=Tcompletion−Tarrival

ਕਿਉਂਕਿ ਅਸੀਂ ਇਹ ਮੰਨ ਲਿਆ ਹੈ ਕਿ ਸਾਰੇ ਕੰਮ ਇੱਕੋ ਸਮੇਂ 'ਤੇ ਆਏ ਹਨ, ਫਿਰ Ta=0 ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ Tt=Tc। ਇਹ ਮੁੱਲ ਕੁਦਰਤੀ ਤੌਰ 'ਤੇ ਬਦਲ ਜਾਵੇਗਾ ਜਦੋਂ ਅਸੀਂ ਉਪਰੋਕਤ ਧਾਰਨਾਵਾਂ ਨੂੰ ਬਦਲਦੇ ਹਾਂ।

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

ਫਸਟ ਇਨ ਫਸਟ ਆਊਟ (ਫੀਫੋ)

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

ਆਉ ਇੱਕ ਸਧਾਰਨ ਉਦਾਹਰਣ ਵੱਲ ਧਿਆਨ ਦੇਈਏ. ਦੱਸ ਦੇਈਏ ਕਿ ਇੱਕੋ ਸਮੇਂ 3 ਟਾਸਕ ਸੈੱਟ ਕੀਤੇ ਗਏ ਸਨ। ਪਰ ਚਲੋ ਮੰਨ ਲਓ ਕਿ ਟਾਸਕ ਏ ਬਾਕੀਆਂ ਨਾਲੋਂ ਥੋੜਾ ਪਹਿਲਾਂ ਪਹੁੰਚਿਆ ਹੈ, ਇਸਲਈ ਇਹ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਸੂਚੀ ਵਿੱਚ ਦੂਜਿਆਂ ਨਾਲੋਂ ਪਹਿਲਾਂ ਦਿਖਾਈ ਦੇਵੇਗਾ, ਜਿਵੇਂ ਕਿ C ਦੇ ਮੁਕਾਬਲੇ B। ਚਲੋ ਇਹ ਮੰਨ ਲਓ ਕਿ ਉਹਨਾਂ ਵਿੱਚੋਂ ਹਰੇਕ ਨੂੰ 10 ਸਕਿੰਟਾਂ ਲਈ ਚਲਾਇਆ ਜਾਵੇਗਾ। ਇਸ ਕੇਸ ਵਿੱਚ ਇਹਨਾਂ ਕੰਮਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਔਸਤ ਸਮਾਂ ਕੀ ਹੋਵੇਗਾ?

ਮੁੱਲਾਂ ਦੀ ਗਿਣਤੀ ਕਰਕੇ - 10+20+30 ਅਤੇ 3 ਨਾਲ ਭਾਗ ਕਰਨ ਨਾਲ, ਸਾਨੂੰ ਔਸਤ ਪ੍ਰੋਗਰਾਮ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਸਮਾਂ 20 ਸਕਿੰਟਾਂ ਦੇ ਬਰਾਬਰ ਮਿਲਦਾ ਹੈ।
ਹੁਣ ਅਸੀਂ ਆਪਣੀਆਂ ਧਾਰਨਾਵਾਂ ਨੂੰ ਬਦਲਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ। ਖਾਸ ਤੌਰ 'ਤੇ, ਧਾਰਨਾ 1 ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਅਸੀਂ ਹੁਣ ਇਹ ਨਹੀਂ ਮੰਨਾਂਗੇ ਕਿ ਹਰੇਕ ਕੰਮ ਨੂੰ ਚਲਾਉਣ ਲਈ ਇੱਕੋ ਜਿਹਾ ਸਮਾਂ ਲੱਗਦਾ ਹੈ। FIFO ਇਸ ਵਾਰ ਕਿਵੇਂ ਪ੍ਰਦਰਸ਼ਨ ਕਰੇਗਾ?

ਜਿਵੇਂ ਕਿ ਇਹ ਪਤਾ ਚਲਦਾ ਹੈ, ਵੱਖ-ਵੱਖ ਕਾਰਜਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੇ ਸਮੇਂ ਦਾ FIFO ਐਲਗੋਰਿਦਮ ਦੀ ਉਤਪਾਦਕਤਾ 'ਤੇ ਬਹੁਤ ਮਾੜਾ ਪ੍ਰਭਾਵ ਪੈਂਦਾ ਹੈ। ਚਲੋ ਮੰਨ ਲਓ ਕਿ ਟਾਸਕ A ਨੂੰ ਪੂਰਾ ਹੋਣ ਵਿੱਚ 100 ਸਕਿੰਟ ਦਾ ਸਮਾਂ ਲੱਗੇਗਾ, ਜਦੋਂ ਕਿ B ਅਤੇ C ਨੂੰ ਅਜੇ ਵੀ 10 ਸਕਿੰਟ ਲੱਗਣਗੇ।

ਜਿਵੇਂ ਕਿ ਚਿੱਤਰ ਤੋਂ ਦੇਖਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਸਿਸਟਮ ਲਈ ਔਸਤ ਸਮਾਂ (100+110+120)/3=110 ਹੋਵੇਗਾ। ਇਸ ਪ੍ਰਭਾਵ ਨੂੰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਕਾਫਲੇ ਪ੍ਰਭਾਵ, ਜਦੋਂ ਇੱਕ ਸਰੋਤ ਦੇ ਕੁਝ ਥੋੜ੍ਹੇ ਸਮੇਂ ਦੇ ਖਪਤਕਾਰ ਇੱਕ ਭਾਰੀ ਖਪਤਕਾਰ ਦੇ ਬਾਅਦ ਕਤਾਰ ਵਿੱਚ ਹੋਣਗੇ. ਇਹ ਕਰਿਆਨੇ ਦੀ ਦੁਕਾਨ 'ਤੇ ਲਾਈਨ ਦੀ ਤਰ੍ਹਾਂ ਹੈ ਜਦੋਂ ਤੁਹਾਡੇ ਸਾਹਮਣੇ ਕੋਈ ਗਾਹਕ ਪੂਰੀ ਕਾਰਟ ਨਾਲ ਹੁੰਦਾ ਹੈ। ਸਮੱਸਿਆ ਦਾ ਸਭ ਤੋਂ ਵਧੀਆ ਹੱਲ ਕੈਸ਼ ਰਜਿਸਟਰ ਨੂੰ ਬਦਲਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨਾ ਜਾਂ ਆਰਾਮ ਕਰਨਾ ਅਤੇ ਡੂੰਘਾ ਸਾਹ ਲੈਣਾ ਹੈ।

ਸਭ ਤੋਂ ਛੋਟੀ ਨੌਕਰੀ ਪਹਿਲਾਂ

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

ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, ਇੱਕੋ ਜਿਹੀਆਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਚਲਾਉਣ ਦਾ ਨਤੀਜਾ ਔਸਤ ਪ੍ਰੋਗਰਾਮ ਦੇ ਬਦਲਣ ਦੇ ਸਮੇਂ ਵਿੱਚ ਸੁਧਾਰ ਹੋਵੇਗਾ ਅਤੇ ਇਹ ਬਰਾਬਰ ਹੋਵੇਗਾ 50 ਦੀ ਬਜਾਏ 110, ਜੋ ਲਗਭਗ 2 ਗੁਣਾ ਬਿਹਤਰ ਹੈ।

ਇਸ ਤਰ੍ਹਾਂ, ਦਿੱਤੀ ਗਈ ਧਾਰਨਾ ਲਈ ਕਿ ਸਾਰੇ ਕਾਰਜ ਇੱਕੋ ਸਮੇਂ 'ਤੇ ਪਹੁੰਚਦੇ ਹਨ, SJF ਐਲਗੋਰਿਦਮ ਸਭ ਤੋਂ ਅਨੁਕੂਲ ਐਲਗੋਰਿਦਮ ਜਾਪਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਸਾਡੀਆਂ ਧਾਰਨਾਵਾਂ ਅਜੇ ਵੀ ਵਾਸਤਵਿਕ ਨਹੀਂ ਜਾਪਦੀਆਂ। ਇਸ ਵਾਰ ਅਸੀਂ ਧਾਰਨਾ 2 ਨੂੰ ਬਦਲਦੇ ਹਾਂ ਅਤੇ ਇਸ ਵਾਰ ਕਲਪਨਾ ਕਰੋ ਕਿ ਕੰਮ ਕਿਸੇ ਵੀ ਸਮੇਂ ਮੌਜੂਦ ਹੋ ਸਕਦੇ ਹਨ, ਅਤੇ ਸਾਰੇ ਇੱਕੋ ਸਮੇਂ ਨਹੀਂ। ਇਸ ਨਾਲ ਕਿਹੜੀਆਂ ਸਮੱਸਿਆਵਾਂ ਪੈਦਾ ਹੋ ਸਕਦੀਆਂ ਹਨ?

ਚਲੋ ਕਲਪਨਾ ਕਰੀਏ ਕਿ ਟਾਸਕ A (100c) ਪਹਿਲਾਂ ਆਉਂਦਾ ਹੈ ਅਤੇ ਚਲਾਇਆ ਜਾਣਾ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ। t=10 'ਤੇ, ਟਾਸਕ B ਅਤੇ C ਆਉਂਦੇ ਹਨ, ਜਿਨ੍ਹਾਂ ਵਿੱਚੋਂ ਹਰ ਇੱਕ ਨੂੰ 10 ਸਕਿੰਟ ਲੱਗਣਗੇ। ਇਸ ਲਈ ਔਸਤ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਸਮਾਂ (100+(110-10)+(120-10))3 = 103 ਹੈ। ਸ਼ਡਿਊਲਰ ਇਸ ਨੂੰ ਸੁਧਾਰਨ ਲਈ ਕੀ ਕਰ ਸਕਦਾ ਹੈ?

ਪੂਰਾ ਕਰਨ ਲਈ ਸਭ ਤੋਂ ਛੋਟਾ ਸਮਾਂ (STCF)

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

ਇਸ ਯੋਜਨਾਕਾਰ ਦਾ ਨਤੀਜਾ ਹੇਠਾਂ ਦਿੱਤਾ ਨਤੀਜਾ ਹੋਵੇਗਾ: ((120-0)+(20-10)+(30-10))/3=50। ਇਸ ਤਰ੍ਹਾਂ, ਅਜਿਹਾ ਸ਼ਡਿਊਲਰ ਸਾਡੇ ਕੰਮਾਂ ਲਈ ਹੋਰ ਵੀ ਅਨੁਕੂਲ ਬਣ ਜਾਂਦਾ ਹੈ।

ਮੀਟ੍ਰਿਕ ਜਵਾਬ ਸਮਾਂ

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

ਜਵਾਬ ਦੇ ਸਮੇਂ ਦੀ ਗਣਨਾ ਇਸ ਤਰ੍ਹਾਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ:

Tresponse=Tfirstrun−Tarrival

ਇਸ ਤਰ੍ਹਾਂ, ਪਿਛਲੀ ਉਦਾਹਰਨ ਲਈ, ਜਵਾਬ ਸਮਾਂ ਹੋਵੇਗਾ: A=0, B=0, C=10 (abg=3,33)।

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

ਇਸ ਲਈ ਸਾਨੂੰ ਇੱਕ ਹੋਰ ਸਮੱਸਿਆ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪੈ ਰਿਹਾ ਹੈ - ਅਸੀਂ ਇੱਕ ਸ਼ਡਿਊਲਰ ਕਿਵੇਂ ਬਣਾ ਸਕਦੇ ਹਾਂ ਜੋ ਜਵਾਬ ਸਮੇਂ ਲਈ ਸੰਵੇਦਨਸ਼ੀਲ ਹੈ?

ਗੋਲ ਰਾਬਿਨ

ਇਸ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਇੱਕ ਐਲਗੋਰਿਦਮ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਸੀ ਗੋਲ ਰਾਬਿਨ (ਆਰ.ਆਰ.) ਮੁਢਲਾ ਵਿਚਾਰ ਕਾਫ਼ੀ ਸਰਲ ਹੈ: ਕਾਰਜਾਂ ਨੂੰ ਪੂਰਾ ਹੋਣ ਤੱਕ ਚਲਾਉਣ ਦੀ ਬਜਾਏ, ਅਸੀਂ ਕੰਮ ਨੂੰ ਇੱਕ ਨਿਸ਼ਚਿਤ ਸਮੇਂ ਲਈ ਚਲਾਵਾਂਗੇ (ਇੱਕ ਸਮੇਂ ਦਾ ਟੁਕੜਾ ਕਿਹਾ ਜਾਂਦਾ ਹੈ) ਅਤੇ ਫਿਰ ਕਤਾਰ ਤੋਂ ਕਿਸੇ ਹੋਰ ਕੰਮ 'ਤੇ ਸਵਿਚ ਕਰਾਂਗੇ। ਐਲਗੋਰਿਦਮ ਆਪਣੇ ਕੰਮ ਨੂੰ ਉਦੋਂ ਤੱਕ ਦੁਹਰਾਉਂਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਸਾਰੇ ਕੰਮ ਪੂਰੇ ਨਹੀਂ ਹੋ ਜਾਂਦੇ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਪ੍ਰੋਗਰਾਮ ਦਾ ਚੱਲਣ ਦਾ ਸਮਾਂ ਉਸ ਸਮੇਂ ਦਾ ਗੁਣਕ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਜਿਸ ਤੋਂ ਬਾਅਦ ਟਾਈਮਰ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਵਿਘਨ ਪਾਵੇਗਾ। ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਇੱਕ ਟਾਈਮਰ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਹਰ x=10ms ਵਿੱਚ ਰੁਕਾਵਟ ਪਾਉਂਦਾ ਹੈ, ਤਾਂ ਪ੍ਰਕਿਰਿਆ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਵਿੰਡੋ ਦਾ ਆਕਾਰ 10 ਦਾ ਮਲਟੀਪਲ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ 10,20 ਜਾਂ x*10 ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।

ਆਉ ਇੱਕ ਉਦਾਹਰਨ ਵੇਖੀਏ: ABC ਟਾਸਕ ਸਿਸਟਮ ਵਿੱਚ ਇੱਕੋ ਸਮੇਂ ਆਉਂਦੇ ਹਨ ਅਤੇ ਉਹਨਾਂ ਵਿੱਚੋਂ ਹਰ ਇੱਕ 5 ਸਕਿੰਟਾਂ ਲਈ ਚੱਲਣਾ ਚਾਹੁੰਦਾ ਹੈ। SJF ਐਲਗੋਰਿਦਮ ਹਰ ਕੰਮ ਨੂੰ ਹੋਰ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਪੂਰਾ ਕਰੇਗਾ। ਇਸਦੇ ਉਲਟ, ਇੱਕ ਲਾਂਚ ਵਿੰਡੋ = 1s ਦੇ ਨਾਲ RR ਐਲਗੋਰਿਦਮ ਹੇਠ ਲਿਖੇ ਕੰਮਾਂ ਵਿੱਚੋਂ ਲੰਘੇਗਾ (ਚਿੱਤਰ 4.3):

(SJF ਦੁਬਾਰਾ (ਜਵਾਬ ਸਮੇਂ ਲਈ ਮਾੜਾ)

(ਰਾਊਂਡ ਰੌਬਿਨ (ਜਵਾਬ ਸਮੇਂ ਲਈ ਚੰਗਾ)

RR ਐਲਗੋਰਿਦਮ ਲਈ ਔਸਤ ਜਵਾਬ ਸਮਾਂ (0+1+2)/3=1 ਹੈ, ਜਦੋਂ ਕਿ SJF (0+5+10)/3=5 ਲਈ।

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

ਆਰਆਰ ਇੱਕ ਵਧੀਆ ਸ਼ਡਿਊਲਰ ਹੈ ਜੇਕਰ ਅਸੀਂ ਸਿਰਫ ਜਵਾਬ ਸਮਾਂ ਮੈਟ੍ਰਿਕ ਬਾਰੇ ਗੱਲ ਕਰ ਰਹੇ ਸੀ. ਪਰ ਇਸ ਐਲਗੋਰਿਦਮ ਨਾਲ ਟਾਸਕ ਟਰਨਅਰਾਊਂਡ ਟਾਈਮ ਮੈਟ੍ਰਿਕ ਕਿਵੇਂ ਵਿਵਹਾਰ ਕਰੇਗਾ? ਉਪਰੋਕਤ ਉਦਾਹਰਨ 'ਤੇ ਗੌਰ ਕਰੋ, ਜਦੋਂ A, B, C = 5s ਦਾ ਓਪਰੇਟਿੰਗ ਸਮਾਂ ਹੁੰਦਾ ਹੈ ਅਤੇ ਉਸੇ ਸਮੇਂ ਪਹੁੰਚਦਾ ਹੈ। ਟਾਸਕ A 13 'ਤੇ, B 14 'ਤੇ, C 'ਤੇ 15s ਅਤੇ ਔਸਤ ਟਰਨਅਰਾਊਂਡ ਸਮਾਂ 14s ਹੋਵੇਗਾ। ਇਸ ਤਰ੍ਹਾਂ, ਟਰਨਓਵਰ ਮੈਟ੍ਰਿਕ ਲਈ ਆਰਆਰ ਸਭ ਤੋਂ ਭੈੜਾ ਐਲਗੋਰਿਦਮ ਹੈ।

ਵਧੇਰੇ ਆਮ ਸ਼ਬਦਾਂ ਵਿੱਚ, ਕੋਈ ਵੀ ਆਰਆਰ-ਕਿਸਮ ਦਾ ਐਲਗੋਰਿਦਮ ਨਿਰਪੱਖ ਹੈ; ਇਹ CPU ਸਮੇਂ ਨੂੰ ਸਾਰੀਆਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਵਿਚਕਾਰ ਬਰਾਬਰ ਵੰਡਦਾ ਹੈ। ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ, ਇਹ ਮਾਪਦੰਡ ਲਗਾਤਾਰ ਇੱਕ ਦੂਜੇ ਨਾਲ ਟਕਰਾ ਜਾਂਦੇ ਹਨ।

ਇਸ ਤਰ੍ਹਾਂ, ਸਾਡੇ ਕੋਲ ਕਈ ਵਿਪਰੀਤ ਐਲਗੋਰਿਦਮ ਹਨ ਅਤੇ ਉਸੇ ਸਮੇਂ ਅਜੇ ਵੀ ਕਈ ਧਾਰਨਾਵਾਂ ਬਾਕੀ ਹਨ - ਕਿ ਕੰਮ ਦਾ ਸਮਾਂ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਇਹ ਕਿ ਕੰਮ ਸਿਰਫ CPU ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।

I/O ਨਾਲ ਮਿਲਾਉਣਾ

ਸਭ ਤੋਂ ਪਹਿਲਾਂ, ਆਓ ਇਸ ਧਾਰਨਾ 4 ਨੂੰ ਹਟਾ ਦੇਈਏ ਕਿ ਪ੍ਰਕਿਰਿਆ ਸਿਰਫ CPU ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ; ਕੁਦਰਤੀ ਤੌਰ 'ਤੇ, ਅਜਿਹਾ ਨਹੀਂ ਹੈ ਅਤੇ ਪ੍ਰਕਿਰਿਆਵਾਂ ਹੋਰ ਉਪਕਰਣਾਂ ਤੱਕ ਪਹੁੰਚ ਕਰ ਸਕਦੀਆਂ ਹਨ।

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

ਆਉ ਕਈ ਕਾਰਜਾਂ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਵੇਖੀਏ. ਉਹਨਾਂ ਵਿੱਚੋਂ ਹਰੇਕ ਨੂੰ 50ms CPU ਸਮਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਹਾਲਾਂਕਿ, ਪਹਿਲਾ ਇੱਕ I/O ਨੂੰ ਹਰ 10ms ਤੱਕ ਪਹੁੰਚ ਕਰੇਗਾ (ਜੋ ਹਰ 10ms ਬਾਅਦ ਚਲਾਇਆ ਜਾਵੇਗਾ)। ਅਤੇ ਪ੍ਰੋਸੈਸ B I/O ਤੋਂ ਬਿਨਾਂ 50ms ਪ੍ਰੋਸੈਸਰ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।

ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ ਅਸੀਂ STCF ਸ਼ਡਿਊਲਰ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ। ਸ਼ਡਿਊਲਰ ਕਿਵੇਂ ਵਿਵਹਾਰ ਕਰੇਗਾ ਜੇਕਰ A ਵਰਗੀ ਪ੍ਰਕਿਰਿਆ ਇਸ 'ਤੇ ਸ਼ੁਰੂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ? ਉਹ ਹੇਠ ਲਿਖੇ ਕੰਮ ਕਰੇਗਾ: ਪਹਿਲਾਂ ਉਹ ਪ੍ਰਕਿਰਿਆ ਏ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਤਿਆਰ ਕਰੇਗਾ, ਅਤੇ ਫਿਰ ਬੀ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰੇਗਾ।

ਇਸ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਪਰੰਪਰਾਗਤ ਪਹੁੰਚ ਪ੍ਰਕਿਰਿਆ A ਦੇ ਹਰੇਕ 10 ms ਉਪ-ਟਾਸਕ ਨੂੰ ਇੱਕ ਵੱਖਰੇ ਕਾਰਜ ਵਜੋਂ ਮੰਨਣਾ ਹੈ। ਇਸ ਤਰ੍ਹਾਂ, ਜਦੋਂ STJF ਐਲਗੋਰਿਦਮ ਨਾਲ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋ, ਤਾਂ 50 ms ਟਾਸਕ ਅਤੇ 10 ms ਟਾਸਕ ਵਿਚਕਾਰ ਚੋਣ ਸਪੱਸ਼ਟ ਹੈ। ਫਿਰ, ਜਦੋਂ ਸਬਟਾਸਕ A ਪੂਰਾ ਹੋ ਜਾਂਦਾ ਹੈ, ਪ੍ਰਕਿਰਿਆ B ਅਤੇ I/O ਨੂੰ ਲਾਂਚ ਕੀਤਾ ਜਾਵੇਗਾ। I/O ਪੂਰਾ ਹੋਣ ਤੋਂ ਬਾਅਦ, ਪ੍ਰਕਿਰਿਆ B ਦੀ ਬਜਾਏ 10ms ਪ੍ਰਕਿਰਿਆ A ਨੂੰ ਦੁਬਾਰਾ ਸ਼ੁਰੂ ਕਰਨ ਦਾ ਰਿਵਾਜ ਹੋਵੇਗਾ। ਇਸ ਤਰ੍ਹਾਂ, ਓਵਰਲੈਪ ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਸੰਭਵ ਹੈ, ਜਿੱਥੇ CPU ਨੂੰ ਕਿਸੇ ਹੋਰ ਪ੍ਰਕਿਰਿਆ ਦੁਆਰਾ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਕਿ ਪਹਿਲੇ ਦੀ ਉਡੀਕ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। I/O ਅਤੇ ਨਤੀਜੇ ਵਜੋਂ, ਸਿਸਟਮ ਦੀ ਬਿਹਤਰ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ - ਇਸ ਸਮੇਂ ਜਦੋਂ ਇੰਟਰਐਕਟਿਵ ਪ੍ਰਕਿਰਿਆਵਾਂ I/O ਦੀ ਉਡੀਕ ਕਰ ਰਹੀਆਂ ਹਨ, ਹੋਰ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਪ੍ਰੋਸੈਸਰ 'ਤੇ ਚਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।

ਓਰੇਕਲ ਹੋਰ ਨਹੀਂ ਹੈ

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

ਨਤੀਜਾ

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

ਸਰੋਤ: www.habr.com