Stack vs heap in embedded context - Visual Side-by-Side Comparison

Concept Flow - Stack vs heap in embedded context

Start Program

↓

Initialize Stack

↓

Function Calls & Local Variables

↓

Push/Pop on Stack

↓

Initialize Heap

↓

Dynamic Memory Allocation

↓

Allocate/Free on Heap

↓

Program Ends

Program starts with stack setup for function calls and local variables, and heap setup for dynamic memory; stack grows/shrinks with calls, heap allocates/frees memory dynamically.

Execution Sample

Embedded C

void func() {
  int a = 10;
  int *p = malloc(sizeof(int));
  *p = 20;
  free(p);
}

This code shows local variable 'a' on stack and dynamic allocation of 'p' on heap, then freeing heap memory.

Execution Table

Step	Action	Stack State	Heap State	Notes
1	Enter func(), allocate 'a'	a=10 (top of stack)	empty	Local variable 'a' stored on stack
2	Call malloc(sizeof(int))	a=10	Allocated 4 bytes at addr X	Heap allocates memory for '*p'
3	Assign *p = 20	a=10	Memory at addr X = 20	Heap memory content updated
4	Call free(p)	a=10	Memory at addr X freed	Heap memory released
5	Exit func(), pop 'a'	stack empty	heap empty	Stack frame removed, heap memory freed

💡 Function ends, stack frame popped, heap memory freed

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
a	undefined	10	10	10	10	undefined
p	undefined	undefined	addr X	addr X	addr X	undefined
Heap Memory at addr X	empty	empty	allocated	20	freed	empty
Stack	empty	a=10	a=10	a=10	a=10	empty

Key Moments - 3 Insights

Why is the local variable 'a' stored on the stack and not on the heap?

Local variables like 'a' are stored on the stack because they have fixed size and lifetime tied to function calls, as shown in execution_table step 1 where 'a' is allocated on stack when func() starts.

What happens if we forget to free the heap memory allocated by malloc?

If we don't free heap memory (step 4), it remains allocated causing memory leaks, which is critical in embedded systems with limited memory.

Why does the stack grow and shrink automatically but heap requires manual management?

Stack grows/shrinks with function calls automatically (push/pop), but heap memory must be allocated and freed manually (steps 2 and 4), as heap is managed by programmer.

Visual Quiz - 3 Questions

Look at the execution_table at step 2, what happens to the heap?

A Stack allocates 4 bytes

B Heap memory is freed

C Heap allocates 4 bytes of memory

D Stack memory is freed

💡 Hint

Check the 'Heap State' column at step 2 in execution_table

At which step does the stack frame for 'a' get removed?

A Step 3

B Step 5

C Step 2

D Step 4

💡 Hint

Look at the 'Stack State' column and notes in execution_table

If we remove the free(p) call, what changes in the variable_tracker for heap memory?

A Heap memory remains allocated after final step

B Heap memory is freed as usual

C Stack memory increases

D Variable 'a' is stored on heap

💡 Hint

Refer to 'Heap Memory at addr X' row in variable_tracker after step 4

Concept Snapshot

Stack vs Heap in Embedded C:
- Stack stores local variables and function calls
- Stack grows/shrinks automatically with calls
- Heap stores dynamic memory allocated with malloc
- Heap requires manual allocation and free
- Embedded systems have limited memory, careful management needed

Full Transcript

In embedded C, the stack is used for local variables and function calls, growing and shrinking automatically as functions start and end. The heap is used for dynamic memory allocation with malloc and free, which must be managed manually. For example, in the code, variable 'a' is stored on the stack when func() is called, while memory for pointer 'p' is allocated on the heap. The heap memory must be freed to avoid leaks. The stack frame is removed when the function ends. This distinction is important in embedded systems where memory is limited and must be carefully managed.