MPI 奇偶排序

最新推荐文章于 2024-06-19 09:41:13 发布
最新推荐文章于 2024-06-19 09:41:13 发布
阅读量1.1k 收藏 4
点赞数 1
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44814439/article/details/105401267
版权

编译:mpicc -o 目标文件 源文件.cpp
运行:mpirun -n 进程数 -machinefile ./machinefile ./目标文件

带注释版(但是有点小的语法错误)


#include "mpi.h"
#include <stdio.h>
#include <stdlib.h>//exit 
#include <malloc.h>
#include <memory.h>
#include <time.h>
void merge(int mykeys[], int receive[], int n, int flag);
void odd_even_sort(int a[], int n);
void doSort(int myid, int local_n, int np);
void printMatrix(int array[], int n);
void init(int n, int myid, int np);
int getPartner(int phase, int myid, int comm_sz);
int cmp(const void *a, const void *b);
int *array, *mykeys, *receive;
int n, partner;
void Get_input(int my_rank , int comm_sz, int * n_p) {
    int dest ;
    if(my_rank ==0) {
        printf("Enter  n\n");
        scanf("%d", n_p);
        for(dest =1 ;dest < comm_sz;dest++) {
            MPI_Send(n_p,1,MPI_INT, dest,0, MPI_COMM_WORLD);
        }
    }
    else {
        MPI_Recv(n_p, 1 ,MPI_INT,0,0,MPI_COMM_WORLD, MPI_STATUS_IGNORE);
    }
}
void merge(int mykeys[], int receive[], int n, int flag)
{
    int mi, ti, ri; //mykeys receive的数目 
    int *temp = malloc(sizeof(int) * n * 2); //n 为local_n ,将两个进程的数合并 
    if (temp == NULL)
    {
        exit(-1);//非正常运行退出  
    }
    mi = ri = ti = 0;
    while (mi < n && ri < n)
    {
        if (mykeys[mi] >= receive[ri])
        {
            temp[ti] = receive[ri];
            ri++;
            ti++;
        }
        else
        {
            temp[ti] = mykeys[mi];
            ti++;
            mi++;
        }
    }
    while (mi < n)
    {
        temp[ti] = mykeys[mi];
        ti++;
        mi++;
    }
    while (ri < n)
    {
        temp[ti] = receive[ri];
        ti++;
        ri++;
    }
    ti = flag > 0 ? n : 0;
    
    for (mi = 0; mi < n; mi++)
        mykeys[mi] = temp[ti++];
        
    free(temp);
}
void printMatrix(int array[], int n)
{
    int i;
    for (i = 0; i < n; i++)
        printf("%d\n", array[i]);
}
void doSort(int myid, int local_n, int np)   4. 进行np轮排序。 
{
    int i;
    for (i = 0; i < np; i++)
    {
        partner = getPartner(i, myid, np);
        if (partner != MPI_PROC_NULL) // 不是空进程 
        {
            MPI_Sendrecv(mykeys, local_n, MPI_INT, partner, 0, receive, local_n, MPI_INT, partner, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
            merge(mykeys, receive, local_n, myid - partner);
        }
    }//接受和发送消息标签都为0 
}
//进程间的通信需要通过一个通信器来完成。MPI 环境在初始化时会自动创建两个通信器,一个称为 MPI_COMM_WORLD,它包含程序中的所有进程
// MPI_COMM_SELF,它是每个进程独自构成的、仅包含自己的通信器。
//MPI 系统提供了一个特殊进程号 MPI_PROC_NULL,它代表空进程 (不存在的进程),
//与 MPI_PROC_NULL 进行通信相当于一个空操作,对程序的运行没有任何影响。 
//若单纯的利用MPI_Send, MPI_Recv函数进行通讯的话，容易造成死锁，下面介绍MPI_Sendrecv的来解决这个问题。
//MPI_Sendrecv表示的作用是将本进程的信息发送出去，并接收其他进程的信息
//MPI_Send和MPI_Recv两个函数是MPI里基本的点对点通信例程。
//两个函数都会阻塞调用进程，直到通信操作完成。阻塞可能会造成死锁。
void init(int n, int myid, int np)
{
    int i;
    int total = n + np - n % np;  //一共有多少个数(填充后) 
 //其中有不能整除问题，对于不能整除的进行填补，
 //用最大的数填充数组最后几个元素使之能整除 
    if (!myid) //如果不是0进程 
    {
        srand(time(NULL));
        //srand( (time(NULL) )中time(NULL)函数是得到一个从1900年1月1日到现在的时间秒数
  //这样每一次运行程序的时间的不同就可以保证得到不同的随机数了。 
        array = (int *)malloc(sizeof(int) * total);
        for (i = 0; i < n; i++)
        {
            *(array + i) = random();
        }
        for (i = n; i < total; i++)
        {
            *(array + i) = 0x7fffffff; //数组元素大小不能超过 0x7fffffff
        }
    }
    receive = (int *)malloc(sizeof(int) * total / np);
    mykeys = (int *)malloc(sizeof(int) * total / np);
}
int getPartner(int phase, int myid, int comm_sz)  //partner = getPartner(i, myid, np); 
{
    int partner;
    //phase为第几轮,先从偶排序开始 
    if (phase % 2 == 0)
    {
        if (myid % 2 != 0)
        {
            partner = myid - 1;
        }
        else
        {
            partner = myid + 1;  0和1 2和3 
        }
    }
    else
    {
        if (myid % 2 != 0)
        {
            partner = myid + 1;
        }
        else
        {
            partner = myid - 1;
        }
    }
    if (partner == -1 || partner == comm_sz)
    {
        partner = MPI_PROC_NULL;
    }
    return partner;
}
int cmp(const void *a, const void *b)   //第一步:自己内部排序 
{
    return *((int *)a) > *((int *)b);
}
int main(void) //int argc, char **argv
{
    int i, j;
    int myid, np, namelen; // np is size numprocess
    char proc_name[MPI_MAX_PROCESSOR_NAME];
    MPI_Init(NULL, NULL);
    MPI_Comm_rank(MPI_COMM_WORLD, &myid);
    MPI_Comm_size(MPI_COMM_WORLD, &np);
    MPI_Get_processor_name(proc_name, &namelen);
    double beginTime, endTime;
    beginTime = MPI_Wtime();  
    Get_input(myid, np,  &n);
   // n = atoi(argv[1]);  //atoi()代表的是ascii to integer，即“把字符串转换成有符号数字” 
    int local_n = (n + (np - n % np)) / np; // 填充  矩阵 
    //其中有不能整除问题，对于不能整除的进行填补，
 //用最大的数填充数组最后几个元素使之能整除  
    //初始化随机数。
    init(n, myid, np);
    // 2. 把数据广播出去。
//int array[] = {15, 11, 9, 16, 3, 14, 8, 7, 4, 6, 12, 10, 5, 2, 13, 1};
    MPI_Scatter(array, local_n, MPI_INT, mykeys, local_n, MPI_INT, 0, MPI_COMM_WORLD); //mykey为接受缓冲区起始地址 
    // 3. local sort
    qsort(mykeys, local_n, sizeof(int), cmp);
    // 4. 进行np轮排序。
    doSort(myid, local_n, np);
    // 5. 0号进程收集排序好的数据
    MPI_Gather(mykeys, local_n, MPI_INT, array, local_n, MPI_INT, 0, MPI_COMM_WORLD);
    endTime = MPI_Wtime();
    if (myid == 0)
    {
        printMatrix(array, n);
        printf("spent time = %lf second\n", endTime - beginTime);
    }
    free(array);
    free(mykeys);
    free(receive);
    MPI_Finalize();
    return 0;
}

无注释版,无语法错误,编译通过

#include "mpi.h"
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <time.h>
#include <stdlib.h>
//int array[] = {15, 11, 9, 16, 3, 14, 8, 7, 4, 6, 12, 10, 5, 2, 13, 1};
void merge(int mykeys[], int receive[], int n, int flag);
void odd_even_sort(int a[], int n);
void doSort(int myid, int local_n, int np);
void printMatrix(int array[], int n);
void init(int n, int myid, int np);
int getPartner(int phase, int myid, int comm_sz);
int cmp(const void *a, const void *b);
int *array, *mykeys, *receive;
int n, partner;
void Get_input(int my_rank , int comm_sz, int * n_p) {
    int dest ;
    if(my_rank ==0) {
        printf("Enter  n\n");
        scanf("%d", n_p);
        for(dest =1 ;dest < comm_sz;dest++) {
            MPI_Send(n_p,1,MPI_INT, dest,0, MPI_COMM_WORLD);
        }
    }
    else {
        MPI_Recv(n_p, 1 ,MPI_INT,0,0,MPI_COMM_WORLD, MPI_STATUS_IGNORE);
    }
}
int main(void)
{
    int i, j,n;
    int myid, np, namelen;
    char proc_name[MPI_MAX_PROCESSOR_NAME];
    MPI_Init(NULL, NULL);
    MPI_Comm_rank(MPI_COMM_WORLD, &myid);
    MPI_Comm_size(MPI_COMM_WORLD, &np);
    MPI_Get_processor_name(proc_name, &namelen);
    double beginTime, endTime;
    beginTime = MPI_Wtime();
    Get_input(myid, np,  &n);
    int local_n = (n + (np - n % np)) / np; // fill with the matrix
    //初始化随机数。
    init(n, myid, np);
    // 2. 把数据广播出去。
    MPI_Scatter(array, local_n, MPI_INT, mykeys, local_n, MPI_INT, 0, MPI_COMM_WORLD);
    // 3. local sort
    qsort(mykeys, local_n, sizeof(int), cmp);
    // 4. 进行np轮排序。
    doSort(myid, local_n, np);
    // 5. 0号进程收集排序好的数据
    MPI_Gather(mykeys, local_n, MPI_INT, array, local_n, MPI_INT, 0, MPI_COMM_WORLD);
    endTime = MPI_Wtime();
    if (myid == 0)
    {
        printMatrix(array, n);
        printf("spent time = %lf second\n", endTime - beginTime);
    }
    free(array);
    free(mykeys);
    free(receive);
    MPI_Finalize();
}
void merge(int mykeys[], int receive[], int n, int flag)
{
    int mi, ti, ri;
    int *temp = (int *)malloc(sizeof(int) * n * 2);
    if (temp == NULL)
    {
        exit(-1);
    }
    mi = ri = ti = 0;
    while (mi < n && ri < n)
    {
        if (mykeys[mi] >= receive[ri])
        {
            temp[ti] = receive[ri];
            ri++;
            ti++;
        }
        else
        {
            temp[ti] = mykeys[mi];
            ti++;
            mi++;
        }
    }
    while (mi < n)
    {
        temp[ti] = mykeys[mi];
        ti++;
        mi++;
    }
    while (ri < n)
    {
        temp[ti] = receive[ri];
        ti++;
        ri++;
    }
    ti = flag > 0 ? n : 0;
    for (mi = 0; mi < n; mi++)
        mykeys[mi] = temp[ti++];
    free(temp);
}
void printMatrix(int array[], int n)
{
    int i;
    for (i = 0; i < n; i++)
        printf("%d\n", array[i]);
}
void doSort(int myid, int local_n, int np)
{
    int i;
    for (i = 0; i < np; i++)
    {
        partner = getPartner(i, myid, np);
        if (partner != MPI_PROC_NULL)
        {
            MPI_Sendrecv(mykeys, local_n, MPI_INT, partner, 0, receive, local_n, MPI_INT, partner, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
            merge(mykeys, receive, local_n, myid - partner);
        }
    }
}
void init(int n, int myid, int np)
{
    int i;
    int total = n + np - n % np;
    if (!myid)
    {
        srand(time(NULL));
        array = (int *)malloc(sizeof(int) * total);
        for (i = 0; i < n; i++)
        {
            *(array + i) = random();
        }
        for (i = n; i < total; i++)
        {
            *(array + i) = 0x7fffffff;
        }
    }
    receive = (int *)malloc(sizeof(int) * total / np);
    mykeys = (int *)malloc(sizeof(int) * total / np);
}
int getPartner(int phase, int myid, int comm_sz)
{
    int partner;
    if (phase % 2 == 0)
    {
        if (myid % 2 != 0)
        {
            partner = myid - 1;
        }
        else
        {
            partner = myid + 1;
        }
    }
    else
    {
        if (myid % 2 != 0)
        {
            partner = myid + 1;
        }
        else
        {
            partner = myid - 1;
        }
    }
    if (partner == -1 || partner == comm_sz)
    {
        partner = MPI_PROC_NULL;
    }
    return partner;
}
int cmp(const void *a, const void *b)
{
    return *((int *)a) > *((int *)b);
}
Chloemxc
关注
用MPI实现并行排序算法——奇偶交换排序(C++)
yjjgoodbay的博客
12-08 8783
本文主要讨论并行排序算法的实现，将串行的奇偶排序算法并行化。同时本文也涉及MPI通信安全方面的讨论，MPI_SendRecv函数提供了有关进程通信的调度，用它替代send和recv函数使程序更安全
MPI(Message-Passing Interface)实现奇偶排序
Splend520的博客
12-15 4837
MPI奇偶排序的实现： 各个进程拿到自己需要做排序那一部分数据时即需要需要的总数除进程数（其中有不能整除问题，对于不能整除的进行填补，用最大的数填充数组最后几个元素使之能整除），先进行局部排序。第一轮偶排序时，0和进程和1号交换数据，2和3交换，进程号小的保留数据小的那一半。进行奇排序时，1和2进行交换。0和3号进程闲置。以此类推，进行p个阶段。这个根据定理。参考并行计算导论。#include
使用MPI 实现奇偶排序
綾華の笔记本
06-19 909
定义规模 计算partner 保留小一半数据 保留大一半数据 主函数 随机数序列生成 使用python生成一个包含100000000个数字的文本文件 测试代码 可视化代码 利用matplot进行可视化 结果 因为我的电脑的CPU是I7-12700H，只有20个物理核心，所以在执行MPI并行程序时将线程设置为16。将16线程奇偶排序与串行Std::Sort在不同数据规模下用相同数据集进行测试，得到的结果如下（具体的数值记录在test.json文件中）： 对于较小的数据集（小于等于10410^410
基于mpi的奇偶排序_奇偶排序
weixin_30322901的博客
12-29 1049
昆明理工大学硕士研究生课程–期末实习作业姓名：韩翠翠学号：2013704098一、实习题目与要求奇偶交换排序实现MPI下的一个奇偶交换排序，odd_even_sort.c中已经包括排序的一个顺序实现。不断重复上述两种操作，直到数组中没有任何数可以交换。在并行环境中实现上述过程。二、程序的设计与实现1.主要思想奇偶排序的顺序执行是不断的重复两种操作，直到所有的数据完成排序。第一种操作是奇/偶阶段，把...
基于mpi的奇偶排序_【MPI】并行奇偶交换排序
weixin_39541600的博客
12-20 368
typedef long long __int64;#include "mpi.h"#include #include #include using namespace std;int Compute_partner(int phase,int my_rank,int comm_sz){//根据趟数的奇偶性以及当前编号的编号得到partner进程的编号int partner;if(!(phase&...
MPI实现的奇偶排序(ODD_EVEN)
06-04
代码稍微有点儿缺陷，默认是10个数据，用5个进程进行排序。所以其中的比较函数写死了，大家可以自己重新改一下这里。
并行计算mpi奇偶排序
12-16
运用mpi实现奇偶排序，在不同的处理器之间通过消息传递完成奇偶index的数的交换，实现最终的数列排序
MPI奇偶排序源代码+可运行程序
05-12
MPICH2+VC++6.0开发，内含奇偶并行排序源代码及EXE可运行程序。
基于mpi的奇偶排序_MPI并行编程系列三：并行正则采样排序PSRS
weixin_39875031的博客
12-20 472
快速排序算法的效率相对较高，并行算法在理想的情况下时间复杂度可达到o(n)，但并行快速排序算法有一个严重的问题：会造成严重的负载不平衡，最差情况下算法的复杂度可达o(n^2)。本篇我们介绍一种基于均匀划分的负载平衡的并行排序算法------并行正则采样排序(Parallel Sorting by Regular Sampling)。一、算法的基本思想假设待排序的元素n个，处理器p个。首先将这n个元...
并行计算 MPI奇偶排序实验
qq_39804517的博客
08-23 988
添加用户 sudo adduser mpit 增加权限 sudo visudo 切换用户 su - mpit 安装openmpi sudo apt install libopenmpi-dev 测试单机 mpiexec -np 8 hostname 多机环境 关闭防火墙 sudo ufw status sudo ufw disable 修改hosts sudo vim /etc/hosts 添加　IP地址　主机名　　 创建ssh ssh-keygen -t rsa 将自己的公钥传给别的机器,注意也
MPI实现的快速排序
12-15
用MPI实现的快速排序，提高快速排序的效率
奇偶排序算法的并行实现
09-09
利用mpi进行奇偶排序的实现，有较好的性能和可扩展性
MPI并行计算学习笔记4——奇偶排序的优雅实现
askjff的博客
05-07 4854
1.运行环境VS2017 + MPI 2.算法背景与原理，可见博客：https://www.cnblogs.com/kongzhongqijing/p/6687699.html 值得一提的是，奇偶排序算法设计的初衷便是并行计算，只是更加贴合OpenMP这种共享内存式的编程框架，以后会和大家分享。 3.MPI模式下的奇偶排序算法，有更大的灵活性（个人观点：用到了奇偶排序的思想，并不是完全意...
奇偶排序
qq_35751236的博客
04-27 289
#include <iostream> #include <vector> using namespace std; void reOrderEvenOdd(vector<int> &array, int begin, int end){ if (!array.size()) return; if ((end - begin) <= 0) return
基于mpi的奇偶排序_MPI 并行奇偶交换排序 + 集合通信函数 Sendrecv() Sendvecv_replace()...
weixin_39681621的博客
12-20 634
▶ 《并行程序设计导论》第三章的例子程序● 代码1 #include 2 #include 3 #include 45 const int nProcess = 8, localSize = 1024 * 1024, globalSize = nProcess *localSize;67 int compare(const void *a, const void *b) { return *(in...
A. 实验7_5_奇偶排序
Hush
12-13 493
已知n个整数，将n个整数的奇数放在前，偶数放在后，奇数部分与偶数部分都按升序排列输出。 输入与输出要求：首先输入一个整数n，代表输入整数个数，n不会超过200。然后是n个待排序的整数，每个整数的取值范围是0-1000。输出排序后的n个数，其中奇数在前偶数在后，数与数之间用空格分开，注意第n个数后没有空格而是换行符。 程序运行效果： Sample 1： 10↙ 10 9 8 7 6 5 4 3 2 ...
奇偶融合排序的mpi4py实现
EXYlkx的博客
01-22 576
目录 算法介绍 算法实现 局部排序 排序合并 奇偶融合 运行结果 算法介绍 冒泡排序：是串行算法，在每次迭代过程中，每个元素可能与前面元素交换，也可能和后面的元素交换，数据的相关性比较强很难直接改成并行算法。 奇偶排序：或奇偶换位排序，或砖排序，是一种相对简单的排序算法，最初发明用于有本地互连的并行计算。这是与冒泡排序特点类似的一种比较排序。该算法中，排序过程分两个阶段，奇交换和偶交换，两种交换都是成对出现。对于奇交换，它总是比较奇数索引以及其相邻的后续元素。对偶交换，总是比较偶数索引
MPI并行程序编写与调试（奇偶变换排序）
weixin_44238355的博客
07-31 1058
MPI并行程序编写与调试（奇偶变换排序） 一、编写MPI并行计算程序 奇偶排序在多线程进行计算代码如下： 关于奇偶排序这里不做过多描述。 /* * File: mpi_odd_even.c * Purpose: Implement parallel odd-even sort of an array of * nonegative ints * Input: * A: elements of array (optional) * Output:
mpi排序
weixin_45806592的博客
10-18 1392
思想 将一个较大的需要排序的数组，拆分成等大小的数据段,分配给不同的进程，利用归约排序算法的思想，将不同进程之间的数据进行排序，同时在规约中包含快排结合使用最大程度的加速程序的速度，最后将各个程序的内容发送到根进程中，完成输出。 #include <stdio.h> #include <stdlib.h> #include <time.h> #include <mpi.h> #define length 10//0//0000 //快排的实现 void sw
写一个基于mpi的奇偶交换排序程序
最新发布
10-23
要编写一个基于MPI（Message Passing Interface）的奇偶交换排序程序，首先我们需要了解MPI的基本概念和其在分布式内存环境下的通信机制。这是一个简单的双进程版本，用于演示如何利用MPI交换数组中的奇数和偶数元素： ```python from mpi4py import MPI # 初始化MPI环境 comm = MPI.COMM_WORLD rank = comm.Get_rank() size = comm.Get_size() # 定义全局数组，大小是所有进程总数的两倍 global_array = [0] * (2 * size) # 假设我们有两个进程，进程0负责偶数位置，进程1负责奇数位置 local_array = [None] * size # 随机填充本地数组 for i in range(size): local_array[i] = i + rank # 排序本地数组 local_array.sort() # 将奇偶位置的数据交换到全局数组中 if rank % 2 == 0: global_array[rank::2] = local_array else: global_array[1+rank::2] = local_array # 通知所有进程已经完成数据交换 comm.Barrier() # 打印全局数组，每个进程只打印自身范围内的部分 start = rank * 2 end = start + 2 print(f"Rank {rank}: {global_array[start:end]}") # MPI结束程序 MPI.Finalize() ``` 在这个程序中，我们首先确定当前进程的秩（rank）以及整个进程组（world communicator）的大小。然后分配一个足够大的全局数组，用于存放每个进程中数据的副本。接着，每个进程对自己的局部数据进行排序，并将奇偶位置的数据交换至全局数组。最后，各进程打印出自己处理的部分，显示排序后的结果。 注意这只是一个简化版的例子，实际上在大规模排序任务中，MPI通常会结合更复杂的算法，如快速排序、归并排序等，同时考虑效率和负载均衡。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值