代码和性能的秩序代码和性能的秩序(Order of the code and performance

我想找到这是更快：结构VS阵列。 所以我写在我写4倍INT的值（1,2,3和4），以一个结构的成员，然后到长度为4的阵列我试图找到它需要时间来写一个GO代码。

情况1：首先，我值写入的结构，然后到一个数组。 在这里，我发现阵列比结构更快。

package main

import (
    "fmt"
    "time"
)

type abc struct {
    a, b, c, d int
}

func main() {

    var obj abc

    t1 := time.Now()
    obj.a = 1
    obj.b = 2
    obj.c = 3
    obj.d = 4
    t2 := time.Since(t1)

    fmt.Println("Struct access time: : ", t2)

    a := make([]int, 4)
    t3 := time.Now()
    a[0] = 1
    a[1] = 2
    a[2] = 3
    a[3] = 4
    t4 := time.Since(t3)

    fmt.Println("Array access time: : ", t4)

}

情况2：其次，我将值写入数组，然后的结构。 在这里，我发现结构比数组更快。

package main

import (
    "fmt"
    "time"
)

type abc struct {
    a, b, c, d int
}

func main() {

    var obj abc

    a := make([]int, 4)
    t3 := time.Now()
    a[0] = 1
    a[1] = 2
    a[2] = 3
    a[3] = 4
    t4 := time.Since(t3)

    fmt.Println("Array access time: : ", t4)

    t1 := time.Now()
    obj.a = 1
    obj.b = 2
    obj.c = 3
    obj.d = 4
    t2 := time.Since(t1)

    fmt.Println("Struct access time: : ", t2)

}

为什么性能取决于什么，我写的第一？ 我写的第一个似乎要慢一些。 为什么会这样呢？

Answer 1:

对方的回答解释的时间差，让我们进入结构与切片。

如果编译器可以在编译时计算出切片是足够大的，访问所述切片和一个结构将产生相同代码的元素。 当然，在现实中，往往是编译器将不知道片有多大，完全不同的优化将被应用取决于如果你与一个结构或切片工作，所以衡量性能，你必须看整体程序和它的行为，而不是一个特定的操作。

Answer 2:

运行的第一次任意代码可能有一些（显著）开销，如相关的代码可以被加载，很多事情可能会被推迟，直到它们被需要（如内部缓冲器）。 再次运行同样的事情可能需要显著的时间更少，差异甚至可能是几个数量级 。

每当你想测量执行时间，你应该跑了很多次，测量多次运行的执行时间，并计算平均时间。 它也排除了第一个（一些）运行在计算上面提到的原因是一个好主意。

在围棋，最好和最简单的方法是使用测试文件和标杆作用。 阅读的包doc testing的更多细节和例子。

你的情况下，可以基准如下：

package main

import "testing"

type abc struct {
    a, b, c, d int
}

func BenchmarkSlice(b *testing.B) {
    a := make([]int, 4)
    for i := 0; i < b.N; i++ {
        a[0] = 1
        a[1] = 2
        a[2] = 3
        a[3] = 4
    }
}

func BenchmarkStruct(b *testing.B) {
    a := abc{}
    for i := 0; i < b.N; i++ {
        a.a = 1
        a.b = 2
        a.c = 3
        a.d = 4
    }
}

它保存到像一个文件something_test.go ，与运行它go test -bench . 。 输出：

BenchmarkSlice-4        2000000000           1.24 ns/op
BenchmarkStruct-4       2000000000           0.31 ns/op

你可以看到，使用结构是快约4倍 。 如果你重新排序基准功能，您将得到类似的（非常接近）的结果。

文章来源: Order of the code and performance