云计算基础实验

云计算基础实验报告

实验一 Linux环境下算法的测试

一， 根据基本计算头脑，验证和求解，设计算法。
根据运行需要，自行完成（C和Python）环境配置。
1.1验证卡布列克常数6174

原理过程：

• 循环输入一个1000-9999之间的数字，找出其最大数和其最小数，并进行相减。直到其末了值得到6174.
  
• 输出此卡布列克常数的运算过程以及结果
     

  ---

  
  

算法实现（在C语言环境运行）

1. #include<stdio.h>
3. void sort(int a[], int num)   //将数字按照从大到小的顺序排列
4. {
5.     int i, j, temp;
6.     for (i = 0; i < num; i++)
7.         for (j = i + 1; j < num; j++)
8.             if (a[i] > a[j])
9.             {
10.                 temp = a[i];
11.                 a[i] = a[j];
12.                 a[j] = temp;
13.             }
14. }
16. int main() {
17.     int n = 1000, count, result, s;
18.     int a[4];   //存储一个4位数
19.     int max, min;   //存放最大值最小值
21.     printf("验证[1000-9999]卡布列克常数6174：");
24.     while (n <= 9999)
25.     {
26.         count = 1; result = 0;
27.         s = n;
28.         
29.         while (n != 6174 && result != 6174 && count <= 7)
30.         {
31.             a[0] = s % 10;                        /*分别算出4位数，再将其存放在数组中*/
32.             a[1] = s / 10 % 10;
33.             a[2] = s / 100 % 10;
34.             a[3] = s / 1000;
36.             sort(a, 4);   //调用函数
38.             max = 1000 * a[3] + 100 * a[2] + 10 * a[1] + a[0]; //计算最大值
39.             min = 1000 * a[0] + 100 * a[1] + 10 * a[2] + a[3];//计算最小值
41.             printf("[%d] : %d - %d = %d\n", count, max, min, max - min);
43.             result = max - min;
44.             count++;    //统计进行了几次计算
46.             
47.             if (result == 6174 && count < 8)
48.             {
49.                 printf("%d is the num.\n", n);
50.                 printf("-----------------------\n");
51.             }
53.             
54.                   
55.             s = result; //将进行减的值赋给s，回到while循环判断
56.         }   
58.         n = n + 1;
60.     }
61.     return 0;
62. }

复制代码

结果显示（运行截图）

1.2蒙特卡洛算法

原理过程：
定义一个常量NUM_POINTS，体现要天生的随机点的数量。
利用rand()函数天生随机点，并查抄这些点是否落在单位圆内（即x^2 + y^2 <= 1）
每天生一个落在单位圆内的点，计数器inside_circle就增长1
计算并输出π的估计值。
算法实现（

---

在C语言环境运行）

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <time.h>
5. #define NUM_POINTS 1000000
7. int main() {
8.     int inside_circle = 0;
9.     double x, y;
11.     // 初始化随机数种子
12.     srand(time(NULL));
14.     // 生成NUM_POINTS个随机点
15.     for (int i = 0; i < NUM_POINTS; i++) {
16.         // 生成0到1之间的随机数作为x和y坐标
17.         x = (double)rand() / RAND_MAX;
18.         y = (double)rand() / RAND_MAX;
20.         // 检查点是否在单位圆内
21.         if (x * x + y * y <= 1.0) {
22.             inside_circle++;
23.         }
24.     }
26.     // 计算π的估计值
27.     double pi = 4.0 * inside_circle / NUM_POINTS;
29.     printf("估计的π值为: %.6f\n", pi);
31.     return 0;
32. }

复制代码

结果显示（运行截图）

1.3冰雹猜想验证（验证范围1~100）

原理过程：
输入一个1-100之间的整数n，如果n为偶数，就将它变成n/2，如果除后变成奇数，则将它乘3加1，不断重复运算，经过有限步数后，是否可以得到1

---

算法实现（在C语言环境运行）

1. #include<stdio.h>
2. int main()
3. {
4.     int i,number,count=0;
6.     for(i=1; i<=100; i++)
7.     {
8.         number = i;
9.         printf("%d : ",number);
10.         while(number != 1)
11.         {
12.             if (number % 2 == 0)
13.             {
14.                 number /= 2;
15.                 printf("%d - ", number);
16.             }
17.             else
18.             {
19.                 number = number * 3 + 1;
20.                 printf("%d - ", number);
21.             }
22.             count++;
23.         }
24.         printf("共执行了%d步\n",count);  
25. }
26. return 0;
27. }

复制代码

结果显示（运行截图）

1.4亲和数验证（验证范围1~10000）

原理过程：
如果整数A的全部因子（包括1，但不包括其本身）之和等于整数B，整数B的因子（包括1，但不包括其本身）之和等于整数A，则整数A与B称为密切数。

---

算法实现（在C语言环境运行）

1. #include<stdio.h>
2. int main()
3. {
4.     int a=1, i=1;
5.     int j=1;
6.     for(a=1; a<=10000; a++)
7.     {
8.         int B = 0, A = 0;
9.         for(i=1; i<a; i++)
10.         {
11.             if(a%i==0)
12.                 {
13.                     B = B + i;
14.                 }
15.         }
17.         for(j=1; j<B; j++)
18.         {
19.             if(B%j == 0)
20.                 {
21.                     A = A + j;
22.                 }
23.         }
25.         if(A == a )
26.             {
27.                 printf("%d和%d是亲和数\n",a,B);
28.             }
29.     }
30.     return 0;
31. }

复制代码

结果显示（运行截图）

实验二 MPI分布式运行框架设计

一、 实验目标
设计运行框架，了解运行环境需求。
nfs的应用
mpi的安装和利用
mpi的环境测试
二、 实验环境
Ubuntu 22.04 (LTS),
VM环境下，网络架构NAT，
计算节点数：4个
三、 基本步调介绍：
3.1 构建四台计算节点

• 每个节点计算机的网络均采用NAT模式，构建一个内部的计算集群.
  
• 设置每个节点的hostname，依次是node01, node02, node03, node04。
  
• 根据上一步序次，依次设置每个节点ip，范围（192.168.26.111~114）。
  
  
  
  
  
  
  
  
  
  
  
  
  

四台主机都需要进行此配置

3.2 构建四台计算节点之间相互免密钥访问（利用rsa方式天生）

#公钥和密钥都已天生

3.3 给四台主机安装nfs并实现永久挂载

• 四台节点，全部安装nfs及nfs-utils
  

//下载nfs

• node01节点作为运行主节点，启动并运行nfs服务程序，该程序随系统启动。
  

• node01节点作为运行主节点，提供挂载的目次资源。
  

挂载目次/var/mpi4.0/，如果没有此目次，则先创建，再修改配置文件提供挂载。

• 别的节点node02~04，实现永久挂载主节点node01的共享目次，并具有读写权限。
  

770:可读可写，
sync：共享目次同步文件，
no_root_squash：root权限设置**
//现永久挂载主机 node01节点的共享目次

///在node02-04客户端上安装nfs-common（客户端包）

///在node01上重启nfs服务器，在node02-04上挂载目次到node01实现目次共享

#mount：这是用来挂载文件系统的命令。
#-t nfs：这指定了文件系统的类型为NFS。
#-o nolock：这是挂载选项，nolock体现客户端不锁定文件，这可以提高性能，但可能不恰当需要严酷文件锁定的应用。
#192.168.26.111:/var/mpi4.0：这是NFS服务器的IP地点和要挂载的远程目次的路径。这里假设NFS服务器的IP地点是192.168.26.111，而且您想要挂载的目次是/var/mpi4.0。
/var/mp14.0：这是当地挂载点的路径，即您希望将远程目次挂载到当地的哪个位置。

//编辑配置文件实现永久挂载
3.4 在node01节点上安装mpi4.0

• 通过官方网站链接，下载mpi4.0源码包(四台主机都要安装)
  

https://www.mpich.org/static/downloads/4.0/mpich-4.0.tar.gz

编译安装mpi到/var/mpi4.0/（四台假造机都要实行）
解压缩文件包
//解压

//安装编译软件

a) 进入mpich解压目次，安装make
//绿色为可实行文件，蓝色为目次

b) 设置安装目次(以下配置信息，仅供参考，未写完备，实行会有错误提示。请根据错误提示，修改正确)
**#./configure –disable-fortran --prefix=/**var/mpi4.0
**报错：**configure: error: The Fortran compiler gfortran does not accept programs that call the same
#–disable-fortran：告诉配置脚本在编译过程中不利用Fortran编译器支持。
–prefix=/var/mpi4.0**：** 指定了软件安装的前缀路径，软件将被安装到**/var/mpi4.0****目次下，所有相关的可实行文件、库文件、头文件等都将被放置在这个目次及其子目次中。**

**//**配置安装乐成

c) make编译

d) make install 安装

#赋值放置程序的文件夹到共享目次/var/mpi4.0

#安装mpich

#切换到daisy用户（由于你如果用root用户编译运行程序，会导致权限过大）

#利用6个进程实行./cpi（下面显示运行结果和运行时间）

e) 退出到用户的主目次
#cd
f) 通过编辑.bashrc文件修改环境变量（每次打开终端时都会加载的启动项）

1. vim .bashrc

复制代码

g) 测试环境变量设置
#source ~/.bashrc
#which mpicc 查察位置信息
#which mpiexec

h) 在/var/mpi4.0/examples下，创建主机名称聚集文件csmpd.hosts，

1. vim csmpd.hosts

复制代码

文件内容如下：

3.5环境测试

• 测试运行MPICH的例子程序
  

查询怎样编译mpi源代码，怎样运行mpi程序

• 例子程序运行截图
  

#rank是你返回的进程号
#size就是进程数

四、 Helloworld程序代码实现及测试展示：
4.1程序源码：

1. /*hello.c*/
2. #include <stdio.h>
3. #include "mpi.h"
5. int main( int argc, char *argv[] )
6. {
7.     int rank;
8.     int size;
10.     MPI_Init( 0, 0 );
11.     MPI_Comm_rank(MPI_COMM_WORLD, &rank);
12.     MPI_Comm_size(MPI_COMM_WORLD, &size);
13.     printf( "Hello world from process %d of %d\n", rank, size );
14.     MPI_Finalize();
15.     return 0;
16. }

复制代码

4.2程序编译输出文件

1. $mpicc –o hello hello.c

复制代码

4.3运行

1. $mpiexec –n <processes> ./hello
3. $mpiexec -f csmpd.hosts –n <processes> ./hello

复制代码

【截图显示】

实验三 基本MPI环境的程序测试

一、 实验目标
逐一测试，提供的mpi实验程序文件。
熟悉 MPI 编程，加深对其编程的明白。
二、实验环境
Ubuntu 22.04 (LTS),
VM环境下，网络架构NAT，
计算节点数：4个
三、代码测试与截图
3.1代码泉源程序5.4
详细代码如下：

1. /*文件名：who.c*/
2. #include "mpi.h"
3. #include <stdio.h>
4. int main(int argc,char **argv)
5. {
6.           int myid, numprocs;
7.           int namelen;
8.           char processor_name[MPI_MAX_PROCESSOR_NAME];
9.           MPI_Init(&argc,&argv);
10.           MPI_Comm_rank(MPI_COMM_WORLD,&myid);//获得本进程ID
11.           MPI_Comm_size(MPI_COMM_WORLD,&numprocs);//获得总的进程数目
12.           MPI_Get_processor_name(processor_name,&namelen);//获得本进程的机器名
13.           printf("Hello World! Process %d of %d on %s\n",myid, numprocs, processor_name);
14.           MPI_Finalize();
15. }

复制代码

结果显示（运行截图）

3.2代码泉源程序5.5
详细代码如下：

1. /*文件名：message.c*/
2. #include <stdio.h>
3. #include "mpi.h"
4. #include <string.h>
5. int main(int argc, char** argv)
6. {
7.      int myid,numprocs,source;
8.      MPI_Status status;
9.      char message[100];
10.      MPI_Init(&argc,&argv);
11.      MPI_Comm_rank(MPI_COMM_WORLD, &myid);
12.      MPI_Comm_size(MPI_COMM_WORLD,&numprocs);
13.      if (myid != 0)
14.      {
15.            strcpy(message, "Hello World!");//为发送字符串赋值
16.            //发送字符串时长度要加1，从而包括串结束标志
17.            MPI_Send(message,strlen(message)+1, MPI_CHAR, 0,99,MPI_COMM_WORLD);
18.      }
19.      else
20.      {
21.            //除0进程的其他进程接收来自于0进程的字符串数据
22.            for (source = 1; source < numprocs; source++)
23.           {
24.                  MPI_Recv(message, 100, MPI_CHAR, source, 99,MPI_COMM_WORLD, &status);
25.                  printf("I am process %d. I recv string '%s' from process %d.\n", myid, message,source);
26.           }
27.      }
28.      MPI_Finalize();
29. }

复制代码

结果显示（运行截图）

3.3代码泉源程序5.7
详细代码如下：

1. #define N 100000000
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <time.h>
5. #include "mpi.h"
6. int main(int argc, char** argv)
7. {
8.   int myid,numprocs;
9.   int i;
10.   double local=0.0;
11.   double inte,tmp=0.0,x;
12.   MPI_Init(&argc, &argv);
13.   MPI_Comm_rank(MPI_COMM_WORLD, &myid);
14.   MPI_Comm_size(MPI_COMM_WORLD,&numprocs);
15.   srand((int)time(0));//设置随机数种子
16. /*各节点分别计算一部分积分值*/
17. /*以下代码在不同节点运行的结果不同*/
18.   for(i=myid;i<N;i=i+numprocs)
19.   {
20.     x=10.0*rand()/(RAND_MAX+1.0);//求函数值
21.     tmp=x*x/N;
22.     local=tmp+local;//各节点计算面积和
23.   }       
24. //计算总的面积和，得到积分值
25.   MPI_Reduce(&local,&inte,1,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD);
26.   if(myid==0)
27.   {
28.     printf("The integal of x*x=%16.15f\n",inte);
29.   }
30.   MPI_Finalize();
31. }

复制代码

结果显示（运行截图）

3.4代码泉源程序5.8
详细代码如下：

• 初始化MPI****环境。
  
• 获取当进步程的ID (myid) 和总进程数 (numprocs)****。
  
• 利用随机数天生器天生 N*N* 个在 [1, 10] 区间内的随机数 x*x*****。
  
• 计算每个随机数 x*x* 对应的 x2*x*2 并累加到 local 变量中。
  
• 调用自定义的归约函数 Myreduce**，将所有进程的 local** 值汇总到根节点（进程0**）。**
  
• 如果当进步程是根节点，打印出积分结果。
  
• 结束MPI****环境。
  

1. /*文件名 myreduce.c*/
2. #define N 100000000
3. #include <stdio.h>
4. #include <stdlib.h>
5. #include <time.h>
6. #include "mpi.h"
8. void Myreduce(double sendbuf, double *recvbuf, int root); // 修改函数原型
10. int main(int argc, char** argv) {
11.     int myid, numprocs;
12.     double local = 0.0;
13.     double inte;
14.     double x;
15.     MPI_Init(&argc, &argv);
16.     MPI_Comm_rank(MPI_COMM_WORLD, &myid);
17.     MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
19.     // 采用归约对y=x*x在[1,10]区间求积分
20.     srand((unsigned)time(NULL) + myid); // 使用myid作为种子的一部分
21.     int localN = N / numprocs; // 每个进程处理的随机数数量
22.     for (int i = 0; i < localN; i++) {
23.         x = 10.0 * rand() / (RAND_MAX / 10.0 + 1.0); // 生成[1,10]区间的随机数
24.         local += x * x / N; // 累加到local变量中
25.     }
26.     Myreduce(local, &inte, 0); // 调用自定义的规约函数，传递local的值
28.     if (myid == 0) {
29.         printf("id:%d 总进程：%d The integral of x*x = %16.15f\n",myid,numprocs,inte);
30.     }
31.     MPI_Finalize();
32.     return 0;
33. }
35. // 自定义的归约函数
36. void Myreduce(double sendbuf, double *recvbuf, int root) {
37.     MPI_Status status;
38.     int myid, numprocs;
39.     MPI_Comm_rank(MPI_COMM_WORLD, &myid);
40.     MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
42.     // 非root节点向root节点发送数据
43.     if (myid != root) {
44.         MPI_Send(&sendbuf, 1, MPI_DOUBLE, root, 99, MPI_COMM_WORLD);
45.     } else {
46.         *recvbuf = 0.0; // 初始化接收缓冲区
47.         // root节点接收数据并对数据求和，完成规约操作
48.         for (int i = 0; i < numprocs; i++) {
49.             if (i != root) {
50.                 double tmp;
51.                 MPI_Recv(&tmp, 1, MPI_DOUBLE, i, 99, MPI_COMM_WORLD, &status);
52.                 *recvbuf += tmp; // 累加求和
53.             }
54.         }
55.     }
56. }

复制代码

结果显示（运行截图）

实验四 卡布列克常数的MPI测试
一、 实验题目
用 MPI 方式遍历数据，证实卡布列克常数6174猜想。
二、实验目标
熟悉 MPI 编程，加深对其编程的明白。
三、实验环境
Ubuntu 22.04 (LTS),
VM环境下，网络架构NAT，
计算节点数：4个
四、原理介绍：
6174猜想：一个恣意的四位正整数（全雷同的除外，如1111）。将数字重新组合成一个最大的数和最小的数相减，重复这个过程，最多七步，必得6174。
例如：
输入：2000
输出：
第1步：2000-0002=1998
第2步：9981-1899=8082
第3步：8820-0288=8532
第4步：8532-2358=6174
分步解题：

• 遍历所有的四位数，判断。
  
• 分解数字的千位，百位，十位，个位，放置在4个变量中，排序，将最大的放在最前面，最小的放在末了面。
  
• 利用4个变量的值，构建四位数，最大值及最小值，并计算差值
  
• 如差值不是6174，则重复步调2.如果差值为6174，则程序打印输出最闭幕果，程序结束。
  

用各自节点分别计算的数据范围，分担计算任务。
例如，如果有4个节点呆板，就将10009999****分成四个小范围，分给****4****个节点计算验证。如果有****3****个节点呆板，就将****10009999分成三个小范围，分给3个节点计算验证。
五、 程序代码实现及测试：

1. #include <mpi.h>
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <unistd.h>
6. //找出最大值和最小值
7. void sort_digits(int num, int *sorted, int *largest, int *smallest) {
8.     for (int i = 0; i < 4; ++i) {
9.         sorted[i] = num % 10;
10.         num /= 10;
11.     }
12.     // Sort the digits
13.     for (int i = 0; i < 3; ++i) {
14.         for (int j = i + 1; j < 4; ++j) {
15.             if (sorted[i] > sorted[j]) {
16.                 int temp = sorted[i];
17.                 sorted[i] = sorted[j];
18.                 sorted[j] = temp;
19.             }
20.         }
21.     }
22.     //将排序好的数组数编排成最大的数和最小的数
23.     *largest = sorted[0] * 1000 + sorted[1] * 100 + sorted[2] * 10 + sorted[3];
24.     *smallest = sorted[3] * 1000 + sorted[2] * 100 + sorted[1] * 10 + sorted[0];
25. }
27. //检查是否能在7步以内得到6174，输出运行节点和步骤
28. void check_convergence(int num, int myid, char *hostname) {
29.     int steps = 0;
30.     int sorted[4], largest, smallest;
31.     printf("进程 %d: 数字 %d on %s\n",myid, num,hostname);
32.     while (num != 6174 && steps < 7) {
33.         sort_digits(num, sorted, &largest, &smallest);
34.         num = largest - smallest;
35.         steps++;
36.         printf("进程 %d: 第%d步: %d - %d = %d on %s\n", myid, steps, largest, smallest, num, hostname);
37.     }
38.     if (num == 6174) {
39.         printf("进程 %d: Convergence to 6174 after %d 步: %d - %d = 6174 on %s\n",myid, steps, largest, smallest,hostname);
40.     }
41. }
43. int main(int argc, char **argv) {
44.     int myid, numprocs;
45.     char hostname[256];
46.     MPI_Init(&argc, &argv);
47.     MPI_Comm_rank(MPI_COMM_WORLD, &myid);
48.     MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
50.     gethostname(hostname, sizeof(hostname));
52.     int start = 1000 + myid * (9999 / numprocs);
53.     int end = 1000 + (myid + 1) * (9999 / numprocs);
54.     if (myid == numprocs - 1) {
55.         end = 9999;
56.     }
58.     for (int i = start; i <= end; ++i) {
59.         if (i % 1111 != 0) { //不包含四位数都相同的数
60.             check_convergence(i, myid, hostname);
61.         }
62.     }
64.     MPI_Finalize();
65.     return 0;
66. }

复制代码

实验五 基于蒙特卡洛算法求π值的MPI程序设计

一、 实验题目
用 MPI 技术计算π的值，运行代码参考程序5.6。
二、实验目标
熟悉 MPI 编程，加深对其编程的明白。
三、实验环境
Ubuntu 22.04 (LTS),
VM环境下，网络架构NAT，
计算节点数：4个
四、程序代码实现及测试

1. /*文件名：mtpi.c*/
2. #include "mpi.h"
3. #include <stdio.h>
4. #include <stdlib.h>
5. #include <time.h> // 包含 time.h 头文件
7. int main(int argc, char **argv) {
8.     int myid, numprocs;
9.     int namelen;
10.     long count = 1000000;
11.     char processor_name[MPI_MAX_PROCESSOR_NAME];
12.     MPI_Status status;
13.     MPI_Init(&argc, &argv); // 初始化 MPI 环境
14.     MPI_Comm_rank(MPI_COMM_WORLD, &myid); // 得到当前进程的进程号
15.     MPI_Comm_size(MPI_COMM_WORLD, &numprocs); // 得到通信域中的总进程数
16.     MPI_Get_processor_name(processor_name, &namelen); // 得到节点主机名称
17.     srand((int)time(0)); // 设置随机种子
18.     double y;
19.     double x;
20.     long m = 0, m1 = 0, i = 0;
21.     double pi = 0.0, n = 0.0;
22.     for (i = 0; i < count; i++) {
23.         x = (double)rand() / (double)RAND_MAX; // 得到0～1之间的随机数，x坐标
24.         y = (double)rand() / (double)RAND_MAX; // 得到0～1之间的随机数，y坐标
25.         if ((x - 0.5) * (x - 0.5) + (y - 0.5) * (y - 0.5) < 0.25) // 判断产生的随机点坐标是否在圆内
26.             m++;
27.     }
28.     n = 4.0 * m / 1000000;
29.     printf("Process %d of %d on %s pi= %f\n", myid, numprocs, processor_name, n);
30.     if (myid != 0) { // 判断是否是主节点
31.         MPI_Send(&m, 1, MPI_LONG, 0, 1, MPI_COMM_WORLD); // 子节点向主节点传送结果
32.     } else {
33.         long p = m; // 主进程也参与计算，所以初始化 p 为 m
34.         // 分别接收来自于不同子节点的数据
35.         for (int source = 1; source < numprocs; source++) {
36.             MPI_Recv(&m1, 1, MPI_LONG, source, 1, MPI_COMM_WORLD, &status); // 主节点接收数据
37.             p += m1;
38.         }
39.         pi = 4.0 * p / (count * numprocs); // 汇总计算 pi 值
40.         printf("pi= %f\n", pi);
41.     }
42.     MPI_Finalize(); // 结束 MPI 环境
43.     return 0;
44. }

复制代码

五、运行结果效果图

实验六 并行计算的综合设计

一、 实验题目
用 MPI 技术去验证角谷猜想，要求验证数据的范围尽可能的大。
二、实验目标
熟悉 MPI 编程，加深对其编程的明白。
三、实验环境
Ubuntu 22.04 (LTS),
VM环境下，网络架构NAT，
计算节点数：4个
四、程序代码实现及测试

1. #include <stdio.h>
2. #include <mpi.h>
4. // 函数用于验证角谷猜想，并返回到达1所需的步骤数
5. int collatzSteps(int number) {
6.     int steps = 0;
7.     while (number != 1) {
8.         if (number % 2 == 0) {
9.             number /= 2;
10.         } else {
11.             number = number * 3 + 1;
12.         }
13.         steps++;
14.     }
15.     return steps;
16. }
18. int main(int argc, char** argv) {
19.     int rank, size;
20.     int start, end, step;
21.     int namelen;
22.     char processor_name[MPI_MAX_PROCESSOR_NAME];
24.     MPI_Init(&argc, &argv); // 初始化MPI环境
25.     MPI_Comm_size(MPI_COMM_WORLD, &size); // 获取进程总数
26.     MPI_Comm_rank(MPI_COMM_WORLD, &rank); // 获取当前进程标识
27.     MPI_Get_processor_name(processor_name, &namelen); // 获取节点名称
29.     // 确定每个进程的起始和结束值
30.     int total_numbers = 100; // 总共需要计算的数
31.     start = rank * (total_numbers / size) + 1;
32.     if (rank == size - 1) {
33.         // 最后一个进程需要处理剩余的数
34.         end = total_numbers;
35.     } else {
36.         end = start + (total_numbers / size) - 1;
37.     }
39.     // 输出当前进程的编号和所在节点名称
40.     printf("Process %d is on %s\n", rank, processor_name);
42.     // 验证角谷猜想并输出结果
43.     for (int i = start; i <= end; i++) {
44.         step = collatzSteps(i);
45.         printf("%d 执行了 %d 步, 等于1 on %s\n",i, step,processor_name);
46.     }
48.     MPI_Finalize(); // 结束MPI环境
49.     return 0;
50. }

复制代码

五、运行结果效果图

实验七 并行计算的综合设计

一、 实验题目
用 MPI 技术去验证亲和数组合的个数。
要求验证数据，程序运行时间大于20分钟以上。
二、实验目标
熟悉 MPI 编程，加深对其编程的明白。
三、实验环境
Ubuntu 22.04 (LTS),
VM环境下，网络架构NAT，
计算节点数：4个
四、程序代码实现及测试

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <mpi.h>
5. // 函数用于计算一个数的约数之和
6. int sum_of_divisors(int n) {
7.     int sum = 0;
8.     for (int i = 1; i <= n / 2; i++) {
9.         if (n % i == 0) {
10.             sum += i;
11.         }
12.     }
13.     return sum;
14. }
16. // 主程序
17. int main(int argc, char** argv) {
18.     int rank, size;
19.     char processor_name[MPI_MAX_PROCESSOR_NAME];
20.     int namelen;
22.     MPI_Init(&argc, &argv);
23.     MPI_Comm_rank(MPI_COMM_WORLD, &rank);
24.     MPI_Comm_size(MPI_COMM_WORLD, &size);
25.     MPI_Get_processor_name(processor_name, &namelen); // 获取进程所在的节点名称
27.     // 设置验证的上限值
28.     int limit = 10000;
30.     // 计算每个进程的起始和结束值
31.     int start = rank * (limit / size);
32.     int end = (rank + 1) * (limit / size) - 1;
33.     if (rank == size - 1) {
34.         end = limit;
35.     }
37.     // 寻找亲和数并输出结果
38.     for (int a = start; a <= end; a++) {
39.         int B = sum_of_divisors(a);
40.         int A = sum_of_divisors(B);
41.         if (A == a) {
42.             printf(" 进程 %d： 亲和数: %d and %d on %s\n", rank, a, B,processor_name);
43.         }
44.     }
46.     MPI_Finalize();
47.     return 0;
48. }

复制代码

五、运行结果效果图

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <mpi.h>
5. // 函数用于计算一个数的约数之和
6. int sum_of_divisors(int n) {
7.     int sum = 0;
8.     for (int i = 1; i <= n / 2; i++) {
9.         if (n % i == 0) {
10.             sum += i;
11.         }
12.     }
13.     return sum;
14. }
16. // 主程序
17. int main(int argc, char** argv) {
18.     int rank, size;
19.     char processor_name[MPI_MAX_PROCESSOR_NAME];
20.     int namelen;
22.     MPI_Init(&argc, &argv);
23.     MPI_Comm_rank(MPI_COMM_WORLD, &rank);
24.     MPI_Comm_size(MPI_COMM_WORLD, &size);
25.     MPI_Get_processor_name(processor_name, &namelen); // 获取进程所在的节点名称
27.     // 设置验证的上限值
28.     int limit = 10000;
30.     // 计算每个进程的起始和结束值
31.     int start = rank * (limit / size);
32.     int end = (rank + 1) * (limit / size) - 1;
33.     if (rank == size - 1) {
34.         end = limit;
35.     }
37.     // 寻找亲和数并输出结果
38.     for (int a = start; a <= end; a++) {
39.         int B = sum_of_divisors(a);
40.         int A = sum_of_divisors(B);
41.         if (A == a) {
42.             printf(" 进程 %d： 亲和数: %d and %d on %s\n", rank, a, B,processor_name);
43.         }
44.     }
46.     MPI_Finalize();
47.     return 0;
48. }

复制代码

五、运行结果效果图

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。