In this test program, I have 2 functions that manipulate elements of a slice. One function just gets passed the slice, the other gets passed the address of the slice. On my machine (x86-64 intel i7 6700k) it is consistently faster to manipulate elements of a pointer to a slice (you can switch up the order of chg() and chgPtr() to see that the relationship still holds). This is the opposite of what I expected. Why is this so?

Edit: On my machine it is anywhere from 5% to 7% faster to manipulate elements of a pointer to a slice

package main

import (
    "fmt"
    "math/rand"
    "time"
)

type Stuff struct {
    A float64
    B float64
}

func main() {
    rand.Seed(time.Now().UnixNano())
    var lst []Stuff

    // init list
    for i := 0; i < 1000000; i++ {
        lst = append(lst, Stuff{float64(i), float64(i)})
    }

    // make sure first to be measured isn't at disadvantage
    chg(lst)

    avgTbMinusTa := int64(0)
    avgPercent := float64(0)
    iterations := 100

    for i := 0; i < iterations; i++ {
            taStart := time.Now().UnixNano()
            chg(lst)
            taStop := time.Now().UnixNano()

            tbStart := time.Now().UnixNano()
            chgPtr(&lst)
            tbStop := time.Now().UnixNano()

            ta := taStop - taStart
            tb := tbStop - tbStart

            avgTbMinusTa += (tb - ta)
            avgPercent += ((float64(tb) / float64(ta)) * 100)
    }

    fmt.Println("avg Tb - Ta =", float64(avgTbMinusTa)/(float64(iterations)*1000000), "ms")
    fmt.Println("Tb % of Ta =", avgPercent/float64(iterations))
}

func chg(s []Stuff) {
    for i := 0; i < len(s); i++ {
        s[i].A = rand.Float64()
    }
}

func chgPtr(s *[]Stuff) {
    for i := 0; i < len(*s); i++ {
        (*s)[i].B = rand.Float64()
    }
}

---

**评论：**

anossov:

I don't know, however, I will show you the proper way of benchmarking go stuff:
File slice_test.go
package main                                                                                
import (                                                                                    
    "math/rand"                                                                             
    "testing"                                                                               
    "time"                                                                                  
)                                                                                           
type Stuff struct {                                                                         
    A float64                                                                               
    B float64                                                                               
}                                                                                           
func setup() (lst []Stuff) {                                                                
    rand.Seed(time.Now().UnixNano())                                                        
    for i := 0; i < 1000000; i++ {                                                          
        lst = append(lst, Stuff{float64(i), float64(i)})                                    
    }                                                                                       
    return lst                                                                              
}                                                                                           
func BenchmarkCopy(b *testing.B) {                                                          
    lst := setup()                                                                          
    b.ResetTimer()        
    for i := 0; i < b.N; i++ {                                                              
        chg(lst)                                                                            
    }                                                                                       
}                                                                                           
func BenchmarkPtr(b *testing.B) {                                                           
    lst := setup()                                                                          
    b.ResetTimer()                                                                          
    for i := 0; i < b.N; i++ {                                                              
        chgPtr(&lst)                                                                        
    }                                                                                       
}                                                                                           
func chg(s []Stuff) {                                                                       
    for i := 0; i < len(s); i++ {                                                           
        s[i].A = rand.Float64()                                                             
    }                                                                                       
}                                                                                           
func chgPtr(s *[]Stuff) {                                                                   
    for i := 0; i < len(*s); i++ {                                                          
        (*s)[i].B = rand.Float64()                                                          
    }                                                                                       
}                                                                                           

Benchmarking
$ go test -bench=. -benchtime=10s
testing: warning: no tests to run
PASS
BenchmarkCopy       1000          25255135 ns/op
BenchmarkPtr        1000          25572549 ns/op
ok      _/home/anossov/slice    56.059s

 
It's not faster for me ¯\_(ツ)_/¯  (i5 6600k @3.5GHz, Ubuntu subsystem on Windows 10)
https://golang.org/pkg/testing/#hdr-Benchmarks

epiphanius_zeno:

Thanks! I'm not familiar with the testing package.

Morgahl:

Using rand.Float64() in this case hides the actual array iteration costs in you are attempting to show in your benchmark. Simply changing this to a simple static value shows that passing just the slice header is indeed slightly faster (in my case only ~1.5%).

drunken_thor:

Why is that the opposite of what you expect? If you pass a pointer, all you are passing is an address. If you pass a slice you are passing the full value which actually means that the value is being copied into a new slice to assign to your parameter value. 

jmoiron:

Only the slice header is copied.

epiphanius_zeno:

I expected passing a pointer to a slice to be the same speed or slower. In c/c++ if you pass in a vector it makes a full copy of the vector, but I don't think that's what happens with slices. You can manipulate elements of a slice and those changes will remain outside of the function. How could changes remain if it copied the slice?
My reasoning was that by passing a pointer to a slice you're actually passing a pointer to a pointer to a slice, and every time you update an element you'd have to de-reference twice. 

kaliku:

A slice contains 3 things:

* pointer to the underlying array

* len

* cap  
Go, always passing by value, will copy this data structure and allocate on the stack for all three items, which is a greater allocation than just allocating for the pointer. 
The changes remain because you are manipulating the underlying array.