ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളുടെ ആമുഖം

ഹേ ഹബർ! എന്റെ അഭിപ്രായത്തിൽ രസകരമായ ഒരു സാഹിത്യത്തിന്റെ വിവർത്തനങ്ങൾ - OSTEP - ലേഖനങ്ങളുടെ ഒരു പരമ്പര നിങ്ങളുടെ ശ്രദ്ധയിൽപ്പെടുത്താൻ ഞാൻ ആഗ്രഹിക്കുന്നു. ഈ മെറ്റീരിയൽ യുണിക്സ് പോലുള്ള ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളുടെ പ്രവർത്തനത്തെക്കുറിച്ച് വളരെ ആഴത്തിൽ ചർച്ചചെയ്യുന്നു, അതായത്, പ്രോസസ്സുകൾ, വിവിധ ഷെഡ്യൂളറുകൾ, മെമ്മറി, കൂടാതെ ഒരു ആധുനിക OS നിർമ്മിക്കുന്ന മറ്റ് സമാന ഘടകങ്ങൾ എന്നിവയുമായി പ്രവർത്തിക്കുക. എല്ലാ മെറ്റീരിയലുകളുടെയും ഒറിജിനൽ നിങ്ങൾക്ക് ഇവിടെ കാണാം ഇവിടെ. വിവർത്തനം പ്രൊഫഷണലായിട്ടല്ല (തീർച്ചയായും സ്വതന്ത്രമായി) നിർമ്മിച്ചിരിക്കുന്നത് എന്നത് ദയവായി ശ്രദ്ധിക്കുക, എന്നാൽ പൊതുവായ അർത്ഥം ഞാൻ നിലനിർത്തിയെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു.

ഈ വിഷയത്തെക്കുറിച്ചുള്ള ലാബ് വർക്ക് ഇവിടെ കാണാം:

• യഥാർത്ഥമായത്
• യഥാർത്ഥമായത്
• എന്റെ വ്യക്തിപരമായ പൊരുത്തപ്പെടുത്തൽ

മറ്റ് ഭാഗങ്ങൾ:

• ഭാഗം 1: ആമുഖം
• ഭാഗം 2: അമൂർത്തീകരണം: പ്രക്രിയ
• ഭാഗം 3: പ്രോസസ്സ് API-യുടെ ആമുഖം
• ഭാഗം 4: ഷെഡ്യൂളറിലേക്കുള്ള ആമുഖം
• ഭാഗം 5: MLFQ ഷെഡ്യൂളർ

നിങ്ങൾക്ക് എന്റെ ചാനൽ പരിശോധിക്കാനും കഴിയും ടെലഗ്രാം =)

ആസൂത്രണം: മൾട്ടി ലെവൽ ഫീഡ്‌ബാക്ക് ക്യൂ

ഈ പ്രഭാഷണത്തിൽ, ഏറ്റവും പ്രശസ്തമായ ഒരു സമീപനം വികസിപ്പിക്കുന്നതിലെ പ്രശ്നങ്ങളെക്കുറിച്ച് നമ്മൾ സംസാരിക്കും
ആസൂത്രണം, അതിനെ വിളിക്കുന്നു മൾട്ടി-ലെവൽ ഫീഡ്ബാക്ക് ക്യൂ (MLFQ). MLFQ ഷെഡ്യൂളർ ആദ്യമായി വിവരിച്ചത് 1962-ൽ ഫെർണാണ്ടോ ജെ. കോർബറ്റോ ആണ്.
അനുയോജ്യമായ സമയ-പങ്കിടൽ സംവിധാനം (CTSS). ഈ സൃഷ്ടികൾ (പിന്നീടുള്ള പ്രവൃത്തികൾ ഉൾപ്പെടെ
മൾട്ടിക്സ്) പിന്നീട് ട്യൂറിംഗ് അവാർഡിന് നാമനിർദ്ദേശം ചെയ്യപ്പെട്ടു. ഷെഡ്യൂളർ ആയിരുന്നു
പിന്നീട് മെച്ചപ്പെടുത്തുകയും ഇതിനകം കാണാവുന്ന രൂപം സ്വന്തമാക്കുകയും ചെയ്തു
ചില ആധുനിക സംവിധാനങ്ങൾ.

MLFQ അൽഗോരിതം 2 അടിസ്ഥാന ഓവർലാപ്പിംഗ് പ്രശ്നങ്ങൾ പരിഹരിക്കാൻ ശ്രമിക്കുന്നു.
ഒന്നാമതായി, ഇത് ടേൺറൗണ്ട് സമയം ഒപ്റ്റിമൈസ് ചെയ്യാൻ ശ്രമിക്കുന്നു, ഞങ്ങൾ മുൻ പ്രഭാഷണത്തിൽ ചർച്ച ചെയ്തതുപോലെ, ക്യൂവിന്റെ തലയിൽ നിന്ന് ആരംഭിക്കുന്ന രീതി ഒപ്റ്റിമൈസ് ചെയ്യുന്നു
ചെറിയ ജോലികൾ. എന്നിരുന്നാലും, ഈ അല്ലെങ്കിൽ ആ പ്രക്രിയ എത്രത്തോളം പ്രവർത്തിക്കുമെന്ന് OS-ന് അറിയില്ല, ഇതും
SJF, STCF അൽഗോരിതങ്ങളുടെ പ്രവർത്തനത്തിന് ആവശ്യമായ അറിവ്. രണ്ടാമത്, MLFQ ശ്രമിക്കുന്നു
ഉപയോക്താക്കൾക്കായി സിസ്റ്റം പ്രതികരിക്കുന്നതാക്കുക (ഉദാഹരണത്തിന്, ഇരിക്കുന്നവർക്കും
ടാസ്‌ക് പൂർത്തിയാകുന്നതിനായി കാത്തിരിക്കുമ്പോൾ സ്‌ക്രീനിൽ ഉറ്റുനോക്കുന്നു) അങ്ങനെ സമയം കുറയ്ക്കുക
പ്രതികരണം. നിർഭാഗ്യവശാൽ, RR പോലുള്ള അൽഗോരിതങ്ങൾ പ്രതികരണ സമയം കുറയ്ക്കുന്നു, പക്ഷേ
ടേൺറൗണ്ട് ടൈം മെട്രിക്കിൽ മോശം സ്വാധീനം ചെലുത്തുന്നു. അതിനാൽ ഞങ്ങളുടെ പ്രശ്നം: എങ്ങനെ ഡിസൈൻ ചെയ്യാം
ഞങ്ങളുടെ ആവശ്യകതകൾ നിറവേറ്റുന്ന ഷെഡ്യൂളർ, അതേ സമയം ഇതിനെക്കുറിച്ച് ഒന്നുമറിയില്ല
പ്രക്രിയയുടെ സ്വഭാവം, പൊതുവേ? ഷെഡ്യൂളർക്ക് ടാസ്‌ക്കുകളുടെ സവിശേഷതകൾ എങ്ങനെ പഠിക്കാനാകും,
അത് ഏത് സമാരംഭിക്കുകയും അങ്ങനെ മികച്ച ഷെഡ്യൂളിംഗ് തീരുമാനങ്ങൾ എടുക്കുകയും ചെയ്യുന്നു?

പ്രശ്നത്തിന്റെ സാരാംശം: തികഞ്ഞ അറിവില്ലാതെ ടാസ്ക്കുകളുടെ ക്രമീകരണം എങ്ങനെ ആസൂത്രണം ചെയ്യാം?
ഒരേസമയം പ്രതികരണ സമയം കുറയ്ക്കുന്ന ഒരു ഷെഡ്യൂളർ എങ്ങനെ രൂപകൽപ്പന ചെയ്യാം
സംവേദനാത്മക ജോലികൾക്കായി, അതേ സമയം അറിയാതെ തന്നെ ടേൺറൗണ്ട് സമയം കുറയ്ക്കുന്നു
ചുമതല നിർവഹിക്കുന്ന സമയത്തെക്കുറിച്ചുള്ള അറിവ്?

ശ്രദ്ധിക്കുക: മുൻ സംഭവങ്ങളിൽ നിന്ന് പഠിക്കുക

MLFQ ക്യൂ പരിശീലനം ലഭിച്ച ഒരു സിസ്റ്റത്തിന്റെ മികച്ച ഉദാഹരണമാണ്
ഭാവി പ്രവചിക്കാൻ കഴിഞ്ഞ സംഭവങ്ങൾ. അത്തരം സമീപനങ്ങൾ പലപ്പോഴും ഉണ്ടാകാറുണ്ട്
OS-ൽ കണ്ടെത്തി (ശാഖകൾ ഉൾപ്പെടെ കമ്പ്യൂട്ടർ സയൻസിലെ മറ്റ് പല ശാഖകളും
ഹാർഡ്‌വെയർ പ്രവചനങ്ങളും കാഷിംഗ് അൽഗോരിതങ്ങളും). സമാനമായ കയറ്റങ്ങൾ
ടാസ്‌ക്കുകൾക്ക് പെരുമാറ്റ ഘട്ടങ്ങൾ ഉള്ളപ്പോൾ ട്രിഗർ ചെയ്യുക.
എന്നിരുന്നാലും, ഈ സാങ്കേതികവിദ്യയിൽ ഒരാൾ ശ്രദ്ധിക്കണം, കാരണം പ്രവചനങ്ങൾ വളരെ എളുപ്പമാണ്.
തെറ്റായി മാറുകയും വ്യവസ്ഥിതിയെക്കാൾ മോശമായ തീരുമാനങ്ങളെടുക്കുകയും ചെയ്യാം
ഒരു അറിവും ഇല്ലാതെ ആയിരിക്കും.

MLFQ: അടിസ്ഥാന നിയമങ്ങൾ

MLFQ അൽഗോരിതത്തിന്റെ അടിസ്ഥാന നിയമങ്ങൾ പരിഗണിക്കുക. ഈ അൽഗോരിതം നടപ്പിലാക്കിയാലും
നിരവധി ഉണ്ട്, അടിസ്ഥാന സമീപനങ്ങൾ സമാനമാണ്.
ഞങ്ങൾ പരിഗണിക്കുന്ന നടപ്പാക്കലിൽ, MLFQ നിരവധി ഉണ്ടാകും
പ്രത്യേക ക്യൂകൾ, അവയിൽ ഓരോന്നിനും വ്യത്യസ്‌ത മുൻഗണന ഉണ്ടായിരിക്കും. ഏതുസമയത്തും,
നിർവ്വഹണത്തിന് തയ്യാറായ ടാസ്ക് അതേ ക്യൂവിലാണ്. MLFQ മുൻഗണനകൾ ഉപയോഗിക്കുന്നു,
നിർവ്വഹണത്തിനായി ഏത് ടാസ്ക് പ്രവർത്തിപ്പിക്കണമെന്ന് തീരുമാനിക്കാൻ, അതായത്. ഉയർന്ന ചുമതല
മുൻഗണന (ഏറ്റവും ഉയർന്ന മുൻഗണനയുള്ള ക്യൂവിൽ നിന്നുള്ള ഒരു ടാസ്ക്) ആദ്യം സമാരംഭിക്കും
ക്യൂ.
തീർച്ചയായും, ഒരു പ്രത്യേക ക്യൂവിൽ ഒന്നിൽ കൂടുതൽ ജോലികൾ ഉണ്ടാകാം
അതിനാൽ അവർക്ക് ഒരേ മുൻഗണന ഉണ്ടായിരിക്കും. ഈ സാഹചര്യത്തിൽ, മെക്കാനിസം ഉപയോഗിക്കും
ഈ ടാസ്‌ക്കുകൾക്കിടയിൽ ലോഞ്ച് പ്ലാനിംഗിനുള്ള RR.
അങ്ങനെ ഞങ്ങൾ MLFQ-നുള്ള രണ്ട് അടിസ്ഥാന നിയമങ്ങളിൽ എത്തിച്ചേരുന്നു:

• റൂൾ1: മുൻഗണന(എ) > മുൻഗണന(ബി), ടാസ്‌ക് എ പ്രവർത്തിക്കും (ബി ചെയ്യില്ല)
• റൂൾ2: മുൻഗണന(A) = മുൻഗണന(B), A&B ആരംഭിക്കുന്നത് RR ഉപയോഗിച്ചാണ്

മുകളിൽ പറഞ്ഞവയെ അടിസ്ഥാനമാക്കി, ഒരു MLFQ ആസൂത്രണം ചെയ്യുന്നതിനുള്ള പ്രധാന ഘടകങ്ങൾ ഇവയാണ്
മുൻഗണനകളാണ്. ഓരോന്നിനും നിശ്ചിത മുൻഗണന നൽകുന്നതിനു പകരം
ടാസ്‌ക്, നിരീക്ഷിച്ച പെരുമാറ്റത്തെ ആശ്രയിച്ച് MLFQ അതിന്റെ മുൻഗണന മാറ്റുന്നു.
ഉദാഹരണത്തിന്, കീബോർഡ് ഇൻപുട്ടിനായി കാത്തിരിക്കുമ്പോൾ ഒരു ടാസ്‌ക് സിപിയുവിൽ നിന്ന് തുടർച്ചയായി ഉപേക്ഷിക്കുകയാണെങ്കിൽ,
MLFQ പ്രോസസ് മുൻ‌ഗണന ഉയർന്നതായി നിലനിർത്തും, കാരണം അങ്ങനെയാണ്
സംവേദനാത്മക പ്രക്രിയ പ്രവർത്തിക്കണം. നേരെമറിച്ച്, ചുമതല നിരന്തരം ആണെങ്കിൽ
ദീർഘകാലത്തേക്ക് CPU തീവ്രതയുള്ളതാണ്, MLFQ അതിനെ തരംതാഴ്ത്തും
ഒരു മുൻഗണന. അങ്ങനെ, MLFQ അവ പ്രവർത്തിക്കുന്ന സമയത്ത് പ്രക്രിയകളുടെ സ്വഭാവം പഠിക്കും.
പെരുമാറ്റരീതികളും ഉപയോഗിക്കുക.
ചില സമയങ്ങളിൽ ക്യൂകൾ എങ്ങനെയായിരിക്കുമെന്നതിന്റെ ഒരു ഉദാഹരണം വരയ്ക്കാം
സമയം, തുടർന്ന് നിങ്ങൾക്ക് ഇതുപോലൊന്ന് ലഭിക്കും:


ഈ സ്കീമിൽ, എ, ബി എന്നീ 2 പ്രക്രിയകൾ ഉയർന്ന മുൻഗണനയോടെ ക്യൂവിലാണ്. പ്രക്രിയ
C നടുവിൽ എവിടെയോ ആണ്, ക്യൂവിന്റെ ഏറ്റവും അവസാനം പ്രോസസ്സ് D ആണ്. മുകളിൽ പറഞ്ഞ പ്രകാരം
MLFQ അൽഗോരിതത്തിന്റെ വിവരണങ്ങൾ, ഷെഡ്യൂളർ ഏറ്റവും ഉയർന്ന ജോലികൾ മാത്രമേ നിർവഹിക്കുകയുള്ളൂ
RR അനുസരിച്ച് മുൻഗണന, കൂടാതെ C, D ടാസ്‌ക്കുകൾ ജോലിക്ക് പുറത്തായിരിക്കും.
സ്വാഭാവികമായും, ഒരു സ്റ്റാറ്റിക് സ്നാപ്പ്ഷോട്ട് MLFQ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിന്റെ പൂർണ്ണമായ ചിത്രം നൽകില്ല.
കാലക്രമേണ ചിത്രം എങ്ങനെ മാറുന്നു എന്നത് കൃത്യമായി മനസ്സിലാക്കേണ്ടത് പ്രധാനമാണ്.

ശ്രമം 1: മുൻഗണന എങ്ങനെ മാറ്റാം

ഈ ഘട്ടത്തിൽ, MLFQ എങ്ങനെ മുൻഗണനാ തലം മാറ്റുമെന്ന് നിങ്ങൾ തീരുമാനിക്കേണ്ടതുണ്ട്
ചുമതല (അങ്ങനെ ക്യൂവിലെ ചുമതലയുടെ സ്ഥാനം) അതിന്റെ ജീവിത ചക്രത്തിൽ. വേണ്ടി
ഇതിൽ, നിങ്ങൾ വർക്ക്ഫ്ലോ മനസ്സിൽ സൂക്ഷിക്കേണ്ടതുണ്ട്: ഒരു നിശ്ചിത തുക
ഹ്രസ്വ റൺടൈമുകളുള്ള ഇന്ററാക്ടീവ് ടാസ്‌ക്കുകൾ (അതുവഴി പതിവ് റിലീസ്
സിപിയു) കൂടാതെ സിപിയു അവരുടെ മുഴുവൻ പ്രവർത്തന സമയവും ഉപയോഗിക്കുന്ന നിരവധി ദൈർഘ്യമേറിയ ജോലികൾ
അത്തരം ജോലികൾക്കുള്ള പ്രതികരണ സമയം പ്രധാനമല്ല. അതിനാൽ നിങ്ങൾക്ക് ആദ്യ ശ്രമം നടത്താം
ഇനിപ്പറയുന്ന നിയമങ്ങൾ ഉപയോഗിച്ച് MLFQ അൽഗോരിതം നടപ്പിലാക്കുക:

• റൂൾ 3: ഒരു ടാസ്‌ക് സിസ്റ്റത്തിലേക്ക് പ്രവേശിക്കുമ്പോൾ, അത് ഏറ്റവും ഉയർന്ന ക്യൂവിൽ സ്ഥാപിക്കും
• മുൻഗണന.
• Rule4a: ഒരു ടാസ്‌ക് അതിന്റെ മുഴുവൻ സമയ വിൻഡോയും ഉപയോഗിക്കുന്നുവെങ്കിൽ, അത്
• മുൻഗണന കുറച്ചു.
• Rule4b: ഒരു ടാസ്ക് അതിന്റെ സമയ വിൻഡോ കാലഹരണപ്പെടുന്നതിന് മുമ്പ് CPU റിലീസ് ചെയ്താൽ, അത്
• അതേ മുൻഗണനയിൽ തുടരുന്നു.

ഉദാഹരണം 1: സിംഗിൾ ദൈർഘ്യമുള്ള ടാസ്ക്ക്

ഈ ഉദാഹരണത്തിൽ നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, പ്രവേശനത്തിലെ ചുമതല ഏറ്റവും ഉയർന്നത് കൊണ്ട് സജ്ജീകരിച്ചിരിക്കുന്നു
മുൻഗണന. ഒരു 10ms സമയ വിൻഡോയ്ക്ക് ശേഷം, പ്രോസസ്സ് മുൻഗണനയിൽ തരംതാഴ്ത്തപ്പെടും.
ഷെഡ്യൂളർ. അടുത്ത ടൈം വിൻഡോയ്ക്ക് ശേഷം, ടാസ്‌ക് ഒടുവിൽ ഇതിലേക്ക് തരംതാഴ്ത്തപ്പെടും
സിസ്റ്റത്തിലെ ഏറ്റവും കുറഞ്ഞ മുൻഗണന, അത് നിലനിൽക്കുന്നിടത്ത്.


ഉദാഹരണം 2: ഒരു ചെറിയ ടാസ്ക്ക് തിരഞ്ഞെടുത്തു

MLFQ എങ്ങനെ SJF-നെ സമീപിക്കാൻ ശ്രമിക്കും എന്നതിന്റെ ഒരു ഉദാഹരണം നോക്കാം. അതിൽ
ഉദാഹരണത്തിന്, രണ്ട് ടാസ്ക്കുകൾ: എ, ഇത് നിരന്തരം നീണ്ടുനിൽക്കുന്ന ഒരു ജോലിയാണ്
സിപിയുവും ബിയും കൈവശപ്പെടുത്തുന്നു, ഇത് ഒരു ഹ്രസ്വ സംവേദനാത്മക ജോലിയാണ്. കരുതുക
ടാസ്‌ക് ബി എത്തുമ്പോഴേക്കും എ കുറച്ച് സമയമായി ഓടുകയായിരുന്നു.


ഈ ഗ്രാഫ് സാഹചര്യത്തിന്റെ ഫലങ്ങൾ കാണിക്കുന്നു. ടാസ്‌ക് എ, ഏതൊരു ജോലിയും പോലെ,
CPU ഉപയോഗിക്കുന്നത് വളരെ താഴെയായിരുന്നു. ടാസ്‌ക് ബി T=100 സമയത്ത് എത്തും
ഏറ്റവും മുൻഗണനയുള്ള ക്യൂവിൽ സ്ഥാപിച്ചു. പ്രവർത്തന സമയം കുറവായതിനാൽ,
അവസാന ക്യൂവിൽ എത്തുന്നതിന് മുമ്പ് അത് പൂർത്തിയാകും.

ഈ ഉദാഹരണത്തിൽ നിന്ന്, അൽഗോരിതത്തിന്റെ പ്രധാന ലക്ഷ്യം നിങ്ങൾ മനസ്സിലാക്കണം: അൽഗോരിതം അല്ലാത്തതിനാൽ
ഒരു ദൈർഘ്യമേറിയ അല്ലെങ്കിൽ ഹ്രസ്വമായ ഒരു ജോലി അറിയുന്നു, ആദ്യം അവൻ ചുമതല ഏറ്റെടുക്കുന്നു
ഹ്രസ്വവും അതിന് ഏറ്റവും ഉയർന്ന മുൻഗണനയും നൽകുന്നു. ഇത് ശരിക്കും ഒരു ചെറിയ ജോലിയാണെങ്കിൽ, പിന്നെ
അത് വേഗത്തിൽ നിർവ്വഹിക്കും, അല്ലാത്തപക്ഷം അത് ഒരു നീണ്ട ജോലിയാണെങ്കിൽ അത് സാവധാനം നീങ്ങും
മുൻ‌ഗണനയിൽ കുറയുന്നു, അവൾ തീർച്ചയായും ചെയ്യാത്ത ഒരു നീണ്ട ജോലിയാണെന്ന് ഉടൻ തെളിയിക്കും
ഒരു പ്രതികരണം ആവശ്യമാണ്.

ഉദാഹരണം 3: I/O-യെ സംബന്ധിച്ചെന്ത്?

ഇനി ഒരു I/O ഉദാഹരണം നോക്കാം. റൂൾ 4 ബിയിൽ പറഞ്ഞിരിക്കുന്നത് പോലെ,
ഒരു പ്രോസസ്സ് അതിന്റെ മുഴുവൻ സമയവും ഉപയോഗിക്കാതെ തന്നെ പ്രൊസസർ റിലീസ് ചെയ്യുകയാണെങ്കിൽ,
പിന്നീട് അത് അതേ മുൻഗണനാ തലത്തിൽ തന്നെ തുടരും. ഈ നിയമത്തിന്റെ ഉദ്ദേശ്യം വളരെ ലളിതമാണ്.
- ഇന്ററാക്ടീവ് ജോലി ധാരാളം I/O നിർവ്വഹിക്കുന്നുവെങ്കിൽ, ഉദാഹരണത്തിന്, കാത്തിരിക്കുന്നു
ഉപയോക്തൃ കീസ്ട്രോക്കുകളിൽ നിന്നോ മൗസിൽ നിന്നോ, അത്തരമൊരു ടാസ്ക് പ്രോസസറിനെ സ്വതന്ത്രമാക്കും
അനുവദിച്ച വിൻഡോയ്ക്ക് മുമ്പ്. ഇത്തരമൊരു മുൻഗണനാ ചുമതല ഒഴിവാക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നില്ല,
അങ്ങനെ അത് അതേ തലത്തിൽ തന്നെ തുടരും.


ഇത്തരം പ്രക്രിയകൾക്കൊപ്പം അൽഗോരിതം എങ്ങനെ പ്രവർത്തിക്കുമെന്ന് ഈ ഉദാഹരണം കാണിക്കുന്നു - ഇന്ററാക്ടീവ് ടാസ്‌ക് ബി, എക്‌സിക്യൂട്ട് ചെയ്യുന്നതിന് മുമ്പ് 1മി.സിക്ക് മാത്രമേ സിപിയു ആവശ്യമുള്ളൂ.
I/O പ്രോസസ്സും ഒരു നീണ്ട ജോലി എ, അത് എല്ലാ സമയത്തും CPU ഉപയോഗിക്കുന്നു.
MLFQ പ്രോസസ് B യെ ഏറ്റവും ഉയർന്ന മുൻഗണനയിൽ നിലനിർത്തുന്നു
CPU റിലീസ് ചെയ്യുക. ബി ഒരു ഇന്ററാക്ടീവ് ടാസ്‌ക് ആണെങ്കിൽ, ഈ കേസിലെ അൽഗോരിതം എത്തി
ഇന്ററാക്ടീവ് ജോലികൾ വേഗത്തിൽ സമാരംഭിക്കുക എന്നതാണ് ഇതിന്റെ ഉദ്ദേശ്യം.

നിലവിലെ MLFQ അൽഗോരിതത്തിലെ പ്രശ്നങ്ങൾ

മുമ്പത്തെ ഉദാഹരണങ്ങളിൽ, ഞങ്ങൾ MLFQ ന്റെ അടിസ്ഥാന പതിപ്പ് നിർമ്മിച്ചിട്ടുണ്ട്. അവൻ ആണെന്നും തോന്നുന്നു
അതിന്റെ ജോലി മികച്ചതും ന്യായമായും ചെയ്യുന്നു, സിപിയു സമയം തമ്മിൽ തുല്യമായി വിതരണം ചെയ്യുന്നു
ദൈർഘ്യമേറിയ ജോലികൾ, ഹ്രസ്വമായ ടാസ്ക്കുകൾ അല്ലെങ്കിൽ വൻതോതിൽ ആക്സസ് ചെയ്യപ്പെടുന്ന ടാസ്ക്കുകൾ അനുവദിക്കുക
വേഗത്തിൽ പ്രോസസ്സ് ചെയ്യുന്നതിന് I/O ലേക്ക്. നിർഭാഗ്യവശാൽ, ഈ സമീപനം പലതും ഉൾക്കൊള്ളുന്നു
ഗുരുതരമായ പ്രശ്നങ്ങൾ.
ഒന്നാമതായി, വിശപ്പിന്റെ പ്രശ്നം: സിസ്റ്റത്തിന് ധാരാളം ഇന്ററാക്ടീവ് ഉണ്ടെങ്കിൽ
ടാസ്‌ക്കുകൾ, അവർ എല്ലാ സിപിയു സമയവും ചെലവഴിക്കും, അങ്ങനെ ഒരു ദൈർഘ്യം പോലുമില്ല
ചുമതല നിർവഹിക്കാനുള്ള അവസരം ലഭിക്കില്ല (അവർ പട്ടിണിയിലാണ്).

രണ്ടാമത്, സ്മാർട്ട് ഉപയോക്താക്കൾക്ക് അവരുടെ പ്രോഗ്രാമുകൾ എഴുതാൻ കഴിയും
ഷെഡ്യൂളറെ കബളിപ്പിക്കുക. നിർബന്ധിക്കാൻ വേണ്ടി എന്തെങ്കിലും ചെയ്യുന്നതിലാണ് ചതി
പ്രക്രിയയ്ക്ക് കൂടുതൽ സിപിയു സമയം നൽകുന്നതിന് ഷെഡ്യൂളർ. എന്ന അൽഗോരിതം
മുകളിൽ വിവരിച്ച അത്തരം ആക്രമണങ്ങൾക്ക് വളരെ ദുർബലമാണ്: സമയ ജാലകത്തിന് മുമ്പ് പ്രായോഗികമായി
അവസാനമായി, നിങ്ങൾ ഒരു I / O ഓപ്പറേഷൻ നടത്തേണ്ടതുണ്ട് (ചിലർക്ക്, ഏത് ഫയലായാലും)
അങ്ങനെ CPU സ്വതന്ത്രമാക്കുക. അത്തരം പെരുമാറ്റം നിങ്ങളെ അതേപടി തുടരാൻ അനുവദിക്കും
ക്യൂവിൽ തന്നെ വീണ്ടും സിപിയു സമയത്തിന്റെ വലിയൊരു ശതമാനം ലഭിക്കും. ചെയ്താൽ
ഇത് ശരിയാണ് (ഉദാ. CPU റിലീസ് ചെയ്യുന്നതിന് മുമ്പ് വിൻഡോ സമയത്തിന്റെ 99% പ്രവർത്തിപ്പിക്കുക),
അത്തരമൊരു ടാസ്ക്കിന് പ്രോസസറിനെ കുത്തകയാക്കാൻ കഴിയും.

അവസാനമായി, ഒരു പ്രോഗ്രാമിന് കാലക്രമേണ അതിന്റെ സ്വഭാവം മാറ്റാൻ കഴിയും. ആ ചുമതലകൾ
ഉപയോഗിച്ച സിപിയു ഇന്ററാക്ടീവാകും. ഞങ്ങളുടെ ഉദാഹരണത്തിൽ, സമാനമാണ്
മറ്റുള്ളവരെപ്പോലെ ടാസ്‌ക്കുകൾക്ക് ഷെഡ്യൂളറിൽ നിന്ന് ശരിയായ ചികിത്സ ലഭിക്കില്ല
(യഥാർത്ഥ) സംവേദനാത്മക ജോലികൾ.

പ്രേക്ഷകരോടുള്ള ചോദ്യം: ആധുനിക ലോകത്ത് ഷെഡ്യൂളർക്കെതിരെ എന്ത് ആക്രമണങ്ങൾ നടത്താം?

ശ്രമം 2: മുൻഗണന വർദ്ധിപ്പിക്കുക

നിയമങ്ങൾ മാറ്റാൻ ശ്രമിക്കാം, പ്രശ്നങ്ങൾ ഒഴിവാക്കാനാകുമോ എന്ന് നോക്കാം
പട്ടിണി. അതുമായി ബന്ധപ്പെട്ടതാണെന്ന് ഉറപ്പാക്കാൻ നമുക്ക് എന്തുചെയ്യാൻ കഴിയും
സിപിയു ടാസ്‌ക്കുകൾക്ക് അവരുടെ സമയം ലഭിക്കും (ദീർഘമല്ലെങ്കിലും).
പ്രശ്നത്തിനുള്ള ഒരു ലളിതമായ പരിഹാരമെന്ന നിലയിൽ, നിങ്ങൾക്ക് ആനുകാലികമായി നിർദ്ദേശിക്കാവുന്നതാണ്
സിസ്റ്റത്തിലെ അത്തരം എല്ലാ ജോലികളുടെയും മുൻഗണന വർദ്ധിപ്പിക്കുക. പല വഴികളുണ്ട്
ഇത് നേടുന്നതിന്, ഉദാഹരണമായി ലളിതമായ എന്തെങ്കിലും നടപ്പിലാക്കാൻ ശ്രമിക്കാം: വിവർത്തനം ചെയ്യുക
എല്ലാ ജോലികളും ഒരേസമയം ഉയർന്ന മുൻഗണനയിലേക്ക്, അതിനാൽ പുതിയ നിയമം:

• റൂൾ 5: കുറച്ച് കാലയളവ് എസ് കഴിഞ്ഞ്, സിസ്റ്റത്തിലെ എല്ലാ ജോലികളും ഏറ്റവും ഉയർന്ന ക്യൂവിലേക്ക് മാറ്റുക.

ഞങ്ങളുടെ പുതിയ നിയമം ഒരേസമയം രണ്ട് പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നു. ആദ്യം, പ്രക്രിയകൾ
പട്ടിണി കിടക്കില്ലെന്ന് ഉറപ്പ്: ഉയർന്ന ക്യൂവിലുള്ള ജോലികൾ പങ്കിടും
RR അൽഗോരിതം അനുസരിച്ച് പ്രോസസ്സർ സമയം, അങ്ങനെ എല്ലാ പ്രക്രിയകൾക്കും ലഭിക്കും
പ്രോസസ്സർ സമയം. രണ്ടാമതായി, മുമ്പ് ഉപയോഗിച്ച ചില പ്രക്രിയകൾ
പ്രോസസർ മാത്രമേ സംവേദനാത്മകമാകൂ, അത് ഏറ്റവും ഉയർന്ന ക്യൂവിൽ തുടരും
ഒരിക്കൽ ഉയർന്ന മുൻഗണനയിലേക്ക് ഒരു ബൂസ്റ്റ് ലഭിച്ചതിന് ശേഷം മുൻഗണന.
ഒരു ഉദാഹരണം പരിഗണിക്കുക. ഈ സാഹചര്യത്തിൽ, ഒരൊറ്റ പ്രക്രിയ ഉപയോഗിക്കുന്നത് പരിഗണിക്കുക


സിപിയുവും രണ്ട് സംവേദനാത്മകവും ഹ്രസ്വവുമായ പ്രക്രിയകൾ. ചിത്രത്തിൽ ഇടതുവശത്ത്, മുൻഗണനാ ബൂസ്റ്റ് ഇല്ലാതെയുള്ള പെരുമാറ്റം ചിത്രം കാണിക്കുന്നു, അങ്ങനെ സിസ്റ്റത്തിൽ രണ്ട് ഇന്ററാക്ടീവ് ടാസ്ക്കുകൾ വന്നതിന് ശേഷം ദീർഘനേരം പ്രവർത്തിക്കുന്ന ടാസ്ക്ക് പട്ടിണി കിടക്കാൻ തുടങ്ങുന്നു. വലതുവശത്തുള്ള ചിത്രത്തിൽ, ഓരോ 50 എംഎസിലും മുൻഗണനാ വർദ്ധനവ് നടത്തുന്നു, അങ്ങനെ എല്ലാ പ്രക്രിയകൾക്കും പ്രോസസർ സമയം ലഭിക്കുമെന്ന് ഉറപ്പുനൽകുന്നു, അത് ഇടയ്ക്കിടെ ആരംഭിക്കും. ഈ കേസിൽ 50ms ഒരു ഉദാഹരണമായി എടുക്കുന്നു, വാസ്തവത്തിൽ ഈ സംഖ്യ കുറച്ചുകൂടി കൂടുതലാണ്.
ആനുകാലിക ഉയർച്ച സമയം എസ് കൂട്ടിച്ചേർക്കുന്നത് വ്യക്തമാണ്
യുക്തിസഹമായ ചോദ്യം: എന്ത് മൂല്യമാണ് സജ്ജീകരിക്കേണ്ടത്? അർഹതപ്പെട്ടവരിൽ ഒരാൾ
സിസ്റ്റം എഞ്ചിനീയർമാരായ ജോൺ ഓസ്റ്റർഹൗട്ട് സിസ്റ്റങ്ങളിലെ സമാന അളവുകളെ വൂ-ഡൂ എന്ന് വിളിക്കുന്നു
സ്ഥിരമായത്, കാരണം അവർക്ക് ഏതെങ്കിലും വിധത്തിൽ ശരിയായതിന് ബ്ലാക്ക് മാജിക് ആവശ്യമാണ്
സമ്പർക്കം. കൂടാതെ, നിർഭാഗ്യവശാൽ, S ന് അത്തരമൊരു രസമുണ്ട്. നിങ്ങൾ മൂല്യവും സജ്ജമാക്കുകയാണെങ്കിൽ
വലിയ - നീണ്ട ജോലികൾ പട്ടിണിയാകും. നിങ്ങൾ അത് വളരെ താഴ്ത്തിവെച്ചാൽ,
ഇന്ററാക്ടീവ് ടാസ്‌ക്കുകൾക്ക് ശരിയായ സിപിയു സമയം ലഭിക്കില്ല.

ശ്രമം 3: മികച്ച അക്കൗണ്ടിംഗ്

ഇപ്പോൾ നമുക്ക് ഒരു പ്രശ്നം കൂടി പരിഹരിക്കാനുണ്ട്: എങ്ങനെ പാടില്ല
ഞങ്ങളുടെ ഷെഡ്യൂളറെ വഞ്ചിക്കാൻ അനുവദിക്കണോ? ഈ സാധ്യതയുടെ കുറ്റവാളികൾ
പ്രോസസർ സ്വതന്ത്രമാക്കുന്നതിലൂടെ ജോലിയെ അതിന്റെ മുൻഗണന നിലനിർത്താൻ അനുവദിക്കുന്ന നിയമങ്ങൾ 4a, 4b
അനുവദിച്ച സമയം അവസാനിക്കുന്നതിന് മുമ്പ്. അത് എങ്ങനെ കൈകാര്യം ചെയ്യണം?
ഈ കേസിലെ പരിഹാരം ഓരോന്നിനും സിപിയു സമയത്തിന്റെ മികച്ച അക്കൌണ്ടിംഗ് ആയി കണക്കാക്കാം
MLFQ ലെവൽ. പ്രോഗ്രാം ഉപയോഗിച്ച സമയം മറക്കുന്നതിന് പകരം
അനുവദിച്ച ഇടവേളയ്ക്കുള്ള പ്രോസസ്സർ, നിങ്ങൾ അത് കണക്കിലെടുക്കുകയും സംരക്ഷിക്കുകയും വേണം. ശേഷം
പ്രക്രിയ അതിന്റെ അനുവദിച്ച സമയം ഉപയോഗിച്ചു, അത് അടുത്തതിലേക്ക് തരംതാഴ്ത്തണം
മുൻഗണനാ തലം. പ്രക്രിയ അതിന്റെ സമയം എങ്ങനെ ഉപയോഗിക്കുമെന്നത് ഇപ്പോൾ പ്രശ്നമല്ല - എങ്ങനെ
പ്രോസസറിൽ അല്ലെങ്കിൽ ഒരു കൂട്ടം കോളുകളായി നിരന്തരം കമ്പ്യൂട്ടിംഗ് ചെയ്യുന്നു. അങ്ങനെ,
ചട്ടം 4 ഇനിപ്പറയുന്ന രീതിയിൽ മാറ്റിയെഴുതണം:

• റൂൾ 4: ഒരു ടാസ്‌ക് നിലവിലെ ക്യൂവിൽ അനുവദിച്ച സമയം ഉപയോഗിച്ചുകഴിഞ്ഞാൽ (അത് എത്ര തവണ സിപിയു സ്വതന്ത്രമാക്കി എന്നത് പരിഗണിക്കാതെ തന്നെ), അത്തരം ഒരു ടാസ്‌ക്കിന്റെ മുൻഗണന കുറയുന്നു (അത് ക്യൂവിൽ നിന്ന് താഴേക്ക് നീങ്ങുന്നു).

നമുക്ക് ഒരു ഉദാഹരണം നോക്കാം:
»

നിങ്ങൾ ഷെഡ്യൂളറെ കബളിപ്പിക്കാൻ ശ്രമിച്ചാൽ എന്ത് സംഭവിക്കുമെന്ന് ചിത്രം കാണിക്കുന്നു
മുമ്പത്തെ നിയമങ്ങൾ 4a-ൽ ആണെങ്കിൽ, ഇടതുവശത്ത് 4b ആയിരിക്കും ഫലം. പുതിയത് കൊണ്ട്
ഫലം വലതുവശത്താണ്. പരിരക്ഷയ്ക്ക് മുമ്പ്, ഏത് പ്രക്രിയയ്ക്കും പൂർത്തിയാകുന്നതിന് മുമ്പ് I/O-യെ വിളിക്കാം
പെരുമാറ്റം പരിഗണിക്കാതെ, സംരക്ഷണം പ്രവർത്തനക്ഷമമാക്കിയതിന് ശേഷം, അങ്ങനെ സിപിയുവിൽ ആധിപത്യം സ്ഥാപിക്കുക
I/O, അവൻ ഇപ്പോഴും ക്യൂവിൽ ഇറങ്ങും, അതിനാൽ സത്യസന്ധതയില്ലാതെ ചെയ്യാൻ കഴിയില്ല
സിപിയു ഉറവിടങ്ങൾ ഏറ്റെടുക്കുക.

MLFQ ഉം മറ്റ് പ്രശ്നങ്ങളും മെച്ചപ്പെടുത്തുന്നു

മുകളിലുള്ള മെച്ചപ്പെടുത്തലുകൾക്കൊപ്പം, പുതിയ പ്രശ്നങ്ങൾ ഉണ്ടാകുന്നു: പ്രധാനമായ ഒന്ന്
ചോദ്യങ്ങൾ - അത്തരമൊരു ഷെഡ്യൂളറെ എങ്ങനെ പാരാമീറ്റർ ചെയ്യാം? ആ. എത്രയായിരിക്കണം
ക്യൂകൾ? ക്യൂവിലെ പ്രോഗ്രാം വിൻഡോയുടെ വലുപ്പം എന്തായിരിക്കണം? എങ്ങനെ
പട്ടിണി ഒഴിവാക്കാനും പ്രോഗ്രാമിന് പലപ്പോഴും മുൻഗണന നൽകണം
പ്രോഗ്രാമിന്റെ പെരുമാറ്റത്തിലെ മാറ്റം കണക്കിലെടുക്കണോ? ഈ ചോദ്യങ്ങൾക്ക്, ലളിതമല്ല
പ്രതികരണവും ലോഡുകളുമായുള്ള പരീക്ഷണങ്ങളും തുടർന്നുള്ള കോൺഫിഗറേഷനും മാത്രം
ഷെഡ്യൂളർ ചില തൃപ്തികരമായ ബാലൻസ് നയിച്ചേക്കാം.

ഉദാഹരണത്തിന്, മിക്ക MLFQ നടപ്പിലാക്കലുകളും വ്യത്യസ്തമായി അസൈൻ ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു
വ്യത്യസ്ത ക്യൂകൾക്കുള്ള സമയ സ്ലോട്ടുകൾ. ഉയർന്ന മുൻഗണനയുള്ള ക്യൂകൾ സാധാരണമാണ്
ചെറിയ ഇടവേളകൾ. ഈ ക്യൂകളിൽ സംവേദനാത്മക ജോലികൾ അടങ്ങിയിരിക്കുന്നു,
ഇവയ്ക്കിടയിൽ മാറുന്നത് വളരെ സെൻസിറ്റീവായതിനാൽ 10 അല്ലെങ്കിൽ അതിൽ കുറവ് എടുക്കണം
മിസ്. നേരെമറിച്ച്, കുറഞ്ഞ മുൻഗണനയുള്ള ക്യൂകളിൽ ദീർഘനേരം പ്രവർത്തിക്കുന്ന ജോലികൾ അടങ്ങിയിരിക്കുന്നു
സിപിയു. ഈ സാഹചര്യത്തിൽ, ദീർഘകാല ഇടവേളകൾ നന്നായി യോജിക്കുന്നു (100 മി.


ഈ ഉദാഹരണത്തിൽ, ഉയർന്ന മുൻഗണനയുള്ള ക്യൂ 2 ൽ പ്രവർത്തിച്ച 20 ടാസ്ക്കുകൾ ഉണ്ട്
ms 10ms വിൻഡോകളായി തിരിച്ചിരിക്കുന്നു. നടുവിലുള്ള ക്യൂവിൽ (40മി.സെ. വിൻഡോ) 20മി.സെ.യും കുറഞ്ഞ മുൻഗണനയുള്ള ക്യൂവിലും
ക്യൂ ടൈം വിൻഡോ 40ms ആയി, അവിടെ ടാസ്‌ക്കുകൾ അവരുടെ ജോലി പൂർത്തിയാക്കി.

സോളാരിസ് OS-ൽ MLFQ നടപ്പിലാക്കുന്നത് സമയ-പങ്കിടൽ ഷെഡ്യൂളറുകളുടെ ഒരു വിഭാഗമാണ്.
അത് എങ്ങനെ വേണമെന്ന് കൃത്യമായി നിർവ്വചിക്കുന്ന ഒരു കൂട്ടം പട്ടികകൾ ഷെഡ്യൂളർ നൽകും
അതിന്റെ ജീവിതകാലം മുഴുവൻ പ്രക്രിയയുടെ മുൻഗണന മാറ്റുക, വലിപ്പം എന്തായിരിക്കണം
ജാലകം അനുവദിക്കേണ്ടതും ടാസ്‌ക് മുൻഗണനകൾ എത്ര തവണ ഉയർത്തണമെന്നും. കാര്യനിർവാഹകൻ
സിസ്റ്റത്തിന് ഈ പട്ടികയുമായി സംവദിക്കാനും ഷെഡ്യൂളറെ പെരുമാറാനും കഴിയും
വ്യത്യസ്തമായി. സ്ഥിരസ്ഥിതിയായി, ഈ പട്ടികയിൽ ക്രമാനുഗതമായ വർദ്ധനവോടെ 60 ക്യൂകളുണ്ട്
വിൻഡോ വലുപ്പം 20ms (ഉയർന്ന മുൻഗണന) മുതൽ നൂറുകണക്കിന് ms വരെ (ഏറ്റവും കുറഞ്ഞ മുൻഗണന), കൂടാതെ
ഒരു സെക്കൻഡിൽ ഒരിക്കൽ എല്ലാ ടാസ്ക്കുകളുടെയും ബൂസ്റ്റിനൊപ്പം.

മറ്റ് MLFQ ഷെഡ്യൂളർമാർ ഒരു പട്ടികയോ ഏതെങ്കിലും നിർദ്ദിഷ്ടമോ ഉപയോഗിക്കുന്നില്ല
ഈ അധ്യായത്തിൽ വിവരിച്ചിരിക്കുന്ന നിയമങ്ങൾ, മറിച്ച്, അവർ ഉപയോഗിച്ച് മുൻഗണനകൾ കണക്കാക്കുന്നു
ഗണിത സൂത്രവാക്യങ്ങൾ. ഉദാഹരണത്തിന്, FreeBSD-യിലെ ഷെഡ്യൂളർ ഒരു ഫോർമുല ഉപയോഗിക്കുന്നു
പ്രോസസ്സ് എത്രയെന്നതിനെ അടിസ്ഥാനമാക്കി നിലവിലെ ടാസ്‌ക് മുൻഗണന കണക്കാക്കുന്നു
CPU ഉപയോഗിച്ചു. കൂടാതെ, CPU ഉപയോഗം കാലക്രമേണ അഴുകുന്നു, അങ്ങനെ
അതിനാൽ, മുൻഗണനാ വർദ്ധനവ് മുകളിൽ വിവരിച്ചതിൽ നിന്ന് വ്യത്യസ്തമാണ്. ഇത് സത്യമാണ്
decay algorithms എന്ന് വിളിക്കുന്നു. പതിപ്പ് 7.1 പോലെ, FreeBSD ULE ഷെഡ്യൂളർ ഉപയോഗിക്കുന്നു.

അവസാനമായി, പല പ്ലാനർമാർക്കും മറ്റ് സവിശേഷതകളുണ്ട്. ഉദാഹരണത്തിന്, ചിലത്
ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിന്റെ പ്രവർത്തനത്തിനായി ഷെഡ്യൂളർമാർ ഉയർന്ന തലങ്ങളിൽ കരുതിവയ്ക്കുന്നു
അതിനാൽ, ഒരു ഉപയോക്തൃ പ്രക്രിയയ്ക്കും ഉയർന്ന മുൻഗണന ലഭിക്കില്ല
സിസ്റ്റം. ചില സംവിധാനങ്ങൾ നിങ്ങളെ സഹായിക്കാൻ ഉപദേശം നൽകാൻ അനുവദിക്കുന്നു
ഷെഡ്യൂളർ ശരിയായി മുൻഗണന നൽകണം. ഉദാഹരണത്തിന്, കമാൻഡ് ഉപയോഗിച്ച് നൈസ്
നിങ്ങൾക്ക് ഒരു ടാസ്ക്കിന്റെ മുൻഗണന കൂട്ടുകയോ കുറയ്ക്കുകയോ ചെയ്യാം, അങ്ങനെ കൂട്ടുകയോ കുറയ്ക്കുകയോ ചെയ്യാം
സിപിയു സമയത്തിനുള്ള പ്രോഗ്രാമിന്റെ സാധ്യതകൾ കുറയ്ക്കുക.

MLFQ: സംഗ്രഹം

MLFQ എന്ന ആസൂത്രണ സമീപനം ഞങ്ങൾ വിവരിച്ചിട്ടുണ്ട്. അവന്റെ പേര്
പ്രവർത്തന തത്വത്തിൽ സമാപിച്ചു - ഇതിന് നിരവധി ക്യൂകളുണ്ട് കൂടാതെ ഫീഡ്‌ബാക്ക് ഉപയോഗിക്കുന്നു
ഒരു ടാസ്ക്കിന് മുൻഗണന നൽകാൻ.
നിയമങ്ങളുടെ അന്തിമ രൂപം ഇപ്രകാരമായിരിക്കും:

• റൂൾ 1: മുൻഗണന(എ) > മുൻഗണന(ബി) ആണെങ്കിൽ, ടാസ്ക് എ പ്രവർത്തിക്കും (ബി ചെയ്യില്ല)
• റൂൾ 2: മുൻഗണന(A) = മുൻഗണന(B), A&B ആരംഭിക്കുന്നത് RR ഉപയോഗിച്ചാണ്
• റൂൾ 3: ഒരു ടാസ്ക്ക് സിസ്റ്റത്തിൽ പ്രവേശിക്കുമ്പോൾ, അത് ഉയർന്ന മുൻഗണനയുള്ള ക്യൂവിൽ സ്ഥാപിക്കുന്നു.
• റൂൾ 4: ഒരു ടാസ്‌ക് നിലവിലെ ക്യൂവിൽ അനുവദിച്ച സമയം ഉപയോഗിച്ചുകഴിഞ്ഞാൽ (അത് എത്ര തവണ സിപിയു സ്വതന്ത്രമാക്കി എന്നത് പരിഗണിക്കാതെ തന്നെ), അത്തരം ഒരു ടാസ്‌ക്കിന്റെ മുൻഗണന കുറയുന്നു (അത് ക്യൂവിൽ നിന്ന് താഴേക്ക് നീങ്ങുന്നു).
• റൂൾ 5: കുറച്ച് കാലയളവ് എസ് കഴിഞ്ഞ്, സിസ്റ്റത്തിലെ എല്ലാ ജോലികളും ഏറ്റവും ഉയർന്ന ക്യൂവിലേക്ക് മാറ്റുക.

ഇനിപ്പറയുന്ന കാരണത്താൽ MLFQ രസകരമാണ് - അറിവ് ആവശ്യപ്പെടുന്നതിനുപകരം
ടാസ്‌ക്കിന്റെ സ്വഭാവം മുൻ‌കൂട്ടി, അൽ‌ഗോരിതം ടാസ്‌ക്കിന്റെ മുൻ‌കാല സ്വഭാവം മനസിലാക്കുകയും സെറ്റ് ചെയ്യുകയും ചെയ്യുന്നു
അതനുസരിച്ച് മുൻഗണനകൾ. അങ്ങനെ, അവൻ ഒരേസമയം രണ്ട് കസേരകളിൽ ഇരിക്കാൻ ശ്രമിക്കുന്നു - ചെറിയ ജോലികൾക്കായി (എസ്ജെഎഫ്, എസ്ടിസിഎഫ്) പ്രകടനം നേടാനും സത്യസന്ധമായി ദീർഘനേരം ഓടാനും,
CPU-ലോഡിംഗ് ജോലികൾ. അതിനാൽ, ബിഎസ്ഡിയും അവയുടെ ഡെറിവേറ്റീവുകളും ഉൾപ്പെടെ നിരവധി സിസ്റ്റങ്ങൾ,
സോളാരിസ്, വിൻഡോസ്, മാക് എന്നിവ ഷെഡ്യൂളറായി ഏതെങ്കിലും തരത്തിലുള്ള അൽഗോരിതം ഉപയോഗിക്കുന്നു
അടിസ്ഥാനരേഖയായി 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