Copy-on-write technique in Operating Systems - Mini Project: Build & Apply

Understanding Copy-on-write Technique

📖 Scenario: Imagine you are managing memory in an operating system. You want to efficiently handle situations where multiple processes share the same data but might change it later. This is where the copy-on-write technique helps save memory and improve performance.

🎯 Goal: Build a simple step-by-step explanation and example of the copy-on-write technique using a dictionary to represent shared data and how it changes when a write occurs.

📋 What You'll Learn

Create an initial shared data dictionary with exact key-value pairs

Add a flag variable to indicate if the data is shared

Implement the copy-on-write logic to create a copy only when a write happens

Complete the example by updating the data and changing the shared flag accordingly

💡 Why This Matters

🌍 Real World

Copy-on-write is used in operating systems to optimize memory usage when multiple processes share the same data but may modify it later.

💼 Career

Understanding copy-on-write helps in roles related to system programming, OS development, and performance optimization.

1

DATA SETUP: Create the initial shared data dictionary

Create a dictionary called shared_data with these exact entries: 'file1': 'contentA', 'file2': 'contentB', and 'file3': 'contentC'.

Operating Systems

# Create the shared_data dictionary with exact entries
# Your code here

Hint

Use curly braces to create a dictionary with the given keys and values.

2

CONFIGURATION: Add a flag to indicate shared status

Add a boolean variable called is_shared and set it to True to indicate that the data is currently shared.

Operating Systems

shared_data = {'file1': 'contentA', 'file2': 'contentB', 'file3': 'contentC'}
# Add the is_shared flag set to True
# Your code here

Hint

Use a simple variable assignment to create the flag.

3

CORE LOGIC: Implement copy-on-write behavior

Write code that checks if is_shared is True. If so, create a copy of shared_data called private_data and set is_shared to False. Use the copy() method of the dictionary.

Operating Systems

shared_data = {'file1': 'contentA', 'file2': 'contentB', 'file3': 'contentC'}
is_shared = True
# Implement copy-on-write logic
# Your code here

Hint

Use an if statement to check the flag and then copy the dictionary.

4

COMPLETION: Update the private copy and finalize

Update the private_data dictionary by changing the value of 'file2' to 'contentB_modified'. This simulates writing to the data after copying.

Operating Systems

shared_data = {'file1': 'contentA', 'file2': 'contentB', 'file3': 'contentC'}
is_shared = True
if is_shared:
    private_data = shared_data.copy()
    is_shared = False
# Update private_data for file2
# Your code here

Hint

Use dictionary key assignment to update the value.

Practice

1. What is the main idea behind the copy-on-write technique in operating systems?

easy

A. Data is copied only when it is modified, not when initially shared

B. Data is copied immediately when a process is created

C. Data is never copied, only referenced

D. Data is copied multiple times to improve speed

Solution

1. Step 1: Understand the purpose of copy-on-write

   Copy-on-write delays copying data until a modification is made, saving resources.

2. Step 2: Compare options with the concept

   Only Data is copied only when it is modified, not when initially shared correctly states that copying happens only on modification, not immediately.

3. Final Answer:

   Data is copied only when it is modified, not when initially shared -> Option A

4. Quick Check:

   Copy-on-write = Copy on modification [OK]

Hint: Copy happens only when data changes, not before [OK]

Common Mistakes:

• Thinking data copies immediately on sharing
• Believing data is never copied
• Assuming multiple copies improve speed

2. Which of the following best describes when a copy is made in a copy-on-write system?

easy

A. When the original data is read

B. When the data is modified

C. When the system boots

D. When the data is deleted

Solution

1. Step 1: Identify the trigger for copying in copy-on-write

   Copy-on-write means copying happens only when data is changed or written to.

2. Step 2: Match the correct event

   Only When the data is modified correctly states copying occurs on modification.

3. Final Answer:

   When the data is modified -> Option B

4. Quick Check:

   Copy-on-write triggers on modification [OK]

Hint: Copy only on write, not on read [OK]

Common Mistakes:

• Confusing read with write triggers
• Thinking copy happens at system start
• Assuming copy on deletion

3. Consider a process creation using copy-on-write. If the parent process has 100MB of memory, and the child process is created but does not modify any data, how much memory is used by both processes together?

medium

A. 0MB

B. 200MB

C. 50MB

D. 100MB

Solution

1. Step 1: Understand memory sharing in copy-on-write

   Initially, both processes share the same memory pages without copying.

2. Step 2: Calculate total memory usage

   Since no modifications occur, memory is shared, so total used is 100MB, not doubled.

3. Final Answer:

   100MB -> Option D

4. Quick Check:

   Shared memory means total = original size [OK]

Hint: No changes mean no extra memory used [OK]

Common Mistakes:

• Assuming memory doubles immediately
• Thinking child process uses zero memory
• Confusing copy-on-write with full copy

4. A system uses copy-on-write for file snapshots. A snapshot is taken, but later the original file is modified. What is the likely error if the snapshot also changes unexpectedly?

medium

A. Copy-on-write was not properly implemented, causing shared data to change

B. Snapshot was created after modification

C. The file system does not support snapshots

D. The snapshot was deleted accidentally

Solution

1. Step 1: Analyze snapshot behavior with copy-on-write

   Snapshots should remain unchanged because copy-on-write protects original data by copying on modification.

2. Step 2: Identify cause of snapshot changing

   If snapshot changes, it means copy-on-write failed and data was shared incorrectly.

3. Final Answer:

   Copy-on-write was not properly implemented, causing shared data to change -> Option A

4. Quick Check:

   Snapshot changes mean copy-on-write failure [OK]

Hint: Snapshot changes mean copy-on-write error [OK]

Common Mistakes:

• Assuming snapshot created after modification
• Blaming unsupported file system without evidence
• Confusing deletion with modification

5. In a system using copy-on-write, a parent process forks a child. The child modifies a small 1MB part of a 500MB memory space. How much additional memory is used after the modification?

hard

A. 500MB

B. 501MB

C. 1MB

D. 0MB

Solution

1. Step 1: Understand copy-on-write memory allocation on modification

   Only the modified part is copied, so only 1MB is newly allocated.

2. Step 2: Calculate total additional memory used

   The rest of the 499MB remains shared, so additional memory is exactly 1MB.

3. Final Answer:

   1MB -> Option C

4. Quick Check:

   Copy-on-write copies only changed data [OK]

Hint: Only changed data uses extra memory [OK]

Common Mistakes:

• Assuming entire memory is copied
• Adding modified size to total incorrectly
• Thinking no memory is used on modification