Critical section problem in operating system.

The
Critical-Section
Problem
MOHITDADU

The Critical-Section
A code segment that accesses shared variables (or other shared resources)
and that has to be executed as an atomic action is referred to as a critical
section.
n processes competing to use some shared data.
No assumptions may be made about speeds or the number of CPUs.
Each process has a code segment, called Critical Section (CS), in which
the shared data is accessed.
Problem – ensure that when one process is executing in its CS, no other
process is allowed to execute in its CS.

informally,
a critical section is a code segment that accesses shared variables and
has to be executed as an atomic action.
The critical section problem refers to the problem of how to ensure that
at most one process is executing its critical section at a given time.
Important: critical sections in different threads are not necessarily the
same code segment!
PROBLEM DESCRIPTION

PROBLEM DESCRIPTION
Formally,
Mutual exclusion: when a thread is executing in its critical section, no other
threads can be executing in their critical sections.
Progress: if no thread is executing in its critical section, and if there are
some threads that wish to enter their critical sections, then one of these threads
will get into the critical section.
Bounded waiting: after a thread makes a request to enter its critical section,
there is a bound on the number of times that other threads are allowed to enter
their critical sections, before the request is granted.

CS Problem Dynamics (1)
When a process executes code that manipulates shared data (or
resource), we say that the process is in it’s Critical Section (for that
shared data).
The execution of critical sections must be mutually exclusive: at any
time, only one process is allowed to execute in its critical section
(even with multiple processors).
So each process must first request permission to enter its critical
section.

CS Problem Dynamics (2)
The section of code implementing this request is called the Entry Section (ES).
The critical section (CS) might be followed by a Leave/Exit Section (LS).
The remaining code is the Remainder Section (RS).
The critical section problem is to design a protocol that the processes can use so
that their action will not depend on the order in which their execution is
interleaved (possibly on many processors).

General structure of process
while (true)
{
Entry-Section
Critical section
// contains accesses to shared variables or other resources.
Exit-Section
Non-critical section
// a thread may terminate its execution in this section.
}

EXPLANATION
 ENTRY SECTION:- The process will request to enter the critical section
then a part of code decide wheather process can enter in the Critical
Section on not.
 CRITICAL SECTION:- A code segment that accesses shared resources and
that has to be executed as an atomic action.
 EXIT SECTION:- Locking section can be undone which is done in Critical
Section.
 REMAINDER SECTION:- Remaining part of the program .

Solution to Critical-Section Problem
There are 3 requirements that must stand for a correct solution:
1. Mutual Exclusion
2. Progress
3. Bounded Waiting
We can check on all three requirements in each proposed solution,
even though the non-existence of each one of them is enough for an
incorrect solution.

Solution to CS Problem – Mutual Exclusion
1. Mutual Exclusion –
If process Pi is executing in its critical section, then no other processes can be
executing in their critical sections.
Whenever one process is entered in the critical section then there is no other
process can enter in the critical section.
Only one process can be execute at a time.
That means access to the critical section must be mutually exclusive.

 Critical sections better be focused and short.
 Better not get into an infinite loop in there.
 If a process somehow halts/waits in its critical section, it
must not interfere with other processes.
IMPLICATIONS:

Solution to CS Problem– Progress
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 process that will enter the critical section next cannot be
postponed indefinitely:
If only one process wants to enter, it should be able to.
If two or more want to enter, one of them should succeed.

Solution to CS Problem– Bounded Waiting
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.
• Assume that each process executes at a non zero speed.
• No assumption concerning relative speed of the n processes.

Types of solutions to CS
problem
Software Solutions :– Algorithms who’s correctness does not rely
on any other assumptions.
Hardware Solutions :– Rely on some special machine instructions.
Operating System solutions :– Provide some functions and data
structures to the programmer through system /library calls.
Programming Language solutions :– Linguistic constructs
provided as part of a language.

Each process disables all interrupts just after entering in its critical
section and re-enable all interrupts just before leaving critical section.
With interrupts turned off the CPU could not be switched to other
process.
Hence, no other process will enter its critical and mutual exclusion
achieved.
Disabling Interrupts
(Hardware Solution)

Disabling interrupts is sometimes a useful technique within the kernel
of an operating system,
But it is not appropriate as a general mutual exclusion mechanism for
users process.
The reason is that it is unwise to give user process the power to turn
off interrupts.
Conclusion

• In this solution, we consider a single, shared, (lock) variable, initially 0.
• When a process wants to enter in its critical section, it first test the lock.
• If lock is 0, the process first sets it to 1 and then enters the critical section.
• If the lock is already 1, the process just waits until (lock) variable becomes
0.
• Thus, a 0 means that no process in its critical section, and 1 means hold
your horses - some process is in its critical section.
Lock Variable
(Software Solution)

Drawbacks of
software solutions
Software solutions are very delicate .
Processes that are requesting to enter their critical section
are busy waiting (consuming processor time needlessly).
If critical sections are long, it would be more efficient to block
processes that are waiting.

Initial Attempts to Solve
Problem

Threads T0 and T1 use variables flag[i] and flag[j] to indicate their intention to enter their
critical section. A thread will not enter its critical section if the other thread has already
signaled its intention to enter.
boolean flag[i]=false , flag[j]=false ;
Incorrect Solution 1
T1
while (true) {
while (flag[ i ]) { ; } (1)
flag[ j ] = true; (2)
critical section (3)
flag[ j ] = false; (4)
non-critical section (5)
}
T0
while (true) {
while (flag[ j ]) { ; } (1)
flag[ i ] = true; (2)
flag[ i ] = false; (4)
}
This solution does not guarantee mutual exclusion.

T0
WHILE (TRUE) {
WHILE (TURN != 0) { ; } (1)
CRITICAL SECTION (2)
TURN = 1; (3)
NON-CRITICAL SECTION (4)
}
Global variable turn is used to indicate which thread is allowed to enter its
critical section, i.e., the threads take turns entering their critical sections. The
initial value of turn can be 0 or 1.
int turn = 1;
T1
while (true) {
while (turn != 1) { ; } (1)
turn = 0; (3)
}
Thread T0 cannot exit the loop in (1) since the value of turn is 1 and turn will never be
changed by T1.

T0
while (true) {
flag0= true; (1)
while ( flag1) { (2)
flag0= false; (3)
while( flag1) {;} (4)
flag0= true; (5)
}
Flag0= false; (7)
}
T1
while ( true ) {
flag1= true; (1)
while ( Flag0) { (2)
flag1= false; (3)
while( Flag0) {;} (4)
flag1= true; (5)
}
flag1= false; (7)
}
When one thread finds that the other thread also intends to enter its critical section, it
sets its own flag to false and waits for the other thread to exit its critical section.

Thus, the mutual exclusion requirement is satisfied.
In this execution sequence,
T0 enters its critical section infinitely often and
T1 waits forever to enter its critical section.
Thus, this solution does not guarantee bounded waiting.
This solution ensures that when both Flag0 and Flag1 are true,
only one of T0 and T1 is allowed to enter its critical section.

Correct solution:
Correct solution is a combination of solutions (2) and (3). If both threads intend to enter their
critical sections, then turn is used to break the tie.
boolean Flag0 = false , Flag1= false;
int turn; // no initial value for turn is needed.
T0
while (true) {
Flag0= true; (1)
turn = 1; (2)
while ( Flag1&& (3)
Turn == 1) { ; }
Flag0= false; (5)
}
T1
while (true) {
Flag1= true; (1)
turn = 0; (2)
while ( Flag0&& (3)
Turn == 0) { ; }
Flag1= false; (5)
}

Critical section problem in operating system.

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Critical section problem in operating system. (20)

Recently uploaded (20)

Critical section problem in operating system.