登录
当前位置： 首页 > 面试题库 >

node.js如何比C和Java更快？比较node.js，c，java和python的基准

子车俊哲
2023-03-14
问题内容：

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

  • （2.97秒）-node.js（javascript）（4.4.5）
  • （6.96秒）-c（c99）
  • （6.91秒）-Java（1.7）
  • （45.5秒）-python（2.7）

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

Node.js到目前为止运行最快。这使我感到困惑，原因有两个：

  1. 在这种情况下，c和java使用（长）整数时，javascript始终对变量使用双精度浮点数。整数数学应该更快。
  2. 实际上，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 s）没有优化，gcc primeCalc.c -lm -std = c99 -Wall
  • （8.13 s）优化0，gcc primeCalc.c -lm -O0 -std = c99 -Wall
  • （7.30 s）优化1，gcc primeCalc.c -lm -O1 -std = c99 -Wall

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

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

这段代码使用的示例实际上并没有做任何重要的事情。好像编译器可以在编译时算出结果，甚至不需要执行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黑色上运行。

  • 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秒（c，长数据类型）
  • 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，长数据类型）-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秒（c，长数据类型）-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兼容的事实令我惊讶。


问题答案：

我花了几天的时间研究JS / V8和C之间的性能差异，首先关注V8引擎生成的Hydrogen
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);
}


 类似资料：
  • 比C更快的Java[副本]

    今天我做了一个简单的测试来比较Java和c之间的速度--一个简单的循环，让一个整数“I”从0增加到20亿。 我真的期望C语言比Java更快。我对结果感到惊讶： Java所用的时间（秒）：大约。1.8秒 C：大约用秒表示的时间。3.6秒。 我不认为Java是一种更快的语言，但我也不明白为什么在我的简单程序中循环的速度是c的两倍？ 我是不是在计划中犯了重大错误？还是MinGW的编译器配置不好还是怎么的

  • Python比C ++更快更轻吗？

    问题内容： 我一直认为Python的优势在于代码的可读性和开发速度，但是时间和内存的使用却不如C ++。 这些统计数据让我非常震惊。 您的经验告诉您关于Python与C ++的时间和内存使用情况？ 问题答案： 我认为您错误地读取了这些统计信息。他们表明，Python比C ++ 慢 大约400倍，除了一个案例，Python更像是一种内存消耗。不过，就源代码大小而言，Python胜出。 我的Pytho

  • Python比Java / C＃慢吗？

    问题内容： Python比Java / C＃慢吗？ 性能比较c-java-python-ruby-jython-jruby- groovy 这是一个优化CPython的项目：空载吞咽 问题答案： 不要混淆语言和运行时。 Python（该语言）具有许多运行时实现。 CPython通常是解释型的，并且会比本机代码C＃慢。取决于Java JIT编译器，它可能比Java慢。 JYthon在JVM中进行解释

  • 基于java中cookie和session的比较

    本文向大家介绍基于java中cookie和session的比较，包括了基于java中cookie和session的比较的使用技巧和注意事项，需要的朋友参考一下 cookie和session的比较 一、对于cookie： ①cookie是创建于服务器端 ②cookie保存在浏览器端 ③cookie的生命周期可以通过cookie.setMaxAge(2000);来设置，如果没有设置setMaxAge,

  • 为什么这段代码在java中比在C++和C#中更快

    Java： 如果java以微弱优势击败了C和C#我不会感到惊讶，但速度快了20倍？！ 文件的格式如下： 另外，我认为值得注意的是，java在NetBeans中运行时大约需要11秒（即使是在“运行”模式下，而不是在“调试”模式下）。 我也尝试编译为C++而不是C，但没有什么不同。 我对C和C#都使用VS2015。 Java： 好吧，我按照建议重新做了测试： 首先，我在C和C#中都使用了类/struc

  • 附录B 对比C++和Java

    “作为一名C++程序员，我们早已掌握了面向对象程序设计的基本概念，而且Java的语法无疑是非常熟悉的。事实上，Java本来就是从C++衍生出来的。” 然而，C++和Java之间仍存在一些显著的差异。可以这样说，这些差异代表着技术的极大进步。一旦我们弄清楚了这些差异，就会理解为什么说Java是一种优秀的程序设计语言。本附录将引导大家认识用于区分Java和C++的一些重要特征。 (1) 最大的障碍在于

相关阅读

Java何时使用可比和比较器为什么Node.JS中的V8比我的本机C ++插件更快？不同语言（例如Java和C ++）的“随机”生成器如何比较？C#中Dynamic和Dictionary性能比较我们如何比较Java中的StringBuilder和StringBuffer？

相关文章

Python比较运算符Kafka 和 RocketMq 的对比MVC和DDD的对比吉比特 C++ 二面面经Selenium与QTP比较

相关问答

Java流创建对象和比较比较和比较的负和正返回值To你知道如何比较Sql中的Datetime和C#中的datetimepicker吗？可比数组比较java比较器java 8中的比较出错

相关工具

Node.jsNode.js FastSkywalking Node.jsNode.js PackerNode.js Foundation

相关文档

Node.js 基础教程Node.js 基础教程如何正确的学习 Node.js基于 Node.js 的 HTTPS MITM 中间人代理的原理和实现C++ 基础教程
快捷导航： 新手教程 算法原理 架构设计 Java进阶 数据库进阶 大厂专栏 面试经验 编程笔记 编程问答 所有专题 文档资料 工具软件 电子书籍 小牛导航
在线工具： 房贷计算器 个税计算器 Linux命令查询 Json格式化 正则表达式 颜色转换 AES加解密 SHA1加密 MD5加密 毒鸡汤 字数统计 随机密码生成 进制转换 Base64编解码 励志句子
Copyright © 2019-2024 小牛知识库@xnip.cn. All Rights Reserved.