TECHNISCHE UNIVERSITEIT EINDHOVEN ComputerSystemen Deeltentamen B (weken 6..9) vakcode 2M208 woensdag 19 Maart 2003, 9:00-10:30 Algemene opmerkingen (lees dit!): - Dit tentamen duurt ANDERHALF UUR! - Dit is een open boek tentamen. Gebruik van Tanenbaum s Gestructureerde Computerarchitectuur (of de Engelse versie hiervan) de is toegestaan. Daarnaast mogen de practicumhandleiding Practical Exercises for course Computer Architecture en afdrukken van de collegeoverheads gebruikt worden. - Het tentamen bestaat uit VIER opgaven (totaal 100 punten). - Uitwerkingen worden ná het tentamen gepubliceerd op de vakhomepage: http://www.win.tue.nl/~michaelf/2m200 - Het gebruik van eigen (losse) aantekeningen, examenbundels en laptops is NIET toegestaan. Veel succes! Opgave 1 (15+5 punten): -a Waarom kan een chip niet gewoon direct een waarde lezen van een bus, maar is dat met een DAV/ACK of REQ/ACK protocol wel mogelijk? -b Wat is het verschil tussen het DAV/ACK en het REQ/ACK protocol? Opgave 2 (20+10 punten): -a Na een systeemcrash wordt een analyse gemaakt van de administratie van het virtuele geheugen van het systeem kort voor de crash. De page-tables van de segmenten 0 t/m 3 zagen eruit zoals hieronder weergegeven. De status bits hebben de volgende betekenis: P is present (pagina is geladen), W is writeable (pagina is schrijfbaar), C is changed (pagina is sinds laden veranderd), X is executable (pagina bevat executeerbare code) met de waarden T (true) en F (false). 1
Segment 0: 0 3 F F T T 1 34 T F F T 2 23 T F F T 3 45 F F T T 4 35 F F T T 5 34 F T T T 6 28 T F F T Segment 1: 0 1 T T T F 1 28 T T T F 2 35 T T F F 3 45 T T F F Segment 2: 0 6 F T T F 1 12 T T F F 2 1 T F F F 3 34 F T T F 4 17 F F T F 5 9 T T T F Segment 3: 0 9 F F F F 1 19 T F F F 2 21 F F F F 3 17 T F F F Wat is er mis met bovenstaande page-tables? Wat was dan wellicht de oorzaak van de systeemcrash? -b Stel dat elke pagina 64 kilobyte groot is. Wat is dan het fysieke adres dat hoort bij: virtueel adres 34734 van segment 1 virtueel adres 34734 van segment 3 Opgave 3 (10+10+10 punten): -a Leg kort het verschil uit tussen recursieve procedures en coroutines. Hoe gaan beiden met de stack om? -b Een CD-brander leest uit een FIFO-buffer 1800 kbyte/sec (12 speed). Een trage PC schrijft in diezelfde buffer 1500 kbyte/sec. Als het schrijven van een CD pas begint als de FIFO-buffer helemaal vol is, hoe groot moet de buffer dan zijn om 700 MegaByte op de CD probleemloos te kunnen schrijven? (Laat je berekening zien en licht die toe. Afrondingsfouten zijn niet van belang; de berekening wel!) -c Wat is een race conditie en hoe bieden semaforen daar een nette oplossing voor? 2
Opgave 4 (20 punten): Geef een systematische vertaling voor de volgende toekenning: D:=B²-4*A*C Daarbij moet gebruik worden gemaakt van de op het college behandelde methode met de rekenstapel. Om een waarde op de rekenstapel te zetten mag de instructie 'PUSH MATH,waarde' worden gebruikt. Met 'POP register,math' kan een waarde van de rekenstapel afgehaald en in een register geplaatst worden. Verder zijn er subroutines gegeven met de beginlabels SQUARE, MINUS en TIMES die de operaties '²', '-' en '*' uitvoeren op de bovenste elementen op de rekenstapel. De argumenten worden door deze routines van de stapel verwijderd en het resultaat wordt erop teruggeplaatst. De routines gaan ervan uit dat het eerste argument (linkerlid) als eerste op de stapel is geplaatst en het tweede argument (rechterlid) als laatste. Laat zien hoe je aan het antwoord komt! 3
Uitwerkingen: Opgave 1: -a De waarde op een bus wisselt op niet te voorspellen momenten. Tijdens zo'n wisseling zijn niet alle bits tegelijk weer stabiel. Indien op een willekeurig moment wordt gelezen kunnen de bits op dat moment elk in transitie zijn. Op zo'n moment wordt een random waarde gelezen. Met een DAV/ACK of REQ/ACK protocol wordt gegarandeerd dat de waarde op de bus stabiel is op het moment dat deze wordt gelezen (tussen de 2e en 3e fase). -b Het voornaamste verschil tussen DAV/ACK en REQ/ACK is dat bij DAV/ACK de producent van de data het initiatief van communicatie neemt (Data Available) en bij REQ/ACK de verbruiker van de data (Request Data). Opgave 2: -a We hoeven alleen die pagina's in overweging te nemen die op het moment van de crash waren geladen. Pagina's die niet waren geladen (Present is false) zijn niet van belang, evenals de overige status bits van deze pagina's. De geladen pagina's (in het fysieke geheugen) zijn: segment 0: 23, 28, 34 segment 1: 1, 28, 35, 45 segment 2: 1, 9, 12 segment 3: 17, 19 De page-tables van de segmenten zijn dus inconsistent. Pagina 1 hoort bij segment 1 én bij segment 2. Echter, ze bevatten in beide gevallen geen executeerbare code. Pagina 1 kan ook alleen d.m.v. segment 1 worden geschreven (dat is ook gebeurd, want Change is true). Hierdoor kunnen dus wel fouten in de data ontstaan, maar dat verklaart nog niet de systeemcrash. Pagina 28 hoort bij segment 0 én bij segment 1. Volgens segment 0 bevat de pagina executeerbare code. Volgens segment 1 is de pagina echter schrijfbaar en ook dat is gebeurd (Change is true). Het systeem is dus waarschijnlijk gecrasht, omdat middels segment 1 is geschreven naar een stuk geheugen dat executeerbare code bevat van segment 0. Daarmee is het programma vernield en vervolgens uitgevoerd. 4
-b Adres 34734 van segment 1 valt binnen de eerste virtuele pagina van dit segment. Deze staat in fysieke pagina 1. Fysieke pagina 1 begint op 2^16=65536. Het adres is dus 65536+34734=100260. Adres 34734 van segment 3 valt binnen de eerste virtuele pagina van dit segment. Deze is echter niet geladen (Present is false). Er bestaat dus geen bijbehorend fysiek adres (Page fault). Opgave 3: -a Een recursieve procedure roept herhaaldelijk zichzelf aan, gewoonlijk met verschillende argumenten. Bij elke aanroep begint de procedure weer van voren af aan. Daarbij wordt op de stack telkens een nieuw terugkeeradres afgelegd, dat bij de return weer wordt opgehaald. Bij coroutines gaat het om twee procedures die elkaar aanroepen, waarbij niet telkens opnieuw wordt begonnen, maar waarbij de andere routine verder gaat waar die was gebleven. Daarbij wordt telkens het nieuwe terugkeeradres verwisseld met dat op de stack, waardoor deze eigenlijk constant blijft. Ook worden bij het wisselen van coroutine geen parameters doorgegeven. -b Noem de buffergrootte B (in MegaByte). Vanaf het moment dat de buffer vol is, duurt het branden nog 700 MB/1800 KB = 700*1024/1800=±400 sec. In die tijd kan er maximaal 400*1500KB=600000KB naar de buffer worden geschreven. Dat is dus 700MB-B, dus B is 700*1024-600000 KB. De buffer is dus in de orde van 100MB. -c Een race-conditie onstaat wanneer meerdere processen tegelijk een variabele gebruiken. Het kan dan gebeuren dat de actie die een proces neemt op basis van de waarde van die variabele al niet meer gerechtvaardigd is op het moment dat de actie zelf plaatsvindt (na de test). De reden hiervoor is dat tussen het meten van de waarde en het ondernemen van de actie een ander proces de waarde van de variabele alweer kan hebben veranderd. De race conditie is de situatie waarin beide programma's zich bevinden op het moment dat deze fout kan optreden (dus de toestand van het programma op het kritieke moment; net voordat het fout gaat). Semaforen lossen dit probleem op omdat zij het mogelijk maken om de waarde te veranderen en daar een actie op te ondernemen (namelijk gaan wachten) zonder dat een tussentijdse verandering van de semafoorwaarde mogelijk is (Semafooracties zijn ondeelbaar). Om die onderbreking makkelijker te kunnen tegenhouden worden semaforen gewoonlijk door het operating system ondersteund. Opgave 4: Stapsgewijs herschrijven levert: 5
'Bereken B²-4*A*C' vervolgens: (LET OP: op stack!) 'Bereken B²' 'Bereken 4*A*C' dan: 'Bereken B' ACALL SQUARE 'Bereken 4*A' 'Bereken C' daarna: PUSH MATH,B ACALL SQUARE 'Bereken 4' 'Bereken A' PUSH MATH,C tenslotte: PUSH MATH,B ACALL SQUARE PUSH MATH,#4 PUSH MATH,A PUSH MATH,C 6