Question

基于之前关于SO的问题建议我使用DEALER / ROUTER模型来最大化性能（而不是REQ / REP模型），我设置了以下客户端和服务器代码。

客户端asynccli.c源触发8个线程，每个线程在zmq TCP套接字上发送和接收。服务器asyncsrv.c触发4个工作线程并使用代理将传入的请求分发给工作线程。

对于持续10秒的测试，我的体验范围从40 000 msgs到120,000，最多12,000 msgs / sec，这是非常低的。我在拥有8GB内存的i7（8HT内核）笔记本电脑上运行Ubuntu。我使用czmq库。

我以为我可以实现＆gt; ZeroMQ使用200,000 msgs / s。我想我没有正确地捕捉到“异步”的事情。任何C示例代码？基本上我不知道如何得到异步的东西因为我现在在这里zmq_poll（）。

asynccli.c：

// results : 4000/s
#include "czmq.h"
int id = 0;

static void *
client_task (void *args)
{
    zctx_t *ctx = zctx_new ();
    void *client = zsocket_new (ctx, ZMQ_DEALER);

    char identity [10];

    sprintf (identity, "%d", id);
    zsockopt_set_identity (client, identity);
    zsocket_connect (client, "tcp://localhost:5570");

    zmq_pollitem_t items [] = { { client, 0, ZMQ_POLLIN, 0 } };
    int request_nbr = 0;
    while (true) {
        //  Tick once per second, pulling in arriving messages
        int centitick;
        for (centitick = 0; centitick < 100; centitick++) {
            zmq_poll (items, 1, 1);
            if (items [0].revents & ZMQ_POLLIN) {
                zmsg_t *msg = zmsg_recv (client);
                //zframe_print (zmsg_last (msg), identity);
                zmsg_destroy (&msg);
                break;
            }
        }

        id+=1;
        zstr_send (client, "request #%d", ++request_nbr);
    }
    zctx_destroy (&ctx);
    return NULL;
}

//  The main thread simply starts several clients and a server, and then
//  waits for the server to finish.

int main (void)
{

    zthread_new (client_task, NULL);
    zthread_new (client_task, NULL);
    zthread_new (client_task, NULL);
    zthread_new (client_task, NULL);
    zthread_new (client_task, NULL);
    zthread_new (client_task, NULL);
    zthread_new (client_task, NULL);
    zthread_new (client_task, NULL);

    zclock_sleep (10 * 1000);    //  Run for 10 seconds then quit
    printf ("\\ntotal iterations = %d\n" , id );
    return 0;
}

asyncsrv.c：

#include "czmq.h"

static void server_worker (void *args, zctx_t *ctx, void *pipe);

void *server_task (void *args)
{
    //  Frontend socket talks to clients over TCP
    zctx_t *ctx = zctx_new ();
    void *frontend = zsocket_new (ctx, ZMQ_ROUTER);
    zsocket_bind (frontend, "tcp://*:5570");

    //  Backend socket talks to workers over inproc
    void *backend = zsocket_new (ctx, ZMQ_DEALER);
    zsocket_bind (backend, "inproc://backend");

    //  Launch pool of worker threads, precise number is not critical
    int thread_nbr;
    for (thread_nbr = 0; thread_nbr < 3; thread_nbr++)
        zthread_fork (ctx, server_worker, NULL);

    //  Connect backend to frontend via a proxy
    zmq_proxy (frontend, backend, NULL);

    zctx_destroy (&ctx);
    return NULL;
}

static void
server_worker (void *args, zctx_t *ctx, void *pipe)
{
    void *worker = zsocket_new (ctx, ZMQ_DEALER);
    zsocket_connect (worker, "inproc://backend");

    while (true) {
        //  The DEALER socket gives us the reply envelope and message
        zmsg_t *msg = zmsg_recv (worker);
        zframe_t *identity = zmsg_pop (msg);
        zframe_t *content = zmsg_pop (msg);
        assert (content);
        zmsg_destroy (&msg);

        //  Sleep for some fraction of a second
        zframe_send (&identity, worker, ZFRAME_REUSE + ZFRAME_MORE);
        zframe_send (&content, worker, ZFRAME_REUSE);

        zframe_destroy (&identity);
        zframe_destroy (&content);
    }
}

int main (void)
{
    zthread_new (server_task, NULL);
    zclock_sleep (15 * 1000);    //  Run for 15 seconds then quit
    return 0;
}

Answer 1

你必须在工人中使用与经销商相同的逻辑：

while(1)

zmq_pollitem_t items [] = { { worker, 0, ZMQ_POLLIN, 0 } };

zmq_poll (items, 1, 1);

if (items [0].revents & ZMQ_POLLIN)

如果没有if语句，zmsg_recv（）会阻塞。此外，zmq_pollitem_t应在每次迭代时重新创建。我认为这有一个低级别的原因，看看使用FD_SET的原始套接字并选择，它可能会给你一个线索.......

此外，这也是不正确的：

for (centitick = 0; centitick < 100; centitick++) {

如果您只想测量100个iterrations，请使用一些计数器。

Answer 2

问题是：客户受到限制＆＃34;通过阅读＆＃39;发送功能之前发送＆＃39;在你的代码中。

现在，客户端中的代码是：

while(true)
{
  pull_any_income_messages()
  send()
}

这将严重限制客户端在发送任何待处理传入消息时发送任何内容。因此，这基本上成为请求 - 回复模式。

要缩放此尺寸，您必须将“传入的消息”分离出来。和＆＃39;发送＆＃39;部分。一种方法是，不是拥有处理发送和接收的通用客户端线程，而是为客户端创建两个独立的线程类型，专门发送，另一个独占读取。

另一种方法是进行基于信用的流量控制＆＃39;。 ZMQ指南中的第7章有关于它的信息（http://zguide.zeromq.org/page:all#Chapter-Advanced-Architecture-using-MQ）。

-GK

http://gk.palem.in/

如何使用ZeroMQ实现超过4000 msg /秒的速度？

2 个答案: