Question

我使用node.js，Python和Java为zeromq编写了一个简单的echo请求/回复测试。代码运行一个100K请求的循环。该平台是一款配备2核的5yo MacBook Pro和运行Snow Leopard的3G内存。

node.js始终比其他两个平台慢一个数量级。

爪哇： real 0m18.823s user 0m2.735s sys 0m6.042s

的Python： real 0m18.600s user 0m2.656s sys 0m5.857s

的node.js： real 3m19.034s user 2m43.460s sys 0m24.668s

有趣的是，使用Python和Java，客户端和服务器进程都使用了大约一半的CPU。 node.js的客户端使用大约一个完整的CPU，服务器使用大约30％的CPU。客户端进程也有大量的页面错误导致我相信这是一个内存问题。此外，在10K请求节点只慢3倍;它运行的时间越长越慢。

这是客户端代码（请注意，process.exit（）行也不起作用，这就是除了使用time命令之外我还包括内部计时器的原因）：

var zeromq = require("zeromq");

var counter = 0;
var startTime = new Date();

var maxnum = 10000;

var socket = zeromq.createSocket('req');

socket.connect("tcp://127.0.0.1:5502");
console.log("Connected to port 5502.");

function moo()
{
    process.nextTick(function(){
        socket.send('Hello');
        if (counter < maxnum)
        {
            moo();
        }
    });
}

moo();

socket.on('message',
          function(data)
          {
              if (counter % 1000 == 0)
              {
                  console.log(data.toString('utf8'), counter);
              }

              if (counter >= maxnum)
              {
                  var endTime = new Date();
                  console.log("Time: ", startTime, endTime);
                  console.log("ms  : ", endTime - startTime);
                  process.exit(0);
              }

              //console.log("Received: " + data);
              counter += 1;

          }
);

socket.on('error', function(error) {
  console.log("Error: "+error);
});

服务器代码：

var zeromq = require("zeromq");

var socket = zeromq.createSocket('rep');

socket.bind("tcp://127.0.0.1:5502",
            function(err)
            {
                if (err) throw err;
                console.log("Bound to port 5502.");

                socket.on('message', function(envelope, blank, data)
                          {
                              socket.send(envelope.toString('utf8') + " Blancmange!");
                          });

                socket.on('error', function(err) {
                    console.log("Error: "+err);
                });
            }
);

为了比较，Python客户端和服务器代码：

import zmq

context = zmq.Context()
socket = context.socket(zmq.REQ)
socket.connect("tcp://127.0.0.1:5502")

for counter in range(0, 100001):
    socket.send("Hello")
    message = socket.recv()

    if counter % 1000 == 0:
        print message, counter



import zmq

context = zmq.Context()
socket = context.socket(zmq.REP)

socket.bind("tcp://127.0.0.1:5502")
print "Bound to port 5502."

while True:
    message = socket.recv()
    socket.send(message + " Blancmange!")

Java客户端和服务器代码：

package com.moo.test;

import org.zeromq.ZMQ;
import org.zeromq.ZMQ.Context;
import org.zeromq.ZMQ.Socket;

public class TestClient
{
    public static void main (String[] args)
    {
        Context context = ZMQ.context(1);

        Socket requester = context.socket(ZMQ.REQ);
        requester.connect("tcp://127.0.0.1:5502");

        System.out.println("Connected to port 5502.");

        for (int counter = 0; counter < 100001; counter++)
        {
            if (!requester.send("Hello".getBytes(), 0))
            {
                throw new RuntimeException("Error on send.");
            }

            byte[] reply = requester.recv(0);
            if (reply == null)
            {
                throw new RuntimeException("Error on receive.");
            }

            if (counter % 1000 == 0)
            {
                String replyValue = new String(reply);
                System.out.println((new String(reply)) + " " + counter);
            }
        }

        requester.close();
        context.term();
    }
}

package com.moo.test;

import org.zeromq.ZMQ;
import org.zeromq.ZMQ.Context;
import org.zeromq.ZMQ.Socket;

public class TestServer
{
    public static void main (String[] args) {
        Context context = ZMQ.context(1);

        Socket socket  = context.socket(ZMQ.REP);
        socket.bind("tcp://127.0.0.1:5502");

        System.out.println("Bound to port 5502.");

        while (!Thread.currentThread().isInterrupted())
        {
            byte[] request = socket.recv(0);
            if (request == null)
            {
                throw new RuntimeException("Error on receive.");
            }

            if (!socket.send(" Blancmange!".getBytes(), 0))
            {
                throw new RuntimeException("Error on send.");
            }
        }

        socket.close();
        context.term();
    }
}

我想要节点，但由于代码大小，简单性和性能的巨大差异，我现在很难说服自己。

那么，有没有人见过这样的行为，或者我在代码中做了什么asin？

Answer 1

您正在使用第三方C ++绑定。据我了解，v8的“js-land”与用“c ++ land”编写的v8的绑定之间的交叉是非常昂贵的。如果你注意到，一些流行的database bindings节点完全用JS实现（虽然，部分我确定，因为人们不想编译东西，但也因为它有可能非常快。）

如果我没记错的话，当Ryan Dahl为节点编写Buffer对象时，他注意到如果他们主要用JS而不是C ++实现它们，实际上它们实际上要快得多。他最终在C++写下了他的所作所为，并在pure javascript中做了其他所有事情。

所以，我猜这里的部分性能问题与c ++绑定的特定模块有关。

基于第三方模块判断节点的性能不是确定其速度或质量的良好媒介。您可以更好地对节点的本机TCP接口进行基准测试。

Answer 2

“您可以尝试从Python示例中模拟逻辑（e.i仅在收到上一个消息后发送下一条消息）？” - Andrey Sidorov 7月11日6:24

我认为这是其中的一部分：

var zeromq = require("zeromq");

var counter = 0;
var startTime = new Date();

var maxnum = 100000;

var socket = zeromq.createSocket('req');

socket.connect("tcp://127.0.0.1:5502");
console.log("Connected to port 5502.");

socket.send('Hello');

socket.on('message',
          function(data)
          {
              if (counter % 1000 == 0)
              {
                  console.log(data.toString('utf8'), counter);
              }

              if (counter >= maxnum)
              {
                  var endTime = new Date();
                  console.log("Time: ", startTime, endTime);
                  console.log("ms  : ", endTime - startTime);
                  socket.close(); // or the process.exit(0) won't work.
                  process.exit(0);
              }

              //console.log("Received: " + data);
              counter += 1;

          socket.send('Hello');
          }
     );

socket.on('error', function(error) {
    console.log("Error: "+error);
});

此版本没有表现出与之前相同的增长速度，可能是因为它没有在服务器上尽可能多地抛出请求，只计算与之前版本相同的响应。它大约是Python / Java的1.5倍，而在之前的版本中慢了5-10倍。

对于这个目的，仍然不是一个令人惊叹的节点表彰，但肯定比“糟透了”要好得多。

Answer 3

这是节点的zeroMQ绑定的问题。我不知道从什么时候开始，但它是固定的，你会得到与其他语言相同的结果。

Answer 4

我对node.js并不熟悉，但是你执行它的方式是一遍又一遍地递归创建新函数，难怪它正在爆炸。为了与python或java相提并论，代码需要更加符合以下几行：

    if (counter < maxnum)
    {
       socket.send('Hello');
       processmessages();  // or something similar in node.js if available
    }

Answer 5

使用REQ / REP套接字进行的任何性能测试都会因为往返和线程延迟而出现偏差。对于每条消息，你基本上都在为整个堆栈唤醒。它作为度量标准并不是很有用，因为REQ / REP情况从来都不是高性能（它们不可能）。有两个更好的性能测试：

从1个字节到1K发送各种大小的消息，查看您可以发送的消息数量，例如10秒这为您提供了基本的吞吐量这告诉你堆栈的效率如何。
衡量端到端的延迟，但是会出现一些消息;即在每条消息中插入时间戳，并查看接收器上的偏差。这告诉你堆栈是否有抖动，例如由于垃圾收集。

Answer 6

你的客户端python代码在循环中被阻塞。在节点示例中，您将异步接收“message”事件处理程序中的事件。如果你想从你的客户端获得数据是从zmq接收数据，那么你的python代码将更有效，因为它被编码为一个专门的一招小马。如果你想添加诸如监听其他不使用zmq的事件之类的功能，那么你会发现重写python代码很复杂。使用node，您只需要添加另一个事件处理程序。节点永远不会成为简单示例的性能野兽。但是，随着您的项目变得越来越复杂，移动部件越来越多，将正确功能添加到节点要比使用您编写的vanilla python更容易。我宁愿在硬件上投入更多钱，提高可读性并减少开发时间/成本。

node.js使用zeromq与Python与Java相比的性能

6 个答案: