Software Based Solutions in Process Synchronization

A software-based solution is a method of solving problems using software programs instead of additional hardware. In operating systems, it means handling tasks like security, error detection, or resource management through software techniques, making the system more flexible and cost-effective.

Various software solutions to the Critical Section Problem are:

• Lock Variable
• Strict Alternation
• Peterson's Algorithm
• Dekker's Algorithm

1. Lock Variable

This is a simple synchronization method that works in user mode and is a busy-waiting solution for multiple processes. It uses a lock variable, lock to manage access to the critical section.

The lock variable can have two values:

• 0: Indicates the critical section is free.
• 1: Indicates the critical section is in use.

When a process wants to enter the critical section, it first checks the lock variable:

• If the value is 0, the process sets it to 1 and enters the critical section.
• If the value is 1, the process waits until it becomes 0.

Entry Section   
While (lock! = 0);   
Lock = 1;  
//Critical Section   
Exit Section 
Lock =0; 

Initially, the lock variable is set to 0. When a process wants to enter the critical section, it goes through an entry section and checks a condition in a while loop.

• The process keeps waiting in the loop until the lock value changes to 1.
• If the critical section is free (lock is 0), the process enters the critical section and sets the lock to 1 to indicate it is in use.

When the process finishes its work in the critical section, it goes through the exit section and sets the lock back to 0, making the critical section available for other processes.
Lock Variable fails to satisfy Bounded Wait. This may be because a process can enter CS multiple times successively while other processes are waiting for their turn to enter CS.

Read more about Lock Variable Synchronization Mechanism.

2. Strict Alternation

The Turn Variable or Strict Alternation Approach is a simple software mechanism used in user mode. It is a busy-waiting solution designed specifically for two processes.

• A turn variable acts as a lock, determining which process can access the critical section.
• The turn alternates between the two processes, ensuring they take turns to enter the critical section.

This method works only for two processes and is not suitable for systems with more than two processes.

A process can enter the critical section only when the turn variable matches the process's ID (PID). The turn variable can have only two values: i or j.

• In the entry section, process Pi cannot enter the critical section until the turn variable is i. Similarly, process Pj cannot enter until the turn variable is j.
• Initially, the turn variable is set to i, so Pi gets the first chance to enter the critical section. The turn variable stays i while Pi is in the critical section.
• Once Pi finishes its work in the critical section, it sets the turn variable to j. This allows Pj to enter the critical section, and the turn variable stays j until Pj finishes.

This ensures that the two processes alternate access to the critical section.

Strict Alternation never guarantees progress.

3. Peterson’s Algorithm

To handle the problem of Critical Section (CS) Peterson gave an algorithm with a bounded waiting.
Suppose there are N processes (P1, P2, … PN) and each of them at some point need to enter the Critical Section.
A flag[] array of size N is maintained which is by default false and whenever a process need to enter the critical section it has to set its flag as true, i.e. suppose Pi wants to enter so it will set flag[i]=TRUE.
There is another variable called turn which indicates the process number which is currently to enter into the CS. The process that enters into the CS while exiting would change the turn to another number from among the list of ready processes.

var flag[]: array [0..1] of boolean;
turn: 0..1;
%flag[k] means that process[k] is interested in the critical section
flag[0] := FALSE;
flag[1] := FALSE;
turn := random(0..1)
After initialization, each process, which is called process i in the code (the other process is process j), runs the following code:

repeat
flag[i] := TRUE;
turn := j;
while (flag[j] and turn=j) do no-op;
CRITICAL SECTION
flag[i] := FALSE;
REMAINDER SECTION
until FALSE;

Information common to both processes:
turn = 0
flag[0] = FALSE
flag[1] = FALSE

Read more about Peterson's Solution.

4. Dekker's Algorithm

Dekker’s Algorithm is one of the earliest known solutions to the Critical Section (CS) problem. It ensures mutual exclusion, progress, and bounded waiting for two processes trying to access a shared resource. Unlike Peterson’s, it was designed before modern atomic instructions and uses shared variables with busy waiting.

Suppose there are two processes (P0 and P1). Each process uses a flag[] array and a shared variable turn.

• flag[i] indicates whether process i wants to enter the CS.
• turn indicates whose turn it is to enter the CS if both want to enter simultaneously.

Initialization:

var flag[]: array [0..1] of boolean;

turn: 0..1;

flag[0] := FALSE;

flag[1] := FALSE;

turn := 0

Algorithm (for each process i):

Let the other process be j.

repeat

flag[i] := TRUE;

while flag[j] do

if turn = j then

begin

flag[i] := FALSE;

while turn = j do

no-op; % wait

flag[i] := TRUE;

end;

CRITICAL SECTION

turn := j;

flag[i] := FALSE;

REMAINDER SECTION

until FALSE;

Working:

1. Intention to enter CS: Each process sets its flag[i] := TRUE to indicate that it wants to enter the Critical Section (CS).

2. Check if the other process wants to enter: If the other process (j) has also set flag[j] = TRUE, then both want to enter at the same time.

3. Turn mechanism

• The turn variable decides which process gets priority.
• If it is the other process’s turn (turn = j), the current process backs off by setting flag[i] := FALSE and waits until turn ≠ j.
• After waiting, it again sets flag[i] := TRUE and tries to enter.

4. Critical Section (CS): Once the conditions are satisfied, the process enters the CS safely, ensuring only one process executes inside CS at a time.

5. Exit section: After finishing CS, the process

• Gives priority to the other process by setting turn := j.
• Resets its flag with flag[i] := FALSE.

6. Remainder Section: The process executes its normal code (non-critical part) and then repeats the cycle.

Before this many

Final and completed Solution: Idea is to use favoured thread notion to determine entry to the critical section. Favoured thread alternates between the thread providing mutual exclusion and avoiding deadlock, indefinite postponement, or lockstep synchronization.

This version guarantees a complete solution to the critical solution problem.

Read more about Dekker's Algorithm.