IN 147 Program og maskinvare

Transkript

1 Dagens tema: Lettvektsprosesser Moderne synkroniseringsmetoder Meldinger Monitorer Programkode er også bit-mønstre! Selvmodifiserende kode Ark 1 av 23 Forelesning

2 Lettvektsprosesser Det er vanlig å tegne en prosess slik: Stakk Data Kode En lettvektsprosess (ofte kalt «tråd») deler data- og kodelager med opphavet: Stakk Stakk Data Kode Dataoverføring er da ikke lenger noe problem, men synkronisering er stadig nødvendig. Forelesning Ark 2 av 23

3 Lettvektsprosesser i Java I Java kan man opprette lettvektsprosesser ved å deklarere subklasser av Thread som inneholder en metode run: class PingPong extends Thread { String id; int ventetid; PingPong(String idx, int ventx) { id = idx; ventetid = ventx; public void run() { try { while (true) { System.out.print(id + " "); sleep(ventetid); catch (Exception e) { return; public static void main(string args[]) { new PingPong("ping", 33).start(); new PingPong("PONG", 84).start(); Metoden start() brukes til å starte tråden, og stop() til å stoppe den. maskin navn> java PingPong ping PONG ping ping PONG ping ping PONG ping ping PONG ping ping PONG ping ping PONG ping ping PONG ping ping PONG ping ping PONG ping ping PONG ping ping PONG ping ping PONG ping ping PONG ping ping Forelesning Ark 3 av 23

4 Parallellstyring på høyt nivå Teknikkene beskrevet hittil har vært mellomnivåteknikker; de fungerer fint hvis programmeren behersker dem tilstrekkelig godt og ikke gjør feil. Feil bruk av semaforer semaphore mutex = 1; semaphore empty = N; /* Teller tomme */ semaphore full = 0; /* Teller fulle */ void producer() { int item; while (TRUE) { produce_item(&item); down(&mutex); down(&empty); /* Byttet! */ enter_item(item); up(&mutex); up(&full); void consumer() { int item; while (TRUE) { down(&full); down(&mutex); remove_item(&item); up(&mutex); up(&empty); consume_item(item); Forelesning Ark 4 av 23

5 Her kan følgende skje: 1. Vi antar at produsenten har vært raskere enn konsumenten slik at bufferen nå er full. 2. Produsenten lager enda ett element. Så utfører den down(&mutex) og går inn i kritisk region, og deretter down(&empty). Nå blokkeres den fordi bufferen er full. 3. Så skjer et prosessbytte. 4. Konsumenten gjør en down(&full) og deretter en down(&mutex) for å gå inn i kritisk region. Da blokkeres den, fordi produsenten allerede er i kritisk region. Vi har altså fått en situasjon med vranglås fordi to kall på down ble byttet om. Vi ønsker oss mer høynivå mekanismer hvor deterlettereåunngåslikt. Forelesning Ark 5 av 23

6 Meldinger Mange parallelle systemer er basert på en mekanisme som kalles meldinger. Det finnes mange varianter; én ser slik ut: Oversikt over meldinger Det finnes kun to operatorer for meldinger: send(q, kode, data ) sender meldingen data til meldingskøen q. Senderen blokkeren hvis køen er full, ellers ikke. receive(q, kode, & data ) henter en melding med angitt kode fra køen q. Henteren blokkeres inntil det finnes meldinger i køen. Forelesning Ark 6 av 23

7 Bruk av UNIX-meldinger #include <stdio.h> #include <string.h> #include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h> typedef struct { long id; char data[200]; mess_struct; void barn(int n, int q) { mess_struct m; int r_stat; printf("dette er barn nr %d\n", n); r_stat = msgrcv(q, &m, sizeof(m), n, 0); printf("barn %d: status=%d, id=%d, data=\"%s\"\n", n, r_stat, m.id, m.data); Meldingene er av typen mess struct; legg merke til at koden (id) ligger i første ord. Barne henter en melding med riktig kode (n) fra køen q (med msgrcv) og skriver ut data de får. maskin navn> q Dette er barn nr 1 Dette er barn nr 2 Barn 2: status=204, id=2, data="dette er post 2." Barn 1: status=204, id=1, data="dette er post 1." Forelesning Ark 7 av 23

8 int main(void) { mess_struct m1, m2; int q, status; q = msgget(ipc_private, 0700); /* Opprett køen */ if (q < 0) { perror("q"); exit(1); if (safefork() == 0) { barn(1,q); exit(0); if (safefork() == 0) { barn(2,q); exit(0); m1.id = 1; strcpy(m1.data, "Dette er post 1."); m2.id = 2; strcpy(m2.data, "Dette er post 2."); if (msgsnd(q,&m2,sizeof(m2),0)<0) { perror("q"); exit(12); if (msgsnd(q,&m1,sizeof(m1),0)<0) { perror("q"); exit(11); wait(&status); wait(&status); /* Vent på barna */ msgctl(q, IPC_RMID, NULL); /* Fjern køen */ Hovedprogrammet gjør følgende: 1. oppretter en meldingeskø q, 2. oppretter to barneprosesser, 3. bygger opp to meldinger m1 og m2, 4. sender de to meldingene til køen q, 5. venter til barna dør og 6. fjerner køen q. Forelesning Ark 8 av 23

9 Vurdering + Meldinger er enkle å bruke og forstå. + De er enkle å implementere. Resultatet er at meldinger brukes svært mye. Forelesning Ark 9 av 23

10 Monitorer Den aller første høynivåløsningen ble oppfunnetavc.a.r.hoareogper Brinch-Hansen i Den består av en klasse-lignende struktur kalt en monitor: class Eksempel { int i; // Lokal variabel. void synchronized p(...) {. wait();. notify();. // Operator: Eksempel e; e :- new Eksempel(); e.p(...); Forelesning Ark 10 av 23

11 Følgende gjelder for monitorer: Kun én prosess av gangen får utføre en operator i en monitor. Ytterligere forsøk på kall vil bli blokkert inntil monitoren er ledig. (I Java angis dette med synchronized.) Alle de lokale variablene er usynlige utenfor monitoren. (Dette kreves ikke i Java, men jeg anbefaler det.) En monitor kan blokkere seg selv ved å benytte wait() vil blokkere prosessen. Monitoren vil da bli åpnet for andre prosesser. notify() vil starte en eller annen prosess som tidligere ble blokkert ved å utføre wait(). Forelesning Ark 11 av 23

12 PK-problemet med Javas monitorer Produsenten class Producer extends Thread { Monitor m; intx,i,s,n; Producer(int start, int inkr, int sleep, Monitor mx) { x = start; i = inkr; s = sleep; m = mx; n = 0; public void run() { while (n < 20) { m.enter(x); x += i; ++n; try { sleep(s); catch (Exception e) { return; Produsenten er en lettvektsprosess som genererer 20 tall x, x + i, x + 2i,...,x+19i som sendes til monitoren med m.enter(x). Etter hvert tall sover prosessen litt. Forelesning Ark 12 av 23

13 Konsumenten class Consumer extends Thread { Monitor m; Consumer(Monitor mx) { m = mx; setdaemon(true); public void run() { int n_on_line = 0; while (true) { int x = m.remove(); System.out.print(x + " "); if (++n_on_line%10 == 0) System.out.println(""); Konsumenten er en lettvektsprosess som henter tall fra monitoren med m.remove() og skriver dem ut, 10 på hver linje. Konsumenten er konfigurert som demon slik at den automatisk drepes når alle brukerprosessene er ferdige. Forelesning Ark 13 av 23

14 Monitoren (med hovedprogrammet) class Monitor { // En ringbuffer: private int buf[], inn_p = 0, ut_p = 0, n = 0; Monitor() { buf = new int[10]; public synchronized void enter(int x) { try { while (n == 10) wait(); catch (Exception e) { System.exit(1); buf[inn_p++] = x; ++n; if (inn_p >= 10) inn_p = 0; notify(); public synchronized int remove() { int res; try { while (n == 0) wait(); catch (Exception e) { System.exit(2); res = buf[ut_p++]; --n; if (ut_p >= 10) ut_p = 0; notify(); return res; public static void main(string args[]) { Monitor m = new Monitor(); new Producer(1,2,25,m).start(); new Producer(101,1,40,m).start(); new Consumer(m).start(); Forelesning Ark 14 av 23

15 Hoveprogrammet Hovedprogrammet main oppretter en monitor. Så oppretter den to produsenter og én konsument som startes. Monitoren Monitoren har en privat ringbuffer til bufring av 10 tall. Den har to operatorer: enter venter først til det er plass i ringbufferen. Så setter den inn et element og kaller notify (i tilfelle en konsument venter). remove venter først til det er noen elementer i ringbufferen. Så henter den ett element derfra som skal returneres. Først kaller den imidlertid notify (i tilfelle noen produsenter venter). Siden ringbufferen er private og operatorene er synchronized, er parallellstyringen sikker. Kjøring Slik blir en kjøring: maskin navn> java Monitor Forelesning Ark 15 av 23

16 Vurdering + Monitorer er meget sikre. Kompilatoren vil ta seg av det meste av parallellitetskontrollen. + De er enkle å bruke. Det er lettere å unngå vranglås. + Det er trivielt å overføre data mellom prosessene (ved å benytte parametre til monitor-operatorene). + De gir anledning til strukturert programmering, siden monitorer er en form for abstrakte typer. Monitorer krever et eget språk; det er ikke nok å skrive noen rutiner. Svært få språk har monitorer. Konklusjon Monitorer er ypperlige, hvis de finnes. Forelesning Ark 16 av 23

17 Oppsummering av teknikker Teknikk Synk Data Spesielt UNIX filer UNIX rør Forutsetter samme urprosess Delt lager Lettvektsprosesser Semaforer Meldinger Monitorer Lite brukt Forelesning Ark 17 av 23

18 Programkode Som omtrent alt annet i en datamaskin er programkode representert med bit-mønstre. Anta at vi skriver funksjonen #include <regdef.h>.text.globl sumn # Navn: sumn. # Synopsis: Beregner summen n # med formelen n*(n+1)/2. # C-signatur: unsigned sumn(unsigned n). sumn: addi t0,a0,1 # (n+1) multu t0,a0 # n* mflo v0 # sra v0,v0,1 # /2; jr ra # return Denne funksjonen beregner summen av de n første tallene ved å benytte formelen n k=1 k = n(n + 1) 2 Forelesning Ark 18 av 23

19 Assemblering Programmet oversettes («assembleres») til maskinkode med cc: maskin navn> cc -c sumn.s Disassemblering Programmet dis går den motsatte veien: maskin navn> dis sumn.o **** DISASSEMBLER **** disassembly for sumn.o section.text 0x 0: addi t0,a0,1 0x 4: multu t0,a0 0x 8: mflo v0 0x c: sra v0,v0,1 0x 10: 03 e jr ra 0x 14: nop 0x 18: nop 0x 1c: nop Forelesning Ark 19 av 23

20 Bit-mønstre som kode Vi kan også legge inn bit-mønstrene i en vektor: #include <stdio.h> unsigned long code[] = { 0x , 0x , 0x , 0x , 0x03e00008, 0, 0, 0; int main(void) { unsigned (*f)(unsigned) = (unsigned(*)(unsigned))code; int i; for (i = 1; i <= 6; ++i) printf("f(%d) = %u\n", i, f(i)); return 0; Ved å «lure» C til å tro at adressen til vektoren code er adressen til funksjonen f, kan vi kalle f. maskin navn> cc sumn.c -o sumn && sumn f(1) = 1 f(2) = 3 f(3) = 6 f(4) = 10 f(5) = 15 f(6) = 21 Forelesning Ark 20 av 23

21 Selvmodifiserende kode Siden programkoden bare er bit-mønstre, kan vi da endre koden under kjøring? #include <stdio.h> /* Funksjon som returnerer 1, 2, 3,... */ unsigned long code[] = { 0x , /* addi v0,zero,1 */ 0x03e00008, /* jr ra */ 0, /* nop */ 0, /* nop */ 0 /* nop */ ; #define CACHE_SIZE void clear_cache(void) { int a[cache_size], i; for (i=cache_size/sizeof(int); i>=0; --i) ++a[i]; int main(void) { int (*f)(void) = (int(*)(void))code; int i; for (i = 1; i <= 6; ++i) { printf("f() = %d\n", f()); ++code[0]; clear_cache(); return 0; Forelesning Ark 21 av 23

22 På noen maskiner vil dette gå bra: maskin navn> cc newn.c -o newn && newn f(1) = 1 f(2) = 2 f(3) = 3 f(4) = 4 f(5) = 5 f(6) = 6 Det er to grunner til at dette ikke alltid går: Kode og data kan ligge i ulike deler av lageret, og kodelageret er ofte skrivebeskyttet. Kode- og datalageret har ofte separat cache, så endring i det ene vil da ikke merkes i det andre. (I eksemplet løses dette problemet av funksjonen clear cache.) Selvmodifiserende kode brukes nesten aldri. + Slik kode kan øke hastigheten siden man slipper noen tester. Det er nesten umulig å finne feil i slik kode. Forelesning Ark 22 av 23

23 Problem med gets Funksjonskallet char linje[80]; int a, b, c;. gets(linje); leser neste linje fra standard inn (som vanligvis er tastaturet) og legger den i linje. Hva hvis linjen er for lang? Da skriver den over a, b og c og andre variable. Hva hvis linjen er flere tusen tegn lang? Da kan den skrive over programkoden. Hvis brukeren kjenner programkoden, kan altså han eller hun endre den etter ønske! Dette har vært benyttet i flere innbrudd, blant annet Morris-ormen, som er beskrevet på notatet fra i fjor om sikkerhet og virus ( Forelesning Ark 23 av 23