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

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

આ વિષય પર લેબ વર્ક અહીં મળી શકે છે:

• મૂળ
• મૂળ
• મારું અંગત અનુકૂલન

અન્ય ભાગો:

• ભાગ 1: પ્રસ્તાવના
• ભાગ 2: અમૂર્ત: પ્રક્રિયા
• ભાગ 3: પ્રક્રિયા API નો પરિચય
• ભાગ 4: શેડ્યૂલરનો પરિચય

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

શેડ્યૂલરનો પરિચય

સમસ્યાનો સાર: શેડ્યૂલર નીતિ કેવી રીતે વિકસિત કરવી
અન્ડરલાઇંગ શેડ્યુલર પોલિસી ફ્રેમવર્ક કેવી રીતે ડિઝાઇન કરવું જોઈએ? મુખ્ય ધારણાઓ શું હોવી જોઈએ? કયા મેટ્રિક્સ મહત્વપૂર્ણ છે? પ્રારંભિક કમ્પ્યુટિંગ સિસ્ટમ્સમાં કઈ મૂળભૂત તકનીકોનો ઉપયોગ કરવામાં આવ્યો હતો?

વર્કલોડ ધારણાઓ

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

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

1. દરેક કાર્ય સમાન સમય માટે ચાલે છે,
2. બધા કાર્યો એક સાથે સેટ કરવામાં આવે છે,
3. સોંપાયેલ કાર્ય તેની પૂર્ણતા સુધી કાર્ય કરે છે,
4. બધા કાર્યો ફક્ત CPU નો ઉપયોગ કરે છે,
5. દરેક કાર્યનો ચાલી રહેલ સમય જાણીતો છે.

શેડ્યૂલર મેટ્રિક્સ

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

ઉદાહરણ તરીકે, અમે મેટ્રિક નામનો ઉપયોગ કરીશું કાર્ય પૂર્ણ કરવાનો સમય (કાર્ય પૂર્ણ કરવાનો સમય). ટાસ્ક ટર્નઅરાઉન્ડ ટાઈમને સિસ્ટમમાં કાર્ય પૂર્ણ થવાના સમય અને કાર્યના આગમનના સમય વચ્ચેના તફાવત તરીકે વ્યાખ્યાયિત કરવામાં આવે છે.

ટર્નઅરાઉન્ડ=Tcompletion−Tarrival

અમે ધારીએ છીએ કે તમામ કાર્યો એક જ સમયે આવ્યા છે, પછી Ta=0 અને આમ Tt=Tc. જ્યારે આપણે ઉપરોક્ત ધારણાઓને બદલીશું ત્યારે આ મૂલ્ય કુદરતી રીતે બદલાશે.

અન્ય મેટ્રિક - ઔચિત્યની (પ્રમાણિકતા, પ્રામાણિકતા). ઉત્પાદકતા અને નિષ્પક્ષતા ઘણીવાર આયોજનમાં વિરોધી લાક્ષણિકતાઓ હોય છે. ઉદાહરણ તરીકે, શેડ્યૂલર પ્રદર્શનને ઑપ્ટિમાઇઝ કરી શકે છે, પરંતુ અન્ય કાર્યોને ચલાવવાની રાહ જોવાની કિંમતે, આમ ન્યાયીપણું ઘટાડે છે.

ફર્સ્ટ ઇન ફર્સ્ટ આઉટ (FIFO)

સૌથી મૂળભૂત અલ્ગોરિધમ કે જેને આપણે અમલમાં મૂકી શકીએ છીએ તેને FIFO અથવા કહેવાય છે પ્રથમ આવો (અંદર), પ્રથમ સેવા (બહાર). આ અલ્ગોરિધમના ઘણા ફાયદા છે: તે અમલમાં મૂકવું ખૂબ જ સરળ છે અને તે અમારી બધી ધારણાઓ સાથે બંધબેસે છે અને કામ સારી રીતે કરે છે.

ચાલો એક સરળ ઉદાહરણ જોઈએ. ચાલો કહીએ કે એક સાથે 3 કાર્યો સેટ કરવામાં આવ્યા હતા. પરંતુ ચાલો ધારીએ કે કાર્ય A એ બીજા બધા કરતા થોડું વહેલું આવ્યું છે, તેથી તે અન્ય કરતા વહેલા એક્ઝેક્યુશન લિસ્ટમાં દેખાશે, જેમ કે C ના સંબંધમાં B. ચાલો ધારીએ કે તેમાંથી દરેક 10 સેકન્ડ માટે એક્ઝિક્યુટ થશે. આ કિસ્સામાં આ કાર્યો પૂર્ણ કરવા માટે સરેરાશ સમય કેટલો હશે?

મૂલ્યોની ગણતરી કરીને - 10+20+30 અને 3 વડે ભાગતા, અમને સરેરાશ પ્રોગ્રામ એક્ઝેક્યુશન સમય 20 સેકન્ડ જેટલો મળે છે.
હવે ચાલો આપણી ધારણાઓને બદલવાનો પ્રયાસ કરીએ. ખાસ કરીને, ધારણા 1 ​​અને આ રીતે આપણે હવે ધારીશું નહીં કે દરેક કાર્યને એક્ઝિક્યુટ કરવામાં સમાન સમય લાગે છે. આ વખતે ફિફો કેવું પ્રદર્શન કરશે?

જેમ જેમ તે બહાર આવ્યું છે, વિવિધ કાર્ય અમલીકરણ સમય FIFO અલ્ગોરિધમની ઉત્પાદકતા પર અત્યંત નકારાત્મક અસર કરે છે. ચાલો ધારીએ કે કાર્ય A ને પૂર્ણ થવામાં 100 સેકન્ડ લાગશે, જ્યારે B અને C હજુ પણ 10 સેકન્ડ લેશે.

આકૃતિમાંથી જોઈ શકાય છે તેમ, સિસ્ટમ માટે સરેરાશ સમય હશે (100+110+120)/3=110. આ અસર કહેવાય છે કાફલાની અસર, જ્યારે સંસાધનના કેટલાક ટૂંકા ગાળાના ઉપભોક્તા ભારે ઉપભોક્તા પછી કતાર કરશે. તે કરિયાણાની દુકાન પરની લાઇન જેવું છે જ્યારે તમારી સામે કોઈ ગ્રાહક સંપૂર્ણ કાર્ટ સાથે હોય. સમસ્યાનો શ્રેષ્ઠ ઉકેલ એ છે કે રોકડ રજિસ્ટર બદલવાનો પ્રયાસ કરો અથવા આરામ કરો અને ઊંડો શ્વાસ લો.

સૌથી ટૂંકી નોકરી પ્રથમ

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

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

આમ, આપેલ ધારણા માટે કે તમામ કાર્યો એક જ સમયે આવે છે, SJF અલ્ગોરિધમ સૌથી શ્રેષ્ઠ અલ્ગોરિધમ લાગે છે. જો કે, અમારી ધારણાઓ હજુ પણ વાસ્તવિક લાગતી નથી. આ વખતે આપણે ધારણા 2 બદલીએ છીએ અને આ વખતે કલ્પના કરો કે કાર્યો કોઈપણ સમયે હાજર હોઈ શકે છે, અને બધા એક જ સમયે નહીં. આ કઈ સમસ્યાઓ તરફ દોરી શકે છે?

ચાલો કલ્પના કરીએ કે કાર્ય A (100c) પ્રથમ આવે છે અને ચલાવવાનું શરૂ કરે છે. t=10 પર, B અને C કાર્યો આવે છે, જેમાંથી દરેક 10 સેકન્ડ લેશે. તેથી સરેરાશ અમલ સમય (100+(110-10)+(120-10))3 = 103 છે. આને સુધારવા માટે શેડ્યૂલર શું કરી શકે?

પૂર્ણ થવા માટેનો સૌથી ટૂંકો સમય (STCF)

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

આ પ્લાનરનું પરિણામ નીચે મુજબ હશે: ((120-0)+(20-10)+(30-10))/3=50. આમ, આવા શેડ્યૂલર અમારા કાર્યો માટે વધુ શ્રેષ્ઠ બની જાય છે.

મેટ્રિક પ્રતિભાવ સમય

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

પ્રતિભાવ સમય નીચે પ્રમાણે ગણવામાં આવે છે:

ટ્રેસ્પોન્સ=Tfirstrun−Tarrival

આમ, અગાઉના ઉદાહરણ માટે, પ્રતિભાવ સમય હશે: A=0, B=0, C=10 (abg=3,33).

અને તે તારણ આપે છે કે STCF અલ્ગોરિધમ એવી પરિસ્થિતિમાં એટલું સારું નથી કે જ્યાં એક જ સમયે 3 કાર્યો આવે છે - નાના કાર્યો સંપૂર્ણપણે પૂર્ણ થાય ત્યાં સુધી રાહ જોવી પડશે. તેથી ટર્નઅરાઉન્ડ ટાઇમ મેટ્રિક માટે અલ્ગોરિધમ સારું છે, પરંતુ ઇન્ટરેક્ટિવિટી મેટ્રિક માટે ખરાબ છે. કલ્પના કરો કે તમે ટર્મિનલ પર બેસીને સંપાદકમાં અક્ષરો લખવાનો પ્રયાસ કરી રહ્યાં છો અને 10 સેકન્ડથી વધુ રાહ જોવી પડી રહી છે કારણ કે અન્ય કોઈ કાર્ય CPU લઈ રહ્યું છે. તે બહુ સુખદ નથી.

તેથી અમે બીજી સમસ્યાનો સામનો કરી રહ્યા છીએ - અમે કેવી રીતે શેડ્યૂલર બનાવી શકીએ જે પ્રતિભાવ સમય માટે સંવેદનશીલ હોય?

રાઉન્ડ રોબિન

આ સમસ્યાને ઉકેલવા માટે એક અલ્ગોરિધમનો વિકાસ કરવામાં આવ્યો હતો રાઉન્ડ રોબિન (આરઆર). મૂળભૂત વિચાર એકદમ સરળ છે: જ્યાં સુધી કાર્યો પૂર્ણ ન થાય ત્યાં સુધી ચલાવવાને બદલે, અમે ચોક્કસ સમયગાળા માટે કાર્ય ચલાવીશું (જેને ટાઈમ સ્લાઈસ કહેવાય છે) અને પછી કતારમાંથી બીજા કાર્ય પર સ્વિચ કરીશું. બધા કાર્યો પૂર્ણ ન થાય ત્યાં સુધી અલ્ગોરિધમ તેના કાર્યને પુનરાવર્તિત કરે છે. આ કિસ્સામાં, પ્રોગ્રામનો ચાલી રહેલ સમય એ સમયનો બહુવિધ હોવો જોઈએ જે પછી ટાઈમર પ્રક્રિયામાં વિક્ષેપ પાડશે. ઉદાહરણ તરીકે, જો ટાઈમર દરેક x=10ms પ્રક્રિયામાં વિક્ષેપ પાડે છે, તો પ્રક્રિયા એક્ઝેક્યુશન વિન્ડોનું કદ 10 ના ગુણાંકનું હોવું જોઈએ અને 10,20 અથવા x*10 હોવું જોઈએ.

ચાલો એક ઉદાહરણ જોઈએ: એબીસી કાર્યો સિસ્ટમમાં એક સાથે આવે છે અને તેમાંથી દરેક 5 સેકન્ડ માટે ચલાવવા માંગે છે. SJF અલ્ગોરિધમ બીજું શરૂ કરતા પહેલા દરેક કાર્ય પૂર્ણ કરશે. તેનાથી વિપરિત, લોન્ચ વિન્ડો = 1s સાથે RR અલ્ગોરિધમ નીચે મુજબના કાર્યોમાંથી પસાર થશે (ફિગ. 4.3):

(એસજેએફ ફરીથી (પ્રતિભાવ સમય માટે ખરાબ)

(રાઉન્ડ રોબિન (પ્રતિભાવ સમય માટે સારું)

RR અલ્ગોરિધમનો સરેરાશ પ્રતિભાવ સમય (0+1+2)/3=1 છે, જ્યારે SJF (0+5+10)/3=5 છે.

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

જો આપણે માત્ર પ્રતિભાવ સમય મેટ્રિક વિશે વાત કરતા હોઈએ તો RR એ એક ઉત્તમ શેડ્યૂલર છે. પરંતુ આ અલ્ગોરિધમ સાથે કાર્ય ટર્નઅરાઉન્ડ ટાઇમ મેટ્રિક કેવી રીતે વર્તે છે? ઉપરના ઉદાહરણને ધ્યાનમાં લો, જ્યારે A, B, C = 5s નો ઓપરેટિંગ સમય અને તે જ સમયે આવે છે. કાર્ય A 13, B 14, C 15 પર સમાપ્ત થશે અને સરેરાશ ટર્નઅરાઉન્ડ સમય 14 સેકન્ડનો રહેશે. આમ, ટર્નઓવર મેટ્રિક માટે આરઆર એ સૌથી ખરાબ અલ્ગોરિધમ છે.

વધુ સામાન્ય શબ્દોમાં, કોઈપણ RR-પ્રકાર અલ્ગોરિધમ વાજબી છે; તે CPU સમયને બધી પ્રક્રિયાઓ વચ્ચે સમાન રીતે વિભાજિત કરે છે. અને આમ, આ મેટ્રિક્સ સતત એકબીજા સાથે સંઘર્ષ કરે છે.

આમ, અમારી પાસે ઘણા વિરોધાભાસી અલ્ગોરિધમ્સ છે અને તે જ સમયે હજી પણ ઘણી ધારણાઓ બાકી છે - કે કાર્યનો સમય જાણીતો છે અને તે કાર્ય ફક્ત CPU નો ઉપયોગ કરે છે.

I/O સાથે મિશ્રણ

સૌ પ્રથમ, ચાલો ધારણા 4 દૂર કરીએ કે પ્રક્રિયા ફક્ત CPU નો ઉપયોગ કરે છે; કુદરતી રીતે, આ કેસ નથી અને પ્રક્રિયાઓ અન્ય સાધનોને ઍક્સેસ કરી શકે છે.

જે ક્ષણે કોઈપણ પ્રક્રિયા I/O ઑપરેશનની વિનંતી કરે છે, પ્રક્રિયા I/O પૂર્ણ થવાની રાહ જોઈને અવરોધિત સ્થિતિમાં પ્રવેશે છે. જો I/O ને હાર્ડ ડ્રાઈવ પર મોકલવામાં આવે છે, તો પછી આવા ઓપરેશનમાં ઘણા ms અથવા વધુ સમય લાગી શકે છે, અને પ્રોસેસર આ ક્ષણે નિષ્ક્રિય હશે. આ સમય દરમિયાન, શેડ્યૂલર કોઈપણ અન્ય પ્રક્રિયા સાથે પ્રોસેસર પર કબજો કરી શકે છે. શેડ્યૂલરે આગળનો નિર્ણય લેવાનો રહેશે જ્યારે પ્રક્રિયા તેના I/O પૂર્ણ કરશે. જ્યારે આવું થાય છે, ત્યારે એક વિક્ષેપ આવશે અને OS પ્રક્રિયાને તૈયાર સ્થિતિમાં મૂકશે જે I/O કહેવાય છે.

ચાલો ઘણી સમસ્યાઓનું ઉદાહરણ જોઈએ. તેમાંના દરેકને 50ms CPU સમયની જરૂર છે. જો કે, પ્રથમ I/O ને દર 10ms (જે દર 10ms પર એક્ઝિક્યુટ કરવામાં આવશે) ઍક્સેસ કરશે. અને પ્રક્રિયા B ફક્ત I/O વગર 50ms પ્રોસેસરનો ઉપયોગ કરે છે.

આ ઉદાહરણમાં આપણે STCF શેડ્યૂલરનો ઉપયોગ કરીશું. જો A જેવી પ્રક્રિયા તેના પર શરૂ કરવામાં આવે તો શેડ્યૂલર કેવું વર્તન કરશે? તે નીચે મુજબ કરશે: પ્રથમ તે પ્રક્રિયા A ને સંપૂર્ણ રીતે કામ કરશે, અને પછી B પ્રક્રિયા કરશે.

આ સમસ્યાનો ઉકેલ લાવવાનો પરંપરાગત અભિગમ એ પ્રક્રિયા A ના દરેક 10 ms સબટાસ્કને એક અલગ કાર્ય તરીકે ગણવામાં આવે છે. આમ, જ્યારે STJF અલ્ગોરિધમથી શરૂ થાય છે, ત્યારે 50 ms કાર્ય અને 10 ms કાર્ય વચ્ચેની પસંદગી સ્પષ્ટ છે. પછી, જ્યારે સબટાસ્ક A પૂર્ણ થશે, પ્રક્રિયા B અને I/O શરૂ થશે. I/O પૂર્ણ થયા પછી, પ્રક્રિયા B ને બદલે ફરીથી 10ms પ્રક્રિયા A શરૂ કરવાનો રિવાજ હશે. આ રીતે, ઓવરલેપ અમલમાં મૂકવું શક્ય છે, જ્યાં CPU નો ઉપયોગ બીજી પ્રક્રિયા દ્વારા કરવામાં આવે છે જ્યારે પ્રથમ પ્રક્રિયાની રાહ જોઈ રહી હોય. I/O. અને પરિણામે, સિસ્ટમનો વધુ સારી રીતે ઉપયોગ થાય છે - આ ક્ષણે જ્યારે ઇન્ટરેક્ટિવ પ્રક્રિયાઓ I/O ની રાહ જોઈ રહી હોય, અન્ય પ્રક્રિયાઓ પ્રોસેસર પર ચલાવી શકાય છે.

ઓરેકલ હવે નથી

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

પરિણામ

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

સોર્સ: www.habr.com