Низкоуровневое представление типов в памяти в Rust (Type Layout)

Введение

#

Писать безопасный и быстрый код — это здорово, но иногда полезно понимать, как именно наши данные располагаются на физическом уровне в оперативной памяти. В Rust компилятор берет на себя управление памятью, оптимизируя размеры типов и выравнивание. В этой статье мы разберем основные понятия Type Layout в Rust.

Поведение компилятора по умолчанию

#

• Управление памятью: Компилятор Rust автоматически рассчитывает и задает типу такие размеры (size) и выравнивание (alignment), которые гарантированно удовлетворяют техническим требованиям всех его внутренних полей на целевой архитектуре процессора.
• Паддинг (Padding): Компилятор имеет право автоматически вставлять неявные байты заполнения (паддинг) в структуру для обеспечения корректного выравнивания данных в памяти.
• Переупорядочивание полей: По умолчанию Rust не гарантирует сохранение порядка полей, написанного в коде. Компилятор оставляет за собой право произвольно менять порядок полей в кортежах, структурах и перечислениях для оптимизации размера и минимизации паддинга.

Давайте изучим выравнивание, размеры типов, использование атрибутов представления #[repr(...)] и работу с тегами перечислений на интерактивных слайдах ниже:

 1use std::mem::{size_of, align_of};
 2
 3#[allow(dead_code)]
 4struct Foo {
 5    a: u8,
 6    b: u32,
 7    c: u16,
 8}
 9
10fn main() {
11    println!("Размер Foo: {} байт", size_of::<Foo>());
12    println!("Выравнивание Foo: {} байт", align_of::<Foo>());
13    
14    // Если бы поля лежали в памяти строго по порядку (a, b, c):
15    // 1 байт (a) + 3 байта паддинга + 4 байта (b) + 2 байта (c) + 2 байта паддинга = 12 байт.
16    // Однако компилятор Rust переупорядочил поля в памяти (b, c, a):
17    // 4 байта (b) + 2 байта (c) + 1 байт (a) + 1 байт паддинга = 8 байт!
18}

 1use std::mem::size_of;
 2
 3#[repr(C)]
 4#[allow(dead_code)]
 5struct StructC {
 6    a: u8,
 7    b: u32,
 8    c: u16,
 9}
10
11#[repr(align(16))]
12#[allow(dead_code)]
13struct StructAlign {
14    a: u32,
15}
16
17#[repr(transparent)]
18#[allow(dead_code)]
19struct Wrapper(u32);
20
21fn main() {
22    println!("Размер StructC (repr(C)): {} байт", size_of::<StructC>());
23    println!("Размер StructAlign (repr(align(16))): {} байт", size_of::<StructAlign>());
24    println!("Размер Wrapper (repr(transparent)): {} байт", size_of::<Wrapper>());
25}

 1#[repr(u32)] // Задаем тип тега (дискриминанта) в памяти как u32
 2#[allow(dead_code)]
 3enum Status {
 4    Active = 42,
 5    Inactive = 24,
 6    Pending = 134,
 7}
 8
 9fn main() {
10    let val = Status::Active;
11    
12    // Приведение перечисления к целому числу с помощью оператора `as`
13    let num = val as u32;
14    
15    println!("Тег Status::Active в памяти равен: {}", num);
16}

Детали реализации и шаги:

#

1. Шаг 1. Выравнивание и размер по умолчанию:

   • Каждому типу данных требуется выравнивание в памяти: адрес начала данных должен быть кратен выравниванию типа (обычно степени двойки: 1, 2, 4, 8 байт).
   • Из-за этого между полями могут образовываться пустые байты — паддинг.
   • По умолчанию (представление repr(Rust)) компилятор переупорядочивает поля структуры Foo так, чтобы они занимали 8 байт вместо 12 байт, размещая сначала самые строгие по выравниванию типы.

2. Шаг 2. Управление расположением данных с помощью атрибутов: Для явного изменения логики размещения данных в памяти и обеспечения совместимости с другими языками используются специальные атрибуты представления:

   • #[repr(C)] — отключает оптимизацию переупорядочивания полей Rust и выстраивает их строго в том порядке, в котором они объявлены (совместимо с ABI языка C).
   • #[repr(align(N))] — принудительно устанавливает минимальное выравнивание типа в памяти (например, 16 байт).
   • #[repr(transparent)] — гарантирует, что тип имеет точно такое же представление в памяти и ABI, как и его единственное некорректное поле (используется для newtype-оберток).

3. Шаг 3. Явное тегирование перечислений (Enum Discriminants):

   • Для перечислений можно жестко фиксировать тип числового тега (дискриминанта) в памяти и присваивать явные числовые значения каждому варианту.
   • Это позволяет осуществлять безопасное приведение типов (кастинг) из перечисления в целочисленный тип с помощью ключевого слова as.

Проверь свои знания!

#

Пройдите короткий интерактивный тест, чтобы закрепить понимание расположения типов данных в памяти.