Transcript Kritisk sektion

Kapitel 6: Processsynkronisering
Operating System Concepts – 8th Edition,
Silberschatz, Galvin and Gagne ©2009
Bakgrund
 Samarbetande processer delar data med
varandra – kan leda till datainkonsistens
 Vi behöver mekanismer som ser till att
samarbetande processer exekverar korrekt
 Producent/konsument-problemet:
Producent-processen producerar (skriver)
information som konsument-processen
konsumerar (läser)
 Vi har en buffert som delas av båda
processerna + en räknare som håller koll
på antal element i bufferten
Operating System Concepts – 8th Edition
6.2
Silberschatz, Galvin and Gagne ©2009
Producent
while (true) {
/* produce an item and put in nextProduced */
while (count == BUFFER_SIZE)
; // do nothing
buffer [in] = nextProduced;
in = (in + 1) % BUFFER_SIZE;
count++;
}
Operating System Concepts – 8th Edition
6.3
Silberschatz, Galvin and Gagne ©2009
konsument
while (true) {
while (count == 0)
; // do nothing
nextConsumed = buffer[out];
out = (out + 1) % BUFFER_SIZE;
count--;
/* consume the item in nextConsumed
}
Operating System Concepts – 8th Edition
6.4
Silberschatz, Galvin and Gagne ©2009
Race Condition

count++ kan implementeras som
register1 = count
register1 = register1 + 1
count = register1

count-- kan implementeras som
register2 = count
register2 = register2 - 1
count = register2

Dessa instruktioner kan exekvera enligt följande: (count = 5 från början)
S0: producer execute register1 = count {register1 = 5}
S1: producer execute register1 = register1 + 1 {register1 = 6}
S2: consumer execute register2 = count {register2 = 5}
S3: consumer execute register2 = register2 - 1 {register2 = 4}
S4: producer execute count = register1 {count = 6 }
S5: consumer execute count = register2 {count = 4}
Operating System Concepts – 8th Edition
6.5
Silberschatz, Galvin and Gagne ©2009
Problemet med den kritiska sektionen
 Felet med föregående kod var att båda processerna fick
manipulera den gemensamma variabeln count samtidigt
 Kritisk sektion – Ett segment med kod där processen
kan uppdatera gemensamma variabler, skriva till en fil
mm
 Två processer kan inte tillåtas att exekvera i sin kritiska
sektion samtidigt
 Vi behöver ett protokoll för att lösa problemet

En process måste be om tillåtelse innan den går in i
sin kritiska sektion
Operating System Concepts – 8th Edition
6.6
Silberschatz, Galvin and Gagne ©2009
Generell struktur hos en typisk process
do {
entry section
critical section
exit section
remainder section
} while (TRUE);
Operating System Concepts – 8th Edition
6.7
Silberschatz, Galvin and Gagne ©2009
Protokollet måste uppfylla tre krav
1.
Mutual Exclusion - om process Pi exekverar i sin
kritiska sektion får ingen annan process exekvera i sin
kritiska sektion
2. Progress – om det finns processer som vill exekvera i
sin kritiska sektion (och ingen annan process gör det)
måste en process väljas inom rimlig tid
3. Bounded Waiting - det måste finnas ett tak på antalet
gånger andra processer får exekvera i sina kritiska
sektioner efter det att en process har begärt att få
exekvera i sin kritiska sektion och innan begäran blir
beviljad
Operating System Concepts – 8th Edition
6.8
Silberschatz, Galvin and Gagne ©2009
Peterson’s lösning
 Två processer som alternerar mellan den kritiska
sektionen och remainder section
 Anta att LOAD och STORE är atomära; dvs, de
kan inte avbrytas
 Processerna delar på två variabler:
 int turn;
 Boolean flag[2]
 variabeln turn talar om vems tur det är att gå in i
sin kritiska sektion.
 Arrayen flag talar om ifall en process är redo att gå
in i sin kritiska sektion. flag[i] = true visar att
process Pi is redo!
Operating System Concepts – 8th Edition
6.9
Silberschatz, Galvin and Gagne ©2009
Algoritm för process Pi
do {
flag[i] = TRUE;
turn = j;
while (flag[j] && turn == j);
critical section
flag[i] = FALSE;
remainder section
} while (TRUE);
Operating System Concepts – 8th Edition
6.10
Silberschatz, Galvin and Gagne ©2009
Synkroniseringshårdvara
 Många system erbjuder hårdvarustöd för kritiska
sektioner
 Enprocessorsystem – Avbrott kan stängas av

Ineffektivt i multiprocessor-system
 Moderna maskiner har speciella atomära
hårdvaruinstruktioner
Atomär = går ej att avbryta


TestandSet()
Swap()
Operating System Concepts – 8th Edition
6.11
Silberschatz, Galvin and Gagne ©2009
Solution to Critical-section Problem Using Locks
do {
acquire lock
critical section
release lock
remainder section
} while (TRUE);
Operating System Concepts – 8th Edition
6.12
Silberschatz, Galvin and Gagne ©2009
TestAndSet-instruktionen
 Definition:
boolean TestAndSet (boolean *target)
{
boolean rv = *target;
*target = TRUE;
return rv:
}
Operating System Concepts – 8th Edition
6.13
Silberschatz, Galvin and Gagne ©2009
Lösning med TestAndSet
 Delad boolesk variabel lock, initialiserad till false.
 Lösning:
do {
while ( TestAndSet (&lock ))
; // do nothing
//
critical section
lock = FALSE;
//
remainder section
} while (TRUE);
Operating System Concepts – 8th Edition
6.14
Silberschatz, Galvin and Gagne ©2009
Swap-instruktionen
 Definition:
void Swap (boolean *a, boolean *b)
{
boolean temp = *a;
*a = *b;
*b = temp:
}
Operating System Concepts – 8th Edition
6.15
Silberschatz, Galvin and Gagne ©2009
Lösning med Swap
 Delad boolesk variabel lock initialiserad till FALSE; varje
process har en lokal boolesk variabel key
 Lösning:
do {
key = TRUE;
while ( key == TRUE)
Swap (&lock, &key );
//
critical section
lock = FALSE;
//
remainder section
} while (TRUE);
Operating System Concepts – 8th Edition
6.16
Silberschatz, Galvin and Gagne ©2009
Bounded-waiting Mutual Exclusion med TestandSet()
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
} while (TRUE);
Operating System Concepts – 8th Edition
6.17
Silberschatz, Galvin and Gagne ©2009
Semaforer

Synkroniseringsverktyg

Semafor S – heltalsvariabel

Kan bara accessas genom två atomära operationer: wait() and signal()


Originally called P() and V()
Definition:

wait (S) {
while S <= 0
; // no-op
S--;
}
 signal (S) {
S++;
}
Operating System Concepts – 8th Edition
6.18
Silberschatz, Galvin and Gagne ©2009
Användning
 Counting semaphore – semaforens värden är obegränsade
 Binary semaphore – semaforens värde är antingen 0 eller 1; enklare att
implementera

Kallas ibland mutex locks
 Kritisk sektion med semafor:
Semaphore mutex;
// initialized to 1
do {
wait (mutex);
// Critical Section
signal (mutex);
// remainder section
} while (TRUE);
 Ett problem är busy waiting – en väntande process loopar i entry-koden

Semaforen kallas ibland för ett spinlock
Operating System Concepts – 8th Edition
6.19
Silberschatz, Galvin and Gagne ©2009
Semaforimplementation utan Busy waiting
Definition av semafor:
typedef struct {
int value;
struct process *list;
} semaphore;
 Två operationer:

block – placera den anropande processen i väntekön

wakeup – ta bort den anropande processen från väntekön
och placera den i ready queue
Operating System Concepts – 8th Edition
6.20
Silberschatz, Galvin and Gagne ©2009
Semaforimplementation utan Busy waiting (forts)


Implementation av wait:
wait(semaphore *S) {
S->value--;
if (S->value < 0) {
add this process to S->list;
block();
}
}
Implementation av signal:
signal(semaphore *S) {
S->value++;
if (S->value <= 0) {
remove a process P from S->list;
wakeup(P);
}
}
Operating System Concepts – 8th Edition
6.21
Silberschatz, Galvin and Gagne ©2009
Deadlock och Starvation
 Deadlock – två eller fler processer väntar på en händelse som bara kan
orsakas av en av de väntande processerna.
 Låt S och Q vara två semaforer, initialiserade till 1
P0
P1
wait (S);
wait (Q);
wait (Q);
wait (S);
.
.
.
.
.
.
signal (S);
signal (Q);
signal (Q);
signal (S);
 Starvation – en process blir aldrig borttagen från väntekön
Operating System Concepts – 8th Edition
6.22
Silberschatz, Galvin and Gagne ©2009
Klassiska synkroniseringsproblem
 Bounded-Buffer Problem
 Readers and Writers Problem
 Dining-Philosophers Problem (i boken)
Operating System Concepts – 8th Edition
6.23
Silberschatz, Galvin and Gagne ©2009
Bounded-Buffer Problem
 N buffertar som var och en kan lagra ett element
 En semafor mutex initialiserad till 1
 En semafor full initialiserad till 1
 En semafor empty initialiserad till N.
Operating System Concepts – 8th Edition
6.24
Silberschatz, Galvin and Gagne ©2009
Bounded Buffer Problem (forts)

Strukturen på producent-processen:
do {
// produce an item in nextp
wait (empty);
wait (mutex);
// add the item to the buffer
signal (mutex);
signal (full);
} while (TRUE);
Operating System Concepts – 8th Edition
6.25
Silberschatz, Galvin and Gagne ©2009
Bounded Buffer Problem (Cont.)

Strukturen på konsument-processen:
do {
wait (full);
wait (mutex);
// remove an item from buffer to nextc
signal (mutex);
signal (empty);
// consume the item in nextc
} while (TRUE);
Operating System Concepts – 8th Edition
6.26
Silberschatz, Galvin and Gagne ©2009
Readers-Writers Problem
 En datamängd delas av ett antal parallella processer

Readers – processer som bara läser data

Writers – processer som både läser och skriver data
 Problem – tillåta många readers att läsa samtidigt. Bara en
writer åt gången får accessa datan
 Delad data:

Datamängd

En semafor mutex initialiserad till 1

En semafor wrt initialiserad till 1

Integer readcount initialiserad till 0
Operating System Concepts – 8th Edition
6.27
Silberschatz, Galvin and Gagne ©2009
Readers-Writers Problem (forts)
 Strukturen på en writer-process
do {
wait (wrt) ;
//
writing is performed
signal (wrt) ;
} while (TRUE);
Operating System Concepts – 8th Edition
6.28
Silberschatz, Galvin and Gagne ©2009
Readers-Writers Problem (forts)

Strukturen på en reader-process
do {
wait (mutex) ;
readcount ++ ;
if (readcount == 1)
wait (wrt) ;
signal (mutex)
// reading is performed
wait (mutex) ;
readcount - - ;
if (readcount == 0)
signal (wrt) ;
signal (mutex) ;
} while (TRUE);
Operating System Concepts – 8th Edition
6.29
Silberschatz, Galvin and Gagne ©2009