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
pruefungen:bachelor:gra:loesungss13 [21.01.2015 17:40] – Alpha2000pruefungen:bachelor:gra:loesungss13 [22.09.2015 13:37] (aktuell) – Übersicht verbessert und Rechtschreibfehler ausgebessert. dom
Zeile 1: Zeile 1:
-====== Aufgabe 1: Microprogrammierung ======+====== Aufgabe 1: Mikroprogrammierung ======
  
 1) 1)
  
-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+**Sequencing Logic**: Ermittelt die nächste Befehlsadresse aus dem Control Memory und schreibt das Ergebnis in das Control Address Register(CAR).
  
-Instruction Register: Adresse des MacoBefehls+**Control Memory**: Speicher der nächsten Mikroinstruktion. 
 + 
 +**Instruction Register**: Adresse des Makrobefehls.
  
 2) 2)
  
-Vertikale Microprogramierung, zu erkennen an dem Decoder nr2 +Vertikale Mikroprogrammierung; zu erkennen an Decoder 2. 
  
  
 3) 3)
  
-Bedingte und Unbedingte Sprünge(Siehe Leitung 16 / 17)+Bedingte und Unbedingte Sprünge (siehe Leitung 16 / 17)
  
 4) 4)
Zeile 31: Zeile 32:
  }  }
 </code> </code>
-MicroCode:+Mikroprogrammierung:
 <code> <code>
  Speicher → D  Speicher → D
Zeile 48: Zeile 49:
 </code> </code>
  
-====== Aufgabe2: Assemblerprogrammierung ======+====== Aufgabe 2: Assemblerprogrammierung ======
  
 1) 1)
Zeile 56: Zeile 57:
 2) 2)
  
-Register Register = Load Store (Speicher muss erst in Register geladen werden), Operationen sind  nur zwischen Registern möglich.+**Register Register**: Load, store Befehle (Speicher muss erst in Register geladen werden), Operationen sind nur zwischen Registern möglich.
  
-Akku = Operationen nur zwischen Akku und Register/Speicher möglich+**Akku**: Operationen nur zwischen Akku und Register/Speicher möglich
  
-Stack = Rechen Operationen nur zwischen auf Stack geladen werten möglich+**Stack**: Rechenoperationen nur zwischen Werten, welche auf dem Stack liegen, möglich. Zu erkennen an den Befehlen push und pop.
  
 3) 3)
Zeile 77: Zeile 78:
 } }
 </code> </code>
-====== Aufgabe3: Paging ======+====== Aufgabe 3: Paging ======
  
 1) 1)
  
-sehr große Seiten:  Haben einen großen Speicher verschnitt bei kleinen Programmen+sehr große Seiten:  Interne Fragmentierung
  
-sehr kleinen Seiten: Viele kleine hierarchische-stufen um Daten zu finden+sehr kleinen Seiten: Externe Fragmentierung
  
 2) 2)
  
-Cache für Pages: um das suchen in den Pages zu beschleunigen(enthalt die Virtuelle und Physikalische adresse)+Cache für Pages: Um das Suchen in den Pages zu beschleunigen (enthält die virtuelle und physikalische Adresse + Flags)
  
 3) 3)
  
-Unbekannt+**Seitengröße**: 4 KiB = 2^12 Byte. 
 + 
 +**Adressbreite**: 48 Bit (36 Bit Tag, 12 Bit Offset). 
 + 
 +**Größe der Einträge**: 8 Byte = 2^3 Byte. 
 +<code> 
 +  2^12 Byte / 2^3 Byte  = 2^9  --> 9 Bit Tabellen Index. 
 +  [48 Bit - 12 Bit (Offset)] / 9 Bit = 4  --> 4-stufige Tabellenhierarchie 
 +</code>
  
 4) 4)
  
-Zeichnen Paging+**--TODO--**
  
 ====== Aufgabe 4: Peripherie ====== ====== Aufgabe 4: Peripherie ======
Zeile 102: Zeile 111:
  
 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. +**Programmed Input/Output**: Aktives Warten der CPU auf entsprechende Eingabe.
-z.b. Stdin einlesen(z.b. Fgets)+
  
-DMA IO: DMA Controller wickelt den Datentransfer ohne CPU ab  +Vorteil: Sobald IO antwortet werden die Daten gleich bearbeitet 
-z.b. Auslesen von einer CD mittels DMA Controller+ 
 + 
 +**Interrupt-driven Input/Output**: CPU Fordert Daten vom I/O Gerät an 
 + 
 +Vorteil: CPU Kann solange andere Sachen machen, I/O meldet, sobald Daten da sind. 
 + 
 + 
 +**DMA**:  Von der CPU angestoßener Datentransfer, DMA macht den Rest. 
 + 
 +Vorteil: CPU wird nach dem Anstoßen nicht mehr benötigt, Transfer von Daten erfolgt ohne weitere Prozesse zu beeinflussen.
  
-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 123: Zeile 142:
 1) 1)
  
-Vorteil:  +**Vorteil**: Datenwörter liegen ausgerichtet im Speicher und können daher einfacher und schneller ausgelesen werden.
-Datenworter liegen ausgerichtet im Speicher +
-Datenworter liegen immer in zusammenhängenden Speicherbereich+
  
-Nachteil:  + 
-Bei Speicher evtl nicht mehr nutzbar wenn Datenworter nicht mehr rein passen+**Nachteil**: Nicht alle Speicherbereiche werden ausgenutzt, Speicherplatz wird dadurch verschwendet.
  
 2) 2)
  
-name = 15 Byte + 1 Byte Alignement+<code> 
 +name = 15 Byte + 1 Byte Alignment
 vorname = 16 Byte vorname = 16 Byte
-versuch = 2 Byte + 2 Byte Alignement+versuch = 2 Byte + 2 Byte Alignment
 matnr. = 4 Byte matnr. = 4 Byte
-geschlecht = 1 Byte + 3 Byte Alignement+geschlecht = 1 Byte + 3 Byte Alignment
 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**: Das niederwertigste Byte steht an erster Stelle. 
-Big-Endian(BE) = Das Höherwertigste byte steht an der ersten stelle+ 
 +**Big-Endian**: Das höherwertigste Byte steht an erster Stelle.
  
 5) 5)
  
 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 = n*s*t / [s+(n-1)]*t 
 +lim S (n -> unendlich) = s 
 +</code> 
 +**S**: SpeedUp 
 +**T1**: Ausführungszeit ohne Pipeline 
 +**Ts**: Ausführungszeit mit Pipeline 
 +**n**: Anzahl der Instruktionen 
 +**t(tau)**: Zykluszeit 
 +**s**: Stufen
  
 3) 3)
  
-DatenHazards ( Sind daten abhängigkeiten) und SteuerHazards(BedingteSprünge)+**1. Datenhazards**: Aktueller Befehl benötigt das Ergebnis des vorherigen Befehls, dessen Ergebnis wiederum noch nicht zurückgeschrieben wurde. Die Pipeline muss warten. 
 + 
 + 
 +**2. Controlhazards (Bedingte Sprünge)**: Der nächste Befehl ist evtl. nicht der richtige, da gesprungen werden kann.
  
 4) 4)
  
-Regeln von Pollack+**Die Regel 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
  
-Pollacks Regeln Rückwärts angewandt +Pollacks Regeln rückwärts angewandt: 
  
 Statt einen großen Kern zwei kleinere, halb so große Kerne Statt einen großen Kern zwei kleinere, halb so große Kerne
 (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 191: Zeile 233:
 1) 1)
  
-Räumliche Lokalität = wenn Zugriffe erfolgt nächster zugriff meist auf benachbarte Adresse+**Räumliche Lokalität**: Nach Zugriffe erfolgt in naher Zukunft erneut Zugriff auf __benachbarte__ Adresse.
  
-Zeitliche Lokalität = wenn Zugriff erfolgt nächster zugriff wieder auf selber Adresse+**Zeitliche Lokalität**: Nach Zugriffe erfolgt in naher Zukunft erneut Zugriff auf __dieselbe__ Adresse.
  
 2) 2)
 +<code>
 +2048 Byte / 64 Byte = 32
 +</code>
 +Frühestens beim 33. Zugriff findet eine Verdrängung statt (Compulsory Miss).
  
-2048/64 = 32 zugriffe+3)
  
-Beim 33 Zugriff Compulsory+a)
  
-3)+Tag = 2^16
  
-Nochmal anschauen+Index = 2^12
  
 +ByteAdr. = 2^4
 +<code>
 +Anzahl der Blöcke = Cachegröße / Blockgröße =  512 KiB / 2^4 (Byteadr.) = 2^19 / 2^4 = 2^15
  
 +n = Cachegröße / Menge = 2^15 / 2^12 (Index) = 2^3 -> 8-fach assoziativer Cache
 +</code>
  
-====== FORUM´s Diskusion dazu ====== +b) 
-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]]+<code> 
 +Anzahl der Blöcke: 2^16 Byte / 2^4 = 2^12 
 + 
 +2^12 / 2^12 (Index)= 1 -> direktabbildend 
 +</code>
  
 +====== Forum ======
 +Falls ihr Fehler findet oder Fragen habt, hier ist der Thread im Forum dazu [[https://fsi.informatik.uni-erlangen.de/forum/thread/12272-Loesungen-SS-2013|zum Forum]]