Proper size of the stack is important. It must be small enough to prevent memory wastage and large enough to accommodate real-time application requirements.
The ways to determine the size to allocate are-
Browsing for stack sizes through the Dalvik source history:
API 3 (Android 1.5) = 8KB
API 4-10 (Android 1.6 – Android 2.3.7) = 12KB
API 14-17 (Android 4.0 – Android 4.2.2) = 16KB
Garbage collection on the stack – The life span of variables on the stack is limited to the duration of the function. As soon as the function returns, the used stack memory will be freed.
Multi-Task Stack Sharing (MTSS) scheme
MTSS is a multi-task stack sharing technique, that grows the stack of a particular task into other tasks in the system after it has overflown its bounds. A possible configuration to use MTSS effectively is to deliberately reduce the memory provided to each task to below what it needs, and the deficit is recovered from stacks of other tasks. It helps to reduce the physical memory needed for an embedded system without reducing its reliability.
Real-time performance of the heap is not deterministic. Memory allocation time depends on such factors as previous use and the requested data space size. So, minimizing heap usage is a must in small embedded systems.
Private-Shared-Anonymous Paging (PSAP) Algorithm
The PSAP algorithm separates the physical memory space into several blocks. It is used for allocating memory pages in interactive real-time systems.
Each interactive real-time task can create a private-reserve block where pages are never stolen by other tasks. There is also a shared-reserve block where pages are shared by all interactive real-time tasks but are never stolen by best-effort tasks.
The rest of memory space, which is categorized into neither a private- nor a shared-reserve block, is called an anonymous memory block where any tasks are allowed to get pages.
Fixed-Size Blocks Allocation/Memory Pool Allocation
Uses free list of fixed-size blocks of memory, usually all same size. It works well for simple embedded systems where no large objects need to be allocated. It has a very low overhead, which results in improved performance for frequent allocation/deallocation. However, it can suffer from fragmentation.
Android does not use virtual memory. Virtual memory hardware leads to increased energy usage, area cost, and design complexity. Also, the possibility of Translation Lookaside Buffer (TLB) misses is detrimental to real-time guarantees.
Lacking virtual memory, the system will encounter a fatal error if its memory footprint exceeds the physical memory by even one byte.
Global – Size of the global segment is fixed at compile time.
Stack – Grows at run time. Estimation of maximum size s done by the compiler by measuring the stack usage of the longest path in the call graph from main() to any leaf procedure.
Stack size estimation from call graph at compile time fails in case of –