दुमियों के लिए एमपीआई मूल बातें

ऐसा हुआ कि मुझे समानांतर कंप्यूटिंग और विशेष रूप से एमपीआई के अध्ययन का सामना करना पड़ा। शायद आज यह दिशा बहुत ही आशाजनक है, इसलिए मैं इस प्रक्रिया की मूल बातें हब्रायज़रों को दिखाना चाहूंगा।

मूल सिद्धांत और उदाहरण

एक उदाहरण के रूप में, प्रतिपादक (ई) की गणना का उपयोग किया जाएगा। इसे खोजने के लिए विकल्पों में से एक टेलर श्रृंखला है:
e ^ x = ^ ((x ^ n) / n!) , जहाँ योग n = 0 से अनंत तक है।

यह सूत्र समानांतर करना आसान है, क्योंकि वांछित संख्या व्यक्तिगत शब्दों का योग है और इसके लिए धन्यवाद, प्रत्येक व्यक्तिगत प्रोसेसर व्यक्तिगत शब्दों की गणना कर सकता है।

प्रत्येक व्यक्तिगत प्रोसेसर में गणना की जाने वाली शर्तों की संख्या अंतराल n की लंबाई और प्रोसेसर k की उपलब्ध संख्या पर निर्भर करती है जो गणना प्रक्रिया में भाग ले सकते हैं। इसलिए, उदाहरण के लिए, यदि अंतराल की लंबाई n = 4 है, और पांच प्रोसेसर गणना (k = 5) में भाग लेते हैं, तो पहले से चौथे प्रोसेसर को एक शब्द प्राप्त होगा और पांचवें का उपयोग नहीं किया जाएगा। यदि n = 10, और k = 5, तो प्रत्येक प्रोसेसर को गणना के लिए दो शब्द मिलेंगे।

प्रारंभ में, पहला प्रोसेसर, MPI_Bcast प्रसारण फ़ंक्शन का उपयोग करते हुए, उपयोगकर्ताओं द्वारा निर्धारित शेष मान को वेरिएबल n पर भेजता है। सामान्य तौर पर, MPI_Bcast फ़ंक्शन का निम्न प्रारूप है:
int MPI_Bcast (void * बफर, int count, MPI_Datatype datatype, int root, MPI_Comm comm), जहाँ बफर तत्व के साथ बफर का पता है, गिनती तत्वों की संख्या है, डेटा टाइप MPI में संबंधित डेटा प्रकार है, रूट मुख्य प्रोसेसर की रैंक है जो सौदों के साथ काम करता है। हस्तांतरण, और संचारक का नाम है।
मेरे मामले में, मुख्य प्रोसेसर, जैसा कि पहले ही उल्लेख किया गया है, 0 के रैंक के साथ पहला प्रोसेसर होगा।

उसके बाद, नंबर n को सफलतापूर्वक भेजा जाएगा, प्रत्येक प्रोसेसर इसकी शर्तों की गणना में लगा होगा। ऐसा करने के लिए, चक्र के प्रत्येक चरण में, गणना में शामिल प्रोसेसर की संख्या के बराबर संख्या को संख्या i में जोड़ दिया जाएगा, जो प्रारंभ में प्रोसेसर के रैंक के बराबर है। यदि निम्न क्रियाओं के दौरान उपयोगकर्ता द्वारा निर्दिष्ट संख्या n से अधिक है, तो इस प्रोसेसर के लिए चक्र का निष्पादन बंद हो जाएगा।

चक्र के निष्पादन के दौरान, शर्तों को एक अलग चर में जोड़ा जाएगा और, इसके पूरा होने के बाद, प्राप्त राशि मुख्य प्रोसेसर को भेजी जाएगी। इसके लिए, कास्ट ऑपरेशन MPI_Reduce के फ़ंक्शन का उपयोग किया जाएगा। सामान्य शब्दों में, यह इस प्रकार है:
int MPI_Reduce (शून्य * buf, void * परिणाम, int count, MPI_Datatype datatype, MPI_Op op, int root, MPI_Comm comm)

यह ऑप ऑपरेशन का उपयोग करके समूह में प्रत्येक प्रक्रिया के इनपुट बफर तत्वों को जोड़ता है, और रूट संख्या के साथ प्रक्रिया के आउटपुट बफर में संयुक्त मूल्य देता है। इस तरह के ऑपरेशन का परिणाम एकमात्र मूल्य होगा, जिसके कारण कलाकारों के कार्य को इसका नाम मिला।

सभी प्रोसेसर पर प्रोग्राम को निष्पादित करने के बाद, पहले प्रोसेसर को कुल योग प्राप्त होगा, जो हमारे लिए आवश्यक घातांक होगा।

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

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

कोड निष्पादन एल्गोरिथ्म

1. दृश्य शेल से, n का मान प्रोग्राम में प्रसारित होता है, जिसे बाद में प्रसारण फ़ंक्शन के माध्यम से सभी प्रोसेसरों में भेज दिया जाता है।
2. जब पहला मुख्य प्रोसेसर शुरू किया जाता है, तो टाइमर शुरू होता है।
3. प्रत्येक प्रोसेसर एक चक्र करता है जहां वेतन वृद्धि प्रणाली में प्रोसेसर की संख्या होती है। लूप के प्रत्येक पुनरावृत्ति में, शब्द की गणना की जाती है और इस तरह के शब्दों का योग चर drobSum में संग्रहीत होता है।
4. लूप पूरा होने के बाद, प्रत्येक प्रोसेसर इसके drobSum मान को इसके लिए MPI_Reduce कास्ट फ़ंक्शन का उपयोग करके परिणाम चर में भेजता है।
5. सभी प्रोसेसर पर गणना पूरी होने के बाद, पहला मुख्य प्रोसेसर टाइमर को रोकता है और परिणामी चर के परिणामी मूल्य को आउटपुट स्ट्रीम में भेजता है।
6. हमारे टाइमर द्वारा मापा गया मिलीसेकंड में मापा गया समय का मान भी आउटपुट स्ट्रीम में भेजा जाता है।

कोड लिस्टिंग

कार्यक्रम सी ++ में लिखा गया है, हम मानते हैं कि निष्पादन के लिए तर्क बाहरी शेल से पारित किए जाते हैं। कोड निम्नानुसार है:

#include "mpi.h"
#include <iostream>
#include <windows.h>
using namespace std;

double Fact( int n)
{
if (n==0)
return 1;
else
return n*Fact(n-1);
}

int main( int argc, char *argv[])
{
SetConsoleOutputCP(1251);
int n;
int myid;
int numprocs;
int i;
int rc;
long double drob,drobSum=0,Result, sum;
double startwtime = 0.0;
double endwtime;

n = atoi(argv[1]);

if (rc= MPI_Init(&argc, &argv))
{
cout << " , " << endl;
MPI_Abort(MPI_COMM_WORLD, rc);
}

MPI_Comm_size(MPI_COMM_WORLD,&numprocs);
MPI_Comm_rank(MPI_COMM_WORLD,&myid);


if (myid == 0)
{

startwtime = MPI_Wtime();
}
MPI_Bcast(&n, 1, MPI_INT, 0, MPI_COMM_WORLD);

for (i = myid; i <= n; i += numprocs)
{
drob = 1/Fact(i);
drobSum += drob;
}

MPI_Reduce(&drobSum, &Result, 1, MPI_LONG_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
cout.precision(20);
if (myid == 0)
{
cout << Result << endl;
endwtime = MPI_Wtime();
cout << (endwtime-startwtime)*1000 << endl;
}

MPI_Finalize();
return 0;
}

* This source code was highlighted with Source Code Highlighter .

निष्कर्ष

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