关于c++、go、nodejs、python的计算性能测试，结果令人惊讶

计算性能在计算密集型的服务上，是非常重要的，一直以为，在计算性能上，肯定是C++ > go > nodejs >= python

但测试结果却让人大跌眼镜！！！

实际的结果是：

go > nodejs > c++ > python

各语言同样逻辑下的运行结果，如下：

其中， ./t是go编译的程序， ./a.out是c++编译的程序， nodejs和python直接跑脚本

不用关注target size的内容，这个是验证结果一致的，保证算法是一致

主要看use time，单位是秒：

这个结果很奇妙，反映出在计算密集的场景下，C++并非想象中那么快，而nodejs表现却非常亮眼

难道是我的代码问题？各位看官看看有没办办法优化性能的？

相关的编译器、执行器版本如下：

go: 1.15.2

g++: 4.8.2

nodejs: 14.18.0

python:3.7.3

各语言的测试代码如下，计算逻辑是完全一致的：

Go：

package main;

import "fmt"

import "time"

type Data struct {

    x float64

    y float64

    a int

}

func MakeData(num int) []Data {

    var vec = make([]Data, 0, num)

    for i:=0; i< num; i++ {

        var data Data

        data.x = float64(i) + 0.5;

        data.y = float64(i) + 1.5;

        data.a = i;

        vec = append(vec, data)

    }

    return vec

}

func Cal(data []Data, idx int, num int) float64 {

    var sum1 float64 = 0.0;

    var sum2 float64 = 0.0;

    for i:= idx-num+1; i <= idx; i++ {

        if i <0 {

            continue;

        }

        var elem = data[i];

        sum1 += elem.x;

        sum2 += elem.y;

    }

    var avg1 = sum1/float64(num);

    var avg2 = sum2/float64(num);

    return (avg1 + avg2)/2;

}

func Make(data []Data) {

    var target = make([]float64, 0, len(data));

    for i := 0; i < len(data); i++ {

        var v = Cal(data, i, 1000);

        if v > 1000 {

            target = append(target, v)

        }

    }

    fmt.Println("target size:" , len(target))

}

func main() {

    var t1 = time.Now().UnixNano()

    var data = MakeData(300*365*5);

    Make(data);

    var t2 = time.Now().UnixNano()

    fmt.Println("use time:", float64(t2-t1)/1000000000)

}

C++:

#include <stdio.h>

#include <iostream>

#include <vector>

#include <utility>

#include <string>

#include <unistd.h>

#include <sys/time.h>

struct Data {

    double x;

    double y;

    int    a;

};

std::vector<Data> MakeData(int num) {

    std::vector<Data> vec;

    vec.reserve(num);

    for (int i=0; i< num; i++) {

        Data data;

        data.x = static_cast<double>(i) + 0.5;

        data.y = static_cast<double>(i) + 1.5;

        data.a = i;

        vec.push_back(std::move(data));

    }

    return std::move(vec);

}

double Cal(std::vector<Data> & data, int idx, int num) {

    double sum1 = 0.0;

    double sum2 = 0.0;

    for (int i = idx-num+1; i <= idx; i++) {

        if (i <0) {

            continue;

        }

        auto & elem = data[i];

        sum1 += elem.x;

        sum2 += elem.y;

    }

    auto avg1 =sum1/num;

    auto avg2 =sum2/num;

    return (avg1 + avg2)/2;

}

void Make(std::vector<Data> & data) {

    std::vector<double> target;

    target.reserve(data.size());

    for (int i = 0; i < data.size(); i++) {

        auto v = Cal(data, i, 1000);

        if (v > 1000) {

            target.push_back(v);

        }

    }

    std::cout << "target size:" << target.size() << std::endl;

}

int main(int argc,char** argv)

{

    struct timeval t1;

    struct timeval t2;

    gettimeofday(&t1, NULL);

    auto data = MakeData(300*365*5);

    Make(data);

    gettimeofday(&t2, NULL);

    auto usetime = double((t2.tv_sec*1000000 + t2.tv_usec) - (t1.tv_sec*1000000 + t1.tv_usec))/1000000;

    std::cout <<"use time: " << usetime << std::endl;

}

NodeJs:

class Data {

    constructor() {

        this.x = 0.0;

        this.y = 0.0;

        this.a = 0;

    }

};

function MakeData(num) {

    let vec = [];

    for (let i=0; i< num; i++) {

        let data = new Data();

        data.x = i + 0.5;

        data.y = i + 1.5;

        data.a = i;

        vec.push(data);

    }

    return vec;

}

function Cal(data, idx, num) {

    let sum1 = 0.0;

    let sum2 = 0.0;

    for (let i = idx-num+1; i <= idx; i++) {

        if (i <0) {

            continue;

        }

        let elem = data[i];

        sum1 += elem.x;

        sum2 += elem.y;

    }

    let avg1 =sum1/num;

    let avg2 =sum2/num;

    return (avg1 + avg2)/2;

}

function Make(data) {

    let target = [];

    for (let i = 0; i < data.length; i++) {

        let v = Cal(data, i, 1000);

        if (v > 1000) {

            target.push(v);

        }

    }

    console.log("target size:", target.length);

}

t1 = new Date().getTime();

let data = MakeData(300*365*5);

Make(data);

t2= new Date().getTime();

console.log("use time:", (t2-t1)/1000)

Python:

import time

class Data:

    def __init__(self):

        self.x = 0.0

        self.y = 0.0

        self.a = 0

def MakeData(num):

    vec = []

    for i in range(0, num):

        data = Data()

        data.x = i + 0.5

        data.y = i + 1.5

        data.a = i

        vec.append(data)

    return vec

def  Cal(data, idx, num):

    sum1 = 0.0

    sum2 = 0.0

    i = idx-num+1

    while i<=idx:

        if i <0:

            i+=1

            continue

        elem = data[i]

        sum1 += elem.x

        sum2 += elem.y

        i+=1

    avg1 =sum1/num

    avg2 =sum2/num

    return (avg1 + avg2)/2

def Make(data):

    target = []

    data_len = len(data)

    for i in range(0, data_len):

        v = Cal(data, i, 1000)

        if v > 1000:

            target.append(v)

    print("target size:" , len(target))

t1=time.time()

data = MakeData(300*365*5)

Make(data)

print("use time:", time.time() -  t1)

巴特西

关于c++、go、nodejs、python的计算性能测试，结果令人惊讶

最新文章

热门文章