एचपीसी के लिए जावा। वैक्टर के स्केलर उत्पाद की गणना

स्वागत



यह पोस्ट विषय पर पहले पोस्ट की निरंतरता है।





यह पोस्ट "जावा फॉर हाई परफॉर्मेंस कंप्यूटिंग" लेख से एक संक्षिप्त उद्धरण है, जो टॉम्स्क पॉलिटेक्निक यूनिवर्सिटी सम्मेलन में मेरे द्वारा प्रस्तुत किया जाएगा।



वैक्टर का स्केलर उत्पाद वैक्टर के संगत तत्वों के सभी उत्पादों का योग है।



समस्या को हल करने के लिए, दो कार्यक्रम लिखे गए थे - सी में (मेरे द्वारा नहीं :-)) और जावा में।



दोनों कार्यक्रमों का परीक्षण टॉम्स्क पॉलिटेक्निक यूनिवर्सिटी में स्थापित SKIF-Polytech सुपरकंप्यूटर क्लस्टर पर किया गया और इसमें 2 इंटेल Xeon 5150 2.66 Ghz प्रोसेसर और 24 GB रैम के साथ 24 नोड्स शामिल थे जो प्रत्येक Linux के SuSE Enterprise संस्करण 3.3 पर चल रहे थे।



पहले मामले में, आयाम के दो वैक्टर 99999999 पूर्णांक तत्वों को बेतरतीब ढंग से आरंभ किया गया था, और दूसरे मामले में, 99999999 वास्तविक तत्वों के दो वैक्टर डेटा सेट के रूप में उपयोग किए गए थे। प्रत्येक प्रोग्राम में दो बार (2 से 40 तक) उपयोग किए जाने वाले प्रोसेसर कोर की संख्या में बदलाव के साथ प्रत्येक डेटा सेट के लिए दोनों प्रोग्राम 21 बार लॉन्च किए गए थे।



यह ध्यान दिया जाना चाहिए कि दोनों कार्यक्रम:

* अनुकूलित नहीं;

* समान कार्यक्षमता (भाषाओं की आंतरिक विशेषताओं के अपवाद के साथ) का उपयोग करें।



इसलिए, टिप्पणियों को अतिरिक्त रूप से प्रोत्साहित किया जाता है।



समस्या को हल करने के लिए आवश्यक सिद्धांत



सी और जावा के लिए एमपीआई कार्यान्वयन में, दो अंतर हैं जो पहले भ्रमित हो सकते हैं:

1) संदेश अग्रेषण कार्यों में, सी में पहला तर्क ऑब्जेक्ट है, जावा में, यह एक-आयामी सरणी है;

2) तर्कों का एक अलग क्रम।



वैक्टर के स्केलर उत्पाद की गणना करने के लिए, निम्नलिखित समस्याओं को हल करना आवश्यक है:



1) एन तत्वों के दो वैक्टर बनाएं और मूल्यों को इनिशियलाइज़ करें;

2) वैक्टर को कणों में विभाजित करें जो नोड्स को भेजे जाएंगे;

3) कणों को बाहर भेजें;

4) नोड्स पर कण ले लो;

5) गणना करने के लिए;

6) वापस भेजें;

7) संक्षेप और परिणाम प्राप्त करें;

8) कार्यक्रम को पूरा करने में लगने वाले समय की गणना करें।



अंक पर:

1) एन तत्वों के दो वैक्टर बनाएँ और मूल्यों को इनिशियलाइज़ करें



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



2) वैक्टर को कणों में विभाजित करें जो नोड्स को भेजे जाएंगे



सी और जावा के लिए इसे उसी तरह हल किया जाता है:

n = कुल / संख्या + 1, जहां

N प्रति नोड कणों की संख्या है,

कुल - वेक्टर लंबाई,

numprocs - पूल में प्रक्रियाओं की संख्या (MPI_COMM_Size)।



3) कणों को बाहर भेजें;



हम MPI लाइब्रेरी से एक फ़ंक्शन का उपयोग करते हैं - MPI_Bcast, जो पूल में सभी प्रक्रियाओं के लिए एक ऑब्जेक्ट भेजता है। विनिर्देशों के लिए, कृपया निर्माता की वेबसाइट से संपर्क करें ।



परिणामस्वरूप, जावा में सरणियाँ भेजना इस तरह दिखता है:



MPI.COMM_WORLD.Bcast(d, 1, 0,MPI.DOUBLE, 0);

MPI.COMM_WORLD.Send(a,0,a.length,MPI.DOUBLE,dest,0);

MPI.COMM_WORLD.Send(b,0,b.length,MPI.DOUBLE,dest,0);









जहां d सरणियों से टुकड़े की लंबाई है,

a पहला वेक्टर है

b दूसरा वेक्टर है।



4) नोड्स पर कणों को स्वीकार करें

MPI.COMM_WORLD.Recv(a,0,d[0],MPI.DOUBLE,0,0);

MPI.COMM_WORLD.Recv(b,0,d[0],MPI.DOUBLE,0,0);







कोई टिप्पणी नहीं।



5) गणना करें



for (int i=0; i<d[0];i++){



sum[0]+=a[i]*b[i];

}









6) वापस भेजें; 7) संक्षेप और परिणाम प्राप्त करें;

और यहां एक दिलचस्प बिंदु है - हम दो कार्यों को एक में जोड़ते हैं। हम एक कम करने वाले फ़ंक्शन का उपयोग करेंगे जो हमारे लिए सभी आवश्यक कार्य करेगा - परिणाम एकत्र करेगा और उन्हें एक-आयामी सरणी में डाल देगा (यह मत भूलो कि जावा के लिए कार्यान्वयन में सरल चर नहीं होना चाहिए!) परिणाम।

MPI.COMM_WORLD.Reduce(sum,0,result,0,1,MPI.DOUBLE,MPI.SUM,0);









8) कार्यक्रम को पूरा करने में लगने वाले समय की गणना करें



इसके लिए दो अंतर्निहित कार्यों का उपयोग किया जाता है, दोनों मानक कार्यों के लिए आवरण - MPI.WIME (दीवार समय)। हम कार्यक्रम की शुरुआत में पहले एक को बुलाते हैं और अंत में कार्यक्रम के कुल निष्पादन समय (गणना नहीं!) की गणना करते हैं।



निष्कर्ष



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



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



सी कार्यक्रम

#include "mpi.h"

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

#include <signal.h>



#define MYTAG 1



int myid, j;

char processor_name[MPI_MAX_PROCESSOR_NAME];

double startwtime = 0.0, endwtime;



int main(int argc,char *argv[])

{

int total, n, numprocs, i, dest;

double *a, *b, sum, result;

int namelen;

MPI_Status status;



MPI_Init(&argc,&argv);

MPI_Comm_size(MPI_COMM_WORLD,&numprocs);

MPI_Comm_rank(MPI_COMM_WORLD,&myid);

MPI_Get_processor_name(processor_name,&namelen);



if (myid == 0) {

total = atoi(argv[1]);

}



printf("Process %d of %d is on %s\n",

myid, numprocs, processor_name);



startwtime = MPI_Wtime();



n = total / numprocs + 1;

MPI_Bcast(&n, 1, MPI_INT, 0, MPI_COMM_WORLD);



a = malloc(n*sizeof(double));

b = malloc(n*sizeof(double));



if ((a == NULL) || (b == NULL)) {

fprintf(stderr,"Error allocating vectors (not enough memory?)\n");

exit(1);

}



if (myid == 0) {

for (dest=1; dest < numprocs; dest++) {

for (i=0; i < n; i++) {

a[i] = 4294967296;//rand();

b[i] = 4294967296;//rand();

}

MPI_Send(a, n, MPI_INT, dest, MYTAG, MPI_COMM_WORLD);

MPI_Send(b, n, MPI_INT, dest, MYTAG, MPI_COMM_WORLD);

}

n = total - n*(numprocs-1);

for (i=0; i < n; i++) {

a[i] = rand();

b[i] = rand();

}

} else {

MPI_Recv(a, n, MPI_INT, 0, MYTAG, MPI_COMM_WORLD, &status);

MPI_Recv(b, n, MPI_INT, 0, MYTAG, MPI_COMM_WORLD, &status);

}



printf("Process %d on node %s starting calc at %f sec\n",

myid, processor_name, MPI_Wtime()-startwtime);



sum = 0.0;

for (i=0; i<n; i++)

sum += a[i]*b[i];



printf("Process %d on node %s ending calc at %f sec\n",

myid, processor_name, MPI_Wtime()-startwtime);

MPI_Reduce(&sum, &result, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);



if (myid == 0) {

endwtime = MPI_Wtime();

printf("Answer is %f\n", result);

printf("wall clock time = %f\n", endwtime-startwtime);

fflush(stdout);

}



MPI_Finalize();

return 0;

}









जावा कार्यक्रम



import mpi.*;

import java.util.*;



public class scalar {



public static void main(String args[]){

MPI.Init(args);



double[] result = new double[1];

int me = MPI.COMM_WORLD.Rank();

int size = MPI.COMM_WORLD.Size();



double startwtime=0.0;

double endwtime=0.0;

int total = 99999999;



int[] d = new int[1];

d[0] = total/size+1;



double[] a = new double[d[0]];

double[] b = new double[d[0]];

Random r = new Random();



MPI.COMM_WORLD.Bcast(d, 1, 0,MPI.INT, 0);



if (me == 0){

startwtime = MPI.Wtime();

for (int dest=1; dest<size;dest++){

for (int i=0; i<d[0]; i++){

a[i] = r.nextDouble();

b[i] = r.nextDouble();

}



MPI.COMM_WORLD.Send(a,0,a.length,MPI.INT,dest,0);

MPI.COMM_WORLD.Send(b,0,b.length,MPI.INT,dest,0);

}



d[0] = total - d[0]*(size-1);

for (int i=0; i<d[0];i++){



a[i] = r.nextDouble();

b[i] = r.nextDouble();

}



} else {



MPI.COMM_WORLD.Recv(a,0,d[0],MPI.INT,0,0);

MPI.COMM_WORLD.Recv(b,0,d[0],MPI.INT,0,0);



}



int[] sum = new int[1];



for (int i=0; i<d[0];i++){



sum[0]+=a[i]*b[i];



}



MPI.COMM_WORLD.Reduce(sum,0,result,0,1,MPI.INT,MPI.SUM,0);



if (me == 0){



System.out.println("answer is"+result[0]+" time of calcs is equal to "+(MPI.Wtime()-startwtime));



}

MPI.Finalize();



}

}