DS-kursusgang nr. 4 IPC generelt IPC eksempel: beskedkøer IPC tidsforbrug: kontekstskift, skedulering C: abstraktion, funktionsbiblioteker

IPC i server klient boss worke r manag er server

Hvorfor IPC ? Processer har behov for at udveksle information Eksempler på kommunikation: boss-proces sender input data til "worker"-proces 1 proces fortæller ander processer: "jeg er i kritisk region, hold jer væk" ● administrator-proces fortæller boss-proces at en bruger skal have flere rettigheder

Implementation af IPC Processer har ikke umiddelbart adgang til hinandens data. På grund af indkapsling i adresserum. Derfor må IPC gå via operativsystemets systemkald. CDK: invocation (invokation (?) af en indkapslet ressource) Tråde i samme proces deler data er ikke IPC kræver ikke systemkald / invokation af indkapslet ressource

Forskellige metoder til IPC Den mest udbredte metode: sockets ● er en grænseflade til TCP/IP ● internt mellem processer på samme maskine ● mellem processer på forskellige maskiner ● understøttes af mange operativsystemer og sprog ● bruges af middleware til implementation af rpc, RMI, http, o.m.a. Andre metoder/faciliteter til IPC Message passing Signaler Delt hukommelse mellem separate processer Semaforer Pipes Filer (eks.: låsefiler)

Ren tekstbaseret kommunikation.. manager boss "hello.... grant privileges.... stop service.... raise priority of service.... bye" ● Nødvendigt at konstruere parser Mange fejlmuligheder, - mange fejl først vil vise sig på køretidspunktet ?

Fordele ved distribuerede objekter og fjernprocedurekald Højniveau-programmering lade systemet (oversætter, RMI,..) håndtere detaljer jf. løkker i stedet for GOTO-sætninger, Java i stedet for C,.. Typecheck vil afsløre fejl allerede på oversættelsestidspunktet "metoden gant_privileges findes ikke.." Muliggør udarbejdelse af abstrakt design Overordnet design kan abstrahere fra fordeling af objekter på processer og maskiner CORBA: højere abstraktionsniveau end RMI: uafhængig af programmeringssprog

DS-kursusgang nr. 4 IPC generelt IPC eksempel: beskedkøer IPC tidsforbrug: kontekstskift, skedulering C: abstraktion, funktionsbiblioteker

Grundlæggende om Unix beskedkøer Afsender- proces hej Modtager- proces.. msgsnd(,"hej",..);.. msgrcv(..);.. Stammer fra AT&T / System V Tilgås via systemkald: msgsnd(), msgrcv(), msgget(), msgctl() Afsender bruger msgsnd() og skal bl.a. angive den besked der ønskes afsendt hvilken kø der ønskes sendt til

Selve beskedkøen kan opfattes som et separat adresserum Bruger-proces 1 Bruger-proces 2 Kerne Beskedkø

Beskedkøer: features … Persistent (eksisterer uafhængigt af processer) Tilgås af vilkårligt mange processer Rettighedsstyring Valgfrihed ml. synkron/asynkron kommunikation Prioritet Andre egenskaber: ● beskeder forbruges ● afsenderproces får ikke besked om modtagelse/forbrug ● modtagerproces kan ikke (automatisk) se afsenderproces

Prioritet og synkronisering 12 … Prioritet: ● prioritetsværdi (P>0) angives af afsender som del af besked ● prioritetsparameter angives af modtager: ● 0: modtag uden prioritet (FIFO) ● X (X>0): modtag første besked med prioritetsværdi P=X ● -Y (Y>0): modtag første besked med P <= Y ● (diverse andre muligheder) Synkronisering: ● på modtagerside hvis der ikke er passende besked: ● bloker (synkron modtagelse) ● returner med passende (fejl)meddelelse (asynkron modtagelse) ● på afsenderside: bloker eller returner hvis manglende plads

Format af besked … struct m_struct { long int priority; char a[X] } Første attribut (long int) skal have positiv værdi Anden attribut (a) skal være char array Den ved erklæringen angivne længde (X) af arrayet er ligegyldig ● Antallet af bytes der sendes/modtages angives eksplicit af begge parter ● Dette antal bytes overføres uanset arrayets længde priority a a[o] a[1]

Format af besked: eksempler // Simpel besked struct tekst_besked { long int prioritet; char txt[40]; } // Kompleks besked struct ordre { long int rute; // hvilken flyrute ? char ordre[1]; // 'b' = bestil, 'a' = afbestil int antal; // antal billetter char navn[40]; // personen der afgiver ordren } - Vigtigt at typen ordre bruges af begge parter - Fejl hvis modtager læser ordre som tekst_besked

msgget() og msgctl: Oprettelse og nedlæggelse beskedkø Beskedkøer skal ● oprettes (via reference til globalt navn) ● have et navn (reference) i den enkelte proces ● tilknyttes rettigheder ● knyttes til processer som ressourcer ● (bruges) ● nedlægges msgget(, ) msgid = msgget(117,IPC_CREAT | 0666); /* opretter kø hvis ikke eksisterer + sætter rettigheder = rw-rw-rw- */ msgctl(,IPC_RMID,NULL);

Afsendelse // Simpel besked struct tekst_besked { long int prioritet; char txt[40]; }.. struct tekst_besked min_besked = {1,"hej"};.. msgsnd(,(void *)&min_besked,40, ); hvorfor pointer ?

Modtagelse msgrcv(,, );

Lighedspunkter i systemkald: beskedkøer ~ filbehandling start fd = open(,..)msqid = msgget(,..) operationFilerBeskedkøer brug read(fd,&buf,size) write(fd,&buf,size) msqsnd(msgid,&mess,siz,..) msgrcv(msqid,&mess,siz,..) slut close(fd)msgctl() Adskillelse ml. globalt navn og lokal reference Rettighedskontrol Filer og beskedkøer arbejder med pointere til blokke af data Blokkene kopieres af operativsystemet under systemkaldenes udførelse

Sammenligning filer/beskedkøer Generelle egenskaber Kapacitet ? Persistens ? Tilgængelighed ?

Ekstra: Filbehandling Filbehandling i C ikke med i kursets litteratur (hverken kursorisk eller 'almindelig'). Se: ● Muldner kapitel 5 ● Muldner-opgaver 5-1, 5-5, 5-11, 7-11 og 11-6.

Højniveau-læsning fra (almindelig) fil #include main () { int c; FILE *filehandle; if ((filehandle = fopen("myfile.c","r")) == NULL) exit(EXIT_FAILURE); while ((c = fgetc(filehandle)) != EOF) putchar(c); fclose(filehandle); } ● fopen/fclose/fgetc m.fl. arbejder med filer via en pointer til en FILE struktur som bl.a. rummer en buffer ● bemærk funktions-orienteret tilgang, modsat " filehandle.fgetc() " ● ungetc() lægger 1 tegn tilbage i bufferen (opgave 5-11)

Lavniveau-læsning fra fil #include main () { int c, fd, count = 1; fd = open("myfile.c",O_RDONLY); if (fd < 0) exit(EXIT_FAILURE); while ((count = read(fd,&c,1)) > 0) write(1,&c,1); close(fd); } open/read/write/close arbejder med filer via en fildeskriptorer man skal selv oprette en buffer symbolsk talkonstant

DS-kursusgang nr. 4 IPC generelt IPC eksempel: beskedkøer IPC tidsforbrug: kontekstskift, skedulering C: abstraktion, funktionsbiblioteker

Omkostninger ved IPC Tid - der kan være tidsmæssigt overhead pga.: ● kontekstskift ● skedulering ● netværksforsinkelse (men ikke ved beskedkøer) Plads - her er begrænsningerne: ● kapacitet af netværk ● størrelse af arbejdslager

Opgave 2: måling af tidsforbrug ved beskedkommunikation (t/r) 1 byte: 0, sekund 650 MHz Intel Pentium

16 B Samme tid

X KB 0, sekund (bruger-mode) 0, sekund (kerne-mode) + 0, sekund per KB (kerne-mode) Svinger +/- 10% Samlet tid lidt større (andre processer)

Synkronisering af processerne i opgave 2 Klient Server msgget() msgsnd() msgrcv() msgsnd() msgrcv() msgsnd() msgrcv() msgsnd() msgrcv()... 1 iteration: ● klient sender besked ● server modtager besked og echoer den tilbage ● klient modtager besked

Tidsforbrug ved message passing proces 1 msgget() tråde i bruger tilstandtråde i kerne tilstand trap til kernen for at privilegeret kode kan udføre msgget() skedulator vælger ny proces proces 2 msgget() Scenarie 1: oprettelse og tilkobling til kø

Tidsforbrug ved message passing proces 1 msgrcv(.., ) ● trap til kernen ● proces 1 blokeres (ingen passende besked) ● skedulator vælger ny proces proces 2 msgsnd() Scenarie 2: synkron læsning ● skedulator vælger proces 1 (af-blokerede processer prioriteres) ● proces 1 kopierer i kerne-mode proces 1

Tidsforbrug ved message passing: konklusion Tidsmæssigt overhead: ● kontekstskift ved alle basale operationer ● synkron kommunikation kan medføre ekstra invokation af skedulator Pladsmæssigt overhead: ● beskeder ligger og fylder op indtil de bliver læst/forbrugt

Skedulerings-politik Målsætning: Effektivitet (cpu-udnyttelse) CPU-en aktiv hele tiden processer der venter på i/o skal give plads til andre høj prioritet til processer der skifter tilstand fra blokeret til klar Målsætning: Lav svartid (interaktive brugere) lille kvantum retfærdighed ift. samlet forbrug ! Målsætning: Effektivitet (II) (færdiggørelse af processer) stort kvantum De to primære virkemidler er: ● størrelse af det tidskvantum, den enkelte proces skeduleres ad gangen ● prioritetsregler

Simpel skeduleringsmulighed: Round-Robin indenfor 1 kø kørendeklar Lav-niveau skedulator bruger simpel kø (FIFO) af processer der er klar lsftpcc ftpccls ftpccls

Fordel ved stort tidskvantum P1 (1 kvantum)P2 (1 kvantum) Proces- skift Proces- skift... Minimering af spildtid - tid til processkift er lille i forhold til tidskvantum

Fordel ved lille tidskvantum P1P2 Proces- skift Proces- skift... P117 Hvornår bliver det min tur ? Et lille tidskvantum er vigtigt for lavere svartid til interaktive processer forudsat: det pgld. input kan behandles inden for 1 tidskvantum der er mange processer processer, der har været i/o-blokerede, ikke prioriteres systematisk

Dynamisk prioritet: placering af ikke-blokerede processer i prioritetsklasser ftp ls cc Httpd ikke med da den er i klasse for sig pga. høj statisk prioritet Prioritet 4 Prioritet 3 Prioritet 1 Har ventet på disk input Har ventet på terminal input Har brugt megen cpu-tid Prioritet 2

Skedulering - opsummering Enkelte særligt vigtige processer kan give forrang med statisk prioritet f.eks. webserverproces Alle andre processer har principielt lige adgang til cpu-en Størrelsen af tidskvantum vælges som kompromis Dynamisk prioritet bruges til finjustering undgå nedprioritering af processer der blokeres ofte sikre en (begrænset) nedprioritering af processer der har kørt længe

DS-kursusgang nr. 4 IPC generelt IPC eksempel: beskedkøer IPC tidsforbrug: kontekstskift, skedulering C: abstraktion, funktionsbiblioteker

Abstraktion i C Eksempel: Vi ønsker at skjule detaljerne vedr. beskedkøer (parametrene til systemkaldene) I det enkelte beskedkø-program bruger vi altid de samme flag m.m. ● Beskeder har altid prioritet = 1 ● Modtager læser altid u-prioriteret ● Rettigheder er altid rw-rw-rw- ● etc. C er et imperativt sprog uden klasser. ● den væsentligste mekanisme til abstraktion er funktioner: ● send() kan kalde msgsnd() med faste parametre ● definition og erklæring af send() i separate filer

Struktur af C-programmer #include void klient(..); int main(..) {..} void klient(..) {..} En C-kildetekstfil ("oversættelsesenhed") indeholder: direktiver (#include, #define) til præprocessoren erklæringer bl.a. af funktioner og globale variable definitioner af funktioner (jf. metoder i Java) Et oversat C-program (flere filer) skal indeholde: 1 main-funktion

Definition af funktioner void klient(..,..); int main(int argc,char *argv[]) {..} void klient(..,..) {..} void betyder at funktionen ikke har returværdi. argc er antallet af parametre (inkl. programnavnet selv) argc parameteroverføres da arrayet selv ikke har informationen char *argv[] er en erklæring af argv som : et array af tegn-pointere = et array af strenge

Erklæring af funktioner I programteksten bør en funktion erklæres før den kaldes, enten ved dens definition eller ved en prototype (helst). (definitionen kan include's fra en headerfil) Prototypen skal angive samme signatur, dvs. typer af parametre og eventuel returværdi, mens navne på parametre er ligegyldige (og kan udelades). Prototyper anbringes meget ofte i såkaldte header-filer (.h). void klient(..,int); int main(..,..) {.. klient(.., );.. } void klient(..,int iterationer) {.. }

Erklæring + definition af funktioner i separate filer /* beskeder.h */ struct besked { long int prioritet; char a[2048] } int send(besked * bsk,int antal_byte); /* beskeder.c */ int send(besked * bsk,int antal_byte) { msgsnd(..); }

OO-lignende programstruktur /* beskeder.h */ struct besked { long int prioritet; char a[2048] } #define MIN_PRIORITET 1 #define MIT_MSGGET_FLAG 0666|IPC_CREAT int init_besked(besked *bsk); int send(besked * bsk,int antal_byte); Datastruktur X og alle tilhørende funktioner og macroer m.m.: ● x.h: erklæring af funktioner, definition af macroer ● x.c: definition af funktioner ● Svarer til gruppering af klasse X's metoder og attributter

Erklæring + definition af funktioner: er der noget galt ? int f1(); int main(..,..) { int a = f1(); }

Erklæring + definition af funktioner: svar int f1(); int main(..,..) { int a = f1(); } Fejl: der mangler en definition af f1(). Hvem detekterer fejlen ? gcc -c f.c # ikke en fejl ifølge oversætter # -c betyder 'kun oversætter' gcc -o f f.o # men en fejl ifølge linker, # som terminerer med fejlværdi # -o betyder 'outputfil' gcc -o f f.c # oversættelse + linkning i 1 kald #.c indikerer C kildetekst

Erklæring + definition af funktioner: er der noget galt ? int f2(int); int f2(int, int); int main(..,..) { int a = f2(0); int b = f2(0,0); } int f2(..) {..;} int f2(..,..) {..;}

Erklæring + definition af funktioner: svar int f2(int); int f2(int, int); int main(..,..) { int a = f2(0); int b = f2(0,0); } int f2(..) {..;} int f2(..,..) {..;} Fejl: et funktionsnavn kan ikke overloades.

Erklæring + definition af funktioner: er der noget galt ? int f3(); int f4(); int main(..,..) { int a = f3(0); int b = f4(); } int f3() {..;} int f4(int c) {..;}

Erklæring + definition af funktioner: svar int f3(); int f4(); int main(..,..) { int a = f3(0); int b = f4(); } int f3() {..;} int f4(int c) {..;} Ingen fejl. Erklæringen af f3/f4 betyder at antallet af parametre ikke er fastlagt ● overskydende aktuelle parametre bruges ikke ● overskydende formelle parametre instantieres ikke ● for at fastlægge tom parameterliste kræves i stedet brug af f(void)

Erklæring + definition af funktioner: er der noget galt ? int main(..,..) { f5(); } void f5() {..;}

Erklæring + definition af funktioner: svar int main(..,..) { f5(); } void f5() {..;} ● OK at der ikke er eksplicit erklæring (men kun implicit erklæring via kaldet). ● Men advarsel for at implicit erklæring ikke matcher definition: Den implicitte erklæring fortolkes som en erklæring af en integer-funktion (default).

Erklæring + definition af funktioner: er der noget galt ? void f6(void); int main(..,..) { f6(); } void f6(void) {return 0;}

Erklæring + definition af funktioner: svar void f6(void); int main(..,..) { f6(); } void f6(void) {return 0;} Oversætter advarer om at der returneres en værdi på trods af void-type.

Genbrug af klasser/funktioner Java: Klasser samles i pakker, og evt. jar-filer Genbrugs-program oversættes Bruger-program (inkl. importsætning) oversættes g.javag.class b.javab.class

Oversættelse i C = egentlig oversættelse + linkning myprogr.cmyprogr.omyprogr cc -c myprogr.ccc -o myprogr myprogr.o.o-filer: objektfiler = maskinkode men ikke linket, dvs. har ikke adresser på definitioner af eksterne funktioner, hvilket muliggør inkremental oversættelse Flag: flaget -c betyder: spring link-fasen over flaget -o betyder: placer output i den angivne fil (første parameter) hvorvidt cc -o er oversættelse eller oversættelse+linkning afgør oversætteren ud fra endelsen af inputfil cc -o myprogr myprogr.c

Oversættelse Hvad er input og output til C-oversætteren/linkeren ? cc -o hello hello.o world.o Hvad er forskellen i forhold til cc -o hello world.o hello.o

Genbrug af C-funktion uden bibliotek getline.c myprogr.c getline.o myprogr.omyprogr cc -c getline.c cc -c myprogr.ccc -o myprogr myprogr.o getline.o Ved at liste getline.o som parameter til linkningen kommer definitionerne i getline.o med i myprogr (statisk linkning) ● objektfiler linkes 1 ad gangen, hvorunder udefinerede symboler (funktioner) akkumuleres og resolveres i tekstlig rækkefølge

Genbrug af C-funktioner v.hj.a. biblioteker f2.c p.c f2.o p.op ar crv lib.a f1.o f2.o Ved at liste lib.a som parameter til linkningen kommer de relevante definitionerne i lib.a med i p (stadig statisk linkning) f1.cf2.olib.a cc -o p p.o lib.a