![Wait ( chopstick [i]);
Wait (chopstick [(i+1)%5]);
. . . . . . . . . . . . .
Eat
. . . . . . . . . . . . .
Signal (chopstick [i]);
Signal (chopstick [(i+1)%5]);
. . . . . . . . . . . . .
Think
. . . . . . . . . . . . .
} While (1);
Critical Region:
According to the critical section problem using semaphore all processes must share a semaphore
variablemutex which is initialized to one. Each process must execute wait (mutex) before
entering the critical section and execute the signal (mutex) after completing the execution but
there are various difficulties may arise with this approach like:
Case 1: Suppose that a process interchanges the order in which the wait and signal operations on
the semaphore mutex are executed, resulting in the following execution: Signal (mutex);
. . . . . . . . . .
Critical Section
. . . . . . . . . . .
Wait (mutex);
In this situation several processes may be executing in their critical sections simultaneously, which is
violating mutual exclusion requirement.
Case 2: Suppose that a process replaces the signal (mutex) with wait (mutex). The execution is as
follows:
Wait (mutex);
. . . . . . . . . . .
Critical Section
. . . . . . . . . . .
Wait (mutex);
33 | P a g e](https://image.slidesharecdn.com/osunit3-181029014707/85/Os-unit-3-6-320.jpg)
Os unit 3
- 1. Process Synchronization: A co-operation process is one that can affect or be affected by other processes executing in the system. Co-operating process may either directly share a logical address space or be allotted to the shared data only through files. This concurrent access is known as Process synchronization. Critical Section Problem: Consider a system consisting of n processes (P0, P1, ………Pn -1) each process has a segment of code which is known as critical section in which the process may be changing common variable, updating a table, writing a file and so on. The important feature of the system is that when the process is executing in its critical section no other process is to be allowed to execute in its critical section. The execution of critical sections by the processes is a mutually exclusive. The critical section problem is to design a protocol that the process can use to cooperate each process must request permission to enter its critical section. The section of code implementing this request is the entry section. The critical section is followed on exit section. The remaining code is the remainder section. Example: While (1) { Entry Section; Critical Section; Exit Section; Remainder Section; } A solution to the critical section problem must satisfy the following three conditions. 1. Mutual Exclusion: If process Pi is executing in its critical section then no any other process can be executing in their critical section. 2. Progress: If no process is executing in its critical section and some process wish to enter their critical sections then only those process that are not executing in their remainder section can enter its critical section next. 3. Bounded waiting: There exists a bound on the number of times that other processes are allowed to enter their critical sections after a process has made a request. Semaphores: For the solution to the critical section problem one synchronization tool is used which is known as semaphores. A semaphore ‗S‘ is an integer variable which is accessed through two standard
- 2. operations such as wait and signal. These operations were originally termed ‗P‘ (for wait means to test) and ‗V‘ (for single means to increment). The classical definition of wait is Wait (S) { While (S <= 0) { Test; } S--; } The classical definition of the signal is Signal (S) { S++; } In case of wait the test condition is executed with interruption and the decrement is executed without interruption. Binary Semaphore: A binary semaphore is a semaphore with an integer value which can range between 0 and 1. Let ‗S‘ be a counting semaphore. To implement the binary semaphore we need following the structure of data. Binary Semaphores S1, S2; int C; Initially S1 = 1, S2 = 0 and the value of C is set to the initial value of the counting semaphore ‗S‘. Then the wait operation of the binary semaphore can be implemented as follows. Wait (S1) C--; if (C < 0) { Signal (S1); Wait (S2); }
- 3. Signal (S1); The signal operation of the binary semaphore can be implemented as follows: Wait (S1); C++; if (C <=0) Signal (S2); Else Signal (S1); Classical Problem on Synchronization: There are various types of problem which are proposed for synchronization scheme such as Bounded Buffer Problem: This problem was commonly used to illustrate the power of synchronization primitives. In this scheme we assumed that the pool consists of ‗N‘ buffer and each capable of holding one item. The ‗mutex‘ semaphore provides mutual exclusion for access to the buffer pool and is initialized to the value one. The empty and full semaphores count the number of empty and full buffer respectively. The semaphore empty is initialized to ‗N‘ and the semaphore full is initialized to zero. This problem is known as procedure and consumer problem. The code of the producer is producing full buffer and the code of consumer is producing empty buffer. The structure of producer process is as follows: do { produce an item in nextp . . . . . . . . . . . . Wait (empty); Wait (mutex); . . . . . . . . . . . add nextp to buffer . . . . . . . . . . . . Signal (mutex); Signal (full); } While (1); The structure of consumer process is as follows:
- 4. do { Wait (full); Wait (mutex); . . . . . . . . . . . Remove an item from buffer to nextc . . . . . . . . . . . Signal (mutex); Signal (empty); . . . . . . . . . . . . Consume the item in nextc; . . . . . . . .. . . .. . } While (1); Reader Writer Problem: In this type of problem there are two types of process are used such as Reader process and Writer process. The reader process is responsible for only reading and the writer process is responsible for writing. This is an important problem of synchronization which has several variations like o The simplest one is referred as first reader writer problem which requires that no reader will be kept waiting unless a writer has obtained permission to use the shared object. In other words no reader should wait for other reader to finish because a writer is waiting. o The second reader writer problem requires that once a writer is ready then the writer performs its write operation as soon as possible. The structure of a reader process is as follows: Wait (mutex); Read count++; if (read count == 1) Wait (wrt); Signal (mutex); . . . . . . . . . . . Reading is performed . . . . . . . . . . . Wait (mutex);
- 5. Read count --; if (read count == 0) Signal (wrt); Signal (mutex); The structure of the writer process is as follows: Wait (wrt); Writing is performed; Signal (wrt); Dining Philosopher Problem: Consider 5 philosophers to spend their lives in thinking & eating. A philosopher shares common circular table surrounded by 5 chairs each occupies by one philosopher. In the center of the table there is a bowl of rice and the table is laid with 6 chopsticks as shown in below figure. When a philosopher thinks she does not interact with her colleagues. From time to time a philosopher gets hungry and tries to pickup two chopsticks that are closest to her. A philosopher may pickup one chopstick or two chopsticks at a time but she cannot pickup a chopstick that is already in hand of the neighbor. When a hungry philosopher has both her chopsticks at the same time, she eats without releasing her chopsticks. When she finished eating, she puts down both of her chopsticks and starts thinking again. This problem is considered as classic synchronization problem. According to this problem each chopstick is represented by a semaphore. A philosopher grabs the chopsticks by executing the wait operation on that semaphore. She releases the chopsticks by executing the signal operation on the appropriate semaphore. The structure of dining philosopher is as follows: do{ 32 | P a g e
- 6. Wait ( chopstick [i]); Wait (chopstick [(i+1)%5]); . . . . . . . . . . . . . Eat . . . . . . . . . . . . . Signal (chopstick [i]); Signal (chopstick [(i+1)%5]); . . . . . . . . . . . . . Think . . . . . . . . . . . . . } While (1); Critical Region: According to the critical section problem using semaphore all processes must share a semaphore variablemutex which is initialized to one. Each process must execute wait (mutex) before entering the critical section and execute the signal (mutex) after completing the execution but there are various difficulties may arise with this approach like: Case 1: Suppose that a process interchanges the order in which the wait and signal operations on the semaphore mutex are executed, resulting in the following execution: Signal (mutex); . . . . . . . . . . Critical Section . . . . . . . . . . . Wait (mutex); In this situation several processes may be executing in their critical sections simultaneously, which is violating mutual exclusion requirement. Case 2: Suppose that a process replaces the signal (mutex) with wait (mutex). The execution is as follows: Wait (mutex); . . . . . . . . . . . Critical Section . . . . . . . . . . . Wait (mutex); 33 | P a g e
- 7. In this situation a deadlock will occur Case 3: Suppose that a process omits the wait (mutex) and the signal (mutex). In this case the mutual exclusion is violated or a deadlock will occur. To illustrate the various types or error generated by using semaphore there are some high level language constructs have been introduced such as critical region and monitor. Critical region is also known as conditional critical regions. It constructs guards against certain simple errors associated with semaphore. This high level language synchronization construct requires a variable V of type T which is to be shared among many processes. It is declared as V: shared T; The variable V can be accessed only inside a region statement as like below: Wait (mutex); While (! B) { First_count++; if (second_count> 0) Signal (second_delay); Else Signal (mutex); Wait (first_delay); First_count--; Second_count++; if (first_count> 0) Signal (first_delay); Else Signal (second_delay); Wait (second_delay); Second_count --; } S; if (first_count> 0) Signal (first_delay); Else if (second_count> 0) Signal (second_delay);
- 8. Else Signal (mutex); (Implementation of the conditional region constructs) Where B is a Boolean variable which governs the access to the critical regions which is initialized to false.Mutex, First_delay and Second_delay are the semaphores which are initialized to 1, 0, and 0 respectively. First_count and Second_count are the integer variables which are initialized to zero. Monitor: It is characterized as a set of programmer defined operators. Its representation consists of declaring of variables, whose value defines the state of an instance. The syntax of monitor is as follows. Monitor monitor_name { Shared variable declarations Procedure body P1 (………) { . . . . . . . . } Procedure body P2 (………) { . . . . . . . . } . . . Procedure body Pn (………) { . . . . . . . . } { Initialization Code } }