问题描述
ZeroMQ documentation提到了zmq_poll作为在单个线程上多路复用多个套接字的方法。仅在一个套接字中使用数据的线程中进行轮询有任何好处吗？还是应该只使用zmq_recv？
例如：
/* POLLING A SINGLE SOCKET */
while (true) {
zmq::poll(&items[0],1,-1);
if (items[0].revents & ZMQ_POLLIN) {
int size = zmq_recv(receiver,msg,255,0);
if (size != -1) {
// do something with msg
}
}
}
vs。
/* NO POLLING AND BLOCKING RECV */
while (true) {
int size = zmq_recv(receiver,0);
if (size != -1) {
// do something with msg
}
}
是否存在使用轮询的版本，还是仅将其用于多路复用？轮询会提高cpu使用效率吗？答案是否取决于接收消息的速度？
***编辑此帖子以包含一个玩具示例***
问这个问题的原因是，我观察到如果不进行轮询（超过一个数量级），我的订户可以实现更高的吞吐量
#include <thread>
#include <zmq.hpp>
#include <iostream>
#include <unistd.h>
#include <chrono>
using msg_t = char[88];
using timepoint_t = std::chrono::high_resolution_clock::time_point;
using milliseconds = std::chrono::milliseconds;
using microseconds = std::chrono::microseconds;
/* Log stats about how many packets were sent/received */
class SocketStats {
public:
SocketStats(const std::string& name) : m_socketName(name),m_timePrev(Now()) {}
void update() {
m_numPackets++;
timepoint_t timeNow = Now();
if (duration(timeNow,m_timePrev) > m_logIntervalMs) {
uint64_t packetsPerSec = m_numPackets - m_numPacketsPrev;
std::cout << m_socketName << " : " << "processed " << (packetsPerSec) << " packets" << std::endl;
m_numPacketsPrev = m_numPackets;
m_timePrev = timeNow;
}
}
private:
timepoint_t Now() { return std::chrono::steady_clock::Now(); }
static milliseconds duration(timepoint_t timeNow,timepoint_t timePrev) {
return std::chrono::duration_cast<milliseconds>(timeNow - timePrev);
}
timepoint_t m_timePrev;
uint64_t m_numPackets = 0;
uint64_t m_numPacketsPrev = 0;
milliseconds m_logIntervalMs = milliseconds{1000};
const std::string m_socketName;
};
/* non-polling subscriber uses blocking receive and no poll */
void startNonPollingSubscriber(){
SocketStats subStats("NonPollingSubscriber");
zmq::context_t ctx(1);
zmq::socket_t sub(ctx,ZMQ_SUB);
sub.connect("tcp://127.0.0.1:5602");
sub.setsockopt(ZMQ_SUBSCRIBE,"",0);
while (true) {
zmq::message_t msg;
bool success = sub.recv(&msg);
if (success) { subStats.update(); }
}
}
/* polling subscriber receives messages when available */
void startPollingSubscriber(){
SocketStats subStats("PollingSubscriber");
zmq::context_t ctx(1);
zmq::socket_t sub(ctx,0);
zmq::pollitem_t items [] = {{static_cast<void*>(sub),ZMQ_POLLIN,0 }};
while (true) {
zmq::message_t msg;
int rc = zmq::poll (&items[0],-1);
if (rc < 1) { continue; }
if (items[0].revents & ZMQ_POLLIN) {
bool success = sub.recv(&msg,ZMQ_DONTWAIT);
if (success) { subStats.update(); }
}
}
}
void startFastPublisher() {
SocketStats pubStats("FastPublisher");
zmq::context_t ctx(1);
zmq::socket_t pub(ctx,ZMQ_PUB);
pub.bind("tcp://127.0.0.1:5602");
while (true) {
msg_t mymessage;
zmq::message_t msg(sizeof(msg_t));
memcpy((char *)msg.data(),(void*)(&mymessage),sizeof(msg_t));
bool success = pub.send(&msg,ZMQ_DONTWAIT);
if (success) { pubStats.update(); }
}
}
int main() {
std::thread t_sub1(startPollingSubscriber);
sleep(1);
std::thread t_sub2(startNonPollingSubscriber);
sleep(1);
std::thread t_pub(startFastPublisher);
while(true) {
sleep(10);
}
}
解决方法
Q ：“在仅消耗一个套接字数据的线程中进行轮询有什么好处吗？”
哦，肯定有。
作为非阻塞设计的主要推动者，我始终主张在决定.poll()调用之前设计零等待的.recv()-s。
Q ：“轮询会提高CPU使用效率吗？”
更难的一个，但我喜欢它：
可以通过两种不同的方式来决定这个问题：
a）阅读.poll()方法和.recv()方法的源代码，并将其移植到目标平台上，并估算调用每个v / s的成本 >
b）测试运行时生态系统内部的两个用例，并在体内进行微基准测试。
无论哪种方式，您都可以看到差异。
您看不到ATM的是一旦您尝试（或一旦被迫）扩展用例以便适应其他属性（在前者或后者。
在这里，我的主要偏爱是在决定进一步使用之前先使用.poll()，这可以对实际的.recv()呼叫和其他更高级别的决定进行其他基于优先级的重排序，而这两个决定都不是源代码，测试也无法决定。
不要犹豫，先进行测试，如果测试似乎没有定论（以{低|超低}潜伏期的敏感性衡量），请深入源代码以了解原因。
,通常情况下，您可以通过在执行另一个轮询之前排空套接字来获得最佳性能。换句话说，一旦 poll 返回，你就一直读，直到 read 返回“没有更多数据”，此时你调用 poll。
示例见https://github.com/nyfix/OZ/blob/4627b0364be80de4451bf1a80a26c00d0ba9310f/src/transport.c#L524
这种方法有一些折衷（在代码注释中提到），但如果您只是从单个套接字读取数据，则可以忽略这些。