Пролог

В этом тексте я написал про то как наблюдать за расходованием стековой памяти прямо во время исполнения прошивки на микроконтроллере.

Терминология

RAM память — оперативная память в которой хранятся глобальные переменные.

Стек — Часть RAM памяти. В стеке хранятся локальные переменные, адрес возврата, значения регистров процессора. Обычно стек растет от большего адреса к меньшему адресу. При вызове прерываний в стек сохраняется регистровый файл процессора.

Стековый кадр — часть RAM памяти на стеке, которая образуется при вызове Си‑функции. В стековом кадре хранятся аргументы функции, локальные переменные данной функции и адрес возврата.

компоновщик (Linker) — консольная утилита, которая из множества объектных файлов склеивает один монолитный *.elf файл с финальной программой.

Реализация технологии раскраски стека

В микроконтроллерных прошивках вся RAM память делится на область глобальных переменных, стек и кучу. Надо отметить, что стек это динамическая часть памяти. При этом по умолчанию не существует никаких ограничений на бесконтрольное разрастание стека. В связи с этим, задача слежения за переполнением стека целиком и полностью ложится на плечи программиста. Следить за переполнением стека можно по-разному.

В этом тексте поговорим о раскраске стека.

Как можно заметить, в процедуре Reset_Handler сразу после инициализации регистра указателя на верхушку стека происходит обнуление стековой RAM памяти. Это делает процедура LoopFillZero_STACK

    ldr        r0, =0xE000ED08
    ldr        r1, =__vector_table
    str        r1, [r0]

    /* Initialize the stack pointer */
    ldr     r0,=__Core0_StackTop
    mov     sp,r0   ; sp=r13 

    /* Clear Stack */
    ldr r2, =__Core0_StackLimit
    ldr r4, =__Core0_StackTop
    movs r3, #0
    b LoopFillZero_STACK

FillZero_STACK:
    str  r3, [r2]
    adds r2, r2, #4

LoopFillZero_STACK:
    cmp r2, r4                   /* Compare (immediate) subtracts an immediate value from a register value. */
    bcc FillZero_STACK           /*branch if carry clear  */

Переменные __Core0_StackTop и __Core0_StackLimit определяются компоновщиком в скрипте компоновщика. Они содержат адрес начала и условного конца стековой памяти.

    .stack_dummy :
    {
        . = ALIGN(8);
        __Core0_StackLimit = .;
        . += STACK_SIZE;
        . = ALIGN(8);
        __Core0_StackTop = .;
    } > DTCM_STACK
    

Как же понять в каком направлении у нас растет стековая память? Самое простое это написать функцию которая сама и ответит на этот вопрос.

static bool stack_dir(int32_t* main_local_addr) {
    bool res = false;
    int32_t fun_local = 0;
    if(((void*)main_local_addr) < ((void*)&fun_local)) {
        LOG_INFO(SYS, "Stack grows from small addr to big addr -> ");
    } else {
        LOG_INFO(SYS, "Stack grows from big addr to small addr <- "); /*hangOn here*/
    }
    return res;
}

bool explore_stack_dir(void) {
    bool res = false;
    int32_t main_local = 0;
    res = stack_dir(&main_local);
    return res;
}

У меня на микроконтроллере эта функция сообщает, что при увеличении стека вызова функций адреса локальных переменных уменьшаются. Значит стек растет вниз.

В процессоре ARM Cortex-M стек растет от большего адреса к меньшему. Вот так.

Поэтому считать израсходованный стек можно определив соотношение непрерывных нулей к ненулевым значениям в стековой памяти.

Сам стек мы будет измерять при помощи функции core_stack_used. Задача сводится к подсчету количества нулей в массиве.

bool array_max_cont(const uint8_t* const arr, 
                    uint32_t size, 
                    uint8_t patt, 
                    uint32_t* max_cont_patt) {
    bool res = false;
    if(arr && (0 < size) && max_cont_patt) {
        res = true;
        uint32_t cur_cont_pat = 0;
        uint32_t max_cont_pat = 0;
        uint8_t prev_elem = 0xFF;
        uint32_t i = 0;
        for(i = 0; i < size; i++) {
            if(patt == arr[i]) {
                cur_cont_pat++;
                if(prev_elem != arr[i]) {
                    cur_cont_pat = 1;
                }
            } else {
                cur_cont_pat = 0;
            }
            prev_elem = arr[i];
            max_cont_pat = MAX(max_cont_pat, cur_cont_pat);
        }
        *max_cont_patt = max_cont_pat;
    }
    
    return res;
}

float core_stack_used(const uint32_t top_stack_val,
                      const uint32_t exp_size) {
    float precent = 0.0f;
    LOG_DEBUG(CORE,"StackTop:0x%08X,Size:%u Byte" , top_stack_val, exp_size);
#ifdef HAS_ARRAY_EXT
    if(exp_size) {
        uint32_t busy = 0;
        uint32_t max_cont_patt = 0;
        bool res = array_max_cont((uint8_t*)top_stack_val - exp_size, 
                                  exp_size, 0, &max_cont_patt);
        if(res) {
            busy = exp_size - max_cont_patt;
            precent = ((float)(100 * busy)) / ((float)exp_size);
        }
    }
#endif
    return precent;
}

extern void __Core0_StackTop;
extern void __Core0_StackLimit;

float core_stack_used_get(void) {
    uint32_t exp_size =  &__Core0_StackTop - &__Core0_StackLimit;
    float stack_used = core_stack_used((uint32_t) &__Core0_StackTop, exp_size);
    LOG_DEBUG(CORE, "StackUsed:%s", FloatToStr(stack_used,2));
    return stack_used;
}

Далее надо в супер цикле периодически вызывать функцию core_stack_monitor_proc

bool core_stack_monitor_proc(void) {
    bool res = false ;
    float stack_used=core_stack_used_get();
    if(80.0<stack_used){
        LOG_ERROR(CORE, "StackUsed80%%+:%s", FloatToStr(stack_used,2));
        res = false ;
    }else{
        if(70.0<stack_used){
            LOG_WARNING(CORE, "StackUsed,70%%+:%s", FloatToStr(stack_used,2));
            res = false ;
        }else{
            res = true;
        }
    }
    return res ;
}

Вот пожалуй, и все изменения, которые следует внести в прошивку, чтобы заработала диагностика стека.

Отладка

Что ж, вот мы написали в коде периодическую проверку степени заполнения стековой памяти. Настало время как-н загрузить процессор. Это можно провернуть при помощи вызова специально добавленной рекурсивной функции. Для этого у меня в прошивки есть UART-CLI команда try stack , вызывающая функцию try_recursion.

static bool call_recursion(uint32_t stack_top_addr, 
                           uint32_t cur_depth, 
                           uint32_t max_depth, 
                           uint32_t* stack_size) {
    bool res = false;
    if(cur_depth < max_depth) {
        res = call_recursion(stack_top_addr, cur_depth + 1, 
                             max_depth, stack_size);
    } else if(cur_depth == max_depth) {
        uint32_t cur_stack_use = stack_top_addr - ((uint32_t)&res);
        *stack_size = cur_stack_use;
        res = true;
    } else {
        res = false;
    }
    return res;
}

bool try_recursion(const uint32_t stack_top_addr, 
                   const uint32_t max_depth, 
                   uint32_t* const stack_size) {
    bool res = false;
    res = call_recursion(stack_top_addr, 0, max_depth, stack_size);
#ifdef HAS_LOG
    LOG_INFO(CORE, "Depth:%u,StackSize:%u,byte", max_depth, *stack_size);
#endif
    return res;
}

В данной сборке уже при вызове с аргументом 50 вложений со стороны главной консоли управления прошивкой появляются первые предупреждения, что стек перевалил за 70%.

А при 60 вызовах функциями вложенных функций появляются сообщения, что превышено 80% выделенного компоновщиком стека.

Это красное сообщение в логе является настоятельным сигналом к тому, что следует пересобрать прошивку с другими конфигами компоновщика для минимального размера стека, либо и вовсе крепко переработать всю компьютерную программу.

В случае многоядерного микроконтроллера всё аналогично, только для каждого ядра в отдельности следует создать конфиг для каждого ядра в котором надо указать адрес начала стека и его размер. А алгоритм вычисления тот же самый.

Итог

Удалось реализовать в ARM Cortex-M прошивке автоматическую проверку процентного соотношения заполнения стековой RAM памяти. Это даёт ценнейшую метрику при разработке программного обеспечения. Достаточно теперь прогнать модульные тесты, посмотреть на заполнения стека и выделить большее количество в новом релизе прошивки по мере надобности.

Сокращения

Ссылки

Вопросы

--Как сделать так, чтобы при выходе из стекового кадра происходило обнуление освободившегося интервала RAM памяти?