Operativsystem - Processkommunikation

Transkript

1 Operativsystem - Processkommunikation Mats Björkman

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 Operativsystem, Mats Björkman, MDH 2

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 Operativsystem, Mats Björkman, MDH 3

4 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) Operativsystem, Mats Björkman, MDH 4

5 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 Operativsystem, Mats Björkman, MDH 5

6 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." Operativsystem, Mats Björkman, MDH 6

7 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 Operativsystem, Mats Björkman, MDH 7

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 Operativsystem, Mats Björkman, MDH 8

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

10 Ömsesidigt uteslutande 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 exklusion) kallas egenskapen vi vill garantera för dessa resurser Operativsystem, Mats Björkman, MDH 10

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

12 Exempel ur verkligheten 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 Operativsystem, Mats Björkman, MDH 12

13 Exempel ur verkligheten 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 Operativsystem, Mats Björkman, MDH 13

14 Exempel ur verkligheten 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 Operativsystem, Mats Björkman, MDH 14

15 Kritiskt avsnitt 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 Operativsystem, Mats Björkman, MDH 15

16 Ömsesidigt uteslutande Exempel utan kritiskt avsnitt: Process A Process 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. Operativsystem, Mats Björkman, MDH 16

17 Ömsesidigt uteslutande 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 Operativsystem, Mats Björkman, MDH 17

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

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

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

21 Ömsesidigt uteslutande Ä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 Operativsystem, Mats Björkman, MDH 21

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

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

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 Operativsystem, Mats Björkman, MDH 24

25 Ömsesidigt uteslutande - Algoritm i tillämpningen int turn = 0; void thread0(){ void thread1(){ while(1){ while(1){ // some code // 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? Operativsystem, Mats Björkman, MDH 25

26 Ömsesidigt uteslutande - Algoritm i tillämpningen int turn = 0; void thread0(){ void thread1(){ while(1){ while(1){ // some code // 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? Operativsystem, Mats Björkman, MDH 26

27 Ömsesidigt uteslutande - Algoritm i tillämpningen int turn = 0; void thread0(){ void thread1(){ while(1){ while(1){ // some code // 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? Operativsystem, Mats Björkman, MDH 27

28 Ömsesidigt uteslutande - Algoritm i tillämpningen (bättre?) boolean interested[2] = {false,false}; void thread0(){ void thread1(){ while(1){ while(1){ // some code // 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? Operativsystem, Mats Björkman, MDH 28

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 // 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? Operativsystem, Mats Björkman, MDH 29

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

31 Ö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) int TAS(char *flag){ int result; asm{ tas flag bne alreadyset move #0,&result bra exit alreadyset: move #1,&result exit: } return result; } Operativsystem, Mats Björkman, MDH 31

32 Ömsesidigt uteslutande - Algoritm i tillämpningen med hårdvarustöd 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? } Operativsystem, Mats Björkman, MDH 32

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 Operativsystem, Mats Björkman, MDH 33

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? Operativsystem, Mats Björkman, MDH 34

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

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

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

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

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 Operativsystem, Mats Björkman, MDH 39

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. Operativsystem, Mats Björkman, MDH 40

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) Operativsystem, Mats Björkman, MDH 41

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) Operativsystem, Mats Björkman, MDH 42

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 Operativsystem, Mats Björkman, MDH 43

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( ) Operativsystem, Mats Björkman, MDH 44

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 Operativsystem, Mats Björkman, MDH 45

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 Operativsystem, Mats Björkman, MDH 46

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) Operativsystem, Mats Björkman, MDH 47

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 Operativsystem, Mats Björkman, MDH 48

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 Operativsystem, Mats Björkman, MDH 49

50 Semaforer forts. Skrivarproblemet löst med semaforer: Process A Process 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). Operativsystem, Mats Björkman, MDH 50

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

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 Operativsystem, Mats Björkman, MDH 52

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 Operativsystem, Mats Björkman, MDH 53

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 Operativsystem, Mats Björkman, MDH 54

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);! }! }! Operativsystem, Mats Björkman, MDH 55

56 Producent/konsumentproblemet med semaforer felaktigt #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);! }! }! Operativsystem, Mats Björkman, MDH 56

57 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 Operativsystem, Mats Björkman, MDH 57

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

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 Operativsystem, Mats Björkman, MDH 59

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 Mailbox owned by the process P1 P2 Mailbox owned by the OS Mailboxen ägs av OS:et P1 P2 P3 Operativsystem, Mats Björkman, MDH 60

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<n;i++) send(procucer,&token); while(1){ receive(producer,&m); } extract_item(&m); send(producer, &token); consume_item(item); Operativsystem, Mats Björkman, MDH 61

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 Operativsystem, Mats Björkman, MDH 62

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

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 Operativsystem, Mats Björkman, MDH 64