Struct packing and alignment in Embedded C - Mini Project: Build & Apply

Struct packing and alignment

📖 Scenario: You are working on a small embedded device that communicates sensor data. To save memory and send data efficiently, you need to understand how struct packing and alignment affect the size of your data structures.

🎯 Goal: You will create a struct representing sensor data, then apply packing to reduce its size, and finally print the size of the struct before and after packing.

📋 What You'll Learn

Create a struct called SensorData with three fields: char id, int value, and char status.

Create a variable called data of type SensorData.

Create a packed version of the struct called PackedSensorData using __attribute__((packed)).

Print the size of SensorData and PackedSensorData using sizeof.

💡 Why This Matters

🌍 Real World

Embedded systems often have limited memory and bandwidth. Understanding struct packing helps save memory and send data efficiently over networks.

💼 Career

Many embedded software jobs require knowledge of memory layout and optimization techniques like struct packing to write efficient low-level code.

1

Create the SensorData struct

Create a struct called SensorData with these exact fields in this order: char id, int value, and char status. Then declare a variable called data of type SensorData.

Embedded C

// Define struct SensorData and declare variable data
// Your code here

Hint

Remember to define the struct with the fields in the exact order and then declare a variable of that struct type.

2

Create a packed version of the struct

Create a packed struct called PackedSensorData with the same fields and order as SensorData. Use __attribute__((packed)) after the struct definition. Then declare a variable called packedData of type PackedSensorData.

Embedded C

struct SensorData {
    char id;
    int value;
    char status;
};

struct SensorData data;

// Define packed struct PackedSensorData and declare variable packedData
// Your code here

Hint

Use __attribute__((packed)) right after the closing brace of the struct definition.

3

Calculate sizes of structs

Create two variables: sizeNormal and sizePacked. Assign sizeof(data) to sizeNormal and sizeof(packedData) to sizePacked.

Embedded C

struct SensorData {
    char id;
    int value;
    char status;
};

struct SensorData data;

struct PackedSensorData {
    char id;
    int value;
    char status;
} __attribute__((packed));

struct PackedSensorData packedData;

// Create sizeNormal and sizePacked variables and assign sizes
// Your code here

Hint

Use sizeof operator on the variables data and packedData.

4

Print the sizes of both structs

Use printf to print the sizes stored in sizeNormal and sizePacked. Print exactly these two lines:
Size of SensorData: X
Size of PackedSensorData: Y
where X and Y are the values of sizeNormal and sizePacked respectively.

Embedded C

struct SensorData {
    char id;
    int value;
    char status;
};

struct SensorData data;

struct PackedSensorData {
    char id;
    int value;
    char status;
} __attribute__((packed));

struct PackedSensorData packedData;

unsigned int sizeNormal = sizeof(data);
unsigned int sizePacked = sizeof(packedData);

// Print the sizes of both structs
// Your code here

Hint

Use printf with %u to print unsigned integers and include a newline \n.

Practice

1. What does struct packing do in embedded C?

easy

A. Removes extra spaces between fields to save memory

B. Adds extra spaces to align data on memory boundaries

C. Changes the data types of struct members

D. Automatically initializes struct members to zero

Solution

1. Step 1: Understand struct packing purpose

   Struct packing removes padding bytes between fields to reduce memory usage.

2. Step 2: Compare with alignment

   Alignment adds padding for faster access, packing removes it to save space.

3. Final Answer:

   Removes extra spaces between fields to save memory -> Option A

4. Quick Check:

   Struct packing = removes padding [OK]

Hint: Packing removes spaces, alignment adds spaces [OK]

Common Mistakes:

• Confusing packing with alignment
• Thinking packing changes data types
• Assuming packing initializes values

2. Which of the following is the correct syntax to pack a struct in embedded C using GCC?

easy

A. struct MyStruct { int a; char b; } __packed;

B. struct MyStruct __packed { int a; char b; };

C. struct MyStruct { int a; char b; } __attribute__((aligned));

D. struct __attribute__((packed)) MyStruct { int a; char b; };

Solution

1. Step 1: Recall GCC packing syntax

   GCC uses __attribute__((packed)) after struct keyword or at end of struct definition.

2. Step 2: Identify correct placement

   struct __attribute__((packed)) MyStruct { int a; char b; }; places __attribute__((packed)) correctly after struct keyword.

3. Final Answer:

   struct __attribute__((packed)) MyStruct { int a; char b; }; -> Option D

4. Quick Check:

   GCC packing syntax = __attribute__((packed)) [OK]

Hint: Use __attribute__((packed)) after struct keyword [OK]

Common Mistakes:

• Using __packed keyword which is not standard GCC
• Placing __attribute__((aligned)) instead of packed
• Putting attributes in wrong position

3. Consider this struct without packing:

struct Example {
  char a;
  int b;
};

sizeof(struct Example);

What is the likely output on a 32-bit system where int is 4 bytes and alignment is on 4-byte boundaries?

medium

A. 5

B. 8

C. 12

D. 16

Solution

1. Step 1: Analyze struct member sizes and alignment

   char a = 1 byte, int b = 4 bytes aligned on 4-byte boundary.

2. Step 2: Calculate padding and total size

   After char a, 3 bytes padding added to align int b. Total size = 1 + 3 + 4 = 8 bytes. Struct size must be multiple of largest alignment (4), which 8 satisfies.

3. Final Answer:

   8 -> Option B

4. Quick Check:

   Size with padding = 8 bytes [OK]

Hint: Add padding after smaller types to align next member [OK]

Common Mistakes:

• Ignoring padding bytes
• Adding padding after last member unnecessarily
• Assuming size is sum of member sizes only

4. Given this code snippet:

struct Data {
  char c;
  int i;
} __attribute__((packed));

struct Data d;
printf("%zu", sizeof(d));

The output is 5, but the program crashes when accessing d.i. What is the likely cause?

medium

A. Accessing unaligned int causes crash on some systems

B. The struct is not actually packed

C. char c is not initialized

D. printf format specifier is incorrect

Solution

1. Step 1: Understand packing effect on alignment

   Packing removes padding, so int i may not be aligned on 4-byte boundary.

2. Step 2: Recognize hardware alignment requirements

   Some systems crash or fault when accessing unaligned int variables.

3. Final Answer:

   Accessing unaligned int causes crash on some systems -> Option A

4. Quick Check:

   Unaligned access = crash risk [OK]

Hint: Packed structs can cause unaligned access crashes [OK]

Common Mistakes:

• Blaming printf format specifier
• Assuming packing always safe
• Ignoring hardware alignment rules

5. You have a struct with members:

char a;
short b;
int c;

On a 32-bit system, how can you arrange and pack this struct to minimize memory size without causing unaligned access faults?

hard

A. Order members as char a; int c; short b; and use packing

B. Order members as char a; short b; int c; without packing

C. Order members as int c; short b; char a; and use packing

D. Order members as short b; char a; int c; without packing

Solution

1. Step 1: Understand alignment requirements

   int requires 4-byte alignment, short 2-byte, char 1-byte.

2. Step 2: Arrange members largest to smallest

   Ordering int c; short b; char a; places largest first, minimizing padding.

3. Step 3: Use packing carefully

   Packing removes padding but can cause unaligned access; here, ordering avoids unaligned access.

4. Final Answer:

   Order members as int c; short b; char a; and use packing -> Option C

5. Quick Check:

   Largest to smallest + packing = minimal size safe [OK]

Hint: Order largest to smallest type, then pack [OK]

Common Mistakes:

• Ordering members smallest to largest causing padding
• Packing without considering alignment faults
• Ignoring hardware alignment rules