Question

我遇到了ZeroMQ的问题，我认为这是因为我对它不是很熟悉。

我正在尝试构建一个非常简单的服务，其中多个客户端连接到服务器并发送查询。服务器响应此查询。

当我使用REQ-REP套接字组合（客户端使用REQ，服务器绑定到REP套接字）时，我能够在服务器端每秒接近60,000条消息（当客户端和服务器在同一台机器上时）。当跨机器分布时，不同机器上的每个新客户端实例都会线性增加服务器上的每秒消息数，并且在足够的客户端实例下可轻松达到40,000+。

现在REP套接字正在阻塞，所以我遵循了ZeroMQ指南并使用了rrbroker模式（http://zguide.zeromq.org/cs:rrbroker）：

REQ (client) <----> [server ROUTER -- DEALER --- REP (workers running on different threads)]

然而，这完全搞砸了性能。在跨机器运行时，我在服务器上每秒只能获得大约4000条消息。不仅如此，在不同机器上启动的每个新客户端都会降低每个其他客户端的吞吐量。

我很确定我做的事情很愚蠢。我想知道ZeroMQ专家是否可以指出任何明显的错误。谢谢！

编辑：根据建议添加代码。我正在使用clrzmq nuget包（https://www.nuget.org/packages/clrzmq-x64/）

这是客户端代码。计时器计算每秒接收的响应数。

for (int i = 0; i < numTasks; i++) { Task.Factory.StartNew(() => Client(), TaskCreationOptions.LongRunning); }

void Client()
    {
        using (var ctx = new Context())
        {
            Socket socket = ctx.Socket(SocketType.REQ);
            socket.Connect("tcp://192.168.1.10:1234");
            while (true)
            {
                socket.Send("ping", Encoding.Unicode);
                string res = socket.Recv(Encoding.Unicode);
            }
        }
    }

服务器 - 案例1 ：服务器会跟踪每秒收到的请求数

using (var zmqContext = new Context())
{
    Socket socket = zmqContext.Socket(SocketType.REP);
    socket.Bind("tcp://*:1234");
    while (true)
    {
        string q = socket.Recv(Encoding.Unicode);
        if (q.CompareTo("ping") == 0) {
            socket.Send("pong", Encoding.Unicode);
        }
    }
}

使用此设置，在服务器端，我可以看到每秒接收大约60,000个请求（当客户端在同一台计算机上时）。当在不同的计算机上时，每个新客户端都会按预期增加在服务器上接收的请求数。

服务器案例2：这实际上是ZMQ指南中的rrbroker。

   void ReceiveMessages(Context zmqContext, string zmqConnectionString, int numWorkers)
   {
       List<PollItem> pollItemsList = new List<PollItem>();

       routerSocket = zmqContext.Socket(SocketType.ROUTER);
       try
       {
            routerSocket.Bind(zmqConnectionString);
            PollItem pollItem = routerSocket.CreatePollItem(IOMultiPlex.POLLIN);
            pollItem.PollInHandler += RouterSocket_PollInHandler;
            pollItemsList.Add(pollItem);
       }
       catch (ZMQ.Exception ze)
       {
            Console.WriteLine("{0}", ze.Message);
            return;
       }

        dealerSocket = zmqContext.Socket(SocketType.DEALER);
        try
        {
            dealerSocket.Bind("inproc://workers");
            PollItem pollItem = dealerSocket.CreatePollItem(IOMultiPlex.POLLIN);
            pollItem.PollInHandler += DealerSocket_PollInHandler;
            pollItemsList.Add(pollItem);
        }
        catch (ZMQ.Exception ze)
        {
            Console.WriteLine("{0}", ze.Message);
            return;
        }

        // Start the worker pool; cant connect  
        // to inproc socket before binding.
        workerPool.Start(numWorkers);

        while (true)
        {
           zmqContext.Poll(pollItemsList.ToArray());
        }
    }

    void RouterSocket_PollInHandler(Socket socket, IOMultiPlex revents)
    {
        RelayMessage(routerSocket, dealerSocket);
    }

    void DealerSocket_PollInHandler(Socket socket, IOMultiPlex revents)
    {
        RelayMessage(dealerSocket, routerSocket);
    }

    void RelayMessage(Socket source, Socket destination)
    {
        bool hasMore = true;
        while (hasMore)
        {
            byte[] message = source.Recv();
            hasMore = source.RcvMore;
            destination.Send(message, message.Length, hasMore ? SendRecvOpt.SNDMORE : SendRecvOpt.NONE);
        }
    }

工作池的启动方法是：

   public void Start(int numWorkerTasks=8)
    {   
        for (int i = 0; i < numWorkerTasks; i++)
        {
            QueryWorker worker = new QueryWorker(this.zmqContext);
            Task task = Task.Factory.StartNew(() =>
            worker.Start(),
            TaskCreationOptions.LongRunning);
        }
        Console.WriteLine("Started {0} with {1} workers.", this.GetType().Name, numWorkerTasks);
    }

public class QueryWorker
{
    Context zmqContext;

    public QueryWorker(Context zmqContext)
    {
        this.zmqContext = zmqContext;
    }

    public void Start()
    {
        Socket socket = this.zmqContext.Socket(SocketType.REP);
        try
        {
            socket.Connect("inproc://workers");
        }
        catch (ZMQ.Exception ze)
        {
            Console.WriteLine("Could not create worker, error: {0}", ze.Message);
            return;
        }

        while (true)
        {
            try
            {
                string message = socket.Recv(Encoding.Unicode);
                if (message.CompareTo("ping") == 0)
                {
                    socket.Send("pong", Encoding.Unicode);
                }
            }
            catch (ZMQ.Exception ze)
            {
                Console.WriteLine("Could not receive message, error: " + ze.ToString());
            }
        }
    }
}

Answer 1

您是否可以发布一些源代码或至少更详细的测试用例说明？一般来说，构建设计的方法是一次进行一次更改，并在每次更改时进行测量。您可以随时从已知的工作设计逐步移动到更复杂的设计。

Answer 2

很可能是＆＃39; ROUTER＆＃39;是瓶颈。

查看以下相关问题：

Client maintenance in ZMQ ROUTER
Load testing ZeroMQ (ZMQ_STREAM) for finding the maximum simultaneous users it can handle

ROUTER（和ZMQ_STREAM，它只是ROUTER的一种变体）内部必须维护客户端映射，因此IMO可以接受来自特定客户端的有限连接。看起来ROUTER可以复用多个客户端，只要每个客户端只有一个活动连接。

我可能在这里错了 - 但我没有看到相反的证据（简单的工作代码可以扩展到具有ROUTER或STREAM的多连接的多客户端）。

对于与ZeroMQ的并发连接肯定存在非常严格的限制，尽管看起来没人知道是什么导致了它。

Answer 3

我已经完成了使用C＃中的各种方法调用本机非托管DLL函数的性能测试： 1. C ++ / CLI包装器 2. PInvoke 3. ZeroMQ / clrzmq

最后一点可能对你有意思。

我在性能测试结束时的发现是，在我尝试优化绑定源代码中的PInvoke调用之后，使用ZMQ绑定clrzmq没有用，并产生了100倍的性能开销。因此，我使用了没有绑定但是使用PInvoke调用的ZMQ。这些调用必须使用cdecl约定和选项＆＃34; SuppressUnmanagedCodeSecurity＆＃34;获得最快的速度。我只需导入5个相当简单的函数。最后速度比PInvoke调用慢一点，但是在我的情况下使用ZMQ＆＃34; inproc＆＃34;。

如果速度对您有意义，这可能会给您提示在没有绑定的情况下尝试它。

这不是您问题的直接答案，但可能会帮助您提高整体效果。

ZeroMQ性能问题

3 个答案: