👩‍🎤 🈂️ 🔺 जूलिया और समानांतर कम्प्यूटिंग 🚰 🚓 🆚

अगस्त 2018 में रिलीज़ होने के बाद से, जूलिया सक्रिय रूप से अपवर्क के अनुसार गितुब पर शीर्ष 10 भाषाओं और शीर्ष 20 सबसे लोकप्रिय पेशेवर कौशल में प्रवेश करके लोकप्रियता हासिल कर रही है। शुरुआती के लिए, पाठ्यक्रम शुरू होता है और किताबें प्रकाशित होती हैं । जूलिया का उपयोग अंतरिक्ष मिशन योजना , फार्माकोमेट्री और जलवायु मॉडलिंग के लिए किया जाता है ।

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

समानांतर कम्प्यूटिंग और कारक समानांतर कम्प्यूटिंग प्रदर्शन को प्रभावित करते हैं

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

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

जूलिया के पास प्रत्येक स्तर पर समानांतर कंप्यूटिंग के लिए कई अंतर्निहित प्राइमेटरीज हैं: वेक्टराइजेशन (SIMD), मल्टीथ्रेडिंग और वितरित कंप्यूटिंग।

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

जूलिया में स्वचालित वेक्टरकरण

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

बहु सूत्रण

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

वितरित कंप्यूटिंग

यद्यपि जूलिया की अंतर्निहित प्राइमेटरीज बड़े पैमाने पर समानांतर तैनाती के लिए पर्याप्त हैं, अधिक विशिष्ट कार्य के लिए कई पैकेज हैं। ClusterManagers.jl सन ग्रिड इंजन और स्लम जैसे कंप्यूटिंग क्लस्टर्स में आमतौर पर उपयोग किए जाने वाले कई काम कतार प्रणाली के लिए इंटरफेस प्रदान करता है। DistributedArrays.jl एक क्लस्टर में वितरित डेटा सरणियों के लिए एक सुविधाजनक इंटरफ़ेस प्रदान करता है। यह कई मशीनों के मेमोरी संसाधनों को जोड़ती है, जिससे उन सरणियों का उपयोग करना संभव हो जाता है जो एक मशीन पर फिट होने के लिए बहुत बड़े हैं। प्रत्येक प्रक्रिया उस सरणी के हिस्से पर चलती है जिसका वह मालिक है, इस सवाल का तैयार उत्तर प्रदान करता है कि प्रोग्राम को मशीनों के बीच कैसे विभाजित किया जाना चाहिए।

कुछ विरासत अनुप्रयोगों में, उपयोगकर्ता अपने समानांतर मॉडल पर पुनर्विचार नहीं करना चाहते हैं और MPI -style संगामिति का उपयोग जारी रखना चाहते हैं। उनके लिए, MPI.jl MPI के चारों ओर एक पतला आवरण प्रदान करता है जो उपयोगकर्ताओं को MPI- शैली संदेश पासिंग प्रक्रियाओं का उपयोग करने की अनुमति देता है।

युद्ध में जूलिया

सेलेस्टे प्रोजेक्ट जूलिया कंप्यूटिंग, इंटेल लैब्स, जूलियालैब्स @ एमआईटी, लॉरेंस बर्कले नेशनल लैब्स और बर्कले में कैलिफोर्निया विश्वविद्यालय के बीच एक सहयोग है।

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

स्लोअन डिजिटल स्काई सर्वे (SDSS) से उदाहरण

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

सेलेस्टे प्रोजेक्ट ने NERSC कोरी फेज II के सुपरकंप्यूटर पर 9,300 शूरवीरों की लैंडिंग (KNL) नोड्स का इस्तेमाल किया, जो 650,000 KNL कोर पर 1.3 मिलियन थ्रेड्स निष्पादित करने के लिए थे, जिन्होंने गति के साथ अनुप्रयोगों की सूची को दूसरे Taflops प्रति सेकंड से अधिक कर दिया, जिससे जूलिया केवल गतिशील बन गई। एक उच्च स्तरीय भाषा जिसने कभी इस तरह की उपलब्धि हासिल की है। ?? लेकिन क्या 10.04.19 को टेलिस्कोप के सिंक्रनाइज़ेशन और ब्लैक होल इमेज के लिए डेटा के प्रसंस्करण ने इस रिकॉर्ड को तोड़ दिया? ऐसा लगता है कि पाइथन ज्यादातर वहां इस्तेमाल किया गया था।

MPI का उपयोग करते हुए जूलिया के साथ समानांतर प्रोग्रामिंग

क्लाउडियो प्लाज्मा भौतिकी ब्लॉग 2018-09-30 से सामग्री का अनुवाद

जूलिया 2012 से अस्तित्व में है, और विकास के छह से अधिक वर्षों के बाद, संस्करण 1.0 अंततः जारी किया गया है। यह एक महत्वपूर्ण चरण है जिसने मुझे एक नया पद (कई महीनों के मौन के बाद) बनाने के लिए प्रेरित किया। इस बार हम देखेंगे कि ओपन एमपीआई ओपन सोर्स लाइब्रेरी के माध्यम से संदेश पासिंग इंटरफेस (एमपीआई) प्रतिमान का उपयोग करके जूलिया में समानांतर प्रोग्रामिंग कैसे करें। हम एक वास्तविक भौतिक समस्या को हल करके ऐसा करेंगे: दो-आयामी क्षेत्र के माध्यम से गर्मी प्रसार।

चित्रा 1. परमाणु हथियारों के संख्यात्मक सिमुलेशन के लिए लगभग 1.6 मिलियन प्रोसेसर के साथ LLNL में सिकोइया सुपर कंप्यूटर। hpc.llnl.gov

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

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

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

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

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

यहां प्रस्तुत जूलिया कोड अनिवार्य रूप से फेबियन डर्नक द्वारा उस शानदार पोस्ट में समझाया गया सी / फोरट्रान कोड का अनुवाद है।

इस पोस्ट में मैं स्केलिंग की गति और प्रोसेसर की संख्या का विस्तार से विश्लेषण नहीं करूंगा। मुख्य रूप से क्योंकि मेरे पास केवल दो प्रोसेसर हैं जो मैं घर पर खेल सकता हूं (मेरे मैकबुक प्रो पर इंटेल कोर i7 प्रोसेसर) ... हालांकि, मैं अब भी गर्व से कह सकता हूं कि इस पोस्ट में जूलिया कोड प्रस्तुत किया गया है, एक के खिलाफ दो प्रोसेसर का उपयोग करते समय महत्वपूर्ण त्वरण दिखाता है। वैसे भी: यह बराबर फोरट्रान और सी कोड से तेज है! (इस पर और बाद में)

इस विषय को हम इस पोस्ट में शामिल करने जा रहे हैं:

जूलिया: मेरा पहला इंप्रेशन
अपने कंप्यूटर पर ओपन एमपीआई कैसे स्थापित करें
समस्या: दो-आयामी डोमेन के माध्यम से प्रसार
इंटर-प्रोसेसर संचार: भूत कोशिकाओं की आवश्यकता
MPI का उपयोग करना
समाधान दृश्य
उत्पादकता
निष्कर्ष

1. जूलिया का पहला इंप्रेशन

वास्तव में, मैं हाल ही में जूलिया से मिला, इसलिए मैंने यहां "पहले छापों" के एक जोड़े पर ध्यान केंद्रित करने का फैसला किया।

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

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

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

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

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

2. ओपन एमपीआई स्थापित करना

ओपन MPI एक ओपन सोर्स मैसेजिंग इंटरफ़ेस लाइब्रेरी है। अन्य प्रसिद्ध पुस्तकालयों में MPICH और MVAPICH शामिल हैं। ओहियो स्टेट यूनिवर्सिटी द्वारा विकसित, MVAPICH वर्तमान में सबसे उन्नत पुस्तकालय है क्योंकि यह GPU क्लस्टर का भी समर्थन कर सकता है - जो विशेष रूप से डीप लर्निंग अनुप्रयोगों के लिए उपयोगी है (वास्तव में, NVIDIA और MVAPICH टीम के बीच घनिष्ठ सहयोग है)।

इन सभी पुस्तकालयों को एक सामान्य इंटरफ़ेस पर बनाया गया है: एमपीआई एपीआई। इसलिए, यदि आप एक या दूसरे पुस्तकालय का उपयोग नहीं करते हैं, तो इससे कोई फर्क नहीं पड़ता: आपके द्वारा लिखा गया कोड समान हो सकता है।

Github पर MPI.jl परियोजना MPI के लिए एक आवरण है। हुड के तहत, यह सी और फोरट्रान एमपीआई प्रतिष्ठानों का उपयोग करता है। यह बहुत अच्छा काम करता है, हालांकि इसमें इन अन्य भाषाओं में उपलब्ध कुछ विशेषताओं का अभाव है।

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

ओपन MPI आपके कंप्यूटर पर स्थापित होने के बाद, आपको cmake को स्थापित करना चाहिए। फिर से, यदि आपके पास एक मैक है, तो आपके टर्मिनल पर brew install cmake टाइप करना उतना ही आसान है।

फिलहाल, आप जूलिया में एमपीआई पैकेज स्थापित करने के लिए तैयार हैं। जूलिया REPL खोलें और using Pkg Pkg.add («MPI») । आमतौर पर इस बिंदु पर आपको एमपीआई का उपयोग करके आयात करने के लिए पैकेज आयात करने में सक्षम होना चाहिए। हालाँकि, मुझे काम करने से पहले Pkg.build («MPI») माध्यम से पैकेज का निर्माण करना था।

3. समस्या: दो आयामी प्रसार समीकरण

प्रसार समीकरण एक परवलयिक आंशिक अंतर समीकरण का एक उदाहरण है। वह इस तरह की घटनाओं का वर्णन गर्मी प्रसार या एकाग्रता प्रसार (फ़िक का दूसरा नियम) के रूप में करता है। दो स्थानिक आयामों में, प्रसार समीकरण लिखा जाता है

आ ं श ि क आ ं श ि क आ ं श ि क आ ं श ि क आ ं श ि क आ ं श ि क ।

$\ frac {\ आंशिक {u}} {\ आंशिक {t}} = D \ left (\ frac {\ आंशिक ^ 2 {u}} {\ आंशिक {x ^ 2}} + \ frac {\ आंशिक ^ 2 {u}} {\ आंशिक {y ^ 2}} \ right) \।$

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

$1) \ \ frac {u_ {i, k} ^ {j + 1} - 2u_ {i, k} ^ {j}} {\ Delta t} = D \ left (\ frac {u_ {i + 1), k} ^ j-2u_ {i, k} ^ j + u_ {i-1, k} ^ j} {\ Delta x ^ 2} + \ frac {u_ {i, k + 1} ^ j-2u_ {i , k} ^ j + u_ {i, k-1} ^ j} {\ Delta y ^ 2} \ right)$

जहां i और k स्थानिक ग्रिड के साथ चलने वाले सूचकांक k , समय में j । पहली बार की परत प्रारंभिक स्थितियों से भरी हुई है, और प्रत्येक बाद में $u ^ {j + 1} _ {i, k}$ पिछली परत के मूल्यों का उपयोग करके गणना की गई। आकृति में, लाल नोड्स परत के नोड्स को इंगित करते हैं $u ^ {j}$ जो बिंदु पर मूल्य की गणना करने के लिए आवश्यक हैं $u ^ {j + 1} _ {i, k}$

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

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

दो पड़ोसी प्रक्रियाओं को सीमा के पास समाधान खोजने के लिए बातचीत करनी चाहिए। प्रक्रिया 0 को ग्रिड बिंदु ए पर समाधान की गणना करने के लिए बी में समाधान के मूल्य को जानना चाहिए। इसी तरह, प्रक्रिया 1 को ग्रिड बिंदु पर समाधान की गणना करने के लिए बिंदु सी पर मूल्य का पता होना चाहिए। ये मूल्य प्रक्रियाओं के लिए अज्ञात हैं जब तक कि प्रक्रिया 0 और 1 के बीच कोई संबंध नहीं है। ।

यह दिखाता है कि सीमा के पास किसी समाधान का मूल्यांकन करने के लिए प्रक्रियाओं को 0 और 1 को कैसे इंटरैक्ट करना होगा। यह वह जगह है जहां एमपीआई दृश्य में प्रवेश करता है। अगले भाग में, हम संदेश भेजने के एक प्रभावी तरीके को देखेंगे।

4. प्रक्रियाओं के बीच संचार: भूत कोशिकाएं

कम्प्यूटेशनल द्रव की गतिशीलता में एक महत्वपूर्ण अवधारणा भूत कोशिकाओं की अवधारणा है। जब भी एक स्थानिक डोमेन कई उप-डोमेन में विघटित होता है, तो यह अवधारणा उपयोगी होती है, जिनमें से प्रत्येक को एक एकल प्रक्रिया द्वारा हल किया जाता है।

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

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

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

5. MPI का उपयोग करना

कई एमपीआई ट्यूटोरियल हैं। यहाँ मैं सिर्फ जूलिया के लिए MPI.jl शेल भाषा में व्यक्त किए गए आदेशों का वर्णन करना चाहता हूं जो मैंने द्वि-आयामी भ्रम की समस्या को हल करने के लिए उपयोग किया था। ये कुछ मूल आदेश हैं जो लगभग हर MPI कार्यान्वयन में उपयोग किए जाते हैं।

MPI कमांड

MPI.init () - रनटाइम को इनिशियलाइज़ करता है
MPI.COMM_WORLD - MPI.COMM_WORLD प्रतिनिधित्व करता है, अर्थात, MPI अनुप्रयोग के माध्यम से उपलब्ध सभी प्रक्रियाएँ (प्रत्येक संदेश संचारक से जुड़ा होना चाहिए)
MPI.Comm_rank (MPI. COMM_WORLD) - प्रक्रिया की आंतरिक रैंक (आईडी) को परिभाषित करता है
MPI.Barrier (MPI.COMM_WORLD) - जब तक सभी प्रक्रियाएं इस प्रक्रिया तक नहीं पहुंच MPI.Barrier (MPI.COMM_WORLD) तब तक ब्लॉक का निष्पादन
MPI.Bcast! (Buf, n_buf, rank_root, MPI.COMM_WORLD) MPI.Bcast! (Buf, n_buf, rank_root, MPI.COMM_WORLD) - संदेश के बफर बफ़ को आकार n_buf के साथ एक प्रक्रिया से रैंक rank_root के साथ संचारक MPI.COM_WORLD की अन्य सभी प्रक्रियाओं में प्रसारित करें।
MPI.Waitall! (reqs) MPI.Waitall! (reqs) - सभी MPI अनुरोधों के पूरा होने का इंतजार करता है (अनुरोध एक विवरणक है, दूसरे शब्दों में, अतुल्यकालिक संदेश हस्तांतरण के लिए एक लिंक,)
MPI.REQUEST_NULL - इंगित करता है कि अनुरोध किसी भी चल रहे कनेक्शन से संबद्ध नहीं है
MPI.Gather (buf, rank_root, MPI.COMM_WORLD) - रैंक_root प्राप्त करने की प्रक्रिया के लिए buf चर को कम करता है
MPI.Isend (buf, rank_dest, tag, MPI.COMM_WORL D) - buf संदेश को वर्तमान प्रक्रिया से asynchronously को rank_dest प्रक्रिया में भेजा जाता है, और संदेश पैरामीटर के साथ टैग किया जाता है
MPI.Irecv! (Buf, rank_src, tag, MPI.COMM_WORLD) MPI.Irecv! (Buf, rank_src, tag, MPI.COMM_WORLD) - स्थानीय बफर बुफ़ को रैंक रैंक_src की स्रोत प्रक्रिया से टैग टैग के साथ एक संदेश प्राप्त होता है
MPI.Finalize () - MPI रनटाइम को समाप्त करता है

5.1 पड़ोसी खोजने की प्रक्रिया

हमारे कार्य के लिए, हम अपने दो-आयामी क्षेत्र को कई आयताकार उप-क्षेत्रों में विघटित करने जा रहे हैं, जैसा कि नीचे दिए गए चित्र में दिखाया गया है।

चित्रा 5. 12 उप-क्षेत्रों में विभाजित एक द्वि-आयामी क्षेत्र का कार्टेशियन अपघटन। ध्यान दें कि MPI रैंक (प्रक्रिया पहचानकर्ता) शून्य से शुरू होती है।

ध्यान दें कि x और y कुल्हाड़ियों को एक्स अक्ष को पंक्तियों के साथ और समाधान मैट्रिक्स के स्तंभों के साथ y अक्ष के साथ सामान्य उपयोग के सापेक्ष उलटा किया जाता है।

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

कोड

 function neighbors(my_id::Int, nproc::Int, nx_domains::Int, ny_domains::Int) id_pos = Array{Int,2}(undef, nx_domains, ny_domains) for id = 0:nproc-1 n_row = (id+1) % nx_domains > 0 ? (id+1) % nx_domains : nx_domains n_col = ceil(Int, (id + 1) / nx_domains) if (id == my_id) global my_row = n_row global my_col = n_col end id_pos[n_row, n_col] = id end neighbor_N = my_row + 1 <= nx_domains ? my_row + 1 : -1 neighbor_S = my_row - 1 > 0 ? my_row - 1 : -1 neighbor_E = my_col + 1 <= ny_domains ? my_col + 1 : -1 neighbor_W = my_col - 1 > 0 ? my_col - 1 : -1 neighbors = Dict{String,Int}() neighbors["N"] = neighbor_N >= 0 ? id_pos[neighbor_N, my_col] : -1 neighbors["S"] = neighbor_S >= 0 ? id_pos[neighbor_S, my_col] : -1 neighbors["E"] = neighbor_E >= 0 ? id_pos[my_row, neighbor_E] : -1 neighbors["W"] = neighbor_W >= 0 ? id_pos[my_row, neighbor_W] : -1 return neighbors end

जब हमने माज़े बनाए तो हमने भी ऐसा ही किया

इस फ़ंक्शन का इनपुट my_id , जो प्रक्रिया का रैंक (या पहचानकर्ता) है, प्रक्रियाओं की संख्या nproc , x दिशा में डिवीजनों की संख्या nx_domains और y दिशा के विभाजनों की संख्या ny_domains ।

चलिए अब इस फीचर को चेक करते हैं। उदाहरण के लिए, फिर से अंजीर को देखना। 5, हम रैंक 4 की प्रक्रिया और रैंक 11 की प्रक्रिया के लिए आउटपुट की जांच कर सकते हैं। आरईपीएल में ड्राइव करें:

 julia> neighbors(4, 12, 3, 4) Dict{String,Int64} with 4 entries: "S" => 3 "W" => 1 "N" => 5 "E" => 7

और

 julia> neighbors(11, 12, 3, 4) Dict{String,Int64} with 4 entries: "S" => 10 "W" => 8 "N" => -1 "E" => -1

जैसा कि आप देख सकते हैं, मैं पड़ोसी के स्थान को इंगित करने के लिए कार्डिनल दिशाओं "एन", "एस", "ई", "डब्ल्यू" का उपयोग करता हूं। उदाहरण के लिए, प्रक्रिया 4 में पड़ोसी के रूप में प्रक्रिया 3 है जो इसकी स्थिति के दक्षिण में स्थित है। आप यह सत्यापित कर सकते हैं कि उपरोक्त सभी परिणाम सही हैं, यह देखते हुए कि "-1" दूसरे उदाहरण में इसका मतलब है कि प्रक्रिया 11 के "उत्तर" और "पूर्व" पक्षों पर कोई पड़ोसी नहीं पाए गए थे।

5.2 मैसेजिंग

जैसा कि हमने पहले देखा था, प्रत्येक पुनरावृत्ति पर, प्रत्येक प्रक्रिया पड़ोसी प्रक्रियाओं को अपनी सीमाएं भेजती है। इसी समय, प्रत्येक प्रक्रिया अपने पड़ोसियों से डेटा प्राप्त करती है। इन आंकड़ों को "घोस्ट सेल्स" के रूप में प्रत्येक प्रक्रिया द्वारा संग्रहीत किया जाता है और प्रत्येक उपडोमेन की सीमा के पास समाधान की गणना करने के लिए उपयोग किया जाता है।

MPI में एक बहुत ही उपयोगी MPI_Sendrecv कमांड है जो आपको दो प्रक्रियाओं के बीच एक साथ संदेश भेजने और प्राप्त करने की अनुमति देता है। दुर्भाग्य से, MPI.jl यह कार्यक्षमता प्रदान नहीं करता है, हालाँकि MPI_Send और MPI_Receive अलग-अलग उपयोग करके समान परिणाम प्राप्त करना अभी भी संभव है।

यहां देखें कि अगला updateBound! फ़ंक्शन में क्या किया गया था updateBound! , जो प्रत्येक पुनरावृत्ति पर भूत कोशिकाओं को अद्यतन करता है। इस फ़ंक्शन का इनपुट एक वैश्विक 2 डी समाधान यू है, जिसमें भूत कोशिकाएं, साथ ही एक विशिष्ट प्रक्रिया से संबंधित सभी जानकारी शामिल है जो एक फ़ंक्शन करती है (इसकी रैंक क्या है, इसके उपडोमेन के निर्देशांक क्या हैं, इसके पड़ोसी क्या हैं)। फ़ंक्शन पहले पड़ोसियों को अपनी सीमा भेजता है, और फिर अपनी सीमाएं प्राप्त करता है। प्राप्त भाग को MPI.Waitall! टीम के माध्यम से अंतिम रूप दिया जा रहा है MPI.Waitall! , जो यह सुनिश्चित करता है कि ब्याज की विशेष उपडोमेन के लिए साइड सेल को अपडेट करने से पहले सभी अपेक्षित संदेश प्राप्त किए गए थे।

कोड

 function updateBound!(u::Array{Float64,2}, size_total_x, size_total_y, neighbors, comm, me, xs, ys, xe, ye, xcell, ycell, nproc) mep1 = me + 1 #assume, to start with, that this process is not going to receive anything rreq = Dict{String, MPI.Request}( "N" => MPI.REQUEST_NULL, "S" => MPI.REQUEST_NULL, "E" => MPI.REQUEST_NULL, "W" => MPI.REQUEST_NULL ) recv = Dict{String, Array{Float64,1}}() ghost_boundaries = Dict{String, Any}( "N" => (xe[mep1]+1, ys[mep1]:ye[mep1]), "S" => (xs[mep1]-1, ys[mep1]:ye[mep1]), "E" => (xs[mep1]:xe[mep1], ye[mep1]+1), "W" => (xs[mep1]:xe[mep1], ys[mep1]-1) ) is_receiving = Dict{String, Bool}("N" => false, "S" => false, "E" => false, "W" => false) #send neighbors["N"] >=0 && MPI.Isend(u[xe[mep1], ys[mep1]:ye[mep1]], neighbors["N"], me + 40, comm) neighbors["S"] >=0 && MPI.Isend(u[xs[mep1], ys[mep1]:ye[mep1]], neighbors["S"], me + 50, comm) neighbors["E"] >=0 && MPI.Isend(u[xs[mep1]:xe[mep1], ye[mep1]], neighbors["E"], me + 60, comm) neighbors["W"] >=0 && MPI.Isend(u[xs[mep1]:xe[mep1], ys[mep1]], neighbors["W"], me + 70, comm) #receive if (neighbors["N"] >= 0) recv["N"] = Array{Float64,1}(undef, ycell) is_receiving["N"] = true rreq["N"] = MPI.Irecv!(recv["N"], neighbors["N"], neighbors["N"] + 50, comm) end if (neighbors["S"] >= 0) recv["S"] = Array{Float64,1}(undef, ycell) is_receiving["S"] = true rreq["S"] = MPI.Irecv!(recv["S"], neighbors["S"], neighbors["S"] + 40, comm) end if (neighbors["E"] >= 0) recv["E"] = Array{Float64,1}(undef, xcell) is_receiving["E"] = true rreq["E"] = MPI.Irecv!(recv["E"], neighbors["E"], neighbors["E"] + 70, comm) end if (neighbors["W"] >= 0) recv["W"] = Array{Float64,1}(undef, xcell) is_receiving["W"] = true rreq["W"] = MPI.Irecv!(recv["W"], neighbors["W"], neighbors["W"] + 60, comm) end MPI.Waitall!([rreq[k] for k in keys(rreq)]) for (k, v) in is_receiving if v u[ghost_boundaries[k][1], ghost_boundaries[k][2]] = recv[k] end end end

5. समाधान दृश्य

डोमेन को सीमा के चारों ओर एक निरंतर मान u = +10 साथ प्रारंभ किया जाता है, जिसे सीमा पर एक स्थिर तापमान स्रोत की उपस्थिति के रूप में व्याख्या किया जा सकता है। प्रारंभिक स्थिति u = −10 क्षेत्र के अंदर (छवि 6 बाईं ओर)। समय के साथ, सीमा पर मान u = 10 क्षेत्र के केंद्र में फैलता है। उदाहरण के लिए, चरण j = 15203 समाधान ऐसा दिखता है जैसे कि अंजीर में दिखाया गया है। दाईं ओर 6।

बढ़ते समय टी के साथ, समाधान अधिक से अधिक सजातीय हो जाता है, जबकि सैद्धांतिक रूप से $t \ rightarrow + \ infty$ यह पूरे डोमेन में u = +10 नहीं बनेगा।

अंजीर। 6. प्रारंभिक स्थिति (बाएं) और समय (दाएं) चरण 15203 में समाधान। क्षेत्र की सीमाएँ हमेशा u = +10 पर संग्रहीत की जाती हैं। समय के साथ, समाधान अधिक से अधिक समान हो जाता है और पूरे क्षेत्र में मूल्य u = +10 के करीब और करीब हो जाता है।

6. प्रदर्शन

जब मैं फोरट्रान और सी की तुलना में जूलिया कार्यान्वयन के प्रदर्शन का परीक्षण किया तो मैं बहुत प्रभावित हुआ: मैंने पाया कि जूलिया कार्यान्वयन सबसे तेज़ है!

तुलना में देरी करने से पहले, आइए जूलिया कोड के एमपीआई प्रदर्शन को स्वयं देखें। चित्रा 1 1 से 2 (सीपीयू) प्रक्रियाओं के साथ काम करते समय रनटाइम के अनुपात को दिखाता है। आदर्श रूप से, आप चाहेंगे कि यह संख्या 2 के करीब हो, अर्थात दो प्रोसेसर के साथ काम एक प्रोसेसर के साथ दोगुना तेजी से होना चाहिए। इसके बजाय, यह देखा गया है कि छोटे कार्य आकार (128x128 कोशिकाओं का एक ग्रिड) के लिए, संकलन समय और संचार ओवरहेड का समग्र निष्पादन समय पर नकारात्मक प्रभाव पड़ता है: त्वरण एक से कम है। कई प्रक्रियाओं का उपयोग करने का लाभ केवल बड़े कार्यों के लिए स्पष्ट हो जाता है।

चित्रा 7. कार्य की जटिलता (ग्रिड आकार) के आधार पर, दो प्रक्रियाओं बनाम एक प्रक्रिया के साथ जूलिया एमपीआई के कार्यान्वयन को गति देना। "एक्सेलेरेशन" 1 प्रक्रिया से 2 प्रक्रियाओं तक कुल निष्पादन समय के अनुपात को संदर्भित करता है।

और अब एक अप्रत्याशित मोड़: अंजीर में। चित्र 8 से पता चलता है कि जूलिया कार्यान्वयन फ़ोर्ट्रान और सी से तेज़ है और कार्यों के लिए आकार 256x256 और 512x512 है (केवल वही जिन्हें मैंने परीक्षण किया था)। यहां मैं केवल मुख्य पुनरावृत्ति लूप को पूरा करने के लिए आवश्यक समय को मापता हूं। मुझे लगता है कि यह एक उचित तुलना है, क्योंकि लंबे सिमुलेशन के लिए यह समग्र रनटाइम में सबसे बड़ा योगदान होगा।

चित्रा 8. दो ग्रिड आकार के लिए जूलिया बनाम फोरट्रान बनाम सी का प्रदर्शन: 256x256 (शीर्ष) और 512x512 (नीचे)। इससे पता चलता है कि जूलिया सबसे अच्छा प्रदर्शन करने वाली भाषा है। प्रदर्शन को उस समय के रूप में मापा जाता है जब मुख्य कोड लूप में निश्चित संख्या में पुनरावृत्तियों को करने में समय लगता है।

निष्कर्ष

इस पद को शुरू करने से पहले, मुझे संदेह था कि जूलिया वैज्ञानिक अनुप्रयोगों के लिए फोरट्रान और सी की गति के साथ प्रतिस्पर्धा कर सकती है। मुख्य कारण यह था कि मैंने पहले फोरट्रान से जूलिया 0.6 तक लगभग 2,000 लाइनों वाले शैक्षणिक कोड का अनुवाद किया था, और मैंने लगभग 3 बार प्रदर्शन ड्रॉप देखा।

लेकिन इस बार ... मैं बहुत प्रभावित हूं। मैंने वास्तव में फोर्ट्रान और सी में जूलिया 1.0 में लिखे गए मौजूदा एमपीआई कार्यान्वयन का अनुवाद किया है। अंजीर में दिखाए गए परिणाम। 8, खुद के लिए बोलो: जूलिया अब तक की सबसे तेज लग रही है। कृपया ध्यान दें कि मैंने जूलिया कंपाइलर द्वारा उपभोग किए गए लंबे संकलन समय को ध्यान में नहीं रखा था, क्योंकि यह "वास्तविक" अनुप्रयोगों के लिए एक महत्वहीन कारक होगा जिसे पूरा करने के लिए घंटों की आवश्यकता होती है।

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

वैसे भी, इस अभ्यास ने मुझे आश्वस्त किया कि डेटा साइंस और वैज्ञानिक अनुप्रयोगों के लिए जूलिया का अध्ययन और उपयोग करने में अधिक समय बिताने के लायक होगा। नई उपलब्धियों पर जाएं!

संदर्भ

जूलिया और समानांतर कम्प्यूटिंग