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

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

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

• मूल
• मूल
• मेरा व्यक्तिगत अनुकूलन

अन्य भागों:

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

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

Alyarm! इस व्याख्यान के लिए एक प्रयोगशाला है! जीथब देखें

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

UNIX सिस्टम पर एक प्रक्रिया बनाने के एक उदाहरण पर विचार करें। यह दो सिस्टम कॉल फोर्क () और एक्जीक्यूट () के माध्यम से होता है।

कांटा () कॉल

एक कार्यक्रम पर विचार करें जो एक कांटा () कॉल करता है। इसके कार्यान्वयन का परिणाम निम्नानुसार होगा।



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

कॉल प्रतीक्षा ()

निम्नलिखित कार्यक्रम पर विचार करें। इस कार्यक्रम में, प्रतीक्षा () कॉल की उपस्थिति के कारण, अभिभावक प्रक्रिया हमेशा अपने काम को पूरा करने के लिए बच्चे की प्रक्रिया की प्रतीक्षा करेगी। इस मामले में, हमें स्क्रीन पर एक सख्ती से परिभाषित पाठ आउटपुट मिलता है।

कॉल निष्पादन ()

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

लॉन्च करने की यह जटिलता यूनिक्स शेल के लिए बिल्कुल सामान्य है, और इस शेल को फोर्क () कॉल करने के बाद कोड निष्पादित करने की अनुमति देता है, लेकिन निष्पादन कॉल करने से पहले () । इस तरह के कोड का एक उदाहरण सीधे लॉन्च किए जाने से पहले, कार्यक्रम की जरूरतों को खोल के पर्यावरण को समायोजित कर सकता है।

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

अलग कांटा () और निष्पादन () शेल को निम्न चीजों को करने की अनुमति देता है, उदाहरण के लिए:
wc फ़ाइल> new_file।

इस उदाहरण में, wc से आउटपुट को किसी फ़ाइल में रीडायरेक्ट किया जाता है। जिस तरह से शेल प्राप्त होता है वह काफी सरल है - निष्पादन को कॉल करने से पहले एक बच्चे की प्रक्रिया बनाते समय () , शेल मानक आउटपुट स्ट्रीम को बंद कर देता है और new_file फ़ाइल को खोलता है, इसलिए प्रारंभ किए गए wc प्रोग्राम से सभी आउटपुट स्क्रीन के बजाय फ़ाइल पर रीडायरेक्ट किए जाएंगे।

यूनिक्स पाइप को एक समान तरीके से लागू किया जाता है, इस अंतर के साथ कि वे पाइप () कॉल का उपयोग करते हैं। इस मामले में, प्रक्रिया की आउटपुट स्ट्रीम कर्नेल में स्थित पाइप कतार से जुड़ी होगी, जिसमें किसी अन्य प्रक्रिया का इनपुट स्ट्रीम संलग्न किया जाएगा।