首页 > Golang > Go问答

如何最大程度地减少失败率

来源：stackoverflow

时间：2024-03-29 13:45:29 363浏览收藏

目前golang学习网上已经有很多关于Golang的文章了，自己在初次阅读这些文章中，也见识到了很多学习思路；那么本文《如何最大程度地减少失败率》，也希望能帮助到大家，如果阅读完后真的对你学习Golang有帮助，欢迎动动手指，评论留言并分享~

问题内容

我是一名经验丰富的 c++ 程序员，习惯于低级优化，我正在尝试提高 go 的性能。

到目前为止，我对 gflop/s 感兴趣。

我编写了以下 go 代码：

package main

import (
        "fmt"
        "time"
        "runtime"
        "sync"
)


func expm1(x float64) float64 {
        return ((((((((((((((15.0 + x) * x + 210.0) * x + 2730.0) * x + 32760.0) * x + 360360.0) * x + 3603600.0) * x + 32432400.0) * x + 259459200.0) * x + 1816214400.0) * x + 10897286400.0) * x + 54486432000.0) * x + 217945728000.0) *
x + 653837184000.0) * x + 1307674368000.0) * x * 7.6471637318198164759011319857881e-13;
}

func twelve(x float64) float64 {
        return expm1( expm1( expm1( expm1( expm1( expm1( expm1( expm1( expm1( expm1( expm1( expm1(x))))))))))));
}

func populate(data []float64, n int) {
        cpucount := runtime.numcpu();
        var wg sync.waitgroup
        var slice = n / cpucount;
        wg.add(cpucount)
        defer wg.wait()

        for i := 0; i < cpucount; i++ {
                go func(ii int) {
                        for j := ii * slice; j < ii * slice + slice; j += 1 {
                                data[j] = 0.1;
                        }
                        defer wg.done();
                }(i);
        }
}

func apply(data []float64, n int) {
        cpucount := runtime.numcpu();
        var wg sync.waitgroup
        var slice = n / cpucount;
        wg.add(cpucount)
        defer wg.wait()

        for i := 0; i < cpucount; i++ {
                go func(ii int) {
                        for j := ii * slice; j < ii * slice + slice; j += 8 {
                                data[j] = twelve(data[j]);
                                data[j+1] = twelve(data[j+1]);
                                data[j+2] = twelve(data[j+2]);
                                data[j+3] = twelve(data[j+3]);
                                data[j+4] = twelve(data[j+4]);
                                data[j+5] = twelve(data[j+5]);
                                data[j+6] = twelve(data[j+6]);
                                data[j+7] = twelve(data[j+7]);
                        }
                        defer wg.done();
                }(i);
        }
}

func run(data []float64, n int) {
        populate(data, n);
        start:= time.now();
        apply(data, n);
        stop:= time.now();
        elapsed:=stop.sub(start);
        seconds := float64(elapsed.milliseconds()) / 1000.0;
        gflop := float64(n) * 12.0 * 15.0e-9;
        fmt.printf("%f\n", gflop / seconds);
}

func main() {
        cpucount := runtime.numcpu();
        fmt.printf("num procs : %d\n", cpucount);
        n := 1024*1024*32 * cpucount;
        data:= make([]float64, n);
        for i := 0; i < 100; i++ {
                run(data, n);
        }
}

这是对我的 c++ 基准测试的翻译尝试，它产生了 80% 的峰值失败率。

c++ 版本产生 95 gflops/s，而 go 版本产生 6 gflops/s（fma 计数器为 1）。

这是 go 程序集的一部分（gccgo -o3 -mfma -mavx2）：

vfmadd132sd     %xmm1, %xmm15, %xmm0
        .loc 1 12 50
        vfmadd132sd     %xmm1, %xmm14, %xmm0
        .loc 1 12 64
        vfmadd132sd     %xmm1, %xmm13, %xmm0
        .loc 1 12 79
        vfmadd132sd     %xmm1, %xmm12, %xmm0
        .loc 1 12 95
        vfmadd132sd     %xmm1, %xmm11, %xmm0
        .loc 1 12 112
        vfmadd132sd     %xmm1, %xmm10, %xmm0

我从 c++ 代码 (g++ -fopenmp -mfma -mavx2 -o3) 中得到的结果：

vfmadd213pd     .LC3(%rip), %ymm12, %ymm5
        vfmadd213pd     .LC3(%rip), %ymm11, %ymm4
        vfmadd213pd     .LC3(%rip), %ymm10, %ymm3
        vfmadd213pd     .LC3(%rip), %ymm9, %ymm2
        vfmadd213pd     .LC3(%rip), %ymm8, %ymm1
        vfmadd213pd     .LC3(%rip), %ymm15, %ymm0
        vfmadd213pd     .LC4(%rip), %ymm15, %ymm0
        vfmadd213pd     .LC4(%rip), %ymm14, %ymm7
        vfmadd213pd     .LC4(%rip), %ymm13, %ymm6
        vfmadd213pd     .LC4(%rip), %ymm12, %ymm5
        vfmadd213pd     .LC4(%rip), %ymm11, %ymm4

因此我有几个问题，其中最重要的是：