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

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

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

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

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

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

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

ഷെഡ്യൂളറിനുള്ള ആമുഖം

പ്രശ്നത്തിന്റെ സാരാംശം: ഒരു ഷെഡ്യൂളർ നയം എങ്ങനെ വികസിപ്പിക്കാം
അടിസ്ഥാന ഷെഡ്യൂളർ നയ ചട്ടക്കൂടുകൾ എങ്ങനെ രൂപകൽപ്പന ചെയ്യണം? പ്രധാന അനുമാനങ്ങൾ എന്തായിരിക്കണം? എന്ത് അളവുകൾ പ്രധാനമാണ്? ആദ്യകാല കമ്പ്യൂട്ടിംഗ് സിസ്റ്റങ്ങളിൽ എന്ത് അടിസ്ഥാന സാങ്കേതിക വിദ്യകളാണ് ഉപയോഗിച്ചിരുന്നത്?

ജോലിഭാരം അനുമാനങ്ങൾ

സാധ്യമായ നയങ്ങൾ ചർച്ച ചെയ്യുന്നതിനുമുമ്പ്, സിസ്റ്റത്തിൽ പ്രവർത്തിക്കുന്ന പ്രക്രിയകളെക്കുറിച്ച് നമുക്ക് ആദ്യം കുറച്ച് ലളിതവൽക്കരിക്കുക, അവയെ മൊത്തത്തിൽ വിളിക്കുന്നു. ജോലിഭാരം. ജോലിഭാരം നിർവചിക്കുന്നത് നയങ്ങൾ നിർമ്മിക്കുന്നതിന്റെ ഒരു നിർണായക ഭാഗമാണ്, ജോലിഭാരത്തെക്കുറിച്ച് നിങ്ങൾക്ക് കൂടുതൽ അറിയാവുന്നതനുസരിച്ച് നിങ്ങൾക്ക് പോളിസി എഴുതാൻ കഴിയും.

സിസ്റ്റത്തിൽ പ്രവർത്തിക്കുന്ന പ്രക്രിയകളെക്കുറിച്ച് നമുക്ക് ഇനിപ്പറയുന്ന അനുമാനങ്ങൾ ഉണ്ടാക്കാം, ചിലപ്പോൾ വിളിക്കപ്പെടുന്നു ജോലികൾ (ജോലികൾ). ഈ അനുമാനങ്ങളെല്ലാം യാഥാർത്ഥ്യമല്ല, മറിച്ച് ചിന്തയുടെ വികാസത്തിന് ആവശ്യമാണ്.

1. ഓരോ ജോലിയും ഒരേ സമയത്തേക്ക് പ്രവർത്തിക്കുന്നു,
2. എല്ലാ ജോലികളും ഒരേസമയം സജ്ജീകരിച്ചിരിക്കുന്നു,
3. നിയുക്ത ചുമതല പൂർത്തിയാകുന്നതുവരെ പ്രവർത്തിക്കുന്നു,
4. എല്ലാ ജോലികളും CPU മാത്രം ഉപയോഗിക്കുന്നു,
5. ഓരോ ജോലിയുടെയും പ്രവർത്തന സമയം അറിയാം.

ഷെഡ്യൂളർ മെട്രിക്സ്

ലോഡിനെക്കുറിച്ചുള്ള ചില അനുമാനങ്ങൾക്ക് പുറമേ, വ്യത്യസ്ത ഷെഡ്യൂളിംഗ് നയങ്ങൾ താരതമ്യം ചെയ്യുന്നതിനുള്ള മറ്റൊരു ഉപകരണം ആവശ്യമാണ്: ഷെഡ്യൂളർ മെട്രിക്സ്. മെട്രിക് എന്നത് എന്തിന്റെയെങ്കിലും ചില അളവ് മാത്രമാണ്. ഷെഡ്യൂളർമാരെ താരതമ്യം ചെയ്യാൻ ഉപയോഗിക്കാവുന്ന നിരവധി മെട്രിക്കുകൾ ഉണ്ട്.

ഉദാഹരണത്തിന്, ഞങ്ങൾ ഒരു മെട്രിക് ഉപയോഗിക്കും തിരിയുന്ന സമയം (തിരിവ് സമയം). ടാസ്‌ക് പൂർത്തിയാക്കുന്ന സമയവും സിസ്റ്റത്തിലെ ടാസ്‌ക് എത്തിച്ചേരുന്ന സമയവും തമ്മിലുള്ള വ്യത്യാസമായാണ് ടാസ്‌ക് ടേൺഅറൗണ്ട് സമയം നിർവചിച്ചിരിക്കുന്നത്.

ടേൺറൗണ്ട്=പൂർത്തിയാക്കൽ−ടാർറൈവൽ

എല്ലാ ജോലികളും ഒരേ സമയത്താണ് എത്തിയതെന്ന് ഞങ്ങൾ അനുമാനിച്ചതിനാൽ, Ta=0 അങ്ങനെ Tt=Tc. മുകളിലുള്ള അനുമാനങ്ങൾ മാറ്റുമ്പോൾ ഈ മൂല്യം സ്വാഭാവികമായും മാറും.

മറ്റൊരു മെട്രിക് - നല്ലത് (ന്യായം, സത്യസന്ധത). ഉൽപ്പാദനക്ഷമതയും ന്യായവും ആസൂത്രണത്തിൽ പലപ്പോഴും വിപരീത സ്വഭാവങ്ങളാണ്. ഉദാഹരണത്തിന്, ഷെഡ്യൂളർ പ്രകടനം ഒപ്റ്റിമൈസ് ചെയ്‌തേക്കാം, എന്നാൽ മറ്റ് ടാസ്‌ക്കുകൾ പ്രവർത്തിപ്പിക്കുന്നതിനായി കാത്തിരിക്കുന്നതിന്റെ ചെലവിൽ, അതുവഴി ന്യായം കുറയുന്നു.

ഫസ്റ്റ് ഇൻ ഫസ്റ്റ് ഔട്ട് (FIFO)

നമുക്ക് നടപ്പിലാക്കാൻ കഴിയുന്ന ഏറ്റവും അടിസ്ഥാനപരമായ അൽഗോരിതം FIFO അല്ലെങ്കിൽ ആദ്യം വരുന്നവർ (ഇൻ), ആദ്യം നൽകിയത് (ഔട്ട്). ഈ അൽഗോരിതത്തിന് നിരവധി ഗുണങ്ങളുണ്ട്: ഇത് നടപ്പിലാക്കാൻ വളരെ എളുപ്പമാണ്, ഇത് ഞങ്ങളുടെ എല്ലാ അനുമാനങ്ങൾക്കും യോജിക്കുകയും ജോലി നന്നായി നിർവഹിക്കുകയും ചെയ്യുന്നു.

ഒരു ലളിതമായ ഉദാഹരണം നോക്കാം. 3 ടാസ്‌ക്കുകൾ ഒരേസമയം സജ്ജീകരിച്ചുവെന്ന് പറയാം. എന്നാൽ ടാസ്‌ക് എ മറ്റെല്ലാറ്റിനേക്കാളും അൽപ്പം മുമ്പാണ് എത്തിയതെന്ന് നമുക്ക് അനുമാനിക്കാം, അതിനാൽ സി യുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ ബി പോലെ തന്നെ അത് മറ്റുള്ളവരേക്കാൾ നേരത്തെ എക്‌സിക്യൂഷൻ ലിസ്റ്റിൽ ദൃശ്യമാകും. അവ ഓരോന്നും 10 സെക്കൻഡ് എക്‌സിക്യൂട്ട് ചെയ്യുമെന്ന് നമുക്ക് അനുമാനിക്കാം. ഈ സാഹചര്യത്തിൽ ഈ ജോലികൾ പൂർത്തിയാക്കുന്നതിനുള്ള ശരാശരി സമയം എത്രയായിരിക്കും?

മൂല്യങ്ങൾ എണ്ണുന്നതിലൂടെ - 10+20+30, 3 കൊണ്ട് ഹരിച്ചാൽ, നമുക്ക് ശരാശരി പ്രോഗ്രാം എക്സിക്യൂഷൻ സമയം 20 സെക്കൻഡിന് തുല്യമാണ്.
ഇനി നമുക്ക് നമ്മുടെ അനുമാനങ്ങൾ മാറ്റാൻ ശ്രമിക്കാം. പ്രത്യേകിച്ചും, അനുമാനം 1, അതിനാൽ ഓരോ ജോലിയും എക്സിക്യൂട്ട് ചെയ്യാൻ ഒരേ സമയം എടുക്കുമെന്ന് ഞങ്ങൾ ഇനി അനുമാനിക്കില്ല. ഇത്തവണ FIFO എങ്ങനെ പ്രവർത്തിക്കും?

ഇത് മാറുന്നതുപോലെ, വ്യത്യസ്ത ടാസ്‌ക് എക്‌സിക്യൂഷൻ സമയങ്ങൾ FIFO അൽഗോരിതത്തിന്റെ ഉൽ‌പാദനക്ഷമതയെ അങ്ങേയറ്റം പ്രതികൂലമായി ബാധിക്കുന്നു. ടാസ്‌ക് എ പൂർത്തിയാക്കാൻ 100 സെക്കൻഡ് എടുക്കുമെന്ന് നമുക്ക് അനുമാനിക്കാം, അതേസമയം ബിയും സിയും 10 സെക്കൻഡ് വീതം എടുക്കും.

ചിത്രത്തിൽ നിന്ന് കാണാൻ കഴിയുന്നത് പോലെ, സിസ്റ്റത്തിന്റെ ശരാശരി സമയം (100+110+120)/3=110 ആയിരിക്കും. ഈ പ്രഭാവം വിളിക്കുന്നു കോൺവോയ് പ്രഭാവം, ഒരു വിഭവത്തിന്റെ ചില ഹ്രസ്വകാല ഉപഭോക്താക്കൾ കനത്ത ഉപഭോക്താവിന് ശേഷം ക്യൂ നിൽക്കുമ്പോൾ. നിറയെ വണ്ടിയുമായി ഒരു ഉപഭോക്താവ് നിങ്ങളുടെ മുന്നിൽ വരുമ്പോൾ അത് പലചരക്ക് കടയിലെ വരി പോലെയാണ്. പ്രശ്നത്തിനുള്ള ഏറ്റവും നല്ല പരിഹാരം ക്യാഷ് രജിസ്റ്റർ മാറ്റാൻ ശ്രമിക്കുക അല്ലെങ്കിൽ വിശ്രമിക്കുകയും ആഴത്തിൽ ശ്വസിക്കുകയും ചെയ്യുക എന്നതാണ്.

ഏറ്റവും ചെറിയ ജോലി ആദ്യം

ഹെവിവെയ്റ്റ് പ്രക്രിയകൾ ഉപയോഗിച്ച് സമാനമായ ഒരു സാഹചര്യം എങ്ങനെയെങ്കിലും പരിഹരിക്കാൻ കഴിയുമോ? തീർച്ചയായും. മറ്റൊരു തരത്തിലുള്ള ആസൂത്രണത്തെ വിളിക്കുന്നുഏറ്റവും ചെറിയ ജോലി ആദ്യം (എസ്.ജെ.എഫ്.). ഇതിന്റെ അൽഗോരിതം തികച്ചും പ്രാകൃതമാണ് - പേര് സൂചിപ്പിക്കുന്നത് പോലെ, ഏറ്റവും ചെറിയ ടാസ്ക്കുകൾ ഒന്നിന് പുറകെ ഒന്നായി ആദ്യം സമാരംഭിക്കും.

ഈ ഉദാഹരണത്തിൽ, ഒരേ പ്രക്രിയകൾ പ്രവർത്തിപ്പിക്കുന്നതിന്റെ ഫലം ശരാശരി പ്രോഗ്രാം ടേൺറൗണ്ട് സമയത്തിൽ ഒരു മെച്ചപ്പെടുത്തൽ ആയിരിക്കും, അത് തുല്യമായിരിക്കും 50-ന് പകരം 110, ഇത് ഏകദേശം 2 മടങ്ങ് മികച്ചതാണ്.

അതിനാൽ, എല്ലാ ടാസ്ക്കുകളും ഒരേ സമയം എത്തുന്നു എന്ന അനുമാനത്തിന്, SJF അൽഗോരിതം ഏറ്റവും ഒപ്റ്റിമൽ അൽഗോരിതം ആണെന്ന് തോന്നുന്നു. എന്നിരുന്നാലും, ഞങ്ങളുടെ അനുമാനങ്ങൾ ഇപ്പോഴും യാഥാർത്ഥ്യമാണെന്ന് തോന്നുന്നില്ല. ഇത്തവണ ഞങ്ങൾ അനുമാനം 2 മാറ്റുന്നു, ഈ സമയം ടാസ്‌ക്കുകൾ എപ്പോൾ വേണമെങ്കിലും ഉണ്ടായിരിക്കാം, എല്ലാം ഒരേ സമയം അല്ല. ഇത് എന്ത് പ്രശ്നങ്ങളിലേക്ക് നയിച്ചേക്കാം?

ടാസ്‌ക് A (100c) ആദ്യം എത്തുകയും അത് നടപ്പിലാക്കാൻ തുടങ്ങുകയും ചെയ്യുന്നുവെന്ന് നമുക്ക് സങ്കൽപ്പിക്കാം. t=10-ൽ, B, C ടാസ്‌ക്കുകൾ എത്തുന്നു, ഓരോന്നിനും 10 സെക്കൻഡ് എടുക്കും. അപ്പോൾ ശരാശരി എക്സിക്യൂഷൻ സമയം (100+(110-10)+(120-10))3 = 103 ആണ്. ഇത് മെച്ചപ്പെടുത്താൻ ഷെഡ്യൂളർക്ക് എന്തുചെയ്യാൻ കഴിയും?

ഏറ്റവും കുറഞ്ഞ സമയം പൂർത്തിയാക്കാൻ ആദ്യം (STCF)

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

ഈ പ്ലാനറുടെ ഫലം ഇനിപ്പറയുന്ന ഫലമായിരിക്കും: ((120-0)+(20-10)+(30-10))/3=50. അങ്ങനെ, അത്തരമൊരു ഷെഡ്യൂളർ ഞങ്ങളുടെ ജോലികൾക്ക് കൂടുതൽ അനുയോജ്യമാകും.

മെട്രിക് പ്രതികരണ സമയം

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

പ്രതികരണ സമയം ഇനിപ്പറയുന്ന രീതിയിൽ കണക്കാക്കുന്നു:

പ്രതികരണം=Tfirstrun−Tarrival

അതിനാൽ, മുമ്പത്തെ ഉദാഹരണത്തിന്, പ്രതികരണ സമയം ഇതായിരിക്കും: A=0, B=0, C=10 (abg=3,33).

ഒരേ സമയം 3 ടാസ്ക്കുകൾ എത്തുന്ന സാഹചര്യത്തിൽ STCF അൽഗോരിതം അത്ര നല്ലതല്ലെന്ന് ഇത് മാറുന്നു - ചെറിയ ജോലികൾ പൂർണ്ണമായും പൂർത്തിയാകുന്നതുവരെ കാത്തിരിക്കേണ്ടി വരും. അതിനാൽ ടേൺറൗണ്ട് ടൈം മെട്രിക്കിന് അൽഗോരിതം നല്ലതാണ്, എന്നാൽ ഇന്ററാക്ടിവിറ്റി മെട്രിക്കിന് മോശമാണ്. നിങ്ങൾ ഒരു ടെർമിനലിൽ ഇരുന്നുകൊണ്ട് ഒരു എഡിറ്ററിൽ അക്ഷരങ്ങൾ ടൈപ്പ് ചെയ്യാൻ ശ്രമിക്കുകയാണെങ്കിൽ 10 സെക്കൻഡിൽ കൂടുതൽ കാത്തിരിക്കേണ്ടി വരികയാണെങ്കിൽ മറ്റെന്തെങ്കിലും ടാസ്‌ക് CPU ഏറ്റെടുക്കുന്നതിനാൽ സങ്കൽപ്പിക്കുക. അത് വളരെ സുഖകരമല്ല.

അതിനാൽ ഞങ്ങൾ മറ്റൊരു പ്രശ്നം നേരിടുന്നു - പ്രതികരണ സമയത്തോട് സംവേദനക്ഷമതയുള്ള ഒരു ഷെഡ്യൂളർ എങ്ങനെ നിർമ്മിക്കാം?

റ ound ണ്ട് റോബിൻ

ഈ പ്രശ്നം പരിഹരിക്കാൻ ഒരു അൽഗോരിതം വികസിപ്പിച്ചെടുത്തു റ ound ണ്ട് റോബിൻ (RR). അടിസ്ഥാന ആശയം വളരെ ലളിതമാണ്: ടാസ്‌ക്കുകൾ പൂർത്തിയാകുന്നതുവരെ പ്രവർത്തിപ്പിക്കുന്നതിനുപകരം, ഞങ്ങൾ ഒരു നിശ്ചിത സമയത്തേക്ക് ടാസ്‌ക് പ്രവർത്തിപ്പിക്കും (ടൈം സ്ലൈസ് എന്ന് വിളിക്കുന്നു) തുടർന്ന് ക്യൂവിൽ നിന്ന് മറ്റൊരു ടാസ്‌ക്കിലേക്ക് മാറും. എല്ലാ ജോലികളും പൂർത്തിയാകുന്നതുവരെ അൽഗോരിതം അതിന്റെ പ്രവർത്തനം ആവർത്തിക്കുന്നു. ഈ സാഹചര്യത്തിൽ, പ്രോഗ്രാമിന്റെ പ്രവർത്തന സമയം ടൈമർ പ്രക്രിയയെ തടസ്സപ്പെടുത്തുന്ന സമയത്തിന്റെ ഗുണിതമായിരിക്കണം. ഉദാഹരണത്തിന്, ഓരോ x=10ms-ലും ഒരു ടൈമർ ഒരു പ്രോസസ്സിനെ തടസ്സപ്പെടുത്തുകയാണെങ്കിൽ, പ്രോസസ്സ് എക്സിക്യൂഷൻ വിൻഡോയുടെ വലുപ്പം 10 ന്റെ ഗുണിതവും 10,20 അല്ലെങ്കിൽ x*10 ആയിരിക്കണം.

നമുക്ക് ഒരു ഉദാഹരണം നോക്കാം: എബിസി ടാസ്ക്കുകൾ ഒരേസമയം സിസ്റ്റത്തിൽ എത്തുന്നു, അവ ഓരോന്നും 5 സെക്കൻഡ് പ്രവർത്തിക്കാൻ ആഗ്രഹിക്കുന്നു. SJF അൽഗോരിതം ഓരോ ജോലിയും മറ്റൊന്ന് ആരംഭിക്കുന്നതിന് മുമ്പ് പൂർത്തിയാക്കും. ഇതിനു വിപരീതമായി, ഒരു ലോഞ്ച് വിൻഡോ = 1s ഉള്ള RR അൽഗോരിതം ഇനിപ്പറയുന്ന രീതിയിൽ ടാസ്‌ക്കുകളിലൂടെ കടന്നുപോകും (ചിത്രം 4.3):

(SJF വീണ്ടും (പ്രതികരണ സമയത്തിന് മോശം)

(റൗണ്ട് റോബിൻ (പ്രതികരണ സമയത്തിന് നല്ലതാണ്)

RR അൽഗോരിതത്തിന്റെ ശരാശരി പ്രതികരണ സമയം (0+1+2)/3=1 ആണ്, അതേസമയം SJF-ന് (0+5+10)/3=5 ആണ്.

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

പ്രതികരണ സമയ മെട്രിക്കിനെക്കുറിച്ചാണ് നമ്മൾ സംസാരിക്കുന്നതെങ്കിൽ RR ഒരു മികച്ച ഷെഡ്യൂളറാണ്. എന്നാൽ ഈ അൽഗോരിതം ഉപയോഗിച്ച് ടാസ്‌ക് ടേൺഅറൗണ്ട് ടൈം മെട്രിക് എങ്ങനെ പ്രവർത്തിക്കും? A, B, C = 5s എന്നിവയുടെ പ്രവർത്തന സമയം ഒരേ സമയം എത്തുമ്പോൾ മുകളിലുള്ള ഉദാഹരണം പരിഗണിക്കുക. ടാസ്‌ക് എ 13-നും ബി 14-നും സി 15-നും അവസാനിക്കും, ശരാശരി ടേൺറൗണ്ട് സമയം 14-ന് ആയിരിക്കും. അതിനാൽ, വിറ്റുവരവ് മെട്രിക്കിനുള്ള ഏറ്റവും മോശം അൽഗോരിതം RR ആണ്.

കൂടുതൽ പൊതുവായി പറഞ്ഞാൽ, ഏത് ആർആർ-ടൈപ്പ് അൽഗോരിതം ന്യായമാണ്; ഇത് സിപിയു സമയത്തെ എല്ലാ പ്രക്രിയകൾക്കും തുല്യമായി വിഭജിക്കുന്നു. അതിനാൽ, ഈ അളവുകൾ നിരന്തരം പരസ്പരം വൈരുദ്ധ്യം പുലർത്തുന്നു.

അതിനാൽ, ഞങ്ങൾക്ക് നിരവധി വൈരുദ്ധ്യാത്മക അൽഗോരിതങ്ങൾ ഉണ്ട്, അതേ സമയം ഇനിയും നിരവധി അനുമാനങ്ങൾ അവശേഷിക്കുന്നു - ടാസ്ക് സമയം അറിയാമെന്നും ടാസ്ക്ക് CPU മാത്രമേ ഉപയോഗിക്കുന്നുള്ളൂ എന്നും.

I/O യുമായി മിക്സ് ചെയ്യുന്നു

ഒന്നാമതായി, പ്രോസസ്സ് CPU മാത്രമേ ഉപയോഗിക്കുന്നുള്ളൂ എന്ന അനുമാനം 4 നീക്കം ചെയ്യാം; സ്വാഭാവികമായും, ഇത് അങ്ങനെയല്ല, കൂടാതെ പ്രോസസ്സുകൾക്ക് മറ്റ് ഉപകരണങ്ങൾ ആക്സസ് ചെയ്യാൻ കഴിയും.

ഏതെങ്കിലും പ്രക്രിയ ഒരു I/O ഓപ്പറേഷൻ അഭ്യർത്ഥിക്കുന്ന നിമിഷം, പ്രക്രിയ തടഞ്ഞ അവസ്ഥയിലേക്ക് പ്രവേശിക്കുന്നു, I/O പൂർത്തിയാകുന്നതുവരെ കാത്തിരിക്കുന്നു. I/O ഹാർഡ് ഡ്രൈവിലേക്ക് അയയ്‌ക്കുകയാണെങ്കിൽ, അത്തരം ഒരു പ്രവർത്തനത്തിന് നിരവധി ms അല്ലെങ്കിൽ അതിൽ കൂടുതൽ സമയമെടുക്കും, ഈ നിമിഷം പ്രോസസ്സർ നിഷ്‌ക്രിയമായിരിക്കും. ഈ സമയത്ത്, ഷെഡ്യൂളർക്ക് മറ്റേതെങ്കിലും പ്രക്രിയയ്‌ക്കൊപ്പം പ്രോസസർ കൈവശപ്പെടുത്താനാകും. പ്രക്രിയ അതിന്റെ I/O പൂർത്തിയാകുമ്പോൾ ഷെഡ്യൂളർ എടുക്കേണ്ട അടുത്ത തീരുമാനം. ഇത് സംഭവിക്കുമ്പോൾ, ഒരു തടസ്സം സംഭവിക്കുകയും OS I/O എന്ന് വിളിക്കുന്ന പ്രക്രിയയെ റെഡി സ്റ്റേറ്റിലേക്ക് മാറ്റുകയും ചെയ്യും.

നിരവധി പ്രശ്നങ്ങളുടെ ഒരു ഉദാഹരണം നോക്കാം. ഓരോന്നിനും 50ms CPU സമയം ആവശ്യമാണ്. എന്നിരുന്നാലും, ആദ്യത്തേത് ഓരോ 10മി.സിയിലും I/O ആക്‌സസ് ചെയ്യും (ഇത് ഓരോ 10മി.സിയിലും എക്‌സിക്യൂട്ട് ചെയ്യപ്പെടും). കൂടാതെ പ്രോസസ്സ് ബി ഐ/ഒ ഇല്ലാതെ 50 എംഎസ് പ്രോസസർ ഉപയോഗിക്കുന്നു.

ഈ ഉദാഹരണത്തിൽ നമ്മൾ STCF ഷെഡ്യൂളർ ഉപയോഗിക്കും. A പോലെയുള്ള ഒരു പ്രോസസ്സ് അതിൽ സമാരംഭിച്ചാൽ ഷെഡ്യൂളർ എങ്ങനെ പെരുമാറും? അവൻ ഇനിപ്പറയുന്നവ ചെയ്യും: ആദ്യം അവൻ എ പ്രോസസ് പൂർണ്ണമായും പ്രവർത്തിക്കും, തുടർന്ന് ബി പ്രോസസ്സ് ചെയ്യും.

ഈ പ്രശ്നം പരിഹരിക്കുന്നതിനുള്ള പരമ്പരാഗത സമീപനം, പ്രോസസ്സ് എയുടെ ഓരോ 10 എംഎസ് സബ് ടാസ്‌ക്കും ഒരു പ്രത്യേക ടാസ്‌ക്കായി പരിഗണിക്കുക എന്നതാണ്. അതിനാൽ, STJF അൽഗോരിതം ഉപയോഗിച്ച് ആരംഭിക്കുമ്പോൾ, ഒരു 50 ms ടാസ്ക്കിനും 10 ms ടാസ്ക്കിനും ഇടയിലുള്ള തിരഞ്ഞെടുപ്പ് വ്യക്തമാണ്. തുടർന്ന്, സബ് ടാസ്‌ക് എ പൂർത്തിയാകുമ്പോൾ, പ്രോസസ്സ് ബി, ഐ/ഒ എന്നിവ സമാരംഭിക്കും. I/O പൂർത്തിയാക്കിയ ശേഷം, പ്രോസസ്സ് B-ക്ക് പകരം 10ms പ്രോസസ്സ് A വീണ്ടും ആരംഭിക്കുന്നത് പതിവായിരിക്കും. ഈ രീതിയിൽ, ഓവർലാപ്പ് നടപ്പിലാക്കാൻ സാധിക്കും, അവിടെ CPU മറ്റൊരു പ്രോസസ്സ് ഉപയോഗിച്ച് ആദ്യത്തേതിന് കാത്തിരിക്കുമ്പോൾ I/O. തൽഫലമായി, സിസ്റ്റം മികച്ച രീതിയിൽ ഉപയോഗപ്പെടുത്തുന്നു - ഇന്ററാക്ടീവ് പ്രോസസ്സുകൾ I/O-യ്‌ക്കായി കാത്തിരിക്കുന്ന നിമിഷത്തിൽ, പ്രോസസ്സറിൽ മറ്റ് പ്രോസസ്സുകൾ നടപ്പിലാക്കാൻ കഴിയും.

ഒറാക്കിൾ ഇപ്പോൾ ഇല്ല

ഇനി ടാസ്‌ക്കിന്റെ റണ്ണിംഗ് ടൈം അറിയാമെന്ന അനുമാനത്തിൽ നിന്ന് രക്ഷപ്പെടാൻ ശ്രമിക്കാം. ഇത് പൊതുവെ മുഴുവൻ ലിസ്റ്റിലെയും ഏറ്റവും മോശവും അയഥാർത്ഥവുമായ അനുമാനമാണ്. വാസ്തവത്തിൽ, ശരാശരി സാധാരണ OS-ൽ, ടാസ്ക്കുകളുടെ എക്സിക്യൂഷൻ സമയത്തെക്കുറിച്ച് OS-ന് വളരെ കുറച്ച് മാത്രമേ അറിയൂ, അപ്പോൾ ടാസ്ക്ക് എക്സിക്യൂട്ട് ചെയ്യാൻ എത്ര സമയമെടുക്കുമെന്ന് അറിയാതെ നിങ്ങൾക്ക് എങ്ങനെ ഒരു ഷെഡ്യൂളർ നിർമ്മിക്കാൻ കഴിയും? ഈ പ്രശ്നം പരിഹരിക്കാൻ നമുക്ക് ചില RR തത്വങ്ങൾ ഉപയോഗിക്കാമോ?

ഫലം

ഞങ്ങൾ ടാസ്‌ക് ഷെഡ്യൂളിംഗിന്റെ അടിസ്ഥാന ആശയങ്ങൾ നോക്കുകയും ഷെഡ്യൂളർമാരുടെ 2 കുടുംബങ്ങളെ നോക്കുകയും ചെയ്തു. ആദ്യത്തേത് ഏറ്റവും ചെറിയ ടാസ്‌ക് ആദ്യം ആരംഭിക്കുകയും അങ്ങനെ ടേൺറൗണ്ട് സമയം വർദ്ധിപ്പിക്കുകയും ചെയ്യുന്നു, രണ്ടാമത്തേത് എല്ലാ ജോലികൾക്കിടയിലും തുല്യമായി കീറി, പ്രതികരണ സമയം വർദ്ധിപ്പിക്കുന്നു. മറ്റ് കുടുംബത്തിന്റെ അൽഗോരിതങ്ങൾ നല്ലതാണെങ്കിൽ രണ്ട് അൽഗോരിതങ്ങളും മോശമാണ്. സിപിയു, ഐ/ഒ എന്നിവയുടെ സമാന്തര ഉപയോഗം പ്രകടനം മെച്ചപ്പെടുത്തുന്നത് എങ്ങനെയെന്നും ഞങ്ങൾ പരിശോധിച്ചു, എന്നാൽ ഒഎസ് ക്ലെയർവോയൻസ് പ്രശ്നം പരിഹരിച്ചില്ല. അടുത്ത പാഠത്തിൽ, അടുത്ത ഭൂതകാലത്തിലേക്ക് നോക്കുകയും ഭാവി പ്രവചിക്കാൻ ശ്രമിക്കുകയും ചെയ്യുന്ന ഒരു പ്ലാനറെ ഞങ്ങൾ നോക്കും. ഇതിനെ മൾട്ടി ലെവൽ ഫീഡ്‌ബാക്ക് ക്യൂ എന്ന് വിളിക്കുന്നു.

അവലംബം: www.habr.com