Übungsklausur I
a)
not x4 and not x3 and x2 and x1
x3 and not x2
x4 and x1
x4 and not x3 and x2 and not x1
b) P1 und P4 sind auch Kernimplikanten
c)
c1) 1-Bit Komperator
b a a=b a<b a>b
0 0 1 0 0
0 1 0 1 0
1 0 0 0 1
1 1 1 0 0
c2) Halbaddierer
b a c s
0 0 0 0
0 1 0 1
1 0 0 1
1 1 1 0
d)
d1)
1010101b ^=
1 2^0 * 1 = 1 +
0 2^1 * 0
1 2^2 * 1 = 4 +
0 2^3 * 0
1 2^4 * 1 = 16 +
0 2^5 * 0
1 2^6 * 1 = 64 +
16+64 + 4 + 1 = 80 + 5 = 85
d2) 53d ^= xxx xxxb
53/2 = 26 Rest 1
26/2 = 13 Rest 0
13/2 = 6 Rest 1
6/2 = 3 Rest 0
3/2 = 1 Rest 1
1/2 = 0 Rest 1
110 101
d3) -7d ^= xxx xxxb
7d ^= 000 111b
Einerkomplement: 111 000b
Zweierkomplement: 111 001b
d4)
1101 1010b ^= xd
Einerkomplement: 1101 1001b
Invertiert: 0010 0110b
0 0*2^0 =
1 1*2^1 = 2
1 1*2^2 = 4
0 0*2^3 =
0 0*2^4 =
1 1*2^5 = 32
0 0*2^6 =
0 0*2^7 =
32+6 = 38
Also -38
Zustand Eingabe Ausgabe Folgezustand Code Folgezustand
z0+ z1+ z2+ z3+
0 0 0 2 0 0 1 0
0 1 1 1 0 1 0 0
1 0 0 3 0 0 0 1
1 1 1 2 0 0 1 0
2 0 1 1 0 1 0 0
2 1 0 3 0 0 0 1
3 0 1 0 1 0 0 0
3 1 0 2 0 0 1 0
z3+
Zustand Eingabe Ausgabe Folgezustand Code Folgezustand
z0+ z1+ z2+ z3+
1 0 0 3 0 0 0 1
2 1 0 3 0 0 0 1
z3+ <= (z1 and not x) or
(z2 and x);
z2+
Zustand Eingabe Ausgabe Folgezustand Code Folgezustand
z0+ z1+ z2+ z3+
0 0 0 2 0 0 1 0
1 1 1 2 0 0 1 0
3 1 0 2 0 0 1 0
z2+ <= (z0 and not x) or
(z1 and x) or
(z3 and x);
z1+
Zustand Eingabe Ausgabe Folgezustand Code Folgezustand
z0+ z1+ z2+ z3+
0 1 1 1 0 1 0 0
2 0 1 1 0 1 0 0
z1+ <= (z0 and x) or
(z2 and not x);
z0+
Zustand Eingabe Ausgabe Folgezustand Code Folgezustand
z0+ z1+ z2+ z3+
3 0 1 0 1 0 0 0
z0+ <= (z3 and not x);
y
Zustand Eingabe Ausgabe Folgezustand Code Folgezustand
z0+ z1+ z2+ z3+
0 1 1 1 0 1 0 0
1 1 1 2 0 0 1 0
2 0 1 1 0 1 0 0
3 0 1 0 1 0 0 0
y <= (z0 and x) or
(z1 and x) or
(z2 and not x) or
(z3 and not x);
z3+ <= (z1 and not x) or
(z2 and x);
z2+ <= (z0 and not x) or
(z1 and x) or
(z3 and x);
z1+ <= (z0 and x) or
(z2 and not x);
z0+ <= (z3 and not x);
y <= (z0 and x) or
(z1 and x) or
(z2 and not x) or
(z3 and not x);
Zustand
0/1
1/1
2/0
2/1
3/0
0/1 -0-> 2/0
0/1 -1-> 1/1
1/1 -0-> 3/0
1/1 -1-> 2/1
2/0 -0-> 1/1
2/1 -0-> 1/1
2/0 -1-> 3/0
2/1 -1-> 3/0
3/0 -0-> 0/1
3/0 -1-> 2/0
Zustand Eingabe Ausgabe Folgezustand Folgezustand Unär Codiert
z1+ z2+ z3+
z1 0 0 z2 0 1 0
z1 1 0 z2 0 1 0
z2 0 1 z3 0 0 1
z2 1 0 z2 0 1 0
z3 0 1 z1 1 0 0
z3 1 0 z2 0 1 0
z3+
Zustand Eingabe Ausgabe Folgezustand Folgezustand Unär Codiert
z1+ z2+ z3+
z2 0 1 z3 0 0 1
z3+ <= (z2 and not x);
z2+
Zustand Eingabe Ausgabe Folgezustand Folgezustand Unär Codiert
z1+ z2+ z3+
z1 0 0 z2 0 1 0
z1 1 0 z2 0 1 0
z2 1 0 z2 0 1 0
z3 1 0 z2 0 1 0
z2+ <= (z1 and not x) or
(z1 and x) or
(z2 and x) or
(z3 and x)
z1+
Zustand Eingabe Ausgabe Folgezustand Folgezustand Unär Codiert
z1+ z2+ z3+
z3 0 1 z1 1 0 0
z1+ <= (z3 and not x);
y
Zustand Eingabe Ausgabe Folgezustand Folgezustand Unär Codiert
z1+ z2+ z3+
z2 0 1 z3 0 0 1
z3 0 1 z1 1 0 0
y <= (z2 and not x) or
(z3 and not x);
z3+ <= (z2 and not x);
z2+ <= (z1 and not x) or
(z1 and x) or
(z2 and x) or
(z3 and x);
z1+ <= (z3 and not x);
y <= (z2 and not x) or
(z3 and not x);
c) Zustandsminimierung üben
Aufgabe I-3
a) In z2 hat A den Wert 3. Zunächst ein Mal muss geprüft werden, was der Initialwert ist. Er ist 0. Wäre dies nicht der Fall, würde die Prozedur nicht etwa endlos vollzogen. aber länger. Es würde solange dauern, bis die Breite des Registers A erreicht ist. Ab diesem Zeitpunkt fangen wir spätestens wieder bei 0 an. Im Schlimmmsten Fall, würden wir das Überlaufflag, oder das Übertragsflag von A in weitere Register Schreiben. Bei einer heute üblichen Maximal Breite von 64 GByte Arbeitsspeicher, würden wir irgendwann wieder da ankommen, wo wir hinwollen
Die Vorraussetzung wäre, dass der Übertrag aus der obersten Addresse im RAM nicht wieder als 1 in A geschrieben wird. Wovon hier allerdings nichts steht.
Die Verzweigung wird solange ausgeführt, solange A kleiner 3 ist. Das heisst, sie wird abgebrochen sobald A == 3 ist. Da keiner andere Anweisung hier steht, als
A <- A + 1
Also einem einfachen inkrement, wird das nach 3 Schritten der Fall sein
In Zustand Z2 hat B den Wert 1. Dafür gibt es einen Grund. Im selben Zustand findet die Anweisung B <- A statt, während A, allerdings imselben Zustand mit 5 initialisiert wird. Das ist eine Echte Datenabhängigkeit. Die es so nicht geben darf, nur unter einer Vorraussetzung, sie stört den Ablauf nicht. Bis dahin war A mit dem Wert 1 geladen. Deswegen trägt diesen Wert jetzt auch B
c1) Wie ich schon sagte, eine Multiplikation von B*A
Es wird solange Multipliziert, wie B gross ist. Und zwar A. Das entspricht B*A
Siehe Zeichnung
a) Klassen von Registern beim Prozessor
1.) Universalregister
2.) Addressregister
3.) Programmzähler (Zeiger und Addressregister)
4.) Stackpointer (Zeiger und Addressregister)
5.) Systemregister
6.) Instruction Register (kein direkter Zugriff, meistens)
7.) Flag Register
8.) Direction Table / Page Table
9.) E/A-Register ....
