कार्यों का समानांतर होना। "पूर्ण समानता" का मामला। भाग २

.NET 4 में सुझाए गए समाधान

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



"आदर्श" छोरों को समानांतर बनाने के लिए निम्नलिखित विकल्प दिए गए हैं:

• क्लास सिस्टम। थ्रेडिंग। मास्क। फॉर (), फॉरएच () विधियों के साथ समानांतर
• AsParallel () एक्सटेंशन विधि के साथ समानांतर LINQ।

Parallel.For और Parallel.ForEach Methods

आइए समानांतर वर्ग और इसके लूप संगठन के तरीकों को देखकर शुरू करें।



पहली विधि जिस पर हम विचार कर रहे हैं, वह एक हस्ताक्षर है (यह एक बुनियादी एक है, कई अतिभारों में से एक है):

1. public static ParallelLoopResult For ( int fromInclusive, int toExclusive, Action < int > body ) ;
   
   
   
   

यह रिटर्न मूल्य के प्रकार को छोड़कर, लेख के पहले भाग से हमारे प्रयोगात्मक तरीकों के हस्ताक्षर के समान कई मायनों में है।



दूसरा "बुनियादी विन्यास में" ऐसा दिखता है:

1. सार्वजनिक स्थैतिक ParallelLoopResult ForEach < TSource > ( IEnumerable < TSource > स्रोत, Action < TSource > body ) ;

विचार करें कि Parallel.For और Parallel.ForEach विधियाँ क्या कर सकती हैं।



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



चक्र का प्रारंभिक व्यवधान। फ़ॉरेस्ट पद्धति के संबंधित अधिभार संदर्भ ऑब्जेक्ट पर स्टॉप या ब्रेक के तरीकों को कॉल करके निष्पादन को बाधित करने की क्षमता प्रदान करते हैं (प्रत्येक प्रवाह के लिए पारित)।



स्टॉप और ब्रेक के बीच का अंतर यह है कि स्टॉप सामान्य रूप से नए पुनरावृत्तियों को शुरू करने से रोकने की आवश्यकता को इंगित करता है, और ब्रेक - नए पुनरावृत्तियों को रोकने के लिए, निम्नलिखित (क्रम में) जिसमें ब्रेक कहा जाता है। यही है, जब 5 वीं पुनरावृत्ति पर ब्रेक का आह्वान किया जाता है, तो यह गारंटी दी जाती है कि समानता के बावजूद, 1 से 4 वें तक की पुनरावृत्तियों को अभी भी प्रदर्शन किया जाएगा। और जब स्टॉप को 5 पुनरावृत्तियों पर बुलाया जाता है, यदि पुनरावृत्ति 4 अभी तक शुरू नहीं हुआ है, तो यह शुरू नहीं होगा।



वर्तमान पुनरावृत्तियों जो पहले से ही स्टॉप या ब्रेक के लिए कॉल के समय चल रहे थे, चक्र की रुकावट की स्थिति की जांच कर सकते हैं, और यदि वे पूरे चक्र के रुकावट के बारे में सीखते हैं तो समय से पहले समाप्त हो जाएंगे। ऐसा करने के लिए, वे संदर्भ ऑब्जेक्ट के संबंधित गुणों की जांच कर सकते हैं: IsStopping और LowestBreakIteration।



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



समानता के स्तर को कॉन्फ़िगर करने की क्षमता । आप निष्पादित करने के लिए उपयोग किए जाने वाले थ्रेड्स की अधिकतम संख्या निर्दिष्ट कर सकते हैं।



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



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



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



इसके बाहर से एक लूप के निष्पादन को रद्द करने के लिए समर्थन ऐसा करने के लिए, क्लास कैंसिलेशनटोकनसोर्स का उपयोग करें। लूप शुरू करते समय, आपको इसमें टोकन संपत्ति को पास करने की आवश्यकता होती है, और फिर बाहर से लूप को रद्द करने का अनुरोध करने के लिए, आपको बस रद्द करने की आवश्यकता होती है रद्द करें () विधि को कैंसेलेशनटोकनसे सोर्स ऑब्जेक्ट पर, जो लूप के नए पुनरावृत्तियों की शुरुआत को रोक देगा, और सभी चालू पुनरावृत्तियों के पूरा होने पर एक ऑपरेशनचैनेल को समायोजित करेगा। मौजूदा पुनरावृत्तियों, रद्द करने की स्थिति की जांच कर सकते हैं ताकि वे "स्वेच्छा से" समय से पहले समाप्त हो जाएं यदि उन्हें पता चले कि पूरा चक्र रद्द हो गया है।

समानान्तर समानांतर

.NET 3.5 में एक एक्सटेंशन के रूप में उपलब्ध है, System.Core में .NET 4.0 में समानांतर LINQ उपलब्ध है। इसका उपयोग करने का विचार बहुत सरल है: हम .As समानांतर () कॉल को LINQ क्वेरी श्रृंखला में जोड़ते हैं, और श्रृंखला के सभी बाद के कॉल समानांतर में किए जाते हैं। उदाहरण के लिए:

1. var दोगुनी = नई [ ] { १ , २ , ३ , ४ } । AsParallel ( ) । चयन करें ( i => i * 2 ) ;

यह स्पष्ट नहीं हो सकता है कि परिणामस्वरूप संग्रह में तत्वों का क्रम मनमाना हो सकता है, क्योंकि वे समानांतर में संसाधित होते हैं। संग्रह में तत्वों के क्रम को बनाए रखने के लिए, हम इस तरह से अपने पहले टुकड़े को संशोधित कर सकते हैं:

1. var दोगुनी = नई [ ] { १ , २ , ३ , ४ } । AsParallel ( ) । AsOrdered ( ) । चयन करें ( i => i * 2 ) ;

प्रसंस्करण अभी भी समानांतर में होगा, लेकिन एकत्रीकरण चरण (प्रत्येक थ्रेड से परिणाम का संग्रह) अधिक समय ले सकता है, क्योंकि आपको उन थ्रेड्स की प्रतीक्षा करने की आवश्यकता होगी जो पहले "पहले" तत्वों को गिनते हैं, उनका परिणाम लेते हैं, और उसके बाद ही उन थ्रेड्स से परिणाम लेते हैं जो "अंतिम" पढ़ते हैं तत्वों।



पीएलआईएनक्यू के साथ काम करते समय जागरूक होना महत्वपूर्ण है कि इसके लिए अतिरिक्त ओवरहेड है

1. प्रवाह द्वारा मूल गणना के आने वाले तत्वों का वितरण
2. एक आम संग्रह में गणना तत्वों का एकत्रीकरण।

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



AsParallel () मेथड IEnumerable नहीं, बल्कि ParallelEnumerable देता है, इसके बाद अन्य सभी LINQ मेथड (Select, Where, etc.) भी उसी प्रकार वापस आते हैं। जब तक श्रृंखला में ParallelEnumarable को प्रसारित किया जाता है, तब तक प्रत्येक प्रवाह की गणना के परिणाम अनावश्यक रूप से एकत्र नहीं किए जाते हैं, और एक पाइपलाइन बनाई जाती है।



यह समझना महत्वपूर्ण है कि जब पाइप लाइन टूट जाती है, तो समानांतरता बंद हो जाती है और डेटा को एकल परिणामी संग्रह में एकत्र किया जाता है। उदाहरण के लिए, यह कोड काम नहीं करता है क्योंकि कोई गलत तरीके से मान सकता है:

1. सूची < InputData > inputData = ... ;
2. foreach ( इनपुट ओटाटा में var o। AsParallel ( ) । Select ( i => new OutputData ( i ) )
3. {
4. प्रोसेसऑटपुट ( ओ ) ;
5. }

समानांतर में, केवल OutputData ऑब्जेक्ट्स का निर्माण यहां किया जाएगा, जिसके बाद सभी प्रवाह इन ऑब्जेक्ट्स को इकट्ठा करेंगे और परिणामी संग्रह बनाएंगे, जो प्रत्येक तत्व के लिए ProcessOutput () को कॉल के साथ क्रमिक रूप से फैलाएंगे।



यहां एकत्र होने वाले अनावश्यक कदम से बचने के लिए, आप ParallelEnumarable.ForAll () विधि का उपयोग कर सकते हैं:

1. सूची < InputData > inputData = ... ;
2. inputData। AsParallel ( ) । चुनें ( i => नया आउटपुटडेटा ( i ) ) । ForAll ( o =>)
3. {
4. प्रोसेसऑटपुट ( ओ ) ;
5. } ;

इस मामले में, "नए आउटपुटडैट (i)" चरण के बाद, "प्रॉसेसऑटपुट (ओ)" चरण को भी समानांतर में निष्पादित किया जाएगा, उनके बीच एकत्रीकरण चरण के बिना।



यह ध्यान दिया जाना चाहिए कि "inputData.AsParallel () के लिए Parallel.ForEach () को कॉल करना ।Select (i => new OutputData (i))" में समान आवर्ती के साथ पहले उदाहरण के रूप में एक ही खामी होगी: Parallel.ForEach () में IEnumerable पारित हो जाता है, ParallelEnumerable नहीं - इसलिए, Parallel.ForEach () के संग्रह को पास करने से पहले, इसे एकत्रित कर देगा। इससे बचने के लिए, ParallelEnumerable.ForAll () विधि है, जिसका उपयोग इस मामले में किया जाना चाहिए।

आम समस्याओं और त्रुटियों

इन घटकों के साथ काम करते समय संभावित समस्याओं पर विचार करें।

देशी धागा सुरक्षा

सबसे पहले, आपको यह समझने की आवश्यकता है कि Parallel.ForEach का उपयोग करने से आपका कोड थ्रेड सुरक्षित नहीं होगा - आपको यह सुनिश्चित करने की आवश्यकता है कि पुनरावृत्तियां एक दूसरे से स्वतंत्र हैं, या, यदि वे निर्भर हैं, तो स्पष्ट रूप से साझा संसाधनों के साथ थ्रेड सुरक्षित संचालन के लिए प्रदान करें।



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

चक्र शरीर के आयाम

समानांतर वर्ग का उपयोग करने में कम से कम एक ओवरहेड शामिल है

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

यदि चक्र का शरीर काफी लंबा है, तो ये अतिरिक्त लागतें एक छोटी भूमिका निभाती हैं। हालांकि, अगर हम "i = i * i" जैसे कुछ बहुत ही सरल करते हैं, तो इस मामले में ओवरहेड उपयोगी काम से अधिक है। इस कमी से छुटकारा पाने के लिए, चक्र के शरीर को "बड़ा" करना आवश्यक है। ऐसा करना बहुत सरल है, इसमें एक नहीं, बल्कि कई पुनरावृत्तियां शामिल हैं।



आप ब्लॉक के सेट में इनपुट अनुक्रम को स्पष्ट रूप से तोड़कर मैन्युअल रूप से कर सकते हैं, और इस सेट पर एक समानांतर चक्र शुरू कर सकते हैं, और इस समानांतर चक्र के शरीर में, प्रत्येक ब्लॉक पहले से ही क्रमिक रूप से संसाधित होता है। हालांकि, यहां आपको इन ब्लॉकों की संख्या के बारे में फैसला करना होगा। आप इसे लाइब्रेरी को सौंप सकते हैं और इनपुट अनुक्रम से सबसेट बनाने के लिए विशेष रूप से बनाए गए वर्ग का उपयोग कर सकते हैं: System.Concurrent.Collections.Partitioner।



यह चक्र का उपयोग करना

1. for ( int i = 0 ; मैं < लंबाई ; i ++ )
2. परिणाम [ i ] = i * i ;

भोले संस्करण के बजाय:

1. समानांतर। के लिए ( से, को, मैं =>
2. {
3. परिणाम [ i ] = i * i ;
4. } ;

इस तरह प्रभावी ढंग से समानांतर किया जा सकता है:

1. समानांतर। ForEach ( विभाजनकर्ता । बनाएँ ( से, से ) , श्रेणी =>
2. {
3. for ( int i = range। Item1 ; i < रेंज। Item2 ; i ++ )
4. {
5. परिणाम [ i ] = i * i ;
6. }
7. } ;

Partitioner.Create (से), ब्लॉकों का एक ही सेट बनाता है जिसे हम समानांतर, क्रमिक रूप से लूप बॉडी के अंदर प्रत्येक ब्लॉक को संसाधित करते हैं। इस प्रकार, हम एक लंबे शरीर को एक समानांतर चक्र प्रदान करते हैं, और अधिक से अधिक उपयोगी कार्य के लिए ओवरहेड वितरित करते हैं।

नेस्टेड लूप प्रसंस्करण

नेस्टेड लूप को संसाधित करते समय, सवाल उठता है कि समानांतर रूप से यह कितनी गहराई से लायक है। एक आयताकार छवि को संसाधित करने का एक उदाहरण लें:

1. के लिए ( int y = 0 ; y < स्क्रीनहाइट ; y ++ )
2. {
3. int stride = y * screenWidth ;
4. ( int x = 0 ; x < screenWidth ; x ++ ) के लिए
5. {
6. आरजीबी [ एक्स + स्ट्राइड ] = कैल्कलर ( एक्स, वाई ) ; // रंग की गणना करें
7. }
8. } ;

आप केवल बाहरी लूप को कॉल के साथ Paralllel.For, या दोनों में बदल सकते हैं। यदि दोनों चक्र समानांतर बनाए जाते हैं, तो क्या आंतरिक शरीर बहुत छोटा हो जाएगा? यदि हम आंतरिक को छोड़ देते हैं, तो क्या हम अपने सभी कोर को काम के साथ लोड करना सुनिश्चित करते हैं?



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



एक वैकल्पिक तरीका एक में दो नेस्टेड छोरों को तैनात करना और पहले से ही इसे समानांतर करना हो सकता है:

1. int TotalPixels = screenHeight * screenWidth ;
2. समानांतर। के लिए ( 0 , TotalPixels, i =>
3. {
4. int y = i / screenWidth, x = i % screenWidth ;
5. आरजीबी [ i ] = कैल्ककलर ( एक्स, वाई ) ;
6. } ;

अगर कैल्कॉलर () बहुत सरल है, तो लूप के शरीर को बड़ा करने के लिए, आप विभाजनकर्ता वर्ग का उपयोग कर सकते हैं, जैसा कि पिछले उदाहरण में है:

1. int TotalPixels = screenHeight * screenWidth ;
2. समानांतर। ForEach ( विभाजक। Create ( 0 , TotalPixels ) , श्रेणी =>
3. {
4. for ( int i = range। Item1 ; i < रेंज। Item2 ; i ++ )
5. {
6. int y = i / screenWidth, x = i % screenWidth ;
7. आरजीबी [ i ] = कैल्ककलर ( एक्स, वाई ) ;
8. }
9. } ;

असुरक्षित IList कार्यान्वयन

Parallel.ForEach और PLINQ दोनों ही इनपुट पर IEnumerable को स्वीकार करते हैं, लेकिन साथ ही साथ उनके पास गए संग्रह के लिए इसके साथ काम करने के लिए सबसे तेज़ इंटरफ़ेस खोजने की कोशिश करते हैं। विशेष रूप से, समानांतरकरण के लिए, IList इंटरफ़ेस केवल IEnumerable से बेहतर है क्योंकि इसमें किसी भी तत्व के लिए यादृच्छिक अभिगम के लिए अनुक्रमणिका है। इसलिए, यदि IList को हस्तांतरित संग्रह के लिए परिभाषित किया गया है, तो इसके साथ काम इस इंटरफ़ेस के माध्यम से होता है। यह सिंक्रनाइज़ेशन की लागत को कम करता है, लेकिन पुस्तकालय कोड अनुक्रमणिका के थ्रेड-सुरक्षित कार्यान्वयन पर निर्भर करता है ।



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



ऐसा करने के लिए, दो विकल्प उपयुक्त हैं। सबसे पहले एक System.Collections.Concurrent.Partitioner बनाने के लिए है:

1. // IList <T> का उपयोग यहां किया जा सकता है यदि यह संग्रह द्वारा समर्थित है
2. IEnumerable < T > स्रोत = ... ;
3. समानांतर। ForEach ( स्रोत, आइटम => { /*..आईएमआई }} ) ;
5. // और यहाँ IEnumerable <T> का उपयोग करने की गारंटी दी गई है
6. IEnumerable < T > स्रोत = ... ;
7. समानांतर। ForEach ( विभाजनकर्ता । क्रिएट ( स्रोत ) , आइटम => { /*..आईएमआई }} ;

दूसरा तरीका स्पष्ट है, और सामान्य LINQ में परिचित है: बस संग्रह के लिए कॉल करें ".Select (आइटम => आइटम)"। यह Parallel.For और PLINQ दोनों के लिए उपयुक्त है:

1. // यह भी IEnumerable <T> का उपयोग करने की गारंटी है
2. स्रोत। चुनें ( i => i ) । AsParallel ( ) । चयन करें ( i => { /*...*/ } ) ;

स्रोत संग्रह के लिए थ्रेड आत्मीयता

जब Parallel.ForEach और PLINQ को चलाते हैं, तो प्रत्येक वर्कफ़्लोज़ स्वयं को स्रोत संग्रह पर MoveNext () कहता है। यदि संग्रह ऐसा है कि इसका उपयोग केवल एक विशिष्ट स्ट्रीम से संभव है (इसमें "स्ट्रीम के लिए आत्मीयता है"), उदाहरण के लिए, जब विंडोज फॉर्म या डब्ल्यूपीएफ में यूआई घटकों के साथ काम करते हैं, तो आप सीधे इन तंत्रों का उपयोग नहीं कर सकते।



इस तरह के संग्रह के समानांतर प्रसंस्करण को सुनिश्चित करने के लिए, आपको निर्माता-उपभोक्ता टेम्पलेट का उपयोग करने की आवश्यकता है, मुख्य "ईंट" जिसके लिए .NET 4.0 ब्लॉकिंगकॉलक्शन क्लास है, जिसे मैं बाद में अलग से लिखूंगा। आप मूल दस्तावेज़ के पृष्ठ 53 पर निर्माता-उपभोक्ता अनुभाग में अंग्रेजी में इसके बारे में अधिक पढ़ सकते हैं।



PS यह लेख " PATTERNS OF PARALLEL PROGRAMMING: UNDERSTANDING AND APPLYING PARALLEL PATTERNS with THE .NET FRAMEWORK 4 और VISUAL C " पुस्तक के प्रभाव में लिखा गया था और इसे प्रसंस्करण के साथ इसका मुफ्त अनुवाद माना जा सकता है।

निष्कर्ष

मुझे उम्मीद है कि यह दौरा आपको अपने कोड को समानांतर करते समय अपनी खुद की कम गलतियां करने में मदद करेगा। लेकिन वैसे भी, सफल डिबगिंग, और खुश छुट्टी :)

भविष्य के लिए

ब्याज होने पर मैं 4 फ्रेमवर्क में समानता के विषय को जारी रख सकता हूं। इसके बारे में हो सकता है:

• निर्भरता के साथ समानांतर कंप्यूटिंग के लिए टास्क क्लास और बुनियादी ढांचा,
• नया धागा सुरक्षित संग्रह
• आलस्य और शालीनता
• साझा डेटा और सिंक्रनाइज़ेशन।

यह लिखें कि यह किस हद तक दिलचस्प है :)