👣 🙍🏾 ↘️ AsyncIO Micropython: एसिंक्रोनस प्रोग्रामिंग में सिंक्रोनाइज़ेशन के तरीके 🦄 🚶🏽 🧝🏼

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

while True: do_ext_proc_before() do_internal_proc() sleep(5) do_ext_proc_after()

आप 'स्लीप ()' को छोड़ सकते हैं और लूप में कुछ शर्तों के लिए जाँच सक्षम कर सकते हैं, जो आपको आवधिक घटना होने तक कम से कम मुख्य लूप में देरी नहीं करने देगा।

  start = time() set_timer(start,wait=5) #   set_timeout(start,wait_to=7) #   set_irq(alarm) #    while True: curTime = time() do_ext_proc_before() if timer(curTime) or timeout(curTime) or alarm: # if all events crazy start simultaneously - reset all start = time() set_timer(start,wait=5) #   set_timeout(start,wait_to=7) #   set_irq(alarm) #    do_internal_proc() do_ext_proc_after()

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

  setTask(do_ext_proc_before()) setTask(do_internal_proc(),timer=5,timeout=7,alarm_handler=alarm) setTask(do_ext_proc_after()) runTasks()

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

मैंने इस प्रश्न का अध्ययन किया प्रकाशित किए गए asyncio Micropython विस्तारित पुस्तकालय का उपयोग करके
पीटर हेंच ( https://github.com/peterhinch/micropython-async/blob/master/TUTORIAL.md )
सबसे सरल समाधान यह है कि घटना को इच्छुक प्रक्रियाओं के लिए संकेत दिया जाए। ऐसा करने के लिए, इवेंट () वर्ग का उपयोग करें, जिसमें कई मॉड्यूल शामिल हैं

  Event.Set( timeout = None, data = None ) -    (Event = True), ,     , Event.IsSet() - ,   ,  True,    False   Event.Wait() -   ,     - Done,Timeout,Cancel Event.Data() -  ,     Event.Clear() -   (Event = False).

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

यह ध्यान में रखा जाना चाहिए कि यह केवल एक प्रक्रिया के साथ Event.Clear () बनाने के लिए सलाह दी जाती है, अगर यह दिए गए एल्गोरिथ्म का विरोध नहीं करता है। अन्यथा, यदि कई प्रक्रिया ईवेंट Event.et () के होने की प्रतीक्षा कर रही हैं, तो यह माना जाता है कि Event.Clear () को किसी एक इच्छुक प्रक्रिया द्वारा निष्पादित किया जाना चाहिए, केवल यह सुनिश्चित करते हुए कि सभी इच्छुक प्रक्रियाओं ने ईवेंट का जवाब दिया है। कई प्रक्रियाओं द्वारा इवेंट की प्रतीक्षा करते समय इवेंट-क्लास का उपयोग करते समय यह निर्णय तर्क को जटिल करता है। यह स्थिति घटित हुई घटना की एक निश्चित मात्रा में Clear () स्थापित करके हल की जाती है।

  Barrier.Set( quantity = 1, timeout = None, data = None ) - quantity = 1  Event.Set() Barrier.IsSet() - ,   ,  True,    False   Barrier.Wait() -   ,     - Done,Timeout,Cancel Barrier.Data() -  ,     Barrier.qty -      Barrier.Clear() -   (Event = False),        Barrier.quantity  ,    ,

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

  EEvent.Set (creators, folowers, timeout = None, data = None ) -  True,        EEvent.IsSet( procName ) - procName -   ID   EEvent.Wait( procName ) EEvent.Clear( procName ) EEvent.Folowers() -    ,      . Barrier.qty = len(EEvent.List()) EEvent.Creators() -   ,

ईवेंट-क्लास मॉड्यूल का उपयोग करके, हम पहले से चर्चा की गई समस्या के समाधान का वर्णन कर सकते हैं।

  def do_internal_proc(): ... EEvent.Set ('p_Creator',('p_Folwer1','p_Folwer2')) # exec 'p_Folwer1','p_Folwer2' after event is come in 'p_Creator' ... def do_ext_proc_after1() ... EEvent.Wait('p_Creator') ... EEvent.Clear('p_Folwer1') def do_ext_proc_after1() ... EEvent.Wait('p_Creator') ... EEvent.Clear('p_Folwer2')

विपरीत स्थिति पर विचार करें - जब एक प्रक्रिया कई घटनाओं के पूरा होने या एक 'कई से एक' स्थिति की प्रतीक्षा कर रही हो। दूसरे शब्दों में, कि यदि do_internal_proc () का निष्पादन do_ext_proc_before () के निष्पादन के बाद ही हो सकता है। चरम स्थिति में, जब एक प्रक्रिया किसी घटना के पूरा होने / घटने की प्रतीक्षा कर रही है, तो कार्य को इवेंट-क्लास का उपयोग करके हल किया जा सकता है। जब कई घटनाओं के पूरा होने की उम्मीद की जाती है, उदाहरण के लिए, केवल प्राप्त आंकड़ों को प्रदर्शित करने और उन्हें सर्वर पर भेजने के बाद, उन्हें डिस्क पर सहेजने के लिए, यह आवश्यक है कि प्रत्येक निष्पादित प्रक्रिया अपेक्षित घटना में अपनी भागीदारी स्थापित करे और सभी प्रक्रियाएं पूरी होने तक प्रतीक्षा करें।

  def do_ext_proc_before1() ... EEvent.Set('p_Creator1','p_Folwer') ... def do_ext_proc_before2() ... EEvent.Set('p_Creator2','p_Folwer') ... def do_internal_proc(): ... EEvent.Wait(('p_Creator1','p_Creator2')) ... EEvent.Clear('p_Folwer')

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

अतुल्यकालिक प्रोग्रामिंग मानक में, यह कार्य लॉक-क्लास मॉड्यूल द्वारा हल किया जाता है। सामान्य स्थिति में, समस्या को एक से कई स्थितियों के समान हल किया जा सकता है

  def do_internal_proc(): # lock activity all 'followers' in list ... EEvent.Set ('p_Creator',('p_Folwer1','p_Folwer2')) # exec 'p_Folwer1','p_Folwer2' after event is come in 'p_Creator' ... def do_ext_proc_after1() ... EEvent.Wait('p_Creator') # waiting for recourse releale if ( EEvent.Set ('p_Folwer1','p_Folwer2')): # lock resource 'p_Folower1' now is 'p_Creator' ... else: EEvent.Wait('p_Folower2') # continue waiting for recourse releale ... EEvent.Clear('p_Folwer1') # releafe recourse def do_ext_proc_after1() ... EEvent.Wait('p_Creator') if ( EEvent.Set ('p_Folwer2','p_Folwer1')): # lock resource 'p_Folower2' now is 'p_Creator' ... else: EEvent.Wait('p_Folower1') # continue waiting for recourse releale ... EEvent.Clear('p_Folwer2') # releafe recourse

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

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

AsyncIO Micropython: एसिंक्रोनस प्रोग्रामिंग में सिंक्रोनाइज़ेशन के तरीके

More articles: