INF3140 Modeller for parallellitet INF3140/4140: Låser og Barrierer

Transkript

1 INF3140/4140: Låser og Barrierer Uke 2, side 1.

2 Praktisk Obligatorisk oppgave 1 Er nå lagt ut. Merk: Frist fredag 21. sept. Guppelærer Mohammad Ali Norozi mohammno@ifi.uio.no Merk: Kun gruppe 1 åpen! Forelesningssted Lille Aud: fra og med neste uke (dvs )! Uke 2, side 2.

3 Innledning Sentralt for kurset er generelle mekanismer og problemstillinger knyttet til parallelle programmer Forrige gang: await språket og enkel versjon av produsent/konsument-eksemplet I dag Inngangs- og utgangsprotokoller til kritisk region Beskytte lesing og skriving til felles variable Barrierer Iterative algoritmer: Prosessene må synkroniseres mellom hver iterasjon Koordinering v.h.a. flagg Uke 2, side 3.

4 Hoved-spørsmål: Hvordan kan man implementere kritiske regioner/ betingede kritiske regioner? v.h.a. låser og lavnivå operasjoner aktiv venting (senere semaphorer og passiv venting) ulike løsninger og egenskaper Uke 2, side 4.

5 Adgang til Kritisk Region (KR) Flere prosesser konkurrerer om tilgang til felles ressurs Bare én prosess kan ha tilgang av gangen Mulige eksempler: Utføring av banktransaksjoner Tilgang til skriver Løsning kan brukes til å implementere await-setninger Uke 2, side 5.

6 Kritisk region: Første tilnærming til løsning Operasjoner på felles variable skjer inne i KR. Aksess til KR må da beskyttes for å unngå interferens process p[i=1 to n] { while (true) { KRinngang ; KR; KRutgang ; ikke KR # inngang til KR # utgang fra KR Antagelse: En prosess som kommer inn i KR vil til slutt forlate denne. Uke 2, side 6.

7 Naiv løsning int in = 1; 1 eller 2 process p1 { process p2 { while (true) { while (true) { while (in=2) skip; while (in=1) skip; KR KR in = 2; in = 1; ikke KR ikke KR God løsning? Hva er bra, hva er ikke så bra? Uke 2, side 7.

8 Safety egenskaper Safety: Ikke noe går galt, kommer ikke i uønsket tilstand Typiske eksempler for sekvensielle programmer Sluttilstanden er riktig, invariant holder,... Typiske safety egenskaper for parallelle programmer Mutex: Bare én prosess i kritisk region om gangen Fravær av vranglås: unngå at alle prosessene venter på betingelser samtidig (deadlock) Uke 2, side 8.

9 Safety: Invarianter (repetisjon) En sikkerhetsegenskap uttrykker at et program ikke kommer til en dårlig tilstand. For å bevise dette, kan vi vise at programmet aldri vil forlate en god tilstand: Vis at egenskapen holder i alle starttilstander Vis at programsetningene opprettholder egenskapen En slik egenskap kalles gjerne global invariant Uke 2, side 9.

10 Atomære regioner Brukes til synkronisering av prosesser Generell form: < await(b)s; > B: Synkroniseringsbetingelse Utføres atomært nårber sann Ubetinget kritisk region (B er true): < S; > S utføres atomært Betingelsessynkronisering: < await(b); > Uke 2, side 10.

11 Kritisk region v.h.a. lås bool lock = false; Lås: Én variabel brukes til regulere process p[i=1 to n] { adgang til KR for n prosesser while (true) { < await (!lock) lock = true; > # KRinngang KR lock = false; # KRutgang ikke KR Safety egenskaper: Mutex Fravær av deadlock Fravær av unødig venting Hva med å endre plasseringen av <...>? Uke 2, side 11.

12 Test & Set Test & Set er en metode for å implementere betinget atomær aksjon: bool TS(bool lock) { < bool initial = lock ; lock = true; return initial; > Virkningen avts(lock): Variabelenlock vil alltid ha verditrue etterts(lock), men returverdien vil variere mellomtrue ogfalse. Finnes som atomær instruksjon på mange maskiner. Uke 2, side 12.

13 Kritisk region v.h.a. TS og Spinnelås bool lock = false; Spinnelås: process p[i=1 to n] { Prosessene brukerts til å gå i løkke. while (true) { while (TS(lock)) skip; Utgang fra løkka skjer nårlock KR har verdienfalse før while-testen. lock = false; ikke KR Uke 2, side 13.

14 Kritisk region v.h.a. Test, test & Set Låsvariabelenlock blir kontinuerlig skrevet til av prosessene. Dette kan være ineffektivt, og en mer effektiv løsning er test, test og set. bool lock = false; process p[i=1 to n] { while (true) { while (lock) skip; while (TS(lock)) { while (lock) skip; KR lock = false; ikke KR spinn mens låsen er opptatt prøv å ta låsen spinn hvis det feiler Uke 2, side 14.

15 Implementere await-setninger LaKRinngang ogkrutgang implementere inngangs- og utgangsprotokoller til kritisk region. Da kan setningen< S;> implementeres ved KRinngang; S; KRutgang; Implementasjon av betinget kritisk region < await (B) S;> : KRinngang; while (!B) { KRutgang; KRinngang; S; KRutgang; Implementasjonen kan effektiviseres meddelay mellom utgang og inngang i kroppen påwhile-setningen. Uke 2, side 15.

16 Liveness egenskaper Liveness: Noe går godt Typisk eksempel for sekvensielle programmer Programmet terminerer Typisk liveness egenskap for parallelle programmer En gitt prosess vil til slutt komme inn i kritisk region Dette påvirkes av strategier for skedulering. Uke 2, side 16.

17 Skedulering og fairness Fairness: garanti for at prosesser får anledning til å eksekvere. Skedulering: Strategi for å avgjøre hvilken prosess som får anledning til å eksekvere. Eksempel: bool x = true; co while (x); x = false; oc Uke 2, side 17.

18 Ubetinget fairness En strategi for skedulering er ubetinget fair hvis enhver ubetinget atomær aksjon som kan velges til slutt blir valgt. Round robin eksekvering Eksempel: bool x = true; co while (x); x = false; oc x = false er ubetinget Må dermed før eller siden bli valgt Dette garanterer terminering Uke 2, side 18.

19 Svak fairness En strategi for skedulering er svakt fair hvis den er ubetinget fair enhver betinget atomær aksjon blir til slutt valgt, forutsatt at betingelsen blir sann og deretter forblir sann til aksjonen blir eksekvert. Eksempel: bool x = true, int y = 0; co while (x) y = y + 1; < await y >= 10; > x = false; oc Nåry >= 10 blir sann, så forblir denne betingelsen sann Dette sikrer terminering av programmet Round robin eksekvering Uke 2, side 19.

20 Sterk fairness En strategi for skedulering er sterkt fair hvis den er ubetinget fair enhver betinget atomær aksjon blir til slutt valgt, forutsatt at betingelsen er sann uendelig ofte. Eksempel: bool x = true, y = false; co while (x) { y = true; y = false; < await (y) x = false; > oc Med sterk fairness: Programmet vil terminere, fordiyer sann uendelig ofte. Med svak fairness: Programmet trenger ikke terminere, fordiyogså er usann uendelig ofte. Uke 2, side 20.

21 Fairness for kritisk region v.h.a lås KR løsningene tidligere i forelesningen trenger antagelse om sterk fairness for å garantere tilgang for en gitt prosess (i ): Jevnt tilsig av prosesser som ønsker låsen Verdien tillock pendler (uendelig lenge) mellomtrue ogfalse Svak fairness: Prosess i kan leselock bare når verdien erfalse Sterk fairness: Garanterer at i før eller siden ser atlock ertrue Vanskelig å lage en skeduleringsstrategi som er både praktisk og sterkt fair. Skal nå se på KR-løsninger der inngang garanteres med svakt fair strategier Uke 2, side 21.

22 Fair løsninger på KR-problemet Tie-Breaker Kø-lapp I tillegg beskriver boka bakeri-algoritmen Uke 2, side 22.

23 Tie-Breaker algoritmen Trenger ingen spesiell maskininstruksjon (somts) Ser på løsning med to prosesser Hver prosess har privat lås Hver prosess setter sin lås i inngangsprotokollen Den private låsen leses, men blir ikke endret av den andre prosessen Uke 2, side 23.

24 Tie-Breaker algoritmen: Forsøk 1 bool in1 = false, in2 = false process p1 { process p2 { while (true) { while (true) { while (in2) skip; while (in1) skip; in1 = true; in2 = true; KR KR in1 = false; in2 = false; ikke KR ikke KR Her kan vi ikke garantere mutex! Uke 2, side 24.

25 Tie-Breaker algoritmen: Forsøk 2 Prøver å snu rekkefølgen i inngangsprotokollen: bool in1 = false, in2 = false process p1 { process p2 { while (true) { while (true) { in1 = true; in2 = true; while (in2) skip; while (in1) skip; KR KR in1 = false; in2 = false; ikke KR ikke KR Her kan vi ikke garantere fravær av deadlock! Uke 2, side 25.

26 Tie-Breaker algoritmen: Forsøk 3 Innfører variabellast som forteller hvilken prosess som sist begynte på inngangsprotokollen. bool in1 = false, in2 = false int last = 1 process p1 { while (true) { in1 = true; last = 1; < await (!in2 or last==2);> KR in1 = false; ikke KR process p2 { while (true) { in2 = true; last = 2; < await (!in1 or last==1);> KR in2 = false; ikke KR Uke 2, side 26.

27 Tie-Breaker algoritmen Selv om variablenein1,in2 oglast kan endre verdi mens en ventebetingelse evaluerer til sann, vil ventebetingelsen fremdeles være sann. p1 ser at ventebetingelsen er sann: in2 == false in2 kan etterhvert blitrue, men da måp2 også settelast til 2 Da holder forsatt ventebetingelsen tilp1 last == 2 Da villast == 2 holde helt tilp1 har eksekvert Dermed kan vi erstatte await-setningen med en while-løkke. Uke 2, side 27.

28 Tie-Breaker algoritmen (4): Implementasjon bool in1 = false, in2 = false int last = 1 process p1 { while (true) { in1 = true; last = 1; while (in2 and last==1) skip; KR in1 = false; ikke KR process p2 { while (true) { in2 = true; last = 2; while (in1 and last==2) skip; KR in2 = false; ikke KR Kan generaliseres til flere prosesser (se boka) Uke 2, side 28.

29 Kølapp-algoritmen Hvis Tie-Breaker algoritmen skaleres for n prosesser, får vi en løkke med n 1 2-prosess Tie-Breaker algoritmer Kølapp-algoritmen gir enklere løsning på KR-problemet for n prosesser. Fungerer som køsystemet på posten (med én luke) En kunde (prosess) som kommer inn trekker et nummer som er høyere enn nummeret til alle andre som venter Kunden betjenes når luka er ledig og hun har lavest nummer av ventende prosesser Uke 2, side 29.

30 Kølapp-algoritmen: Skisse (n prosesser) int number = 1, next = 1, turn[1:n]= ([n] 0); process p[i = 1 to n] { while (true) { < turn[i] = number; number = number + 1; > < await (turn[i] = next);> KR < next = next + 1; > Ikke KR Første linje i løkka må gjøres atomært! await-setningen kan implementeres som egen løkke Noen maskiner har instruksjonen FA(var, incr): < int tmp = var; var = var + incr; return tmp; > Uke 2, side 30.

31 Kølapp-algoritmen: Implementasjon int number = 1, next = 1, turn[1:n]= ([n] 0); process p[i = 1 to n] { while (true) { turn[i] = FA(number, 1); while (turn[i]!= next) skip; KR next = next + 1; Ikke KR FA(var, incr): < int tmp = var; var = var + incr; return tmp; > Uten denne instruksjonen, bruker vi en annen KR: KRinngang; turn[i]=number; number = number + 1; KRutgang; Problem med fairness for KR. Løses med bakeri-algoritmen (se boka). Uke 2, side 31.

32 Kølapp-algoritmen: Invariant Vi kan formulere en global invariant for prosessene i kølapp-algoritmen: 0 < next number For hver prosessp[i]: turn[i] < number hvisp[i] er i KR så erturn[i] == next. For alle prosesserp[i],p[j] deri!= j: hvisturn[i] > 0 så erturn[j]!= turn[i]. Dette holder initielt, og blir opprettholdt av alle atomære setninger. Uke 2, side 32.

33 Barriere-synkronisering Utregning av disjunkte deler i parallell (f.eks. array-elementer). Prosessene går i løkke, der hver gjennomgang er avhengig av resultatene fra forrige gjennomgang. process Worker[i=1 to n] { while (true) { Arbeidsoppgave i; Vent til n-oppgaver er gjort; # Barriere Alle prosessene må nå barrieren før noen kan forsette. Uke 2, side 33.

34 Delt teller Et antall prosesser skal synkronisere avslutning av sine arbeidsoppgaver. Synkroniseringen kan implementeres ved en felles teller : int count = 0; process Worker[i=1 to n] { while (true) { Arbeidsoppgave i < count = count + 1; > < await (count == n); > Kan implementeres v.h.a. FA-instruksjon. Ulemper: count må nullstilles mellom hver gjennomgang. Må endres v.h.a. atomære operasjoner. Ineffektivt: Mange prosesser leser og skriver tilcount samtidig. Uke 2, side 34.

35 Koordinering ved hjelp av flagg Målsetning: Unngår overbelastning av lese- og skriveoperasjoner på én variabel. Deler felles teller i flere lokale variable. Worker[i]: arrive[i] = 1; < await (continue[i] == 1);> Coordinator: for [i=1 to n] < await (arrive[i]==1);> for [i=1 to n] continue[i] = 1; Hvis det er flere synkroniseringspunkter på samme flagg, gjelder følgende: Prosessen som venter på et flagg, er den som skal nullstille flagget etter synkronisering Et flagg skal ikke settes før det er nullstilt Uke 2, side 35.

36 Synkronisering v.h.a. flagg int arrive[1:n] = ([n] 0), continue[1:n] = ([n] 0); process Worker[i = 1 to n] { process Coordinator { while(true) { while(true) { Arbeidsoppgave i; for[i = 1 to n] { arrive[i] = 1; < await (arrive[i] == 1);> < await (continue[i] == 1);> arrive[i] = 0; continue[i] = 0; for [i = 1 to n] continue[i] = 1; Uke 2, side 36.

37 Kombinerte barrierer Rollene til Worker- og Coordinator-prosessene kan kombineres. I en kombinert tre-barriere er prosessene organisert i en trestruktur. Prosessene signaliserer arrive oppover i treet og continue nedover i treet. Uke 2, side 37.