Opgaven Registers Concurrency, 29 nov 2018, Werkgroep.

Transcriptie

1 Opgaven Registers Concurrency, 29 nov 2018, Werkgroep. Gebruik deze opgaven om de stof te oefenen op het werkcollege. Cijfer: Op een toets krijg je meestal zes tot acht opgaven. 1. Safe Integer: Van een Safe bit kun je een Regular bit maken met de methode van silent writes. (a) Wanneer zal een Write operatie als silent uitgevoerd worden? (b) Is de methode van silent writes ook toe te passen om van een Safe Integer een regular Integer te maken? Oplossing: (a) Een Write operatie zal alleen daadwerkelijk schrijven als de waarde verschilt van de vorige; dus silent zijn als de wrtite-waarde gelijk is aan de vorige. (b) Voor integers werkt dit niet. Voor bits alleen omdat er maar twee waarden zijn, zodat tijdens een (actieve) write alle waarden uit het domein zijn toegestaan. Als je een safe int met waarde 0, overschrijft met een 1, kan een overlappende read waarde 2 opleveren. Beoordeling/Toelichting: Max 2, voor elke deelvraag 1. Codes: C = Een andere Constructie van regular integer werd niet gevraagd. M = Onvoldoede of onjuiste Motivatie. 2. Safe en Regular Bit: Bij het implementeren van registers kennen we een onderscheid tussen een safe register, een regular register en een atomic register. (a) Leg uit, waarom regular een sterkere eigenschap is dan safe. (b) Leg uit, waarom regular een zwakkere eigenschap is dan atomic. (c) Laat zien, hoe je met een safe bit, een regular bit kunt implementeren. Oplossing: (a) Bij safe is er niets gespecificeerd over de uitkomst van een read die met een write overlapt. Bij regular wel, dan heb je de garantie dat de opgeleverde waarde die van de laatste ervoor, of een overlappende write is. (b) Als het atomair is, lijkt het of elke operatie apart gebeurt op een moment binnen de werkelijke uitvoering. Voor een read betekent dat sowieso, dat de opgeleverde waarde er eentje is van een overlappende of de voorlaatste write. Maar bovendien kan er bij atomic geen inversie zijn: dat achtereenvolgende reads eerst een nieuwe, dan een oudere waarde opleveren. Bij regular kan dat wel, omdat regular wel iets zegt over de uitkomst van elke individuele read, maar niet over de relatie tussen de opgeleverde waarden. (c) Een regular bit mag de oude en nieuwe waarde opleveren als een read met een write overlapt. Een safe bit kan bij overlap sowieso alle waarden opleveren. Nu kent een bit maar twee waarden, 0 en 1, en als er dus sprake is van een werkelijke verandering, zijn oud en nieuw samen dus ook alles. Constructie, de Silent Write: gebruik een SAFE bit, maar de Writer houdt bij wat de laatste write waarde was. In een Write(x) wordt gekeken of x al in het register zit, en alleen als dat niet zo is, wordt een write werkelijk gedaan. De Read doet gewoon een read en levert de waarde op. Beoordeling/Toelichting: Een punt per deelvraag. R = Bij b niets over Regular. W = Willekeurige uitkomst alleen bij overlap.

2 3. Register uit bit: Om een m-waardig register te implementeren uit bits gebruiken we een unaire representatie. De Write(x) set bit r[x], en reset de lagere bits. De Read bekijkt bits van laag naar hoog, en returnt de eerste x waarvoor r[x] true is. Deze constructie is behandeld op college. (a) Een karakteristieke eigenschap van registers is: dat een Write alle voorgaande toestanden van het register uitwist. In deze register-implementatie zijn oude toestanden echter nog zichtbaar als 1-en in de array. Heeft deze implementatie dan wel de karakteristieke register-eigenschap? (b) Een programmeur vindt het mooier om, in een Write(x), ook de hogere bits te resetten (zodat na de operatie, precies één bit true is). Laat zien, dat dit tot een foute uitkomst bij Read leidt. Oplossing: (a) Je moet hier een onderscheid maken tussen de interne representatie van de toestand, en de extern aangeboden toegang. De oude toestanden die als 1 zichtbaar zijn, kun je alleen zien door inspectie van de interne toestand van het object. Als een Write-operatie eenmaal is afgerond, is geen van de daarvoor geschreven waarden nog te zien met een Read-operatie. (b) Als je deze hogere bits gaat resetten, kun je op zeker moment een bit resetten ZON- DER dat er een hogere op 1 staat. Dit kan ertoe leiden dat een Read volledig uit de rij loopt. Beoordeling/Toelichting:

3 4. Atomaire en Regular Registers: Deze vraag gaat over Single Reader, Single Writer Registers. (a) Geef een voorbeeld van gedrag dat wel Regular is, maar niet Atomic. (b) Hoe kun je met een Regular register een Atomic register maken? Oplossing: (a) Bij Regular registers is een inversie acceptabel. Register heeft waarde 8 en er komt een write(5). Tijdens de write doet de reader twee reads, waarvan de eerste de 5 oplevert en de tweede de 8. (b) Gebruik sequence numbers. Writer houdt sn bij en doet Write(x) als write((x,++sn)). De Reader onthoudt de hoogst gekregen combinatie. Na een read pakt hij het hoogste sn, onthoudt en returnt die waarde. Beoordeling/Toelichting: Totaal 3, nl 1 voor (a) en 2 voor (b). Bedoeling van de opgave was, dat je kennis uit het college/boek met enige nauwkeurigheid zou weergeven. Voor sommigen was het al lastig, welke kennis moest worden opgeschreven. Het ging niet om het regular maken van safe bits, het multiread maken van singleread, het multivalued maken van bits! A = Wat je beschrijft is wel Atomair. H = Helpen door Readers was alleen bij Multireader maken. I = Je beschrijving van het gedrag is Incompleet. L = Locking mag absoluut niet want om dat te maken heb je eerst sterke registers nodig. M = Duplicatie gebruik je voor Multireader. N = Niet alleen opslaan, ook serienummers erbij! R = Wat je beschrijft is niet Regular. S = Wat je opschrijft is niet Singlereader. U = Unair gebruik je om multivalued registers te maken. W = Je oplossing is niet Wachtvrij.

4 5. Register Implementaties: Voor het implementeren van wacht-vrije registers bestaan o.a. deze technieken: (A) Copying, (B) Silent Write, (C) Sequence Numbers, (D) Unary Representation. (a) Welke hiervan gebruik je om (i) van een Safe Bit een Regular Bit te maken; (ii) van een Regular Register een Atomic Register te maken; (iii) van een Regular Bit een Regular m-valued Register te maken? (b) Leg uit hoe de Silent Write werkt. (c) Kun je deze technieken combineren om met registers een TaS-instructie te implementeren? Oplossing: (a) i = B, ii = C, iii = D. (b) De Silent Write wordt gebruikt bij een write op bits. Als de te schrijven waarde gelijk is aan de vorige waarde, wordt de write niet uitgevoerd (is Silent). Hierdoor kan een read op de bit alleen overlappen met een write die de waarde ook echt verandert, en in dat geval is zowel een 0 als een 1 goed als antwoord. (c) Dat zal niet gaan, want het is onmogelijk om met registers wachtvrij een TaS te implementeren. Die heeft namelijk Consensusgetal 2. Beoordeling/Toelichting: Max 3, een per deelvraag. Bij (a) is 2 goede antwoorden 1/2, 1 goed is 0pt. Codes: C = Beredeneer het met Consensusgetallen! M = Geen Motivering of onzinnig verhaal. L = Silent Write zal niet het shared register uitlezen, maar checkt tegen een locale kopie van de laatstgeschreven waarde. S = Silent Write werkt alleen voor iets dat een Single Writer heeft. Bij meerdere writers werkt het niet meer, daarom kun je er geen TaS mee implementeren.

5 6. Multivalued register: Je kunt een m-waardig regular register maken uit een array van m regular bits. De Writer schrijft waarde x door bit x op 1 te zetten en de lagere bits op 0, de reader zoekt vanaf positie 0 naar de eerste 1: Write(x): Read: r[x].write(1) for(i=0; i<m; i++) for (i=x-1; i>=0; i--) if (r[i].read == 1) r[i].write(0) return i (a) Laat zien dat de Reader kan falen wanneer de Writer ook de hogere bits op 0 zet (met een loopje for (i=x+1; i<m; i++) r[i].write(0)). (b) Is het gebouwde register ook atomic? Leg uit! Oplossing: (a) Stel dat de Writer eerst Write(4) doet en dan Write(2). Na de Write(4) zijn alle bits voor positie 4 op 0, neem aan dat de Reader begint en de 0len leest tot positie 3. De Writer voert zijn complete Write(2) uit, daarna staan alle bits voorbij positie 2 op 0. De Reader gaat verder en leest alleen maar 0len. (b) Het is niet atomic, een inversie is mogelijk, omdat de gebruikte bits zelf alleen maar regular zijn. Scenario hiervoor: stel de waarde is 2 maar de Writer doet een Write(3). De Writer begint met r[3] op 1 te zetten, en gaat dan r[2] op 0 zetten met r[2].write(0). Tijdens deze write kan de Reader een volledige Read afwerken, waarbij de read op r[2], die met de r[2].write(0) overlapt, de nieuwe waarde al geeft zodat de Read resultaat 3 geeft. Daarna kan de Reader weer een volledige Read afwerken, waarbij de r[2].read, die weer met de r[2].write(0) overlapt, de oude waarde nog teruggeeft zodat deze Read 2 oplevert. (We vermoeden dat de constructie wel een atomair register zou opleveren als de gebruikte bits atomair zijn. Als dat klopt, kun je een scenario alleen maar geven door niet-atomair gedrag van bits erin te bouwen.) Beoordeling/Toelichting: Voor a en b elk 2pt. Beoordelingscodes: A = Motiveert een nee bij (b) met een Atomair scenario; 0pt. Bijvoorbeeld: een inversie bij twee overlappende reads, dit kan niet want als twee Reads overlappen kan nooit sprake zijn van inversie. B = Beredeneert bij (b) dat het atomair is, maar vanuit Atomaire bits. Slim, maar de gegeven bits zijn slechts regular; 1pt. D = Noemt alleen Definitie van atomic maar bewijst er niets over, 0pt. L = Beweert dat een Latere writewaarde kan worden geretourneerd. Kan niet, zou ook niet regular zijn; 0pt. M = Beredeneert bij (b) incorrectheid met een MultiWriter scenario, terwijl deze constructie alleen bedoeld is voor SingleWriter; 0pt. R = Beredeneert Regular ipv atomair, 0pt. S = Zegt bij (b) nee en noemt inversie, maar zonder Scenario te geven; 1pt. T = Beweert bij (b) dat het niet atomair is omdat Timestamps nodig zijn; 1pt. W = Voert bij (a) een scenario op waarin het fout gaat met twee Writers; zie M, 1pt.

6 7. Multivalued register: Je kunt een m-waardig regular register maken uit een array van m regular bits. De Writer schrijft waarde x door bit x op 1 te zetten en de lagere bits op 0, de reader zoekt vanaf positie 0 naar de eerste 1: Write(x): Read: r[x].write(1) for(i=0; i<m; i++) for (i=x-1; i>=0; i--) if (r[i].read == 1) return i; r[i].write(0) // A (a) Laat zien dat de Reader kan falen wanneer de Writer ook de hogere bits op 0 zet (met een loopje for (i=x+1; i<m; i++) r[i].write(0)). (b) Is het gebouwde register ook atomic? Leg uit! (c) Bobs compiler weigert de Read code wegens executiepaden zonder return. Daarom wil Bob als default op plek A een return... zetten; met welke waarde achter de return is de methode correct? Oplossing: (a) Stel dat de Writer eerst Write(4) doet en dan Write(2). Na de Write(4) zijn alle bits voor positie 4 op 0, neem aan dat de Reader begint en de 0len leest tot positie 3. De Writer voert zijn complete Write(2) uit, daarna staan alle bits voorbij positie 2 op 0. De Reader gaat verder en leest alleen maar 0len. (b) Het is niet atomic, een inversie is mogelijk, omdat de gebruikte bits zelf alleen maar regular zijn. (Scenario hiervoor: stel de waarde is 2 maar de Writer doet een Write(3). De Writer begint met r[3] op 1 te zetten, en gaat dan r[2] op 0 zetten met r[2].write(0). Tijdens deze write kan de Reader een volledige Read afwerken, waarbij de read op r[2], die met de r[2].write(0) overlapt, de nieuwe waarde al geeft zodat de Read resultaat 3 geeft. Daarna kan de Reader weer een volledige Read afwerken, waarbij de r[2].read, die weer met de r[2].write(0) overlapt, de oude waarde nog teruggeeft zodat deze Read 2 oplevert. We vermoeden dat de constructie wel een atomair register zou opleveren als de gebruikte bits atomair zijn. Als dat klopt, kun je een scenario alleen maar geven door niet-atomair gedrag van bits erin te bouwen.) (c) Met elke waarde, omdat deze return statement nooit wordt uitgevoerd. Beoordeling/Toelichting: Voor a, b en c elk 1pt. Beoordelingscodes: A = Motiveert een nee bij (b) met een Atomair scenario; 0pt. Bijvoorbeeld: een inversie bij twee overlappende reads, dit kan niet want als twee Reads overlappen kan nooit sprake zijn van inversie. B = Beredeneert bij (b) dat het atomair is, maar vanuit Atomaire bits. Slim, maar de gegeven bits zijn slechts regular; 1pt. D = Noemt alleen Definitie van atomic maar bewijst er niets over, 0pt. L = Beweert dat een Latere writewaarde kan worden geretourneerd. Kan niet, zou ook niet regular zijn; 0pt. M = Beredeneert bij (b) incorrectheid met een MultiWriter scenario, terwijl deze constructie alleen bedoeld is voor SingleWriter; 0pt. R = Beredeneert Regular ipv atomair, 0pt. S = Zegt bij (b) nee en noemt inversie, maar zonder Scenario te geven; 1pt. T = Beweert bij (b) dat het niet atomair is omdat Timestamps nodig zijn; 1/2pt. W = Voert bij (a) een scenario op waarin het fout gaat met twee Writers; zie M, 1pt. Z = Bij (c) zijn natuurlijk oneindig veel goede antwoorden, maar voor vol punt moet je

7 Zien dat het niet uitmaakt. 8. Technieken voor Register-Implementatie: Om sterke registers te implementeren kunnen deze technieken worden gebruikt: Silent Write, Unaire notatie, Serienummers. (a) Hoe werkt de Silent Write? (b) Welke techniek gebruikt men om van een regular bit naar een m-valued register te gaan? Welke techniek gebruikt men om van een Safe bit naar een Regular bit te gaan? Oplossing: (a) De Writer onthoudt welke waarde hij als laatste geschreven heeft, en voert een write alleen uit als de nieuwe waarde anders is. (b) Dat gaat met unaire notatie. Dat gaat met Silent Write. Beoordeling/Toelichting: 2pt.

8 9. Multivalued register: Je kunt een 12-waardig regular register maken uit een array van 12 regular bits. De Writer schrijft waarde x door bit x op 1 te zetten en de lagere bits op 0, de reader zoekt vanaf positie 0 naar de eerste 1: Write(x): Read: r[x].write(1) for(i=0; i<12; i++) for (i=x-1; i>=0; i--) if (r[i].read == 1) r[i].write(0) return i (a) Stel dat de Writer al een Write(4) en daarna een Write(7) heeft afgerond, dat dan een Read begint, en terwijl die Read bezig is, begint de Writer aan een Write(5). Welke uitkomsten mag de Reader krijgen volgens de eis van Regular? (b) Otto zegt dat je de write(1) ook later kunt doen, dwz., de r[x].write(1) na de for-lus zetten. Laat door een voorbeeld zien dat het register dan niet Regular is. Oplossing: (a) Regular betekent dat een Read die overlapt met een of meer writes, de waarde ziet van een van de overlappende Writes of de laatste die daarvoor was afgesloten. Volgens het gegeven was de Write(7) de laatst afgeronde, en de Write(5) overlappend. De 4 uit de eerste Write is onnacceptabel, omdat die door de afgeronde Write(7) onzichtbaar is geworden. (Zouden er tijdens de Read nog andere Writes beginnen, dan is de waarde daarvan ook acceptabel.) (b) Stel dat de inhoud van het Register eerst 7 is en dat deze 7 wordt overschreven door een 3; de bits staan dan op Nu begint de Writer aan een Write(5), en gaat volgens Otto s idee eerst de eerste vijf bits op 0 zetten. Inhoud van het Register is dan , en als nu de Reader langskomt en een volledige Read uitvoert, levert die 7 op. Volgens de eisen van Regular zou dat alleen 5 mogen zijn (huidige overlappende Write) of 3 (voorgaande afgesloten Write). Beoordeling/Toelichting: Totaal 3pt. Voor a 1pt voor b 2pt. Beoordelingscodes: M = Beredeneert bij (b) incorrectheid met een MultiWriter scenario, terwijl deze constructie alleen bedoeld is voor SingleWriter; 0pt. R = Zeg bij (a) wat mag volgens de eis Regular, niet wat kan volgens deze implementatie. U = Scenario waar een kleine waarde wordt overschreven met een grotere, en de Reader Uit de array loopt. Om compleet aan te tonen dat dit niet regular is, zou je het moeten aanvullen met de default die in dat geval opgeleverd moet worden. Deze scenario s zijn in principe wel goed gerekend. W = Voert bij (b) een scenario op waarin het fout gaat met twee Writers; zie M, 1pt.