s
Sesiya.ru

Исследование метода распараллеливания линейных последовательных программ

Информация о работе

Тема
Исследование метода распараллеливания линейных последовательных программ
Тип Лабораторная работа
Предмет Программирование
Количество страниц 17
Язык работы Русский язык
Дата загрузки 2015-11-27 06:48:31
Размер файла 135.96 кб
Количество скачиваний 0
Скидка 15%

Поможем подготовить работу любой сложности

Заполнение заявки не обязывает Вас к заказу


Скачать файл с работой

Помогла работа? Поделись ссылкой

Министерство образования и науки Украины

Севастопольский национальный технический университет

 

 

 

 

 

 

 

Кафедра

Информационных

систем

 

 

 

 

 

 

 

Лабораторная работа № 2

Исследование метода распараллеливания линейных последовательных программ с использованием понятий модели вычислительного процесса

 

 

Выполнение

Оценка

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Выполнил:

ст. гр. И-41д

Лынок А.Ю.

Проверил:

Кротов К. В.

 

 

 

 

Севастополь

2013

2 вариант.

Вычислить полином Y=a0j0+a1j1+…+a5j5, где

Ai – коэффициент разложения (определяются как вводимые переменные),

ji – параболы i-го порядка.

 j0  =1; ji  =x-(n+1)/2; jk+1 = j1 jk -jk-1k2(n2-k2)/(4(4k2-1))

n – число точек, в которых задано значение функции Y (n=5)

 

Используем программу Maple для составления результирующего полинома. Раскрывая скобки и приводя подобные слагаемые, получаем:

Последовательную программу можно представить в виде следующих операций:

                                   

                                              

                                  

                                  

                                  

                                  

                                   

 

            Структурная схема последовательной программы представлена на рис. 1.

 

Рисунок 1 – Структурная схема последовательной программы

 

Представим последовательную программу в форме (1) (таблица 1).

ajx ={j,Q jx,in a jx, out a jx, W jx, |in a jx|, |W jx|}                  (1)

Для этого введём обозначения типов операции:

0 – унарная операция присваивания и переименования переменных

1 – унарная операция умножения (возведение в степень или умножение на коэффициент)

2 – бинарная операция умножения

3 – операция сложения

 

Таблица 1 – Представление программы в виде формы (1)

Тип

Операнды

Результат

Wj

|in aj|

|Wj|

1

0

T1

32

1

1

2

0

T2

12, 13

1

2

3

0

T3

14, 15, 16

1

3

4

0

T4

17, 18, 19, 20

1

4

5

0

T5

21, 22, 23, 24, 25

1

5

6

0

T6

26, 27, 28, 29, 30, 31

1

6

7

0

x

T7

12, 15, 19, 24, 30

1

5

8

1

T8

14, 18, 23, 29

1

4

9

1

T9

17, 22, 28

1

3

10

1

T10

21, 27

1

2

11

1

T11

26

1

1

12

2

T2, T7

T12

32

2

1

13

1

T2

T13

32

1

1

14

2

T3, T8

T14

32

2

1

15

2

T3, T7

T15

32

2

1

16

1

T3

T16

32

1

1

17

2

T4, T9

T17

32

2

1

18

2

T4, T8

T18

32

2

1

19

2

T4, T7

T19

32

2

1

20

1

T4

T20

32

1

1

21

2

T5, T10

T21

32

2

1

22

2

T5, T9

T22

32

2

1

23

2

T5, T8

T23

32

2

1

24

2

T5, T7

T24

32

2

1

               

Таблица 1 – Продолжение

Тип

Операнды

Результат

Wj

|in aj|

|Wj|

25

1

T5

T25

32

1

1

26

2

T6, T11

T26

32

2

1

27

2

T6, T10

T27

32

2

1

28

2

T6, T9

T28

32

2

1

29

2

T6, T8

T29

32

2

1

30

2

T6, T7

T30

32

2

1

31

1

T6

T31

32

1

1

32

3

Z

T32 = Y

21

0

 

Z = {T1, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31}.

 

Найдём множество  из условия Èaj    | in ajin P.

При этом, in P = {, , , ,, , x}. Т.е. это множество включает в себя данные, являющиеся входными для программы.

Тогда:

{, , , ,, , x}.

            Тогда на ярусе 0 будут присутствовать операции {1..11}, и они подготовят данные для следующих операций:

W1x = {32};                            W4x = {17, 18, 19, 20};                      W7x = {12, 15, 19, 24, 30};

W2x = {12, 13};                      W5x = {21, 22, 23, 24, 25};                W8x = {14, 18, 23, 29};

W3x = {14, 15, 16};                W6x = {26, 27, 28, 29, 30, 31};          W9x = {17, 22, 28};

W10x = {21, 27}; W11x = {26};

 

Тогда множество  формируется по условию:

.

Т.е. в него будут включены те операции, входные данные для которых являются выходными данными (результатами вычисления) операций нулевого яруса (см. таблицу 1).

Таким образом, получим:

 = {12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31}.

 

Выпишем из таблицы 1 множества Wj, согласно множеству .

W12x ={32};    W18x ={32};    W24x ={32};    W30x ={32};

W13x ={32};    W19x ={32};    W25x ={32};    W31x ={32};

W14x ={32};    W20x ={32};    W26x ={32};

W15x ={32};    W21x ={32};    W27x ={32};

W16x ={32};    W22x ={32};    W28x ={32};

W17x ={32};    W23x ={32};    W29x ={32};

 

Таким образом, во множество  будет входить только операция 32:  = {32}.

Проведённые вычисления позволяют построить двумерную модель вычислительного процесса (таблица 2).

 

 

 

Таблица 2 – Двумерная модель вычислительного процесса

t

oAt

*At

+At

PAt

At

0

12-32

1-11

1-11

1-11

1

32

12, 13, 14, 15,

16, 17, 18, 19,

20, 21, 22, 23,

24, 25, 26, 27,

28, 29, 30, 31

12, 13, 14, 15,

16, 17, 18, 19,

20, 21, 22, 23,

24, 25, 26, 27,

28, 29, 30, 31

12, 13, 14, 15,

16, 17, 18, 19,

20, 21, 22, 23,

24, 25, 26, 27,

   28, 29, 30, 31

1-11

2

32

32

32

12, 13, 14, 15,

16, 17, 18, 19,

20, 21, 22, 23,

24, 25, 26, 27,

28, 29, 30, 31

3

32

 

 

На рисунке 2 показано графическое представление ЯПФ.

 

 

 

 

 

 

 

 

 

 

 

 

Рисунок 2 – Графическое представление ЯПФ

 

 

 

 

 

 

 

 

 

 

ТЕКСТ ПРОГРАММЫ:

 

#include "stdafx.h"

#include <iostream>

#include "mpi.h"

#include <iomanip>

 

 

using namespace std;

MPI_Status status;

 

 

void S0()

{

       float a0,a1,a2,a3,a4,a5,x;

       a0=1; a1=2; a2=3; a3=4;

       a4=5; a5=6; x=7;

cout<<"a0= ";

cin>>a0;

cout<<endl<<"a1= ";

cin>>a1;

cout<<endl<<"a2= ";

cin>>a2;

cout<<endl<<"a3= ";

cin>>a3;

cout<<endl<<"a4= ";

cin>>a4;

cout<<endl<<"a5= ";

cin>>a5;

cout<<endl<<"x= ";

cin>>x;

 

MPI_Request req1, req2, req3, req4, req5, req6, req7, req8, req9, req10, req11;

int  f1=0, f2=0,f3=0,f4=0,f5=0,f6=0,f7=0,f8=0,f9=0,f10=0,f11=0;

 

MPI_Isend(&a0,1,MPI_FLOAT,1,1,MPI_COMM_WORLD, &req1);

MPI_Isend(&a1,1,MPI_FLOAT,2,2,MPI_COMM_WORLD, &req2);

MPI_Isend(&a2,1,MPI_FLOAT,3,3,MPI_COMM_WORLD, &req3);

MPI_Isend(&a3,1,MPI_FLOAT,4,4,MPI_COMM_WORLD, &req4);

MPI_Isend(&a4,1,MPI_FLOAT,5,5,MPI_COMM_WORLD, &req5);

MPI_Isend(&a5,1,MPI_FLOAT,6,6,MPI_COMM_WORLD, &req6);

MPI_Isend(&x, 1,MPI_FLOAT,7,7,MPI_COMM_WORLD, &req7);

MPI_Isend(&x, 1,MPI_FLOAT,8,8,MPI_COMM_WORLD, &req8);

MPI_Isend(&x, 1,MPI_FLOAT,9,9,MPI_COMM_WORLD, &req9);

MPI_Isend(&x, 1,MPI_FLOAT,10,10,MPI_COMM_WORLD, &req10);

MPI_Isend(&x, 1,MPI_FLOAT,11,11,MPI_COMM_WORLD, &req11);

 

 

while(!f1||!f2||!f3||!f4||!f5||!f6||!f7||!f8||!f9||!f10||

       !f11)

{

       MPI_Test(&req1,&f1,&status);

       MPI_Test(&req2,&f2,&status);

       MPI_Test(&req3,&f3,&status);

       MPI_Test(&req4,&f4,&status);

       MPI_Test(&req5,&f5,&status);

       MPI_Test(&req6,&f6,&status);

       MPI_Test(&req7,&f7,&status);

       MPI_Test(&req8,&f8,&status);

       MPI_Test(&req9,&f9,&status);

       MPI_Test(&req10,&f10,&status);

       MPI_Test(&req11,&f11,&status);

}

cout<<"S0 : all data were sent"<<endl;

 

 

 

float t1,t12,t13,t14,t15,t16,t17,t18,t19,t20,t21,t22,t23,t24,t25,t26,t27,t28,t29,t30,t31;

 

MPI_Recv(&t1, 1,MPI_FLOAT,1, 1, MPI_COMM_WORLD, &status);

MPI_Recv(&t12,1,MPI_FLOAT,12,12,MPI_COMM_WORLD, &status);

MPI_Recv(&t13,1,MPI_FLOAT,13,13,MPI_COMM_WORLD, &status);

MPI_Recv(&t14,1,MPI_FLOAT,14,14,MPI_COMM_WORLD, &status);

MPI_Recv(&t15,1,MPI_FLOAT,15,15,MPI_COMM_WORLD, &status);

MPI_Recv(&t16,1,MPI_FLOAT,16,16,MPI_COMM_WORLD, &status);

MPI_Recv(&t17,1,MPI_FLOAT,17,17,MPI_COMM_WORLD, &status);

MPI_Recv(&t18,1,MPI_FLOAT,18,18,MPI_COMM_WORLD, &status);

MPI_Recv(&t19,1,MPI_FLOAT,19,19,MPI_COMM_WORLD, &status);

MPI_Recv(&t20,1,MPI_FLOAT,20,20,MPI_COMM_WORLD, &status);

MPI_Recv(&t21,1,MPI_FLOAT,21,21,MPI_COMM_WORLD, &status);

MPI_Recv(&t22,1,MPI_FLOAT,22,22,MPI_COMM_WORLD, &status);

MPI_Recv(&t23,1,MPI_FLOAT,23,23,MPI_COMM_WORLD, &status);

MPI_Recv(&t24,1,MPI_FLOAT,24,24,MPI_COMM_WORLD, &status);

MPI_Recv(&t25,1,MPI_FLOAT,25,25,MPI_COMM_WORLD, &status);

MPI_Recv(&t26,1,MPI_FLOAT,26,26,MPI_COMM_WORLD, &status);

MPI_Recv(&t27,1,MPI_FLOAT,27,27,MPI_COMM_WORLD, &status);

MPI_Recv(&t28,1,MPI_FLOAT,28,28,MPI_COMM_WORLD, &status);

MPI_Recv(&t29,1,MPI_FLOAT,29,29,MPI_COMM_WORLD, &status);

MPI_Recv(&t30,1,MPI_FLOAT,30,30,MPI_COMM_WORLD, &status);

MPI_Recv(&t31,1,MPI_FLOAT,31,31,MPI_COMM_WORLD, &status);

 

float lastRes=t1+t12+t13+t14+t15+t16+t17+t18+t19+t20+t21

+t22+t23+t24+t25+t26+t27+t28+t29+t30+t31;

cout<<"S0: RESULtaaat: "<<lastRes<<endl;

getchar();

}

 

void S1()

{

float a0;

MPI_Request req1;

MPI_Irecv(&a0,1,MPI_FLOAT,0,1,MPI_COMM_WORLD,&req1);

MPI_Wait(&req1,&status);

cout<<"S1: received a0= "<<a0<<endl;

MPI_Send(&a0,1,MPI_FLOAT,0,1,MPI_COMM_WORLD);

}

 

void S2()

{

float a1;

MPI_Request req2,req3;

MPI_Irecv(&a1,1,MPI_FLOAT,0,2,MPI_COMM_WORLD,&req2);

MPI_Wait(&req2,&status);

cout<<"S2: received a1= "<<a1<<endl;

 

MPI_Isend(&a1,1,MPI_FLOAT,12,12,MPI_COMM_WORLD,&req2);

MPI_Isend(&a1,1,MPI_FLOAT,13,13,MPI_COMM_WORLD,&req3);

MPI_Wait(&req2,&status);

MPI_Wait(&req3,&status);

}

 

void S3()

{

float a2;

MPI_Request req3,req4, req5;

MPI_Irecv(&a2,1,MPI_FLOAT,0,3,MPI_COMM_WORLD,&req3);

MPI_Wait(&req3,&status);

cout<<"S3: received a2= "<<a2<<endl;

 

MPI_Isend(&a2,1,MPI_FLOAT,14,14,MPI_COMM_WORLD,&req3);

MPI_Isend(&a2,1,MPI_FLOAT,15,15,MPI_COMM_WORLD,&req4);

MPI_Isend(&a2,1,MPI_FLOAT,16,16,MPI_COMM_WORLD,&req5);

MPI_Wait(&req3,&status);

MPI_Wait(&req4,&status);

MPI_Wait(&req5,&status);

}

 

void S4()

{

float a3;

MPI_Request req4,req5, req6,req7;

MPI_Irecv(&a3,1,MPI_FLOAT,0,4,MPI_COMM_WORLD,&req4);

MPI_Wait(&req4,&status);

cout<<"S4: received a3= "<<a3<<endl;

 

MPI_Isend(&a3,1,MPI_FLOAT,17,17,MPI_COMM_WORLD,&req4);

MPI_Isend(&a3,1,MPI_FLOAT,18,18,MPI_COMM_WORLD,&req5);

MPI_Isend(&a3,1,MPI_FLOAT,19,19,MPI_COMM_WORLD,&req6);

MPI_Isend(&a3,1,MPI_FLOAT,20,20,MPI_COMM_WORLD,&req7);

 

MPI_Wait(&req4,&status);

MPI_Wait(&req5,&status);

MPI_Wait(&req6,&status);

MPI_Wait(&req7,&status);

}

 

void S5()

{

float a4;

MPI_Request req5,req6, req7,req8,req9;

MPI_Irecv(&a4,1,MPI_FLOAT,0,5,MPI_COMM_WORLD,&req5);

MPI_Wait(&req5,&status);

cout<<"S5: received a4= "<<a4<<endl;

 

MPI_Isend(&a4,1,MPI_FLOAT,21,21,MPI_COMM_WORLD,&req5);

MPI_Isend(&a4,1,MPI_FLOAT,22,22,MPI_COMM_WORLD,&req6);

MPI_Isend(&a4,1,MPI_FLOAT,23,23,MPI_COMM_WORLD,&req7);

MPI_Isend(&a4,1,MPI_FLOAT,24,24,MPI_COMM_WORLD,&req8);

MPI_Isend(&a4,1,MPI_FLOAT,25,25,MPI_COMM_WORLD,&req9);

 

MPI_Wait(&req5,&status);

MPI_Wait(&req6,&status);

MPI_Wait(&req7,&status);

MPI_Wait(&req8,&status);

MPI_Wait(&req9,&status);

}

 

 

void S6()

{

float a5;

MPI_Request req6,req7, req8,req11,req12,req2,req1;

MPI_Irecv(&a5,1,MPI_FLOAT,0,6,MPI_COMM_WORLD,&req6);

MPI_Wait(&req6,&status);

cout<<"S6: received a5= "<<a5<<endl;

 

MPI_Isend(&a5,1,MPI_FLOAT,26,26,MPI_COMM_WORLD,&req7);

MPI_Isend(&a5,1,MPI_FLOAT,27,27,MPI_COMM_WORLD,&req8);

MPI_Isend(&a5,1,MPI_FLOAT,28,28,MPI_COMM_WORLD,&req11);

MPI_Isend(&a5,1,MPI_FLOAT,29,29,MPI_COMM_WORLD,&req12);

MPI_Isend(&a5,1,MPI_FLOAT,30,30,MPI_COMM_WORLD,&req1);

MPI_Isend(&a5,1,MPI_FLOAT,31,31,MPI_COMM_WORLD,&req2);

 

MPI_Wait(&req7,&status);

MPI_Wait(&req8,&status);

MPI_Wait(&req11,&status);

MPI_Wait(&req12,&status);

MPI_Wait(&req1,&status);

MPI_Wait(&req2,&status);

}

 

void S7()

{

float x;

MPI_Request req7, req8,req9,req10,req11;

MPI_Irecv(&x,1,MPI_FLOAT,0,7,MPI_COMM_WORLD,&req7);

MPI_Wait(&req7,&status);

cout<<"S7: received x= "<<x<<endl;

 

MPI_Isend(&x,1,MPI_FLOAT,12,12,MPI_COMM_WORLD,&req7);

MPI_Isend(&x,1,MPI_FLOAT,15,15,MPI_COMM_WORLD,&req8);

MPI_Isend(&x,1,MPI_FLOAT,19,19,MPI_COMM_WORLD,&req9);

MPI_Isend(&x,1,MPI_FLOAT,24,24,MPI_COMM_WORLD,&req10);

MPI_Isend(&x,1,MPI_FLOAT,30,30,MPI_COMM_WORLD,&req11);

 

MPI_Wait(&req7,&status);

MPI_Wait(&req8,&status);

MPI_Wait(&req9,&status);

MPI_Wait(&req10,&status);

MPI_Wait(&req11,&status);

}

 

void S8()

{

float x;

MPI_Request req12, req8,req9,req10;

MPI_Irecv(&x,1,MPI_FLOAT,0,8,MPI_COMM_WORLD,&req8);

MPI_Wait(&req8,&status);

cout<<"S8: received x= "<<x<<endl;

float res=x*x;

 

MPI_Isend(&res,1,MPI_FLOAT,14,14,MPI_COMM_WORLD,&req8);

MPI_Isend(&res,1,MPI_FLOAT,18,18,MPI_COMM_WORLD,&req9);

MPI_Isend(&res,1,MPI_FLOAT,23,23,MPI_COMM_WORLD,&req10);

MPI_Isend(&res,1,MPI_FLOAT,29,29,MPI_COMM_WORLD,&req12);

 

MPI_Wait(&req8,&status);

MPI_Wait(&req9,&status);

MPI_Wait(&req10,&status);

MPI_Wait(&req12,&status);

}

 

 

void S9()

{

float x;

MPI_Request  req11,req9,req10;

MPI_Irecv(&x,1,MPI_FLOAT,0,9,MPI_COMM_WORLD,&req9);

MPI_Wait(&req9,&status);

cout<<"S9: received x= "<<x<<endl;

float res=x*x*x;

 

MPI_Isend(&res,1,MPI_FLOAT,17,17,MPI_COMM_WORLD,&req9);

MPI_Isend(&res,1,MPI_FLOAT,22,22,MPI_COMM_WORLD,&req10);

MPI_Isend(&res,1,MPI_FLOAT,28,28,MPI_COMM_WORLD,&req11);

 

 

MPI_Wait(&req9,&status);

MPI_Wait(&req10,&status);

MPI_Wait(&req11,&status);

}

 

void S10()

{

float x;

MPI_Request  req10,req8;

MPI_Irecv(&x,1,MPI_FLOAT,0,10,MPI_COMM_WORLD,&req10);

MPI_Wait(&req10,&status);

cout<<"S10: received x= "<<x<<endl;

float res=x*x*x*x;

 

MPI_Isend(&res,1,MPI_FLOAT,21,21,MPI_COMM_WORLD,&req10);

MPI_Isend(&res,1,MPI_FLOAT,27,27,MPI_COMM_WORLD,&req8);

 

MPI_Wait(&req10,&status);

MPI_Wait(&req8,&status);

}

 

void S11()

{

float x;

MPI_Request  req11,req7;

MPI_Irecv(&x,1,MPI_FLOAT,0,11,MPI_COMM_WORLD,&req11);

MPI_Wait(&req11,&status);

cout<<"S11: received x= "<<x<<endl;

float res=x*x*x*x*x;

 

MPI_Isend(&res,1,MPI_FLOAT,26,26,MPI_COMM_WORLD,&req7);

 

MPI_Wait(&req7,&status);

}

 

void S12()

{

float t2,t7;

MPI_Request  req1,req2;

 

MPI_Irecv(&t2,1,MPI_FLOAT,2,12,MPI_COMM_WORLD,&req1);

MPI_Wait(&req1,&status);

MPI_Irecv(&t7,1,MPI_FLOAT,7,12,MPI_COMM_WORLD,&req2);

MPI_Wait(&req2,&status);

float res=t2*t7;

cout<<"S12: done"<<endl;

 

MPI_Send(&res,1,MPI_FLOAT,0,12,MPI_COMM_WORLD);

}

 

void S13()

{

float t2;

MPI_Request  req;

 

MPI_Irecv(&t2,1,MPI_FLOAT,2,13,MPI_COMM_WORLD,&req);

MPI_Wait(&req,&status);

float res=-3*t2;

cout<<"S13: done"<<endl;

 

MPI_Send(&res,1,MPI_FLOAT,0,13,MPI_COMM_WORLD);

}

 

void S14()

{

float t3,t8;

MPI_Request  req1,req2;

 

MPI_Irecv(&t3,1,MPI_FLOAT,3,14,MPI_COMM_WORLD,&req1);

MPI_Wait(&req1,&status);

MPI_Irecv(&t8,1,MPI_FLOAT,8,14,MPI_COMM_WORLD,&req2);

MPI_Wait(&req2,&status);

float res=t3*t8;

cout<<"S14: done"<<t3<<"*"<<t8<<"= "<<res<<endl;

MPI_Send(&res,1,MPI_FLOAT,0,14,MPI_COMM_WORLD);

}

 

void S15()

{

float t3,t7;

MPI_Request  req1,req2;

 

MPI_Irecv(&t3,1,MPI_FLOAT,3,15,MPI_COMM_WORLD,&req1);

MPI_Wait(&req1,&status);

MPI_Irecv(&t7,1,MPI_FLOAT,7,15,MPI_COMM_WORLD,&req2);

MPI_Wait(&req2,&status);

float res=-6*t3*t7;

cout<<"S15: done"<<"-6 * "<<t3<<"*"<<t7<<"= "<<res<<endl;

MPI_Send(&res,1,MPI_FLOAT,0,15,MPI_COMM_WORLD);

}

 

void S16()

{

float t3;

MPI_Request  req1;

 

MPI_Irecv(&t3,1,MPI_FLOAT,3,16,MPI_COMM_WORLD,&req1);

MPI_Wait(&req1,&status);

float res=7*t3;

cout<<"S16: done"<<"7 * "<<t3<<"= "<<res<<endl;

MPI_Send(&res,1,MPI_FLOAT,0,16,MPI_COMM_WORLD);

}

 

void S17()

{

float t4,t9;

MPI_Request  req1,req2;

 

MPI_Irecv(&t4,1,MPI_FLOAT,4,17,MPI_COMM_WORLD,&req1);

MPI_Wait(&req1,&status);

MPI_Irecv(&t9,1,MPI_FLOAT,9,17,MPI_COMM_WORLD,&req2);

MPI_Wait(&req2,&status);

float res=t4*t9;

cout<<"S17: done"<<t4<<" * "<<t9<<"= "<<res<<endl;

MPI_Send(&res,1,MPI_FLOAT,0,17,MPI_COMM_WORLD);

}

 

void S18()

{

float t4,t8;

MPI_Request  req1,req2;

 

MPI_Irecv(&t4,1,MPI_FLOAT,4,18,MPI_COMM_WORLD,&req1);

MPI_Wait(&req1,&status);

MPI_Irecv(&t8,1,MPI_FLOAT,8,18,MPI_COMM_WORLD,&req2);

MPI_Wait(&req2,&status);

float res=-9*t4*t8;

cout<<"S18: done"<<"-9 *"<<t4<<" * "<<t8<<"= "<<res<<endl;

MPI_Send(&res,1,MPI_FLOAT,0,18,MPI_COMM_WORLD);

}

 

void S19()

{

float t4,t7;

MPI_Request  req1,req2;

 

MPI_Irecv(&t4,1,MPI_FLOAT,4,19,MPI_COMM_WORLD,&req1);

MPI_Wait(&req1,&status);

MPI_Irecv(&t7,1,MPI_FLOAT,7,19,MPI_COMM_WORLD,&req2);

MPI_Wait(&req2,&status);

float res=23.6*t4*t7;

cout<<"S19: done"<<"23.6 *"<<t4<<" * "<<t7<<"= "<<res<<endl;

MPI_Send(&res,1,MPI_FLOAT,0,19,MPI_COMM_WORLD);

}

 

void S20()

{

float t4;

MPI_Request  req1;

 

MPI_Irecv(&t4,1,MPI_FLOAT,4,20,MPI_COMM_WORLD,&req1);

MPI_Wait(&req1,&status);

float res=-16.8*t4;

cout<<"S20: done"<<"-16.8 *"<<t4<<"= "<<res<<endl;

MPI_Send(&res,1,MPI_FLOAT,0,20,MPI_COMM_WORLD);

}

 

void S21()

{

float t5,t10;

MPI_Request  req1,req2;

 

MPI_Irecv(&t5,1,MPI_FLOAT,5,21,MPI_COMM_WORLD,&req1);

MPI_Wait(&req1,&status);

MPI_Irecv(&t10,1,MPI_FLOAT,10,21,MPI_COMM_WORLD,&req2);

MPI_Wait(&req2,&status);

float res=t5*t10;

cout<<"S21: done"<<t5<<" * "<<t10<<"= "<<res<<endl;

MPI_Send(&res,1,MPI_FLOAT,0,21,MPI_COMM_WORLD);

}

 

void S22()

{

float t5,t9;

MPI_Request  req1,req2;

 

MPI_Irecv(&t5,1,MPI_FLOAT,5,22,MPI_COMM_WORLD,&req1);

MPI_Wait(&req1,&status);

MPI_Irecv(&t9,1,MPI_FLOAT,9,22,MPI_COMM_WORLD,&req2);

MPI_Wait(&req2,&status);

float res=-12*t5*t9;

cout<<"S22: done"<<"-12 * "<<t5<<" * "<<t9<<"= "<<res<<endl;

MPI_Send(&res,1,MPI_FLOAT,0,22,MPI_COMM_WORLD);

}

 

void S23()

{

float t5,t8;

MPI_Request  req1,req2;

 

MPI_Irecv(&t5,1,MPI_FLOAT,5,23,MPI_COMM_WORLD,&req1);

MPI_Wait(&req1,&status);

MPI_Irecv(&t8,1,MPI_FLOAT,8,23,MPI_COMM_WORLD,&req2);

MPI_Wait(&req2,&status);

float z=347.0/7.0;

float res=z*t5*t8;

cout<<"S23: done"<<z<<" * "<<t5<<" * "<<t8<<"= "<<res<<endl;

MPI_Send(&res,1,MPI_FLOAT,0,23,MPI_COMM_WORLD);

}

 

void S24()

{

float t5,t7;

MPI_Request  req1,req2;

 

MPI_Irecv(&t5,1,MPI_FLOAT,5,24,MPI_COMM_WORLD,&req1);

MPI_Wait(&req1,&status);

MPI_Irecv(&t7,1,MPI_FLOAT,7,24,MPI_COMM_WORLD,&req2);

MPI_Wait(&req2,&status);

float z=-570./7.0;

float res=z*t5*t7;

cout<<"S24: done"<<z<<" * "<<t5<<" * "<<t7<<"= "<<res<<endl;

MPI_Send(&res,1,MPI_FLOAT,0,24,MPI_COMM_WORLD);

}

 

void S25()

{

float t5;

MPI_Request  req1;

 

MPI_Irecv(&t5,1,MPI_FLOAT,5,25,MPI_COMM_WORLD,&req1);

MPI_Wait(&req1,&status);

float z=216.0/5.0;

float res=z*t5;

cout<<"S25: done"<<z<<" * "<<t5<<"= "<<res<<endl;

MPI_Send(&res,1,MPI_FLOAT,0,25,MPI_COMM_WORLD);

}

 

void S26()

{

float t6,t11;

MPI_Request  req2,req1;

 

MPI_Irecv(&t6,1,MPI_FLOAT,6,26,MPI_COMM_WORLD,&req1);

MPI_Wait(&req1,&status);

MPI_Irecv(&t11,1,MPI_FLOAT,11,26,MPI_COMM_WORLD,&req2);

MPI_Wait(&req2,&status);

float res=t6*t11;

cout<<"S26: done"<<t6<<" * "<<t11<<"= "<<res<<endl;

MPI_Send(&res,1,MPI_FLOAT,0,26,MPI_COMM_WORLD);

}

 

void S27()

{

float t6,t10;

MPI_Request  req2,req1;

 

MPI_Irecv(&t6,1,MPI_FLOAT,6,27,MPI_COMM_WORLD,&req1);

MPI_Wait(&req1,&status);

MPI_Irecv(&t10,1,MPI_FLOAT,10,27,MPI_COMM_WORLD,&req2);

MPI_Wait(&req2,&status);

float res=-15*t6*t10;

cout<<"S27: done"<<"-15 * "<<t6<<" * "<<t10<<"= "<<res<<endl;

MPI_Send(&res,1,MPI_FLOAT,0,27,MPI_COMM_WORLD);

}

 

void S28()

{

float t6,t9;

MPI_Request  req2,req1;

 

MPI_Irecv(&t6,1,MPI_FLOAT,6,28,MPI_COMM_WORLD,&req1);

MPI_Wait(&req1,&status);

MPI_Irecv(&t9,1,MPI_FLOAT,9,28,MPI_COMM_WORLD,&req2);

MPI_Wait(&req2,&status);

float res=85*t6*t9;

cout<<"S28: done"<<"85 * "<<t6<<" * "<<t9<<"= "<<res<<endl;

MPI_Send(&res,1,MPI_FLOAT,0,28,MPI_COMM_WORLD);

}

 

void S29()

{

float t6,t8;

MPI_Request  req2,req1;

 

MPI_Irecv(&t6,1,MPI_FLOAT,6,29,MPI_COMM_WORLD,&req1);

MPI_Wait(&req1,&status);

MPI_Irecv(&t8,1,MPI_FLOAT,8,29,MPI_COMM_WORLD,&req2);

MPI_Wait(&req2,&status);

float res=-225*t6*t8;

cout<<"S29: done"<<"-225 * "<<t6<<" * "<<t8<<"= "<<res<<endl;

MPI_Send(&res,1,MPI_FLOAT,0,29,MPI_COMM_WORLD);

}

 

void S30()

{

float t6,t7;

MPI_Request  req2,req1;

 

MPI_Irecv(&t6,1,MPI_FLOAT,6,30,MPI_COMM_WORLD,&req1);

MPI_Wait(&req1,&status);

MPI_Irecv(&t7,1,MPI_FLOAT,7,30,MPI_COMM_WORLD,&req2);

MPI_Wait(&req2,&status);

float res=274*t6*t7;

cout<<"S30: done"<<"274 * "<<t6<<" * "<<t7<<"= "<<res<<endl;

MPI_Send(&res,1,MPI_FLOAT,0,30,MPI_COMM_WORLD);

}

 

void S31()

{

float t6;

MPI_Request req1;

 

MPI_Irecv(&t6,1,MPI_FLOAT,6,31,MPI_COMM_WORLD,&req1);

MPI_Wait(&req1,&status);

float res=-120*t6;

cout<<"S31: done"<<"-120 * "<<t6<<" * "<<"= "<<res<<endl;

MPI_Send(&res,1,MPI_FLOAT,0,31,MPI_COMM_WORLD);

}

 

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

{

    int rank;   

    MPI_Init(&argc, &argv);

    MPI_Comm_rank(MPI_COMM_WORLD, &rank);

 

    switch(rank) {

       case 0:  S0();break;

       case 1:  S1();break;

       case 2:  S2();break;

       case 3:  S3();break;

       case 4:  S4();break;

       case 5:  S5();break;

       case 6:  S6();break;

       case 7:  S7();break;

       case 8:  S8();break;

       case 9:  S9();break;

       case 10: S10();break;

       case 11: S11();break;

       case 12: S12();break;

       case 13: S13();break;

       case 14: S14();break;

       case 15: S15();break;

       case 16: S16();break;

       case 17: S17();break;

       case 18: S18();break;

       case 19: S19();break;

       case 20: S20();break;

       case 21: S21();break;

       case 22: S22();break;

       case 23: S23();break;

       case 24: S24();break;

       case 25: S25();break;

       case 26: S26();break;

       case 27: S27();break;

       case 28: S28();break;

       case 29: S29();break;

       case 30: S30();break;

       case 31: S31();break;

       }

   MPI_Finalize();

    return 0;

}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

ВЫВОДЫ

            В процессе выполнения данной лабораторной работы исследовался метод распараллеливания последовательной программы с помощью двумерной модели вычислительного процесса. В результате распараллеливания получилось 32 процесса, реализующие элементарные операции. Процесс с рангом 0 сначала считывает данные, вводимые с клавиатуры, рассылает данные процессам 0-ого яруса, а затем ожидает данные от процессов 1-ого яруса для того, чтобы вычислить результат.