कुछ समय पहले, "आधुनिक भोजन दार्शनिकों" लेख का एक लिंक Reddit और HackerNews जैसे संसाधनों पर फैला है। लेख दिलचस्प है, यह इस प्रसिद्ध कार्य के लिए कई समाधान दिखाता है, आधुनिक सी ++ में कार्य-आधारित दृष्टिकोण का उपयोग करके कार्यान्वित किया गया है। यदि किसी ने अभी तक इस लेख को नहीं पढ़ा है, तो यह समय बिताने और इसे पढ़ने के लिए समझ में आता है।

हालाँकि, मैं यह नहीं कह सकता कि लेख में प्रस्तुत समाधान मुझे सरल और समझ में आता है। यह संभवतः कार्यों के उपयोग के कारण है। उनमें से बहुत से विभिन्न प्रकार के डिस्पैचर / धारावाहिकों के माध्यम से निर्मित और भेजे जाते हैं। इसलिए यह हमेशा स्पष्ट नहीं होता है कि कहां, कब, और कौन से कार्य किए जाते हैं।

इसके अलावा, कार्य-आधारित दृष्टिकोण ऐसी समस्याओं को हल करने के लिए एकमात्र संभव नहीं है। यह क्यों नहीं देखा गया कि अभिनेता और सीएसपी के मॉडल के माध्यम से "डाइनिंग दार्शनिकों" का कार्य कैसे हल किया जाता है?

इसलिए, मैंने एक्टर्स और सीएसपी दोनों का उपयोग करके इस समस्या के कई समाधानों को देखने और कार्यान्वित करने का प्रयास किया। इन समाधानों के लिए कोड GitHub पर भंडार में पाया जा सकता है । और कटर, स्पष्टीकरण और स्पष्टीकरण के तहत, इसलिए जो कोई भी इच्छुक है, कट के तहत स्वागत करता है।

कुछ सामान्य शब्द

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

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

यह "डाइनिंग दार्शनिकों" के उन कार्यों का बोध है जो मैंने करने की कोशिश की थी। उसी समय, कुछ समाधानों ने उल्लेखित लेख (उदाहरण के लिए, ForkLevelPhilosopherProtocol और WaiterFair प्रोटोकॉल द्वारा कार्यान्वित) के समान दृष्टिकोण का उपयोग किया।

मैंने अपने निर्णय SObjectizer के आधार पर बनाए , जो उन लोगों को आश्चर्यचकित करने की संभावना नहीं है, जिन्होंने पहले मेरे लेख पढ़े हैं। यदि किसी ने अभी तक SObjectizer के बारे में नहीं सुना है, संक्षेप में: यह C ++ ( CAF और QP / C ++ के लिए अन्य लोगों के बीच भी उल्लेख किया जा सकता है) के कुछ लाइव और विकासशील ओपनसोर्स "अभिनेता फ्रेमवर्क" में से एक है। मुझे उम्मीद है कि मेरी टिप्पणियों के साथ उपरोक्त उदाहरण SObjectizer से अपरिचित लोगों के लिए भी पर्याप्त स्पष्ट होंगे। यदि नहीं, तो मुझे टिप्पणियों में प्रश्नों का उत्तर देने में खुशी होगी।

अभिनेता समाधान

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

दीजकस्ट्रा का फैसला

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

उदाहरण के लिए, यदि एक दार्शनिक को संख्या 5 और 6 के साथ कांटे का उपयोग करने की आवश्यकता होती है, तो एक दार्शनिक को पहले संख्या 5 का एक कांटा लेना होगा। उसके बाद ही वह संख्या 6 का एक कांटा ले सकता है। इस प्रकार, यदि कम संख्या वाले कांटे दार्शनिकों के बाईं ओर हैं, तो दार्शनिक को चाहिए पहले बाएं कांटे को लें और उसके बाद ही वह दायां कांटा ले सकता है।

सूची में अंतिम दार्शनिक, जिसे संख्याओं (N-1) और 0 पर कांटे का सामना करना पड़ता है, विपरीत करता है: वह पहले नंबर 0 के साथ दायाँ कांटा लेता है, और फिर नंबर (N-1) के साथ बाएँ कांटा लेता है।

इस दृष्टिकोण को लागू करने के लिए, दो प्रकार के अभिनेताओं की आवश्यकता होगी: एक कांटे के लिए और एक दार्शनिकों के लिए। यदि दार्शनिक खाना चाहता है, तो वह कांटे पर कब्जा करने के लिए संबंधित कांटा अभिनेता को संदेश भेजता है, और कांटा अभिनेता प्रतिक्रिया संदेश के साथ प्रतिक्रिया करता है।

इस दृष्टिकोण को लागू करने के लिए कोड यहाँ देखा जा सकता है ।

संदेशों

अभिनेताओं के बारे में बात करने से पहले, आपको उन संदेशों को देखना होगा जो अभिनेता विनिमय करेंगे:

struct take_t { const so_5::mbox_t m_who; std::size_t m_philosopher_index; }; struct taken_t : public so_5::signal_t {}; struct put_t : public so_5::signal_t {}; 

जब अभिनेता-दार्शनिक प्लग लेना चाहता है, तो वह कांटा take_t को take_t संदेश भेजता है, और कांटा अभिनेता ने taken_t संदेश के साथ जवाब दिया। जब अभिनेता-दार्शनिक खाने को खत्म कर देता है और कांटे को वापस मेज पर रखना चाहता है, तो वह put_t -forks को संदेश भेजता है।

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

अभिनेता का कांटा

अब हम देख सकते हैं कि एक कांटा अभिनेता क्या है। यहाँ उसका कोड है:

 class fork_t final : public so_5::agent_t { public : fork_t( context_t ctx ) : so_5::agent_t{ std::move(ctx) } {} void so_define_agent() override { //     'free'. this >>= st_free; //   'free'    . st_free .event( [this]( mhood_t<take_t> cmd ) { this >>= st_taken; so_5::send< taken_t >( cmd->m_who ); } ); //   'taken'   . st_taken .event( [this]( mhood_t<take_t> cmd ) { //     . m_queue.push( cmd->m_who ); } ) .event( [this]( mhood_t<put_t> ) { if( m_queue.empty() ) //     . this >>= st_free; else { //      . const auto who = m_queue.front(); m_queue.pop(); so_5::send< taken_t >( who ); } } ); } private : //    . const state_t st_free{ this, "free" }; const state_t st_taken{ this, "taken" }; //   . std::queue< so_5::mbox_t > m_queue; }; 

SObjectizer में प्रत्येक अभिनेता को बेस क्लास agent_t से प्राप्त किया जाना चाहिए। हम यहाँ टाइप fork_t लिए क्या देखते हैं।

so_define_agent() विधि so_define_agent() वर्ग में ओवरराइड की so_define_agent() । यह एक विशेष विधि है, यह एक नए एजेंट को पंजीकृत करते समय SObjectizer द्वारा स्वचालित रूप से कहा जाता है। so_define_agent() विधि में, so_define_agent() SObjectizer में काम करने के लिए "कॉन्फ़िगर" किया गया है: प्रारंभ स्थिति में परिवर्तन होता है, आवश्यक संदेश सब्सक्राइब किए जाते हैं।

SObjectizer में प्रत्येक अभिनेता राज्यों के साथ एक राज्य मशीन है (भले ही अभिनेता केवल एक डिफ़ॉल्ट राज्य का उपयोग करता है)। fork_t अभिनेता के दो राज्य हैं: निःशुल्क और लिया गया । जब कोई अभिनेता स्वतंत्र अवस्था में होता है, तो दार्शनिक द्वारा प्लग को "कैप्चर" किया जा सकता है। और "कांटा" पर कब्जा करने के बाद, fork_t अभिनेता को लिया स्थिति में जाना चाहिए। fork_t वर्ग के अंदर fork_t स्टेट्स को विशेष state_t प्रकार के st_free और st_taken उदाहरणों द्वारा दर्शाया जाता है।

राज्य आपको आने वाले संदेशों को विभिन्न तरीकों से संसाधित करने की अनुमति देते हैं। उदाहरण के लिए, मुक्त अवस्था में, एजेंट केवल take_t प्रतिक्रिया देता है और यह प्रतिक्रिया बहुत सरल होती है: अभिनेता की स्थिति बदल जाती है और लिया गया प्रतिक्रिया_ taken_t :

 st_free .event( [this]( mhood_t<take_t> cmd ) { this >>= st_taken; so_5::send< taken_t >( cmd->m_who ); } ); 

जबकि मुक्त अवस्था में put_t सहित अन्य सभी संदेशों को आसानी से अनदेखा कर दिया जाता है।

ली गई स्थिति में, अभिनेता दो संदेशों को संसाधित करता है, और यहां तक ​​कि take_t संदेश को भी अलग तरीके से संसाधित करता है:

 st_taken .event( [this]( mhood_t<take_t> cmd ) { m_queue.push( cmd->m_who ); } ) .event( [this]( mhood_t<put_t> ) { if( m_queue.empty() ) this >>= st_free; else { const auto who = m_queue.front(); m_queue.pop(); so_5::send< taken_t >( who ); } } ); 

put_t लिए हैंडलर put_t सबसे दिलचस्प put_t : यदि प्रतीक्षा दार्शनिकों की कतार खाली है, तो हम मुफ्त में लौट सकते हैं, लेकिन अगर यह खाली नहीं है, तो उनमें से पहले को भेजा जाना चाहिए।

दार्शनिक अभिनेता

अभिनेता-दार्शनिक का कोड बहुत अधिक चमकदार है, इसलिए मैं इसे यहां पूर्ण रूप से नहीं दूंगा। हम केवल सबसे महत्वपूर्ण अंशों पर चर्चा करेंगे।

एक अभिनेता-दार्शनिक के पास कुछ और राज्य हैं:

 state_t st_thinking{ this, "thinking.normal" }; state_t st_wait_left{ this, "wait_left" }; state_t st_wait_right{ this, "wait_right" }; state_t st_eating{ this, "eating" }; state_t st_done{ this, "done" }; 

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

एक अभिनेता-दार्शनिक के लिए राज्य चित्र को निम्नानुसार दर्शाया जा सकता है:

अभिनेता के व्यवहार का तर्क उसके so_define_agent() विधि के कार्यान्वयन में वर्णित है:

 void so_define_agent() override { //   thinking     stop_thinking. st_thinking .event( [=]( mhood_t<stop_thinking_t> ) { //    . this >>= st_wait_left; so_5::send< take_t >( m_left_fork, so_direct_mbox(), m_index ); } ); //        taken. st_wait_left .event( [=]( mhood_t<taken_t> ) { //     .   . this >>= st_wait_right; so_5::send< take_t >( m_right_fork, so_direct_mbox(), m_index ); } ); //    ,    taken. st_wait_right .event( [=]( mhood_t<taken_t> ) { //    ,  . this >>= st_eating; } ); //      stop_eating. st_eating // 'stop_eating'        'eating'. .on_enter( [=] { so_5::send_delayed< stop_eating_t >( *this, eat_pause() ); } ) .event( [=]( mhood_t<stop_eating_t> ) { //      . so_5::send< put_t >( m_right_fork ); so_5::send< put_t >( m_left_fork ); //     . ++m_meals_eaten; if( m_meals_count == m_meals_eaten ) this >>= st_done; //  ,  ,  . else think(); } ); st_done .on_enter( [=] { //   ,   . completion_watcher_t::done( so_environment(), m_index ); } ); } 

शायद एकमात्र बिंदु जिसे विशेष रूप से जोर दिया जाना चाहिए वह "सोच" और "खाने" की प्रक्रियाओं की नकल करने का दृष्टिकोण है। वर्तमान कार्य थ्रेड को ब्लॉक करने के लिए अभिनेता के कोड या किसी अन्य तरीके से this_thread::sleep_for नहीं this_thread::sleep_for है। इसके बजाय, लंबित संदेशों का उपयोग किया जाता है। उदाहरण के लिए, जब कोई अभिनेता खाने की स्थिति में प्रवेश करता है, तो वह खुद को एक लंबित stop_eating_t संदेश भेजता है। यह संदेश SObjectizer टाइमर को दिया गया है और समय आने पर टाइमर अभिनेता को संदेश भेजता है।

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

परिणाम

इस कार्यान्वयन के परिणाम निम्नानुसार हो सकते हैं (एक छोटा टुकड़ा):

  Socrates: tttttttttttLRRRRRRRRRRRRRREEEEEEEttttttttLRRRRRRRRRRRRRREEEEEEEEEEEEE Plato: ttttttttttEEEEEEEEEEEEEEEEttttttttttRRRRRREEEEEEEEEEEEEEttttttttttLLL Aristotle: ttttEEEEEtttttttttttLLLLLLRRRREEEEEEEEEEEEttttttttttttLLEEEEEEEEEEEEE Descartes: tttttLLLLRRRRRRRREEEEEEEEEEEEEtttLLLLLLLLLRRRRREEEEEEttttttttttLLLLLL Spinoza: ttttEEEEEEEEEEEEEttttttttttLLLRRRREEEEEEEEEEEEEttttttttttRRRREEEEEEtt Kant: ttttttttttLLLLLLLRREEEEEEEEEEEEEEEttttttttttLLLEEEEEEEEEEEEEEtttttttt Schopenhauer: ttttttEEEEEEEEEEEEEttttttLLLLLLLLLEEEEEEEEEttttttttLLLLLLLLLLRRRRRRRR Nietzsche: tttttttttLLLLLLLLLLEEEEEEEEEEEEEttttttttLLLEEEEEEEEEttttttttRRRRRRRRE Wittgenstein: ttttEEEEEEEEEEtttttLLLLLLLLLLLLLEEEEEEEEEttttttttttttRRRREEEEEEEEEEEt Heidegger: tttttttttttLLLEEEEEEEEEEEEEEtttttttLLLLLLREEEEEEEEEEEEEEEtttLLLLLLLLR Sartre: tttEEEEEEEEEttttLLLLLLLLLLLLRRRRREEEEEEEEEtttttttLLLLLLLLRRRRRRRRRRRR 

इसे इस प्रकार पढ़ें:

• t दर्शाता है कि दार्शनिक "सोच" है;
• L मतलब है कि दार्शनिक को बाएं कांटे पर कब्जा करने की उम्मीद है ( प्रतीक्षा_लेफ्ट अवस्था में है);
• R मतलब है कि दार्शनिक सही कांटे पर कब्जा करने की उम्मीद कर रहा है ( इंतजार की स्थिति में है);
• E अर्थ है कि दार्शनिक "खाता है।"

हम देख सकते हैं कि सार्त्र के दूर होने के बाद ही सुकरात बाईं ओर कांटा ले जा सकता है। जिसके बाद सुकरात तब तक इंतजार करेगा जब तक प्लेटो सही कांटा जारी नहीं करता। इसके बाद ही सुकरात खा सकेंगे।

मध्यस्थ (वेटर) के बिना एक सरल निर्णय

यदि हम दिज्क्स्ट्रा के निर्णय के परिणाम का विश्लेषण करते हैं, तो हम देखेंगे कि दार्शनिकों को कांटे पर कब्जा करने के लिए इंतजार करने में बहुत समय लगता है। क्या अच्छा नहीं है, क्योंकि यह समय परावर्तन पर भी खर्च किया जा सकता है। यह कुछ भी नहीं है कि एक राय है कि यदि आप खाली पेट पर सोचते हैं, तो आप बहुत अधिक रोचक और अप्रत्याशित परिणाम प्राप्त कर सकते हैं;)

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

इस कार्यान्वयन के लिए स्रोत कोड यहाँ देखा जा सकता है , और इसी दार्शनिक अभिनेता के लिए कोड यहाँ ।

संदेशों

यह समाधान संदेशों के लगभग समान सेट का उपयोग करता है:

 struct take_t { const so_5::mbox_t m_who; std::size_t m_philosopher_index; }; struct busy_t : public so_5::signal_t {}; struct taken_t : public so_5::signal_t {}; struct put_t : public so_5::signal_t {}; 

एकमात्र अंतर busy_t सिग्नल की उपस्थिति है। अभिनेता-कांटा दार्शनिक-अभिनेता के जवाब में यह संकेत भेजता है यदि कांटा पहले से ही किसी अन्य दार्शनिक द्वारा कब्जा कर लिया गया हो।

अभिनेता का कांटा

इस समाधान में कांटा अभिनेता, दिज्क्स्ट्रा के समाधान से भी सरल है:

 class fork_t final : public so_5::agent_t { public : fork_t( context_t ctx ) : so_5::agent_t( ctx ) { this >>= st_free; st_free.event( [this]( mhood_t<take_t> cmd ) { this >>= st_taken; so_5::send< taken_t >( cmd->m_who ); } ); st_taken.event( []( mhood_t<take_t> cmd ) { so_5::send< busy_t >( cmd->m_who ); } ) .just_switch_to< put_t >( st_free ); } private : const state_t st_free{ this }; const state_t st_taken{ this }; }; 

यहां हमें प्रतीक्षा दार्शनिकों की कतार को बनाए रखने की आवश्यकता नहीं है।

दार्शनिक अभिनेता

इस कार्यान्वयन में दार्शनिक-अभिनेता, दिज्क्स्ट्रा के समाधान के समान है, लेकिन यहाँ दार्शनिक-अभिनेता को busy_t प्रक्रिया busy_t , इसलिए राज्य चित्र इस तरह दिखता है:

इसी तरह, एक अभिनेता-दार्शनिक का पूरा तर्क so_define_agent() में परिभाषित किया गया है:

 void so_define_agent() override { st_thinking .event< stop_thinking_t >( [=] { this >>= st_wait_left; so_5::send< take_t >( m_left_fork, so_direct_mbox(), m_index ); } ); st_wait_left .event< taken_t >( [=] { this >>= st_wait_right; so_5::send< take_t >( m_right_fork, so_direct_mbox(), m_index ); } ) .event< busy_t >( [=] { think( st_hungry_thinking ); } ); st_wait_right .event< taken_t >( [=] { this >>= st_eating; } ) .event< busy_t >( [=] { so_5::send< put_t >( m_left_fork ); think( st_hungry_thinking ); } ); st_eating .on_enter( [=] { so_5::send_delayed< stop_eating_t >( *this, eat_pause() ); } ) .event< stop_eating_t >( [=] { so_5::send< put_t >( m_right_fork ); so_5::send< put_t >( m_left_fork ); ++m_meals_eaten; if( m_meals_count == m_meals_eaten ) this >>= st_done; else think( st_normal_thinking ); } ); st_done .on_enter( [=] { completion_watcher_t::done( so_environment(), m_index ); } ); } 

सामान्य तौर पर, यह दिज्क्स्ट्रा के समाधान में लगभग समान कोड है, busy_t लिए हैंडलर्स के एक जोड़े को छोड़कर।

परिणाम

कार्य के परिणाम अलग दिखते हैं:

  Socrates: tttttttttL..R.....EEEEEEEEEEEEttttttttttR...LL..EEEEEEEttEEEEEE Plato: ttttEEEEEEEEEEEttttttL.....L..EEEEEEEEEEEEEEEttttttttttL....L.... Aristotle: ttttttttttttL..LR.EEEEEEtttttttttttL..L....L....R.....EEEEEEEEE Descartes: ttttttttttEEEEEEEEttttttttttttEEEEEEEEttttEEEEEEEEEEEttttttL..L.. Spinoza: ttttttttttL.....L...EEEEEEtttttttttL.L......L....L..L...R...R...E Kant: tttttttEEEEEEEttttttttL.L.....EEEEEEEEttttttttR...R..R..EEEEEtttt Schopenhauer: tttR..R..L.....EEEEEEEttttttR.....L...EEEEEEEEEEEEEEEEttttttttttt Nietzsche: tttEEEEEEEEEEtttttttttEEEEEEEEEEEEEEEttttL....L...L..L....EEEEEEE Wittgenstein: tttttL.L..L.....RR....L.....L....L...EEEEEEEEEEEEEEEtttttttttL. Heidegger: ttttR..R......EEEEEEEEEEEEEttttttttttR..L...L...L..L...EEEEtttttt Sartre: tttEEEEEEEtttttttL..L...L....R.EEEEEEEtttttEEEEtttttttR.....R..R. 

यहां हम एक नया प्रतीक देखते हैं, जिसका अर्थ है कि अभिनेता-दार्शनिक "भूखे विचारों" में है।

इस छोटे से टुकड़े में भी, कोई भी देख सकता है कि लंबे समय के दौरान दार्शनिक भोजन नहीं कर सकते हैं। ऐसा इसलिए है क्योंकि यह समाधान गतिरोध की समस्या से सुरक्षित है, लेकिन भुखमरी से सुरक्षा नहीं है।

वेटर और कतार के साथ निर्णय

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

आइए एक नज़र डालते हैं कि यह वही समाधान अभिनेताओं पर कैसे लग सकता है।

इस कार्यान्वयन का स्रोत कोड यहां पाया जा सकता है ।

चाल

सबसे आसान तरीका संदेशों का एक नया सेट पेश करना होगा, जिसके माध्यम से दार्शनिक वेटर के साथ संवाद कर सकते हैं। लेकिन मैं न केवल संदेशों के पहले से मौजूद सेट (यानी take_t , taken_t , busy_t , put_t ) को बचाना चाहता था। मैं यह भी चाहता था कि पिछले समाधान में भी उसी अभिनेता-दार्शनिक का उपयोग किया जाए। इसलिए, मुझे एक मुश्किल समस्या को हल करना था: अभिनेता-दार्शनिक को एकमात्र अभिनेता-वेटर के साथ कैसे संवाद करना है, लेकिन एक ही समय में सोचा कि वह सीधे अभिनेताओं-कांटे (जो पहले से ही चले गए हैं) के साथ बातचीत करता है।

इस समस्या को एक सरल चाल का उपयोग करके हल किया गया था: एक अभिनेता-वेटर mbox-s का एक सेट बनाता है, लिंक जो दार्शनिक-अभिनेताओं को कांटा अभिनेताओं के mbox-s के लिंक के रूप में दिया जाता है। उसी समय, अभिनेता-वेटर इन सभी मोक्स से संदेशों की सदस्यता लेता है (जो आसानी से SObjectizer में कार्यान्वित किया जाता है, क्योंकि SObjectizer न केवल / जैसा कि कई अभिनेताओं के मॉडल का कार्यान्वयन है, लेकिन Pub / Sub भी "बॉक्स से बाहर" समर्थित है) ।

कोड में, यह कुछ इस तरह दिखता है:

 class waiter_t final : public so_5::agent_t { public : waiter_t( context_t ctx, std::size_t forks_count ) : so_5::agent_t{ std::move(ctx) } , m_fork_states( forks_count, fork_state_t::free ) { //  mbox-   "" m_fork_mboxes.reserve( forks_count ); for( std::size_t i{}; i != forks_count; ++i ) m_fork_mboxes.push_back( so_environment().create_mbox() ); } ... void so_define_agent() override { //      "". for( std::size_t i{}; i != m_fork_mboxes.size(); ++i ) { //     .   . //          //    . so_subscribe( fork_mbox( i ) ) .event( [i, this]( mhood_t<take_t> cmd ) { on_take_fork( std::move(cmd), i ); } ) .event( [i, this]( mhood_t<put_t> cmd ) { on_put_fork( std::move(cmd), i ); } ); } } private : ... //     "". std::vector< so_5::mbox_t > m_fork_mboxes; 

यानी पहले, गैर-मौजूद "कांटे" के लिए एमबॉक्स-एस का एक वेक्टर बनाएं, फिर उनमें से प्रत्येक की सदस्यता लें। हां, हम यह जानने के लिए सदस्यता लेते हैं कि अनुरोध किस विशेष प्लग से संबंधित है।

on_take_fork() अनुरोध के लिए वास्तविक हैंडलर on_take_fork() विधि है:

 void on_take_fork( mhood_t<take_t> cmd, std::size_t fork_index ) { //   ,       //    . if( fork_index == cmd->m_philosopher_index ) handle_take_left_fork( std::move(cmd), fork_index ); else handle_take_right_fork( std::move(cmd), fork_index ); } 

वैसे, यह यहाँ था कि हमें take_t संदेश से दूसरे क्षेत्र की आवश्यकता थी।

तो, on_take_fork() हमारे पास मूल अनुरोध और कांटे का सूचकांक है जिससे अनुरोध संबंधित है। इसलिए, हम यह निर्धारित कर सकते हैं कि दार्शनिक एक बाएं कांटा या एक सही के लिए पूछता है। और, तदनुसार, हम उन्हें अलग तरीके से संसाधित कर सकते हैं (और हमें उन्हें अलग तरीके से संसाधित करना होगा)।

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

1. दोनों कांटे स्वतंत्र हैं और अनुरोध भेजने वाले दार्शनिक को दिए जा सकते हैं। इस मामले में, हम दार्शनिक taken_t , और सही कांटे को आरक्षित के रूप में चिह्नित करते हैं ताकि कोई और इसे न ले सके।
2. दार्शनिक को कांटे नहीं दिए जा सकते। कोई फर्क नहीं पड़ता क्यों। शायद उनमें से कुछ अभी व्यस्त हैं। या लाइन में दार्शनिक के पड़ोसियों में से एक है। वैसे भी, हमने अनुरोध भेजने वाले दार्शनिक को कतार में खड़ा कर दिया, जिसके बाद हम उसे busy_t ।

काम के इस तर्क के लिए धन्यवाद, दार्शनिक जो बाएं कांटे के लिए taken_t प्राप्त taken_t है, वह सही कांटे के लिए take_t अनुरोध भेज सकता है। यह अनुरोध तुरंत संतुष्ट हो जाएगा, जैसा कि कांटा पहले से ही इस दार्शनिक के लिए आरक्षित है।

परिणाम

यदि आप परिणामी समाधान चलाते हैं, तो आप कुछ इस तरह देख सकते हैं:

  Socrates: tttttttttttL....EEEEEEEEEEEEEEttttttttttL...L...EEEEEEEEEEEEEtttttL. Plato: tttttttttttL....L..L..L...L...EEEEEEEEEEEEEtttttL.....L....L.....EEE Aristotle: tttttttttL.....EEEEEEEEEttttttttttL.....L.....EEEEEEEEEEEtttL....LL Descartes: ttEEEEEEEEEEtttttttL.L..EEEEEEEEEEEEtttL..L....L....L.....EEEEEEEEEE Spinoza: tttttttttL.....EEEEEEEEEttttttttttL.....L.....EEEEEEEEEEEtttL....LL Kant: ttEEEEEEEEEEEEEtttttttL...L.....L.....EEEEEttttL....L...L..L...EEEEE Schopenhauer: ttttL...L.....L.EEEEEEEEEEEEEEEEEtttttttttttL..L...L..EEEEEEEttttttt Nietzsche: tttttttttttL....L..L..L...L...L.....L....EEEEEEEEEEEEttL.....L...L.. Wittgenstein: tttttttttL....L...L....L....L...EEEEEEEttttL......L.....L.....EEEEEE Heidegger: ttttttL..L...L.....EEEEEEEEEEEEtttttL...L..L.....EEEEEEEEEEEttttttL. Sartre: ttEEEEEEEEEEEEEttttttttL.....L...EEEEEEEEEEEEttttttttttttL.....EEEEE 

आप पात्रों R की कमी पर ध्यान दे सकते हैं R ऐसा इसलिए है क्योंकि विफल या अपेक्षाएँ एक सही कांटे के अनुरोध पर नहीं हो सकती हैं।

मध्यस्थ (वेटर) का उपयोग कर एक और निर्णय

कुछ मामलों में, पिछले waiter_with_queue समाधान इस के समान परिणाम दिखा सकते हैं:

  Socrates: tttttEEEEEEEEEEEEEEtttL.....LL...L....EEEEEEEEEttttttttttL....L.....EE Plato: tttttL..L..L....LL...EEEEEEEEEEEEEEEttttttttttttL.....EEEEEEEEEttttttt Aristotle: tttttttttttL..L...L.....L.....L....L.....EEEEEEEEEEEEtttttttttttL....L.. Descartes: ttttttttttEEEEEEEEEEttttttL.....L....L..L.....L.....L..L...L..EEEEEEEEtt Spinoza: tttttttttttL..L...L.....L.....L....L.....L..L..L....EEEEEEEEEEtttttttttt Kant: tttttttttL....L....L...L...L....L..L...EEEEEEEEEEEttttttttttL...L......E Schopenhauer: ttttttL....L..L...L...LL...L...EEEEEtttttL....L...L.....EEEEEEEEEttttt Nietzsche: tttttL..L..L....EEEEEEEEEEEEEttttttttttttEEEEEEEEEEEEEEEttttttttttttL... Wittgenstein: tttEEEEEEEEEEEEtttL....L....L..EEEEEEEEEtttttL..L..L....EEEEEEEEEEEEEEEE Heidegger: tttttttttL...L..EEEEEEEEttttL..L.....L...EEEEEEEEEtttL.L..L...L....L...L Sartre: ttttttttttL..L....L...L.EEEEEEEEEEEtttttL...L..L....EEEEEEEEEEtttttttttt 

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

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

इस समस्या को हल करने के लिए, मैंने एक और समाधान लागू किया, waiter_with_timestamp (इसका कोड यहां पाया जा सकता है )। कतारबद्ध होने के बजाय, वे दार्शनिकों से उनके उपवास के समय को ध्यान में रखते हुए अनुरोधों को प्राथमिकता देते हैं। दार्शनिक जितनी देर भूखा रहेगा, उतनी ही प्राथमिकता उसके अनुरोध की होगी।

हम इस समाधान के लिए कोड पर विचार नहीं करेंगे, क्योंकि द्वारा और इसमें मुख्य बात यह है कि किसी भी "कांटे" के लिए mboxes के एक सेट के साथ एक ही चाल है, जिसे हमने पहले ही बातचीत में waiter_with_queue के कार्यान्वयन के बारे में चर्चा की थी।

कुछ कार्यान्वयन विवरण जो मैं ध्यान आकर्षित करना चाहूंगा

अभिनेताओं पर आधारित कार्यान्वयन में कई विवरण हैं, जिन पर मैं ध्यान देना चाहूंगा, क्योंकि ये विवरण SObjectizer की दिलचस्प विशेषताओं को प्रदर्शित करते हैं।

अभिनेताओं के लिए काम का संदर्भ

fork_t क्रियान्वयन में, सभी मुख्य अभिनेताओं ( fork_t , philosopher_t , waiter_t ) ने एक सामान्य कार्य सूत्र के संदर्भ में काम किया। जिसका मतलब यह नहीं है कि SObjectizer में सभी कलाकार केवल एक ही धागे पर काम करते हैं। SObjectizer में, आप अभिनेताओं को विभिन्न संदर्भों में बाँध सकते हैं, जिन्हें देखा जा सकता है, उदाहरण के लिए, no_waiter_simple समाधान में run_simulation() फ़ंक्शन के कोड में।

 void run_simulation( so_5::environment_t & env, const names_holder_t & names ) { env.introduce_coop( [&]( so_5::coop_t & coop ) { coop.make_agent_with_binder< trace_maker_t >( so_5::disp::one_thread::create_private_disp( env )->binder(), names, random_pause_generator_t::trace_step() ); coop.make_agent_with_binder< completion_watcher_t >( so_5::disp::one_thread::create_private_disp( env )->binder(), names ); const auto count = names.size(); std::vector< so_5::agent_t * > forks( count, nullptr ); for( std::size_t i{}; i != count; ++i ) forks[ i ] = coop.make_agent< fork_t >(); for( std::size_t i{}; i != count; ++i ) coop.make_agent< philosopher_t >( i, forks[ i ]->so_direct_mbox(), forks[ (i + 1) % count ]->so_direct_mbox(), default_meals_count ); }); } 

इस फ़ंक्शन में, trace_maker_t और trace_maker_t के प्रकार के अतिरिक्त कलाकार completion_watcher_t । वे व्यक्तिगत काम के संदर्भों पर काम करेंगे। ऐसा करने के लिए, one_thread प्रकार के डिस्पैचर के दो उदाहरण one_thread जाते हैं और अभिनेता डिस्पैचर के इन उदाहरणों से बंधे होते हैं। जिसका अर्थ है कि ये कलाकार सक्रिय वस्तुओं के रूप में काम करेंगे: प्रत्येक का अपना कार्य सूत्र होगा।

SObjectizer कई अलग-अलग डिस्पैचर का एक सेट प्रदान करता है जिसका उपयोग बॉक्स के ठीक बाहर किया जा सकता है। इस मामले में, डेवलपर अपने आवेदन में डेवलपर की जरूरत के अनुसार डिस्पैचर के कई उदाहरण बना सकता है।

, , . , fork_t , philosopher_t .

 void run_simulation( so_5::environment_t & env, const names_holder_t & names ) { env.introduce_coop( [&]( so_5::coop_t & coop ) { coop.make_agent_with_binder< trace_maker_t >( so_5::disp::one_thread::create_private_disp( env )->binder(), names, random_pause_generator_t::trace_step() ); coop.make_agent_with_binder< completion_watcher_t >( so_5::disp::one_thread::create_private_disp( env )->binder(), names ); const auto count = names.size(); //     thread_pool-. so_5::disp::thread_pool::bind_params_t bind_params; bind_params.fifo( so_5::disp::thread_pool::fifo_t::individual ); std::vector< so_5::agent_t * > forks( count, nullptr ); //     -. auto fork_disp = so_5::disp::thread_pool::create_private_disp( env, 3u //  . ); for( std::size_t i{}; i != count; ++i ) //      . forks[ i ] = coop.make_agent_with_binder< fork_t >( fork_disp->binder( bind_params ) ); //     -. auto philosopher_disp = so_5::disp::thread_pool::create_private_disp( env, 6u //  . ); for( std::size_t i{}; i != count; ++i ) coop.make_agent_with_binder< philosopher_t >( philosopher_disp->binder( bind_params ), i, forks[ i ]->so_direct_mbox(), forks[ (i + 1) % count ]->so_direct_mbox(), default_meals_count ); }); } 

fork_t philosopher_t .

Modern dining philosophers , , :

 void doEat() { eventLog_.startActivity(ActivityType::eat); wait(randBetween(10, 50)); eventLog_.endActivity(ActivityType::eat); 

SObjectizer . , , . किस कारण से?

, SObjectizer- : . agent_state_listener_t . , SObjectizer .

greedy_philosopher_t philosopher_t :

 philosopher_t(...) ... { so_add_destroyable_listener( state_watcher_t::make( so_environment(), index ) ); } 

state_watcher_t — .

 class state_watcher_t final : public so_5::agent_state_listener_t { const so_5::mbox_t m_mbox; const std::size_t m_index; state_watcher_t( so_5::mbox_t mbox, std::size_t index ); public : static auto make( so_5::environment_t & env, std::size_t index ) { return so_5::agent_state_listener_unique_ptr_t{ new state_watcher_t{ trace_maker_t::make_mbox(env), index } }; } void changed( so_5::agent_t &, const so_5::state_t & state ) override; }; 

state_watcher_t SObjectizer changed() . state_watcher_t::changed -.

 void state_watcher_t::changed( so_5::agent_t &, const so_5::state_t & state ) { const auto detect_label = []( const std::string & name ) {...}; const char state_label = detect_label( state.query_name() ); if( '?' == state_label ) return; so_5::send< trace::state_changed_t >( m_mbox, m_index, state_label ); } 

CSP

, . (no_waiter_dijkstra, no_waiter_simple, waiter_with_timestamps) std::thread SObjectizer- mchain- (, , CSP- ). , , CSP- ( take_t , taken_t , busy_t , put_t ).

CSP- "" . , std::thread .

.

: + take_t put_t . fork_process :

 void fork_process( so_5::mchain_t fork_ch ) { //  :   . bool taken = false; //   . std::queue< so_5::mbox_t > wait_queue; //        . so_5::receive( so_5::from( fork_ch ), [&]( so_5::mhood_t<take_t> cmd ) { if( taken ) //  ,     . wait_queue.push( cmd->m_who ); else { //    . taken = true; so_5::send< taken_t >( cmd->m_who ); } }, [&]( so_5::mhood_t<put_t> ) { if( wait_queue.empty() ) taken = false; //     . else { //       . const auto who = wait_queue.front(); wait_queue.pop(); so_5::send< taken_t >( who ); } } ); } 

fork_process : , - .

fork_process — "" , . receive() :

 so_5::receive( so_5::from( fork_ch ), [&]( so_5::mhood_t<take_t> cmd ) {...}, [&]( so_5::mhood_t<put_t> ) {...} ); 

SObjectizer- receive() . . . , . , .

-. fork_t . , , .

philosopher_process . , .

 oid philosopher_process( trace_maker_t & tracer, so_5::mchain_t control_ch, std::size_t philosopher_index, so_5::mbox_t left_fork, so_5::mbox_t right_fork, int meals_count ) { int meals_eaten{ 0 }; random_pause_generator_t pause_generator; //         . auto self_ch = so_5::create_mchain( control_ch->environment() ); while( meals_eaten < meals_count ) { tracer.thinking_started( philosopher_index, thinking_type_t::normal ); //    . std::this_thread::sleep_for( pause_generator.think_pause( thinking_type_t::normal ) ); //    . tracer.take_left_attempt( philosopher_index ); so_5::send< take_t >( left_fork, self_ch->as_mbox(), philosopher_index ); //  ,  . so_5::receive( so_5::from( self_ch ).handle_n( 1u ), [&]( so_5::mhood_t<taken_t> ) { //   ,   . tracer.take_right_attempt( philosopher_index ); so_5::send< take_t >( right_fork, self_ch->as_mbox(), philosopher_index ); //  ,  . so_5::receive( so_5::from( self_ch ).handle_n( 1u ), [&]( so_5::mhood_t<taken_t> ) { //    .  . tracer.eating_started( philosopher_index ); //     . std::this_thread::sleep_for( pause_generator.eat_pause() ); //     . ++meals_eaten; //     . so_5::send< put_t >( right_fork ); } ); //     . so_5::send< put_t >( left_fork ); } ); } //   ,   . tracer.philosopher_done( philosopher_index ); so_5::send< philosopher_done_t >( control_ch, philosopher_index ); } 

:

 void philosopher_process( trace_maker_t & tracer, so_5::mchain_t control_ch, std::size_t philosopher_index, so_5::mbox_t left_fork, so_5::mbox_t right_fork, int meals_count ) 

.

SObjectizer- , , Actor-. :

 tracer.thinking_started( philosopher_index, thinking_type_t::normal ); 

tracer , .

control_ch , philosopher_done_t , , . .

left_fork right_fork . take_t put_t . , mbox_t mchain_t ?

! , . , mchain — - mbox-, mchain- mbox_t .

, :

 int meals_eaten{ 0 }; random_pause_generator_t pause_generator; auto self_ch = so_5::create_mchain( control_ch->environment() ); 

— self_ch . , .

. यानी , .

, , this_thread::sleep_for .

, :

 so_5::send< take_t >( left_fork, self_ch->as_mbox(), philosopher_index ); 

take_t . mbox_t , self_ch mchain_t . as_mbox() .

receive() :

 so_5::receive( so_5::from( self_ch ).handle_n( 1u ), [&]( so_5::mhood_t<taken_t> ) {...} ); 

taken_t . . , .

- , philosopher_process . receive() :

 so_5::receive( so_5::from( self_ch ).handle_n( 1u ), [&]( so_5::mhood_t<taken_t> ) { ... so_5::receive( so_5::from( self_ch ).handle_n( 1u ), [&]( so_5::mhood_t<taken_t> ) {...} ); ... } ); 

- .

run_simulation() , . CSP- run_simulation() . , , ( ).

 void run_simulation( so_5::environment_t & env, const names_holder_t & names ) noexcept { const auto table_size = names.size(); const auto join_all = []( std::vector<std::thread> & threads ) { for( auto & t : threads ) t.join(); }; trace_maker_t tracer{ env, names, random_pause_generator_t::trace_step() }; //  . std::vector< so_5::mchain_t > fork_chains; std::vector< std::thread > fork_threads( table_size ); for( std::size_t i{}; i != table_size; ++i ) { //     . fork_chains.emplace_back( so_5::create_mchain(env) ); //     . fork_threads[ i ] = std::thread{ fork_process, fork_chains.back() }; } //      . auto control_ch = so_5::create_mchain( env ); //  . const auto philosopher_maker = [&](auto index, auto left_fork_idx, auto right_fork_idx) { return std::thread{ philosopher_process, std::ref(tracer), control_ch, index, fork_chains[ left_fork_idx ]->as_mbox(), fork_chains[ right_fork_idx ]->as_mbox(), default_meals_count }; }; std::vector< std::thread > philosopher_threads( table_size ); for( std::size_t i{}; i != table_size - 1u; ++i ) { //      . philosopher_threads[ i ] = philosopher_maker( i, i, i+1u ); } //        . philosopher_threads[ table_size - 1u ] = philosopher_maker( table_size - 1u, table_size - 1u, 0u ); //     . so_5::receive( so_5::from( control_ch ).handle_n( table_size ), [&names]( so_5::mhood_t<philosopher_done_t> cmd ) { fmt::print( "{}: done\n", names[ cmd->m_philosopher_index ] ); } ); //     . join_all( philosopher_threads ); //     . for( auto & ch : fork_chains ) so_5::close_drop_content( ch ); //       . join_all( fork_threads ); //  . tracer.done(); //   SObjectizer. env.stop(); } 

, run_simulation() - . .

. :

 std::vector< so_5::mchain_t > fork_chains; std::vector< std::thread > fork_threads( table_size ); for( std::size_t i{}; i != table_size; ++i ) { fork_chains.emplace_back( so_5::create_mchain(env) ); fork_threads[ i ] = std::thread{ fork_process, fork_chains.back() }; } 

, , . . , join .

, .. join :

 std::vector< std::thread > philosopher_threads( table_size ); for( std::size_t i{}; i != table_size - 1u; ++i ) { philosopher_threads[ i ] = philosopher_maker( i, i, i+1u ); } philosopher_threads[ table_size - 1u ] = philosopher_maker( table_size - 1u, table_size - 1u, 0u ); 

. :

 so_5::receive( so_5::from( control_ch ).handle_n( table_size ), [&names]( so_5::mhood_t<philosopher_done_t> cmd ) { fmt::print( "{}: done\n", names[ cmd->m_philosopher_index ] ); } ); 

receive() table_size philosopher_done_t .

philosopher_done_t .

join :

 join_all( philosopher_threads ); 

join . join , .. . receive() . join :

 for( auto & ch : fork_chains ) so_5::close_drop_content( ch ); join_all( fork_threads ); 

.

noexcept

, run_simulation , noexcept . , exception-safety . — .

run_simulation ?

, . - exception-safety , . - , :

 try { for( std::size_t i{}; i != table_size; ++i ) { fork_chains.emplace_back( so_5::create_mchain(env) ); fork_threads[ i ] = std::thread{ fork_process, fork_chains.back() }; } } catch( ... ) { for( std::size_t i{}; i != fork_chains.size(); ++i ) { so_5::close_drop_content( fork_chains[ i ] ); if( fork_threads[ i ].joinable() ) fork_threads[ i ].join(); } throw; } 

, . क्योंकि , . - :

 struct fork_threads_stuff_t { std::vector< so_5::mchain_t > m_fork_chains; std::vector< std::thread > m_fork_threads; fork_threads_stuff_t( std::size_t table_size ) : m_fork_threads( table_size ) {} ~fork_threads_stuff_t() { for( std::size_t i{}; i != m_fork_chains.size(); ++i ) { so_5::close_drop_content( m_fork_chains[ i ] ); if( m_fork_threads[ i ].joinable() ) m_fork_threads[ i ].join(); } } void run() { for( std::size_t i{}; i != m_fork_threads.size(); ++i ) { m_fork_chains.emplace_back( so_5::create_mchain(env) ); m_fork_threads[ i ] = std::thread{ fork_process, m_fork_chains.back() }; } } } fork_threads_stuff{ table_size }; //   . fork_threads_stuff.run(); //     . //       fork_threads_stuff. 

, (, Boost- ScopeExit-, GSL- finally() ).

. .

, exception-safety run_simulation() , run_simulation() , . , -. exception-safety run_simulation() noexcept , std::terminate . , .

, , , , . , join , join . .

()

, CSP- , .

.

fork_process , :

 void fork_process( so_5::mchain_t fork_ch ) { //  :   . bool taken = false; //      . so_5::receive( so_5::from( fork_ch ), [&]( so_5::mhood_t<take_t> cmd ) { if( taken ) so_5::send< busy_t >( cmd->m_who ); else { taken = true; so_5::send< taken_t >( cmd->m_who ); } }, [&]( so_5::mhood_t<put_t> ) { if( taken ) taken = false; } ); } 

, fork_process , ( , ).

philosopher_process , , .

 void philosopher_process( trace_maker_t & tracer, so_5::mchain_t control_ch, std::size_t philosopher_index, so_5::mbox_t left_fork, so_5::mbox_t right_fork, int meals_count ) { int meals_eaten{ 0 }; //       . thinking_type_t thinking_type{ thinking_type_t::normal }; random_pause_generator_t pause_generator; //      . auto self_ch = so_5::create_mchain( control_ch->environment() ); while( meals_eaten < meals_count ) { tracer.thinking_started( philosopher_index, thinking_type ); //    . std::this_thread::sleep_for( pause_generator.think_pause( thinking_type ) ); //  ,     . thinking_type = thinking_type_t::hungry; //    . tracer.take_left_attempt( philosopher_index ); so_5::send< take_t >( left_fork, self_ch->as_mbox(), philosopher_index ); //  ,  . so_5::receive( so_5::from( self_ch ).handle_n( 1u ), []( so_5::mhood_t<busy_t> ) { /*     */ }, [&]( so_5::mhood_t<taken_t> ) { //   ,   . tracer.take_right_attempt( philosopher_index ); so_5::send< take_t >( right_fork, self_ch->as_mbox(), philosopher_index ); //  ,  . so_5::receive( so_5::from( self_ch ).handle_n( 1u ), []( so_5::mhood_t<busy_t> ) { /*     */ }, [&]( so_5::mhood_t<taken_t> ) { //    ,  . tracer.eating_started( philosopher_index ); //     . std::this_thread::sleep_for( pause_generator.eat_pause() ); //     . ++meals_eaten; //      . so_5::send< put_t >( right_fork ); //        "normal". thinking_type = thinking_type_t::normal; } ); //       . so_5::send< put_t >( left_fork ); } ); } //    . tracer.philosopher_done( philosopher_index ); so_5::send< philosopher_done_t >( control_ch, philosopher_index ); } 

- philosopher_process philosopher_process . .

-, thinking_type . , , , "" .

-, busy_t . receive() :

 so_5::receive( so_5::from( self_ch ).handle_n( 1u ), []( so_5::mhood_t<busy_t> ) { /*     */ }, [&]( so_5::mhood_t<taken_t> ) { ... so_5::receive( so_5::from( self_ch ).handle_n( 1u ), []( so_5::mhood_t<busy_t> ) { /*     */ }, [&]( so_5::mhood_t<taken_t> ) {...} ); 

, busy_t , , receive() , receive() . busy_t . , .. receive() busy_t . receive() busy_t .

CSP- , . (): waiter_with_queue, , waiter_with_timestamps. : mbox- , mbox- , mbox- .

CSP- , philosopher_process no_waiter_simple. mchain- , ?

, .

mchain- . , mchain-.

SObjectizer- select() , , , :

 so_5::select( so_5::from_all(), case_(ch1, one_handler_1, one_handler_2, one_handler_3, ...), case_(ch2, two_handler_1, two_handler_2, two_handler_3, ...), ...); 

select() , -. " " . CSP- .

.

, , take_t put_t . - . take_t put_t , :

 struct extended_take_t final : public so_5::message_t { const so_5::mbox_t m_who; const std::size_t m_philosopher_index; const std::size_t m_fork_index; extended_take_t( so_5::mbox_t who, std::size_t philosopher_index, std::size_t fork_index ) : m_who{ std::move(who) } , m_philosopher_index{ philosopher_index } , m_fork_index{ fork_index } {} }; struct extended_put_t final : public so_5::message_t { const std::size_t m_fork_index; extended_put_t( std::size_t fork_index ) : m_fork_index{ fork_index } {} }; 

, so_5::message_t , ( ). , SObjectizer- .

, . take_t put_t , extended_take_t extended_put_t , .

mbox. :)

 class wrapping_mbox_t final : public so_5::extra::mboxes::proxy::simple_t { using base_type_t = so_5::extra::mboxes::proxy::simple_t; //    . const so_5::mbox_t m_target; //  ,      . const std::size_t m_fork_index; //    . static std::type_index original_take_type; static std::type_index original_put_type; public : wrapping_mbox_t( const so_5::mbox_t & target, std::size_t fork_index ) : base_type_t{ target } , m_target{ target } , m_fork_index{ fork_index } {} //    so_5::abstract_message_box_t   . //       . void do_deliver_message( const std::type_index & msg_type, const so_5::message_ref_t & message, unsigned int overlimit_reaction_deep ) const override { if( original_take_type == msg_type ) { //     . const auto & original_msg = so_5::message_payload_type<::take_t>:: payload_reference( *message ); //     . so_5::send< extended_take_t >( m_target, original_msg.m_who, original_msg.m_philosopher_index, m_fork_index ); } else if( original_put_type == msg_type ) { //     . so_5::send< extended_put_t >( m_target, m_fork_index ); } else base_type_t::do_deliver_message( msg_type, message, overlimit_reaction_deep ); } //       wrapping_mbox_t. static auto make( const so_5::mbox_t & target, std::size_t fork_index ) { return so_5::mbox_t{ new wrapping_mbox_t{ target, fork_index } }; } }; std::type_index wrapping_mbox_t::original_take_type{ typeid(::take_t) }; std::type_index wrapping_mbox_t::original_put_type{ typeid(::put_t) }; 

mbox-: so_5_extra , . so_5::abstract_message_box_t .

, wrapping_mbox_t . , . wrapping_mbox, mchain . waiter_process , , :

 void waiter_process( so_5::mchain_t waiter_ch, details::waiter_logic_t & logic ) { //        . so_5::receive( so_5::from( waiter_ch ), [&]( so_5::mhood_t<details::extended_take_t> cmd ) { logic.on_take_fork( std::move(cmd) ); }, [&]( so_5::mhood_t<details::extended_put_t> cmd ) { logic.on_put_fork( std::move(cmd) ); } ); } 

, , . waiter_with_timestamps .

: " philosopher_process mbox-?" , waiter_with_timestamps mbox, mchain.

, mchain. , .. so_5_extra mchain- ( ). mbox- mchain-.

निष्कर्ष

, , , CSP . , . , , . , - .

, SObjectizer-. , "" SObjectizer — 5.6, 5.5. , ( ). - , SO-5.6 ( ).

, !

पुनश्च। "" , . C++14.