Setting Stack Size and Heap Size in Cortex-M1 Vector Table

The Cortex-M1 vector table allows developers to configure the stack size and heap size for an application. Properly setting these values can optimize memory usage and prevent stack overflows or heap allocation failures. This article provides a step-by-step guide to setting the stack and heap size in the vector table for Cortex-M1 chips.

Overview of Cortex-M1 Vector Table

The vector table on Cortex-M1 processors contains the initial stack pointer value and heap base address and size values. These settings determine how much memory is allocated for the stack and heap when the application starts up. The vector table is located at the start of code memory and contains the following stack and heap related entries:

• Initial Stack Pointer Value – Sets the starting stack pointer address
• Heap Base Address – Base address for the heap in memory
• Heap Size Value – Defines the size of the heap in bytes

The initial stack pointer value sets where the stack begins in memory. The processor loads this value into the stack pointer register at reset. Having the stack pointer initialized early is critical for startup and exceptions. The heap base address and heap size values define the memory region used for dynamic memory allocation on the heap. The C library functions like malloc and free will allocate memory from this heap region.

Factors Influencing Stack and Heap Size

There are several factors that influence the ideal stack size and heap size for a Cortex-M1 application:

• Memory Usage of Functions: The stack must be large enough to handle the local variables and register saving for interrupts and function calls. Complex functions require more stack space.
• Interrupt Usage: Interrupt handlers will use stack space and can overflow a smaller stack. The stack size limits nested interrupts.
• Dynamic Memory Requirements: The heap size must be large enough to handle the maximum dynamic memory allocation needs.
• Available Memory: The size of available SRAM places a hard limit on the stack and heap size.
• Memory Fragmentation: Allow space between stack, heap, static allocations to prevent fragmentation.

Determining the optimal stack and heap size requires analyzing the target application code. The maximum stack usage can be estimated by looking at stack usage of functions and handlers. The heap requirements depend on the application’s dynamic allocation behavior. With these estimates, the stack and heap can be sized to fit within the total SRAM without fragmenting memory.

Setting the Initial Stack Pointer

The stack pointer defines the start of the stack in memory. It must be initialized early in the startup process so that exception handlers and system code can rely on a valid stack. The address for the initial stack pointer is set in the vector table. When configured properly, the processor will load this stack pointer address during the early startup sequence.

To set the initial stack pointer in the vector table:

1. Determine the end address for the stack – This is the start address plus the stack size.
2. Align the stack end address down to a 4-byte boundary.
3. Set the initial stack pointer to this aligned end address.

For example, if the stack is 1KB (0x400 bytes) and located at 0x20008000, the end address is 0x200083FF. Aligning this down to a 4-byte boundary gives 0x200083FC, which becomes the initial stack pointer value in the vector table.

It is important to align the stack properly to maintain 4-byte alignment for stack operations. Improper stack alignment can lead to hard faults on Cortex-M1 processors. The stack grows down from the end address, so the initial stack pointer is set to the aligned end address.

Setting the Heap Base and Size

The heap region provides memory for dynamic allocation and is defined by a base address and size parameter in the Cortex-M1 vector table. The heap base address sets the start of the heap memory region. The heap size defines the total size of the region in bytes.

To configure the heap:

1. Choose a heap region within the SRAM memory map, accounting for other memory allocations.
2. Set the heap base address to the start of this heap region.
3. Set the heap size value to the size of the heap region in bytes.

For example, to set a 1KB heap region at 0x20004000, the heap base address would be 0x20004000 and the heap size would be 0x400 bytes. This defines a 1KB heap region for the C library allocation functions.

The heap can be placed anywhere within the SRAM memory map as long as the base and size are configured correctly. Make sure no other code or data uses the same memory region. Also allow space between the heap and other allocations to prevent fragmentation issues.

Modifying the Vector Table

The Cortex-M1 vector table is typically defined within a startup file or in the linker script. To modify the stack and heap settings, edit these locations to update the values. For example: .vector_table : .word __initial_stack_pointer ; initial stack pointer value … .word __heap_base ; heap base address .word __heap_size ; heap size in bytes

The initial stack pointer, heap base address, and heap size symbols can be defined in the linker file or startup code to set the values. Make sure the linker script properly places the vector table at the start of code memory.

After changing the vector table, rebuild the application image to apply the new settings. The updated vector table will be flashed into the start of code memory. Validate the address and alignment of the stack and heap when debugging the application.

Tuning the Stack and Heap

The ideal stack and heap size will depend on the target application. Here are some tips for tuning these values:

• Start with conservative estimates for stack and heap sizes.
• Stress test the application to determine max stack usage.
• Profile dynamic memory allocation behavior.
• Iteratively reduce the stack and heap sizes until failures occur.
• Leave margin between stack, heap, and other allocations.

Tooling can help measure stack usage and dynamic memory requirements. ARM’s Memap tool can show stack usage across functions. Monitoring heap usage over time can identify peak allocation needs. This data can be used to optimize the stack and heap sizes, reducing to the smallest size that still prevents overflows or allocation failures.

Properly configuring the Cortex-M1 vector table stack and heap settings ensures the application has enough memory for its needs without excess. Utilizing tools to analyze stack and heap requirements can maximize memory usage and prevent low memory issues.