【MPI】非阻塞通信(点对点)

最新推荐文章于 2024-07-01 00:07:07 发布
最新推荐文章于 2024-07-01 00:07:07 发布
阅读量211 收藏
点赞数
文章标签： 服务器 网络 linux c++ 矩阵
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43730667/article/details/131473728
版权

👍一. 非阻塞通信

非阻塞通信的完成与检测

  1. any 任意一个
  2. some 多个
  3. all 全部完成
    在这里插入图片描述
    在这里插入图片描述

Jacobi迭代4:非阻塞

  1. 阻塞版本分析
    需要对于不同进程边界数据进行传输,因此想改变通信和计算能够重叠的功能,可以先计算边界数据,然后开启数据传输的同时计算.不同的算法,这种方式不一定好去做,Jacobi是没有依赖关系的.
    在这里插入图片描述
#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[4], status1;
    MPI_Request request[4];
	
	// 初始化数据
	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] = myRows2[1][j] = 8.0;
	}
	if (myid == 3){
		for (j = 0; j < N; j ++)
			myRows[2][j] = myRows2[2][j] = 8.0;
	}
	for (i = 1; i < SIZE + 1; i ++){
		myRows[i][0] = myRows2[i][0] = 8.0;
		myRows[i][N - 1] = myRows2[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);
    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, &status1);
    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, &status1);
	for (step = 0; step < T; step ++){        
        // 先计算边界数据,因为初始化的时候边界还没有数据，所以迭代之前要先传输一下
        if (myid == 0){
            for (int j = 1; j < N - 1; j ++) myRows2[2][j] = 0.25 * (myRows[1][j] + myRows[3][j] + myRows[2][j + 1] + myRows[2][j - 1]);
        }else if (myid == 3){
            for (int j = 1; j < N - 1; j ++) myRows2[1][j] = 0.25 * (myRows[0][j] + myRows[2][j] + myRows[1][j + 1] + myRows[1][j - 1]);
        }else{
            for (int i = 1; i <= 2; 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]);
            }
        }

        MPI_Isend(&myRows2[2][0], 8, MPI_FLOAT, down_proc_id, tag_down, MPI_COMM_WORLD, &request[0]);
        MPI_Irecv(&myRows2[0][0], 8, MPI_FLOAT, up_proc_id, tag_down, MPI_COMM_WORLD, &request[1]);

        MPI_Isend(&myRows2[1][0], 8, MPI_FLOAT, up_proc_id, tag_up, MPI_COMM_WORLD, &request[2]);
        MPI_Irecv(&myRows2[3][0], 8, MPI_FLOAT, down_proc_id, tag_up, MPI_COMM_WORLD, &request[3]);

        // 计算剩余数据，但是计算边界数据的时候，所有的迭代数据已经全部计算完成

        // 更新矩阵
        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 ++){
				myRows[i][j] = myRows2[i][j];
		    }
	    }
        
        // 等待所有非阻塞对象完成
        MPI_Waitall(4, &request[0], &status[0]);
    }
	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. 16行版本,加上迭代计算非边界的时候
  • 如果计算剩余时间和通信时间相等,能够很好地隐藏通信时间
  • 网格或者矩阵比较大,一般边界计算和通信时间很短,剩余计算花费时间很长
  • 所以通过非阻塞通信能够隐藏
  • 如果循环很多次,需要多次调用MPI_Isend MPI_Irecv,需要分配缓存 初始化 分配端口,一系列过程需要每次循环都要重新开始
#include<stdio.h>
#include<mpi.h>
#include<stdlib.h>
#include<unistd.h>

#define N 16
#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[4], status1;
    MPI_Request request[4];
	
	// 初始化数据
	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] = myRows2[1][j] = 8.0;
	}
	if (myid == 3){
		for (j = 0; j < N; j ++)
			myRows[SIZE - 1][j] = myRows2[SIZE - 1][j] = 8.0;
	}
	for (i = 1; i < SIZE + 1; i ++){
		myRows[i][0] = myRows2[i][0] = 8.0;
		myRows[i][N - 1] = myRows2[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);
    MPI_Sendrecv(&myRows[SIZE][0], N, MPI_FLOAT, down_proc_id, tag_down, &myRows[0][0], N, MPI_FLOAT, up_proc_id, tag_down, MPI_COMM_WORLD, &status1);
    MPI_Sendrecv(&myRows[1][0], N, MPI_FLOAT, up_proc_id, tag_up, &myRows[SIZE + 1][0], N, MPI_FLOAT, down_proc_id, tag_up, MPI_COMM_WORLD, &status1);
	for (step = 0; step < T; step ++){        
        // 先计算边界数据,因为初始化的时候边界还没有数据，所以迭代之前要先传输一下
        if (myid == 0){
            for (int j = 1; j < N - 1; j ++) myRows2[SIZE][j] = 0.25 * (myRows[SIZE - 1][j] + myRows[SIZE + 1][j] + myRows[SIZE][j + 1] + myRows[SIZE][j - 1]);
        }else if (myid == 3){
            for (int j = 1; j < N - 1; j ++) myRows2[1][j] = 0.25 * (myRows[0][j] + myRows[2][j] + myRows[1][j + 1] + myRows[1][j - 1]);
        }else{
            for (int j = 1; j < N - 1; j ++){
                myRows2[1][j] = 0.25 * (myRows[0][j] + myRows[2][j] + myRows[0][j + 1] + myRows[0][j - 1]);
                myRows2[SIZE][j] = 0.25 * (myRows[SIZE -1 ][j] + myRows[SIZE + 1][j] + myRows[SIZE][j + 1] + myRows[SIZE][j - 1]);
            } 
        }

        MPI_Isend(&myRows2[SIZE][0], N, MPI_FLOAT, down_proc_id, tag_down, MPI_COMM_WORLD, &request[0]);
        MPI_Irecv(&myRows2[0][0], N, MPI_FLOAT, up_proc_id, tag_down, MPI_COMM_WORLD, &request[1]);

        MPI_Isend(&myRows2[1][0], N, MPI_FLOAT, up_proc_id, tag_up, MPI_COMM_WORLD, &request[2]);
        MPI_Irecv(&myRows2[SIZE + 1][0], N, MPI_FLOAT, down_proc_id, tag_up, MPI_COMM_WORLD, &request[3]);

        // 计算剩余数据，但是计算边界数据的时候，所有的迭代数据已经全部计算完成
        int begin = 2;
        int end = SIZE - 1;
        for (int i = begin; i <= end; 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]);
            }
        }
        // 更新矩阵
        int begin_row = (0 == myid) ? 2 : 1;
		int end_row = (3 == myid)? SIZE - 1 : SIZE;
        for (i = begin_row; i <= end_row; i ++){
			for (int j = 1; j < N - 1; j ++){
				myRows[i][j] = myRows2[i][j];
		    }
	    }
        
        // 等待所有非阻塞对象完成
        MPI_Waitall(4, &request[0], &status[0]);
    }
	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, 64, MPI_FLOAT, c, 64, 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. 重复非阻塞通信
  • 上述都是一样的,只是每次的发送数据时不同的
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

Jacobi迭代总结

  • 阻塞消息通信版本
    • 代码繁琐,存在死锁可能性
  • 基于捆绑消息通信版本
    • 引入虚拟进程,MPI维护消息发送次序
  • 非阻塞消息通信版本
    • 优化性能,流程复杂度高
  • 重复非阻塞消息通信版本
    • 优化通信,提前初始化通信

MPI_WAIT/MPI_TEST

根据使用时机有不同的效果,MPI_WAIT等待所有完成.

张西瓜.�
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
学习笔记：MPI非阻塞通信
10-19 2115
学习笔记-MPI非阻塞通信 非阻塞通信主要用于计算和通信的重叠。 在非阻塞通信中，同样有之前提到的四种通信模式，其效果是将非阻塞通信的基本特征和具体的通信模式相结合后的综合体现。 非阻塞通信模式 发送 接收 标准 MPI_Isend MPI_Irecv 缓存 MPI_Ibsend MPI_Irecv 同步 MPI_Issend MPI_Irecv 就绪 MPI_Irse...
MPI-3 非阻塞集合通信
自可乐的博客
06-19 722
本文从本人简书博客同步过来 在上一篇中我们概要地介绍了最新的 MPI-3 标准中引进的新特性，mpi4py 3.0.0 支持 MPI-3 的很多新特性，我们将在后面逐步介绍，下面我们首先介绍 mpi4py 中的非阻塞集合通信。 在前面我们介绍了 mpi4py 中的集合通信，不过前面介绍的是 MPI-1 和 MPI-2 标准下的集合通信方法，所有这些方法都是阻塞式的，在通信没有完成之前，这些方法...
MPI非阻塞式点对点通信
最新发布
weixin_74939789的博客
07-01 675
非阻塞通信是一种通信方式，允许程序在消息发送或接收的过程中，不必等待操作完成而继续执行其他任务。这种方式能够提高并行程序的效率，因为程序不再因为等待通信完成而停滞。与之相对的是阻塞通信，它要求程序必须等待消息传递完成后才能继续执行。
3. 初探MPI——（非阻塞）点对点通信
qq_43067403的博客
05-09 1007
非阻塞式点对点通信
mpi4py 点到点通信之非阻塞通信
自可乐的博客
03-25 510
本文从本人简书博客同步过来 在上一篇中我们介绍了 mpi4py 中同步阻塞通信模式，下面我们将进入到对非阻塞通信模式的介绍。 非阻塞通信将通信和计算进行重叠，在一些情况下可以大大改善性能。特别是在那些具有独立通信控制硬件的系统上，将更能发挥其优势。 非阻塞通信需要通过发送操作的 start 函数启动发送，但并不要求操作立即执行和结束，启动发送操作的 start 调用在 MPI 环境从发送数据...
MPI非阻塞通信使用、性能分析与实现原理
qq100440110的专栏
08-03 8044
非阻塞通信： 异步通信通常是使MPI应用程序实现高性能计算的关键，使用异步通信具有如下优势： 1）函数是非阻塞的，这使得进程在与另一个进程通信的同时继续参与计算； 2）如果应用适当，可以绕过MPI的内部buffers，极大地提高程序的通信带宽； 最常见的基本的非阻塞调用就是MPI_Isend和MPI_Irecv MPI_Isend的使用 与同步版本的MPI_Send不同，MPI
MATLAB_并行程序的设计方法_消息传递编程_GPU软硬件架构_点对点通信，阻塞和非阻塞通信，聚合通信_并行化开销，嵌套训练
06-06
近年来，由于频率墙和功耗墙的存在，计算机计算性能的提升主要依赖于计算核心数量的增加，这使得传统的串行算法设计逐步转向基于多核和众核的并行算法设计，越多越多的应用领域，特别是... MPI并行程序设计开发，点对
mpi 1.1 并行计算环境 并行算法
04-15
- **点对点通信**：MPI提供了点对点通信功能，使得两个进程之间能够直接发送和接收消息，这对于实现复杂的并行算法至关重要。 - **集群通信**：除了点对点通信外，MPI还支持多进程之间的广播、收集、散播等集群通信...
MPI.zip_linux mpi
09-21
3. **消息传递**：消息可以是任意大小的数据块，且支持阻塞和非阻塞通信模式，以及点对点和集合通信。 4. **集合操作**：如`MPI_Reduce`用于执行诸如求和、最大值等操作，`MPI_Scatter`和`MPI_Gatherv`用于在进程间...
mpi.rar_MPI_mpi master
09-22
6. **同步与非阻塞通信**：`MPI_Send`和`MPI_Recv`是同步的，即发送方必须等待接收方准备好接收数据才能继续执行。MPI还提供了非阻塞版本的`MPI_Isend`和`MPI_Irecv`，允许进程在发送或接收过程中执行其他操作。 7....
MPI-Demo_MPI_DEMO_
09-29
2. **非阻塞通信**：`MPI_Isend`和`MPI_Irecv`提供非阻塞版本的发送和接收，允许进程在等待消息到达的同时执行其他操作。 3. **缓冲区通信**：`MPI_Ssend`、`MPI_Rsend`和`MPI_Sendrecv`提供了不同类型的同步通信...
MPI学习四 非阻塞通信MPI程序设计
s_sunnyy的博客
02-27 694
待整理
mpi学习2：非租塞通信程序
ouou1997的博客
04-15 241
mpi的非阻塞通信程序，这个又称为异步通信。 分类 发送 接收 阻塞通信 MPI_Send MPI_Bsend MPI_RSend MPI_SSend MPI_Recv MPI_Irecv MPI_Recv_Init 非租塞通信 MPI_Isend MPI_IBSend MPI_ISSend MPI_Send_Init MPI_Bsend_Init MPI_Bsend_Init...
linux 进程阻塞 语句,MPI进程拓扑及非阻塞通信程序示例
weixin_30479433的博客
05-10 139
题目如下，是关于MPI进程拓扑的：请编写具有二维拓扑的MPI程序，每个程序都与其上下左右进程进行通信，请打印出它的上下左右进程的进程号和通信的内容。代码如下，通信语句使用了非阻塞通信方式：#include"mpi.h"#include#defineNUM_DIMS 2intmain( int argc, char **argv ){int rank,size;int periods[NUM_DIM...
（三）MPI中的阻塞式和非阻塞式
xinwuya_的博客
04-15 7447
1.MPI阻塞式通信的一个例子 先看下面这段程序，可以看到每个进程都调用了两次MPI_Bcast()，其中第一次广播的数据为字符串HelloStr的长度，第二次广播的数据为HelloStr字符串本身。所以可以很容易地理解到，0号进程要向其他进程广播一个任意长度地字符串时，需要分为两步，第一次先向组中的其他进程广播字符串的长度，第二次广播字符串本身；其他进程在接收时，要先接收到从0号进程发送来的字符...
并行计算之MPI简介以及基本通信案例(阻塞，非阻塞)
KingOfMyHeart的博客
08-29 3236
MPI_Test 函数的作用与 MPI_Wait 函数类似，都是等待一个请求对象进入完成状态，但 MPI_Test 函数是非阻塞的，即当请求对象尚未完成时，MPI_Test 函数会立即返回一个标志值，而不会阻塞当前进程的执行。通信域中的每个进程都有一个唯一的标识符（通信域内部的秩/等级(rank)），并可以通过指定目标进程的标识符来对目标进程进行通信。，在每个阶段中，数据沿着流水线被处理，不同的进程专门处理不同的阶段。拥有一个主进程，主进程作为任务的分配方，从进程执行任务，主进程负责管理数据的分发和接受；
高性能期末复习之第五章：MPI并行编程
qq_45347768的博客
11-30 2481
名词解释：一个3分 总分30 简答题：一个5分 总分40 编程题：一个10分 总分30 高性能计算导论复习（根据复习范围） 第五章-重点：MPI并行编程 MPI 消息传递编程的模型 进程组 指MPI程序的全部进程集合的一个有序子集且进程组中每个进程被赋于一个在该组中唯一的序号(rank)，用于在该组中标识该进程。序号的取值范围是[0, 进程数 - 1] 通信器 理解为一类进程的集合即一个进程组，且在该进程组，进程间可以相互通信 任何MPI通信函数均必须在某个通信器内发生 MPI系统提供缺省的通.
MPI 点对点通信
帅比王的博客
07-21 3439
定义 点对点通信是两个进程之间的通信，从源进程发送消息到目标进程。通信是发生在同一个通信器内，并且进程可以通过其在通信器内的标号标识。 MPI 系统的通信方式都是建立在点对点通信之上。 阻塞式点对点通信 阻塞式点对点通信主要涉及四个函数： MPI_SEND MPI_Recv MPI_Get_count（查询接收到的消息长度） MPI_Sendrecv（捆绑发送和接受） 消息 MPI 消息包括信封和数据两个部分。信封指出了发送或接收消息的对象及相关信息，而数据是本消息将要传递的内容。信封和数据又分别包括三个部
MPI知识点梳理
qq_41103202的博客
01-31 853
MPI简单知识点梳理
并行计算进阶：进程Q的双缓冲与点对点通信
"进程Q的代码展示了在并行计算中的双缓冲技术，用于点对点通信。代码中，进程Q不断地检查变量X是否等于Xbuf0，根据结果更新X和Y，并利用MPI（Message Passing Interface）进行异步发送和接收操作，实现计算任务的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值