【问题标题】:node.js performance with zeromq vs. Python vs. Javazeromq 与 Python 与 Java 的 node.js 性能
【发布时间】:2011-10-02 12:19:27
【问题描述】:

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

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

Java: 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();
    }
}

我喜欢 node,但由于代码大小、简单性和性能方面的巨大差异,我现在很难说服自己。

那么,以前有没有人看到过这样的行为,或者我在代码中做了什么愚蠢的事情?

【问题讨论】:

  • 您可以尝试从您的 Python 示例中模拟逻辑(例如,我仅在收到上一条消息后才发送下一条消息)?
  • 你必须记住 Node 还很年轻。你不能指望像 python 这样的老手在其 1.0.0 版本还没有发布的框架下的简单性和口才。
  • 我想知道 Node.js 的 zmq 模块是否有问题?我做了一个simple micro benchmark,它显示 Node.js 比所有版本的 Python 都快得多,用于简单的数字运算,与 Java 的速度相当。
  • 我不知道这是不是一个公平的测试。正如您所说,您的节点进程只使用了一个核心。由于节点使用单个进程,因此它只能使用一个内核,而线程解决方案可以免费使用您机器上的所有内核。这个页面展示了如何(用很少​​的代码行)spool up N 个节点进程,其中 N 是核心数:nodejs.org/api/cluster.html
  • @Jess 其他两个示例都没有使用线程。

标签: java python node.js zeromq


【解决方案1】:

“您可以尝试从您的 Python 示例中模拟逻辑(例如,我仅在收到上一条消息后才发送下一条消息)?” – 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 倍。

对于 node 来说仍然不是一个惊人的赞扬,但肯定比“abysmal”要好得多。

【讨论】:

    【解决方案2】:

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

    如果我没记错的话,当 Ryan Dahl 为 node 编写 Buffer 对象时,他注意到如果他主要用 JS 而不是 C++ 实现它们,它们实际上要快得多。他最终在C++ 中写了他必须写的东西,并在pure javascript 中完成了其他所有事情。

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

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

    【讨论】:

    • 我同意你的观点,只是我对 Node 的原生界面不感兴趣:我想使用 zeromq。因此,使用我打算用于项目的模块和接口的真实世界基准测试正是执行的最佳基准测试。其他任何东西都是人为的,不是很相关。
    • 如果有人写了一个原生的 JS ZeroMQ 接口,我们可以期待什么样的性能?也许比 Python 或 Java 还要快?
    • @dkamins:很有可能,但是您在那时遇到了维护问题,因为所有(我认为,尚未检查)zeromq 接口都使用 C 实现。
    【解决方案3】:

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

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

    【讨论】:

    • 修改后的解决方案既解决了这个问题,也解决了真正的性能杀手:将消息扔到服务器而不首先处理响应。它的性能仍然比 Python 或 Java 差,只是没有最初有缺陷的尝试那么慢。
    【解决方案4】:

    您的客户端 python 代码在循环中阻塞。在节点示例中,您在“消息”事件处理程序中异步接收事件。如果您只想从客户那里接收来自 zmq 的数据,那么您的 python 代码将更有效率,因为它被编码为专门的 one-trick 小马。如果你想添加一些特性,比如监听其他不使用 zmq 的事件,那么你会发现重写 python 代码来做到这一点很复杂。使用节点,您只需要添加另一个事件处理程序。对于简单的示例,节点永远不会成为性能野兽。然而,随着您的项目变得越来越复杂,移动的部分越来越多,将功能正确添加到节点要比使用您编写的 vanilla python 更容易。我宁愿在硬件上多花点钱,增加可读性并减少我的开发时间/成本。

    【讨论】:

    • 是的,它是玩具 Python 代码,但您得出的结论是狭隘示例无法支持的。 Node 并不是让事物立即可读的魔法酱:使用 Node 可以编写不可维护的垃圾,就像使用 Python 可以编写出色的可维护(同步或异步)代码一样。我写了很多 大量 Javascript,但我发现 Python 通常是更易于维护的语言。 YMMV。
    【解决方案5】:

    这是 node 的 zeroMQ 绑定的问题。 我不知道从什么时候开始,但它是固定的,并且您会得到与其他语言相同的结果。

    【讨论】:

    • 很高兴知道这三个例子应该是相对等价的,因为大多数代码都在 C 绑定中运行。
    【解决方案6】:

    由于往返和线程延迟,使用 REQ/REP 套接字的任何性能测试都会出现偏差。对于每条消息,您基本上都在唤醒整个堆栈,一直向下和向上。它作为一个指标不是很有用,因为 REQ/REP 案例从来都不是高性能(它们不可能)。有两个更好的性能测试:

    • 发送许多不同大小的消息,从 1 字节到 1K,看看你可以发送多少,例如10 秒。这为您提供了基本的吞吐量。这告诉您堆栈的效率。
    • 测量端到端延迟,但测量消息流;即在每条消息中插入时间戳并查看接收器上的偏差。这会告诉您堆栈是否有抖动,例如由于垃圾回收。

    【讨论】:

    • 除了我的用例是这样的:发出请求,得到响应。我不确定测试流媒体性能将如何向我展示在这种情况下会发生什么。我并没有打算展示哪种解决方案可以最快地传输消息。
    • 阅读指南,它有很多高性能异步请求-回复的例子。
    • 我愿意接受教育,但如果我比较 Python 和 Java,在测试中使用整个堆栈可能是个好主意,不是吗?
    猜你喜欢
    • 2012-03-06
    • 2020-08-23
    相关资源
    最近更新 更多