Critical section problem in Operating Systems - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to indicate the section where shared resources are accessed.

Operating Systems

process() {
  [1] // critical section
  // code accessing shared resource
}

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

Acritical section

Bcritical_section

Ccritical-section

DcriticalSection

Attempts:

3 left

💡 Hint

Common Mistakes

Using camelCase or underscores instead of the phrase 'critical section'.

Writing it as one word or hyphenated.

The term critical section refers to the part of the code where shared resources are accessed and must be protected to avoid conflicts.

2fill in blank

medium

Complete the sentence to describe the main goal of the critical section problem.

Operating Systems

The critical section problem aims to ensure that [1] processes do not access the shared resource simultaneously.

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

Ano two

Bmultiple

Call

Donly one

Attempts:

3 left

💡 Hint

Common Mistakes

Choosing 'all' or 'multiple' which allow simultaneous access.

Choosing 'only one' which is close but less precise than 'no two'.

The goal is to ensure that no two processes enter their critical sections at the same time to prevent conflicts.

3fill in blank

hard

Fix the error in the statement about the critical section problem.

Operating Systems

One of the requirements is [1]: no process should wait forever to enter its critical section.

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

Astarvation freedom

Bdeadlock

Cprogress

Dmutual exclusion

Attempts:

3 left

💡 Hint

Common Mistakes

Confusing with 'deadlock' which is a different problem.

Choosing 'mutual exclusion' which is about exclusive access, not waiting time.

Starvation freedom means no process waits forever to enter its critical section, ensuring fairness.

4fill in blank

hard

Fill both blanks to complete the conditions for a correct solution to the critical section problem.

Operating Systems

A correct solution must satisfy [1] to prevent simultaneous access and [2] to ensure processes eventually enter their critical section.

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

Amutual exclusion

Bdeadlock

Cprogress

Dstarvation

Attempts:

3 left

💡 Hint

Common Mistakes

Confusing deadlock with progress.

Mixing starvation with mutual exclusion.

The two key conditions are mutual exclusion to avoid simultaneous access and progress to ensure processes can enter their critical section without unnecessary delay.

5fill in blank

hard

Fill all three blanks to complete the description of the critical section problem requirements.

Operating Systems

The three main requirements are [1], [2], and [3] to ensure safe and fair access to shared resources.

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

Amutual exclusion

Bprogress

Cbounded waiting

Ddeadlock prevention

Attempts:

3 left

💡 Hint

Common Mistakes

Including deadlock prevention as a main requirement.

Confusing bounded waiting with starvation freedom.

The critical section problem requires mutual exclusion (only one process in critical section), progress (processes decide who enters next), and bounded waiting (no process waits forever).

Practice

1. What is the main goal of the critical section problem in operating systems?

easy

A. To ensure only one process accesses shared resources at a time

B. To allow multiple processes to access resources simultaneously

C. To speed up the execution of all processes

D. To prevent processes from running in parallel

Solution

1. Step 1: Understand the critical section concept

   The critical section is a part of the program where shared resources are accessed.

2. Step 2: Identify the problem goal

   The goal is to prevent multiple processes from entering the critical section simultaneously to avoid conflicts.

3. Final Answer:

   To ensure only one process accesses shared resources at a time -> Option A

4. Quick Check:

   Critical section = exclusive access [OK]

Hint: Only one process can be inside critical section at once [OK]

Common Mistakes:

• Thinking multiple processes can safely access shared data simultaneously
• Confusing critical section with process scheduling
• Believing critical section speeds up all processes

2. Which of the following is a correct way to indicate a process is in its critical section using a flag variable flag[i]?

easy

A. flag[i] = true

B. flag[i] = -1

C. flag[i] = 0

D. flag[i] = false

Solution

1. Step 1: Understand flag usage in critical section

   A flag variable is often used to indicate if a process wants to enter or is inside the critical section.

2. Step 2: Identify correct flag value for 'in critical section'

   Setting flag[i] = true means the process is active or wants to enter the critical section.

3. Final Answer:

   flag[i] = true -> Option A

4. Quick Check:

   Flag true means process active [OK]

Hint: True means process wants or is inside critical section [OK]

Common Mistakes:

• Using 0 or false to indicate active process
• Confusing flag values with process IDs
• Using negative values for flags

3. Consider this pseudocode for two processes P0 and P1 using flags to enter critical section:

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

What happens if both processes set their flags to true at the same time?

medium

A. Both enter critical section simultaneously

B. Both skip critical section

C. Both wait forever (deadlock)

D. One waits while the other enters critical section

Solution

1. Step 1: Analyze the waiting condition

   Each process waits while the other's flag is true, so if both flags are true simultaneously, both wait.

2. Step 2: Identify the outcome

   Since both wait for the other to clear their flag, neither proceeds, causing deadlock.

3. Final Answer:

   Both wait forever (deadlock) -> Option C

4. Quick Check:

   Both flags true = deadlock [OK]

Hint: Both flags true means both wait forever [OK]

Common Mistakes:

• Assuming both can enter critical section simultaneously
• Thinking one process always proceeds first
• Ignoring the waiting loop condition

4. In the following code snippet, what is the main error that can cause the critical section problem?

flag[i] = true
while(flag[j]) {
  // do nothing
}
// critical section
flag[i] = false

Assuming two processes P0 and P1 use this code with i=0, j=1 and vice versa.

medium

A. Infinite loop if flag[j] is false

B. No mutual exclusion, both can enter critical section

C. Flag reset happens before critical section

D. Deadlock if both set flag true simultaneously

Solution

1. Step 1: Understand the waiting condition

   Each process waits while the other process's flag is true.

2. Step 2: Identify the error scenario

   If both processes set their flags to true simultaneously, both wait forever, causing deadlock.

3. Final Answer:

   Deadlock if both set flag true simultaneously -> Option D

4. Quick Check:

   Simultaneous flags true = deadlock [OK]

Hint: Both flags true causes deadlock, not mutual exclusion [OK]

Common Mistakes:

• Thinking both can enter critical section simultaneously
• Believing flag reset is before critical section
• Assuming infinite loop if flag[j] is false

5. Which of the following solutions correctly solves the critical section problem by ensuring mutual exclusion, progress, and bounded waiting?

hard

A. Using a simple flag variable without turn variable

B. Peterson's algorithm using flags and turn variable

C. Both processes entering critical section simultaneously

D. Ignoring synchronization and relying on process speed

Solution

1. Step 1: Review solution requirements

   The solution must ensure mutual exclusion, progress, and bounded waiting to solve the critical section problem correctly.

2. Step 2: Evaluate each option

   Using a simple flag variable without turn variable lacks a turn variable, so it can cause deadlock or starvation. Peterson's algorithm using flags and turn variable uses flags and turn to guarantee all three conditions. The other options are incorrect approaches.

3. Final Answer:

   Peterson's algorithm using flags and turn variable -> Option B

4. Quick Check:

   Peterson's algorithm = correct solution [OK]

Hint: Peterson's algorithm uses flags + turn for safe access [OK]

Common Mistakes:

• Ignoring the need for a turn variable
• Assuming simple flags are enough
• Believing processes can safely ignore synchronization