-2

我是一位经验丰富的 C++ 程序员，习惯于低级优化，我正试图从 Go 中获得性能。

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

我写了以下代码：

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 GFlop/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？
  • 我是否使用了正确的编译器？
4

1 回答 1

0

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

不，您可能正在破坏 CPU 缓存。（但如果不了解您的系统的详细信息，这很难说清楚。猜猜它不是 NUMA？）。无论如何，从技术上讲，您的代码是并发的而不是并行的。

为什么我在程序集中只看到 vfmadd132sd 指令，而不是 vfmadd132pd ？

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

如何正确对齐内存分配？

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

如何从生成的可执行文件中删除调试信息？

查阅 gcc 的文档。

我是否将正确的选项传递给 gccgo ？

我不知道。

我使用正确的编译器吗？

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

于 2020-12-29T15:34:43.480 回答