BOOST c++库学习之 boost.mpi库入门实战指南以及使用 boost.mpi库实现进程间通讯（同步与异步的对比）的简单例程

Narcotis

于 2024-08-15 12:29:54 发布

阅读量489

点赞数 9

文章标签： c++ 学习开发语言 linux 架构嵌入式实时数据库

本文链接：https://blog.csdn.net/weixin_44251074/article/details/141216500

版权

Boost.MPI 库介绍

1. 概述

Boost.MPI 是 C++ 的 Boost 库中的一个模块，专门用于在分布式内存并行计算中提供消息传递接口。它基于 MPI（Message Passing Interface）标准，旨在简化和提升 C++ 中的分布式计算编程体验。Boost.MPI 封装了传统 MPI 的复杂性，使得开发者可以更自然地在 C++ 中编写高效的并行程序。

2. 与其他进程间通信工具的对比

在分布式计算和多进程通信领域，Boost.MPI 并不是唯一的选择。其他常见的进程间通信（IPC）工具包括传统的 MPI、Boost.Interprocess、POSIX 共享内存和消息队列等。以下是 Boost.MPI 与这些工具的对比分析。

2.1 Boost.MPI vs 传统 MPI

封装性与易用性: 传统的 MPI 是用 C 语言实现的，接口相对较底层且复杂。Boost.MPI 对其进行了 C++ 封装，使得通信过程更加直观和安全，减少了编码中的错误风险。
类型安全: Boost.MPI 在编译时进行类型检查，确保了数据传递的类型安全，而传统 MPI 需要手动管理数据类型，容易引发错误。
自动序列化: Boost.MPI 与 Boost.Serialization 集成，自动处理数据的序列化和反序列化；传统 MPI 则需要手动处理，增加了开发复杂度。

2.2 Boost.MPI vs Boost.Interprocess

使用场景: Boost.Interprocess 专注于单机多进程间的通信，主要使用共享内存、消息队列、信号量等机制，而 Boost.MPI 则专为分布式多节点计算设计，适用于多台计算机之间的进程通信。
通信范围: Boost.Interprocess 适用于同一主机内的进程通信，而 Boost.MPI 则可以在不同的物理节点上进行进程通信。
编程复杂度: Boost.Interprocess 需要开发者手动管理内存和同步，而 Boost.MPI 提供了更高层次的 API，隐藏了许多底层细节。

2.3 Boost.MPI vs POSIX IPC（共享内存、消息队列等）

跨平台支持: POSIX IPC 在 Linux 和类 Unix 系统上表现优异，但在 Windows 上的支持有限。Boost.MPI 作为 Boost 库的一部分，具有良好的跨平台兼容性。
编程模型: POSIX IPC 提供的是底层的通信原语，开发者需要处理复杂的同步和数据管理。Boost.MPI 提供了更高级的抽象，简化了分布式计算中的通信过程。
性能: POSIX IPC 在单机上提供了非常高效的通信方式，适用于高频次、低延迟的进程间通信。而 Boost.MPI 则更多地在多节点环境中提供高效的消息传递功能。

3. Boost.MPI API 简介

Boost.MPI 提供了一系列简洁的 API，用于实现点对点通信、集体通信和异步通信等功能。以下是一些常用的 API：

mpi::environment: 初始化和管理 MPI 环境。
mpi::communicator: 表示一个通信通道，包含了所有进程的上下文。
send/recv: 实现进程间的同步发送和接收操作。
broadcast/gather: 提供集体通信功能，如广播数据、收集数据。
isend/irecv: 用于异步通信，使进程可以在等待通信完成时继续其他操作。

Boost.MPI 各个接口函数 API 详解以及使用

1. 环境和通信器管理

1.1 `mpi::environment`

mpi::environment 是 MPI 程序的入口，用于初始化和终止 MPI 环境。它确保在程序开始时正确初始化 MPI，并在程序结束时清理资源。

用法:

#include <boost/mpi.hpp>

int main() {
    mpi::environment env;  // 初始化 MPI 环境
    // Your MPI code here
    return 0;  // 在 main 函数结束时，自动清理 MPI 环境
}

1.2 `mpi::communicator`

mpi::communicator 表示一个通信通道或上下文，包含了可以互相通信的一组进程。最常见的通信器是 mpi::communicator world，表示全局通信器，涵盖了所有参与的进程。

常用方法:

rank(): 返回当前进程在通信器中的 ID（即进程的排名）。
size(): 返回通信器中的进程总数。
barrier(): 阻塞所有进程，直到所有进程都到达该点。

示例:

#include <boost/mpi.hpp>
#include <iostream>

namespace mpi = boost::mpi;

int main() {
    mpi::environment env;
    mpi::communicator world;

    std::cout << "Process " << world.rank() << " of " << world.size() << std::endl;

    world.barrier();  // 所有进程在此同步

    return 0;
}

2. 点对点通信

2.1 `send`

send 函数用于将数据从一个进程发送到另一个进程。数据可以是基本类型，也可以是复杂的自定义数据类型。

语法:

void send(int dest, int tag, const T& value);

dest: 目标进程的排名（rank）。
tag: 消息标签，用于标识消息类型或目的。
value: 要发送的数据，可以是基本类型或支持序列化的类型。

示例:

#include <boost/mpi.hpp>
#include <vector>

namespace mpi = boost::mpi;

int main() {
    mpi::environment env;
    mpi::communicator world;

    if (world.rank() == 0) {
        std::vector<int> data = {1, 2, 3, 4, 5};
        world.send(1, 0, data);
    }

    return 0;
}

2.2 `recv`

recv 函数用于从指定进程接收数据。接收的数据类型必须与发送的数据类型匹配。

语法:

void recv(int source, int tag, T& value);

source: 数据来源的进程排名（rank）。
tag: 消息标签，与 send 中的标签相匹配。
value: 用于存储接收到的数据。

示例:

#include <boost/mpi.hpp>
#include <vector>
#include <iostream>

namespace mpi = boost::mpi;

int main() {
    mpi::environment env;
    mpi::communicator world;

    if (world.rank() == 1) {
        std::vector<int> received_data;
        world.recv(0, 0, received_data);

        std::cout << "Received data: ";
        for (int i : received_data) {
            std::cout << i << " ";
        }
        std::cout << std::endl;
    }

    return 0;
}

2.3 `isend` 和 `irecv`

isend 和 irecv 提供异步通信功能，允许进程在消息传递的同时执行其他任务。

语法:

request isend(int dest, int tag, const T& value);
request irecv(int source, int tag, T& value);

返回值为 request 对象，可以用于检查通信是否完成或等待通信完成。

示例:

#include <boost/mpi.hpp>
#include <vector>
#include <iostream>

namespace mpi = boost::mpi;

int main() {
    mpi::environment env;
    mpi::communicator world;

    if (world.rank() == 0) {
        std::vector<int> data = {1, 2, 3, 4, 5};
        mpi::request req = world.isend(1, 0, data);
        // 这里可以做其他工作
        req.wait();  // 等待发送完成
    } else if (world.rank() == 1) {
        std::vector<int> received_data;
        mpi::request req = world.irecv(0, 0, received_data);
        // 这里可以做其他工作
        req.wait();  // 等待接收完成

        std::cout << "Received data: ";
        for (int i : received_data) {
            std::cout << i << " ";
        }
        std::cout << std::endl;
    }

    return 0;
}

3. 集体通信

3.1 `broadcast`

broadcast 将数据从根进程发送到所有其他进程。根进程的 rank 可以指定。

语法:

void broadcast(T& value, int root);

value: 广播的数据；根进程负责提供数据，其他进程接收数据。
root: 进行广播的根进程的排名。

示例:

#include <boost/mpi.hpp>
#include <iostream>

namespace mpi = boost::mpi;

int main() {
    mpi::environment env;
    mpi::communicator world;

    int data;
    if (world.rank() == 0) {
        data = 42;  // Root process assigns the value
    }

    world.broadcast(data, 0);  // Broadcast data from root (rank 0)

    std::cout << "Process " << world.rank() << " received data: " << data << std::endl;

    return 0;
}

3.2 `scatter`

scatter 将不同的数据块从根进程分发给其他进程。

语法:

void scatter(const T* in_values, T& out_value, int root);

in_values: 根进程中的输入数据数组。
out_value: 每个进程接收到的输出数据。
root: 进行分发的根进程的排名。

示例:

#include <boost/mpi.hpp>
#include <iostream>
#include <vector>

namespace mpi = boost::mpi;

int main() {
    mpi::environment env;
    mpi::communicator world;

    std::vector<int> send_data;
    int recv_data;

    if (world.rank() == 0) {
        send_data = {10, 20, 30, 40};  // Root process data
    }

    world.scatter(send_data.data(), recv_data, 0);

    std::cout << "Process " << world.rank() << " received: " << recv_data << std::endl;

    return 0;
}

3.3 `gather`

gather 从所有进程收集数据到根进程。

语法:

void gather(const T& in_value, std::vector<T>& out_values, int root);

in_value: 每个进程要发送的数据。
out_values: 根进程接收的所有进程的数据集合。
root: 进行收集的根进程的排名。

示例:

#include <boost/mpi.hpp>
#include <iostream>
#include <vector>

namespace mpi = boost::mpi;

int main() {
    mpi::environment env;
    mpi::communicator world;

    int send_data = world.rank() * 10;
    std::vector<int> recv_data;

    world.gather(send_data, recv_data, 0);

    if (world.rank() == 0) {
        std::cout << "Process " << world.rank() << " gathered data: ";
        for (int val : recv_data) {
            std::cout << val << " ";
        }
        std::cout << std::endl;
    }

    return 0;
}

3.4 `all_gather`

all_gather 从所有进程收集数据，并将所有数据分发给每个进程。

语法:

void all_gather(const T& in_value, std::vector<T>& out_values);

in_value: 每个进程要发送的数据。
out_values: 每个进程接收到的所有进程的数据集合。

示例:

#include <boost/mpi.hpp>
#include <iostream>
#include <vector>

namespace mpi = boost::mpi;

int main() {
    mpi::environment env;
    mpi::communicator world;

    int send_data = world.rank() * 10;
    std::vector<int> recv_data;

    world.all_gather(send_data, recv_data);

    std::cout << "Process " << world.rank() << " received all data: ";
    for (int val : recv_data) {
        std::cout << val << " ";
    }
    std::cout << std::endl;

    return 0;
}

4. 异常处理

4.1 `mpi::exception`

mpi::exception 是 Boost.MPI 提供的异常类，用于处理 MPI 操作中的错误。这个类继承自 std::runtime_error，可以捕获和处理 MPI 相关的异常。

用法:

#include <boost/mpi.hpp>
#include <iostream>

namespace mpi = boost::mpi;

int main() {
    try {
        mpi::environment env;
        mpi::communicator world;

        // Some MPI operation that may fail
    } catch (mpi::exception& e) {
        std::cerr << "MPI Exception: " << e.what() << std::endl;
    }

    return 0;
}

5. 其他有用的工具

5.1 `mpi::reduce`

reduce 用于将所有进程的数据进行规约操作，并将结果传递给根进程。常见的操作包括加法、乘法、最大值等。

语法:

void reduce(const T& in_value, T& out_value, Op op, int root);

in_value: 每个进程的输入数据。
out_value: 根进程接收的规约结果。
op: 规约操作，如 mpi::plus<T>() 表示加法。
root: 进行规约的根进程的排名。

示例:

#include <boost/mpi.hpp>
#include <iostream>

namespace mpi = boost::mpi;

int main() {
    mpi::environment env;
    mpi::communicator world;

    int send_data = world.rank();
    int result;

    world.reduce(send_data, result, mpi::plus<int>(), 0);

    if (world.rank() == 0) {
        std::cout << "Sum of ranks: " << result << std::endl;
    }

    return 0;
}

5.2 `mpi::all_reduce`

all_reduce 是 reduce 的扩展，规约操作的结果会被传递给所有进程。

语法:

void all_reduce(const T& in_value, T& out_value, Op op);

in_value: 每个进程的输入数据。
out_value: 每个进程接收的规约结果。
op: 规约操作，如 mpi::plus<T>() 表示加法。

示例:

#include <boost/mpi.hpp>
#include <iostream>

namespace mpi = boost::mpi;

int main() {
    mpi::environment env;
    mpi::communicator world;

    int send_data = world.rank();
    int result;

    world.all_reduce(send_data, result, mpi::plus<int>());

    std::cout << "Sum of ranks: " << result << " (Process " << world.rank() << ")" << std::endl;

    return 0;
}

Boost.MPI 异步与同步进程间通信对比测试

下面将演示如何使用 Boost.MPI 实现异步和同步的进程间通信，并对两者进行对比。代码包含两个部分：一个是异步通信的实现，另一个是同步通信的实现。最后，我们将展示如何运行这些测试，并对结果进行分析。

1. 异步通信示例

#include <boost/mpi.hpp>
#include <iostream>
#include <vector>
#include <thread>

namespace mpi = boost::mpi;

void process_data() {
    // 模拟一个处理任务，使用线程睡眠表示
    std::this_thread::sleep_for(std::chrono::seconds(2));
}

int main() {
    mpi::environment env;
    mpi::communicator world;

    if (world.rank() == 0) {
        std::vector<int> data = {1, 2, 3, 4, 5};
        mpi::request req = world.isend(1, 0, data);

        std::cout << "Process 0 is doing some other work while sending data..." << std::endl;
        process_data();  // 模拟其他工作
        req.wait();  // 等待发送完成
        std::cout << "Process 0 finished sending data." << std::endl;

    } else if (world.rank() == 1) {
        std::vector<int> received_data;
        mpi::request req = world.irecv(0, 0, received_data);

        std::cout << "Process 1 is doing some other work while receiving data..." << std::endl;
        process_data();  // 模拟其他工作
        req.wait();  // 等待接收完成

        std::cout << "Process 1 received data: ";
        for (int i : received_data) {
            std::cout << i << " ";
        }
        std::cout << std::endl;
    }

    return 0;
}

2. 同步通信示例

#include <boost/mpi.hpp>
#include <iostream>
#include <vector>

namespace mpi = boost::mpi;

void process_data() {
    // 模拟一个处理任务，使用线程睡眠表示
    std::this_thread::sleep_for(std::chrono::seconds(2));
}

int main() {
    mpi::environment env;
    mpi::communicator world;

    if (world.rank() == 0) {
        std::vector<int> data = {1, 2, 3, 4, 5};
        world.send(1, 0, data);  // 同步发送
        std::cout << "Process 0 finished sending data." << std::endl;
        process_data();  // 发送完成后执行其他工作

    } else if (world.rank() == 1) {
        std::vector<int> received_data;
        world.recv(0, 0, received_data);  // 同步接收

        std::cout << "Process 1 received data: ";
        for (int i : received_data) {
            std::cout << i << " ";
        }
        std::cout << std::endl;

        process_data();  // 接收完成后执行其他工作
    }

    return 0;
}

3. 使用步骤

安装 Boost.MPI:

如果还没有安装 Boost 和 MPI，可以使用以下命令：

sudo apt-get install libboost-mpi-dev openmpi-bin openmpi-common openmpi-doc libopenmpi-dev

编译代码:

将上述代码分别保存为 async_mpi_test.cpp 和 sync_mpi_test.cpp，并使用 mpic++ 编译：

mpic++ -o async_mpi_test async_mpi_test.cpp -lboost_mpi -lboost_serialization
mpic++ -o sync_mpi_test sync_mpi_test.cpp -lboost_mpi -lboost_serialization

运行测试:
- 使用 mpirun 启动两个进程运行异步和同步测试程序：
```
mpirun -np 2 ./async_mpi_test
mpirun -np 2 ./sync_mpi_test
```

4. 测试结果

运行异步通信程序的输出：

Process 0 is doing some other work while sending data...
Process 1 is doing some other work while receiving data...
Process 0 finished sending data.
Process 1 received data: 1 2 3 4 5

运行同步通信程序的输出：

Process 0 finished sending data.
Process 1 received data: 1 2 3 4 5

5. 结果分析

异步通信:
- 在异步模式下，进程 0 在数据传输过程中可以并行执行其他任务，而不必等待发送完成。类似地，进程 1 在数据到达前也可以执行其他任务。这种方式可以有效利用 CPU 时间，提高并行计算的效率。
- 异步通信通常适用于需要重叠计算和通信的情况，尤其是在长时间的数据传输或大量数据的情况下。
同步通信:
- 在同步模式下，进程 0 会等待数据完全发送完毕，然后才开始执行其他任务。进程 1 也会等待数据完全接收完毕，然后再执行其他任务。通信与计算的次序是严格线性的。
- 同步通信的优点是简单且容易实现，但它可能会导致 CPU 资源的浪费，特别是在通信延迟较大或通信量较大的情况下。
对比:
- 异步通信在高性能计算中有显著优势，因为它允许计算与通信的重叠，从而最大限度地利用系统资源。
- 同步通信虽然简单，但可能导致等待时间的增加，进而影响系统整体性能。适用于简单且通信量较少的场景。

通过这些测试，可以直观地看到异步通信如何在程序执行过程中提高效率，尤其是当数据传输时间较长时。

总结

Boost.MPI 是一个强大而易用的库，它封装了传统 MPI 的复杂性，提供了高层次、类型安全和自动序列化的接口，使得 C++ 开发者可以更加专注于算法设计，而无需担心底层通信细节。与其他进程间通信工具相比，Boost.MPI 在分布式多节点计算环境中表现优异，尤其适合需要跨多个物理节点进行通信的应用场景。

Narcotis

关注

9
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
BOOST c++库学习之 boost.mpi库入门实战指南以及使用 boost.mpi库实现进程间通讯（同步与异步的对比）的简单例程

Boost.MPI 提供了一系列简洁的 API，用于实现点对点通信、集体通信和异步通信等功能。: 初始化和管理 MPI 环境。: 表示一个通信通道，包含了所有进程的上下文。send/recv: 实现进程间的同步发送和接收操作。: 提供集体通信功能，如广播数据、收集数据。: 用于异步通信，使进程可以在等待通信完成时继续其他操作。
复制链接

扫一扫

BOOST c++库学习 之 boost.mpi库入门实战指南 以及 使用 boost.mpi库实现进程间通讯（同步与异步的对比）的简单例程

Boost.MPI 库介绍

1. 概述

2. 与其他进程间通信工具的对比

2.1 Boost.MPI vs 传统 MPI

2.2 Boost.MPI vs Boost.Interprocess

2.3 Boost.MPI vs POSIX IPC（共享内存、消息队列等）

3. Boost.MPI API 简介

Boost.MPI 各个接口函数 API 详解以及使用

1. 环境和通信器管理

1.1 mpi::environment

1.2 mpi::communicator

2. 点对点通信

2.1 send

2.2 recv

2.3 isend 和 irecv

3. 集体通信

3.1 broadcast

3.2 scatter

3.3 gather

3.4 all_gather

4. 异常处理

4.1 mpi::exception

5. 其他有用的工具

5.1 mpi::reduce

5.2 mpi::all_reduce

Boost.MPI 异步与同步进程间通信对比测试

1. 异步通信示例

2. 同步通信示例

3. 使用步骤

4. 测试结果

5. 结果分析

总结

BOOST c++库学习之 boost.mpi库入门实战指南以及使用 boost.mpi库实现进程间通讯（同步与异步的对比）的简单例程

1.1 `mpi::environment`

1.2 `mpi::communicator`

2.1 `send`

2.2 `recv`

2.3 `isend` 和 `irecv`

3.1 `broadcast`

3.2 `scatter`

3.3 `gather`

3.4 `all_gather`

4.1 `mpi::exception`

5.1 `mpi::reduce`

5.2 `mpi::all_reduce`