Dagens tema: Semaforer Hva er en semafor? Produsent/konsument-problemet Fraktaleksemplet med semaforer og delt lager. Klassisk eksempel: «De spisende filosofer» Vranglås «De spisende filosofer»: løsning som fungerer En foreløbig oversikt Ark 1 av 29 Forelesning 30.4.2001
Semaforer Semaforer ble oppfunnet i 1965 av Edsger Dijkstra og var den første praktisk brukbare mekanismen for parallellstyring. En semafor er en datastruktur: Verdi Kø Semaforer har to operasjoner: down(&s) Hvis verdien til s er > 0, vildenbli senket med 1. Hvis ikke, vil prosessen bli blokkert og dens nummer lagt til køen til s. up(&s) Hvis køen til s er tom, økes verdien med 1. Hvis ikke, fjernes ett prosessnummer fra køen, og den tilhørende prosessen startes opp igjen. Forelesning 30.4.2001 Ark 2 av 29
Semaforer beskytter kritisk region semaphore mutex = 1; /* Mutual exclusion */. down(&mutex); Kritisk region up(&mutex); Med en slik beskyttelse er det garantert at maksimalt én prosess av gangen er i kritisk region. En semafor som kun har verdiene 0 og 1, kalles en binær-semafor. Forelesning 30.4.2001 Ark 3 av 29
Bruk av semaforer Hva skjer når en prosess vil inn i kritisk region? Hvis mutex.verdi> 0, er det bare å gå inn. Hvis mutex.verdi= 0, må prosessen vente. Ved å sette en annen initialverdi, kan man tillate flere inne i kritisk region samtidig. Forelesning 30.4.2001 Ark 4 av 29
Produsent/konsument-problemet Dette problemet er et av de aller mest kjente problemene innen parallellstyring. Buffer P K I dette systemet er det to prosesser: P produserer ett eller annet. Dette legges i bufferen. K konsumerer det P lager, dvs. henter det fra bufferen og gjør ett eller annet med det. Siden bufferen er begrenset, hender det at P eller K må ta en pause: P må stoppe hvis det ikke er mer ledig plass i bufferen. K må stoppe hvis det ikke er flere elementer å hente i bufferen. Dessuten må ikke mer enn én prosess av gangen aksessere bufferen. Forelesning 30.4.2001 Ark 5 av 29
PK-problemet løst med semaforer #define N 100 semaphore mutex = 1; semaphore empty = N; /* Teller tomme */ semaphore full = 0; /* Teller fulle */ producer() int item; while (TRUE) produce_item(&item); down(&empty); down(&mutex); enter_item(item); up(&mutex); up(&full); consumer() int item; while (TRUE) down(&full); down(&mutex); remove_item(&item); up(&mutex); up(&empty); consume_item(item); Forelesning 30.4.2001 Ark 6 av 29
Her skjer følgende: Det å sette verdier inn i bufferen (ved å kalle på funksjonen enter item) og ta dem ut derfra (ved å kalle remove item) er kritiske regioner. Disse beskyttes av en binær-semafor (mutex). For å blokkere producer når bufferen er full, innføres semaforen empty, som teller hvor lange tomme plasser det er i bufferen. Hvis det ikke er noen ledige plasser, vil producer bli blokkert. Når consumer har hentet et nytt element fra bufferen, vil den øke empty. Hvis producer da var blokkert, vil den bli frigjort. For å blokkere consumer når bufferen er tom, innføres semaforen full, som teller hvor mange fulle posisjoner det er i bufferen. Hvis det ikke er noen fulle posisjoner, vil consumer bli blokkert. Når producer har lagt et nytt element i bufferen, vil den øke full. Hvis consumer da var blokkert, vil den bli frigjort. Forelesning 30.4.2001 Ark 7 av 29
Semaforer i SVIPC i UNIX For å kunne operere på semaforer i UNIX trenger vi et par definisjonsfiler: #include <sys/ipc.h> #include <sys/sem.h> En gruppe på n semaforer allokeres slik i SVIPC: int sem_id; sem_id = semget(ipc_private, /* Nøkkel */ n, /* Antall */ 0700); /* Aksesskode */ if (sem_id<0) perror("semprog"); Etter bruk må man huske å frigjøre semaforene: semctl(sem_id, 0, IPC_RMID); Forelesning 30.4.2001 Ark 8 av 29
Operasjonene down og up kan programmeres slik (uten at man trenger å forstå det): void down(int n) struct sembuf op; int status; op.sem_num = n; op.sem_op = -1; op.sem_flg = 0; status = semop(sem_id, &op, 1); if (status!= 0) printf("semaphore down error %d.\n", status); exit(1); void up(int n) struct sembuf op; int status; op.sem_num = n; op.sem_op = 1; op.sem_flg = 0; status = semop(sem_id, &op, 1); if (status!= 0) printf("semaphore up error %d.\n", status); exit(1); Forelesning 30.4.2001 Ark 9 av 29
Fraktal-eksemplet med semaforer Fraktal-eksemplet vårt er et meget godt eksempel på produsent-konsument-problemet: Én eller flere produsenter produserer kolonner med fraktalpunkter. Bufferen har plass til ett sett data. En konsument mottar kolonnene med data og tegner dem på skjermen. Dataoverføringen skjer via delt lager. Forelesning 30.4.2001 Ark 10 av 29
Deklarasjoner #include <sys/ipc.h> #include <sys/shm.h> #include <sys/sem.h> #include <sys/types.h> #include <stdio.h> #include <stdlib.h> #include <time.h> #include <unistd.h> #include "fraktal.h" #include "x147.h" extern pid_t safefork(void); #define NX 750 #define NY 550 #define MAX 180 #define MUTEX 0 /* Våre tre semaforer */ #define FULL 1 #define EMPTY 2 float x1 = -0.01, x2 = 0.01, y1 = -0.01, y2 = 0.01; typedef struct int xpos; unsigned char ycol[ny]; col_data; int sh_mem_id, sem_id; col_data *sh_mem; Forelesning 30.4.2001 Ark 11 av 29
Hovedprogrammet Hovedprogrammet allokerer ressurer og starter produsentene og konsumenten. int main(int argc, char *argv[]) time_t start_tid = time(null); int n_proc, nc; n_proc= argc <= 1? 1 : atoi(argv[1]); sh_mem_id = shmget(ipc_private,sizeof(col_data),0700); if (sh_mem_id < 0) perror("fraksem1"); sh_mem = shmat(sh_mem_id,0,0); sem_id = semget(ipc_private, 3, 0700); if (sem_id < 0) perror("fraksem1"); up(mutex); up(empty); /* Sett initialverdi. */ x147open(nx, NY); for (nc = 1; nc <= n_proc; ++nc) if (safefork() == 0) produsent(nx*(nc-1)/n_proc, NX*nc/n_proc-1); exit(0); konsument(); printf("det hele tok %d sekunder.\n", time(null)-start_tid); x147pause(); terminate(0); Forelesning 30.4.2001 Ark 12 av 29
Produsentene Hver produsent skal generere data for sitt område av bildet. Når én kolonne er ferdig, sendes den til konsumenten. void produsent(int xstart, int xend) float x, y; int ix, iy, fx; col_data buf; for (ix = xstart; ix <= xend; ++ix) buf.xpos = ix; x = x1 + ix*(x2-x1)/(nx-1); for (iy = 0; iy < NY; ++iy) y = y1 + iy*(y2-y1)/(ny-1); buf.ycol[iy] = fraktal(x, y, 255.0, MAX); /* Kritisk region... */ down(empty); down(mutex); *sh_mem = buf; up(mutex); up(full); /*... slutt på kritisk region. */ Forelesning 30.4.2001 Ark 13 av 29
Konsumenten Produsenten skal hente data fra produsentene og tegne dem på skjermen. Den er ferdig når alle kolonnene er tegnet opp. void konsument(void) col_data buf; int cx, iy; for (cx = 0; cx < NX; ++cx) /* Kritisk region... */ down(full); down(mutex); buf = *sh_mem; up(mutex); up(empty); /*... slutt på kritisk region. */ for (iy = 0; iy < NY; ++iy) x147plot(buf.xpos, iy, buf.ycol[iy]); x147sync(); if (x147done) terminate(0); Forelesning 30.4.2001 Ark 14 av 29
Terminering void terminate(int status) if (shmctl(sh_mem_id, IPC_RMID, 0) < 0) perror("fraksem"); if (semctl(sem_id, 0, IPC_RMID) < 0) perror("fraksem"); exit(status); Resultat Kombinasjonen semaforer/felles lager er like effektivt som rør, men med større fleksibilitet. Ikke-parallell tegning 19s fraksem 1 18s fraksem 2 10s fraksem 3 7s fraksem 4 7s fraksem 6 8s Forelesning 30.4.2001 Ark 15 av 29
Husk! Husk at både semaforer og delt lager er en meget begrenset ressurs, og at disse ikke fjernes automatisk. Sjekking Kommandoen ipcs forteller om det er allokert noen semaforer eller delt lager: maskin navn> ipcs IPC status from /dev/kmem as of Fri Apr 27 16:35:30 T ID KEY MODE OWNER GROUP Message Queues: Shared Memory: m 0 0x53637444 --rw-r--r-- root root m 2001 0x00000000 --rw------- kritisk ifi-a m 2 0x00000000 --rw------- kritisk ifi-a Semaphores: s 0 0x2a1107e3 --ra-ra-ra- root root s 41 0x00000000 --ra------- kritisk ifi-a s 2 0x00000000 --ra------- kritisk ifi-a Forelesning 30.4.2001 Ark 16 av 29
Fjerning Kommandoen ipcrm brukes til fjerning av både semaforer (opsjonen -s) og delt lager (opsjonen -m): maskin navn> ipcrm -m 2001 maskin navn> ipcrm -m 2 maskin navn> ipcrm -s 41 maskin navn> ipcrm -s 2 maskin navn> ipcs IPC status from /dev/kmem as of Fri Apr 27 16:37:51 T ID KEY MODE OWNER GROUP Message Queues: Shared Memory: m 0 0x53637444 --rw-r--r-- root root Semaphores: s 0 0x2a1107e3 --ra-ra-ra- root root Forelesning 30.4.2001 Ark 17 av 29
«De spisende filosofer» Problemet med «the dining philosophers» ble presentert av Edsger Dijkstra i 1965. Rundt et bord sitter 5 filosofer: 7 7 7 7 7 Hver av dem har foran seg en tallerken med spagetti og en gaffel til venstre for tallerkenen. Man trenger to gafler (ens egen og høyre sidemanns) for å spise spagetti. Hver filosof tilbringer dagen med vekselvis å tenke og å spise. De snakker aldri sammen. Problemet er å finne en algoritme som sørger for at alle filosofene får mat fra tid til annen. Forelesning 30.4.2001 Ark 18 av 29
Forsøk på løsning #define N 5 #define LEFT(x) ((x)==0? N-1 : (x)-1) #define RIGHT(x) ((x)==n-1? 0 : (x)+1) philosopher(i) /* Hva skal filosof i gjøre? */ int i; while (TRUE) think(); take_fork(i); take_fork(right(i)); eat(); put_fork(i); put_fork(right(i)); Rutinen take fork okkuperer angitte gaffel hvis den er ledig; hvis ikke, blir prosessen blokkert. Rutinen put fork frigjør angitte gaffel. Vurdering Kan føre til vranglås. Vi kan risikere at alle filosofene plukker opp sin gaffel og så sulter i hjel mens de venter på at en annen skal legge fra seg sin. Konklusjon: Ubrukelig. Forelesning 30.4.2001 Ark 19 av 29
Et nytt forsøk på løsning Ved å gjøre spisingen til en kritisk region, sikrer vi at filosofen alltid får tak i begge gafler. #define N 5 #define LEFT(x) ((x)==0? N-1 : (x)-1) #define RIGHT(x) ((x)==n-1? 0 : (x)+1) semaphore mutex = 1; philosopher(i) /* Hva skal filosof i gjøre? */ int i; while (TRUE) think(); down(&mutex); /* Lag en kritisk region... */ take_fork(i); take_fork(right(i)); eat(); put_fork(i); put_fork(right(i)); up(&mutex); /*...kritisk region. */ Vurdering + Vil ikke gå i vranglås. Kun én filosof kan spise av gangen. Konklusjon: Egentlig ubrukelig. Forelesning 30.4.2001 Ark 20 av 29
Enda et forsøk Vi kan la en sulten filosof sjekke om gaffelen til høyre sidemann er ledig; hvis den ikke er det, legger filosofen fra seg sin egen gaffel og tenker litt til. #define N 5 #define LEFT(x) ((x)==0? N-1 : (x)-1) #define RIGHT(x) ((x)==n-1? 0 : (x)+1) philosopher(i) /* Hva skal filosof i gjøre? */ int i; while (TRUE) think(); take_fork(i); if (free_fork(right(i)) /* Sjekk om ledig. */ eat(); put_fork(right(i)); put_fork(i); (Her vil kallet på free fork returnere med 0 (= FALSE) hvis gaffelen ikke er ledig. Hvis den er ledig, blir den tatt, så vi trenger ikke kalle på take fork.) Forelesning 30.4.2001 Ark 21 av 29
Vurdering + Denne løsningen vil stort sett gå bra, særlig hvis vi vet at hvor lenge hver filosof tenker om gangen varierer tilfeldig. I meget spesielle tilfelle oppstår det utsulting. Filosofene vil ta opp og legge ned gafler i takt uten at noen får spise. Konklusjon: Brukbar, med mindre vi ønsker 100% sikkerhet. Forelesning 30.4.2001 Ark 22 av 29
Vranglås Av og til kan det skje at flere prosesser venter på hverandre, for eksempel A skriver fil F A og trenger å lese F B. B skriver fil F B og trenger å lese F A. Hvis det å skrive på en fil låser den, har vi en vranglåssituasjon. Løsning Den eneste måten å løse opp en slik situasjon på er å drepe en av prosessene. Forhåpentligvis kan den startes på nytt igjen. Forelesning 30.4.2001 Ark 23 av 29
Hvordan løse vranglås? Dette har det vært forsket mye på. Noen muligheter er: Programmere slik at de ikke oppstår! Skrive programmene slik at de kan startes på nytt om noe går galt. Lære å leve med dem («strutsemetoden»). Forelesning 30.4.2001 Ark 24 av 29
Endelig: et forslag som fungerer Denne løsningen ble funnet av Edsger Dijkstra: #define N 5 #define LEFT(x) ((x)==0? N-1 : (x)-1) #define RIGHT(x) ((x)==n-1? 0 : (x)+1) enum Status Tenker, Sulten, Spiser; enum Status stat[n]; semaphore mutex = 1; semaphore s[n]; void philosopher(i) /* Filosof nr. i */ int i; while (TRUE) think(); take_forks(i); eat(); put_forks(i); void take_forks(i) /* Få tak i 2 gafler. */ int i; down(&mutex); /* Kritisk region... */ stat[i] = Sulten; /* Fortell om sulten. */ test(i); /* Prøv å få 2 gafler. */ up(&mutex); /*...kritisk region. */ down(&s[i]); /* Blokkér uten gafler. */ Forelesning 30.4.2001 Ark 25 av 29
void put_forks(i) /* Legg gaflene tilbake. */ int i; down(&mutex); /* Kritisk region... */ stat[i] = Tenker; /* Fortell hva jeg gjør. */ test(left(i)); /* Sjekk om en nabo */ test(right(i)); /* vil spise nå. */ up(&mutex); /*...kritisk region. */ void test(i) /* Kan filosof nr i spise? */ int i; if (stat[i] == Sulten && stat[left(i)]!= Spiser && stat[right(i)]!= Spiser) stat[i] = Spiser; /* Nå kan nr. i spise. */ up(&s[i]); Forelesning 30.4.2001 Ark 26 av 29
Hvorledes fungerer dette opplegget? philosopher er filosof-prosessene. Hver filosof veksler mellom å tenke, bli sulten og ta opp to gafler (take forks vil blokkere inntil de aktuelle to gaflene er ledige), spise, og legge fra seg gaflene. take forks endrer filosofens status til Sulten. Så sjekkes (i funksjonen test) om filosofen kan spise; i så fall avsluttes rutinen; hvis ikke blokkeres på down(&s[i]). put forks vil legge fra seg gaflene og endre filosofens status til Tenker. Så sjekkes de to naboene; hvis de ønsket å spise og kan gjøre det nå, får de lov til det (up(&s[i])). test sjekker om en spesiell filosof (angitt som parameter) kan spise. I så fall endres status til Spiser, og det foretas en up(&s[i]). Avhengig av kallet kan dette ha to effekter: Hvis test ble kalt fra take forks, vildet siste down-kallet der gå glatt. Hvis test ble kalt fra put forks, vilden aktuelle filosofen være blokkert på det siste down-kallet i take forks, og vil nå få lov å spise. Forelesning 30.4.2001 Ark 27 av 29
Oppsummering Teknikk Synk Data Spesielt UNIX filer UNIX rør Forutsetter samme urprosess, kan ikke alltid brukes. Delt lager Semaforer Forelesning 30.4.2001 Ark 28 av 29
Viktig beskjed! Som nevnt i starten av semesteret er alle oppmeldt til eksamen i både IN147 og IN147-A. Det er viktig at dere melder dere av den delen dere ikke skal ta før fristen går ut. Frist for avmelding til eksamen er senest 14 dager før eksamensdatoen, hvilket vil si 14. mai Forelesning 30.4.2001 Ark 29 av 29