For real-time embedded systems, static or startup-only allocation is usually the simpler choice when predictable memory use and avoiding runtime allocation failures matter most. Heap allocation can still be appropriate when object lifetimes vary and reusing RAM is valuable—but only if the chosen allocator’s worst-case timing, fragmentation behavior, failure handling, and calling context meet the system’s requirements.
What static and heap allocation mean
Static allocation means the storage size and location are established before runtime. In an RTOS, that can include application-provided memory for a task, queue, or other kernel object. It does not mean every memory use in the whole program is static.
Heap allocation means requesting memory while the program runs, commonly through malloc or an RTOS-specific allocation API. It can make object creation simpler and allow storage from deleted objects to be reused. Arm’s learning material frames the distinction around whether memory needs are known at build time or acquired during execution.
Stack allocation is a separate concept: function-call storage usually has automatic lifetime and is constrained by stack capacity. It is not interchangeable with static storage or heap allocation.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
#1 Best Overall
How to choose for a real-time design
| Design condition | Likely direction | What to verify |
|---|---|---|
| Object sizes and the set of objects are known; predictable maximum RAM matters | Static or application-provided allocation | Check the link-time memory map, stack sizing, and whether all relevant subsystems follow the policy. |
| Objects are created before the scheduler or deadline-sensitive work starts, then remain for the system lifetime | Startup allocation can be reasonable | Confirm there are no later create/delete paths that allocate, and inspect the actual allocator. |
| Object lifetimes vary and reuse can materially reduce peak RAM | Heap allocation may fit | Establish worst-case allocation and free time, fragmentation behavior, exhaustion handling, and permitted call contexts. |
| Allocation would occur with preemption or interrupts disabled, or in another non-sleepable context | Do not call an allocator that may sleep there | Move allocation outside the critical context or use an API and design suited to that context. |
These are trade-offs, not a universal rule against heaps. Compare the actual allocator and usage pattern against the application’s timing and memory requirements. FreeRTOS itself documents multiple heap schemes and permits applications to provide their own allocation scheme; the API used to create an RTOS object does not, by itself, describe the allocator’s behavior.
FreeRTOS: static object creation versus dynamic creation
FreeRTOS provides static creation functions for tasks, software timers, queues, event groups, binary and counting semaphores, recursive semaphores, and mutexes. Examples include xTaskCreateStatic() and xQueueCreateStatic(); the application supplies the storage. Its static-versus-dynamic allocation guide explains the practical distinction:
- Static creation offers control over object placement, makes the maximum RAM footprint for those objects determinable at link time, and avoids allocation-failure handling for those objects.
- Dynamic creation generally requires fewer API parameters and allows storage from a deleted object to be reused. FreeRTOS also provides heap information functions.
Static creation does not guarantee that unrelated libraries or subsystems avoid runtime allocation. Likewise, choosing a dynamic creation function does not identify which heap scheme is configured. Check the project’s configSUPPORT_STATIC_ALLOCATION and configSUPPORT_DYNAMIC_ALLOCATION settings and review the actual creation calls.
Can a real-time system use a heap?
Yes, if the allocator and allocation schedule are compatible with the deadlines. One comparatively simple pattern is to allocate objects during initialization, before deadline-sensitive work begins, and retain them for the application’s lifetime.
Rank #3
FreeRTOS’s heap_1 illustrates why allocator details matter: it only allocates and does not free, and the FreeRTOS kernel guide describes its allocation behavior as deterministic and non-fragmenting. Those properties are specific to that scheme and pattern; they should not be generalized to heaps that repeatedly allocate and free differently sized objects. See the FreeRTOS kernel guide for the allocator discussion.
For any runtime allocation policy, define what happens if memory is exhausted. A failed allocation must have a deliberate response—such as refusing to start a nonessential feature or entering a defined fault path—not an assumption that memory will always be available.
Rank #4
Is heap allocation safe inside a real-time task?
It depends on both the allocator and the execution context. A deadline-sensitive path should not allocate or free memory unless the allocator’s worst-case behavior has been shown to fit the timing budget and the call is legal in that context. Average timing is not enough when a hard deadline depends on a bounded worst case.
Linux PREEMPT_RT provides a useful, platform-specific example: its documentation says allocation and deallocation APIs use locks that may sleep, so they must not be called where preemption is disabled. It recommends allocating outside the critical section. Linux PREEMPT_RT is not an MCU RTOS, so its API rules should not be copied directly to an embedded target; check the target’s allocator and context rules in the Linux real-time kernel documentation.
Recommended Free Tools
Quick Recap
A practical review checklist
- What is the maximum RAM footprint, including stacks and memory used outside the RTOS objects under review?
- Are object sizes and lifetimes known in advance, or do they vary enough that reuse reduces peak RAM?
- What are the allocator’s worst-case allocation and free times, and how were they established?
- Can the allocation pattern fragment the available memory before the system runs out?
- What happens on allocation failure, and is that response acceptable for the affected function?
- Can any allocation or free call occur in a deadline-critical, interrupt, preemption-disabled, or otherwise restricted context?
- For FreeRTOS, which static/dynamic creation APIs and heap implementation are enabled in the actual project configuration?
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
