ESP32 Performance Optimization Strategies: Execution Efficiency Analysis

In ESP32 development, execution efficiency analysis is a core aspect of performance optimization, aimed at identifying code bottlenecks through quantitative methods and optimizing them accordingly. The following are execution efficiency analysis strategies based on the characteristics of the ESP32 and practical project experience, covering performance testing methods, algorithm optimization, compiler configuration, and task scheduling:

1. Performance Testing and Analysis Tools

1.1 High-Precision Timer (<span>esp_timer</span>)

The ESP32 has a built-in high-precision timer (with a resolution of up to 10 nanoseconds) that can be used to measure the execution time of code segments:

#include <esp_timer.h>

uint64_t start_time = esp_timer_get_time();
// Code segment to be measured
uint64_t end_time = esp_timer_get_time();
printf("Execution time: %lld us\n", (end_time - start_time) / 1000);
  • Applicable Scenarios Measure the execution time of function calls, loops, and critical algorithms.
  • Example Measure the call frequency of <span>i2s_write</span> during audio playback (see knowledge base [2]).

1.2 FreeRTOS Task Analysis

Use <span>vTaskGetInfo()</span> and <span>uxTaskGetSystemState()</span> to obtain task status:

TaskStatus_t task_status;
vTaskGetInfo(NULL, &task_status, pdTRUE, eInvalid);
printf("Task %s used %d bytes of stack.\n", task_status.pcTaskName, task_status.usStackHighWaterMark);
  • Purpose Analyze CPU usage, stack usage, and scheduling delays of tasks.
  • Optimization Direction Adjust task priority or core allocation (see knowledge base [1] and [7]).

1.3 Memory and Heap Analysis

Monitor heap memory fragmentation and usage with <span>heap_caps_get_info()</span>:

heap_caps_heap_info_t info;
esp_heap_caps_get_info(&info, MALLOC_CAP_DEFAULT);
printf("Total free: %d, Largest free block: %d\n", info.total_free_bytes, info.largest_free_block);
  • Problem Location Performance degradation caused by frequent dynamic memory allocation (see knowledge base [3]).

2. Algorithm and Code Optimization

2.1 Replacing Inefficient Algorithms

  • Recursion vs Iteration Replace recursive algorithms (e.g., Fibonacci sequence) with iterative or dynamic programming (see knowledge base [4]). 
    // Dynamic programming optimization for Fibonacci sequence
int fibonacci(int n) {
    int fib[n + 1];
    fib[0] = 0; fib[1] = 1;
    for (int i = 2; i <= n; i++) {
        fib[i] = fib[i-1] + fib[i-2];
    }
    return fib[n];
}
  • Complexity Optimization Reduce nested loops and avoid redundant calculations (see knowledge base [1]).

2.2 Data Structure Optimization

  • Packed Structs Align memory layout to reduce padding bytes. 
    #pragma pack(1)
typedef struct {
    uint16_t x;
    uint8_t y;
} CompactData;
#pragma pack()
  • Pre-allocated Buffers Statically allocate fixed-size buffers (see knowledge base [3]).

2.3 Reducing Redundant Operations

  • Avoid Blocking Calls Use non-blocking logic (e.g., state machines).
  • Inline Critical Functions Use the <span>inline</span> keyword for small functions that are called frequently. 
    inline void fast_gpio_set(int pin) {
    GPIO_OUT_W1TS_REG(GPIO_PORT) |= BIT(pin);
}

3. Compiler and Hardware Acceleration

3.1 Compiler Optimization Options

  • Optimization Level Select <span>-O2</span> (balance between performance and compilation time) or <span>-O3</span> (aggressive optimization) in <span>menuconfig</span>.
  • Hardware Acceleration Enable DSP instruction set (<span>CONFIG_DSP</span>) or SIMD optimizations (see knowledge base [4]). 
    # menuconfig path
Component config -> ESP32-specific -> Enable DSP instructions

3.2 Utilizing Hardware Features

  • DMA Transfers Reduce CPU interrupt overhead (e.g., I2S, SPI data transfers, see knowledge base [2]).
  • Direct Register Access Replace library function calls (see knowledge base [1]). 
    // Set GPIO 13 to high (direct register operation)
GPIO_OUT_W1TS_REG(GPIO_PORT) |= BIT(13);

4. Task Scheduling and Concurrency Optimization

4.1 Multi-core Task Allocation

  • Core Isolation Bind high-priority tasks to separate cores (Core 0 or Core 1). 
    xTaskCreatePinnedToCore(task_function, "TaskName", 2048, NULL, 5, NULL, 1); // Core 1
  • Load Balancing Avoid two cores competing for shared resources (e.g., global variables).

4.2 Interrupt and Priority Optimization

  • Increase Critical Interrupt Priority Ensure real-time tasks (e.g., touchscreen response) are prioritized (see knowledge base [6]).
  • Reduce Interrupt Nesting Avoid performing complex operations in ISRs.

5. Typical Optimization Cases

5.1 Audio Stream Playback Optimization

  • Problem Sending samples one by one leads to CPU usage as high as 65%.
  • Solution
  1. Use batch sending techniques (transmit 16 frames of audio data at once).
  2. Enable DMA transfers to reduce CPU intervention.
  3. Optimize buffer size (64 bytes/frame).
  • Result CPU usage reduced to 32%, performance improved by 50% (see knowledge base [2]).

    • 5.2 Multi-device Monitoring System Optimization

    • Problem BLE connections cause frequent system restarts.
    • Solution
    1. Disable PSRAM (enabled by default on ESP32-S3).
    2. Switch to UART connections (Victron SmartShunt).
    3. Simplify BMS configuration (remove redundant monitoring items).
  • Result ESP32 Devkit V1 can stably run 3 BMS devices (see knowledge base [1] and [7]).

    • 6. Considerations

    • Balance Performance and Stability Over-optimization may lead to code complexity or hardware instability (e.g., PSRAM configuration issues).
    • Testing and Validation Use <span>esp_timer_get_time()</span> and <span>heap_caps_get_info()</span> to verify optimization effects.
    • Documentation and Comments Record key optimization points for future maintenance.

    Through the above strategies, developers can systematically analyze the execution efficiency bottlenecks of the ESP32 and achieve performance breakthroughs through algorithm optimization, hardware acceleration, and task scheduling adjustments. In practical applications, optimization directions should be chosen based on specific scenarios.

    ESP32 Development Board Three Days to Master Microcontrollers Arduino Development Board

    STM32 Development Board

    Leave a Comment