The Critical-Section

Problem

MOHIT DADU

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 DESCRIPTIONFormally,

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 Exclusion2. Progress3. 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

T1while (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) critical section (3) flag[ i ] = false; (4) non-critical section (5)}

This solution does not guarantee mutual exclusion.

T0WHILE (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;

Incorrect Solution 2

T1while (true){

while (turn != 1) { ; } (1)critical section (2)turn = 0; (3)non-critical section (4)}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) }critical section (6)

Flag0= false; (7) non-critical section (8) }

T1while ( true ) {

flag1 = true; (1)

while ( Flag0 ) { (2)

flag1 = false; (3)

while( Flag0 ) {;} (4)

flag1 = true; (5)}critical section (6)

flag1= false; (7)non-critical section (8)}

Incorrect Solution 3When 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) { ; } critical section (4)

Flag0= false; (5) non-critical section (6) }

T1while (true) {

Flag1= true; (1)turn = 0; (2)

while ( Flag0&& (3) Turn == 0) { ; }critical section (4)

Flag1= false; (5)non-critical section (6)}