C++高性能编程：使用 Nanomsg 实现基于共享内存的发布-订阅模型

已于 2024-08-07 07:19:04 修改
阅读量1.2k 收藏 23
点赞数 35
分类专栏： C++ C++中间件 性能优化、功能优化 文章标签： nanomsg 共享内存 cpp-ipc shm nn_poll poll 进程间通信
于 2024-08-06 22:10:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/stallion5632/article/details/140966467
版权

0. 概要

Nanomsg在发送消息的时候足够高效，但是由于进程间通信是ipc管道，因此发送文件或者图片的时候实时性不够好。
文件将介绍如何基于Nanomsg框架 实现一个基于共享内存的发布-订阅模型。
本文详细代码：sub_pub_nanomsg_shm
前置阅读: C++编程：使用Nanomsg实现高效的文件和图片传输
共享内存库的选择请看 C++编程：使用cpp-ipc实现基于共享内存的进程间发布订阅

1. 订阅者代码解析 (sub_nanomsg_shm.cc)

首先来看 sub_nanomsg_shm.cc 文件中的实现，该文件负责接收发布者发送的数据，并通过共享内存进行通信。

#include "pub_sub_common.h"

double total_latency = 0.0;
ipc::route* p_shm_channel = nullptr;
std::chrono::high_resolution_clock::time_point start_time;
std::chrono::high_resolution_clock::time_point end_time;

// 信号处理函数
void signal_handler(int signal) {
  fprintf(stdout, "Received signal %d\n", signal);
  if (p_shm_channel != nullptr) {
    p_shm_channel->disconnect();
    fprintf(stdout, "Disconnected from shared memory channel\n");
  }
}

// 处理接收到的共享内存数据
void shm_consumer(ipc::route& shm_channel) {
  auto buffer = shm_channel.recv();
  const uint32_t buffer_size = buffer.size();

  if (buffer_size < sizeof(uint32_t)) {
    fprintf(stderr, "buffer_size < 4, received termination signal\n");
    return;
  }
  end_time = std::chrono::high_resolution_clock::now();

#if ENABLE_CRC_CHECK
  uint8_t* buffer_header = reinterpret_cast<uint8_t*>(buffer.data());
  uint32_t received_length;
  std::memcpy(&received_length, buffer_header, sizeof(received_length));

  uint16_t received_crc;
  std::memcpy(&received_crc, buffer_header + sizeof(received_length), sizeof(received_crc));

  uint32_t data_length = buffer_size - sizeof(uint32_t) - sizeof(uint16_t);
#if DEBUG_ON
  fprintf(stdout, "buffer_size: %u, received_length: %u, data_length: %u, received_crc: %hx\n", buffer_size,
          received_length, data_length, received_crc);
#endif

  if (received_length != data_length) {
#if DEBUG_ON
    fprintf(stdout, "data length exceeds buffer size, expected %u, got %u\n", received_length, data_length);
#endif
    return;
  }

  uint16_t calculated_crc =
    calculate_crc2(reinterpret_cast<char*>(buffer_header + sizeof(uint32_t) + sizeof(uint16_t)), received_length);

  if (calculated_crc != received_crc) {
    fprintf(stdout, "CRC mismatch: expected %hx, got %hx\n", received_crc, calculated_crc);
    return;
  }
#if DEBUG_ON
  fprintf(stdout, "received data of size %u bytes with valid CRC\n", received_length);
#endif
#endif
}

// 运行 Nanomsg 订阅者
void nanomsg_subscriber(std::vector<std::chrono::duration<double, std::micro>>& latencies) {
  ipc::route shm_channel(kIpcRouteName, ipc::receiver);
  if (!shm_channel.valid()) {
    fprintf(stderr, "channel %s is not valid.\n", kIpcRouteName);
    return;
  } else {
    p_shm_channel = &shm_channel;
  }

  setup_signal_handlers();

  int sock = nn_socket(AF_SP, NN_SUB);
  if (sock < 0) {
    fprintf(stderr, "Error creating subscriber socket: %s\n", nn_strerror(nn_errno()));
    return;
  }
  if (nn_connect(sock, URL) < 0) {
    fprintf(stderr, "Error connecting subscriber socket: %s\n", nn_strerror(nn_errno()));
    nn_close(sock);
    return;
  }
  nn_setsockopt(sock, NN_SUB, NN_SUB_SUBSCRIBE, "", 0);
  nn_setsockopt(sock, NN_SOL_SOCKET, NN_RCVTIMEO, &RECEIVE_TIMEOUT, sizeof(RECEIVE_TIMEOUT));

  fprintf(stdout, "Subscriber socket connected to %s\n", URL);

  char* buf = nullptr;
  nn_pollfd pfd[1];
  pfd[0].fd = sock;
  pfd[0].events = NN_POLLIN;
  uint32_t recv_count{0};
  fprintf(stdout, "@@ Start to recv, current time: %s\n", get_currenttime_millis().c_str());
  start_time = std::chrono::high_resolution_clock::now();
  while (recv_count < NUM_MESSAGES) {
    int rc = nn_poll(pfd, 1, POLL_TIMEOUT);
    if (rc < 0) {
      fprintf(stderr, "Error polling socket: %s\n", nn_strerror(nn_errno()));
      return;
    } else if (rc > 0) {
      if ((pfd[0].revents & NN_POLLIN) != 0U) {
        int bytes = nn_recv(sock, &buf, NN_MSG, 0);
        shm_consumer(shm_channel);
        if (bytes < 0) {
          fprintf(stderr, "Error receiving message %d: %s\n", recv_count + 1, nn_strerror(nn_errno()));
          if (buf) {
            nn_freemsg(buf);
          }
          return;
        }
        nn_freemsg(buf);
        recv_count += 1;
      }
    } else {
#if DEBUG_ON
      fprintf(stdout, "nn_poll timeout %d(ms)\n", POLL_TIMEOUT);
#endif
    }
  }
  end_time = std::chrono::high_resolution_clock::now();
  fprintf(stdout, "@@ Finish recv, current time: %s\n", get_currenttime_millis().c_str());
  nn_close(sock);
}

int main() {
  std::vector<std::chrono::duration<double, std::micro>> latencies;
  nanomsg_subscriber(latencies);

  auto total_latency = end_time - start_time;
  auto avg_latency = total_latency / NUM_MESSAGES;
  fprintf(stdout, "Subscriber receive %d messages.\nAverage latency: %lf milliseconds\n", NUM_MESSAGES,
          std::chrono::duration<double, std::milli>(avg_latency).count());

  return 0;
}

1.1 代码解析
Start
Initialize Publisher Socket
Bind Publisher Socket
Check Subscriber Ready
Generate Data with CRC
Send Data Using nn_send
End
  • 信号处理函数：用于处理进程信号，确保在接收到信号时正确断开与共享内存的连接。
  • 数据接收和验证：通过共享内存接收数据，并进行CRC校验，确保数据完整性。
  • Nanomsg 订阅者：初始化订阅者套接字，连接到指定URL，接收消息并调用 shm_consumer 处理接收到的数据。

2. 发布者代码解析 (pub_nanomsg.cc)

接下来是 pub_nanomsg.cc 文件的实现，该文件负责生成并发送数据给订阅者。

#include "pub_sub_common.h"

bool is_subcriber_ready() {
  try {
    FileLock lock;
    return lock.check();
  } catch (const std::exception& e) {
    std::cerr << "Error: " << e.what() << std::endl;
    return false;
  }
}

void publisher() {
  int sock = nn_socket(AF_SP, NN_PUB);
  if (sock < 0) {
    fprintf(stderr, "Error creating publisher socket: %s\n", nn_strerror(nn_errno()));
    return;
  }
  if (nn_bind(sock, URL) < 0) {
    fprintf(stderr, "Error binding publisher socket: %s\n", nn_strerror(nn_errno()));
    nn_close(sock);
    return;
  }
  int read_buf_len{0};
  size_t sz = sizeof(read_buf_len);
  nn_getsockopt(sock, NN_SOL_SOCKET, NN_SNDBUF, &read_buf_len, &sz);
  fprintf(stdout, "### Default NN_SNDBUF size %d.\n", read_buf_len);

#if ENABLE_CHANGE_BUFSIZE
  // 设置发送缓冲区大小
  nn_setsockopt(sock, NN_SOL_SOCKET, NN_SNDBUF, &BUFFER_SIZE, sizeof(BUFFER_SIZE));
  nn_getsockopt(sock, NN_SOL_SOCKET, NN_SNDBUF, &read_buf_len, &sz);
  fprintf(stdout, "### After set NN_SNDBUF size %d.\n", read_buf_len);
#endif

  fprintf(stdout, "Publisher socket bound to %s\n", URL);

  while (!is_subcriber_ready()) {
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
  }

  std::vector<uint8_t> large_data;
  uint32_t data_size = create_large_data(large_data);
  uint16_t crc = calculate_crc({large_data.begin() + sizeof(uint32_t) + sizeof(uint16_t), large_data.end()});
  std::memcpy(large_data.data(), &data_size, sizeof(data_size));
  std::memcpy(large_data.data() + sizeof(data_size), &crc, sizeof(crc));
  fprintf(stdout, "@@ Start to send, current time: %s\n", get_currenttime_millis().c_str());

  for (int i = 0; i < NUM_MESSAGES; ++i) {
#if DEBUG_ON
    fprintf(stdout, "Publisher prepared message %d of size %zu bytes\n", i + 1, large_data.size());
#endif
    int bytes = nn

_send(sock, large_data.data(), large_data.size(), 0);
    if (bytes < 0) {
      fprintf(stderr, "Error sending message: %s\n", nn_strerror(nn_errno()));
      nn_close(sock);
      return;
    }
#if DEBUG_ON
    fprintf(stdout, "Sent message %d of size %zu bytes\n", i + 1, large_data.size());
#endif
    std::this_thread::sleep_for(std::chrono::microseconds(THROTTLE_MESSAGE_SLEEP));  // 控制发送频率
  }
  fprintf(stdout, "@@ Finish send, current time: %s\n", get_currenttime_millis().c_str());
  std::this_thread::sleep_for(std::chrono::seconds(4));
  nn_close(sock);
}

int main() {
  publisher();
  fprintf(stdout, "Publisher finish send %d messages\n", NUM_MESSAGES);
  return 0;
}

2.1 代码解析
highlight
Start
Start Subscriber Socket
Connect Subscriber Socket
Poll for Data Using nn_poll
nn_poll
Receive Data Using nn_recv
Process Data and Validate CRC
End
  • 检查订阅者状态：使用文件锁机制检查订阅者是否已准备好接收数据。
  • 初始化发布者套接字：创建并绑定发布者套接字，设置发送缓冲区大小。
  • 数据生成和发送：生成包含 CRC 校验的数据包，并发送给订阅者，同时控制发送频率。

3. 执行结果

发送端

test@t:~/sub_pub_nanomsg_shm/build$ ./pub_nanomsg_shm 
channel recv_count is 1.
### Default NN_SNDBUF size 131072.
Publisher socket bound to ipc:///tmp/pub_sub_nanomsg.ipc
@@ Start to send, current time: 2024-08-06 13:09:57.704
@@ Finish send, current time: 2024-08-06 13:10:02.831
Publisher finish send 10000 messages

接收端

test@t:~/sub_pub_nanomsg_shm/build$ ./sub_nanomsg_shm 
Subscriber socket connected to ipc:///tmp/pub_sub_nanomsg.ipc
@@ Start to recv, current time: 2024-08-06 13:09:56.686
@@ Finish recv, current time: 2024-08-06 13:10:02.831
Subscriber receive 10000 messages.
Average latency: 0.614469 milliseconds

4. 对比直接使用nanomsg 发送文件

C++编程：使用Nanomsg实现高效的文件和图片传输中提到直接使用 Nanomsg 发送消息的结果的平均延时为3.096960 milliseconds

  • 发送时间：

    • 使用共享内存：大约 5.127 秒（13:09:57.704 到 13:10:02.831）
    • 直接使用 Nanomsg：大约 30.901 秒（13:56:10.115 到 13:56:41.016）

    使用共享内存的发送时间显著低于直接使用 Nanomsg，这表明共享内存的方式更高效。

  • 接收时间：

    • 使用共享内存：大约 6.145 秒（13:09:56.686 到 13:10:02.831）
    • 直接使用 Nanomsg：大约 30.970 秒（13:56:10.044 到 13:56:41.014）

    使用共享内存的接收时间同样显著低于直接使用 Nanomsg。

  • 平均延迟：

    • 使用共享内存：0.614469 毫秒
    • 直接使用 Nanomsg：3.096960 毫秒

    使用共享内存的平均延迟显著低于直接使用 Nanomsg，表明共享内存方式不仅在传输速度上有优势，而且在延迟上也表现更好。

  • 缓冲区大小：

    • 使用共享内存：
      • 发送端默认缓冲区大小为 131072 字节
    • 直接使用 Nanomsg：
      • 发送端设置缓冲区大小为 16777216 字节
      • 接收端设置缓冲区大小为 16777216 字节

    尽管直接使用 Nanomsg 时设置了更大的缓冲区，但由于发送和接收过程中数据的处理机制不同，仍然表现出较高的延迟和较慢的速度。

5. 总结

通过对比可以看出，使用共享内存的方式在传输效率和平均延迟方面都优于直接使用 Nanomsg 的方式。这主要是因为共享内存能够更直接地进行数据交换，减少了传输过程中的开销和延迟。因此，在需要高效大规模数据传输的场景中，使用本文提到的方案会是一种更优的选择。

橘色的喵
关注
  • 35
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Nanomsg 代码分析.docx
01-01
nanomsg 源码分析 ，
C++编程：使用cpp-ipc实现基于共享内存的进程间发布订阅
最新发布
Where there is life, there is hope.
08-02 1325
`mutouyun/cpp-ipc` 我们提供了一种高效、跨平台且无锁的进程间通信解决方案。本文将基于`cpp-ipc` 实现两个生产者和消费者实例，特别重点介绍可以传输大文件的示例代码。
车载中间件大全
Autostone99的博客
09-01 3265
软件定义汽车，核心中间件
Apollo如何通知/订阅主题topic
haima1998的专栏
10-14 968
转自：https://blog.csdn.net/u012423865/article/details/80024870 导读 众所周知，Apollo是基于ROS开发的，所以其底层也是基于消息的机制进行节点通信的。但是它在ROS的基础上做了一些改动，如下：  P2P——由于原生ROS的消息机制是通过主节点(Master)分发数据来实现的，这样一个强中心化的结构始终存在一个Master意外导致系统...
用nanomsg中的PUBSUB(发布、订阅)模式实现线程、进程间的消息互相传递
weixin_43701705的博客
11-27 2841
首先了解一下nanomsg的PUBSUB模式的原理 这个只能单方向从server发消息给client。 但是如果想要实现 进程与进程之间、进程与线程之间、线程与线程之间消息的互相传递，也是可以的，我个人进行如下的设计。 就像上面这样，每个 线程/进程 都新建两个线程，一个用来订阅接收，另一个用来发布。当然如果只需要接收不需要发布也可以不创建多个线程。 下面来写一个demo，demo功能如下 进程一 开三个线程 A B C A线程开两个子线程，发布线程绑定一个本地地址和一个进程地址，并且会发布 05 10
C++编程: 使用 Nanomsg 进行 PUB-SUB 模式基准测试
Where there is life, there is hope.
07-27 848
Nanomsg 作为一款高性能的通信库，支持多种消息传递模式，其中包括 PUB-SUB（发布-订阅）。 本篇文章将介绍如何使用 NanoMsg 库来实现一个简单的 PUB-SUB 模式的基准测试程序，该程序能够测量消息从发布到订阅的平均延迟。
Linux 使用nanomsg库进行进程间通信
weixin_45715405的博客
05-13 1169
server：创建一个pair模式的socket，然后将socket设置为非阻塞，将这个套接字加入到nn_poll中进行事假监控，当有事件来时，调用对应的回调函数，进行数据收发。nanomsg是一个消息通信组件，主要通过c语言进行编写的，使用宽松的MIT许可开源，小、轻、快，非常方便。可以使用json数据格式进行，通信，本项目就是使用json进行通信使用cjson库。1、pull/push 单向管道推送模式。3、pair 端对端双向通信模式。4、req/res模型，收发模式。
nanomsg实验——pubsub
weixin_34261415的博客
03-24 899
nanomsg实验——pubsub 发布订阅模式是很多消息中间件提供的常见功能。通过消息机制，能够将消息发布者和消息接收（消费）者 进行解耦。pubsub模式也是nanomsg直接支持的一直消息模型之一，因此通过pubsub模式实验， 同时也大致了解了下nanomsg的基础用法。 服务端 #include <stdio.h> #includ...
nanomsg(4) :pub/sub 模式
Mr.Sugarcane
08-31 653
nanomsg(4) :pub/sub 模式。
组合开发一个订阅发布通信库minimsg
jinyuttt的专栏
04-12 776
曾经的付出 以前根据自己的喜好和项目，研究过opendds，编译和使用都很复杂的东西，但是它是dds的一个标准。 以为学习Java，所有了就过netty,弄过dotnetty,但是官方都没有管了。 接触通信传输，UDP的使用很快，弄过一个udt. Java的mq都接触过，还了解过nsq(go). 看见没有，我对网络通信很感兴趣。 自己也写过简单的网络通信，当然号称高效通信。 当然还有正在使用的grpc库。 看，我多么无聊。所以，我任然关注通信、数据库‘分布式。 最近又开始了...
Nanomsg 代码分析
01-28
本人从本站下载的Nanomsg资源，发布的人太黑了，要5个资源分，于是本人下载后再次发布，只要1资源分，同时呼吁大家都照搬本人的操作，鄙视要那么多资源分的人，支持的顶哦！
C++高效编程：内存与性能优化(pdf版）
09-11
C++高效编程：内存与性能优化(pdf版），深入C++经典好书！
Web技术（七）：如何使用并实现MQTT 消息订阅-发布模型？
流云
05-12 1万+
物联网时代，大量的嵌入式设备需要接入网络，并完成复杂的消息传递过程。基于请求响应的单对单同步通信协议 -- HTTP 已经难以满足大规模物联网设备的通信需求，因此需要为物联网通信设计一种新的消息传递机制，MQTT 实现的订阅-发布消息模型就可以满足物联网通信需求。什么是订阅-发布消息模型呢？这种消息传递模型有哪些应用呢？订阅-发布消息模型除了用于复杂网络节点间的通信，是否可用于进程或服务间通信呢？MQTT 是如何实现消息订阅-发布机制的呢？MQTT 又是如何保证网络通信安全的呢？
C++11 时间编程（5） std::chrono::steady_clock使用--计算程序片段执行时间
二进制君
10-24 7268
std::chrono是C++11引入的日期时间处理库，其中包含3种时钟：system_clock，steady_clock，high_resolution_clock。分别是系统时钟，单调时钟，high_resolution_clock字面意思是高精度时钟，其底层究竟是使用系统时钟还是单调时钟，取决于实现。 /** * @brief Monotonic clock * * Time returned has the property of only increas
Microsoft C++ 异常: std::length_error，位于内存位置 0x000000AF9B7AF810 处
jacke121的专栏
09-22 1万+
mnn运行报错： 0x00007FFCFD1C4ED9 处(位于 mnn_yolo.exe 中)有未经处理的异常: Microsoft C++ 异常: std::length_error，位于内存位置 0x000000AF9B7AF810 处。 原因： release库，选择运行库模式 mtd，这时需要引用debug库，但是运行会报错。 解决方法： release，运行库需要设置成mt或者md debug，运行库需要设置为MTd或者MDd 　在各个版本的编译器中，我们可以通过配置选...
深入探究基于发布/订阅模式的轻量级消息传输协议 MQTT
热门推荐
dvlinker的技术专栏
10-13 2万+
深入探究基于发布 / 订阅模式的轻量级消息传输协议MQTT。
nanomsg项目实战
deroy
03-03 2642
文章目录nanomsg下载编译使用方式基本概念PipelineRequest/ReplyPairPub/SubSurveyBus项目中使用发布服务订阅服务makefile nanomsg下载 下载地址：https://github.com/nanomsg/nanomsg/releases 编译 unzip nanomsg-1.1.5.zip cd nanomsg-1.1.5/ mkdir build cd build cmake .. cmake --build . ctest . sudo cmake
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

橘色的喵

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值