Mpi Obiektowo, Klastry Pod Linuxem

[Kowal]

Proszę o pomoc w programie, który zrobiłem obiektowo, ale nie wiem jak go skończyć, żeby MPI działało prawidłowo, tzn. MPI musi dzielić podany zakres liczb między procesy i wyświetlać wyniki parami (bez MPI działało prawidłowo).

 

Zadanie brzmi:

W zakresie podanym przez użytkownika znaleźć pary liczb spełniające równanie:

x²=2y⁴-1

 

 

Mam problem ze zrobieniem MPI w klasie wt.h (warstwa transportowa) i zrobieniem metod w klasie serwer.h, ponieważ nie bardzo rozumiem działanie MPI.

 

Bardzo proszę "tęższe" umysły o pomoc

 

 

Kod:

 

 plik main.C

//#include "klient.h"

#include "rezultat.h"

//#include "serwer.h"

//#include "wt.h"

//#include "zadanie.h"

#include 

#include 

using namespace std;


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

{

Serwer s;

s.prepareZadania(argc,argv);

};

 

 

plik zadanie.h



#ifndef ZADANIE_H

#define ZADANIE_H

/*! \brief KLASA ZADANIE

*

* Klasa przechowuje zakres przeszukiwanych liczb

*/

class Zadanie

{

private:

int x[]; //!< Tablica przechowuje wartosc zakresu gornego i dolnego

public:

/*! \brief ZWROC WARTOSC ZAKRESU GORNEGO

*

* Funkcja zwraca dana wartosc zakresu gornego

*/

int getZakresGorny();

/*! \brief ZWROC WARTOSC ZAKRESU DOLNEGO

*

* Funkcja zwraca dana wartosc zakresu dolnego

*/

int getZakresDolny();

/*! \brief USTAW ZAKRES

*

* Funkcja ustawia zakres przeszukiwanych liczb

* \param d Nowa wartosc zakresu dolnego

* \param g Nowa wartosc zakresu gornego

*/

void setZakres(int d,int g);

/*! \brief KONSTRUKTOR KLASY

*

* Funkcja wyzerowuje zmienne

*/

Zadanie();

};

/***************************************************************/

inline Zadanie::Zadanie()

{

x[0]=0;

x[1]=0;

};

inline void Zadanie::setZakres(int d, int g)

{

x[0]=d;

x[1]=g;

};

inline int Zadanie::getZakresDolny()

{

return x[0];

};

inline int Zadanie::getZakresGorny()

{

return x[1];

};

#endif

 

 

plik klient.h



#ifndef KLIENT_H

#define KLIENT_H

#include "rezultat.h"

class Klient

{

private:

int i,k; //!< Zmienne pomocnicze

public:

/*! \brief LICZ ZADANIE

* Funkcja liczy otrzymane zadanie na podstawie wbudowanego algorytmu

* \param zd Zakres dolny

* \param zg zakres gorny

*/

void licz(int zd,int zg);

/*! \brief KONSTRUKTOR KLASY

*

* Funkcja wyzerowuje zmienne

*/

Klient();

inline Klient::Klient()

{

i=0;

k=0;

};

inline void Klient::licz(int zd,int zg)

{

Rezultat re;

for(k=zd;k<=zg;k++)

{

for(i=zd;i<=zg;i++)

{

if(k*k==(2*(i*i*i*i))-1)

re.setRez(k,i);

}

}

};

#endif

 

 

plik rezultat.h



#ifndef REZULTAT_H

#define REZULTAT_H

/*! \brief KLASA REZULTAT

*

* KLASA przechowuje pary liczb spelniajace warunki przeszukiwania(rezultat)

*/

class Rezultat

{

private:

int tab[100][2]; //!< Tablica przechowujÄ…ca wyniki

int i; //!< Ilosc wynikow

public:

/*! \brief USTAW REZULTAT

*

* Funkcja ustawia rezultat

* \param x Wartosc pierwszej liczby spelniajacej warunek

* \param y Wartosc drugiej liczby spelniajacej warunek

*/

void setRez(int x,int y);

/*! \brief ZWROC REZULTAT

*

* Funkcja zwraca rezultat

* \param a Wartosc pierwszej liczby spelniajacej warunek

* \param b Wartosc drugiej liczby spelniajacej warunek

*/

int getRez(int a,int ;

/*! \brief ZWROC ILOSC TRAFIEN

*

* Funkcja zwraca ilosc trafien

*/

int getIlosc();

/*! \brief KONSTRUKTOR KLASY

*

* Funkcja wyzerowuje zmienne

*/

Rezultat();

};

/**********************************************************/

inline Rezultat::Rezultat()

{

i=0;

};

inline void Rezultat::setRez(int x,int y)

{

tab[i][0]=x;

tab[i][1]=y;

i++;

};

inline int Rezultat::getRez(int a,int 

{

return tab[a][b];

};

inline int Rezultat::getIlosc()

{

return i;

};

#endif

 

 

plik serwer.h



#ifndef SERWER_H

#define SERWER_H

#include "wt.h"

class Serwer

{

private:

int zg,zd,li;

public:

int prepareZadania();

void sendZadania();

void receiveRezultaty();

void displayWynik();

Serwer();

};

/***********************************************************/

inline Serwer::Serwer()

{

zg=0;

zd=0;

li=0;

};

inline int prepareZadania(int a,char* b[])

{

WT w;

w.initMPI(a,;

li=w.getLiKlientow();





};

inline void sendZadania()

{

?????????????

};

inline void receiveRezultaty()

{

???????????????

};

inline void displayWynik()

{

?????????? 

};

#endif

 

 

plik wt.h (warstwa transportowa)



#ifndef WT_H

#define WT_H

#include 

class WT

{

private:

int np,id,a;

char* b[];

public:

WT();

void initMPI(int a,char* b[]);/*

void sendZadanie(int x,int y,int kl);

int receiveZadanie();

void sendRezultat(int x,int y,int kl);

int receiveRezultat();*/

int getLiKlientow();

int getIdKlienta();

~WT();

};

/********************************************************/

inline WT::WT()

{

np=0;

id=0;

};

inline void WT::initMPI(int a,char* b[])

{

MPI_Init(&a,&;

};/*

inline void WT::sendZadanie(int x,int y,int kl)

{

int MPI_Send(&x,&y,2,MPI_INT,kl,zad,MPI_COMM_WORLD);

};

inline int WT::receiveZadanie()

{

MPI_Status stat;

int MPI_Rec(&x,&y,2,MPI_INT,MPI_ANY_SOURCE,zad,MPI_COMM_WORLD,&stat);

return 0;

};

inline void WT::sendRezultat(int x,int y,int kl)

{

int MPI_Send(&x,&y,2,MPI_INT,kl,rez,MPI_COMM_WORLD);

};

inline int WT::receiveRezultat()

{

MPI_Status stat;

int MPI_Rec(&x,&y,2,MPI_INT,MPI_ANY_SOURCE,rez,MPI_COMM_WORLD,&stat);

return 0;

};*/

inline int WT::getLiKlientow()

{

MPI_Comm_size(MPI_COMM_WORLD,&np);

return np;

};

inline int WT::getIdKlienta()

{

MPI_Comm_rank(MPI_COMM_WORLD, &id);

return id;

};

inline WT::~WT()

{

MPI_Finalize();

};

#endif

[klimas7]

Z tego co mi wiadomo a wiadomo ponoć aż na 4.5 (zdawałem z z tego egzamin ponad tydzień temu ) to MPI jets biblioteką jezyka C wiec o obiektach nie bardzo może być tytaj mowa.

 

MPI to model programowania RÓWNOLEGŁEGO !! a nie rozproszonego. W MPI nie ma czegoś takiego jak serwer i klient (to nie Corba czy RMI) jest ewentualnie PROCES który ma rank=0 ale nic pozatym.

 

Powiedzmy że urychamiasz sobie 10 procesów !! a nie serwer i klient. Jeden znich np. ten który ma rank=0 zajmuje się podzieleniem przedziału zadanego przez usera na odpowiednią ilość przedziałów (przewarznie 10razy wiecej niż przydzielonych procesów), oraz ewentualną komunikacją między procesami.

 

W MPI TEN sam kod np. main.c wykonywany jest przez wszystkie procesy.

No może to rozjaśni Ci ide MPI

 

Zapewne nie masz lub masz ograniczony dostęp do maszyn ze skonfigurowanym mpich, wiec pozostaje lam

 

pz

[Kowal]

Z tego co mi wiadomo a wiadomo ponoć aż na 4.5 ...

..

 

 

Dzięki za pomoc, ale niewiele mi to rozjaśniło sytuację. Poprostu nie wiem jak napisać polecenia MPI (w plikach serwer.h i wt.h): wysyłające i odbierające zadanie oraz wyświetlające wyniki. Może jakieś dokładniejsze podpowiedzi?

[klimas7]

Hmm ale nie można wyjaśnić prościej. Masz jakieś odgórne nakazy że to ma przypominać architekture rozproszoną (serwer klient) (Corba lub RMI), i że ma być NA SIŁE OBIEKTOWE, MPI NIE JEST OBIEKTOWY !! Jeśli nie musisz to nie komplikuj sobie sprawy.

Taki rozjaśniający link

http://www-users.mat.uni.torun.pl/~bala/se...r_2000/mpi.html

 

moze to Ci pomoże.

To Twoje zadanie jest czysto teoretyczne :/ czy na jakiś maszynach bedziesz to uruchamiał ?

 

tutaj znajduje się przykładowy program który wylicza wartość liczby PI.

http://fatcat.ftj.agh.edu.pl/~klimas7/doc/mpi/

Idea jest taka sama jak u Ciebie im wiecej dostepnych procesów (procesorów) tym szybciej zostanie wykonane zadanie (dokładność nie zależy od liczby procesów).

 

pz

 

 

[Kowal]

Hmm ale nie można wyjaśnić prościej. Masz jakieś odgórne nakazy że to ma przypominać architekture rozproszoną (serwer klient) (Corba lub RMI), i że ma być NA SIŁE OBIEKTOWE, MPI NIE JEST OBIEKTOWY ...

 

Dzięki, te linki przeglądałem wcześniej (to PI też gdzieś znalazłem); MPI jest prościejsze jeśli wszystko jest w jednym pliku (w moim przypadku mam problem z przesyłaniem zadania i wyniku). Wiem, że MPI nie jest obiektowe, ale ten program ma być obiektowy (ma być klient, serwer i warstwa transportowa - u mnie wt.h). To jest odpalane na jednym kompie, plik Makefile wygląda tak:

 

CC = g++

CFLAGS = -Wall



prog: main.o

$(CC) $(CFLAGS) -o prog main.o

main.o: main.C zadanie.h

$(CC) $(CFLAGS) -c main.C 

clean:

rm -f prog main.o

doc:

doxygen projekt.dox

 

i później odpalany poleceniem: mpirun -np 5 prog

[klimas7]

int MPI_Send(&x,&y,2,MPI_INT,kl,zad,MPI_COMM_WORLD);

wydaje mi się ze tu nie może być jednoczesnie &x, &y, mimo tego że count=2 (tak samo MPI_Recv)poprawnie jest stworzyć sobie strukture do przesyłania informacji.

A tu przykład już bardziej ambitny (Trudno natknąć się na niego googlując ):

Program generyje zbiór mandelbrota - jest tam pare sztuczek które mogą Ci pomóc no i jest pełna dokumentacji (pl )

http://fatcat.ftj.agh.edu.pl/~klimas7/doc/mpi/mandelbrot/

 

Powodzenia.

pz

 

Hmm i ak dobrze że ktokolwiek wie co to MPI (już nie wspomne pvm :/)

[Kowal]

int MPI_Send(&x,&y,2,MPI_INT,kl,zad,MPI_COMM_WORLD);

wydaje mi się ze tu nie może być jednoczesnie &x, &y, mimo tego że count=2 (tak samo MPI_Recv)poprawnie jest stworzyć sobie strukture do przesyłania informacji.

...

 

 

Z tym przesyłaniem dwóch zmiennych to też nie jestem do końca pewien (miałem to napisane w pliku wt.h), ale nie bardzo wiem jak do tego napisać coś w pliku serwer.h. Dzięki za mandelbrota, przeanalizuję go dzisiaj w trochę późniejszych godzinach ...