Garbage collection basics in Compiler Design - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to identify unreachable objects in a heap.

Compiler Design

unreachable_objects = [obj for obj in heap if obj not in [1]]

Drag options to blanks, or click blank then click option'

Avariables

Bstack

Cheap

Droots

Attempts:

3 left

💡 Hint

Common Mistakes

Confusing heap with roots

Using stack instead of roots

The roots set contains all objects directly accessible by the program. Objects not reachable from roots are considered unreachable.

2fill in blank

medium

Complete the code to mark reachable objects during garbage collection.

Compiler Design

def mark(obj):
    if obj not in marked:
        marked.add(obj)
        for ref in obj.[1]:
            mark(ref)

Drag options to blanks, or click blank then click option'

Areferences

Bchildren

Cpointers

Dlinks

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'children' which is not a standard term

Using 'links' which is ambiguous

Each object has references to other objects. We recursively mark all referenced objects as reachable.

3fill in blank

hard

Fix the error in the code to sweep unmarked objects from the heap.

Compiler Design

for obj in heap[:]:
    if obj not in [1]:
        heap.remove(obj)

Drag options to blanks, or click blank then click option'

Astack

Broots

Cmarked

Dvisited

Attempts:

3 left

💡 Hint

Common Mistakes

Removing objects not in roots (too broad)

Using stack which is unrelated here

Only objects not marked as reachable should be removed from the heap during the sweep phase.

4fill in blank

hard

Fill both blanks to implement reference counting update after object assignment.

Compiler Design

def assign(obj, new_ref):
    obj.ref_count [1] 1
    new_ref.ref_count [2] 1

Drag options to blanks, or click blank then click option'

A-=

B+=

C*=

D/=

Attempts:

3 left

💡 Hint

Common Mistakes

Increasing old ref count

Decreasing new ref count

When an object reference is replaced, the old object's reference count decreases and the new object's reference count increases.

5fill in blank

hard

Fill both blanks to create a dictionary comprehension that maps objects to their reference counts if count is greater than zero.

Compiler Design

ref_counts = {obj[1]: obj.ref_count : obj.ref_count for obj in heap if obj.ref_count [2] 0}

Drag options to blanks, or click blank then click option'

A.id

B:

C>

D==

Attempts:

3 left

💡 Hint

Common Mistakes

Using '==' instead of '>' in condition

Using ':' incorrectly in comprehension

The dictionary maps object IDs to their reference counts, but only includes objects with positive reference counts.

Practice

1. What is the main purpose of garbage collection in programming?

easy

A. To automatically free memory that is no longer used by the program

B. To speed up the execution of the program

C. To compile the program faster

D. To store data permanently on disk

Solution

1. Step 1: Understand what garbage collection does

   Garbage collection automatically frees memory that the program no longer uses, preventing memory waste.

2. Step 2: Compare options with this purpose

   Only To automatically free memory that is no longer used by the program describes this automatic freeing of unused memory, while others describe unrelated tasks.

3. Final Answer:

   To automatically free memory that is no longer used by the program -> Option A

4. Quick Check:

   Garbage collection = automatic memory freeing [OK]

Hint: Garbage collection frees unused memory automatically [OK]

Common Mistakes:

• Thinking garbage collection speeds up program execution
• Confusing garbage collection with compiling
• Believing garbage collection stores data permanently

2. Which of the following is a correct statement about garbage collection syntax in most programming languages?

easy

A. You declare garbage collection using gc start; in code

B. You must manually call a function named garbageCollect() to free memory

C. Garbage collection runs automatically without explicit syntax

D. Garbage collection is triggered by writing freeMemory() in the program

Solution

1. Step 1: Recall how garbage collection works in modern languages

   Most modern languages run garbage collection automatically without needing explicit calls or syntax.

2. Step 2: Evaluate each option

   Options B, C, and D suggest manual calls or commands that are not standard syntax; only A correctly states automatic operation.

3. Final Answer:

   Garbage collection runs automatically without explicit syntax -> Option C

4. Quick Check:

   Garbage collection = automatic, no manual calls [OK]

Hint: Garbage collection usually needs no manual commands [OK]

Common Mistakes:

• Assuming you must call garbage collection manually
• Looking for special syntax to start garbage collection
• Confusing garbage collection with memory free functions

3. Consider this pseudocode snippet:

var a = new Object()
var b = a
b = null
// Garbage collection runs here

Which object(s) will be collected by garbage collection?

medium

A. No objects will be collected because a still references the object

B. The object referenced by a and b

C. The object referenced by b only

D. Both a and b variables will be collected

Solution

1. Step 1: Analyze references to the object

   Initially, both a and b point to the same object. After b = null, only a references it.

2. Step 2: Determine if object is unreachable

   Since a still references the object, it is reachable and will not be collected.

3. Final Answer:

   No objects will be collected because a still references the object -> Option A

4. Quick Check:

   Object referenced = not collected [OK]

Hint: Object with any reference is not collected [OK]

Common Mistakes:

• Thinking object is collected when one reference is null
• Confusing variable collection with object collection
• Assuming variables themselves are garbage collected

4. Identify the error in this pseudocode related to garbage collection:

var x = new Object()
var y = x
x = null
// Garbage collection runs here
print(y.property)

What problem might occur?

medium

A. Syntax error due to missing garbage collection call

B. Runtime error because y is null

C. Garbage collector frees object causing y.property to fail

D. No error; object is still referenced by y

Solution

1. Step 1: Check references after x = null

   Even though x is null, y still references the object, so it remains reachable.

2. Step 2: Understand garbage collection behavior

   Garbage collection only frees objects with no references. Since y references the object, it won't be freed, so y.property is safe.

3. Final Answer:

   No error; object is still referenced by y -> Option D

4. Quick Check:

   Object referenced = no error [OK]

Hint: Object referenced by any variable is safe from collection [OK]

Common Mistakes:

• Assuming object is freed when one reference is null
• Expecting syntax error for missing manual garbage call
• Confusing variable null assignment with object deletion

5. In a program, you have a complex data structure where some objects reference each other in a cycle, but no external variables reference any of them. What will happen during garbage collection?

hard

A. Only some objects in the cycle will be collected, others remain

B. The cycle of objects will be collected because they are unreachable from outside

C. The cycle will never be collected because objects reference each other

D. Garbage collection will cause a runtime error due to the cycle

Solution

1. Step 1: Understand reachability in garbage collection

   Garbage collection frees objects unreachable from any external references, even if they reference each other.

2. Step 2: Apply this to cyclic references

   Since no external variables reference the cycle, the entire cycle is unreachable and will be collected.

3. Final Answer:

   The cycle of objects will be collected because they are unreachable from outside -> Option B

4. Quick Check:

   Unreachable cycles = collected [OK]

Hint: Unreachable cycles are collected despite internal references [OK]

Common Mistakes:

• Believing cycles prevent garbage collection
• Thinking only some objects in cycle are collected
• Expecting runtime errors from cycles