Du befindest dich hier: FSI Informatik » Prüfungsfragen und Altklausuren » Prüfungen im Bachelor-Studium (1. - 5. Semester) » gra » Aufgabe 1: Mikroprogrammierung

Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen der Seite angezeigt.

Link zu der Vergleichsansicht

Nächste Überarbeitung		Vorherige Überarbeitung
Letzte ÜberarbeitungBeide Seiten, nächste Überarbeitung
pruefungen:bachelor:gra:loesungss13 [21.01.2015 17:33] – angelegt Alpha2000pruefungen:bachelor:gra:loesungss13 [29.01.2015 17:45] – Alpha2000
Zeile 5: Zeile 5:
 Sequencing Logic: Ermittelt die näste Befehls Adresse aus der Control Memory und schreibt das ergebniss in das Control Address Register Sequencing Logic: Ermittelt die näste Befehls Adresse aus der Control Memory und schreibt das ergebniss in das Control Address Register
  
-Control Memory: Lädt die nächste micoinstruktion+Control Memory: Speicher der nästen Microinstuktion
  
 Instruction Register: Adresse des MacoBefehls Instruction Register: Adresse des MacoBefehls
Zeile 81: Zeile 81:
 1) 1)
  
-sehr große Seiten:  Haben einen großen Speicher verschnitt bei kleinen Programmen+sehr große Seiten:  
  
-sehr kleinen Seiten: Viele kleine hierarchische-stufen um Daten zu finden+interne Fragmentierung 
 + 
 +sehr kleinen Seiten: 
 + 
 +Externe Fragmentierung
  
 2) 2)
Zeile 90: Zeile 94:
  
 3) 3)
 +<code>
 +tag = 36 bit
 +offset = 2^12
 +8 Byte pro eintrag = 2^3
 +  
 +  2^12 / 2^3 = 512 Einträge -> 9 bit / Tabellen index
 +  36 / 9 = 4 Stuffige Hierarchie
  
-Unbekannt+</code> 
 +__4 Stuffige Hierarchie__
  
 4) 4)
Zeile 102: Zeile 114:
  
 Eine temporäre Unterbrechung des Programms.(externe) Eine temporäre Unterbrechung des Programms.(externe)
 +
 +um zeitkritische und meist kurze abschnitte abzuarbeiten.
 +
 z.b. IO Geräte auszulesen z.b. IO Geräte auszulesen
 +
  
 2) 2)
  
-Programmierte IO: Direktes Auslesen der IO bei Eingabe. +Programmierte IO: Aktives Warten der CPU auf entsprechender Eingabe 
-z.b. Stdin einlesen(z.b. Fgets)+ 
 +Vorteil: Sobald IO antwortet werden die Daten gleich bearbeitet 
 + 
 + 
 +Interupts IO: CPU Fordert Daten vom IO gerät an 
 + 
 +Vorteil: CPU Kann solange andere Sachen machen, IO Meldet sobald Daten da sind 
 + 
 + 
 +DMA:  Vom CPU angestoßener Datentransfer, DMA Mach den Rest
  
-DMA IO: DMA Controller wickelt den Datentransfer ohne CPU ab  +Vorteil: CPU wird nach dem Anstoßen nicht mehr benötigt, Transfer von Daten erfolgt ohne weiter Prozesse zu beeinflussen ab
-z.b. Auslesen von einer CD mittels DMA Controller+
  
-Unterbrechung´s gesteuerte IO: Angestoßen durch eine Interrupt macht die CPU 
-z.b. CPU muss nur arbeiten wenn Daten zur Verfügung steht 
  
 3) 3)
Zeile 124: Zeile 146:
  
 Vorteil:  Vorteil: 
-Datenworter liegen ausgerichtet im Speicher + 
-Datenworter liegen immer in zusammenhängenden Speicherbereich+Datenworter liegen ausgerichtet im Speicher und können daher einfacher und schneller ausgelesen werden 
  
 Nachteil:  Nachteil: 
-Bei Speicher evtl nicht mehr nutzbar wenn Datenworter nicht mehr rein passen+ 
 +Nicht alle Speicherbereiche werden genutzt Speicher platzt wird dadurch verschwendet.
  
 2) 2)
  
 +<code>
 name = 15 Byte + 1 Byte Alignement name = 15 Byte + 1 Byte Alignement
 vorname = 16 Byte vorname = 16 Byte
Zeile 139: Zeile 164:
 note = 4 Byte  note = 4 Byte 
 ==  48 Byte ==  48 Byte
 +</code>
  
 3) 3)
  
 +<code>
 48 * 8 = 384 48 * 8 = 384
 (96 * 1024)/384 = 256 (96 * 1024)/384 = 256
 +</code>
  
 4) 4)
  
 Little-Endian(LE) = Das niederwertigste byte steht an der ersten stelle Little-Endian(LE) = Das niederwertigste byte steht an der ersten stelle
 +
 Big-Endian(BE) = Das Höherwertigste byte steht an der ersten stelle Big-Endian(BE) = Das Höherwertigste byte steht an der ersten stelle
  
Zeile 153: Zeile 182:
  
 LE: 0x10 32 54 76 LE: 0x10 32 54 76
 +
 BE: 0x76 54 32 10 BE: 0x76 54 32 10
  
 ====== Aufgabe 6: Parallelverarbeitung ====== ====== Aufgabe 6: Parallelverarbeitung ======
 1) 1)
 +
 +Das Hochsprachprogramm unterscheidet sich nicht dabei
  
 VLIW Parallele Alu Operationen ← Compiler VLIW Parallele Alu Operationen ← Compiler
 +
 Superskalar ist es Pipelining ← Prozessor  Superskalar ist es Pipelining ← Prozessor 
  
 2) 2)
 +<code>
 S = T1/Ts = nst/(s+(n-1))t = lim → s S = T1/Ts = nst/(s+(n-1))t = lim → s
 +</code>
  
 3) 3)
  
-DatenHazards ( Sind daten abhängigkeiten) und SteuerHazards(BedingteSprünge)+DatenHazards ( Sind daten abhängigkeiten)  
 + 
 +Durch Daten Abhängigkeiten ist ein Linear fortführen der pipe nicht möglich da auf andere befehle vorher gewartet werden muss 
 + 
 +und  
 + 
 +SteuerHazards(BedingteSprünge) 
 + 
 +Pipeline kann nicht linear durchgezogen werden da nicht bekannt ist an welcher Position das Programm fortgeführt wird
  
 4) 4)
  
 Regeln von Pollack Regeln von Pollack
 +
 Rechenleistungszuwachs ~ sqrt(Anstieg Komplexität) Doppelt so großer Einzelkern-Prozessor gemäß Regel von Pollack → Verdopplung der Logik, d.h. Komplexität, im Prozessor bringt 40 % mehr Leistung Rechenleistungszuwachs ~ sqrt(Anstieg Komplexität) Doppelt so großer Einzelkern-Prozessor gemäß Regel von Pollack → Verdopplung der Logik, d.h. Komplexität, im Prozessor bringt 40 % mehr Leistung
 +
 Doppelte Komplexität = 1.4x Leistungszuwachs Doppelte Komplexität = 1.4x Leistungszuwachs
  
Zeile 180: Zeile 224:
 (Rechen-)Leistung nimmt invers quadratisch ab (Rechen-)Leistung nimmt invers quadratisch ab
 sqrt(1/2) = 70% sqrt(1/2) = 70%
 +
 Somit mit halber Fläche 70% der Leistung das größeren Systems pro Kern Somit mit halber Fläche 70% der Leistung das größeren Systems pro Kern
 Aber nur noch halber Leistungsverbrauch pro Kern Aber nur noch halber Leistungsverbrauch pro Kern
 In der Summe mehr (Rechen-)Leistung als vorher In der Summe mehr (Rechen-)Leistung als vorher
 +
 2*70% = 140% 2*70% = 140%
 +
 Bei gleichem Leistungsverbrauch für 2 Kerne wie beim großen System Bei gleichem Leistungsverbrauch für 2 Kerne wie beim großen System
 Schlussfolgerung: einfacherer, aber dafür immer mehr Kerne Schlussfolgerung: einfacherer, aber dafür immer mehr Kerne
Zeile 203: Zeile 250:
 3) 3)
  
-Nochmal anschauen+a)
  
 +<code>
  
 +index = 2^12 index
 +ByteAdr. = 2^4 byte/Block
 +
 +512 / 16 byte Pro block = 2^19 / 2^4 = 2^15 Blöcke im Cache
 +
 +2^15 / 2^12 index = 2^3 -> 8 - fach Assoziative Cache
 +</code>
 +
 +b)
 +
 +<code>
 +2^16 / 2^4 = 2^12 Blöcke
 +
 +2^12 / 2^12 = 1 -> Direkt abbildend
 +</code>
  
 +====== FORUM´s Diskusion dazu ======
 +Wenn ihr Fehler findet und diese ausbessert am besten noch ins Forum Posten was genau falsch war
 +[[https://fsi.informatik.uni-erlangen.de/forum/thread/12272-Loesungen-SS-2013| zum FORUM]]