एक बार फिर नेटवर्क डेमॉन की वास्तुकला के बारे में

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



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



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

मेरे निबंध में, कवर या कुछ अज्ञात चाल का कोई टूटना नहीं है, यह बस एक व्यक्ति द्वारा विभिन्न दृष्टिकोणों के फायदे और नुकसान का वर्णन करता है, जिन्होंने यह जांचा कि यह सब अलग-अलग ऑपरेटिंग सिस्टम में कैसे काम करता है।

ज्ञानियों की इच्छा रखने वालों के लिए, बिल्ली में आपका स्वागत है।

नेटवर्क डेमॉन के लिए टीके

सबसे पहले आपको यह समझने की आवश्यकता है कि नेटवर्क सेवाओं को वास्तव में क्या करना चाहिए और क्या समस्या है।



किसी भी डेमॉन को नेटवर्क कनेक्शन को स्वीकार और प्रोसेस करना होगा। चूंकि TCP / IP प्रोटोकॉल स्टैक UNIX से बढ़ा है, और यह OS हठधर्मिता "सब कुछ एक फाइल है" को बताता है, नेटवर्क कनेक्शन एक विशेष प्रकार की फाइलें हैं जिन्हें फाइलों के साथ काम करने के लिए मानक OS फ़ंक्शन द्वारा खोला, बंद, पढ़ा और लिखा जा सकता है। शब्द "सैद्धांतिक रूप से" के साथ संयोजन में, मोडल क्रिया "कैन" पर ध्यान दें, यह वास्तविकता का बहुत सटीक वर्णन करता है।



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



हालाँकि सुनने वाला सॉकेट एक फाइल है, लेकिन यह सब कुछ समय-समय पर होने वाली घटनाओं जैसे "इनकमिंग कनेक्शन रिक्वेस्ट" के रूप में हो सकता है। डेमॉन इस कनेक्शन को स्वीकार () फ़ंक्शन के साथ स्वीकार कर सकता है, जो एक नई फ़ाइल बनाएगा, इस प्रकार के "ओपन टीसीपी / आईपी नेटवर्क सॉकेट"। संभवतः, डेमॉन को इस कनेक्शन से अनुरोध पढ़ना चाहिए, इसे संसाधित करना चाहिए और परिणाम वापस भेजना चाहिए।



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

* सभी घटनाएं वास्तव में अतुल्यकालिक और एक अज्ञात समय अवधि के साथ होती हैं। सबसे खराब स्थिति में किसी भी ऑपरेशन में दसियों मिनट लग सकते हैं। आम तौर पर कोई भी।

* कनेक्शन, फाइलों के विपरीत, किसी भी समय "खुद से" बंद किया जा सकता है, सबसे अप्रत्याशित क्षण।

* ओएस हमेशा एक बंद कनेक्शन की रिपोर्ट नहीं करता है, "मृत" सॉकेट आधे घंटे तक लटका रह सकता है।

* क्लाइंट और सर्वर पर कनेक्शन अलग-अलग समय पर बंद होते हैं। यदि क्लाइंट एक नया कनेक्शन बनाने की कोशिश करता है और डेटा को "भेज" देता है, तो डेटा का दोहराव संभव है, और यदि क्लाइंट गलत तरीके से लिखा गया है, तो यह खो सकता है। यह भी संभव है कि सर्वर में एक क्लाइंट से कई खुले कनेक्शन हों।

* डेटा को बाइट्स की एक धारा के रूप में माना जाता है और सचमुच 1 बाइट के हिस्से में आ सकता है। इसलिए, उन पर विचार करना असंभव है, उदाहरण के लिए, यूटीएफ -8 तार के रूप में।

* नेटवर्क पर डेमन द्वारा प्रदान किए गए लोगों के अलावा कोई बफ़र नहीं हैं। इसलिए, सॉकेट के लिए भी 1 बाइट लिखना दसियों मिनट (ऊपर देखें) के लिए डेमन को अवरुद्ध कर सकता है। इसके अलावा, सर्वर पर मेमोरी "नॉन-रबर" है, डेमॉन को उस गति को सीमित करने में सक्षम होना चाहिए जिसके साथ परिणाम उत्पन्न होते हैं।

* कोई भी त्रुटि कहीं भी हो सकती है, डेमॉन को उन सभी को सही ढंग से संभालना चाहिए।



यदि आप सभी खुले कनेक्शन "माथे" पर एक लूप लिखते हैं, तो पहला "लटका हुआ" कनेक्शन अन्य सभी को अवरुद्ध करेगा। हाँ, दसियों मिनट के लिए। और यहां डेमन के विभिन्न मॉड्यूलों की बातचीत के आयोजन के लिए विभिन्न विकल्प हैं। देखें तस्वीर:



अस्वीकरण : आंकड़ा छद्म भाषा कोड दिखाता है जो वास्तविकता के अनुरूप नहीं है। कई महत्वपूर्ण सिस्टम कॉल और सभी त्रुटि हैंडलिंग कोड स्पष्टता के लिए छोड़ दिए गए हैं।

2. मल्टीप्रोसेस आर्किटेक्चर

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



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



ग्राफ़ पर - लिनक्स कर्नेल के संस्करण के आधार पर, प्रति सेकंड एक स्थिर फ़ाइल के लिए संसाधित अनुरोधों की संख्या। ज्यादा बेहतर है।

टेस्ट बेंच: कोर i7 970, 3Gb DDR3, एनवीडिया जीटीएक्स 460, 64 जीबी ओसीजेड वेरटेक्स एसएसडी।

स्रोत: Phoronix

मैं आपके राक्षसों को प्रति सेकंड 17k फाइलें देने की कामना करता हूं।



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



अंत में, प्रत्येक प्रक्रिया का अपना पता स्थान होता है, और विभिन्न प्रक्रियाएं एक-दूसरे की मेमोरी के उपयोग में हस्तक्षेप नहीं करती हैं। इस लाभ को भाग में क्यों समझाया गया है

3. बहुस्तरीय वास्तुकला

धाराएँ सबसे आसान "प्रक्रियाएँ" हैं जिनमें साझा मेमोरी, सिस्टम संसाधन और एक्सेस अधिकार हैं, लेकिन अलग-अलग स्टैक। इसका मतलब है कि थ्रेड्स में सामान्य गतिशील, वैश्विक और स्थिर चर हैं, लेकिन विभिन्न स्थानीय हैं। मल्टीप्रोसेसर और / या मल्टीकोर सिस्टम में, एक ही प्रक्रिया के विभिन्न थ्रेड्स एक साथ शारीरिक रूप से निष्पादित किए जा सकते हैं।



एक बहु-थ्रेडेड आर्किटेक्चर एक मल्टी-प्रोसेस आर्किटेक्चर के समान है जिसमें प्रदर्शन और मेमोरी खपत के लिए सुरक्षा और स्थिरता का त्याग किया जाता है।



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



एक साथ कनेक्शन की अपेक्षाकृत छोटी संख्या के लिए, बहु-थ्रेडेड आर्किटेक्चर एक उत्कृष्ट विकल्प है। लेकिन अगर वास्तव में बहुत सारे कनेक्शन हैं, तो दस हजार कहते हैं, थ्रेड के बीच स्विच करने में बहुत अधिक समय लगता है। लेकिन यहां तक ​​कि यह बहु-थ्रेडेड आर्किटेक्चर का मुख्य दोष नहीं है।



और मुख्य बात यह है कि धागे स्वतंत्र नहीं हैं और एक दूसरे को अवरुद्ध (और कर सकते हैं) कर सकते हैं। यह समझने के लिए कि यह कैसे होता है, एक उदाहरण पर विचार करें।



मान लें कि हमें किसी अभिव्यक्ति के मूल्य की गणना करने की आवश्यकता है

a = b + c;





, जहां ए, बी और सी वैश्विक चर हैं।



सामान्य, एकल-थ्रेडेड स्थिति में, कंपाइलर इस मशीन कोड जैसा कुछ उत्पन्न करेगा:

a = b; // MOV A, B

a += c; // ADD A, C









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



इसलिए, बहु-थ्रेडेड संस्करण में, कोड का उपयोग इस तरह किया जाता है:

lock a;

lock b;

lock c;

a = b;

a += c;

unlock c;

unlock b;

unlock a;







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



इस प्रकार, यदि दो धागे एक साथ संचालन शुरू करते हैं a = b + c और b = c + a, तो वे एक दूसरे को हमेशा के लिए अवरुद्ध कर देंगे। इस स्थिति को एक क्लिनिक कहा जाता है, क्लीनिकों की खोज और संकल्प समानांतर प्रोग्रामिंग का एक अलग "पीड़ादायक विषय" है। लेकिन यहां तक ​​कि बिना थ्रेड्स, थ्रेड्स, यदि वे जल्दी से ताले जारी नहीं करते हैं, तो एक दूसरे को काफी लंबे समय तक रोक सकते हैं।



इसके अलावा, परमाणु संचालन शारीरिक रूप से रैम बस और रैम के अनन्य नियंत्रण के माध्यम से कार्यान्वित किया जाता है। मेमोरी के साथ सीधे काम करना, और कैश के साथ नहीं, अपने आप में बहुत धीमा है, और इस मामले में भी अन्य सभी सर्वर प्रोसेसर के सभी कोर की इसी कैश लाइनों के अमान्यकरण (रीसेट) का कारण बनता है। यही है, यहां तक ​​कि सबसे अच्छे मामले में, ताले की अनुपस्थिति में, प्रत्येक परमाणु ऑपरेशन पर्याप्त रूप से लंबे समय तक किया जाता है और अन्य थ्रेड्स के प्रदर्शन को नीचा दिखाता है।



लेकिन, ऐसा लगता है, क्योंकि राक्षसों में कनेक्शन लगभग स्वतंत्र हैं, वे सामान्य चर कहां से प्राप्त कर सकते हैं?

लेकिन कहां से:

* नए यौगिकों की सामान्य कतार;

* डेटाबेस या समान संसाधनों तक पहुंच के लिए सामान्य कतार;

* मेमोरी आवंटन के लिए अनुरोधों की सामान्य कतार (हाँ, मालोक) और नई () अवरुद्ध होने का कारण बन सकती है;

* सामान्य लॉग (लॉग-फ़ाइल) और सांख्यिकी गणना की सामान्य वस्तुएं।

ये केवल सबसे स्पष्ट हैं।



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

4. गैर-अवरुद्ध वास्तुकला

आदर्श रूप से, आवेदन में थ्रेड्स की संख्या परिमाण के क्रम में प्रोसेसर कोर की संख्या के लगभग बराबर होनी चाहिए। इसे प्राप्त करने के लिए एक तंत्र गैर-अवरुद्ध I / O है।



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

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

एसिंक्रोनस I / O के अगले भाग में विस्तार से चर्चा की गई है, लेकिन यहां हम गैर-अवरुद्ध पढ़ने और लिखने के कार्यों के उपयोग पर ध्यान केंद्रित करते हैं।



वास्तविक परिस्थितियों में, नॉनब्लॉकिंग रीड () कॉल के 95% प्रत्येक 0 बाइट्स पढ़ेंगे। ओएस कर्नेल के इन "बेकार" कॉलों से बचने के लिए, एक चयन () फ़ंक्शन है जो आपको ऑपरेटिंग सिस्टम को उन कनेक्शनों की सूची से चयन करने के लिए कहता है जिनसे आप पहले से ही पढ़ सकते हैं और / या लिख ​​सकते हैं। कुछ * निक्स ऑपरेटिंग सिस्टम में इस फ़ंक्शन का एक प्रकार होता है जिसे पोल () कहा जाता है।

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

मैं मदद नहीं कर सकता, लेकिन एक ग्राफ दिखाते हुए बताऊंगा कि इन सभी नवाचारों से क्या होता है ग्राफ पर - लूप इंटरफ़ेस के माध्यम से 10 जीबी डेटा पंप करने का समय, कर्नेल के संस्करण पर निर्भर करता है। कम बेहतर है। स्रोत समान है, परीक्षण बेंच समान है।

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



चलो थ्रेड्स की संख्या को कम करने के लिए वापस जाते हैं।

तो, डेमॉन के पास "कनेक्शन" वर्ग की बड़ी संख्या में ऑब्जेक्ट्स हैं, और ऑपरेशन का एक सेट है जिसे प्रत्येक कनेक्शन ऑब्जेक्ट पर और सही क्रम में लागू करने की आवश्यकता है।



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



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



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

5. एसिंक्रोनस I / O

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



ऐतिहासिक रूप से, विंडोज 2000 एसिंक्रोनस I / O का समर्थन करने वाले पहले OS में से एक था।

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

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



इस संरचना के अतिरिक्त, आप अपने कॉलबैक फ़ंक्शंस को अतुल्यकालिक I / O फ़ंक्शंस में स्थानांतरित कर सकते हैं जो OVERLAPPED को एक पॉइंटर लेते हैं, जिसे ऑपरेशन के अंत में ऑपरेटिंग सिस्टम द्वारा बुलाया जाएगा।

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



ऊपर वर्णित अतुल्यकालिक I / O योजना WindowsNT कर्नेल के लिए "मूल" है, अर्थात, अन्य सभी ऑपरेशन किसी न किसी तरह इसके माध्यम से कार्यान्वित किए जाते हैं। पूरा नाम - IOCP (इनपुट / आउटपुट कंप्लीशन पोर्ट)। यह माना जाता है कि यह योजना लोहे से सैद्धांतिक रूप से अधिकतम प्रदर्शन प्राप्त करने की अनुमति देती है। विंडोज के तहत गंभीर काम के लिए डिज़ाइन किए गए किसी भी डेमन को IOCP के आधार पर विकसित किया जाना चाहिए। अधिक जानकारी के लिए MSDN पर IOCP का परिचय देखें।



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



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

सारांश

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



जैसा कि हो सकता है, डेमन एक I / O के साथ पर्याप्त नहीं हैं, और बहुत अधिक जटिल "गैग्स" अनुरोध प्रसंस्करण के दौरान होते हैं। लेकिन यह किसी अन्य लेख के लिए एक विषय है, अगर किसी को दिलचस्पी है।

संदर्भ

1. C10K समस्या , टिप o_O_Tync के लिए धन्यवाद

2. कामेच्छा पुस्तकालय में मदद करें , बड़े पैमाने पर इनपुट-आउटपुट ( संलग्न ) के विभिन्न तंत्रों के वर्णन के साथ एक स्वादिष्ट हिस्सा, टिप के लिए धन्यवाद।

3. FAQ गूंज ru.unix.prog

4. यूनिक्स पुस्तकालय लिबियो का परिचय

5. 2.6.12 से 2.6.37 तक कोर प्रदर्शन परीक्षण ।