Process Synchronization (Part I)

Transcription

1 Process Synchronization (Part I) Amir H. Payberah Amirkabir University of Technology (Tehran Polytechnic) Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 1 / 44

2 Motivation Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 2 / 44

3 Background Processes can execute concurrently. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 3 / 44

4 Background Processes can execute concurrently. Concurrent access to shared data may result in data inconsistency. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 3 / 44

5 Background Processes can execute concurrently. Concurrent access to shared data may result in data inconsistency. Maintaining data consistency requires mechanisms to ensure the orderly execution of cooperating processes. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 3 / 44

6 Producer-Consumer Problem Providing a solution to the producer-consumer problem that fills all the buffers. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 4 / 44

7 Producer-Consumer Problem Providing a solution to the producer-consumer problem that fills all the buffers. Having an integer counter that keeps track of the number of full buffers. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 4 / 44

8 Producer-Consumer Problem Providing a solution to the producer-consumer problem that fills all the buffers. Having an integer counter that keeps track of the number of full buffers. Initially, counter is set to 0. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 4 / 44

9 Producer-Consumer Problem Providing a solution to the producer-consumer problem that fills all the buffers. Having an integer counter that keeps track of the number of full buffers. Initially, counter is set to 0. The producer produces a new buffer: increment the counter Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 4 / 44

10 Producer-Consumer Problem Providing a solution to the producer-consumer problem that fills all the buffers. Having an integer counter that keeps track of the number of full buffers. Initially, counter is set to 0. The producer produces a new buffer: increment the counter The consumer consumes a buffer: decrement the counter Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 4 / 44

11 Producer Producer while (true) { /* produce an item in next produced */ while (counter == BUFFER_SIZE); /* do nothing */ buffer[in] = next_produced; in = (in + 1) % BUFFER_SIZE; } counter++; Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 5 / 44

12 Consumer Consumer while (true) { while (counter == 0); /* do nothing */ next_consumed = buffer[out]; out = (out + 1) % BUFFER_SIZE; counter--; /* consume the item in next consumed */ } Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 6 / 44

13 Race Condition counter++ could be implemented as register1 = counter register1 = register1 + 1 counter = register1 Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 7 / 44

14 Race Condition counter++ could be implemented as register1 = counter register1 = register1 + 1 counter = register1 counter-- could be implemented as register2 = counter register2 = register2-1 counter = register2 Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 7 / 44

15 Race Condition counter++ could be implemented as register1 = counter register1 = register1 + 1 counter = register1 counter-- could be implemented as register2 = counter register2 = register2-1 counter = register2 Consider this execution interleaving with count = 5 initially: S0: producer: register1 = counter: register1 = 5 S1: producer: register1 = register1 + 1: register1 = 6 S2: consumer: register2 = counter: register2 = 5 S3: consumer: register2 = register2-1: register2 = 4 S4: producer: counter = register1: counter = 6 S5: consumer: counter = register2: counter = 4 Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 7 / 44

16 The Critical-Section (CS) Problem Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 8 / 44

17 The Critical-Section Problem (1/2) Consider system of n processes {p 0, p 1,, p n 1 }. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 9 / 44

18 The Critical-Section Problem (1/2) Consider system of n processes {p 0, p 1,, p n 1 }. Each process has CS segment of code. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 9 / 44

19 The Critical-Section Problem (1/2) Consider system of n processes {p 0, p 1,, p n 1 }. Each process has CS segment of code. Process may be changing common variables, updating table, writing file, etc. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 9 / 44

20 The Critical-Section Problem (1/2) Consider system of n processes {p 0, p 1,, p n 1 }. Each process has CS segment of code. Process may be changing common variables, updating table, writing file, etc. When one process in CS, no other may be in its CS. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 9 / 44

21 The Critical-Section Problem (2/2) CS problem is to design protocol to solve this. Each process must ask permission to enter CS in entry section, may follow CS with exit section, then remainder section. General structure of process P i. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 10 / 44

22 CS Problem Solution Requirements (1/3) Mutual Exclusion: if process P i is executing in its CS, then no other processes can be executing in their CSs. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 11 / 44

23 CS Problem Solution Requirements (2/3) Progress: if no process is executing in its CS and there exist some processes that wish to enter their CS, then the selection of the processes that will enter the CS next cannot be postponed indefinitely. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 12 / 44

24 CS Problem Solution Requirements (3/3) Bounded Waiting: a bound must exist on the number of times that other processes are allowed to enter their CSs after a process has made a request to enter its CS and before that request is granted. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 13 / 44

25 CS Handling in OS Two approaches depending on if kernel is preemptive or nonpreemptive. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 14 / 44

26 CS Handling in OS Two approaches depending on if kernel is preemptive or nonpreemptive. Preemptive: allows preemption of process when running in kernel mode. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 14 / 44

27 CS Handling in OS Two approaches depending on if kernel is preemptive or nonpreemptive. Preemptive: allows preemption of process when running in kernel mode. Non-preemptive: runs until exits kernel mode, blocks, or voluntarily yields CPU. Essentially free of race conditions in kernel mode. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 14 / 44

28 Peterson s Solution Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 15 / 44

29 Peterson s Solution Two-process solution. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 16 / 44

30 Peterson s Solution Two-process solution. The two processes share two variables: int turn boolean flag[2] Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 16 / 44

31 Peterson s Solution Two-process solution. The two processes share two variables: int turn boolean flag[2] turn: indicates whose turn it is to enter the CS. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 16 / 44

32 Peterson s Solution Two-process solution. The two processes share two variables: int turn boolean flag[2] turn: indicates whose turn it is to enter the CS. flag: indicates if a process is ready to enter the CS, i.e., flag[i] = true implies that process P i is ready. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 16 / 44

33 Algorithm for Process P i Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 17 / 44

34 CS Requirements Provable that the three CS requirement are met: Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 18 / 44

35 CS Requirements Provable that the three CS requirement are met: 1 Mutual exclusion is preserved: P i enters CS only if: either flag[j] = false or turn = i Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 18 / 44

36 CS Requirements Provable that the three CS requirement are met: 1 Mutual exclusion is preserved: P i enters CS only if: either flag[j] = false or turn = i 2 Progress requirement is satisfied. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 18 / 44

37 CS Requirements Provable that the three CS requirement are met: 1 Mutual exclusion is preserved: P i enters CS only if: either flag[j] = false or turn = i 2 Progress requirement is satisfied. 3 Bounded-waiting requirement is met. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 18 / 44

38 Synchronization Hardware Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 19 / 44

39 Synchronization Hardware Many systems provide hardware support for implementing the CS code. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 20 / 44

40 Synchronization Hardware Many systems provide hardware support for implementing the CS code. Uniprocessors: could disable interrupts: running code without preemption. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 20 / 44

41 Synchronization Hardware Many systems provide hardware support for implementing the CS code. Uniprocessors: could disable interrupts: running code without preemption. Modern machines provide atomic hardware instructions: atomic = non-interruptible Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 20 / 44

42 Solution to CS Problem Using Locks Protecting CS via locks. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 21 / 44

43 Atomic Instructions test and set compare and swap Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 22 / 44

44 test and set Instruction Executed atomically. Returns the original value of passed parameter. Set the new value of passed parameter to true. boolean test_and_set(boolean *target) { boolean rv = *target; *target = true; return rv; } Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 23 / 44

45 Solution Using test and set Shared boolean variable lock, initialized to false. do { while (test_and_set(&lock)); /* do nothing */ /* critical section */ lock = false; /* remainder section */ } while (true); Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 24 / 44

46 compare and swap Instruction Executed atomically. Returns the original value of passed parameter value. Set the value the value of the passed parameter new value but only if value == expected. int compare_and_swap(int *value, int expected, int new_value) { int temp = *value; if (*value == expected) *value = new_value; } return temp; Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 25 / 44

47 Solution Using compare and swap Shared integer lock initialized to 0. do { while (compare_and_swap(&lock, 0, 1)!= 0); /* do nothing */ /* critical section */ lock = 0; /* remainder section */ } while (true); Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 26 / 44

48 compare and swap and compare and swap Problem Although these algorithms satisfy the mutual-exclusion requirement, they do not satisfy the bounded-waiting requirement. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 27 / 44

49 Mutex Locks Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 28 / 44

50 Mutex Locks (1/2) Previous solutions are complicated and generally inaccessible to application programmers. OS designers build software tools to solve CS problem. Simplest is mutex lock. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 29 / 44

51 Mutex Locks (2/2) Protect a CS by first acquire() a lock then release() the lock. Boolean variable indicating if lock is available or not. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 30 / 44

52 Mutex Locks (2/2) Protect a CS by first acquire() a lock then release() the lock. Boolean variable indicating if lock is available or not. Calls to acquire() and release() must be atomic. Usually implemented via hardware atomic instructions. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 30 / 44

53 Mutex Locks (2/2) Protect a CS by first acquire() a lock then release() the lock. Boolean variable indicating if lock is available or not. Calls to acquire() and release() must be atomic. Usually implemented via hardware atomic instructions. But this solution requires busy waiting. This lock therefore called a spinlock. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 30 / 44

54 acquire() and release() acquire() { while (!available); /* busy wait */ } available = false; release() { available = true; } Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 31 / 44

55 Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 32 / 44

56 Initializing Mutexes Mutexes are represented by the pthread mutex t object. /* define and initialize a mutex named mutex */ pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 33 / 44

57 Locking Mutexes pthread mutex lock() locks (acquires) a pthreads mutex. #include <pthread.h> int pthread_mutex_lock(pthread_mutex_t *mutex); Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 34 / 44

58 Unlocking Mutexes pthread mutex unlock() unlocks (releases) a pthreads mutex. #include <pthread.h> int pthread_mutex_unlock(pthread_mutex_t *mutex); Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 35 / 44

59 Mutex Example static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; int withdraw(struct account *account, int amount) { pthread_mutex_lock(&mutex); const int balance = account->balance; if (balance < amount) { pthread_mutex_unlock(&mutex); return -1; } account->balance = balance - amount; pthread_mutex_unlock(&mutex); disburse_money(amount); return 0; } Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 36 / 44

60 Condition Variable Mutex is very resource consuming since the thread would be continuously busy in this activity. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 37 / 44

61 Condition Variable Mutex is very resource consuming since the thread would be continuously busy in this activity. A condition variable is a way to achieve the same goal without polling. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 37 / 44

62 Condition Variable Mutex is very resource consuming since the thread would be continuously busy in this activity. A condition variable is a way to achieve the same goal without polling. A condition variable allows one thread to inform other threads about changes in the state of a shared variable. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 37 / 44

63 Waiting on Condition Variables pthread cond wait() must be called after pthread mutex lock() and before pthread mutex unlock(). pthread cond wait() release the mutex lock while it is waiting, so that pthread cond signal(), which is also called in the mutex should get access and can give signal to waiting thread to awake. #include <pthread.h> int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex); Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 38 / 44

64 Signaling on Condition Variables This routine is used to wakeup the thread which is waiting for any condition to occur. If in any case pthread cond signal() calls first before the execution of pthread cond wait() then it cannot awake the thread which is waiting. #include <pthread.h> int pthread_cond_signal(pthread_cond_t *cond); Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 39 / 44

65 Condition Variable Calling Format static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER; static pthread_cond_t cond = PTHREAD_COND_INITIALIZER; s = pthread_mutex_lock(&mtx); while (/* Check that shared variable is not in state we want */ ) pthread_cond_wait(&cond, &mtx); /* Now shared variable is in desired state; do some work */ s = pthread_mutex_unlock(&mtx); Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 40 / 44

66 Condition Variable Example pthread_mutex_t count_lock; pthread_cond_t count_nonzero; unsigned count; decrement_count() { pthread_mutex_lock(&count_lock); while (count == 0) pthread_cond_wait(&count_nonzero, &count_lock); count = count - 1; pthread_mutex_unlock(&count_lock); } increment_count() { pthread_mutex_lock(&count_lock); if (count == 0) pthread_cond_signal(&count_nonzero); count = count + 1; pthread_mutex_unlock(&count_lock); } Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 41 / 44

67 Summary Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 42 / 44

68 Summary Access to shared data Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 43 / 44

69 Summary Access to shared data Race condition Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 43 / 44

70 Summary Access to shared data Race condition The critical-section problem Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 43 / 44

71 Summary Access to shared data Race condition The critical-section problem Requirements: mutual-exclusion, progress, bounding waiting Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 43 / 44

72 Summary Access to shared data Race condition The critical-section problem Requirements: mutual-exclusion, progress, bounding waiting Peterson solution Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 43 / 44

73 Summary Access to shared data Race condition The critical-section problem Requirements: mutual-exclusion, progress, bounding waiting Peterson solution Synchronization hardware Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 43 / 44

74 Summary Access to shared data Race condition The critical-section problem Requirements: mutual-exclusion, progress, bounding waiting Peterson solution Synchronization hardware Mutex lock and condition variable Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 43 / 44

75 Questions? Acknowledgements Some slides were derived from Avi Silberschatz slides. Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 44 / 44