Why does my benchmark show same fast performance for ranging over a slice by value vs. index?

type Item struct {
    A int
    B [1024]byte
}
 
func BenchmarkRange1(b *testing.B) {
    s := make([]Item, 1024)
    for i := 0; i < b.N; i++ {
        for _, v := range s {
            _ = v.A
        }
    }
}
 
func BenchmarkRange2(b *testing.B) {
    s := make([]Item, 1024)
    for i := 0; i < b.N; i++ {
        for i := range s {
            _ = s[i].A
        }
    }
}

Now, take a look at the result of the benchmark.

go test -bench=BenchmarkRange -benchmem main/copy
goos: darwin
goarch: amd64
pkg: main/copy
cpu: Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz
BenchmarkRange1-12       4577601               260.9 ns/op             0 B/op          0 allocs/op
BenchmarkRange2-12       4697178               254.9 ns/op             0 B/op          0 allocs/op
PASS
ok      main/copy       3.391s

Isn't it to copy elements when range slice by value? Why the performance is same? What optimization does the compiler do when we range the slice by value？

When I fobidden the optimization of compiler by compiling option "-gcflags=-N", I will get the expected result:

go test -bench=BenchmarkRange -benchmem -gcflags=-N main/copy
goos: darwin
goarch: amd64
pkg: main/copy
cpu: Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz
BenchmarkRange1-12         39004             29481 ns/op              27 B/op          0 allocs/op
BenchmarkRange2-12        777356              1572 ns/op               1 B/op          0 allocs/op
PASS
ok      main/copy       3.169s

Who can explain how the compiler to optimize.

With the default optimizations, your inner loop in both both BenchmarkRange1 and BenchmarkRange2 is being compiled down to an empty loop with 1024 iterations, as if you had written your inner loop like:

	for i := 0; i < 1024; i++ {

	}

In both of your examples, the compiler is smart enough to recognize that you aren't doing anything inside the inner loop (that is, not making use of v, v.A, s[i], or s[i].A).

go.godbolt.org is a great resource for looking at the assembly the Go compiler produces. For example, the inner loop in BenchmarkRange1 gets compiled down to the following (which zeros out AX, then loops 1024 times):

        XORL    AX, AX
Range1_pc39:
        INCQ    AX
        CMPQ    AX, $1024
        JLT     Range1_pc39

You can look at the complete output here, along with handy tooltips that (usually) explain the different assembly instructions:
https://go.godbolt.org/z/raTPjTrYG

(To make your example shorter, I dropped the testing package; the //go:nosplit comments aren't really needed, but slightly simplify the resulting assembly).