Processer og koordinering. dopsys 1

Processer og koordinering dopsys 1

Motivation.. parallelle processer udnytter hardwaren bedre: Batch operativsystemer (50 erne): Multiprogrammering og time-sharing (60 erne): dopsys 2

Motivation.. parallelle algoritmer kan gøre store beregninger hurtigere: Evaluering af aritmetiske udtryk: Proces-flowgraf: (a + b) * (c + d) - (e / f).. flere aktiviteter afvikles samtidigt (logisk eller fysisk). dopsys 3

Proces-begrebet.. er centralt i understøttelse af virtualisering: Kørende system: samling af samtidige, sekventielle processer Proces: et program under afvikling SP A data stack SP B data stack proces-struktur (process image) PC A program Proces A program Proces B.. processer kommunikerer og synkroniserer med hinanden. PC B dopsys 4

Proces-primitiver (1) cobegin-coend (Dijkstra, 1968): cobegin C1 // C2 // // Cn coend cobegin cobegin t1 = a+b // t2 = c+d coend; t4 = t1*t2 // t3 = e/f coend; t5 = t4-t3;.. begrænset form for synkronisering ifm. terminering kan udtrykkes. dopsys 5

Proces-primitiver (2) fork-join-quit (Conway 1963, Dennis/Van Horn 1966): fork x : skab en ny proces, begynd udførelse ved label x join t,y : t = t 1; if (t == 0) goto y; (atomart) quit : terminér processen n = 2; fork L3; m = 2; fork L2; t1 = a+b; join m,l4; quit; L2: t2 = c+d; join m,l4; quit; L4: t4 = t1*t2; join n,l5; quit; L3: t3 = e/f; join n,l5; quit; L5: t5 = t4-t3;.. alle proces-flowgrafer kan udtrykkes, men ikke pænt... dopsys 6

? [Click] Hvorfor kan denne procesgraf ikke udtrykkes med cobegin/coend? S A. To kanter ender i samme knude, men starter ikke i samme knude B. Et ulige antal kanter mødes i et punkt C. Manglende parentes-struktur D. Vi kan ikke udtrykke S og F E. Den kan da godt udtrykkes! F dopsys 7

Eksempel: Unix OS.. implementerer variant af fork-join-quit: dopsys 8

Dokumentation af systemkald %> man fork NAME fork - create a child process SYNOPSIS #include <sys/types.h> #include <unistd.h> pid_t fork(void); DESCRIPTION fork creates a child process that differs from the parent process only in its PID and PPID, and in the fact that resource utilizations are set to 0. File locks and pending signals are not inherited. RETURN VALUE On success, the PID of the child process is returned in the parent's thread of execution, and a 0 is returned in the child's thread of execution. On failure, a -1 will be returned in the parent's context, no child process will be created, and errno will be set appropriately. ERRORS dopsys 9

void process_a(void) { pid_t pid = fork (); if (pid == 0) { /* child process */ int i; for (i=0; i<10; i++) { printf("process B\n"); sleep(2); else { /* parent process */ int i; for (i=0; i<10; i++) { printf("process A\n"); sleep(1); int main(int argc,char *argv[]) { process_a(); exit(0); >%./processab process A process B process A process B process A process A process B process A process A process B process A process A process B process A process B process B dopsys 10

void process_a(void) { pid_t pid = fork (); if (pid == 0) { /* child process */ int i; for (i=0; i<10; i++) { printf("process B\n"); sleep(2); else { /* parent process */ int i; for (i=0; i<10; i++) { printf("process A\n"); sleep(1); int main(int argc,char *argv[]) { process_a(); exit(0); OK, men her har vi selvfølgelig glemt noget. >%./processab process A process B process A process B process A process A process B process A process A process B process A process A process B process A process B process B Hvad er det? ;-) dopsys 10

/* processa.c */ void process_a(void) { pid_t pid = fork (); /* execute the program */ if (pid == 0) { /* child process */ char filename[9] = "processb"; char *argv[2]; argv[0] = filename; argv[1] = NULL; execvp(filename,argv); else { /* parent process */ int i; for (i=0; i<10; i++) { printf("process A\n"); sleep(1); /* processb.c */ #include <stdio.h> #include <unistd.h> int main(int argc,char *argv[]) { int i; for (i=0; i<10; i++) { printf("process B\n"); sleep(2); exit(0); %> gcc o processb processb.c %> gcc o processa processa.c %>./processa... int main(int argc,char *argv[]) { process_a(); exit(0); dopsys 11

spørgsmål omkring processer? dopsys 12

Proces-interaktion.. processer skal synkronisere adgang til delte data: cobegin P1: x = x + 1; // P2: x = x + 1; coend ønsket: x new = x old +2 P1 1 mov x,r1 2 inc R1 3 mov R1,x P2 1 mov x,r1 2 inc R1 3 mov R1,x.. korrekthed af resultatet afhænger af schedulering (race condition). dopsys 13

Kritiske regioner cobegin p1: while(1) {CS1; program 1; // p2: while(1) {CS2; program 2; //... // pn: while(1) {CSn; program n; coend data Antagelser: 1. Delte data tilgås kun i kritisk region (CSi) 2. Læsning/skrivning af lagerceller sker atomart 3. Processers hastighed kendes ikke (kan være lav!) 4. Processer terminerer kun udenfor kritiske regioner (program i) dopsys 14

Gensidig udelukkelse (mutual exclusion).. kun een proces ad gangen kan udføre kode i en kritisk region: entry kode exit kode data Undgå gensidig blokering (mutual blocking): 1. Processer udenfor CS må ikke forhindre andre processers adgang 2. En proces der ønsker adgang skal have adgang med tiden (starvation) 3. Processer må ikke gensidigt blokere hinanden (deadlocks) 4. Processer må ikke altid gensidigt udsætte adgang til CS (livelocks) dopsys 15

Alternerings-algoritme int turn = 1; cobegin p1: while (1) { while (turn==2); /* wait */ CS1; turn = 2; program 1; // p2: while (1) { while (turn==1); /* wait*/ CS2; turn = 1; program 2; coend dopsys 16

Alternerings-algoritme int turn = 1; cobegin p1: while (1) { while (turn==2); /* wait */ CS1; turn = 2; program 1; // p2: while (1) { while (turn==1); /* wait*/ CS2; turn = 1; program 2; coend Naiv! dopsys 17

Forsøg #2 int c1 = 0, c2 = 0; cobegin p1: while (1) { c1 = 1; while (c2); /* wait */ CS1; c1 = 0; program 1; // p2: while (1) { c2 = 1; while (c1); /* wait */ CS2; c2 = 0; program 2; coend Dur ikke! (deadlock) dopsys 18

Forsøg #2 int c1 = 0, c2 = 0; cobegin p1: while (1) { c1 = 1; while (c2); /* wait */ CS1; c1 = 0; program 1; // p2: while (1) { c2 = 1; while (c1); /* wait */ CS2; c2 = 0; program 2; coend Dur ikke! (deadlock) dopsys 19

Forsøg #3 int c1 = 0, c2 = 0; cobegin p1: while (1) { c1 = 1; if (c2) { c1 = 0 else { CS1; c1 = 0; program 1; // p2: while (1) {... /* similar */ coend Dur ikke! (livelock) dopsys 20

Forsøg #3 int c1 = 0, c2 = 0; cobegin p1: while (1) { c1 = 1; if (c2) { c1 = 0 else { CS1; c1 = 0; program 1; // p2: while (1) {... /* similar */ coend Dur ikke! (livelock) dopsys 21

Petersons Algoritme (1981) int c1 = 0, c2 = 0, willwait; cobegin p1: while (1) { c1 = 1; willwait = 1; while (c2 && (willwait==1)); /* wait */ CS1; c1 = 0; program 1; // p2: while (1) { c2 = 1; willwait = 2; while (c1 && (willwait==2)); /* wait */ CS2; c2 = 0; program 2; coend dopsys 22

Q/A En kritisk region er associeret med to typer områder i lageret. Beskriv dem (to og to)! dopsys 23

Korrekthed Kun kritiske regioner bruger delte data. Højst een proces ad gangen er i en kritisk region. Undgå gensidig blokering (mutual blocking): 1. Processer udenfor CS må ikke forhindre adgang for andre processer 2. En proces der ønsker adgang skal senere få muligheden (starvation) 3. Processer må ikke gensidigt blokere hinanden (deadlocks) 4. Processer må ikke gensidigt kunne udsætte adgang til CS (livelocks) dopsys 24

spørgsmål om synkronisering? dopsys 25

Semaphorer (Dijkstra, 1968).. et ikke-negativt heltal der kan blokere processer: Atomare operationer: V (up): if anyblocked() then unblockone() else s = s + 1; P (down): if s > 0 then s = s - 1; else block () Tællesemaphorer: husker antallet af up operationer. Binære semaphorer (mutex): kun værdierne 0 eller 1 antages... semaphor-operationer ofte implementeret via systemkald. dopsys 26

Eksempel: Wait/Wakeup semaphore s = 0; cobegin p1:... down(s); /* sit down and wait for signal */... // p2:... up(s); /* send signal to wake up p1 */...... coend; dopsys 27

Eksempel: Gensidig udelukkelse.. kan nu realiseres ved brug af binære semaphorer: semaphore mutex = 1; cobegin pi: while(1) { down(mutex); /* lock CS */ CSi; up(mutex); /* unlock CS */ program i; coend dopsys 28

Eksempel: Producer-Consumer Begrænset buffer af størrelse n mellem Producer og Consumer: 1. Producer blokerer hvis buffer er fuld. 2. Consumer blokerer hvis buffer er tom... integritet af buffer datastruktur skal sikres. dopsys 29

Eksempel: Producer-Consumer Tællesemaphorer: e antal tomme buffer indgange (blokering af producer). f antal fyldte buffer slots (blokering af consumer). Mutex: b gensidig udelukkelse omkring buffer opdatering. semaphore e = n, f = 0, b = 1; cobegin Producer: while (1) { Produce_next_record; down(e); lock(b); Add_to_buf; unlock(b); up(f); // Consumer: while (1) { down(f); lock(b); Take_from_buf; unlock(b); up(e); Process_record; coend dopsys 30

[Click] Hvad hvis vi bytter down/lock? A. OK B. Fare for deadlock C. Fare for race condition semaphore e = n, f = 0, b = 1; cobegin Producer: while (1) { Produce_next_record; down(e); lock(b); Add_to_buf; unlock(b); up(f); // Consumer: while (1) { down(f); lock(b); Take_from_buf; unlock(b); up(e); Process_record; coend dopsys 31

Opsummering Processer: Proces-begreb: program under afvikling Logisk og fysisk parallellitet Basale proces-primitiver: cobegin/coend, fork/join/quit Unix OS primitiver: fork, execve, exit og waitpid Koordinering: Kritiske regioner og gensidig udelukkelse Peterson s algoritme Semaphorer: tælle-semaphorer og binære semaphorer Nyhedsværdi: Flere begreber kendt fra andre kurser, nu på vej ind i ny kontekst dopsys 32