MPI में MPI_Allgather और MPI_Alltoall फ़ंक्शंस में मुख्य अंतर क्या है?MPI_Allgather और MPI_Alltoall फ़ंक्शंस के बीच अंतर?
मेरा मतलब है कि कोई मुझे ऐसे उदाहरण दे सकता है जहां MPI_Allgather सहायक होगा और MPI_Alltoall नहीं होगा? और इसके विपरीत।
मैं मुख्य अंतर को समझने में सक्षम नहीं हूं? ऐसा लगता है कि दोनों मामलों में सभी प्रक्रियाएं संचारक में भाग लेने वाली हर दूसरी प्रक्रिया में send_cnt तत्व भेजती हैं और उन्हें प्राप्त करती हैं?
धन्यवाद
एक तस्वीर कहते हैं और अधिक से अधिक हजार शब्दों, इसलिए यहाँ कई ASCII आर्ट तस्वीरें हैं:
rank send buf recv buf
---- -------- --------
0 a,b,c MPI_Allgather a,b,c,A,B,C,#,@,%
1 A,B,C ----------------> a,b,c,A,B,C,#,@,%
2 #,@,% a,b,c,A,B,C,#,@,%
यह केवल इस मामले सभी प्रक्रियाओं डेटा हिस्सा प्राप्त में बस नियमित MPI_Gather है, आपरेशन यानी, जड़ कम है।
rank send buf recv buf
---- -------- --------
0 a,b,c MPI_Alltoall a,A,#
1 A,B,C ----------------> b,B,@
2 #,@,% c,C,%
(a more elaborate case with two elements per process)
rank send buf recv buf
---- -------- --------
0 a,b,c,d,e,f MPI_Alltoall a,b,A,B,#,@
1 A,B,C,D,E,F ----------------> c,d,C,D,%,$
2 #,@,%,$,&,* e,f,E,F,&,*
(बेहतर लग रहा है, तो प्रत्येक तत्व रैंक है कि यह भेजता है लेकिन ... द्वारा रंग है) संयुक्त MPI_Scatter और MPI_Gather रूप
MPI_Alltoall काम करता है - प्रत्येक प्रक्रिया में भेजने बफर MPI_Scatter में तरह विभाजित है और तो भाग के प्रत्येक कॉलम को संबंधित प्रक्रिया द्वारा एकत्र किया जाता है, जिसका रैंक खंड कॉलम की संख्या से मेल खाता है। MPI_Alltoall को वैश्विक ट्रांसपोजिशन ऑपरेशन के रूप में भी देखा जा सकता है, जो डेटा के हिस्सों पर कार्य करता है।
क्या कोई ऐसा मामला है जब दो संचालन एक दूसरे के बदले में हो?ठीक से इस सवाल का जवाब करने के लिए, एक बस प्राप्त बफर में भेजने बफर में और डेटा के डेटा के आकार का विश्लेषण करने के होते हैं:
operation send buf size recv buf size
--------- ------------- -------------
MPI_Allgather sendcnt n_procs * sendcnt
MPI_Alltoall n_procs * sendcnt n_procs * sendcnt
प्राप्त बफर आकार वास्तव में n_procs * recvcnt है, लेकिन एमपीआई जनादेश है कि संख्या भेजे गए मूलभूत तत्वों की संख्या मूलभूत तत्वों की संख्या के बराबर होनी चाहिए, इसलिए यदि एक ही एमपीआई डेटाटाइप का उपयोग MPI_All... के हिस्सों को भेजने और प्राप्त करने में किया जाता है, तो recvcntsendcnt के बराबर होना चाहिए।
यह तुरंत स्पष्ट है कि प्राप्त डेटा के उसी आकार के लिए, प्रत्येक प्रक्रिया द्वारा भेजे गए डेटा की मात्रा अलग है। दोनों परिचालनों के बराबर होने के लिए, एक आवश्यक शर्त यह है कि दोनों मामलों में भेजे गए बफर के आकार बराबर हैं, यानी n_procs * sendcnt == sendcnt, जो केवल n_procs == 1 है, यानी यदि केवल एक प्रक्रिया है, या sendcnt == 0, यानी कोई डेटा नहीं है बिल्कुल भेजा जा रहा है। इसलिए कोई व्यावहारिक रूप से व्यवहार्य मामला नहीं है जहां दोनों परिचालन वास्तव में अंतर-परिवर्तनीय हैं। लेकिन कोई MPI_AllgatherMPI_Alltoall के साथ n_procs दोहराए गए बफर में समान डेटा (जैसा कि पहले से ही टायलर गिल द्वारा नोट किया गया है) को दोहरा कर अनुकरण कर सकता है।
rank send buf recv buf
---- -------- --------
0 a MPI_Allgather a,A,#
1 A ----------------> a,A,#
2 # a,A,#
और यहाँ एक ही MPI_Alltoall के साथ लागू किया:
rank send buf recv buf
---- -------- --------
0 a,a,a MPI_Alltoall a,A,#
1 A,A,A ----------------> a,A,#
2 #,#,# a,A,#
रिवर्स है संभव नहीं - एक MPI_Allgather साथ MPI_Alltoall की कार्रवाई नहीं दिखाई जा सकतीं यहाँ एक तत्व भेज बफ़र्स साथ MPI_Allgather की कार्रवाई है सामान्य मामले में।
MPI_Allgatherv
MPI_Alltoallv
इस एक कंपनियों हालांकि:
एक बहुत अच्छा जवाब। विशेष रूप से चित्रण और चित्रों के साथ अवधारणा बहुत स्पष्ट है। धन्यवाद हिस्टो Iliev –
इन दोनों तरीकों वास्तव में बहुत समान हैं, वहीं उनमें से दो के बीच एक महत्वपूर्ण अंतर हो रहा है।
MPI_Allgather प्रत्येक प्रक्रिया के साथ समाप्त होता है जिसमें उसके प्राप्त बफर में सटीक डेटा होता है, और प्रत्येक प्रक्रिया समग्र सरणी में एक मान का योगदान देती है। उदाहरण के लिए, यदि प्रक्रियाओं के एक समूह में से प्रत्येक को अपने राज्य के बारे में कुछ और मूल्य साझा करने की आवश्यकता होती है, तो प्रत्येक एक अपना मूल्य प्रदान करेगा। इन मानों को तब सभी को भेजा जाएगा, इसलिए सभी के पास एक ही संरचना की एक प्रति होगी।
MPI_Alltoall एक ही मूल्य को एक-दूसरे की प्रक्रिया में नहीं भेजता है। एक अन्य मूल्य प्रदान करने के बजाय जिसे एक-दूसरे की प्रक्रिया के साथ साझा किया जाना चाहिए, प्रत्येक प्रक्रिया एक दूसरे को प्रक्रिया देने के लिए एक मान निर्दिष्ट करती है। दूसरे शब्दों में, एन प्रक्रियाओं के साथ, प्रत्येक को साझा करने के लिए एन मान निर्दिष्ट करना होगा। फिर, प्रत्येक प्रोसेसर जे के लिए, इसके k'th मान को प्राप्त बफर में k के j'th अनुक्रमणिका को संसाधित करने के लिए भेजा जाएगा। यह उपयोगी है अगर प्रत्येक प्रक्रिया में एक दूसरे के लिए एक एकल, अद्वितीय संदेश होता है।
अंतिम नोट के रूप में, ऑलगदर और ऑलटॉल चलाने के परिणाम उसी मामले में समान होंगे जहां प्रत्येक प्रक्रिया ने उसी मूल्य के साथ अपने प्रेषण बफर को भर दिया था। केवल अंतर यह होगा कि गठबंधन अधिक कुशल होगा।
आपको बहुत धन्यवाद –
इन दो स्क्रीनशॉट एक त्वरित स्पष्टीकरण MPI_Allgatherv और MPI_Alltoallv के बीच rison, लेकिन यह भी बताता है कि MPI_Allgather MPI_Alltoall से अलग कैसे है।
क्या आपने इस प्रश्न पूछने से पहले एमपीआई मानक पढ़ा था? यह बहुत स्पष्ट स्पष्टीकरण देता है और यहां तक कि कई सामूहिक सामग्रियों के ग्राफिकल प्रतिनिधित्व भी करता है। – Jeff