What is “bit padding” or “padding bits” exactly?

by

I often find the term “bit padding” in relation of data types, but don´t understand what it is nor what it does exactly with those.

The gist of it is they are “wasted” space. I say “wasted” because while having padding bits makes the object bigger, it can make working with the object much easier (which means faster) and the small space waste can generate huge performance gains. In some cases it is essential because the CPU can’t handle working with objects of that size.

Lets say you have a struct like (all numbers are just an example, different platforms can have different values):

struct foo
{
    short a; // 16 bits
    char  b; // 8 bits 
};

and the machine you are working with reads 32 bits of data in a single read operation. Reading a single foo is not a problem since the entire object fits into that 32 bit chunk. What does become a problem is when you have an array. The important thing to remember about arrays is that they are contiguous, there is no space between elements. It’s just one object immediately followed by another. So, if you have an array like

foo array[10]{};

With this the first foo object is in a 32 bit bucket. The next element of the array though will be in the first 32 bit bucket and the second 32 bit bucket. This means that the member a is in two separate buckets. Some processors can do this (at a cost) and other processors will just crash if you try to do this. To solve both those problems the compiler will add padding bits to the end of foo to pad out it’s size. This means foo actually becomes

struct foo
{
    short a; // 16 bits
    char  b; // 8 bits 
    char  _; // 8 bits of padding
};

And now it is easy for the processor to handle foo objects by themselves or in an array. It doesn’t need to do any extra work and you’ve only added 8 bits per object. You’d need a lot of objects for that to start to matter on a modern machine.

There is also times where you need padding between members of the type because of unaligned access. Lets say you have

struct bar
{
    char c; // 8 bits
    int  d; // 32 bits
};

Now bar is 40 bits wide and d more often then not will be stored in two different buckets again. To fix this the compiler adds padding bits between c an d like

struct bar
{
    char    c; // 8 bits
    char _[3]; // 24 bits
    int     d; // 32 bits
};

and now d is guaranteed to go into a single 32 bit bucket.

More Related Contents:

  1. Dynamic memory allocation in game server [closed]
  2. When and why will a compiler initialise memory to 0xCD, 0xDD, etc. on malloc/free/new/delete?
  3. General guidelines to avoid memory leaks in C++ [closed]
  4. Allocating more memory than there exists using malloc
  5. How do you determine the size of an object in C++?
  6. What is the behavior of “delete” with stack objects? [duplicate]
  7. How do I call the original “operator new” if I have overloaded it?
  8. Is global memory initialized in C++?
  9. What does “Memory allocated at compile time” really mean?
  10. Class members and explicit stack/heap allocation
  11. Avoid memory leaks in C++ Pointers [closed]
  12. C++ – destructors [closed]
  13. What is a “cache-friendly” code?
  14. delete vs delete[] [duplicate]
  15. How to get memory usage at runtime using C++?
  16. How to properly replace global new & delete operators
  17. How to read file content into istringstream?
  18. Difference between pointer to a reference and reference to a pointer
  19. What happens when a computer program runs?
  20. Read process memory of a process does not return everything
  21. Multithreaded Memory Allocators for C/C++
  22. initializing std::string from char* without copy
  23. How can i estimate memory usage of std::map?
  24. Call destructor and then constructor (resetting an object)
  25. Memory allocation and deallocation across dll boundaries
  26. How to track memory allocations in C++ (especially new/delete)
  27. Why doesn’t delete destroy anything?
  28. how do arrays work internally in c/c++
  29. new, delete ,malloc & free
  30. Should objects delete themselves in C++?

Leave a Comment