Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition, Kapitel 6: Process- synkronisering

6.2 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition 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

6.3 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition 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++; }

6.4 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition konsument while (true) { while (count == 0) ; // do nothing nextConsumed = buffer[out]; out = (out + 1) % BUFFER_SIZE; count--; /* consume the item in nextConsumed }

6.5 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition 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}

6.6 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition 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

6.7 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Generell struktur hos en typisk process do { entry section critical section exit section remainder section } while (TRUE);

6.8 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Protokollet måste uppfylla tre krav 1. Mutual Exclusion - om process P i 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

6.9 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition 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 P i is redo!

6.10 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition do { flag[i] = TRUE; turn = j; while (flag[j] && turn == j); critical section flag[i] = FALSE; remainder section } while (TRUE); Algoritm för process P i

6.11 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition 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()

6.12 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Solution to Critical-section Problem Using Locks do { acquire lock critical section release lock remainder section } while (TRUE);

6.13 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition TestAndSet-instruktionen Definition: boolean TestAndSet (boolean *target) { boolean rv = *target; *target = TRUE; return rv: }

6.14 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition 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);

6.15 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Swap-instruktionen Definition: void Swap (boolean *a, boolean *b) { boolean temp = *a; *a = *b; *b = temp: }

6.16 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition 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);

6.17 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition 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);

6.18 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition 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++; }

6.19 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition 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

6.20 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition 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

6.21 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition 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); }

6.22 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition 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 P 0 P 1 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

6.23 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Klassiska synkroniseringsproblem Bounded-Buffer Problem Readers and Writers Problem Dining-Philosophers Problem (i boken)

6.24 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition 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.

6.25 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition 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);

6.26 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition 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);

6.27 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition 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

6.28 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Readers-Writers Problem (forts) Strukturen på en writer-process do { wait (wrt) ; // writing is performed signal (wrt) ; } while (TRUE);

6.29 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition 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);