Process Synchronization

2,222 views
2,022 views

Published on

Published in: Education
0 Comments
2 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total views
2,222
On SlideShare
0
From Embeds
0
Number of Embeds
4
Actions
Shares
0
Downloads
205
Comments
0
Likes
2
Embeds 0
No embeds

No notes for slide

Process Synchronization

  1. 1. Process Synchronization Organized By: V.A. V.A. CSED,TU
  2. 2. Disclaimer This is NOT A COPYRIGHT MATERIALContent has been taken mainly from the following books: Operating Systems Concepts By Silberschatz & Galvin , Operating systems By D M Dhamdhere, System Programming By John J Donovan etc… VA. CSED,TU
  3. 3. Process & Synchronization  Process – Program in Execution.  Synchronization – Coordination.  Independent process cannot affect or be affected by the execution of another process  Cooperating process can affect or be affected by the execution of another process  Advantages of process cooperation  Information sharing  Computation speed-up  Modularity  Convenience VA. CSED,TU
  4. 4. Buffer VA. CSED,TU
  5. 5. Bounded-Buffer – Shared-Memory Solution  Shared Data #define BUFFER_SIZE 10 typedef struct { ... } item; item buffer [BUFFER_SIZE]; int in = 0; int out = 0;  Can only use BUFFER_SIZE-1 elements VA. CSED,TU
  6. 6. Producer – Consumer VA. CSED,TU
  7. 7. Bounded-Buffer – Producer while (true) { /* Produce an item */ while (((in = (in + 1) % BUFFER SIZE count) == out) ; /* do nothing -- no free buffers */ buffer[in] = item; in = (in + 1) % BUFFER SIZE; } VA. CSED,TU
  8. 8. Bounded Buffer – Consumer while (true) { while (in == out) ; // do nothing -- nothing to consume // remove an item from the buffer item = buffer[out]; out = (out + 1) % BUFFER SIZE; return item; } VA. CSED,TU
  9. 9. Setting Final value of Counter VA. CSED,TU
  10. 10. Buffer Types  Paradigm for cooperating processes, producer process produces information that is consumed by a consumer process  Unbounded-buffer places no practical limit on the size of the buffer  Bounded-buffer assumes that there is a fixed buffer size VA. CSED,TU
  11. 11. RC & CS  Race Condition – Where several processes access and manipulate the same data concurrently and the outcome of the execution depends on the particular order in which access takes place.  Critical Section – Segment of code in which Process may be changing common variables, updating a table, writing a file and so on. VA. CSED,TU
  12. 12. Peterson’s Solution VA. CSED,TU
  13. 13. Peterson’s Solution Var flag : array [0…1] of Boolean; Turn : 0..1; Begin Flag[0] = false; Flag[1] = false; Parbegin Repeat Repeat Flag[0] = true Flag[1] = true Turn = 1 Turn = 0 While flag[1] && turn==1 While flag[0] && turn==0 Do {nothing}; Do {nothing}; {Critical Section} {Critical Section} Flag[0] = false; Flag[1] = false; {Remainder} {Remainder} Forver; Forver; Parend end VA. CSED,TU
  14. 14. Peterson’s Solution VA. CSED,TU
  15. 15. Synchronization Hardware  Many Systems provide hardware support for critical section code  Uni-Processors – Could disable Interrupts  Currently running code would execute without preemption  Generally too inefficient on multiprocessor systems  Modern machines provide special atomic hardware instructions  Atomic :- Uninterruptible  Either Test memory word and Set value  Or Swap contents of two memory words VA. CSED,TU
  16. 16. TestAndSet Instruction Definition: boolean TestAndSet (boolean *target) { boolean rv = *target; *target = TRUE; return rv: } VA. CSED,TU
  17. 17. Solution using TestAndSet  Shared Boolean variable Lock, Initialized to FALSE. Solution: do { while ( TestAndSet (&lock )) ; /* do nothing // critical section lock = FALSE; // remainder section } while ( TRUE); VA. CSED,TU
  18. 18. Swap Instruction Definition: void Swap (boolean *a, boolean *b) { boolean temp = *a; *a = *b; *b = temp: } VA. CSED,TU
  19. 19. Solution using Swap  Shared Boolean variable lock initialized to FALSE, Each process has a local Boolean variable key. Solution: do { key = TRUE; while ( key == TRUE) Swap (&lock, &key ); // critical section lock = FALSE; // remainder section } while ( TRUE); VA. CSED,TU
  20. 20. Semaphore  Synchronization tool that does not require busy waiting  Semaphore S – Integer Variable  Two standard operations modify S: wait() and signal()  Originally called P() and V()  Less complicated  Can only be accessed via two indivisible (atomic) operations  wait (S) { while S <= 0 ; // no-op S--; }  signal (S) { S++; } VA. CSED,TU
  21. 21. Semaphore as General Synchronization Tool  Counting Semaphore – Integer value can range over an unrestricted domain  Binary Semaphore – Integer value can range only between 0 and 1, Can be simpler to Implement  Also known as Mutex locks  Can implement a counting semaphore S as a binary semaphore  Provides mutual exclusion  Semaphore S; // initialized to 1  wait (S); Critical Section signal (S); VA. CSED,TU
  22. 22. Semaphore Implementation  Must guarantee that no two processes can execute wait () and signal () on the same semaphore at the same time  Thus, implementation becomes the critical section problem where the wait and signal code are placed in the critical section.  Could now have busy waiting in critical section implementation  But implementation code is short  Little busy waiting if critical section rarely occupied  Note that applications may spend lots of time in critical sections and therefore this is not a good solution. VA. CSED,TU
  23. 23. Semaphore Implementation with no Busy waiting  With each Semaphore there is an associated waiting queue. Each entry in a waiting queue has two data items:  Value (of type Integer)  Pointer to next record in the list  Two operations:  Block – Place the Process invoking the operation on the appropriate waiting queue.  Wakeup – Remove one of Processes in the waiting queue and place it in the ready queue. VA. CSED,TU
  24. 24. Semaphore Implementation with no Busy waiting (Cont.)  Implementation of WAIT: wait (S){ value--; if (value < 0) { add this process to waiting queue block(); } }  Implementation of SIGNAL: Signal (S){ value++; if (value <= 0) { remove a process P from the waiting queue wakeup(P); } } VA. CSED,TU
  25. 25. Deadlock and Starvation  Deadlock – Two or more Processes are waiting Indefinitely for an event that can be caused by only one of the waiting processes  Let S and Q be two Semaphores initialized to 1 P0 P1 wait (S); wait (Q); wait (Q); wait (S); . . . . . . signal (S); signal (Q); signal (Q); signal (S);  Starvation – Indefinite Blocking. A process may never be removed from the semaphore queue in which it is suspended. VA. CSED,TU
  26. 26. Producer Consumer VA. CSED,TU
  27. 27. Solution to PC must satisfy 3 conditions VA. CSED,TU
  28. 28. Solution to PC with Busy Wait VA. CSED,TU
  29. 29. Solution to PC with Signaling VA. CSED,TU
  30. 30. Indivisible Operations for PC VA. CSED,TU
  31. 31. Readers & Writers in Banking System VA. CSED,TU
  32. 32. Correctness Condition for R-W Problem VA. CSED,TU
  33. 33. Solution outline for R-W without Writer priority VA. CSED,TU
  34. 34. Dining Philosophers VA. CSED,TU
  35. 35. Outline of a Philosopher Process Pi VA. CSED,TU
  36. 36. An Improved Outline of a Philosopher Process VA. CSED,TU
  37. 37. Reference ListOperating Systems Concepts By Silberschatz & Galvin, Operating systems By D M Dhamdhere, System Programming By John J Donovan, www.os-book.com www.cs.jhu.edu/~yairamir/cs418/os2/sld001.htmhttp://gaia.ecs.csus.edu/~zhangd/oscal/pscheduling.html http://www.edugrid.ac.in/iiitmk/os/os_module03.htm http://williamstallings.com/OS/Animations.html etc… VA. CSED,TU
  38. 38. Thnx…VA.CSED,TU

×