0
1
2
3
4
5
6
7
//#0进程发送数据
    for (int i = 0; i < comm_sz - 1; i++) { // 分配矩阵A的行
        begin_Arow = i * avg_rows;
        end_Arow = (i + 1 == comm_sz - 1) ? M : (i + 1) * avg_rows;
        MPI_Send(&end_Arow, 1, MPI_INT, i + 1, 10, MPI_COMM_WORLD);
        MPI_Send(&A[begin_Arow * N], (end_Arow - begin_Arow) * N, MPI_FLOAT, i + 1, 1, MPI_COMM_WORLD);
        MPI_Send(B, N * K, MPI_FLOAT, i + 1, 2, MPI_COMM_WORLD); // 发送整个B矩阵
    }

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
else { // 其他进程接收数据并计算
        MPI_Recv(&end_Arow, 1, MPI_INT, 0, 10, MPI_COMM_WORLD, &status);
        begin_Arow = avg_rows * (my_rank - 1);

        float *localA = (float *)malloc((end_Arow - begin_Arow) * N * sizeof(float));
        float *localB = (float *)malloc(N * K * sizeof(float));
        float *localC = (float *)malloc((end_Arow - begin_Arow) * K * sizeof(float));
    	//创建本地矩阵空间
        MPI_Recv(localA, (end_Arow - begin_Arow) * N, MPI_FLOAT, 0, 1, MPI_COMM_WORLD, &status);
        MPI_Recv(localB, N * K, MPI_FLOAT, 0, 2, MPI_COMM_WORLD, &status);

        matrix_multiply_s(end_Arow - begin_Arow, N, K, localA, localB, localC); // 计算

        MPI_Send(localC, (end_Arow - begin_Arow) * K, MPI_FLOAT, 0, 3, MPI_COMM_WORLD); // 发送结果

        free(localA);
        free(localB);
        free(localC);
    }

0
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
    float *A = (float *)malloc(M * N * sizeof(float));
    float *localA = (float *)malloc(split_num * N * sizeof(float));
    float *B = (float *)malloc(N * K * sizeof(float));
    float *localC = (float *)malloc(split_num * K * sizeof(float));
    float *C = (float *)malloc(M * K * sizeof(float));
    double start ,end; //以上是所有进程都要创建的变量
	...
    else{ // 0号进程负责分配任务


        MPI_Bcast(B, N * K, MPI_FLOAT, 0,  MPI_COMM_WORLD); // 发送整个B矩阵
        MPI_Scatter(A, split_num*N, MPI_FLOAT, localA, split_num*N, MPI_FLOAT, 0, MPI_COMM_WORLD);
        
        matrix_multiply_s(split_num, N, K, localA, B, localC); // 计算

        MPI_Gather(localC, split_num * K, MPI_FLOAT, C, split_num * K, MPI_FLOAT, 0, MPI_COMM_WORLD);
        if(my_rank ==0 ){
            double end = MPI_Wtime();
            printf("computing time: %.8lf\n", end-start);
            // printf("%f,%f,%f,%f", C[0], C[K-1], C[(M-1)*K],C[(M-1)*K+K-1]);
        }

        free(A);
        free(B);
        free(C);
        free(localC);
        free(localA);

    } 

0
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
//matrix_multiply_s.h
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <time.h>


/*
    输入三个矩阵的维度，以及三个矩阵的二维矩阵，输出计算时间
*/

extern void matrix_multiply_s(int M, int N, int K, float* A, float* B, float* C);



// matrix_multiply_s.cpp
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void matrix_multiply_s(int M, int N, int K, float* A, float* B, float* C) {
/*
    输入三个矩阵的维度，以及三个矩阵的指针，输出计算时间
*/
    for (int i = 0; i < M; ++i) {
        for (int j = 0; j < K; ++j) {
            C[i*M+j] = 0;
        }
    }
    clock_t start, end;
    start = clock();

    for (int i = 0; i < M; i++) {
        for (int k = 0; k < N; k++){
            for (int j = 0; j < K; j++){  
                C[i*K+j] += A[i*N+k] * B[k*K+j];
            }
        }
    }
    end = clock();
    printf("C Matrix Multiplying in sequence of %d*%d and %d*%d use time of %f seconds\n", M, N, N, K, (double)(end - start) / CLOCKS_PER_SEC);

    return ;
}