通过 boost::asio::udp 以高数据速率发送图像数据？

Question

我有 4MB 大的图像，必须通过以太网发送。这些图像来自一台计算机 X86_64，它生成它们，然后发送到另一台计算机 ARM。图像以两位数的帧速率生成，我使用 6a 类电缆以确保我能够以合理的速度获得足够的数据。我无法理解哪种实用程序 boost 可以让我通过 UDP 发送任意大小的数据，并在另一端接收它。两台计算机都安装了 Boost，都是 linux（但不同的发行版）。单个图像丢失并不是那么重要，但发送或拒绝整个图像很重要。

• 我是否必须手动细分要发送的数据？
• 如果出现这种情况，我该如何处理图像丢包？就像我怎样才能知道我的图像的结尾是什么？我必须用它对应的图像行标记每个数据包吗？
• boost 是否有实用程序来处理通过 UDP 发送的任意数据？

在我自己尝试这样做（用行标识符标记每一行）之后，我似乎过度饱和了一些缓冲区（标签是连续的，直到某个点，它们开始单调地增加数量，所以没有重新排序，但丢包）注意这是在本地主机上，所以我不确定我应该期待什么。

我似乎无法找到解决大量图像丢失的方法，但我不确定这是否只是因为某些网络电缆限制（尽管在本地主机上发送和接收？）。

我会改用 TCP，但我需要确保我可以通过另一端的直接以太网连接可靠地获得 200MB/s。图像开始发送之前的时间不如给定秒内的整体吞吐量重要。

我为此编写的稍微简化的代码：

发送图片

// sender.cpp

#include <thread>
#include <chrono>
#include <algorithm>
#include <boost/asio.hpp>
#include <boost/array.hpp>
#include "PgmImage.h"

using boost::asio::ip::udp;

const std::string &host = "localhost";
const std::string &port = "8000";
const int image_width = 2048;
const int image_height = 2048;

int main() {
    try {
        boost::asio::io_service io_service;
        udp::resolver resolver(io_service);
        udp::resolver::query query(udp::v4(), host, port);
        udp::endpoint receiver_endpoint = *resolver.resolve(query);
        udp::socket send_socket(io_service);
        send_socket.open(udp::v4());
        boost::array<std::uint16_t, 2> send_header_buffer;
        boost::array<std::uint8_t, image_height + 2> send_row_buffer;
        auto time1 = std::chrono::high_resolution_clock::now();
        for (int j = 0; j < 1000; ++j) {
            for (const auto &file_path : file_path_list) {
                // reads in image and has a vector member of char. 
                PgmP5Image image("../short_armcam_clip/" + file_path);
                send_header_buffer = {image.width(), image.height()};
                send_socket.send_to(boost::asio::buffer(send_header_buffer), receiver_endpoint);
                for (std::uint16_t i = 0; i < image_height; i++) {
                    send_row_buffer[0] = static_cast<std::uint8_t>(i >> 8);
                    send_row_buffer[1] = static_cast<std::uint8_t>(i);
                    std::copy(&image.getRawBytes()[i * image_width],
                              &image.getRawBytes()[i * image_width + image_width], &send_row_buffer[2]);
                    send_socket.send_to(boost::asio::buffer(send_row_buffer), receiver_endpoint);
                    if (i % 64 == 0) {
                        std::this_thread::sleep_for(std::chrono::duration<int, std::milli>(1));
                    }
                }
            }
        }
        auto time2 = std::chrono::high_resolution_clock::now();
        std::cout << "took : " << std::chrono::duration_cast<std::chrono::milliseconds>(time2 - time1).count() << "millis"
                  << std::endl;
    }
    catch (std::exception &e) {
        std::cerr << e.what() << std::endl;
    }
    return 0;
}

接收图像

// receiver.cpp

#include <ctime>
#include <iostream>
#include <string>
#include <boost/asio.hpp>
#include <boost/array.hpp>
#include <iostream>

using boost::asio::ip::udp;

int main() {
    try {
        boost::asio::io_service io_service;
        udp::socket socket(io_service, udp::endpoint(udp::v4(), 8000));
        udp::endpoint remote_endpoint;

        boost::array<std::uint16_t, 2> recv_header_buffer;
        boost::array<std::uint8_t, 2050> recv_row_buffer;
        int num_recieved = 0;
        while (true) {
            boost::system::error_code error;
            socket.receive_from(boost::asio::buffer(recv_header_buffer), remote_endpoint, 0, error);
            if (error && (error != boost::asio::error::message_size)) {
                throw boost::system::system_error(error);
            }
            int width = recv_header_buffer[0];
            int height = recv_header_buffer[1];
            std::cout << "width : " << width << " height : " << height << std::endl;
            for (int i = 0; i < height; ++i) {
                socket.receive_from(boost::asio::buffer(recv_row_buffer), remote_endpoint, 0, error);
                if (error && (error != boost::asio::error::message_size)) {
                    throw boost::system::system_error(error);
                }
                std::uint16_t row = (recv_row_buffer[0] << 8) + recv_row_buffer[1];

                std::cout << "row : " << row << " processed " << std::endl;
                std::cout << "i : " << i << std::endl;
                if (row != i) {
                    break;
                }
                if (i == 2047) {
                    num_recieved += 1;
                    std::cout << "Num received: " << num_recieved << std::endl;
                }
            }
        }
    }
    catch (std::exception &e) {
        std::cerr << e.what() << std::endl;
    }
}

Answer 1

• 我是否必须手动细分要发送的数据？

是的，你知道。您应该对它们进行分段，以便每个段适合以太网数据包（1536 字节 - 以太网 + ip + udp 标头），这有点不方便，但所有段都可以作为向量的向量传递到 asio::buffer 到 async_write ()。

• 如果出现这种情况，我该如何处理图像丢包？就像我怎样才能知道我的图像的结尾是什么？我必须用它对应的图像行标记每个数据包吗？

您必须为每个数据包编号，一个数据包 # 就足够了，但您的错误处理最终可能会使您的传输速度比 tcp 慢。

• boost 是否有实用程序来处理通过 UDP 发送的任意数据？

据我所知，Boost 没有任何现成的工具可以帮助您通过 UDP 流式传输数据。

我认为您最好的选择是使用 TCP，它可以处理流式传输以获得最大速度，并为您提供一些额外的数据完整性保障。

• 我会改用 TCP，但我需要确保我可以通过另一端的直接以太网连接可靠地获得 200MB/s。图像开始发送之前的时间不如给定秒内的整体吞吐量重要。

只有一种方法可以检查这一点，那就是在您的网络上，在实际主机和目标之间运行测试。该问题的答案取决于网络硬件和拓扑、NIC 设备驱动程序和机器负载。

请注意，TCP 可能会为您提供尽可能高的吞吐量。您不必自己将数据分割成数据包，然后您就可以从 boost::asio 获得最大可能的性能。