Caché इवेंट API का उपयोग करके कार्य समांतरिकरण के दौरान प्रक्रिया सिंक्रनाइज़ेशन

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

यह तुरंत ध्यान दिया जाना चाहिए कि विंडोज के लिए Caché DBMS के संस्करण में JOB कमांड एक थ्रेड उत्पन्न नहीं करता है, बल्कि एक प्रक्रिया है। इसलिए, बहु-थ्रेडेड के बारे में नहीं, बल्कि एक बहु-प्रक्रिया अनुप्रयोग के बारे में बात करना अधिक सही होगा।
यह निम्नानुसार है कि प्रोसेसर के लिए हाइपर-थ्रेडिंग तकनीक की उपस्थिति की तुलना में प्रोसेसर में कोर की संख्या अधिक महत्वपूर्ण है, जिसे हार्डवेयर का चयन करते समय विचार किया जाना चाहिए।

समानांतरकरण चरण: मानचित्र और घटाना

सबसे पहले, बायोमेट्रिक पहचान के उदाहरण का उपयोग करते हुए समानांतर कार्यों के चरणों पर संक्षेप में विचार करें।

मान लीजिए कि बॉयोमीट्रिक जानकारी के साथ एक डेटाबेस है, जैसे कि तस्वीरें।
और आप, किसी व्यक्ति की फोटो होने पर, इस आधार पर उसकी पहचान करना चाहते हैं (खोज "एक-से-कई")।

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

अगले चरण में ( कम करें ) हमें अपने सबसैट से डेटा एकत्र करना चाहिए, उन्हें एकत्र करना चाहिए और अंतिम परिणाम देना चाहिए।

हमारे उदाहरण के लिए, मानचित्र की रणनीति काफी भिन्न हो सकती है।
उदाहरण के लिए, मूल फोटो में लोगों की संख्या।



यदि तस्वीर में केवल एक ही व्यक्ति है, तो प्रत्येक प्रक्रिया को डेटा के अपने हिस्से के ढांचे के भीतर इसे पहचानने का निर्देश दिया जा सकता है, जो या तो नोड्स में फैल सकता है या सभी नोड्स द्वारा साझा किया जा सकता है।



यदि कई लोगों को एक साथ फोटो पर कब्जा कर लिया जाता है, तो प्रत्येक प्रक्रिया को सभी डेटा के अनुसार एक बार में एक व्यक्ति की पहचान करने का निर्देश दिया जा सकता है।

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

कैच इवेंट API

प्रत्येक चरण से परिणाम प्राप्त करने के साथ-साथ, Reduce स्टेज पर, हमें यह निर्धारित करने में सक्षम होना चाहिए कि उनमें से कौन सा पहले ही पूरा हो चुका है और कौन सा नहीं है, और % SYSTEM.Event वर्ग हमारी मदद करेगा।
प्रलेखन घटना कतार के प्रसंस्करण के लिए तंत्र का विस्तार से वर्णन करता है, इसलिए यह विस्तार से रोकने के लिए कोई मतलब नहीं है।

मैं केवल दो मुख्य तरीकों पर ध्यान देता हूं:

1. प्रतीक्षा / WaitMsg - एक संदेश प्राप्त किए बिना / के साथ जागने के लिए संसाधन की प्रतीक्षा कर रहा है
2. सिग्नल - एक संदेश के साथ एक संसाधन को जगाने के लिए एक संकेत भेजना

आवेदन उदाहरण

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

इसलिए, निम्नलिखित कार्यक्रम बनाएं:

मुख्य () {

; पिछले समय से अस्थायी डेटा हटाएं
मार ^ tmp

; हम तीन उपप्रकार शुरू करते हैं, वे प्रक्रियाएं हैं
नौकरी की नौकरी (1, सेब , 5)
नौकरी की नौकरी (2, "नाशपाती" , 6)
नौकरी की नौकरी (3, "नाली" , 7)

; स्क्रीन पर परिणाम प्रदर्शित करें
zwrite ^ tmp

}

नौकरी (ए, बी, सी)

लटका 1 ; 1 सेकंड की देरी के साथ हिंसक गतिविधि का अनुकरण करें।

set ^ tmp ( a ) = b _ "-" _ ( c * 2) // परिणाम तैयार करें

टर्मिनल से हमारा कार्यक्रम चलाएं:

TEST>do ^main

TEST>

नतीजतन, हमें कोई परिणाम नहीं दिखता है, क्योंकि चलने वाली प्रक्रियाएं अपना जीवन जीती हैं (अतुल्यकालिक रूप से निष्पादित होती हैं) और हम मुख्य प्रक्रिया से उनके पूरा होने की प्रतीक्षा नहीं करते थे।

चलिए, देरी दर्शाते हुए इसे ठीक करने का प्रयास करते हैं, जैसा कि नीचे दिखाया गया है:

मुख्य () {

; ...
नौकरी की नौकरी (3, "नाली" , 7)

लटकना १

; परिणाम प्रदर्शित करें
; ...

}

इसे फिर से चलाएँ:

TEST>do ^main
^tmp(1)="-10"
^tmp(2)="-12"
^tmp(3)="-14"

TEST>

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

इस स्थिति में, अंतर्निहित " इवेंट क्यूइंग " तंत्र हमें बचाता है।

हम अपने आवेदन को फिर से लिखते हैं, इसके अलावा प्रत्येक प्रक्रिया को उसकी प्राथमिकता देते हैं।

मुख्य () {

; हम अपनी प्राथमिकता के साथ तीन प्रक्रियाएँ बनाते हैं
नौकरी की नौकरी (3, -7, सेब , 5)
नौकरी की नौकरी (2, 0, नाशपाती , 6)
नौकरी की नौकरी (1, 8, बेर , 7)

; जागृति संकेत की प्रतीक्षा कर रहा है और
; स्क्रीन पर परिणाम प्रदर्शित करें
$ सूची ( $ सिस्टम । ईवेंट । WaitMsg (), 2), लिखें !
$ सूची ( $ सिस्टम । ईवेंट । WaitMsg (), 2), लिखें !
$ सूची ( $ सिस्टम । ईवेंट । WaitMsg (), 2), लिखें !

}

नौकरी (एक्स, डेल्टा, ए, बी)

; डेल्टा के लिए वर्तमान प्रक्रिया की प्राथमिकता बदलें
$ सिस्टम करो ।Util सेटप्रियो ( डेल्टा )

x लटकाओ ; एक्स सेकंड की देरी के साथ हिंसक गतिविधि का अनुकरण करें।

// मूल प्रक्रिया के लिए वेक-अप संकेत भेजें
// परिणाम के साथ
$ प्रणाली करो । संकेत ( $ zparent , एक _ "-" _ ( b * 2))

आउटपुट परिणाम:

TEST>do ^main
-14
-12
-10

TEST>

---

कुछ उपयोगी लिंक वर्ग संदर्भ में पाए जा सकते हैं:

1. %% SYSTEM.CPU - प्रोसेसर की जानकारी प्रदान करता है
2. %% SYSTEM.Util - में विभिन्न उपयोगी विधियाँ समाहित हैं।
   उदाहरण के लिए: NumberOfCPUs , SetBatch , SetPrio
3. पैरामीटर JobServers - प्रक्रिया पूल के आकार को नियंत्रित करता है