Memory allocation in embedded systems

Question

Linux/Unix systems often run on x86 CPU architecture which provides a MMU for memory mapping, but I guess embedded systems lack this, so no malloc and free.

I saw that ES programmers can create a big static buffer to reserve memory:

unsigned char mem[10240];

But I wonder how it works, where does the buffer start exactly, and how the C compiler can map variable definitions to actual memory locations on some platforms.

I have also seen such constants in ES headers (extracted from the ARM STM32L1xx):

#define SRAM_BASE ((uint32_t)0x20000000) /*!< SRAM base address in the alias region */

I understand that SRAM stands for "Static" RAM but does "base address" means the beginning of the memory area reserved to heap/stack access, so a programmer could allocate and free chunks of RAM using a pointer to this base address and a linked list of blocks ?

I saw some "homemade" implementations of malloc using various techniques, but the malloc I use in my system uses the mmap system call, which uses the MMU. — explogx
Also, ES implementations of malloc are hardware-dependent: it must use these base addresses constants for DMA since you don't have a MMU. — explogx
unsigned char *mem[10240]; is not probably typed as you'd want... Perhaps you meant unsigned char mem[10240]; — Antti Haapala
No. Accessing physical memory is not what is described by "Direct memory access". DMA is, simplified, accessing memory without using the CPU, e..g a peripheral storing larger chunks of data slowly and then only notifying CPU when done. — Yunnosch

Yunnosch Yunnosch · Accepted Answer · 2018-12-25T13:50:45

I get the impression that there are some misunderstandings related to this question. Let me try to sort them out.

The function malloc and free do not require an MMU.
The fact that you have seen one implementation using the MMU does not mean it is always needed.
While an MMU might make implementing easier and in case of a PMMU even postpone the failure of attempted mallocs (by using virtual memory), implementing those two functions on statically allocated variables is possible. Using appropriatly large arrays (as you mention) is a way to do so. I did so in at least two different cases, to accommodate immplementations of applications which use dynamic memory allocation.
Note that on embedded systems extended knowledge about the system behaviour is needed, in order to use appropriate algorithms and size to avoid running out of memory (usually caused or exarcerbated by fragementation). But for embedded system that knowledge is sometimes available.

Using such an array means that it is first allocated perfectly normally by the linker, like any other (large) variable.
The address is therefor determined by the linker, according to configuration and system attributes. One likely location is inside the BSS segment (global or static variables without specific value initialisation).

The last paragraph of your question is especially unclear and seems to switch between multiple topics.
Yes, SRAM is for static RAM. The "static" in that is however not related to any of the meanings according to C syntax. The "static" of SRAM refers to the hardware implementation of the memory. It is in contrast to dynamic RAM. Dynamic RAM is much cheaper than static RAM, it does however require regular refreshing. The refreshing is practically always handled by an MMU but I do not see any relation to the other case of MMU-need you mentioned. SRAM can keep its content just with power supply, DRAM loses content after quite short a time. SRAM therefor can be used in embedded systems to keep content across phases in which the CPU is practically dead, often referred to as "low power modes".

The term "base address" has many meanings. It can refer to e.g. the lowest address of an area used to allocate BSS variables, or the lowest address of an area used for dynamic memory management.

A progorammer allocates memory dynamically NOT by giving a pointer, it is done by asking for a pointer instead, which is the return value of e.g. a successful malloc attempt.

The implementation allocates dynamic memory inside a memory area available for specifically that purpose (which might be the mentioned large array). If memory is available (e.g. there are still blocks found in a linked list of free blocks), it returns an address inside one of them (which is of course followed by enough free space to accomodate the requested size) and keeps information on the remaining (if any) free memory (e.g. by inserting that now smaller space back into the linked list). If not enough memory is left anymore, the return value indicates failure.

Memory allocation in embedded systems

2 Answers