ओपनएमपी का उपयोग कर समांतरता के कई स्तर - संभव? होशियार? प्रैक्टिकल?

Question

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

हमारे द्वारा हल किए जाने वाले डोमेन को उप-डोमेन में विभाजित किया जा सकता है, जो एक ब्लॉक-विकर्ण प्रारूप में एक साथ आते हैं। तो हमारी स्टोरेज योजना उप-डोमेन (जैसे संपीड़ित पंक्ति भंडारण: सीआरएस, संपीड़ित विकर्ण भंडारण: सीडीएस, घने, आदि ..) के लिए उपयुक्त प्रारूप के साथ छोटे स्क्वायर मैट्रिस (ब्लॉक []) की एक सरणी की तरह दिखती है। और एक पृष्ठभूमि मैट्रिक्स (वर्तमान में सीआरएस का उपयोग) जो उप-डोमेन के बीच कनेक्टिविटी के लिए जिम्मेदार है।

अधिकांश (सभी?) पुनरावृत्त सॉल्वर में "हॉट स्पॉट" मैट्रिक्स वेक्टर गुणात्मक ऑपरेशन है, और यह मेरी लाइब्रेरी के बारे में सच है। इस प्रकार, मैं अपने एमएक्सवी रूटीन को अनुकूलित करने के अपने प्रयासों पर ध्यान केंद्रित कर रहा हूं। ब्लॉक विकर्ण संरचना के लिए, के लिए एम * एक्स = ख छद्म कोड के रूप में किया जाएगा इस प्रकार है:

b=background_matrix*x 
start_index = 1; 
end_index = 0; 
for(i=1:number of blocks) { 
    end_index=start_index+blocks[i].numRows(); 
    b.range(start_index, end_index) += blocks[i] * x.range(start_index, end_index); 
    start_index = end_index+1; 
} 

जहां background_matrix पृष्ठभूमि है (सीआरएस) मैट्रिक्स, ब्लॉक सब-डोमेन मैट्रिक्स की सरणी, और .range है एक प्रारंभिक सूचकांक से एक अंत सूचकांक तक वेक्टर का हिस्सा देता है।

जाहिर है कि लूप समानांतर हो सकता है (और किया गया है), क्योंकि ऑपरेशन लूप के अन्य पुनरावृत्तियों से स्वतंत्र हैं (श्रेणियां गैर-ओवरलैपिंग हैं)। चूंकि हमारे पास एक ठेठ प्रणाली में 10-15 ब्लॉक हैं, इसलिए 4+ धागे वास्तव में एक महत्वपूर्ण अंतर बनाते हैं।

दूसरी जगह जहां समांतरता को एक अच्छा विकल्प माना गया है, प्रत्येक उप-डोमेन संग्रहण योजना (उपरोक्त कोड में पंक्ति 1 और 6 में कॉल) के लिए एमएक्सवी ऑपरेशन में है। समानांतर सीआरएस, सीडीएस, और घने मैट्रिक्स एमएक्सवी संचालन पर बहुत कुछ है। आम तौर पर 2 धागे के साथ एक अच्छा बढ़ावा देखा जाता है, जिसमें बहुत कम रिटर्न होते हैं क्योंकि अधिक धागे जोड़े जाते हैं।

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

Answer 1

कृपया ध्यान दें कि जो कुछ भी मैं वर्णन करता हूं वह कार्यान्वयन निर्भर है।

क्या लूप के लिए ओपनएमपी में धागे की संख्या को सीमित करना संभव है?

हां। ऐसा करने के विभिन्न तरीके हैं। omp_set_nested(1); निर्धारित करें और अपनी बाहरी पाश और अपने भीतर के पाश में #pragma omp parallel for num_threads(2) निर्देश में #pragma omp parallel for num_threads(4) या इसी तरह की तरह कुछ का उपयोग करें।यह आपको 8 धागे (कार्यान्वयन के आधार पर, आपको संभवतः OMP_THREAD_LIMIT सेट करना होगा यदि आपके पास 8 से कम कोर हैं)

वैकल्पिक रूप से, आप मैन्युअल रूप से अपने लूप को अनलॉक कर सकते हैं, उदा। जैसे

#pragma omp parallel sections { 
    #pragma omp section 
    do your stuff for the first part, nest parallel region again 
    #pragma omp section 
    and so on for the other parts 
} 

कुछ का उपयोग कर आप #pragma omp task साथ OpenMP 3.0 में कभी कभी और अधिक कुशलता से एक ही बात कर सकते हैं।

या आप 8 थ्रेड शुरू करते हैं और समान थ्रेड नंबर के भीतर वर्तमान थ्रेड नंबर प्राप्त करते हैं और थ्रेड नंबर के आधार पर मैन्युअल रूप से शेड्यूल करते हैं।

अंत में, यदि आपके पास पूरी तरह से नेस्टेड लूप है (एक लूप पूरी तरह से घोंसला है, यदि वास्तविक असाइनमेंट केवल सबसे कम लूप में होता है), तो आप सब कुछ एक ही लूप में फिर से लिख सकते हैं। मूल रूप से अपने दो इटरेटर i और j को एक बड़े इटरेटर (i, j) में पैक करें। ध्यान दें कि इससे इलाके में कमी आ सकती है और इसलिए प्रदर्शन कम हो सकता है

क्या यह बहु-स्तर समांतरता कुछ है जो अभ्यास में समझ में आता है?

यह निर्भर करता है, और आपको स्वयं को ढूंढना होगा। आम तौर पर, बहु-स्तर समानांतरता आपकी समस्या को अधिक स्केलेबल बनाती है। शेड्यूलिंग, हालांकि, अधिक जटिल हो सकता है। यह paper दिलचस्प हो सकता है।

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

मैन्युअल नेस्टेड समानांतरवाद में धागे की संख्या की स्थापना का मुख्य नुकसान यह है कि अंतरतम पाश में धागे अंतर्निहित बाधा पर इडली इंतजार सकता है, जबकि अतिरिक्त कार्य किया जा सकता है (example) है। इसके अलावा, मोटे अनाज समांतरता अच्छी तरह से पैमाने पर नहीं है। तो यदि आपके बाहरी लूप में लूप के भीतर बहुत अलग रन-टाइम है, तो आप केवल 4 धागे में विभाजित होने से अधिक लचीला रूप से शेड्यूल करना चाहते हैं। हालांकि SIMD साथ MXV करने के बारे में

किसी भी अन्य विचारों

आप लो। वास्तुकला के आधार पर, यह 2-4 की गति प्रदान कर सकता है। मैंने आपके लिए इस presentation को जल्दी से गुगल किया।

एमएक्सवी, loop tiling, register and cache blocking और संबंधित तकनीक डेटा इलाके में वृद्धि कर सकती है और अन्य मुद्दों को कम कर सकती है, उदाहरण के लिए झूठी साझाकरण यह book, अध्याय 11 (आप इसका पूर्वावलोकन कर सकते हैं), आपको डेटा एक्सेस को पुन: स्थापित करने के तरीके पर कुछ अतिरिक्त विचार दे सकते हैं।

Answer 2

क्यों नहीं OpenMP.org

रजिस्टर पर विशेषज्ञों से अधिक पूछने के लिए और पर लॉग इन करें: http://openmp.org/forum/viewforum.php?f=3