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

હે હબર! હું તમારા ધ્યાન પર મારા મતે એક રસપ્રદ સાહિત્યના લેખો-અનુવાદોની શ્રેણી લાવવા માંગુ છું - OSTEP. આ સામગ્રી યુનિક્સ જેવી ઓપરેટિંગ સિસ્ટમના કામની ખૂબ જ ઊંડાણપૂર્વક ચર્ચા કરે છે, એટલે કે, પ્રક્રિયાઓ, વિવિધ શેડ્યુલર્સ, મેમરી અને અન્ય સમાન ઘટકો જે આધુનિક OS બનાવે છે. તમે અહીં તમામ સામગ્રીની મૂળ જોઈ શકો છો અહીં. કૃપા કરીને નોંધો કે અનુવાદ અવ્યાવસાયિક રીતે કરવામાં આવ્યો હતો (તદ્દન મુક્તપણે), પરંતુ મને આશા છે કે મેં સામાન્ય અર્થ જાળવી રાખ્યો છે.

આ વિષય પર લેબ વર્ક અહીં મળી શકે છે:
- મૂળ: pages.cs.wisc.edu/~remzi/OSTEP/Homework/homework.html
- મૂળ: github.com/remzi-arpacidusseau/ostep-code
- મારું અંગત અનુકૂલન: github.com/bykvaadm/OS/tree/master/ostep

તમે મારી ચેનલ પર પણ જોઈ શકો છો ટેલિગ્રામ =)

કાર્યક્રમ કામગીરી

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

ગણતરીનું વોન ન્યુમેન મોડેલ

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

ઓપરેટિંગ સિસ્ટમ

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

CPU વર્ચ્યુઅલાઈઝેશન

નીચેના પ્રોગ્રામને ધ્યાનમાં લો:
(https://www.youtube.com/watch?v=zDwT5fUcki4&feature=youtu.be)

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

મેમરી વર્ચ્યુઅલાઈઝેશન

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

malloc() કૉલ

નીચેના પ્રોગ્રામને ધ્યાનમાં લો, જે કૉલનો ઉપયોગ કરીને મેમરીનો વિસ્તાર ફાળવે છે malloc () (https://youtu.be/jnlKRnoT1m0):

પ્રોગ્રામ ઘણી વસ્તુઓ કરે છે. પ્રથમ, તે કેટલીક મેમરી (લાઇન 7) ફાળવે છે, પછી ફાળવેલ સેલ (લાઇન 9) નું સરનામું છાપે છે, ફાળવેલ મેમરીના પ્રથમ સ્લોટ પર શૂન્ય લખે છે. આગળ, પ્રોગ્રામ એક લૂપમાં પ્રવેશ કરે છે જેમાં તે "p" વેરીએબલમાં સરનામાં પર મેમરીમાં સંગ્રહિત મૂલ્યમાં વધારો કરે છે. તે પોતે જ પ્રોસેસ આઈડી પણ પ્રિન્ટ કરે છે. પ્રક્રિયા ID દરેક ચાલી રહેલ પ્રક્રિયા માટે અનન્ય છે. ઘણી નકલો લોંચ કર્યા પછી, અમે એક રસપ્રદ પરિણામ પર ઠોકર ખાઈશું: પ્રથમ કિસ્સામાં, જો તમે કંઈ ન કરો અને ફક્ત ઘણી નકલો ચલાવો, તો સરનામાંઓ અલગ હશે. પરંતુ આ આપણા સિદ્ધાંત હેઠળ આવતું નથી! સાચું, કારણ કે આધુનિક વિતરણોમાં ડિફોલ્ટ રૂપે મેમરી રેન્ડમાઇઝેશન સક્ષમ છે. જો તે અક્ષમ હોય, તો અમને અપેક્ષિત પરિણામ મળે છે - એક સાથે ચાલતા બે પ્રોગ્રામ્સના મેમરી સરનામાં મેળ ખાશે.

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

સુસંગતતા

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

નીચેના પ્રોગ્રામને ધ્યાનમાં લો:

મુખ્ય કાર્યમાંનો પ્રોગ્રામ કોલનો ઉપયોગ કરીને બે થ્રેડો બનાવે છે pthread_create(). આ ઉદાહરણમાં, થ્રેડને અન્ય ફંક્શન્સની સાથે સમાન મેમરી સ્પેસમાં ચાલતા ફંક્શન તરીકે વિચારી શકાય છે, જેમાં સ્પષ્ટપણે એકથી વધુ ફંક્શન એક જ સમયે ચાલી રહ્યા છે. આ ઉદાહરણમાં, દરેક થ્રેડ શરૂ થાય છે અને કાર્યને એક્ઝિક્યુટ કરે છે worker() જે બદલામાં ફક્ત વેરીએબલમાં વધારો કરે છે,.

ચાલો આ પ્રોગ્રામને 1000 ની દલીલ સાથે ચલાવીએ. જેમ તમે અનુમાન કર્યું હશે, પરિણામ 2000 હોવું જોઈએ કારણ કે દરેક થ્રેડે વેરીએબલને 1000 વખત વધાર્યું છે. જો કે, બધું એટલું સરળ નથી. ચાલો પ્રોગ્રામને વધુ પુનરાવર્તનોના ક્રમ સાથે ચલાવવાનો પ્રયાસ કરીએ.

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

સોર્સ: www.habr.com