并行程序设计基础——并行模式之主从模式

最新推荐文章于 2024-10-14 16:42:33 发布

猿核试Bug愁

最新推荐文章于 2024-10-14 16:42:33 发布

阅读量440

点赞数 4

分类专栏：并行编程文章标签： linux 分布式负载均衡 c++

本文链接：https://blog.csdn.net/L_peanut/article/details/141135632

版权

并行编程专栏收录该内容

31 篇文章 0 订阅

订阅专栏

一、矩阵向量乘

二、主进程打印从进程消息

三、小结

上一节内容我们介绍了并行程序设计中的常用模式——对等模式，本节对另一种模式——主从模式进行介绍。

一、矩阵向量乘

首先通过矩阵向量乘C=A×B的例子来介绍主从模式。

具体实现方法为：主进程将向量B广播给所有的从进程，然后将矩阵A的各行依次发送给从进程，从进程计算一行和B相乘的结果，然后将结果发送给主进程。主进程循环向各个从进程发送一行A的数据，直至将A的各行数据发生完毕，一旦主进程将A的各行发送完毕，则每收到一个计算结果，就向相应的从进程发送结束标志，从进程接收到结束标志后退出执行。主进程收集完成所有结果后也结束。

#include <iostream>
#include "mpi.h"
using namespace std;

int main(int argc, char *argv[])
{
    int rows = 10, cols = 10;
    int numsent = 0, numprocs = 0;
    int m_id = 0, end_tag = 0, myid = 0;
    double ans = 0.0;
    double a[rows][cols] = {0}, b[cols] = {0}, c[rows] = {0};
    double buffer[cols] = {0};
    MPI_Status status;

    MPI_Init(&argc, &argv);
    MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
    MPI_Comm_rank(MPI_COMM_WORLD, &myid);

    printf("Process %d of %d is alive!\n", myid, numprocs);

    if(myid == m_id)
    {
        for(int i = 0; i < cols; i++)
        {
            b[i] = i;
            for(int j = 0; j < rows; j++)
            {
                a[i][j] = i + 1;
            }
        }

        MPI_Bcast(b, cols, MPI_DOUBLE, m_id, MPI_COMM_WORLD);

        for(int i = 0; i < std::min(numprocs - 1, rows); i++)
        {
            for(int j = 0; j < cols; j++)
            {
                buffer[j] = a[i][j];
            }
            MPI_Send(buffer, cols, MPI_DOUBLE, i + 1, i + 1, MPI_COMM_WORLD);
            numsent = numsent + 1;
        }
        for(int i = 0; i < rows; i++)
        {
            MPI_Recv(&ans, 1, MPI_DOUBLE, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &status);
            int sender = status.MPI_SOURCE;
            int rtag = status.MPI_TAG - 1;
            c[rtag] = ans;

            if(numsent < rows)
            {
                for(int j = 0; j < cols; j++)
                {
                    buffer[j] = a[numsent][j];
                }
                MPI_Send(buffer, cols, MPI_DOUBLE, sender, numsent + 1, MPI_COMM_WORLD);
                numsent = numsent + 1;
            }
            else
            {
                int tmp = 1.0;
                MPI_Send(&tmp, 0, MPI_DOUBLE, sender, end_tag, MPI_COMM_WORLD);
            }
        }
    }
    else
    {
        MPI_Bcast(b, cols, MPI_DOUBLE, m_id, MPI_COMM_WORLD);
        while(1)
        {
            MPI_Recv(buffer, cols, MPI_DOUBLE, m_id, MPI_ANY_TAG, MPI_COMM_WORLD, &status);
            if(status.MPI_TAG != end_tag)
            {
                int row = status.MPI_TAG;
                ans = 0.0;
                for(int i = 0; i < cols; i++)
                {
                    ans = ans + buffer[i] * b[i];
                }
                MPI_Send(&ans, 1, MPI_DOUBLE, m_id, row, MPI_COMM_WORLD);
            }
            else
            {
                break;
            }
        }
    }

    if(myid == m_id)
    {
        for(int i = 0; i < rows; i++)
        {
            printf("c[%d] = %f.\n", i, c[i]);
        }
    }

    MPI_Finalize();

    return 0;
}

编译及运行结果如下：

二、主进程打印从进程消息

这里我们实现另一个主从模式的例子，功能是：主进程接收从进程的消息，根据消息的不同，分两种方式将消息打印。一是按照从进程节点编号的大小依次打印，二是按照任意顺序打印。从进程则实现向主进程发送消息的任务，消息分为两种：以任意顺序打印的消息和按进程编号顺序打印的消息。

#include <stdio.h>
#include "mpi.h"
#define MSG_EXIT 1
#define MSG_PRINT_ORDERED 2
#define MSG_PRINT_UNORDERED 3

int main(int argc, char *argv[])
{
    int rank;

    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    if(rank == 0)
        master_io();
    else
        slave_io();
    
    MPI_Finalize();
    
    return 0;
}

int master_io(void)
{
    int i, j, size, nslave, firstmsg;
    char buf[256], buf2[256];
    MPI_Status status;

    MPI_Comm_size(MPI_COMM_WORLD, &size);

    nslave = size - 1;
    while(nslave > 0)
    {
        MPI_Recv(buf, 256, MPI_CHAR, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &status);
        switch(status.MPI_TAG)
        {
            case MSG_EXIT:
                nslave--; 
                break;
            case MSG_PRINT_UNORDERED: 
                fputs(buf, stdout);
                break;
            case MSG_PRINT_ORDERED: 
                firstmsg = status.MPI_SOURCE;
                for(i = 1; i < size; i++)
                {
                    if(i == firstmsg)
                        fputs(buf, stdout);
                    else
                    {
                        MPI_Recv(buf2, 256, MPI_CHAR, i, MSG_PRINT_ORDERED, MPI_COMM_WORLD, &status);
                        fputs(buf2, stdout);
                    }
                }
                break;
         }
    }
}

int slave_io(void)
{
    char buf[256];
    int rank;

    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    sprintf(buf, "Hello from slave %d, ordered print.\n", rank);
    MPI_Send(buf, strlen(buf) + 1, MPI_CHAR, 0, MSG_PRINT_ORDERED, MPI_COMM_WORLD);
    sprintf(buf, "Goodbye from slave %d, ordered printd.\n", rank);
    MPI_Send(buf, strlen(buf) + 1, MPI_CHAR, 0, MSG_PRINT_ORDERED, MPI_COMM_WORLD);
    sprintf(buf, "I'm exiting (%d), unordered print.\n", rank);
    MPI_Send(buf, strlen(buf) + 1, MPI_CHAR, 0, MSG_PRINT_UNORDERED, MPI_COMM_WORLD);
    MPI_Send(buf, 0, MPI_CHAR, 0, MSG_EXIT, MPI_COMM_WORLD);
}

编译及运行结果如下：