====== Aufgabe 1: Mikroprogrammierung ======

1)


**Sequencing Logic**: Ermittelt die nächste Befehlsadresse aus dem Control Memory und schreibt das Ergebnis in das Control Address Register(CAR).

**Control Memory**: Speicher der nächsten Mikroinstruktion.

**Instruction Register**: Adresse des Makrobefehls.

2)

Vertikale Mikroprogrammierung; zu erkennen an Decoder 2. 


3)

Bedingte und Unbedingte Sprünge (siehe Leitung 16 / 17)

4)

Pseudocode:
<code>
	Speicher nach B
	Schleife:
		B-1
		if(B>=0 ){
			A = A<<1
		}else{
			break
		}
</code>
Mikroprogrammierung:
<code>
	Speicher → D
	D → B
	goto lcon

Schleife:
	C → B
	A<<1 → C
	C → A

lcon:
	B-1 → C
	C>=0 goto schleife
exit:
</code>

====== Aufgabe 2: Assemblerprogrammierung ======

1)

Register Memory

2)

**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

**Stack**: Rechenoperationen nur zwischen Werten, welche auf dem Stack liegen, möglich. Zu erkennen an den Befehlen push und pop.

3)

<code>
for(int i = 0; i< length; i++){
	for(int j = i ; j <lenght; j++){
		swap1 = value[i]
		swap2 = value[j]
		if(swap1 > swap2){
			temp = value[i]
			value[i] = value[j]
			value[j] = temp
		}
	}
}
</code>
====== Aufgabe 3: Paging ======

1)

sehr große Seiten:  Interne Fragmentierung

sehr kleinen Seiten: Externe Fragmentierung

2)

Cache für Pages: Um das Suchen in den Pages zu beschleunigen (enthält die virtuelle und physikalische Adresse + Flags)

3)

**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)

**--TODO--**

====== Aufgabe 4: Peripherie ======

1)

Eine temporäre Unterbrechung des Programms.(externe)

um zeitkritische und meist kurze abschnitte abzuarbeiten.

z.b. IO Geräte auszulesen


2)

**Programmed Input/Output**: Aktives Warten der CPU auf entsprechende Eingabe.

Vorteil: Sobald IO antwortet werden die Daten gleich bearbeitet


**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.


3)

Speicheradresse wird im Speicher automatisch erhöht
Ohne Direkte Anforderung der CPU werden weitere Daten aus dem Speicher gelesen

====== Aufgabe 5: Speicherverwaltung ======
1)

**Vorteil**: Datenwörter liegen ausgerichtet im Speicher und können daher einfacher und schneller ausgelesen werden.


**Nachteil**: Nicht alle Speicherbereiche werden ausgenutzt, Speicherplatz wird dadurch verschwendet.

2)

<code>
name = 15 Byte + 1 Byte Alignment
vorname = 16 Byte
versuch = 2 Byte + 2 Byte Alignment
matnr. = 4 Byte
geschlecht = 1 Byte + 3 Byte Alignment
note = 4 Byte 
==  48 Byte
</code>

3)

<code>
48 * 8 = 384
(96 * 1024)/384 = 256
</code>

4)

**Little-Endian**: Das niederwertigste Byte steht an erster Stelle.

**Big-Endian**: Das höherwertigste Byte steht an erster Stelle.

5)

LE: 0x10 32 54 76

BE: 0x76 54 32 10

====== Aufgabe 6: Parallelverarbeitung ======
1)

Das Hochsprachprogramm unterscheidet sich nicht dabei

VLIW Parallele Alu Operationen ← Compiler

Superskalar ist es Pipelining ← Prozessor 

2)
<code>
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)

**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)

**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

Doppelte Komplexität = 1.4x Leistungszuwachs

Pollacks Regeln rückwärts angewandt: 

Statt einen großen Kern zwei kleinere, halb so große Kerne
(Rechen-)Leistung nimmt invers quadratisch ab
sqrt(1/2) = 70%

Somit mit halber Fläche 70% der Leistung das größeren Systems pro Kern
Aber nur noch halber Leistungsverbrauch pro Kern
In der Summe mehr (Rechen-)Leistung als vorher

2*70% = 140%

Bei gleichem Leistungsverbrauch für 2 Kerne wie beim großen System
Schlussfolgerung: einfacherer, aber dafür immer mehr Kerne

====== Aufgabe 7: Cache ======

1)

**Räumliche Lokalität**: Nach Zugriffe erfolgt in naher Zukunft erneut Zugriff auf __benachbarte__ Adresse.

**Zeitliche Lokalität**: Nach Zugriffe erfolgt in naher Zukunft erneut Zugriff auf __dieselbe__ Adresse.

2)
<code>
2048 Byte / 64 Byte = 32
</code>
Frühestens beim 33. Zugriff findet eine Verdrängung statt (Compulsory Miss).

3)

a)

Tag = 2^16

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>

b)

<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]]