在此阵列访问微基准测试（相对于 GCC）中，Go 的性能降低了 4 倍？

Question

我写这个微基准测试是为了更好地理解 Go 的性能特征，这样我就可以在何时使用它时做出明智的选择。

从性能开销的角度来看，我认为这将是 Go 的理想场景：

• 循环内没有分配/释放
• 清楚地在边界内访问数组（可以删除边界检查）

仍然，我看到相对于 AMD64 上的

gcc -O3

速度正好是 4 倍的差异。这是为什么？

（使用 shell 计时。每次都需要几秒钟，所以启动可以忽略不计）

package main

import "fmt"

func main() {
    fmt.Println("started");

    var n int32 = 1024 * 32

    a := make([]int32, n, n)
    b := make([]int32, n, n)

    var it, i, j int32

    for i = 0; i < n; i++ {
        a[i] =  i
        b[i] = -i
    }

    var r int32 = 10
    var sum int32 = 0

    for it = 0; it < r; it++ {
        for i = 0; i < n; i++ {
            for j = 0; j < n; j++ {
                sum += (a[i] + b[j]) * (it + 1)
            }
        }
    }
    fmt.Printf("n = %d, r = %d, sum = %d\n", n, r, sum)
}

C版：

#include <stdio.h>
#include <stdlib.h>


int main() {
    printf("started\n");

    int32_t n = 1024 * 32;

    int32_t* a = malloc(sizeof(int32_t) * n);
    int32_t* b = malloc(sizeof(int32_t) * n);

    for(int32_t i = 0; i < n; ++i) {
        a[i] =  i;
        b[i] = -i;
    }

    int32_t r = 10;
    int32_t sum = 0;

    for(int32_t it = 0; it < r; ++it) {
        for(int32_t i = 0; i < n; ++i) {
            for(int32_t j = 0; j < n; ++j) {
                sum += (a[i] + b[j]) * (it + 1);
            }
        }
    }
    printf("n = %d, r = %d, sum = %d\n", n, r, sum);

    free(a);
    free(b);
}

Answer 1

我运行了你的 Go 程序：

$ go build x.0.go && time ./x.0
started
n = 32768, r = 10, sum = 0
real    0m4.659s
user    0m4.666s
sys     0m0.004s

https://go.dev/play/p/cIUkQYlLBsc

---

我运行了一个更高效的 Go 程序版本：

$ go build x.go && time ./x
n = 32768, r = 10, sum = 0
real    0m0.248s
user    0m0.249s
sys     0m0.000s

x.go:

package main

import "fmt"

func main() {
    var n int32 = 1024 * 32

    a := make([]int32, n)
    b := make([]int32, n)

    for i := int32(0); i < n; i++ {
        a[i] = i
        b[i] = -i
    }

    var r int32 = 10
    var sum int32 = 0

    for _, ai := range a {
        sum += ai * int32(len(b))
        for _, bj := range b {
            sum += bj
        }
    }
    sum *= r * (r + 1) / 2
    fmt.Printf("n = %d, r = %d, sum = %d\n", n, r, sum)
}

https://go.dev/play/p/jSCG63i4KBD

n = 32768, r = 10, sum = 0

Answer 2

看看 C 程序与 Go 程序的汇编器输出，至少在我使用的 Go 和 GCC 版本（分别为 1.19.6 和 12.2.0）上，最直接和明显的区别是 GCC 具有自动 -向量化 C 程序，而 Go 编译器似乎无法做到这一点。

这也很好地解释了为什么您看到性能提高了四倍，因为 GCC 在不针对特定体系结构时使用 SSE 而不是 AVX，这意味着 32 位操作的标量指令宽度是其四倍。事实上，添加

-march=native

为我又增加了两倍的性能，因为这使得 GCC 在我的 CPU 上输出 AVX 代码。

我对 Go 不够熟悉，无法告诉您 Go 编译器是否本质上无法进行自动向量化，或者是否只是这个特定的程序由于某种原因使它出错，但这似乎是根本原因。