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

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

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

• യഥാർത്ഥം: pages.cs.wisc.edu/~remzi/OSTEP/Homework/homework.html
• യഥാർത്ഥം: github.com/remzi-arpacidusseau/ostep-code
• എന്റെ വ്യക്തിപരമായ പൊരുത്തപ്പെടുത്തൽ: github.com/bykvaadm/OS/tree/master/ostep

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

• ഭാഗം 1: ആമുഖം

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

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

ഇത് പ്രശ്നം ഉയർത്തുന്നു: പല CPU-കളുടെ മിഥ്യ എങ്ങനെ നൽകാം? നിങ്ങൾക്ക് ഒരു ഫിസിക്കൽ സിപിയു മാത്രമേ ഉള്ളൂവെങ്കിലും, ഏതാണ്ട് അനന്തമായ സിപിയുകളുടെ മിഥ്യാധാരണ OS-ന് എങ്ങനെ സൃഷ്ടിക്കാനാകും?

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

സംഗ്രഹം: പ്രക്രിയ

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

പ്രോസസ്സ് API

പ്രോസസ്സ് എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിനെക്കുറിച്ചുള്ള നമ്മുടെ ധാരണ മെച്ചപ്പെടുത്തുന്നതിന്, ഏത് ഓപ്പറേറ്റിംഗ് സിസ്റ്റം ഇന്റർഫേസിലും ഉൾപ്പെടുത്തേണ്ട സിസ്റ്റം കോളുകളുടെ ഉദാഹരണങ്ങൾ നമുക്ക് പഠിക്കാം. ഈ API-കൾ ഏതെങ്കിലും OS-ൽ ഒരു രൂപത്തിൽ അല്ലെങ്കിൽ മറ്റൊന്നിൽ ലഭ്യമാണ്.

● സൃഷ്ടിക്കാൻ (സൃഷ്ടിക്കൽ): പുതിയ പ്രക്രിയകൾ സൃഷ്ടിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന ചില രീതികൾ OS-ൽ ഉൾപ്പെടുത്തിയിരിക്കണം. നിങ്ങൾ ടെർമിനലിലേക്ക് ഒരു കമാൻഡ് നൽകുമ്പോഴോ ഒരു ഐക്കണിൽ ഇരട്ട-ക്ലിക്കുചെയ്യുന്നതിലൂടെ ഒരു ആപ്ലിക്കേഷൻ സമാരംഭിക്കുമ്പോഴോ, ഒരു പുതിയ പ്രോസസ്സ് സൃഷ്ടിക്കുന്നതിനും നിർദ്ദിഷ്ട പ്രോഗ്രാം സമാരംഭിക്കുന്നതിനും OS-ലേക്ക് ഒരു കോൾ അയയ്‌ക്കും.
● ഇല്ലാതാക്കുക: ഒരു പ്രോസസ് സൃഷ്‌ടിക്കുന്നതിന് ഒരു ഇന്റർഫേസ് ഉള്ളതിനാൽ, ഒരു പ്രോസസ്സ് നീക്കം ചെയ്യാൻ നിർബന്ധിതമാക്കാനുള്ള കഴിവും OS നൽകണം. മിക്ക പ്രോഗ്രാമുകളും പ്രവർത്തിക്കുമ്പോൾ സ്വാഭാവികമായും സ്വയം ആരംഭിക്കുകയും അവസാനിപ്പിക്കുകയും ചെയ്യും. അല്ലെങ്കിൽ, ഉപയോക്താവിന് അവരെ കൊല്ലാൻ കഴിയും, അതിനാൽ പ്രക്രിയ നിർത്തുന്നതിനുള്ള ഒരു ഇന്റർഫേസ് ഉപയോഗപ്രദമാകും.
● കാക്കുക (കാത്തിരിക്കുന്നു): ചിലപ്പോൾ ഒരു പ്രക്രിയ പൂർത്തിയാകുന്നതുവരെ കാത്തിരിക്കുന്നത് ഉപയോഗപ്രദമാണ്, അതിനാൽ കാത്തിരിക്കാനുള്ള കഴിവ് നൽകുന്ന ചില ഇന്റർഫേസുകൾ നൽകിയിരിക്കുന്നു.
● വിവിധ നിയന്ത്രണം (വിവിധ നിയന്ത്രണം): കൊല്ലുന്നതിനും പ്രക്രിയയ്ക്കായി കാത്തിരിക്കുന്നതിനും പുറമേ, മറ്റ് വിവിധ നിയന്ത്രണ രീതികളും ഉണ്ട്. ഉദാഹരണത്തിന്, മിക്ക ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളും ഒരു പ്രോസസ്സ് ഫ്രീസ് ചെയ്യാനുള്ള കഴിവ് നൽകുന്നു (ഒരു നിശ്ചിത കാലയളവിലേക്ക് അതിന്റെ നിർവ്വഹണം നിർത്തുക) തുടർന്ന് അത് പുനരാരംഭിക്കുക (നിർവ്വഹണം തുടരുക)
● പദവി (സംസ്ഥാനം): ഒരു പ്രക്രിയയുടെ നിലയെക്കുറിച്ചുള്ള ചില വിവരങ്ങൾ ലഭിക്കുന്നതിന് വിവിധ ഇന്റർഫേസുകളുണ്ട്, അത് എത്ര നേരം പ്രവർത്തിക്കുന്നു അല്ലെങ്കിൽ നിലവിൽ ഏത് അവസ്ഥയിലാണ്.

പ്രക്രിയ സൃഷ്ടിക്കൽ: വിശദാംശങ്ങൾ

പ്രോഗ്രാമുകൾ എങ്ങനെ കൃത്യമായി പ്രക്രിയകളായി രൂപാന്തരപ്പെടുന്നു എന്നതാണ് രസകരമായ ഒരു കാര്യം. പ്രത്യേകിച്ചും OS എങ്ങനെയാണ് പ്രോഗ്രാം എടുത്ത് പ്രവർത്തിപ്പിക്കുന്നത്. പ്രക്രിയ എങ്ങനെ കൃത്യമായി സൃഷ്ടിക്കപ്പെടുന്നു.
ഒന്നാമതായി, OS പ്രോഗ്രാം കോഡും സ്റ്റാറ്റിക് ഡാറ്റയും മെമ്മറിയിലേക്ക് ലോഡ് ചെയ്യണം (പ്രോസസ് അഡ്രസ് സ്പേസിലേക്ക്). പ്രോഗ്രാമുകൾ സാധാരണയായി ചില എക്സിക്യൂട്ടബിൾ ഫോർമാറ്റിൽ ഒരു ഡിസ്കിലോ സോളിഡ്-സ്റ്റേറ്റ് ഡ്രൈവിലോ സ്ഥിതി ചെയ്യുന്നു. അങ്ങനെ, പ്രോഗ്രാമും സ്റ്റാറ്റിക് ഡാറ്റയും മെമ്മറിയിലേക്ക് ലോഡുചെയ്യുന്ന പ്രക്രിയയ്ക്ക് OS-ന് ആ ബൈറ്റുകൾ ഡിസ്കിൽ നിന്ന് വായിക്കാനും മെമ്മറിയിൽ എവിടെയെങ്കിലും സ്ഥാപിക്കാനും കഴിയേണ്ടതുണ്ട്.

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

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

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

ഓപറേറ്റിംഗ് സിസ്റ്റം ഇനീഷ്യലൈസേഷൻ ജോലികളും നിർവഹിക്കും, പ്രത്യേകിച്ച് I/O യുമായി ബന്ധപ്പെട്ടവ. ഉദാഹരണത്തിന്, UNIX സിസ്റ്റങ്ങളിൽ, സാധാരണ ഇൻപുട്ട്, ഔട്ട്പുട്ട്, പിശക് എന്നിവയ്ക്കായി ഡിഫോൾട്ടായി ഓരോ പ്രോസസ്സിനും 3 ഓപ്പൺ ഫയൽ ഡിസ്ക്രിപ്റ്ററുകൾ ഉണ്ട്. ഈ ഹാൻഡിലുകൾ പ്രോഗ്രാമുകളെ ടെർമിനലിൽ നിന്നുള്ള ഇൻപുട്ട് വായിക്കാനും സ്ക്രീനിൽ വിവരങ്ങൾ പ്രദർശിപ്പിക്കാനും അനുവദിക്കുന്നു.

അങ്ങനെ, കോഡും സ്റ്റാറ്റിക് ഡാറ്റയും മെമ്മറിയിലേക്ക് ലോഡുചെയ്യുന്നതിലൂടെയും സ്റ്റാക്ക് സൃഷ്‌ടിച്ച് സമാരംഭിക്കുന്നതിലൂടെയും I/O ടാസ്‌ക്കുകൾ നിർവഹിക്കുന്നതുമായി ബന്ധപ്പെട്ട മറ്റ് ജോലികൾ ചെയ്യുന്നതിലൂടെയും, പ്രോസസ്സ് എക്‌സിക്യൂട്ട് ചെയ്യുന്നതിനുള്ള ഘട്ടം OS ഒരുക്കുന്നു. അവസാനമായി, അവസാനമായി ഒരു ടാസ്ക് അവശേഷിക്കുന്നു: പ്രോഗ്രാം അതിന്റെ എൻട്രി പോയിന്റിലൂടെ പ്രവർത്തിപ്പിക്കുക, പ്രധാന () ഫംഗ്ഷൻ എന്ന് വിളിക്കുന്നു. മെയിൻ() ഫംഗ്‌ഷൻ എക്‌സിക്യൂട്ട് ചെയ്യുന്നതിലൂടെ, പുതിയതായി സൃഷ്‌ടിച്ച പ്രോസസ്സിലേക്ക് OS സിപിയു നിയന്ത്രണം കൈമാറുന്നു, അങ്ങനെ പ്രോഗ്രാം എക്‌സിക്യൂട്ട് ചെയ്യാൻ തുടങ്ങുന്നു.

പ്രോസസ്സ് അവസ്ഥ

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

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

ഇനിപ്പറയുന്ന ഉദാഹരണത്തിൽ, ആദ്യ പ്രോസസ്സ്, കുറച്ച് സമയത്തിന് ശേഷം, IO അഭ്യർത്ഥിക്കുകയും തടയപ്പെട്ട അവസ്ഥയിലേക്ക് പ്രവേശിക്കുകയും ചെയ്യുന്നു, ഇത് മറ്റൊരു പ്രോസസ്സ് പ്രവർത്തിപ്പിക്കാൻ അനുവദിക്കുന്നു (ചിത്രം 1.4). പ്രോസസ്സ് 0 CPU ഉപയോഗിക്കുന്നില്ലെന്ന് OS കാണുകയും പ്രോസസ്സ് 1 ആരംഭിക്കുകയും ചെയ്യുന്നു. പ്രോസസ്സ് 1 പ്രവർത്തിക്കുമ്പോൾ, IO പൂർത്തിയായി, പ്രോസസ്സ് 0 ന്റെ നില റെഡിയായി മാറുന്നു. അവസാനമായി, പ്രോസസ്സ് 1 പൂർത്തിയായി, പൂർത്തിയാകുമ്പോൾ, പ്രോസസ്സ് 0 അതിന്റെ ജോലി ആരംഭിക്കുകയും നിർവ്വഹിക്കുകയും പൂർത്തിയാക്കുകയും ചെയ്യുന്നു.

ഡാറ്റ ഘടന

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

ഉദാഹരണത്തിന്, പ്രോസസ്സർ രജിസ്റ്ററുകളുടെ അവസ്ഥ OS സംരക്ഷിക്കണം. പ്രക്രിയ നിർത്തുന്ന നിമിഷത്തിൽ, രജിസ്റ്ററുകളുടെ അവസ്ഥ പ്രോസസ്സിന്റെ വിലാസ സ്ഥലത്ത് സംഭരിക്കുന്നു, അതിന്റെ പ്രവർത്തനം തുടരുന്ന നിമിഷത്തിൽ, രജിസ്റ്ററുകളുടെ മൂല്യങ്ങൾ പുനഃസ്ഥാപിക്കുകയും അങ്ങനെ ഈ പ്രക്രിയയുടെ നിർവ്വഹണം തുടരുകയും ചെയ്യുന്നു.

റെഡി, ബ്ലോക്ക്ഡ്, റണ്ണിംഗ് സ്റ്റേറ്റുകൾക്ക് പുറമെ വേറെയും ചില സംസ്ഥാനങ്ങളുണ്ട്. ചിലപ്പോൾ, സൃഷ്ടിക്കുന്ന സമയത്ത്, ഒരു പ്രക്രിയ INIT അവസ്ഥയിലായിരിക്കാം. അവസാനമായി, ഒരു പ്രോസസ്സ് ഇതിനകം പൂർത്തിയാകുമ്പോൾ അന്തിമ അവസ്ഥയിൽ സ്ഥാപിക്കാൻ കഴിയും, പക്ഷേ അതിന്റെ വിവരങ്ങൾ ഇതുവരെ മായ്‌ച്ചിട്ടില്ല. UNIX സിസ്റ്റങ്ങളിൽ ഈ അവസ്ഥയെ വിളിക്കുന്നു സോംബി പ്രക്രിയ. ഒരു കുട്ടിയുടെ റിട്ടേൺ കോഡ് അറിയാൻ ഒരു രക്ഷാകർതൃ പ്രക്രിയ ആഗ്രഹിക്കുന്ന സന്ദർഭങ്ങളിൽ ഈ അവസ്ഥ ഉപയോഗപ്രദമാണ്, ഉദാഹരണത്തിന്, സാധാരണയായി 0 ഒരു വിജയവും 1 ഒരു പിശകും നൽകുന്നു, എന്നാൽ പ്രോഗ്രാമർമാർക്ക് വ്യത്യസ്ത പ്രശ്നങ്ങൾ സൂചിപ്പിക്കാൻ അധിക ഔട്ട്പുട്ട് കോഡുകൾ നൽകാൻ കഴിയും. പാരന്റ് പ്രോസസ്സ് അവസാനിക്കുമ്പോൾ, ചൈൽഡ് പ്രോസസ്സ് അവസാനിക്കുന്നതുവരെ കാത്തിരിക്കാനും അവസാനിപ്പിച്ച പ്രോസസ്സുമായി ബന്ധപ്പെട്ട ഏത് ഡാറ്റയും മായ്‌ക്കാൻ കഴിയുമെന്ന് OS-ന് സിഗ്നൽ നൽകാനും കാത്തിരിക്കുക() പോലുള്ള ഒരു അന്തിമ സിസ്റ്റം കോൾ ചെയ്യുന്നു.

പ്രഭാഷണത്തിലെ പ്രധാന പോയിന്റുകൾ:

● പ്രക്രിയ - OS-ൽ പ്രവർത്തിക്കുന്ന പ്രോഗ്രാമിന്റെ പ്രധാന സംഗ്രഹം. ഏത് സമയത്തും, ഒരു പ്രക്രിയയെ അതിന്റെ അവസ്ഥ പ്രകാരം വിവരിക്കാം: അതിന്റെ വിലാസ സ്ഥലത്ത് മെമ്മറിയുടെ ഉള്ളടക്കം, ഇൻസ്ട്രക്ഷൻ പോയിന്ററും സ്റ്റാക്ക് പോയിന്ററും ഉൾപ്പെടെയുള്ള പ്രോസസർ രജിസ്റ്ററുകളിലെ ഉള്ളടക്കങ്ങൾ, തുറന്ന ഫയലുകൾ വായിക്കുകയോ എഴുതുകയോ ചെയ്യുന്നതുപോലുള്ള IO വിവരങ്ങൾ.
● പ്രോസസ്സ് API പ്രോഗ്രാമുകൾക്ക് പ്രോസസ് ചെയ്യാൻ കഴിയുന്ന കോളുകൾ അടങ്ങിയിരിക്കുന്നു. സാധാരണയായി ഇവ സൃഷ്ടിക്കുക, ഇല്ലാതാക്കുക അല്ലെങ്കിൽ മറ്റ് കോളുകളാണ്.
● റണ്ണിംഗ്, റെഡി, ബ്ലോക്ക്ഡ് എന്നിവയുൾപ്പെടെ നിരവധി സംസ്ഥാനങ്ങളിലൊന്നിലാണ് ഈ പ്രക്രിയ. ഷെഡ്യൂളിംഗ്, ഷെഡ്യൂൾ ചെയ്യുന്നതിൽ നിന്നുള്ള ഒഴിവാക്കലുകൾ അല്ലെങ്കിൽ കാത്തിരിപ്പുകൾ എന്നിവ പോലുള്ള വിവിധ ഇവന്റുകൾ ഒരു പ്രക്രിയയുടെ അവസ്ഥയെ ഒന്നിൽ നിന്ന് മറ്റൊന്നിലേക്ക് മാറ്റാൻ കഴിയും.
● പ്രക്രിയ ലിസ്റ്റ് സിസ്റ്റത്തിലെ എല്ലാ പ്രക്രിയകളെയും കുറിച്ചുള്ള വിവരങ്ങൾ അടങ്ങിയിരിക്കുന്നു. അതിലെ ഓരോ എൻട്രിയെയും ഒരു പ്രോസസ് കൺട്രോൾ ബ്ലോക്ക് എന്ന് വിളിക്കുന്നു, വാസ്തവത്തിൽ ഇത് ഒരു നിർദ്ദിഷ്ട പ്രക്രിയയെക്കുറിച്ചുള്ള ആവശ്യമായ എല്ലാ വിവരങ്ങളും ഉൾക്കൊള്ളുന്ന ഒരു ഘടനയാണ്. 

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