首页 - 资讯 - 科技 - 教育 - 汽车 - 财经 - 健康 - 房产 - 文旅 - 娱乐 - 游戏
维修 |车展 |报价 |行情 |时评 |新车 |建材 |政策 |市场 |建筑 |家装 |访谈 |股票 |创投人物 |产业 |金融
当前位置： 首页> 汽车> 报价 > 沈阳做网站的互联网公司_武汉房地产政策最新消息_手机网站建设公司_网络推广营销公司

沈阳做网站的互联网公司_武汉房地产政策最新消息_手机网站建设公司_网络推广营销公司

时间:2025/8/7 9:32:09来源：https://blog.csdn.net/HuaQi666/article/details/143594198 浏览次数: 0次
沈阳做网站的互联网公司_武汉房地产政策最新消息_手机网站建设公司_网络推广营销公司

Ubuntun搭建并行计算环境

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

1、卡布列克常数6174

原理过程

验证卡布列克运算，任意一个四位数，只要它们各个位上的数字是不全相同的，就有这样的规律：

(1)将组成该四位数的四个数字由大到小排列，形成由这四个数字构成的最大的四位数；
(2)将组成该四位数的四个数字由小到大排列，形成由这四个数字构成的最小的四位数(如果四个数中含有0，则得到的数不足四位)；
(3)求两个数的差，得到一个新的四位数(高位零保留)。重复以上过程，最后得到的结果是6174，这个数被称为卡布列克数。例如：
4321-1234=3087
8730-378=8352
8532-2358=6174
7641-1467=6174
代码实现
#include <stdio.h>int count = 0;void vr6174(int num);
void sort(int num, int *each);
void max_min(int *each, int *max, int *min);int main()
{int n;printf("Please input n: ");scanf("%d", &n);printf("Output:\n");if (n > 9999 || n == 0){printf("Input error!\n");return 0;}vr6174(n);return 0;
}void vr6174(int num)
{int each[4], max, min;if (num != 6174 && num){sort(num, each);max_min(each, &max, &min);num = max - min;printf("[%d]: %d-%d=%d\n", ++count, max, min, num);vr6174(num);}
}void sort(int num, int *each)
{int i, *j, *k, temp;for (i = 0; i <= 4; i++){j = each + 3 - i;*j = num % 10;num /= 10;}for (i = 0; i < 3; i++){for (j = each, k = each + 1; j <= each + 3 - 1; j++, k++)if (*j > *k){temp = *j;*j = *k;*k = temp;}}
}void max_min(int *each, int *max, int *min)
{int *i;*min = 0;for (i = each; i < each + 4; i++)*min = *min * 10 + *i;*max = 0;for (i = each + 3; i >= each; i--)*max = *max * 10 + *i;
}

2、蒙特卡洛算法

原理过程
1.首先，我们定义了一个宏NUM_POINTS，表示要生成的随机点的数量。这个值越大，估计的精度越高，但计算时间也越长。
2.我们使用rand()函数生成两个0到1之间的随机数，分别表示点的x和y坐标。
3.判断这个点是否在单位圆内。如果点到原点的距离小于等于1，那么它就在单位圆内。这里我们使用了勾股定理来计算距离：sqrt(x^2 + y^2) <= 1。
4.如果点在单位圆内，我们将points_inside_circle计数器加1。
5.最后，我们用落在单位圆内的点数除以总点数，然后乘以4，得到π的估计值。这是因为单位正方形的面积是1，而单位圆的面积是π/4，所以落在圆内的点数与总点数的比例应该接近π/4。乘以4后，我们就得到了π的估计值。
算法实验
#include <stdio.h>
#include <stdlib.h>
#include <time.h>#define NUM_POINTS 1000000int main() {int points_inside_circle = 0;double x, y;srand(time(NULL)); // 初始化随机数生成器for (int i = 0; i < NUM_POINTS; i++) {x = (double)rand() / RAND_MAX; // 生成0到1之间的随机数y = (double)rand() / RAND_MAX; // 生成0到1之间的随机数if (x * x + y * y <= 1) {points_inside_circle++; // 如果点在单位圆内，计数器加1}}double pi_estimate = 4.0 * points_inside_circle / NUM_POINTS;printf("Estimated value of Pi: %f\n", pi_estimate);return 0;
}

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

原理过程
代码实现
#include <stdio.h>void collatz(int n) {if (n == 1) {return;} else if (n % 2 == 0) {collatz(n / 2);} else {collatz(3 * n + 1);}
}int main() {for (int i = 1; i <= 100; i++) {printf("Number: %d\n", i);collatz(i);printf("\n");}return 0;
}

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

原理过程
代码实现
#include <stdio.h>int sum_of_divisors(int n) {int sum = 1;for (int i = 2; i * i <= n; i++) {if (n % i == 0) {sum += i;if (i != n / i) {sum += n / i;}}}return sum;
}int main() {for (int a = 1; a <= 10000; a++) {int b = sum_of_divisors(a);if (b > a && sum_of_divisors(b) == a) {printf("Amicable numbers: %d and %d\n", a, b);}}return 0;
}

实验二、MPI分布式运行框架搭建

1、前置操作

1.1、静态IP配置

/etc/netplan/文件下的网络配置文件

network:version: 2ethernets:ens33:  # 请将 ens33 替换为您的实际接口名称dhcp4: noaddresses:- 192.168.60.181/24  # 静态 IP 地址和子网掩码routes:- to: defaultvia: 192.168.60.2  # 默认网关地址nameservers:addresses:- 8.8.8.8- 8.8.4.4  # DNS 服务器地址

需要改正的参数

  • enp0s3：使用ip a查看网卡地址
  • addresse：改变需要配置的IP地址
  • via：更改网关

刷新配置

sudo netplan apply

我的配置

01-netcfg.yaml

network:version: 2ethernets:ens33:dhcp4: noaddresses:- 192.168.60.181/24routes:- to: defaultvia: 192.168.60.2nameservers:addresses:- 8.8.8.8- 8.8.4.4

动态IP的配置

network:ethernets:ens33:dhcp4: trueversion: 2
1.2、虚拟机配置静态IP

vmware虚拟机设置静态ip并且通过xshell连接参考：https://www.cnblogs.com/qq1141100952com/p/15745106.html

1.3、构建互相免密钥访问（使用rsa方式生成）

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

先确定/etc/hosts文件配置了node1、node2、node3、node4的

192.168.60.181  node01
192.168.60.182  node02
192.168.60.183  node03
192.168.60.184  node04

构建秘钥

ssh-keygen -t rsa -b 2048

赋值秘钥到其他节点上

ssh-copy-id root@node2
ssh-copy-id root@node3
ssh-copy-id root@node4

我的

ssh-copy-id peng@node02
ssh-copy-id peng@node01
ssh-copy-id peng@node03

2、安装NFS服务器

https://blog.csdn.net/ssp584731180/article/details/131113101

2.1、安装 NFS 和 NFS Utils
sudo apt update
sudo apt install -y nfs-kernel-server nfs-common

在 node01 上配置 NFS 服务

创建共享目录 /var/mpi4.0/（如果不存在）：

sudo mkdir -p /var/mpi4.0/

修改 NFS 配置文件，允许其他节点挂载该目录：

打开 /etc/exports 文件并添加如下内容：

/var/mpi4.0/ node02(rw,sync,no_subtree_check) node03(rw,sync,no_subtree_check) node04(rw,sync,no_subtree_check)

这行配置表示允许 node02、node03 和 node04 挂载该目录，并授予读写权限。

启动并使 NFS 服务开机自启：

sudo systemctl enable --now nfs-server

应用配置：

sudo exportfs -ra

验证共享：

sudo exportfs -v
2.2、在其他节点配置NFS

创建挂载目录 /var/mpi4.0/（与主节点路径一致）：

sudo mkdir -p /var/mpi4.0/

需要配置权限

sudo chmod 777 /var/mpi4.0

配置自动挂载：

打开 /etc/fstab 文件，添加以下内容

192.168.1.1:/var/mpi4.0/ /var/mpi4.0/ nfs defaults 0 0

此行配置会将 node01 的 /var/mpi4.0/ 目录挂载到本地的 /var/mpi4.0/，并设置开机自动挂载。

挂载目录

sudo mount -a

**验证挂载是否成功 **

df -h

应该能看到挂载在 /var/mpi4.0/ 的共享目录。

3、安装和测试MPI

3.1、安装MPI

下载MPI

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

解压

tar -xvf mpich-4.0.tar.gz
FCFLAGS=-fallow-argument-mismatch ./configure --prefix=/var/mpi4.0
./configure --prefix=/var/mpi4.0 --disable-fortran
make
sudo make install

配置环境变量

vi ~/.bashrc

# .bashrc
# User specific aliases and functions 
alias rm='rm -i'
alias cp='cp -i'
alias mv='mv -i'
PATH="$PATH:/var/mpi4.0/bin"  # 新增路径
# Source global definitions
if [ -f /etc/bashrc ]; then. /etc/bashrc
fi

刷新

source ~/.bashrc

验证路径是否正确配置

which mpicc
which mpiexec

创建主机名称集合文件

在 /var/mpi4.0/bin 下创建一个 csmpd.hosts 文件，内容如下：

node01
node02
node03
node04

测试（我的在）

在 /var/mpi4.0/examples/ 目录下可以找到一些示例程序。编译并运行其中一个：

mpicc -o my_mpi_example /var/mpi4.0/examples/cpi.c

运行时指定主机文件 csmpd.hosts：

mpiexec -np 4 -f /var/mpi4.0/bin/csmpd.hosts ./my_mpi_example
mpiexec -n 4 -f /var/mpi4.0/bin/csmpd.hosts /var/mpi4.0/code/hello
3.2、测试MPI
/*hello.c*/
#include <stdio.h>
#include "mpi.h"int main( int argc, char *argv[] )
{int rank;int size;MPI_Init( 0, 0 );MPI_Comm_rank(MPI_COMM_WORLD, &rank);MPI_Comm_size(MPI_COMM_WORLD, &size);printf( "Hello world from process %d of %d\n", rank, size );MPI_Finalize();return 0;
}

编译

mpicc –o hello hello.c

运行

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

实验三、运行5.4、5.5、5.7、5.8

程序5.4

/*文件名：who.c*/
#include "mpi.h"
#include <stdio.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);//获得本进程IDMPI_Comm_size(MPI_COMM_WORLD,&numprocs);//获得总的进程数目MPI_Get_processor_name(processor_name,&namelen);//获得本进程的机器名printf("Hello World! Process %d of %d on %s\n",myid, numprocs, processor_name);MPI_Finalize();
}

程序5.5

/*文件名：message.c*/
#include <stdio.h>
#include "mpi.h"
int main(int argc, char** argv)
{ int myid, numprocs, source;MPI_Status status;char message[100];MPI_Init(&argc, &argv);MPI_Comm_rank(MPI_COMM_WORLD, &myid);MPI_Comm_size(MPI_COMM_WORLD,&numprocs);if (myid != 0){strcpy(message, "Hello World!");//为发送字符串赋值//发送字符串时长度要加1，从而包括串结束标志MPI_Send(message,strlen(message)+1, MPI_CHAR, 0,99,MPI_COMM_WORLD);}else{//除0进程的其他进程接收来自于0进程的字符串数据for (source = 1; source < numprocs; source++){MPI_Recv(message, 100, MPI_CHAR, source, 99,MPI_COMM_WORLD, &status);printf("I am process %d. I recv string '%s' from process %d.\n", myid, message,source);}}MPI_Finalize();
}

程序5.7

/*文件名 inte.c*/
#define N 100000000
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "mpi.h"
int main(int argc, char** argv)
{int myid,numprocs;int i;double local=0.0;double inte,tmp=0.0,x;MPI_Init(&argc, &argv);MPI_Comm_rank(MPI_COMM_WORLD, &myid);MPI_Comm_size(MPI_COMM_WORLD,&numprocs);srand((int)time(0));//设置随机数种子
/*各节点分别计算一部分积分值*/
/*以下代码在不同节点运行的结果不同*/for(i=myid;i<N;i=i+numprocs){x=10.0*rand()/(RAND_MAX+1.0);//求函数值tmp=x*x/N;local=tmp+local;//各节点计算面积和}	
//计算总的面积和，得到积分值MPI_Reduce(&local,&inte,1,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD);if(myid==0){printf("The integal of x*x=%16.15f\n",inte);}MPI_Finalize();
}

程序5.8

/*文件名 myreduce.c*/
#define N 100000000
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "mpi.h"
void Myreduce(double *sendbuf, double *recvbuf,int count,int root);//定义自己的reduce函数
int main(int argc, char** argv)
{int myid,numprocs;int i;double local=0.0;double inte,tmp=0.0,x;MPI_Init(&argc, &argv);MPI_Comm_rank(MPI_COMM_WORLD, &myid);MPI_Comm_size(MPI_COMM_WORLD,&numprocs);
/*采用归约对y=x*x在[1,10]区间求积分*/srand((int)time(0));for(i=myid;i<N;i=i+numprocs){x=10.0*rand()/(RAND_MAX+1.0);tmp=x*x/N;local=tmp+local;}Myreduce(&local,&inte,1,0);//调用自定义的规约函数if(myid==0){printf("The integal of x*x=%16.15f\n",inte);}MPI_Finalize();
}
/*自定义的归约函数，sendbuf为发送缓冲区，recvbuf为接收缓冲区，count为数据个数，root为指定根节点*/
/*该函数实现归约求和的功能*/
void Myreduce(double *sendbuf,double *recvbuf,int count,int root)
{MPI_Status status;	int i;int myid,numprocs;*recvbuf=0.0;MPI_Comm_rank(MPI_COMM_WORLD, &myid);MPI_Comm_size(MPI_COMM_WORLD,&numprocs);double *tmp;//非root节点向root节点发送数据if(myid!=root){MPI_Send(sendbuf,count,MPI_DOUBLE,root,99,MPI_COMM_WORLD);}//root节点接收数据并对数据求和，完成规约操作if(myid==root){*recvbuf=*sendbuf;for(i=0;i<numprocs;i++){if(i!=root){MPI_Recv(tmp,count,MPI_DOUBLE,i,99,MPI_COMM_WORLD,&status); *recvbuf=*recvbuf+*tmp;}}}
}

实验四、卡布列克常数的MPI测试

思路

初始化 MPI 环境：使用 MPI_Init 初始化 MPI 环境，并获取每个节点的 rank 和总节点数 size。

分配任务：根据 rank 和 size 将四位数区间分割给不同的节点。比如，如果是 4 个节点，可以让每个节点负责一个子区间。

卡布列克运算：

  • 将当前数字分解成 4 位数的数组。
  • 排序并生成最大数和最小数。
  • 计算两者的差值，如果差值不为 6174，重复操作，直到达到 6174 或步骤达到上限。

输出结果：当一个数达到了 6174，打印步骤，结果，以及这个数所需的步骤数。

汇总与退出：所有节点完成计算后，MPI 程序结束，释放资源。

代码

kaprekar_mpi.c

#include <mpi.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>#define TARGET 6174// 对数字分解成千位、百位、十位和个位
void split_digits(int num, int digits[4]) {digits[0] = num / 1000;digits[1] = (num / 100) % 10;digits[2] = (num / 10) % 10;digits[3] = num % 10;
}// 排序数字数组
void sort_digits(int digits[4], int ascending) {for (int i = 0; i < 3; i++) {for (int j = i + 1; j < 4; j++) {if ((ascending && digits[i] > digits[j]) || (!ascending && digits[i] < digits[j])) {int temp = digits[i];digits[i] = digits[j];digits[j] = temp;}}}
}// 生成最大和最小数字
int form_number(int digits[4]) {return digits[0] * 1000 + digits[1] * 100 + digits[2] * 10 + digits[3];
}// 卡布列克猜想的核心算法
int kaprekar_routine(int num) {int steps = 0;while (num != TARGET && steps < 7) {int digits[4];split_digits(num, digits);sort_digits(digits, 0); // 降序排列int large = form_number(digits);sort_digits(digits, 1); // 升序排列int small = form_number(digits);num = large - small;steps++;}return steps;
}int main(int argc, char *argv[]) {MPI_Init(&argc, &argv);int rank, size;MPI_Comm_rank(MPI_COMM_WORLD, &rank);MPI_Comm_size(MPI_COMM_WORLD, &size);int start = 1000 + (9000 / size) * rank;int end = (rank == size - 1) ? 9999 : start + (9000 / size) - 1;printf("Node %d processing range %d to %d\n", rank, start, end);for (int i = start; i <= end; i++) {if (i % 1111 == 0) continue;  // 排除全相同的数int steps = kaprekar_routine(i);if (steps <= 7) {printf("Node %d: %d reaches 6174 in %d steps\n", rank, i, steps);}}MPI_Finalize();return 0;
}
  • split_digits：将数字分解为千、百、十、个位。
  • sort_digits：对数字数组进行排序，用于生成最大和最小数字。
  • form_number：将分解后的数字数组重新组合成整数。
  • kaprekar_routine：核心算法，计算每个四位数到达 6174 所需的步骤数。
  • MPI_Comm_rank 和 MPI_Comm_size：获取当前节点的编号和节点总数，以分配任务。

运行

  1. 先安装 MPI（例如使用 mpich 或 openmpi）。

  2. 编译代码：

    mpicc -o kaprekar_mpi kaprekar_mpi.c

  3. 运行代码（假设使用 4 个节点）：

    mpirun -np 4 ./kaprekar_mpi

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

思路

代码

以下代码实现了基于蒙特卡洛方法估算 π 值的 MPI 并行程序。程序将随机点生成和圆内点的计数分配给多个进程，每个进程独立计算局部结果，并将其汇总到主进程以得到最终 π 值。

#include <mpi.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>#define TOTAL_POINTS 1000000  // 每个进程要生成的总点数，可以根据需要调整int main(int argc, char **argv) { int myid, numprocs;long count = TOTAL_POINTS;long local_m = 0, global_m = 0;  // 局部和全局的圆内点数double x, y;double local_pi, pi_estimate;MPI_Init(&argc, &argv);MPI_Comm_rank(MPI_COMM_WORLD, &myid);  // 获取当前进程的进程号MPI_Comm_size(MPI_COMM_WORLD, &numprocs);  // 获取通信域中的总进程数srand(time(NULL) + myid);  // 设置随机种子，确保每个进程生成不同随机序列// 每个进程生成随机点并统计在单位圆内的点数for (long i = 0; i < count; i++) {x = (double)rand() / RAND_MAX;y = (double)rand() / RAND_MAX;if ((x * x + y * y) <= 1) {local_m++;}}// 计算局部 π 值local_pi = 4.0 * local_m / count;printf("Process %d of %d on pi = %f\n", myid, numprocs, local_pi);// 使用 MPI_Reduce 汇总所有进程的圆内点数MPI_Reduce(&local_m, &global_m, 1, MPI_LONG, MPI_SUM, 0, MPI_COMM_WORLD);// 主进程计算总 π 值if (myid == 0) {pi_estimate = 4.0 * global_m / (count * numprocs);printf("Estimated value of π: %f\n", pi_estimate);}MPI_Finalize();return 0;
}
  1. 设置随机数：每个进程通过 srand 设置不同的随机数种子，以确保生成的随机点不同。
  2. 蒙特卡洛方法计算 π 值
    • 每个进程独立生成 TOTAL_POINTS 个随机点 (x, y)。
    • 判断点是否在单位圆内，并统计圆内点数 local_m。
  3. MPI 汇总
    • 使用 MPI_Reduce 将各进程的 local_m 汇总到 global_m。
  4. 结果计算
    • 主进程 (myid == 0) 使用汇总的圆内点数计算 π 的近似值，并打印结果。

运行

将代码保存为 mtpi.c，然后在终端中进行编译和运行：

# 编译代码
mpicc -o mtpi mtpi.c# 使用 4 个进程运行
mpirun -np 4 ./mtpi

实验六、使用 MPI 技术验证角谷猜想

思路

角谷猜想（Collatz conjecture）是一个数学猜想，对任何一个正整数 n，若 n 为偶数，则把它除以 2，若 n 为奇数，则把它乘以 3 再加 1，得到一个新的数。对新的数重复上述步骤，最终总会得到 1。

代码

#include <mpi.h>
#include <stdio.h>void verify_collatz(long n) {while (n != 1) {if (n % 2 == 0) {n = n / 2;} else {n = 3 * n + 1;}}
}int main(int argc, char **argv) {int myid, numprocs;long start, end, range;long i;// 设置验证数据的范围long min_range = 1;long max_range = 100000;  // 可根据需求增大此数值，验证更大范围的数MPI_Init(&argc, &argv);MPI_Comm_rank(MPI_COMM_WORLD, &myid);    // 获取当前进程号MPI_Comm_size(MPI_COMM_WORLD, &numprocs); // 获取进程总数// 将范围划分给各个进程range = (max_range - min_range + 1) / numprocs;start = min_range + myid * range;end = (myid == numprocs - 1) ? max_range : start + range - 1;printf("Process %d is verifying numbers from %ld to %ld\n", myid, start, end);// 遍历每个数并验证角谷猜想for (i = start; i <= end; i++) {verify_collatz(i);}// 所有进程完成计算后输出结果if (myid == 0) {printf("Verification of the Collatz conjecture from %ld to %ld completed.\n", min_range, max_range);}MPI_Finalize();return 0;
}

verify_collatz 函数执行角谷猜想的验证过程。

主程序中，各个 MPI 进程会分配到一个范围的数字，分别验证这些数字是否满足角谷猜想。

各进程完成计算后，主进程（myid == 0）输出验证完成的消息。

运行

编译代码

mpicc -o collatz collatz.c

运行代码

mpirun -np 4 ./collatz

实验七、使用 MPI 技术验证亲和数组合的个数

思路

亲和数组合指的是满足一定条件的数对或数集合。这里的实验将并行计算所有可能的亲和数组合数量，通过划分数据范围来分配到不同的计算节点，并验证这些组合满足的特定亲和条件。

代码

#include <mpi.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>// 判断是否为亲和数组合
int is_amicable(int a, int b) {int sum_a = 0, sum_b = 0;for (int i = 1; i <= a / 2; i++) {if (a % i == 0) sum_a += i;}for (int i = 1; i <= b / 2; i++) {if (b % i == 0) sum_b += i;}return (sum_a == b && sum_b == a);
}int main(int argc, char **argv) {int myid, numprocs;long range_start, range_end, total_pairs = 0, local_pairs = 0;long range = 100000;  // 大范围以延长运行时间MPI_Init(&argc, &argv);MPI_Comm_rank(MPI_COMM_WORLD, &myid);    // 获取当前进程号MPI_Comm_size(MPI_COMM_WORLD, &numprocs); // 获取进程总数// 划分数据范围long range_per_proc = range / numprocs;range_start = myid * range_per_proc + 1;range_end = (myid == numprocs - 1) ? range : range_start + range_per_proc - 1;printf("Process %d is calculating from %ld to %ld\n", myid, range_start, range_end);// 计算亲和数组合数量for (long a = range_start; a <= range_end; a++) {for (long b = a + 1; b <= range; b++) {if (is_amicable(a, b)) {local_pairs++;}}}// 汇总所有进程的结果MPI_Reduce(&local_pairs, &total_pairs, 1, MPI_LONG, MPI_SUM, 0, MPI_COMM_WORLD);// 主进程输出结果if (myid == 0) {printf("Total number of amicable pairs in the range: %ld\n", total_pairs);}MPI_Finalize();return 0;
}

is_amicable 函数用于判断两个数是否为亲和数组合。若数 a 的因子和等于 b，且数 b 的因子和等于 a，则这两个数为亲和数组合。

主程序中，每个 MPI 进程被分配到一段范围来检查亲和数组合。

最终，通过 MPI_Reduce 汇总各进程的亲和数组合总数。

为了确保运行时间超过 20 分钟，可以适当调大 range 的值（例如，增加至 500000 或更大），从而增加计算复杂度和运行时间。

运行

编译代码

mpicc -o amicable_pairs amicable_pairs.c

运行代码

mpirun -np 4 ./amicable_pairs

使用Docker搭建并行计算环境

1、拉取镜像

docker pull ubuntu:22.04

2、启动镜像

docker run -d --name node1 -p 30001:22 ubuntu:22.04 sleep infinity
docker run -d --name node2 -p 30001:22 ubuntu:22.04 sleep infinity
docker run -d --name node3 -p 30001:22 ubuntu:22.04 sleep infinity
docker run -d --name node4 -p 30001:22 ubuntu:22.04 sleep infinity

查看运行中的容器

docker ps

进入节点

docker exec -it node1 /bin/bash

3、安装相关软件

安装ssh服务

apt install -y openssh-server
service ssh start

确保主机上的防火墙没有阻止访问映射的端口（如 2222）。你可以使用以下命令查看防火墙状态：

  • 对于 iptables：

    iptables -L

  • 对于 ufw（如果使用）：

    ufw status

如果端口被阻止，可以添加规则以允许访问：

ufw allow 2222

确保 SSH 配置文件 /etc/ssh/sshd_config 中允许使用密码进行身份验证：

PermitRootLogin yes
PasswordAuthentication yes

修改后，重启 SSH 服务以使更改生效：

service ssh restart

修改ubuntu的密码，修改密码后然后就可以使用xshell登录了。

passwd root

安装vim【可选】

apt install vim

安装net-tools【可选】

sudo apt install net-tools

安装iproute2【可选】

apt install -y iproute2

安装curl和wget【可选】

apt install -y curl
apt install -y wget

4、使用XShell连接

使用XShell批量连接节点

关键字：沈阳做网站的互联网公司_武汉房地产政策最新消息_手机网站建设公司_网络推广营销公司

版权声明:

本网仅为发布的内容提供存储空间，不对发表、转载的内容提供任何形式的保证。凡本网注明“来源：XXX网络”的作品，均转载自其它媒体，著作权归作者所有，商业转载请联系作者获得授权，非商业转载请注明出处。

我们尊重并感谢每一位作者，均已注明文章来源和作者。如因作品内容、版权或其它问题，请及时与我们联系，联系邮箱：809451989@qq.com，投稿邮箱：809451989@qq.com

责任编辑：
>> 相关文章
>> 热门图片
南宁定制网站制作价格_开发公司工程部绩效考核管理办法_网站快速优化排名_在线视频用什么网址
南宁定制网站制作价格_开发公司工程部绩效考核管理办法_网站快速优化排名_在线视频用什么网址
crm管理系统软件_网页ui设计师培训_怎么查权重查询_企业网站管理系统怎么操作
crm管理系统软件_网页ui设计师培训_怎么查权重查询_企业网站管理系统怎么操作
杭州产品网络推广方案_软件开发包括哪些_网站排名优化软件联系方式_浏阳廖主任打人案
杭州产品网络推广方案_软件开发包括哪些_网站排名优化软件联系方式_浏阳廖主任打人案
官方新闻平台有哪些_低价网站建设费用多少_百度指数下载手机版_网站收录大全
官方新闻平台有哪些_低价网站建设费用多少_百度指数下载手机版_网站收录大全
安卓手机app开发工具_中小型企业网络部署_seo优化网站优化_小辉seo
安卓手机app开发工具_中小型企业网络部署_seo优化网站优化_小辉seo
网络运维工程师面试题及答案_今日新闻头条新闻今天_做一个推广网站大概多少钱_正规的培训机构有哪些
网络运维工程师面试题及答案_今日新闻头条新闻今天_做一个推广网站大概多少钱_正规的培训机构有哪些
网站的内容规划怎么写_在线登录qq聊天入口_欧洲网站服务器_网络推广的手段
网站的内容规划怎么写_在线登录qq聊天入口_欧洲网站服务器_网络推广的手段
免费申请pos_开放平台是什么意思_查看别人网站的访问量_推广资源网
免费申请pos_开放平台是什么意思_查看别人网站的访问量_推广资源网
>> 热门搜索
评论排行
图片新闻
更多>>
设计图纸网站_辽宁建设工程信息网官网入口官方_重庆seo小z博客_衡阳seo服务
为啥找对象千万别找大厂男，还好我不是大厂的。。
seo优化方向_东莞人力资源招聘官网_seo网络排名优化哪家好_产品销售方案与营销策略
博主回应网络热梗_网页无法打开怎么办_淘宝关键词优化技巧_网站快速收录的方法
点击排行

邮箱：809451989@qq.com 网站地图
未经过本站允许,请勿将本站内容传播或复制