C ++ में Coroutines के बारे में अधिक जानकारी

कॉरआउट क्या हैं?

• स्टैकलेस कोराटाइन
• स्टैक कोरटाइन
• हरी धाराएँ
• रेशे
• Gorutins

void foo(){
     return; //     
}	
foo(); //   / 

def generate_nums():
     num = 0
     while True:
          yield num
          num = num + 1	

nums = generate_nums()
	
for x in nums:
     print(x)
	
     if x > 9:
          break

एक पुस्तकालय के रूप में Coroutines

स्टैक कोरटाइन

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

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

1. एक थ्रेड के अंदर एक नियमित फ़ंक्शन कॉल। मेमोरी स्टैक पर आवंटित की जाती है।
2. . . , . . , .
3. .
4. . .
5. .
6. .
7. . , , , .
8. .
9. .
10. – , .
11. , .
12. . .
13. . : , . , ( ) .
14. , .
15. .
16. . . . , .
17. .
18. , , .

#include <cstdlib>
#include <iostream>
#include <memory>
#include <string>
#include <thread>
	
#include <boost/intrusive_ptr.hpp>
	
#include <boost/fiber/all.hpp>
	
inline
void fn( std::string const& str, int n) {
     for ( int i = 0; i < n; ++i) {
          std::cout << i << ": " << str << std::endl;
               boost::this_fiber::yield();
     }
}
	
int main() {
     try {
          boost::fibers::fiber f1( fn, "abc", 5);
          std::cerr << "f1 : " << f1.get_id() << std::endl;
          f1.join();
          std::cout << "done." << std::endl;
	
          return EXIT_SUCCESS;
     } catch ( std::exception const& e) {
          std::cerr << "exception: " << e.what() << std::endl;
     } catch (...) {
          std::cerr << "unhandled exception" << std::endl;
     }
     return EXIT_FAILURE;
}

स्टैकलेस कोराटाइन

• कॉरटीन अपने कॉलर के साथ घनिष्ठ रूप से जुड़ा हुआ है: जब एक कोरटाइन कहा जाता है, तो निष्पादन उसे स्थानांतरित कर दिया जाता है, और कॉरआउट का परिणाम कॉलर को वापस स्थानांतरित कर दिया जाता है।
• स्टैक कोरुटिन का जीवन काल इसके स्टैक के जीवन के बराबर होता है। एक स्टैकलेस कोरटाइन का जीवनकाल उसकी वस्तु के जीवन के बराबर होता है।

1. एक नियमित फ़ंक्शन कॉल जिसका फ्रेम स्टैक पर संग्रहीत है
2. फ़ंक्शन एक coroutine बनाता है । यही है, यह ढेर पर कहीं इसके लिए एक सक्रियण फ्रेम आवंटित करता है।
3. सामान्य फ़ंक्शन कॉल।
4. कॉर्टिन को बुलाओ । कोरुटिन का शरीर एक नियमित ढेर में खड़ा है। कार्यक्रम को उसी तरह से निष्पादित किया जाता है जैसे कि एक नियमित कार्य के मामले में।
5. कोरटाइन से एक नियमित फ़ंक्शन कॉल। फिर से, सब कुछ अभी भी स्टैक पर होता है [नोट: आप इस बिंदु से coroutine को रोक नहीं सकते हैं, क्योंकि यह coroutine में सबसे ऊपरी फ़ंक्शन नहीं है]
6. [: .]
7. – , , .
9. – , + .
10. 5.
11. 6.
12. . .

कोरुटिन का व्यावहारिक उपयोग

• जनरेटर
• अतुल्यकालिक इनपुट / आउटपुट कोड
• आलसी कंप्यूटिंग
• घटना संचालित अनुप्रयोगों

सारांश

• C ++ में आपको समर्पित भाषा सुविधा के रूप में कोरटाइन लागू करने की आवश्यकता क्यों है
• स्टैक किए गए और स्टैकलेस कोरआउट के बीच अंतर क्या है?
• कोरटाइन की आवश्यकता क्यों है