🔶 🎏 🙇🏿 हम पाई को समानांतर में मानते हैं। भाग 1 🌟 ☑️ 👩🏿‍🔬

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

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

स्रोत कोड github.com/undertherain/pi पर भी उपलब्ध हैं (पोस्ट के अगले भाग लिखे जाने पर इसे फिर से भरना होगा)।

सीरियल का संस्करण

चलिए सीरियल संस्करण बनाकर शुरू करते हैं। यानी एक जो पारंपरिक केंद्रीय प्रसंस्करण इकाई के एक कोर का उपयोग करता है। हम संख्यात्मक एकीकरण के तरीकों में से सबसे सरल लेते हैं - आयत विधि और इसे सी भाषा में कोड करते हैं (सामान्य तौर पर हम कई कारणों से सामान्य रूप से C \ C ++ surzhik का उपयोग करेंगे।
हम एक निश्चित संख्या में cntSteps आयतों की घोषणा करेंगे, जिसमें हम अपने क्षेत्र को अभिन्न के तहत विभाजित करते हैं, आधार की गणना करते हैं:

step = 1./static_cast<double>(cntSteps);

और पूरे क्षेत्र, प्रत्येक आयत में फ़ंक्शन के मूल्य की गिनती और आधार से गुणा करना।

 for (unsigned long i=0; i<cntSteps; i++) { x = ( i + .5 ) *step; sum = sum + 4.0/(1.+ x*x); }

हालाँकि, हम आधार कदम से गुणा करते हैं, हम बेहतर "कोष्ठक के बाहर", यानी चक्र के लिए - यह मूल रूप से है।

यहाँ पूरा कार्यक्रम कोड है:

 #include <iostream> #include <iomanip> #include <sys/times.h> #include <cmath> int main(int argc, char** argv) { const unsigned long cntSteps=500000000; /* # of rectangles */ double step; const double PI25DT = 3.141592653589793238462643; //reference Pi value double pi=0; double sum=0.0; double x; std::cout<< "calculating pi on CPU single-threaded\n"; //  clock_t clockStart, clockStop; tms tmsStart, tmsStop; clockStart = times(&tmsStart); //      step = 1./static_cast<double>(cntSteps); for (unsigned long i=0; i<cntSteps; i++) { x = (i + .5)*step; sum = sum + 4.0/(1.+ x*x); } pi = sum*step; //      clockStop = times(&tmsStop); std::cout << "The value of PI is " << pi << " Error is " << fabs(pi - PI25DT) << "\n"; std::cout << "The time to calculate PI was " ; double secs= (clockStop - clockStart)/static_cast<double>(sysconf(_SC_CLK_TCK)); std::cout << secs << " seconds\n"; return 0; }

Http://dumpz.org/195276/ पर कॉपी करें।

मूल सूत्र

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

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

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

 for (long long i=args->left; i<args->right; i++) { x = (i + .5)*step; sum = sum + 4.0/(1.+ x*x); }

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

 arrArgsThread[idThread].left = idThread*cntStepsPerThread; arrArgsThread[idThread].right = (idThread+1)*cntStepsPerThread;

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

हम प्रत्येक स्ट्रीम से परिणाम को आम चर pi + = sum * चरण में जोड़ देंगे ; (याद रखें कि हम एक आम पते की जगह पर हैं)।

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

 pthread_mutex_lock(&mutexReduction); pi += sum*step; pthread_mutex_unlock(&mutexReduction);

कुल कुछ इस तरह है:

 #include <iostream> #include <iomanip> #include <cmath> #include <cstdlib> #include <pthread.h> #include <sys/times.h> #define cntThreads 4 pthread_mutex_t mutexReduction; double pi=0.; //      struct ArgsThread { long long left,right; double step; }; //  static void *worker(void *ptrArgs) { ArgsThread * args = reinterpret_cast<ArgsThread *>(ptrArgs); double x; double sum=0.; double step=args->step; for (long long i=args->left; i<args->right; i++) { x = (i + .5)*step; sum = sum + 4.0/(1.+ x*x); } pthread_mutex_lock(&mutexReduction); pi += sum*step; pthread_mutex_unlock(&mutexReduction); return NULL; } int main(int argc, char** argv) { const unsigned long num_steps=500000000; const double PI25DT = 3.141592653589793238462643; pthread_t threads[cntThreads]; ArgsThread arrArgsThread[cntThreads]; std::cout<<"POSIX threads. number of threads = "<<cntThreads<<std::endl; clock_t clockStart, clockStop; tms tmsStart, tmsStop; clockStart = times(&tmsStart); double step = 1./(double)num_steps; long long cntStepsPerThread= num_steps / cntThreads; //          for (unsigned int idThread=0; idThread<<cntThreads; idThread++) { arrArgsThread[idThread].left = idThread*cntStepsPerThread; arrArgsThread[idThread].right = (idThread+1)*cntStepsPerThread; arrArgsThread[idThread].step = step; if (pthread_create(&threads[idThread], NULL, worker, &arrArgsThread[idThread]) != 0) { return EXIT_FAILURE; } } //        join for (unsigned int idThread=0; idThread<cntThreads; idThread++) { if (pthread_join(threads[idThread], NULL) != 0) { return EXIT_FAILURE; } } //! clockStop = times(&tmsStop); std::cout << "The value of PI is " << pi << " Error is " << fabs(pi - PI25DT) << std::endl; std::cout << "The time to calculate PI was " ; double secs= (clockStop - clockStart)/static_cast<double>(sysconf(_SC_CLK_TCK)); std::cout << secs << " seconds\n" << std::endl; return 0; }

Http://dumpz.org/195404/ पर कॉपी करें यदि किसी को मेरी नारकीय प्रारूपण असमान रूप से प्रदर्शित होती है।

वास्तव में, यह इस उदाहरण में ठोस था (लेकिन यह हमेशा इतना भाग्यशाली नहीं होगा) कि आप म्यूटेक्स के बिना कर सकते हैं यदि आप प्रत्येक थ्रेड में एक अलग चर में परिणाम बचाते हैं (सरणी तत्व ArgsThread arrArgsThread ( cntThreads ];
) और फिर, सभी थ्रेड्स के पूरा होने का इंतजार करने के बाद - योग हुआ।

यहाँ म्यूटेक्स के बिना कोड है:

 #include <iostream> #include <iomanip> #include <cmath> #include <cstdlib> #include <pthread.h> #include <sys/times.h> #define cntThreads 4 struct ArgsThread { long long left,right; double step; double partialSum; }; static void *worker(void *ptrArgs) { ArgsThread * args = reinterpret_cast<ArgsThread *>(ptrArgs); double x; double sum=0.; double step=args->step; for (long long i=args->left; i<args->right; i++) { x = (i + .5)*step; sum = sum + 4.0/(1.+ x*x); } args->partialSum=sum*step; return NULL; } int main(int argc, char** argv) { const unsigned long num_steps=500000000; const double PI25DT = 3.141592653589793238462643; pthread_t threads[cntThreads]; ArgsThread arrArgsThread[cntThreads]; std::cout<<"POSIX threads. number of threads = "<<cntThreads<<std::endl; clock_t clockStart, clockStop; tms tmsStart, tmsStop; clockStart = times(&tmsStart); double step = 1./(double)num_steps; long long cntStepsPerThread= num_steps / cntThreads; for (unsigned int idThread=0; idThread<cntThreads; idThread++) { arrArgsThread[idThread].left = idThread*cntStepsPerThread; arrArgsThread[idThread].right = (idThread+1)*cntStepsPerThread; arrArgsThread[idThread].step = step; if (pthread_create(&threads[idThread], NULL, worker, &arrArgsThread[idThread]) != 0) { return EXIT_FAILURE; } } double pi=0.; for (unsigned int idThread=0; idThread<cntThreads; idThread++) { if (pthread_join(threads[idThread], NULL) != 0) { return EXIT_FAILURE; } pi +=arrArgsThread[idThread].partialSum; } clockStop = times(&tmsStop); std::cout << "The value of PI is " << pi << " Error is " << fabs(pi - PI25DT) << std::endl; std::cout << "The time to calculate PI was " ; double secs= (clockStop - clockStart)/static_cast<double>(sysconf(_SC_CLK_TCK)); std::cout << secs << " seconds\n" << std::endl; return 0; }

और http://dumpz.org/195415/ पर एक प्रति।

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

OpenMP

ओपनएमपी भाषा का एक विस्तार (C / C ++ / Fortran) है जो हमें लगभग वही काम करने की अनुमति देता है जो हमने ऑपरेटिंग सिस्टम के थ्रेड API का उपयोग करके किया था - लेकिन यह तथाकथित सरल और अधिक संक्षिप्त है, तथाकथित प्रांगण की मदद से। प्रागमा, जैसा कि यह था, संकलक को "इस कोड को लेने और इसे समानांतर में निष्पादित करने के लिए कहता है" - और कॉप्युलेटर बाकी काम करता है।
हमारे पहले अनुक्रमिक उदाहरण में लूप के लिए समानांतर करने के लिए, बस एक पंक्ति जोड़ें:

 #pragma omp parallel for private (x), reduction (+:sum) for (int i=0; i<numSteps; i++) { x = (i + .5)*step; sum = sum + 4.0/(1.+ x*x); }

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

 #include <iostream> #include <iomanip> #include <sys/times.h> #include <cmath> #include <omp.h> int main(int argc, char** argv) { const unsigned long numSteps=500000000; /* default # of rectangles */ double step; double PI25DT = 3.141592653589793238462643; double pi=0; double sum=0.0; double x; #pragma omp parallel { #pragma omp master { int cntThreads=omp_get_num_threads(); std::cout<<"OpenMP. number of threads = "<<cntThreads<<std::endl; } } clock_t clockStart, clockStop; tms tmsStart, tmsStop; step = 1./static_cast<double>(numSteps); clockStart = times(&tmsStart); #pragma omp parallel for private (x), reduction (+:sum) for (int i=0; i<numSteps; i++) { x = (i + .5)*step; sum = sum + 4.0/(1.+ x*x); } pi = sum*step; clockStop = times(&tmsStop); std::cout << "The value of PI is " << pi << " Error is " << fabs(pi - PI25DT) << std::endl; std::cout << "The time to calculate PI was " ; double secs= (clockStop - clockStart)/static_cast<double>(sysconf(_SC_CLK_TCK)); std::cout << secs << " seconds\n" << std::endl; return 0; }

Http://dumpz.org/195550/ की कॉपी।
जी ++ के मामले में -fopenmp विकल्प के साथ संकलन, एक अन्य संकलक के मामले के साथ, उपयोगकर्ता मैनुअल को देखें।

प्रश्नों और टिप्पणियों का स्वागत है, जारी रखा जाना है!

हम पाई को समानांतर में मानते हैं। भाग 1

सीरियल का संस्करण

मूल सूत्र

OpenMP

More articles: