🔖 📙 👨🏿‍🤝‍👨🏻 कोरो और एक अन्य रोस-कॉलबैक कार्यान्वयन ⛺️ 🚣🏻 👏🏾

CPAN के पास मॉड्यूल - कोरो का ऐसा अद्भुत परिवार है। ये मॉड्यूल आपको corutin का उपयोग करके मोती में प्रोग्राम करने की अनुमति देते हैं।

छोटा सा परिचय

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

कोरो थ्रेड बनाना

कोरो स्ट्रीम बनाने के लिए, आपको किसी एक निर्माण का उपयोग करना होगा:

Coro::async { ... } @args;

ब्लॉक और इसके तर्कों के बीच अल्पविराम की अनुपस्थिति पर ध्यान दें, या

 my $coro = new Coro(\&code_ref, @args); $coro->ready();

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

कोरो धाराओं के बीच स्विच करना

सिस्टम थ्रेड्स के विपरीत, जिसके बीच स्विच करना ऑपरेटिंग सिस्टम के आंतों में कहीं बाहर किया जाता है, मैन्युअल रूप से कोरो-थ्रेड्स के बीच स्विच करना आवश्यक है। सबसे स्पष्ट स्विचिंग पॉइंट (आप अधिक या कम स्पष्ट के साथ आ सकते हैं):

"लंबे समय तक चलने" चक्र के प्रत्येक एन-वें पुनरावृत्ति
प्रत्येक ब्लॉकिंग ऑपरेशन (नेटवर्क, डिस्क आदि के साथ काम करना)

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

 $Coro::current->ready(); Coro::schedule;

आइए एक उदाहरण देखें।

 #!/usr/bin/perl $| = 1; use strict; use warnings; use Coro; #  coro-   Coro::async Coro::async { my $thread_id = shift; #    coro- $Coro::current->desc("Thread #$thread_id"); for (my $i = 0; $i < 1_000_000; $i++) { if ($i % 1000 == 0) { print "$Coro::current->{desc} - Processed: $i items\n"; #   coro-   ready- $Coro::current->ready(); #      ready- Coro::schedule(); } } } 0; #       coro- sub my_thread { my $thread_id = shift; $Coro::current->desc("Thread #$thread_id"); for (my $i = 0; $i < 1_000_000; $i++) { if ($i % 1000 == 0) { print "$Coro::current->{desc} - Processed: $i items\n"; #     coro- Coro::cede(); } } } my @threads = (); for (my $thread_id = 1; $thread_id < 5; $thread_id++) { #   coro-   Coro::new() my $thread = new Coro(\&my_thread, $thread_id); #   coro-   ready- $thread->ready(); push @threads, $thread; } while (my $thread = shift @threads) { #   coro-   ,   coro-   $thread->join(); }

परिणाम:

 धागा # 0 - संसाधित: 0 आइटम
 धागा # 1 - संसाधित: 0 आइटम
 धागा # 2 - संसाधित: 0 आइटम
 धागा # 3 - संसाधित: 0 आइटम
 धागा # 4 - संसाधित: 0 आइटम
 धागा # 0 - संसाधित: 1000 आइटम
 धागा # 1 - संसाधित: 1000 आइटम
 धागा # 2 - संसाधित: 1000 आइटम
 धागा # 3 - संसाधित: 1000 आइटम
 धागा # 4 - संसाधित: 1000 आइटम
 ...
 धागा # 0 - संसाधित: 999000 आइटम
 थ्रेड # 1 - संसाधित: 999000 आइटम
 धागा # 2 - संसाधित: 999000 आइटम
 धागा # 3 - संसाधित: 999000 आइटम
 थ्रेड # 4 - संसाधित: 999000 आइटम

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

इवेंट लूप इंटीग्रेशन

उपरोक्त उदाहरण दर्शाता है कि कोरो थ्रेड्स प्रोसेसर समय को कैसे साझा करते हैं, समय लेने वाले काम से ब्रेक लेते हैं। जैसा कि ऊपर उल्लेख किया गया है, प्रोसेसर समय साझा करने का एक अच्छा कारण अवरुद्ध संचालन (आमतौर पर I / O) करना भी है।
जब हमें कई अवरुद्ध कार्यों के साथ प्रभावी कार्यक्रम संचालन की समस्या का सामना करना पड़ता है, तो हम आमतौर पर इवेंट लूप की मदद से इस समस्या को हल करते हैं। उदाहरण के लिए, हम सॉकेट्स को नॉन-ब्लॉकिंग मोड में डालते हैं और उन पर "हैंग" "वॉचर्स" लिखते हैं, लिखने या पढ़ने के लिए सॉकेट की तत्परता की निगरानी करते हैं, और टाइमआउट ऑपरेशन को बाधित करने के लिए एक टाइमर बनाते हैं। जैसे ही हमारे लिए रुचि की घटनाएं घटती हैं, घटना चक्र के आघात से संबंधित "घड़ी" से संबंधित कॉलबैक को कहा जाता है। जैसे-जैसे यह परियोजना और अधिक जटिल होती जा रही है, यह समझना और अधिक कठिन होता जा रहा है कि किस कॉलबैक को कब और क्यों कहा जा रहा है। कोरो का उपयोग करते हुए, स्थिति में स्पष्ट रूप से सुधार होता है और प्रोग्राम कोड अधिक रैखिक और समझ में आता है (विशुद्ध रूप से मेरी राय)।
सबसे पहले, यह ध्यान दिया जाना चाहिए कि कोरो मॉड्यूल परिवार में कोर लूप को इवेंट लूप में एकीकृत करने के लिए तीन मॉड्यूल हैं - ये हैं कोरो :: AnyEvent , Coro :: घटना और कोरो :: EV (नीचे दिए गए कोड के टुकड़े कोरो :: EV के लिए होंगे)। अपने कार्यक्रम में ईवेंट लूप को एकीकृत करने के लिए, आपको बस लूप को किसी भी कोरो-स्ट्रीम (उदाहरण के लिए, मुख्य थ्रेड में) को चलाने की आवश्यकता है:

 Coro::async { EV::run() };

घटना प्रसंस्करण की सुविधा के लिए, कोरो मॉड्यूल दो उपयोगी कार्य प्रदान करता है - rouse_cb() और rouse_wait() :

rouse_cb() उत्पन्न करता है और एक कॉलबैक देता है, जिसे कॉल करने पर, उसके पास दिए गए तर्कों को सहेजता है और कॉल के तथ्य के कोरो इंटर्नल को सूचित करता है
rouse_wait() वर्तमान कोरो स्ट्रीम को तब तक ब्लॉक करता है जब तक कि rouse_cb() फ़ंक्शन द्वारा बनाई गई अंतिम rouse_cb() (आप एक तर्क के रूप में प्रतीक्षा करने के लिए कॉलबैक को कॉल भी निर्दिष्ट कर सकते हैं); फ़ंक्शन देता है जो कॉलबैक में तर्कों के रूप में दिया गया था

तो नीचे दिए गए कोड के टुकड़े बराबर हैं:

 # 1.   rouse_cb()  rouse_wait() my $timer = EV::timer(5, 5, sub { my ($watcher, $revents) = @_; print "Timer $wathcer: timeout\n"; }); #2.   rouse_cb()  rouse_wait() my $timer = EV::timer(5, 5, rouse_cb()); my ($watcher, $revents) = rouse_wait(); print "Timer $wathcer: timeout\n";

रोस कॉलबैक का एक और कार्यान्वयन

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

 my $cb = new My::RouseCallback; my $timer = EV::timer(5, 5, $cb); my ($watcher, $revents) = $cb->wait(); print "Timer $wathcer: timeout\n";

मेरा :: RouseCallback का कार्यान्वयन

 package My::RouseCallback; use strict; use warnings; use Coro; # ""      My::RouseCallback my %STORAGE = (); #  : my $cb = new My::RouseCallback; sub new { my ($class) = @_; my $context = {args => [], done => 0, coro => undef}; my $self = bless sub { #     $context->{args} = \@_; #   ,     $context->{done} = 1; if ($context->{coro}) { #   coro- $context->{coro}->ready(); } }, $class; $STORAGE{"$self"} = $context; return $self; }; #   : $cb->wait(); sub wait { my $self = shift; my $context = $STORAGE{"$self"}; #   ,  coro-   $context->{coro} = $Coro::current; #   coro-   ,      while ($context->{done} == 0) { Coro::schedule(); } #        my @args = @{ $context->{args} }; $context->{args} = []; $context->{done} = 0; return @args; } sub DESTROY { my $self = shift; $self->(); delete $STORAGE{"$self"}; }; 1; __END__

यदि आप अपने कार्य में कोरो का उपयोग करने की संभावना देखते हैं, तो प्रयास करना सुनिश्चित करें, शायद आप इसे पसंद करेंगे। प्रलेखन का अध्ययन करें, व्यवहार में प्राप्त ज्ञान को साझा करें।

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

कोरो और एक अन्य रोस-कॉलबैक कार्यान्वयन

छोटा सा परिचय

कोरो थ्रेड बनाना

कोरो धाराओं के बीच स्विच करना

इवेंट लूप इंटीग्रेशन

रोस कॉलबैक का एक और कार्यान्वयन

More articles: