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

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

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

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

ਹੋਰ ਹਿੱਸੇ:

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

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

ਯੋਜਨਾਬੰਦੀ: ਬਹੁ-ਪੱਧਰੀ ਫੀਡਬੈਕ ਕਤਾਰ

ਇਸ ਲੈਕਚਰ ਵਿੱਚ, ਅਸੀਂ ਸਭ ਤੋਂ ਮਸ਼ਹੂਰ ਪਹੁੰਚਾਂ ਵਿੱਚੋਂ ਇੱਕ ਨੂੰ ਵਿਕਸਤ ਕਰਨ ਦੀਆਂ ਸਮੱਸਿਆਵਾਂ ਬਾਰੇ ਗੱਲ ਕਰਾਂਗੇ
ਯੋਜਨਾ, ਜਿਸ ਨੂੰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਬਹੁ-ਪੱਧਰੀ ਫੀਡਬੈਕ ਕਤਾਰ (MLFQ)। MLFQ ਸ਼ਡਿਊਲਰ ਦਾ ਵਰਣਨ ਪਹਿਲੀ ਵਾਰ 1962 ਵਿੱਚ ਫਰਨਾਂਡੋ ਜੇ. ਕੋਰਬਾਟੋ ਦੁਆਰਾ ਇੱਕ ਸਿਸਟਮ ਵਿੱਚ ਕੀਤਾ ਗਿਆ ਸੀ।
ਅਨੁਕੂਲ ਸਮਾਂ-ਸ਼ੇਅਰਿੰਗ ਸਿਸਟਮ (CTSS)। ਇਹ ਕੰਮ (ਬਾਅਦ ਦੇ ਕੰਮਾਂ ਸਮੇਤ
ਮਲਟੀਕਸ) ਨੂੰ ਬਾਅਦ ਵਿੱਚ ਟਿਊਰਿੰਗ ਅਵਾਰਡ ਲਈ ਨਾਮਜ਼ਦ ਕੀਤਾ ਗਿਆ ਸੀ। ਸ਼ਡਿਊਲਰ ਸੀ
ਬਾਅਦ ਵਿੱਚ ਸੁਧਾਰ ਕੀਤਾ ਅਤੇ ਦਿੱਖ ਹਾਸਲ ਕੀਤੀ ਜੋ ਪਹਿਲਾਂ ਹੀ ਲੱਭੀ ਜਾ ਸਕਦੀ ਹੈ
ਕੁਝ ਆਧੁਨਿਕ ਸਿਸਟਮ.

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

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

ਨੋਟ: ਪਿਛਲੀਆਂ ਘਟਨਾਵਾਂ ਤੋਂ ਸਿੱਖਣਾ

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

MLFQ: ਬੁਨਿਆਦੀ ਨਿਯਮ

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

• ਨਿਯਮ 1: ਜੇਕਰ ਤਰਜੀਹ(A) > ਤਰਜੀਹ(B), ਕਾਰਜ A ਚੱਲੇਗਾ (B ਨਹੀਂ ਹੋਵੇਗਾ)
• ਨਿਯਮ2: ਜੇਕਰ ਤਰਜੀਹ(A) = ਤਰਜੀਹ(B), A&B ਨੂੰ RR ਦੀ ਵਰਤੋਂ ਸ਼ੁਰੂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ

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

ਇਸ ਸਕੀਮ ਵਿੱਚ, 2 ਪ੍ਰਕਿਰਿਆਵਾਂ A ਅਤੇ B ਸਭ ਤੋਂ ਵੱਧ ਤਰਜੀਹ ਦੇ ਨਾਲ ਕਤਾਰ ਵਿੱਚ ਹਨ। ਪ੍ਰਕਿਰਿਆ
C ਮੱਧ ਵਿੱਚ ਕਿਤੇ ਹੈ, ਅਤੇ ਪ੍ਰਕਿਰਿਆ D ਕਤਾਰ ਦੇ ਬਿਲਕੁਲ ਅੰਤ ਵਿੱਚ ਹੈ। ਉਪਰੋਕਤ ਅਨੁਸਾਰ
MLFQ ਐਲਗੋਰਿਦਮ ਦੇ ਵਰਣਨ, ਸ਼ਡਿਊਲਰ ਸਿਰਫ ਉੱਚਤਮ ਕਾਰਜਾਂ ਨੂੰ ਲਾਗੂ ਕਰੇਗਾ
RR ਦੇ ਅਨੁਸਾਰ ਤਰਜੀਹ, ਅਤੇ ਟਾਸਕ C, D ਕੰਮ ਤੋਂ ਬਾਹਰ ਹੋ ਜਾਣਗੇ।
ਕੁਦਰਤੀ ਤੌਰ 'ਤੇ, ਇੱਕ ਸਥਿਰ ਸਨੈਪਸ਼ਾਟ ਇਸ ਗੱਲ ਦੀ ਪੂਰੀ ਤਸਵੀਰ ਨਹੀਂ ਦੇਵੇਗਾ ਕਿ MLFQ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ।
ਇਹ ਸਮਝਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਸਮੇਂ ਦੇ ਨਾਲ ਤਸਵੀਰ ਕਿਵੇਂ ਬਦਲਦੀ ਹੈ.

ਕੋਸ਼ਿਸ਼ 1: ਤਰਜੀਹ ਨੂੰ ਕਿਵੇਂ ਬਦਲਣਾ ਹੈ

ਇਸ ਸਮੇਂ, ਤੁਹਾਨੂੰ ਇਹ ਫੈਸਲਾ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਕਿ MLFQ ਤਰਜੀਹੀ ਪੱਧਰ ਨੂੰ ਕਿਵੇਂ ਬਦਲੇਗਾ
ਕਾਰਜ (ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਕਤਾਰ ਵਿੱਚ ਕੰਮ ਦੀ ਸਥਿਤੀ) ਇਸਦੇ ਜੀਵਨ ਚੱਕਰ ਦੇ ਦੌਰਾਨ. ਲਈ
ਇਸ ਵਿੱਚੋਂ, ਤੁਹਾਨੂੰ ਵਰਕਫਲੋ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਣ ਦੀ ਲੋੜ ਹੈ: ਇੱਕ ਨਿਸ਼ਚਿਤ ਮਾਤਰਾ
ਥੋੜ੍ਹੇ ਸਮੇਂ ਦੇ ਚੱਲਣ ਵਾਲੇ ਇੰਟਰਐਕਟਿਵ ਕੰਮ (ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਅਕਸਰ ਰੀਲੀਜ਼
CPU) ਅਤੇ ਕਈ ਲੰਬੇ ਕਾਰਜ ਜੋ CPU ਨੂੰ ਆਪਣੇ ਸਾਰੇ ਕੰਮ ਕਰਨ ਦੇ ਸਮੇਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ, ਜਦਕਿ
ਅਜਿਹੇ ਕੰਮਾਂ ਲਈ ਜਵਾਬ ਸਮਾਂ ਮਹੱਤਵਪੂਰਨ ਨਹੀਂ ਹੈ। ਅਤੇ ਇਸ ਲਈ ਤੁਸੀਂ ਪਹਿਲੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਸਕਦੇ ਹੋ
ਹੇਠਾਂ ਦਿੱਤੇ ਨਿਯਮਾਂ ਨਾਲ MLFQ ਐਲਗੋਰਿਦਮ ਲਾਗੂ ਕਰੋ:

• ਨਿਯਮ 3: ਜਦੋਂ ਕੋਈ ਕੰਮ ਸਿਸਟਮ ਵਿੱਚ ਦਾਖਲ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਸਭ ਤੋਂ ਉੱਚੀ ਕਤਾਰ ਵਿੱਚ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ
• ਤਰਜੀਹ.
• ਨਿਯਮ 4 ਏ: ਜੇਕਰ ਕੋਈ ਕੰਮ ਆਪਣੀ ਪੂਰੀ ਸਮਾਂ ਵਿੰਡੋ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਤਾਂ ਇਹ
• ਤਰਜੀਹ ਘੱਟ ਕੀਤੀ ਗਈ ਹੈ।
• Rule4b: ਜੇਕਰ ਕੋਈ ਟਾਸਕ CPU ਨੂੰ ਇਸਦੀ ਸਮਾਂ ਵਿੰਡੋ ਦੀ ਮਿਆਦ ਪੁੱਗਣ ਤੋਂ ਪਹਿਲਾਂ ਜਾਰੀ ਕਰਦਾ ਹੈ, ਤਾਂ ਇਹ
• ਉਸੇ ਤਰਜੀਹ ਦੇ ਨਾਲ ਰਹਿੰਦਾ ਹੈ.

ਉਦਾਹਰਨ 1: ਲੰਬੇ ਸਮੇਂ ਤੱਕ ਚੱਲਣ ਵਾਲਾ ਸਿੰਗਲ ਟਾਸਕ

ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ ਦੇਖ ਸਕਦੇ ਹੋ, ਦਾਖਲੇ 'ਤੇ ਕੰਮ ਸਭ ਤੋਂ ਉੱਚੇ ਨਾਲ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ
ਤਰਜੀਹ. ਇੱਕ 10ms ਸਮਾਂ ਵਿੰਡੋ ਤੋਂ ਬਾਅਦ, ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਤਰਜੀਹ ਵਿੱਚ ਡਾਊਨਗ੍ਰੇਡ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
ਸ਼ਡਿਊਲਰ ਅਗਲੀ ਵਾਰ ਵਿੰਡੋ ਦੇ ਬਾਅਦ, ਕਾਰਜ ਨੂੰ ਅੰਤ ਵਿੱਚ ਡਾਊਨਗ੍ਰੇਡ ਕੀਤਾ ਗਿਆ ਹੈ
ਸਿਸਟਮ ਵਿੱਚ ਸਭ ਤੋਂ ਘੱਟ ਤਰਜੀਹ, ਜਿੱਥੇ ਇਹ ਰਹਿੰਦਾ ਹੈ।

ਉਦਾਹਰਨ 2: ਇੱਕ ਛੋਟਾ ਕੰਮ ਚੁਣਿਆ

ਹੁਣ ਆਓ ਇੱਕ ਉਦਾਹਰਨ ਵੇਖੀਏ ਕਿ ਕਿਵੇਂ MLFQ SJF ਤੱਕ ਪਹੁੰਚਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੇਗਾ। ਉਸ ਵਿੱਚ
ਉਦਾਹਰਨ ਲਈ, ਦੋ ਕਾਰਜ: A, ਜੋ ਕਿ ਇੱਕ ਲੰਬੇ ਸਮੇਂ ਤੋਂ ਚੱਲ ਰਿਹਾ ਕੰਮ ਹੈ
CPU ਅਤੇ B 'ਤੇ ਕਬਜ਼ਾ ਕਰਨਾ, ਜੋ ਕਿ ਇੱਕ ਛੋਟਾ ਇੰਟਰਐਕਟਿਵ ਕੰਮ ਹੈ। ਮੰਨ ਲਓ
ਕਿ ਟਾਸਕ ਬੀ ਦੇ ਪਹੁੰਚਣ ਤੱਕ A ਕੁਝ ਸਮੇਂ ਲਈ ਚੱਲ ਰਿਹਾ ਸੀ।

ਇਹ ਗ੍ਰਾਫ਼ ਦ੍ਰਿਸ਼ ਦੇ ਨਤੀਜੇ ਦਿਖਾਉਂਦਾ ਹੈ। ਟਾਸਕ ਏ, ਕਿਸੇ ਵੀ ਕੰਮ ਵਾਂਗ,
CPU ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਬਹੁਤ ਹੇਠਾਂ ਸੀ. ਟਾਸਕ ਬੀ T=100 ਸਮੇਂ ਤੇ ਪਹੁੰਚੇਗਾ ਅਤੇ ਹੋਵੇਗਾ
ਸਭ ਤੋਂ ਵੱਧ ਤਰਜੀਹ ਵਾਲੀ ਕਤਾਰ ਵਿੱਚ ਰੱਖਿਆ ਗਿਆ। ਕਿਉਂਕਿ ਚੱਲਣ ਦਾ ਸਮਾਂ ਛੋਟਾ ਹੈ,
ਇਹ ਆਖਰੀ ਕਤਾਰ 'ਤੇ ਪਹੁੰਚਣ ਤੋਂ ਪਹਿਲਾਂ ਪੂਰਾ ਹੋ ਜਾਵੇਗਾ।

ਇਸ ਉਦਾਹਰਨ ਤੋਂ, ਤੁਹਾਨੂੰ ਐਲਗੋਰਿਦਮ ਦੇ ਮੁੱਖ ਟੀਚੇ ਨੂੰ ਸਮਝਣਾ ਚਾਹੀਦਾ ਹੈ: ਕਿਉਂਕਿ ਐਲਗੋਰਿਦਮ ਅਜਿਹਾ ਨਹੀਂ ਕਰਦਾ ਹੈ
ਇੱਕ ਲੰਮਾ ਜਾਂ ਛੋਟਾ ਕੰਮ ਜਾਣਦਾ ਹੈ, ਫਿਰ ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਉਹ ਕੰਮ ਮੰਨ ਲੈਂਦਾ ਹੈ
ਛੋਟਾ ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਸਭ ਤੋਂ ਵੱਧ ਤਰਜੀਹ ਦਿੰਦਾ ਹੈ। ਜੇ ਇਹ ਸੱਚਮੁੱਚ ਇੱਕ ਛੋਟਾ ਕੰਮ ਹੈ, ਤਾਂ
ਇਹ ਤੇਜ਼ੀ ਨਾਲ ਚੱਲੇਗਾ, ਨਹੀਂ ਤਾਂ ਜੇਕਰ ਇਹ ਇੱਕ ਲੰਮਾ ਕੰਮ ਹੈ ਤਾਂ ਇਹ ਹੌਲੀ-ਹੌਲੀ ਅੱਗੇ ਵਧੇਗਾ
ਹੇਠਾਂ ਤਰਜੀਹ ਦਿੱਤੀ ਗਈ ਹੈ ਅਤੇ ਜਲਦੀ ਹੀ ਇਹ ਸਾਬਤ ਕਰੇਗੀ ਕਿ ਉਹ ਅਸਲ ਵਿੱਚ ਇੱਕ ਲੰਮਾ ਕੰਮ ਹੈ ਜੋ ਨਹੀਂ ਕਰਦਾ
ਜਵਾਬ ਦੀ ਲੋੜ ਹੈ।

ਉਦਾਹਰਨ 3: I/O ਬਾਰੇ ਕੀ?

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

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

ਮੌਜੂਦਾ MLFQ ਐਲਗੋਰਿਦਮ ਨਾਲ ਸਮੱਸਿਆਵਾਂ

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

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

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

ਹਾਜ਼ਰੀਨ ਨੂੰ ਸਵਾਲ: ਆਧੁਨਿਕ ਸੰਸਾਰ ਵਿੱਚ ਸ਼ਡਿਊਲਰ 'ਤੇ ਕੀ ਹਮਲੇ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ?

ਕੋਸ਼ਿਸ਼ 2: ਤਰਜੀਹ ਵਧਾਓ

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

• ਨਿਯਮ.: ਕੁਝ ਸਮੇਂ ਬਾਅਦ S, ਸਿਸਟਮ ਦੇ ਸਾਰੇ ਕਾਰਜਾਂ ਨੂੰ ਸਭ ਤੋਂ ਉੱਚੀ ਕਤਾਰ ਵਿੱਚ ਤਬਦੀਲ ਕਰੋ।

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

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

ਕੋਸ਼ਿਸ਼ 3: ਬਿਹਤਰ ਲੇਖਾ-ਜੋਖਾ

ਹੁਣ ਸਾਡੇ ਕੋਲ ਹੱਲ ਕਰਨ ਲਈ ਇੱਕ ਹੋਰ ਸਮੱਸਿਆ ਹੈ: ਕਿਵੇਂ ਨਹੀਂ
ਸਾਡੇ ਸ਼ਡਿਊਲਰ ਨੂੰ ਧੋਖਾ ਦੇਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿਓ? ਇਸ ਸੰਭਾਵਨਾ ਲਈ ਦੋਸ਼ੀ ਹਨ
ਨਿਯਮ 4a, 4b ਜੋ ਪ੍ਰੋਸੈਸਰ ਨੂੰ ਖਾਲੀ ਕਰਕੇ ਨੌਕਰੀ ਨੂੰ ਆਪਣੀ ਤਰਜੀਹ ਰੱਖਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੇ ਹਨ
ਨਿਰਧਾਰਤ ਸਮੇਂ ਦੀ ਸਮਾਪਤੀ ਤੋਂ ਪਹਿਲਾਂ। ਇਸ ਨਾਲ ਕਿਵੇਂ ਨਜਿੱਠਣਾ ਹੈ?
ਇਸ ਮਾਮਲੇ ਵਿੱਚ ਹੱਲ ਹਰੇਕ 'ਤੇ CPU ਸਮੇਂ ਦਾ ਬਿਹਤਰ ਲੇਖਾ-ਜੋਖਾ ਮੰਨਿਆ ਜਾ ਸਕਦਾ ਹੈ
MLFQ ਪੱਧਰ। ਪ੍ਰੋਗਰਾਮ ਦਾ ਸਮਾਂ ਭੁੱਲਣ ਦੀ ਬਜਾਏ
ਨਿਰਧਾਰਤ ਅੰਤਰਾਲ ਲਈ ਪ੍ਰੋਸੈਸਰ, ਤੁਹਾਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਣਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। ਤੋਂ ਬਾਅਦ
ਪ੍ਰਕਿਰਿਆ ਨੇ ਆਪਣੇ ਨਿਰਧਾਰਤ ਸਮੇਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ, ਇਸ ਨੂੰ ਅਗਲੇ ਵਿੱਚ ਘਟਾ ਦਿੱਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ
ਤਰਜੀਹ ਪੱਧਰ. ਹੁਣ ਇਸ ਨਾਲ ਕੋਈ ਫਰਕ ਨਹੀਂ ਪੈਂਦਾ ਕਿ ਪ੍ਰਕਿਰਿਆ ਆਪਣੇ ਸਮੇਂ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰੇਗੀ - ਕਿਵੇਂ
ਪ੍ਰੋਸੈਸਰ 'ਤੇ ਜਾਂ ਕਾਲਾਂ ਦੇ ਸੈੱਟ ਵਜੋਂ ਲਗਾਤਾਰ ਕੰਪਿਊਟਿੰਗ। ਇਸ ਤਰ੍ਹਾਂ,
ਨਿਯਮ 4 ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਦੁਬਾਰਾ ਲਿਖਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ:

• ਨਿਯਮ.: ਇੱਕ ਕਾਰਜ ਦੁਆਰਾ ਮੌਜੂਦਾ ਕਤਾਰ ਵਿੱਚ ਆਪਣੇ ਨਿਰਧਾਰਤ ਸਮੇਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਤੋਂ ਬਾਅਦ (ਭਾਵੇਂ ਇਸਨੇ CPU ਨੂੰ ਕਿੰਨੀ ਵਾਰ ਖਾਲੀ ਕੀਤਾ ਹੋਵੇ), ਅਜਿਹੇ ਕਾਰਜ ਦੀ ਤਰਜੀਹ ਘਟ ਜਾਂਦੀ ਹੈ (ਇਹ ਕਤਾਰ ਦੇ ਹੇਠਾਂ ਚਲੀ ਜਾਂਦੀ ਹੈ)।

ਆਓ ਇੱਕ ਉਦਾਹਰਨ ਵੇਖੀਏ:
»

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

MLFQ ਅਤੇ ਹੋਰ ਮੁੱਦਿਆਂ ਵਿੱਚ ਸੁਧਾਰ ਕਰਨਾ

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

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

ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, 2 ਕਾਰਜ ਹਨ ਜਿਨ੍ਹਾਂ ਨੇ ਉੱਚ ਤਰਜੀਹ ਕਤਾਰ 20 ਵਿੱਚ ਕੰਮ ਕੀਤਾ ਹੈ
ms ਨੂੰ 10ms ਵਿੰਡੋਜ਼ ਵਿੱਚ ਵੰਡਿਆ ਗਿਆ ਹੈ। ਮੱਧ ਕਤਾਰ (40ms ਵਿੰਡੋ) ਵਿੱਚ ਅਤੇ ਘੱਟ ਤਰਜੀਹ ਵਾਲੀ ਕਤਾਰ ਵਿੱਚ 20ms
ਕਤਾਰ ਸਮਾਂ ਵਿੰਡੋ 40ms ਬਣ ਗਈ ਜਿੱਥੇ ਕਾਰਜਾਂ ਨੇ ਆਪਣਾ ਕੰਮ ਪੂਰਾ ਕੀਤਾ।

ਸੋਲਾਰਿਸ OS ਵਿੱਚ MLFQ ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਸਮਾਂ-ਸਾਂਝੇ ਸ਼ਡਿਊਲਰਾਂ ਦੀ ਇੱਕ ਸ਼੍ਰੇਣੀ ਹੈ।
ਸ਼ਡਿਊਲਰ ਟੇਬਲਾਂ ਦਾ ਇੱਕ ਸੈੱਟ ਪ੍ਰਦਾਨ ਕਰੇਗਾ ਜੋ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ ਕਿ ਇਹ ਕਿਵੇਂ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ
ਇਸ ਦੇ ਜੀਵਨ ਦੇ ਦੌਰਾਨ ਪ੍ਰਕਿਰਿਆ ਦੀ ਤਰਜੀਹ ਨੂੰ ਬਦਲੋ, ਆਕਾਰ ਕੀ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ
ਵਿੰਡੋ ਨਿਰਧਾਰਤ ਕੀਤੀ ਜਾਣੀ ਹੈ ਅਤੇ ਕਿੰਨੀ ਵਾਰ ਕੰਮ ਦੀਆਂ ਤਰਜੀਹਾਂ ਨੂੰ ਵਧਾਉਣਾ ਹੈ। ਪ੍ਰਸ਼ਾਸਕ
ਸਿਸਟਮ ਇਸ ਸਾਰਣੀ ਨਾਲ ਇੰਟਰੈਕਟ ਕਰ ਸਕਦਾ ਹੈ ਅਤੇ ਸ਼ਡਿਊਲਰ ਨੂੰ ਵਿਵਹਾਰ ਕਰ ਸਕਦਾ ਹੈ
ਵੱਖਰੇ ਤੌਰ 'ਤੇ। ਮੂਲ ਰੂਪ ਵਿੱਚ, ਇਸ ਸਾਰਣੀ ਵਿੱਚ ਹੌਲੀ-ਹੌਲੀ ਵਾਧੇ ਦੇ ਨਾਲ 60 ਕਤਾਰਾਂ ਹਨ
ਵਿੰਡੋ ਦਾ ਆਕਾਰ 20ms (ਉੱਚ ਤਰਜੀਹ) ਤੋਂ ਕਈ ਸੌ ms (ਸਭ ਤੋਂ ਘੱਟ ਤਰਜੀਹ) ਤੱਕ, ਅਤੇ
ਹਰ ਸਕਿੰਟ ਵਿੱਚ ਇੱਕ ਵਾਰ ਸਾਰੇ ਕਾਰਜਾਂ ਨੂੰ ਵਧਾਉਣ ਦੇ ਨਾਲ।

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

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

MLFQ: ਸੰਖੇਪ

ਅਸੀਂ MLFQ ਨਾਮਕ ਯੋਜਨਾਬੰਦੀ ਪਹੁੰਚ ਦਾ ਵਰਣਨ ਕੀਤਾ ਹੈ। ਉਸਦਾ ਨਾਮ
ਸੰਚਾਲਨ ਦੇ ਸਿਧਾਂਤ ਵਿੱਚ ਸਿੱਟਾ ਕੱਢਿਆ ਗਿਆ ਹੈ - ਇਸ ਵਿੱਚ ਕਈ ਕਤਾਰਾਂ ਹਨ ਅਤੇ ਫੀਡਬੈਕ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ
ਕਿਸੇ ਕੰਮ ਨੂੰ ਤਰਜੀਹ ਦੇਣ ਲਈ।
ਨਿਯਮਾਂ ਦਾ ਅੰਤਮ ਰੂਪ ਇਸ ਤਰ੍ਹਾਂ ਹੋਵੇਗਾ:

• ਨਿਯਮ.: ਜੇਕਰ ਤਰਜੀਹ(A) > ਤਰਜੀਹ(B), ਕਾਰਜ A ਚੱਲੇਗਾ (B ਨਹੀਂ ਕਰੇਗਾ)
• ਨਿਯਮ.: ਜੇਕਰ ਤਰਜੀਹ(A) = ਤਰਜੀਹ(B), A&B ਨੂੰ RR ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਸ਼ੁਰੂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ
• ਨਿਯਮ.: ਜਦੋਂ ਕੋਈ ਕੰਮ ਸਿਸਟਮ ਵਿੱਚ ਦਾਖਲ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਸਭ ਤੋਂ ਵੱਧ ਤਰਜੀਹ ਵਾਲੀ ਕਤਾਰ ਵਿੱਚ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ।
• ਨਿਯਮ.: ਇੱਕ ਕਾਰਜ ਦੁਆਰਾ ਮੌਜੂਦਾ ਕਤਾਰ ਵਿੱਚ ਆਪਣੇ ਨਿਰਧਾਰਤ ਸਮੇਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਤੋਂ ਬਾਅਦ (ਭਾਵੇਂ ਇਸਨੇ CPU ਨੂੰ ਕਿੰਨੀ ਵਾਰ ਖਾਲੀ ਕੀਤਾ ਹੋਵੇ), ਅਜਿਹੇ ਕਾਰਜ ਦੀ ਤਰਜੀਹ ਘਟ ਜਾਂਦੀ ਹੈ (ਇਹ ਕਤਾਰ ਦੇ ਹੇਠਾਂ ਚਲੀ ਜਾਂਦੀ ਹੈ)।
• ਨਿਯਮ.: ਕੁਝ ਸਮੇਂ ਬਾਅਦ S, ਸਿਸਟਮ ਦੇ ਸਾਰੇ ਕਾਰਜਾਂ ਨੂੰ ਸਭ ਤੋਂ ਉੱਚੀ ਕਤਾਰ ਵਿੱਚ ਤਬਦੀਲ ਕਰੋ।

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

Ые :ы:

1. manpages.debian.org/stretch/manpages/sched.7.en.html
2. en.wikipedia.org/wiki/Scheduling_(ਕੰਪਿਊਟਿੰਗ)
3. pages.lip6.fr/Julia.Lawall/atc18-bouron.pdf
4. www.usenix.org/legacy/event/bsdcon03/tech/full_papers/roberson/roberson.pdf
5. chebykin.org/freebsd-process-scheduling

ਸਰੋਤ: www.habr.com