Presentation laddar. Vänta.

Presentation laddar. Vänta.

Operativsystem - Processkommunikation Mats Björkman 2015-01-26.

Liknande presentationer


En presentation över ämnet: "Operativsystem - Processkommunikation Mats Björkman 2015-01-26."— Presentationens avskrift:

1 Operativsystem - Processkommunikation Mats Björkman

2 Operativsystem, © Mats Björkman, MDH 2 Innehåll Processer (föreläsning 2) Processmodell Processtillstånd Trådar Processkommunikation (föreläsning 3, den här) Semaforer Monitorer Meddelandesystem Skedulering/schemaläggning (föreläsning 4) Kriterier för en skedulerare Skeduleringsalgoritmer

3 Operativsystem, © Mats Björkman, MDH 3 Lärandemål Varför behövs processkommunikation och processynkronisering? Race condition, ömsesidigt uteslutande, kritiska avsnitt Mekanismer för kommunikation/synkronisering Semaforer, meddelandeöverföring, delat minne

4 Operativsystem, © Mats Björkman, MDH Mer begrepp Prioritet: Olika processer kan ha tilldelats olika prioritet, vilket betyder att skeduleraren tar hänsyn till detta i valet av nästa process att köra (mer i nästa föreläsning) 4

5 Operativsystem, © Mats Björkman, MDH Förtydligande: Multitrådade kärnor Moderna OS-kärnor är oftast multitrådade, vilket betyder att flera aktiviteter kan vara på gång samtidigt i OS-kärnan Detta är en anledning till att varje process behöver en egen kernel stack, exv. kan flera processer ha systemanrop som pågår samtidigt 5

6 Operativsystem, © Mats Björkman, MDH Multitasking=> samtidighet Wikipedia: Synchronization "In computer science, especially parallel computing, synchronization means the coordination of simultaneous threads or processes to complete a task in order to get correct runtime order and avoid unexpected race conditions." 6

7 Operativsystem, © Mats Björkman, MDH Multitasking=> samtidighet Processer som är omedvetna om varandra: Oberoende tillämpningar Konkurrerar om samma resurser Processer medvetna om varandra: Samarbetar genom att dela resurser En process kan vara beroende av info från en annan 7

8 Operativsystem, © Mats Björkman, MDH 8 Processkommunikation och synkronisering Varför kommunikation och synkronisering? Odelbara resurser (ömsesidigt uteslutande) Synkronisera aktiviteter Undvika baklås (deadlock/livelock) i systemet Kommunikation mellan processer

9 Operativsystem, © Mats Björkman, MDH 9 Kommunikationsmetoder Semaforer Meddelandeöverföring Delat minne Processkommunikation och synkronisering forts.

10 Operativsystem, © Mats Björkman, MDH 10 Det finns resurser som endast en process i taget bör få använda (exv. enkel skrivare utan egen hantering av samtidiga utskriftsjobb) Ömsesidigt uteslutande (mutual exclusion) kallas egenskapen vi vill garantera för dessa resurser Ömsesidigt uteslutande

11 Operativsystem, © Mats Björkman, MDH 11 Garantin innebär att det aldrig får finnas en risk för att mer än en process använder resursen samtidigt Ömsesidigt uteslutande

12 Operativsystem, © Mats Björkman, MDH 12 Ur en gammal OS-kurs i Uppsala: En enkelspårig järnvägssträcka i Anderna mellan Peru och Bolivien (sic) måste ha ett signalsystem för att garantera att max ett tåg i taget är ute på linjen Exempel ur verkligheten

13 Operativsystem, © Mats Björkman, MDH 13 Problemet uppstår förstås när det kommer tåg från båda hållen precis samtidigt Vi måste hitta en lösning som garanterar ömsesidigt uteslutande utan att resultera i baklås Exempel ur verkligheten

14 Operativsystem, © Mats Björkman, MDH 14 Lösningen skall passa att koda in i en algoritm Ofta ställs dessutom kraven att algoritmen skall vara rättvis och fri från svält Exempel ur verkligheten

15 Operativsystem, © Mats Björkman, MDH 15 En typisk mekanism för att åstadkomma ömsesidigt uteslutande i kod är kritiska avsnitt (critical region el. critical section) Kritiska avsnitt är kodavsnitt som bara en process i taget får exekvera i Exempel: Koden som exekveras för att skriva ut på skrivaren Kritiskt avsnitt

16 Operativsystem, © Mats Björkman, MDH 16 Ömsesidigt uteslutande Exempel utan kritiskt avsnitt: Process AProcess B Börjar skriva ut ett dokument på skrivaren. Blir avbruten av process B som har högre prioritet. Avbryter A och skriver ut sitt dokument. Blir klar och avslutar. Fortsätter utskriften av det första dokumentet. Resultatet blir ihopblandade utskrifter.

17 Operativsystem, © Mats Björkman, MDH 17 Lösningen blir att hela den kod som skriver ut på skrivaren måste vara ett kritiskt avsnitt, så att inte process B kan skriva ut när A redan börjat skriva ut, utan B måste vänta tills A är klar Ömsesidigt uteslutande

18 Operativsystem, © Mats Björkman, MDH 18 Ett annat exempel handlar om åtkomst till delade variabler Ömsesidigt uteslutande

19 Operativsystem, © Mats Björkman, MDH 19 Ömsesidigt uteslutande forts. Race condition Example: int saldo= 1000; Thread AThread B void A(void){void B(void){ int peng; peng=saldo; peng=saldo; peng=peng-100; peng=peng+1000; saldo=peng; saldo=peng; …} Scenario 1 RESULTAT: saldo=

20 Operativsystem, © Mats Björkman, MDH Race condition Example: int saldo= 1000; Thread AThread B void A(void){void B(void){ int peng; peng=saldo; peng=saldo; peng=peng-100; peng=peng+1000; saldo=peng; saldo=peng; …} 20 Ömsesidigt uteslutande forts. Scenario 2 RESULTAT: saldo=

21 Operativsystem, © Mats Björkman, MDH 21 Även i detta exempel gäller det att skapa ett kritiskt avsnitt, i detta fall är det koden från innan processen läser saldot tills efter den har skrivit det nya saldot som behöver utgöra ett kritiskt avsnitt Ömsesidigt uteslutande

22 Operativsystem, © Mats Björkman, MDH 22 Ömsesidigt uteslutande genom kritiska avsnitt

23 Operativsystem, © Mats Björkman, MDH 23 Nu behöver vi några mekanismer som hjälper oss att skapa kritiska avsnitt Ömsesidigt uteslutande

24 Operativsystem, © Mats Björkman, MDH 24 Ömsesidigt uteslutande forts. Fyra krav: 1. Aldrig fler än en process samtidigt i kritiska avsnittet 2. Inga antaganden om processhastighet eller antal CPU:er 3. Ingen process som inte är i kritiska avsnittet får blockera en annan process 4. Ingen process skall behöva vänta i evighet på exekvering Undvik baklås, svält och busy waiting (“rastlös väntan”) Hur kan detta lösas? Algoritmiskt i tillämpningen Algoritmiskt i tillämpningen + hårdvarustöd Interrupt disable Test And Set-primitiv OS-stöd: semaforer, meddelandeöverföring

25 Operativsystem, © Mats Björkman, MDH 25 Ömsesidigt uteslutande - Algoritm i tillämpningen int turn = 0; void thread0(){void thread1(){ while(1){ while(1){ // some code while(turn!=0) ; while(turn!=1) ; // Critical Section // Critical section turn = 1; turn = 0; }} Fungerar denna algoritm? Finns det nackdelar med denna lösning?

26 Operativsystem, © Mats Björkman, MDH 26 Ömsesidigt uteslutande - Algoritm i tillämpningen int turn = 0; void thread0(){void thread1(){ while(1){ while(1){ // some code while(turn!=0) ; while(turn!=1) ; // Critical Section // Critical section turn = 1; turn = 0; }} Fungerar denna algoritm? Finns det nackdelar med denna lösning?

27 Operativsystem, © Mats Björkman, MDH 27 Ömsesidigt uteslutande - Algoritm i tillämpningen int turn = 0; void thread0(){void thread1(){ while(1){ while(1){ // some code while(turn!=0){} //spin while(turn!=1){} //spin // Critical Section // Critical section turn = 1; turn = 0; }} Fungerar denna algoritm? Finns det nackdelar med denna lösning?

28 Operativsystem, © Mats Björkman, MDH 28 Ömsesidigt uteslutande - Algoritm i tillämpningen (bättre?) boolean interested[2] = {false,false}; void thread0(){void thread1(){ while(1){ while(1){ // some code interested[0] = true; interested[1] = true; while(interested[1]){} while(interested[0]){} // Critical Section // Critical section interested[0] = false; interested[1] = false; }} Fungerar denna algoritm? Finns det nackdelar med denna lösning?

29 Operativsystem, © Mats Björkman, MDH 29 Ömsesidigt uteslutande - Algoritm i tillämpningen (nu då?) int int loser; boolean interested[2] = {false,false}; void thread0(){void thread1(){ while(1){ while(1){ // some code interested[0] = true; interested[1] = true; loser = 0; loser = 1; while(loser==0 && while(loser==1 && interested[1]) {} interested[0]) {} // Critical Section // Critical section interested[0] = false; interested[1] = false; }} Fungerar denna algoritm? Finns det nackdelar med denna lösning?

30 Operativsystem, © Mats Björkman, MDH 30 Ömsesidigt uteslutande - Algoritm i tillämpningen med hårdvarustöd void thread0(){void thread1(){ while(1){ while(1){ // some code interrupt_disable(); interrupt_disable(); // Critical Section // Critical section interrupt_enable(); interrupt_enable(); }} Fungerar denna algoritm? Finns det nackdelar med denna lösning?

31 Operativsystem, © Mats Björkman, MDH 31 int TAS(char *flag){ int result; __asm{ tas flag bne alreadySet move #0,&result bra exit alreadySet: move #1,&result exit: } return result; } Ömsesidigt uteslutande - Algoritm i tillämpningen med hårdvarustöd Test and Set (TAS) Sätter en variabel och returnerar gamla värdet Läsningen av gamla värdet och sättningen av nya är garanterat atomärt (odelbart)

32 Operativsystem, © Mats Björkman, MDH 32 char flag=0; void thread0(){void thread1(){int TAS(char *flag){ while(1){ while(1){ int result; // some code // some code __asm{ while(TAS(&flag)==1){} while(TAS(&flag)==1){} tas flag // Critical Sec. // Critical sec. bne alreadySet flag=0; flag=0; move #0,&result } } bra exit }} alreadySet: move #1,&result exit: } return result; } Finns det nackdelar med denna lösning? Ömsesidigt uteslutande - Algoritm i tillämpningen med hårdvarustöd

33 Operativsystem, © Mats Björkman, MDH 33 Test and set Varianter på test and set kan heta: Compare and swap Atomic exchange Samma princip: en odelbar operation där en variabel ändras och det gamla värdet kontrolleras

34 Operativsystem, © Mats Björkman, MDH 34 Busy wait Alla lösningar (hittills) har använt busy wait, den process som måste vänta ligger i en tight loop och kollar och kollar och kollar… Slöseri med CPU-tid, vem kan hjälpa?

35 Operativsystem, © Mats Björkman, MDH 35 Ta-daa! Is it a spin lock? Is it a test-and-set instruction? No! It’s… …The Operating System!

36 36 OS-stöd för kommunikation och synkronisering

37 Operativsystem, © Mats Björkman, MDH 37 Semaforer Ett verktyg för att åstadkomma ömsesidigt uteslutande Finns i så gott som alla operativsystem

38 Operativsystem, © Mats Björkman, MDH 38 Semaforer Två versioner: Binära semaforer kan vara 0 eller 1 Räknande semaforer kan vara  0

39 Operativsystem, © Mats Björkman, MDH 39 Semaforer Binära semaforer används när det finns en instans av en resurs och den kan användas av en process i taget Exempel: Lås på toadörr. En användare kan gå in på toa och vrida om låset. Övriga får då vänta till dess den som använder toan låser upp dörren

40 Operativsystem, © Mats Björkman, MDH 40 Semaforer Räknande semaforer används när det finns flera instanser av resursen och/eller flera processorer kan samsas Exempel: En ut/en in på krogen. Det finns ett maximalt antal tillåtna samtidiga besökare. När maxantalet är uppfyllt måste nästa besökare vänta på att någon lämnar lokalen.

41 Operativsystem, © Mats Björkman, MDH 41 Semaforer forts. En semafor har två operationer: wait(semaphore); räknar ner signal(semaphore); räknar upp Alternativa namn: take/give, acquire/release, down/up, P/V (holländska Proberen/Verhogen ≈ försök/höj)

42 Operativsystem, © Mats Björkman, MDH 42 Mutex (MUTual EXclusion) En binär semafor kallas ibland mutex En mutex används som ett lås (kom ihåg toadörren), operationerna kallas ibland mutex_lock (wait) respektive mutex_unlock (signal)

43 Operativsystem, © Mats Björkman, MDH 43 Semaforer forts. Om en semafor är 1 (eller mer) och en process anropar wait(…), så kommer semaforen att räknas ned och processen får fortsätta

44 Operativsystem, © Mats Björkman, MDH 44 Semaforer forts. Om en semafor är 0 och en process anropar wait(…), så kommer processen att flyttas till ett väntetillstånd (wait/sleep) och sättas i en kö associerad till semaforen Processen blir kvar i kön till dess en annan process anropar signal(…)

45 Operativsystem, © Mats Björkman, MDH 45 Semaforer forts. När en process anropar signal(…) tittar operativsystemet om det finns någon process i väntelistan till den semaforen. Om det finns någon i kön, så väcks den första processen i kön upp och får fortsätta exekvera Om väntelistan är tom, räknas semaforen upp med 1

46 Operativsystem, © Mats Björkman, MDH 46 Semaforer forts. OS:et löser problemet med busy wait: När en process måste vänta behöver den inte ligga och spinna runt runt och testa om den får fortsätta Operativsystemet försätter istället processen i ett väntetillstånd, och lovar att väcka upp processen när den kan fortsätta Systemet slipper slösa CPU-tid på busy wait

47 Operativsystem, © Mats Björkman, MDH 47 Semaforer forts. Operativsystemet tillhandahåller även rättvisa: Om flera processer med samma prioritet blir väntande på wait(…), så kommer operativsystemet att först väcka den som anropade wait(…) först (Vid busy wait och exv. test_and_set är det slumpmässigt vilken av de väntande som har tur att testa precis vid rätt tid)

48 Operativsystem, © Mats Björkman, MDH 48 Semaforer forts. Semaforoperationerna måste vara odelbara (atomära) Operativsystemet garanterar detta Väntande processer sätts tillståndet till väntande (wait/sleep) läggs in i väntelistan på en semafor

49 Operativsystem, © Mats Björkman, MDH 49 Semaforer forts. Problem med semaforer Priority inversion: en process med hög prioritet kan bli väntande på en semafor som en process med lägre prioritet har låst Baklås: Process 0 har låst semaforen A och väntar på semaforen B, Process 1 har låst semaforen B och väntar på semaforen A

50 Operativsystem, © Mats Björkman, MDH 50 Semaforer forts. Skrivarproblemet löst med semaforer: Process AProcess B Ett skrivarjobb begärs. Processen anropar wait(lpr). Eftersom skrivaren är ledig räknas semaforen ner till 0. Utskriften startar. A blir avbruten av process B som har högre prioritet. B vill också skriva ut. B anropar wait(lpr). Eftersom semaforen redan är 0 blir B försatt i väntetillstånd (wait/sleep). A slutför utskriften av det första dokumentet. Anropar signal(lpr). B plockas ut semaforkön och kan skriva ut. Anropar signal(lpr).

51 Operativsystem, © Mats Björkman, MDH 51 Semaforer forts. UNLOCK EXIT TO DISPATCHER EXIT TO DISPATCHER LOCK WAIT(S) SIGNAL(S) S > 0 N Y N Y FIND CURRENT PROCESS DESCRIPTOR MOVE FROM READY QUEUE TO WAITING ADD TO SEMAPHORE QUEUE S = S - 1S = S + 1 EMPTY SEMAPHORE QUEUE DEQUEUE PROCESS DESCRIPTOR ADD TO READY QUEUE

52 Operativsystem, © Mats Björkman, MDH 52 Processynkronisering Uppgift: synkronisera aktiviteter som måste ske i viss ordning Exempel: Producent/konsumentproblemet En process producerar meddelanden Meddelandena placeras i en kö En annan process läser meddelandena Problem: Begränsad köstorlek

53 Operativsystem, © Mats Björkman, MDH 53 Producent/konsument När producenten har producerat ett meddelande skall konsumenten kunna konsumera det När kön är full måste producenten vänta tills konsumenten konsumerat ett meddelande När kön är tom näste konsumenten vänta tills producenten producerat ett meddelande

54 Operativsystem, © Mats Björkman, MDH 54 Producent/konsument Exempel: Vi använder tre semaforer: En räknande semafor för antalet tomma platser En räknande semafor för antalet fulla platser En binär semafor (mutex) för att få ömsesidigt uteslutande vid åtkomst till den delade kön

55 Operativsystem, © Mats Björkman, MDH 55 Producent/konsumentproblemet – med semaforer # define N 100 semaphore mutex = 1; semaphore empty = N; semaphore full = 0; void producer(void) { int item; while(TRUE){ produce_item(&item); wait(&empty); wait(&mutex); enter_item(item); signal(&mutex); signal(&full); } /* Number of slots in the buffer */ /* Mutual exclusion */ /* Number of empty slots in the buffer */ /* Number of full slots in the buffer */ void consumer(void) { int item; while(TRUE){ wait(&full); wait(&mutex); remove_item(&item); signal(&mutex); signal(&empty); consume_item(item); }

56 Operativsystem, © Mats Björkman, MDH 56 # define N 100 semaphore mutex = 1; semaphore empty = N; semaphore full = 0; void producer(void) { int item; while(TRUE){ produce_item(&item); wait(&empty); wait(&mutex); enter_item(item); signal(&mutex); signal(&full); } /* Number of slots in the buffer */ /* Mutual exclusion */ /* Number of empty slots in the buffer */ /* Number of full slots in the buffer */ void consumer(void) { int item; while(TRUE){ wait(&mutex); wait(&full); remove_item(&item); signal(&mutex); signal(&empty); consume_item(item); } Producent/konsumentproblemet – med semaforer – felaktigt

57 Operativsystem, © Mats Björkman, MDH Semaforer Semaforer i kernel space vs user space Semaforer i kernel space => systemanrop till OS:et Användbara för synkronisering mellan processer Kräver inte delat minne mellan processerna Windows: CreateSemaphore(), CreateMutex() Unix: semget() Semaphore Standard POSIX: sem_init() Semaforer i user space => hanteras i tillämpningen Användbara för synkronisering mellan trådar i samma process Använder delat minne (plus ofta någon form av stöd från OS:et) Windows: CriticalSection() – anropar endast kärnan när någon behöver ställa sig i kö Linux Futex (Fast userspace mutex): kräver TAS el. liknande + systemanrop för köhanterning 57

58 Operativsystem, © Mats Björkman, MDH 58 Meddelandesystem Processkommunikation genom meddelanden Två primitiver send receive Direkt kommunikation, eller Indirekt kommunikation

59 Operativsystem, © Mats Björkman, MDH 59 Meddelandesystem - Direkt kommunikation Process to Process IPC Send(toProcess, message); Receive(fromProcess, message); Skicka “broadcast” till flera mottagande processer Synkron överföring (Rendezvous) Ingen buffring, processerna blockeras tills överföringen sker Analogi: Telefon Asynkron överföring Buffrad kommunikation, ingen blockering Analogi: telefonsvarare

60 Operativsystem, © Mats Björkman, MDH 60 Meddelandesystem - Indirekt kommunikation Kommunikation via brevlåda (mailbox) En mailbox innehåller En buffert Ett namn Två möjligheter Mailboxen ägs av en process Mailboxen ägs av OS:et P1P2 P3 Mailbox owned by the OS P1P2 Mailbox owned by the process

61 Operativsystem, © Mats Björkman, MDH 61 Producent/konsumentproblemet – med meddelandeöverföring #define N 100 void producer(void){ int item; message m,token; while(1){ produce_item(&item); receive(consumer,&token); build_mesg(&m,&item); send(consumer, &m); } void consumer(void){ int item, i; message m,token; for(i=0;i

62 Operativsystem, © Mats Björkman, MDH 62 Delat minne De flesta operativsystem stöder det Speciella primitiver för skapande och åtkomst Felkällor: synkronisering måste bli rätt Inte bra för distribuerade system Dock snabbt och effektivt om processerna kan dela fysiskt minne

63 Operativsystem, © Mats Björkman, MDH Delat minne Det delade minnet mappas in i båda processernas adressrymd 63 P1P2 Shared Memory Windows: CreateFileMapping(), MapViewOfFile() Linux/Unix: shm_open(), mmap()

64 Operativsystem, © Mats Björkman, MDH 64 Lärandemålen igen Varför behövs processkommunikation och processynkronisering? Race condition, ömsesidigt uteslutande, kritiska avsnitt Mekanismer för kommunikaiton/synkronisering Semaforer, meddelandeöverföring, delat minne


Ladda ner ppt "Operativsystem - Processkommunikation Mats Björkman 2015-01-26."

Liknande presentationer


Google-annonser