doParallel पैकेज का उपयोग करते समय registerDoParallel में क्लस्टर और कोर के बीच क्या अंतर है?doParallel, क्लस्टर बनाम कोर
मेरी समझ सही है कि एक मशीन पर इन परस्पर विनिमय कर रहे हैं और मैं के लिए एक ही परिणाम प्राप्त होगा: मैं देख रहा हूँ makeCluster() स्पष्ट रूप से बंद कर दिया जाना है
cl <- makeCluster(4)
registerDoParallel(cl)
और
registerDoParallel(cores = 4)
फर्क सिर्फ इतना है stopCluster() का उपयोग कर।
हां, यह सॉफ्टवेयर दृश्य से सही है।
एकल मशीन पर ये एक दूसरे के बदले हैं और मुझे एक ही परिणाम मिलेंगे।
'समूह' और 'कोर' को समझने के लिए स्पष्ट रूप से, मैं 'हार्डवेयर' और 'सॉफ्टवेयर' स्तर से सोचने के लिए सुझाव देते हैं।
हार्डवेयर स्तर में, 'क्लस्टर' का अर्थ नेटवर्क से जुड़ा हुआ मशीन है जो सॉकेट द्वारा संचार द्वारा एक साथ काम कर सकता है (stopCluster के रूप में अधिक init/stop संचालन की आवश्यकता है)। जबकि 'कोर' का मतलब स्थानीय सीपीयू में कई हार्डवेयर कोर होते हैं और वे साझा स्मृति द्वारा आम तौर पर काम करते हैं (ए से बी से स्पष्ट रूप से संदेश भेजने की आवश्यकता नहीं है)।
सॉफ़्टवेयर स्तर में, कभी-कभी cluster और cores की सीमा स्पष्ट नहीं है। इस कार्यक्रम को क्लस्टर द्वारा कोर या रिमोट द्वारा स्थानीय में चलाया जा सकता है, और उच्च स्तरीय सॉफ़्टवेयर को विवरण जानने की आवश्यकता नहीं है। इसलिए, हम एक मशीन, में cl सेटिंग के रूप में स्थानीय में स्पष्ट संचार का उपयोग करने जैसे दो मोड मिश्रण कर सकते हैं और प्रत्येक दूरस्थ मशीनों में मल्टीकोर भी चला सकते हैं।
अपने प्रश्न पर वापस, cl या cores बराबर स्थापित कर रही है?
सॉफ़्टवेयर से, यह वही होगा जो प्रोग्राम क्लाइंट/सर्वरों द्वारा समान संख्या में चलाया जाएगा और फिर एक ही परिणाम प्राप्त होगा।
हार्डवेयर से, यह अलग हो सकता है। cl साझा स्मृति के लिए स्पष्ट और cores संवाद करने का मतलब है, लेकिन यदि उच्च स्तरीय सॉफ़्टवेयर बहुत अच्छी तरह अनुकूलित हुआ है। स्थानीय मशीन में, दोनों सेटिंग एक ही प्रवाह में चलेगी। मैं अब doParallel में बहुत गहराई से नहीं देखता हूं, इसलिए मुझे यकीन नहीं है कि ये दोनों एक जैसे हैं।
लेकिन व्यवहार में, एकल मशीन के लिए cores निर्दिष्ट करना और cl क्लस्टर के लिए निर्दिष्ट करना बेहतर है।
आपके लिए यह सहायता आशा है।
यह बहुत सामान्य है। ओपी का सवाल doParallel पैकेज के बारे में एक विशिष्ट सवाल है, सामान्य अवधारणा प्रश्न नहीं। इस सवाल के लिए, यह प्लेटफार्म कार्यान्वयन के बारे में अधिक है, और वे एकल मशीन के लिए भी अलग हैं। – dracodoc
मुझे लगता है कि चुना गया उत्तर बहुत सामान्य है और वास्तव में सटीक नहीं है, क्योंकि यह doParallel पैकेज के विवरण को स्पर्श नहीं करता है। यदि आप विगेट्स पढ़ते हैं, तो यह वास्तव में बहुत स्पष्ट है।
समानांतर पैकेज अनिवार्य रूप से मल्टीकोर पैकेज है, जो साइमन Urbanek द्वारा लिखा गया था के विलय, और बर्फ पैकेज, जो ल्यूक टायर्नी और दूसरों के द्वारा लिखा गया था है। मल्टीकोर कार्यक्षमता केवल उन कार्यकर्ताओं का समर्थन करती है जो ऑपरेटिंग सिस्टम जो फोर्क सिस्टम कॉल का समर्थन करती हैं; इसमें विंडोज़ शामिल नहीं है। डिफ़ॉल्ट रूप से, doParallel यूनिक्स-जैसी सिस्टम और विंडोज़ पर बर्फ कार्यक्षमता पर मल्टीकोर कार्यक्षमता का उपयोग करता है।
हम बर्फ जैसी कार्यप्रणाली इस शब्दचित्र में प्रयोग करेंगे, तो हम पैकेज लोड हो रहा है और एक क्लस्टर
मल्टीकोर की तरह कार्यक्षमता का उपयोग करने के लिए शुरू करने से शुरू, हम कोर की संख्या के बजाय
उपयोग करने के लिए निर्दिष्ट करना होगा
संक्षेप में, यह सिस्टम निर्भर है। क्लस्टर अधिक सामान्य मोड सभी प्लेटफार्मों को कवर करता है, और कोर केवल यूनिक्स जैसी प्रणाली के लिए है।
इंटरफ़ेस को सुसंगत बनाने के लिए, पैकेज ने इन दो तरीकों के लिए एक ही फ़ंक्शन का उपयोग किया।
> library(doParallel)
> cl <- makeCluster(4)
> registerDoParallel(cl)
> getDoParName()
[1] "doParallelSNOW"
> registerDoParallel(cores=4)
> getDoParName()
[1] "doParallelMC"
doParallel::registerDoParallel(<numeric>) के व्यवहार ऑपरेटिंग सिस्टम पर निर्भर करता है, जानकारी के लिए print(doParallel::registerDoParallel) देखते हैं।
Windows मशीनों पर,
doParallel::registerDoParallel(4)
प्रभावी रूप से
cl <- makeCluster(4)
doParallel::registerDoParallel(cl)
करता है अर्थात यह चार ("PSOCK") कि पृष्ठभूमि आर सत्र में चलाने के कार्यकर्ताओं की स्थापना की। फिर, %dopar% मूल रूप से parallel::parLapply() मशीनरी का उपयोग करेगा। इस सेटअप के साथ, आपको प्रत्येक श्रमिकों पर वैश्विक चर और पैकेज संलग्न होने की चिंता करनी होगी।
तथापि, गैर Windows मशीनों पर,
doParallel::registerDoParallel(4)
परिणाम होगा कि %dopar%parallel::mclapply() मशीनरी, जो बारी में निर्भर करता है पर प्रक्रियाओं काँटेदार का उपयोग करेंगे। चूंकि फोर्किंग का उपयोग किया जाता है, इसलिए आपको ग्लोबल्स और पैकेज के बारे में चिंता करने की ज़रूरत नहीं है।
सुनिश्चित नहीं है, लेकिन मुझे लगता है कि आप कोर की संख्या से शारीरिक रूप से सीमित होंगे, लेकिन क्लस्टर की संख्या से नहीं, यानी "समानांतर में चल रहे आर की प्रतियां और सॉकेट पर संचार" की संख्या। बेशक, क्लस्टर/कोर की संख्या के अनुपात संख्या के आधार पर क्लस्टर संभावित रूप से एक ही कोर साझा कर सकते हैं। –
मैं @ पास्कल से सहमत हूं और यह कि एक मशीन पर कोई फर्क नहीं पड़ता है, वास्तव में यह पता लगाने के बाहर कि क्या हासिल किया जा सकता है और चीजें कैसे काम करती हैं। यदि आप बस कुछ कोड समानांतर करना चाहते हैं, तो इससे किसी भी तरह से कोई फर्क नहीं पड़ता। – LauriK