Go和C ++之间的地图性能比较

时间:2019-02-12 19:05:29

标签: c++ go

我不知道golang在此操作中的表现如何比c ++高出10倍,即使在go中查找地图也比c ++快3倍。

这是c ++代码段

#include <iostream>
#include <unordered_map>
#include <chrono>

std::chrono::nanoseconds elapsed(std::chrono::steady_clock::time_point start) {
    std::chrono::steady_clock::time_point now = std::chrono::high_resolution_clock::now();
    return std::chrono::duration_cast<std::chrono::nanoseconds>(now - start);
}
void make_map(int times) {
    std::unordered_map<double, double> hm;
    double c = 0.0;
    for (int i = 0; i < times; i++) {
        hm[c] = c + 10.0;
        c += 1.0;
    }
}

int main() {
    std::chrono::steady_clock::time_point start_time = std::chrono::high_resolution_clock::now();
    make_map(10000000);
    printf("elapsed %lld", elapsed(start_time).count());
}

这是golang片段:

func makeMap() {
    o := make(map[float64]float64)
    var i float64 = 0
    x := time.Now()
    for ; i <= 10000000; i++ {
        o[i] = i+ 10
    }
    TimeTrack(x)
}
func TimeTrack(start time.Time) {
    elapsed := time.Since(start)

    // Skip this function, and fetch the PC and file for its parent.
    pc, _, _, _ := runtime.Caller(1)

    // Retrieve a function object this functions parent.
    funcObj := runtime.FuncForPC(pc)

    // Regex to extract just the function name (and not the module path).
    runtimeFunc := regexp.MustCompile(`^.*\.(.*)$`)
    name := runtimeFunc.ReplaceAllString(funcObj.Name(), "$1")

    log.Println(fmt.Sprintf("%s took %s", name, elapsed))
}

我想知道的是如何优化c ++以获得更好的性能。

3 个答案:

答案 0 :(得分:3)

要确定“ C ++的速度”(几乎适用于任何特定事物)有点困难,因为它可能取决于相当多的变量,例如您使用的编译器。例如,对于此代码的C ++版本,我通常看到gcc和msvc之间的差异为2:1左右。

就C ++和Go之间的差异而言,我认为这主要归因于哈希表实现方式的差异。显而易见的一点是,Go的map实现一次将数据空间分配为8个元素的块。至少我见过的标准库实现std::unordered_map每块仅放置一项。

我们希望这意味着在典型情况下,C ++代码将从堆/空闲存储中进行大量的单独分配,因此其速度将在很大程度上取决于堆管理器的速度。 Go版本还应该具有更高的参考位置,以便更好地使用缓存。

鉴于这些差异,您仅看到10:1的差异令我有些惊讶。我立即的猜测会(比)要高一些-但众所周知,一项测量值得超过100个猜测。

参考

Go's Map Implementation

liststdc++ unordered_map

libc++ unordered_map

答案 1 :(得分:1)

已更新,以测量cppgo的类似操作。它在调用地图制作函数之前开始测量,并在该函数返回时结束测量。这两个版本都在地图中保留空间并返回创建的地图(从中打印出一些数字)。

稍作修改的cpp

#include <iostream>
#include <unordered_map>
#include <chrono>

std::unordered_map<double, double> make_map(double times) {
    std::unordered_map<double, double> m(times);

    for (double c = 0; c < times; ++c) {
        m[c] = c + 10.0;
    }
    return m;
}

int main() {
    std::chrono::high_resolution_clock::time_point start_time = std::chrono::high_resolution_clock::now();
    auto m = make_map(10000000);
    std::chrono::high_resolution_clock::time_point end_time = std::chrono::high_resolution_clock::now();
    auto elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(end_time-start_time);
    std::cout << elapsed.count()/1000000000. << "s\n";
    std::cout << m[10] << "\n"
              << m[9999999] << "\n";    
}

% g++ -DNDEBUG -std=c++17 -Ofast -o perf perf.cpp
% ./perf
2.81886s
20
1e+07

稍作修改的go版本:

package main

import (
    "fmt"
    "time"
)

func make_map(elem float64) map[float64]float64 {
    m := make(map[float64]float64, int(elem))
    var i float64 = 0
    for ; i < elem; i++ {
        m[i] = i + 10
    }
    return m
}

func main() {
    start_time := time.Now()
    r := make_map(10000000)
    end_time := time.Now()
    fmt.Println(end_time.Sub(start_time))
    fmt.Println(r[10])
    fmt.Println(r[9999999])
}

% go build -a perf.go
% ./perf
1.967707381s
20
1.0000009e+07

它看起来不像更新前那样平庸。降低cpp版本速度的一件事是double的默认哈希函数。当用一个非常糟糕(但很快)的哈希器替换它时,我的时间降到了1.89489s。

struct bad_hasher {
    size_t operator()(const double& d) const {
        static_assert(sizeof(double)==sizeof(size_t));

        return
            *reinterpret_cast<const size_t*>( reinterpret_cast<const std::byte*>(&d) );
    }
};

答案 2 :(得分:1)

无意义的微基准测试将产生毫无意义的结果。


继续@mrclx@TedLyngmo的微基准测试线程,修复@TedLyngmo的Go微基准测试中的错误:

perf.go

package main

import (
    "fmt"
    "time"
)

func makeMap(elem float64) time.Duration {
    x := time.Now()
    o := make(map[float64]float64, int(elem))
    var i float64 = 0
    for ; i < elem; i++ {
        o[i] = i + 10
    }
    t := time.Now()
    return t.Sub(x)
}

func main() {
    r := makeMap(10000000)
    fmt.Println(r)
}

输出:

$ go version
go version devel +11af353531 Tue Feb 12 14:48:26 2019 +0000 linux/amd64
$ go build -a perf.go
$ ./perf
1.649880112s
$ 

perf.cpp

#include <iostream>
#include <unordered_map>
#include <chrono>

void make_map(double times) {
    std::unordered_map<double, double> hm;
    hm.reserve(static_cast<size_t>(times)); // <- good stuff

    for (double c = 0; c < times; ++c) {
        hm[c] = c + 10.0;
    }
}

int main() {
    std::chrono::high_resolution_clock::time_point start_time = std::chrono::high_resolution_clock::now();
    make_map(10000000);
    std::chrono::high_resolution_clock::time_point end_time = std::chrono::high_resolution_clock::now();
    auto elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(end_time-start_time);
    std::cout << elapsed.count()/1000000000. << "s\n";
}

输出:

$ g++ --version
g++ (Ubuntu 8.2.0-7ubuntu1) 8.2.0
$ g++ -DNDEBUG -std=c++17 -Ofast -o perf perf.cpp
$ ./perf
3.09203s
$ 

成为潜在客户!