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

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

इस विषय पर लैब का काम यहां पाया जा सकता है:

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

अन्य भागों:

• भाग 1: परिचय

आप मेरा चैनल पर भी देख सकते हैं तार =)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

प्रक्रिया अवस्था

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

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

निम्नलिखित उदाहरण में, पहली प्रक्रिया, कुछ समय चलने के बाद, IO से अनुरोध करती है और अवरुद्ध स्थिति में प्रवेश करती है, जिससे दूसरी प्रक्रिया चलने की अनुमति मिलती है (चित्र 1.4)। ओएस देखता है कि प्रक्रिया 0 सीपीयू का उपयोग नहीं कर रही है और प्रक्रिया 1 शुरू करती है। जबकि प्रक्रिया 1 चल रही है, आईओ पूरा हो गया है और प्रक्रिया 0 की स्थिति तैयार में बदल जाती है। अंत में, प्रक्रिया 1 पूरी हो गई है, और पूरा होने पर, प्रक्रिया 0 अपना काम शुरू करती है, निष्पादित करती है और समाप्त करती है।

डेटा संरचना

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

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

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

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

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

स्रोत: www.habr.com