Ломтики структур против ломтиков указателей на структуры

Я часто работаю с фрагментами структур. Вот пример такой структуры:

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

Итак, я определяю свои фрагменты следующим образом:

[]MyStruct

Скажем, у меня около миллиона элементов, и я сильно работаю с срезом:

• Я часто добавляю новые элементы. (Общее количество элементов неизвестно.)
• Я сортирую его время от времени.
• Я также удаляю элементы (хотя и не столько как добавление новых элементов).
• Я часто читаю элементы и передаю их (как аргументы функции).
• Содержимое самих элементов не изменяется.

Мое понимание заключается в том, что это приводит к большому перетасовке фактической структуры. Альтернативой является создание фрагмента указателей на структуру:

[]*MyStruct

Теперь структуры остаются там, где они есть, и мы имеем дело только с указателями, которые, как я предполагаю, имеют меньший размер и, следовательно, делают мои операции быстрее. Но теперь я даю сборщику мусора намного больше работы.

• Можете ли вы предоставить общие рекомендации по работе с структурами напрямую или при работе с указателями на структуры?
• Должен ли я беспокоиться о том, сколько работы я оставляю в GC?
• Является ли служебная нагрузка при копировании структуры или копировании указателя пренебрежимо малой?
• Возможно, миллион элементов не так много. Как все это изменяется, когда срез становится намного больше (но, конечно, все равно в ОЗУ)?

Ответы

type MyStruct struct {
    F1, F2, F3, F4, F5, F6, F7 string
    I1, I2, I3, I4, I5, I6, I7 int64
}

func BenchmarkAppendingStructs(b *testing.B) {
    var s []MyStruct

    for i := 0; i < b.N; i++ {
        s = append(s, MyStruct{})
    }
}

func BenchmarkAppendingPointers(b *testing.B) {
    var s []*MyStruct

    for i := 0; i < b.N; i++ {
        s = append(s, &MyStruct{})
    }
}

BenchmarkAppendingStructs  1000000        3528 ns/op
BenchmarkAppendingPointers 5000000         246 ns/op