Minimizing RAM Usage
In some cases, a firmware application's available RAM may run low or run out entirely. In these cases, it is necessary to tune the memory usage of the firmware application.
In general, firmware should aim to leave some headroom of free internal RAM to deal with extraordinary situations or changes in RAM usage in future updates.
Before optimizing ESP-IDF RAM usage, it is necessary to understand the basics of ESP32 memory types, the difference between static and dynamic memory usage in C, and the way ESP-IDF uses stack and heap. This information can all be found in Heap Memory Allocation.
Measuring Static Memory Usage
Measuring Dynamic Memory Usage
ESP-IDF contains a range of heap APIs for measuring free heap at runtime, see Heap Memory Debugging.
In embedded systems, heap fragmentation can be a significant issue alongside total RAM usage. The heap measurement APIs provide ways to measure the largest free block. Monitoring this value along with the total number of free bytes can give a quick indication of whether heap fragmentation is becoming an issue.
Reducing Static Memory Usage
Reducing the static memory usage of the application increases the amount of RAM available for heap at runtime, and vice versa.
Generally speaking, minimizing static memory usage requires monitoring the
.bsssizes. For tools to do this, see Measuring Static Sizes.
Internal ESP-IDF functions do not make heavy use of static RAM in C. In many instances (such as Wi-Fi library, Bluetooth controller), static buffers are still allocated from the heap. However, the allocation is performed only once during feature initialization and will be freed if the feature is deinitialized. This approach is adopted to optimize the availability of free memory at various stages of the application's life cycle.
To minimize static memory use:
Constant data can be stored in flash memory instead of RAM, thus it is recommended to declare structures, buffers, or other variables as
const. This approach may require modifying firmware functions to accept
const *arguments instead of mutable pointer arguments. These changes can also help reduce the stack usage of certain functions.
If using Bluedroid, setting the option CONFIG_BT_BLE_DYNAMIC_ENV_MEMORY will cause Bluedroid to allocate memory on initialization and free it on deinitialization. This does not necessarily reduce the peak memory usage, but changes it from static memory usage to runtime memory usage.
If using OpenThread, enabling the option CONFIG_OPENTHREAD_PLATFORM_MSGPOOL_MANAGEMENT will cause OpenThread to allocate message pool buffers from PSRAM, which will reduce static memory use.
Reducing Stack Sizes
In FreeRTOS, task stacks are usually allocated from the heap. The stack size for each task is fixed and passed as an argument to
xTaskCreate(). Each task can use up to its allocated stack size, but using more than this will cause an otherwise valid program to crash, with a stack overflow or heap corruption.
Therefore, determining the optimum sizes of each task stack, minimizing the required size of each task stack, and minimizing the number of task stacks as whole, can all substantially reduce RAM usage.
To determine the optimum size for a particular task stack, users can consider the following methods:
At runtime, call the function
uxTaskGetStackHighWaterMark()with the handle of any task where you think there is unused stack memory. This function returns the minimum lifetime free stack memory in bytes.
The easiest time to call
uxTaskGetStackHighWaterMark()is from the task itself: call
uxTaskGetStackHighWaterMark(NULL)to get the current task's high water mark after the time that the task has achieved its peak stack usage, i.e., if there is a main loop, execute the main loop a number of times with all possible states, and then call
Often, it is possible to subtract almost the entire value returned here from the total stack size of a task, but allow some safety margin to account for unexpected small increases in stack usage at runtime.
uxTaskGetSystemState()at runtime to get a summary of all tasks in the system. This includes their individual stack high watermark values.
When debugger watchpoints are not being used, users can set the CONFIG_FREERTOS_WATCHPOINT_END_OF_STACK option. This will cause one of the watchpoints to watch the last word of the task's stack. If that word is overwritten (such as in a stack overflow), a panic is triggered immediately. This is slightly more reliable than the default CONFIG_FREERTOS_CHECK_STACKOVERFLOW option of
Check using canary bytes, because the panic happens immediately, rather than on the next RTOS context switch. Neither option is perfect. In some cases, it is possible that the stack pointer skips the watchpoint or canary bytes and corrupts another region of RAM instead.
To reduce the required size of a particular task stack, users can consider the following methods:
Avoid stack heavy functions. String formatting functions (like
printf()) are particularly heavy users of the stack, so any task which does not ever call these can usually have its stack size reduced.
Enabling Newlib Nano Formatting reduces the stack usage of any task that calls
printf()or other C string formatting functions.
Avoid allocating large variables on the stack. In C, any large structures or arrays allocated as an automatic variable (i.e., default scope of a C declaration) uses space on the stack. To minimize the sizes of these, allocate them statically and/or see if you can save memory by dynamically allocating them from the heap only when they are needed.
Avoid deep recursive function calls. Individual recursive function calls do not always add a lot of stack usage each time they are called, but if each function includes large stack-based variables then the overhead can get quite high.
To reduce the total number of tasks, users can consider the following method:
Combine tasks. If a particular task is never created, the task's stack is never allocated, thus reducing RAM usage significantly. Unnecessary tasks can typically be removed if those tasks can be combined with another task. In an application, tasks can typically be combined or removed if:
The work done by the tasks can be structured into multiple functions that are called sequentially.
The work done by the tasks can be structured into smaller jobs that are serialized (via a FreeRTOS queue or similar) for execution by a worker task.
Internal Task Stack Sizes
ESP-IDF allocates a number of internal tasks for housekeeping purposes or operating system functions. Some are created during the startup process, and some are created at runtime when particular features are initialized.
The default stack sizes for these tasks are usually set conservatively high to allow all common usage patterns. Many of the stack sizes are configurable, and it may be possible to reduce them to match the real runtime stack usage of the task.
If internal task stack sizes are set too small, ESP-IDF will crash unpredictably. Even if the root cause is task stack overflow, this is not always clear when debugging. It is recommended that internal stack sizes are only reduced carefully (if at all), with close attention to high water mark free space under load. If reporting an issue that occurs when internal task stack sizes have been reduced, please always include the following information and the specific configuration that is being used.
FreeRTOS Timer Task to handle FreeRTOS timer callbacks has stack size CONFIG_FREERTOS_TIMER_TASK_STACK_DEPTH.
The Ethernet driver creates a task for the MAC to receive Ethernet frames. If using the default config
ETH_MAC_DEFAULT_CONFIGthen the task stack size is 4 KB. This setting can be changed by passing a custom
eth_mac_config_tstruct when initializing the Ethernet MAC.
FreeRTOS idle task stack size is configured by CONFIG_FREERTOS_IDLE_TASK_STACKSIZE.
If using the ESP-MQTT component, it creates a task with stack size configured by CONFIG_MQTT_TASK_STACK_SIZE. MQTT stack size can also be configured using
To see how to optimize RAM usage when using
mDNS, please check Minimizing RAM Usage.
Aside from built-in system features such as ESP-timer, if an ESP-IDF feature is not initialized by the firmware, then no associated task is created. In those cases, the stack usage is zero, and the stack-size configuration for the task is not relevant.
Reducing Heap Usage
For functions that assist in analyzing heap usage at runtime, see Heap Memory Debugging.
Normally, optimizing heap usage consists of analyzing the usage and removing calls to
malloc() that are not being used, reducing the corresponding sizes, or freeing previously allocated buffers earlier.
There are some ESP-IDF configuration options that can reduce heap usage at runtime:
lwIP documentation has a section to configure Minimum RAM Usage.
Wi-Fi Buffer Usage describes options to either reduce the number of static buffers or reduce the maximum number of dynamic buffers in use, so as to minimize memory usage at a possible cost of performance. Note that static Wi-Fi buffers are still allocated from the heap when Wi-Fi is initialized, and will be freed if Wi-Fi is deinitialized.
The Ethernet driver allocates DMA buffers for the internal Ethernet MAC when it is initialized - configuration options are CONFIG_ETH_DMA_BUFFER_SIZE, CONFIG_ETH_DMA_RX_BUFFER_NUM, CONFIG_ETH_DMA_TX_BUFFER_NUM.
Several Mbed TLS configuration options can be used to reduce heap memory usage. See the Reducing Heap Usage docs for details.
In single-core mode only, it is possible to use IRAM as byte-accessible memory added to the regular heap by enabling CONFIG_ESP32_IRAM_AS_8BIT_ACCESSIBLE_MEMORY. Note that this option carries a performance penalty, and the risk of security issues caused by executable data. If this option is enabled, then it is possible to set other options to prefer certain buffers allocated from this memory: CONFIG_MBEDTLS_MEM_ALLOC_MODE, NimBLE.
Reduce CONFIG_BTDM_CTRL_BLE_MAX_CONN if using Bluetooth LE.
Reduce CONFIG_BTDM_CTRL_BR_EDR_MAX_ACL_CONN if using Bluetooth Classic.
There are other configuration options that increases heap usage at runtime if changed from the defaults. These options are not listed above, but the help text for the configuration item will mention if there is some memory impact.
Optimizing IRAM Usage
If the app allocates more static IRAM than available, then the app will fail to build, and linker errors such as
section '.iram0.text' will not fit in region 'iram0_0_seg',
IRAM0 segment data does not fit, and
region 'iram0_0_seg' overflowed by 84-bytes will be seen. If this happens, it is necessary to find ways to reduce static IRAM usage in order to link the application.
The following options will reduce IRAM usage of some ESP-IDF features:
Enable CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH. Provided these functions are not incorrectly used from ISRs, this option is safe to enable in all configurations.
Enable CONFIG_RINGBUF_PLACE_FUNCTIONS_INTO_FLASH. Provided these functions are not incorrectly used from ISRs, this option is safe to enable in all configurations.
Enable CONFIG_RINGBUF_PLACE_ISR_FUNCTIONS_INTO_FLASH. This option is not safe to use if the ISR ringbuf functions are used from an IRAM interrupt context, e.g., if CONFIG_UART_ISR_IN_IRAM is enabled. For the ESP-IDF drivers where this is the case, you can get an error at run-time when installing the driver in question.
Disabling CONFIG_SPI_FLASH_ROM_DRIVER_PATCH frees some IRAM but is only available in some flash configurations, see the configuration item help text.
If the application uses PSRAM and is based on ESP32 rev. 3 (ECO3), setting CONFIG_ESP32_REV_MIN to
3disables PSRAM bug workarounds, saving 10 KB or more of IRAM.
Disabling CONFIG_SPI_MASTER_ISR_IN_IRAM prevents spi_master interrupts from being serviced while writing to flash, and may otherwise reduce spi_master performance, but saves some IRAM.
Disabling CONFIG_SPI_SLAVE_ISR_IN_IRAM prevents spi_slave interrupts from being serviced while writing to flash, which saves some IRAM.
Setting CONFIG_HAL_DEFAULT_ASSERTION_LEVEL to disable assertion for HAL component saves some IRAM, especially for HAL code who calls
HAL_ASSERTa lot and resides in IRAM.
Refer to the sdkconfig menu
Auto-detect Flash chips, and you can disable flash drivers which you do not need to save some IRAM.
Enable CONFIG_HEAP_PLACE_FUNCTION_INTO_FLASH. Provided that CONFIG_SPI_MASTER_ISR_IN_IRAM is not enabled and the heap functions are not incorrectly used from ISRs, this option is safe to enable in all configurations.
Using SRAM1 for IRAM
The SRAM1 memory area is normally used for DRAM, but it is possible to use parts of it for IRAM with CONFIG_ESP_SYSTEM_ESP32_SRAM1_REGION_AS_IRAM. This memory would previously be reserved for DRAM data usage (e.g.,
.bss) by the software bootloader and later added to the heap. After this option was introduced, the bootloader DRAM size was reduced to a value closer to what it normally actually needs.
To use this option, ESP-IDF should be able to recognize that the new SRAM1 area is also a valid load address for an image segment. If the software bootloader was compiled before this option existed, then the bootloader will not be able to load the app that has code placed in this new extended IRAM area. This would typically happen if you are doing an OTA update, where only the app would be updated.
If the IRAM section were to be placed in an invalid area, then this would be detected during the bootup process, and result in a failed boot:
E (204) esp_image: Segment 5 0x400845f8-0x400a126c invalid: bad load address range
Apps compiled with CONFIG_ESP_SYSTEM_ESP32_SRAM1_REGION_AS_IRAM may fail to boot, if used together with a software bootloader that was compiled before this config option was introduced. If you are using an older bootloader and updating over OTA, please test carefully before pushing any updates.
Any memory that ends up unused for static IRAM will be added to the heap.
Putting C Library in Flash
When compiling for ESP32 revisions older than ECO3 (CONFIG_ESP32_REV_MIN), the PSRAM Cache bug workaround (CONFIG_SPIRAM_CACHE_WORKAROUND) option is enabled, and the C library functions normally located in ROM are recompiled with the workaround and placed into IRAM instead. For most applications, it is safe to move many of the C library functions into flash, reclaiming some IRAM. Corresponding options include:
CONFIG_SPIRAM_CACHE_LIBJMP_IN_IRAM: affects the functions
CONFIG_SPIRAM_CACHE_LIBMATH_IN_IRAM: affects the functions
CONFIG_SPIRAM_CACHE_LIBNUMPARSER_IN_IRAM: affects the functions
CONFIG_SPIRAM_CACHE_LIBIO_IN_IRAM: affects the functions
CONFIG_SPIRAM_CACHE_LIBTIME_IN_IRAM: affects the functions
CONFIG_SPIRAM_CACHE_LIBCHAR_IN_IRAM: affects the functions
CONFIG_SPIRAM_CACHE_LIBMEM_IN_IRAM: affects the functions
CONFIG_SPIRAM_CACHE_LIBSTR_IN_IRAM: affects the functions
strtok_r, and ``strupr.
CONFIG_SPIRAM_CACHE_LIBRAND_IN_IRAM: affects the functions
CONFIG_SPIRAM_CACHE_LIBENV_IN_IRAM: affects the functions
CONFIG_SPIRAM_CACHE_LIBFILE_IN_IRAM: affects the functions
CONFIG_SPIRAM_CACHE_LIBMISC_IN_IRAM: affects the functions
The exact amount of IRAM saved will depend on how much C library code is actually used by the application. In addition, the following options may be used to move more of the C library code into flash, however note that this may result in reduced performance. Be careful not to use the C library function allocated with
ESP_INTR_FLAG_IRAM flag from interrupts when cache is disabled, refer to IRAM-Safe Interrupt Handlers for more details. For these reasons, the functions
strlen are always put in IRAM.
Moving frequently-called functions from IRAM to flash may increase their execution time.
Other configuration options exist that will increase IRAM usage by moving some functionality into IRAM, usually for performance, but the default option is not to do this. These are not listed here. The IRAM size impact of enabling these options is usually noted in the configuration item help text.