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

Лабораторная работа по предмету «Программирование»
Информация о работе
  • Тема: Исследование метода распараллеливания линейных последовательных программ
  • Количество скачиваний: 2
  • Тип: Лабораторная работа
  • Предмет: Программирование
  • Количество страниц: 17
  • Язык работы: Русский язык
  • Дата загрузки: 2015-11-27 06:48:31
  • Размер файла: 135.96 кб
Помогла работа? Поделись ссылкой
Узнать стоимость учебной работы online!
  • Тип работы
  • Часть диплома
  • Дипломная работа
  • Курсовая работа
  • Контрольная работа
  • Решение задач
  • Реферат
  • Научно - исследовательская работа
  • Отчет по практике
  • Ответы на билеты
  • Тест/экзамен online
  • Монография
  • Эссе
  • Доклад
  • Компьютерный набор текста
  • Компьютерный чертеж
  • Рецензия
  • Перевод
  • Репетитор
  • Бизнес-план
  • Конспекты
  • Проверка качества
  • Экзамен на сайте
  • Аспирантский реферат
  • Магистерская работа
  • Научная статья
  • Научный труд
  • Техническая редакция текста
  • Чертеж от руки
  • Диаграммы, таблицы
  • Презентация к защите
  • Тезисный план
  • Речь к диплому
  • Доработка заказа клиента
  • Отзыв на диплом
  • Публикация статьи в ВАК
  • Публикация статьи в Scopus
  • Дипломная работа MBA
  • Повышение оригинальности
  • Копирайтинг
  • Другое
Узнать стоимость
Информация о документе

Документ предоставляется как есть, мы не несем ответственности, за правильность представленной в нём информации. Используя информацию для подготовки своей работы необходимо помнить, что текст работы может быть устаревшим, работа может не пройти проверку на заимствования.

Если Вы являетесь автором текста представленного на данной странице и не хотите чтобы он был размешён на нашем сайте напишите об этом перейдя по ссылке: «Правообладателям»

Можно ли скачать документ с работой

Да, скачать документ можно бесплатно, без регистрации перейдя по ссылке:

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

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

 

 

 

 

 

 

 

Кафедра

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

систем

 

 

 

 

 

 

 

Лабораторная работа № 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-ого яруса для того, чтобы вычислить результат.