问题 node.js如何比c和java更快？基准比较node.js，c，java和python


我做了一个非常简单的基准测试程序，用4种不同语言计算高达10,000,000的所有素数。

  • （2.97秒） - node.js（javascript）（4.4.5）
  • （6.96秒） - c（c99）
  • （6.91秒） - java（1.7）
  • （45.5秒） - 蟒蛇（2.7）

以上是每次平均3次运行，用户时间

Node.js运行速度最快。这让我很困惑，原因有两个：

  1. javascript总是对变量使用双精度浮点数，而c和java在这种情况下使用（长）整数。带整数的数学应该更快。
  2. 当javascript实际上是一种及时编译的语言时，javascript通常被称为解释。但即便如此，JIT编译器如何比完全编译的语言更快？ python代码运行速度最慢，这并不奇怪，但为什么node.js代码的运行速度与python类似？

我使用-O2优化编译了c代码，但我尝试了所有级别的优化，并没有产生显着的差异。

countPrime.js

"use strict";

var isPrime = function(n){
    //if (n !== parseInt(n,10)) {return false};
    if (n < 2) {return false};
    if (n === 2) {return true};
    if (n === 3) {return true};
    if (n % 2 === 0) {return false};
    if (n % 3 === 0) {return false};
    if (n % 1) {return false};
    var sqrtOfN = Math.sqrt(n);
    for (var i = 5; i <= sqrtOfN; i += 6){
        if (n % i === 0) {return false}
        if (n % (i + 2) === 0) {return false}
    }
    return true;
};

var countPrime = function(){
    var count = 0;
    for (let i = 1; i < 10000000;i++){
        if (isPrime(i)){
            count++;
        }
    }
    console.log('total',count);
};

countPrime();

node.js结果

$ time node primeCalc.js
total 664579

real    0m2.965s
user    0m2.928s
sys     0m0.016s

$ node --version
v4.4.5

primeCalc.c

#include <stdio.h>
#include <math.h>

#define true 1
#define false 0

int isPrime (register long n){
    if (n < 2)      return false;
    if (n == 2)     return true;
    if (n == 3)     return true;
    if (n % 2 == 0) return false;
    if (n % 3 == 0) return false;
    if (n % 1)      return false;
    double sqrtOfN = sqrt(n);
    for (long i = 5; i <= sqrtOfN; i += 6){
        if (n % i == 0) return false;
        if (n % (i + 2) == 0) return false;
    }
    return true;
};

int main(int argc, const char * argv[]) {
    register long count = 0;
    for (register long i = 0; i < 10000000; i++){
        if (isPrime(i)){
            count++;
        }
    }

    printf("total %li\n",count);
    return 0;
}

c结果

$ gcc primeCalc.c -lm -g -O2 -std=c99 -Wall
$ time ./a.out
total 664579
real    0m6.718s
user    0m6.668s
sys     0m0.008s

PrimeCalc.java

公共类PrimeCalc {

  public static void main(String[] args) {
     long count = 0;
     for (long i = 0; i < 10000000; i++){
        if (isPrime(i)){
           count++;
        }
     }
     System.out.println("total "+count);
  }


  public static boolean isPrime(long n) {
     if (n < 2)      return false;
     if (n == 2)     return true;
     if (n == 3)     return true;
     if (n % 2 == 0) return false;
     if (n % 3 == 0) return false;
     if (n % 1 > 0)  return false;
     double sqrtOfN = Math.sqrt(n);
     for (long i = 5; i <= sqrtOfN; i += 6){
        if (n % i == 0) return false;
        if (n % (i + 2) == 0) return false;
     }
     return true;
  };

}

java结果

 $ javac PrimeCalc.java 
 $ time java PrimeCalc
 total 664579
 real    0m7.197s
 user    0m7.036s
 sys     0m0.040s
 $ java -version
 java version "1.7.0_111"
 OpenJDK Runtime Environment (IcedTea 2.6.7) (7u111-2.6.7-0ubuntu0.14.04.3)
 OpenJDK 64-Bit Server VM (build 24.111-b01, mixed mode)

primeCalc.py

import math

def isPrime (n):
    if n < 2       : return False
    if n == 2      : return True
    if n == 3      : return True
    if n % 2 == 0  : return False
    if n % 3 == 0  : return False
    if n % 1 >0    : return False
    sqrtOfN = int(math.sqrt(n)) + 1
    for i in xrange (5, sqrtOfN, 6):
        if n % i == 0       : return False;
        if n % (i + 2) == 0 : return False;
    return True

count = 0;
for i in xrange(10000000) :
    if isPrime(i) :
        count+=1

print "total ",count

python结果

time python primeCalc.py
total  664579
real    0m46.588s
user    0m45.732s
sys     0m0.156s 
$ python --version
Python 2.7.6

Linux的

$ uname -a
Linux hoarfrost-node_6-3667558 4.2.0-c9 #1 SMP Wed Sep 30 16:14:37 UTC 2015 x86_64 x86_64 x86_64 GNU/Linux

额外的c运行时间（附录）

  • （7.81秒）没有优化，gcc primeCalc.c -lm -std = c99 -Wall
  • （8.13 s）优化0，gcc primeCalc.c -lm -O0 -std = c99 -Wall
  • （7.30秒）优化1，gcc primeCalc.c -lm -O1 -std = c99 -Wall

  • （6.66 s）优化2，gcc primeCalc.c -lm -O2 -std = c99-Wall

    • 每个优化级别用户时间平均3次新运行*

我在这里阅读帖子： 为什么这个NodeJS比本机C快2倍？ 此代码使用的实例实际上并没有做任何重要的事情。就好像编译器可以在编译时找出结果，甚至不需要执行循环100000000次来得出答案。 如果在计算中添加另一个除法步骤，则优化不太重要。

for (long i = 0; i < 100000000; i++) {
  d += i >> 1;    
  d = d / (i +1); // <-- New Term 
}
  • （1.88秒）没有优化
  • （1.53秒）优化（-O2）

更新03/15/2017 在阅读了@leon的答案后，我进行了一些验证测试。

测试1 - 32位Beaglebone Black，664,579素数高达10,000,000

未编辑的calcPrime.js和calcPrime.c在具有32位处理器的Beaglebone black上运行。

  • C代码= 62秒（gcc，长数据类型）
  • JS代码= 102秒（节点v4）

测试2 - 64位Macbook Pro，664,579素数高达10,000,000

使用uint32_t替换calcPrime.c代码中的长数据类型，并在具有64位处理器的MacBook pro上运行。

  • C代码= 5.73秒（clang，长数据类型）
  • C代码= 2.43秒（clang，uint_32_t数据类型）
  • JS代码= 2.12秒（节点v4）

测试3 - 64位Macbook Pro，91,836个素数（i = 1; i <8,000,000,000; i + = 10000）

在C代码中使用无符号长数据类型，强制javascript使用64位。   - C代码= 20.4秒（clang，long数据类型）   - JS代码= 17.8秒（节点v4）

测试4 - 64位Macbook Pro，86,277个素数（i = 8,000,00,001; i <16,000,000,000; i + = 10000）

在C代码中使用无符号长数据类型，强制javascript使用全部64位。   - C代码= 35.8秒（clang，long数据类型）   - JS代码= 34.1秒（节点v4）

测试5 - Cloud9 64位Linux，（i = 0; i <10000000; i ++）

language    datatype    time    % to C
javascript  auto        3.22      31%
C           long        7.95     224%
C           int         2.46       0%
Java        long        8.08     229%
Java        int         2.15     -12%
Python      auto       48.43    1872%
Pypy        auto        9.51     287%

测试6 - Cloud9 64位Linux，（i = 8000000001; i <16000000000; i + = 10000）

javascript  auto       52.38      12%
C           long       46.80       0%
Java        long       49.70       6%
Python      auto      268.47     474%
Pypy        auto       56.55      21%

（所有结果均为三次运行的用户秒数的平均值，运行之间的时间差异<10％）

混合结果

在整数范围内将C和Java数据类型更改为整数会显着加快执行速度。在BBB和Cloud9计算机上切换到int使得C比node.js更快。但是在我的Mac上，node.js程序仍然运行得更快。也许是因为Mac正在使用clang而BBB和Cloud 9计算机正在使用gcc。有谁知道gcc是否编译比gcc更快的程序？

当使用所有64位整数时，C比BBB和Cloud9 PC上的node.js快一点但在我的MAC上稍微慢一些。

您还可以看到，在这些测试中，pypy比标准python快四倍。

node.js甚至与C兼容的事实令我惊讶。


6645
2017-09-07 02:31


起源
V8 是 优化。事实上， V8 是 非常  优化。然而， 谨防 微基准测试。 - Elliott Frisch
也许你正在把手指放在一些东西上 long 至 double 转换，从长远来看，这些可能代价高昂 - dvhh
可能重复 为什么这个NodeJS比本机C快2倍？ - enRaiser
@enRaiser在这里， gcc 正在通过 -O2 已经。 - Elliott Frisch
-O2 -m64在三次运行中的平均值从6.66秒降至6.41秒，但结果每次变化几十分之一秒，所以我不能说它实际上有任何显着的结果。 - Timothy Vann

答案:

我花了几天时间研究JS / V8和C之间的性能差异，首先关注V8发动机产生的氢气IR。然而，在确定那里没有非常优化之后，我回到了对装配输出的分析，并且让我觉得答案是一个非常简单的答案，可以归结为几句话。 Jay Conrod的博客文章 在V8的内部：

根据规范，JavaScript中的所有数字都是64位浮点双精度数。我们经常使用整数，所以 V8尽可能表示具有31位有符号整数的数字。

手边的示例允许以32位和node.js拟合所有计算，充分利用它！ C代码利用了 long 类型，在OP（以及我的）平台上恰好是64位类型。因此，它是32位算术与64位算术问题，主要是由于昂贵的除法/余数运算。

如果 long 在C代码中替换为 int，然后由gcc生成的二进制文件节点node.js.

此外，如果循环用于在32位数字范围之外的范围内查找质数，则node.js版本的性能会显着下降。

证明

在结果下面的答案中进一步找到使用的源代码。

使用C和node.js计算小于1000万的素数

$ gcc count_primes.c -std=c99 -O3 -lm -o count_primes_long
$ sed 's/long/int/g; s/%li/%i/g' count_primes.c > count_primes_int.c
$ gcc count_primes_int.c -std=c99 -O3 -lm -o count_primes_int

# Count primes <10M using C code with (64-bit) long type
$ time ./count_primes_long 0 10000000
The range [0, 10000000) contains 664579 primes

real    0m4.394s
user    0m4.392s
sys 0m0.000s

# Count primes <10M using C code with (32-bit) int type
$ time ./count_primes_int 0 10000000
The range [0, 10000000) contains 664579 primes

real    0m1.386s
user    0m1.384s
sys 0m0.000s

# Count primes <10M using node.js/V8 which transparently does the
# job utilizing 32-bit types
$ time nodejs ./count_primes.js 0 10000000
The range [ 0 , 10000000 ) contains 664579 primes

real    0m1.828s
user    0m1.820s
sys 0m0.004s

性能数字在有符号32位整数的限制附近

从第一列中包含的数字开始计算长度为100,000的素数：

              | node.js | C (long) 
-----------------------------------
2,000,000,000 | 0.293s  | 0.639s    # fully within the 32-bit range
-----------------------------------
2,147,383,647 | 0.296s  | 0.655s    # fully within the 32-bit range
-----------------------------------
2,147,453,647 | 2.498s  | 0.646s    # 50% within the 32-bit range
-----------------------------------
2,147,483,647 | 4.717s  | 0.652s    # fully outside the 32-bit range
-----------------------------------
3,000,000,000 | 5.449s  | 0.755s    # fully outside the 32-bit range
-----------------------------------

count_primes.js

"use strict";

var isPrime = function(n){
    if (n < 2) {return false};
    if (n === 2) {return true};
    if (n === 3) {return true};
    if (n % 2 === 0) {return false};
    if (n % 3 === 0) {return false};
    var sqrtOfN = Math.sqrt(n);
    for (var i = 5; i <= sqrtOfN; i += 6){
        if (n % i === 0) {return false}
        if (n % (i + 2) === 0) {return false}
    }
    return true;
};

var countPrime = function(S, E){
    var count = 0;
    for (let i = S; i < E;i++){
        if ( isPrime(i) ) { ++count; }
    }
    return count;
};

if( process.argv.length != 4) {
    console.log('Usage: nodejs count_prime.js <range_start> <range_length>');
    process.exit();
}

var S = parseInt(process.argv[2]);
var N = parseInt(process.argv[3]);
var E = S+N;
var P = countPrime(S, E);
console.log('The range [', S, ',', E, ') contains', P, 'primes');

count_primes.c

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define true 1
#define false 0

int isPrime (register long n){
    if (n < 2)      return false;
    if (n == 2)     return true;
    if (n == 3)     return true;
    if (n % 2 == 0) return false;
    if (n % 3 == 0) return false;
    double sqrtOfN = sqrt(n);
    for (long i = 5; i <= sqrtOfN; i += 6){
        if (n % i == 0) return false;
        if (n % (i + 2) == 0) return false;
    }
    return true;
};

int main(int argc, const char * argv[]) {
    if ( argc != 3 ) {
        fprintf(stderr, "Usage: count_primes <range_start> <range_length>\n");
        exit(1);
    }
    const long S = atol(argv[1]);
    const long N = atol(argv[2]);
    register long count = 0;
    for (register long i = S; i < S + N; i++){
        if ( isPrime(i) ) ++count;
    }
    printf("The range [%li, %li) contains %li primes\n", S, S+N, count);
}

15
2018-03-15 15:51



热门问题

不使用eval / new函数的JavaScript模板库 当涉及内部类时，Java继承如何工作 .NET Windows服务的奇怪问题 在.ipa或.app下查找App ID 快速入门XSLT参考[关闭] 如何找出Android应用程序中未使用的资源 Ruby中并发的同步方法[重复] 将std :: chrono :: system_clock :: time_point转换为struct timeval并返回 Google Drive API V3（javascript）更新文件内容 Bootstrap 3.0 - 将元素推到底部 受密码保护的.NET ClickOnce部署？ 如何用postgresql安装wordpress coq Set或Type如何成为命题 硒滚动元素进入（中心）视图 在Spring Transaction JUnit测试中自动装配Hibernate会话的正确方法 Git的Dockerfile策略 如何在FOS_PICKFOLDER中使用IFileDialog，同时仍在对话框中显示文件名 在Firefox扩展中复制Google Chrome浏览器操作弹出效果 CakePHP找到MAX 芹菜 - 完成任务的召唤功能 从使用fmemopen创建的流中读取宽字符 .NET是否为每个程序集创建一个字符串实习池？ DefaultModelBinder不绑定嵌套模型 Navigator.MediaDevices.getUserMedia（）使用了哪些相机通信标准？ 选择命名空间名称时应该知道什么？ cout Swagger Codegen CLI Java客户端 - 如何正确使用它 一个很好的哈希函数用于采访整数，字符串？ Maven 3 ciManagement配置的目的是什么？ 如何通过语言文化获取代码页？
licensed under cc by-sa 3.0 with attribution.
隐私政策 往来