#include "mpi.h" #include <stdio.h> #include <math.h> int main(int argc, char *argv[]){ int myid, numprocs; int namelen; char processor_name[MPI_MAX_PROCESSOR_NAME]; MPI_Init(&argc,&argv); MPI_Comm_rank(MPI_COMM_WORLD,&myid); MPI_Comm_size(MPI_COMM_WORLD,&numprocs); MPI_Get_processor_name(processor_name,&namelen); fprintf(stderr,"Hello World! Process %d of %d on %s\n",myid, numprocs, processor_name); MPI_Finalize(); }

这是一个使用MPI（Message Passing Interface）库编写的并行程序，用于在多个计算节点上执行相同的任务，以提高程序的执行效率。该程序使用MPI库中的函数来获取当前进程的编号、进程总数以及处理器的名称，并将这些信息输出到标准错误流中。MPI_Init()函数用于初始化MPI库，MPI_Comm_rank()函数用于获取当前进程的编号，MPI_Comm_size()函数用于获取进程总数，MPI_Get_processor_name()函数用于获取处理器的名称，最后使用MPI_Finalize()函数来关闭MPI库。

相关问题

#include "mpi.h" #include <stdio.h> #include <math.h> void main(argc,argv) int argc; char *argv[]; { int myid, numprocs; int namelen; char processor_name[MPI_MAX_PROCESSOR_NAME]; MPI_Init(&argc,&argv); MPI_Comm_rank(MPI_COMM_WORLD,&myid); MPI_Comm_size(MPI_COMM_WORLD,&numprocs); MPI_Get_processor_name(processor_name,&namelen); fprintf(stderr,"Hello World! Process %d of %d on %s\n",myid, numprocs, processor_name); MPI_Finalize(); }分析上面的程序

这是一个使用 MPI (Message Passing Interface) 库编写的并行程序，它展示了如何使用 MPI 在多个进程之间传递消息。该程序会在每个进程上输出 "Hello World!" 以及该进程的 ID、进程总数和处理器名字。

具体分析如下：

1. `#include "mpi.h"`：引入 MPI 库。

2. `void main(argc,argv) int argc; char *argv[];`：定义 main 函数，其中包含 argc 和 argv 参数，这样可以从命令行获取参数。

3. `MPI_Init(&argc,&argv);`：MPI 初始化。

4. `MPI_Comm_rank(MPI_COMM_WORLD,&myid);`：获取当前进程的 ID。

5. `MPI_Comm_size(MPI_COMM_WORLD,&numprocs);`：获取进程总数。

6. `MPI_Get_processor_name(processor_name,&namelen);`：获取当前进程所在的处理器名字。

7. `fprintf(stderr,"Hello World! Process %d of %d on %s\n",myid, numprocs, processor_name);`：输出 "Hello World!" 以及当前进程的 ID、进程总数和处理器名字到 stderr 流。

8. `MPI_Finalize();`：MPI 结束。

该程序使用 MPI 让多个进程并行执行相同的代码，每个进程输出自己的信息，从而展示了 MPI 的基本用法。

使以下程序减小占用内存，并能准确显示结果：#include <stdio.h> #include <stdlib.h> #include <mpi.h> #define N 6 int main(int argc, char** argv) { int rank, size; int A[N][N], B[N][N], C[N][N], sub_A[N / N][N], sub_B[N / N][N], sub_C[N / N][N]; int i, j, k, l, m, n; MPI_Status status; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); if (N % size != 0) { if (rank == 0) { printf("Matrix size should be multiple of number of processes\n"); } MPI_Finalize(); return 0; } if (rank == 0) { for (i = 0; i < N; i++) { for (j = 0; j < N; j++) { A[i][j] = i * j; B[i][j] = i + j; } } } MPI_Scatter(A, N * N / size, MPI_INT, sub_A, N * N / size, MPI_INT, 0, MPI_COMM_WORLD); MPI_Scatter(B, N * N / size, MPI_INT, sub_B, N * N / size, MPI_INT, 0, MPI_COMM_WORLD); for (i = 0; i < N / N; i++) { for (j = 0; j < N; j++) { sub_C[i][j] = 0; } } for (i = 0; i < N / N; i++) { for (j = 0; j < N; j++) { for (k = 0; k < N / N; k++) { sub_C[i][j] += sub_A[i][k] * sub_B[k][j]; } } } MPI_Gather(sub_C, N * N / size, MPI_INT, C, N * N / size, MPI_INT, 0, MPI_COMM_WORLD); if (rank == 0) { for (i = 0; i < N; i++) { for (j = 0; j < N; j++) { for (k = 0; k < size; k++) { for (l = 0; l < N / N; l++) { m = i % (N / N) + l * (N / N); n = j + k * N / N; sub_C[l][j] = C[m][n]; } } for (k = 0; k < N / N; k++) { for (l = 0; l < size; l++) { C[i][j] += sub_C[k][j + l * N / N]; } } } } } if (rank == 0) { for (i = 0; i < N; i++) { for (j = 0; j < N; j++) { printf("%d ", C[i][j]); } printf("\n"); } } MPI_Finalize(); return 0; }

这个程序可以通过使用更小的子矩阵来减小内存占用。同时，可以将子矩阵的大小设置为更接近于处理器数量的值，以减少通信的开销。下面是修改后的程序：

#include <stdio.h>
#include <stdlib.h>
#include <mpi.h>

#define N 6

int main(int argc, char** argv) {
int rank, size;
int A[N][N], B[N][N], C[N][N], sub_A[N / 2][N], sub_B[N][N / 2], sub_C[N / 2][N / 2];
int i, j, k, l, m, n;

MPI_Status status;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);

if (N % size != 0) {
if (rank == 0) {
printf("Matrix size should be multiple of number of processes\n");
}
MPI_Finalize();
return 0;
}

if (rank == 0) {
for (i = 0; i < N; i++) {
for (j = 0; j < N; j++) {
A[i][j] = i * j;
B[i][j] = i + j;
}
}
}

MPI_Scatter(A, N * N / size, MPI_INT, sub_A, N / 2 * N, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Scatter(B, N * N / size, MPI_INT, sub_B, N * N / 2, MPI_INT, 0, MPI_COMM_WORLD);

for (i = 0; i < N / 2; i++) {
for (j = 0; j < N / 2; j++) {
sub_C[i][j] = 0;
}
}

for (i = 0; i < N / 2; i++) {
for (j = 0; j < N / 2; j++) {
for (k = 0; k < N; k++) {
sub_C[i][j] += sub_A[i][k] * sub_B[k][j];
}
}
}

MPI_Gather(sub_C, N / 2 * N / 2, MPI_INT, C, N / 2 * N / 2, MPI_INT, 0, MPI_COMM_WORLD);

if (rank == 0) {
for (i = 0; i < N; i++) {
for (j = 0; j < N; j++) {
C[i][j] = 0;
}
}

for (i = 0; i < N / 2; i++) {
for (j = 0; j < N / 2; j++) {
for (k = 0; k < size; k++) {
m = i + k * N / 2;
n = j * N / 2;
for (l = 0; l < N / 2; l++) {
C[m][n + l] = sub_C[i][j];
}
}
}
}

for (i = 0; i < N; i++) {
for (j = 0; j < N; j++) {
printf("%d ", C[i][j]);
}
printf("\n");
}
}

MPI_Finalize();

return 0;
}