Operating Systems | Lock Variable Synchronization Mechanism

To learn lock variable synchronization mechanism, you have to understand different modes of execution of instructions in an operating system.

Basically there are two modes of execution in a system, User Mode and Kernel Mode.

The unrestricted access to any resources in the system, for executing instructions in Kernel Mode makes resources available only for most trusted basic level functions of operating system.
Direct access of hardware or memory references are not allowed in User Mode, due security concerns over higher level applications. System APIs provide a path way to reference these resources.

Features of Lock Variable

  • Lock variable synchronization mechanism is a software logic implemented in User Mode.
  • Lock variable synchronization mechanism is a Busy waiting method of synchronization.
  • Multiple processes can be handled by single lock variable mechanism.

There are two basic section for every synchronization method, which decides the nature of that algorithm, Entry and Exit sections. Arranged as shown.

Here in lock variable method, a global variable Lock acts as a decision making key parameter, that decides entry and exit of processes into critical section.

The structure of the synchronization program will be as as follows:

Code snippet of entry and exit section will decide, whether a program has access to critical resource or not.

If a process sees Lock variable as Zero- means there will no process in critical section. So while( Lock !=0 ); loop fails and Lock variable get set again HIGH to prevent other processes and enter into critical section.

Once the process leaves the critical section, it reset Lock flag as LOW, to indicate the critical resource is free.

Performance Of Lock Variable Synchronization Method

The assembly equivalent of entry section of Lock variable synchronization method is as shown :

  • Let Lock flag be zero. ( Lock = 0 )
  • A process ( say P1 ) is executed its entry section and got preempted at instruction number four.
  • { Instruction 4: The barrier of while loop is over and the flag Lock if not raised to HIGH. }

  • Let another process ( say P2 ) executes its entry section and enters into critical section.
  • { It is possible, since Lock is not raised to HIGH by the P1. }

  • Then there is a chance to get P2 preempted from critical section and P1 get reschedules to execute from where it got preempted previously.

Which means the lock variable fails to prevent another process from accessing a shared resource, while there is a process working over the same resource.

That is Mutual exclusion is not achieved. So we need much sophisticated algorithm to implement synchronization among processes.