Peterson's solution in Operating Systems - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare the flag array used in Peterson's solution.

Operating Systems

boolean flag[2] = { [1], [1] };

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

Afalse

Btrue

Cnull

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Setting flags to true initially, which incorrectly indicates both processes want to enter.

Using 0 or null instead of boolean false.

The flag array is initialized to false for both processes, indicating neither wants to enter the critical section initially.

2fill in blank

medium

Complete the code to assign the turn variable in Peterson's solution.

Operating Systems

turn = [1];

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

A0

Bother

C1

Dprocess_id

Attempts:

3 left

💡 Hint

Common Mistakes

Setting turn to the current process's ID instead of the other process.

Using fixed values like 0 or 1 without considering the other process.

The turn variable is assigned the other process's ID to give it priority in entering the critical section.

3fill in blank

hard

Fix the error in the waiting condition of Peterson's solution.

Operating Systems

while (flag[[1]] && turn == [1]) { /* wait */ }

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

Ai

B1

C0

Dj

Attempts:

3 left

💡 Hint

Common Mistakes

Using the current process's index instead of the other process's index.

Confusing the turn variable with the flag array index.

The waiting condition checks if the other process (j) wants to enter and if it's that process's turn.

4fill in blank

hard

Fill both blanks to correctly set flags and turn in Peterson's solution for process i.

Operating Systems

flag[[1]] = true;
turn = [2];

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

Ai

Bj

C0

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Setting turn to the same process's ID.

Setting the wrong flag index.

Process i sets its flag to true indicating it wants to enter, and sets turn to j to give priority to the other process.

5fill in blank

hard

Fill all three blanks to complete the exit section of Peterson's solution for process i.

Operating Systems

flag[[1]] = [2];
// Process [3] exits critical section

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

Ai

Bfalse

Dtrue

Attempts:

3 left

💡 Hint

Common Mistakes

Setting flag to true instead of false on exit.

Using the wrong process ID in the comment.

Process i sets its flag to false to indicate it no longer wants to enter the critical section and exits.

Practice

1. What is the main purpose of Peterson's solution in operating systems?

easy

A. To prevent two processes from accessing a shared resource simultaneously

B. To increase the speed of process execution

C. To allocate memory to processes

D. To schedule processes based on priority

Solution

1. Step 1: Understand the problem Peterson's solution addresses

   Peterson's solution is designed to handle the critical section problem where two processes must not access a shared resource at the same time.

2. Step 2: Identify the main goal of the solution

   The main goal is to ensure mutual exclusion, preventing simultaneous access to shared resources.

3. Final Answer:

   To prevent two processes from accessing a shared resource simultaneously -> Option A

4. Quick Check:

   Mutual exclusion = Prevent simultaneous access [OK]

Hint: Peterson's solution controls access to shared resources [OK]

Common Mistakes:

• Confusing it with process scheduling
• Thinking it manages memory allocation
• Assuming it increases execution speed

2. Which of the following variables is NOT used in Peterson's solution?

easy

A. flag

B. turn

C. counter

D. process_id

Solution

1. Step 1: Recall the variables used in Peterson's solution

   Peterson's solution uses two flags (one per process) and a turn variable to control access.

2. Step 2: Identify the variable not part of the solution

   The variable 'counter' is not used in Peterson's solution; it is unrelated to mutual exclusion control.

3. Final Answer:

   counter -> Option C

4. Quick Check:

   Variables used = flag, turn; counter not used [OK]

Hint: Remember only flag and turn variables are used [OK]

Common Mistakes:

• Assuming process_id is a variable in Peterson's solution
• Confusing counter with flag
• Thinking turn is a counter

3. Consider two processes P0 and P1 using Peterson's solution. If both set their flags to true and turn to 1, which process will enter the critical section first?

medium

A. P0

B. P1

C. Both enter simultaneously

D. Neither enters

Solution

1. Step 1: Analyze the turn variable's role

   The turn variable indicates which process's turn it is to enter the critical section when both want access.

2. Step 2: Apply the given values

   Both flags are true, meaning both want to enter. Since turn is set to 1, process P1 has priority to enter first.

3. Final Answer:

   P1 -> Option B

4. Quick Check:

   Turn = 1 means P1 enters first [OK]

Hint: Turn variable decides which process enters first [OK]

Common Mistakes:

• Assuming both enter simultaneously
• Ignoring the turn variable
• Thinking the first flag set enters first

4. Identify the error in this Peterson's solution snippet for process P0:

flag[0] = true;
turn = 1;
while(flag[1] && turn == 1) {
  // wait
}
// critical section
flag[0] = false;

medium

A. No error; this is correct Peterson's solution code

B. turn should be set to 0 instead of 1

C. flag[0] should be set to false before the while loop

D. The while condition should use OR instead of AND

Solution

1. Step 1: Review the Peterson's solution steps for process P0

   Process P0 sets its flag true, sets turn to the other process (1), then waits while the other process wants to enter and it's their turn.

2. Step 2: Check the correctness of the code snippet

   The code correctly implements the waiting condition and resets the flag after the critical section.

3. Final Answer:

   No error; this is correct Peterson's solution code -> Option A

4. Quick Check:

   Code matches Peterson's solution pattern [OK]

Hint: Check waiting condition and flag reset carefully [OK]

Common Mistakes:

• Changing turn to own process instead of other
• Misplacing flag reset before critical section
• Using OR instead of AND in while condition

5. How does Peterson's solution ensure fairness between two processes competing for a critical section?

hard

A. By allowing the process with higher priority to enter first

B. By locking the resource permanently for the first process

C. By using a random number generator to decide access

D. By using a turn variable to alternate access between processes

Solution

1. Step 1: Understand fairness in Peterson's solution

   Fairness means no process waits forever; both get a chance to enter the critical section.

2. Step 2: Identify how fairness is implemented

   The turn variable ensures that if both processes want access, the one whose turn it is gets priority, then the turn switches, alternating access.

3. Final Answer:

   By using a turn variable to alternate access between processes -> Option D

4. Quick Check:

   Turn variable alternates access = fairness [OK]

Hint: Turn variable alternates access to ensure fairness [OK]

Common Mistakes:

• Thinking priority decides access
• Assuming random choice controls fairness
• Believing resource is locked permanently