Memory Management#

Proper memory management is essential in any software project, but it becomes even more critical in embedded systems like the ESP32, where memory is a limited resource. This section outlines the best practices for managing memory efficiently and avoiding common pitfalls such as memory leaks, heap fragmentation, and stack overflows.

General Guidelines#

Prefer Static Allocation: Whenever possible, use static memory allocation instead of dynamic allocation (e.g., malloc/free) to prevent heap fragmentation and improve performance.
- Static Memory: This memory is allocated at compile time and persists throughout the program’s lifetime. It’s ideal for variables that need to exist for the entire duration of the program.
Example:
```
static int buffer[1024];
```
- Dynamic Memory: This memory is allocated at runtime using functions like malloc and free. While flexible, dynamic memory can lead to fragmentation over time, particularly in long-running applications.
Example:
```
int *buffer = malloc(1024 * sizeof(int));
if (!buffer) {
  /* Handle allocation failure */
}
free(buffer);
```
Use Dynamic Memory Sparingly: In memory-constrained environments, minimize the use of dynamic memory. If dynamic memory must be used, ensure that all allocations are matched with corresponding deallocations to prevent memory leaks.
Avoid Heap Fragmentation: Fragmentation occurs when free memory is divided into small, non-contiguous blocks, making it difficult to allocate larger blocks of memory. Use dynamic memory only for objects with well-defined lifetimes, and consider static allocation for long-lived data.
Check for Memory Allocation Failures: Always check the return value of malloc, calloc, or realloc to ensure that memory was successfully allocated. If memory allocation fails, handle the failure gracefully.

Example:
```
int *buffer = malloc(1024 * sizeof(int));
if (!buffer) {
  /* Handle allocation failure */
  return -ENOMEM;
}
```
Free Dynamically Allocated Memory: Ensure that all dynamically allocated memory is properly deallocated using free. Failing to do so will lead to memory leaks.

Example:
```
free(buffer);
```

Stack vs. Heap#

In embedded systems, memory is divided into the stack and the heap. Understanding the differences and when to use each is critical for efficient memory management.

Stack: The stack is a region of memory used for local variables and function calls. It is fast, but limited in size. Exceeding the stack size can lead to stack overflows, which are difficult to debug.
- Use the stack for small, short-lived variables (e.g., local variables in a function).
- Be mindful of recursive functions or deep call chains, which can consume a lot of stack space.
Example:
```
void function(void) {
  int local_array[100];  /* Stored on the stack */
}
```
Heap: The heap is used for dynamically allocated memory (e.g., malloc). The heap offers more flexibility but is prone to fragmentation over time.
- Use the heap for large or variable-sized data that needs to persist across function calls.
Example:
```
int *buffer = malloc(100 * sizeof(int));  /* Stored on the heap */
if (buffer) {
  free(buffer);  /* Free the memory when no longer needed */
}
```
Stack Size: Pay attention to the stack size of each task in an embedded system. Underestimating the required stack size can lead to stack overflows, while overestimating it wastes valuable memory.