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

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

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

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

અન્ય ભાગો:

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

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

આયોજન: મલ્ટી-લેવલ ફીડબેક કતાર

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

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

સમસ્યાનો સાર: સંપૂર્ણ જ્ઞાન વિના કાર્યોના સેટિંગની યોજના કેવી રીતે કરવી?
શેડ્યૂલર કેવી રીતે ડિઝાઇન કરવું કે જે એક સાથે પ્રતિસાદનો સમય ઘટાડે
ઇન્ટરેક્ટિવ કાર્યો માટે અને તે જ સમયે જાણ્યા વિના ટર્નઅરાઉન્ડ સમય ઘટાડે છે
કાર્ય અમલના સમયનું જ્ઞાન?

નોંધ: અગાઉની ઘટનાઓમાંથી શીખવું

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

MLFQ: મૂળભૂત નિયમો

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

• નિયમ 1: જો અગ્રતા(A) > અગ્રતા (B), કાર્ય A ચાલશે (B ચાલશે નહીં)
• નિયમ 2: જો અગ્રતા(A) = પ્રાથમિકતા(B), A&B આરઆરનો ઉપયોગ કરીને શરૂ કરવામાં આવે છે

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

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

પ્રયાસ 1: અગ્રતા કેવી રીતે બદલવી

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

• નિયમ3: જ્યારે કોઈ કાર્ય સિસ્ટમમાં પ્રવેશે છે, ત્યારે તેને સૌથી વધુ સાથે કતારમાં મૂકવામાં આવે છે
• પ્રાથમિકતા.
• નિયમ 4a: જો કોઈ કાર્ય તેની સંપૂર્ણ સમય વિન્ડોનો ઉપયોગ કરે છે, તો તે
• પ્રાધાન્યતા ઓછી થઈ છે.
• નિયમ4b: જો કોઈ કાર્ય CPU ને તેની સમય વિન્ડો સમાપ્ત થાય તે પહેલાં રિલીઝ કરે છે, તો તે
• સમાન અગ્રતા સાથે રહે છે.

ઉદાહરણ 1: એક લાંબા સમયથી ચાલતું કાર્ય

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

ઉદાહરણ 2: એક નાનું કાર્ય પસંદ કર્યું

હવે ચાલો એક ઉદાહરણ જોઈએ કે કેવી રીતે MLFQ SJF નો સંપર્ક કરવાનો પ્રયાસ કરશે. તેમાં
ઉદાહરણ તરીકે, બે કાર્યો: A, જે સતત લાંબા સમયથી ચાલતું કાર્ય છે
CPU અને B પર કબજો મેળવવો, જે ટૂંકા ઇન્ટરેક્ટિવ કાર્ય છે. ધારો
કે A પહેલાથી જ ટાસ્ક Bના આગમન સુધીમાં થોડા સમય માટે ચાલી રહ્યો હતો.

આ ગ્રાફ દૃશ્યના પરિણામો બતાવે છે. કાર્ય A, કોઈપણ કાર્યની જેમ,
CPU નો ઉપયોગ ખૂબ જ તળિયે હતો. ટાસ્ક B T=100 સમયે પહોંચશે અને આવશે
સર્વોચ્ચ અગ્રતા કતારમાં મૂકવામાં આવે છે. ચાલવાનો સમય ઓછો હોવાથી,
છેલ્લી કતાર સુધી પહોંચતા પહેલા તે પૂર્ણ થશે.

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

ઉદાહરણ 3: I/O વિશે શું?

હવે ચાલો I/O ઉદાહરણ જોઈએ. નિયમ 4b માં જણાવ્યા મુજબ,
જો કોઈ પ્રક્રિયા તેના પ્રોસેસર સમયનો સંપૂર્ણ ઉપયોગ કર્યા વિના પ્રોસેસરને રિલીઝ કરે છે,
પછી તે સમાન અગ્રતા સ્તર પર રહે છે. આ નિયમનો હેતુ એકદમ સરળ છે.
- જો ઇન્ટરેક્ટિવ જોબ ઘણા બધા I/O કરે છે, ઉદાહરણ તરીકે, રાહ જોવી
વપરાશકર્તા કી અથવા માઉસ પ્રેસથી, આવા કાર્ય પ્રોસેસરને મુક્ત કરશે
ફાળવેલ વિન્ડો પહેલાં. અમે આવા પ્રાથમિકતાના કાર્યને છોડી દેવા માંગતા નથી,
અને આમ તે સમાન સ્તર પર રહેશે.

આ ઉદાહરણ બતાવે છે કે કેવી રીતે અલ્ગોરિધમ આવી પ્રક્રિયાઓ સાથે કામ કરશે - ઇન્ટરેક્ટિવ ટાસ્ક B, જેને એક્ઝેક્યુટ કરતા પહેલા માત્ર 1ms માટે CPUની જરૂર છે
I/O પ્રક્રિયા અને લાંબી નોકરી A, જે દરેક સમયે CPU નો ઉપયોગ કરે છે.
MLFQ પ્રક્રિયા B ને સર્વોચ્ચ અગ્રતા પર રાખે છે કારણ કે તે ચાલુ રહે છે
CPU છોડો. જો B એક ઇન્ટરેક્ટિવ કાર્ય છે, તો આ કિસ્સામાં અલ્ગોરિધમ પહોંચી ગયું છે
તેનો હેતુ ઇન્ટરેક્ટિવ કાર્યોને ઝડપથી શરૂ કરવાનો છે.

વર્તમાન MLFQ અલ્ગોરિધમ સાથે સમસ્યાઓ

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

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

છેવટે, પ્રોગ્રામ સમય જતાં તેનું વર્તન બદલી શકે છે. તે કાર્યો
જેનો ઉપયોગ CPU ઇન્ટરેક્ટિવ બની શકે છે. અમારા ઉદાહરણમાં, સમાન
કાર્યોને શેડ્યૂલર પાસેથી યોગ્ય સારવાર મળશે નહીં, જેમ કે અન્ય લોકો કરશે
(પ્રારંભિક) ઇન્ટરેક્ટિવ કાર્યો.

પ્રેક્ષકોને પ્રશ્ન: આધુનિક વિશ્વમાં શેડ્યૂલર પર કયા હુમલાઓ કરી શકાય છે?

પ્રયાસ 2: પ્રાથમિકતામાં વધારો

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

• નિયમ 5: અમુક સમયગાળા S પછી, સિસ્ટમમાંના તમામ કાર્યોને ઉચ્ચતમ કતારમાં સ્થાનાંતરિત કરો.

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

CPU અને બે ઇન્ટરેક્ટિવ, ટૂંકી પ્રક્રિયાઓ. આકૃતિમાં ડાબી બાજુએ, આકૃતિ પ્રાયોરિટી પ્રમોશન વિનાની વર્તણૂક દર્શાવે છે, અને આમ સિસ્ટમમાં બે ઇન્ટરેક્ટિવ કાર્યો આવ્યા પછી લાંબા સમયથી ચાલતું કાર્ય ભૂખે મરવા લાગે છે. જમણી બાજુની આકૃતિમાં, દર 50msએ અગ્રતામાં વધારો કરવામાં આવે છે અને આ રીતે તમામ પ્રક્રિયાઓ CPU સમય મેળવવાની ખાતરી આપે છે અને સમયાંતરે શરૂ કરવામાં આવશે. આ કિસ્સામાં 50ms એક ઉદાહરણ તરીકે લેવામાં આવે છે, વાસ્તવમાં આ સંખ્યા થોડી વધારે છે.
તે સ્પષ્ટ છે કે સામયિક વધારો સમય S નો ઉમેરો થાય છે
તાર્કિક પ્રશ્ન: શું મૂલ્ય સેટ કરવું જોઈએ? એક સારી રીતે લાયક
સિસ્ટમ એન્જિનિયરો જ્હોન ઓસ્ટરહાઉટે સિસ્ટમમાં સમાન જથ્થાને વૂ-ડૂ તરીકે ઉલ્લેખ કર્યો છે
સતત, કારણ કે તેમને અમુક રીતે સાચા માટે કાળા જાદુની જરૂર હતી
સંપર્કમાં આવું છું. અને, કમનસીબે, એસ આવા સ્વાદ ધરાવે છે. જો તમે મૂલ્ય પણ સેટ કરો છો
મોટા - લાંબા કાર્યો ભૂખે મરવા લાગશે. અને જો તમે મૂલ્ય ખૂબ ઓછું સેટ કરો છો,
ઇન્ટરેક્ટિવ કાર્યો યોગ્ય CPU સમય પ્રાપ્ત કરશે નહીં.

પ્રયાસ 3: બહેતર એકાઉન્ટિંગ

હવે અમારી પાસે એક વધુ સમસ્યા હલ કરવાની છે: કેવી રીતે નહીં
અમારા શેડ્યૂલરને છેતરવા દે છે? આ શક્યતા માટે ગુનેગારો છે
નિયમો 4a, 4b કે જે પ્રોસેસરને મુક્ત કરીને નોકરીને તેની પ્રાથમિકતા જાળવી રાખવા દે છે
ફાળવેલ સમયની સમાપ્તિ પહેલાં. તેની સાથે કેવી રીતે વ્યવહાર કરવો?
આ કિસ્સામાં ઉકેલ દરેક પર CPU સમયનો વધુ સારો હિસાબ ગણી શકાય
MLFQ સ્તર. પ્રોગ્રામમાં વપરાયેલ સમયને ભૂલી જવાને બદલે
ફાળવેલ અંતરાલ માટે પ્રોસેસર, તમારે ધ્યાનમાં લેવું જોઈએ અને તેને સાચવવું જોઈએ. પછી
પ્રક્રિયાએ તેના ફાળવેલ સમયનો ઉપયોગ કર્યો છે, તે પછીના સમય માટે ઘટાડવો જોઈએ
અગ્રતા સ્તર. હવે તે કોઈ વાંધો નથી કે પ્રક્રિયા તેના સમયનો ઉપયોગ કેવી રીતે કરશે - કેવી રીતે
પ્રોસેસર પર અથવા કૉલના સમૂહ તરીકે સતત ગણતરી કરવી. આમ,
નિયમ 4 નીચે પ્રમાણે ફરીથી લખવો જોઈએ:

• નિયમ 4: કોઈ કાર્ય વર્તમાન કતારમાં તેના ફાળવેલ સમયનો ઉપયોગ કરે પછી (તે CPU ને કેટલી વાર મુક્ત કરે છે તે ધ્યાનમાં લીધા વિના), આવા કાર્યની પ્રાથમિકતા ઓછી થઈ જાય છે (તે કતારની નીચે જાય છે).

ચાલો એક ઉદાહરણ જોઈએ:
»

આકૃતિ બતાવે છે કે જો તમે શેડ્યૂલરની જેમ યુક્તિ કરવાનો પ્રયાસ કરો તો શું થાય છે
જો તે અગાઉના નિયમો 4a સાથે હોત, તો 4b ડાબી બાજુનું પરિણામ હશે. નવા સાથે
નિયમ એ છે કે પરિણામ જમણી બાજુએ છે. સંરક્ષણ પહેલાં, કોઈપણ પ્રક્રિયા પૂર્ણ થતાં પહેલાં I/O ને કૉલ કરી શકે છે અને
આ રીતે CPU પર વર્ચસ્વ મેળવો, સુરક્ષાને સક્ષમ કર્યા પછી, વર્તનને ધ્યાનમાં લીધા વગર
I/O, તે હજી પણ કતારમાં નીચે જશે અને આમ તે અપ્રમાણિક રીતે સક્ષમ રહેશે નહીં
CPU સંસાધનો લો.

MLFQ અને અન્ય સમસ્યાઓમાં સુધારો

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

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

આ ઉદાહરણમાં, ત્યાં 2 કાર્યો છે જે ઉચ્ચ પ્રાથમિકતા કતાર 20 માં કામ કરે છે
ms 10ms વિન્ડોમાં વિભાજિત. મધ્ય કતારમાં 40ms (20ms વિન્ડો) અને ઓછી અગ્રતાવાળી કતારમાં
કતાર સમયની વિન્ડો 40ms બની જ્યાં કાર્યોએ તેમનું કાર્ય પૂર્ણ કર્યું.

Solaris OS માં MLFQ નો અમલ એ સમય-શેર શેડ્યૂલરનો વર્ગ છે.
શેડ્યૂલર કોષ્ટકોનો સમૂહ પ્રદાન કરશે જે બરાબર તે કેવી રીતે હોવું જોઈએ તે વ્યાખ્યાયિત કરે છે
તેના જીવન દરમિયાન પ્રક્રિયાની પ્રાથમિકતા બદલો, કદ શું હોવું જોઈએ
વિન્ડો ફાળવવામાં આવશે અને કેટલી વાર કાર્ય પ્રાથમિકતાઓ વધારવી. સંચાલક
સિસ્ટમ આ કોષ્ટક સાથે ક્રિયાપ્રતિક્રિયા કરી શકે છે અને શેડ્યૂલરને વર્તે છે
અલગ રીતે મૂળભૂત રીતે, આ કોષ્ટકમાં ક્રમશઃ વધારા સાથે 60 કતાર છે
વિન્ડોનું કદ 20ms (ઉચ્ચ પ્રાધાન્યતા) થી કેટલાક સો ms (સૌથી ઓછી પ્રાધાન્યતા), અને
દરેક સેકન્ડમાં એકવાર તમામ કાર્યોના બુસ્ટ સાથે.

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

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

MLFQ: સારાંશ

અમે MLFQ નામના આયોજન અભિગમનું વર્ણન કર્યું છે. તેમના નામ
ઓપરેશનના સિદ્ધાંતમાં તારણ કાઢ્યું - તેમાં ઘણી કતાર છે અને પ્રતિસાદનો ઉપયોગ કરે છે
કાર્યને પ્રાથમિકતા આપવા માટે.
નિયમોનું અંતિમ સ્વરૂપ નીચે મુજબ હશે.

• નિયમ 1: જો અગ્રતા(A) > અગ્રતા(B), કાર્ય A ચાલશે (B ચાલશે નહીં)
• નિયમ 2: જો અગ્રતા(A) = અગ્રતા(B), A&B આરઆરનો ઉપયોગ કરીને શરૂ કરવામાં આવે છે
• નિયમ 3: જ્યારે કોઈ કાર્ય સિસ્ટમમાં પ્રવેશે છે, ત્યારે તેને સર્વોચ્ચ પ્રાથમિકતાવાળી કતારમાં મૂકવામાં આવે છે.
• નિયમ 4: કોઈ કાર્ય વર્તમાન કતારમાં તેના ફાળવેલ સમયનો ઉપયોગ કરે પછી (તે CPU ને કેટલી વાર મુક્ત કરે છે તે ધ્યાનમાં લીધા વિના), આવા કાર્યની પ્રાથમિકતા ઓછી થઈ જાય છે (તે કતારની નીચે જાય છે).
• નિયમ 5: અમુક સમયગાળા S પછી, સિસ્ટમમાંના તમામ કાર્યોને ઉચ્ચતમ કતારમાં સ્થાનાંતરિત કરો.

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

વધારાની સામગ્રી:

1. manpages.debian.org/stretch/manpages/sched.7.en.html
2. en.wikipedia.org/wiki/Scheduling_(કમ્પ્યુટિંગ)
3. pages.lip6.fr/Julia.Lawall/atc18-bouron.pdf
4. www.usenix.org/legacy/event/bsdcon03/tech/full_papers/roberson/roberson.pdf
5. chebykin.org/freebsd-process-scheduling

સોર્સ: www.habr.com