ऑपरेटिंग सिस्टम का परिचय

नमस्कार, हेब्र! मैं आपके ध्यान में एक दिलचस्प साहित्य के लेख-अनुवाद की एक श्रंखला लाना चाहता हूं - OSTEP। यह लेख यूनिक्स जैसे ऑपरेटिंग सिस्टम के काम पर गहराई से चर्चा करता है, अर्थात्, प्रक्रियाओं के साथ काम करते हैं, विभिन्न शेड्यूलर, मेमोरी, और अन्य समान घटक जो आधुनिक ओएस बनाते हैं। सभी सामग्रियों का मूल आप यहां देख सकते हैं। कृपया ध्यान दें कि अनुवाद अनप्रोफेशनली (काफी स्वतंत्र रूप से) किया गया था, लेकिन मुझे आशा है कि मैंने सामान्य अर्थ को बरकरार रखा।

इस विषय पर प्रयोगशाला का काम यहां पाया जा सकता है:

• मूल: Pages.cs.wisc.edu/~remzi/OSTEP/Homework/homework.html
• मूल: github.com/remzi-arpacidusseau/ostep-code
• मेरा व्यक्तिगत अनुकूलन: github.com/bykvaadm/OS/tree/master/ostep
• भाग 3: अनुसूचक का परिचय

अन्य भागों:

• भाग 1: परिचय
• भाग 2: अमूर्त: प्रक्रिया
• भाग 3: प्रक्रिया एपीआई का परिचय
• भाग 4: अनुसूचक का परिचय
• भाग 5: MLFQ समयबद्धक

और आप टेलीग्राम में मेरे चैनल को देख सकते हैं =)


सबसे मौलिक अमूर्तता पर विचार करें जो ओएस उपयोगकर्ताओं को प्रदान करता है: एक प्रक्रिया। एक प्रक्रिया को परिभाषित करना बहुत सरल है - यह एक कार्यशील कार्यक्रम है । कार्यक्रम स्वयं डिस्क पर स्थित एक बेजान चीज़ है - यह निर्देशों का एक सेट है और संभवतः किसी प्रकार का स्थैतिक डेटा लॉन्च होने की प्रतीक्षा कर रहा है। यह ओएस है जो इन बाइट्स को लेता है और उन्हें लॉन्च करता है, प्रोग्राम को कुछ उपयोगी में परिवर्तित करता है।
सबसे अधिक बार, उपयोगकर्ता एक समय में एक से अधिक प्रोग्राम चलाना चाहते हैं, उदाहरण के लिए, आप अपने लैपटॉप पर एक ब्राउज़र, गेम, मीडिया प्लेयर, टेक्स्ट एडिटर और जैसे चला सकते हैं। वास्तव में, एक विशिष्ट प्रणाली दसियों और सैकड़ों प्रक्रियाओं को एक साथ चला सकती है। यह तथ्य सिस्टम को उपयोग करना आसान बनाता है, आपको इस बात की चिंता कभी नहीं करनी चाहिए कि क्या सीपीयू मुफ्त है, आप सिर्फ प्रोग्राम चलाते हैं।

यह समस्या उठाता है: कई सीपीयू का भ्रम कैसे प्रदान करें? ओएस लगभग सीपीयू की अनंत राशि का भ्रम कैसे पैदा करता है, भले ही आपके पास केवल एक भौतिक सीपीयू हो?

सीपीयू वर्चुअलाइजेशन के माध्यम से ओएस इस भ्रम को बनाता है। एक प्रक्रिया शुरू करके, फिर इसे रोकना, एक और प्रक्रिया शुरू करना, और इसी तरह, ओएस इस भ्रम का समर्थन कर सकता है कि कई आभासी सीपीयू हैं, हालांकि वास्तव में यह एक या एक से अधिक भौतिक प्रोसेसर होगा। इस तकनीक को सीपीयू टाइम शेयरिंग कहा जाता है। यह तकनीक उपयोगकर्ताओं को जितनी चाहें उतनी प्रक्रियाओं को चलाने की अनुमति देती है। इस तरह के समाधान की लागत प्रदर्शन है - क्योंकि अगर सीपीयू कई प्रक्रियाओं द्वारा साझा किया जाता है, तो प्रत्येक प्रक्रिया को और अधिक धीरे-धीरे संसाधित किया जाएगा।
सीपीयू वर्चुअलाइजेशन को कार्यान्वित करने के लिए, और विशेष रूप से इसे अच्छी तरह से करने के लिए, ओएस को निम्न-स्तर और उच्च-स्तर दोनों का समर्थन चाहिए। निम्न-स्तरीय समर्थन को तंत्र कहा जाता है - ये निम्न-स्तर के तरीके या प्रोटोकॉल हैं जो कार्यक्षमता के आवश्यक हिस्से को लागू करते हैं। ऐसी कार्यक्षमता का एक उदाहरण संदर्भ स्विचिंग है, जो ओएस को एक प्रोग्राम को रोकने और प्रोसेसर पर एक और प्रोग्राम चलाने की क्षमता देता है। यह समय विभाजन सभी आधुनिक ऑपरेटिंग सिस्टमों में लागू किया गया है।
इन तंत्रों में सबसे ऊपर ओएस में कुछ तर्क-वितर्क हैं, जो "नीतियों" के रूप में हैं। ऑपरेटिंग सिस्टम द्वारा एक नीति एक निश्चित निर्णय लेने वाली एल्गोरिथ्म है। उदाहरण के लिए, ऐसे राजनेता तय करते हैं कि कौन सा कार्यक्रम (कमांड की सूची से) पहली बार में चलाया जाए। इसलिए, उदाहरण के लिए, एक शेड्यूलिंग नीति नामक नीति इस समस्या को हल करेगी और समाधान चुनते समय इसे ऐसे डेटा द्वारा निर्देशित किया जाएगा: स्टार्टअप इतिहास (अंतिम समय में कौन सा कार्यक्रम सबसे लंबे समय तक चल रहा है), इस प्रक्रिया को किस तरह के भार से चलाया जाता है (किस प्रकार के प्रोग्राम लॉन्च किए गए थे ), प्रदर्शन मेट्रिक्स (क्या सिस्टम इंटरएक्टिव बातचीत के लिए या बैंडविड्थ के लिए अनुकूलित है) और इसी तरह।

अमूर्त: प्रक्रिया

ऑपरेटिंग सिस्टम द्वारा निष्पादित एक चल रहे कार्यक्रम का अमूर्त है जिसे हम एक प्रक्रिया कहते हैं । जैसा कि पहले उल्लेख किया गया है, एक प्रक्रिया बस एक कार्यशील कार्यक्रम है, किसी भी तात्कालिक समय पर। एक प्रोग्राम जिसकी मदद से हम सिस्टम के विभिन्न संसाधनों से सारांश जानकारी प्राप्त कर सकते हैं, और जिस पर यह प्रोग्राम पता करता है या जो इसके निष्पादन के दौरान प्रभावित होता है।
प्रक्रिया के घटकों को समझने के लिए, आपको सिस्टम की स्थिति को समझने की आवश्यकता है: कि कार्यक्रम इसके संचालन के दौरान पढ़ सकता है या बदल सकता है। किसी भी समय, आपको यह समझने की आवश्यकता है कि प्रोग्राम निष्पादन के लिए सिस्टम के कौन से तत्व महत्वपूर्ण हैं।
सिस्टम की स्थिति के स्पष्ट तत्वों में से एक है जिसमें प्रक्रिया शामिल है स्मृति है । निर्देश स्मृति में हैं। प्रोग्राम जो डेटा पढ़ता है या लिखता है वह मेमोरी में स्थित होता है। इस प्रकार, स्मृति जो प्रक्रिया को संबोधित कर सकती है (तथाकथित पता स्थान) प्रक्रिया का हिस्सा है।
रजिस्टर भी सिस्टम की स्थिति का हिस्सा हैं। बहुत सारे निर्देश रजिस्टरों के अर्थ को बदलने या उनके अर्थ को पढ़ने के उद्देश्य से हैं, और इस प्रकार रजिस्टरों भी प्रक्रिया का एक महत्वपूर्ण हिस्सा बन जाते हैं।
यह ध्यान दिया जाना चाहिए कि मशीन का राज्य कुछ विशेष रजिस्टरों से भी बनता है। उदाहरण के लिए, आईपी ​​- इंस्ट्रक्शन पॉइंटर - निर्देश का एक पाइंटर जो प्रोग्राम वर्तमान में निष्पादित कर रहा है। एक स्टैक पॉइंटर और संबंधित फ़्रेम पॉइंटर भी है , जिसका उपयोग नियंत्रण करने के लिए किया जाता है: फ़ंक्शन पैरामीटर, स्थानीय चर और वापसी पते।
अंत में, प्रोग्राम अक्सर रॉम (केवल पढ़ने के लिए मेमोरी) तक पहुंचते हैं। "I / O" (इनपुट-आउटपुट) के बारे में ऐसी जानकारी में वर्तमान में प्रक्रिया द्वारा खोली गई फ़ाइलों की एक सूची शामिल होनी चाहिए।

प्रक्रिया एपीआई

प्रक्रिया की समझ में सुधार करने के लिए, आइए हम सिस्टम कॉल के उदाहरणों की जांच करें जिन्हें ऑपरेटिंग सिस्टम के किसी भी इंटरफ़ेस में शामिल किया जाना चाहिए। एक या दूसरे रूप में ये एपीआई किसी भी ओएस पर उपलब्ध हैं।

● बनाएँ : OS में कुछ विधि शामिल होनी चाहिए जो आपको नई प्रक्रियाएँ बनाने की अनुमति देती है। जब आप टर्मिनल में एक कमांड दर्ज करते हैं या आइकन पर डबल-क्लिक करके एप्लिकेशन लॉन्च करते हैं, तो एक ओएस को एक नई प्रक्रिया बनाने और फिर निर्दिष्ट प्रोग्राम लॉन्च करने के लिए एक अपील भेजी जाती है।
● विलोपन : एक बार एक प्रक्रिया बनाने के लिए एक इंटरफ़ेस है, ओएस को एक प्रक्रिया को हटाने के लिए मजबूर करने की क्षमता भी प्रदान करनी चाहिए। अधिकांश कार्यक्रमों को स्वाभाविक रूप से लॉन्च और पूरा किया जाएगा क्योंकि वे निष्पादित होते हैं। अन्यथा, उपयोगकर्ता उन्हें मारने में सक्षम होना चाहते हैं, और इस प्रकार प्रक्रिया को रोकने के लिए इंटरफ़ेस शानदार नहीं होगा।
● प्रतीक्षा करें : प्रक्रिया को पूरा करने के लिए इंतजार करना कभी-कभी उपयोगी होता है, इसलिए कुछ इंटरफेस प्रदान किए जाते हैं जो प्रतीक्षा करने की क्षमता प्रदान करते हैं।
● विविध नियंत्रण (विविध नियंत्रण): प्रक्रिया को मारने और इंतजार करने के अलावा, कई अन्य नियंत्रण विधियां हैं। उदाहरण के लिए, अधिकांश ऑपरेटिंग सिस्टम एक प्रक्रिया को स्थिर करने की क्षमता प्रदान करते हैं (एक निश्चित अवधि के लिए इसे रोकें) और फिर इसे फिर से शुरू करें (निष्पादन जारी रखें)
● स्थिति : प्रक्रिया की स्थिति के बारे में कुछ जानकारी प्राप्त करने के लिए विभिन्न इंटरफेस हैं, जैसे कि इसके संचालन की अवधि या यह अब किस अवस्था में है।

प्रक्रिया निर्माण: विवरण

दिलचस्प चीजों में से एक यह है कि कार्यक्रमों को प्रक्रियाओं में कैसे बदला जाता है। विशेष रूप से ओएस कैसे उठाता है और कार्यक्रम चलाता है। प्रक्रिया कैसे बनाई जाती है।
सबसे पहले, ओएस को प्रोग्राम कोड और स्थिर डेटा को मेमोरी में लोड करना होगा (प्रोसेस एड्रेस स्पेस में)। कार्यक्रम आमतौर पर डिस्क पर या कुछ निष्पादन योग्य प्रारूप में एक ठोस राज्य ड्राइव में स्थित होते हैं। इस प्रकार, प्रोग्राम और मेमोरी में स्टैटिक डेटा लोड करने की प्रक्रिया के लिए ओएस को डिस्क से इन बाइट्स को पढ़ने और उन्हें मेमोरी में कहीं रखने की आवश्यकता होती है।

शुरुआती ओएस में, बूट प्रक्रिया को उत्सुकता से निष्पादित किया गया था, जिसका अर्थ है कि प्रोग्राम शुरू होने से पहले कोड को पूरी तरह से मेमोरी में लोड किया गया था। आधुनिक ओएस इस आलसी को करते हैं, अर्थात, कोड या डेटा के टुकड़ों को केवल तब लोड करते हैं जब उन्हें इसके निष्पादन के दौरान कार्यक्रम की आवश्यकता होती है।

कोड और स्थिर डेटा को OS की मेमोरी में लोड करने के बाद, आपको प्रक्रिया शुरू करने से पहले कुछ और चीजें करने की जरूरत है। स्टैक के लिए एक निश्चित मात्रा में मेमोरी आवंटित की जानी चाहिए। प्रोग्राम स्थानीय चर, फ़ंक्शन पैरामीटर और रिटर्न एड्रेस के लिए स्टैक का उपयोग करते हैं । ओएस इस मेमोरी को आवंटित करता है और इसे प्रक्रिया को देता है। स्टैक को कुछ तर्कों के साथ भी आवंटित किया जा सकता है, विशेष रूप से यह मुख्य () फ़ंक्शन के मापदंडों को भरता है, उदाहरण के लिए, argc और argv सरणी के साथ।

ऑपरेटिंग सिस्टम प्रोग्राम के ढेर के लिए एक निश्चित मात्रा में मेमोरी भी आवंटित कर सकता है। ढेर का उपयोग प्रोग्राम द्वारा गतिशील रूप से आवंटित डेटा के लिए किया जाता है । कार्यक्रम इस स्पेस को मॉलोक () फ़ंक्शन को कॉल करके और निशुल्क () फ़ंक्शन को कॉल करके स्पष्ट रूप से स्पष्ट करने का अनुरोध करते हैं। लिंक शीट, हैश टेबल, पेड़, और अन्य जैसे डेटा संरचनाओं के लिए एक ढेर की आवश्यकता है। सबसे पहले, मेमोरी की एक छोटी मात्रा को ढेर के नीचे आवंटित किया जाता है, लेकिन समय के साथ, कार्यक्रम के संचालन के दौरान, लाइब्रेरी लाइब्रेरी एपीआई कॉल मॉलोक () के माध्यम से अधिक मेमोरी का अनुरोध कर सकता है। ऑपरेटिंग सिस्टम इन चुनौतियों को पूरा करने में मदद करने के लिए अधिक मेमोरी आवंटित करने की प्रक्रिया में शामिल है।

ऑपरेटिंग सिस्टम इनिशियलाइज़ेशन कार्य भी करेगा, विशेष रूप से I / O से संबंधित। उदाहरण के लिए, UNIX सिस्टम पर, प्रत्येक प्रक्रिया में मानक इनपुट, आउटपुट और त्रुटि प्रवाह के लिए डिफ़ॉल्ट रूप से 3 ओपन फ़ाइल डिस्क्रिप्टर होते हैं। ये वर्णनकर्ता प्रोग्राम को टर्मिनल से इनपुट पढ़ने के लिए अनुमति देते हैं, साथ ही स्क्रीन पर जानकारी भी प्रदर्शित करते हैं।

इस प्रकार, मेमोरी में कोड और स्टैटिक डेटा लोड करना, स्टैक बनाना और शुरू करना, और I / O कार्यों के निष्पादन से संबंधित अन्य कार्य करना, OS प्रक्रिया के लिए साइट तैयार करता है। अंत में, अंतिम कार्य शेष है: अपने प्रवेश बिंदु के माध्यम से कार्यक्रम को चलाने के लिए, मुख्य () फ़ंक्शन कहा जाता है। मुख्य () फ़ंक्शन के लिए आगे बढ़ते हुए, ओएस सीपीयू नियंत्रण को नई बनाई गई प्रक्रिया में स्थानांतरित करता है, इसलिए प्रोग्राम चलना शुरू हो जाता है।

प्रक्रिया की स्थिति

अब जब हम समझ गए हैं कि एक प्रक्रिया क्या है और इसे कैसे बनाया जाता है, तो हम उस प्रक्रिया के राज्यों को सूचीबद्ध करते हैं जिसमें यह हो सकता है। अपने सरलतम रूप में, एक प्रक्रिया इन राज्यों में से एक में हो सकती है:
● चल रहा है । रनिंग अवस्था में, प्रोसेस प्रोसेसर पर चलता है। इसका मतलब है कि निर्देशों को निष्पादित किया जा रहा है।
● तैयार है । एक तैयार स्थिति में, प्रक्रिया शुरू करने के लिए तैयार है, लेकिन किसी कारण से, ओएस इसे किसी निश्चित समय पर निष्पादित नहीं करता है।
● अवरुद्ध । एक बंद अवस्था में, प्रक्रिया कुछ ऑपरेशन करती है जो इसे तब तक क्रियान्वित होने से रोकती है जब तक कि कोई घटना नहीं हो जाती। एक सामान्य उदाहरण यह है कि जब कोई प्रक्रिया एक IO ऑपरेशन शुरू करती है, तो यह अवरुद्ध हो जाता है और इसलिए कुछ अन्य प्रक्रिया प्रोसेसर का उपयोग कर सकती है।



आप ग्राफ के रूप में इन राज्यों की कल्पना कर सकते हैं। जैसा कि हम तस्वीर में देख सकते हैं, ओएस के विवेक पर रेनिंग और आरएडीवाई के बीच प्रक्रिया की स्थिति बदल सकती है। जब किसी प्रक्रिया की स्थिति READY से RUNNING में बदल जाती है, तो इसका मतलब है कि प्रक्रिया निर्धारित हो गई है। विपरीत दिशा में - लेआउट से हटा दिया गया। उस समय जब प्रक्रिया ब्लॉक हो जाती है, उदाहरण के लिए, मैं एक IO ऑपरेशन शुरू करता हूं, OS इसे इस स्थिति में रखेगा जब तक कि कुछ घटना नहीं होती है, उदाहरण के लिए, IO का पूरा होना। इस समय, READY राज्य में संक्रमण और संभवतः RUNNING राज्य में तुरंत, यदि OS ऐसा तय करता है।
आइए एक उदाहरण देखें कि इन राज्यों में दो प्रक्रियाएं कैसे होती हैं। सबसे पहले, कल्पना करें कि दोनों प्रक्रियाएं चल रही हैं, और प्रत्येक केवल सीपीयू का उपयोग करता है। इस मामले में, उनके राज्य निम्नानुसार होंगे।



निम्नलिखित उदाहरण में, थोड़ी देर के बाद, पहली प्रक्रिया एक IO का अनुरोध करती है और BLOCKED अवस्था में प्रवेश करती है, दूसरी प्रक्रिया को शुरू करने की क्षमता देती है (FIG। 1.4)। OS देखता है कि प्रक्रिया 0 CPU का उपयोग नहीं करती है और प्रक्रिया 1 शुरू करती है। प्रक्रिया 1 के निष्पादन के दौरान - IO समाप्त होता है और प्रक्रिया 0 की स्थिति READY में बदल जाती है। अंत में, प्रक्रिया 1 पूरी हो गई है, और इसके अंत में, प्रक्रिया 0 शुरू होती है, निष्पादित होती है, और अपना काम समाप्त करती है।

डेटा संरचना

ओएस खुद एक कार्यक्रम है, और किसी भी अन्य कार्यक्रम की तरह, इसमें कुछ महत्वपूर्ण डेटा संरचनाएं हैं जो विभिन्न प्रकार की प्रासंगिक जानकारी को ट्रैक करती हैं। ओएस में प्रत्येक प्रक्रिया की स्थिति को ट्रैक करने के लिए, READY राज्य में सभी प्रक्रियाओं के लिए एक निश्चित प्रक्रिया सूची और वर्तमान में चल रही प्रक्रियाओं पर नज़र रखने के लिए कुछ अतिरिक्त जानकारी का समर्थन किया जाएगा। साथ ही, OS को प्रक्रियाओं को ट्रैक और ब्लॉक करना होगा। IO पूरा करने के बाद, OS को वांछित प्रक्रिया को जगाना चाहिए और इसे लॉन्च करने के लिए तत्परता की स्थिति में रखना चाहिए।

इसलिए, उदाहरण के लिए, ओएस को प्रोसेसर रजिस्टरों की स्थिति को बचाना होगा। फिलहाल प्रक्रिया को रोक दिया जाता है, रजिस्टरों की स्थिति प्रक्रिया के पते स्थान में सहेजी जाती है, और इसकी निरंतरता के समय, रजिस्टरों के मूल्यों को पुनर्स्थापित करना संभव होता है और इस प्रकार यह प्रक्रिया जारी रहती है।

तैयार, अवरुद्ध, चल रहे राज्यों के अलावा, कुछ अन्य राज्य भी हैं। कभी-कभी, निर्माण के समय, एक प्रक्रिया में एक INIT राज्य हो सकता है। अंत में, एक प्रक्रिया को अंतिम राज्य में रखा जा सकता है जब यह पहले ही पूरा हो चुका है, लेकिन इसके बारे में जानकारी अभी तक साफ नहीं की गई है। UNIX प्रणालियों पर, इस राज्य को एक ज़ोंबी प्रक्रिया कहा जाता है । यह स्थिति उन मामलों के लिए उपयोगी होती है जब मूल प्रक्रिया वंशज का रिटर्न कोड जानना चाहती है, उदाहरण के लिए, आमतौर पर 0 सफल समापन को इंगित करता है, और 1 एक त्रुटि को इंगित करता है, लेकिन प्रोग्रामर अतिरिक्त आउटपुट कोड बना सकते हैं, विभिन्न समस्याओं का संकेत देते हैं। पूरा होने पर, मूल प्रक्रिया अंतिम सिस्टम कॉल करती है, उदाहरण के लिए, प्रतीक्षा करें (), ओएस को पूरा करने और संकेत देने के लिए वंश प्रक्रिया का इंतजार करने के लिए कि पूरी प्रक्रिया से जुड़े किसी भी डेटा को साफ किया जा सकता है।

व्याख्यान के मुख्य बिंदु:

● प्रक्रिया - ओएस में एक चल रहे कार्यक्रम का मुख्य अमूर्त। किसी भी समय, एक प्रक्रिया का वर्णन इसके राज्य द्वारा किया जा सकता है: इसके पते की जगह में मेमोरी की सामग्री, प्रोसेसर के रजिस्टरों की सामग्री, जिसमें इंस्ट्रक्टर पॉइंटर और स्टैक पॉइंटर भी शामिल हैं, IO के बारे में जानकारी के साथ, उदाहरण के लिए, खुली हुई फाइलें जो पढ़ी या लिखी गई हैं।
● प्रोसेस एपीआई में ऐसे कॉल होते हैं जो प्रोग्राम प्रक्रियाओं के संबंध में कर सकते हैं। आमतौर पर ये कॉल, बनाने, हटाने या अन्य करने के लिए होते हैं।
● एक प्रक्रिया कई राज्यों में से एक में है, जिसमें रनिंग, रेडी, ब्लॉक किया गया है। विभिन्न आयोजन, जैसे नियोजन, योजना से बहिष्करण, या अपेक्षाएँ, एक प्रक्रिया की स्थिति को एक से दूसरे में अनुवाद कर सकते हैं।
● प्रक्रिया सूची में सिस्टम की सभी प्रक्रियाओं के बारे में जानकारी है। इसमें प्रत्येक प्रविष्टि को एक प्रक्रिया नियंत्रण ब्लॉक कहा जाता है, जो वास्तव में एक संरचना है जिसमें किसी विशेष प्रक्रिया के बारे में सभी आवश्यक जानकारी होती है।