This question asks us to analyze the output of two C programs, P1 and P2, which use the fork() system call in a UNIX/Linux environment. The fork() system call is fundamental for process creation.

Understanding the fork() System Call

The fork() system call creates a new process, called the child process, which is an almost exact copy of the calling process (the parent process). After the fork() call, both the parent and child processes execute the code starting from the statement immediately following the fork() call. The key difference is the return value of fork():

• In the parent process, fork() returns the Process ID (PID) of the child process.
• In the child process, fork() returns 0.
• If fork() fails, it returns -1 (the question states it never fails).

Each time a process executes a fork(), the number of processes doubles at that point in the code, as both the original process and the newly created child process continue execution.

Analyzing C Program P1 Execution with fork()

Program P1 has three consecutive fork() calls followed by a Printf("Happy\n") statement. Let's trace the number of processes executing the code:

1. Initially, there is 1 process (the parent process).
2. After the first fork(), 1 new child process is created. Now there are 2 processes (1 parent + 1 child) executing the code after the first fork().
3. After the second fork(), both of the existing 2 processes execute this fork(), each creating a new child. This adds 2 new children (1 new child from parent, 1 new child from the first child). Now there are $2 \times 2 = 4$ processes executing the code after the second fork().
4. After the third fork(), all 4 existing processes execute this fork(), each creating a new child. This adds 4 new children. Now there are $4 \times 2 = 8$ processes executing the code after the third fork().

All 8 processes that exist after the third fork() will execute the statement Printf("Happy\n").

The number of processes at each stage can be represented as powers of 2:

Since the Printf is the last statement and is executed by all 8 processes that reach that point, "Happy" will be displayed 8 times.

Statement I says P1 displays "Happy" 8 times. Based on our analysis, this statement is true.

Analyzing C Program P2 Execution with fork() and Printf()

Program P2 has `fork()` and Printf() calls interleaved. Let's trace the execution path and the number of prints at each Printf() call.

1. Initially, there is 1 process. This process executes the first fork().
2. After the first fork(), there are 2 processes (original parent + 1 child). Both processes then execute the first Printf("Happy\n").
   • Prints from first Printf(): 2 times.
3. Both of these 2 processes then execute the second fork(). This creates 2 new child processes. Now there are $2 \times 2 = 4$ processes executing the code after the second fork(). These 4 processes then execute the second Printf("Happy\n").
   • Prints from second Printf(): 4 times.
4. Both of these 4 processes then execute the third fork(). This creates 4 new child processes. Now there are $4 \times 2 = 8$ processes executing the code after the third fork(). These 8 processes then execute the third Printf("Happy\n").
   • Prints from third Printf(): 8 times.

The total number of times "Happy" is displayed is the sum of prints from each Printf() statement:

Total prints = (Prints from 1st Printf) + (Prints from 2nd Printf) + (Prints from 3rd Printf)

Total prints = $2 + 4 + 8 = 14$.

So, program P2 displays "Happy" 14 times.

Statement II says P2 displays "Happy" 12 times. Based on our analysis, this statement is false.

Comparing Statements and Choosing the Answer

• Statement I: P1 displays "Happy" 8 times. (True)
• Statement II: P2 displays "Happy" 12 times. (False)

Therefore, Statement I is correct, but Statement II is false.

Revision Table: fork() and Print Behavior

Additional Information on Process Creation

The fork() system call is a powerful mechanism in Unix-like operating systems for creating new processes. Each successful fork() call essentially duplicates the calling process. The child process inherits many attributes from the parent, including the code segment, data segment, environment variables, open file descriptors, etc. However, they are distinct processes with their own memory space (usually achieved through copy-on-write) and their own unique Process ID (PID). Understanding how code execution diverges in parent and child processes after a fork() is crucial for analyzing programs like P1 and P2, especially when input/output operations like Printf() are involved, as each process's output contributes to the overall display.