ઑપરેટિંગ સિસ્ટમ્સનો પરિચય

હે હબર! હું તમારા ધ્યાન પર મારા મતે એક રસપ્રદ સાહિત્યના લેખો-અનુવાદોની શ્રેણી લાવવા માંગુ છું - 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 લગભગ અસંખ્ય CPU નો ભ્રમ કેવી રીતે બનાવી શકે?

OS CPU વર્ચ્યુઅલાઈઝેશન દ્વારા આ ભ્રમ બનાવે છે. એક પ્રક્રિયા શરૂ કરીને, પછી તેને અટકાવીને, બીજી પ્રક્રિયા શરૂ કરીને, વગેરે, OS એ ભ્રમ જાળવી શકે છે કે ત્યાં ઘણા વર્ચ્યુઅલ CPU છે, જ્યારે હકીકતમાં એક અથવા વધુ ભૌતિક પ્રોસેસર હશે. આ તકનીક કહેવામાં આવે છે સમય પ્રમાણે CPU સંસાધનોનું વિભાજન. આ તકનીક વપરાશકર્તાઓને તેઓ ઈચ્છે તેટલી સહવર્તી પ્રક્રિયાઓ ચલાવવાની મંજૂરી આપે છે. આ સોલ્યુશનની કિંમત કામગીરી છે - કારણ કે જો CPU ઘણી પ્રક્રિયાઓ દ્વારા વહેંચાયેલું હોય, તો દરેક પ્રક્રિયા વધુ ધીમેથી પ્રક્રિયા કરવામાં આવશે.
CPU વર્ચ્યુઅલાઈઝેશનને અમલમાં મૂકવા માટે, અને ખાસ કરીને તેને સારી રીતે કરવા માટે, OS ને લો-લેવલ અને હાઈ-લેવલ સપોર્ટ બંનેની જરૂર છે. લો લેવલ સપોર્ટ કહેવાય છે મિકેનિઝમ્સ નિમ્ન-સ્તરની પદ્ધતિઓ અથવા પ્રોટોકોલ છે જે કાર્યક્ષમતાના જરૂરી ભાગને અમલમાં મૂકે છે. આવી કાર્યક્ષમતાનું ઉદાહરણ સંદર્ભ સ્વિચિંગ છે, જે OS ને એક પ્રોગ્રામ બંધ કરવાની અને પ્રોસેસર પર બીજો પ્રોગ્રામ ચલાવવાની ક્ષમતા આપે છે. આ સમયનો વિભાગ તમામ આધુનિક ઓપરેટિંગ સિસ્ટમમાં લાગુ કરવામાં આવ્યો છે.
આ મિકેનિઝમ્સની ટોચ પર "નીતિઓ" ના રૂપમાં OS માં બનેલ કેટલાક તર્ક છે. નીતિ ઓપરેટિંગ સિસ્ટમ માટે ચોક્કસ નિર્ણય લેવાનું અલ્ગોરિધમ છે. આવી નીતિઓ, ઉદાહરણ તરીકે, નક્કી કરે છે કે કયો પ્રોગ્રામ શરૂ કરવો જોઈએ (આદેશોની સૂચિમાંથી). તેથી, ઉદાહરણ તરીકે, આ સમસ્યા નામની નીતિ દ્વારા ઉકેલવામાં આવશે શેડ્યૂલર (શેડ્યુલિંગ નીતિ) અને સોલ્યુશન પસંદ કરતી વખતે, તે ડેટા દ્વારા માર્ગદર્શન આપવામાં આવશે જેમ કે: સ્ટાર્ટઅપ ઇતિહાસ (કયો પ્રોગ્રામ છેલ્લી મિનિટોમાં સૌથી લાંબો લોંચ કરવામાં આવ્યો હતો), આ પ્રક્રિયામાં કેટલો ભાર છે (કેવા પ્રકારના પ્રોગ્રામ્સ લોન્ચ કરવામાં આવ્યા હતા), પ્રદર્શન મેટ્રિક્સ (શું સિસ્ટમ છે ઇન્ટરેક્ટિવ ક્રિયાપ્રતિક્રિયા માટે અથવા થ્રુપુટ માટે ઑપ્ટિમાઇઝ કરવામાં આવે છે) અને તેથી વધુ.

અમૂર્ત: પ્રક્રિયા

ઑપરેટિંગ સિસ્ટમ દ્વારા ચલાવવામાં આવતા પ્રોગ્રામનું અમૂર્તકરણ જેને આપણે કહીએ છીએ પ્રક્રિયા. અગાઉ ઉલ્લેખ કર્યો છે તેમ, કોઈપણ ત્વરિત સમયગાળામાં, પ્રક્રિયા ફક્ત એક ચાલી રહેલ પ્રોગ્રામ છે. એક પ્રોગ્રામ કે જેની સાથે આપણે વિવિધ સિસ્ટમ સંસાધનોમાંથી સારાંશ માહિતી મેળવી શકીએ છીએ કે જે આ પ્રોગ્રામ તેના અમલ દરમિયાન ઍક્સેસ કરે છે અથવા અસર કરે છે.
પ્રક્રિયાના ઘટકોને સમજવા માટે, તમારે સિસ્ટમની સ્થિતિઓને સમજવાની જરૂર છે: પ્રોગ્રામ તેના ઓપરેશન દરમિયાન શું વાંચી અથવા બદલી શકે છે. કોઈપણ સમયે, તમારે એ સમજવાની જરૂર છે કે પ્રોગ્રામના અમલ માટે સિસ્ટમના કયા ઘટકો મહત્વપૂર્ણ છે.
સિસ્ટમના સ્પષ્ટ ઘટકોમાંનું એક જણાવે છે કે પ્રક્રિયામાં શામેલ છે મેમરી. સૂચનાઓ મેમરીમાં સ્થિત છે. પ્રોગ્રામ વાંચે છે અથવા લખે છે તે ડેટા પણ મેમરીમાં સ્થિત છે. આમ, પ્રક્રિયા જે મેમરીને સંબોધિત કરી શકે છે (જેને સરનામાની જગ્યા કહેવાય છે) તે પ્રક્રિયાનો એક ભાગ છે.
સિસ્ટમ સ્ટેટનો પણ એક ભાગ રજિસ્ટર છે. ઘણી સૂચનાઓનો હેતુ રજિસ્ટરની કિંમત બદલવા અથવા તેનું મૂલ્ય વાંચવાનો છે, અને આમ રજિસ્ટર પ્રક્રિયાના સંચાલનનો એક મહત્વપૂર્ણ ભાગ પણ બની જાય છે.
એ નોંધવું જોઇએ કે મશીનની સ્થિતિ પણ કેટલાક વિશિષ્ટ રજિસ્ટરમાંથી રચાય છે. દાખ્લા તરીકે, આઈપી - સૂચના નિર્દેશક - સૂચના માટે નિર્દેશક કે જે પ્રોગ્રામ હાલમાં એક્ઝેક્યુટ કરી રહ્યું છે. ત્યાં પણ છે સ્ટેક પોઇન્ટર અને તેનાથી સંબંધિત ફ્રેમ પોઇન્ટર, જેનો ઉપયોગ મેનેજ કરવા માટે થાય છે: ફંક્શન પેરામીટર્સ, સ્થાનિક ચલો અને રીટર્ન એડ્રેસ.
છેલ્લે, પ્રોગ્રામ્સ ઘણીવાર ROM (ફક્ત વાંચવા માટેની મેમરી) ઍક્સેસ કરે છે. આ "I/O" (ઇનપુટ/આઉટપુટ) માહિતીમાં હાલમાં પ્રક્રિયા દ્વારા ખુલ્લી ફાઇલોની સૂચિ શામેલ હોવી જોઈએ.

પ્રક્રિયા API

પ્રક્રિયા કેવી રીતે કાર્ય કરે છે તેની અમારી સમજને સુધારવા માટે, ચાલો સિસ્ટમ કૉલ્સના ઉદાહરણોનો અભ્યાસ કરીએ જે કોઈપણ ઑપરેટિંગ સિસ્ટમ ઇન્ટરફેસમાં શામેલ હોવા જોઈએ. આ APIs કોઈપણ OS પર એક અથવા બીજા સ્વરૂપમાં ઉપલબ્ધ છે.

● બનાવો (સર્જન): OS માં કેટલીક પદ્ધતિ શામેલ હોવી આવશ્યક છે જે તમને નવી પ્રક્રિયાઓ બનાવવા માટે પરવાનગી આપે છે. જ્યારે તમે ટર્મિનલમાં આદેશ દાખલ કરો છો અથવા આઇકોન પર ડબલ-ક્લિક કરીને એપ્લિકેશન લોંચ કરો છો, ત્યારે નવી પ્રક્રિયા બનાવવા માટે OS ને કોલ મોકલવામાં આવે છે અને પછી ઉલ્લેખિત પ્રોગ્રામ લોંચ કરો.
● કાઢી નાંખો: પ્રક્રિયા બનાવવા માટે એક ઇન્ટરફેસ હોવાથી, OS એ પ્રક્રિયાને દૂર કરવા દબાણ કરવાની ક્ષમતા પણ પ્રદાન કરવી જોઈએ. મોટા ભાગના પ્રોગ્રામ્સ કુદરતી રીતે જ શરૂ થાય છે અને તેમના પોતાના પર સમાપ્ત થાય છે કારણ કે તેઓ ચાલે છે. નહિંતર, વપરાશકર્તા તેમને મારી નાખવા માટે સક્ષમ બનવા માંગે છે અને આ રીતે પ્રક્રિયાને રોકવા માટેનું ઇન્ટરફેસ ઉપયોગી થશે.
● રાહ જુઓ (પ્રતીક્ષા): કેટલીકવાર પ્રક્રિયા પૂર્ણ થવાની રાહ જોવી ઉપયોગી છે, તેથી કેટલાક ઇન્ટરફેસ પ્રદાન કરવામાં આવે છે જે રાહ જોવાની ક્ષમતા પ્રદાન કરે છે.
● વિવિધ નિયંત્રણ (વિવિધ નિયંત્રણ): હત્યા અને પ્રક્રિયાની રાહ જોવા ઉપરાંત, અન્ય વિવિધ નિયંત્રણ પદ્ધતિઓ પણ છે. ઉદાહરણ તરીકે, મોટાભાગની ઓપરેટિંગ સિસ્ટમ્સ પ્રક્રિયાને સ્થિર કરવાની ક્ષમતા પૂરી પાડે છે (ચોક્કસ સમયગાળા માટે તેના અમલને અટકાવે છે) અને પછી તેને ફરી શરૂ કરો (એક્ઝિક્યુશન ચાલુ રાખો)
● સ્થિતિ (રાજ્ય): પ્રક્રિયાની સ્થિતિ વિશે કેટલીક માહિતી મેળવવા માટે વિવિધ ઇન્ટરફેસ છે, જેમ કે તે કેટલા સમયથી ચાલી રહી છે અથવા તે હાલમાં કઈ સ્થિતિમાં છે.

પ્રક્રિયા બનાવટ: વિગતો

એક રસપ્રદ બાબત એ છે કે પ્રોગ્રામ કેવી રીતે પ્રક્રિયાઓમાં પરિવર્તિત થાય છે. ખાસ કરીને કેવી રીતે OS પ્રોગ્રામને પસંદ કરે છે અને ચલાવે છે. પ્રક્રિયા બરાબર કેવી રીતે બનાવવામાં આવે છે.
સૌ પ્રથમ, OS એ પ્રોગ્રામ કોડ અને સ્ટેટિક ડેટાને મેમરીમાં (પ્રોસેસ એડ્રેસ સ્પેસમાં) લોડ કરવો આવશ્યક છે. પ્રોગ્રામ્સ સામાન્ય રીતે ડિસ્ક અથવા સોલિડ-સ્ટેટ ડ્રાઇવ પર અમુક એક્ઝિક્યુટેબલ ફોર્મેટમાં સ્થિત હોય છે. આમ, મેમરીમાં પ્રોગ્રામ અને સ્ટેટિક ડેટા લોડ કરવાની પ્રક્રિયા માટે જરૂરી છે કે OS એ ડિસ્કમાંથી તે બાઈટ વાંચી શકે અને તેને મેમરીમાં ક્યાંક મૂકી શકે.

પ્રારંભિક ઓપરેટિંગ સિસ્ટમ્સમાં, લોડિંગ પ્રક્રિયા આતુરતાપૂર્વક કરવામાં આવતી હતી, જેનો અર્થ છે કે પ્રોગ્રામ શરૂ થાય તે પહેલાં સમગ્ર કોડ મેમરીમાં લોડ કરવામાં આવ્યો હતો. આધુનિક ઓપરેટિંગ સિસ્ટમ્સ આ આળસથી કરે છે, એટલે કે, કોડ અથવા ડેટાના ટુકડાઓ લોડ કરે છે જ્યારે પ્રોગ્રામને તેના અમલ દરમિયાન તેની જરૂર હોય.

એકવાર કોડ અને સ્ટેટિક ડેટા OS મેમરીમાં લોડ થઈ જાય, ત્યાં થોડી વધુ વસ્તુઓ છે જે પ્રક્રિયા ચાલી શકે તે પહેલાં કરવાની જરૂર છે. સ્ટેક માટે મેમરીનો અમુક જથ્થો ફાળવવો આવશ્યક છે. પ્રોગ્રામ્સ સ્થાનિક ચલો, ફંક્શન પેરામીટર્સ અને રીટર્ન એડ્રેસ માટે સ્ટેકનો ઉપયોગ કરે છે. OS આ મેમરીને ફાળવે છે અને પ્રક્રિયાને આપે છે. સ્ટેકને કેટલીક દલીલો સાથે પણ ફાળવી શકાય છે, ખાસ કરીને તે main() ફંક્શનના પરિમાણોને ભરે છે, ઉદાહરણ તરીકે argc અને argv ની શ્રેણી સાથે.

ઑપરેટિંગ સિસ્ટમ પ્રોગ્રામના ઢગલા માટે કેટલીક મેમરી પણ ફાળવી શકે છે. ગતિશીલ રીતે ફાળવેલ ડેટાની સ્પષ્ટ વિનંતી કરવા માટે પ્રોગ્રામ્સ દ્વારા હીપનો ઉપયોગ કરવામાં આવે છે. પ્રોગ્રામ્સ ફંક્શનને કૉલ કરીને આ જગ્યાની વિનંતી કરે છે malloc () અને ફંક્શનને કૉલ કરીને તેને સ્પષ્ટપણે સાફ કરે છે મફત(). ડેટા સ્ટ્રક્ચર્સ જેમ કે લિંક્ડ શીટ્સ, હેશ કોષ્ટકો, વૃક્ષો અને અન્ય માટે ઢગલા જરૂરી છે. શરૂઆતમાં, ઢગલા માટે થોડી માત્રામાં મેમરી ફાળવવામાં આવે છે, પરંતુ સમય જતાં, પ્રોગ્રામ ચાલે છે, ઢગલો લાઇબ્રેરી API કૉલ malloc() દ્વારા વધુ મેમરીની વિનંતી કરી શકે છે. ઑપરેટિંગ સિસ્ટમ આ કૉલ્સને સંતોષવામાં મદદ કરવા માટે વધુ મેમરી ફાળવવાની પ્રક્રિયામાં સામેલ છે.

ઓપરેટિંગ સિસ્ટમ પ્રારંભિક કાર્યો પણ કરશે, ખાસ કરીને I/O થી સંબંધિત. ઉદાહરણ તરીકે, UNIX સિસ્ટમો પર, દરેક પ્રક્રિયામાં મૂળભૂત રીતે 3 ઓપન ફાઇલ ડિસ્ક્રીપ્ટર હોય છે, પ્રમાણભૂત ઇનપુટ, આઉટપુટ અને ભૂલ માટે. આ હેન્ડલ્સ પ્રોગ્રામ્સને ટર્મિનલમાંથી ઇનપુટ વાંચવા તેમજ સ્ક્રીન પર માહિતી પ્રદર્શિત કરવાની મંજૂરી આપે છે.

આમ, કોડ અને સ્ટેટિક ડેટાને મેમરીમાં લોડ કરીને, સ્ટેક બનાવીને અને પ્રારંભ કરીને અને I/O કાર્યો કરવા સંબંધિત અન્ય કામ કરીને, OS પ્રક્રિયાને એક્ઝિક્યુટ કરવા માટે સ્ટેજ તૈયાર કરે છે. છેલ્લે, એક છેલ્લું કાર્ય બાકી છે: પ્રોગ્રામને તેના એન્ટ્રી પોઈન્ટ દ્વારા ચલાવવું, જેને main() ફંક્શન કહેવાય છે. મુખ્ય() ફંક્શનને એક્ઝિક્યુટ કરીને, OS CPU કંટ્રોલને નવી બનાવેલી પ્રક્રિયામાં ટ્રાન્સફર કરે છે, આમ પ્રોગ્રામ એક્ઝિક્યુટ થવાનું શરૂ કરે છે.

પ્રક્રિયા સ્થિતિ

હવે જ્યારે આપણે પ્રક્રિયા શું છે અને તે કેવી રીતે બનાવવામાં આવે છે તેની થોડી સમજણ મેળવી લીધી છે, ચાલો તે પ્રક્રિયાના રાજ્યોની સૂચિ બનાવીએ જેમાં તે હોઈ શકે છે. તેના સરળ સ્વરૂપમાં, પ્રક્રિયા આમાંથી એક રાજ્યમાં હોઈ શકે છે:
● ચાલી રહેલ. ચાલતી વખતે, પ્રક્રિયા પ્રોસેસર પર ચાલે છે. આનો અર્થ એ છે કે સૂચનાઓ અમલમાં આવી રહી છે.
● તૈયાર. તૈયાર સ્થિતિમાં, પ્રક્રિયા ચલાવવા માટે તૈયાર છે, પરંતુ કેટલાક કારણોસર OS તેને નિર્દિષ્ટ સમયે એક્ઝિક્યુટ કરતું નથી.
● અવરોધિત. અવરોધિત સ્થિતિમાં, પ્રક્રિયા કેટલીક ક્રિયાઓ કરે છે જે તેને અમલ માટે તૈયાર થવાથી અટકાવે છે જ્યાં સુધી કોઈ ઘટના ન બને ત્યાં સુધી. એક સામાન્ય ઉદાહરણ એ છે કે જ્યારે કોઈ પ્રક્રિયા IO ઑપરેશન શરૂ કરે છે, ત્યારે તે અવરોધિત થઈ જાય છે જેથી કરીને કોઈ અન્ય પ્રક્રિયા પ્રોસેસરનો ઉપયોગ કરી શકે.

તમે ગ્રાફના રૂપમાં આ રાજ્યોની કલ્પના કરી શકો છો. જેમ આપણે ચિત્રમાં જોઈ શકીએ છીએ, પ્રક્રિયાની સ્થિતિ OS ના વિવેકબુદ્ધિથી RUNNING અને READY વચ્ચે બદલાઈ શકે છે. જ્યારે પ્રક્રિયાની સ્થિતિ READY થી RUNNING માં બદલાય છે, તેનો અર્થ એ થાય છે કે પ્રક્રિયા સુનિશ્ચિત કરવામાં આવી છે. વિરુદ્ધ દિશામાં - લેઆઉટમાંથી દૂર. આ ક્ષણે જ્યારે કોઈ પ્રક્રિયા અવરોધિત થઈ જાય છે, ઉદાહરણ તરીકે, હું IO ઑપરેશન શરૂ કરું છું, OS તેને આ સ્થિતિમાં રાખશે જ્યાં સુધી કોઈ ઘટના ન બને, ઉદાહરણ તરીકે IO ની પૂર્ણતા. આ ક્ષણે તૈયાર સ્થિતિમાં સંક્રમણ અને સંભવતઃ તરત જ ચાલી રહેલ સ્થિતિમાં જો OS નક્કી કરે.
ચાલો એક ઉદાહરણ જોઈએ કે કેવી રીતે બે પ્રક્રિયાઓ આ રાજ્યોમાંથી પસાર થાય છે. શરૂ કરવા માટે, ચાલો કલ્પના કરીએ કે બંને પ્રક્રિયાઓ ચાલી રહી છે, અને દરેક માત્ર CPU નો ઉપયોગ કરી રહી છે. આ કિસ્સામાં, તેમના રાજ્યો આના જેવા દેખાશે.

નીચેના ઉદાહરણમાં, પ્રથમ પ્રક્રિયા, થોડો સમય ચાલ્યા પછી, IO ને વિનંતી કરે છે અને અવરોધિત સ્થિતિમાં પ્રવેશે છે, જે બીજી પ્રક્રિયાને ચાલવા દે છે (ફિગ 1.4). OS જુએ છે કે પ્રક્રિયા 0 એ CPU નો ઉપયોગ કરી રહી નથી અને પ્રક્રિયા 1 શરૂ કરે છે. જ્યારે પ્રક્રિયા 1 ચાલી રહી હોય, IO પૂર્ણ થાય છે અને પ્રક્રિયા 0 ની સ્થિતિ READY માં બદલાય છે. છેલ્લે, પ્રક્રિયા 1 પૂર્ણ થાય છે, અને પૂર્ણ થયા પછી, પ્રક્રિયા 0 શરૂ થાય છે, એક્ઝેક્યુટ કરે છે અને તેનું કામ પૂર્ણ કરે છે.

ડેટા માળખું

OS પોતે એક પ્રોગ્રામ છે, અને અન્ય કોઈપણ પ્રોગ્રામની જેમ, તેમાં કેટલાક મુખ્ય ડેટા સ્ટ્રક્ચર્સ છે જે માહિતીના વિવિધ સંબંધિત ભાગોનો ટ્રૅક રાખે છે. દરેક પ્રક્રિયાની સ્થિતિને ટ્રૅક કરવા માટે, OS અમુકને સપોર્ટ કરશે પ્રક્રિયા યાદી તૈયાર સ્થિતિમાં તમામ પ્રક્રિયાઓ માટે અને હાલમાં ચાલી રહેલી પ્રક્રિયાઓને ટ્રૅક કરવા માટે કેટલીક વધારાની માહિતી. ઉપરાંત, OS એ અવરોધિત પ્રક્રિયાઓનું નિરીક્ષણ કરવું જોઈએ. IO પૂર્ણ થયા પછી, OS એ જરૂરી પ્રક્રિયાને જાગૃત કરવી જોઈએ અને તેને ચલાવવા માટે તૈયાર સ્થિતિમાં મૂકવી જોઈએ.

ઉદાહરણ તરીકે, OS એ પ્રોસેસર રજિસ્ટરની સ્થિતિ સાચવવી આવશ્યક છે. પ્રક્રિયા અટકે તે ક્ષણે, રજિસ્ટરની સ્થિતિ પ્રક્રિયાના સરનામાંની જગ્યામાં સંગ્રહિત થાય છે, અને તે ક્ષણે તેની કામગીરી ચાલુ રહે છે, રજિસ્ટરના મૂલ્યો પુનઃસ્થાપિત થાય છે અને આ રીતે આ પ્રક્રિયાનો અમલ ચાલુ રાખે છે.

તૈયાર, અવરોધિત, ચાલી રહેલ રાજ્યો ઉપરાંત, કેટલાક અન્ય રાજ્યો છે. કેટલીકવાર, બનાવટ સમયે, પ્રક્રિયા INIT સ્થિતિમાં હોઈ શકે છે. છેલ્લે, જ્યારે પ્રક્રિયા પૂર્ણ થઈ ગઈ હોય ત્યારે તેને અંતિમ સ્થિતિમાં મૂકી શકાય છે, પરંતુ તેની માહિતી હજુ સુધી સાફ કરવામાં આવી નથી. UNIX સિસ્ટમો પર આ સ્થિતિ કહેવામાં આવે છે ઝોમ્બી પ્રક્રિયા. આ સ્થિતિ એવા કિસ્સાઓ માટે ઉપયોગી છે કે જ્યાં માતાપિતા પ્રક્રિયા બાળકના રીટર્ન કોડને જાણવા માંગે છે, ઉદાહરણ તરીકે, સામાન્ય રીતે 0 સફળતાનો સંકેત આપે છે અને 1 ભૂલનો સંકેત આપે છે, પરંતુ પ્રોગ્રામરો વિવિધ સમસ્યાઓને સંકેત આપવા માટે વધારાના આઉટપુટ કોડ જારી કરી શકે છે. જ્યારે પિતૃ પ્રક્રિયા સમાપ્ત થાય છે, ત્યારે તે ચાઇલ્ડ પ્રક્રિયા સમાપ્ત થવાની રાહ જોવા માટે અને OSને સંકેત આપે છે કે તે સમાપ્ત પ્રક્રિયા સાથે સંકળાયેલ કોઈપણ ડેટાને સાફ કરી શકે છે તે માટે રાહ જોવા માટે wait() જેવા અંતિમ સિસ્ટમ કૉલ કરે છે.

વ્યાખ્યાનના મુખ્ય મુદ્દાઓ:

● Процесс — OS માં ચાલી રહેલ પ્રોગ્રામનું મુખ્ય એબ્સ્ટ્રેક્શન. કોઈપણ સમયે, પ્રક્રિયાને તેની સ્થિતિ દ્વારા વર્ણવી શકાય છે: તેની સરનામાંની જગ્યામાં મેમરીની સામગ્રી, પ્રોસેસર રજિસ્ટરની સામગ્રી, સૂચના નિર્દેશક અને સ્ટેક પોઇન્ટર સહિત, અને IO માહિતી, જેમ કે ખુલ્લી ફાઇલો વાંચવા અથવા લખવામાં આવી રહી છે.
● પ્રક્રિયા API કોલ્સનો સમાવેશ થાય છે જે પ્રોગ્રામ પ્રક્રિયાઓ માટે કરી શકે છે. સામાન્ય રીતે આ બનાવો, કાઢી નાખો અથવા અન્ય કૉલ્સ છે.
● પ્રક્રિયા ચાલી રહેલ, તૈયાર, અવરોધિત સહિત ઘણા રાજ્યોમાંથી એકમાં છે. વિવિધ ઇવેન્ટ્સ જેમ કે શેડ્યુલિંગ, શેડ્યૂલિંગમાંથી અપવાદો અથવા રાહ જોવાથી પ્રક્રિયાની સ્થિતિ એકથી બીજીમાં બદલાઈ શકે છે.
● પ્રક્રિયા યાદી સિસ્ટમની તમામ પ્રક્રિયાઓ વિશેની માહિતી સમાવે છે. તેમાંની દરેક એન્ટ્રીને પ્રોસેસ કંટ્રોલ બ્લોક કહેવામાં આવે છે, જે વાસ્તવમાં એક માળખું છે જેમાં ચોક્કસ પ્રક્રિયા વિશેની તમામ જરૂરી માહિતી હોય છે. 

સોર્સ: www.habr.com