Memory Alignment in Go and Struct Optimization

Memory Alignment in Go and Struct Optimization

I. Description
Memory alignment is a data arrangement rule in computer systems designed to improve memory access efficiency. In the Go language, the compiler automatically performs memory alignment for struct fields. However, understanding its principles can help us optimize struct layout, reduce memory usage, and enhance CPU access efficiency. This topic will delve into the principles, rules, methods of inspection, and practical optimization of memory alignment.

II. Alignment Coefficient and Basic Rules

  1. Alignment Coefficient (Alignment Size)
    Each data type in Go has a corresponding alignment coefficient, usually equal to its size:

    • bool, int8, uint8 → alignment coefficient of 1 byte
    • int16, uint16 → alignment coefficient of 2 bytes
    • int32, uint32, float32, rune → alignment coefficient of 4 bytes
    • int64, uint64, float64, complex64 → alignment coefficient of 8 bytes
    • string, slice, interface{} → alignment coefficient of 8 bytes (due to containing pointers)
    • The alignment coefficient of a struct is the maximum alignment coefficient among all its fields.

  2. Alignment Rules

    • The starting address of a field must be an integer multiple of its alignment coefficient.
    • The total size of a struct must be an integer multiple of its alignment coefficient.

III. Example Analysis of Struct Memory Alignment

type Example1 struct {
    a bool      // size 1 byte, alignment coefficient 1
    b int32     // size 4 bytes, alignment coefficient 4
    c int8      // size 1 byte, alignment coefficient 1
}

Memory Layout Derivation:

  1. a starts at address 0, occupying 1 byte (address 0).
  2. b needs to be aligned to a multiple of 4, so the next available address is 4. Thus, addresses 1~3 are skipped (3 bytes of padding), and b occupies addresses 4~7.
  3. c has an alignment coefficient of 1 and is placed directly after b at address 8.
  4. The struct's alignment coefficient is max(1,4,1)=4, and the total size must be a multiple of 4. Currently, addresses 0~8 occupy 9 bytes, so padding is added to reach 12 bytes (9→12).

Verification Using Tools:

fmt.Println(unsafe.Sizeof(Example1{}))  // Output: 12
fmt.Println(unsafe.Alignof(Example1{})) // Output: 4

IV. Optimizing Struct Layout
Adjusting field order can reduce padding space:

type Example2 struct {
    b int32     // alignment coefficient 4, occupies addresses 0~3
    a bool      // alignment coefficient 1, occupies address 4
    c int8      // alignment coefficient 1, occupies address 5
}

Derivation process:

  1. b starts at address 0, occupying addresses 0~3.
  2. a is placed directly after b at address 4.
  3. c is placed at address 5.
  4. The current total size is 6 bytes. The struct's alignment coefficient is 4, so padding is added to reach 8 bytes (6→8).
    Memory usage decreases from 12 bytes to 8 bytes, a 33% reduction.

V. Alignment Characteristics of Empty Structs
The empty struct struct{} has a size of 0, but when used as a field, it requires alignment:

type S struct {
    a struct{}  // size 0, but its address cannot overlap with other fields
    b int64
}
  • If a is before b: a occupies address 0 (size 0), and b has an alignment coefficient of 8, so its starting address must be a multiple of 8. Thus, it starts at address 8, resulting in a total size of 16 bytes.
  • Moving a to the end can avoid padding: 
    type SOptimized struct {
    b int64
    a struct{}  // address immediately follows b, no extra space occupied
}
    The total size remains 8 bytes (the empty struct does not occupy memory).

VI. Practical Application Scenarios

  1. Reducing Memory Usage
    In scenarios with a large number of struct instances (e.g., slices, caches), optimizing field order can significantly reduce memory usage.
  2. Interoperability with C
    Manual adjustment via //go:packed comments or field ordering is required to match C struct layout.
  3. High-Performance Computing
    Ensuring data alignment avoids performance penalties caused by misaligned memory access on the CPU.

VII. Summary

  • Memory alignment is automatically handled by the compiler, but understanding the rules helps with proactive optimization.
  • Prioritize fields with larger alignment coefficients to reduce padding gaps.
  • Use unsafe.Sizeof and unsafe.Offsetof to analyze layout.
  • Placing empty structs as the last field avoids memory waste.