मल्टीप्लेक्स इनपुट / आउटपुट

प्रस्तावना

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

निम्नलिखित लक्ष्यों का पीछा किया जाता है:

1. इस क्षेत्र में सामग्री को व्यवस्थित करने के लिए, शब्दावली में कुछ विसंगतियों पर चर्चा करें
2. नींव को पूरी तरह से अलग करना जिस पर कई ग्राहक सेवा एप्लिकेशन बनाए गए हैं।
3. भविष्य के अजगर आवेदन के लिए एक रणनीति विकसित करें जिसे कई ग्राहकों की सेवा करनी चाहिए
4. अपने सिर में एक स्पष्ट चित्र बनाएं (यह बिना कारण के कि वे कहते हैं कि आप समझते हैं - जब आप समझा सकते हैं)

क्यों?

PHP प्रोग्रामिंग के वर्षों ने भुगतान किया है - मैंने कभी नहीं सोचा कि पर्दे के पीछे क्या चल रहा था। लेकिन जब परियोजनाएं धीमी गति से शुरू हुईं, लेकिन निश्चित रूप से धीमी हो गईं - मैंने फैसला किया कि यह मन को लेने का समय था और अजगर का अध्ययन करना शुरू कर दिया (जो मैं अब सफलतापूर्वक कर रहा हूं)। लेकिन चूंकि मैं निश्चित रूप से "कांटा", "सॉकेट", "इवेंटलूप", "मल्टीप्रोसेसिंग", "एपोल", आदि सभी प्रकार के शब्दों से थक गया था। मैंने गहरी खुदाई करने का फैसला किया। इससे जो निकला वह आप पर निर्भर है। फिर भी, एक निश्चित भ्रम मौजूद है। इस की पुष्टि संदर्भों में पाई जा सकती है [ 6 , 7 ]

int main ()

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

मूल अवधारणाएँ

फ़ाइल लिनक्स में एक मौलिक अमूर्तता है। लिनक्स "सब कुछ एक फाइल है" के दर्शन का पालन करता है, जिसका अर्थ है कि अधिकांश इंटरैक्शन फाइलों को पढ़ने और लिखने के माध्यम से महसूस किया जाता है। फ़ाइल ऑपरेशन एक अद्वितीय डिस्क्रिप्टर का उपयोग करके किया जाता है - एक फाइल डिस्क्रिप्टर या एफडी। अधिकांश लिनक्स सिस्टम प्रोग्रामिंग में फ़ाइल डिस्क्रिप्टर के साथ काम करना शामिल है।

नियमित फ़ाइलें (नियमित फ़ाइल) हैं - यह वही है जो हम (सामान्य अर्थों में सबसे साधारण "फ़ाइल" के लिए उपयोग किया जाता है) और विशेष फाइलें कुछ ऑब्जेक्ट हैं जिन्हें फ़ाइलों के रूप में दर्शाया जाता है। लिनक्स 4 प्रकार की विशेष फाइलों का समर्थन करता है:

• डिवाइस फ़ाइलें ब्लॉक करें
• चरित्र I / O डिवाइस फ़ाइलें
• नामित पाइप (नामित पाइप या फीफो)
• सॉकेट

उत्तरार्द्ध ठीक हमारे हितों का क्षेत्र है, क्योंकि सॉकेट दो अलग-अलग प्रक्रियाओं के बीच संचार प्रदान करते हैं जो विभिन्न कंप्यूटर (क्लाइंट-सर्वर) पर स्थित हो सकते हैं। वास्तव में, इंटरनेट के लिए नेटवर्क प्रोग्रामिंग और प्रोग्रामिंग सॉकेट्स पर बनाया गया है।

पहले सन्निकटन में, यह केवल नियमित फ़ाइलों और सॉकेट्स पर विचार करने के लिए पर्याप्त है।

इनपुट / आउटपुट मॉडल

कुल मिलाकर, यूनिक्स जैसी प्रणालियों में, 5 + 1 विभिन्न I / O मॉडल उपलब्ध हैं। "प्लस एक" मैं थोड़ा बाद में समझाऊंगा, लेकिन अभी के लिए, प्रत्येक मॉडल पर अधिक विस्तार से विचार करें।

अवरोधक I / O (अवरुद्ध I / O)

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







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

उसके बाद, सिस्टम कॉल समाप्त होता है (ओके लौटें) और हम अपने डेटा को प्रोसेस कर सकते हैं।

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

नॉनब्लॉकिंग आई / ओ (नॉनब्लॉकिंग आई / ओ)

हम सॉकेट्स के साथ काम करते समय नॉन-ब्लॉकिंग मोड सेट कर सकते हैं, वास्तव में कर्नेल को निम्न बता सकते हैं: "यदि इनपुट / आउटपुट जो हम करना चाहते हैं, वह एक लॉक (स्लीप) में प्रक्रिया को डुबोए बिना असंभव है, तो मुझे त्रुटि वापस करें कि आप इसे बिना ब्लॉक किए कर सकते हैं।" गैर-अवरोधक इनपुट / आउटपुट के साथ होने वाली प्रक्रियाओं का योजनाबद्ध प्रतिनिधित्व।







पहले तीन बार हम पढ़ने के लिए एक सिस्टम कॉल भेजते हैं, क्योंकि परिणाम वापस नहीं आता है कर्नेल देखता है कि कोई डेटा नहीं है और बस हमें एक EWOULDBLOCK त्रुटि देता है।

अंतिम सिस्टम कॉल सफल होगा क्योंकि डेटा पढ़ने के लिए तैयार है। नतीजतन, कर्नेल प्रक्रिया बफर को डेटा लिखेंगे और वे प्रसंस्करण के लिए उपलब्ध हो जाएंगे।

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

मल्टीप्लेक्सिंग I / O (मल्टीप्लेक्सिंग I / O)

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







सॉकेट पढ़ने योग्य बनने के लिए select'a प्रतीक्षा करने पर कॉल करने पर एप्लिकेशन अवरुद्ध हो जाता है। फिर कर्नेल हमें पठनीय स्थिति देता है और आप रिकवरफ्रेम का उपयोग करके डेटा प्राप्त कर सकते हैं। पहली नज़र में - एक पूरी निराशा। एक ही लॉक, प्रतीक्षा, और 2 और सिस्टम कॉल (चुनिंदा और पुनरावृत्ति) - उच्च ओवरहेड। लेकिन अवरुद्ध करने की विधि के विपरीत, चयन करें (और कोई भी मल्टीप्लेक्स) आपको डेटा एक से नहीं, बल्कि कई फ़ाइल डिस्क्रिप्टर से प्राप्त करने की अनुमति देता है। मुझे कहना होगा कि यह कई ग्राहकों की सेवा के लिए सबसे उचित तरीका है, खासकर अगर संसाधन काफी सीमित हैं। ऐसा क्यों है? क्योंकि मल्टीप्लेक्स डाउनटाइम (नींद) को कम करता है। मैं निम्नलिखित छवि को समझाने की कोशिश करूंगा







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

अब ध्यान! सबसे महत्वपूर्ण बात!

प्रश्न का उत्तर दें: किस घटना की अधिक संभावना है? इवेंट A के लिए, कि डेटा किसी विशेष सॉकेट के लिए या इवेंट B के लिए तैयार होगा, कि डेटा कम से कम एक सॉकेट के लिए तैयार होगा ? । उत्तर: बी

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

यदि हम समस्या को सामान्य तरीके से (अवरुद्ध करने के साथ) हल करते हैं, तो हमें अनुमान लगाना होगा कि किस कनेक्शन को पहले दूसरे सेकंड को पढ़ना है, आदि। यानी हम 100% गलत हैं और प्रतीक्षा करेंगे, और यद्यपि हम इस समय को बर्बाद नहीं कर सकते

I / O इन थ्रेड्स / चाइल्ड प्रोसेस (एक फाइल डिस्क्रर प्रति थ्रेड या प्रोसेस)

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

इनपुट सिग्नल-संचालित आउटपुट (सिग्नल-संचालित I / O)

सिग्नल का उपयोग करना संभव है, कर्नेल को हमें SIGIO फॉर्म का एक संकेत भेजने के लिए मजबूर करता है जब अवरुद्ध किए बिना डेटा पढ़ना संभव हो जाता है (हैंडल पढ़ने के लिए तैयार है)। योजनाबद्ध रूप से, यह दृष्टिकोण छवि में दिखाया गया है।







सबसे पहले, आपको सिग्नल के साथ काम करने के लिए सॉकेट पैरामीटर सेट करने की आवश्यकता है और सिगनेशन सिस्टम कॉल का उपयोग करके सिग्नल हैंडलर असाइन करना है। परिणाम तुरंत वापस आ जाता है और इसलिए आवेदन अवरुद्ध नहीं होता है। वास्तव में, कोर सभी कार्यों का ध्यान रखता है, जैसे यह मॉनिटर करता है कि डेटा तैयार है और हमें एक SIGIO सिग्नल भेजता है, जो उस पर स्थापित हैंडलर को कॉल करता है (कॉलबैक फ़ंक्शन, कॉलबैक)। तदनुसार, रिकवरफ्रॉम कॉल स्वयं सिग्नल हैंडलर या मुख्य प्रोग्राम स्ट्रीम में किया जा सकता है। जहां तक ​​मैं बता सकता हूं, यहां एक समस्या है - इस प्रकार की प्रत्येक प्रक्रिया के लिए केवल एक संकेत हो सकता है। यानी हम एक समय में केवल एक fd के साथ काम कर सकते हैं (हालांकि मुझे यकीन नहीं है)

एसिंक्रोनस I / O (एसिंक्रोनस I / O)

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







हम एक सिस्टम कॉल करते हैं aio_read और सभी आवश्यक पैरामीटर निर्दिष्ट करें। बाकी काम हमारे लिए कोर द्वारा किया जाता है। बेशक, एक तंत्र होना चाहिए जो उस प्रक्रिया को सूचित करता है जो I / O पूर्ण है। और यहां बहुत सारी समस्याएं संभावित रूप से उत्पन्न होती हैं। लेकिन उस समय के बारे में अधिक।

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

व्यवहार में

व्यवहार में, कार्य के आधार पर विभिन्न मॉडलों का एक संयोजन। निम्नानुसार करें:

• लॉक के साथ प्रत्येक ऑपरेशन के लिए एक धागा / प्रक्रिया का उपयोग करें - लाभदायक नहीं
• विभिन्न थ्रेड / प्रक्रियाओं में कई क्लाइंट। प्रत्येक थ्रेड / प्रक्रिया एक मल्टीप्लेक्सर का उपयोग करती है
• विभिन्न थ्रेड / प्रक्रियाओं में कई क्लाइंट। प्रयुक्त अतुल्यकालिक इनपुट / आउटपुट (aio)
• बस कर्नेल में सर्वर को एम्बेड करें

C10K समस्या में अधिक जानकारी

परिणाम

मुझे उम्मीद है कि अब कम से कम उन चीजों के अंतर के बारे में थोड़ा स्पष्ट हो जाएगा जिनमें भ्रमित होना आसान है।

अच्छी तरह से और हाँ, मल्टीप्लेक्सिंग नियम (जब तक वे एओआई खत्म नहीं करते, मुझे लगता है)।

संदर्भ साहित्य का अध्ययन करते हुए, मैं इस निष्कर्ष पर पहुंचा कि, सॉकेट्स के विपरीत, नियमित फ़ाइलों को गैर-अवरुद्ध मोड में स्थानांतरित नहीं किया जा सकता है। Aio उनके लिए उपलब्ध प्रतीत होता है, जिसकी चर्चा यहां की गई है: लिन पर एसिंक्रोनस I / O या नरक में आपका स्वागत है

साहित्य और संदर्भ

1. रॉबर्ट लव “लिनक्स। सिस्टम प्रोग्रामिंग
2. डब्ल्यू। रिचर्ड स्टीवंस, बिल फेनर, एंड्रयू एम। रुडॉफ़ "यूनिक्स नेटवर्क प्रोग्रामिंग वॉल्यूम 1, तीसरा संस्करण: सॉकेट नेटवर्किंग नेटवर्क"
3. स्टीवंस आर।, रागो एस यूनिक्स। व्यावसायिक प्रोग्रामिंग, दूसरा संस्करण
4. हर किसी की पसंदीदा C10K समस्या
5. लिनोल पर अतुल्यकालिक I / O या नरक में आपका स्वागत है
6. दो उच्च-प्रदर्शन I / O डिज़ाइन पैटर्न की तुलना करना
7. अतुल्यकालिक बनाम गैर-अवरुद्ध
8. ब्लॉकिंग बनाम गैर-अवरुद्ध सॉकेट