Что такое выравнивание памяти (padding) в структурах?

Выравнивание памяти (structure padding) — это автоматическое добавление компилятором неиспользуемых байтов (padding) между полями структуры или класса для размещения каждого поля по адресу, кратному его требованию к выравниванию.

Зачем это нужно? Процессоры читают память не побайтово, а блоками (например, по 4 или 8 байт). Доступ к данным, адрес которых кратен их размеру (естественное выравнивание), выполняется за одну операцию. Невыровненный доступ может требовать нескольких операций чтения, что снижает производительность или даже вызывает краш на некоторых архитектурах (например, ARM).

Пример в Swift:

struct ExampleStruct {
    let flag: Bool    // 1 байт
    // Компилятор добавит 3 байта padding здесь
    let number: Int32 // 4 байта, требует выравнивания на 4
} // Общий размер: 1 + 3(padding) + 4 = 8 байт

print(MemoryLayout<ExampleStruct>.size) // 8
print(MemoryLayout<ExampleStruct>.stride) // 8 (размер + padding до следующей структуры в массиве)
print(MemoryLayout<ExampleStruct>.alignment) // 4 (максимальное требование выравнивания среди полей)

Практические следствия и управление:

1. Влияние на размер: Padding увеличивает потребление памяти, что критично для больших массивов структур.
2. Оптимизация: Перестановка полей в порядке убывания размера может уменьшить padding.

   struct Optimized { // Лучший порядок
       let a: Int64 // 8
       let b: Int32 // 4
       let c: Bool  // 1
       // Итог: 8 + 4 + 1 = 13, padding до 16 (кратно 8)
   }
   struct NonOptimized { // Худший порядок
       let c: Bool  // 1 + 7 padding
       let a: Int64 // 8
       let b: Int32 // 4
       // Итог: 1 + 7 + 8 + 4 = 20, padding до 24
   }

3. Сетевое взаимодействие: При отправке сырых байтов структуры по сети padding передается как мусор. Для точного контроля используют @frozen структуры или ручную сериализацию.
4. Низкоуровневый доступ: При работе с UnsafeRawPointer необходимо учитывать выравнивание для корректного чтения данных.

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