Datalogi 1F Forår 2003 Multiprogrammering[4] Kerner og processer Jørgen Sværke Hansen

Datalogi 1F: Multiprogrammering[4] 2 Planen for i dag C/C++ eftermiddage? Repetition af kerner med afbrydelser Kerner med tvungent processkift Eksempel på anvendelse af processer/tråde i en web-server

Datalogi 1F: Multiprogrammering[4] 3 C/C++ eftermiddage Et kursus i C++ programmering med fokus på programmering af kerner To ”teoretiske” øvelsesgange –en gang er sat til 11/3: –anden/første gang sidst i uge 10 eller i uge 11

Datalogi 1F: Multiprogrammering[4] 4 Kerner med afbrydelser Vi erstatter aktiv venten med: –ventende processer placeres i ventekøer –afbrydelser aktiverer ventede processer ved at flytte dem til klarkøen Bedre udnyttelse af CPU Introduktion af parallelisme i kernen: –afbrydelsesroutiner kan udføres når som helst (undtagen når vi lukker for afbrydelser) –fokus på kritiske regioner

Datalogi 1F: Multiprogrammering[4] 5 Kerne med afbrydelser KInitProc(…)KReadyQ KSleep() KCurProc KPause() KSelectNewProcess() KInterruptHandler() KInitSem() KReadChar() KWait() KWriteChar() KSignal() KReadLine() KWriteLine() readerProc writerProc KReadQ KWriteQ

Datalogi 1F: Multiprogrammering[4] 6 Tætkoblede drivprogrammer Hver slags hændelse (tegn skrevet, tegn læst, …) er tilknyttet en ventekø: char KReadChar() { while(!(rdio(com1lsr) & 0x01)) KPause(KReadQ); return rdio(com1Rbr); }

Datalogi 1F: Multiprogrammering[4] 7 Synkronisering med ydre enheder void KInterruptHandler() { if( rdio(com1Iir) & 2) while(!KReadQ.isEmpty()) KReadyQ.Put(KReadQ.Get()); else if( rdio(com1Iir) & 4) while(!KWriteQ.isEmpty()) KReadyQ.Put(KWriteQ.Get()); }

Datalogi 1F: Multiprogrammering[4] 8 Uheldig rækkefølge while(!(rdio(com1lsr) & 0x01)) sætter ready-bit while(!KWaitQ.isEmpty()) KPause(KReadQ); AAAAARGH: vi opdager ikke at tegnet er læst

Datalogi 1F: Multiprogrammering[4] 9 Problem Vi har to parallelle processer: –brugerproces –afbrydelsesroutine der deler data: –kontrolregistre –proceskøer Vi må sikre udelelig udførsel af kritiske regioner

Datalogi 1F: Multiprogrammering[4] 10 Implementering af udelelighed Luk for afbrydelser: char KReadChar() { forbid(); while(!(rdio(com1lsr) & 0x01)) KPause(KReadQ); char ch = rdio(com1Rbr); permit(); return ch; } Nu bliver vi ikke afbrudt mellem check af statusregister og KWaitQ.Put() Men hvor bliver er åbnet for afbrydelser?

Datalogi 1F: Multiprogrammering[4] 11 Ny KPause KPause skal skifte afbrydelsesniveau (ipl er en del af processens tilstand): void KPause() { ; }

Datalogi 1F: Multiprogrammering[4] 12 Andre routiner der skal beskyttes? Afbrydelsesroutiner og alm. kernefunktioner deler køstrukturer Beskyt køoperationerne: int isEmpty() { int oldipl = forbid(); int b = (size == 0); permit(oldipl); return b; };

Datalogi 1F: Multiprogrammering[4] 13 Kerner med tvungent processkift Indtil nu har vi kun set på kerner med frivilligt processkift via KPause() En afbrydelsesroutine sætter processen i klarkøen, men der kan gå lang tid inden den aktive proces opgiver CPU’en Vi vil tvinge et processkift som en del af afbrydelsen: –dette sikrer hurtigere behandling af afbrydelser

Datalogi 1F: Multiprogrammering[4] 14 Ny afbrydelsesprocedure void KInterruptHandler() { if(rdio(com1Iir) & 2) KSleep (KReadyQ, KReadQ); else if(rdio(com1Iir) & 4) KSleep (KReadyQ, KWriteQ); …… } Fejl i kursusbog bind 4 side 74

15 KSleep og venner Queue * KPutQ, KGetQ; void KSleep(Queue & put, Queue & get) { KPutQ = &put, KGetQ = &get; KPause(); } Registers* KSelectNewProcess (Registers* sp) { KCurProc->sp = sp; KPutQ->Put(KCurProc); KCurProc = KGetQ->Get(); return KCurProc->sp; }

16 Tvungent processkift - eksempel AP: printl() AP: KWriteChar AP:BP1_start() AP: KPause BP1 sp AP: Wait(sem) AP:BP2_start() BP2 sp AP: ent_int AP: KInterruptH… PAL stakramme P2 AP: KPause Registre P2 AP: KSelectNewP… AP: KSleep AP: KWriteLine AP: KSelectNewP… afbrydelse Skift: stakpeger afbrydelsesniveau Processkift sker EFTER behandling af og kvittering for afbrydelse a2 a1 a0 gp pc ps

Datalogi 1F: Multiprogrammering[4] 17 Semaforroutiner Nu kan vores semaforroutiner også blive afbrudt: void KWait (KSem *sem) { if (!sem) KSleep(sem->WaitQ, KReadyQ); sem--; } Førhen var dette sikkert fordi afbrydelser ikke rørte ved semaforerne Men nu kan en vilkårlig proces blive afbrudt

En anden uheldig rækkefølge if(!sem) KPause(KReadyQ, KReadQ);... sem--; KPause(KReadyQ, KWriteQ);... sem--; UUUPS: der er 2 processer i kritisk region!!

Datalogi 1F: Multiprogrammering[4] 19 Nye semaforroutiner Nu kan vores semaforroutiner ikke mere blive afbrudt: void KWait (KSem *sem) { forbid(); if (!sem) KSleep(sem->WaitQ, KReadyQ); sem--; permit(); }

Datalogi 1F: Multiprogrammering[4] 20 Andre routiner der har problemer? Måske KSleep generelt? Kan vi klare at skifte proces mens vi skifter proces? Registers* KSelectNewProcess (Registers* sp) { KCurProc->sp = sp; KPutQ->Put(KCurProc); KCurProc = KGetQ->Get(); return KCurProc->sp; } De to globale variable KPutQ og KGetQ ser suspekte ud

Datalogi 1F: Multiprogrammering[4] 21 Endnu en uheldig rækkefølge... < Sætter sig selv på KReadQ men aktiverer proces fra KReadyQ >

Datalogi 1F: Multiprogrammering[4] 22 Morale Man skal være forsigtig!!!! Identificer alle variable der deles mellem afbrydelsesroutiner og alm. kerneroutiner Foretag sikring af kritiske regioner Ved aflusning af kerner (f.eks. K1) kan det være en god ide at starte med helt at lukke for afbrydelser i kernen og så langsom bløde det op

Datalogi 1F: Multiprogrammering[4] 23 Kerner med periodisk processkift Hidtil har vi udskiftet den kørende proces ved afbrydelse fra I/O enhed: –Har vi kun en CPU tung proces, er det fint nok, da den vil blive afbrudt –Men hvis vi har flere, kan der stadig gå lang tid inden en ventende proces ”kommer til fadet” KPause() kaldes typisk som led i et systemkald: –ved hvert systemkald kunne man undersøge om en proces har kørt for længe, og derefter kalde KPause Hvad med beregningstunge processer, der sjældent bruger systemkald? –Kræv at de skal indsætte frivillige processkift –Tving dem væk fra CPU’en

Datalogi 1F: Multiprogrammering[4] 24 Implementering af periodisk processkift void KInterruptHandler (ulong a0) { if ( a0 & 0x01) KSleep(KReadyQ, KReadyQ); else } Hver gang uret afbryder puttes den aktive proces bagerst i klarkøen (round robin) Men hvad hvis der ingen aktiv proces er?

Datalogi 1F: Multiprogrammering[4] 25 Tomgangsprocessen For at sikre, at der altid er en proces i klarkøen, har vi en tomgangsproces: void KIdleProcess { for(;;;) KSleep(KReadyQ,KReadyQ); } men man kunne nu stadig bruge en venteløkke i selve KSelectNewProcess

Datalogi 1F: Multiprogrammering[4] 26 Brug af to sikkerhedsniveauer Hardware indeholder en eller flere bits, der viser sikkerhedsniveau, f.eks. (0) brugertilstand og (1) kernetilstand Ved afbrydelser skiftes til kernetilstand, f.eks. ved en trap operation Specielle privilegerede instruktioner kan kun udføres i kernetilstand, typisk instruktioner der har med ressourcedeling at gøre kernetilstand brugertilstand trap/ exception skift til brugerniveau

Datalogi 1F: Multiprogrammering[4] 27 2 slags stakke Når brugerprogrammer udføres i brugertilstand benytter de en brugerstakpeger Systemkald samt afbrydelser udføres i kernetilstanden og benytter en kernestakpeger Kernestakpegeren peger på et andet lagerområde end brugerstakpegeren Kerne sp vil typisk være beskyttet mod skrivning og læsning fra brugertilstand Skiftet mellem stakpegerne foretages på Alphaerne af PAL koden ved skift mellem bruger og kernetilstand

Datalogi 1F: Multiprogrammering[4] 28 Brugerstak og kernestak eksempel AP: calc() AP: ent_int AP: calc() AP: KInterruptH… AP:BP1_start() PAL stakramme BP1 sp kerne sp PAL registre: bruger sp: BP1 sp kerne sp: 0x BP1_start(void) { calc(t3_root); } PAL registre: bruger sp: ikke def. kerne sp: 0x afbrydelse $sp = kerne spkerne sp = $sp$sp = bruger sp

Datalogi 1F: Multiprogrammering[4] 29 Processkift i afbrydelsesproceduren Hvis vi ønsker at skifte proces i en afbrydelsesprocedure skal vi dels: –gemme kørende proces’ tilstand –ændre brugerstakpeger i PAL register –gendanne nye proces’ tilstand Ændring af bruger sp er nemt: –PAL_rdusp læser bruger stakpeger fra PAL register –PAL_wrusp skriver en ny bruger stakpeger til PAL register Men processernes tilstande omfatter: –PAL stakramme –Registre gemt af ent_int (afbrydelsesniveau)

Datalogi 1F: Multiprogrammering[4] 30 Skift mellem stakke ved processkift under afbrydelse Vi ser på fire eksempler Skift mellem processer i brugertilstand: –én kernestak –en kernestak pr proces Processkift med en proces i systemtilstand og en i brugertilstand Processkift ved indlejrede afbrydelser, f.eks.: –først afbrydelse fra UART (ipl 3) –KInterruptHandler afbrydes af uret (ipl 5)

31 PAL registre: bruger sp: XXXXX kerne sp: 0x processer i brugertilstand: én kernestak AP: calc() AP: ent_int AP: calc() AP: KInterruptH… AP:BP1_start() PAL stakramme P2 AP: KSelectNewP… BP1 sp kerne sp AP: calc() AP:BP2_start() BP2 sp PAL registre: bruger sp: BP2 sp kerne sp: 0x PAL registre: bruger sp: BP1 sp kerne sp: 0x afbrydelse Registre P2 PAL stakramme P1 Registre P1 Gem kopi af BP2s kernestak (f.eks. på brugerstakken) Gendan kopi af BP1s kernestak

32 2 processer i brugertilstand: en kernestak per proces AP: calc() AP: ent_int AP: calc() AP: KInterruptH… AP:BP1_start() AP: KSelectNewP… BP1 sp kerne sp AP: calc() AP:BP2_start() BP2 sp afbrydelse PAL stakramme P1 Registre P1 AP: ent_int AP: KInterruptH… PAL stakramme P2 AP: KSelectNewP… kerne sp Registre P2 PAL registre: bruger sp: BP2 sp kerne sp: 0x PAL registre: bruger sp: BP1 sp kerne sp: 0x PAL registre: bruger sp: XXXXX kerne sp: 0x PAL registre: bruger sp: BP1 sp kerne sp: 0x200000

33 2 processer: en i brugertilstand og en i kernetilstand AP: ent_sys AP: printl() AP: KWriteChar AP:BP1_start() AP: KPause BP1 sp kerne sp AP: calc() AP:BP2_start() BP2 sp afbrydelse PAL stakramme P1 Registre P1 AP: ent_int AP: KInterruptH… PAL stakramme P2 AP: KSelectNewP… kerne sp Registre P2 AP: KSelectNewP… AP: KPause Skift: brugerstakpeger aktiv stakpeger afbrydelsesniveau

34 Indlejrede afbrydelser AP: ent_int AP: KInterruptH… PAL stakramme P2 kerne sp Registre P2 AP: ent_int AP: KInterruptH… PAL stakramme P2 Registre P2 AP: KSelectNewP… AP: KPause AP: calc() AP:BP2_start() BP2 sp afbrydelse Er flag for processkift sat og er vi den sidste afbrydelse? AP: KSelectNewP… AP: KPause Så kan vi skifte til en anden proces afbrydelse Vi sætter et flag, der fortæller at vi skal foretage et processkift Duer ikke – vi var allerede i gang med at behandle et interrupt

Datalogi 1F: Multiprogrammering[4] 35 Indlejrede afbrydelser Hvordan ved man at man er det ”eneste” interrupt? På stakken ligger et statusregister, der fortæller hvad afbrydelsesniveau var inden den aktuelle afbrydelse: –ipl == 0 => ingen forudgående afbrydelser

36 Linux tomgangsproces void cpu_idle (void) { init_idle(); current->nice = 20; current->counter = -100; while (1) { void (*idle)(void) = pm_idle; if (!idle) idle = default_idle; while (!current->need_resched) idle(); schedule(); check_pgt_cache(); }

Datalogi 1F: Multiprogrammering[4] 37 Multiprogrammeringseksempel: web server klient server

Datalogi 1F: Multiprogrammering[4] 38 Klient-server kommunikation Skab forespørgsel Afkod forespørgsel Behandl forespørgsel Beregn svar forespørgsel svar Behandl svar Klient Server

Datalogi 1F: Multiprogrammering[4] 39 Netværksserver: struktur Protokol stak Server applikation Protokol stak Foresp.svar Demultipleksning af Indkommende forespørgsler (opret forbindelse) Afkod forespørgsel, Behandl forespørgsel, Beregn svar Netværksserver

Datalogi 1F: Multiprogrammering[4] 40 Enkelttrådet server Nemt at programmere En forespørgsel ad gangen Ingen parallelisme Afkod Foresp. Generer svar Konstruer header læs data Fspsvar Behandel forespørgsel

Datalogi 1F: Multiprogrammering[4] 41 Server med flere processer Fsp Svar Afkod Foresp. Generer svar Konstruer header Læs data Afkod Foresp. Generer svar Konstruer header Læs data Afkod Foresp. Læs data Generer svar Konstruer header

Datalogi 1F: Multiprogrammering[4] 42 Server med flere processer En proces per forespørgsel resulterer i: Høj grad af parallelisme Spildtid på grund af procesoprettelse/nedlæggelse (brug pulje af processer) Spildtid pga. processkedulering Det er vanskeligt at dele ressourcer (data) Synkronisering er nødvendigt

Datalogi 1F: Multiprogrammering[4] 43 Flertrådet server En server proces En tråd per forespørgsel God parallelisme Lav omkostning ved brugertråde Delt hukommelse Synkronisering er stadig nødvendig Afkod foresp. Generer svar Konstruer header Læs data Forsp Svar

Datalogi 1F: Multiprogrammering[4] 44 Hændelsesstyret server En proces/tråd Eksplicit tilstand per forespørgsel (status, forbindelse, etc.) God parallelisme Server bestemmer prioritering af forespørgsler Undgå blokerende systemkald (asynchronous) Afkod foresp Send svar Konstruer header Læs data Fsp Svar Tilstandsmaskine Ny fsp Fsp færdigData læstLæst fsp

45 Eksempel: Flash webserveren Asymmetrisk flerproces hændelsesstyret –Brug hjælperprocesser/tråde ved blokerende operationer –Har brug for interproceskommunikation (IPC) Hjælper proces Hjælper proces Hjælper proces Hjælper proces Læs fsp CGI Afkod foresp Generer svar Konstruer header Læs fildata Fsp Svar Tilstandsmaskine Ny fsp Fsp færdigData læst Data i cache Læs fsp

Datalogi 1F: Multiprogrammering[4] 46 Flash / mmap Applikation Virtuelt adresse rum Mmap’ed fil Fysisk lager OperativsystemYdre enhed File Dobbelt buffering/caching undgås

Datalogi 1F: Multiprogrammering[4] 47 Flash File I/O Cache bestående af mmap’ede filer Hjælper proces tilgår al data og giver besked til server proces Server proces kan derved tilgå data uden at blokere Server prøver at kontrollere hukommelsesforbrug Fil Hjælper proces Server Proces bruger OS

Datalogi 1F: Multiprogrammering[4] 48 Flash resultater Afprøvning: –kunstig genereret arbejdsbelastning –forespørgselsmønstre opsamlet fra ”den virkelige verden” Resultater: –30% - 50% procent højere ydelse end kommercielle web servere (men kan til dels skyldes mindre funktionalitet).

Datalogi 1F: Multiprogrammering[4] 49 Mere om Flash Flash: An Efficient and Portable Web Server: Vivek S. Pai, Peter Druschel, Willy Zwaenepoel, i Proceedings of the USENIX 1999 Annual Technical Conference

Datalogi 1F: Multiprogrammering[4] 50 Opsummering Kerner med afbrydelser: –introduktion af parallelisme i kernen –implementation af udelelighed ved styring af afbrydelsesniveau Tvungent processkift: –øget parallelisme i kernen (alle processer kan afbrydes) –periodisk processkift –indlejrede afbrydelser Multiprogrammeringseksempel: –Flash web serveren: multiproces, hændelsesstyret tilstandsmaskine

Datalogi 1F: Multiprogrammering[4] 51 Kilder Disse slides er baseret på indholdet i Datalogi 1F kursusbog bind 4, kapitlerne 7 & 8.