Copy-on-write technique in Operating Systems - Step-by-Step Execution

Concept Flow - Copy-on-write technique

Process A and B share same memory page

↓

Process B tries to write to shared page

↓

OS detects write attempt

↓

OS creates a copy of the page for Process B

↓

Process B writes to its own copy

↓

Process A continues using original page

↓

Both processes have separate pages after write

Two processes share the same memory page until one tries to write, then the OS copies the page so each has its own.

Execution Sample

Operating Systems

Process A and B share page P
Process B writes to page P
OS copies page P to P_B
Process B writes to P_B
Process A uses original P

Shows how copy-on-write delays copying memory until a write happens.

Analysis Table

Step	Action	Memory State	Result
1	Process A and B share page P	P shared by A and B	No copy, memory shared
2	Process B attempts to write to P	P shared by A and B	Write detected, triggers copy
3	OS copies page P to P_B for Process B	P owned by A, P_B owned by B	Separate copies created
4	Process B writes to P_B	P unchanged, P_B modified	B's write isolated
5	Process A continues using original P	P unchanged	A unaffected by B's write
6	End	Separate pages for A and B	Copy-on-write complete

💡 Process B's write triggers copy, so both have separate pages after step 5

State Tracker

Memory Page	Start	After Step 3	After Step 4	Final
P (Process A)	Shared	Owned by A	Unchanged	Owned by A
P_B (Process B)	N/A	New copy created	Modified by B	Owned by B

Key Insights - 3 Insights

Why is memory not copied when processes first share the page?

Because both processes only read the page initially, so OS saves memory by sharing until a write occurs (see step 1 in execution_table).

What triggers the OS to make a copy of the memory page?

A write attempt by one process to the shared page triggers the OS to copy it (see step 2 and 3 in execution_table).

Does the original process's memory page change after the other process writes?

No, the original process keeps using the original page unchanged (see step 5 in execution_table).

Visual Quiz - 3 Questions

Look at the execution_table, at which step does the OS create a new copy of the memory page?

A Step 3

B Step 4

C Step 2

D Step 5

💡 Hint

Check the 'Action' and 'Result' columns in execution_table rows for step 3.

According to variable_tracker, what is the state of Process B's memory page after step 4?

A Shared with Process A

B New copy modified by Process B

C Unchanged original page

D No memory page assigned

💡 Hint

Look at the 'P_B (Process B)' row under 'After Step 4' in variable_tracker.

If Process B never writes to the shared page, what would happen according to the concept flow?

A Process A loses access to the page

B OS copies the page anyway

C Processes continue sharing the same page

D Both processes crash

💡 Hint

Refer to the first step in concept_flow where sharing continues until a write occurs.

Concept Snapshot

Copy-on-write delays copying shared memory pages until a write occurs.
Processes share pages to save memory.
When a write happens, OS copies the page for the writing process.
This keeps memory use efficient and isolated after writes.
Used in OS for process creation and memory management.

Full Transcript

Copy-on-write is a technique where two processes initially share the same memory page to save space. When one process tries to write to that page, the operating system detects this and creates a separate copy of the page for that process. This way, the writing process modifies its own copy, while the other process continues using the original page unchanged. This method avoids unnecessary copying until it is needed, making memory use more efficient. The execution steps show the shared state, the write attempt, the copying action, and the final separate pages for each process.

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