Why Memory Alignment Matters in Go: Making Your Structs Lean and Fast

When writing Go code, it’s easy to forget what’s happening under the hood—especially when it comes to memory layout. But did you know that how you organize fields in a struct can actually bloat memory and even affect performance?

Let’s take a fun but technical dive into how memory alignment works in Go, and why struct layout matters more than you might think.

🧠 What Is Memory Alignment, Exactly?

Memory alignment is a concept rooted in how CPUs access memory. Most modern CPUs are optimized to access memory at aligned addresses—that is, addresses that are multiples of the data’s size.

For example:

• An int64 (8 bytes) should ideally start at a memory address that’s a multiple of 8.
• An int32 (4 bytes) should start at a multiple of 4.

If a variable is misaligned, the CPU might need to perform multiple memory reads just to get the full data. This slows things down. On top of that, if a variable spans across two cache lines, you’ll suffer a performance penalty because the CPU has to load both cache lines.

Here’s a simple analogy: imagine reading a sentence split across two pages in a book. You flip once, then again, just to get the whole message. Alignment keeps your "sentence" on the same page.

TL;DR:

• Aligned data = fast memory access
• Misaligned data = slow, possibly multiple reads

🛠️ How Go Handles Memory Alignment

Go takes care of alignment automatically. Each data type has an alignment requirement, and Go inserts padding bytes between struct fields to ensure proper alignment.

Let’s look at this struct:

type PoorlyAligned struct {
    a byte   // 1 byte
    b int64  // 8 bytes
    c byte   // 1 byte
}

Although the fields themselves total 9 bytes, the compiler inserts padding to align each field properly. This results in:

📆 Total size: 24 bytes

Why?

✅ Well-Aligned Layout = Happy Memory

Now let’s rearrange the fields:

type WellAligned struct {
    b int64  // 8 bytes
    a byte   // 1 byte
    c byte   // 1 byte
}

Result:

📆 Total size: 16 bytes

💡 By simply reordering the fields, we reduced the struct's size from 24 bytes down to 16 bytes—saving 8 bytes for every single instance of this struct.

🚀 Real-World Impact: Memory and Performance

Why does this matter?

• Less memory per struct = lower overall memory usage
• Smaller structs fit better into CPU cache lines
• Better cache usage = fewer cache misses = faster processing
• Less memory used = less work for the garbage collector

🔬 Benchmarking Time!

Let’s benchmark two slices: one using the poorly-aligned struct, one using the optimized version.

package main

import (
    "testing"
)

type PoorlyAligned struct {
    a byte   // 1 byte
    b int64  // 8 bytes
    c byte   // 1 byte
}

type WellAligned struct {
    b int64  // 8 bytes
    a byte   // 1 byte
    c byte   // 1 byte
}

var poorlySlice = make([]PoorlyAligned, 1_000_000)
var wellSlice = make([]WellAligned, 1_000_000)

func BenchmarkPoorlyAligned(b *testing.B) {
    var sum int64
    for n := 0; n < b.N; n++ {
        for i := range poorlySlice {
            sum += poorlySlice[i].c
        }
    }
}

func BenchmarkWellAligned(b *testing.B) {
    var sum int64
    for n := 0; n < b.N; n++ {
        for i := range wellSlice {
            sum += wellSlice[i].c
        }
    }
}

📊 Typical Results:

goos: darwin
goarch: arm64
pkg: metaleap/pkg/tunatest
cpu: Apple M1
BenchmarkPoorlyAligned-8            3609            323200 ns/op
BenchmarkWellAligned-8              3759            316617 ns/op
PASS

✅ Result: On my Apple M1 chip, optimizing the struct layout resulted in a ~2% performance improvement.

🛠️ Tools: Check Alignment with go vet

You don’t need to do this manually. Go provides a vetting tool to help:

go vet -fieldalignment ./...

It will suggest better ordering for your structs when applicable, like:

struct with 24 bytes could be 16 bytes

✅ Best Practices for Struct Layout in Go

• Order fields from largest to smallest alignment.
• Group fields with the same size together.
• Consider memory layout when defining high-volume or performance-critical structs.
• Use go vet -fieldalignment for automatic suggestions.

📝 Final Thoughts

Memory alignment is one of those “under-the-hood” details that can have outsized effects in real-world programs—especially those dealing with millions of objects or high-performance data processing.

With just a bit of attention to field ordering, you can:

• Save memory
• Speed up your programs
• Make your data more cache-friendly

Go’s compiler does the heavy lifting to ensure safety and correctness. Your job is to be mindful of layout when performance or memory use matters.

📚 References

• Go Optimization Guide
• Go go vet fieldalignment Analyzer