देखें: लिनक्स कर्नेल को समझना , डैनियल पी। बोवेट, मार्को सेसती द्वारा तीसरा संस्करण
- प्रकाशक: ओ'रेली
- पब की तारीख: नवंबर 2005
- आईएसबीएन: 0-596-00565-2
- पेज: 942
अपने परिचय में, डैनियल पी। बोवेट और मार्को सीसाती ने कहा:
तकनीकी रूप से बोलना, लिनक्स एक सच्चा यूनिक्स कर्नेल है, हालाँकि यह एक पूर्ण यूनिक्स ऑपरेटिंग सिस्टम नहीं है, क्योंकि इसमें फाइल सिस्टम यूटिलिटीज, विंडोिंग सिस्टम और ग्राफिकल डेस्कटॉप, सिस्टम एडमिनिस्ट्रेटर कमांड, टेक्स्ट एडिटर, कंपाइलर, और जैसे सभी अनुप्रयोग शामिल नहीं हैं। पर। आप इस पुस्तक को पढ़ते हैं और लिनक्स कर्नेल में देखते हैं, इसलिए, आपको अन्य यूनिक्स वेरिएंट को समझने में भी मदद मिल सकती है।
अगले पैराग्राफ में, मैं "लिनक्स कर्नेल को समझना" में प्रस्तुत तथ्यों को मेरी समझ के आधार पर आपके दृष्टिकोण को संबोधित करने का प्रयास करूंगा जो कि बहुत हद तक यूनिक्स में उन लोगों के समान हैं।
एक प्रक्रिया का क्या मतलब है? :
प्रक्रियाएं मनुष्य की तरह होती हैं, वे उत्पन्न होती हैं, उनके पास कम या ज्यादा महत्वपूर्ण जीवन होता है, वे वैकल्पिक रूप से एक या एक से अधिक बाल प्रक्रियाएं उत्पन्न करते हैं, और अंततः वे मर जाते हैं। एक प्रक्रिया में पाँच मूलभूत भाग होते हैं: कोड ("टेक्स्ट"), डेटा (VM), स्टैक, फ़ाइल I / O और सिग्नल टेबल
कर्नेल में एक प्रक्रिया का उद्देश्य एक इकाई के रूप में कार्य करना है जिसके लिए सिस्टम संसाधन (सीपीयू समय, मेमोरी, आदि) आवंटित किए जाते हैं। जब एक प्रक्रिया बनाई जाती है, तो यह लगभग अपने माता-पिता के समान होती है। यह माता-पिता के पते की जगह की एक तार्किक (तार्किक) प्रति प्राप्त करता है और प्रक्रिया निर्माण प्रणाली कॉल के बाद अगले निर्देश पर शुरुआत करते हुए माता-पिता के समान कोड निष्पादित करता है। यद्यपि माता-पिता और बच्चा प्रोग्राम कोड (टेक्स्ट) वाले पृष्ठों को साझा कर सकते हैं, उनके पास डेटा (स्टैक और हीप) की अलग-अलग प्रतियां हैं, ताकि बच्चे द्वारा मेमोरी स्थान में परिवर्तन माता-पिता के लिए अदृश्य हो (और इसके विपरीत) ।
कैसे काम करता है?
एक निष्पादन कार्यक्रम को केवल बाइनरी कोड से अधिक की आवश्यकता होती है जो कंप्यूटर को बताता है कि क्या करना है। कार्यक्रम को चलाने के लिए मेमोरी और विभिन्न ऑपरेटिंग सिस्टम संसाधनों की आवश्यकता होती है। एक "प्रक्रिया" वह है जिसे हम एक प्रोग्राम कहते हैं जिसे सभी संसाधनों के साथ मेमोरी में लोड किया गया है जिसे इसे संचालित करने की आवश्यकता है। एक धागा एक प्रक्रिया के भीतर निष्पादन की इकाई है। एक प्रक्रिया में सिर्फ एक धागे से लेकर कई धागे तक हो सकते हैं। जब कोई प्रक्रिया शुरू होती है, तो उसे स्मृति और संसाधन दिए जाते हैं। प्रक्रिया में प्रत्येक थ्रेड स्मृति और संसाधनों को साझा करता है। एकल-थ्रेडेड प्रक्रियाओं में, प्रक्रिया में एक थ्रेड होता है। प्रक्रिया और धागा एक है और एक ही है, और केवल एक चीज हो रही है। मल्टीथ्रेडेड प्रक्रियाओं में, प्रक्रिया में एक से अधिक थ्रेड होते हैं, और यह प्रक्रिया एक ही समय में कई चीजों को पूरा कर रही है।
एक बहु-प्रसंस्करण प्रणाली के यांत्रिकी, हल्के और भारी वजन प्रक्रियाओं में शामिल हैं:
एक हेवीवेट प्रक्रिया में, कई प्रक्रियाएं समानांतर में एक साथ चल रही हैं। समानांतर में प्रत्येक हैवीवेट प्रक्रिया का अपना मेमोरी एड्रेस स्पेस होता है। अंतर-प्रक्रिया संचार धीमा है क्योंकि प्रक्रियाओं में अलग-अलग मेमोरी पते हैं। प्रक्रियाओं के बीच संदर्भ स्विच करना अधिक महंगा है। प्रक्रियाएँ अन्य प्रक्रियाओं के साथ मेमोरी साझा नहीं करती हैं। इन प्रक्रियाओं के बीच संचार में अतिरिक्त संचार तंत्र शामिल होंगे जैसे सॉकेट या पाइप।
एक हल्की प्रक्रिया में, जिसे थ्रेड्स भी कहा जाता है। कार्यभार को साझा करने और विभाजित करने के लिए थ्रेड्स का उपयोग किया जाता है। थ्रेड्स उस प्रक्रिया की मेमोरी का उपयोग करते हैं जो वे संबंधित हैं। इंटर-थ्रेड कम्युनिकेशन अंतर-प्रक्रिया संचार की तुलना में तेज़ हो सकता है क्योंकि उसी प्रक्रिया के धागे उस प्रक्रिया के साथ मेमोरी साझा करते हैं जो वे संबंधित हैं। परिणामस्वरूप थ्रेड्स के बीच संचार बहुत सरल और कुशल है। एक ही प्रक्रिया के थ्रेड्स के बीच संदर्भ स्विच करना कम खर्चीला है। थ्रेड्स उसी प्रक्रिया के अन्य थ्रेड्स के साथ मेमोरी साझा करते हैं
थ्रेड्स दो प्रकार के होते हैं: उपयोगकर्ता-स्तरीय थ्रेड्स और कर्नेल-लेवल थ्रेड्स। उपयोगकर्ता-स्तरीय थ्रेड कर्नेल से बचते हैं और अपने आप पर काम का प्रबंधन करते हैं। उपयोगकर्ता-स्तरीय थ्रेड्स में एक समस्या होती है कि एक एकल थ्रेड समय स्लाइस को एकाधिकार कर सकता है और इस तरह अन्य थ्रेड्स को कार्य के भीतर भूखा कर सकता है। उपयोगकर्ता-स्तर के थ्रेड आमतौर पर उपयोगकर्ता स्थान में कर्नेल के ऊपर समर्थित होते हैं और कर्नेल समर्थन के बिना प्रबंधित होते हैं। कर्नेल उपयोगकर्ता-स्तरीय थ्रेड्स के बारे में कुछ नहीं जानता है और उन्हें प्रबंधित करता है जैसे कि वे एकल-थ्रेडेड प्रक्रियाएं थीं। जैसे, उपयोगकर्ता-स्तर के थ्रेड बहुत तेज़ होते हैं, यह कर्नेल थ्रेड्स की तुलना में 100X तेज़ संचालित होता है।
कर्नेल-स्तर के धागे अक्सर कर्नेल में कई कार्यों का उपयोग करके कार्यान्वित किए जाते हैं। इस मामले में, कर्नेल प्रत्येक थ्रेड को प्रत्येक प्रक्रिया के समय के भीतर निर्धारित करता है। यहाँ, चूंकि घड़ी की टिक स्विचिंग के समय को निर्धारित करेगी, इसलिए किसी कार्य को कार्य के भीतर अन्य थ्रेड्स से टाइमलाइन को हॉग करने की संभावना कम है। कर्नेल स्तर के थ्रेड्स ऑपरेटिंग सिस्टम द्वारा सीधे समर्थित और प्रबंधित किए जाते हैं। उपयोगकर्ता-स्तरीय थ्रेड और कर्नेल-स्तर थ्रेड्स के बीच का संबंध पूरी तरह से स्वतंत्र नहीं है, वास्तव में इन दोनों स्तरों के बीच एक बातचीत है। सामान्य तौर पर, उपयोगकर्ता-स्तरीय थ्रेड को चार मॉडलों में से एक का उपयोग करके लागू किया जा सकता है: कई-से-एक, एक-से-एक, कई-से-कई और दो-स्तरीय मॉडल। ये सभी मॉडल उपयोगकर्ता-स्तर के थ्रेड को कर्नेल-स्तर के थ्रेड्स में मैप करते हैं, और दोनों स्तरों के बीच अलग-अलग डिग्री में इंटरैक्शन का कारण बनते हैं।
थ्रेड्स बनाम प्रोसेस
- प्रोग्राम प्रोग्रामिंग कोड के टेक्स्ट फ़ाइल के रूप में शुरू होता है,
- कार्यक्रम को बाइनरी रूप में संकलित या व्याख्या किया गया है,
- कार्यक्रम को मेमोरी में लोड किया गया है,
- कार्यक्रम एक या अधिक चलने वाली प्रक्रिया बन जाता है।
- प्रक्रियाएं आम तौर पर एक दूसरे से स्वतंत्र होती हैं,
- जबकि थ्रेड्स एक प्रक्रिया के सबसेट के रूप में मौजूद हैं।
- थ्रेड प्रक्रियाओं की तुलना में एक दूसरे के साथ आसानी से संवाद कर सकते हैं,
- लेकिन थ्रेड्स एक ही प्रक्रिया में अन्य थ्रेड्स के कारण होने वाली समस्याओं के प्रति अधिक संवेदनशील होते हैं
संदर्भ:
लिनक्स कर्नेल को समझना, तीसरा संस्करण
अधिक 1 2 3 4 5
...............................................
अब, आइए इन सभी पदों को सरल करें ( यह पैराग्राफ मेरे दृष्टिकोण से है )। कर्नेल सॉफ्टवेयर और हार्डवेयर के बीच एक इंटरफेस है। दूसरे शब्दों में, कर्नेल मस्तिष्क की तरह कार्य करता है। यह आनुवंशिक सामग्री (यानी कोड और उसके डेरिवेटिव सॉफ्टवेयर), और शरीर प्रणालियों (यानी हार्डवेयर या मांसपेशियों) के बीच एक संबंध में हेरफेर करता है।
यह मस्तिष्क (यानी कर्नेल) प्रक्रियाओं को संकेत भेजता है जो तदनुसार कार्य करता है। इनमें से कुछ प्रक्रियाएं मांसपेशियों (यानी धागे) की तरह होती हैं, प्रत्येक मांसपेशी का अपना कार्य और कार्य होता है लेकिन वे सभी कार्यभार को पूरा करने के लिए एक साथ काम करते हैं। इन थ्रेड्स (यानी मांसपेशियों) के बीच संचार बहुत कुशल और सरल है, इसलिए वे अपनी नौकरी को आसानी से, जल्दी और प्रभावी ढंग से प्राप्त करते हैं। कुछ थ्रेड्स (यानी मांसपेशियां) उपयोगकर्ता के नियंत्रण में हैं (जैसे कि हमारे हाथ और पैर की मांसपेशियां)। अन्य मस्तिष्क नियंत्रण के अधीन हैं (जैसे हमारे पेट, आंख, हृदय की मांसपेशियां जो हम नियंत्रित नहीं करते हैं)।
उपयोगकर्ता-स्पेस थ्रेड कर्नेल से बचता है और कार्यों को स्वयं प्रबंधित करता है। अक्सर इसे "सहकारी मल्टीटास्किंग" कहा जाता है, और वास्तव में यह हमारे ऊपरी और निचले छोरों की तरह है, यह हमारे स्वयं के नियंत्रण में है और यह काम हासिल करने के लिए एक साथ काम करता है (यानी अभ्यास या ...) और इसके लिए सीधे आदेश की आवश्यकता नहीं है दिमाग। दूसरी तरफ, कर्नेल-स्पेस थ्रेड पूरी तरह से कर्नेल और इसके शेड्यूलर द्वारा नियंत्रित होते हैं।
...............................................
आपके सवालों के जवाब में:
क्या एक प्रक्रिया हमेशा एक या अधिक हल्के वजन प्रक्रियाओं के आधार पर लागू की जाती है? चित्र 3.4 हां कहता है। चित्र 3.5 (क) सीपीयू के शीर्ष पर सीधे प्रक्रियाओं को क्यों दिखाता है?
हां, थ्रेड्स और हेवीवेट प्रक्रियाओं नामक हल्की प्रक्रियाएं होती हैं।
एक हेवीवेट प्रक्रिया (आप इसे सिग्नल थ्रेड प्रक्रिया कह सकते हैं) को प्रोसेसर को अपने निष्पादन का आदेश देने के लिए अधिक कार्य करने की आवश्यकता होती है, यही कारण है कि चित्र 3.5 (ए) सीपीयू के शीर्ष पर सीधे प्रक्रियाओं को दिखाता है।
क्या एक हल्के वजन की प्रक्रिया हमेशा कर्नेल धागे के आधार पर लागू की जाती है? चित्र 3.4 हां कहता है। चित्रा 3.5 (बी) प्रक्रियाओं के शीर्ष पर सीधे हल्के वजन प्रक्रियाओं को क्यों दिखाता है?
नहीं, हल्के वजन की प्रक्रियाओं को दो श्रेणियों में विभाजित किया गया है: उपयोगकर्ता-स्तर और कर्नेल-स्तरीय प्रक्रियाएं, जैसा कि ऊपर बताया गया है। उपयोगकर्ता-स्तरीय प्रक्रिया अपने कार्यों को संसाधित करने के लिए अपने स्वयं के पुस्तकालय पर निर्भर करती है। कर्नेल ही कर्नेल-स्तरीय प्रक्रिया को शेड्यूल करता है। उपयोगकर्ता स्तर के धागे को चार मॉडल में से एक का उपयोग करके लागू किया जा सकता है: कई-से-एक, एक-एक, कई-से-कई और दो-स्तर। सभी, ये मॉडल उपयोगकर्ता-स्तरीय थ्रेड को कर्नेल-स्तर थ्रेड्स में मैप करते हैं।
क्या कर्नेल थ्रेड्स केवल शेड्यूल किए जाने योग्य हैं?
नहीं, कर्नेल-स्तर के धागे, कर्नेल द्वारा ही बनाए जाते हैं। वे उपयोगकर्ता-स्तरीय थ्रेड्स से इस तथ्य में भिन्न होते हैं कि कर्नेल-स्तर के थ्रेड्स में एक सीमित पता स्थान नहीं है। वे पूरी तरह से कर्नेल-स्पेस में रहते हैं, कभी भी उपयोगकर्ता-भूमि के दायरे में नहीं जाते। हालांकि, वे पूरी तरह से शेड्यूल करने योग्य और प्रीमिटेबल इकाइयां हैं, सामान्य प्रक्रियाओं की तरह (ध्यान दें: महत्वपूर्ण कर्नेल क्रियाओं के लिए लगभग सभी व्यवधानों को अक्षम करना संभव है)। कर्नेल के अपने थ्रेड्स का उद्देश्य मुख्य रूप से सिस्टम पर रखरखाव कर्तव्यों का पालन करना है। केवल कर्नेल एक कर्नेल थ्रेड को शुरू या रोक सकता है। दूसरी तरफ, उपयोगकर्ता-स्तरीय प्रक्रिया स्वयं के आधार पर अनुसूची कर सकती है, यह स्वयं की लाइब्रेरी है और साथ ही इसे दो-स्तरीय और कई-से-कई मॉडल (ऊपर उल्लेखित) के आधार पर कर्नेल द्वारा शेड्यूल किया जा सकता है।
क्या हल्के वजन प्रक्रियाएं केवल अंतर्निहित कर्नेल थ्रेड्स को शेड्यूल करने के माध्यम से अप्रत्यक्ष रूप से निर्धारित हैं?
कर्नेल थ्रेड्स को कर्नेल शेड्यूलर द्वारा ही नियंत्रित किया जाता है। उपयोगकर्ता स्तर पर थ्रेडिंग का समर्थन करने का अर्थ है कि एक उपयोगकर्ता स्तर लाइब्रेरी है जो एप्लिकेशन के साथ जुड़ा हुआ है और यह लाइब्रेरी (सीपीयू नहीं) थ्रेड्स के लिए रनटाइम समर्थन में प्रबंधन के सभी प्रदान करता है। यह थ्रेड एब्स्ट्रक्शन को लागू करने के लिए आवश्यक डेटा संरचनाओं का समर्थन करेगा और इन थ्रेड्स के लिए संसाधन प्रबंधन निर्णय लेने के लिए आवश्यक सभी शेड्यूलिंग सिंक्रनाइज़ेशन और अन्य तंत्र प्रदान करेगा। अब, कुछ उपयोगकर्ता स्तर थ्रेड प्रक्रियाओं को अंतर्निहित कर्नेल स्तर थ्रेड्स में मैप किया जा सकता है और इसमें एक-से-एक, एक-से-कई और कई-से-कई मैपिंग शामिल हैं।
अंतर्निहित हल्की प्रक्रियाओं को शेड्यूल करने के माध्यम से क्या प्रक्रियाएं केवल अप्रत्यक्ष रूप से निर्धारित हैं?
यह इस बात पर निर्भर करता है कि यह एक भारी वजन या हल्की प्रक्रिया है। भारी कर्नेल द्वारा ही निर्धारित प्रक्रियाएं हैं। प्रकाश प्रक्रिया को कर्नेल स्तर और उपयोगकर्ता स्तर पर प्रबंधित किया जा सकता है।
