SObjectizer और इसके इतिहास के बारे में कुछ शब्द

सोबिजाइज़र एक छोटा सी C ++ फ्रेमवर्क है जो मल्टीथ्रेडेड अनुप्रयोगों के विकास को सरल करता है। SObjectizer एक डेवलपर को एक्टर, पब्लिश-सब्सक्राइब और कम्युनिकेटिंग सेक्शनल प्रॉसेस (CSP) मॉडल के दृष्टिकोण का उपयोग करने की अनुमति देता है। यह एक OpenSource प्रोजेक्ट है जिसे BSD-3-CLAUSE लाइसेंस के तहत वितरित किया गया है।

SObjectizer का एक लंबा इतिहास रहा है। SObjectizer स्वयं 2002 में SObjectizer-4 प्रोजेक्ट के रूप में पैदा हुआ था। लेकिन यह पिछले SCADA ऑब्जेक्टिज़र के विचारों पर आधारित था जो 1995 और 2000 के बीच विकसित किया गया था। SObjectizer-4 2006 में खुला था, लेकिन इसके विकास को इसके तुरंत बाद रोक दिया गया था। SObjectizer-5 नाम के साथ SObjectizer का एक नया संस्करण 2010 में शुरू किया गया था और 2013 में इसे ओपन-सोर्स किया गया था। SObjectizer-5 का विकास अभी भी जारी है और SObjectizer-5 ने 2013 के बाद कई नई विशेषताओं को शामिल किया है।

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

SObjectizer और इसी तरह के उपकरणों के लिए एक आला

मल्टीथ्रेडिंग का उपयोग समानांतर कंप्यूटिंग के साथ-साथ समवर्ती कंप्यूटिंग में किया जाता है । लेकिन समानांतर और समवर्ती कंप्यूटिंग के बीच एक बड़ा अंतर है। और, एक परिणाम के रूप में, समानांतर कंप्यूटिंग को लक्षित उपकरण हैं, और समवर्ती कंप्यूटिंग के लिए उपकरण हैं, और वे अलग हैं।

मोटे तौर पर, गणना समय को कम करने के लिए समानांतर कंप्यूटिंग कई कोर का उपयोग करने के बारे में है। उदाहरण के लिए, एक वीडियो फ़ाइल को एक प्रारूप से दूसरे प्रारूप में ट्रांसकोड करना एक सीपीयू कोर पर एक घंटे ले सकता है, लेकिन चार सीपीयू कोर पर सिर्फ 15 मिनट। OpenMP, Intel TBB, HPX या cpp-taskflow जैसे उपकरण समानांतर कंप्यूटिंग में उपयोग किए जाने के लिए डिज़ाइन किए गए हैं। और वे उपकरण उस क्षेत्र के दृष्टिकोण के लिए उपयुक्त हैं, जैसे कार्य-आधारित या डेटा-प्रवाह प्रोग्रामिंग।

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

अभिनेता मॉडल या सीएसपी जैसे दृष्टिकोण समवर्ती कंप्यूटिंग से निपटने के लिए अभिप्रेत हैं। समवर्ती कंप्यूटिंग क्षेत्र में उपयोग अभिनेताओं के अच्छे उदाहरण हैं InfineSQL परियोजना और यैंडेक्स संदेश-कतार । उन दोनों परियोजनाओं के अंदर के कलाकार उपयोग करते हैं।

इसलिए SObjectizer, QP / C ++ या CAF जैसे उपकरण, जो अभिनेता मॉडल का समर्थन करते हैं, समवर्ती कंप्यूटिंग क्षेत्र से कार्यों को हल करने में उपयोगी हैं। इसका अर्थ है कि SObjectizer का उपयोग संभवतः आपको वीडियो स्ट्रीम के रूपांतरण जैसे कार्यों में कुछ भी नहीं देगा। लेकिन आप SOBjectizer के शीर्ष पर एक संदेश दलाल को लागू करने के लिए एक बहुत अलग परिणाम प्राप्त कर सकते हैं।

त्याग

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

SObjectizer एक उपयोगकर्ता को क्या दे सकता है?

साझा-कुछ भी नहीं और आग-विस्मृत सिद्धांत सिर्फ बॉक्स से बाहर

अभिनेताओं का उपयोग किसी भी साझा किए गए डेटा की अनुपस्थिति को मानता है। प्रत्येक अभिनेता अपने डेटा का मालिक है और यह डेटा किसी और को दिखाई नहीं देता है। यह साझा-कुछ भी सिद्धांत नहीं है जो एक उदाहरण के लिए वितरित अनुप्रयोग विकास में अच्छी तरह से जाना जाता है। मल्टीथ्रेडेड एप्लिकेशन में साझा-कुछ सिद्धांत का एक महत्वपूर्ण लाभ है: यह साझा डेटा के साथ काम के लिए ऐसी खतरनाक समस्याओं से बचने की अनुमति देता है जैसे गतिरोध और डेटा-दौड़।

SObjectizer में अभिनेताओं (एजेंटों) के बीच सहभागिता केवल अतुल्यकालिक संदेशों के माध्यम से की जाती है। एक एजेंट दूसरे एजेंट को संदेश भेजता है और यह ऑपरेशन प्रेषक (एक सामान्य मामले में) को अवरुद्ध नहीं करता है।

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

उदाहरण के लिए, एक एजेंट हो सकता है जो स्वीकृत कनेक्शन पढ़ता है और आने वाले डेटा को पार्स करता है। यदि पूरे पीडीयू को पढ़ा जाता है और एजेंट को पार्स किया जाता है, तो वह पीडीयू दूसरे एजेंट-प्रोसेसर को भेजता है और नए आने वाले डेटा को पढ़ने / पार्स करने के लिए वापस लौटता है।

प्रेषक

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

SObjectizer में डिस्पैचर और एजेंटों के साथ सबसे अच्छी बात यह है कि अवधारणाओं का पृथक्करण: डिस्पैचर काम के संदर्भ और स्वयं संदेश कतारों के प्रबंधन के लिए जिम्मेदार हैं, एजेंट आवेदन तर्क करते हैं और कार्यकर्ता संदर्भ के बारे में परेशान नहीं करते हैं। यह एक एजेंट को एक डिस्पैचर से दूसरे पर क्लिक करके शाब्दिक रूप से ले जाने की अनुमति देता है। कल एक एजेंट ने one_thread डिस्पैचर पर काम किया, आज हम इसे active_obj डिस्पैचर में रिबंड कर सकते हैं, और कल हम इसे थ्रेड_पूल डिस्पैचर में रिबंड कर सकते हैं। एजेंट के कार्यान्वयन में एक पंक्ति को बदलने के बिना।

SObjectizer-5.6.0 में आठ प्रकार के डिस्पैचर हैं (और एक अन्य को so5extra साथी प्रोजेक्ट में पाया जा सकता है): बहुत ही सरल (one_thread या थ्रेड_पूल) से परिष्कृत लोगों (जैसे adv_thol_pool या prio_dedicated_threads :: one_per_prio) तक शुरू करना। और एक उपयोगकर्ता विशिष्ट स्थितियों के लिए अपना स्वयं का डिस्पैचर लिख सकता है।

पदानुक्रमित राज्य मशीनों में अंतर्निहित कार्यक्षमता होती है

SObjectizer में एजेंट (अभिनेता) राज्य मशीन हैं: एक आने वाले संदेश पर प्रतिक्रिया एजेंट की वर्तमान स्थिति पर निर्भर करती है। SObjectizer अधिकांश पदानुक्रमित राज्य मशीनों (HSM) सुविधाओं का समर्थन करता है: नेस्टेड अवस्थाएँ, एक राज्य के लिए गहरी, और उथले इतिहास, on_enter / on_exit हैंडलर, एक राज्य में रहने की समय सीमा। SObjectizer में अब केवल ऑर्थोगोनल राज्यों का समर्थन नहीं किया गया है (हमने अपनी परियोजनाओं में उस सुविधा की आवश्यकता नहीं देखी, और किसी ने हमें उस सुविधा के लिए समर्थन जोड़ने के लिए नहीं कहा)।

सीएसपी जैसे चैनल सिर्फ आउट ऑफ बॉक्स हैं

SObjectizer के एजेंटों (उर्फ अभिनेताओं) का उपयोग करने की कोई आवश्यकता नहीं है। पूरे एप्लिकेशन को केवल std::thread ऑब्जेक्ट्स और SObjectizer के माचिन (उर्फ CSP- चैनल) का उपयोग करके विकसित किया जा सकता है। उस स्थिति में SObjectizer के साथ एप्लिकेशन डेवलपमेंट कुछ हद तक Go लैंग्वेज में डेवलपमेंट के समान होगा (इसमें Go के select कंस्ट्रक्शन का एनालॉग भी शामिल है जो कई चैनलों के संदेशों को इंतजार करने की अनुमति देता है)।

सोबिजाइज़र के मचिन्स में एक बहुत ही महत्वपूर्ण विशेषता हो सकती है: बैक-प्रेशर मैकेनिज्म। यदि कोई उपयोगकर्ता आकार-सीमित माचिन बनाता है और फिर किसी संदेश को पूर्ण मचिन में धकेलने की कोशिश करता है तो भेजने वाला ऑपरेशन कुछ समय के लिए प्रेषक को ब्लॉक कर सकता है। यह एक तेज निर्माता और एक धीमी उपभोक्ता के साथ एक प्रसिद्ध समस्या को हल करने की अनुमति देता है।

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

एप्लिकेशन के केवल कुछ भाग ही एसओबीजेनाइज़र का उपयोग कर सकते हैं

एक आवेदन पर हर हिस्से में SObjectizer का उपयोग करने की आवश्यकता नहीं है। SObjectizer का उपयोग करके किसी एप्लिकेशन के केवल एक भाग को विकसित किया जा सकता है। इसलिए यदि आप पहले से ही Qt या wxWidgets, या Boost.Asio का उपयोग अपने आवेदन के मुख्य ढांचे के रूप में करते हैं, तो अपने ऐप के सिर्फ एक सबमॉड्यूल में SObjectize का उपयोग करना संभव है।

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

यदि SObjectizer का उपयोग केवल अनुप्रयोग के एक भाग में किया जाता है तो SObjectizer- और गैर-SObjectizer-अनुप्रयोग के कुछ हिस्सों के बीच संचार का कार्य होता है। यह कार्य आसानी से हल हो गया है: नॉन-सोबिजाइजर-पार्ट से एसओबीजेलाइजर-पार्ट के संदेश साधारण संदेश-वितरण एसओबीजेनाइजर के तंत्र के माध्यम से भेजे जा सकते हैं। विपरीत दिशा में संदेश mchains के माध्यम से दिया जा सकता है।

आप एक ही समय में SObjectizer के कई उदाहरण चला सकते हैं

SObjectizer एक ही समय में एक आवेदन में SObjectizer (जिसे SObjectizer पर्यावरण कहा जाता है) के कई उदाहरणों को चलाने की अनुमति देता है। हर SObjectizer पर्यावरण ऐसे अन्य वातावरणों से स्वतंत्र होगा।

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

टाइमर SObjectizer का हिस्सा हैं

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

SObjectizer में विभिन्न अनुकूलन बिंदु और ट्यूनिंग विकल्प हैं

SObjectizer कई महत्वपूर्ण तंत्रों के अनुकूलन की अनुमति देता है। उदाहरण के लिए, एक उपयोगकर्ता टाइमर_थ्रेड (या टाइमर_मनगर) के मानक कार्यान्वयन में से एक का चयन कर सकता है। या अपना खुद का कार्यान्वयन प्रदान कर सकते हैं। एक उपयोगकर्ता SObjectizer के डिस्पैचर्स में संदेश कतारों द्वारा उपयोग की जाने वाली लॉक ऑब्जेक्ट के कार्यान्वयन का चयन कर सकता है। या अपना खुद का कार्यान्वयन प्रदान कर सकते हैं।

एक उपयोगकर्ता अपने स्वयं के डिस्पैचर को लागू कर सकता है। एक उपयोगकर्ता अपने संदेश बॉक्स को लागू कर सकता है। एक उपयोगकर्ता अपने स्वयं के संदेश लिफाफे को लागू कर सकता है। एक उपयोगकर्ता अपने स्वयं के event_queue_hook को लागू कर सकता है। और इसी तरह।

जहाँ SObjectizer का उपयोग किया जा सकता है या नहीं किया जा सकता है?

यह कहना बहुत आसान है कि वस्तु के कारणों से SObjectizer का उपयोग कहां नहीं किया जा सकता है। इसलिए हम ऐसे क्षेत्रों की गणना करके चर्चा शुरू करते हैं और फिर हम अतीत में (और न केवल अतीत में) SObjectizer के उपयोग के कुछ उदाहरण देंगे।

जहाँ SObjectizer का उपयोग नहीं किया जा सकता है?

समानांतर कंप्यूटिंग से संबंधित कार्य

जैसा कि अभिनेता के ऊपर कहा गया है- और सीएसपी-मॉडल उच्च-प्रदर्शन कंप्यूटिंग और समानांतर कंप्यूटिंग के अन्य क्षेत्रों के लिए एक अच्छा विकल्प नहीं है। इसलिए अगर आपको कई मैट्रिक्स या ट्रांसकोड वीडियो स्ट्रीम करने हैं तो OpenMP, Intel TBB, cpp-taskflow, HPX या MPI जैसे टूल अधिक उपयुक्त होंगे।

कठिन वास्तविक समय प्रणाली

इस तथ्य के बावजूद कि SObjectizer की जड़ें SCADA- सिस्टम में हैं, SObjectizer (aka SObjectizer-5) का वर्तमान कार्यान्वयन कठिन वास्तविक समय प्रणालियों में उपयोग नहीं किया जा सकता है। यह मुख्य रूप से SObjectizer कार्यान्वयन में गतिशील मेमोरी के उपयोग के कारण है: संदेश गतिशील रूप से आवंटित ऑब्जेक्ट हैं (हालांकि, SObjectizer संदेश के रूप में प्रचारित वस्तुओं का उपयोग कर सकते हैं), डिस्पैचर संदेश कतार के लिए गतिशील मेमोरी का उपयोग करते हैं, यहां तक ​​कि एजेंट के राज्यों की समय-सीमा गतिशील रूप से आवंटित वस्तुओं का उपयोग करते हैं। समय-जाँच करने के लिए।

दुर्भाग्य से, आधुनिक दुनिया में "वास्तविक समय" शब्द का अत्यधिक उपयोग किया जाता है। यह अक्सर वास्तविक समय की वेब सेवाओं के बारे में कहा जाता है, जैसे "वास्तविक समय वेब अनुप्रयोग" या "वास्तविक समय वेब विश्लेषिकी" और इसी तरह। "ऑन-लाइन" या "लाइव" शब्द "वास्तविक-समय" शब्द की तुलना में ऐसे अनुप्रयोगों के लिए अधिक उपयुक्त है, यहां तक ​​कि "सॉफ्ट रियल-टाइम" फॉर्म में भी। इस प्रकार, यदि हम "रीयल-टाइम वेब एप्लिकेशन" जैसी किसी चीज़ के बारे में बोलते हैं, तो SObjectizer को आसानी से ऐसे "रियल-टाइम" सिस्टम में उपयोग किया जा सकता है।

विवश एम्बेडेड सिस्टम

SObjectizer C ++ मानक पुस्तकालय पर निर्भर करता है: std::thread का उपयोग थ्रेड प्रबंधन के लिए किया जाता है, std::atomic , std::mutex , std::condition_variable डेटा सिंक्रोनाइज़ेशन के लिए उपयोग किया जाता है, RTTI और डायनेमिक_कास्ट का उपयोग SObjectizer को इन्सुलेट करता है (उदाहरण के लिए) , std::type_index का उपयोग संदेश प्रकार की पहचान के लिए किया जाता है), C ++ अपवाद का उपयोग त्रुटि रिपोर्टिंग के लिए किया जाता है।

इसका अर्थ है कि SObjectizer का उपयोग उन वातावरणों में नहीं किया जा सकता है जहाँ मानक पुस्तकालय की ऐसी सुविधाएँ उपलब्ध नहीं हैं। उदाहरण के लिए, विवश एम्बेडेड सिस्टम के विकास में जहां C ++ और C ++ stdlib का केवल एक हिस्सा उपयोग किया जा सकता है।

अतीत में SObjectizer का उपयोग कहां किया गया था?

अब हम SObjectizer के उपयोग के कुछ मामलों के बारे में संक्षेप में बोलने की कोशिश करते हैं (अतीत में ही नहीं)। दुर्भाग्य से, यह पूरी जानकारी नहीं है क्योंकि कुछ समस्याएं हैं।

सबसे पहले, हम सबजेक्ट के सभी उपयोगों के बारे में नहीं जानते हैं। एसओबीजेनाइजर मुफ्त सॉफ्टवेयर है जिसे मालिकाना परियोजनाओं में भी इस्तेमाल किया जा सकता है। इसलिए कुछ लोग बस SObjectizer प्राप्त करते हैं और हमारे लिए कोई प्रतिक्रिया प्रदान किए बिना इसका उपयोग करते हैं। कभी-कभी हम SObjectizer के उपयोग के बारे में कुछ जानकारी प्राप्त करते हैं (लेकिन बिना किसी विवरण के), कभी-कभी हमें कुछ नहीं पता होता है।

दूसरी समस्या किसी विशेष परियोजना में SObjectizer के उपयोग के बारे में जानकारी साझा करने की अनुमति है। हमें वह अनुमति बहुत कम ही मिली है, ज्यादातर मामलों में SObjectizer के उपयोगकर्ता अपनी परियोजनाओं का कार्यान्वयन विवरण नहीं खोलना चाहते हैं (कभी-कभी हम कारणों को समझते हैं, कभी-कभी ऐसा नहीं करते हैं)।

हम इस तथ्य के लिए क्षमा चाहते हैं कि प्रदान की गई जानकारी इतनी दुर्लभ है और इसमें कोई विवरण नहीं है। फिर भी, SObjectizer के उपयोग के कुछ उदाहरण हैं:

• एसएमएस / यूएसएसडी एग्रीगेशन गेटवे जो प्रति माह 500M से अधिक संदेशों को संभालता है;
• सबसे बड़े रूसी बैंकों में से एक के एटीएम के माध्यम से ऑनलाइन भुगतान की सेवा करने वाले सिस्टम का हिस्सा;
• आर्थिक प्रक्रियाओं के सिमुलेशन मॉडलिंग (पीएचडी अनुसंधान के भाग के रूप में);
• वितरित डाटा अधिग्रहण और विश्लेषणात्मक प्रणाली। केंद्रीय नोड से कमांड द्वारा दुनिया भर में वितरित बिंदुओं पर एकत्रित डेटा। MQTT का उपयोग नियंत्रण के लिए एक परिवहन के रूप में किया गया और डेटा वितरण का अधिग्रहण किया गया;
• रेलवे उपकरणों के लिए वास्तविक समय नियंत्रण प्रणाली की जाँच के लिए पर्यावरण परीक्षण;
• थिएटर दृश्यों के लिए स्वचालित नियंत्रण प्रणाली। अधिक विवरण यहां पाया जा सकता है ;
• एक ऑनलाइन विज्ञापन प्रणाली में डेटा प्रबंधन मंच के घटक।

SObjectizer का स्वाद

आइए SObjectizer का कुछ स्वाद लेने के लिए कई सरल उदाहरण देखें। वे बहुत सरल उदाहरण हैं, जो हमें उम्मीद है, कोड में टिप्पणियों को छोड़कर अतिरिक्त स्पष्टीकरण की आवश्यकता नहीं है।

अभिनेता मॉडल की शैली में पारंपरिक "हैलो, वर्ल्ड" उदाहरण

केवल एक एजेंट के साथ सबसे सरल उदाहरण जो hello संदेश पर प्रतिक्रिया करता है और अपना काम पूरा करता है:

 #include <so_5/all.hpp> // Message to be sent to an agent. struct hello { std::string greeting_; }; // Demo agent. class demo final : public so_5::agent_t { void on_hello(mhood_t<hello> cmd) { std::cout << "Greeting received: " << cmd->greeting_ << std::endl; // Now agent can finish its work. so_deregister_agent_coop_normally(); } public: // There is no need is a separate constructor. using so_5::agent_t::agent_t; // Preparation of agent to work inside SObjectizer. void so_define_agent() override { // Subscription to 'hello' message. so_subscribe_self().event(&demo::on_hello); } }; int main() { // Run SObjectizer instance. so_5::launch([](so_5::environment_t & env) { // Make and register an instance of demo agent. auto mbox = env.introduce_coop([](so_5::coop_t & coop) { auto * a = coop.make_agent<demo>(); return a->so_direct_mbox(); }); // Send hello message to registered agent. so_5::send<hello>(mbox, "Hello, World!"); }); } 

एजेंटों और प्रकाशित / सदस्यता मॉडल के साथ "हैलो, वर्ल्ड" का एक और संस्करण

कई एजेंटों के साथ सबसे सरल उदाहरण, उनमें से सभी hello संदेश के एक ही उदाहरण पर प्रतिक्रिया करते हैं:

 #include <so_5/all.hpp> using namespace std::string_literals; // Message to be sent to an agent. struct hello { std::string greeting_; }; // Demo agent. class demo final : public so_5::agent_t { const std::string name_; void on_hello(mhood_t<hello> cmd) { std::cout << name_ << ": greeting received: " << cmd->greeting_ << std::endl; // Now agent can finish its work. so_deregister_agent_coop_normally(); } public: demo(context_t ctx, std::string name, so_5::mbox_t board) : agent_t{std::move(ctx)} , name_{std::move(name)} { // Create a subscription for hello message from board. so_subscribe(board).event(&demo::on_hello); } }; int main() { // Run SObjectizer instance. so_5::launch([](so_5::environment_t & env) { // Mbox to be used for speading hello message. auto board = env.create_mbox(); // Create several agents in separate coops. for(const auto & n : {"Alice"s, "Bob"s, "Mike"s}) env.register_agent_as_coop(env.make_agent<demo>(n, board)); // Spread hello message to all subscribers. so_5::send<hello>(board, "Hello, World!"); }); } 

यदि हम उस उदाहरण को चलाते हैं तो हमें ऐसा कुछ प्राप्त हो सकता है:

 Alice: greeting received: Hello, World! Bob: greeting received: Hello, World! Mike: greeting received: Hello, World! 

सीएसपी-शैली में "हैलो, वर्ल्ड" उदाहरण

आइए बिना किसी एक्टर्स के SObjectizer का एक उदाहरण देखें, बस std::thread और CSP-like चैनल।

बहुत ही सरल संस्करण

यह एक बहुत ही सरल संस्करण है जो अपवाद सुरक्षित नहीं है:

 #include <so_5/all.hpp> // Message to be sent to a channel. struct hello { std::string greeting_; }; void demo_thread_func(so_5::mchain_t ch) { // Wait while hello received. so_5::receive(so_5::from(ch).handle_n(1), [](so_5::mhood_t<hello> cmd) { std::cout << "Greeting received: " << cmd->greeting_ << std::endl; }); } int main() { // Run SObjectizer in a separate thread. so_5::wrapped_env_t sobj; // Channel to be used. auto ch = so_5::create_mchain(sobj); std::thread demo_thread{demo_thread_func, ch}; // Send a greeting. so_5::send<hello>(ch, "Hello, World!"); // Wait for demo thread. demo_thread.join(); } 

अधिक मजबूत, लेकिन अभी भी सरल संस्करण

यह अपवाद सुरक्षा के अलावा ऊपर दिखाए गए उदाहरण का एक संशोधित संस्करण है:

 #include <so_5/all.hpp> // Message to be sent to a channel. struct hello { std::string greeting_; }; void demo_thread_func(so_5::mchain_t ch) { // Wait while hello received. so_5::receive(so_5::from(ch).handle_n(1), [](so_5::mhood_t<hello> cmd) { std::cout << "Greeting received: " << cmd->greeting_ << std::endl; }); } int main() { // Run SObjectizer in a separate thread. so_5::wrapped_env_t sobj; // Demo thread. We need object now, but thread will be started later. std::thread demo_thread; // Auto-joiner for the demo thread. auto demo_joiner = so_5::auto_join(demo_thread); // Channel to be used. This channel will be automatically closed // in the case of an exception. so_5::mchain_master_handle_t ch_handle{ so_5::create_mchain(sobj), so_5::mchain_props::close_mode_t::retain_content }; // Now we can run demo thread. demo_thread = std::thread{demo_thread_func, *ch_handle}; // Send a greeting. so_5::send<hello>(*ch_handle, "Hello, World!"); // There is no need to wait for something explicitly. } 

एक साधारण एचएसएम उदाहरण: ब्लिंकिंग_ल्ड

यह SObjectizer के वितरण से एक मानक उदाहरण है। इस उदाहरण का मुख्य एजेंट एक एचएसएम है जिसे निम्नलिखित राज्यचर्चा द्वारा वर्णित किया जा सकता है:

उदाहरण के स्रोत कोड:

 #include <iostream> #include <so_5/all.hpp> class blinking_led final : public so_5::agent_t { state_t off{ this }, blinking{ this }, blink_on{ initial_substate_of{ blinking } }, blink_off{ substate_of{ blinking } }; public : struct turn_on_off final : public so_5::signal_t {}; blinking_led( context_t ctx ) : so_5::agent_t{ ctx } { this >>= off; off.just_switch_to< turn_on_off >( blinking ); blinking.just_switch_to< turn_on_off >( off ); blink_on .on_enter( []{ std::cout << "ON" << std::endl; } ) .on_exit( []{ std::cout << "off" << std::endl; } ) .time_limit( std::chrono::milliseconds{1500}, blink_off ); blink_off .time_limit( std::chrono::milliseconds{750}, blink_on ); } }; int main() { try { so_5::launch( []( so_5::environment_t & env ) { auto m = env.introduce_coop( []( so_5::coop_t & coop ) { auto led = coop.make_agent< blinking_led >(); return led->so_direct_mbox(); } ); auto pause = []( unsigned int v ) { std::this_thread::sleep_for( std::chrono::seconds{v} ); }; std::cout << "Turn blinking on for 10s" << std::endl; so_5::send< blinking_led::turn_on_off >( m ); pause( 10 ); std::cout << "Turn blinking off for 5s" << std::endl; so_5::send< blinking_led::turn_on_off >( m ); pause( 5 ); std::cout << "Turn blinking on for 5s" << std::endl; so_5::send< blinking_led::turn_on_off >( m ); pause( 5 ); std::cout << "Stopping..." << std::endl; env.stop(); } ); } catch( const std::exception & ex ) { std::cerr << "Error: " << ex.what() << std::endl; } return 0; } 

टाइमर, एक एजेंट और active_obj डिस्पैचर के लिए अधिभार नियंत्रण

अधिभार नियंत्रण अभिनेताओं के लिए मुख्य समस्याओं में से एक है: अभिनेताओं के लिए संदेश-कतारें आमतौर पर असीमित होती हैं और इससे कतारों की अनियंत्रित वृद्धि हो सकती है यदि एक तेज संदेश निर्माता संदेश जल्दी भेजता है तो रिसीवर उन्हें संभाल सकता है। निम्न उदाहरण संदेश सीमा के रूप में इस तरह के SObjectizer की सुविधा को दर्शाता है । यह एजेंट की कतार में संदेशों की गिनती को सीमित करने और अनावश्यक संदेशों से रिसीवर की रक्षा करने की अनुमति देता है।

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

 #include <so_5/all.hpp> using namespace std::chrono_literals; // Message to be sent to the consumer. struct task { int task_id_; }; // An agent for utilization of unhandled tasks. class trash_can final : public so_5::agent_t { public: // There is no need is a separate constructor. using so_5::agent_t::agent_t; // Preparation of agent to work inside SObjectizer. void so_define_agent() override { // Subscription to 'task' message. // Event-handler is specified in the form of a lambda-function. so_subscribe_self().event([](mhood_t<task> cmd) { std::cout << "unhandled task: " << cmd->task_id_ << std::endl; }); } }; // The consumer of 'task' messages. class consumer final : public so_5::agent_t { public: // We need the constructor. consumer(context_t ctx, so_5::mbox_t trash_mbox) : so_5::agent_t{ctx + // Only three 'task' messages can wait in the queue. limit_then_redirect<task>(3, // All other messages will go to that mbox. [trash_mbox]{ return trash_mbox; })} { // Define a reaction to incoming 'task' message. so_subscribe_self().event([](mhood_t<task> cmd) { std::cout << "handling task: " << cmd->task_id_ << std::endl; std::this_thread::sleep_for(75ms); }); } }; // The producer of 'test' messages. class producer final : public so_5::agent_t { const so_5::mbox_t dest_; so_5::timer_id_t task_timer_; int id_counter_{}; // Type of periodic signal to produce new 'test' message. struct generate_next final : public so_5::signal_t {}; void on_next(mhood_t<generate_next>) { // Produce a new 'task' message. so_5::send<task>(dest_, id_counter_); ++id_counter_; // Should the work be stopped? if(id_counter_ >= 10) so_deregister_agent_coop_normally(); } public: producer(context_t ctx, so_5::mbox_t dest) : so_5::agent_t{std::move(ctx)} , dest_{std::move(dest)} {} void so_define_agent() override { so_subscribe_self().event(&producer::on_next); } // This method will be automatically called by SObjectizer // when agent starts its work inside SObjectizer Environment. void so_evt_start() override { // Initiate a periodic message with no initial delay // and repetition every 25ms. task_timer_ = so_5::send_periodic<generate_next>(*this, 0ms, 25ms); } }; int main() { // Run SObjectizer instance. so_5::launch([](so_5::environment_t & env) { // Make and register coop with agents. // All agents will be bound to active_obj dispatcher and will // work on separate threads. env.introduce_coop( so_5::disp::active_obj::make_dispatcher(env).binder(), [](so_5::coop_t & coop) { auto * trash = coop.make_agent<trash_can>(); auto * handler = coop.make_agent<consumer>(trash->so_direct_mbox()); coop.make_agent<producer>(handler->so_direct_mbox()); }); }); } 

यदि हम उस उदाहरण को चलाते हैं तो हम निम्नलिखित आउटपुट देख सकते हैं:

 handling task: 0 handling task: 1 unhandled task: 5 unhandled task: 6 handling task: 2 unhandled task: 8 unhandled task: 9 handling task: 3 handling task: 4 handling task: 7 

यह आउटपुट दिखाता है कि कई संदेश जो परिभाषित सीमा में फिट नहीं हो सकते हैं, उन्हें अस्वीकार कर दिया जाता है और दूसरे रिसीवर पर भेज दिया जाता है।

और उदाहरण

एक उदाहरण जो वास्तविक जीवन के अनुप्रयोगों के कोड से कम या ज्यादा समान है, वह हमारी झींगा डेमो परियोजना में पाया जा सकता है। इस मिनी-सीरी में शास्त्रीय "डाइनिंग दार्शनिकों की समस्या": भाग 1 और भाग 2 के बारे में दिलचस्प उदाहरणों का एक और सेट पाया जा सकता है। और, निश्चित रूप से, SObjectizer में बहुत सारे उदाहरण हैं ।

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

एक बहुत ही सरल उत्तर है: यह हमारे लिए बहुत अच्छा है। सोबिजाइज़र प्रति सेकंड लाखों संदेश वितरित कर सकता है, और वास्तविक गति उपयोग किए गए डिस्पैचर, संदेश प्रकार, लोड प्रोफ़ाइल, हार्डवेयर / ओएस / संकलक और इतने पर उपयोग के प्रकारों पर निर्भर करता है। एक वास्तविक अनुप्रयोग में, हम आमतौर पर SObjectizer की गति का केवल एक अंश उपयोग करते हैं।

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

यदि आप कुछ सिंथेटिक बेंचमार्क से नंबर चाहते हैं तो SOBjectizer वितरण के परीक्षण / so_5 / बेंच फ़ोल्डर में कुछ कार्यक्रम हैं।

विभिन्न उपकरणों के साथ तुलना के बारे में एक नोट

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

तो हम गति की तुलना उन लोगों के लिए छोड़ देते हैं जो उस खेल को पसंद करते हैं और इसे खेलने के लिए समय है।

SObjectizer बिल्कुल वैसा ही क्यों दिखता है?

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

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

एजेंट Agent_t से प्राप्त वर्गों की वस्तुएं हैं

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

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

कक्षाओं का उपयोग हमें एजेंटों की जटिलता का प्रबंधन करने की अनुमति देता है। हम वर्गों की विरासत का उपयोग कर सकते हैं। और हम टेम्पलेट कक्षाओं का भी उपयोग कर सकते हैं। ये बहुत उपयोगी तकनीकें हैं जो अंदर समान तर्क वाले एजेंटों के परिवारों के विकास को सरल बनाती हैं।

उपयोगकर्ता संरचना / कक्षाओं की वस्तुओं के रूप में संदेश

SObjectizer में संदेश उपयोगकर्ता द्वारा परिभाषित संरचनाओं या कक्षाओं की वस्तुएँ हैं। उसके कम से कम दो कारण हैं:

• SObjectizer-5 का विकास 2010 में शुरू हुआ जब C ++ 11 को अभी तक मानकीकृत नहीं किया गया था। इसलिए शुरुआत में, हम सी ++ 11 की ऐसी विशेषताओं का उपयोग नहीं कर सकते थे जैसे कि वैरिएडिक टेम्प्लेट और एसडी std::tuple क्लास। हमारे पास एकमात्र विकल्प एक वर्ग का एक वस्तु का उपयोग था जो एक विशेष वर्ग के message_t से विरासत में मिला था। अब message_t से संदेश के प्रकार को प्राप्त करने की कोई आवश्यकता नहीं है, लेकिन SObjectizer किसी भी उपयोगकर्ता को message_t -derived ऑब्जेक्ट में वैसे भी रखता है जो कि हुड के नीचे है;
• ईवेंट हैंडलर्स के हस्ताक्षरों के संशोधन के बिना किसी संदेश की सामग्री को आसानी से बदला जा सकता है। और एक संकलक से एक नियंत्रण होता है: यदि आप किसी क्षेत्र को संदेश से हटाते हैं या उसका प्रकार बदलते हैं तो संकलक आपको उस क्षेत्र में गलत पहुंच के बारे में बताएगा।

संदेशों का उपयोग वस्तुओं के रूप में भी प्रचारित संदेशों के साथ काम करने और प्राप्त संदेश को कुछ कंटेनर में संग्रहीत करने और बाद में इसे फिर से भेजने की अनुमति देता है।

एजेंटों के कोट

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

SObjectizer जीवन की शुरुआत के तुरंत बाद coops में आवश्यकता की खोज की गई थी। यह स्पष्ट हो गया कि एजेंट समूहों द्वारा बनाए जाएंगे, एकल उदाहरणों द्वारा नहीं। एक डेवलपर के जीवन को आसान बनाने के लिए कॉप्स का आविष्कार किया गया था: यदि नए एजेंट का निर्माण विफल हो जाता है, तो अगले एजेंट के निर्माण को नियंत्रित करने और पहले बनाए गए एजेंटों को हटाने की कोई आवश्यकता नहीं है।

एक कॉप को ऑल-फॉर-वन मोड में एक पर्यवेक्षक के रूप में भी देखा जा सकता है: यदि कॉप का एक एजेंट विफल रहता है, तो पूरे कॉप को सोबिजाइज़र पर्यावरण से हटा दिया जाएगा और नष्ट कर दिया जाएगा (एक उपयोगकर्ता उस पर प्रतिक्रिया कर सकता है और कॉप को फिर से बना सकता है)।

संदेश बॉक्स

संदेश बॉक्स एक और अद्वितीय SObjectizer की विशेषता है। SObjectizer में संदेश एक एजेंट को नहीं, बल्कि एक संदेश बॉक्स (mbox) को भेजे जाते हैं। एमबॉक्स के पीछे एक रिसीवर हो सकता है, या एक लाख ग्राहक हो सकते हैं, या कोई भी नहीं हो सकता है।

Mboxes हमें प्रकाशित-सदस्यता मॉडल की मूल कार्यक्षमता का समर्थन करने की अनुमति देता है। एक एमबॉक्स को एमक्यू-ब्रोकर के रूप में देखा जा सकता है और संदेश प्रकार को एक विषय के रूप में देखा जा सकता है।

Mboxes हमें संदेश वितरण के विभिन्न दिलचस्प रूपों को लागू करने की अनुमति देता है। उदाहरण के लिए, एक राउंड-रॉबिन एमबॉक्स है जो राउंड-रॉबिन तरीके से ग्राहकों के बीच संदेश फैलाता है। एक अनुरक्षित एमबॉक्स भी है जो अंतिम भेजे गए संदेश को रखता है और प्रत्येक नए ग्राहक के लिए इसे स्वचालित रूप से फिर से भेज देता है। Libmosquitto के आसपास एक साधारण आवरण भी है जो MQTT को एक वितरित एप्लिकेशन के परिवहन के रूप में उपयोग करने की अनुमति देता है।

एजेंट एचएसएम के रूप में

SObjectizer में एजेंट राज्य मशीन हैं। यह शुरू से ही था क्योंकि SObjectizer की जड़ें SCADA फ़ील्ड में होती हैं, जहाँ राज्य मशीनों का सक्रिय रूप से उपयोग किया जाता है। लेकिन यह जल्दी से स्पष्ट हो गया कि राज्य मशीन के रूप में एजेंट अलग-अलग niches (जैसे दूरसंचार और वित्त अनुप्रयोगों) में भी उपयोगी हो सकते हैं।

पदानुक्रमित राज्य मशीनों का समर्थन (जैसे on_enter / on_exit हैंडलर, नेस्टेड स्टेट्स, समय सीमा और इतने पर) उत्पादन में SObjectizer का उपयोग करने के कुछ समय बाद जोड़ा गया था। और इस सुविधा ने SObjectizer को अभी तक अधिक शक्तिशाली और सुविधाजनक उपकरण बनाया।

सी ++ अपवादों का उपयोग

C ++ अपवादों का उपयोग SObjectizer में मुख्य त्रुटि रिपोर्टिंग तंत्र के रूप में किया जाता है। इस तथ्य के बावजूद कि C ++ अपवाद का उपयोग कभी-कभी महंगा हो सकता है, हमने त्रुटि कोड के बजाय अपवाद का उपयोग करने का निर्णय लिया।

हमें SObjectizer-4 में त्रुटि कोड के साथ एक नकारात्मक अनुभव था, जहां अपवादों का उपयोग नहीं किया गया था। इससे एप्लिकेशन कोड में त्रुटियों की अज्ञानता हो गई और कभी-कभी महत्वपूर्ण कार्रवाइयां नहीं की गईं क्योंकि एक नया कॉप बनाने या संदेश भेजने में त्रुटि हुई थी। लेकिन इस त्रुटि को नजरअंदाज कर दिया गया था और इस तथ्य को बहुत बाद में खोजा गया था।

SObjectizer-5 में C ++ अपवादों का उपयोग अधिक सही और मजबूत कोड लिखने की अनुमति देता है। सामान्य मामलों में, अपवादों को SObjectizer द्वारा बहुत कम ही फेंका जाता है, इसलिए अपवाद के उपयोग का SObjectizer के प्रदर्शन या SObjectizer के शीर्ष पर लिखे गए अनुप्रयोगों के प्रदर्शन पर कोई नकारात्मक प्रभाव नहीं पड़ता है।

वितरित अनुप्रयोगों के लिए कोई समर्थन नहीं है "आउट ऑफ बॉक्स"

SObjectzer-5 में वितरित अनुप्रयोगों के लिए कोई अंतर्निहित समर्थन नहीं है। इसका अर्थ है कि SObjectizer केवल एक प्रक्रिया के अंदर संदेश वितरित करता है। यदि आपको अंतर-प्रक्रिया या अंतर-नोट संदेश वितरण को व्यवस्थित करने की आवश्यकता है, तो आपको अपने आवेदन में किसी प्रकार के आईपीसी को एकीकृत करना होगा।

ऐसा इसलिए नहीं है क्योंकि हम SObjectizer में IPC के कुछ रूप को लागू नहीं कर सकते हैं। हमारे पास पहले से ही SObjectizer-4 में था। और क्योंकि हमारे पास ऐसा अनुभव है, इसलिए हमने SObjectizer-5 में ऐसा नहीं करने का फैसला किया। हमने सीखा कि आईपीसी का कोई एक प्रकार नहीं है जो विभिन्न परिस्थितियों के लिए पूरी तरह से फिट बैठता है।

यदि आप अपने आवेदन में अच्छा अंतर-नोड संचार करना चाहते हैं, तो आपको उपयुक्त अंतर्निहित प्रोटोकॉल का चयन करना होगा। उदाहरण के लिए, यदि आपको कुछ छोटे-छोटे डेटा (वर्तमान मौसम की स्थिति के माप के वितरण जैसे) के साथ लाखों छोटे पैकेट फैलाने हैं तो आपको एक आईपीसी का उपयोग करना होगा। लेकिन अगर आपको भारी BLOBs (जैसे 4K / 8K वीडियो स्ट्रीम या अभिलेखागार के अंदर वित्तीय डेटा के साथ) को स्थानांतरित करना है तो आपको दूसरे IPC प्रकार का उपयोग करना होगा।

और हम विभिन्न भाषाओं में लिखे गए सॉफ्टवेयर के साथ अंतर्मुखता के बारे में नहीं बोलते हैं ...

आप विश्वास कर सकते हैं कि कुछ सार्वभौमिक "अभिनेता ढांचे" आपको एक आईपीसी प्रदान कर सकते हैं जो विभिन्न स्थितियों के लिए अच्छा होगा। लेकिन हम जानते हैं कि यह सिर्फ बकवास है। हमारा अनुभव हमें दिखाता है कि आईपीसी को आपके एप्लिकेशन में जोड़ने के लिए बहुत सरल और अधिक सुरक्षित है, फिर एक 3-पक्षीय पार्टी के "अभिनेता ढांचे" के लेखकों के विचारों, जरूरतों और ज्ञान पर भरोसा करना।

SObjectizer कस्टम mboxes के रूप में विभिन्न प्रकार के IPC को शामिल करने की अनुमति देता है। इसलिए यह SObjectizer के उपयोगकर्ताओं से नेटवर्क पर संदेश वितरण के तथ्य को छिपाने की अनुमति देता है।

निष्कर्ष के बजाय

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

SObjectizer खुद GitHub पर रहता है । GitHub पर प्रोजेक्ट का विकी है और हम SObjectizer 5.6 बेसिक्स से शुरू करने की सलाह देते हैं और फिर इन- डीप सीरीज के लेखों पर जाते हैं। जो लोग गहराई में जाना चाहते हैं, हम अनुशंसा कर सकते हैं कि हम SObjectizer के हूड अनुभाग के तहत देखें ।

यदि आपके कोई प्रश्न हैं, तो आप हमें Google के समूहों पर SObjectizer के समूह में पूछ सकते हैं।