Antwoord.

Historie van de Vraag

Geheugenoptimalisatie is een sleutelfeature van Rust, die het mogelijk maakt om middelen te besparen zonder in te boeten op de veiligheid van de code. Enum Layout is hoe de compiler de varianten van enums (met structvarianten of primitieve typen) plaatst, evenals de velden van elke structuur. In andere talen is deze optimalisatie vaak verborgen, terwijl het in Rust cruciaal is om de volgorde van velden in overweging te nemen om overmatig geheugenverbruik te voorkomen.

Probleem

Als de volgorde van velden in een structuur onhandig is gekozen, begint de structuur door de bijzonderheden van gegevensuitlijning "uit te dikken" in grootte. Voor enums met geassocieerde gegevens wordt de situatie gecompliceerd — de grootte van de enum wordt bepaald door de grootste variant plus de grootte van de discriminator. Negeren hiervan leidt tot overmatig geheugenverbruik en een lagere prestatie van de CPU-cache.

Oplossing

Voor een effectieve verpakking van structuren en enums moeten de meest "brede" velden eerst worden geplaatst, gevolgd door de smallere, en moeten de padding worden overwogen die de compiler kan toevoegen. Voor enums — kies de variantstructuur zodanig dat ze niet streven naar de maximale grootte, tenzij dat gerechtvaardigd is.

Voorbeeldcode:

struct BadAlign {
    a: u8,
    b: u32,
    c: u16,
}

struct GoodAlign {
    b: u32,
    c: u16,
    a: u8,
}

enum Packet {
    A(u8),
    B(u32, [u8; 10]),
}

Belangrijke kenmerken:

De grootte van de structuur (en enum) hangt af van de volgorde en het type velden.
Enums met grote varianten maken de hele enum groter, zelfs als andere varianten erg klein zijn.
Uitlijningsplatforms kunnen het geheugenverbruik aanzienlijk verhogen, vooral voor arrays van structuren.

Vragen met een Twis

Kan een structuur kleiner worden door de volgorde van velden te wijzigen?

Ja. Wanneer velden in volgorde van afnemende grootte zijn gerangschikt, vermindert de compiler vaak de hoeveelheid padding, waardoor de totale grootte van de structuur afneemt.

println!("{}", std::mem::size_of::<BadAlign>()); // bijvoorbeeld, 12
println!("{}", std::mem::size_of::<GoodAlign>()); // bijvoorbeeld, 8

Heeft enige volgorde van velden invloed op de toegangsprestaties?

De volgorde op zich heeft geen invloed op de snelheid van toegang via velden. Echter, bij sequentieel doorlopen van een structuur op laag niveau (bijvoorbeeld met SIMD-instructies of bij het werken met arrays van structuren in een lus) versnelt de juiste uitlijning de toegang door een betere benutting van de cache.

Als een variant van enum erg groot is, zal elke instantie van enum dan zoveel geheugen gebruiken, zelfs als het andere varianten zijn?

Ja, de grootte van de enum wordt altijd bepaald door de grootste variant plus de discriminator. Elke Packet zal de grootte van B innemen, zelfs als het A bevat.

Veelvoorkomende Fouten en Anti-patronen

De volgorde van velden negeren, waardoor onnodige overhead op uitlijning ontstaat.
Gebruik van enums met zeldzame, maar enorme varianten zonder wrappers of Box, wat leidt tot verhoogd geheugenverbruik.
Te agressief herverpakken en de leesbaarheid opofferen voor een paar bytes.

Voorbeeld uit het Leven

**Negatief Geval

In de structuur zijn de velden u8, gevolgd door u64. Gebruik in een array van 100000 records verbruikt tot een gigabyte geheugen door de padding.

Voordelen:

Goedkope implementatie, gewoon "zoals het gekomen is"

Nadelen:

Overmatig geheugenverbruik, slechte localiteit

**Positief Geval

Structuren zijn gesorteerd op de breedte van velden, grote varianten van de enum zijn in een Box geplaatst, kleine zijn in-place gelaten.