Optimizing Program Size in Embedded C/C++ Development: Structure Optimization

In C and C++ programming, the memory layout of structures (struct) has a significant impact on program performance and memory usage, especially in embedded development where RAM is limited to 16K, 8K, or even 4K; every byte counts, and there is no room for waste. This article will detail how to optimize the memory layout of structures to reduce program size and improve efficiency and performance by understanding alignment requirements, padding, and structure reordering techniques.

1. Alignment Requirements

The compiler is constrained by alignment requirements when laying out basic data types in memory to speed up memory access. These constraints lead to similar layouts across architectures such as Intel, ARM, and RISC-V. Except for the char type, other basic C language data types have alignment requirements. For example, a short of 2 bytes must start at an even address, a 4-byte int or float must start at an address that is a multiple of 4, and an 8-byte long or double must start at an address that is a multiple of 8. This self-aligning property makes memory access faster.However, it also leads to additional memory overhead—padding.

2. Padding

Padding refers to the extra bytes added by the compiler between structure members or at the end of the structure to meet alignment requirements. For example, consider the following structure (on a 64-bit system):

struct foo1 {
    char *p;     /* 8 bytes */
    char c;      /* 1 byte */
    long x;      /* 8 bytes */
};

In this structure, the char type member c requires an additional 7 bytes of padding to ensure that the long type member x starts at an 8-byte aligned address:

struct foo1 {
    char *p;     /* 8 bytes */
    char c;      /* 1 byte */
    //char pad[7]; /* 7 bytes padding */
    long x;      /* 8 bytes */
};

This padding, while ensuring fast access to data, also leads to memory waste.

3. Structure Alignment and Padding

Structure alignment is typically based on the width of its widest member. For instance, if a structure contains a long type member, the entire structure will have 8 bytes of alignment. This means the address of the structure matches the address of its first member, with no preceding padding. However, there may be trailing padding at the end of the structure to ensure the next structure instance starts at the correct aligned address.

4. Bit Fields

Bit fields allow you to declare fields in a structure that are smaller than the width of a character, as small as 1 bit. For example:

struct foobits {
    short s;
    char c;
    int flip:1;
    int nybble:4;
    int septet:7;
};

The layout of bit fields is subject to the C standard’s constraints; they cannot cross storage unit boundaries. C99 guarantees that bit fields will be packed as tightly as possible, while C++14 relaxed this constraint, allowing bit fields to span multiple allocation units.

5. Structure Reordering

From the rules of alignment and padding learned above, we can reduce padding and optimize memory layout by reordering structure members. Typically, arranging members in descending order of alignment requirements can reduce padding. For example, placing pointer-aligned members first, followed by 4-byte int, then 2-byte short, and finally char type members. This method can significantly reduce the overall size of the structure, thereby improving memory usage efficiency.

6. Practical Applications of Structure Optimization

Consider a complex structure that contains various types of data members:

struct complex {
    char c1;
    int i1;
    short s1;
    long l1;
    char c2;
};

In this structure, there will be padding between c1 and c2, as well as at the end of l1. By reordering the members, we can reduce padding:

struct complex {
    long l1;
    int i1;
    short s1;
    char c1;
    char c2;
};

This reordered structure has only 4 bytes of padding between l1 and i1, because i1 needs 4 bytes of alignment. There is no padding between c1 and c2 because c1 is already within the padding of i1.

For optimization comparison, the demo source code repository can be found at the end of the article: Optimizing Program Size in Embedded C/C++ Development: Structure Optimization

Conclusion

Understanding and applying structure optimization techniques is crucial for improving the performance and memory efficiency of C and C++ programs. By grasping alignment requirements, padding, and structure reordering, developers can design more efficient and compact data structures, thereby enhancing overall program performance while maintaining code readability. Remember, optimizing structures is not just about reducing memory usage; it can also speed up program execution, especially when handling large amounts of data or in memory-constrained environments.

The article is accompanied by a demo source code repository: Structure Optimization Comparison demo [https://gitee.com/icemaple/windsurfdemo/tree/structsize/]

By the way, a book giveaway event was launched on New Year’s Day, and today (January 6th at 6:06 PM) is the draw. Interested friends can reply in the background to get the lottery link~Wishing everyone a year of 666 ~

Related Reading:1. New Harmony Next in 2025, new open-source Harmony, new Flutter, new lottery—no bugs all year2. Updated MDK Embedded Development Experience: The ‘Not’ Perfect Combination Guide of VS Code + KEIL

3. Windows + vscode + cmake + gtest: C++ unit testing scheme using VSCode editing and CMake building and running on Windows