Semantiek & Correctheid Thread synchronisatie & communicatie

Transcriptie

1 emantiek & Correctheid Thread ynchroniatie & communicatie Naam: Chritian Gilien ( ) Maurice amulki (034239) Datum: 30 juni 2004 Verie: 2.5

2 Inhoudopgave Inhoudopgave...2 Inleiding...3 Thread ynchroniatie en communicatie...4 Algemeen... 4 Meage Queue... 4 Mailboxe... 5 ignal... 5 yntax & O emantiek van While...6 Meage Queue in While...8 ignal in While...0 Race Condition & Deadlock...2 Race Condition... 2 Deadlock... 2 Meage Queue veru ignal...5 While veru ignal...20 While veru Meage Queue...24 Gödel codering Gödel codering : een element toevoegen Gödel codering : een element uitlezen Concluie...28 Referentie...29 emantiek & Correctheid: Thread ynchroniatie & communicatie 2/29

3 Inleiding Dit verlag i gechreven naar aanleiding van de opdracht emantiek in het wild voor het vak emantiek en Correctheid. Het onderwerp van dit verlag i ynchroniatie en communicatie van thread en bechouwt enkele bekende contructie voor het ynchronieren en communiceren van thread in combinatie met de taal While. We vragen on af wat er voor nodig i om de taal While uit te breiden met zogenaamde meage queue en ignal. We vergelijken meage queue met ignal en vragen on af of ignal meerwaarde hebben ten opzichtte van meage queue. We bekijken de mogelijkheid om in While gebruik te maken van meage queue zonder dat we de emantiek van While uitbreiden. We gebruiken een verie van While waarin thread worden geïmplementeerd met behulp van het par tatement. We negeren zoveel mogelijk alle potentiële problemen van thread die voor on niet van belang zijn. (ignal worden vaak gebruikt om deze te voorkomen). Omdat het par tatement alleen in O kan worden uitgedrukt wordt er in dit verlag dan ook alleen gewerkt met O emantiek. Voor het lezen van dit verlag i er enige voorkenni van thread vereit. emantiek & Correctheid: Thread ynchroniatie & communicatie 3/29

4 Thread ynchroniatie en communicatie Algemeen Thread zijn delen van programma die onafhankelijk en parallel aan andere tukken programma kunnen lopen. Een bekend probleem bij thread i de communicatie en ynchroniatie ervan. Het i immer erg handig om meerdere thread aan een gezamenlijke taak te laten werken. Hierbij i het belangrijk dat thread elkaar niet in de weg lopen door bijvoorbeeld gedeelde data op verkeerde momenten te manipuleren. In principe zijn er twee dingen die we graag willen hebben:. we willen thread afhankelijk van elkaar taken laten uitvoeren (in een bepaalde volgorde). 2. we willen dat thread (op veilige wijze) data met elkaar kunnen delen. Om boventaande zaken te verwezenlijken zijn er in veel talen bepaalde contructie ontwikkeld. We zullen van deze contructie in dit verlag niet aantonen dat zij inderdaad deze zaken verwezenlijken. Meage Queue Meage queue worden gebruikt om verchillende thread te ynchronieren en met elkaar te laten communiceren. Een meage queue i een lijt waar een thread een waarde in kan zetten. Een andere thread (of dezelfde, maar dat i niet zo nuttig) kan deze waarde er weer uit halen. De waarde die er al eerte in werd gezet wordt er ook weer al eerte uit gehaald; het zogenaamde FIFO (Firt-In-Firt-Out) principe. Wanneer een thread du gegeven van een andere thread nodig heeft zal hij in de meage queue kijken of de gegeven al bechikbaar zijn. Al de gegeven niet bechikbaar zijn dan zal de thread wachten. Grafich kan men een meage queue al volgt weergeven: thread ending thread meage queue F I F O thread receiving thread emantiek & Correctheid: Thread ynchroniatie & communicatie 4/29

5 Mailboxe Een mailbox i eigenlijk een eenvoudige meage queue waarbij er lecht ruimte i voor bericht. De meage queue bevat du precie element. thread ending thread mailbox thread receiving thread ignal Een mechanime dat veel lijkt op meage queue i ignal. De term ignal wordt in de literatuur voor velerlei verchillende zaken gebruikt. Wij vertaan onder ignal het volgende mechanime: Een thread kan een ignal verturen naar een andere thread. De andere thread kan wachten op een bepaald ignal. thread thread ending thread ignal receiving thread De bechreven contructie komen het bete tot hun recht wanneer er lokale en globale variabele omgevingen zijn. Iedere thread heeft zijn eigen lokale variabele omgeving en er i een globale variabele omgeving waar alle thread aan kunnen. emantiek & Correctheid: Thread ynchroniatie & communicatie 5/29

6 yntax & O emantiek van While De yntax van de taal While ziet er al volgt uit: :: = x : = a kip ; 2 if b then ele 2 while b do De O emantiek van de taal While ziet er al volgt uit: [ a o] x : = a, [ x A[ a ] ] [ kip o] kip, [ comp o] ;, 2, ', ' ' ; 2, ' 2 [ comp o] ;, ' 2, 2, ' tt [ if o] if b then ele 2,, if B[ b ] = tt ff [ if o] if b then ele 2, 2, if B[ b ] = ff [ while o] while b do, if b then ( ; while b do ) ele kip, emantiek & Correctheid: Thread ynchroniatie & communicatie 6/29

7 Voor het gebruik van thread in While i er het par tatement. [ par o], par 2, ', ' ' par 2, ' [ par o] 2, ' par 2, 2, ' [ par o] 3 par 2, 2, 2', ' par 2', ' [ par o] 4 2, ' par 2,, ' emantiek & Correctheid: Thread ynchroniatie & communicatie 7/29

8 Meage Queue in While Om een meage queue te bechrijven moeten we eert een datatructuur bechrijven waarin we meerdere waarden kunnen oplaan. Deze datatructuur moet werken volgen het FIFO principe. We noemen dit datatype een queue. We breiden de yntax van While uit met een queue declaratie: ::=... queue q Q Met Q :: = ε Q : a Een queue zien we al een queue, gevolgd door een numerieke waarde, of al leeg. Volgen boventaande yntax kun je een queue declareren door: queue q ::2:3 De emantiek van een queue declaratie ziet er al volgt uit: queue q Q, [ q Q] Queue variabelen worden gedeeld tuen thread. De verzamelingen van lokale variabelen voor thread zijn dijunct. We zullen deze declaratie in alle voorbeelden weglaten en aannemen dat de gebruikte queue al i toegevoegd aan de tate. Queue hoeven nooit verwijderd te worden; we nemen aan dat ze bij beëindiging van het programma automatich worden verwijderd. Om een element toe te voegen aan een queue introduceren we het volgende tatement: [ puh o] puh a q, [ q q : Α[ a ] ] Puh heeft 2 parameter: de numerieke waarde die op de queue geplaatt moet worden en de naam van de queue waarop de waarde geplaatt moet worden. De waarde wordt achteraan op de queue geplaatt waardoor het geheel werkt al een FIFO. In de praktijk zou zo n tatement al volgt gebruikt kunnen worden: puh 5 q emantiek & Correctheid: Thread ynchroniatie & communicatie 8/29

9 Om elementen van de queue af te halen introduceren we de pop functie. We gebruiken hier (a:q) al notatie voor een queue waarvan het eerte element (de head) a i en de ret (de tail) q i. [ pop o] pop q x, [ ( a : q) q][ x a] not_empty Pop heeft 2 argumenten. Het eerte argument i de naam van de queue waar we een element af willen halen. Het 2 e argument i een variabele waaraan de waarde die we van de queue halen aan zal worden toegekend. Wanneer de queue niet leeg i verwijderd pop het eerte item op de queue. Bijvoorbeeld: pop q c Waarna variabele c de waarde van het eerte element op de queue (q) heeft gekregen en dat eerte element van de queue i verwijderd. Wanneer de queue wel leeg i wordt er gewacht tot er een element op de queue komt. empty [ pop o] pop q x, pop q x, if q = ε Omdat dit in ommige gevallen niet i wat we willen. (tel er komt nooit meer een item op de queue, dan hebben we een hangend programma) introduceren we: empty [ trypop o] trypop q x, if q = ε not_empty [ trypop o] trypop q x, [ ( a : q) q][ x a] if q ε Met behulp van boventaande emantiek en yntax bechrijvingen hebben we nu meage queue in While. emantiek & Correctheid: Thread ynchroniatie & communicatie 9/29

10 ignal in While Een tweede communicatie en ynchroniatie middel voor thread zijn zogenaamde ignal. Een ignal kan een andere thread vertellen dat hij mag beginnen met het uitvoeren van bepaalde taken. Een ignal implementeren we in While aan de hand van de volgende yntax voor een ignal declaratie: ::=... newignal ig Met ig :: = a Een ignal implementeren we al een ignalnaam met een integer waarde. Een ignal heeft initieel de waarde 0 (fale). De emantiek : [ ig ] newignal ig, 0 We zullen deze declaratie in alle voorbeelden weglaten en aannemen dat het gebruikte ignal al i toegevoegd aan de verzameling van ignal variabelen. ignal hoeven nooit uit de tate verwijderd te worden, we nemen aan dat ze bij beëindiging van het programma automatich worden verwijderd. Een ignal verturen gaat doormiddel van het tatement ignal met al parameter de naam van het ignal. Hiermee wordt de waarde van het betreffende ignal op (true) gezet. [ ignal o] ignal ig, [ ig ] Boventaande emantiek maakt duidelijk dat een ignal niet opnieuw kan worden gebruikt, wanneer het ignal tatement nog een keer wordt aangeroepen blijft de waarde van het ignal op taan. emantiek & Correctheid: Thread ynchroniatie & communicatie 0/29

11 Wachten op een ignal gebeurt met het tatement wait met al parameter de naam van het ignal waarop gewacht moet worden. Wanneer de waarde van het ignal waarop gewacht wordt 0 (fale) i, dan blijft wait gewoon wachten. fale [ wait o] wait ig, wait ig, if A[ ig ] = 0 Wanneer de waarde van het ignal waarop gewacht wordt (true) i, dan wordt wait gewoon overgelagen. [ wait ] true o wait ig, if A[ ig ] = wait ignal, kip. wanneer A[ ignal ] = i du equivalent met het tatement Omdat we een ignal nu niet kunnen reetten maken we ook nog een reet tatement. Wanneer we bijvoorbeeld het volgende programma hebben: while true do wait ig; ; od Dan zal al hij eenmaal wordt uitgevoerd daarna oneindig vaak worden uitgevoerd omdat ignal ig, de waarde behoudt. [ reet o] reet ig, [ ig 0] In feite i dit du het tegenovergetelde van het ignal tatement. emantiek & Correctheid: Thread ynchroniatie & communicatie /29

12 Race Condition & Deadlock Race Condition Al thread met elkaar moeten communiceren dan i het noodzakelijk dat er geen race condition kunnen onttaan. In het dictaat van Nielon & Nielon i ondertaand voorbeeld opgenomen om te illutreren dat de volgorde van verwerking invloed kan hebben op het uiteindelijke reultaat. (x := ) par (x := 2; x := x + 2) Dit code voorbeeld kan drie verchillende reultaten voor de waarde van x hebben, namelijk 4, en 3. We zullen waar nodig naar dit probleem verwijzen al race condition. Deadlock We bekijken nu het volgende programma: ignal ig par wait ig In principe kan het nu voorkomen dat par continue het rechter tatement (wait ig) uitvoert waardoor on programma blijft hangen (deadlock). Om dit vervelende probleem te voorkomen paen we de emantiek van par aan voor die pecifieke gevallen waarin onze programma zouden kunnen blijven hangen. Wanneer par een wachtende pop of wait tegenkomt zal hij eert verder gaan met de andere thread. De orginele par emantiek: [ par o], par 2, ', ' ' par 2, ' [ par o] 2, ' par 2, 2, ' [ par o] 3 par 2, 2, 2', ' par 2', ' [ par o] 4 2, ' par 2,, ' emantiek & Correctheid: Thread ynchroniatie & communicatie 2/29

13 Uitbreidingen van par voor ignal: 2, 2', ' [ par ] 5 o if A[ ig ] = 0 wait ig; par 2, wait ig; par 2', ' 2, ' [ par ] 6 o if A[ ig ] = 0 wait ig; par 2, wait ig;, ' 2, 2', ' [ par ] 7 o if A[ ig ] = 0 ( wait ig) par 2, ( wait ig) par 2', ' 2, ' [ par ] 8 o if A[ ig ] = 0 ( wait ig) par 2, wait ig, ', ', ' [ par ] 9 o if A[ ig ] = 0 par wait ig; 2, ' par wait ig;, ' [ par ] 0 o if A[ ig ] = 0 par wait ig; 2, wait ig;, ', ' [ par ] o if A[ ig ] = 0 par wait ig,, ' ' par wait ig, ', ' [ par ] 2 o if A[ ig ] = 0 par wait ig, wait ig, ' 2, ' 2 emantiek & Correctheid: Thread ynchroniatie & communicatie 3/29

14 Het moge duidelijk zijn wat het idee bij deze regel i. Er zijn echter nog meer regel voor par (wanneer er bijvoorbeeld aan beide kanten een wait tatement voorkomt). Deze regel zijn nagenoeg equivalent aan de regel zoal hierboven bechreven en daarom laten we deze weg. Hetzelfde geldt voor de par regel waar pop tatement in voor komen. Ook deze regel zijn nu triviaal en daarom laten we ze weg. pecifiekere par regel hebben hier uiteraard voorrang op mindere pecifieke par regel. Bekijk het volgende programma: (wait ig) par x:=3 In een toetand waarin geldt [ ig ] = 0 en niet [ o] 4 par. A zal uiteraard [ o] 8 par van toepaing zijn We zullen vanaf nu verder werken met deze aangepate verie van par. emantiek & Correctheid: Thread ynchroniatie & communicatie 4/29

15 Meage Queue veru ignal De functionaliteit van meage queue komt zeer terk overeen met de functionaliteit van ignal. We zien dat de functionaliteit van ignal een ubet i van de functionaliteit van meage queue. Ondertaand voorbeeld illutreert dit: Voorbeeld a: ending thread: receiving thread: ignal ignal; par wait ignal; Hier wacht de receiving thread op een ignaal van de ending thread. Ditzelfde zouden we hebben kunnen doen met behulp van een meage queue: Voorbeeld b: ending thread: receiving thread: puh 0 queue; par pop queue x; Omdat we hier te maken hebben met atomaire tatement hoeven we geen rekening te houden met racecondition. We gaan bewijzen dat: en pop q x, ' wait ig, ' (telling a) puh 0 q, ' ignal ig, ' (telling b) Onder de aanname dat [ q] [ ig] ignal ig op meage queue q: ( [ q = ε ]) = ( A[ ig ] = 0) ( [ q ε ]) = ( A[ ig ] = ). Waarmee we een mapping bedoelen van emantiek & Correctheid: Thread ynchroniatie & communicatie 5/29

16 De telling a i onjuit. Dit kunnen we duidelijk maken door een tegenvoorbeeld. Voorbeeld 2a: ending thread: receiving thread: ignal ig; par while true do wait ig; od Wanneer we het recept van voorbeeld ook hier toepaen dan krijgen we het volgende programma: Voorbeeld 2b : ending thread: receiving thread: puh 0 queue; par while true do pop queue x; od Het i duidelijk dat dit programma niet equivalent i met het programma van voorbeeld 2a. Immer bij ieder uitgevoerd pop tatement wordt het bericht van de meage queue verwijderd. De enige manier om met meage queue een equivalent programma te chrijven i door oneindig veel berichten op de queue te plaaten of door na ieder pop tatement een puh uit te voeren. We paen onze tellingen aan en bewijzen: pop q x, ' wait ig, ' (telling 2a) Mit [ q = ε q = 0: ε ] [ q ] [ ig ] en puh 0 q, ' ignal ig, ' Mit [ q ] [ ig ] (telling 2b) emantiek & Correctheid: Thread ynchroniatie & communicatie 6/29

17 We bewijzen telling 2a. We bewijzen dat al: pop q x; puh 0 q, ' (*) dan ook wait ig, ' (**) Al: [ q = ε q = 0 : ε ] [ q ] [ ig ] We nemen aan (*) en bewijzen dat al de berekeningrij van (*) termineert, dan termineert ook de berekeningrij van (**) en de eindtoetanden van beide rijen zijn hetzelfde. Er zijn 2 mogelijkheden voor de berekeningrij van (*). We maken gevalondercheid: Geval [ pop o] not_empty pop gebruiken en we al aanname hebben dat de queue of leeg i of lecht element bevat weten we hoe de queue er initieel uit moet zien. Omdat we de regel [ o] not_empty pop q x; puh 0 q, not_empty { pop } puh 0 q, { puh o} [ q ( 0 : ε )] [ q ( a : ε )] [ q ε ][ x a] We zien verder dat de variabele x de waarde heeft gekregen die op de queue tond. We nemen voor x altijd een ongebruikte variabele die behalve hier verder nergen in on programma voorkomt en ook nooit meer gebruikt zal worden. Om deze reden kunnen we de variabele x al niet relevant voor de toetand bechouwen. emantiek & Correctheid: Thread ynchroniatie & communicatie 7/29

18 Voor wait maken we ook een berekeningrij beginnend in dezelfde toetand. Door ig moet zijn. onze aannamen zien we dat dat de toetand [ ] { wait true o} wait ig, [ ig ] [ ig ] Door onze aannamen kunnen we nu zien dat [ q ] = [ ig ] Geval 2[ pop o] empty { pop empty o}... pop q x; puh 0 q, pop q x; puh 0 q, [ q ε ] [ q ε ] Het i duidelijk dat deze berekeningrij looped. ε. Voor wait maken we weer een berekeningrij beginnend in dezelfde toetand. Door ig 0 moet zijn. onze aannamen zien we dat dat de toetand [ ] wait ig, { wait fale o} wait ig,... [ ig 0] [ ig 0] Deze berekingrij looped vanuit dezelfde toetand al de berekingrij voor (*). Dat deze toetanden hetzelfde zijn blijkt weer uit onze aannamen. En du (*) (**).? emantiek & Correctheid: Thread ynchroniatie & communicatie 8/29

19 Nu bewijzen we telling 2b. We bewijzen dat al: puh 0 q, ' dan ook ignal ig, ' (*) (**) We nemen aan (*) en bewijzen dat al de berekeningrij van (*) termineert, dan termineert ook de berekeningrij van (**) en de eindtoetanden van beide rijen zijn hetzelfde. 0 q, { puh o} puh [ q (0: q) ] Vanuit dezelfde toetand krijgen we volgen de regel [ ignal o] de berekeningrij: ignal ig, { ignal o} [ ig ] En volgen onze aannamen geldt [ q ( 0 : q) ] [ ig ] [ q (0 : q) ] = [ q ε ] =. Immer? emantiek & Correctheid: Thread ynchroniatie & communicatie 9/29

20 While veru ignal Het valt op dat de toegevoegde tatement voor ignal niet zo vreelijk bijzonder zijn en nogal wat overeenkomten vertonen met de originele tatement van While. Wellicht i het zo dat behalve het principe van variabelen in thread en variabelen tuen thread (lokale en globale variabelen) er weinig verchil i. In dat geval zouden er tatement in While moeten betaan die emantich equivalent zijn met ignal en wait. We bewijzen dat tate o while not b == do kip = o[ ] wait b (telling 3) Mit de ignal variabele b ook toegankelijk i voor tatement uit While. Nogmaal de O emantiek van het while tatement: [ whileo] while b do, if b then ( ; while b do ) ele kip, Eert bewijzen we dat al while not ( b == ) do kip, ' (*) dan ook wait b, ' (**) emantiek & Correctheid: Thread ynchroniatie & communicatie 20/29

21 We nemen aan (*) en bewijzen dat al de berekeningrij van (*) termineert, dan termineert ook de berekeningrij van (**) en de eindtoetanden van beide rijen zijn hetzelfde. De berekenigrij voor (*) kan op 2 manieren worden gemaakt. We maken een gevalondercheid. ff Geval [ if o] { while o} if not { if ff o } kip, while not ( b == ) do kip, { kip o } ( b == ) then ( kip; while not ( b == ) do kip) ele kip, Nu maken we een berekeningrij voor (**) vanuit dezelfde toetand, B not ( b == ) = en du A [ b ] =. gebruikmakend van het gegeven [ ] ff wait b, { wait true } Waarmee we zien dat al (*) begint vanuit en gaat naar, dan gaat ook (**) vanuit naar. (waarbij in dit geval = ) emantiek & Correctheid: Thread ynchroniatie & communicatie 2/29

22 tt Geval 2 [ if o] In het 2 e geval geldt du A[ b ] = 0 maken: en kunnen we de volgende berekeningrij while not ( b == ) do kip, { while o} if not { if tt o } while not { while o } if not... ( b == ) then ( kip; while not ( b == ) do kip) ( b == ) do kip, ( b == ) then ( kip; while not ( b == ) do kip) ele ele kip, kip, Het i duidelijk dat deze berekeningrij looped vanuit. Nu maken we een berekeningrij voor (**) vanuit dezelfde toetand, gebruikmakend van het gegeven B [ not ( b == ) ] = tt en du A [ b ] = 0. wait b, { wait fale o} wait b,... Het i wederom duidelijk dat ook deze berekeningrij looped vanuit. Waarmee we hebben aangetoond dat (*) looped al (**) looped en dat al (*) gaat naar, (**) ook gaat naar. * **. Waarmee i bewezen dat ( ) ( ) Het bewij van ( *) (*) concluderen. * gaat op analoog, waardoor we telling 3 kunnen? emantiek & Correctheid: Thread ynchroniatie & communicatie 22/29

23 Het i verder eenvoudig om te zien dat al b een globale variabele i, dat het tatement: b := ; emantich equivalent i met: ignal b; Immer en ook [ A[ ] ] b : =, b = [ A[ ] ] ignal b, b =? emantiek & Correctheid: Thread ynchroniatie & communicatie 23/29

24 While veru Meage Queue Omdat we al gezien hebben dat de functionaliteit van ignal ook met de tandaard while tatement kan worden bereikt (mit er gedeelde variabelen betaan) en we al hebben gezien dat de functionaliteit van meage queue gedeeltelijk overlapt met die van ignal, reit de vraag of het niet ook mogelijk i om meage queue in While te implementeren zonder uitbreiding van de orginele emantiek. Het eerte probleem waar men tegenop loopt i het feit dat er geen datatructuur i om meerdere waarden in op te laan. Om de emantiek van While toch niet te hoeven uitbreiden maken we gebruik van Gödel codering. Gödel codering We maken gebruik van gedeelde (hared) integer variabele waarin we onze reek van waarden oplaan al één getal met behulp van Gödel codering. Een Gödel codering i de codering van een reek getallen in één getal. Een reek getallen x 0, x.. xn van lengte n + wordt gecodeerd door: x0 + x + xn + pn (0) pn().. pn( n) (Bij iedere x wordt opgeteld zodat het ook mogelijk i om het getal 0 te coderen, immer 0 x Ν x ) Hierbij i pn(i) de functie die het i-de priemgetal oplevert. ( pn ( 0) = 2 ) Korter gezegd: { x 0, x.. xn} = n i = 0 pn( i) xi + Bijvoorbeeld de queue :3:2: coderen we met behulp van een Gödel codering al = Dit getal laan we op in de gedeelde variabele. emantiek & Correctheid: Thread ynchroniatie & communicatie 24/29

25 Gödel codering : een element toevoegen Voor het toevoegen van een getal wordt de Gödel codering uitgelezen, gedecodeerd en wordt het nieuwe getal toegevoegd. Dit wordt opnieuw gecodeerd en opgelagen in de gedeelde variabele waarbij de oude waarde overchreven wordt. Hierbij dient er wel erg gelet te worden op race-condition. In de tijd dat er een nieuw getal wordt toegevoegd mag er door de receiving thread niet gelezen worden. Gegeven de functie encode_gödel en decode_gödel met het volgende prototype: encode_gödel (number, queue) De functie die gegeven een getal en een Gödel getal, het getal toevoegt aan het Gödel getal. Bijvoorbeeld: encode_gödel( 3, 08 ); // [,2] retourneert het getal 8000 ( [3,,2] ) decode_gödel (poition, queue) De functie die gegeven een poitie en een Gödel getal het (getal + ) op de poitie decodeert uit het Gödel getal. Wanneer de poitie niet betaat wordt er 0 geretourneerd. Poitie beginnen vanaf 0. Bijvoorbeeld: decode_gödel(, ); // [,2,3] retourneert het getal 3. Wanneer we hier nog vanaf trekken krijgen we het gecodeerde getal 2. (NB Je moet er altijd vanaf trekken ) decode_gödel ( 3, ); // [,2,3] retourneert het getal 0 omdat de poitie 3 niet betaat. emantiek & Correctheid: Thread ynchroniatie & communicatie 25/29

26 Een programma in While dat op deze manier een meage queue implementeert zou er al volgt uit kunnen zien voor een ending thread: Voor de overzichtelijkheid gebruiken we hier een variant van While met procedure en parameter. Teven gebruiken we het protect tatement zoal behandeld in het werkcollege. ending thread x := 3; puh (x, queue) // the hared queue variable i called // queue proc puh i (number, queue) begin protect counter := 0; temp := decode_gödel(counter, queue) - ; new := 0; while temp <> 0 do new := encode_gödel(temp, new); counter := counter + ; temp := decode_gödel(counter, queue) - ; od new := encode_gödel(x, new); queue := new; end end emantiek & Correctheid: Thread ynchroniatie & communicatie 26/29

27 Gödel codering : een element uitlezen De receiving thread leet de Gödel codering uit de gedeelde variabele, decodeert deze, leet het eerte getal en codeert de overige getallen weer en laat ze op in de gedeelde variabele. Ook hier mag er terwijl de receiving thread uitleet, door de ending thread geen nieuw getal worden toegevoegd. Een programma in While dat op deze manier een meage queue implementeert zou er al volgt uit kunnen zien voor een receiving thread: receiving thread pop (queue, x); proc pop i (queue, number) begin protect counter := 0; while queue == 0 do kip; // queue i empty, wait od previou := decode_gödel(counter, queue) - ; end end counter := counter + ; next := decode_gödel(counter, queue) - ; while next <> 0 do previou := next; counter := counter + ; next := decode_gödel(counter, queue) - ; od number := previou; We gaan verder niet in op hoe de functie decode_gödel en encode_gödel er precie uit zien. We weten dat ze in While te implementeren zijn. Met het vinden van een oploing voor het oplaan van meedere waarden zonder het uitbreiden van de emantiek van While hebben we het belangrijkte probleem opgelot. Met behulp van de bechreven functie i het eenvoudig om een meage queue te implementeren. emantiek & Correctheid: Thread ynchroniatie & communicatie 27/29

28 Concluie We hebben laten zien dat het uitbreiden van While met meage queue en ignal relatief eenvoudig i en dat de emantiek hiervoor redelijk voor de hand ligt. Teven hebben we aangetoond dat de functionaliteit van ignal gemakkelijk kan worden nageboott met meage queue en dat een uitbreiding van While voor ignal du in feite overbodig i al er al meage queue aanwezig zijn. Al laatte hebben we gezien dat zelf voor het gebruik van meage queue While niet peré uitgebreid hoeft te worden. We kunnen de functionaliteit van meage queue namelijk ook implementeren door gebruik te maken van Gödel codering. In de praktijk zal dit echter nooit gebeuren omdat Gödel getallen zeer nel erg groot worden en omdat het coderen en decoderen een zeer grote berekening i. Verder dwingen de emantiek uitbreidingen correct gebruik van queue af. Bij het werken met queue zonder emantiek uitbreidingen i het veel eenvoudiger om foute programma te chrijven. Voor het gebruik van meage queue hebben uitbreidingen van de emantiek van While du zeker de voorkeur. emantiek & Correctheid: Thread ynchroniatie & communicatie 28/29

29 Referentie Hilfinger, P., Thread of Control [online], Department of Computer cience Berkeley Univerity, 3 Nov Portable Document Format. Available from: < Nielon, H.R. and Nielon F., emantic with application: A Formal Introduction [online], Revied, John Wiley & on, July 999. Portable Document Format. Available from: < Potcript Format. Available from: < Nutt, G.J., Operating ytem: A Modern Perpective [online], econd Edition, Pearon Education Inc., 8 July 200. [Chapter 9]. Available from: < udkamp. T.A., Language and Machine An Introduction to the Theory of Computer cience, econd Edition, Addion-Weley, January 997. hene, C.K., Multithreaded Programming with ThreadMentor: A Tutorial [online], Revied, Department of Computer cience Michigan Technological Univerity, 6 April Available from: < emantiek & Correctheid: Thread ynchroniatie & communicatie 29/29