1. Embedded Real-Time Systems
Memory management
Lecturer
Department
University

2. Outline Memory types and virtual memory
Separate vs common memory spaces
Memory management in RTOS

3. Same code, but what about the data???
Tasks and data
Task is not code
Two tasks can be executing the same code simultaneously
Think of it as an execution thread running through the code
Task 1
Task 2
int x;
int Func() {
int y;
y = y + 1;
x = x + 1;
... }
Same code, but what about the data???

4. Recall from computer architecture…
CPU registers
Program counter (address of the currently executing instruction)
Data and address registers
Main memory. Depending on the usage, usually subdivided into
code (read only)
data (read/write)
stack (function returns + variables)
heap (dynamically allocated data)
int x;
int Func() {
int y;
int* buf = malloc(…);
y = y + 1;
x = x + 1;
... }
*buf

5. Stack memory Stack memory – LIFO CPU Function return addresses
Local function variables
CPU
Stack pointer
int FuncB() {
int Y;
...
return; }
B allocates memory for Y
B is called Y
int FuncA() {
int X;
...
FuncB();
return; }
ret.addr. for B X
A allocates memory for X
ret.addr. for A
A is called

6. More memories… Virtual memory:
CPU hardware provides mapping between virtual and physical addresses
Virtual memory
Physical memory
1000:
2000:
3000:
...
9000:
1000:
2000:
3000:
...
9000:
Address translation
External
storage
(hard disk)

7. Memory spaces Memory mapping defines memory space Memory mapping 1
Having different memory spaces for different tasks can be used to isolate tasks from each other
Virtual memory space 1
Virtual memory space 2
Physical memory
1000:
2000:
3000:
...
9000:
1000:
2000:
3000:
...
20000:
1000:
2000:
3000:
...
9000:
Memory mapping 1
Memory mapping 2

8. Memory spaces (contd.)
Memory protection can also be used to isolate tasks even when they use the same memory mapping
Virtual memory space 1
Virtual memory space 2
Physical memory
1000:
2000:
3000:
...
9000:
1000:
2000:
3000:
...
20000:
1000:
2000:
3000:
...
9000:
Memory mapping
Memory mapping

9. Task context Each task has its own CPU environment – context
state of the CPU (registers)
state of memory management unit (address translation and protection table) – if virtual memory is used
Task context saved in a task control block (TCB)
OS-specific data: I/O assignments for standard input/output/error
stack – where task stores its dynamic variables and function calls
...

10. Memory management in RTOS
RTP 3
Process heap
Process code
Task
...
Real-time processes
OS kernel
RTP 2
Process heap
Process code
Task
...
RTP 1
Process heap
Process code
Task
...
RTOS kernel environment
...
App. code
App. code
Task
...
Task
Tasks in each RTP run in a memory space separate from tasks in other RTPs and from kernel tasks
RTOS code
Kernel
heap
Board support package

11. Same vs separate memory spaces
Unix/Windows/RTOS RTPs
Process 1 mem. space
Process 2 mem. space
data:
data:
global vars: x
stack: y
global vars: x
stack: y
code:
code:
int x;
int Func() {
int y;
y = y + 1;
x = x + 1;
... }
int x;
int Func() {
int y;
y = y + 1;
x = x + 1;
... }
Task 1
Task 2
PC1
PC2

12. Same vs separate memory spaces
Common mem. space
RTOS kernel
TCB1:
TCB2:
stack: y
stack: y
data:
global vars: x
What about y?
code:
int x;
int Func() {
int y;
y = y + 1;
x = x + 1;
... }
Task 1
Task 2
PC1
PC2

13. Comparing memory models
Inter-task communications
Task switching overheads
Concurrent code execution
Hardware support
Software debugging and testing
System stability

14. RTOS vs Windows/Unix Same Different
Real time process = Windows/Unix process
Task in RTP = Thread in Windows/Unix
Different
RTOS schedules tasks across RTPs
Deterministic real-time behaviour
Windows/Unix shares CPU between processes
Threads are scheduled within each process separately
RTOS does not use address translation and loads whole processes into memory before execution
Fast task switching
Compatible with CPUs without MMU (no memory protection though!)
Deterministic memory access time

15. Summary Virtual memory and task context
Comparison of separate and common memory models
Comparison of RTOS and Windows/Unix memory management