Padding and Alignment

Consequences of Misaligned Memory

What happens if we try to read memory that isn't properly aligned?

Abstract art representing computer programming

When we try to read misaligned memory, different things can happen depending on the CPU architecture and compiler settings. Let's look at three common scenarios:

Performance Penalty

On most modern x86/x64 processors, misaligned access works but is slower:

1#include <chrono>
2#include <iostream>
3
4using namespace std::chrono;
5
6struct Aligned {
7  int Value; // 4 bytes, naturally aligned
8};
9
10#pragma pack(1)  // Force removal of padding
11struct Misaligned {
12  char A;    // 1 byte
13  int Value; // 4 bytes, misaligned!
14};
15#pragma pack()
16
17int main() {
18  const int Iterations{10000000};
19
20  // Test aligned access
21  Aligned A;
22  auto Start = high_resolution_clock::now();
23
24  for (int i = 0; i < Iterations; ++i) {
25    A.Value = i; // Aligned access
26    volatile int Temp = A.Value;
27  }
28
29  auto AlignedTime =
30    high_resolution_clock::now() - Start;
31
32  // Test misaligned access
33  Misaligned M;
34  Start = high_resolution_clock::now();
35
36  for (int i = 0; i < Iterations; ++i) {
37    M.Value = i; // Misaligned access
38    volatile int Temp = M.Value;
39  }
40
41  auto MisalignedTime =
42    high_resolution_clock::now() - Start;
43
44  std::cout
45    << "Aligned time: "
46    << std::chrono::duration_cast<milliseconds>(
47      AlignedTime).count()
48    << "ms\n"
49    << "Misaligned time: "
50    << std::chrono::duration_cast<milliseconds>(
51      MisalignedTime).count()
52    << "ms\n";
53}

Hardware Exception

On some architectures (like older ARM processors), misaligned access causes a hardware exception:

1#include <iostream>
2
3#pragma pack(1)
4struct Dangerous {
5  char A;
6  int Value;
7};
8#pragma pack()
9
10int main() {
11  Dangerous D;
12  D.Value = 42;// May trigger CPU exception! 
13}

Undefined Behavior

Some platforms might silently corrupt data or behave unpredictably:

1#include <iostream>
2
3#pragma pack(1)
4struct Risky {
5  char A;
6  int Value;
7};
8#pragma pack()
9
10void ProcessValue(Risky& Data) {
11  // On some platforms, this might:
12  // - Read incorrect values
13  // - Corrupt nearby memory
14  // - Cause other undefined behavior
15  std::cout << Data.Value << "\n";
16}

The takeaway is that while modern PCs often handle misaligned access gracefully (with a performance penalty), it's best to let the compiler handle alignment through padding to ensure our code works reliably across different platforms.

This Question is from the Lesson: