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

Beide Seiten, vorherige ÜberarbeitungVorherige Überarbeitung
Nächste Überarbeitung		Vorherige Überarbeitung
Letzte ÜberarbeitungBeide Seiten, nächste Überarbeitung
pruefungen:bachelor:gra:loesungss13 [21.01.2015 17:40] – 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 ====== ====== FORUM´s Diskusion dazu ======