Implementation af Koordinering. dopsys 1

Transkript

1 Implementation af Koordinering dopsys 1

2 Oversigt: Impl. af koordinering Begreber: Kritiske regioner Gensidig udelukkelse Synkroniseringsprimitiver: Binære semaforer / mutexes Tællesemaforer Betingelsesvariabler Monitors Kommunikation: via delt lager dopsys 2

3 Generel håndtering af resurser Overordnet mønster: Ejerskab styres med Allocate, Deallocate Eksklusivitet opnås med Process_blocked_on, Free Schedulering sikrer fremdrift Indkapsling: Request, Release Request(res) { if (Free(res)) Allocate(res, self) else { Block(self, res); Scheduler(); Release(res) { Deallocate(res, self); if (Process_blocked_on(res, pr)) { Allocate(res, pr); Unblock(pr, res); Scheduler(); dopsys 3

4 Gensidig Udelukkelse: Ny teknik cobegin p1: while(1) { // CS1; program 1;... // pn: while(1) { coend CSn; program n; data dopsys 4

5 Gensidig Udelukkelse: Ny teknik.. kan implementeres ved at forhindre interrupts: cobegin p1: while(1) { Inbibit_Interrupts; CS1; CS1; program 1; // program 1;... //... pn: // while(1) { pn: while(1) Inbibit_Interrupts; { CSn; CSn; program n; program n; coend data Egenskaber: Kun anvendeligt ved korte kritiske regioner Af sikkerhedsgrunde kun anvendeligt i OS kernen Virker ikke ved mere end een CPU! dopsys 4

6 [Click] Hvorfor virker det ikke ved mere end een CPU? cobegin p1: while(1) { Inbibit_Interrupts; CS1; CS1; program 1; // program 1;... //... pn: // while(1) { pn: while(1) Inbibit_Interrupts; { CSn; CSn; program n; program n; coend A. Andre CPUer kan stadig godt få interrupts B. Deadlock truer C. Livelock truer D. Andre CPUer kan nå kritisk region E. Ved ikke Egenskaber: Kun anvendeligt ved korte kritiske regioner Af sikkerhedsgrunde kun anvendeligt i OS kernen Virker ikke ved mere end een CPU! dopsys 4

7 Instruktionen Test and Set.. læsning og skrivning af lagercelle i en maskininstruktion: TS(R,X) : R CPU register X udpeger lagercelle. Semantik: R = X; X = 0; X:? R:? X: 0 R: X.. kan bruges til at implementere en låsemekanisme. dopsys 5

8 [Q/A] Forklar hvordan TS(X,R) kan modellere allokering hhv. deallokering som at tage æblet dopsys 6

9 Binære semaforer (Mutex).. kan implementeres ved brug af spinlocks og TS: Specifikation: sb: binær semafor værdi (0 - locked, 1 - unlocked) mutex_lock(sb) if (sb == 1) sb = 0 else mutex_lock(sb) mutex_unlock(sb) sb = 1 dopsys 7

10 Binære semaforer (Mutex).. kan implementeres ved brug af spinlocks og TS: Specifikation: sb: binær semafor værdi (0 - locked, 1 - unlocked) mutex_lock(sb) if (sb == 1) sb = 0 else mutex_lock(sb) mutex_unlock(sb) sb = 1 Implementation: sb: lagercelle der indeholder semaforværdien. mutex_lock(sb) do TS(R,sb) while (!R) mutex_unlock(sb) sb = 1 dopsys 7

11 Binære semaforer (Mutex).. kan implementeres ved brug af spinlocks og TS: Specifikation: sb: binær semafor værdi (0 - locked, 1 - unlocked) mutex_lock(sb) if (sb == 1) sb = 0 else mutex_lock(sb) mutex_unlock(sb) sb = 1 Implementation: sb: lagercelle der indeholder semaforværdien. mutex_lock(sb) do TS(R,sb) while (!R) mutex_unlock(sb) sb = 1 Egenskaber: Anvendeligt på multiprocessor arkitektur med delt lager Antager fairness omkring schedulering (unlock vil blive udført) Spinlocks er acceptable hvis ventetiden er kort dopsys 7

12 Tællesemaforer (1).. kan implementeres udfra binære semaforer: s mutex_s delay_s down(s,mutex_s,delay_s) { s = s 1; if (s < 0) { lock(delay_s); >= 0 værdien af tællesemafor, < 0 antal ventende processer binær semafor til beskyttelse af tælleren s binær semafor til at få processer (tråde) til at vente Initialisering: mutex_s = 1; delay_s = 0; up(s,mutex_s,delay_s) { s = s + 1; if (s <= 0) unlock(delay_s); else.. disable/enable interrupts tilføjes aht deadlock; mutex_s kan så fjernes på uniprocessor arkitektur dopsys 8

13 Prioriteter?.. problem hvis processer bliver afbrudt under udførelse af up og down operationer: Initialisering: mutex_s = 1; delay_s = 0; down(s,mutex_s,delay_s) { s = s 1; if (s < 0) { lock(delay_s); up(s,mutex_s,delay_s) { s = s + 1; if (s <= 0) unlock(delay_s); else L proces med lav prioritet. H proces med høj prioritet. dopsys 9

14 Prioriteter?.. problem hvis processer bliver afbrudt under udførelse af up og down operationer: L Initialisering: mutex_s = 1; delay_s = 0; down(s,mutex_s,delay_s) { s = s 1; if (s < 0) { lock(delay_s); up(s,mutex_s,delay_s) { s = s + 1; if (s <= 0) unlock(delay_s); else L proces med lav prioritet. H proces med høj prioritet. dopsys 9

15 Prioriteter?.. problem hvis processer bliver afbrudt under udførelse af up og down operationer: L Initialisering: mutex_s = 1; delay_s = 0; down(s,mutex_s,delay_s) { s = s 1; if (s < 0) { lock(delay_s); H up(s,mutex_s,delay_s) { s = s + 1; if (s <= 0) unlock(delay_s); else L proces med lav prioritet. H proces med høj prioritet. dopsys 9

16 [Q/A].. problem hvis processer bliver afbrudt under udførelse af up og down operationer: L Initialisering: mutex_s = 1; delay_s = 0; down(s,mutex_s,delay_s) { s = s 1; if (s < 0) { lock(delay_s); H up(s,mutex_s,delay_s) { s = s + 1; if (s <= 0) unlock(delay_s); else Der er 1 CPU. L proces Hvad med er lav prioritet. H proces problemet? med høj prioritet. dopsys 10

17 Prioriteter.. undgås ved enabling/disabling af interrupt (men vi har stadig brug for en vis fairness): Initialisering: mutex_s = 1; delay_s = 0; down(s,mutex_s,delay_s) { Inhibit_Interrupts; s = s 1; if (s < 0) { lock(delay_s); up(s,mutex_s,delay_s) { Inhibit_Interrupts; s = s + 1; if (s <= 0) { unlock(delay_s); else dopsys 11

18 Prioriteter.. undgås ved enabling/disabling af interrupt (men vi har stadig brug for en vis fairness): s=0 Initialisering: mutex_s = 1; delay_s = 0; down(s,mutex_s,delay_s) { Inhibit_Interrupts; s = s 1; if (s < 0) { lock(delay_s); up(s,mutex_s,delay_s) { Inhibit_Interrupts; s = s + 1; if (s <= 0) { unlock(delay_s); else dopsys 11

19 Prioriteter.. undgås ved enabling/disabling af interrupt (men vi har stadig brug for en vis fairness): s=0 H Initialisering: mutex_s = 1; delay_s = 0; down(s,mutex_s,delay_s) { Inhibit_Interrupts; s = s 1; if (s < 0) { lock(delay_s); up(s,mutex_s,delay_s) { Inhibit_Interrupts; s = s + 1; if (s <= 0) { unlock(delay_s); else dopsys 11

20 Prioriteter.. undgås ved enabling/disabling af interrupt (men vi har stadig brug for en vis fairness): s=0 H Initialisering: mutex_s = 1; delay_s = 0; down(s,mutex_s,delay_s) { Inhibit_Interrupts; s = s 1; if (s < 0) { lock(delay_s); L? up(s,mutex_s,delay_s) { Inhibit_Interrupts; s = s + 1; if (s <= 0) { unlock(delay_s); else dopsys 11

21 Busy waiting.. kan ske så længe en proces har den resurse der ventes på: Initialisering: mutex_s = 1; delay_s = 0; down(s) { Inhibit_Interrupts; s = s 1; if (s < 0) { lock(delay_s); up(s) { Inhibit_Interrupts; s = s + 1; if (s <= 0) unlock(delay_s); else dopsys 12

22 Busy waiting.. kan ske så længe en proces har den resurse der ventes på:.. busy waiting ønskes reduceret for at spare processor tid Initialisering: mutex_s = 1; delay_s = 0; down(s) { Inhibit_Interrupts; s = s 1; if (s < 0) { lock(delay_s); up(s) { Inhibit_Interrupts; s = s + 1; if (s <= 0) unlock(delay_s); else dopsys 12

23 Tællesemaforer (2).. busy waiting kan reduceres ved interaktion med scheduler. down(s) { Inhibit_Interrupt; s = s - 1; if (s < 0) { Block(self, Ls); Enable_Interrupt; Scheduler(); else { Enable_Interrupt; up(s) { Inhibit_Interrupt; s = s + 1; if (s <= 0) { Unblock(q, Ls); Enable_Interrupt; Scheduler(); else { Enable_Interrupt; Eliminerer busy waiting mens andre processer er i kritiske region. dopsys 13

24 spørgsmål om implementation af koordinering? dopsys 14

25 Re: Monitors (Hoare, 1974).. beskytter tilgang til delte resurser: Monitor komponenter: Data - resursens tilstand. Procedurer - tilgang til resursens data. Egenskaber: Tilgang til resursens data kun via monitorprocedurer. Udførelse af monitorprocedurer er gensidigt udelukkende. dopsys 15

26 Implementation af Monitors Semantik: 1. Gensidig udelukkelse omkring udførelse af monitorprocedurer. 2. Ved c.wait blokerer processen på wait-queue for c. 3. Ved c.signal frigives en proces fra wait-queue for c hvis den ikke er tom, og processen blokerer på signal-queue for monitoren. 4. Når monitorproceduren forlades eller c.wait udføres frigives en proces i signalkøen, såfremt den ikke er tom. Implementation: mutex: Binær semafor for gensidig udelukkelse. condsem_c: Binær semafor for blokering på wait-queue for c. condcnt_c: Antal processer i wait-queue for c. urgent: Binær semafor for blokering på signal-queue. urgentcnt: Antal processer i signal-queue for c. dopsys 16

27 Initialisering: Implementation (1) mutex = 1; condsem_c = 0; concnt_c =0; urgent = 0; urgentcnt = 0; Enter/exit kode: 1. Gensidig udelukkelse omkring udførelse af monitorprocedurer. 4. Når monitorproceduren forlades eller c.wait udføres, frigives en proces i signal-queue såfremt den ikke er tom. lock(mutex); procedure_body; if (urgentcnt) unlock(urgent) else unlock(mutex) dopsys 17

28 c.signal: c.wait: condcnt_c = condcnt_c + 1; if (urgentcnt > 0) unlock(urgent); else unlock(mutex); lock(condsem_c); condcnt_c = condcnt_c 1; Implementation (2) if (condcnt_c > 0) { urgentcnt = urgentcnt + 1; unlock(condsem_c); lock(urgent); urgent_cnt = urgentcnt 1; 3. c.signal: Når wait-queue for c ikke er tom frigives en proces herfra og processen blokerer på signal-queue for monitoren. 2. c.wait: bloker processen på waitqueue for betingelsesvariablen c. 4. Når monitorproceduren forlades eller c.wait udføres frigives en proces fra signal-queue såfremt den ikke er tom. dopsys 18

29 [Click] lock(mutex); procedure_body; if (urgentcnt) unlock(urgent) else unlock(mutex) c.wait: condcnt_c = condcnt_c + 1; if (urgentcnt > 0) unlock(urgent); else unlock(mutex); lock(condsem_c); condcnt_c = condcnt_c 1; c.signal: if (condcnt_c > 0) { urgentcnt = urgentcnt + 1; unlock(condsem_c); lock(urgent); urgent_cnt = urgentcnt 1; Hvorfor kan vi bryde lock/unlockbalancen?! A. Balance er unødvendig, der kan være flere unlocks end locks B. Det er nok at lock/ unlock balancerer, evt. på forskellige mutexes C. Lock/unlock balancerer på samme mutex henover flere kald D. Ved ikke dopsys 18

30 spørgsmål om implementation af monitors? dopsys 19

31 Kommunikation.. kan understøtte koordinering, men bruger det også Primitiver: send(p,m) send besked m til proces p. receive(q,m) modtag besked m fra proces q. Buffering i user space: Buffering i kernel space: Operationer: Blocking/Non-blocking Synkron/Asynkron dopsys 20

32 Interrupt-sekvens Hardware brug: Hardwaren sættes op (Init), kører i parallel med CPU, og p blokerer sig selv Hardwaren genererer interrupt, Interrupt Handler (IH) afvikles, RTI frigør p Generelt er billedet lidt kaotisk: ligner flere GOTO efter hinanden dopsys 21

33 Interrupt organiseret om Monitor Hardware brug: Hardware-processen og CPU-processen p er blot to processer for monitoren Init frigør hardware-processen, og p venter med wait som altid i en monitor Billedet mere klart og forståeligt - dog ikke nødvendigvis implementerbart dopsys 22

34 Opsummering Koordinering: Disable/enable interrupts Test-and-set instruktion Impl. af binære semaforer (mutex) med spinlocks. Impl. af tællesemaforer med spinlock hhv. scheduler. Monitors. Kommunikation: Via delt lager/buffere stillet til rådighed af operativsystemet. Interrupts: Direkte beskrivelse lidt kaotisk. Monitorbegreb organiserer aktiviteten, i princippet. dopsys 23