Pad Structs to Avoid False Sharing Between Threads

Topic Overview

Align Hot Fields to Cache Lines

When each thread increments its own counter in a shared array, placing counters 8 bytes apart packs eight of them into one 64-byte line. Padding or aligning each counter to 64 bytes gives each thread a private line.

Padding Patterns

Use alignas(64) on struct fields or insert explicit char padding arrays. Verify sizeof and offsets with offsetof before trusting layout.

cCopy
Loading…

• Over-padding increases memory but buys parallelism
• C++ std::hardware_destructive_interference_size documents line size when available
• False sharing also hits kernel per-CPU statistics arrays
• Pair padding fixes with perf c2c validation

Working Through the Exercise

Keep the relevant documentation open while you implement. When your output disagrees with the reference, trace one failing case by hand before changing random lines.

• Trace first: walk one failing input step by step
• Read the manual: skim the official doc for the mechanism named in this task
• Compare baselines: save measurements from the prior step so speedups are honest

Why for this exercise

You will pad a struct array so threads no longer false-share, then benchmark before and after. This exercise requires measuring contention drops, not just showing the layout change.

Your Task

Field order changes the size of a C struct: every member is aligned to its own alignment, so a char before a double wastes 7 bytes. Alignment also decides which cache line each array element lands in, and elements sharing a line is exactly how per-thread counters end up false sharing. Write a struct-layout calculator for the x86-64 System V ABI. It prints offsets and padding, reorders fields to remove padding, applies __attribute__((aligned(N))), and maps an array of structs onto cache lines.

Input

cCopy
Loading…

Types (size/alignment): char bool uint8_t 1, short uint16_t 2, int float uint32_t 4, long double pointer uint64_t size_t 8, long_double 16. A struct used as a field has its computed size and alignment.

Rules

• Place each field at the next offset that is a multiple of its alignment. The struct's alignment is the largest field alignment (or the forced alignment, if that is larger), and its size is rounded up to that alignment.
• reorder prints a copy named NAME_reordered, with the fields stably sorted by alignment from largest to smallest, and reports the bytes saved. The original is not changed.
• aligned requires a power of two, and applies to all later uses of the struct.
• array places COUNT elements back to back from address 0. For each line, print which elements have bytes in it, then count the lines holding bytes of several elements and the elements that cross a line boundary. COUNT is 1..1024, and LINE is a power of two.
• Errors: S: unknown type T (the field is skipped), unknown struct S, aligned: N is not a power of two, array: invalid count or line size, and array: struct S is empty.

Output

cCopy
Loading…

Offsets are right-aligned in 4 columns. The padding percentage is rounded half up to 1 decimal using integer arithmetic. Only padding at the struct's own level is counted, not padding inside nested structs.

Example

Input:

cCopy
Loading…

Output:

cCopy
Loading…

Requirements

1. Compute layouts with the ABI rules alone, and verify your mental model against offsetof/sizeof if you like. Never hard-code sizes.
2. Make the reorder stable, so equal-alignment fields keep their declared order.

Hidden tests cover arrays of odd-sized structs that straddle lines, nested structs, long_double, a struct that is already optimal (reordering saves 0 bytes), forcing 64-byte alignment to give each element its own line, and every error message.