Как работает выравнивание памяти в С в структурах?

Question

[AslanPAPA]

Есть структура:

struct  TEST {
     char s; //symbol
     int d; //digit
};

Размер этой структуры 8 байт.
ПАМЯТЬ:


Вот в памяти получается так будет хранится структура? Т.е., в 0 адресе переменная char s;, а потом вроде бы выравнивание, у int это 4 байт (хоть я в примере в ПАМЯТИ показал, что это самое выравнивание 3 байт). Как это работает, т.к. то что я описал, скорее всего неверно. Т.е., каждый тип должен быть не просто по какому-то адресу, а именно в кратном ему адресу? Если int = 4, то он не может располагаться в памяти НЕ кратном ему адресу?

На счёт того, что это нужно для процессора, для быстрой чего-то. Я также не понимаю, но это скорее всего уже дело глубже чем мой вопрос.

Comments

[Кот Абсолютный]

Во-первых, не спамим тегами - Теги Оперативная память и Железо к такому нубскому вопросу по С никакого отноешния не имеют.

Во-вторых, читаем про pragma.

#pragma pack(push, 1) // Сохранить текущее значение и установить выравнивание в 1 байт
struct MyStruct {
    char a; // 1 байт
    int b;  // 4 байта, теперь начинается сразу после 'a', без отступов
};
#pragma pack(pop)     // Восстановить предыдущее выравнивание

Плотно упакованые структуры обычно нужны для адресации полей в памяти каких-то устройств, управляющих слов, в общем при низкоуровневой работе

[AslanPAPA]

Кот Абсолютный, Хорошо не буду спамить тегами, я же тоже нуб, вот и не знал, что нельзя спамить тегами.

А вот вы сейчас убрали выравнивание с помощью дерективы, чисто для примера ? Если в каких-то работах не нужно чтобы компилятор (или что-то) выполнило выравнивание ?

[Кот Абсолютный]

AslanPAPA, В том месте, где тебе нужно отключить выравнивание - втыкаешь прагму, там где нужно его включить снова - втыкаешь отключение. Если используется прагма, лучше оптимизацию компилятора не включать.

[Сергей Соловьев]

AslanPAPA, как пример - ItemPointer структура в PostgreSQL, которая хранится на диске. С паддингом она занимает 8 байт, без него 6 (за каждый байт приходится бороться иногда).

#define pg_attribute_aligned(a) __attribute__((aligned(a)))
#define pg_attribute_packed() __attribute__((packed))

typedef struct ItemPointerData
{
	BlockIdData ip_blkid;
	OffsetNumber ip_posid;
}
pg_attribute_packed()
pg_attribute_aligned(2)
ItemPointerData;

Используется __attribute__((packed)) вместо pragma, но результат тот же

Answer 1

[Пума Тайланд]

да, ты всё правильно понял, дело не в размере char/int, а в alignof — у int это обычно 4 байта. char ложится на 0, дальше 3 байта padding, и d стартует ровно с адреса кратного 4. Проверить руками просто: offsetof(struct TEST, d) из stddef.h выдаст 4. Ещё момент: размер всей структуры округляют под её же выравнивание, иначе в массиве таких структур второй элемент съедет и int снова окажется невыровненным.

Comments

[AslanPAPA]

Спасибо за ответ!

Про округление структуры вы имеете ввиду что, если я к примеру поменяю поля в структуре:

struct TEST {
    int d;
    char s;
};

То в памяти с 0 по 3 адресу будет int (т.к int 4 байт), и в 4 адрес будет char (т.к char 4 байт). итого будет 5 байт, но если бы был массив из этой структуры, то в этом случае чтобы следующий элемент, начинался не с 5-ого адреса, а с 8 адреса (т.к первый эл. int и он второй элемент должен начатся с кратного 4). И поэтому после 5 байта, будет как бы хвостовые байты, т.е как раз эти паддинги ?

[Пума Тайланд]

AslanPAPA, почти, только char тут 1 байт, а не 4: d займёт байты 0-3, s — байт 4, а 5-7 это и есть хвостовой padding, чтобы следующий элемент массива в памяти начинался с адреса кратного 4.

[AslanPAPA]

Пума Тайланд, Случайно написал, что char 4 байт, (char 1 байт).
Всё понял, спасибо большое!

Answer 2

[VoidVolker]

На счёт того что это нужно для процессора, для быстрой чего-то. Я так же не понимаю, но это скорее всего уже дело глубже чем мой вопрос.

Всё просто: процессор работает с памятью не отдельными байтами, а с т.н. "машинными словами" — блоками из нескольких байт. Обычно он кратно степени двойки — 1, 2, 4, 8 и так далее. Поэтому в случае, например, если разместить в памяти число без выравнивания, то для работы с этим числом надо будет прочитать сначала одно машинное слово, сделать сдвиг байтам, чтобы разместить их в нужном порядке в регистре, затем прочитать второе машинное слово в другой регистр, в нём тоже сделать сдвиг байтов, и только после этого "склеить" байты из регистров в одном регистре. Получается надо сделать кучу операций только для того, чтобы прочитать число из памяти. И для его сохранения надо будет всё проделать в обратном порядке. Это будет не очень эффективно. Именно поэтому все данные в памяти почти всегда выравниваются. И по этой же причине обычно в структурах всегда первыми идут поля, которым не нужно выравнивание, а дальше идут уже поля, которым нужно выравнивание. Конечно, это в общем случае, а так — в современных процессорах очень много всего накрутили типа кэшей, прогнозирования ветвлений и прочее, так что там всё несколько сложнее и следует смотреть спецификации на конкретный процессор.