结构切片与结构指针的切片

Question

I often work with slices of structs. Here's an example for such a struct:

type MyStruct struct {
    val1, val2, val3    int
    text1, text2, text3 string
    list                []SomeType
}

So I define my slices as follows:

[]MyStruct

Let's say I have about a million elements in there and I'm working heavily with the slice:

• I append new elements often. (The total number of elements is unknown.)
• I sort it every now and then.
• I also delete elements (although not as much as adding new elements).
• I read elements often and pass them around (as function arguments).
• The content of the elements themselves doesn't get changed.

My understanding is that this leads to a lot of shuffling around of the actual struct. The alternative is to create a slice of pointers to the struct:

[]*MyStruct

Now the structs remain where they are and we only deal with pointers which I assume have a smaller footprint and will therefore make my operations faster. But now I'm giving the garbage collector a lot more work.

• Can you provide general guidelines of when to work with structs directly vs. when to work with pointers to structs?
• Should I worry about how much work I leave to the GC?
• Is the performance overhead of copying a struct vs. copying a pointer negligible?
• Maybe a million elements is not much. How does all of this change when the slice gets much bigger (but still fits in RAM, of course)?

Answer 1

Can you provide general guidelines of when to work with structs directly vs. when to work with pointers to structs?

No, it depends too much on all the other factors you've already mentioned.

The only real answer is: benchmark and see. Every case is different and all the theory in the world doesn't make a difference when you've got actual timings to work with.

(That said, my intuition would be to use pointers, and possibly a sync.Pool to aid the garbage collector: http://golang.org/pkg/sync/#Pool)