Форум программистов, компьютерный форум CyberForum.ru

Умножение 2 матриц с помощью библиотек MPI - C++

Восстановить пароль Регистрация
 
zewer
 Аватар для zewer
1022 / 713 / 72
Регистрация: 07.01.2011
Сообщений: 5,369
22.01.2014, 06:14     Умножение 2 матриц с помощью библиотек MPI #1
Здравствуйте, разрабатываю умножение 2 матриц ( A(120x154), B(154x73) ) с помощью библиотек MPI
Существует 8 процессоров (т.е. матрицы делятся на 8 частей), которые принимают куски матриц, умножают их и отсылают дальше. Программа работает не много криво, а именно 8 процессор отказывается работать, что потянуло за собой работу всего проекта, так как результат от него, и матрица С (120х73) генерироваться не может.
Проект конечно большой, и захочет ли мне кто-то помогать очень даже вряд ли, но все же:

proto.h
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <mpi.h>
#include "math.h"
#include <iostream>
#include <conio.h>
#include <fstream>
using namespace std;
//Operations
int ** dobytok_2_matruc(int** A,int RowA,int** B,int ColumnB, int ColA_RowB);
void Copy_Matrix(int **&To,int **&From,int Rows,int Columns);
 
//initialization
void matrix(int**&M,int size);
void number(int**&Numb);
 
//file
void write_to_file(ofstream &fx,int** MRC,int Rows,int Columns,int processor,char* name);
 
//input
void Generate_Matrix_A_and_B(int offset);
void Read_Matrix_B(int **&B1,int **&B2,int **&B3,int **&B4,int **&B5,
                   int **&B6,int **&B7,int **&B8);
void Read_Matrix_A(int **&A1,int **&A2,int **&A3,int **&A4,int **&A5,
                   int **&A6,int **&A7,int **&A8);
void Read_Matrix_A(int **&A,int nomer);
void Read_Matrix_B(int **&B,int nomer);
void SendRecive_Matrix(int**&SendM,int out_i,int out_j,int to_CPU,int**&ReciveM,int in_i,int in_j,int from_CPU,MPI_Status &status);
 
//send & recive
void Recive_Number(int**&numb,int proc_rank,MPI_Status &status);
void Recive_Matrix(int Row,int Column,int**&matrix1,int proc_rank,MPI_Status &status);
void Send_Number(int**&number,int proc_rank);
void Send_Matrix(int Row,int Column,int**&matrix,int proc_rank);
void number(int**&Numb);
void matrix(int**&M,int Row,int Column);
void SendRecive_Matrix(int**&SendM,int out_i,int out_j,int to_CPU,int**&ReciveM,int in_i,int in_j,int from_CPU,MPI_Status &status);
void Recive_MatrixB4_8(int**&matrix1,int proc_rank,MPI_Status &status);
void Send_MatrixB4_8(int**&matrix,int proc_rank);
 
//processors
void CPU_1();
void CPU_2();
void CPU_3();
void CPU_4();
void CPU_5();
void CPU_6();
void CPU_7();
void CPU_8();
 
#define CPU1 0
#define CPU2 1
#define CPU3 2
#define CPU4 3
#define CPU5 4
#define CPU6 5
#define CPU7 6
#define CPU8 7
 
//test
void Recive_MatrixB4_8(int**&matrix1,int proc_rank,MPI_Status &status);
void Recive_MatrixB123(int**&matrix1,int proc_rank,MPI_Status &status);
void Recive_MatrixA3_8(int**&matrix1,int proc_rank,MPI_Status &status);
void Recive_MatrixA12(int**&matrix1,int proc_rank,MPI_Status &status);
void Send_MatrixB4_8(int**&matrix,int proc_rank);
void Send_MatrixB123(int**&matrix,int proc_rank);
void Send_MatrixA3_8(int**&matrix,int proc_rank);
void Send_MatrixA12(int**&matrix,int proc_rank);
 
char * MakeComent(int porjadok,int proc);
 
void Save_in_mem(int **C1,int Column1,int **C2,int Column2,int **C3,int Column3,int **C4,int Column4,
int **C5,int Column5,int **C6,int Column6,int **C7,int Column7,int **C8,int Column8,int Row);
 
//TIMER
void Write_Time(int step,double time,char* message);
enter.cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
#include "proto.h"
 
ofstream fe;
 
void Read_Matrix_A(int **&A,int nomer)
{
    if(nomer>8 && nomer<1)
    {
        cout<<"Nomer vid 1 - do 8"<<endl;
        _getch();
        exit(17);
    }
 
    ifstream file1("E:\\MEMORY.txt");
    int iteration=0;
    char str[2000]; 
    file1.getline(str, sizeof(str)); // read line Matrix A....
    int ind_i=0;
    while (!file1.eof())
    {
        file1.getline(str, sizeof(str));
        char *pw;
        if(iteration<15 && nomer ==1)//A1 (15x154)
        {
            pw = strtok (str, "\t");
            int ind_j=0;
            while(pw !=NULL)
            {
                A[iteration][ind_j] = atoi(pw);
                ind_j++;
                pw = strtok (NULL, "\t");
            }
 
        }
        else if(iteration>14 && iteration<30 && nomer ==2)//A2 (15x154)
        {
            pw = strtok (str, "\t");
            int ind_j=0;
            while(pw !=NULL)
            {
                A[iteration-15][ind_j] = atoi(pw);
                ind_j++;
                pw = strtok (NULL, "\t");
            }
        }
        else if(iteration>29 && iteration<45 && nomer ==3)//A3 (15x154)
        {
            pw = strtok (str, "\t");
            int ind_j=0;
            while(pw !=NULL)
            {
                A[iteration-30][ind_j] = atoi(pw);
                ind_j++;
                pw = strtok (NULL, "\t");
            }
        }
        else if(iteration>44 && iteration<60 && nomer ==4)//A4 (15x154)
        {
            pw = strtok (str, "\t");
            int ind_j=0;
            while(pw !=NULL)
            {
                A[iteration-45][ind_j] = atoi(pw);
                ind_j++;
                pw = strtok (NULL, "\t");
            }
        }
        else if(iteration>59 && iteration<75 && nomer ==5)//A5 (15x154)
        {
            pw = strtok (str, "\t");
            int ind_j=0;
            while(pw !=NULL)
            {
                A[iteration-60][ind_j] = atoi(pw);
                ind_j++;
                pw = strtok (NULL, "\t");
            }
        }
        else if(iteration>74 && iteration<90 && nomer ==6)//A6 (15x154)
        {
            pw = strtok (str, "\t");
            int ind_j=0;
            while(pw !=NULL)
            {
                A[iteration-75][ind_j] = atoi(pw);
                ind_j++;
                pw = strtok (NULL, "\t");
            }
        }
        else if(iteration>89 && iteration<105 && nomer ==7)//A7 (15x154)
        {
            pw = strtok (str, "\t");
            int ind_j=0;
            while(pw !=NULL)
            {
                A[iteration-90][ind_j] = atoi(pw);
                ind_j++;
                pw = strtok (NULL, "\t");
            }
        }
        else if(iteration>100 && iteration<130 && nomer ==8)//A8 (15x154)
        {
            pw = strtok (str, "\t");
            int ind_j=0;
            while(pw !=NULL)
            {
                A[iteration-105][ind_j] = atoi(pw);
                ind_j++;
                pw = strtok (NULL, "\t");
            }
        }
        //else break;
        iteration++;
    }
    file1.close();
}
 
void Read_Matrix_B(int **&B,int nomer)
{
    if(nomer>8 && nomer<1)
    {
        cout<<"Nomer vid 1 - do 8"<<endl;
        _getch();
        exit(17);
    }
    ifstream file1("E:\\MEMORY.txt");
    char str[20000];
    for(int i=0;i<122;i++)
        file1.getline(str, sizeof(str)); // goto line Matrix B....
    int ind_i=0;
    while (!file1.eof())
    {
        if(ind_i>=154)break;//вся матриця B прочитана 
        file1.getline(str, sizeof(str));
        char *pw;
        pw = strtok (str, "\t");
        int ind_j=0;
        while(pw !=NULL)
        {
            if(ind_j<9)
            {
                if(nomer==1)
                {
                B[ind_i][ind_j] = atoi(pw);             
                }
                ind_j++;
                pw = strtok (NULL, "\t");
            }
            else if(ind_j>8 && ind_j<18)
            {
                if(nomer==2)
                {
                B[ind_i][ind_j-9] = atoi(pw);           
                }
                ind_j++;
                pw = strtok (NULL, "\t");
            }
            else if(ind_j>17 && ind_j<27)
            {
                if(nomer==3)
                {
                B[ind_i][ind_j-18] = atoi(pw);
                }
                ind_j++;
                pw = strtok (NULL, "\t");
            }
            else if(ind_j>26 && ind_j<36)
            {
                if(nomer==4)
                {
                B[ind_i][ind_j-27] = atoi(pw);
                }
                ind_j++;
                pw = strtok (NULL, "\t");
            }
            else if(ind_j>35 && ind_j<45)
            {
                if(nomer==5)
                {
                B[ind_i][ind_j-36] = atoi(pw);
                }
                ind_j++;
                pw = strtok (NULL, "\t");
            }
            else if(ind_j>44 && ind_j<54)
            {
                if(nomer==6)
                {
                B[ind_i][ind_j-45] = atoi(pw);
                }
                ind_j++;
                pw = strtok (NULL, "\t");
            }
            else if(ind_j>53 && ind_j<63)
            {
                if(nomer==7)
                {
                B[ind_i][ind_j-54] = atoi(pw);
                }
                ind_j++;
                pw = strtok (NULL, "\t");
            }
            else if(ind_j>62 && ind_j<73)
            {
                if(nomer==8)
                {
                B[ind_i][ind_j-63] = atoi(pw);
                }
                ind_j++;
                pw = strtok (NULL, "\t");
            }
            //else if(ind_i>216)break;
            else break;
        }
        ind_i++;
    }
    file1.close();
}
file.cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
#include "proto.h"
 
 
void write_to_file(ofstream &fx,int** MRC,int Rows,int Columns,int processor,char* name)
{
    char*path;
    if(processor==0) path = "E:\\1.txt";
    else if(processor==1) path = "E:\\2.txt";
    else if(processor==2) path = "E:\\3.txt";
    else if(processor==3) path = "E:\\4.txt";
    else if(processor==4) path = "E:\\5.txt";
    else if(processor==5) path = "E:\\6.txt";
    else if(processor==6) path = "E:\\7.txt";
    else if(processor==7) path = "E:\\8.txt";
    else {
        cout<<"Error: bad processor  = "<<processor<<endl;
        path = "E:\\Error.txt";
    }
 
    fx.open (path,std::ofstream::out | std::ofstream::app);
    fx << name<<" = \r\n";
    for(int i=0;i<Rows;i++)
    {
        for(int j=0;j<Columns;j++)
            fx << MRC[i][j]<<"\t";
        fx<<"\r\n";
    }
    fx.close();
 
}
 
char * MakeComent(int porjadok,int proc)
{
    char*procchar = new char[2];
    _itoa(proc,procchar,10);
    char str1[] = "Recived B";
    char*ascStep = new char[2];
    _itoa(porjadok,ascStep,10);
    char str2[] = " from #";
    char str3[] = ". Than B";
    char full[30] = { NULL };
    strcat(full, str1);
    strcat(full, ascStep);
    strcat(full, str2);
    strcat(full, procchar);
    strcat(full, str3);
    strcat(full, ascStep);
    return full;
}
 
void Save_in_mem(int **C1,int Column1,int **C2,int Column2,int **C3,int Column3,int **C4,int Column4,
                 int **C5,int Column5,int **C6,int Column6,int **C7,int Column7,int **C8,int Column8,int Row)
{
    ofstream fx("E:\\Total.txt", std::ofstream::out | std::ofstream::app);
    for(int i=0;i<Row;i++)
    {
        for(int j=0;j<Column1;j++) fx<<C1[i][j]<<"\t";
        for(int j=0;j<Column2;j++) fx<<C2[i][j]<<"\t";
        for(int j=0;j<Column3;j++) fx<<C3[i][j]<<"\t";
        for(int j=0;j<Column4;j++) fx<<C4[i][j]<<"\t";
        for(int j=0;j<Column5;j++) fx<<C5[i][j]<<"\t";
        for(int j=0;j<Column6;j++) fx<<C6[i][j]<<"\t";
        for(int j=0;j<Column7;j++) fx<<C7[i][j]<<"\t";
        for(int j=0;j<Column8;j++) fx<<C8[i][j]<<"\t";
 
        fx<<"\r\n";
    }
}
functions.cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
#include "proto.h"
void matrix(int**&M,int Row,int Column) //ініціалізація квадратної матриці
{
    M=new int*[Row];
    for(int i=0;i<Row;i++)
        M[i] = new int[Column];
}
void number(int**&Numb) //ініціалізація квадратної матриці
{
    Numb=new int*[1];
    for(int i=0;i<1;i++)
        Numb[i] = new int[1];
}
 
void Send_Matrix(int Row,int Column,int**&matrix,int proc_rank)
{
    for(int i=0;i<Row;i++)
    {
        MPI_Send(&(matrix[i][0]), Column, MPI_FLOAT,proc_rank,0,MPI_COMM_WORLD);
    }
}
void Send_Number(int**&number,int proc_rank)
{
    MPI_Send(&(number[0][0]), 1, MPI_FLOAT,proc_rank,0,MPI_COMM_WORLD);
}
 
 
 
void Recive_Matrix(int Row,int Column,int**&matrix1,int proc_rank,MPI_Status &status)
{
    matrix(matrix1, Row, Column);
    for(int i=0;i<Row;i++)
    {
        MPI_Recv(&(matrix1[i][0]), Column, MPI_FLOAT, proc_rank, 0, MPI_COMM_WORLD, &status);
    }
}
void Recive_Number(int**&numb,int proc_rank,MPI_Status &status)
{
    number(numb);
    MPI_Recv(&(numb[0][0]), 1, MPI_FLOAT, proc_rank, 0, MPI_COMM_WORLD, &status);
}
 
//test:
 
 
void Send_MatrixA12(int**&matrix,int proc_rank)
{
    for(int i=0;i<15;i++)
    {
        MPI_Send(&(matrix[i][0]), 154, MPI_FLOAT,proc_rank,0,MPI_COMM_WORLD);
    }
}
 
void Send_MatrixA3_8(int**&matrix,int proc_rank)
{
    for(int i=0;i<15;i++)
    {
        MPI_Send(&(matrix[i][0]), 154, MPI_FLOAT,proc_rank,0,MPI_COMM_WORLD);
    }
}
 
void Send_MatrixB123(int**&matrix,int proc_rank)
{
    for(int i=0;i<154;i++)
    {
        MPI_Send(&(matrix[i][0]), 9, MPI_FLOAT,proc_rank,0,MPI_COMM_WORLD);
    }
}
 
void Send_MatrixB4_8(int**&matrix,int proc_rank)
{
    for(int i=0;i<154;i++)
    {
        MPI_Send(&(matrix[i][0]), 10, MPI_FLOAT,proc_rank,0,MPI_COMM_WORLD);
    }
}
 
 
void Recive_MatrixA12(int**&matrix1,int proc_rank,MPI_Status &status)
{
    matrix(matrix1, 15, 154);
    for(int i=0;i<15;i++)
    {
        MPI_Recv(&(matrix1[i][0]), 154, MPI_FLOAT, proc_rank, 0, MPI_COMM_WORLD, &status);
    }
}
void Recive_MatrixA3_8(int**&matrix1,int proc_rank,MPI_Status &status)
{
    matrix(matrix1, 15, 154);
    for(int i=0;i<15;i++)
    {
        MPI_Recv(&(matrix1[i][0]), 154, MPI_FLOAT, proc_rank, 0, MPI_COMM_WORLD, &status);
    }
}
void Recive_MatrixB123(int**&matrix1,int proc_rank,MPI_Status &status)
{
    matrix(matrix1, 154, 9);
    for(int i=0;i<154;i++)
    {
        MPI_Recv(&(matrix1[i][0]), 9, MPI_FLOAT, proc_rank, 0, MPI_COMM_WORLD, &status);
    }
}
void Recive_MatrixB4_8(int**&matrix1,int proc_rank,MPI_Status &status)
{
    matrix(matrix1, 154, 10);
    for(int i=0;i<154;i++)
    {
        MPI_Recv(&(matrix1[i][0]), 10, MPI_FLOAT, proc_rank, 0, MPI_COMM_WORLD, &status);
    }
}
 
void SendRecive_Matrix(int**&SendM,int out_i,int out_j,int to_CPU,int**&ReciveM,int in_i,int in_j,int from_CPU,MPI_Status &status)
{
    for(int i=0;i<out_i;i++)
    {
        MPI_Sendrecv(&(SendM[i][0]), out_j, MPI_FLOAT,to_CPU,0,&(ReciveM[i][0]), in_j,MPI_INT,from_CPU,0,MPI_COMM_WORLD,&status);
    }
}
input.cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
#include "proto.h"
 
ofstream fio;
 
void Read_Matrix_A(int **&A1,int **&A2,int **&A3,int **&A4,int **&A5,
                   int **&A6,int **&A7,int **&A8)
{
    ifstream file1("E:\\MEMORY.txt");
    int iteration=0;
    char str[2000]; 
    file1.getline(str, sizeof(str)); // read line Matrix A....
    int ind_i=0;
    while (!file1.eof())
    {
        file1.getline(str, sizeof(str));
        char *pw;
        if(iteration<15)//A1 (15x154)
        {
            pw = strtok (str, "\t");
            int ind_j=0;
            while(pw !=NULL)
            {
                A1[iteration][ind_j] = atoi(pw);
                ind_j++;
                pw = strtok (NULL, "\t");
            }
 
        }
        else if(iteration>14 && iteration<30)//A2 (15x154)
        {
            pw = strtok (str, "\t");
            int ind_j=0;
            while(pw !=NULL)
            {
                A2[iteration-15][ind_j] = atoi(pw);
                ind_j++;
                pw = strtok (NULL, "\t");
            }
        }
        else if(iteration>29 && iteration<45)//A3 (15x154)
        {
            pw = strtok (str, "\t");
            int ind_j=0;
            while(pw !=NULL)
            {
                A3[iteration-30][ind_j] = atoi(pw);
                ind_j++;
                pw = strtok (NULL, "\t");
            }
        }
        else if(iteration>44 && iteration<60)//A4 (15x154)
        {
            pw = strtok (str, "\t");
            int ind_j=0;
            while(pw !=NULL)
            {
                A4[iteration-45][ind_j] = atoi(pw);
                ind_j++;
                pw = strtok (NULL, "\t");
            }
        }
        else if(iteration>59 && iteration<75)//A5 (15x154)
        {
            pw = strtok (str, "\t");
            int ind_j=0;
            while(pw !=NULL)
            {
                A5[iteration-60][ind_j] = atoi(pw);
                ind_j++;
                pw = strtok (NULL, "\t");
            }
        }
        else if(iteration>74 && iteration<90)//A6 (15x154)
        {
            pw = strtok (str, "\t");
            int ind_j=0;
            while(pw !=NULL)
            {
                A6[iteration-75][ind_j] = atoi(pw);
                ind_j++;
                pw = strtok (NULL, "\t");
            }
        }
        else if(iteration>89 && iteration<105)//A7 (15x154)
        {
            pw = strtok (str, "\t");
            int ind_j=0;
            while(pw !=NULL)
            {
                A7[iteration-90][ind_j] = atoi(pw);
                ind_j++;
                pw = strtok (NULL, "\t");
            }
        }
        else if(iteration>104 && iteration<120)//A8 (15x154)
        {
            pw = strtok (str, "\t");
            int ind_j=0;
            while(pw !=NULL)
            {
                A8[iteration-105][ind_j] = atoi(pw);
                ind_j++;
                pw = strtok (NULL, "\t");
            }
        }
        else break;
        iteration++;
    }
    file1.close();
}
 
void Read_Matrix_B(int **&B1,int **&B2,int **&B3,int **&B4,int **&B5,
                   int **&B6,int **&B7,int **&B8)
{
    ifstream file1("E:\\MEMORY.txt");
    char str[20000];
    for(int i=0;i<122;i++) /////////////???????
        file1.getline(str, sizeof(str)); // goto line Matrix B....
    int ind_i=0;
    while (!file1.eof())
    {
        if(ind_i==154)break;//вся матриця B прочитана 
        file1.getline(str, sizeof(str));
        char *pw;
        pw = strtok (str, "\t");
        int ind_j=0;
        while(pw !=NULL)
        {
            if(ind_j<9)
            {
                B1[ind_i][ind_j] = atoi(pw);
                ind_j++;
                pw = strtok (NULL, "\t");
            }
            else if(ind_j>8 && ind_j<18)
            {
                B2[ind_i][ind_j-9] = atoi(pw);
                ind_j++;
                pw = strtok (NULL, "\t");
            }
            else if(ind_j>17 && ind_j<27)
            {
                B3[ind_i][ind_j-18] = atoi(pw);
                ind_j++;
                pw = strtok (NULL, "\t");
            }
            else if(ind_j>26 && ind_j<36)
            {
                B4[ind_i][ind_j-27] = atoi(pw);
                ind_j++;
                pw = strtok (NULL, "\t");
            }
            else if(ind_j>35 && ind_j<45)
            {
                B5[ind_i][ind_j-36] = atoi(pw);
                ind_j++;
                pw = strtok (NULL, "\t");
            }
            else if(ind_j>44 && ind_j<54)
            {
                B6[ind_i][ind_j-45] = atoi(pw);
                ind_j++;
                pw = strtok (NULL, "\t");
            }
            else if(ind_j>53 && ind_j<63)
            {
                B7[ind_i][ind_j-54] = atoi(pw);
                ind_j++;
                pw = strtok (NULL, "\t");
            }
            else if(ind_j>62 && ind_j<73)
            {
                B8[ind_i][ind_j-63] = atoi(pw);
                ind_j++;
                pw = strtok (NULL, "\t");
            }
            else break;
        }
        ind_i++;
    }
    file1.close();
}
 
void Generate_Matrix_A_and_B(int offset)
{
    srand(time(NULL));
    //A
    fio.open ("E:\\MEMORY.txt",std::ofstream::out);
    fio << "Matrix A(120x154)"<<" : \r\n";
    for(int i=0;i<120;i++)
    {
        for(int j=0;j<154;j++)
        {
            fio <<(rand()%offset+1)<<"\t";
        }
        fio<<"\r\n";
    }
    //B
    fio << "Matrix B(154x73)"<<" : \r\n";
    for(int i=0;i<154;i++)
    {
        for(int j=0;j<73;j++)
        {
            fio <<(rand()%offset+1)<<"\t";
        }
        fio<<"\r\n";
    }
 
    fio.close();
}
main.cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
#include "proto.h"
//main
int main(int argc,char *argv[])
{
    //видалення файлів попередньої сесії, якщо такі існують
    remove( "E:\\1.txt" );
    remove( "E:\\2.txt" );
    remove( "E:\\3.txt" );
    remove( "E:\\4.txt" );
    remove( "E:\\5.txt" );
    remove( "E:\\6.txt" );
    remove( "E:\\7.txt" );
    remove( "E:\\8.txt" );
    remove( "E:\\time_CPU1.txt" );
    remove( "E:\\time_CPU2.txt" );
    remove( "E:\\time_CPU3.txt" );
    remove( "E:\\time_CPU4.txt" );
    remove( "E:\\time_CPU5.txt" );
    remove( "E:\\time_CPU6.txt" );
    remove( "E:\\time_CPU7.txt" );
    remove( "E:\\time_CPU8.txt" );
    remove( "E:\\Total time.txt" );
    remove( "E:\\Total.txt" );
    
setlocale(LC_ALL," ");
    int procCnt=0,procNumb;
    //timer
    double starttime, endtime;
 
    MPI_Init(&argc, &argv); /*START MPI */
    MPI_Comm_size(MPI_COMM_WORLD, &procCnt);
    MPI_Comm_rank(MPI_COMM_WORLD, &procNumb);
 
    if(procNumb==0)
    {
    starttime = MPI_Wtime();
        //послідовний код генерації матриць А та В
    char selector=' ';
    cout<<"Generate Matrix A and B? [y|n]"<<"\t";
    cin>>selector;
        if(selector=='y' || selector=='Y')
        {
            int offset=0;
            cout<<"Enter offset of random elements = ";
            cin>>offset;
            Generate_Matrix_A_and_B(offset);
        }
        else if(selector=='n' || selector=='N')
        {
            cout<<"O K A Y...Please, waiting...."<<endl;
        }
        else 
            cout<<"E R R O R : Please enter symbol [y] or [n]\t";
        CPU_1();
            cout<<"Thank you for waiting...Good Luck!"<<endl;
            cout<<"Now, you can view all results in the TXT-files...."<<endl;
    }
    else if(procNumb==1)
    {
        CPU_2();
    } 
    else if(procNumb==2)
    {
        CPU_3();
    } 
    else if(procNumb==3)
    {
        CPU_4();
    } 
    else if(procNumb==4)
    {
        CPU_5();
    } 
    else if(procNumb==5)
    {
        CPU_6();
    } 
    else if(procNumb==6)
    {
        CPU_7();
    } 
    else if(procNumb==7)
    {
        CPU_8();
        endtime = MPI_Wtime();
    Write_Time(0,(endtime-starttime),"step of Store");
    } 
 
    MPI_Finalize();  /* EXIT MPI */
}
operations.cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
#include "proto.h"
 
int ** dobytok_2_matruc(int** A,int RowA,int** B,int ColumnB, int ColA_RowB)
{
    int tmp=0;
    int** result;
    matrix(result,RowA,ColumnB);
 
    for(int k=0;k<RowA;k++)
    {
        for(int l =0;l<ColumnB;l++)
        {
            for(int s=0;s<ColA_RowB;s++)
                tmp+=A[k][s]*B[s][l];
            result[k][l] = tmp;
            tmp=0;
        }
    }
 
    return result;//повертає матрицю (RowA x ColumnB)
}
 
void Copy_Matrix(int **&To,int **&From,int Rows,int Columns)
{
 for(int i=0;i<Rows;i++)
 {
  for(int j=0;j<Columns;j++)
  {
   To[i][j] = From[i][j];
  }
 }
}
 
void Write_Time(int step,double time,char* message)
{
 ofstream f0,f1,f2,f3,f4,f5,f6,f7,f8;
 switch(step)
 {
 case 0: f0.open("E:\\Total time.txt",std::ofstream::out | std::ofstream::app);
   f0<<"All time for program = "<<time<<"\r\n";
   f0.close();
   break;
 case 1: f1.open("E:\\time_CPU1.txt",std::ofstream::out | std::ofstream::app);
   f1<<message<<" = "<<time<<"\r\n";
   f1.close();
   break;
 case 2: f2.open("E:\\time_CPU2.txt",std::ofstream::out | std::ofstream::app);
   f2<<message<<" = "<<time<<"\r\n";
   f2.close();
   break;
 case 3: f3.open("E:\\time_CPU3.txt",std::ofstream::out | std::ofstream::app);
   f3<<message<<" = "<<time<<"\r\n";
   f3.close();
   break;
 case 4: f4.open("E:\\time_CPU4.txt",std::ofstream::out | std::ofstream::app);
   f4<<message<<" = "<<time<<"\r\n";
   f4.close();
   break;
 case 5: f5.open("E:\\time_CPU5.txt",std::ofstream::out | std::ofstream::app);
   f5<<message<<" = "<<time<<"\r\n";
   f5.close();
   break;
 case 6: f6.open("E:\\time_CPU6.txt",std::ofstream::out | std::ofstream::app);
   f6<<message<<" = "<<time<<"\r\n";
   f6.close();
   break;
 case 7: f7.open("E:\\time_CPU7.txt",std::ofstream::out | std::ofstream::app);
   f7<<message<<" = "<<time<<"\r\n";
   f7.close();
   break;
 case 8: f8.open("E:\\time_CPU8.txt",std::ofstream::out | std::ofstream::app);
   f8<<message<<" = "<<time<<"\r\n";
   f8.close();
   break;
 default: exit(999);break;
 }
}
CPU1.cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
#include "proto.h"
ofstream f1;
void CPU_1()
{
    MPI_Status Status1;
    int **sync;
    number(sync);
    sync[0][0]=1;
    int **A1, **Bx;
    matrix(A1,15,154);
    matrix(Bx,154,10);
    //timer
    double starttime, endtime, endtimeZ, endtimeO, endtimeV;
    starttime = MPI_Wtime();
    
    //Завантаження матриць A1 і B1 на 1 процесор
    Read_Matrix_A(A1,1);
    write_to_file(f1,A1,15,154,CPU1,"A1");
    Read_Matrix_B(Bx,1);
    write_to_file(f1,Bx,154,9,CPU1,"B1");
    Send_Number(sync,CPU2);
 
    //timer
    endtimeZ = MPI_Wtime();
    Write_Time(1,(endtimeZ-starttime),"step of Load");
    //Для переходу на інший етап виконання програми виконаємо синхронізацію
    MPI_Barrier(MPI_COMM_WORLD);
    endtimeZ = MPI_Wtime();
 
    int rozmir_B[8] = {9,9,9,9,9,9,9,10};
    int rozmir_otherB[8] = {9,9,9,9,9,10,9,9};
    int porjadok[8] = {1,2,3,4,5,6,7,8};
    int **C11,**C12,**C13,**C14,**C15,**C16,**C17,**C18;
    matrix(C11,15,9);
    matrix(C12,15,9);
    matrix(C13,15,9);
    matrix(C14,15,9);
    matrix(C15,15,9);
    matrix(C16,15,9);
    matrix(C17,15,9);
    matrix(C18,15,10);
    
    //Обрахунок
    for(int krok=0;krok<8;krok++)
    {   
        /*
        * 1. ----ПРОЦЕС МНОЖЕННЯ ТА ДОДАВАННЯ----
        */
        switch(krok)
        {
        case 0: C11 = dobytok_2_matruc(A1,15,Bx,rozmir_B[krok],154);
            write_to_file(f1,C11,15,rozmir_B[krok],CPU1,"Operation: A1 * B1 = C11. Than C11");
            break;
        case 1: C12 = dobytok_2_matruc(A1,15,Bx,rozmir_B[krok],154); 
            write_to_file(f1,C12,15,rozmir_B[krok],CPU1,"Operation: A1 * B2 = C12. Than C12");
            break;
        case 2: C13 = dobytok_2_matruc(A1,15,Bx,rozmir_B[krok],154); 
            write_to_file(f1,C13,15,rozmir_B[krok],CPU1,"Operation: A1 * B3 = C13. Than C13");
            break;
        case 3: C14 = dobytok_2_matruc(A1,15,Bx,rozmir_B[krok],154);
            write_to_file(f1,C14,15,rozmir_B[krok],CPU1,"Operation: A1 * B4 = C14. Than C14");
            break;
        case 4: C15 = dobytok_2_matruc(A1,15,Bx,rozmir_B[krok],154); 
            write_to_file(f1,C15,15,rozmir_B[krok],CPU1,"Operation: A1 * B5 = C15. Than C15");
            break;
        case 5: C16 = dobytok_2_matruc(A1,15,Bx,rozmir_B[krok],154); 
            write_to_file(f1,C16,15,rozmir_B[krok],CPU1,"Operation: A1 * B6 = C16. Than C16");
            break;
        case 6: C17 = dobytok_2_matruc(A1,15,Bx,rozmir_B[krok],154); 
            write_to_file(f1,C17,15,rozmir_B[krok],CPU1,"Operation: A1 * B7 = C17. Than C17");
            break;
        case 7: C18 = dobytok_2_matruc(A1,15,Bx,rozmir_B[krok],154); 
            write_to_file(f1,C18,15,rozmir_B[krok],CPU1,"Operation: A1 * B8 = C9. Than C18");
            break;
        }
 
        MPI_Barrier(MPI_COMM_WORLD);
 
        /*
        *  ----ПРОЦЕС ПЕРЕСИЛАННЯ----
        */
        if(krok<7)
        {
            int ** otherB;
            matrix(otherB,154,10);
            SendRecive_Matrix(Bx,154,rozmir_B[krok],CPU2,otherB,154,rozmir_otherB[krok],CPU3,Status1);
            /**  ----2 етап ПЕРЕСИЛАННЯ----*/
            SendRecive_Matrix(otherB,154,rozmir_otherB[krok],CPU2,Bx,154,rozmir_B[krok+1],CPU8,Status1);
            char comment[30] = { NULL };
            strcpy(comment,MakeComent(porjadok[krok+1],15)); ///////////???
            write_to_file(f1,Bx,154,rozmir_B[krok+1],CPU1,comment);
            MPI_Barrier(MPI_COMM_WORLD);
        }
    }
    //timer
    endtimeO = MPI_Wtime();
    Write_Time(1,(endtimeO-endtimeZ),"step of Calculation");
    MPI_Barrier(MPI_COMM_WORLD);
    endtimeO = MPI_Wtime();
 
    /*
    *  ----ПРОЦЕС ВИВАНТАЖЕННЯ----
    */
    Save_in_mem(C11,9,C12,9,C13,9,C14,9,C15,9,C16,9,C17,9,C18,10,15); ////////??
    //timer
    endtimeV = MPI_Wtime();
    Write_Time(1,(endtimeV-endtimeO),"step of Store");
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
}
CPU2.cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
#include "proto.h"
ofstream f2;
void CPU_2()
{
    MPI_Status Status1;
    int **sync;
    number(sync);
    sync[0][0]=1;
    int **A2, **Bx;
    matrix(A2,15,154);
    matrix(Bx,154,10);
    //timer
    double starttime, endtime, endtimeZ, endtimeO, endtimeV;
    starttime = MPI_Wtime();
    //Завантаження матриць A2 і B2 на 2 процесор
    Recive_Number(sync,CPU1,Status1);
    Read_Matrix_A(A2,2);
    write_to_file(f2,A2,15,154,CPU2,"A2");
    Read_Matrix_B(Bx,2);
    write_to_file(f2,Bx,154,9,CPU2,"B2");
    Send_Number(sync,CPU3);
 
    //timer
    endtimeZ = MPI_Wtime();
    Write_Time(2,(endtimeZ-starttime),"step of Load");
    //Для переходу на інший етап виконання програми виконаємо синхронізацію
    MPI_Barrier(MPI_COMM_WORLD);
    endtimeZ = MPI_Wtime();
 
    int rozmir_B[8] = {9,9,9,9,9,9,10,9};
    int rozmir_otherB[8] = {9,9,9,9,9,9,9,10};
    int porjadok[8] = {2,3,4,5,6,7,8,1};
    int **C21,**C22,**C23,**C24,**C25,**C26,**C27,**C28;
    matrix(C21,15,9);
    matrix(C22,15,9);
    matrix(C23,15,9);
    matrix(C24,15,9);
    matrix(C25,15,9);
    matrix(C26,15,9);
    matrix(C27,15,9);
    matrix(C28,15,10);
    //Обрахунок
    for(int krok=0;krok<8;krok++)
    {
 
        /*
        * 1. ----ПРОЦЕС МНОЖЕННЯ ТА ДОДАВАННЯ----
        */
        switch(krok)
        {
        case 0: C22 = dobytok_2_matruc(A2,15,Bx,rozmir_B[krok],154);
            write_to_file(f2,C22,15,rozmir_B[krok],CPU2,"Operation: A2 * B2 = C22. Than C22");
            break;
        case 1: C23 = dobytok_2_matruc(A2,15,Bx,rozmir_B[krok],154); 
            write_to_file(f2,C23,15,rozmir_B[krok],CPU2,"Operation: A2 * B3 = C23. Than C23");
            break;
        case 2: C24 = dobytok_2_matruc(A2,15,Bx,rozmir_B[krok],154); 
            write_to_file(f2,C24,15,rozmir_B[krok],CPU2,"Operation: A2 * B4 = C24. Than C24");
            break;
        case 3: C25 = dobytok_2_matruc(A2,15,Bx,rozmir_B[krok],154);
            write_to_file(f2,C25,15,rozmir_B[krok],CPU2,"Operation: A2 * B5 = C25. Than C25");
            break;
        case 4: C26 = dobytok_2_matruc(A2,15,Bx,rozmir_B[krok],154); 
            write_to_file(f2,C26,15,rozmir_B[krok],CPU2,"Operation: A2 * B6 = C26. Than C26");
            break;
        case 5: C27 = dobytok_2_matruc(A2,15,Bx,rozmir_B[krok],154); 
            write_to_file(f2,C27,15,rozmir_B[krok],CPU2,"Operation: A2 * B7 = C27. Than C27");
            break;
        case 6: C28 = dobytok_2_matruc(A2,15,Bx,rozmir_B[krok],154); 
            write_to_file(f2,C28,15,rozmir_B[krok],CPU2,"Operation: A2 * B8 = C28. Than C28");
            break;
        case 7: C21 = dobytok_2_matruc(A2,15,Bx,rozmir_B[krok],154); 
            write_to_file(f2,C21,15,rozmir_B[krok],CPU2,"Operation: A2 * B1 = C21. Than C21");
            break;
        }
        MPI_Barrier(MPI_COMM_WORLD);
        /*
        *  ----ПРОЦЕС ПЕРЕСИЛАННЯ----
        */
        if(krok<7)
        {
            int ** otherB;
            matrix(otherB,154,10);
            SendRecive_Matrix(Bx,154,rozmir_B[krok],CPU8,otherB,154,rozmir_otherB[krok],CPU1,Status1);
            /**  ----2 етап ПЕРЕСИЛАННЯ----*/
            SendRecive_Matrix(otherB,154,rozmir_otherB[krok],CPU8,Bx,154,rozmir_B[krok+1],CPU1,Status1);
            char comment[30] = { NULL };
            strcpy(comment,MakeComent(porjadok[krok+1],1));
            write_to_file(f2,Bx,154,rozmir_B[krok+1],CPU2,comment);
            MPI_Barrier(MPI_COMM_WORLD);
        }
        //Для переходу на інший етап виконання програми виконаємо синхронізацію
        
    }
 
    //timer
    endtimeO = MPI_Wtime();
    Write_Time(2,(endtimeO-endtimeZ),"step of Calculation");
    MPI_Barrier(MPI_COMM_WORLD);
    endtimeO = MPI_Wtime();
    /*
    *  ----ПРОЦЕС ВИВАНТАЖЕННЯ----
    */
    MPI_Barrier(MPI_COMM_WORLD);
    Save_in_mem(C21,9,C22,9,C23,9,C24,9,C25,9,C26,9,C27,9,C28,10,15);
    //timer
    endtimeV = MPI_Wtime();
    Write_Time(2,(endtimeV-endtimeO),"step of Store");
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
}
CPU3.cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
#include "proto.h"
ofstream f3;
void CPU_3()
{
    MPI_Status Status1;
    int **sync;
    number(sync);
    sync[0][0]=1;
    int **A3, **Bx;
    matrix(A3,15,154);
    matrix(Bx,154,10);
    //timer
    double starttime, endtime, endtimeZ, endtimeO, endtimeV;
    starttime = MPI_Wtime();
    //Завантаження матриць A3 і B3 на 3 процесор
    Recive_Number(sync,CPU2,Status1);
    Read_Matrix_A(A3,3);
    write_to_file(f3,A3,15,154,CPU3,"A3");
    Read_Matrix_B(Bx,3);
    write_to_file(f3,Bx,154,9,CPU3,"B3");
    Send_Number(sync,CPU4);
 
    //timer
    endtimeZ = MPI_Wtime();
    Write_Time(3,(endtimeZ-starttime),"step of Load");
    //Для переходу на інший етап виконання програми виконаємо синхронізацію
    MPI_Barrier(MPI_COMM_WORLD);
    endtimeZ = MPI_Wtime();
 
    int rozmir_B[8] = {9,9,9,9,9,10,9,9};
    int porjadok[8] = {3,4,5,6,7,8,1,2};
    int **C31,**C32,**C33,**C34,**C35,**C36,**C37,**C38;
    matrix(C31,15,9);
    matrix(C32,15,9);
    matrix(C33,15,9);
    matrix(C34,15,9);
    matrix(C35,15,9);
    matrix(C36,15,9);
    matrix(C37,15,9);
    matrix(C38,15,10);
    //Обрахунок
    for(int krok=0;krok<8;krok++)
    {
 
        /*
        * 1. ----ПРОЦЕС МНОЖЕННЯ ТА ДОДАВАННЯ----
        */
        switch(krok)
        {
        case 0: C33 = dobytok_2_matruc(A3,15,Bx,rozmir_B[krok],154);
            write_to_file(f3,C33,15,rozmir_B[krok],CPU3,"Operation: A3 * B3 = C33. Than C33");
            break;
        case 1: C34 = dobytok_2_matruc(A3,15,Bx,rozmir_B[krok],154); 
            write_to_file(f3,C34,15,rozmir_B[krok],CPU3,"Operation: A3 * B4 = C34. Than C34");
            break;
        case 2: C35 = dobytok_2_matruc(A3,15,Bx,rozmir_B[krok],154); 
            write_to_file(f3,C35,15,rozmir_B[krok],CPU3,"Operation: A3 * B5 = C35. Than C35");
            break;
        case 3: C36 = dobytok_2_matruc(A3,15,Bx,rozmir_B[krok],154);
            write_to_file(f3,C36,15,rozmir_B[krok],CPU3,"Operation: A3 * B6 = C36. Than C36");
            break;
        case 4: C37 = dobytok_2_matruc(A3,15,Bx,rozmir_B[krok],154); 
            write_to_file(f3,C37,15,rozmir_B[krok],CPU3,"Operation: A3 * B7 = C37. Than C37");
            break;
        case 5: C38 = dobytok_2_matruc(A3,15,Bx,rozmir_B[krok],154); 
            write_to_file(f3,C38,15,rozmir_B[krok],CPU3,"Operation: A3 * B8 = C38. Than C38");
            break;
        case 6: C31 = dobytok_2_matruc(A3,15,Bx,rozmir_B[krok],154); 
            write_to_file(f3,C31,15,rozmir_B[krok],CPU3,"Operation: A3 * B1 = C31. Than C31");
            break;
        case 7: C32 = dobytok_2_matruc(A3,15,Bx,rozmir_B[krok],154); 
            write_to_file(f3,C32,15,rozmir_B[krok],CPU3,"Operation: A3 * B2 = C32. Than C32");
            break;
        }
        MPI_Barrier(MPI_COMM_WORLD);
        /*
        *  ----ПРОЦЕС ПЕРЕСИЛАННЯ----
        */
        if(krok<7)
        {
            int ** otherB;
            matrix(otherB,154,10);
            SendRecive_Matrix(Bx,154,rozmir_B[krok],CPU1,otherB,154,rozmir_B[krok+1],CPU4,Status1);
            Copy_Matrix(Bx,otherB,154,rozmir_B[krok+1]);
            char comment[30] = { NULL };
            strcpy(comment,MakeComent(porjadok[krok+1],4));
            write_to_file(f3,Bx,154,rozmir_B[krok+1],CPU3,comment);
            MPI_Barrier(MPI_COMM_WORLD);
        }
        //Для переходу на інший етап виконання програми виконаємо синхронізацію
        
    }
 
    //timer
    endtimeO = MPI_Wtime();
    Write_Time(3,(endtimeO-endtimeZ),"step of Calculation");
    MPI_Barrier(MPI_COMM_WORLD);
    endtimeO = MPI_Wtime();
    /*
    *  ----ПРОЦЕС ВИВАНТАЖЕННЯ----
    */
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    Save_in_mem(C31,9,C32,9,C33,9,C34,9,C35,9,C36,9,C37,9,C38,10,15);
    //timer
    endtimeV = MPI_Wtime();
    Write_Time(3,(endtimeV-endtimeO),"step of Store");
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
}
CPU4.cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
#include "proto.h"
ofstream f4;
void CPU_4()
{
    MPI_Status Status1;
    int **sync;
    number(sync);
    sync[0][0]=1;
    int **A4, **Bx;
    matrix(A4,15,154);
    matrix(Bx,154,10);
    //timer
    double starttime, endtime, endtimeZ, endtimeO, endtimeV;
    starttime = MPI_Wtime();
    //Завантаження матриць A4 і B4 на 4 процесор
    Recive_Number(sync,CPU3,Status1);
    Read_Matrix_A(A4,4);
    write_to_file(f4,A4,15,154,CPU4,"A4");
    Read_Matrix_B(Bx,4);
    write_to_file(f4,Bx,154,9,CPU4,"B4");
    Send_Number(sync,CPU5);
 
    //timer
    endtimeZ = MPI_Wtime();
    Write_Time(4,(endtimeZ-starttime),"step of Load");
    //Для переходу на інший етап виконання програми виконаємо синхронізацію
    MPI_Barrier(MPI_COMM_WORLD);
    endtimeZ = MPI_Wtime();
 
    int rozmir_B[8] = {9,9,9,9,10,9,9,9};
    int rozmir_otherB[8] = {9,10,9,9,9,9,9,9};
    int porjadok[8] = {4,5,6,7,8,1,2,3};
    int **C41,**C42,**C43,**C44,**C45,**C46,**C47,**C48;
    matrix(C41,15,9);
    matrix(C42,15,9);
    matrix(C43,15,9);
    matrix(C44,15,9);
    matrix(C45,15,9);
    matrix(C46,15,9);
    matrix(C47,15,9);
    matrix(C48,15,10);
    //Обрахунок
    for(int krok=0;krok<8;krok++)
    {
 
        /*
  * 1. ----ПРОЦЕС МНОЖЕННЯ ТА ДОДАВАННЯ----
  */
  switch(krok)
  {
  case 0: C44 = dobytok_2_matruc(A4,15,Bx,rozmir_B[krok],154);
   write_to_file(f4,C44,15,rozmir_B[krok],CPU4,"Operation: A4 * B4 = C44. Than C44");
   break;
  case 1: C45 = dobytok_2_matruc(A4,15,Bx,rozmir_B[krok],154); 
   write_to_file(f4,C45,15,rozmir_B[krok],CPU4,"Operation: A4 * B5 = C45. Than C45");
   break;
  case 2: C46 = dobytok_2_matruc(A4,15,Bx,rozmir_B[krok],154); 
   write_to_file(f4,C46,15,rozmir_B[krok],CPU4,"Operation: A4 * B6 = C46. Than C46");
   break;
  case 3: C47 = dobytok_2_matruc(A4,15,Bx,rozmir_B[krok],154);
   write_to_file(f4,C47,15,rozmir_B[krok],CPU4,"Operation: A4 * B7 = C47. Than C47");
   break;
  case 4: C48 = dobytok_2_matruc(A4,15,Bx,rozmir_B[krok],154); 
   write_to_file(f4,C48,15,rozmir_B[krok],CPU4,"Operation: A4 * B8 = C48. Than C48");
   break;
  case 5: C41 = dobytok_2_matruc(A4,15,Bx,rozmir_B[krok],154); 
   write_to_file(f4,C41,15,rozmir_B[krok],CPU4,"Operation: A4 * B1 = C41. Than C41");
   break;
  case 6: C42 = dobytok_2_matruc(A4,15,Bx,rozmir_B[krok],154); 
   write_to_file(f4,C42,15,rozmir_B[krok],CPU4,"Operation: A4 * B2 = C42. Than C42");
   break;
  case 7: C43 = dobytok_2_matruc(A4,15,Bx,rozmir_B[krok],154); 
   write_to_file(f4,C43,15,rozmir_B[krok],CPU4,"Operation: A4 * B3 = C43. Than C43");
   break;
  }
  MPI_Barrier(MPI_COMM_WORLD);
        /*
        *  ----ПРОЦЕС ПЕРЕСИЛАННЯ----
        */
        if(krok<7)
        {
            int ** otherB;
            matrix(otherB,154,10);
            SendRecive_Matrix(Bx,154,rozmir_B[krok],CPU3,otherB,154,rozmir_otherB[krok],CPU7,Status1);
            /**  ----2 етап ПЕРЕСИЛАННЯ----*/
            SendRecive_Matrix(otherB,154,rozmir_otherB[krok],CPU6,Bx,154,rozmir_B[krok+1],CPU5,Status1);
            char comment[30] = { NULL };
            strcpy(comment,MakeComent(porjadok[krok+1],5));
            write_to_file(f4,Bx,154,rozmir_B[krok+1],CPU4,comment);
                MPI_Barrier(MPI_COMM_WORLD);
        }       
    }
 
    //timer
    endtimeO = MPI_Wtime();
    Write_Time(4,(endtimeO-endtimeZ),"step of Calculation");
    MPI_Barrier(MPI_COMM_WORLD);
    endtimeO = MPI_Wtime();
    /*
    *  ----ПРОЦЕС ВИВАНТАЖЕННЯ----
    */
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    Save_in_mem(C41,9,C42,9,C43,9,C44,9,C45,9,C46,9,C47,9,C48,10,15);
    //timer
    endtimeV = MPI_Wtime();
    Write_Time(4,(endtimeV-endtimeO),"step of Store");
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
}
CPU5.cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
#include "proto.h"
ofstream f5;
void CPU_5()
{
    MPI_Status Status1;
    int **sync;
    number(sync);
    sync[0][0]=1;
    int **A5, **Bx;
    matrix(A5,15,154);
    matrix(Bx,154,10);
    //timer
    double starttime, endtime, endtimeZ, endtimeO, endtimeV;
    starttime = MPI_Wtime();
    //Завантаження матриць A5 і B5 на 5 процесор
    Recive_Number(sync,CPU4,Status1);
    Read_Matrix_A(A5,5);
    write_to_file(f5,A5,15,154,CPU5,"A5");
    Read_Matrix_B(Bx,5);
    write_to_file(f5,Bx,154,9,CPU5,"B5");
    Send_Number(sync,CPU6);
 
    //timer
    endtimeZ = MPI_Wtime();
    Write_Time(5,(endtimeZ-starttime),"step of Load");
    //Для переходу на інший етап виконання програми виконаємо синхронізацію
    MPI_Barrier(MPI_COMM_WORLD);
    endtimeZ = MPI_Wtime();
 
    int rozmir_B[8] = {9,9,9,10,9,9,9,9};
    int porjadok[8] = {5,6,7,8,1,2,3,4};
    int **C51,**C52,**C53,**C54,**C55,**C56,**C57,**C58;
    matrix(C51,15,9);
    matrix(C52,15,9);
    matrix(C53,15,9);
    matrix(C54,15,9);
    matrix(C55,15,9);
    matrix(C56,15,9);
    matrix(C57,15,9);
    matrix(C58,15,10);
    //Обрахунок
    for(int krok=0;krok<8;krok++)
    {
 
        /*
  * 1. ----ПРОЦЕС МНОЖЕННЯ ТА ДОДАВАННЯ----
  */
  switch(krok)
  {
  case 0: C55 = dobytok_2_matruc(A5,15,Bx,rozmir_B[krok],154);
   write_to_file(f5,C55,15,rozmir_B[krok],CPU5,"Operation: A5 * B5 = C55. Than C55");
   break;
  case 1: C56 = dobytok_2_matruc(A5,15,Bx,rozmir_B[krok],154); 
   write_to_file(f5,C56,15,rozmir_B[krok],CPU5,"Operation: A5 * B6 = C56. Than C56");
   break;
  case 2: C57 = dobytok_2_matruc(A5,15,Bx,rozmir_B[krok],154); 
   write_to_file(f5,C57,15,rozmir_B[krok],CPU5,"Operation: A5 * B7 = C57. Than C57");
   break;
  case 3: C58 = dobytok_2_matruc(A5,15,Bx,rozmir_B[krok],154);
   write_to_file(f5,C58,15,rozmir_B[krok],CPU5,"Operation: A5 * B8 = C58. Than C58");
   break;
  case 4: C51 = dobytok_2_matruc(A5,15,Bx,rozmir_B[krok],154); 
   write_to_file(f5,C51,15,rozmir_B[krok],CPU5,"Operation: A5 * B1 = C51. Than C51");
   break;
  case 5: C52 = dobytok_2_matruc(A5,15,Bx,rozmir_B[krok],154); 
   write_to_file(f5,C52,15,rozmir_B[krok],CPU5,"Operation: A5 * B2 = C52. Than C52");
   break;
  case 6: C53 = dobytok_2_matruc(A5,15,Bx,rozmir_B[krok],154); 
   write_to_file(f5,C53,15,rozmir_B[krok],CPU5,"Operation: A5 * B3 = C53. Than C53");
   break;
  case 7: C54 = dobytok_2_matruc(A5,15,Bx,rozmir_B[krok],154); 
   write_to_file(f5,C54,15,rozmir_B[krok],CPU5,"Operation: A5 * B4 = C54. Than C54");
   break;
  }
  MPI_Barrier(MPI_COMM_WORLD);
        /*
        *  ----ПРОЦЕС ПЕРЕСИЛАННЯ----
        */
        if(krok<7)
        {
            int ** otherB;
            matrix(otherB,154,10);
            Recive_Matrix(154,rozmir_B[krok+1],otherB,CPU6,Status1);
            /**  ----2 етап ПЕРЕСИЛАННЯ----*/
            Send_Matrix(154,rozmir_B[krok],Bx,CPU4);
            Copy_Matrix(Bx,otherB,154,rozmir_B[krok+1]);
            char comment[30] = { NULL };
            strcpy(comment,MakeComent(porjadok[krok+1],6));
            write_to_file(f5,Bx,154,rozmir_B[krok+1],CPU5,comment);
            MPI_Barrier(MPI_COMM_WORLD);
        }
        //Для переходу на інший етап виконання програми виконаємо синхронізацію
        
    }
 
    //timer
    endtimeO = MPI_Wtime();
    Write_Time(5,(endtimeO-endtimeZ),"step of Calculation");
    MPI_Barrier(MPI_COMM_WORLD);
    endtimeO = MPI_Wtime();
    /*
    *  ----ПРОЦЕС ВИВАНТАЖЕННЯ----
    */
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    Save_in_mem(C51,9,C52,9,C53,9,C54,9,C55,9,C56,9,C57,9,C58,10,15);
    //timer
    endtimeV = MPI_Wtime();
    Write_Time(5,(endtimeV-endtimeO),"step of Store");
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
}
CPU6.cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
#include "proto.h"
ofstream f6;
void CPU_6()
{
    MPI_Status Status1;
    int **sync;
    number(sync);
    sync[0][0]=1;
    int **A6, **Bx;
    matrix(A6,15,154);
    matrix(Bx,154,10);
    //timer
    double starttime, endtime, endtimeZ, endtimeO, endtimeV;
    starttime = MPI_Wtime();
    //Завантаження матриць A6 і B6 на 6 процесор
    Recive_Number(sync,CPU5,Status1);
    Read_Matrix_A(A6,6);
    write_to_file(f6,A6,15,154,CPU6,"A6");
    Read_Matrix_B(Bx,6);
    write_to_file(f6,Bx,154,9,CPU6,"B6");
    Send_Number(sync,CPU7);
 
    //timer
    endtimeZ = MPI_Wtime();
    Write_Time(6,(endtimeZ-starttime),"step of Load");
    //Для переходу на інший етап виконання програми виконаємо синхронізацію
    MPI_Barrier(MPI_COMM_WORLD);
    endtimeZ = MPI_Wtime();
 
    int rozmir_B[8] = {9,9,10,9,9,9,9,9};
    int porjadok[8] = {6,7,8,1,2,3,4,5};
    int **C61,**C62,**C63,**C64,**C65,**C66,**C67,**C68;
    matrix(C61,15,9);
    matrix(C62,15,9);
    matrix(C63,15,9);
    matrix(C64,15,9);
    matrix(C65,15,9);
    matrix(C66,15,9);
    matrix(C67,15,9);
    matrix(C68,15,10);
    //Обрахунок
    for(int krok=0;krok<8;krok++)
    {
 
        /*
  * 1. ----ПРОЦЕС МНОЖЕННЯ ТА ДОДАВАННЯ----
  */
  switch(krok)
  {
  case 0: C66 = dobytok_2_matruc(A6,15,Bx,rozmir_B[krok],154);
   write_to_file(f6,C66,15,rozmir_B[krok],CPU6,"Operation: A6 * B6 = C66. Than C66");
   break;
  case 1: C67 = dobytok_2_matruc(A6,15,Bx,rozmir_B[krok],154); 
   write_to_file(f6,C67,15,rozmir_B[krok],CPU6,"Operation: A6 * B7 = C67. Than C67");
   break;
  case 2: C68 = dobytok_2_matruc(A6,15,Bx,rozmir_B[krok],154); 
   write_to_file(f6,C68,15,rozmir_B[krok],CPU6,"Operation: A6 * B8 = C68. Than C68");
   break;
  case 3: C61 = dobytok_2_matruc(A6,15,Bx,rozmir_B[krok],154);
   write_to_file(f6,C61,15,rozmir_B[krok],CPU6,"Operation: A6 * B1 = C61. Than C61");
   break;
  case 4: C62 = dobytok_2_matruc(A6,15,Bx,rozmir_B[krok],154); 
   write_to_file(f6,C62,15,rozmir_B[krok],CPU6,"Operation: A6 * B2 = C62. Than C62");
   break;
  case 5: C63 = dobytok_2_matruc(A6,15,Bx,rozmir_B[krok],154); 
   write_to_file(f6,C63,15,rozmir_B[krok],CPU6,"Operation: A6 * B3 = C63. Than C63");
   break;
  case 6: C64 = dobytok_2_matruc(A6,15,Bx,rozmir_B[krok],154); 
   write_to_file(f6,C64,15,rozmir_B[krok],CPU6,"Operation: A6 * B4 = C64. Than C64");
   break;
  case 7: C65 = dobytok_2_matruc(A6,15,Bx,rozmir_B[krok],154); 
   write_to_file(f6,C65,15,rozmir_B[krok],CPU6,"Operation: A6 * B5 = C65. Than C65");
   break;
  }
  MPI_Barrier(MPI_COMM_WORLD);
        /*
        *  ----ПРОЦЕС ПЕРЕСИЛАННЯ----
        */
        if(krok<7)
        {
            Send_Matrix(154,rozmir_B[krok],Bx,CPU5);
            /**  ----2 етап ПЕРЕСИЛАННЯ----*/
            Recive_Matrix(154,rozmir_B[krok+1],Bx,CPU4,Status1);
            char comment[30] = { NULL };
            strcpy(comment,MakeComent(porjadok[krok+1],4));
            write_to_file(f6,Bx,154,rozmir_B[krok+1],CPU6,comment);
            MPI_Barrier(MPI_COMM_WORLD);
        }
    }
 
    //timer
    endtimeO = MPI_Wtime();
    Write_Time(6,(endtimeO-endtimeZ),"step of Calculation");
    MPI_Barrier(MPI_COMM_WORLD);
    endtimeO = MPI_Wtime();
    /*
    *  ----ПРОЦЕС ВИВАНТАЖЕННЯ----
    */
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    Save_in_mem(C61,9,C62,9,C63,9,C64,9,C65,9,C66,9,C67,9,C68,10,15);
    //timer
    endtimeV = MPI_Wtime();
    Write_Time(6,(endtimeV-endtimeO),"step of Store");
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
}
CPU7.cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
#include "proto.h"
ofstream f7;
void CPU_7()
{
    MPI_Status Status1;
    int **sync;
    number(sync);
    sync[0][0]=1;
    int **A7, **Bx;
    matrix(A7,15,154);
    matrix(Bx,154,10);
    //timer
    double starttime, endtime, endtimeZ, endtimeO, endtimeV;
    starttime = MPI_Wtime();
    //Завантаження матриць A7 і B7 на 7 процесор
    Recive_Number(sync,CPU6,Status1);
    Read_Matrix_A(A7,7);
    write_to_file(f7,A7,15,154,CPU7,"A7");
    Read_Matrix_B(Bx,7);
    write_to_file(f7,Bx,154,9,CPU7,"B7");
    Send_Number(sync,CPU8);
 
    //timer
    endtimeZ = MPI_Wtime();
    Write_Time(7,(endtimeZ-starttime),"step of Load");
    //Для переходу на інший етап виконання програми виконаємо синхронізацію
    MPI_Barrier(MPI_COMM_WORLD);
    endtimeZ = MPI_Wtime();
 
    int rozmir_B[8] = {9,10,9,9,9,9,9,9};
    int porjadok[8] = {7,8,1,2,3,4,5,6};
    int **C71,**C72,**C73,**C74,**C75,**C76,**C77,**C78;
    matrix(C71,15,9);
    matrix(C72,15,9);
    matrix(C73,15,9);
    matrix(C74,15,9);
    matrix(C75,15,9);
    matrix(C76,15,9);
    matrix(C77,15,9);
    matrix(C78,15,10);
    //Обрахунок
    for(int krok=0;krok<8;krok++)
    {
 
        /*
  * 1. ----ПРОЦЕС МНОЖЕННЯ ТА ДОДАВАННЯ----
  */
  switch(krok)
  {
  case 0: C77 = dobytok_2_matruc(A7,15,Bx,rozmir_B[krok],154);
   write_to_file(f7,C77,15,rozmir_B[krok],CPU7,"Operation: A7 * B7 = C77. Than C77");
   break;
  case 1: C78 = dobytok_2_matruc(A7,15,Bx,rozmir_B[krok],154); 
   write_to_file(f7,C78,15,rozmir_B[krok],CPU7,"Operation: A7 * B8 = C78. Than C78");
   break;
  case 2: C71 = dobytok_2_matruc(A7,15,Bx,rozmir_B[krok],154); 
   write_to_file(f7,C71,15,rozmir_B[krok],CPU7,"Operation: A7 * B1 = C71. Than C71");
   break;
  case 3: C72 = dobytok_2_matruc(A7,15,Bx,rozmir_B[krok],154);
   write_to_file(f7,C72,15,rozmir_B[krok],CPU7,"Operation: A7 * B2 = C72. Than C72");
   break;
  case 4: C73 = dobytok_2_matruc(A7,15,Bx,rozmir_B[krok],154); 
   write_to_file(f7,C73,15,rozmir_B[krok],CPU7,"Operation: A7 * B3 = C73. Than C73");
   break;
  case 5: C74 = dobytok_2_matruc(A7,15,Bx,rozmir_B[krok],154); 
   write_to_file(f7,C74,15,rozmir_B[krok],CPU7,"Operation: A7 * B4 = C74. Than C74");
   break;
  case 6: C75 = dobytok_2_matruc(A7,15,Bx,rozmir_B[krok],154); 
   write_to_file(f7,C75,15,rozmir_B[krok],CPU7,"Operation: A7 * B5 = C75. Than C75");
   break;
  case 7: C76 = dobytok_2_matruc(A7,15,Bx,rozmir_B[krok],154); 
   write_to_file(f7,C76,15,rozmir_B[krok],CPU7,"Operation: A7 * B6 = C76. Than C76");
   break;
  }
  MPI_Barrier(MPI_COMM_WORLD);
        /*
        *  ----ПРОЦЕС ПЕРЕСИЛАННЯ----
        */
        if(krok<7)
        {
            int ** otherB;
            matrix(otherB,154,10);
            SendRecive_Matrix(Bx,154,rozmir_B[krok],CPU4,otherB,154,rozmir_B[krok+1],CPU8,Status1);
            Copy_Matrix(Bx,otherB,154,rozmir_B[krok+1]);
            char comment[30] = { NULL };
            strcpy(comment,MakeComent(porjadok[krok+1],8));
            write_to_file(f7,Bx,154,rozmir_B[krok+1],CPU7,comment);
            MPI_Barrier(MPI_COMM_WORLD);
        }       
    }
 
    //timer
    endtimeO = MPI_Wtime();
    Write_Time(7,(endtimeO-endtimeZ),"step of Calculation");
    MPI_Barrier(MPI_COMM_WORLD);
    endtimeO = MPI_Wtime();
    /*
    *  ----ПРОЦЕС ВИВАНТАЖЕННЯ----
    */
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    Save_in_mem(C71,9,C72,9,C73,9,C74,9,C75,9,C76,9,C77,9,C78,10,15);
    //timer
    endtimeV = MPI_Wtime();
    Write_Time(7,(endtimeV-endtimeO),"step of Store");
    MPI_Barrier(MPI_COMM_WORLD);
}
CPU8.cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
#include "proto.h"
ofstream f8;
void CPU_8()
{
    MPI_Status Status1;
    int **sync;
    number(sync);
    sync[0][0]=1;
    int **A8, **Bx;
    matrix(A8,15,154);
    matrix(Bx,154,10);
    //timer
    double starttime, endtime, endtimeZ, endtimeO, endtimeV;
    starttime = MPI_Wtime();
    //Завантаження матриць A8 і B8 на 8 процесор
    Recive_Number(sync,CPU7,Status1);
    Read_Matrix_A(A8,8);
    write_to_file(f8,A8,15,154,CPU8,"A8=");
    Read_Matrix_B(Bx,8);
    write_to_file(f8,Bx,154,10,CPU8,"B8=");
 
    //timer
    endtimeZ = MPI_Wtime();
    Write_Time(8,(endtimeZ-starttime),"step of Load");
    //Для переходу на інший етап виконання програми виконаємо синхронізацію
    MPI_Barrier(MPI_COMM_WORLD);
    endtimeZ = MPI_Wtime();
 
    int rozmir_B[8] = {10,9,9,9,9,9,9,9};
    int rozmir_otherB[8] = {9,9,9,9,9,9,10,9};
    int porjadok[8] = {8,1,2,3,4,5,6,7};
    int **C81,**C82,**C83,**C84,**C85,**C86,**C87,**C88;
    matrix(C81,15,9);
    matrix(C82,15,9);
    matrix(C83,15,9);
    matrix(C84,15,9);
    matrix(C85,15,9);
    matrix(C86,15,9);
    matrix(C87,15,9);
    matrix(C88,15,10);
    //Обрахунок
    for(int krok=0;krok<8;krok++)
    {
 
        /*
  * 1. ----ПРОЦЕС МНОЖЕННЯ ТА ДОДАВАННЯ----
  */
  switch(krok)
  {
  case 0: C88 = dobytok_2_matruc(A8,15,Bx,rozmir_B[krok],154);
   write_to_file(f8,C88,15,rozmir_B[krok],CPU8,"Operation: A8 * B8 = C88. Than C88");
   break;
  case 1: C81 = dobytok_2_matruc(A8,15,Bx,rozmir_B[krok],154); 
   write_to_file(f8,C81,15,rozmir_B[krok],CPU8,"Operation: A8 * B1 = C81. Than C81");
   break;
  case 2: C82 = dobytok_2_matruc(A8,15,Bx,rozmir_B[krok],154); 
   write_to_file(f8,C82,15,rozmir_B[krok],CPU8,"Operation: A8 * B2 = C82. Than C82");
   break;
  case 3: C83 = dobytok_2_matruc(A8,15,Bx,rozmir_B[krok],154);
   write_to_file(f8,C83,15,rozmir_B[krok],CPU8,"Operation: A8 * B3 = C83. Than C83");
   break;
  case 4: C84 = dobytok_2_matruc(A8,15,Bx,rozmir_B[krok],154); 
   write_to_file(f8,C84,15,rozmir_B[krok],CPU8,"Operation: A8 * B4 = C84. Than C84");
   break;
  case 5: C85 = dobytok_2_matruc(A8,15,Bx,rozmir_B[krok],154); 
   write_to_file(f8,C85,15,rozmir_B[krok],CPU8,"Operation: A8 * B5 = C85. Than C85");
   break;
  case 6: C86 = dobytok_2_matruc(A8,15,Bx,rozmir_B[krok],154); 
   write_to_file(f8,C86,15,rozmir_B[krok],CPU8,"Operation: A8 * B6 = C86. Than C86");
   break;
  case 7: C87 = dobytok_2_matruc(A8,15,Bx,rozmir_B[krok],154); 
   write_to_file(f8,C87,15,rozmir_B[krok],CPU8,"Operation: A8 * B7 = C87. Than C87");
   break;
  }
  MPI_Barrier(MPI_COMM_WORLD);
        /*
        *  ----ПРОЦЕС ПЕРЕСИЛАННЯ----
        */
        if(krok<7)
        {
            int ** otherB;
            matrix(otherB,154,10);
            SendRecive_Matrix(Bx,154,rozmir_B[krok],CPU7,otherB,154,rozmir_otherB[krok],CPU2,Status1);
            /**  ----2 етап ПЕРЕСИЛАННЯ----*/
            SendRecive_Matrix(otherB,154,rozmir_otherB[krok],CPU1,Bx,154,rozmir_B[krok+1],CPU2,Status1);
            char comment[30] = { NULL };
            strcpy(comment,MakeComent(porjadok[krok+1],2));
            write_to_file(f8,Bx,154,rozmir_B[krok+1],CPU8,comment);
            MPI_Barrier(MPI_COMM_WORLD);
        }
    }
 
    //timer
    endtimeO = MPI_Wtime();
    Write_Time(8,(endtimeO-endtimeZ),"step of Calculation");
    MPI_Barrier(MPI_COMM_WORLD);
    endtimeO = MPI_Wtime();
    /*
    *  ----ПРОЦЕС ВИВАНТАЖЕННЯ----
    */
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Barrier(MPI_COMM_WORLD);
    Save_in_mem(C81,9,C82,9,C83,9,C84,9,C85,9,C86,9,C87,9,C88,10,15);
    //timer
    endtimeV = MPI_Wtime();
    Write_Time(8,(endtimeV-endtimeO),"step of Store");
}
Еще кое что:
Так как у меня параллелизм, про дебагать в автоматическом режиме нельзя. Так же могу закинуть полностью проект в архиве
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
22.01.2014, 06:14     Умножение 2 матриц с помощью библиотек MPI
Посмотрите здесь:

Умножение матриц C++
C++ Умножение матриц
Умножение матриц C++
Умножение матриц C++
Умножение матриц C++
C++ Ленточное умножение матриц с использованием MPI
Умножение матриц C++
C++ умножение матриц C++

Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
Ответ Создать тему
Опции темы

Текущее время: 15:25. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru