Embedded Systems | C Language | Heap Memory

TechTale #8: The Biggest Challenge of Using Dynamic Allocation in C

How Heap Fragmentation Can Destroy Your Application

While you develop your code in C, I’m sure you’ve heard of dynamic memory allocation. You’ve probably also heard about the risks involved, with some tech teams even forbidding its use altogether. But have you ever wondered what these risks are, and how critical they can be to your software application?

What is dynamic allocation?

Dynamic allocation refers to the process of reserving memory space for your variables while coding. This type of allocation is useful when you don’t know how much memory your variable will need, or when you believe it to be more efficient for your application.

In your system’s memory, there’s a region dedicated to this type of allocation, known as the heap. Each time you request dynamic memory for a variable, your program searches for available space in the heap. The search is based on the size of the requested allocation, and it must also ensure that the space is uninterrupted by other allocations.

Many microcontroller architectures allow you to set the size of the heap memory and define its starting and ending addresses.

Are there other types of memory?

Yes, there are other types of memory. One of the most well-known is the stack, which is used to store static variables for each function call, including the main function.

The main difference between the stack and the heap is how memory is managed. The stack’s memory allocation and deallocation are handled automatically by the system as the program executes, whereas the heap’s memory is managed manually by the program. Additionally, the stack typically has a fixed memory size defined before the program starts, while the heap allows dynamic allocation at runtime.

Each memory type has its advantages. The stack is generally faster, but the heap is more flexible when you need to handle data whose size can change during runtime. However, both have drawbacks.

How does dynamic allocation work?

To understand the challenges of heap memory, it’s essential to know how dynamic allocation works in C.

When you perform dynamic allocation in C, you first need to know how much memory you need. For example, if you have a structure that is 35 bytes in size, you would use malloc or calloc to reserve that amount of memory in the heap.

The memory manager (unit controller) will then look for available space in the heap. Once it finds a free spot, it checks whether the available space is large enough to hold the requested memory. If the space is sufficient, it reserves it. If not, the manager continues searching for a larger available block.

When you request memory, the system either returns the memory address of the allocated block or NULL if the allocation fails.

Since heap memory management is manual, the program is responsible for freeing the memory when it’s no longer needed, using the free function.

What happens if I forget to free the memory?

Imagine your heap memory as a wardrobe. When it’s empty, it can hold a lot of clothes. However, if you keep filling it with more clothes, eventually the wardrobe won’t be able to fit any more items because the space is full. Similarly, if you forget to free memory in the heap, you’re filling it up without creating room for new allocations.

Although some architectures offer a dynamically sized heap, the size is still constrained by the amount of available RAM when the program starts. If you use all available memory for your program’s operations, the heap will have no space left for further allocations.

Forgetting to call free essentially "clogs" the heap, preventing the allocation of new memory. After a certain point, the allocation functions will return NULL, indicating that no more space is available.

What if I need to keep crucial data in the heap?

There are situations where you need to keep data in the heap for use by other threads, functions, or after several iterations of the program. However, this can lead to a problem — heap fragmentation.

Heap fragmentation occurs when memory is reserved for various purposes, leaving small gaps between allocated blocks. Let’s illustrate this with an example:

Suppose you have a heap of 1 KB (1024 bytes). The first function reserves 512 bytes, and when it’s done, it frees the memory. However, the function keeps a crucial 1-byte variable in the heap for later use.

Now, if I ask how much available space is left in the heap, you’d likely say 1023 bytes, which is correct. But if I ask how much contiguous memory is available, you may not be able to answer. If that critical 1-byte variable is stored in the middle of the heap, the largest block of available memory might only be 512 bytes, even though 1023 bytes are technically free. This is the fragmentation problem.

In essence, heap fragmentation occurs when memory isn’t wasted, but the largest contiguous block of memory is too small to fulfill future allocation requests. This is a common issue when crucial data is kept in the heap for future use.

In a nutshell

Dynamic allocation is essential for certain applications, especially when optimizing memory usage or handling data whose size isn’t determined until runtime. However, it comes with its own risks, such as forgetting to free memory or causing fragmentation.

These challenges make dynamic allocation less reliable than static allocation for critical applications. Some modern architectures, like the ESP32, offer solutions like heap error managers that help detect and address heap issues, such as resetting the system or forcing deallocation. Others provide methods to partition the heap into virtual zones to store critical variables in specific areas, while leaving other regions available for quick memory allocation.

In conclusion, while heap memory provides flexibility, it requires careful management to avoid future problems. The risks involved make it crucial to develop strategies to manage heap memory efficiently and avoid potential issues.