स्टैकलेस पायथन और सहमति

Stackless और Concurrence सुविधाओं पर आगे बढ़ने से पहले, आइए एक नेटवर्क एप्लिकेशन लिखने का सबसे आसान तरीका देखें जो एक साथ कई कनेक्शनों को संसाधित करता है:

socket() bind() listen() accept() fork() -> read() write() ... close()
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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



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



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



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



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



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

 select() -> read_ready -> read(cmd) if state == "STATE1": if cmd == "CMD1": state = "STATE2" else: invalid_command() elif state == "STATE2": if cmd == "CMD2": state = "STATE1" else: invalid_command()
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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



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

stackless

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



एक प्रोग्रामर के दृष्टिकोण से, एक टास्कलेट (स्टैकलेस शर्तों में माइक्रोफ़्लो) बनाना एक नया ऑपरेटिंग सिस्टम थ्रेड बनाने से अलग नहीं है: स्टैकलेस.tasklet (your_func) (1, 2, 3)। हम नए टास्कलेट के संदर्भ में फ़ंक्शन your_func (1, 2, 3) का निष्पादन शुरू करते हैं। इस फ़ंक्शन का निष्पादन तब तक जारी रहेगा जब तक कि टास्कलेट स्पष्ट रूप से कर्नेल (स्टैक्लेस.स्क्रूइड ()) को नियंत्रण नहीं देता है, या अवरुद्ध है, कुछ जानकारी भेजे जाने या प्राप्त होने की प्रतीक्षा में है। उदाहरण के लिए, एक टास्कलेट नेटवर्क सॉकेट से डेटा प्राप्त करना चाहता है, लेकिन वे अभी तक उपलब्ध नहीं हैं। इस समय, टास्कलेट I / O प्रतीक्षा कतार में प्रवेश करता है, और नियंत्रण बदले में अगले टास्कलेट में स्थानांतरित हो जाता है। जब अपेक्षित डेटा आएगा, तो पहला टास्कलेट नियंत्रण लेगा और डेटा को संसाधित करना जारी रखेगा।



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

 val = memcached.get("some-object-123") if val is None: res = list(mysql.query("select val from tbl where id=%d", 123)) if len(res): val = res[0] memcached.set("some-object-123", val)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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



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

 def get(): if len(self._pool): return self._pool.pop(0) else: return self._wait_channel.receive()
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

 def put(conn): if self._wait_channel.balance < 0: self._wait_channel.send(conn) else: self._pool.append(conn)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यदि "चैनल बैलेंस" शून्य से कम है, तो इसका मतलब है कि इस चैनल पर कुछ टास्कलेट्स इंतजार कर रहे हैं। इस मामले में, पूल में लौटाए गए कनेक्शन को चैनल में रखा जाएगा, जहां से इसे तुरंत टास्कलेट द्वारा निकाला जाएगा, जो पहले कतार में प्रवेश करता है, और यह निष्पादन जारी रखेगा।



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

सन्निपतन

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



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

 def hello_world(environ, start_response): start_response("200 OK", []) return ["<html>Hello, world!</html>"] def main(): server = WSGIServer(hello_world) server.serve(('localhost', 8000)) dispatch(main)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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



अब मरहम में एक मक्खी। दुर्भाग्य से, ऐसा लगता है कि समाप् त को छोड़ दिया गया है और अब समर्थित नहीं है। लेखक पत्रों का जवाब नहीं देता है, जिसमें पैच के साथ बग रिपोर्ट भी शामिल है। इसलिए, मैंने एक सही SMTP क्लाइंट और थ्रिफ्ट सपोर्ट के साथ WebDAV के HTTP PUT समर्थन के साथ, विशेष रूप से, जो कि मुझे मिली बग्स के साथ, और जो कुछ अतिरिक्त सुविधाएँ मिली हैं, उनके साथ अपने वर्ज़न ऑफ़ कॉन्सर्ट को प्रकाशित करने की स्वतंत्रता ली। भंडार गितुब पर है ।



Stackless, Concurrence, या अन्य Python अतुल्यकालिक प्रोग्रामिंग प्रौद्योगिकियों का उपयोग करने की योजना बनाने वाले किसी भी व्यक्ति को ru-python-async मेलिंग सूची की सदस्यता के लिए आमंत्रित किया जाता है।

संदर्भ

स्टैकलेस पायथन - www.stackless.com

सफलता की कहानियां - www.stackless.com/wiki/Applications

समसामयिकी - सलामी स्रोत .hyves.org/ concurrence

मेरा समागम का संस्करण github.com/JoyTeam/concurrence है