Critical Section Problem

Critical Section Problem
Critical Section Problem
• Consider system of n processes {p0, p1, … pn-1}

• Each process has critical section segment of code
– Process may be changing common variables,
updating table, writing file, etc
– When one process in critical section, no other may
be in its critical section
• Critical section problem is to design a protocol that
the processes can use to cooperate.
• Each process must ask permission to enter critical
section in entry section, may follow critical section
with exit section, then remainder section
General structure of process Pi
Solution to Critical-Section Problem
1. Mutual Exclusion - If process Pi is executing in its critical

section, then no other processes can be executing in their
critical sections
2. Progress - If no process is executing in its critical section and
there exist some processes that wish to enter their critical
section, then the selection of the processes that will enter the
critical section next cannot be postponed indefinitely
3. Bounded Waiting - A bound must exist on the number of
times that other processes are allowed to enter their critical
sections after a process has made a request to enter its critical
section and before that request is granted
Critical-Section Handling in OS
• Two general approaches are used to handle critical
sections in operating systems:
– Preemptive – allows preemption of process when
running in kernel mode
– Non-preemptive – A non preemptive kernel does
not allow a process running in kernel mode to be
preempted
– runs until exits kernel mode, blocks, or voluntarily
yields CPU
• Essentially free of race conditions in kernel
mode
• Race Condition
A race condition is an undesirable situation that occurs
when a device or system attempts to perform two or more
operations at the same time, but because of the nature of the
device or system, the operations must be done in the proper
sequence to be done correctly.
Synchronization Hardware
Synchronization Hardware
• Many systems provide hardware support for implementing the
critical section code.
• All solutions below based on idea of locking
– Protecting critical regions via locks
• Uniprocessors – could disable interrupts
– Currently running code would execute without preemption
• Multiprocessor - this solution is not as feasible
– Generally too inefficient disabling interrupts can be time
consuming , System efficiency decreases
• Modern machines provide special atomic hardware
instructions
• Atomic = non-interruptible
– Either to test and modify the content of a word Or
– swap contents of two memory words
Solution to Critical-section Problem Using Locks
do {
acquire lock
critical section
release lock
remainder section
} while (TRUE);
1.test_and_set Instruction
Definition:
boolean test_and_set (boolean *target)
{
boolean rv = *target;
*target = TRUE;
return rv:
}
1. This instruction is atomic
2. This instruction is provided by the hardware
Solution using test_and_set()
• Shared Boolean variable lock, initialized to FALSE

• Solution:
do {
while (test_and_set(&lock))
; /* do nothing */
/* critical section */
lock = false;
/* remainder section */
} while (true);
2.Swap() instruction
Definition:
void Swap(boolean *a, boolean *b)
{
boolean temp = *a;
*a *b;
*b = temp;
}
1. This instruction is atomic
2. This instruction is provided by the hardware
Solution using swap()
• Shared Boolean variable lock initialized to False
• Each process has a local boolean variable key
do
{
key = TRUE;
while (key == TRUE)
Swap(&lock, &key);
critical section
lock = FALSE;
remainder section
} while (TRUE);
Bounded-waiting Mutual Exclusion with
test_and_set
do {
waiting[i] = true;
key = true;
while (waiting[i] && key)
key = test_and_set(&lock);
waiting[i] = false;
/* critical section */
j = (i + 1) % n;
while ((j != i) && !waiting[j])
j = (j + 1) % n;
if (j == i)
lock = false;
else
waiting[j] = false;
/* remainder section */
} while (true);

Critical Section Problem

Uploaded by

Copyright:

Available Formats

Critical Section Problem

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Critical Section Problem

Uploaded by

Copyright:

Available Formats

Critical Section Problem

Critical Section Problem

• Consider system of n processes {p0, p1, … pn-1}

1. Mutual Exclusion - If process Pi is executing in its critical

• Shared Boolean variable lock, initialized to FALSE

You might also like

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.