ऑपरेटिंग सिस्टमची ओळख

अहो हाब्र! मी तुमच्या लक्षात आणून देऊ इच्छितो लेखांची मालिका-माझ्या मते एका मनोरंजक साहित्याचे भाषांतर - OSTEP. ही सामग्री युनिक्स सारख्या ऑपरेटिंग सिस्टीमच्या कार्याची सखोल चर्चा करते, म्हणजे, प्रक्रियांसह कार्य, विविध शेड्यूलर, मेमरी आणि आधुनिक OS बनविणारे इतर समान घटक. आपण येथे सर्व सामग्रीचे मूळ पाहू शकता येथे. कृपया लक्षात ठेवा की भाषांतर अव्यावसायिकपणे केले गेले आहे (अगदी मुक्तपणे), परंतु मला आशा आहे की मी सामान्य अर्थ राखला आहे.

या विषयावरील प्रयोगशाळेतील कार्य येथे आढळू शकते:

इतर भाग:

तुम्ही माझे चॅनल येथे देखील पाहू शकता तार =)

नियोजन: बहु-स्तरीय फीडबॅक रांग

या व्याख्यानात आम्ही सर्वात प्रसिद्ध दृष्टिकोनांपैकी एक विकसित करण्याच्या समस्यांबद्दल बोलू
नियोजन, ज्याला म्हणतात बहु-स्तरीय फीडबॅक रांग (MLFQ). MLFQ शेड्युलरचे वर्णन प्रथम 1962 मध्ये फर्नांडो जे. कॉर्बेटो यांनी या प्रणालीमध्ये केले होते.
सुसंगत वेळ-सामायिकरण प्रणाली (CTSS). ही कामे (नंतरच्या कामासह
मल्टिक्स) नंतर ट्युरिंग पुरस्कारासाठी नामांकन करण्यात आले. नियोजक होते
नंतर सुधारित केले आणि आधीच आढळू शकणारे स्वरूप प्राप्त केले
काही आधुनिक प्रणाली.

MLFQ अल्गोरिदम 2 मूलभूत ओव्हरलॅपिंग समस्या सोडवण्याचा प्रयत्न करतो.
पहिल्याने, तो टर्नअराउंड टाइम ऑप्टिमाइझ करण्याचा प्रयत्न करतो, ज्याची आपण मागील व्याख्यानात चर्चा केली होती, ती सर्वात जास्त रांगेच्या सुरुवातीला सुरू करण्याच्या पद्धतीद्वारे ऑप्टिमाइझ केली जाते.
लहान कार्ये. तथापि, OS ला माहित नाही की एखादी विशिष्ट प्रक्रिया किती काळ चालेल आणि हे
SJF, STCF अल्गोरिदमच्या ऑपरेशनसाठी आवश्यक ज्ञान. दुसरे म्हणजे, MLFQ प्रयत्न करत आहे
वापरकर्त्यांसाठी सिस्टम प्रतिसादात्मक बनवा (उदाहरणार्थ, जे बसतात त्यांच्यासाठी आणि
कार्य पूर्ण होण्याची वाट पाहत स्क्रीनकडे पहा) आणि अशा प्रकारे वेळ कमी करा
प्रतिसाद दुर्दैवाने, RR सारखे अल्गोरिदम प्रतिसाद वेळ सुधारतात, परंतु अत्यंत
टर्नअराउंड टाइम मेट्रिकवर वाईट परिणाम होतो. म्हणून आमची समस्या: डिझाइन कसे करावे
एक शेड्युलर जो आमच्या गरजा पूर्ण करेल याबद्दल काहीही माहिती न घेता
सर्वसाधारणपणे प्रक्रियेचे स्वरूप? शेड्युलर कार्यांची वैशिष्ट्ये कशी शिकू शकतो,
जे ते लाँच करते आणि अशा प्रकारे चांगले नियोजन निर्णय घेते?

समस्येचे सार: परिपूर्ण ज्ञानाशिवाय कार्यांच्या सेटिंगची योजना कशी करावी?
शेड्युलर कसे डिझाइन करावे जे एकाच वेळी प्रतिसाद वेळ कमी करते
परस्परसंवादी कार्यांसाठी आणि त्याच वेळी नकळत टर्नअराउंड वेळ कमी करते
कार्य अंमलबजावणी वेळेचे ज्ञान?

टीप: आपण मागील घटनांवरून शिकतो

MLFQ रांग हे एका प्रणालीचे उत्कृष्ट उदाहरण आहे ज्यातून शिकते
भविष्याचा अंदाज घेण्यासाठी भूतकाळातील घटना. तत्सम दृष्टिकोन अनेकदा आहेत
OS मध्ये आढळले (आणि शाखांसह संगणक विज्ञानाच्या इतर अनेक शाखा
हार्डवेअर अंदाज आणि कॅशिंग अल्गोरिदम). तत्सम सहली
जेव्हा कार्ये वर्तणुकीचे टप्पे असतात आणि त्यामुळे अंदाज लावता येतात तेव्हा ट्रिगर होतात.
तथापि, आपण या तंत्रासह सावधगिरी बाळगली पाहिजे कारण अंदाज करणे खूप सोपे आहे
चुकीचे ठरू शकते आणि सिस्टमला त्यापेक्षा वाईट निर्णय घेण्यास प्रवृत्त करू शकते
अजिबात ज्ञानाशिवाय असेल.

MLFQ: मूलभूत नियम

चला MLFQ अल्गोरिदमचे मूलभूत नियम पाहू. आणि जरी या अल्गोरिदमची अंमलबजावणी
अनेक आहेत, मूलभूत दृष्टिकोन समान आहेत.
अंमलबजावणीमध्ये आम्ही पाहणार आहोत, MLFQ मध्ये अनेक असतील
विभक्त रांगा, त्यातील प्रत्येकाला वेगळे प्राधान्य असेल. कधीही,
अंमलबजावणीसाठी तयार असलेले कार्य एका रांगेत आहे. MLFQ प्राधान्यक्रम वापरते,
कोणते कार्य अंमलात आणायचे ते ठरवणे, म्हणजे उच्च सह कार्य
प्राधान्य (सर्वोच्च प्राधान्य असलेल्या रांगेतील कार्य) प्रथम सुरू केले जाईल
रांग
अर्थात, दिलेल्या रांगेत एकापेक्षा जास्त कार्ये असू शकतात, त्यामुळे
त्यामुळे त्यांना समान प्राधान्य असेल. या प्रकरणात, यंत्रणा वापरली जाईल
या कार्यांमध्ये धावण्याचे वेळापत्रक करण्यासाठी आर.आर.
अशा प्रकारे आम्ही MLFQ साठी दोन मूलभूत नियमांवर पोहोचतो:

नियम 1: जर प्राधान्य(A) > प्राधान्य(B), कार्य A लाँच केले जाईल (B नाही)
नियम 2: जर प्राधान्य(A) = प्राधान्य(B), A&B RR वापरून सुरू केले

वरील आधारावर, MLFQ चे नियोजन करण्याचे प्रमुख घटक
प्राधान्यक्रम आहेत. प्रत्येकाला निश्चित प्राधान्य देण्याऐवजी
कार्य, MLFQ निरीक्षण केलेल्या वर्तनावर अवलंबून त्याचे प्राधान्य बदलते.
उदाहरणार्थ, कीबोर्ड इनपुटची वाट पाहत असताना एखादे कार्य सतत CPU वर काम करत असल्यास,
MLFQ प्रक्रिया प्राधान्य उच्च ठेवेल कारण असेच आहे
परस्परसंवादी प्रक्रिया कार्य करावी. जर, त्याउलट, कार्य सतत आणि
दीर्घ कालावधीसाठी CPU मोठ्या प्रमाणावर वापरते, MLFQ ते कमी करेल
एक प्राधान्य. अशा प्रकारे, MLFQ प्रक्रिया चालू असताना त्यांच्या वर्तनाचा अभ्यास करेल
आणि वर्तन वापरा.
एखाद्या वेळी रांगा कशा दिसू शकतात याचे उदाहरण काढू
वेळ आणि नंतर तुम्हाला असे काहीतरी मिळेल:

या योजनेत, 2 प्रक्रिया A आणि B सर्वोच्च प्राधान्याच्या रांगेत आहेत. प्रक्रिया
C मध्यभागी कुठेतरी आहे आणि D ही प्रक्रिया रांगेच्या अगदी शेवटी आहे. वरील नुसार
MLFQ अल्गोरिदमच्या वर्णनानुसार, शेड्युलर केवळ सर्वोच्च कार्ये कार्यान्वित करेल
RR नुसार प्राधान्य, आणि कार्ये C, D कामाबाहेर असतील.
स्वाभाविकच, स्थिर स्नॅपशॉट MLFQ कसे कार्य करते याचे संपूर्ण चित्र देऊ शकत नाही.
काळानुसार चित्र नेमके कसे बदलते हे समजून घेणे गरजेचे आहे.

प्रयत्न 1: प्राधान्य कसे बदलावे

या टप्प्यावर तुम्हाला हे ठरवावे लागेल की MLFQ प्राधान्य पातळी कशी बदलेल
कार्ये (आणि अशा प्रकारे कार्याचे रांगेतील स्थान) जसे ते त्याच्या जीवन चक्रातून पुढे जाते. च्या साठी
कार्यप्रवाह लक्षात ठेवण्यासाठी हे आवश्यक आहे: एक विशिष्ट रक्कम
लहान रनटाइमसह परस्परसंवादी कार्ये (आणि त्यामुळे वारंवार रिलीज
CPU) आणि अनेक दीर्घकाळ चालणारी कार्ये जी CPU त्यांचा सर्व कामकाजाचा वेळ वापरतात
अशा कामांसाठी प्रतिसाद वेळ महत्त्वाचा नाही. आणि अशा प्रकारे तुम्ही तुमचा पहिला प्रयत्न करू शकता
खालील नियमांसह MLFQ अल्गोरिदम लागू करा:

नियम3: जेव्हा एखादे कार्य सिस्टीममध्ये प्रवेश करते, तेव्हा ते सर्वोच्च रांगेत ठेवले जाते
प्राधान्य
Rule4a: जर एखादे कार्य त्याला दिलेली संपूर्ण वेळ वापरत असेल, तर ते
प्राधान्य कमी केले आहे.
Rule4b: जर एखादे टास्क सीपीयूची टाइम विंडो कालबाह्य होण्याआधी रिलीज करते, तर ते
समान प्राधान्याने राहते.

उदाहरण 1: एकल दीर्घकाळ चालणारे कार्य

या उदाहरणात पाहिल्याप्रमाणे, प्रवेश कार्य सर्वोच्च सह सेट केले आहे
प्राधान्य 10ms च्या टाइम विंडोनंतर, प्रक्रिया प्राधान्याने कमी केली जाते
नियोजक पुढील वेळ विंडो नंतर, कार्य शेवटी demoted आहे
सिस्टममध्ये सर्वात कमी प्राधान्य, जिथे ते राहते.

उदाहरण 2: एक लहान कार्य वितरित केले

आता MLFQ SJF ला कसे जाण्याचा प्रयत्न करेल याचे उदाहरण पाहू. त्यात
उदाहरणार्थ, दोन कार्ये: A, जे सतत दीर्घकाळ चालणारे कार्य आहे
CPU आणि B व्यापत आहे, जे एक लहान संवादात्मक कार्य आहे. समजा
टास्क B येईपर्यंत A आधीच काही काळ काम करत होता.

हा आलेख परिस्थितीचे परिणाम दर्शवितो. कार्य A, कोणत्याही कार्याप्रमाणे,
CPU वापर अगदी तळाशी होता. टास्क B वेळेवर येईल T=100 आणि होईल
सर्वोच्च प्राधान्य रांगेत ठेवले. त्याची ऑपरेटिंग वेळ लहान असल्याने
शेवटच्या रांगेत पोहोचण्यापूर्वी ते पूर्ण होईल.

या उदाहरणावरून, अल्गोरिदमचे मुख्य उद्दिष्ट समजले पाहिजे: कारण अल्गोरिदम नाही
एखादे कार्य लांब आहे की लहान हे माहीत आहे, मग सर्वप्रथम तो कार्य गृहीत धरतो
लहान आणि सर्वोच्च प्राधान्य देते. जर हे खरोखरच लहान कार्य असेल तर
ते त्वरीत पूर्ण होईल, अन्यथा जर ते लांबचे काम असेल तर ते हळूहळू पुढे जाईल
प्राधान्य कमी आहे आणि लवकरच हे सिद्ध करेल की ती खरोखरच एक लांब कार्य आहे जे करत नाही
प्रतिसाद आवश्यक आहे.

उदाहरण ३: I/O चे काय?

आता एक I/O उदाहरण पाहू. नियम 4b मध्ये सांगितल्याप्रमाणे,
जर एखाद्या प्रक्रियेने प्रोसेसरचा सर्व वेळ न वापरता प्रोसेसर सोडला,
मग ते समान प्राधान्य स्तरावर राहते. या नियमाचा हेतू अगदी सोपा आहे
- जर इंटरएक्टिव्ह जॉब अनेक I/O ऑपरेशन करत असेल, उदाहरणार्थ, प्रतीक्षा करा
वापरकर्ता की किंवा माउस दाबून, असे कार्य प्रोसेसर मोकळे करेल
वाटप केलेल्या विंडोच्या आधी. आम्हाला अशा कामाची प्राथमिकता कमी करायला आवडणार नाही,
आणि अशा प्रकारे ते समान पातळीवर राहील.

हे उदाहरण दाखवते की अशा प्रक्रियांसह अल्गोरिदम कसे कार्य करेल - परस्परसंवादी जॉब बी, ज्याला अंमलबजावणीपूर्वी फक्त 1ms साठी CPU आवश्यक आहे
I/O प्रक्रिया आणि दीर्घकाळ चालणारी जॉब A, जी CPU वापरून आपला सर्व वेळ घालवते.
MLFQ प्रक्रिया B ला सर्वोच्च प्राधान्य देते कारण ती चालू राहते
CPU सोडा. जर बी हे परस्परसंवादी कार्य असेल, तर अल्गोरिदमने साध्य केले आहे
तुमचे ध्येय संवादात्मक कार्ये द्रुतपणे चालवणे आहे.

सध्याच्या MLFQ अल्गोरिदममध्ये समस्या

मागील उदाहरणांमध्ये आम्ही MLFQ ची मूलभूत आवृत्ती तयार केली आहे. आणि असे दिसते की तो
CPU वेळेचे वितरण योग्यरित्या आणि प्रामाणिकपणे करते
लांब कार्ये आणि लहान किंवा उच्च-वॉल्यूम कार्यांना अनुमती देणे
I/O वर त्वरीत काम करा. दुर्दैवाने, या पद्धतीमध्ये अनेक आहेत
गंभीर समस्या.
पहिल्याने, उपासमारीची समस्या: जर प्रणालीमध्ये अनेक परस्परसंवादी असतील
कार्ये, नंतर ते प्रोसेसरचा सर्व वेळ वापरतील आणि अशा प्रकारे एकही दीर्घ काळासाठी नाही
कार्य अंमलात आणण्यात सक्षम होणार नाही (ते उपाशी आहेत).

दुसरे म्हणजे, स्मार्ट वापरकर्ते त्यांचे कार्यक्रम लिहू शकतात जेणेकरून
शेड्युलरला मूर्ख बनवा. फसवणूक म्हणजे बळजबरीने काहीतरी करणे
शेड्युलर प्रक्रियेला अधिक CPU वेळ देतो. अल्गोरिदम की
वर वर्णन केलेले तत्सम हल्ल्यांसाठी खूप असुरक्षित आहे: वेळ विंडो व्यावहारिकदृष्ट्या आधी
संपले, तुम्हाला I/O ऑपरेशन करणे आवश्यक आहे (काहींसाठी, कोणतीही फाईल असो)
आणि अशा प्रकारे CPU मोकळा करा. अशी वागणूक तुम्हाला तशीच राहण्याची परवानगी देईल
रांग स्वतः आणि पुन्हा CPU वेळेची मोठी टक्केवारी मिळवा. आपण केले तर
हे बरोबर आहे (उदाहरणार्थ, CPU रिलीझ करण्यापूर्वी विंडो वेळेच्या 99% कार्यान्वित करा),
असे कार्य फक्त प्रोसेसरची मक्तेदारी करू शकते.

शेवटी, प्रोग्राम कालांतराने त्याचे वर्तन बदलू शकतो. ती कामे
जे CPU वापरले ते परस्परसंवादी होऊ शकते. आमच्या उदाहरणात, समान
कार्यांना शेड्युलरकडून इतरांप्रमाणे योग्य वागणूक मिळणार नाही
(प्रारंभिक) परस्परसंवादी कार्ये.

प्रेक्षकांसाठी प्रश्न: आधुनिक जगात शेड्यूलरवर कोणते हल्ले केले जाऊ शकतात?

प्रयत्न 2: प्राधान्य वाढवणे

चला नियम बदलण्याचा प्रयत्न करूया आणि आपण समस्या टाळू शकतो का ते पाहूया
उपवास संबंधित याची खात्री करण्यासाठी आम्ही काय करू शकतो
CPU कार्यांना त्यांचा वेळ मिळेल (जरी लांब नसला तरी).
समस्येवर एक सोपा उपाय म्हणून, आपण वेळोवेळी सुचवू शकता
सिस्टममधील अशा सर्व कामांचे प्राधान्य वाढवा. अनेक मार्ग आहेत
हे साध्य करण्यासाठी, उदाहरण म्हणून काहीतरी सोपे अंमलात आणण्याचा प्रयत्न करूया: भाषांतर
सर्व कार्यांना त्वरित सर्वोच्च प्राधान्य दिले जाते, म्हणून नवीन नियम:

नियम 5: ठराविक कालावधीनंतर S, सिस्टममधील सर्व कार्ये सर्वोच्च रांगेत हलवा.

आमचा नवीन नियम एकाच वेळी दोन समस्या सोडवतो. प्रथम, प्रक्रिया
उपाशी राहणार नाही याची हमी आहे: सर्वोच्च प्राधान्य असलेली कामे विभागली जातील
RR अल्गोरिदमनुसार CPU वेळ आणि अशा प्रकारे सर्व प्रक्रिया प्राप्त होतील
CPU वेळ. दुसरे म्हणजे, जर पूर्वी वापरलेली काही प्रक्रिया
केवळ प्रोसेसर परस्परसंवादी बनतो, तो सर्वोच्च सह रांगेत राहील
सर्वोच्च ते प्राधान्याने एक-वेळ वाढ मिळाल्यानंतर प्राधान्य.
एक उदाहरण पाहू. या परिस्थितीत, वापरून एक प्रक्रिया विचारात घ्या

CPU आणि दोन परस्परसंवादी, लहान प्रक्रिया. आकृतीत डावीकडे, आकृती प्राधान्य प्रमोशनशिवाय वर्तन दर्शवते आणि अशा प्रकारे दोन परस्परसंवादी कार्ये सिस्टममध्ये आल्यानंतर दीर्घकाळ चालणारे कार्य उपाशी राहण्यास सुरवात होते. उजवीकडील आकृतीमध्ये, प्रत्येक 50ms मध्ये प्राधान्य वाढ केली जाते आणि अशा प्रकारे सर्व प्रक्रियांना CPU वेळ मिळण्याची हमी दिली जाते आणि वेळोवेळी लॉन्च केले जाईल. या प्रकरणात 50ms हे उदाहरण म्हणून घेतले जाते; प्रत्यक्षात ही संख्या थोडी जास्त आहे.
साहजिकच, नियतकालिक वाढीची वेळ जोडल्याने S ची वाढ होते
तार्किक प्रश्न: कोणते मूल्य सेट केले पाहिजे? सन्मानितांपैकी एक
सिस्टीम अभियंते जॉन ऑस्टरहाउट यांनी सिस्टीममधील अशा प्रमाणांना वू-डू म्हटले
स्थिर, कारण त्यांना काही प्रमाणात काळ्या जादूची गरज होती
प्रदर्शन करत आहे. आणि, दुर्दैवाने, 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 झाली जिथे कार्यांनी त्यांचे कार्य पूर्ण केले.

MLFQ ची Solaris OS अंमलबजावणी वेळ-सामायिकरण शेड्युलरचा एक वर्ग आहे.
प्लॅनर टेबलचा एक संच प्रदान करेल जे ते जसे पाहिजे तसे परिभाषित करतात
प्रक्रियेचे प्राधान्य त्याच्या आयुष्यादरम्यान बदलते, आकार काय असावा
वाटप केलेली विंडो आणि आपल्याला किती वेळा कार्य प्राधान्यक्रम वाढवण्याची आवश्यकता आहे. प्रशासक
प्रणाली या सारणीशी संवाद साधू शकतात आणि शेड्युलरला वर्तन करण्यास कारणीभूत ठरू शकतात
वेगळ्या पद्धतीने डीफॉल्टनुसार, या टेबलमध्ये हळूहळू वाढीसह 60 रांगा आहेत
खिडकीचा आकार 20ms (उच्च प्राधान्य) पासून कित्येक सौ ms (कमी प्राधान्य) पर्यंत, आणि
तसेच प्रत्येक सेकंदाला एकदा सर्व कार्यांच्या बूस्टसह.

इतर MLFQ नियोजक टेबल किंवा कोणतेही विशिष्ट वापरत नाहीत
या व्याख्यानात वर्णन केलेले नियम, त्याउलट, ते वापरून प्राधान्यक्रमांची गणना करतात
गणितीय सूत्रे. उदाहरणार्थ, फ्रीबीएसडी शेड्युलर यासाठी सूत्र वापरते
प्रक्रिया किती लांब आहे यावर आधारित कार्याच्या वर्तमान प्राधान्याची गणना करा
CPU वापरले. याव्यतिरिक्त, CPU वापर कालांतराने क्षय होतो, आणि त्यामुळे
अशाप्रकारे, वर वर्णन केलेल्या पेक्षा काहीसे वेगळे प्राधान्य वाढते. हे खरं आहे
क्षय अल्गोरिदम म्हणतात. आवृत्ती 7.1 पासून, FreeBSD ने ULE शेड्युलर वापरला आहे.

शेवटी, अनेक शेड्युलरमध्ये इतर वैशिष्ट्ये आहेत. उदाहरणार्थ, काही
शेड्युलर ऑपरेटिंग सिस्टमच्या ऑपरेशनसाठी सर्वोच्च स्तर राखून ठेवतात आणि अशा प्रकारे
अशा प्रकारे, कोणत्याही वापरकर्ता प्रक्रियेस सर्वोच्च प्राधान्य मिळू शकत नाही
प्रणाली काही प्रणाली तुम्हाला मदतीसाठी सल्ला देण्याची परवानगी देतात
नियोजक योग्यरित्या प्राधान्यक्रम सेट करू शकतो. उदाहरणार्थ, कमांड वापरणे छान
तुम्ही एखाद्या कार्याची प्राथमिकता वाढवू किंवा कमी करू शकता आणि अशा प्रकारे वाढवू शकता किंवा
CPU वेळ वापरण्याची प्रोग्रामची शक्यता कमी करा.

MLFQ: सारांश

आम्ही MLFQ नावाच्या नियोजन पद्धतीचे वर्णन केले आहे. त्याचे नाव
ऑपरेशनच्या तत्त्वामध्ये बंद - यात अनेक रांगा आहेत आणि अभिप्राय वापरतात
कार्य प्राधान्य निश्चित करण्यासाठी.
नियमांचे अंतिम स्वरूप खालीलप्रमाणे असेल.

नियम 1: जर प्राधान्य(A) > प्राधान्य(B), कार्य A लाँच केले जाईल (B नाही)
नियम 2: जर प्राधान्य(A) = प्राधान्य(B), A&B RR वापरून सुरू केले असेल
नियम 3: जेव्हा एखादे कार्य प्रणालीमध्ये प्रवेश करते, तेव्हा ते सर्वोच्च प्राधान्य रांगेत ठेवले जाते.
नियम 4: एखादे कार्य सध्याच्या रांगेत त्याचा वाटप केलेला वेळ वापरल्यानंतर (त्याने CPU कितीही वेळा मोकळे केले तरीही) त्या कार्याची प्राथमिकता कमी केली जाते (ते रांगेत खाली सरकते).
नियम 5: ठराविक कालावधीनंतर S, सिस्टममधील सर्व कार्ये सर्वोच्च रांगेत हलवा.

MLFQ खालील कारणास्तव मनोरंजक आहे - त्याऐवजी त्याबद्दल ज्ञान आवश्यक आहे
कार्याचे स्वरूप आगाऊ, अल्गोरिदम कार्याच्या मागील वर्तनाचा अभ्यास करते आणि सेट करते
त्यानुसार प्राधान्यक्रम. अशा प्रकारे, तो एकाच वेळी दोन खुर्च्यांवर बसण्याचा प्रयत्न करतो - छोट्या कामांसाठी (एसजेएफ, एसटीसीएफ) उत्पादकता मिळविण्यासाठी आणि प्रामाणिकपणे लांब धावण्यासाठी,
CPU-लोडिंग नोकर्‍या. म्हणून, बीएसडी आणि त्यांच्या डेरिव्हेटिव्ह्जसह अनेक प्रणाली,
सोलारिस, विंडोज, मॅक काही प्रकारचे अल्गोरिदम शेड्युलर म्हणून वापरतात
MLFQ बेसलाइन म्हणून.

अतिरिक्त साहित्य:

स्त्रोत: www.habr.com

ऑपरेटिंग सिस्टम: तीन सोपे तुकडे. भाग 5: नियोजन: बहु-स्तरीय फीडबॅक रांग (अनुवाद)