GATE CSE 2005 | Question: 72

Question

Consider the following code fragment:
if (fork() == 0)
{
   a = a + 5;
   printf("%d, %p n", a, &a);
}
else
{
   a = a - 5;
   printf ("%d, %p n", a,& a);
}

Let $u,v$ be the values printed by the parent process and $x,y$ be the values printed by the child process. Which one of the following is TRUE?

• A. $u = x + 10  \text{ and } v = y$
• B. $u = x + 10 \text{ and } v != y$
• C. $u + 10 = x \text{ and } v = y$
• D. $u + 10 = x \text{ and } v != y$

Comments

yeh parent and child don't have some address.

---

After fork(), the parent and child processes initially share the same physical memory pages using the copy-on-write mechanism. When either process attempts to modify a shared page, the operating system creates a separate physical copy of that page for the modifying process. However, both processes continue to use the same virtual (logical) addresses for their variables. Therefore, although the parent and child have different physical memory after a write, the virtual address of a variable (as printed by &a in printf) remains the same in both processes, because user programs only see virtual addresses, not physical addresses.

---

This is how Address Remains the same 

Answer 1

•  

THIS MAY HELP YOU !!............

 

Answer 2

 

option c

Answer 3

 

---

Understanding Copy-on-Write in the Context of fork()

When a process calls fork(), the operating system creates a new process (child) by duplicating the memory space of the parent. However, to optimize performance, modern operating systems employ a technique known as Copy-on-Write (COW).

What is Copy-on-Write?

Copy-on-Write delays the actual copying of memory pages until one of the processes (parent or child) tries to modify a shared page. Initially, both processes share the same physical memory pages marked as read-only. When a process attempts to write to a shared page, a page fault is triggered. The OS then:

• Allocates a new page,

• Copies the contents of the original page to the new one,

• Updates the process’s page table to point to the new writable page.

This way, memory is conserved, and copying overhead is avoided unless absolutely necessary.

---

Code Under Consideration

if (fork() == 0) {
   a = a + 5;
   printf("%d, %p\n", a, &a);
} else {
   a = a - 5;
   printf("%d, %p\n", a, &a);
}

Analysis

Let’s break it down with Copy-on-Write in mind:

1. Before the fork(), there’s a variable a (assume it’s a global or stack variable).

2. After fork(), both parent and child share the same virtual address space, including variable a, using COW.

3. When either process tries to write to a, the OS creates a private copy for that process (due to COW), but the virtual address &a remains the same in both processes.

4. Therefore:

   • Both the parent and child will print different values of a (one does a+5, the other a-5),

   • But both will print the same address for &a.

So the correct option is:

(C) Both processes print different values, but the same address.

---

Resource

Further reading: Copy-on-Write in Operating System - Studytonight

---

 

Answer 4

Child will execute else part as it will be if(0) so it will be a-5 , parent will execute if part as it will be if(>0) so it will be a+5 so u = x+10 ...by fork call parent and child will have identical address space so v =y so answer is C

Answer 5

• So these virtual addresses are translations of physical addresses and doesn't represent the same physical memory space, to leave a more practical example we can do a test, if we compile and run multiple times a program that displays the direction of a static variable, such as this program.

  #include <stdio.h>
  
  int main()
  {
  static int a = 0;
  
  printf("%p\n", &a);
  
  getchar();
  
  return 0;
  }

  It would be impossible to obtain the same memory address in two different programs if we deal with the physical memory directly.

  And the results obtained from running the program several times are...

 

 

Source : Stackoverflow.

 

Answer 6

✅ Clean Explanation for the Question:

u + 10 = x because the parent subtracts 5 and child adds 5 to the same initial value of a.

So if a = 10, parent prints 5 and child prints 15, satisfying u + 10 = x.

✅ Hence, the correct option is: C. u + 10 = x and v = y.

Why v = y?

Even though parent and child modify the same variable a, they operate on separate copies of it because fork() creates a new process with its own memory space.

These copies are stored in different physical memory locations, but both processes receive the same virtual address for a.

📌 This virtual address is generated by the Operating System's Memory Management Unit (MMU).

Since C programs and users can only see and access virtual addresses, and the question does not mention physical memory, we consider only virtual addresses.

✅ So, in this question, the addresses of a appear the same, but the actual memory locations are different.

Therefore, the correct comparison is based on virtual addresses, and not physical ones.
 

Comments

Why we take logical Address not phyical address ??