我编写了一个非常简单的基准测试程序,用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运行速度最快。这让我感到困惑,有两个原因:
- Javascript在这种情况下始终使用双精度浮点变量,而c和java使用(长)整数。使用整数进行数学计算应该更快。
- 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秒) 优化0,gcc primeCalc.c -lm -O0 -std=c99 -Wall
- (7.30秒) 优化1,gcc primeCalc.c -lm -O1 -std=c99 -Wall
(6.66秒) 优化2,gcc primeCalc.c -lm -O2 -std=c99 -Wall
- 每个优化级别的用户时间的3次新运行平均值 *
我在这里阅读了这篇文章: 为什么这个NodeJS比本地C快两倍? 这段代码使用的例子实际上并没有做什么重要的事情。好像编译器可以在编译时就算出结果,甚至不需要执行100000000次循环来得出答案。 如果再添加另一个除法步骤,优化效果就会大大降低。
for (long i = 0; i < 100000000; i++) {
d += i >> 1;
d = d / (i +1); // <-- New Term
}
- (1.88秒) 未进行优化
- (1.53秒) 经过优化(-O2)
更新 2017年3月15日 阅读 @leon 的答案后我进行了一些验证测试。
测试1 - 32位 Beaglebone Black,计算10000000以内的664,579个质数
在具有32位处理器的Beaglebone black上运行未编辑的calcPrime.js和calcPrime.c代码。
- C代码 = 62秒(gcc,long datatype)
- JS代码 = 102秒(node v4)
测试2 - 64位 MacBook Pro,计算10000000以内的664,579个质数
将calcPrime.c代码中的长整型数据类型替换为uint32_t,并在我的MacBook pro(64位处理器)上运行。
- C代码 = 5.73秒 (clang,long datatype)
- C代码 = 2.43秒(clang,uint_32_t datatype)
- JS代码 = 2.12秒(node v4)
测试3 - 64位 MacBook Pro,计算( i=1; i < 8,000,000,000; i+=10000 ),共91,836个质数
在C代码中使用unsigned long数据类型,强制javascript使用一些64位。 - C代码=20.4秒(clang,long datatype) - JS代码=17.8秒(node v4)
测试4 - 64位 MacBook Pro,计算(i = 8,000,00,001; i < 16,000,000,000; i+=10000),共86,277个质数
在C代码中使用unsigned long数据类型,强制javascript全部使用64位。 - C代码=35.8秒(clang,long datatype) - JS代码=34.1秒(node 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计算机上,切换到ints使得C比node.js更快。 但是在我的Mac上,node.js程序仍然运行得更快。 可能是因为Mac使用clang,而BBB和Cloud 9计算机使用gcc。 有没有人知道gcc是否编译得比gcc更快?
在使用全部64位整数时,C比node.js在BBB和Cloud9 PC上稍微快一点,但在我的MAC上稍微慢一些。
从这些测试中可以看出,pypy比标准python快约四倍。
事实上,node.js甚至与C兼容,这让我感到惊奇。
long
到double
转换有所发现,这些转换可能会在长期运行中变得代价高昂。 - dvhh