C ++ 20 के लिए तैयार हो रहा है। Coroutines TS Real Case Study

C ++ 20 में, बॉक्स के बाहर कोरआउट के साथ काम करने का अवसर दिखाई देने वाला है। यह विषय Yandex.Taxi पर हमारे लिए करीब और दिलचस्प है। (अपनी जरूरतों के लिए, हम एक अतुल्यकालिक ढांचे का विकास कर रहे हैं)। इसलिए, आज हम Habr के पाठकों को एक वास्तविक उदाहरण का उपयोग करके दिखाएंगे कि C ++ स्टैकलेस कॉरआउट्स के साथ कैसे काम किया जाए।

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

void FuncToDealWith() { InCurrentThread(); writerQueue.PushTask([=]() { InWriterThread1(); const auto finally = [=]() { InWriterThread2(); ShutdownAll(); }; if (NeedNetwork()) { networkQueue.PushTask([=](){ auto v = InNetworkThread(); if (v) { UIQueue.PushTask([=](){ InUIThread(); writerQueue.PushTask(finally); }); } else { writerQueue.PushTask(finally); } }); } else { finally(); } }); } 

परिचय

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

समस्या का बयान

हमारी कई कार्य कतारें हैं। प्रत्येक कार्य में कुछ कार्य होते हैं: ग्राफिक्स खींचने के लिए एक कतार होती है, नेटवर्क इंटरैक्शन के लिए एक कतार होती है, और एक डिस्क के साथ काम करने के लिए एक कतार होती है। सभी कतारें वर्कक्वेय वर्ग के उदाहरण हैं जिनमें शून्य पुष्पक विधि (std :: function <void ()> कार्य) है। कतारें उन सभी कार्यों की तुलना में अधिक समय तक जीवित रहती हैं (जब हम इसमें कोई बकाया कार्य नहीं करते हैं तो ऐसी स्थिति को नष्ट कर देते हैं)।

FuncToDealWith () उदाहरण से कार्य विभिन्न कतारों में कुछ तर्क निष्पादित करता है और, निष्पादन के परिणामों के आधार पर, एक नया कार्य कतार में रखता है।

हम एक रैखिक छद्म कोड के रूप में कॉलबैक के "नूडल्स" को फिर से लिखते हैं, यह चिह्नित करते हुए कि अंतर्निहित कोड को निष्पादित किया जाना चाहिए:

 void CoroToDealWith() { InCurrentThread(); // =>   writerQueue InWriterThread1(); if (NeedNetwork()) { // =>   networkQueue auto v = InNetworkThread(); if (v) { // =>   UIQueue InUIThread(); } } // =>   writerQueue InWriterThread2(); ShutdownAll(); } 

लगभग इस परिणाम को मैं हासिल करना चाहता हूं।

सीमाएँ हैं:

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

निर्णय

पुनर्वितरण FuncToDealWith फ़ंक्शन

Coroutines TS में, coroutine ट्यूनिंग फ़ंक्शन के रिटर्न मान के प्रकार को सेट करके किया जाता है। यदि प्रकार कुछ आवश्यकताओं को पूरा करता है, तो फ़ंक्शन बॉडी के अंदर आप नए कीवर्ड co_await / co_return / co_ield का उपयोग कर सकते हैं। इस उदाहरण में, कतारों के बीच स्विच करने के लिए, हम co_yield का उपयोग करेंगे:

 CoroTask CoroToDealWith() { InCurrentThread(); co_yield writerQueue; InWriterThread1(); if (NeedNetwork()) { co_yield networkQueue; auto v = InNetworkThread(); if (v) { co_yield UIQueue; InUIThread(); } } co_yield writerQueue; InWriterThread2(); ShutdownAll(); } 

यह अंतिम खंड से छद्मकोश के समान निकला। कॉरटाइन्स के साथ काम करने के लिए सभी "जादू" को कोरटस्क क्लास में छिपाया गया है।

CoroTask

सबसे सरल (हमारे) मामले में, कोरटाइन के "ट्यूनर" वर्ग की सामग्री में केवल एक ही उर्फ ​​शामिल है:

 #include <experimental/coroutine> struct CoroTask { using promise_type = PromiseType; }; 

वादा_टाइप एक डेटा प्रकार है जिसे हमें खुद लिखना होगा। इसमें तर्क है जो वर्णन करता है:

• कोरटाइन से बाहर निकलने पर क्या करें
• जब आप पहली बार corutin दर्ज करते हैं तो क्या करें
• जो संसाधनों को मुक्त करता है
• कोरटाइन से बाहर उड़ान के साथ क्या करना है
• कैसे एक CoroTask ऑब्जेक्ट बनाने के लिए
• अगर कॉरटिन के अंदर co_yield कहा जाता है तो क्या करें

उपनाम वादा_ प्रकार को इस तरह से बुलाया जाना चाहिए। यदि आप उपनाम नाम को किसी और चीज़ में बदलते हैं, तो कंपाइलर शपथ लेगा और कहेगा कि आपने कोरोस्क को गलत तरीके से लिखा है। हालाँकि, CoroTask नाम को आप पसंद कर सकते हैं।

PromiseType

मज़ा भाग के लिए हो रही है। हम corutin के व्यवहार का वर्णन करते हैं:

 class WorkQueue; // forward declaration class PromiseType { public: //      `co_return;`     , ... void return_void() const { /* ...    :) */ } //        ,  CoroTask, ... auto initial_suspend() const { // ...       . return std::experimental::suspend_never{}; } //      - , ... auto final_suspend() const { // ...        //      . return std::experimental::suspend_never{}; } //     , ... void unhandled_exception() const { // ...   (  ). std::terminate(); } //    CoroTask,    , ... auto get_return_object() const { // ...  CoroTask. return CoroTask{}; } //     co_yield, ... auto yield_value(WorkQueue& wq) const; // ... <  > }; 

उपरोक्त कोड में, आप डेटा प्रकार std :: प्रयोगात्मक :: suspend_never देख सकते हैं। यह एक विशेष डेटा प्रकार है जो कहता है कि कोरटिन को रोकने की आवश्यकता नहीं है। इसके विपरीत भी है - प्रकार std :: प्रयोगात्मक :: suspend_always, जो आपको कोरटिन को रोकने के लिए कहता है। ये प्रकार तथाकथित प्रतीक्षायोग्य हैं। यदि आप उनकी आंतरिक संरचना में रुचि रखते हैं, तो चिंता न करें, हम जल्द ही हमारे आवाइट्स लिखेंगे।

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

प्रोत्साहन वादा :: उपज_वायु

ऐसा लगता है कि PromiseType :: यील्ड_वेल्यू लिखना काफी सरल है। हमारे पास एक पंक्ति है; कोरटाइन, जिसे निलंबित किया जाना चाहिए और इस बारी में:

 auto PromiseType::yield_value(WorkQueue& wq) { //        std::experimental::coroutine_handle<> this_coro = std::experimental::coroutine_handle<>::from_promise(*this); //    .  this_coro  operator(),    // wq      .   , //     ,  operator(),  //   . wq.PushTask(this_coro); //     . return std::experimental::suspend_always{}; } 

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

सही वादा :: उपज_वायु

इसलिए, हमें पहले कॉरटिन को रोकने की जरूरत है और उसके बाद ही इसे कतार में जोड़ें। ऐसा करने के लिए, हम अपनी Awaitable लिखेंगे और इसे schedule_for_execution कहेंगे:

 auto PromiseType::yield_value(WorkQueue& wq) { struct schedule_for_execution { WorkQueue& wq; constexpr bool await_ready() const noexcept { return false; } void await_suspend(std::experimental::coroutine_handle<> this_coro) const { wq.PushTask(this_coro); } constexpr void await_resume() const noexcept {} }; return schedule_for_execution{wq}; } 

कक्षाएं std :: प्रयोगात्मक :: suspend_always, std :: प्रयोगात्मक :: suspend_never, Schedule_for_execution और अन्य Awaitables में 3 कार्य होने चाहिए। प्रतीक्षा करें पहले से ही यह देखने के लिए कहा जाता है कि क्या कोरटाइन को रोका जाना चाहिए। प्रतीक्षा हो रही है। कार्यक्रम बंद होने के बाद पुकारा जाता है, रुके हुए कोरटाइन के हैंडल को पास किया जाता है। जब coroutine निष्पादन फिर से शुरू हो जाता है, तो wait_resume को कहा जाता है।

हो गया

आप संकलन कर सकते हैं , उदाहरण को ऑनलाइन चला सकते हैं और हर तरह से प्रयोग कर सकते हैं।

धोखा की चादर

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

CoroTask :: वादा_टाइप बताता है कि कैसे और कब कोरटाइन रुकते हैं, संसाधनों को कैसे मुक्त करते हैं, और कैसे CoroTask का निर्माण करते हैं।

प्रतीक्षारत (std :: प्रयोगात्मक :: suspend_always, std :: प्रयोगात्मक :: suspend_never, Schedule_for_execution और अन्य) संकलक को बताएं कि एक विशिष्ट बिंदु पर कॉरटीन के साथ क्या करना है (क्या कोरटिन को रोकने के लिए आवश्यक है, रुके हुए कॉरटिन का क्या करना है और कोरटीन जागने पर क्या करना है) ।

अनुकूलन

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

आइए हम इस दोष को ठीक करें। ऐसा करने के लिए, PromiseType में एक निजी फ़ील्ड जोड़ें:

 WorkQueue* current_queue_ = nullptr; 

इसमें, हम उस क्यू के लिए एक पॉइंटर पकड़ेंगे जिसमें हम वर्तमान में निष्पादित कर रहे हैं।

अगला, वादा करें

 auto PromiseType::yield_value(WorkQueue& wq) { struct schedule_for_execution { const bool do_resume; WorkQueue& wq; constexpr bool await_ready() const noexcept { return do_resume; } void await_suspend(std::experimental::coroutine_handle<> this_coro) const { wq.PushTask(this_coro); } constexpr void await_resume() const noexcept {} }; const bool do_not_suspend = (current_queue_ == &wq); current_queue_ = &wq; return schedule_for_execution{do_not_suspend, wq}; } 

यहाँ हमने शिड्यूल_फोर्स_एक्ज़ीकेशन :: wait_ready () को ट्वीक किया। अब यह फ़ंक्शन कंपाइलर को बताता है कि यदि वर्तमान कार्य जिस पर हम शुरू करने का प्रयास कर रहे हैं, उससे मेल खाता हो तो कोरटाइन को निलंबित करने की आवश्यकता नहीं है।

हो गया। आप हर तरह से प्रयोग कर सकते हैं।

प्रदर्शन के बारे में

मूल उदाहरण में, WorkQueue :: PushTask (std :: function <void ()> f) के हर कॉल के साथ, हमने लैम्ब्डा से क्लास std :: function <void ()> का एक उदाहरण बनाया। वास्तविक कोड में, ये लंबोदा अक्सर आकार में काफी बड़े होते हैं, यही वजह है कि std :: function <void ()> को मेमने को स्टोर करने के लिए स्मृति को आवंटित करने के लिए मजबूर किया जाता है।

Coroutine उदाहरण में, हम std :: function <void ()> std :: प्रयोगात्मक :: coroutine_handle <> के उदाहरण बनाते हैं। Std का आकार :: प्रायोगिक :: coroutine_handle <> कार्यान्वयन पर निर्भर करता है, लेकिन अधिकांश कार्यान्वयन इसके आकार को न्यूनतम रखने का प्रयास करते हैं। तो क्लैंग पर इसका आकार आकार (शून्य *) के बराबर है। जब std :: function <void ()> का निर्माण किया जाता है, तो छोटी वस्तुओं से डायनेमिक एलोकेशन नहीं होता है।
कुल - Coroutines के साथ हमें कई अनावश्यक गतिशील आवंटन से छुटकारा मिला।

लेकिन! कंपाइलर अक्सर स्टैक पर सभी कोरटाइन को नहीं बचा सकता है। इसके कारण, CoroToDealWith में प्रवेश करते समय एक अतिरिक्त गतिशील आवंटन संभव है।

स्टैकलेस बनाम स्टैकफुल

हमने सिर्फ स्टैकलेस कोरटाइन के साथ काम किया, जिसके साथ काम करने के लिए कंपाइलर का समर्थन चाहिए। स्टैकफुल कॉरआउट भी हैं जो पूरी तरह से पुस्तकालय स्तर पर लागू किए जा सकते हैं।

पहले वाले स्मृति के अधिक किफायती आवंटन की अनुमति देते हैं, संभवतः वे संकलक द्वारा बेहतर अनुकूलित होते हैं। मौजूदा परियोजनाओं में दूसरे को लागू करना आसान है, क्योंकि उन्हें कम कोड संशोधनों की आवश्यकता होती है। हालाँकि, इस उदाहरण में आप अंतर महसूस नहीं कर सकते, और अधिक जटिल उदाहरणों की आवश्यकता है।

परिणाम

हमने मूल उदाहरण की जांच की और एक सार्वभौमिक वर्ग कोरोटस्क प्राप्त किया, जिसका उपयोग अन्य कोरटाइन्स बनाने के लिए किया जा सकता है।

इसके साथ कोड भोले दृष्टिकोण के साथ अधिक पठनीय और थोड़ा अधिक उत्पादक हो जाता है:

यह था	कोरटाइन के साथ
void FuncToDealWith() { InCurrentThread(); writerQueue.PushTask([=]() { InWriterThread1(); const auto fin = [=]() { InWriterThread2(); ShutdownAll(); }; if (NeedNetwork()) { networkQueue.PushTask([=](){ auto v = InNetThread(); if (v) { UIQueue.PushTask([=](){ InUIThread(); writerQueue.PushTask(fin); }); } else { writerQueue.PushTask(fin); } }); } else { fin(); } }); }	CoroTask CoroToDealWith() { InCurrentThread(); co_yield writerQueue; InWriterThread1(); if (NeedNetwork()) { co_yield networkQueue; auto v = InNetThread(); if (v) { co_yield UIQueue; InUIThread(); } } co_yield writerQueue; InWriterThread2(); ShutdownAll(); }

ओवरबोर्ड थे कुछ पल:

• कोरुटिन से एक और कॉरआउट को कैसे कॉल करें और इसके पूरा होने की प्रतीक्षा करें
• क्या उपयोगी सामान आप CoroTask में रटना कर सकते हैं
• एक उदाहरण जो स्टैकलेस और स्टैकफुल के बीच अंतर करता है

अन्य

यदि आप C ++ भाषा के अन्य सस्ता माल के बारे में सीखना चाहते हैं या अपने सहयोगियों के साथ pluses पर व्यक्तिगत रूप से संवाद करना चाहते हैं, तो C ++ भाषा सम्मेलन देखें। अगले एक 6 अक्टूबर को निज़नी नोवगोरोड में आयोजित किया जाएगा।

यदि आपके पास C ++ से संबंधित दर्द है और भाषा में कुछ सुधार करना चाहते हैं या बस संभव नवाचारों पर चर्चा करना चाहते हैं, तो https://stdcpp.ru/ में आपका स्वागत है।

ठीक है, अगर यह आपको आश्चर्यचकित करता है कि Yandex.Taxi में बहुत सारे कार्य हैं जो ग्राफ़ से संबंधित नहीं हैं, तो मुझे आशा है कि यह आपके लिए एक सुखद आश्चर्य हो गया :) 11 अक्टूबर को हमें यात्रा करें , हम C ++ और अधिक के बारे में बात करेंगे।