1 / 51

Datalogi 1F Forår 2003 Multiprogrammering[4]

Datalogi 1F Forår 2003 Multiprogrammering[4]. Kerner og processer Jørgen Sværke Hansen cyller@diku.dk. 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. C/C++ eftermiddage.

nubia
Download Presentation

Datalogi 1F Forår 2003 Multiprogrammering[4]

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

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

  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: 15-17 • 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 readerProc writerProc KReadLine() KWriteLine() KInitSem() KReadChar() KWait() KWriteChar() KSignal() KReadQ KWriteQ KInitProc(…) KReadyQ KSleep() KCurProc KPause() KSelectNewProcess() KInterruptHandler() 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 <KReadChar> while(!(rdio(com1lsr) & 0x01)) <UART> sætter ready-bit <KInterruptHandler> while(!KWaitQ.isEmpty()) <KReadChar> KPause(KReadQ); <KSelectNewProcess> <sætter proces i ventekø> 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() { <gem afbrydelsesniveau i PKB>; <gem registre på stakken>; <gem stakpeger i PKB>; <find ny proces>; <gendan stakpeger fra PKB>; <gendan registre>; <gendan afbrydelsesniveau fra PKB>; } Datalogi 1F: Multiprogrammering[4]

  12. Andre routiner derskal 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 Datalogi 1F: Multiprogrammering[4]

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

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

  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 Datalogi 1F: Multiprogrammering[4]

  18. En anden uheldig rækkefølge <BP1> if(!sem) <antag sem == 1> <Afbrydelse> KPause(KReadyQ, KReadQ); . . . . . . <BP2> <if(!sem)> <sem stadig == 1> <BP2> sem--; <Afbrydelse> KPause(KReadyQ, KWriteQ); . . . . . . <BP1> sem--; UUUPS: der er 2 processer i kritisk region!!

  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 derhar 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 <BP1> < KSleep(KReadyQ, myWaitQ) > < KPutQ = KReadyQ, KGetQ = myWaitQ > <Afbrydelse> < KSleep(KReadyQ, KReadQ) > < KPutQ = KReadyQ, KGetQ = KReadQ > <BP4> . . . . . . < KSleep(KReadQ, KReadyQ) > < KPutQ = KReadQ, KGetQ = KReadyQ > <BP1> < KSelectNewProcess > < 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 skift til brugerniveau trap/ exception brugertilstand 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 kernestakeksempel BP1 sp AP:BP1_start() BP1_start(void) { calc(t3_root); } AP: calc() afbrydelse AP: calc() PAL registre: bruger sp: BP1 sp kerne sp: 0x200000 PAL registre: bruger sp: ikke def. kerne sp: 0x200000 kerne sp PAL stakramme $sp = kerne sp $sp = bruger sp kerne sp = $sp AP: ent_int AP: KInterruptH… 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 vedprocesskift 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) Datalogi 1F: Multiprogrammering[4]

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

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

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

  34. Indlejrede afbrydelser PAL stakramme P2 Registre P2 kerne sp Er flag for processkift sat og er vi den sidste afbrydelse? AP: ent_int AP: KInterruptH… BP2 sp AP: KPause PAL stakramme P2 AP:BP2_start() AP: KSelectNewP… Registre P2 Så kan vi skifte til en anden proces AP: calc() AP: ent_int afbrydelse AP: calc() afbrydelse AP: KInterruptH… 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 AP: KPause AP: KSelectNewP…

  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 Datalogi 1F: Multiprogrammering[4]

  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(); } }

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

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

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

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

  41. Server med flere processer Afkod Foresp. Læs data Konstruer header Generer svar Svar Afkod Foresp. Læs data Konstruer header Generer svar Fsp Afkod Foresp. Læs data Konstruer header Generer svar 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. Læs data Konstruer header Generer svar Svar Forsp 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 Læs data Konstruer header Send svar Læst fsp Data læst Fsp færdig Ny fsp Tilstandsmaskine Svar Fsp Datalogi 1F: Multiprogrammering[4]

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

  46. Flash / mmap Applikation Operativsystem Ydre enhed Virtuelt adresse rum File Fysisk lager Mmap’ed fil 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 Hjælper proces Server Proces bruger OS Fil 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, iProceedings of the USENIX 1999 Annual Technical Conference • http://www.cs.princeton.edu/~vivek/flash/ 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]

More Related