Concurrency, Mutual Exclusion and Synchronization C H A P T E R 5

Concurrency, Mutual Exclusion and Synchronization C H A P T E R 5

Multiple Processes OS design is concerned with the management of processes and threads: Multiprogramming Multiprocessing Distributed processing

Concurrency Arises in three different context: Multiple Applications invented to allow processing time to be shared among active applications Structured Applications extension of modular design and structured programming Operating System Structure OS themselves implemented as a set of processes or threads

Key Terms Related to Concurrency

Principles of Concurrency Interleaving and overlapping can be viewed as examples of concurrent processing both present the same problems Uniprocessor the relative speed of execution of processes cannot be predicted depends on activities of other processes the way the OS handles interrupts scheduling policies of the OS

Difficulties of Concurrency 1. Sharing global resources E.g.: two process make use same global variable and both perform reads and writes on that variable, then the order in which the various reads and writes are executed is critical. 2. Difficult for the OS to manage the allocation of resources optimally E.g.: process A may request use of, and be granted control of a particular I/O channel and then be suspended before using that channel 3. Difficult to locate programming errors as results are not deterministic and reproducible

Shared Global Variables Consider the echo procedure below void echo() { chin = getchar(); chout = chin; putchar(chout); }

Shared Global Variables This procedure shows the essential elements of a program that will provide a character echo procedure: Input is obtained from keyboard Each input is stored in variable chin. Then transferred to variable chout and sent to display. Any program can call this procedure repeatedly to accept user input and display it on the user s screen.

Shared Global Variables In uniprocessor multiprogramming system : User can jump from one application to another and each application uses the same keyboard for input and same screen for output. Each application need to use this procedure, so this shared procedure is loaded into a portion of memory global to all applications. Thus only a single copy of echo procedure is used, saving space. The sharing of main memory among processes is useful to permit efficient and close interaction among processes.

Shared Global Variables But, it can leads to problem, consider the following sequence (Process P1 and P2): 1. P1 invokes the echo procedure and is interrupted immediately after the conclusion of getchar function. At this point P1 has entered x, so x is stored in variable chin. 2. P2 is activated and invokes the echo procedure, runs to conclusion, inputting and display a single character y on the screen. 3. P1 is resumed. But the value of x has been overwritten in chin and therefore lost. chin contains y and transferred to chout and displayed on screen.

Shared Global Variables Thus the first character is lost and the second character is displayed twice. The problem is on the shared global variable chin. Multiple processes have access to this variable; if one process updates the global variable and then is interrupted, another process may alter the variable before the first process can use its value. How to Solve??? Only one process at a time in that procedure.

Shared Global Variables So, the following sequence may result: 1. P1 invokes the echo procedure and is interrupted immediately after the conclusion of the input function. x is stored in variable chin. 2. P2 activated and invokes the echo procedure. However because P1 is still in the echo procedure, P2 is currently blocked from entering the procedure. Therefore P2 is suspended awaiting for the availability of the echo procedure. 3. P1 resumes and completes execution of echo. The proper character x is displayed. 4. When P1 exits echo, this removes the block on P2. When P2 later resumed, the echo is successfully invoked.

Shared Global Variables It is important to protect shared global variables. How? By controlling the code that accesses the variable.

Race Condition Occurs when multiple processes or threads read and write data items The final result depends on the order of execution the loser of the race is the process that updates last and will determine the final value of the variable

Race Condition Example 1: Two processes P1 and P2 share the global variable A. P1 updates A = 1, and at some point P2 update A = 2. These two tasks are in race to write in variable A. The loser of the race (the process that updates last) determines the final value of A.

Race Condition Example 2 Two processes P3 and P4 share the global variable B and C, with initial value B = 1 and C = 2. P3 B = B + C, P4 C = B + C. These two processes update different variables. The final values of the two variables depend on the order in which the two processes execute these assignments.

Operating System Concerns Design and management issues raised by the existence of concurrency: The OS must: be able to keep track of various processes allocate and de-allocate resources for each active process protect the data and physical resources of each process against interference by other processes ensure that the processes and outputs are independent of the processing speed To understand how the issue of speed independence can be address, we need to understand the ways in which processes can interact with each other

Process Interaction The process can be classify with the ways which processes interact on the basis of the degree to which they are aware of each other s existence. Processes Unaware of Each Other Processes Indirectly Aware of Each Other Processes Directly Aware of Each Other

Process Unaware of Each Other These are independent processes that are not intended to work together. E.g. of situation: multiprogramming of multiple independent processes that can be batch jobs or interactive sessions or a mixture These processes are not working together, the OS needs to be concerned about competition for resources. E.g.: two independent applications may both want to access the same disk or file or printer. OS must regulate these accesses.

Process Indirectly Aware of Each Other These are processes that are not necessarily aware of each other by their respective process IDs but that share access to some object, such as an I/O buffer. Such processes exhibit cooperation in sharing the common object.

Process Directly Aware of Each Other These are processes that are able to communicate with each other by process ID and that are designed to work jointly on some activity. Processes exhibit cooperation.

Process Interaction Several processes may exhibit aspects of both competition and cooperation. We will look at: Competition among processes for resources Cooperation among processes by sharing Cooperation among process by communication and determine their implications for the OS

Competition Among Processes for Resources Concurrent processes come into conflict with each other when they are competing for the use of the same resource. E.g. of situation: Two or more processes need to access a resource during their execution. Each process unaware of the existence of the other processes, and each is to be unaffected by the execution of other processes. Each process should leave the state of any resource that it uses unaffected. (e.g of resource: I/O devices, memory and processor time)

Competition Among Processes for Resources There is no exchange information btw this processes but the execution of one process may affect the behavior of competing processes. If two process both wish access to a single, then one process will be allocated by the OS and the other will have to wait. The process that is denied access will be slow down. Extreme case: the blocked process may never get access to the resource and hence will never terminate successfully.

Competition Among Processes for Resources Three control problems in the case of competing processes: 1. Mutual Exclusion 2. Deadlock 3. Starvation

Competition Among Processes for Resources Three control problems in the case of competing processes: Mutual Exclusion Deadlock Starvation

Mutual Exclusion The ability to exclude all other processes from a course of action while one process is granted that ability. Suppose there are two or more processes require access to single non sharable resource such as printer. During the execution, each process will be sending commands to the I/O device, receiving status information, sending data and/or receiving data. This resource known as critical resource, and the portion of the program that uses it as a critical section of a program. At a time only one program can be allowed in critical section

Mutual Exclusion Cannot simply rely on OS to understand and enforce the restriction (ME) because OS does not have the detailed requirements of each process. In the case of printer: individual process need to have a control of the printer while it prints an entire file. The enforcement of ME creates another two additional control problem which is deadlock and starvation

Deadlock Consider two processes, P1 and P2, and two resources R1 and R2. Suppose that each process needs access to both resources to perform its function. It is possible to have the following situation: P1 request for R2, receives it P2 request for R1, receives it P1 request R1, queue up waiting for P2 to release it P2 request R2, queue up waiting for P1 to release it

Deadlock Each process waiting for the resources held by the other process. No process will release the resource that it already owns until it has acquired the other resource and performed the function requiring both resources. These two processes are deadlocked.

Starvation Suppose that three processes (P1, P2, P3) each require periodic access to resource R. Consider the situation: P1 is using the resource, both P2 and P3 are delayed waiting for the resources. When P1 exits its critical section, either P2 or P3 should be allowed to access R. Assume OS granted request P3, and P1 again require access.

Starvation If the OS grants access to P1 after P3 has finished and subsequently alternately grants access to P1 and P3, the P2 may indefinitely be denied to the resource, even though there is no deadlock situation.

Competition Among Processes for Resources Control of competition inevitably involves the OS who responsible to allocate resources. But in addition, the processes themselves will need to be able to express the requirement for mutual exclusion, such as locking a resource prior to its use. Any solution will involve some support from the OS, such as the provision of locking facility.

Cooperation Among Processes by Sharing Covers processes that interact with other processes without being explicitly aware of them E.g. multiple processes may have access to shared variables or to a shared files or database. Processes may use and update the shared data without reference to other processes but know that other processes may have access to the same data. Thus the process must cooperate to ensure that the data they share are properly managed. The control mechanisms must ensure the integrity of the shared data.

Cooperation Among Processes by Sharing Data are held on resources, so the control problems of mutual exclusion, deadlock and starvation is also present The different is that data items may be accessed in two different modes, reading and writing Only writing operations must be mutually exclusive. Data coherence as the new requirement is introduced.

Data Coherence Consider an application where various data items may be updated. Suppose two items of data a and b are to be maintained in the relationship a=b. So, any program that updates one value, must also update the other to maintain the relationship (a=b)

Data Coherence Consider the following two processes: P1: a = a + 1; b = b + 1; P2: b = 2 * b; a = 2 * a;

Data Coherence If each process taken separately, in will leave the shared data in consistent state. Consider the following concurrent execution, in which this two processes respect mutual exclusion on each individual data item (a and b); a = a + 1; b = 2 * b; b = b + 1; a = 2 * a;

Data Coherence At the end of the execution sequence, the condition a = b no longer holds. E.g. if we start with a = b = 1, at the end of the execution sequence we have a = 4 and b = 3. How to solve? By declaring the entire sequence in each process to be a critical section.

Cooperation Among Processes by Sharing Four control problems in the case of cooperation sharing: Mutual Exclusion Deadlock Starvation Data Coherence

Cooperation Among Processes by Communication When processes cooperate by communication, the various processes participate in a common effort that links all the processes. The communication provides a way to synchronize, or coordinate, the various activities. Communication can be characterized as consisting messages of some sort. Sevices for sending and receiving messages may be provided as part of programming language or provided by the system kernel of the OS.

Cooperation Among Processes by Communication Nothing is shared between processes in the act of passing messages, so no need to control mutual exclusion. However the problems of deadlock and starvation are still present Deadlock two process may be blocked, each waiting for communication from the other.

Cooperation Among Processes by Communication Starvation Consider three processes, P1,P2 and P3, that exhibit the following behavior: P1 is attempting to communicate with either P2 or P3, and P2 and P3 are both attempting to communicate with P1. A sequence could arise in which P1 and P2 exchange information repeatedly, while P3 is blocked waiting for a communication from P1. There is no deadlock, because P1 still active but P3 is starved here.

Cooperation Among Processes by Communication Two control problems in the case of cooperation communication: Deadlock Starvation

Process Interaction Degree of Awareness Relationship Influences That One Process Has on the Other Unaware of each other Competition Results of one process independent of the action of others Timing of process maybe affected Potential Control Problems Mutual Exclusion Deadlock Starvation Indirectly aware of each other (e.g. share object) Cooperation by sharing Results of one process may depend on information obtained from others Timing of process maybe affected Mutual Exclusion Deadlock Starvation Data Coherence Directly aware of each other (have communication primitives available to them) Cooperation by communication Results of one process may depend on information obtained from others Timing of process maybe affected Deadlock Starvation

Requirements for Mutual Exclusion Any facility or capability that is to provide support for mutual exclusion should meet the following requirements: ME must be enforced A process that halts in its non-critical section must do so without interfering with other processes. It must not be possible for a process requiring access to critical section to be delayed indefinitely A process must not be delayed access to a critical section when there is no other process using it No assumptions are made about relative process speeds or number of processes A process remains inside its critical section for a finite time only

Approaches for Mutual Exclusion 1 Software Approach 2 Hardware Support 3 Provide some level of support within the OS and programming language

Software Approach Leave the responsibility to the process that wish to execute concurrently. Thus processes, whether they are system programs or application programs, would be required to coordinate with one another to enforce mutual exclusion. No support from programming language or operating system. Disadv: Prone to high processing overhead and bugs E.g: Dekker s Algorithm and Peterson Algorithm

Hardware Support 1. Interrupt Disabling In uniprocessor system, concurrent process can t be overlapped. A process runs until it invokes an operating-system service or until it is interrupted Disabling interrupts guarantees mutual exclusion Disadv: Price high : Processor is limited in its ability to interleave programs Will not work in Multiprocessor disabling interrupts on one processor will not guarantee mutual exclusion

Hardware Support 2. Special Purpose Machine Instruction Several machine instruction that carry out two actions atomically (read & write @ read & test). Atomically The instructions are performed in single step that cannot be interrupted. Performed in a single instruction cycle. Not subject to interference from other instruction Adv: Applicable to any number of processes on either a single or multiple processor sharing main memory Simple and easy to verify It can be used to support multiple critical sections Each critical section can be verify by it owns variable.

Hardware Support DisAdv: Busy waiting is employed Process waiting to access critical section, it continues to consumes processor time Starvation is possible When a process leaves a critical section and more that one process is waiting. So the selection of process is random Deadlock If a low priority process (P1) has the critical region and a higher priority process (P2) needs the processor, the higher priority process will obtain the processor. P1 is interrupted in order to give the processor to P2. P2 attempts to use same resources as P1, but will be denied access because of the ME. P2 will be in the busy waiting loop. P1 will never be dispatched because it s priority is lower than P2.

Provide some level of support within the OS and programming language Three Approaches Semaphores Monitors Message Passing