Garbage collection basics in Compiler Design - Step-by-Step Execution

Concept Flow - Garbage collection basics

Program runs

↓

Allocate memory

↓

Use memory

↓

Is memory reachable?

No→Mark for collection

|Yes↓

Continue program

↓

Garbage collector runs

↓

Free unreachable memory

↓

Memory available for reuse

This flow shows how a program allocates and uses memory, then the garbage collector identifies unused memory and frees it for reuse.

Execution Sample

Compiler Design

1. Allocate object A
2. Allocate object B
3. Remove reference to A
4. Run garbage collector
5. Free unreachable objects

This example traces memory allocation, losing reference to an object, and garbage collection freeing that object.

Analysis Table

Step	Action	Memory State	Reachable Objects	Garbage Collected
1	Allocate object A	A allocated	A	None
2	Allocate object B	A, B allocated	A, B	None
3	Remove reference to A	A, B allocated	B	None
4	Run garbage collector	A, B allocated	B	A marked for collection
5	Free unreachable objects	B allocated	B	A freed

💡 Garbage collector frees object A because it is no longer reachable

State Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5
Memory Objects	None	A	A, B	A, B	A, B	B
Reachable Objects	None	A	A, B	B	B	B
Garbage Collected	None	None	None	None	A	A

Key Insights - 2 Insights

Why is object A not immediately freed when its reference is removed?

Because the garbage collector runs separately after program steps, object A remains allocated until the collector runs (see steps 3 and 4 in execution_table).

What does 'reachable' mean in garbage collection?

Reachable means the program can still access the object through some reference. Only unreachable objects are collected (see Reachable Objects column).

Visual Quiz - 3 Questions

Look at the execution_table at step 3, which objects are reachable?

A No objects

B Only object B

C Objects A and B

D Only object A

💡 Hint

Check the 'Reachable Objects' column at step 3 in execution_table

At which step does the garbage collector mark object A for collection?

A Step 4

B Step 2

C Step 3

D Step 5

💡 Hint

Look at the 'Garbage Collected' column in execution_table

If the reference to object A was never removed, what would happen in step 5?

A Object B would be freed

B Object A would be freed

C Object A would remain allocated

D Both objects would be freed

💡 Hint

Refer to the 'Reachable Objects' and 'Garbage Collected' columns in execution_table

Concept Snapshot

Garbage collection automatically frees memory no longer used.
Objects are 'reachable' if program can access them.
Unreachable objects are marked and then freed.
This prevents memory leaks and manual free errors.
Garbage collector runs periodically, not instantly.
Reachability determines what is collected.

Full Transcript

Garbage collection basics show how programs allocate memory for objects and use them. When an object is no longer reachable by the program, it becomes garbage. The garbage collector identifies these unreachable objects and frees their memory so it can be reused. This process happens separately from the main program flow. For example, if object A is allocated and then its reference is removed, it remains in memory until the garbage collector runs and frees it. Reachability means the program can still access the object through some reference. Only unreachable objects are collected. This automatic memory management helps prevent memory leaks and errors from manual memory handling.