Dr. D. M. Akbar Hussain DE5 Department of Electronic Systems

Transcription

1 Concurrency 1 Concurrency Execution of multiple processes. Multi-programming: Management of multiple processes within a uni- processor system, every system has this support, whether big, small or complex. Multi-processing: Management of multiple processes within a multi-processor system, servers and works stations. (Shared Memory) Distributed Processing: Management of multiple processes executing on number of distributed computer systems, for example clusters. (Do not Share Memory) 2 1

2 Concurrency Principle Interleaving: 1. In a single processor case multiple processes are interleaved in time to provide the illusion of simultaneous execution of these processes. 2. Although, it is not really parallel processing but there are benefits using such technique, apart from having overheads involved in switching of these processes. 3 Concurrency Principles Issues: 1. Basically, it is not possible to predict the speed of execution of processes. 2. Optimal allocation of resources is not possible by the o/s. 3. Sharing of global variables. 4 2

3 Concurrency Principles Pseudo Code for Demonstration: Suppose we have two or more applications reading input from the keyboard and putting the result on the screen. It would make sense to have the same procedure for all these applications and obviously it will be loaded into the global address space. Pseudo Code: function_test ( string charact) { readin (input_variable, keyboard); charact = input_variable; readout (charact, display); exit; } 5 Where is the problem P1 Process P1 has called function_test and have just read (X) the input and being interrupted, so charact = X; function_test ( string charact) { readin (input_variable, keyboard); charact = input_variable; i readout (charact, display); exit; } P1 When P1 resume it will display what? P2 Process P2 has called function_test and allowed to run till end with input Y, e.g., charact = Y. 6 3

4 How to Achieve Mutual Exclusion 7 Basics of Mutual Exclusion 1. Only one process is allowed into its critical section. 2. A process which may stop execution in non critical section must not affect/interfere with others. 3. A process should not be delayed indefinitely requiring access to critical section. 4. Any process must be allowed to enter into critical section without delay, if no process is in critical section. 5. No assumptions about speed or numbers of CPUs to be considered. 6. A process should remain in the critical section for a finite time only. 8 4

5 Operating System Concerns What are the issues o/s has to consider for concurrency: 1. O/S must keep track of all the processes (normally it is done through h PCB s). 2. O/S must allocate and de-allocate the resources for the processes. Which includes processor time, memory, files and i/o devices. 3. Protection of resources against unintended interference from other processes. 4. Result of a process must be independent of the speed at which the execution is taking place relative to the speed of other concurrent processes. 9 Operating System Concerns Degree of Awareness Relationship Influence on others Problems Unaware of others Competition 1. Result is independent of others 2. Timing may be affected Indirectly aware of others Cooperation by sharing 1. Result is not independent of others 2. Timing may be affected Directly aware of others Cooperation by communication 1. Result is not independent of others 2. Timing may be affected 1. Mutual Exclusion 2. Deadlock 3. Starvation 1. Mutual Exclusion 2. Deadlock 3. Starvation 4. Data Coherence 1. Deadlock 2. Starvation 10 5

6 Mutual Exclusion has cost? Mutual Exclusion Deadlock Starvation 11 Deadlock Suppose two processes P1 and P2 are to accomplish a task by using two resources R1 and R2 As shown here, What happened next? P1 P2 R1 Waiting (for ever) R2 12 6

7 Starvation P2 is Starved P1 P2 P3 R P1 P3 P1 P3 P1 P3. 13 Data Coherency In addition to deadlock and starvation another requirement may also be necessary, for example, suppose an application needs that a must condition should always be in placed say: a = b. In other words any process updating a must update b or vice versa, say for example a = b = 20; P1: a = a - 10; b = b - 10; P2: b = b * 2; a = a * 2; Which is fine if the consistency is achieved, but consider the following situation and both processes impose mutual exclusion; P1: a = a - 10; P2: b = b * 2; P1: b = b - 10; P2: a = a * 2; Which clearly demonstrate that a = b does not hold any more. 14 7

8 Dekkers Algorithm for ME Process 0 Process 1 Critical Section Turn 0/1 15 Dekkers algorithm Iglo (eskimoisk snehytte) 16 8

9 Dekkers algorithm There is a strict alternation rule. ME is guaranteed Consequences: 1. Execution is dictated by the slowest of the two. 2. If one is lost the other is blocked for ever. 17 Modification

10 Modification 1 Dictated by the slowest of the two. No guarantee of Mutual Exclusion: Because both can set there flags at the same time to true after one process reached at the end and setting others flag to false, so at that point both flags becomes false so now there is a chance to set both flags totrue(meaning both can enter in their critical section). 19 Modification 2 Own Flag is set outside the while loop & then checking others Flag Dictated by the slowest of the two. Guarantee Mutual Exclusion. Deadlock, if both has set the Flag to True at the same instant 20 10

11 Modification 3 Own Flag is set outside the while loop, then checking others Flag & resetting its own flag & introducing Delay Dictated by the slowest of the two Guarantee Mutual Exclusion Deadlock? Almost there 21 Correct Solution As we have observed that knowing the state of other processes is not enough to make our problem workable, basically one needs an order the way processes proceeds

12 Correct Solution 23 Correct Solution Dictated by the slowest of the two. Guarantee Mutual Exclusion. No Deadlock

13 Peterson s Solution Peterson s solution is similar but more elegant as the text says: 25 Hardware Mutual Exclusion Mutual exclusion can also be implemented in Hardware by using either interrupt handling or through special machine instructions: Interrupt Disabling: Just before entering the critical region, forcing interrupt disabling will ensure ME: Potentially system performance is degraded. No support for multi-processor system architecture

14 Machine Instruction 1. Basically two actions are performed in one cycle for these type of instruction atomically, for example, reading and writing. 2. Therefore, one can use them as they cannot be interrupted during these actions. 27 Machine Instruction Test and Set Instruction Boolean testset (int a) { if (a == 0) a = 1; return true; else return false; } 28 14

15 Machine Instruction Exchange Instruction Exchanges the contents of a register with a memory location, obviously during this, access to the memory location is blocked. void exchange (int register, memory) { int temp; temp = memory; memory = register; register = temp; } 29 Testset for ME n number of processes bolt Shared variable (int) Function_ME (process) { while true { while { (!testset (bolt)) be happy and do nothing } Enter Critical Section set bolt to 0; do remaining part } } Initially bolt is set to 0, any process finding it zero will enter into the critical section, obviously all others will go into be happy loop. Once that process leaves its critical section any other process finding bolt zero will immediately go into its critical section and so on

16 Exchange for ME n number of processes bolt Shared variable (int) Function_ME (process) { key local variable (int) while true { key = 1; while { (key!= 0) exchange (key, bolt); be happy until you get bolt zero } Enter Critical Section exchange (key, bolt); do remaining gpart } } Initially bolt is set to 0, any process finding it zero will enter into the critical section, but this time it will be through the local variable key and the bolt exchange mechanism of the exchange instruction. After completing its job, bolt is again set to 0 through the exchange instruction. 31 Plus/Minus of Machine Instruction 1. Easy to implement 2. Support for any number of processors 3. Multiple Critical section support (By using different variables) 1. Busy waiting (performance degradation) 2. Starvation is possible 3. Deadlock is possible 32 16

17 Semaphores Design of an o/s as sequential processes with a reliable mechanism of support for cooperation. Dijkstra proposed a solution based on the fundamental principle of cooperation based on signals, so that a process can be forced to stop at a required place and later starts when instructed through a signal. These signals are called semaphores, to transmit a signal the process executes signal (s) and to receive a signal it executes wait (s). Therefore, if the corresponding signals are not transmitted the process is suspended till the transmission takes place. 33 Properties of Semaphores It is initialized to a non negative value. Wait operation decrements semaphore value, if it goes negative the corresponding process is blocked. Signal operation increments semaphore value, if the value is not positive, process can be unblocked from the suspended list. Signal and Wait are atomic

18 Semaphore Primitives Semaphore could be declared as a simple structure having a variable declaration, may be an integer for count and another variable/structure for a process queue. wait (s) i l( ) count = count - 1; if count < 0 put the process in queue block the process Critical Section (if count is zero) signal (s) count = count + 1; if count 0 get a process from the queue unblock the process and put it in ready queue The order of removal from the queue is not defined, FIFO etc., the only requirement is that no process should wait indefinitely in the queue. 35 Binary Semaphores waitb (s) if count == 1 count = 0; else put the process in queue block the process signalb (s) if queue is empty count = 1; else get a process from the queue put it in ready queue 36 18

19 Semaphore Mechanism (Strong s) Suspended List Process A s = 1 Semaphore Ready List C D B Suspended List Process C s = 0 Semaphore Ready List D B A Suspended List Process B s = 0 Semaphore Ready List A C D Suspended List B A C Process D s = -3 Semaphore Ready List Suspended List B Process D s = -1 Semaphore Ready List A C Suspended List B A Process D s = -2 Semaphore Ready List C Suspended List Process D s = 0 Semaphore Ready List B A C 37 ME Using Semaphores The following pseudo ops can be used for the mutual exclusion problem: There could be n processes Each process executes wait before entering to its critical section Positive value means it can enter into critical section If the value becomes negative, process is suspended Semaphore s = 1; n = number of processes ; Process () loop wait (s) critical section signal (s) remaining execution 38 19

20 ME Using Semaphores Lock A B C 1 0 Wait (lock) Normal Execution 0 B Wait (lock) 0 0 B C C signal (lock) Wait (lock) Blocked 0 1 signal (lock) Critical Section signal (lock) 39 Producer Consumer (Binary) Produce waitb(s) Inset n = n+1 If n == 1 signalb (delay) signalb (s) Critical Section First Time only waitb(delay) waitb(s) Take n = n - 1 signalb (s) consume If n == 0 waitb (delay) Correct Solution? 40 20

21 Possible Scenario Producer Consumer s n Delay waitb (s) n=n If n==1 then signalb (delay) signalb (s) waitb (delay) waitb (s) n=n signalb (s) waitb (s) n=n If n==1 then signalb (delay) signalb (s) If n==0 then waitb (delay) waitb (s) n=n signalb (s) If n==0 then waitb (delay) waitb (s) n=n signalb (s) Producer Consumer (Binary) Produce waitb(s) Inset n = n+1 If n = 1 SignalB (delay) signalb (s) Critical Section First Time only n = n - 1 waitb(delay) waitb(s) Take signalb (s) consume If m = 0 WaitB (delay) m = n Correct Solution 42 21

22 Producer Consumer (Bounded Buffer) Previously for this problem an infinite buffer was consider, now for realistic situations one has bounded buffer (BB) some thing like a circular buffer, therefore, it can be implemented in the following way: Producer: Consumer: Loop produce if ((in + 1)%n) == out {do nothing, remain here} put[in] in = (in + 1)%n Loop if (in == out) {do nothing, remain here} take[out] out = (out + 1)%n consume out in [1] [2] [3] [4] [5] [6] [n] Filled slots 43 22