【MPI】点对点通信2

最新推荐文章于 2024-05-20 19:43:04 发布
最新推荐文章于 2024-05-20 19:43:04 发布
阅读量52 收藏
点赞数
分类专栏： 高性能计算 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43730667/article/details/131464247
版权

点对点通信

tag的使用

  1. tag使用是满足发送和接收完全匹配
    如果B先到达Q,如果没有tag匹配,则会放到X中.
    在这里插入图片描述
  2. 标签的使用
    使用Any_Tag可以都接收,然后用Status.Tag来确定是哪一个发送方.
    在这里插入图片描述
  3. 特殊的Tag
    在这里插入图片描述
#include<stdio.h>
#include<mpi.h>

int main(int argc, char* argv[]){
	int myrank, size;
	MPI_Init(&argc, &argv);
	MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
	MPI_Comm_size(MPI_COMM_WORLD, &size);
	
	if (myrank == 0){
	//指定0号进程发送数据
		int send_num = 99;
		int send_num1 = 100;
		int tag = 0;
		int tag1 = 1;
		MPI_Send(&send_num, 1, MPI_INT, 1, tag, MPI_COMM_WORLD);
		MPI_Send(&send_num1, 1, MPI_INT, 1, tag1, MPI_COMM_WORLD);
	}
	else{
	//指定1号进程接收数据
		int recv_num = 0;
		int recv_num1 = 0;
		int tag = MPI_ANY_TAG;
		MPI_Status status;
		printf("before recv, recv_num = %d\n", recv_num);
		MPI_Recv(&recv_num, 1, MPI_INT, MPI_ANY_SOURCE, tag, MPI_COMM_WORLD, &status);
		// 两者组合任意消息都可以接收 
		// 实际上99和100不一定谁先到达
		MPI_Recv(&recv_num1, 1, MPI_INT, 0, tag, MPI_COMM_WORLD, &status);
		printf("after recv, recv_num = %d\n", recv_num);
		printf("after recv, recv_num = %d\n", recv_num1);
	}
	MPI_Finalize();
	return 0;
  1. 存在的问题
  • 阻塞式,同时都在等recv,永远不会结束,死锁问题
  • 能选择非阻塞则要选择非阻塞,对通信过程要有了解
    在这里插入图片描述

练习1:Jacobi迭代

  1. 采用阻塞式通讯接口
    在这里插入图片描述
#include<stdio.h>
#include<mpi.h>
#inlcude<stdlib.h>
#include<unistd.h>

#define N 8
#define SIZE N / 4
#define T 2
void print_myRows(int, float [][N]);
int main(int argc, char* argv[]){
	int myid, size;
	float myRows[SIZE + 2][N], myRows2[SIZE+2][N], tmp[2][N], c[N][N];
	
	MPI_Init(&argc, &argv);
	MPI_Comm_rank(MPI_COMM_WORLD, &myid);
	MPI_Comm_size(MPI_COMM_WORLD, &size);
    MPI_Status status;
	
	// 初始化数据
	int i, j;
	for (i = 0; i < SIZE + 2; i ++){
		for (j = 0; j < N; j ++){
			myRows[i][j] = myRows2[i][j] = 0;
		}
    }
	
	if (myid == 0){
		for (j = 0; j < N; j ++)
			myRows[1][j] = 8.0;
	}
	if (myid == 3){
		for (j = 0; j < N; j ++)
			myRows[2][j] = 8.0;
	}
	for (i = 1; i < SIZE + 1; i ++){
		myRows[i][0] = 8.0;
		myRows[i][N - 1] = 8.0;
	}

	// 实际迭代过程 0->1->2->3 3->2->1->0
	int step;
	int tag_down = 0, tag_up = 1;
	for (step = 0; step < T; step ++){
		// 数据传输
		if (myid < 3){
			MPI_Send(&myRows[SIZE][0], N, MPI_FLOAT, myid + 1, tag_down, MPI_COMM_WORLD);
		}
		if (myid > 0){
			MPI_Recv(&myRows[0][0], N, MPI_FLOAT, myid - 1, tag_down, MPI_COMM_WORLD, &status);
		}
		if (myid > 0){
			MPI_Send(&myRows[1][0], N, MPI_FLOAT, myid - 1, tag_up, MPI_COMM_WORLD);
		}
		if (myid < 3){
			MPI_Recv(&myRows[SIZE + 1][0], N, MPI_FLOAT, myid + 1, tag_up, MPI_COMM_WORLD, &status);
		}
		// 数据迭代
		// 第一个和最后一个进程取值
		int begin_row = (0 == myid) ? 2 : 1;
		int end_row = (3 == myid)? 1 : 2;
		for (i = begin_row; i <= end_row; i ++){
			for (int j = 1; j < N - 1; j ++){
				myRows2[i][j] = 0.25 * (myRows[i - 1][j] + myRows[i + 1][j] + myRows[i][j + 1] + myRows[i][j - 1]);
			}
		}
		for (i = begin_row; i <= end_row; i ++){
			for (int j = 1; j < N - 1; j ++){
				myRows[i][j] = myRows2[i][j];
		    }
	    }
    }
	sleep(myid);
	
    print_myRows(myid, myRows);
    // if (myid == 1) sleep(1);
	for (int i = 1; i < SIZE + 1; i ++){
		for (int j = 0; j < N; j ++){
			tmp[i - 1][j] = myRows[i][j];
		}
	}
    // MPI_Barrier(MPI_COMM_WORLD);
	MPI_Gather(tmp, 16, MPI_FLOAT, c, 16, MPI_FLOAT, 0, MPI_COMM_WORLD);
    
    // 输出结果
	if (0 == myid){
		fprintf(stderr, "\n收集后结果\n");
		for (int i = 0; i < N; i ++){
			for (int j = 0; j < N; j ++){
				fprintf(stderr, "%.3f\t", c[i][j]);
			}
			fprintf(stderr, "\n");
		}
		fprintf(stderr, "\n");
	}
	MPI_Finalize();
	return 0;
}

void print_myRows(int myid, float myRows[][N]){
	int i, j;
	printf("Result in process %d:\n", myid);
	for (i = 0; i < SIZE + 2;i ++){
		for (j = 0; j < N; j ++){
			printf("%1.3f\t", myRows[i][j]);
		}
		printf("\n");
	}
	MPI_Barrier(MPI_COMM_WORLD);
}
  1. MPI_Sendrecv捆绑发送接收
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    由于第一个进程无上方进程,最后一个进程无下方进程,所以引入了虚拟进程.
    在这里插入图片描述
    可以完成接收操作,不会改变之前接受的数据.
    在这里插入图片描述
#include<stdio.h>
#include<mpi.h>
#include<stdlib.h>
#include<unistd.h>

#define N 8
#define SIZE N / 4
#define T 2
void print_myRows(int, float [][N]);
int main(int argc, char* argv[]){
	int myid, size;
	float myRows[SIZE + 2][N], myRows2[SIZE+2][N], tmp[2][N], c[N][N];
	
	MPI_Init(&argc, &argv);
	MPI_Comm_rank(MPI_COMM_WORLD, &myid);
	MPI_Comm_size(MPI_COMM_WORLD, &size);
    MPI_Status status;
	
	// 初始化数据
	int i, j;
	for (i = 0; i < SIZE + 2; i ++){
		for (j = 0; j < N; j ++){
			myRows[i][j] = myRows2[i][j] = 0;
		}
    }
	
	if (myid == 0){
		for (j = 0; j < N; j ++)
			myRows[1][j] = 8.0;
	}
	if (myid == 3){
		for (j = 0; j < N; j ++)
			myRows[2][j] = 8.0;
	}
	for (i = 1; i < SIZE + 1; i ++){
		myRows[i][0] = 8.0;
		myRows[i][N - 1] = 8.0;
	}

	// 实际迭代过程 0->1->2->3 3->2->1->0
    int step;
	int tag_down = 0, tag_up = 1;
	int up_proc_id = (0 == myid) ? MPI_PROC_NULL:(myid - 1);
	int down_proc_id = (3 == myid) ? MPI_PROC_NULL:(myid + 1);
	for (step = 0; step < T; step ++){
		// 数据传输
		// 数据向下方移动
		MPI_Sendrecv(&myRows[SIZE][0], 8, MPI_FLOAT, down_proc_id, tag_down, &myRows[0][0], 8, MPI_FLOAT, up_proc_id, tag_down, MPI_COMM_WORLD, &status);
		// 数据向上方移动
		MPI_Sendrecv(&myRows[1][0], 8, MPI_FLOAT, up_proc_id, tag_up, &myRows[SIZE + 1][0], 8, MPI_FLOAT, down_proc_id, tag_up, MPI_COMM_WORLD, &status);
		// 数据迭代
		// 第一个和最后一个进程取值
		int begin_row = (0 == myid) ? 2 : 1;
		int end_row = (3 == myid)? 1 : 2;
		for (i = begin_row; i <= end_row; i ++){
			for (int j = 1; j < N - 1; j ++){
				myRows2[i][j] = 0.25 * (myRows[i - 1][j] + myRows[i + 1][j] + myRows[i][j + 1] + myRows[i][j - 1]);
			}
		}
		for (i = begin_row; i <= end_row; i ++){
			for (int j = 1; j < N - 1; j ++){
				myRows[i][j] = myRows2[i][j];
		    }
	    }
    }
	sleep(myid);
	
    print_myRows(myid, myRows);
	
    // if (myid == 1) sleep(1);
	for (int i = 1; i < SIZE + 1; i ++){
		for (int j = 0; j < N; j ++){
			tmp[i - 1][j] = myRows[i][j];
		}
	}
    // MPI_Barrier(MPI_COMM_WORLD);
	MPI_Gather(tmp, 16, MPI_FLOAT, c, 16, MPI_FLOAT, 0, MPI_COMM_WORLD);
    
    // 输出结果
	if (0 == myid){
		fprintf(stderr, "\n收集后结果\n");
		for (int i = 0; i < N; i ++){
			for (int j = 0; j < N; j ++){
				fprintf(stderr, "%.3f\t", c[i][j]);
			}
			fprintf(stderr, "\n");
		}
		fprintf(stderr, "\n");
	}
    
	MPI_Finalize();
	return 0;
}

void print_myRows(int myid, float myRows[][N]){
	int i, j;
	printf("Result in process %d:\n", myid);
	for (i = 0; i < SIZE + 2;i ++){
		for (j = 0; j < N; j ++){
			printf("%1.3f\t", myRows[i][j]);
		}
		printf("\n");
	}
	MPI_Barrier(MPI_COMM_WORLD);
}
  1. 主从模式
    0进程:负责初始化数组,然后发送给1234进程.最后接收结果
    其他进程:负责接收初始化数组,并且进行与其他进程通信计算,结果再返回0号进程
    在这里插入图片描述
#include<stdio.h>
#include<mpi.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>

#define N 8
#define SIZE N / 4
#define T 2

MPI_Status status;
float oriA[N][N], myRows[SIZE + 2][N], myRows2[SIZE+2][N],c[N][N];

void print_myRows(int, float [][N]);

// 主进程，分发和收集
void master(){
    memset(&oriA[0][0], 0, sizeof(float) * N * N);
    for (int i = 0; i < N; i ++){
        oriA[0][i] = 8.0;
        oriA[N - 1][i] = 8.0;
        oriA[i][0] = 8.0;
        oriA[i][N - 1] = 8.0;
    }
    for (int i = 0; i < 4; i ++){
        MPI_Send(&oriA[i * 2][0], N * 2, MPI_FLOAT, i + 1, i + 1, MPI_COMM_WORLD);
    }
    for (int i = 0; i < 4; i ++){
        MPI_Recv(&c[i * 2][0], N * 2, MPI_FLOAT, i + 1, i + 1, MPI_COMM_WORLD, &status);
    }
    
}

void slave(int myid){
    memset(&myRows[0][0], 0, sizeof(float) * N * (SIZE + 2));
    MPI_Recv(&myRows[1][0], N * 2, MPI_FLOAT, 0, myid, MPI_COMM_WORLD, &status);
    // 实际迭代过程 0->1->2->3 3->2->1->0
    int step;
	int tag_down = 0, tag_up = 1;
	int up_proc_id = (1 == myid) ? MPI_PROC_NULL:(myid - 1);
	int down_proc_id = (4 == myid) ? MPI_PROC_NULL:(myid + 1);
	for (step = 0; step < T; step ++){
		// 数据传输
		// 数据向下方移动
		MPI_Sendrecv(&myRows[SIZE][0], 8, MPI_FLOAT, down_proc_id, tag_down, &myRows[0][0], 8, MPI_FLOAT, up_proc_id, tag_down, MPI_COMM_WORLD, &status);
		// 数据向上方移动
		MPI_Sendrecv(&myRows[1][0], 8, MPI_FLOAT, up_proc_id, tag_up, &myRows[SIZE + 1][0], 8, MPI_FLOAT, down_proc_id, tag_up, MPI_COMM_WORLD, &status);
		// 数据迭代
		// 第一个和最后一个进程取值
		int begin_row = (1 == myid) ? 2 : 1;
		int end_row = (4 == myid)? 1 : 2;
		for (int i = begin_row; i <= end_row; i ++){
			for (int j = 1; j < N - 1; j ++){
				myRows2[i][j] = 0.25 * (myRows[i - 1][j] + myRows[i + 1][j] + myRows[i][j + 1] + myRows[i][j - 1]);
			}
		}
		for (int i = begin_row; i <= end_row; i ++){
			for (int j = 1; j < N - 1; j ++){
				myRows[i][j] = myRows2[i][j];
		    }
	    }
    }
    sleep(myid);
    print_myRows(myid, myRows);
    MPI_Send(&myRows[1][0], 2 * N, MPI_FLOAT, 0, myid, MPI_COMM_WORLD);
}

int main(int argc, char* argv[]){
	int myid, size;
	
	MPI_Init(&argc, &argv);
	MPI_Comm_rank(MPI_COMM_WORLD, &myid);
	MPI_Comm_size(MPI_COMM_WORLD, &size);

    if (size != 5){
        printf("Use 5 processes to run Master slave mode!\n");
        MPI_Abort(MPI_COMM_WORLD, 1); // 终止程序，给一个信后
    }

    if (0 == myid){
        master();
    }else{
        slave(myid);
    }
        // 输出结果
	if (0 == myid){
		fprintf(stderr, "\n收集后结果\n");
		for (int i = 0; i < N; i ++){
			for (int j = 0; j < N; j ++){
				fprintf(stderr, "%.3f\t", c[i][j]);
			}
			fprintf(stderr, "\n");
		}
		fprintf(stderr, "\n");
	}
    MPI_Finalize();
	return 0;
}



void print_myRows(int myid, float myRows[][N]){
	int i, j;
	printf("Result in process %d:\n", myid);
	for (i = 0; i < SIZE + 2;i ++){
		for (j = 0; j < N; j ++){
			printf("%1.3f\t", myRows[i][j]);
		}
		printf("\n");
	}
	// MPI_Barrier(MPI_COMM_WORLD);
}

任务1

任务描述

编写MPI程序，求和1+2+3+……+100。
要求：
1、使用两个进程
2、进程0计算1+2+…+20，进程1计算21+22+…+100
3、调用计时函数，分别输出两个进程的计算时间。
4、输出两个进程的计算结果，要求结果加起来等于5050

代码


```cpp
#include<stdio.h>
#include<mpi.h>
#include<sys/time.h>
#include<iostream>

int main(int argc, char* argv[]){
    int myrank, size;
    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
    MPI_Comm_size(MPI_COMM_WORLD, &size);
    //struct timeval time_start, time_end;
    double pStart, pEnd;

    if (myrank == 0){
        int a = 0;
        int b = 0;
        int sum = 0;
        int tag = 0;
        MPI_Status status;
        pStart =  MPI_Wtime();
        //gettimeofday(&time_start, NULL);
        for (int i = 1; i <= 20; i ++) a += i;
        //gettimeofday(&time_end, NULL);
        pEnd = MPI_Wtime();
        MPI_Recv(&b, 1, MPI_INT, 1, tag, MPI_COMM_WORLD, &status);
        //printf("rank 0 used time %ld us \n",  time_end.tv_usec - time_start.tv_usec);
        printf("rank 0 耗时 %lf 秒", pEnd - pStart);
        //std::cout << "rank 0 耗时" << pEnd - pStart << "秒" << std::endl;
        printf("rank 0 result is %d, rank 1 result is %d, sum is %d \n", a, b, a + b);
    }else{
        int b = 0;
        int tag = 0;
        pStart = MPI_Wtime();
        for (int i = 21; i <= 100; i ++) b += i;
        //gettimeofday(&time_end, NULL);
        pEnd = MPI_Wtime();
        MPI_Send(&b, 1, MPI_INT, 0, tag, MPI_COMM_WORLD);
        //printf("rank 1 used time %ld us \n",  time_end.tv_usec - time_start.tv_usec);
        printf("rank 1 耗时 %lf 秒", pEnd - pStart);
        //std::cout << "rank 1 耗时"<<  pEnd - pStart << "秒" << std::endl;
    }
    MPI_Finalize();
    return 0;
}
张西瓜.�
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于Linux集群架构的MPI点对点通信研究.pdf
09-06
基于Linux集群架构的MPI点对点通信研究.pdf
MPI 点对点通信
帅比王的博客
07-21 3325
定义 点对点通信是两个进程之间的通信，从源进程发送消息到目标进程。通信是发生在同一个通信器内，并且进程可以通过其在通信器内的标号标识。 MPI 系统的通信方式都是建立在点对点通信之上。 阻塞式点对点通信 阻塞式点对点通信主要涉及四个函数： MPI_SEND MPI_Recv MPI_Get_count（查询接收到的消息长度） MPI_Sendrecv（捆绑发送和接受） 消息 MPI 消息包括信封和数据两个部分。信封指出了发送或接收消息的对象及相关信息，而数据是本消息将要传递的内容。信封和数据又分别包括三个部
MPI点对点标准通信
MXH的博客
06-01 469
MPI点对点标准通信 1.先来熟悉一下MPI运行环境以及进程分配 /* * MPI hello * MPI_COMM_WORLD * MPI_Init &amp;amp; MPI_Finalize &amp;amp; MPI_Comm_size &amp;amp; MPI_Comm_rank * */ #include&amp;lt;stdio.h&amp;gt; #include&amp;lt;mpi.h&amp;gt; int
MPI 之 点对点通信的一个实例
qq_39709535的博客
09-27 2556
目标：通过MPI 实现100次 点对点通信，并计算平均每次的通信时间。 代码如下： /**点对点通信100次，计算平均通信时间，并观察传输数据量大小和传输时间关系 数据量变化采用动态内存方式 从4kb增加到400M,每次增大400kb **/ #include&lt;stdio.h&gt;//标准输入输出头文件 #include&lt;stdlib.h&gt;//标准库 #incl...
MPI: 点对点通信(Point-to-Point communication)
weixin_42849849的博客
12-07 855
MPI点对点通信(Point-to-Point communication)
MPI点到点通信
高阶近似的博客
11-09 1654
MPI点到点通信总述阻塞通信通信模式阻塞同步发送基本原理不足阻塞就绪发送基本原理不足阻塞缓冲发送基本原理不足阻塞标准发送消息大小小于设定的阈值基本原理不足消息大小大于设定的阈值MPI_Sendrecv 和 MPI_Sendrecv_replace非阻塞通信非阻塞标准发送消息大小小于设定的阈值消息大小大于设定的阈值 本文参考了链接Discussion: MPI Basic Point to Point Communication I (mtsu.edu) 总述 在MPI中，点到点通信分为阻塞通信和非阻塞通信。
MPI通信——点对点通信
JackieFrederickHYZ的博客
05-27 2359
一对进程之间的数据转换，也就是说一边发送数据另一边接收数据，点到点通信是MPI通信机制的基础，它分为同步通信和异步通信二种机制。 阻塞式函数 1.       int MPI_send(void *buf,int count,MPI_Datatype datatype,int dest,int tag,MPI_Comm comm) IN      buf      所要发送消息数
MPI笔记（二）点对点通信
David
04-16 3196
1. 阻塞消息通信 /* 2. 点对点通信 阻塞发送：MPI_Send(buffer,count,type,dest,tag,comm) 非阻塞发送：MPI_Isend(buffer,count,type,dest,tag,comm,request) 阻塞接收：MPI_Recv(buffer,count,type,source,tag,comm,status) 非阻塞接收：MPI_Irec...
MPI—点对点通信
LY_624的专栏
11-14 898
// MPI1.cpp : 定义控制台应用程序的入口点。 //MPI点对点通信 #include "stdafx.h" #include "mpi.h" #include #include #define BUFLEN 512 int main(int argc, char * argv[]) { int myid,numprocs,next; char buffer[BUFLEN]
mpi点对点通信求函数积分
我的博客
03-21 619
mpi简介 MPI是Message Passing Interface的缩写，MPI是一个跨语言的通讯协议，用于编写并行计算机。支持点对点和广播。MPI是一个信息传递应用程序接口，包括协议和和语义说明，他们指明其如何在各种实现中发挥其特性。MPI的目标是高性能，大规模性，和可移植性。 MPI 点对点通信实验 求函数的积分 我们知道求一个函数的积分可以转换为求函数与坐标轴之间的面积。如下图： 我...
MPI——通信集合
绝尘
09-19 5081
通信集合 树形结构通信 一开始1、3、5、7号进程都将它们的值发送给0、2、4、6。然后0、2、4、6进程都将接收到的值加到它们自己原有的值，整个过程重复两次。 但是这个解决的方案不是最理想的，因为其中一半的进程的工作量与原来方案相同。原来的方案需要0号进程接收comm_sz-1=7次。而新的方案中0号进程只需要3次接收和3次加法，并且其他进程所有的接收与加法操作不超过2次。所以，如果所有进程几...
梯形积分法的MPI实现
06-14
实现梯形积分法的MPI编程并掌握MPI编程方法，探讨了不同规模对不同实现方式的影响。。。。。。。。。
mpi 1.1 并行计算环境 并行算法
04-15
reconvened to correct errors and make clarifications in the MPI document of May 5, 1994, referred to below as Version 1.0. These discussions resulted in Version 1.1, which is this document. The ...
论文研究-基于FC-TR网络的MPI通信性能优化研究.pdf
07-22
为了给上层的MPI并行应用程序提供更快的基于信令寻径式光纤通道交换网络（FC-TR网络）的通信支持，针对FC-VIA-MPI进行了通信性能优化，对点对点通信的实现提出了新的优化方法，尽量把同一节点内进程之间的网络通信...
基于MPI环境的并行程序设计
05-13
MPI(Message Passing Interface)是消息传递并 行程序设计的标准之一，由MPI论坛开发，当前...正在制定的MPI2. 0规范除 支持消息传递外，还支持MPI的I/O规范和进程管 理规范。MPI正成为并行程序设计事实上的工业 标准。
C语言.动态内存管理
Joseit的博客
05-16 587
栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS(操作系统)回收。分配方式类似于链表。数据段（静态区）：（static）存放全局变量、静态数据。程序结束后由系统释放。
c语言操作注意事项
最新发布
dropLin的博客
05-20 112
如果取数据的缓存变量是结构体中的成员，比如。这样操作有可能会造成内存溢出，报硬件中断。主要是用于格式化获取字符串中的数据，来设置1个字节对齐，即不能设置为。这时的结构体类型定义不能加。
C语言之函数指针（持续更新）
qq_47607743的博客
05-20 252
C语言指针
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 896
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
如何通过MPI实现服务器之间的通信
07-13
通信域可以定义不同的通信方式，例如广播、点对点通信等。 4. 发送和接收消息：使用MPI_Send和MPI_Recv函数进行消息的发送和接收。你可以指定源服务器、目标服务器和消息标识符来确保消息被正确传递。 5. 同步操作...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值