1 / 81

Chapter 7: Process Synchronization

Chapter 7: Process Synchronization. Background The Critical-Section Problem Synchronization Hardware Semaphores Classical Problems of Synchronization Critical Regions Monitors Synchronization in Solaris 2 & Windows 2000. Background.

hidi
Télécharger la présentation

Chapter 7: Process Synchronization

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Chapter 7: Process Synchronization • Background • The Critical-Section Problem • Synchronization Hardware • Semaphores • Classical Problems of Synchronization • Critical Regions • Monitors • Synchronization in Solaris 2 & Windows 2000 Operating System Concepts

  2. Background • Concurrent access to shared data may result in data inconsistency. • Maintaining data consistency requires mechanisms to ensure the orderly execution of cooperating processes. • Shared-memory solution to bounded-butter problem (Chapter 4) allows at most n – 1 items in buffer at the same time. A solution, where all N buffers are used is not simple. • Suppose that we modify the producer-consumer code by adding a variable counter, initialized to 0 and incremented each time a new item is added to the buffer Operating System Concepts

  3. Bounded-Buffer • Shared data #define BUFFER_SIZE 10 typedef struct { . . . } item; item buffer[BUFFER_SIZE]; int in = 0; int out = 0; int counter = 0; Operating System Concepts

  4. Bounded-Buffer • Producer process item nextProduced; while (1) { while (counter == BUFFER_SIZE) ; /* do nothing */ buffer[in] = nextProduced; in = (in + 1) % BUFFER_SIZE; counter++; } Operating System Concepts

  5. Bounded-Buffer • Consumer process item nextConsumed; while (1) { while (counter == 0) ; /* do nothing */ nextConsumed = buffer[out]; out = (out + 1) % BUFFER_SIZE; counter--; } Operating System Concepts

  6. Bounded Buffer • The statementscounter++;counter--;must be performed atomically.(原子地) • Atomic operation means an operation that completes in its entirety without interruption. (原子操作) Operating System Concepts

  7. Bounded Buffer • The statement “count++” may be implemented in machine language as:register1 = counter register1 = register1 + 1counter = register1 • The statement “count—” may be implemented as:register2 = counterregister2 = register2 – 1counter = register2 Operating System Concepts

  8. Bounded Buffer • If both the producer and consumer attempt to update the buffer concurrently, the assembly language statements may get interleaved. • Interleaving depends upon how the producer and consumer processes are scheduled. Operating System Concepts

  9. Bounded Buffer • Assume counter is initially 5. One interleaving of statements is:producer: register1 = counter (register1 = 5)producer: register1 = register1 + 1 (register1 = 6)consumer: register2 = counter (register2 = 5)consumer: register2 = register2 – 1 (register2 = 4)producer: counter = register1 (counter = 6)consumer: counter = register2 (counter = 4) • The value of count may be either 4 or 6, where the correct result should be 5. Operating System Concepts

  10. Another example two processes p0,p1, share a variable:int total(initialized as 0 ) ; Both of them execute the following program concurrently: p0,p1: { int count; for (count=1; count <=50; count++) total = total + 1 ; } Question: what is the probable result of “total”?(upper limit and lower limit) Operating System Concepts

  11. Race Condition • Race condition: The situation where several processes access – and manipulate shared data concurrently. The final value of the shared data depends upon how these processes interleave. • To prevent race conditions, concurrent processes must be synchronized. Operating System Concepts

  12. The Critical-Section Problem • n processes all competing to use some shared data • The shared data can be accessed only by one process at a time(we call this kind of data as “critical resource”) • Each process has a code segment, called critical section, in which the shared data is accessed. • Problem – ensure that when one process is executing in its critical section, no other process is allowed to execute in its critical section. Operating System Concepts

  13. Solution to Critical-Section Problem Three requirements must be satisfied: （三个必须） 1. Mutual Exclusion. If process Pi is executing in its critical section, then no other processes can be executing in their critical sections.(每次最多只有一个进程在CS) 2. Progress. If no process is executing in its critical section and there exist some processes that wish to enter their critical section, then the selection of the processes that will enter the critical section next cannot be postponed indefinitely.(没有进程在CS,若有多个进程申请进入CS，应在有限时间内让其中之一进入，而不应互相阻塞，以至于各进程都无法进入) 3. Bounded Waiting. A bound must exist on the number of times that other processes are allowed to enter their critical sections after a process has been admitted to enter its critical section. No starvation(进程允许进入CS后,将在有限时间内离开CS并允许其他进程进入) Two assumptions（二个前提） • Assume that each process executes at a nonzero speed • No assumption concerning relative speed of the n processes. Operating System Concepts

  14. Methods to solve the CS Problem 1. Software solution. To solve the CS problem by the user processes themselves. No need of operating system support or special programming language. 2. Hardware support. To rely on special hardware support ( e.g. interrupt disabling, special machine instructions) 3. Operating System support. OS provides services(usually system calls) to solve the CS problem. Operating System Concepts

  15. Software solution: Initial Attempts to Solve Problem • Only 2 processes, P0 and P1 • General structure of process Pi(other process Pj) do { entry section critical section exit section remainder section } while (1); • Processes may share some common variables to synchronize their actions. • Entry section: code requesting for entering CS • Exit section: code releasing resources Operating System Concepts

  16. Algorithm 1 • Shared variables: • int turn;initially turn = 0 • turn = i Pi can enter its critical section • Process Pi do { while (turn != i) ; critical section turn = j; reminder section } while (1); • Satisfies mutual exclusion, but not progress(必须交替进入) Operating System Concepts

  17. Algorithm 2 • Shared variables • boolean flag[2];initially flag [0] = flag [1] = false. • flag [i] = true Pi ready to enter its critical section • Process Pi do { flag[i] := true; while (flag[j]) ; critical section flag [i] = false; remainder section } while (1); • Satisfies mutual exclusion, but not progress requirement.(互相谦让) Operating System Concepts

  18. Algorithm 3(Peterson) • Combined shared variables of algorithms 1 and 2. • Process Pi do { flag [ i ]:= true; turn = j; while (flag [ j ] and turn = j) ; critical section flag [ i ] = false; remainder section } while (1); • Meets all three requirements; solves the critical-section problem for two processes. Operating System Concepts

  19. Proof of Algorithm 3 • Mutual exclusion 1. Pi and Pj can enter CS almost simultaneously only if turn=i and turn=j (impossible) 2. If Pi entered CS in advance, Pj must be loop in while • Progress 1. If only Pi wants to enter CS, Pj does not want to enter CS, then flag[ j ] = false. Pi will enter CS immediately. 2. If Pi and Pj all want to enter CS, they cannot both be blocked in loop(turn = i or turn = j) • Bounded-waiting If Pj exits CS, it will reset flag[ j ]=false. If Pj has time to set flag[ j ]=true, it must also set turn = j, allowing Pi to enter CS. Operating System Concepts

  20. Bakery’s Algorithm • Before entering its critical section, process receives a number. Holder of the smallest number enters the critical section. • If processes Pi and Pj receive the same number, if i < j, then Pi is served first; else Pj is served first. • The numbering scheme always generates numbers in increasing order of enumeration; i.e., 1,2,3,3,3,3,4,5... Critical section for n processes Operating System Concepts

  21. Bakery’s Algorithm (cont.) • Notation ： lexicographical order (ticket #, process id #) • (a,b) < (c,d) if a < c or if a = c and b < d • max (a0,…, an-1) is a minimum number, k, such that k ai for i = 0, …, n – 1 • Shared data boolean choosing[n]; int number[n]; Data structures are initialized to false and 0 respectively Operating System Concepts

  22. Bakery’s Algorithm (cont.) do { choosing[i] = true; number[i] = max(number[0], number[1], …, number [n – 1])+1; choosing[i] = false; for (j = 0; j < n; j++) { while (choosing[j]) ; while (number[j] != 0 && (number[j],j) < (number[i],i)) ; } critical section number[i] = 0; remainder section } while (1); Operating System Concepts

  23. Synchronization Hardware • Disabling interrupt: sometimes impossible(e.g. clock interrupt, SMP) • Test-and-set instruction: Test and modify the content of a word atomically. boolean TestAndSet(boolean &target) { boolean rv = target; // test first tqrget = true; // set next return rv; } Operating System Concepts

  24. Mutual Exclusion with Test-and-Set • Shared data: boolean lock = false; • Process Pi do { while (TestAndSet(lock)) ; critical section lock = false; remainder section } Operating System Concepts

  25. Synchronization Hardware • Swap instruction: Atomically swap two variables. void Swap(boolean &a, boolean &b) { boolean temp = a; a = b; b = temp; } Operating System Concepts

  26. Mutual Exclusion with Swap-- No bounded-waiting • Shared data (initialized to false): boolean lock; • Process Pi do { key = true; while (key == true) //获得lock值为false的进程能进入 Swap(lock,key); critical section lock = false; remainder section } Operating System Concepts

  27. Hardware solution features • No limit on processes and CPUs • Simple and easy to verify • Busy-waiting is required • May cause starvation(do not satisfy bounded-waiting): selection of ready process to run is arbitrarily Operating System Concepts

  28. Mutual Exclusion with TestAndSet-- Bounded-waiting • Shared data (initialized to false): boolean lock; boolean waiting[n]; • Process Pi do { waiting[ i ] = true; key = true; while (waiting[ i ] && key) key = TestAndSet(lock); waiting[ i ] = false; critical section j = ( i + 1) % n; while(( j != i) && !waiting[ j ]) j = ( j + 1 ) %n; if ( j == i ) lock = false; else waiting[ j ] = false; remainder section } Operating System Concepts

  29. Operating system support: Semaphores • Synchronization tool that does not require busy waiting. • Semaphore S – integer variable • can only be accessed via two indivisible (atomic) operations wait (S): //(也叫P操作) while S 0 do no-op;S--; signal (S): //(也叫V操作) S++; Operating System Concepts

  30. Critical Section of n Processes • Shared data: semaphore mutex; //initially mutex = 1 • Process Pi: do { wait(mutex);critical section signal(mutex); remainder section} while (1); Operating System Concepts

  31. Semaphore Implementation • Define a semaphore as a record typedef struct { int value; struct process *queue; } semaphore; • Assume two simple operations: • block suspends the process that invokes it. • wakeup(P) resumes the execution of a blocked process P. Operating System Concepts

  32. Implementation • Semaphore operations now defined as wait(S): S.value- -; if (S.value < 0) { add this process to S.queue; block; } signal(S): S.value++; if (S.value <= 0) { remove a process P from S.queue; wakeup(P); } Operating System Concepts

  33. Semaphore as a General Synchronization Tool • Execute B in Pj only after A executed in Pi • Use semaphore flag initialized to 0 • Code: Pi Pj   Await(flag) signal(flag) B Operating System Concepts

  34. 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 P0P1 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. Operating System Concepts

  35. Two Types of Semaphores • 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. • Can implement a counting semaphore S using binary semaphores. Operating System Concepts

  36. Binary semaphores(Mutex) waitB(S): if (S.value = 1) { S.value := 0; } else { block this process place this process in S.queue } signalB(S): if (S.queue is empty) { S.value := 1; } else { remove a process P from S.queue place this process P on ready list } Operating System Concepts

  37. Implementing S using Binary Semaphores • Data structures: binary-semaphore S1, S2; int C: • Initialization: S1 = 1 S2 = 0 C = initial value of semaphore S Operating System Concepts

  38. Implementing S • wait operation wait(S1); C--; if (C < 0) { signal(S1); wait(S2); } signal(S1); • signal operation wait(S1); C ++; if (C <= 0) signal(S2); else signal(S1); Operating System Concepts

  39. Classical Problems of Synchronization • A semaphore represents a shared data, its initialized value is the number of processes that can access the shared data simultaneously(一个信号量代表一个共享资源，其初值表示可以同时访问该共享资源的进程数) • Bounded-Buffer Problem • Readers and Writers Problem • Dining-Philosophers Problem Operating System Concepts

  40. Bounded-Buffer Problem • Shared datasemaphore full, empty, mutex;Initially:full = 0, empty = n, mutex = 1 Operating System Concepts

  41. Bounded-Buffer Problem Producer Process do { … produce an item in nextp … wait(empty); wait(mutex); … add nextp to buffer … signal(mutex); signal(full); } while (1); do { wait(full) wait(mutex); … remove an item from buffer to nextc … signal(mutex); signal(empty); … consume the item in nextc … } while (1); Operating System Concepts

  42. Bounded-Buffer Problem Consumer Process do { wait(full) wait(mutex); … remove an item from buffer to nextc … signal(mutex); signal(empty); … consume the item in nextc … } while (1); Operating System Concepts

  43. Readers-Writers Problem • Problem description: 读者只能读取共享数据，写者可以读写共享数据。写者只有一人，读者可以有多人。读者和写者不能共存 • Shared datasemaphore mutex //互斥访问readcount semaphore wrt; //读者和写者不能共存Initiallymutex = 1, wrt = 1, readcount = 0 //读者人数 Operating System Concepts

  44. Readers-Writers Problem Writer Process wait(wrt); //申请进入 … writing is performed … signal(wrt); //离开 Operating System Concepts

  45. Reader Process writer: wait(wrt); //申请进入 … writing is performed … signal(wrt); //离开 reader:wait(mutex); //申请访问readcount readcount++; if (readcount == 1) //如果是第一个读者，禁止写者进入 wait(wrt); signal(mutex); //释放访问readcount的锁 … reading is performed … wait(mutex); //申请访问readcount readcount--; if (readcount == 0) //如果没有读者了，应该允许写者进入 signal(wrt); signal(mutex): //释放访问readcount的锁 Operating System Concepts

  46. Dining-Philosophers Problem • Shared data semaphore chopstick[5]:=1, count := 4 Operating System Concepts

  47. Dining-Philosophers Problem • Philosopher i: do { wait(count); wait(chopstick[i]) //want to pick up left chopstick wait(chopstick[(i+1) % 5]) //the right one … eat … signal(chopstick[i]); //release left signal(chopstick[(i+1) % 5]);//release right signal(count); … think … } while (1); Operating System Concepts

  48. 例题 有n个进程（P1，P2，…，Pn）向容量为M的缓冲区写数据，每个进程一次写1个数据，当缓冲区写满时，另一个读进程Pr一次将M个数据全部读完，如此反复。请用信号量解决这些进程的同步互斥问题。 答：本题中需要定义下述变量和信号量： data_type buffer[M]; /* data_type对应于所需要的数据类型，如int、float等 */ int in=0； /* 用来指示下一个可存放数据的缓冲区 */ semaphore empty=M; /* 对应空闲的缓冲区 */ semaphore full=0; /* 对应缓冲区中的数据 */ semaphore mutex=1; /* 用来实现Pi进程对变量in的互斥访问 */ 进程Pi可描述为： Pi(){ while(1){ P(empty); P(mutex); 向缓冲区buffer[in]中写数据； in=(in+1)%M; V(mutex); V(full); } } 进程Pr可描述为： Pr(){ int i; while(1){ for(i=0;i<M;i++) P(full); 取出缓冲buffer[0]到buffer[M-1]中的数据； for(i=0;i<M;i++) V(empty); } } Operating System Concepts

  49. 思考题 • 有一个仓库存放两种零件A和B，最大库容量各为m个。有一车间不断地取A和B进行装配，每次各取一个。有两种供应商分别不断地供应A和B。为保证齐套和合理库存，当某种零件的数量比另一种的数量超过n(n<m)个时，暂停对数量大的零件进货，集中补充数量少的零件。试用信号量正确地实现之。 Operating System Concepts

  50. Unix Semaphores • Are a generalization of the counting semaphores (more operations are permitted). • A semaphore includes: • the current value S of the semaphore(non-negative integer) • number of processes waiting for S to increase • number of processes waiting for S to be 0 • We have queues of processes that are blocked on a semaphore • The system call semget creates an array of semaphores • The system call semop performs a list of operations: one on each semaphore (atomically) Operating System Concepts

More Related