操作系统课件04

}
08／3／13
3
os@sei.ecnu
Race condition
●
count++
could be implemented as
●
count--
could be implemented as
register1 = count register1 = register1 + 1 count = register1
08／3／13
6
os@sei.ecnu
It's non-trivial!
●
A naïve solution:
if (!lock) { lock = true; // critical section lock = false; }
●
Context switch after the testing and before the locking Really hard to debug!
●
08／3／13
7
os@sei.ecnu
Second try
●
Lock before testing? How?
–
Use locks with label
lockB = true; if (!lockA) { // critical section } lockB = false;
lockA = true; if (!lockB) { // critical section } lockA = false;
●
It works, but rather complicated
10 os@sei.ecnu
08／3／13
The roadmap
●
Hardware solutions
– – –
●
Higher-level API
– ts Test & set Compare & swap
– –
Can't let users do this! Doesn't work in multi-processing!
08／3／13
12
os@sei.ecnu
Hardware solutions: test&set instruction
boolean TestAndSet (boolean *target) { boolean rv = *target; *target = TRUE; return rv: }
register1 = count
{register1 {register2 {count {count
= 5} = 6}
register1 = register1 + 1 = count
{register1
= 5}
S2: consumer execute register2 S3: consumer execute register2 S4: producer execute count S5: consumer execute count
●
Context switch after the locking and before the testing Really hard to debug!
8 os@sei.ecnu
●
08／3／13
Third try
●
Lock before testing? How?
lockA = true; while (lockB); //X // critical section lockA = false; lockB = true; if (!lockA) { //Y /* critical section */} lockB = false;
Introduction to Operating Systems
Lecture 4: Process synchronization QIAN Weining wnqian@ Institute of Massive Computing East China Normal University
08／3／13 16 os@sei.ecnu
{
critical section remainder section
lock = false;
Busy waiting
●
Busy waiting: thread consumes cycles while waiting:
– –
while ( TestAndSet (&lock )); while ( key == true) Swap (&lock, &key );
●
register2 = count register2 = register2 - 1 count = register2
Consider this execution interleaving with “count = 5” initially:
– – – – – –
S0: producer execute S1: producer execute
Outline
●
The synchronization problem A roadmap of solutions Hardware solutions Semaphore A brief introduction to monitor Classic problems
●
●
●
●
●
08／3／13
2
os@sei.ecnu
The synchronization problem
●
Producer:
/* produce an item and put in nextProduced */ while (count == BUFFER_SIZE) ; // do nothing buffer [in] = nextProduced; in = (in + 1) % BUFFER_SIZE; count++;
Locks Semaphores Monitors Send/receive
08／3／13
11
os@sei.ecnu
Hardware solutions: Disable interrupts
●
Naïve approach:
– –
LockAcquire() {disable ints;} LockRelease() {enable ints;}
/* do nothing */ critical section remainder section
lock = false;
Hardware solutions: swap instruction
void Swap (boolean *a, boolean *b) { boolean temp = *a; *a = *b; *b = temp: }
Let's try again!
●
Peterson's algorithm
while (true) { lock[i] = true; turn = j; while (lock[j] && turn == j); // critical section lock[i] = false; // remain section }
●
It works:
– –
at X: if B is not locked, enter CS; otherwise wait; at Y: if A is not locked, enter CS; otherwise leave
●
Not symmetric!
9 os@sei.ecnu
08／3／13
08／3／13
13
os@sei.ecnu
Hardware solutions: test&set instruction
init: lock = false; ... while (true) { while ( TestAndSet (&lock )) ; // // }
08／3／13 14 os@sei.ecnu
●
Critical section: piece of code that only one thread can execute at once. Only one thread at a time will get into this section of code.
– –
Critical section is the result of mutual exclusion Critical section and mutual exclusion are two ways of describing the same thing
– –
●
●
Assume that each process executes at a nonzero speed No assumption concerning relative speed of the N processes
5 os@sei.ecnu
08／3／13
Critical section
08／3／13
15
os@sei.ecnu
Hardware solutions: swap instruction
init: lock = false; ... while (true) key = true; while ( key == true) Swap (&lock, &key ); // // }
= register2 - 1