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

目前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

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

• 我是否以正确的方式表达并行性？

如果没有，我该怎么做？

为了进一步提高性能，我需要知道以下项目出了什么问题：

• 为什么我在程序集中只看到 vfmadd132sd 指令，而不是 vfmadd132pd？
• 如何正确调整内存分配？
• 如何从生成的可执行文件中删除调试信息？
• 我是否将正确的选项传递给 gccgo？
• 我使用的编译器正确吗？

解决方案

没有。您可能会破坏 CPU 缓存。 （但是，如果不了解系统的详细信息，就很难判断。猜猜这不是 NUMA？）。无论如何，从技术上讲，您的代码是并发的，而不是并行的。

因为编译器把它放在那里。这是编译器问题还是编程问题？

这取决于你对“适当”的定义。结构体字段和切片对齐不是临时可控的，但您可以重新排序结构体字段（您根本没有使用它，所以我不知道您在这里问什么）。

查阅gcc的文档。

我不知道。

是什么让编译器“正确”？

终于介绍完啦！小伙伴们，这篇关于《如何最大程度地减少失败率》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布Golang相关知识，快来关注吧！