Systemarchitektur

Transcrição

Systemarchitektur

Systemarchitektur-Skript
Dilyana Dimova
Mario Mancino
26. Juli 2004
Inhaltsverzeichnis
1
2
Einführung
1.1 Literaturhinweise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2 Definition: Rechnen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.3 Bool’sche Algebra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.3.1 ∼: {0, 1} −→ {0, 1} . . . . . . . . . . . . . . . . . . . . . . . . . .
n
1.3.2 ∧, ∨, ⊕ : {0, 1} −→ {0, 1} . . . . . . . . . . . . . . . . . . . . . .
1.4 Definition: Bool’sche Ausdrücke (vollständig geklammert) . . . . . . .
1.5 Exkurs: Mengen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.6 Exkurs: Induktionsbeweis . . . . . . . . . . . . . . . . . . . . . . . . . .
1.7 Rechnen mit bool’schen Algebren . . . . . . . . . . . . . . . . . . . . . .
1.7.1 Definition: Einsetzung . . . . . . . . . . . . . . . . . . . . . . . .
1.7.2 Definition: ϕ(e) für e ∈ BA . . . . . . . . . . . . . . . . . . . . .
1.7.3 Definition: Identität (Allgemeingültige Rechenregel) . . . . . .
1.7.4 Satz: Kommutativität . . . . . . . . . . . . . . . . . . . . . . . . .
1.8 Exkurs: Funktionen(6=Funktionssymbole) . . . . . . . . . . . . . . . . .
1.8.1 Definition: Relation . . . . . . . . . . . . . . . . . . . . . . . . . .
1.8.2 Definition: Funktion . . . . . . . . . . . . . . . . . . . . . . . . .
1.9 Erweiterung zu 1.7.2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.10 Konventionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.10.1 Abkürzungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.11 Definition: elementarer bool’scher Ausdruck . . . . . . . . . . . . . . .
1.12 Satz: Darstellungssatz . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.12.1 Beweis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.12.2 Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.13 Lösen einer Gleichung . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.13.1 Beispiel 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.13.2 Beispiel 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.13.3 Beweis: e1 ∧ . . . ∧ en = 1 ⇔ e1 = 1 ∧ . . . ∧ en = 1 . . . . . . . . .
1.13.4 Beweis: e1 ∨ . . . ∨ en = 1 ⇔ e1 = 1 ∨ . . . ∨ en = 1 . . . . . . . . .
1.14 Zusammenhang zwischen Identitäten und Lösungen von Gleichungen
1.15 Spezielle bool’sche Ausdrücke . . . . . . . . . . . . . . . . . . . . . . .
1.15.1 Definition: Literal, Monom, Polynom . . . . . . . . . . . . . . .
1.15.2 Bemerkung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.15.3 Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.16 Vollständig disjunktive Normalform . . . . . . . . . . . . . . . . . . . .
1.16.1 Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.17 Kosten der Darstellungssätze . . . . . . . . . . . . . . . . . . . . . . . .
1.17.1 Hilfssätze . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.17.2 Kosten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.18 Teure Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.18.1 Beweis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.18.2 Offene Fragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
1
1
1
1
2
2
2
2
3
3
3
4
4
4
5
5
5
5
5
6
6
6
7
7
7
7
7
8
8
8
8
9
9
9
10
10
10
10
11
11
Schaltpläne und Schaltkreise
2.1 Gatter . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.1.1 Beispiel-Gatter . . . . . . . . . . . . . . . . . . .
2.1.2 Einsetzung an den Eingängen angelegter Werte
2.1.3 Schwierigkeiten von Zyklen . . . . . . . . . . . .
2.1.4 Definition: Pfad . . . . . . . . . . . . . . . . . . .
2.2 Definition: Schaltkreis . . . . . . . . . . . . . . . . . . .
2.2.1 Hoffnung/Satz . . . . . . . . . . . . . . . . . . .
2.2.2 Beweis . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
12
12
12
13
13
14
14
14
14
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
14
15
15
15
15
17
18
18
19
20
20
Zahlendarstellung, Addieren (für ganze Zahlen)
3.1 Binärdarstellung . . . . . . . . . . . . . . . . . . .
3.1.1 Beispiel . . . . . . . . . . . . . . . . . . . .
3.1.2 Größe der Summe . . . . . . . . . . . . .
3.2 Satz: Eindeutigkeit der Binärdarstellung . . . . .
3.3 Definition: n-bit-Addierer . . . . . . . . . . . . .
3.4 1-bit Addierer / Volladdierer / Full Adder (FA)
3.4.1 Funktionstabelle . . . . . . . . . . . . . .
3.5 Peano Axiome . . . . . . . . . . . . . . . . . . . .
3.6 Zerlegung von Zahlendarstellungen . . . . . . .
3.7 Additionsalgorithmus . . . . . . . . . . . . . . .
3.7.1 Beweis: Induktion über i . . . . . . . . . .
3.8 Carry-Chain-Adder . . . . . . . . . . . . . . . . .
3.9 Definition: Multiplexer (Mux) . . . . . . . . . . .
3.9.1 1-bit Multiplexer Schaltkreis . . . . . . .
3.9.2 n-Mux . . . . . . . . . . . . . . . . . . . .
3.10 Conditional Carry Adder . . . . . . . . . . . . .
3.11 Exkurs: Modulo . . . . . . . . . . . . . . . . . . .
3.12 Subtraktion . . . . . . . . . . . . . . . . . . . . .
3.12.1 Beispiel . . . . . . . . . . . . . . . . . . . .
3.13 Two’s Complement Zahlen . . . . . . . . . . . .
3.13.1 Beispiel . . . . . . . . . . . . . . . . . . . .
3.14 Beweis: Subtraktion . . . . . . . . . . . . . . . . .
3.14.1 Lemma 1 . . . . . . . . . . . . . . . . . . .
3.14.2 Lemma 2 . . . . . . . . . . . . . . . . . . .
3.14.3 Lemma 3 . . . . . . . . . . . . . . . . . . .
3.14.4 Lemma 4 . . . . . . . . . . . . . . . . . . .
3.14.5 Lemma 5 . . . . . . . . . . . . . . . . . . .
3.14.6 Beweis der Subtraktion . . . . . . . . . .
3.15 Definition: n-bit-twoc-Addierer . . . . . . . . . .
3.16 Definition: Arithmetic Unit (AU) . . . . . . . . .
3.16.1 Erweiterung der Notation . . . . . . . . .
3.17 n-bit-twoc AU (auch für Binärzahlen) . . . . . .
3.17.1 Satz: Overflow . . . . . . . . . . . . . . .
3.17.2 Satz: Negation . . . . . . . . . . . . . . . .
3.18 Definition: Arithmetic Logic Unit (ALU) . . . . .
3.18.1 Steuerbit-Tabelle . . . . . . . . . . . . . .
3.18.2 Schaltkreis . . . . . . . . . . . . . . . . . .
3.18.3 akt: Overflow aktivieren/ignorieren . . .
3.18.4 xcc: Fixed Point Condition Code . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
21
21
21
22
22
22
23
23
23
24
25
25
26
27
27
28
28
29
29
29
30
30
30
30
30
31
31
32
32
32
32
33
34
35
35
35
36
36
37
37
2.3
2.4
2.5
3
2.2.3 Beispiel . . . . . . . . . . . . . . . .
2.2.4 Hilfssatz . . . . . . . . . . . . . . .
Satz: Darstellungssatz (Schaltkreise) . . .
2.3.1 Definitionen . . . . . . . . . . . . .
2.3.2 Beweis . . . . . . . . . . . . . . . .
Polynome als Schaltkreise . . . . . . . . .
Flache ∧ / ∨ Bäume . . . . . . . . . . . . .
2.5.1 Definition: Schaltkreise ∧-n . . . .
2.5.2 n keine Zweierpotenz . . . . . . .
2.5.3 Neue Berechnung von Polynomen
2.5.4 PLA: Programmed Logic Array . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
4
5
Prozessorbau
4.1 Mathematische Maschinen . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2 Speicherelemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2.1 Register (n-Bit) . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2.2 Random Access Memory (RAM) . . . . . . . . . . . . . . . . . .
4.3 Instruktionssatz des DLX0 -Prozessors . . . . . . . . . . . . . . . . . . .
4.3.1 Konfiguration . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3.2 Rechnung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3.3 3 Instruktionsformate . . . . . . . . . . . . . . . . . . . . . . . .
4.3.4 Definition: Signed Extension . . . . . . . . . . . . . . . . . . . .
4.3.5 GP R[05 ] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3.6 Instruktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3.7 Zusammenfassung: Instruktionen . . . . . . . . . . . . . . . . .
4.4 Hardware-Konfiguration . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.4.1 Unterteilung der Instruktionen in Stufen . . . . . . . . . . . . .
4.5 Beweis der Gleichheit zwischen DLX0 - und Hardware-Konfiguration
4.5.1 c0 comp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.5.2 adcomp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.5.3 aluoph . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.5.4 mw . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.5.5 ci .m = hi .m . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.5.6 GP R.w . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.5.7 P Cinc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.5.8 Spezifikation: n-Inc . . . . . . . . . . . . . . . . . . . . . . . . . .
4.5.9 nextP C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
38
38
39
39
40
41
41
41
42
43
43
43
45
45
46
47
48
49
50
50
51
51
52
52
53
Compiler für C0 (PASCAL mit C-Syntax)
5.1 Kontextfreie Grammatiken . . . . . . . . . . . . . . . .
5.1.1 Beispiel: Kontextfreie Grammatik . . . . . . .
5.1.2 Definition: Kontextfreie Grammatik . . . . . .
5.1.3 Arbeitsweise von Grammatiken . . . . . . . .
5.1.4 Weitere Definitionen . . . . . . . . . . . . . . .
5.1.5 Problem: Alternativer Ableitungsbaum . . . .
5.1.6 Definition: Eindeutigkeit von Grammatiken .
5.1.7 Satz: Grammatik G ist eindeutig . . . . . . . .
5.2 Aufbohren der Grammatik . . . . . . . . . . . . . . . .
5.2.1 Bool’sche Ausdrücke . . . . . . . . . . . . . . .
5.2.2 Komplexe Datentypen . . . . . . . . . . . . . .
5.2.3 Anweisungen . . . . . . . . . . . . . . . . . . .
5.2.4 Programm . . . . . . . . . . . . . . . . . . . . .
5.2.5 Deklarationen . . . . . . . . . . . . . . . . . . .
5.3 Semantik von C0 . . . . . . . . . . . . . . . . . . . . .
5.4 Deklarations-Teil . . . . . . . . . . . . . . . . . . . . .
5.4.1 Typen-Definition . . . . . . . . . . . . . . . . .
5.4.2 Variablen-Deklaration . . . . . . . . . . . . . .
5.4.3 Funktions-Deklaration . . . . . . . . . . . . . .
5.4.4 Speicher der C0 -Maschine . . . . . . . . . . . .
5.5 Zusammenfassung der Grammatik . . . . . . . . . . .
5.6 Ausdrucksauswertung . . . . . . . . . . . . . . . . . .
5.6.1 Definition: Bindungsfunktion(c, N a → (m, i))
5.6.2 Auswertung . . . . . . . . . . . . . . . . . . . .
5.7 Ausführung von Anweisungen . . . . . . . . . . . . .
5.8 Compilieren . . . . . . . . . . . . . . . . . . . . . . . .
5.8.1 Compiler . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
55
55
55
55
56
57
57
58
58
58
58
58
59
59
59
60
60
60
63
66
67
68
69
69
70
71
72
72
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
73
75
78
78
80
80
81
83
88
89
90
90
91
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
95
95
95
95
95
96
97
97
98
98
98
98
98
99
99
100
101
102
102
103
103
104
104
105
106
106
Betriebssystem-Kern
7.1 CVM: Syntax und Semantik . . . . . . . . . . . . . . . . . . . . . . .
7.1.1 Exkurs: Syntax von k . . . . . . . . . . . . . . . . . . . . . . .
7.1.2 Semantik von cp . . . . . . . . . . . . . . . . . . . . . . . . .
7.1.3 Semantik von Interrupts . . . . . . . . . . . . . . . . . . . . .
7.1.4 Formalismus zum Spefizieren der Handler von Kernel Calls
7.2 CVM mit I/O-Devices . . . . . . . . . . . . . . . . . . . . . . . . . .
7.2.1 Wiederholung: Interrupts . . . . . . . . . . . . . . . . . . . .
7.2.2 return . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.2.3 Kernel Calls . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.2.4 „User-Functions“ . . . . . . . . . . . . . . . . . . . . . . . . .
7.2.5 Devices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.3 Definition: C0A (C0 mit Assembler-Code) . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
107
107
108
109
109
110
111
111
112
112
114
115
116
5.9
6
7
5.8.2 Übersetzen der Bäume . . . . . . . . . . . . . . . . . . .
Codierung von C0 -Konfigurationen in DLX0 -Konfigurationen
5.9.1 Definition: Compiler - Korrektheit . . . . . . . . . . . .
5.9.2 Definition: abase . . . . . . . . . . . . . . . . . . . . . .
5.9.3 Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.9.4 Exkurs: Aho-Ullmann-Algorithmus . . . . . . . . . . .
5.9.5 Satz: Ahu-Ullmann . . . . . . . . . . . . . . . . . . . . .
5.9.6 g-Ausdrucksübersetzung . . . . . . . . . . . . . . . . .
5.9.7 r-Konsistenz . . . . . . . . . . . . . . . . . . . . . . . . .
5.9.8 c-Konsistenz . . . . . . . . . . . . . . . . . . . . . . . . .
5.9.9 Satz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.9.10 Pre-Order-Traversal . . . . . . . . . . . . . . . . . . . .
5.9.11 Code-Generierung . . . . . . . . . . . . . . . . . . . . .
Erweiterungen zur DLX0
6.1 DLX0 mit Interrupts . . . . . . . . . . . . . . . . .
6.1.1 Definition: Interrupt . . . . . . . . . . . . .
6.1.2 Grober Ablauf . . . . . . . . . . . . . . . . .
6.1.3 Klassifikation . . . . . . . . . . . . . . . . .
6.1.4 Interrupts des DLX0 . . . . . . . . . . . . .
6.1.5 Konfiguration / Register . . . . . . . . . . .
6.1.6 Definition: δ für DLX0 mit Interrupts . . .
6.1.7 Neue Instruktionen . . . . . . . . . . . . . .
6.1.8 Interrupts . . . . . . . . . . . . . . . . . . .
6.1.9 Definition: nicht sichtbar . . . . . . . . . . .
6.1.10 Definition: JISR-Signal (Jump ISR) . . . . .
6.1.11 Definition: Interrupt Level . . . . . . . . . .
6.1.12 Delta-Funktion . . . . . . . . . . . . . . . .
6.1.13 Aufbau der ISR . . . . . . . . . . . . . . . .
6.1.14 Devices & I/O (Geräte & E/A) . . . . . . .
6.1.15 Beispiel: Hard Disk (HD) . . . . . . . . . .
6.2 Virtueller Speicher(VM) . . . . . . . . . . . . . . .
6.2.1 Motivation . . . . . . . . . . . . . . . . . . .
6.2.2 Vergleich zweier Maschinen . . . . . . . . .
6.2.3 DLX0 mit Interrupts & Adress Translation
6.2.4 Page Table Lookup . . . . . . . . . . . . . .
6.2.5 Page Fault Exception . . . . . . . . . . . . .
6.2.6 Instruktionsausführung . . . . . . . . . . .
6.2.7 Simulation . . . . . . . . . . . . . . . . . . .
6.2.8 Theorem . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
7.4
Konkreter Kern K . . . . . . . . . . . . . . . . . .
7.4.1 Semantik . . . . . . . . . . . . . . . . . . .
7.4.2 Restriktionen an asm(s) . . . . . . . . . .
7.4.3 Datenstrukturen des konkreten Kerns K
7.5 Simulationssatz . . . . . . . . . . . . . . . . . . .
7.5.1 Definition: konsis(cc, kbase, c) . . . . . .
7.5.2 Definition: e − konsis(c, kbase, cc) . . . .
7.5.3 Definition: p − konsis(c, kbase, cc) . . .
7.5.4 Definition: c − konsis(c, cc) . . . . . . . .
7.6 Korrekturen . . . . . . . . . . . . . . . . . . . . .
7.6.1 Notation: body(. . . , . . .) . . . . . . . . . . .
7.7 body(main, k) . . . . . . . . . . . . . . . . . . . .
7.8 body(main, K) . . . . . . . . . . . . . . . . . . .
7.9 Definition: c − consis(c, cc) . . . . . . . . . . . .
7.10 Bootstrap . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
117
117
118
119
121
121
121
122
122
123
123
124
124
124
125
1 EINFÜHRUNG
1
1 Einführung
1.1
Literaturhinweise
• S.M. Müller, W.J. Paul: Computer Architecture (Springer 2000)
• J. Keller, W.J. Paul: Hardware Design (vergriffen)
• G.Even: Skript
1.2
Definition: Rechnen
Rechnen:
Beispiel:
Definition:
Ziel:
Kalkül:
Variablen:
(Hoffentlich sinnvolle) Manipulation von Zeichenreihen
Hardware
n
Schaltfunktion f : {0, 1} −→ {0, 1}
Bauen von Boxen, die Schaltfunktionen berechnen
Bool’sche Algebra
V = {x0 , x1 , x2 , . . .}
1.3
Bool’sche Algebra
1.3.1
∼: {0, 1} −→ {0, 1}
x
0
1
1.3.2
∼x
1
0
n
∧, ∨, ⊕ : {0, 1} −→ {0, 1}
x0
0
0
1
1
x1
0
1
0
1
x0 ∧ x1
0
0
0
1
x0 ∨ x1
0
1
1
1
x0 ⊕ x1
0
1
1
0
1 EINFÜHRUNG
1.4
2
Definition: Bool’sche Ausdrücke (vollständig geklammert)
1. B0 = V ∪ {0, 1}
2. e1 , e2 ∈ Bi ⇒ e1 , e2 ∈ Bi+1
(∼ e1 ) ∈ Bi+1
e1 ∧ e2 ∈ Bi+1
e1 ∨ e2 ∈ Bi+1
e1 ⊕ e2 ∈ Bi+1
( sonst nichts in Bi+1 )
3. BA =
Beispiel:
S∞
i=0
Bi
(x1 ∧ ((∼ x2 ) ∨ x3 )) ∈ BA
Beweis:
x1 , x2 , x3 ∈ V ⊆ B0 , B1 , B3 , . . .
(∼ x2 ) ∈ B1 , B2 , . . .
((∼ x2 ) ∨ x3 ) ∈ B2 , . . .
(x1 ∧ ((∼ x2 ) ∨ x3 )) ∈ B3 , . . . ⊆ BA
1.5
Exkurs: Mengen
M: Menge, n ∈ N
Mn = {(a1 , . . . , an ) |ai ∈ M }
Beispiel:
M = {0, 1}
M1 = {(0), (1)}
M2 = {(0, 0), (0, 1), (1, 0), (1, 1)}
M3 = {(0, 0, 0), (0, 0, 1), . . .}
1.6
Exkurs: Induktionsbeweis
A(n): Aussage
1. Zeige A(1)
2. Zeige A(n) → A(n+1)
3. Schliesse: A(n) für alle n ∈ N
1.7
Rechnen mit bool’schen Algebren
Beispiel:
x1 ∧ x2 = x2 ∧ x1
((x1 ∧ x2 ) ∧ x3 ) = (x1 ∧ (x2 ∧ x3 ))
1 EINFÜHRUNG
1.7.1
3
Definition: Einsetzung
ϕ : V → {0, 1}
Intuition: setze für xi Werte ϕ(xi ) ein.
Beispiel:
x1
x2
x3
1.7.2
ϕ
0
1
0
Definition: ϕ(e) für e ∈ BA
ϕ(0) = 0
ϕ(1) = 1
ϕ(e1 ∧ e2 ) = ϕ(e1 ) ∧ ϕ(e2 )
ϕ(e1 ∨ e2 ) = ϕ(e1 ) ∨ ϕ(e2 )
ϕ(e1 ⊕ e2 ) = ϕ(e1 ) ⊕ ϕ(e2 )
ϕ(∼ e) =∼ ϕ(e)
Beispiel:
e = (x1 ∧ ((∼ x2 ) ∨ x3 ))
ϕ(x1 ) = 0
ϕ(x2 ) = 1
ϕ(x3 ) = 0
Einsetzung:
ϕ(∼ x2 )
= ∼ ϕ(x2 )
= ∼1
= 0
ϕ((∼ x2 ) ∨ x3 )
ϕ(e)
= ϕ(∼ x2 ) ∨ ϕ(x3 )
= 0∨0
= 0
= ϕ(x1 ) ∧ ϕ((∼ x2 ) ∨ x3 )
= 0∧0
= 0
1.7.3
Definition: Identität (Allgemeingültige Rechenregel)
e1 , e2 ∈ BA:
e1 ≡ e2 ⇔ ϕ(e1 ) = ϕ(e2 ) f ür alle ϕ
1 EINFÜHRUNG
1.7.4
4
Satz: Kommutativität
x1 ∧ x2 = x2 ∧ x1
x1 ∨ x2 = x2 ∨ x1
x1 ⊕ x2 = x2 ⊕ x1
Beweis: trivial durch Ausprobieren aller Fälle.
Rechenregeln:
(x1 ∧ x2 ) ∧ x3 = x1 ∧ (x2 ∧ x3 )
x1 ∧ (x2 ∨ x3 ) = (x1 ∧ x2 ) ∨ (x1 ∧ x3 )
1.8
Exkurs: Funktionen(6=Funktionssymbole)
Seien X,Y Mengen, dann gilt:
X × Y = {(x, y)|x ∈ X, y ∈ Y }
Beispiel:
{0, 1}2
{0, 1}3
{0, 1}3
{0, 1} × {0, 1}2
1.8.1
= {0, 1} × {0, 1}
6
=
{0, 1} × {0, 1}2
= {(0, 0, 0), (0, 0, 1), . . .}
= {(0, (0, 0)), (0, (0, 1)), . . .}
Definition: Relation
R ⊂ X × Y : Relation
z.B.: X = Y = R, R = {(x, y)|x ≥ y}
R
Abbildung 1: Relation
1 EINFÜHRUNG
1.8.2
5
Definition: Funktion
Die Funktion ist eine spezielle (Rechtseindeutige) Relation:
(x, y1 ) ∈ R
(x, y2 ) ∈ R
⇒
y1 = y2
Der Funktion liegt eine Funktionstabelle zugrunde, fi ist nur ein Name dafür.
1.9
Erweiterung zu 1.7.2
ϕ(f (e1 , . . . , es )) =Def f (ϕ(e1 ), . . . , ϕ(es )))
1.10
Konventionen
Um Schreibarbeit zu sparen, vereinbart man:
∼ bindet stärker als ∧
∧ bindet stärker als ∨
1.10.1
Abkürzungen
ē ist Abkürzung für (∼ e)
/e ist Abkürzung für (∼ e)
xi xj ist Abkürzung für xi ∧ xj
= ist Abkürzung für ≡
x[n : 1] ist Abkürzung für (xn , . . . , x1 )
1.11
Definition: elementarer bool’scher Ausdruck
Ein elementarer bool’scher Ausdruck, in dem ∧, ∨, ∼ verwendet werden.
ElBA = {e ∈ BA|e elementar} = alte Def inition
1 EINFÜHRUNG
1.12
6
Satz: Darstellungssatz
∀ f : {0, 1}n → {0, 1} ∃ e elem. B.A. mit :
e ≡ f (x1 , . . . , xn )
1.12.1
Beweis
Beweis per Induktion über n:
n=0:
f : {0, 1}0 → {0, 1}
| {z }
φ
⊆ φ × {0, 1}
Konvention: 0,1:{0, 1}0 → {0, 1}
n=1:
Funktionstabelle:
x1
0
1
e
f1
0
0
0
f2
1
1
1
f3
1
0
x1
f4
0
1
x1
n →n+1:
f (x1 , . . . , xn+1 ) = xn+1 ∧ f (x1 , . . . , xn , 1) ∨ xn+1 ∧ f (x1 , . . . , xn , 0)
1.12.2
Beispiel
x1
0
0
x2
0
0
x3
0
1
f (x3 , x2 , x1 )
0
1
f (0, x2 , x1 )
0
1
0
0
1
1
0
1
1
0
1
1
0
0
0
1
1
1
1
0
z
}|
{
e0 = x2 x1 ∨ x2 x1
f (1, x2 , x1 )
1
1
1
1
1
1
0
1
1
0
1
0
z
}|
{
e0 = x2 ∧ 1 ∨ x2 x1
f (0, 0, x1 )
0
1
z}|{
x1
f (0, 1, x1 )
1
0
z}|{
x1
f (1, 0, x1 )
1
1
z}|{
1
f (1, 1, x1 )
1
0
z}|{
x1
1 EINFÜHRUNG
1.13
7
Lösen einer Gleichung
Einsetzung mit ϕ(e) = ϕ(e′ ) heißt Lösen der Gleichung.
1.13.1
Beispiel 1
Sei e ein elementarer bool’scher Ausdruck.
e=1
Lösung: Einsetzen von ϕ mit:
ϕ(e) = ϕ(1) = 1
ϕ(e) =∼ ϕ(e) = 1 ⇔ ϕ(e) = 0
d.h.
⇔
ϕ Lösung von e = 1
Dies wird abgekürzt als e = 1 ⇔ e = 0
1.13.2
Beispiel 2
Seien e, e’ elementare bool’sche Ausdrücke.
e ∧ e’ = 1
Sei ϕ Lösung:
ϕ(e ∧ e′ ) = ϕ(1) = 1
ϕ(e) ∧ ϕ(e′ ) ⇔ ϕ(e) = 1 ∧ ϕ(e′ ) = 1
⇔
und
1.13.3
ϕ Lösung von e=1
ϕ Lösung von e’=1
Beweis: e1 ∧ . . . ∧ en = 1 ⇔ e1 = 1 ∧ . . . ∧ en = 1
Induktion über n:
n=2:
e1 = e
e2 = e′
(eben in 1.13.1 und 1.13.2 gemacht) n→n+1:
e1 ∧ . . . ∧ en−1 ∧ en = 1 ⇔ e1 ∧ . . . ∧ en−1 = 1 und en = 1
|
{z
} |{z}
{z
}
|
e
1.13.4
e′
⇔e1 =1∧...∧en−1 =1
Beweis: e1 ∨ . . . ∨ en = 1 ⇔ e1 = 1 ∨ . . . ∨ en = 1
Der Beweis läuft analog zu 1.13.3.
1 EINFÜHRUNG
1.14
8
Zusammenhang zwischen Identitäten und Lösungen von Gleichungen
Seien e, e’ elementare bool’sche Ausdrücke.
z
Lösung von e=1, e′ =1
∀ϕ :
⇔
|
}|
{
ϕ Lösung von e′ = 1
ϕ(e) = 1
ϕ(e) = 0
⇔
⇔
{z
ϕ(e′ ) = 1
ϕ(e′ ) = 0
e≡e′
Um e ≡ e’ zu zeigen, genügt es zu zeigen:
Gleichung e=1 und e’=1 haben gleiche Lösungen - Kurz:
e=1 ⇔ e’=1
e ≡ e’
e=1 ⇔ e’=1
1.15
Spezielle bool’sche Ausdrücke
1.15.1
Definition: Literal, Monom, Polynom
⇔
Seien x1 , x2 , . . . , xn Variablen.
Ausdruck L heißt Literal:
⇔ L = xi für ein xi
Ausdruck M heißt M onom:
⇔ M = L1 ∧ . . . ∧ Ls für ein s und Literale Li . . . Ls
Ausdruck P heißt P olynom:
⇔ P = M1 ∨ . . . ∨ Lt für ein t und Monome Mi . . . Ms
1.15.2
Bemerkung
Gleichungen
L=1
M =1
P =1
können wir lösen.
Notation:
ǫ ∈ {0, 1}
½
xi : ǫ = 1
xǫi =
xi : ǫ = 0
xǫi = 1 ⇔ xi = ǫ
}
1 EINFÜHRUNG
1.15.3
9
Beispiel
Sei a = a[n : 1] ∈ {0, 1}n , a 7→ M (a) =Def. xann ∧ . . . ∧ xa1 1
|
{z
}
(M onom)
n=3, a=101:
M (a)
=
=
x13 ∧ x02 ∧ x11
x3 x2 x1
M (a) = 1 ⇔ xai i = 1 f ür alle i
⇔ xi = ai f ür alle i
⇔
x[n : 1] = a[n : 1]
M (a) = 1 ⇔ x = a
1.16
Vollständig disjunktive Normalform
Sei f : {0, 1}n → {0, 1}
T (f ) = {a ∈ {0, 1}n |f (a) = 1}
|
{z
}
(T räger von f )
_
T (f ) 7→ P (f ) =
|
M (a) (P olynom)
a∈T (f )
{z
}
(V ollständig disjunktive N ormalf orm von f )
P (f ) = 1
⇔ es gibt a ∈ T (f ) : M (a) = 1
⇔ es gibt a ∈ T (f ) : x = a
⇔
x ∈ T (f )
⇒ P (f ) ≡ f
(Neuer Beweis des Darstellungssatzes)
1.16.1
Beispiel
x3
0
0
0
0
1
1
1
1
T(f)={
000
↓
M(000)
=
x3 x2 x1
,
011
↓
M(011)
=
x3 x2 x1
,
100
↓
M(100)
=
x3 x2 x1
x2
0
0
1
1
0
0
1
1
,
x1
0
1
0
1
0
1
0
1
101
↓
M(101)
=
x3 x2 x1
f (x)
1
0
0
1
1
1
0
1
,
111
↓
M(111)
=
x3 x2 x1
}
≡
f (x3 , x2 , x1 )
1 EINFÜHRUNG
1.17
10
Kosten der Darstellungssätze
C(e) = Anzahl Vorkommen von ∧, ∨, ∼ in e (Kosten)
G(e) = größte auftretende Kosten für ein f : {0, 1}n → {0, 1}
1.17.1
Hilfssätze
#M = Anzahl der Elemente in M (Mächtigkeit von M)
#(M × N ) = #M · #N
#(M N ) = (#M )N ⇒ #{0, 1}n = (#{o, 1}n = 2n
1.17.2
Kosten
W
1. f (x) ≡ a∈T m(a)
vollständige disjunktive Normalform, Kosten:
G(f ) ≤ 2n · 2n
2. f (x[n : 1]) = xn · f (1, x[n − 1 : 1]) ∨ xn · f (0, x[n − 1 : 1])
Differenzengleichung:
G(1)
G(n)
=
=
1
4 + 2 · · · G(n-1)
geraten (k=n-1):
G(n)
= 2k · · · G(n − k) + 2k+1 + 2k + . . . + 4
= 2n−1 · · · G(1) + 2n + 2n−1 + . . . + 4 + (+2 + 1 −3)
|
{z
}
2n+1 −1
=
=
1.18
n+1
n−1
2
+2
−4
n−1
5...2
−4
Teure Funktionen
Gibt es f : {0, 1}n → {0, 1} für das gilt: Jedes e, das f berechnet ist teuer?
Ja:
• Jedes e berechnet eine Funktion
• Die Menge der billigen Ausdrücke ist klein
⇒ {f |∃: e billig und e berechnet f } ist klein, {f : [0, 1]n → {0, 1}} ist groß
1 EINFÜHRUNG
1.18.1
11
Beweis
Sei e ein elementarer bool’scher Ausdruck.
A = {x1 , . . . , xn , (, ), ∧, ∨, ∼, , 0, 1}
#A = n + 8
22
n
= #{f |f : {0, 1}n → {0, 1}}
≤ #{e|G(e) ≤ k}
#(A5k
(n + 8)5k
=
=
k : ∀f : {0, 1}n → {0, 1} ∃e : e ≡ f (x)
G(e) ≤ k
k≥
1.18.2
Offene Fragen
• Wie sehen f aus, für die jedes e teuer ist?
⊕ erlauben?
A = {x1 , . . . , xn , (, ), ∧, ∨, ∼, , 0, 1, ⊕}
#A = n + 9
2n
k≥
5 · log(n + 9)
• Bool’sches Polynom p:
Hat die Gleichung p=0 eine Lösung?
Gibt es ein schnelles Rechenverfahren?
P = NP?
2n
5 · log(n + 8)
2 SCHALTPLÄNE UND SCHALTKREISE
12
2 Schaltpläne und Schaltkreise
2.1
Gatter
Eingänge:
Gatter:
Ausgänge:
x1 x2
Box zur Berechnung von Schaltfunktionen
y1 . . . yn (Kabel, Leitungen)
,
.
Å
~
,-Gatter
. -Gatter
Å-Gatter
Inverter
Abbildung 2: Gatter-Symbole
2.1.1
Beispiel-Gatter
x1
x2
A
B
C
D
Abbildung 3: Schaltkreis - XOR Gatter
x1
0
0
1
1
x2
0
1
0
1
A
1
0
1
0
B
1
1
0
0
C
0
0
1
0
G ≡ x1 ⊕ x2
D
0
1
0
0
E
0
1
1
0
2.1.2
13
Einsetzung an den Eingängen angelegter Werte
ϕ : {x1 , . . . , xn } → {0, 1}
Z’, Z”: Eingänge des Gatters in Schaltung S
Z: Ausgang eines Gatters in Schaltung S
f: berechnete Funktion des Gatters in Schaltung S
Abbildung 4: Eingänge des Gatters
ϕ(Z)
ϕ(Z)
2.1.3
= f (ϕ(Z ′ ), ϕ(Z ′′ ))

 ϕ(Z ′ ) ∧ ϕ(Z ′′ ) :
ϕ(Z ′ ) ∨ ϕ(Z ′′ ) :
=

ϕ(Z ′ ) ⊕ ϕ(Z ′′ ) :
f =∧
f =∨
f =⊕
= ∼ ϕ(Z ′ )
Schwierigkeiten von Zyklen
1
Abbildung 5: Schaltkreis - Zyklen-Problem
ϕ(A) = 1 ⇒ ϕ(B) = 0 ⇒ ϕ(A) = 0!
ϕ(A) = 0 ⇒ ϕ(B) = 1 ⇒ ϕ(A) = 1!
Abbildung 6: Schaltkreis - AND Flip-Flop
Bei beiden Beispielen ergeben sich Probleme, da in den jeweiligen Gattern mit den Untergattern
G1 , . . . , GS von einem Untergatter Gn zu einem vorherigen Gatter Gn−k (0 < k < n) gesprungen wird.
2.1.4
14
Definition: Pfad
Der Pfad wird definiert durch:
G1 → G2 → . . . → GS
Dabei ist S die Länge das Pfades.
2.2
Definition: Schaltkreis
Ein Schaltkreis ist eine Schaltung in der keine Zyklen vorkommen dürfen.
2.2.1
Hoffnung/Satz
Wir hoffen ein Schaltkreis ist für alle Z mit Z = Eingang oder Z = Ausgang eines Gatters ϕ(Z) wohldefiniert.
2.2.2
Beweis
Induktion über die Tiefe zwischen Z und den Eingängen.
Die Tiefe von einem Gatter ist die Länge eines längsten Pfades von den Eingängen zu G:
Abbildung 7: Tiefe (Formal)
T ief e(G) = max{T ief e(G′ ), T ief e(G′′ )} + 1
2.2.3
Beispiel
x1
x2
1
1
2
2
3
Abbildung 8: Schaltkreis - XOR-Gatters (Tiefe)
T ief e(G) = max{T ief e(G′ ), T ief e(G′′ )} + 1
2.2.4
15
Hilfssatz
In einem Schaltkreis hat jedes Gatter eine Tiefe.
Beweis:
Annahme:
d.h.:
Gatter G in Schaltkreis S hat keine Tiefe:
∀ t ∃ Pfad von den Eingängen zu G mit Länger ≥ t
x1 → G1 → . . . → Gt → G
Sei S endlich, E = #Gatter in S, t > E
⇒
Gatter wiederholt sich ⇒ Zyklus !
Um zu beweisen, dass ϕ wohldefiniert ist, bedient man sich einer Induktion über die Tiefe(G).
2.3
Satz: Darstellungssatz (Schaltkreise)
∀ f : {0, 1}n → {0, 1} ∃ Schaltkreis S : S berechnet f
2.3.1
Definitionen
S berechnet f, f alls ∃ Leitung u in S :
u ≡ f (x1 , . . . , xn )
K(S) = #Gatter von S
(Kosten)
T (S) = max{T ief e(G) | G ist Gatter in S}
2.3.2
Beweis
Sei e bool’scher Ausdruck.
Behauptung:
∃ Schaltkreis S
∃ Leitung u in S: u ≡ e
Induktion über i:
e ∈ BAi
e ∈ BA0
e ∈ {0, 1, x1 , . . . , xi }
0,1 erlauben wir als Eingänge von jedem Schaltkreis:
16
i → i+1:
◦ ∈ {∧, ∨, ⊕}
e′ , e′′ ∈ BAi
1. e = e′ ◦ e′′
Bus der Breite n
Abkürzung für:
n
x[1:n]
x1
S(e'')
S(e')
xn
u
Abbildung 9: Schaltkreise - Darstellungssatz (Binäre Operationen)
2. e =∼ e′
n
x[1:n]
S(e')
u
Abbildung 10: Schaltkreise - Darstellungssatz (Negation)
Bemerkung: K(S(e)) = G(e)
2.4
17
Polynome als Schaltkreise
Sei e Polynom:
e = M1 ∧ . . . ∧ M t
Mi = Li1 ∧ . . . ∧ Mij
Mik = {x1 , . . . , xn , x1 , . . . , xn }
Zur Berechnung aller Literale reichen n Inverter.
x1
_
x1
xn
_
xn
Ve r b i n d e m i t L e i t u n g e n
Lij die zu Monom Mi
gehören
M1 M2
M2
Abbildung 11: Schaltkreise - Polynom
T ief e
leq
leq
1 + max{j, i} + t − 2
1 + +n + 2n − 2
langsam!
Mt
2.5
Flache ∧ / ∨ Bäume
2.5.1
Definition: Schaltkreise ∧-n
18
n=1:
x0
T (∧1 ) = 0
n=2:
x0 x1
Abbildung 12: Schaltkreise - ∧ − 2 Baum
T (∧2 ) = 1
n
2
→n:
x[n-1:n/2]
n/2
x[n/2-1:0]
n/2
Abbildung 13: Schaltkreise - ∧ − n Baum
T (∧n ) = T (∧n/2 ) + 1 = log2 n
Es gilt u ≡ v wegen Assoziativität von ∧.
19
n
xn-1
x0
n
u
v
Abbildung 14: Vergleich - ∧−Reihe / ∧ − n Baum
2.5.2
n keine Zweierpotenz
Falls n keine Zweierpotenz ist:
n = n′ + k
n
2
≤ n′
=
k
max{2i |2i ≤ n}
= n − n′
n
≤
2
In diesem Fall sieht ∧n so aus:
n'
k
Abbildung 15: Schaltkreise - ∧ − n Baum, falls n keine Zweierpotenz ist
2.5.3
20
Neue Berechnung von Polynomen
Tiefe ≤
x1
_
x1
xn
_
xn
1
+
⌈log2 n⌉
j(i)
+
M1
Mt
Mi
⌈log2 n⌉
t
t ≤ 2n ≤ n + log2 n + 2
2.5.4
PLA: Programmed Logic Array
Verwendung zur Realisierung sogenannter „random logic“:
Es werden keine Regelmäßigkeiten der Funktionstabelle ausgenutzt (Zufall = Abwesenheit von Regelmäßigkeiten)
3 ZAHLENDARSTELLUNG, ADDIEREN (FÜR GANZE ZAHLEN)
3 Zahlendarstellung, Addieren (für ganze Zahlen)
b[n-1:0]
a[n-1:0]
n
n
Abbildung 16: Addierer
Kodierung der Eingänge?
Addierer-Schaltkreis?
Kodierung der Summe?
3.1
Binärdarstellung
Binärdarstellungen:
a ∈ {0, 1}n = {0, 1} ∨ {0, 1}2 ∨ . . .
Dargestellte Zahl:
a ∈ {0, 1}n
a = a[n − 1 : 0] = an−1 . . . a0
Definition:
<a>=
⇒
Pn−1
<a> =
i=0
n−1
X
ai · 2i
ai · 2i
i=0
≤
n−1
X
2i
i=0
=
3.1.1
2n − 1
Beispiel
< 101 > = 1 · 22 + 0 · 21 + 1 · 20
= 4+0+1
=
5
21
3.1.2
22
Größe der Summe
Sei S = C 0 + C 1 + . . . + C n−1 (C = 2):
= C 1 + . . . + C n−1 + C n
S·C
= Cn − C0
S · (C − 1)
= Cn − 1
Cn − 1
C −1
= 2n − 1(f alls c = 2)
⇒< a > + ≤ (2n − 1) · 2
S
=
< 2n+1 − 1
Hoffnung:
∃ S ∈ {0, 1}n+1
mit < S > = < a > + 
3.2
Satz: Eindeutigkeit der Binärdarstellung
< >: {0, 1} → {0, . . . , 2n − 1} ist bijektiv (Beweis: Übungsblatt, Hinweis: ∨-Baum → ∨-Gatter-Platzierung)
D.h. jede Zahl aus {0, . . . , 2n − 1} hat eine eindeutige Binärdarstellung der Länge n.
3.3
Definition: n-bit-Addierer
Schaltkreis:
a[n-1:0]
b[n-1:0]
n
cin
n
1
n+1
S[n:0]
Abbildung 17: n-bit Addierer
mit:
< s > = < a > + + cin
3.4
1-bit Addierer / Volladdierer / Full Adder (FA)
a
b
cin
S0
S1
Abbildung 18: Schaltkreis - 1-bit Addierer
3.4.1
Funktionstabelle
a
0
0
0
0
1
1
1
1
3.5
b
0
0
1
1
0
0
1
1
cin
0
1
0
1
0
1
0
1
S1
0
0
0
1
0
1
1
1
S0
0
1
1
0
1
0
0
1
Peano Axiome
N achf olgerf unktion N : N0 → N0
0 ∈ N0
0 ist eine (natürliche) Zahl.
∀ x ∈ N0 ∃ < ∈ N0 : y = N (x)
Jede natürliche Zahl hat einen Nachfolger.
¬ ∃ y : 0 = N (j)
0 ist nicht Nachfolger einer Zahl.
x 6= y ⇔ N (x) 6= N (y)
Sind zwei natürliche Zahlen verschieden dann haben sie verschiedene Nachfolger, d.h aus x 6= y folgt
x + 1 6= y + 1.
23
Definition:
N (x) = x + 1
N (0)
N (1)
=
=
1
2
N (N (N (0)))
=
2·1+1
= N (N (0)) + N (0)
= (1 + 1) + 1
Defintion ·
x...0
x · (y + 1)
x · (0 + 1)
=
=
=
0
x·y+x
x · 0 +x
|{z}
0
=
Defintion +
x·1
(1 + 1)1̇
3.6
=
=
x
1+1
Zerlegung von Zahlendarstellungen
a ∈ {0, . . . , B − 1}n (z.B. B = 10)
< a >B
=
< 101 >10
=
=
n−1
X
ai B i
i=0
=
1 · 102 + 0 · 101 + 1 · 100
(1 + 1) + 1
101????
Konvention:
Ziffernfolge ∈ {0, . . . , 9} - Standardinterpretation: a = a10
a = an−1 · . . . · ak · ak−1 · . . . · a0
< a[n − 1 : 0] >B = < a[n − 1 : k] >B ·B k + < a[k − 1 : 0] >B
B = 10, k = 3:
24197 = 24 · 103 + 197
24
3.7
25
Additionsalgorithmus
Summanden:
a = a[n − 1 : 0] ∈ {0, 1}n
b = b[n − 1 : 0] ∈ {0, 1}n
c = c−1
1
(c1 = 1)
1
1
1
(c0 = 1)
0
1
0
(cin = 0)
1
1
0
c−1
< c1 , Si >
Sn
c
a
c : Übertrag von Stelle i nach Stelle i+1
b i
S
=
=
=
cin
ai + bi + ci+1
cn−1
Satz:
∀ i < a[i : 0] > + < b[i : 0] > + cin = < ci , S[i : 0] >
3.7.1
Beweis: Induktion über i
i = 0:
< a0 > + < b0 > +cin
=
a0 + b0 +
| {z }
Def.: < >
=
< c ,S >
| 0{z 0 }
Def.: cin
Def.: <c0 ,S0 >
c = c−1
c−1
|{z}
i − 1 → i:
< a[i : 0] > + < b[i : 0] > +cin
= ai · 2i + < a[i − 1 : 0] > +bi · 2i + < b[i − 1 : 0] > + cin
|
{z
}
Zerlegung
= ai · 2i + bi · 2i + < ci−1 , S[i − 1 : 0] >
|
{z
}
Induktionsvorraussetzung
= ai · 2i + bi · 2i + ci−1 · 2i + < S[i − 1 : 0] >
{z
}
|
Zerlegung n=k=i
=
i
(ai + bi + ci−1 ) · 2 + < S[i − 1 : 0] >
{z
}
|
Distributivgesetzt
=
< ci , si > ·2i
|
{z
}
+ < S[i − 1 : 0] >
Def.: Additionsschritt
= < ci , si , S[i − 1 : 0] >
{z
}
|
Zerlegung n=i+1, k=i
= < ci , S[i : 0] >
3.8
Carry-Chain-Adder
a0 b0 cin
FA
a0 b0
c0
S0
FA
c1
an-1 bn-1
S1
FA
Sn
Sn-1
Abbildung 19: Carry-Chain-Adder
Kosten = n · K(F A)
Tiefe ≤ n · T (F A)
Für alle n-bit Addierer:
Tiefe ≥ log(2n)
26
3.9
Definition: Multiplexer (Mux)
x
y
n
n
S
(Select Signal)
z
Abbildung 20: Multiplexer
z=
3.9.1
½
x
y
: S=0
: S=1
1-bit Multiplexer Schaltkreis
x
y
S
z
Abbildung 21: 1-bit Multiplexer Schaltkreis
z = xs ∧ ys
27
3.9.2
28
n-Mux
xn-1
x0
yn-1
y0
S
1-Mux
1-Mux
zn-1
z0
Abbildung 22: n-bit Multiplexer
x
y
n
n
1
0
S
z
Abbildung 23: Multiplexer Symbol
3.10
Conditional Carry Adder
Definition von Schaltkreis An (A1 = F A):
ah
al
bh
n/2
bl
n/2
n/2
n/2
1
An/2
An/2
n/2+1
0
cin
0
cn/2
n/2-1
1
S[n:n/2]
Abbildung 24: Conditional Carry Adder
An/2
n/2
S[n/2-1:0]
Tiefe:
T (A1 ) = T (F A)
T (An ) = T (An/2 ) + T (M ux)
| {z }
3
⇒ T (An ) = O(log n)
3.11
Exkurs: Modulo
(u mod v = Rest bei Division durch v ∈ {0, . . . , v − 1}
u ≡ u′ mod v ⇔ (u mod v) = (u′ mod v)
Division mit Rest bei u < 0?
u = a · v + b ; a ∈ Z, b ∈ {0, . . . , v − 1}
3.12
Subtraktion
Notation:
x[n− : 0]
x = (xn−1 , . . . , x0 )
n
Subtraktionsalgorithmus: x, y ∈ {0, 1}
< x > − < y > = (< x > + < y > +1) mod 2n
3.12.1
Beispiel
n=4:
1
-
0
1
1
0
1
1
0
Regel
→
+
+
1
1
1
0
1
1
0
0
0
1
1
1
1
1
0
1
1
1
mod 2
29
3.13
Two’s Complement Zahlen
x ∈ {0, 1}n
Definition:
[x] = −xn−1 · 2n−1 + < x[n − 2 : 0] >
[x] heißt two’s complement Darstellung von x der Länge n
Tn = {−2n−1 , . . . , 2n−1 − 1}
[ ] : 0, 1n → Tn
−2n−1 ≤ [x] ≤ hx[n − 2 : 0]i ≤ 2n−1 − 1
3.13.1
Beispiel
[1011]
= −1 · 23 + < 11 >
= −8 + 3
= −5
3.14
Beweis: Subtraktion
Eigenschaften:
a = a[n − 1 : 0] ∈ {0, 1}n
3.14.1
Lemma 1
<a>
=
[0a]
[0a]
=
=
−0 · 2n + < a > (Def initionvon[ ])
<a>
[a]
=
< a[n − 2 : 0] > mod 2n−1
[a]
=
=
−an−1 · 2n−1 + < a[n − 2 : 0] >
< a[n − 2 : 0] > mod 2n−1
Beweis:
3.14.2
Lemma 2
Beweis:
30
3.14.3
31
Lemma 3
[a]
=
< a > mod 2n
[a]− < a >
=
=
=
−an−1 · 2n−1 + < a[n − 1 : 0] > −(an−1 · 2n−1 − < a[n − 1 : 0] >)
−2 · an−1 · 2n−1
0 mod 2n
Beweis:
Sind Adressen in Rechnern:
• Binärzahlen?
• Two’s Complement Zahlen=
Nach Lemma 3: egal, da mod 232
3.14.4
Lemma 4
[an−1 a]
=
[a]
[an−1 a]
=
=
=
=
−an−1 · 2n + < a >
−an−1 · 2n + an−1 · 2n−1 + < a[n − 2 : 0] >
−an−1 · 2n−1 + < a[n − 2 : 0] >
[a]
[1011]
=
=
[11011]
[111011]
Beweis:
Beispiel:
Definition:
a ∈ {0, 1}n interpretiert als two’s complement Zahl:
an−1 : sign-bit
(Sign Extension)
3.14.5
32
Lemma 5
[a]
=
[a] + 1
[a]
=
=
=
=
=
=
−[an−1 ] · 2n−1 + < [a][n − 2 : 0] >
Pn−2
−[an−1 ] · 2n−1 + i=0 ai · 2i
Pn−2
−[(1 − an−1 ) · 2n−1 + i=0 (1 − ai ) · 2i
P
Pn−2
n−2
xn−1 · 2n−2 − i=0 xi 2i − 2n−1 + i=0 2i
−[x] − 2n−1 + 2n−1 − 1
−[x] − 1
Beweis:
3.14.6
Beweis der Subtraktion
=
=
=
<a>−
3.15
< a > −[0b]
< a > +[1b] + 1
< a > + +1 mod 2n
(Lemma 1)
(Lemma 5)
(Lemma 2)
Definition: n-bit-twoc-Addierer
Siehe hierzu auch Abbildung 17 (Seite 22).
[S] = [a] + [b] + cin mod 2n
Sei An ein n-bit-Addierer:
3.16
< S[n − 1 : 0] >
=
=
=
=
=
=
< a > + +cin
Pn−2
−[an−1 ] · 2n−1 + i=0 ai · 2i
Pn−2
−[(1 − an−1 ) · 2n−1 + i=0 (1 − ai ) · 2i
P
Pn−2
n−2
xn−1 · 2n−2 − i=0 xi 2i − 2n−1 + i=0 2i
−[x] − 2n−1 + 2n−1 − 1
−[x] − 1
< S[n − 1 : 0] >
=
=
=
< a > + +cin
[a] + [b] + cin mod 2n
[S[n − 1 : 0]] mod 2n
(Lemma 3)
(Lemma 3)
Definition: Arithmetic Unit (AU)
a
b
n
n
AU
sub
n
S
Abbildung 25: Arithmetic Unit
[S] =
½
[a] + [b] mod 2n
[a] + [b] mod 2n
(sub = 0)
(sub = 1)
33
Nach Lemma 5:
[S] =
3.16.1
½
[a] + [b] + 0 mod 2n
[a] + [b] + 1 mod 2n
(sub = 0)
(sub = 1)
Erweiterung der Notation
a ∈ {0, 1}n ; x ∈ {0, 1}
◦ : {0, 1}n → {0, 1}
a ◦ x = (an−1 ◦ x, . . . , a0 ◦ x)
x ◦ a = (x ◦ an−1 , . . . , x ◦ a0 )
b
a
an-1
b
a0
1
n
Abk. für:
n
Abbildung 26: Erweiterung der Notation
Beispiel:
b
n
sub
1
Abbildung 27: Beispiel: Erweiterung der Notation
b ⊕ sub =
(bn−1 ⊕ sub, . . . , b0 ⊕ sub)
½
b (sub = 0)
=
b (sub = 1)
b
3.17
34
n-bit-twoc AU (auch für Binärzahlen)
[S] = [a] + [b ⊕ sub] + sub mod 2n
b
n
sub
a
n
n
AU
n
neg ovf
S[n-1:0]
Abbildung 28: n-bit-twoc AU (auch für Binärzahlen)
Behauptung:
addiert/subtrahiert auch Binärzahlen
Frage:
Wann ist [a] + [b] + cin ∈ Tn = {−2n−1 , . . . , 2n−1 − 1}?
Definition:
ovf (a, b, cin ) ⇔
neg(a, b, cin ) ⇔
[a] + [b] + cin ∈
/ Tn (overf low)
[a] + [b] + cin < 0
3.17.1
Satz: Overflow
ovf (a, b, cin ) = 1 ⇔ cn−1 + cn−2
3.17.1.1
Beweis
[a] + [b] + cin
= −an−1 · 2n−1 − bn−1 · 2n−1 + < a[n − 2 : 0] > + < b[n − 2 : 0] >
= −an−1 · 2n−1 − bn−1 · 2n−1 + < cn−2 , S[n − 2 : 0] >
|
{z
}
=2n−1 ·cn−2 +<S[n−2:0]>
(Korrektheitsbeweis d. Addierers, Induktion bei i = n − 2)
= −2n−1 (an−1 + bn−1 + cn−1 − 2cn−2 )+ < S[n − 2 : 0] >
= −2n−1 ( < cn−1 , Sn−1 > + < S[n − 2 : 0] >
{z
}
|
2·(cn−1 +Sn−1 −2cn−2 )
= −2n (cn−1 − cn−2 ) + [S[n − 1 : 0]]
= δ
Fall cn−1 = cn−2 :
⇒ δ = [S[n − 1 : 0]] ∈ Tn
Fall cn−1 = 1; cn−2 = 0:
⇒ δ = −2n + [S] ≤ −2n + 2n−1 − 1 ∈
/ Tn
Fall cn−1 = 0; cn−2 = 1 ≡ Fallcn−1 = 1; cn−2 = 0
3.17.2
Satz: Negation
neg(a, b, cin ) = 1 ⇔ [a] + [b] + cin < 0 ∈ Tn+1 \Tn
neg =
3.18
an−1 ⊕ bn−1 ⊕ cn−1
Definition: Arithmetic Logic Unit (ALU)
b
a
n
n
4
ALU
f [3:0]
(Steuerbits)
n
ovf
S[n-1:0]
Abbildung 29: Arithmetic Logic Unit
35
3.18.1
3.18.2
36
Steuerbit-Tabelle
0
0
0
0
0
0
0
0
f [3 : 0]
0 0
0 0
0 1
0 1
1 0
1 0
1 1
1 1
0
1
0
1
0
1
0
1
1
1
1
1
1
1
1
1
f [3 : 0]
< =
0 0
0 0
0 1
0 1
1 0
1 0
1 1
1 1
>
0
1
0
1
0
1
0
1
S
a +n b
a +n b
a −n b
a −n b
a ∧ b
a ∨ b
a ⊕ b
b[n/2 : 0] 0n/2
overflow akt./ign.
akt.
ign.
akt.
ign.
xcc(1, b, f )
≡
a
a
a
a
a
a
0
>
=
≥
<
6
=
6
=
1
b
b
b
b
b
b
a−b
a−b
a−b
a−b
a−b
a−b
>
=
≥
<
6=
6=
0
0
0
0
0
0
Schaltkreis
n
a
b
n
n/2
sub
n-AU
b[n/2-1:0] 0
f[1]
n
f[3]
neg
n
n
n
akt* ovf'
f[0]
f[0]
1
0
1
0
S''
f[1]
null*
ovf
0
1
0
f[2]
1
n
S'
n-1
0
xcc*
n
Interrupt
Unit
0
1
n
S
Abbildung 30: Schaltkreis - Arithmetic Logic Unit
f[3]
3.18.3
akt: Overflow aktivieren/ignorieren
akt = f3 f2 f0
3.18.4
xcc: Fixed Point Condition Code
neg(a, b, f ) = 1 ⇔
null(a, b, f ) = 1 ⇔
a−b < 1
a−b = 1
pos(a, b, f ) = 1 ⇔
a−b > 1
pos = neg ∧ null
xcc(a, b, f ) = f2 neg ∨ f1 null ∨ f0 pos
37
4 PROZESSORBAU
38
4 Prozessorbau
Prozessor: rechnet in Schritten
Hardware: rechnet besser auch in Schritten
1. Mathematische Maschinen
2. Register, RAM, multiport-RAM’S (Hardware-Erweiterungen)
3. DLX0 : vereinfachter DLX-Instruktionssatz (DLX ≈ MIPS)
4. Bau von DLX0 -Prozessor
4.1
Mathematische Maschinen
Aus Programmier-Sprachen
x := x + 1
|
{z
}
nicht Gleichheit!
Definition von xt :
x vor/während Schritt t
→ xt+1 = xt + 1
x: Register, RAM, . . . : Hardware
x: für Benutzer sichtbare Register : Assembler-Programmierung
x: Variablen eines Programms : Programmier-Sprachen
x: für Benutzer sichtbare Datenstrukturen : Betriebssystem
Definition: mathematische Maschinen
M
=
(τ, δ, c0 )
τ
:
δ
:
M enge von Konf igurationen
(Zustand d. M aschine in einem Schritt)
τ →τ
:
(Ü bergangsf unktion)
Startkonf iguration
c0 ∈ τ
Rechnung:
F olge(C 0 , c1 , c2 , . . .) : ci+i = f (ci ) ∀i
4 PROZESSORBAU
4.2
Speicherelemente
4.2.1
Register (n-Bit)
39
Rin
Ce
n
R
n
Rout
Abbildung 31: Register
R ∈ {0, 1}n (in Register gesp. bits)
ce ∈ {0, 1} (clock enable)
Arbeitsweise:
R
:=
R
=
Rin f alls ce = 1
½ t
Rin : cte = 1
Rt
: sonst
Beispiel:
0
a
n
n
1
n-Add
0
n
n
1
0
reset
R
1
Abbildung 32: Register (Beispiel)
reset0 = 1
t
reset
| {z } = 0
(t>0)
0
Rin
=
0n
1
Rin
t
Rin
= 0n
= Rt +n
1n
|{z}
1n = binn (1)
R
t+1
t
= R +n 1
4 PROZESSORBAU
40
Lemma:
Rt = binn (t)
4.2.2
Random Access Memory (RAM)
Din
d
ad
w
a
S
1
d
Dout
Abbildung 33: 2a × d RAM
4.2.2.1
2a × d RAM
S : {0, 1}a → {0, 1}d
½ t
Din
: x = adt ∧ wt = 1
t+1
s (x) =
t
S (x) : sonst
t
Dout
= S t (adt ) (f alls wt = 0)
Allgemeine Regeln zur Wohldefiniertheit: S.M. Müller, W. Paul:
The Complexity of Simple Computer Architectures, Springer 1995.
Din
d
ad A
ad B
ad C
a
1
a
w
S
a
d
Dout A
d
Dout B
Abbildung 34: 3 − P ort RAM
4.2.2.2
3 − P ort RAM
S : {0, 1}a → {0, 1}d
½
Din C t : x = adC t ∧ wt = 1
S t+1 (x) =
S t (x)
: sonst
Dout At = S t (adAt ) : (adA 6= adC ∧ wt = 1) ∨ wt = 0
Dout B t = S t (adB t ) : (adB 6= adC ∧ wt = 1) ∨ wt = 0
4 PROZESSORBAU
4.3
41
Instruktionssatz des DLX0 -Prozessors
m
CPU
PC
ad
32
32
GPR
Abbildung 35: DLX0 Instruktionssatz
Central Processing Unit:
Memory: Wort-Adressiert
Adressen ∈ {0, 1}32
m : {0, 1}32 → {0, 1}32
mt (ad) : Inhalt von Speicherzelle ad zur Zeit t
Program Counter (PC) ∈ {0, 1}32
General Purpose Register File (GPR): {0, 1}5 → {0, 1}32
32 Adressen
32 Register
GPR[i] ∈ {0, 1}32 ; i ∈ {0, 1}5
4.3.1
Konfiguration
c =
4.3.2
(c.P C, c.GP R, c.m)
c.P C
∈
{0, 1}32
c.GP R
c.m
:
:
{0, 1}5 → {0, 1}32
{0, 1}32 → {0, 1}32
Rechnung
Rechnung: (c0 , c1 , c2 , . . .)
ci+1 = δ(ci )
Ii = die i-te ausgeführte Instruktion
I
I
I
1
0
c2 . . . ci →i ci+1
c1 →
c0 →
I(ct ) = ct .m[ct .P C] ∈ {0, 1}32
N otation : I(ct ) ≡ It
It wird meistens auch im Instruction Register (IR) zwischengespeichert. Effekt von It formal spezifiziert
durch:
ct+1 = (ct+1 .P C, ct+1 .GP R, ct+1 .m) = δ(ct )
4 PROZESSORBAU
4.3.3
42
3 Instruktionsformate
I-Type:
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9
OPC
RS1
RD
8
7
6
5
4
3
2
1
0
6
5
4
3
2
1
0
2
1
0
imm
R-Type:
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9
OPC
RS1
RS2
RD
8
7
(SA)
fu
J-Type:
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9
OPC
8
7
6
5
4
imm
Der Typ der Instruktion wird im OpCode festgelegt:
opc(c)
| {z }
= I(c)[31 : 26]
c=DLX0 −Konf iguration
Prädikate:
R − T ype(c)
⇔
opc(c) = 06
J − T ype(c)
I − T ype(c)
⇔
⇔
opc(c) ∈ {000010, 000011, 111110, 111111}
/(R − T ype(c) ∨ J − T ype(c))
Felder definieren:
RS1(c) = I(c)[25 : 21]
RS2(c) = I(c)[20 : 16]
½
I(c)[20 : 16]
RD(c) =
I(c)[15 : 11]
f u1 (c)
imm(c)
= I(c)[5 : 0]
½
I(c)[15 : 0]
=
I(c)[25 : 0]
: I-Type(c)
sonst
: I-Type(c)
sonst
3
4 PROZESSORBAU
4.3.4
43
Definition: Signed Extension
Sei a ∈ {0, 1}b (interpretiert als twoc):
sxt(a) = a[b − 1]cb−1 a ∈ {0, 1}b+c
Lemma:
[imm] = [sxt(imm)]
4.3.5
GP R[05 ]
Für das GPR des DLX0 soll immer gelten:
c.GP R[00000] = 032
4.3.6
Instruktionen
4.3.6.1 Load/Store
load word (lw):
lw(c) = 1 ⇔ op(c) = 100011
effective address:
ea(c) = c.GP R[RS1(c)] +32 sxt2 (imm(c))
| {z }
| {z }
|
{0,1}5
{z
{0,1}32
}
{0,1}16
ct+1 .GP R [RD (ct )] = ct .m [ea(ct )]
store word (sw):
sw(c) = 1 ⇔ op(c) = 101011
ct+1 .m[x] =
2 sxt:
signed Extension
½
ct .m [ea(ct )]
ct .m [x]
: sw(c) ∧ x = ea(ct )
: sonst
4 PROZESSORBAU
44
4.3.6.2 Compute / Compute Immediate
compute immedate (comp.imm:)
comp.imm(c) = 1 ⇔ I(c)[31 : 30] = 01
Vergleiche hierzu Kapitel 3.18. Wir benötigen hierzu eine 32-bit ALU.
½
aluop(c.GP R[RS1(c)], sxt(imm(c)), I(c)[29 : 26])
ct+1 .GP R[x] =
ct .GP R[x]
compute (comp):
comp(c) = 1 ⇔ R − T ype ∧ I(c)[5 : 4] = 00
½
aluop(c.GP R[RS1(c)], c.GP R[RS2(c)], I(c)[3 : 0])
ct+1 .GP R[x] =
ct .GP R[x]
: x = RD(c) ∧ x 6= 05
: sonst
: x = RD(c) ∧ x 6= 05
: sonst
Zusammenfassung:
lop = c.GP R[RS1(c)]
½
sxt(imm(c))
: comp.imm(c)
c.GP R[RS2(c)] : sonst
½
I(c)[29 : 26] : comp.imm(c)
lop =
I(c)[3 : 0]
: sonst
rop =
4.3.6.3 Branch or Jump taken
bjtaken(c) = 1 ⇔ btaken(c) ∧ jump(c)
branch(c) = 1 ⇔ I(c)[31 : 27] = 11010
AeqZ(c) = 1 ⇔ c.GP R[RS1(c)] = 0
jump(c)
beqz(c)
bnez(c)
btaken(c)
= j(c) ∧ jal(c) ∧ jr(c) ∧ jalr(c)
= branch(c) ∧ I(c)[26] = 0
= branch(c) ∧ I(c)[26] = 1
= c.GP R[RS1(c)] = 0 ∧ beqz(c) ∨ c.GP R[RS1(c)] 6= 0 ∧ bnez(c)
|
{z
}
Def inition
= branch(c) ∧ [c.GP R[RS1(c)] = 0 ∧ I[26] = 0 ∨ c.GP R[RS1(c)] 6= 0 ∧ I[26] = 1)]
4 PROZESSORBAU
45
⇒ Lemma:
*Achtung:
btaken(c) = branch(c) ∧ (AeqZ(c) ⊕ I[26])
 t
 c .P C(ct ) +32 sxt(imm(ct )) : btaken(ct ) ∧ j(ct ) ∧ jal(ct )*
t+1
ct .GP R[RS1(ct )]
: jr(ct ) ∧ jalr(ct )
c .P C =

t
c.P C(c ) +32 132
: sonst
imm(c) ∈ {0, 1}16 oder {0, 1}26
½
imm[15]16 imm : imm(c) ∈ {0, 1}16
sxt(imm) =
imm[25]6 imm
: imm(c) ∈ {0, 1}26
 32
0



t

c
.m[ct ]


 aluop(lop(ct ), rop(ct ), f code(ct ))
ct+1 .GP R[x] =
c.P C +32 132


{z
}
|



Rücksprungadresse

 t
c .GP R[x]
4.3.7
x = 05
lw(ct ) ∧ x = RD(ct ) ∧ x 6= 05
(comp.imm(ct ) ∨ comp(ct )) ∧ x = RD(ct )
(jal(ct ) ∨ jalr(ct )) ∧ x = 15
:
:
:
:
: sonst
Zusammenfassung: Instruktionen
t+1
c
.m[x] =
½
ct .m [ea(ct )]
ct .m [x]
: sw(c) ∧ x = ea(ct )
: sonst
 t
 c .P C(ct ) +32 sxt(imm(ct ))
ct .GP R[RS1(ct )]
ct+1 .P C =

c.P C(ct ) +32 132
 32
0



t

c
.m[ct ]


 aluop(lop(ct ), rop(ct ), f code(ct ))
ct+1 .GP R[x] =
+32 132
 |c.P C {z

}




 Rücksprungadresse
ct .GP R[x]
4.4
:
:
:
:
: btaken(ct ) ∧ j(ct ) ∧ jal(ct )*
: jr(ct ) ∧ jalr(ct )
: sonst
x = 05
lw(ct ) ∧ x = RD(ct ) ∧ x 6= 05
(comp.imm(ct ) ∨ comp(ct )) ∧ x = RD(ct )
(jal(ct ) ∨ jalr(ct )) ∧ x = 15
: sonst
Hardware-Konfiguration
h = (h.P C,
|h.GP
{z R}
modif iziertes 3−P ort RAM
, h.m)
4 PROZESSORBAU
46
{0, 1}5 → {0, 1}32
 32
: x = 05
 0
t+1
t
D
: wt ∧ x 6= 05 ∧ x = adC t
S [x] =
 tin
S [x] : sonst
h.GP R
:
h.P C
∈
{0, 1}32
h.m
:
{0, 1}32 → {0, 1}32
Ziel ist es, zu beweisen, dass die beiden mathematischen Maschinen (Hardware und DLX0 ) gleich funktionieren.
4.4.1
Unterteilung der Instruktionen in Stufen
IM
IF
(instruction fetch)
Ih
32
ID
(instruction
decode)
nextPC
ad comp
c0 comp
PCinc
5
5
ad A ad B ad C
c0
1
5
PLA
Prädikate
PC
A
EX
(execute)
a*
1
0
0
roph
ALU
link
M
aluoph*
32-Add
min
alures
0
b*
1
madr
(memory)
m
mout
0
1
g*
ad A
WB
(write back)
GPR
ad B
GPRw*
ad C
Dout A
B
Dout B
Abbildung 36: DLX0 -Hardware Konfiguration in Stufen
Noch zu definieren:
α, β, γ GP Rw , mw , c0 comp, adcomp, nextP C, aluoph , P Cinc
mw*
4 PROZESSORBAU
4.5
47
Beweis der Gleichheit zwischen DLX0 - und Hardware-Konfiguration
c0 , c1 , c2 , . . . ci+1 = δ(ci )
|
{z
}
DLX0 Rechnung
h0 , h1 , h2 , . . . hi+1 = δ(hi )
|
{z
}
Hardware Rechnung
Zu zeigen ∀ i:
hi .P C = ci .P C
h .GP R = ci .GP R
hi .m = ci .m
(Induktionsbehauptung)
i
Vorraussetzung:
• Induktionsbehauptung(0) gilt
• c0 .m[x] = IM [x] für alle x ∈ codesection
• kein selbsmodifizierender Code
∀i:
sw(ci ) ⇒ ea(ci ) ∈
/ codesection
ci .P C ∈ codesection
Induktionsschluss i → i + 1:
ci .P C = hi .P C
Ih (hi )
=
=
=
=
=
IM [hi .P C]
IM [ci .P C]
m[c0 .P C]
mi [ci .P C]
I[ci ]
(Konstruktion)
(Induktions-Vorraussetzung)
(keine Selbsmodifikation)
4 PROZESSORBAU
4.5.1
48
c0 comp
Ih [31:0]
Ih [15]6
Ih [25]6
0
Ih [15]10
0
1
1
J-Type
J-Type
C0 [31:26]
Ih [15:0]
Ih [25:16]
C0 [25:16]
Abbildung 37: DLX0 -Beweis (c0 comp)
Lemma:
J − T ype(hi ) = J − T ype(ci )
(aus Darstellungssatz!)
Lemma:
c0 (hi ) = sxt(imm(ci ))
C0 [15:0]
4 PROZESSORBAU
4.5.2
49
adcomp
Ih [31:0]
ad B
ad A
Ih [15:11]
Ih [20:16]
Ih [20:16]
Ih [25:21]
1
0
5
R-Type
1
0
1
ad C
jalh oder jalrh
Abbildung 38: DLX0 -Beweis (adcomp)
Lemma:
ad A(hi )
=
RS1(ci )
ad B(hi )
=
½
ad C(hi )
=
A(hi )
½
RS1(ci )
RD(ci )
: R-Type
: I-Type
RD(ci )
15
: I-Type ∧ R-Type
: jal(ci ) ∧ jalr(ci )
i
h
| .GP
{z R}
=
ci .GP R
i
⇒ A(h )
: I-Type ∨ R-Type
[
ad A(hi )
| {z }
]
(ind. V or.) RS1(ci ) (eben gezeigt)
= lop(c ) (f alls I − T ype(ci ) ∨ R − T ype(ci ))
B(hi ) =
i
½
ci .GP R[RS2(ci )]
ci .GP R[RD(ci )]
: R − T ype
: I − T ype
¾
α = R − T ypeh
i
roph (h )
=
=
*Lemma:
∀ Prädikate P : P (ci ) Ph (hi )
½
½
ci .GP R[RS2(ci )]
ci .GP R[RD(ci )]
ci .GP R[RS2(ci )]
ci .GP R[RD(ci )]
: R − T ypeh (hi ) = 1
: R − T ypeh (hi ) = 0
¾
: R − T ype(ci ) = 1
P LA − Lemma ∗
: R − T ype(ci ) = 0
4 PROZESSORBAU
4.5.3
50
aluoph
Ih [29:26]
Ih [3:0]
1
0
R-Type
aluoph
Abbildung 39: DLX0 -Beweis (aluoph )
Mit ALU-Korrektheit:
⇒ alures(hi ) = aluop(lop(ci ), rop(ci ), aluop(ci ))
4.5.4
mw
Mit Addierer-Korrektheit:
⇒ mad (hi ) = A(hi ) +32 c0 (hi )
= ci .GP R[RS1(ci )] +32 sxt(imm(ci ))
= ea(ci )
min (hi ) = ci .GP R[RD(ci )]
Definition:
mw
= swh
= sw(ci ) (P LA − Lemma)
4 PROZESSORBAU
4.5.5
51
ci .m = hi .m
hi+1 .m[x]
| {z }
=
neuer HW −Speicher
½
min
hi .m[x]
: mw (hi ) = 1 ∧ x = mad (ci )
: sonst

i
i

 c .GP R[RD(c )]
i
h .m[x]
=

 i | {z }
¾
Def. : HW − Speicher
: sw(ci ) = 1 ∧ x = ea(ci )
: sonst
c .m[x] (Ind.V or.
= ci+1 .m
Bewiesen:
→
4.5.6
ci .m = hi .m
GP R.w
Definition:

 aluup(lop(ci ), rop(ci ), aluop(ci ))
i
mout (hi )
GP R.Din (h ) =

P C i (hi )
β
γ(hi )
mout (hi )
: α(hi ) = 0 ∧ β(hi ) = 0
: γ(hi ) = 1
: β(hi ) = 1 ∧ γ(hi ) = 0
= jalh ∨ jalrh (γ = lwh )
= lwh (hi )
= lw(ci )
=
i
h
.m}
| {z
[ mad (hi ) ]
| {z }
ci .m (Ind. V or) ea(ci ) (eben)
= ci m[ea(ci )]
Bewiesen mit Lemma nextPC:
P C ′ (hi ) = hi .P C +32 132
Definition:
GP R.w = lwh ∨ computeh ∨ compute.immh ∨ jalh ∨ jalrh
4 PROZESSORBAU
hi+1 .GP R[x] =
52
 32
o








aluup(lop(ci ), rop(ci ), aluop(ci ))







i
i


 c .m(ea(c ))

hi .P C +32 132


|
{z
}



i+1 .GP R[x]
c








hi .GP R[x]



 i | {z }
: x = 05 (Def. HW-Multiport-RAM)
: comp(ci ) ∨ comp.imm(ci ) ∧ x = RD(ci )
: x = RD(ci ) ∧ sw(ci )
: jal ∨ jalr ∧ x = 15
: sonst
c .P C (Ind.V or.)
4.5.7
P Cinc
Ih (hi ) = I(ci )
ci+1 = hi+1 .GP R
ci+1 .m = hi+1 .m
P Cinc (hi ) = ci .P C +32 132
4.5.8
Spezifikation: n-Inc
x
n
n-Inc
n
y
Abbildung 40: Spezifikation - n-Inc
y = x +n 1n
Nach Induktionsvorraussetzung:
P Cinc (hi )
= hi .P C +32 132
= ci .P C +32 132
4 PROZESSORBAU
4.5.9
53
nextP C
C0
32
32-Inc A
0
32-Add
32
32
bjtakenh
1
0
jrh Ú jalrh
0
1
032
reset
1
0
nextPC
PC
1
Abbildung 41: nextP C
PLA-Lemma:
⇒
(jrh ∨ jalh )(hi )
=
jr(ci ) ∨ jalr(ci )
bjtaken(ci )
=
jump(ci ) ∨ branch(ci ) ∧ AeqZ(ci ) ⊕ I(ci )[26]
jumph
jumph (hi )
=
=
jh ∨ jalh ∨ jrh ∨ jalrh
jump(ci )
4 PROZESSORBAU
54
Hardware:
A
32
32-OR
Ih[26]
AeqZh
jumph
bjtakenh
Abbildung 42: bjtakenh
früher:
A(hi )
AeqZh (h ) = 1
i
bjtakenh (hi )
=
⇔
⇔
ci .GP R[RS1(ci )]
∀j : A(hi )[j] = 0
A(hi ) = 032
⇒
AeqZ(hi ) = AeqZ(ci )
=
bjtakenh (ci )
für reset = 0:
 i
 c .GP R[RS1(ci )]
i+1
i
ci .P C +32 sxt(imm(ci ))
h .P C = nextP Ch (h ) =
 i
c .P C +32 132
: jr(ci ) ∨ jalr(ci )
: bjtaken(ci )∧ ∼ (jr(ci ) ∨ jalr(ci ))
: sonst
5 COMPILER FÜR C0 (PASCAL MIT C-SYNTAX)
55
5 Compiler für C0 (PASCAL mit C-Syntax)
Vorgehensweise:
1. Definition der Syntax von C0
(entspricht den bool’schen Ausdrücken, DLX0 -Instruktionsformate)
2. Definition der Sematik von C0 : Definition einer abstrakten C0 -Maschine
(entspricht δ(h), δ(c))
3. Compiler: C0 → DLX0
4. Simulationssatz:
Compiler
p: C0 -Programm → Code(p): DLX0 -Programm
Zu zeigen:
DLX0 mit Code(p) simuliert eine C0 -Maschine mit Programm p
5.1
Kontextfreie Grammatiken
5.1.1
Beispiel: Kontextfreie Grammatik
V C Variable oder Konstante
B → V C|(∼ B)|B ∧ B)|(B ∨ B)|(B ⊕ B)
|
{z
}
P roduktionensystem
Abkürzung für:
{B
{z V C}, B → ∼ B, . . . , B → B ⊕ B}
| →
P roduktion
N
T
S
5.1.2
=
=
=
{B}
{(, ), V C, ∧, ∨, ⊕, ∼}
B
Nichtterminalalphabet
Terminalalphabet
Startsymbol
Definition: Kontextfreie Grammatik
Grammatik G = (T, N, P, S)
|
{z
}
Kontextf reie Grammatik (cf g)
T
N
S
P
:
:
=
⊂
endlich, Terminalalphabet
endlich, Nichtterminalalphabet
Startsymbol
(N × (N ∪ T )∗)
(n, w) ∈ P
(Produktionensystem)
(Produktion)
Schreibweise:
n
{z w}
| →
Aus n kann w abgeleitet werden
5.1.3
56
Arbeitsweise von Grammatiken
Definition: induktiv zu G
Q ist Ableitungsbaum zu G mit Wurzel w und Blattwort b:
b
w
S ist ein Ableitungs-Baum mit Wurzel S und Blattwort S:
S
Sei Q Ableitungs-Baum mit Wurzel w und Blattwort b = b′ n b′′ n ∈ N :
b'
n
b''
w
Sei n → u ∈ P
⇒ u = u1 , . . . , un
Ableitungsbaum mit Wurzel w und Blattwort b = b′ u b′′ :
u1 . . . un
b'
n
b''
w
57
Beispiel:
(B Ù B )
(~ B )
B
(~ B )
B
VC VC
(B Ù B )
(~ B )
B
B
Abbildung 43: Beispiel - Arbeitsweise von Grammatiken
Blattwort: (∼ (V C ∧ V C))
5.1.4
Weitere Definitionen
Zi
ZiF
V
VC
A
→
→
→
→
→
0|1|2|3|4|5|6|7|8|9
Zi|ZiF Zi
XZiF
ZiF |V
V C| −1 A|A + A|A −2 A|A ∗ A|A/A|(A)
(Ziffer)
(Ziffernfolge)
(Variable)
(Variable oder Konstante)
(Ausdruck)
Beispiele:
∗
0
V C → X |{z}
1 |{z}
Zi
Zi
|{z}
ZiF
| {z }
ZiF
{z
}
|
V
{z
}
|
VC
∗
X3
X2 ∗ |{z}
A → |{z}
X1 + |{z}
VC
VC
VC
|{z} |{z}
A
A
| {z }
A
{z
}
|{z}
A
|
A
Dies ist fast ein Schaltkreis (kann als Schaltkreis dargestellt werden).
Da Schaltkreise eine Semantik besitzen, besteht auch die berechtigte Hoffnung, die Semantik ves Ausdrucks
ableiten zu können.
5.1.5
Problem: Alternativer Ableitungsbaum
An dem vorigen Beispiel kann man ebenfalls zeigen, dass es verschiedene Ableitungs-Bäume zum gleichen
Blattwort gibt:
X3
X2 ∗ |{z}
X1 + |{z}
|{z}
VC
VC
VC
|{z} |{z} |{z}
A
A
A
| {z }
A
{z
}
|
A
5.1.6
58
Definition: Eindeutigkeit von Grammatiken
G heißt eindeutig
⇔
∀ w ∈ L(G)
∃ genau 1 Ableitungs-Baum
mit Wurzel s und Blattwort w
Dazu beschränken wir A:
F
T
A
5.1.7
→
→
→
V C| −1 F |(F )
F |T ∗ F |T /F
T |A + T |A − T
(Faktor)
(Term)
(Ausdruck)
Satz: Grammatik G ist eindeutig
Der Beweis ist zum Beispiel in Loexx,Mehlhorn,Wilhem: Programmiersprachen zu finden.
5.2
Aufbohren der Grammatik
5.2.1
Bool’sche Ausdrücke
Beispiel:
if
2 > x + 3
|
{z
}
...
bool′ scherAusdruck
Um dies darzustellen definieren wir:
Atom
BF
BT
BA
5.2.2
→
→
→
→
A > A|A ≥ A|A < A|A ≤ A|A == A|A 6= A|0|1
Atom| BF |(BA)
BF |BT ∧ BF
BT |BA ∨ BT
Komplexe Datentypen
struct-Komponenten:
(.|. . . . . . . . . . . .{z
. . . . . . . . . . . . .}.).N a
identif ier des T yps struct
array-Komponenten:
pointer-Dereferenzierer:
(.|. . . . . . . . . . . .{z
. . . . . . . . . . . . .}.)[e]
adress of-Operator:
∗(.|. . . . . . . . . . . .{z
. . . . . . . . . . . . .}.)
Um dies darzustellen erweitern wir:
&(.|. . . . . . . . . . . .{z
. . . . . . . . . . . . .}.)
identif ier des T yps array
identif ier des T yps pointer
identif ier des T yps adress of
id
→
N a|C|id.N a|id[A]| ∗ id|&id
(wie bool’sche Variable)
(bool’scher Faktor)
(bool’scher Term)
(bool’scher Ausdruck)
5.2.3
59
Anweisungen
An
→
A − F olge
AnF
→
→
id = A
id = BA
if BA then An else An
if BA then An
while BA do An
{AnF }
N a(A − F olge)
return A
return BA
A|A − F olge, A
An|AnF ; An
(Zuweisung)
(Zuweisung für bool’sche Variablen)
(Bedingte Anweisung)
(verkürzte bedignte Anweisung)
(Schleife)
(Anweisungs-Block)
(Funktionsaufruf)
(Rückgabewert)
(Rückgabewert für bool’sche Variablen)
(Ausdrucks-Folge)
(Anweisungs-Folge)
An einem Beispiel zeigt sich wieder, dass diese Grammatik nicht eindeutig ist:
1.
if BA then if BA then An else An
|
{z
}
An
{z
}
|
An
2.
if BA then if BA then An else An
{z
}
|
An
{z
}
|
An
5.2.4
Programm
Das Programm besteht aus einem Deklarations-Teil (zur Deklaration von Variablen, Funktionen und Typen) und einem Anwendungsteil (einer Anweisungs-Folge):
programm
5.2.5
→
DeklF ; AnF
(Programm)
Deklarationen
Dekl
DeklF
N aF
V aD
P ar
P arF
T ypD
eltyp
typ
KompD
KompDF
→
→
→
→
→
→
→
→
→
→
→
V aD|F nD|T ypD
DeklF |DeklF ; Dekl
N a|N aF, N a
typN aF ;
T ypN a
P ar|P arF, P ar
typedef typN a;
int|bool|char|f loag| . . .
eltyp|eltyp[ZiF ]|N a[ZiF ]|structN a{KompDF }|N a∗
N a : eltyp|N a : N a
KompD|KompDF
(Deklaration)
(Deklarations-Folge)
(Namens-Folge)
(Variablen-Deklaration)
(Parameter)
(Parameter-Folge)
(Typen-Definition)
(elementare Typen)
(Typen)
(Komponenten-Definition)
(Komponenten-Folge)
5.3
60
Semantik von C0
Für die Sematik von C0 definieren wir wie schon bei DLX0 eine abstrakte Maschine:
• Deklarations-Teil:

Typen-Definition

Variablen-Deklaration
c.env(. . . , . . . , . . . , . . . , . . . , . . .)
| {z } | {z } | {z }

Funktions-Deklaration
T yp
V ar
Fn
• Anweisungs-Teil:
Programmrest
(noch auszuführende Anweisungen)
5.4
Deklarations-Teil
5.4.1
Typen-Definition
¾
c.prog
Als Beispiel für die Typen-Definitionen gelten folgende Deklarationen:
typedef x int[5];
typedef y x[5];
struct {wert:int,next:LEL*} LEL;
5.4.1.1
Type Table
c.nt
c.tt
=
=
=
Number of Types (Anzahl der Bennutzten Typen)
Type Table
( c.tt.name
{z } )
| {z } , |c.tt.tc
T ype−N ame T ype−Code
Type Table:
c.tt.name
:
c.tt.tc
:
[ ] → T ypeCodes
Type Codes:
c.tt.tc[i]
=
c.tt.tc[i]
:
c.tt.tc[i]
:
c.tt.tc[i]
:
el
falls name[i] elementar
arr(n, j)
typedef (c.tt.name[j])[n] c.tt.name[i]
* i-te Type-Definition (inkl. elem. Typen))
*j i ist erlaubt
struct(n1 , i1 ; . . . ; ns : is )
typedef struct(n1 , t1 ; . . . ; ns : ts ) ∗ c.tt.name[i]
* tj = name(ij )
* ij < i
[0 : nt − 1] → N
| amen
{z }
=L(N a)
61
Eine Tabelle zu den Beispiel-Deklarationen könnte dann wie folgt aussehen:
5.4.1.2
i
0
1
..
.
name
int
bool
..
.
tc
el
el
..
.
4
5
6
7
x
y
p
LEL
arr(5, 0)
arr(5, 4)
ptr(7)
strwert, 0; next, 6
Größe von Typen
• t elementar oder pointer − typ :
{z
}
|
simple value
size(t) = 1
• t = t′ [n] :
size(t) = n · size(t′ )
• t = struct{n1 : t1 ; . . . ; ns : ts } :
Ps−1
size(t) =
i=0 size(ti )
Bemerktung (in ’Sprache’ der Type Table):
• falls c.tt.tc[i] = arr(n, j) :
size(i) = n · size(j)
• falls c.tt.tc[i] = struct{n1 : t1 ; . . . ; ns : ts } :
Ps−1
size(i) =
j=0 size(ij )
• size(i) kann aus c.tt in Reihenfolge i = 0, 1, . . . , c.nt − 1 berechnet werden
size(t) = n · size(t′ )
62
5.4.1.3 Range
Festzulegen ∀ deklarierten Typen t:
Ra(t) = {w|w Wert, Variablen vom Typ t können w als Wert annehmen }
| {z }
Range
t elementar:
Ra(int)
Ra(int)
6= Z
= {−231 , . . . , 231 − 1}
Ra(char) = {0, . . . , 28 − 1}
..
.
Notation:
fs (i) = f [i + s − 1 : i]3
Ra(t[n]) ∋ f [size(t[n]) − 1 : 0]
|
{z
}
n·size(t)
⇔
∀i ∈ {0, . . . , n − 1} : fsize(t) (i.size(t)) ∈ Ra(t)
⇔
Ra(struct{n1 : t1 ; . . . ; ns : ts }) ∋ f
∀i ∈ {1, . . . , s} : fsize(ti ) (di ) ∈ Ra(ti )
Achtung: Wir stellen Werte von Variablen mit (komplexen) Typ t als Folgen von simple values ∈ sv
Länge size(t) dar.
3 Teilfolge
4 sv:
der Länge s beginnend bei Element i
Werte die simple Typen annehmen können (Pointer später!)
4
der
63
Typ int[5] x:
∈ R(int)
∈ R(int)
∈ R(int)
∈ R(int)
∈ R(int)
∈ R(x)
∈ R(x)
∈ R(x)
∈ R(x)
∈ R(x)
∈ R(x)
∈ R(y)
...
∈ R(t1 )
∈ R(t)
size(t1 )
0
Typ x[5] y:
Typ struct{n1 : t1 ; . . . ; ni : ti ; . . . ; ns : ts } z:
size(t) − 1
∈ R(ts )
...
∈ R(ti )
di *
*Displacement: di =
P
j<i
size(tj )
Bemerkung:
Werte sind (bei uns) flach (wegen dem Adress-Of Operator & )
5.4.2
Variablen-Deklaration
• mit Namen ausserhalb von Funktionen (global)
• mit Namen innerhalb von Funktionen (lokal)
• neu: ohne Namen, Zugriff nur über Pointer
Änderung der Grammatik (!):
An
Beispiel:
LEL* q;
q = new LEL*;
→
N a = newN a∗
(Allokieren von Speicher)
64
5.4.2.1 Symbol-Tabelle von Speichern
Erweiterung der Konfiguration:
c = (nt, tt, gm, hm, lms, . . .)
gm
hm
lms
=
=
=
global memory
heap memory
local memory stack
memories m
=
(m.n, m.name, m.typ, m.ct)
|
{z
}
st(m)
m.n
:
m.name
:
m.typ
:
number (Anz. Variablen)
∈ N0
[0 : m.nv − 1] ⇒ Namen
(Variablenname)
[0 : m.nv − 1] ⇒ [0 : c.nt − 1]
{z
}
|
T yp−N r. aus c.tt
m.ct
|{z}
:
size(m)
=
st(gm)
:
W ert
[0 :
m·n−1
X
size(m.typ(i)) − 1] ⇒ sv
i=0
|
{z
Anz. simple values
Pc.nv−1
i=0
size(m.typ[i])
}
durch globale V arDF festgelegt
Eine Tabelle zu den Beispiel-Deklarationen könnte dann wie folgt aussehen (Typen-Nummern entsprechen
wieder dem Beispiel aus der Type Table 5.4.1.1):
i
0
..
.
..
.
..
.
5.4.2.2
Definition: Variable (6=Identifier)
V wird spezifiziert durch ein paar (m, i):
m
i
:
∈
memory
{0, . . . , m.nv − 1}
name
i
..
.
tc
0
..
.
u
4
..
.
..
.
v
5
..
.
..
.
ct
ª
1
¾







5
25
5.4.2.3
65
Definition: Wert von Variable (m, i)
va(m, i) = m.ctsize(m.typ[i]) ba(m, i)
| {z }
| {z }
V alue
ba(m, i)
=
X
Basis−Adr.
size(m.typ[j])
j<i
Problem:
v[1][2] = 7;
Ändert 3 g-Variablen:
• Matrix v
• Vektor v[1]
• einzelnes Element v[1][2]
5.4.2.4
Definition: g(eneralized)-Variablen
• alle Variablen sind g-Variablen
• (m, i)s5
• typ(m, i)s = t[n]
⇒ (m, i)s[j] ist g-Variable
typ ((m, i) s[j]) = t
(für 0 ≤ j ≤ n − 1)
• typ((m, i)s = structn1 : t1 ; . . . ; ns : ts
⇒ (m, i)s.nj ist g-Variable
typ((m, i)s.nj ) = ti
(für 1 ≤ j ≤ i)
Diesen g-Variablen können auch Basis-Adressen und Werte zugeordnet werden:
• typ(m, i)s = t[n]
ba((m, i)s[j]) = ba((m, i)s) + j · size(t)
• typ((m, i)s = structn1 : t1 ; . . . ; ns : ts
P
ba((m, i)s.nj ) = ba((m, i)s) + k<j size(tk )
• va((m, i)s) = m.ctsize(typ((m,i)s)) (ba((m, i)s))
5.4.2.5
5 s:
Definition: Werte von Pointern
selector
pointer
=
(m : a)
m
a
:
∈
memory
{0, m.nv − 1}
5.4.2.6
66
Korrektur: Grammatik
F uD
→
T yp |{z}
N a (P arF ) V
arDF ; rumpf
| {z } | {z }
f P arameter lok. V ar.
{z
}
|
(Funktions-Deklaration)
st(lmf )
rumpf
→
An; return(A)
(Funktions-Rumpf)
lmf ist der local memory von f (Variablen sind die Parameter und die lokalen Variablen)
Ausserdem wird in der Grammatik return aus den Anweisungen entfernt.
Neu:
• Deklaration lokaler Variablen (vorher vergessen)
• Nur eine return-Anweisung am Ende des Rumpfs
5.4.3
Funktions-Deklaration
c = (nt, tt, gm, hm, lms, nf, f t, . . .)
c.nf
:
c.f t
=
[0 : c.nf − 1] → {f d|f d : f unction descriptor}
(number of functions ∈ N0 )
function table
fd
f d.name
f d.typ
f d.st
=
:
:
:
(f d.name, f d.typ , f d.st f d.rumpf )
Name d. dekl. Funktion
Typ d. Funktion
Symbol-Table d. Funktion
f d.typ
ti
=
∈
0≤i≤n−1
i=n
:
:
(t0 , . . . , tn − 1, tn )
[0 : c.nt − 1]
{z
}
|
T ypen d. T T
c.nf
:
c.f t
=
Typ des i-ten Parameters
Typ des return-Werts
[0 : c.nf − 1] → {f d|f d : f unction descriptor}
(number of functions ∈ N0 )
function table
lmf .nv
=
lmf .name[i]
=
lmf .typ[i]
=
⇒
67
#P
½ arameter + # lokalerV ariablen
aus Fn.Def(ParDF) : i < #P arameter
aus
VarDF
für lok. Var. : sonst
½
aus Fn.Def(ParDF) : i < #P arameter
aus VarDF für lok. Var. : sonst
size(lmf ) dadurch festgelegt
5.4.3.1 Rekursion, Rekursionstiefe
c = (nt, tt, gm, hm, lms, nf, f t, rd, lms, rds, . . .)
c.rd
c.lms
:
:
c.rds
c.rds[i]
:
:
5.4.3.2
#call′ s die noch nicht zurückgekehrt sind
[0 : c.rd − 1] → {m|m ist lok. mem. lmf für ein f }
(local memory stack)
return destinations
(m : a) m ∈ gm, lm(i)
(Basisadresse, an dem return-Wert von rd = i gespeichert wird
Heap Memory
c = (nt, tt, gm, hm, lms, nf, f t, rd, lms, rds, hm)
c.hm
5.4.4
:
heap memory
speichert Variablen (und g-Variablen) ohne Namen
Speicher der C0 -Maschine
gm
lms(0)
..
.
lms(c.rd − 1)
hm





























































(abstrakter) Stack des Programms
5.5
68
Zusammenfassung der Grammatik
< Zi >
< ZiF >
< Bu >
< BuF >
< BuZi >
< BuZiF >
< Na >
< N aF >
<C>
< id >
< id >
<F >
<T >
<A>
< A − F olge >
< Atom >
→
→
→
→
→
→
→
→
→
→
→
→
→
→
→
→
< BF >
< BT >
< BA
< An >
→
→
→
→
< AnF >
< Dekl >
< DeklF >
< V aD >


< T ypD >
< F uD >
→
→
→
→
→
→
→
→
< rumpf >
< eltyp >
< typ >
→
→
→
< KompD >
< KompDF >
< programm >
→
→
→
0|1|2|3|4|5|6|7|8|9
< Zi > | < ZiF > < Zi >
a|b|c| . . . |x|y|z
< Bu > | < BuF >< Bu >
< Bu > | < Zi >
< BuZi > | < BuZiF >< BuZi >
< Bu > | < Bu >< BuZiF >
< N a| < N aF >, < N a >
< ZiF >
< N a > | < C > | < id > . < N a > |
< id > [< A >]|∗ < id > |& < id >
< V C > |−1 < F > |(< F >)
<F >|<T >∗<F >|<T >/<F >
<T >|<A>+<T >|<A>−<T >
< A > | < A − F olge >, < A >
<A>><A>|<A>≥<A>|
<A><<A>|<A>≤<A>|
< A > == < A > | < A > 6= < A > |
0|1
< Atom > | < BF > |(< BA >)
< BF > | < BT > ∧ < BF >
< BT > | < BA > ∨ < BT >
< id >=< A >
< id >=< BA >
if < BA > then < An > else < An >
if < BA > then < An >
while < BA > do < An >
{< AnF >}
< N a > (< A − F olge >)
< id >=< N a > (< A − F olge >)
< N a > = new < N a > ∗
< An > | < AnF >; < An >
< V aD > | < F nD > | < T ypD >
< DeklF > | < DeklF >; < Dekl >
< typ >< N aF >;
< T yp >< N a >
 | , 
typedef < typ >< N a >;
< T yp > < N a > () < V arDF >;
< rumpf >
< An >; return(< A >)
int|bool|char|f loag| . . .
< eltyp > | < eltyp > [< ZiF >]|
< N a > [< ZiF >]|
struct{< KompDF >} < N a > | < N a > ∗
< N a > : < eltyp > | < N a > : < N a >
< KompD > | < KompDF >
< DeklF >; < AnF >
(Ziffer)
(Ziffernfolge)
(Buchstabe)
(Buchstabenfolge)
(Buchstabe/Ziffer)
(Buchstaben-/Ziffernfolge)
(Name)
(Namens-Folge)
(Konstante)
(Identifier - früher Variable oder Konstante)
(Faktor)
(Term)
(Ausdruck)
(Ausdrucks-Folge)
(wie bool’sche Variable)
(bool’scher Faktor)
(bool’scher Term)
(bool’scher Ausdruck)
(Zuweisung)
(Zuweisung für bool’sche Variablen)
(Bedingte Anweisung)
(verkürzte bedignte Anweisung)
(Schleife)
(Anweisungs-Block)
(Funktionsaufruf)
(Funktionsaufruf mit Rückgabewert)
(Allokieren von Speicher)
(Anweisungs-Folge)
(Deklaration)
(Deklarations-Folge)
(Variablen-Deklaration)
(Parameter)
(Parameter-Folge)
(Typen-Definition)
(Funktions-Deklaration)
(Funktions-Rumpf)
(elementare Typen)
(Typen)
(Komponenten-Definition)
(Komponenten-Folge)
(Programm)
5.6
69
Ausdrucksauswertung
3 Funktionen:
• addr (Adresse eines Ausdrucks bestimmen):
c, Ausdruck → (m : a)
• typ (Typ eines Ausdrucks bestimmen):
c, Ausdruck → [0 : nt − 1]
• va (Wert eines Ausdrucks bestimmen):
c, Ausdruck → Ra(typ)
5.6.1
Definition: Bindungsfunktion(c, N a → (m, i))
bind(c, n) =

(c.lms[c.rd − 1], i) :



(gm, i) :



falls ∃i mit
c.lms[c.rd − 1].st.name[i] = n
falls ∃i mit
c.gm.st.name[i] = n
5.6.2
70
Auswertung
1. Konstante: e
addr(c, e)
typ(c, e)
va(c, e)
=<C >
= undef iniert
= c.env.tt[x]
= < e >10
(x =
b int)
2. Variable: e = < N a >
Sei bind(c, < N a >)
=
(m : i)
addr(c, e)
typ(c, e)
va(c, e)
=
=
=
(m : ba(m, i))
(m, i)
va(m, i)
3. Arrayzugriff: e = < id > [< A >]
addr(c, e) = (m : (a + j · size(t)))
typ(c, e) = t
va(c, e) = va(< id >)size(t) (j · size(t))
4. Strukturen: e = < id > . < N a >
Sei addr(c, < id >) = (m : a)
typ(c, < id >) = struct{n1 : t1 , . . . , ns : ts }
< N a > = ni (Wir greifen auf die i-te Komponente zu
addr(c, e)
typ(c, e)
va(c, e)
=
=
=
Pi−1
(m : (a + j=1 size(tj )))
ti
Pi−1
va(< id >)size(t) ( j=1 size(tj ))
5. Dereferenzierung: e = ∗ < id >
Sei va(c, < id >)[0] = (m : a)
typ(c, < id >) = ptr(t)
addr(c, e)
typ(c, e)
va(c, e)
=
=
=
(m : a)
t
m.ctsize(t) (a)
6. adress-of Operator: e = & < id >
Sei addr(c, < id >) = (m : a)
typ(c, < id >) = t
addr(c, e)
typ(c, e)
va(c, e)
=
=
=
undef iniert
ptr(t)
(m : a)
7. arithmetische/boole’sche Ausdrücke: e = < A > + < T >
addr(c, e) = undef iniert
typ(c, e) = typ(c, < A >)
va(c, e) = va(c, < A <)[0] + va(c, < T >)[0] mod 232
(Achtung bei bool’schen Vergleichsoperatoren!)
5.7
71
Ausführung von Anweisungen
Definition: next − state Funktion (delta : Konf → Konf )
Berechnet Nachfolgekonfigurationen, delta führt die erste Anweisung vom Programmrest aus:
Fallunterscheidung nach der ersten Anweisung in c.prog, r sei der Rest des Programms:
1. Zuweisung: c.prog = < id >=< A >; r / c.prog = < id >=< BA >; r
Sei
typ(c, < id > = typ(c, < A >)
= t ∈ sv
⇒ size(t) = 1
addr(c, < id >) = (m : a)
delta(c).m.ct[i]
=
delta(c).prog
=
½
va(c, < A >)[0] :
c.m.ct[i] :
falls i = a
falls i 6= a
r
2. if-Anweisung: c.prog½ = if < BA > then < An1 > else < An2 >; r
< An1 >; r falls va(c, < BA >) = 1
delta(c).prog =
< An2 >; r falls va(c, < BA >) = 0
3. while-Schleife: c.prog
½ = while < BA > do < An >; r
< An >; while < BA > do < An >; r
delta(c).prog =
r
falls va(c, < BA >) = 1
falls va(c, < BA >) = 0
4. Speicherallokierung: c.prog = < N a >= new ∗ < T yp >; r
Sei
t : Typnummer von < T yp >
typ(c, < N a >) = ptr(t)
addr(c, < N a >) = (m : a)
delta(c).hm.n
delta(c).hm.typ[c.hm.n]
=
=
delta(c).m.ct[i]
=
delta(c).prog
=
c.hm.n + 1
t½
(c.hm : size(c.hm))
c.m.ct
r
5. Funktionsaufrufe: c.prog = < id >=< N a > (< AF >); r
Sei
pi
addr(c, < id >)
c.f t[j].name
typ(c, pi )
typ(c, < id >)
falls i = a
falls i 6= a
:
=
=
=
=
i-ter Parameter des Funktionsaufrufs
(m : a)
< Na >
c.f t[j].typ[i]
c.f t[j].typ[n]
|
{z
}
Anz. d. P aram.
delta(c).rd
delta(c).lms[c.rd].st
=
=
c.rd + 1
c.f t[j].st
delta(c).lms[c.rd]size(typ(pk )) (ba(c.lms[c.rd], k )
{z
}
|
=
va(c, pk )
delta(c).prog
=
delta(c).rds[c.rd − 1]
=
c.f t[j].body; r
(j-te Fn. der Funktions-Tabelle)
(m : a)
∀k<n:
(m,i)
5.8
72
Compilieren
C0 -Maschine:
Konfiguration:
insbesondere:
c = (nt, tt, gm, hm, lms, nf, f t, rd, lms, rds, hm, prog)
c.prog Programmrest (< AnF >)
Startkonfiguration von C0 :
c.prog = c.f t[0].body
Funktionen:
Anzahl:
spezifiziert in:
body’s:
c.nf
c.f t[0 : c.nf − 1]
c.f t[j].body j = 0, . . . , c.nf − 1
Ableitungsbäume:
c.ft[ j ].body
Tj
→
„Wald“: T0 , . . . , Tc.nf −1 = T von Ableitungsbäumen.
5.8.1
Compiler
→
→
Der Compiler erzeugt aus T ein DLX0 -Programm: code( T ):
Vorgehensweise (vor dem Compilieren):
1. Erzeugen der Symboltabellen für die Funktionen (aus Deklarations-Teil und Parameter-Listen)
2. Erzeugen der Typtable (aus dem Typ-Deklarations-Teil)
3. Erzeugen der Funktionstabelle (aus dem Funktions-Deklarations-Teil)
Vorgehensweise (Compilieren in 2 Phasen):
1. Bäume Tj getrennt übersetzen → code(Tj )
allerdings sind einige Sprungweiten noch offen:
code(T0 )
...
code(Ti )
...
code(Tj )
...
code(Tc.nf −1 )
Sei in code(Ti ) ein Aufruf von c.f t[j]:
Rücksprung: geht mit jal
Vorsprung:
es fehlt im Allgemeinen die Distanz (wenn die Funktion nach der gerade übersetzten Funktion
2. nicht aufgelöste Distanzen einsetzen
5.8.2
73
Übersetzen der Bäume
Ebenfalls in 2 Phasen:
e
B
id
A
AnF
An
AnF
1. code(e) erzeugen, für e:
Ausdruck A
Bedingung B
Identifier id
2. code(q) erzeugen, für alle q:
An, AnF
Ausdrücke:
Beispiel: e = x
x: Name (einer Variable)
steht irgendwo im Speicher d.m einer DLX0 -Maschine
in der Konfiguration d = (d.P C, d.GP R, d.m)
Ansatz:
Wir codieren (auf ziemlich einfache Weise) die memories c.gm, c.lms[i] und c.hm im Speicher der DLX0 Maschine.
74
C0 -Maschine:
i
0
gm
ր
→
ց
j
typ
el
t′ (n)
ct : [0 : size(gm) − 1] → sv
..
.
gm.nv − 1
lms(0)
..
.
lms(c.rd − 1)
hm
• size(gm) =
Pgm.nv − 1
i=0
size(g.typ[i])
• Der Compiler kann size(gm) berechnent
• Der Compiler kann size(lmf ) (für alle deklarierten Funktionen) berechnen





n − t′
5.9
75
Codierung von C0 -Konfigurationen in DLX0 -Konfigurationen
Ausdrücke:
F1 = c.f t[i]
|
{z
}
i−te deklarierte F n.
Funktions-Stack:
SBASE
FS
Funktions-Frame
F0
Funktions-Frame
Frd-1
Funktions-Frame
Base(F0)
Base(Frd-1)
gespeichert in GPR[30]
Abbildung 44: Funktions-Stack
76
Fi codiert lms[i].ct und 3 Wörter mit Zusatzinformationen:
Base(Fi)
Fi.ra
1
Fi.rds
1
base(Fi-1)
1
lms[i].ct[0:size(lms[i])-1]
size(lms[i])
Abbildung 45: Funktions-Frame
Base(Fi )
Basisadresse von Frame i im DLX0 -Speicher d.m
(i.A. erst zur Laufzeit bekannt)
Fi .ra
Rücksprungadresse
(beim Aufruf mit jal berechnet und hier gespeichert)
Fi .rds
Ziel für Rückgabewert
(hier wird das Ergebnis der Funktion gespeichert)
Base(Fi−1 )
Zeigt auf Fi−1
(wird bei Rücksprung aus Fi in GP R[30] geschrieben)
Wenn es gelingt diese Planung während der Laufzeit des übersetzten Programms einzuhalten (Induktionsbewes über die Laufzeit), dann kann man zu Laufzeit auf Werte von Variablen im gm (relativ zu SBASE)
und im lms[rd − 1] zugreifen (relativ zu GP R[30])
Detail:
(m′ , i) = x
Variable der C0 -Maschine
m′ ∈ gm, lms[rd − 1]
|
{z
}
ltop
77
Wo steht der Wert von va(c, x) in c.m′ .ct?
c.m'.ct
0
1
Displacement*
i
va(m',i)
size(m'.typ[i])
*Displacement:
displ(i, m′ )
=
X
size(m′ .typ[j])
j<i
= displ(i, f )
Sei
⇒
m′
m′′
displ(i, m′ )
=
=
=
lms[a] zu Funktion f
lms[b] zu Funktion f
dipl(i, m′′ )
Das Displacement displ(i, f ) (zur Compile-Zeit bekannt!) hängt nur davon ab, zu welcher Funktion f das
lms[a] gehört.
Sei
y
m
adr(c, y)
:
:
=
Name
memory zu f
(m : ba(m, i))
| {z }
displ(i,f )
typ(c, y)
va(c, y)
:
:
simple
va(m,i)



















C0 -Semantik
DLX0 -Code lädt va(m, i) = va(c, y) in GP R[u]
lokal (aus rd) GP R[u] = m[GP R[30] + displ(i, f ) + 3]
global (aus gm) GP R[u] = m[SBASE + displ(i, f ) ]
5.9.1
78
Definition: Compiler - Korrektheit
Der Compiler ist korrekt falls:
∀ Rechnungen C 1 , C 2 , ..., mit Programm P
∀ Rechnungen d1 , d2 , ..., ds(i) , ..., mit code(P )
∃S : N → N Schrittzahlen : ∀i : ds(i) kodiert C i .
C0-Konfiguration
DLX - Konfiguration
gm
GM
lms(i)
F i
Frames zu Funktion Fji
lms(rd-1)
topl
C0 - Konfiguration
x=(m,i) Variable von C −→ Wo steht va(C, x) in d.m
x=(m,i) g - Variable von C
DLX
m
C
x=(m’,i),s
abase(C,x)
size type(x)
Gewünscht: ∀x : typ(x) - elementar:
va(C, x) = d.m(abase(C, x)) e-Konsistenz
e − consis(C, abase, d)
5.9.2
Definition: abase
Frames
base(C, GM ) = sbase
base(C, F0 ) = sbase + size(GM )
base(C, Fi+1 ) = base(C, Fi ) + size(Fi )
| {z }
3+size(fji )
Bemerkung: fji
erst zum Compilerzeit bekannt.
Variablen (m′ , j)
abase(C, (m′ , j)) = base(C, m)
e + displ(j, m′ ) +3
{z
}
|
base(j,m′ )
(
Fi
m
e =
GM
79
m′ = lms(i)
m′ = gm
Namen n
abase(C, n) = abase(C, bind(C, n))
| {z }
Variable
(
(C.topl, i) (1) C.topl.name(i) = n
bind(C, n) =
(C.gm, i) ∼ (1) ∧ gm.name(i) = n
g-Variable und Identifier
e = (m, i)s
abase(C, e[i])
abase(C, e.n)
= abase(C, e) + i.size(typ(C, e))
X
= abase(C, e) +
(typ(C, tj ))
j<i
∗
abase(C, C.e )
später bei code(u = new
t∗ ) definieren .
typ(C, x) = t∗
va(C, x) = (m′ : a)
m
m’. ct
a
gv((m’:a),t)
x
d.m
abase(C,x)
abase(C,gv((m’:a),t)
(m′ : a) Basisadrese einer g-Variable (gv((m : a), t))
d - Speicher
abase(C, x)
abase(C, gv((m′ : a), t))
(m′ : a) = va(C, x)
p − consis(C, abase, d) : ∀x : typ(C, x) = t∗ : d.m(abase(C, x)) = abase(C, gv(va(C, x), t))
d kodiert C
consis(C, abase, d) ↔
e − consis( · · · ) · · · ∧
p − consis( · · · ) · · · ∧
r······∧
c······
Notation: g - Ausdruck : A, B, id
Ableitungsbaum von f , Funktion in P
u
v
u : g Ausdrücke
v : AnF, An
• g - Ausdrücke compilieren.
• Auswertung: entlang den Knoten des Baums, von Blättern zur Wurzel.
5.9.3
Beispiel
e= a1 + a2+a3 + a4 + . . .
+ a40
• Wahl bei Reihenfolge
• beeinflüßt die Anzahl der benötigten Register.
5.9.4
Exkurs: Aho-Ullmann-Algorithmus
Spiel auf DAG’s (Directed Acyclic Graphs)
hier: Bäume
Spielzüge:
Marken (engl. pebbles) auf Knoten setzen oder entfernen.
80
81
Regeln:
1. u Quelle
oder
2.
3.
Ziel:
Jede Senke hat irgendwann eine Marke. Minimiere die Anzahl der Marken gleichzeitig auf dem Graphen.
τ (n) = min{
x| jeder Baum mit n inneren Knoten und mit
indegree = 2 kann mit x Marken markiert werden}
5.9.5
Satz: Ahu-Ullmann
τ (n) ≤ ⌈log n⌉ + 2
Beweis:
Induktion über n.
I.A n = 1
oder
I.S n − 1 → n
T Baum mit n Knoten, w Wurzel.
Fall 1:
T’
T’: n-1 Knoten
w
• Markiere T ′
• Nur die Marke auf w’ halten
• Markiere w
τ (n)
≤ max{τ (n − 1), 2}
≤ max{⌈log(n − 1)⌉ + 2, 2}
≤ ⌈log(n − 1)⌉ + 2
≤ ⌈log n⌉ + 2
Fall 2
T1
T2
w1
w
2
w
OBdA : 2 ≤ T2 ≤
n
2
• Markiere T1
• Lasse Marke auf w1
• Markiere T2
• Lasse Marke auf w2
• Markiere w
τ (n)
n
≤ max{τ (n − 1), 1 + τ ( ), 2}
2
n
≤ max{⌈log(n − 1)⌉ + 2, 1 + ⌈log( )⌉ + 2, 2}
2
≤ max{⌈log(n − 1)⌉ + 2, ⌈log n⌉ − 1 + 1 + 2, 2}
≤ ⌈logn⌉
82
5.9.6
83
g-Ausdrucksübersetzung
Ableitungs-Baum:
u
j
T
Es gelte:
e − consis(c, abase, d)
p − consis(c, abase, d)
(r − consis(. . .))
∀ i: Aus Move mi generiere ecode(i), so dass:
• starte DLX0 in Konfiguration d
• sei d(i) Konfiguration, die nach Abarbeitung von
E(i) = code(e1 ) . . . code(ci )
erreicht wird
• d →∗E(i) d(i)
∀ j (Marken), ∀ u (Knoten, g-Ausdrücke in T ), so dass nach Zug mi Knoten u Marke j hat.
Induktionsbehauptung:

: R(u) = 1, typ(c, m) 6= ptr(t)
 va(c, u)
abase(c, u)
: R(u) = 0
d(i).GP R[j] =

abase(c, gv(va(c, u), t) : R(u) = 1, typ(c, m) = ptr(t)
5.9.6.1
Annotation des Ableitungs-Baums T mit Prädikat R
Left:
x
|{z}
abase
=
Right:
x + z + 2
{z
}
|
va
Definiere rekursiv von der Wurzel zu den Blättern:
R(u) = 1
R(u) = 0
=
=
berechne va(. . .)
berechne abase(. . .)
84
e
An
AnF
return
Vorkommen von g-Ausdrücken:
R(e) Typ
0
Zuweisung (links)
e = ...
1
Zuweisung (rechts)
... = e
1
Parameter
f (. . . , e, . . .)
0
Funktionsaufruf (links) e = f (. . .)
1
Bedingung
if e . . .
while e . . .
rumpf(f)
Induktionsschritt: Wurzel → Blätter:
v
w
u = v◦w
u
u = v◦w
u = v[w]
u = v.n
u = &v
ecode(ui )
:

 remove(j)

mi setzt Marke k auf Knoten u
: kein code
: sonst
◦ ∈ +, −2 , ·, /, ∧, ∨
R(v) = R(w) = 1
◦ ∈ −1 , ∼
R(w) = 1
R(v) = 0
R(v) = 0
R(v) = R(u) (?)
R(v) = 0
5.9.6.2
Ausdrücksübersetzung
85
Fälle:
1. u Konstante u ∈ {0, 1}32
ecode(mi ): 2 DLX0 -Instruktionen
GP R[k] := u
2. u Name
bi (c, u) =
(Übung!)

(gm, j)



(topl, j)



: u nicht lokal → abase(c, u) = SBASE + displ(j, gm)
: u lokal → abase(c, u) = base(Frd−1 ) +displ(j, gm)
|
{z
}
GP R[30]
(f : Funktion deren Rumpf gerade übersetzt wird)
ecode(mi ) : R(u) = 0
u nicht lokal:
u nicht lokal:
GP R[k] := SBASE + displ(j, m)
|
{z
}
2 Instruktionen
u lokal:
GP R[k] := GP R[30] + displ(j, f )
{z
}
|
1 × add.imm
R(u) = 1: zusätzlich GP R[k] dereferenzieren
GP R[k] := m[GP R[k] + 0]
{z
}
|
load
Korrektheit:
R(0) : u lokal
d(i).GP R[k] = c.GP R[30] + displ(j, f )
(Lemma: c.GP R[30] = d(i).GP R[30])
= base(Fc.rd − 1 ) + displ(j, f )
(r − consis(c, abase, d))
= base(bind(c, u))
( Def.: bind)
= abase(c, u)
(Def.: abase(c, N ame))
(triviales Nachrechnen)
R(1) : d′ (i) nach einem weiteren Schritt
d′ (i).GP R[k]
=
=
=
d.m[d(i).GP R[k]]
d.m[abase(c, m)]
va(c, m) (e − consis(. . .))
86
3. u = v ◦ w
v
a
b
w
(a)
v
u
(b)
w
u
k
Induktions-Vorraussetzung (i − 1):
d(i − 1).GP R[a] =
d(i − 1).GP R[b] =
va(c, v)
va(c, w)
Code:
GP R[k]
:=
GP R[a] ◦ GP R[b]
Korrektheit:
=
d(i).GP R[k]
d(i − 1).GP R[a] ◦ d(i − 1).GP R[b]
((DLX0 -Semantik)
= va(c, v) ◦ va(c, w)
= va(c, v ◦ w)
((C0 -Semantik)
4. u = v[w]
v
a
b
w
u
k
Induktions-Vorraussetzung (i − 1):
d(i − 1).GP R[a]
d(i − 1).GP R[b]
typ(c, v)
abase(c, v[w])
=
=
=
=
abase(c, v)
va(c, w)
t
abase(c, v) + va(c, w) · size(typ(c, v))
Code:
GP R[28]
:=
GP R[b] · size(typ(c, v))
|
{z
}
buing: M ult.−Alg.
GP R[k]
:=
R(u) = 0
R(u) = 1
:
:
Korrektheit: (Übung)
GP R[a] + GP R[28]
f ertig
deref erenzieren
5. u = v.n
(Übung!)
6. u = v∗
v
a
u
k
R(u) = 0:
GP R[k]
:=
GP R[a]
R(u) = 0:
zusätzlich dereferenzieren
7. u = &v
GP R[k]
:=
GP R[a] (?)
87
5.9.7
88
r-Konsistenz
Zur Veranschaulichung, siehe Funktions-Stack (Abb. 44, Seite 75) und Funktions-Frame (Abb. 45, Seite 76).
d : F unktions − Stack
r − consis(c, , d)
SBASE
Variablen mit
Namen
base(H)
Variablen ohne
Namen
Amax
GPR[29]: heap pointer
Abbildung 46: Heap und Stack im DLX0 -Memory
base(H)
=
min{ abase(hm, j) |j < c.hm.nv}
{z
}
|
C0 -Variable
im Heap
d.GP R[30]
d.GP R[29]
=
=
base(c, Fc.rd−1 )
base(c.H)
5.9.8
c-Konsistenz
d : F unktions − Stack
c − consis(c, d)
q : An, AnF in Funktion f
↓
code(f ) : Folge von DLX0 -Anweisungen
Sei
start(s)
Folge von DLX0 -Anweisungen
1. Adresse, die von code(s) belegt ist
s
:
start( code(q) )
code(q)
f irst(q) =
½
l( code(q) )
q
erste Anweisung von q
: falls q < An >
: falls q < AnF >
c.pr
:
Folge der noch auszuführenden C0 -Anweisungen
f irst(c.pr)
↓
code(f irst(c.pr))
:
erste dieser Anweisungen
:
übersetzte erste Anweisung
start(code(first(c.pr))) = d.PC
89
5.9.9
Satz
Zu C0 -Rechnung c1 , c2 , . . .
∃ DLX0 -Rechnung
∃ Funktionen
∃ Schrittzahlen
d 1 , d2 , . . .
alloc1 , alloc2 , . . .
s(1), s(2), . . .
so daß ∀ Schritte i der C0 -Maschine
consis(ci , alloci , ds(i)
Beweis:
Mit Ausnahme von c − consis(. . .) einfaches Ausrechnen
5.9.10
Pre-Order-Traversal
Reihenfolge der Erzeugung der code(u): Pre-Order-Traversal
u
return
T
P OT (T )
rumpf
:
:
Baum
pre-order-traversal von T
(Permutationen der Knoten von T )
Definition (rekursiv):
1. T = u
2. T = T1 . . . Ts = u
:
:
P OT (T ) = u
P OT (T ) = P OT (T1 ), . . . , P OT (Ts ), u
Beispiel:
6 7
9 10
5
8
4
2
3
1
P OT (T ) = 4, 6, 7, 5, 2, 9, 10, 8, 3, 1
90
5.9.11
Code-Generierung
Fälle:
1. Zuweisung q : e = e′
code(e)
code(e′ )
• R(e) = 0
• Ergebnis in GP R[i]
• Marke j nicht verwenden ⇔ GP R[j] nicht überschieben
• Ergebnis in GP R[k]
m(GP R[j] + 0) = GP R[k]
store
Korrektheit: leicht ( mit Ausname von c − consis
e − consis
p − consis
r − consis
c − consis
2. Speicherallozierung q : new
t∗
U
abase(C,u)
new
GPR[29]
GP R[29] := GP R[29] − size(t)
code(u)
• R(u) = 0
• Ergebnis in GP R[j]
Heap größer
91
92
• Adresse des Pointers in GP R[j]
• Pointer setzen:
m(GP R[j] := GP R[29]
3. Anweisungsfolge q : AnF ; An
T1
T2
;
q’
q’’
q
= q ′ ; q ′′
q
q′
q ′′
• code(q) = code(q ′ ); code(q ′′ ) -
:
:
AnF
An
automatisch bei POT.
4. If - Anweisung q : if a then b1 else b2
Übung
5. While - Schleife q : while e do u
code(e)
1
code(v)
beqz
j
code(e)
• Ergebnis in GP R[k]
• beqz
P C := P C + GP R[k]?l(code(u) + 2) : 1
• l(code(u)) - bekannt (POT)
code(u)
• j
P C := P C − (l(code(u)) + l(code(e)) + 1)
93
6. call q : e0 = g(e1 , · · · , ek ) in Rumpf(f)
Werte in Pass 1 offen
jal
code(f)...
code(q’)
code(g)
p1 , · · · , pt - Parameter von g
F c.rd-1
zu f
ra
rds
F i-1
p
GPR[30]
p
1
F
\delta(c).rd-1
zu g
t
p(code(i)) : übergibt Parameter (i)
p(code(1)), · · · , p(code(t))
ecode(Ri ))
p(code(i))
• R(ei ) = 1
• Ergebnis in GP R[ji]
• m(GP R[30] + (size lmf + 3) + 3 + i − 1) := GP R[ji]
rds
ecode(e0 )
• R(e0 ) = 0
• Ergebnis in GP R[j]
• m(GP R[30] + (size(
) + 3 + 1) := GP R[j]
altes GP R retten
• m(GP R[30] + (size(
) + 3 + 2) := GP R[30]
stack Pointer auf neuen Top Frame.
• m(GP R[30] := GP R[30] + size( ) + 3
• bis hierher : code(q ′ )
• m(GP R[1] := start(code(g))
bekannt nach Pass 1
jal:
• P C := P C + 1, GP R[31] := P C
• GP R[31] := GP R[31] + 6
• m(GP R[30] := GP R[31]
- Rückgabeadresse
• GP R[1] := start(code(g)) - Pass 2
• P C := GP R[1] - Sprung in g
7. return Übung
94
6 ERWEITERUNGEN ZUR DLX0
95
6 Erweiterungen zur DLX0
6.1
DLX0 mit Interrupts
6.1.1
Definition: Interrupt
Ereignis, das den „normalen“ Programmablauf unterbricht, stattdessen: Aufruf einer Interrupt Service Routine (ISR).
6.1.2
Grober Ablauf
1. Interrupt wird ausgelöst
2. CPU speichert:
• Teile des aktuellen Programmzustandes (v.a. P C)
• Quelle/Grund des Interrupts
3. Behandlung des Interrupts: ISR
4. Meistens: Wiederherstellung des Zustands vor/bei Interrupts (teils Hardware, teils Software)
6.1.3
Klassifikation
Unterscheidungsmerkmale von Interrupts:
1. interner/externer Interrupt
• interner Interrupt (exception, trap)
Ausgelöst durch Prozessor oder Memory.
• externe Interrupt
Quelle ausßerhalb von CPU oder Memory (z.B. ein Gerätertreiber).
Nicht deterministisch - Zeitpunkt des Auftretens ist nicht vorhersehbar.
2. (nicht) maskierbar
maskierbare Interrupts können per Software ignoriert bzw. abgeschaltet werden.
96
3. Return Type
Sei I die unterbrochene Funktion:
• „repeat“:
nach ISR wird I ausgeführt
• „continue“:
nach ISW wird I ′ (die Instruktionsfolge von I, die ohne Interrupt aufgetreten wäre)
• „abort“:
weder mit I noch mit I ′ weitermachen
4. Priorität
Falls zwei Interrupts zeitgleich auftreten wird der Interrupt mit der höchsten Dringlichkeit zuerst behandelt
6.1.4
Interrupts des DLX0
Identifiziere Interrupts mit Nummer j ∈ {0, . . . , 31}
j → P rioritt 0: dringend
..
.
31: nicht so dringend
j
0
1
2
3
4
5
6
6+i
| {z }
i∈{1,...,25}
Abkürzung Name
Return-Type
reset
Reset/Power-Up
abort
ill
Illegal Instruction
abort
→ RA1
pf f
Page Fault Fetch
repeat
pf ls
Page Fault Load/Store
repeat
trap
Trap (SW-Interrupt)
continue
(→ leitet System-Call-routine des OS ein)
ovf
arithmetic overflow
continue/abort
exi
External I/O
continue
Maskierbar
nein
nein
Ext/Int
ext
int
nein
nein
nein
int (Mem)
int (Mem)
int
ja
ja
int
ext
6.1.5
97
Konfiguration / Register
c = (pc, spr, gpr, mem)
c.pc : {0, 1}32
c.spr : {0, 1}5 → {0, 1}32
c.gpr : {0, 1}5 → {0, 1}32
c.mem : {0, 1}32 → {0, 1}32
PC
addr
ev[0]
SPR
data
Mem
ev[6+i]
ev[3]
ev[4]
GPR
ev[0]
ev[1]
ev[2]
ev[5]
.
.
.
Abbildung 47: Special Purpose Register
Derzeit werden nur SP R′ s benutzt:
SP R[0]
SP R[1]
SP R[2]
SP R[3]
(4
SP R[5]
∼
∼
∼
∼
→
∼
SR
ESR
EP R
RA1)
Edata
(Status Register)
(Exception Status Register)
(Exception Cause Register)
(Exception Program Counter)
(Exception Data)
Berechnung :
I
I
I
3
2
1
...
C2 →
C1 →
C0 →
C 0 Startkonf iguration
δ Schrittf unktion
(!)statt δ(f r DLX0 ) schreibe nun δn
6.1.6
Definition: δ für DLX0 mit Interrupts
δ(c) =
½
δn (c) (plus einige neue Instruktionen)
C ′ (neu - siehe unten)
falls kein Interrupt
sonst
6.1.7
98
Neue Instruktionen
Zur Erinnerung:
RS1 = I[25 : 20]
RD = I[15 : 11]
SA = I[10 : 6]
T yp
R
R
R
R
I
I
I
I
6.1.8
I[31 : 26]
000000
000000
000000
000000
010000
010010
111110
111111
I[5 : 0]
010000
010001
000000
000010
%
%
%
%
Mnemonic
movsli
movi2s
add
sub
addi
subi
trap
rfe
Effekt
GP R[RD] = SP R[SA]
SP R[SA] = GP R[RD]
wie addu
wie subu
wie addiu
wie subiu
löst trap aus
SR = ESR , P C = EP C
Interrupts
Eventsignale für interne Interrupts:
ev[1] = 1
⇔
I = mem(P C)
I keine bekannte Instruktion
ev[1] = (add(I) ∨ sub(I) ∨ . . .)
|
{z
}
f r alle Instruktionen
ev[3] = 1
ev[4] = 1
ev[5] = 1
ev[6] = 1
⇔
⇔
nchste V orlesung!
nchste V orlesung!
trap(I)
(add(I) ∨ sub(I) ∨ addi(I) ∨ subi(I)) ∧ ovf (Overflow-Signal aus ALU)
Wie bereits erwähnt: ev[1] und ev[6 + i] extern!
6.1.9
Definition: nicht sichtbar
Masked Cause Register (MCR):
M CA[j] =
½
falls j nicht maskierbar ist
sonst
ev[j]
SR[j] ∧ ev[j]
(!) SR[j] bestimmt ob maskierbarer Interrupt auftreten kann.
6.1.10
Definition: JISR-Signal (Jump ISR)
JISR =
_
M CA[j]
j
6.1.11
Definition: Interrupt Level
il = min{j|M CA[j] = 1}
6.1.12
6.1.13
99
Delta-Funktion
δ(c)
=
c′ falls JISR = 1, wobei für c′ gilt:
ESR
ECR
=
=
EP C
=
Edata
=
SR
PC
=
=
SR
M
½ CR
PC
falls Interrupt il vom Typ „repeat“
u
P
C
∗
sonst
½
imm falls trap(I)
EA
falls lw(I) oder sw(I)
032
SISR Start der ISR (Konstante, z.B. 512)
Aufbau der ISR
Mem
SISR(=512)
SAVE
DISPATCH
RESTORE
H[1]
H[31]
Abbildung 48: Interrupt Service Routine (Aufbau)
Ablauf:
SAV E
DISP AT CH
H[il]
REST ORE
H[0]
-
sichere Register
ermittle il aus ECR (find first one comp)
Handler für Interrupt il
Register wiederherstellen, rf e zum Beenden der ISR benutzen
Sonderbehandlug für reset
6.1.14
100
Devices & I/O (Geräte & E/A)
CPU
Mem
Dev1
Devl
addr
data
control
(read/write)
Abbildung 49: Bus-System
CP U :
„Bus Master“, add und control werden nur durch die CPU gesteuert.
data :
Kann von allen benutzt werden, sollte aber nur von höchstens einer Komponente gleichzeitig benutzt werden.
Seien:
k ∈ N, 2k−1 < l < 2k
m ∈ N, m + k < 2k
Idee:
Gerät 1 ≤ u ≤ l, < i[k − l : 0] > = i
Gerät
über Adressen a[31 : 0] ansprechen mit:
a[31 : 32 − m] = 1m
a[31 − m : 32 − m − k] = i[k + 1 : 0]
6.1.15
101
Beispiel: Hard Disk (HD)
Festplatte mit Geräteadresse < i[k − 1 : 0] > = i:
Abbildung 50: Festplatte
• Daten werden abgelekt in Sektoren (zu je 512 Bytes)
• Sektoren haben Koordinaten:
„c“ylinder: Abstand vom Zentrum
„h“ead: „Etage“ (einzelne Platten)
„s“ector: Sektor des durch (c, h) bestimmten Kreises
Die Festplatte rechnet dies um in die lba (linear block adress):
lba ∈ {0, 1}28 : Festplattengröße ≤ 29 × 228 bytes = 128 GB
32
0
Mem
devbase1
devbase2
Dev1
Dev2
devbasel
Devl
Abbildung 51: Devbase
102
Ab Adresse devbasei = 1k i[k − 1 : 0] 032−m−k blendet die Festplatte Register ein:
busy
error
cmd
lba
count
ien
data
6.1.15.1
=
=
=
=
=
=
=
=
031 1
031 1
032
031 1
(HD beschäftigt)
(letztes Kommando lieferte Fehler)
(READ)
(WRITE)
#Sektor
(Festplatte löst Interrupt aus)
(32-bit Daten, Read/Write)
Lesezugriffe
1. CPU setzt (sw′ ), lba, count
2. CPU setzt cmd = 032
3. HD setzt busy 6= 032 solange sie liest
4. CPU wartet bis busy = 032 (*)
5. CPU prüft error 6= 032 → Fehler, Abbruch
6. CPU liest 128 Wörter (=
b 512 Bytes) vom Data Register (**)
7. Schon count Sektoren gelesen? (Nein: → wieder zu Schritt 3)
(*)
(**)
Polling
Kopieren
¾
„stupide“ Arbeit f ür die CP U
Um die CPU von dieser Arbeit zu entlasten gibt es folgende Möglichkeiten:
(*): ien6= 032 → HD löst externen Interrupt exi aus, falls non-busy
(**): DMA(direct memory access) → HD kann selbst von/in Memory lesen/schreiben
6.2
Virtueller Speicher(VM)
6.2.1
Motivation
RAM ist teuer, dagegen sind Festplatten billig. Es stellt sich also die Frage, ob es möglich ist, mit wenig RAM
und einer Festplatte viel RAM zu simulieren (eine voll ausgestatteter DLX0 kann 232 × 4 Bytes = 16 GB
adressieren!).
Ziel zunächst:
Simulation für ein Programm (user-program)
Lösung: „Demand Paging“
• lade Teile des Speichers von HD nach, wenn gebraucht
• Page: 4KB zusammenhängender Speicher (1024 Worte)
• Paging: Pages auf Festplatte speichern bzw. von Festplatte laden
6.2.2
103
Vergleich zweier Maschinen
(die alte) DLX0 :
• keine Interrupts
• keine Devices
• keine SPR’s
• memsize ∈ {0, 1}32 : Größe von Mem, nur Zugriffe auf Adressen a ∈ {0, 1}32 mit < a > < <
memsize > „erlaubt“
(die neue) DLX0 :
• mit Interrupts
• mit Devices
• mit SPR’s
• memsize
• Modes & Adress Translation
6.2.3
DLX0 mit Interrupts & Adress Translation
Konfiguration:
c = (pc, spr, gpr, pm6 , sm7 : {0, 1}32 → {0, 1}32 )
neue SPR’s:
9
10
11
16
pto
ptl
Emode
Mode
page-table origin
page-table last
exception mode
mode-flag:
031 1 : user − mode
032 : system − mode
Im user-mode (aufgrund einer Page-Table im PM):
• leite Speicherzugriff auf Adresse va ∈ {0, 1}32 um auf Adresse pa ∈ {0, 1}32 im PM
ODER
• löse Interrupt aus (Page Fault - ev[3]/ev[4]), → ISR, Page Fault Handler wird ausgeführt
6 physical
7 swap
memory (altes Mem)
memory(zusammenhängender Bereich auf HD)
6.2.4
104
Page Table Lookup
va[31 : 0] = (px[21 : 0], wx[9 : 0])
wx
px
word index
page index
Ã
Ã
P T (px)
| {z }
= PM
[ptea]
| {z }
Page Table Entry
Page Table Address
=
hpteai
hpto[21 : 0]i.1024 + hpxi
31
9
8
ppx[21:0]
v
Physical Page Index
valid Bit
( mod 232 )
7
0
Abkürzung : ppx(va), v(va)
px[21:0]
10
(pto[21:0],0 )
22
32
+
10
(pto[21:0],0 )
ppx
v
.....
PT
6.2.5
Page Fault Exception
pf (va)
=
∨
(hpx(va)i > hptli)
(v(va) = 0)
pma(va) = (ppx(va), wx(va)) ∈ {0, 1}32
| {z } | {z }
22 Bit
10 Bit
wx[9:0]
6.2.6
105
Instruktionsausführung
1. mode = 0 : alles wie vorher
2. mode = 1 : "usermode"
(a) pf (P C) = 1? → löse pf f Interrupt aus (ev[3])
(b) I = P M [pma(P C)]
• ∼ (lw(I) ∨ sw(I)) - wie vorher
• pf a(EA) = 1? → löse pf ls Interrupt aus (ev[4])
• lade /speichere von pma(EA)
Was passiert bei Interrupt?
JISR = 1
ESR
ECA
=
=
EPC
=
EData
=
PC
SR
MODE
=
=
=
SR
MCA
(
PC
PC n
(Masken)
(Quelle)
typ − repeat
typ − continue
PC n = PC vor δu (C)
(
imm bei Trap
EA
bei load/store
SISR
032
032
(start ISR)
EMODE=MODE
6.2.7
106
Simulation
Cv0
0
C0
mode
C0
Cα
Cβ
I1
I2
v
→
Cv1
v
→
···
···
→
0
C1
→
···
···
→
→
→
···
···
···
→
→
→
C α−1 Intializierung, Power-up
C β−1 User Programm
C γ−1 Page Fault Handler
Berechnung derDLX0 ohne Interrupts
v steht für virtuell
→
0
C α−1
→
1
Cα
→
···
···
User Programm und PFH wechseln sich ab.
Cv
C
=
=
(pcv , gprv , mem)
(pc, spr, gpr, pm, sm)
π : C → Cv
π bildet C-Konfiguration auf Cv -Konfiguration ab.
(mode = 1)
:
mem(va)
=
6.2.8
gprv (i) = gpr(i)
pcv = pc
(
P M [pma(va)]
SM [sma(va)]
falls pf = 0
sonst
Theorem
i - Schritt in der Berechnung von DLX0 mit Interrupts.
∼ (pf f i ∨ pf lsi )
-
kein page fault fetch,
kein page fault lode/store
∼(JISR)
modei = 031 1
j - Schritt in der Berechnung von DLXv .
π(C i ) = Cvj ⇒ π(C i+1 ) = Cvj+1
→
1
C β−1
→
0
Cβ
···
···
7 BETRIEBSSYSTEM-KERN
107
7 Betriebssystem-Kern
• abstraktes Modell:
CVM (communicating virtual machines)
k abstrakter Kern (syntaktisches C0 -Programm)
• Implementierung:
konkreter Kern (zwangsläufig
nicht C0 ):
¾
Benutzerprozesse
müssen sichtbar sein
Prozessorregister
C0A : C0 + Assembler-Makros
• Simulationssatz:
K + Benutzerprogramme auf physikalischer Maschine simulieren
k + Benutzerprogramme vom CVM-Modell
7.1
CVM: Syntax und Semantik
Konfigurationen:
c = (c.np, c.C, c.vm(p), c.cp)
c.np
:
number of processes
(c.np ∈ N)
(c.np = 1024)
prozess 1: abstrakter Kern, C0 -Maschine
c.C : Konfiguration der C0 -Maschine
prozess 2: Benutzer-Prozesse (virtuelle DLX0 -Maschinen)
c.vm(p) : Konfiguration der virtuellen DLX0 -Maschinen
(p = 1, . . . , c.np − 1)
c.cp
:
current process
(p ∈ {0, . . . , c.np − 1})
tvm
:
total virtual memory [Bytes]
c.vm(p).ptl
:
# Pages (je 4K) von der virtuellen Maschine p > 0
(4 GB)
108
Kern
k
vm(1)
vm(p)
vm(np-1)
Abbildung 52: Communicating Virtual Machine
Forderung:
4K ×
c.np−1
X
c.vm(p).ptl ≤ tvm
p=1
7.1.1
Exkurs: Syntax von k
Funktionen die k aufrufen darf:
alloc(p, x) : neue Seiten für vm(p)
f ree(p, x) : Seiten von vm(p) entfernen
Semantik:
Sei
⇒
c.cp
c.C.pr
δ(c)
=
=
=
0
alloc(p, x); r
c′
(k läuft)
(Aufruf von alloc(. . .))
(nächste CVM-Konfiguration)
c′ .C.pr
c .vm(p).ptl
=
=
r
c.vm(p).ptl + x
(abstrakt: alloc(. . .) wird in einem Schritt abgearbeitet)
′
7.1.2
109
Semantik von cp
=
=
c.cp
JISR(c.vm(p))
p>0
0
Benutzerprozess p läuft
kein Interrupt einer virtuellen Maschine (vm sieht keine PageFaults!)
δvm : Nachfolge-Konfiguration von vm:
c.vmp(p)
c′ .vm(x)
c′ C
c′ .cp
=
=
=
=
δvm (c.vmp(p))
c.vm(x) (x 6= p)
c.C
p
c.cp = 0 (k läuft)
c.C.pr 6= s; r (s: normales C0 -Statement)
¯
¯
¯
(!) Simulation kann Handling
¯
¯
von Page-Faults efordern
¯
¯ (Interrupt auf physikalischer Maschine)
¯
start: Statement von k (startet UserProzess ’act’)
act: int-Variable von k
c′ .C = δc (c.C)
δc : Nachfolge-Konfiguration für C0 -Maschinen
c′ .vm(p) = c.vm(p)
¾
Kern läuft lokal
7.1.2.1 Kontrolle von k an User
Sei c.C.pr = startu; r
c′ .C.pr = r
p = va(c.C, act)
c′ .cp
⇒
=
p
7.1.2.2 Kontrolle von vm(p) an k
Dies ist nur durch Interrupts (traps!) möglich.
7.1.3
Semantik von Interrupts
Speziell:
traps = kernel calls (= Prozedur-Aufrufe)
Sei
⇒
c.cp
JISR(c.vm(p))
trap(c.vm(p))
< imm(c.vm(p)) >
=
=
=
=
p > 0
1
1
i
Aufruf von kernel call i durch abstrakten Kern k
(Prädikat wie add.load)
(Parameter von trap = i)
7.1.4
110
Formalismus zum Spefizieren der Handler von Kernel Calls
Analog zur Funktions-Definition in C0 -Konfigurationen:
c.C.f d : [0 : nf − 1] → F D
nf = # C-Funktionen des Kerns
Sei npar(x) = # Parameter der x-ten Funktion von k
c.nkc ∈ N
c.kcd : [0 : c.nkc − 1] → [0 : c.C.nf − 1]
7.1.4.1
Definition der Wirkung von trap(i)
c′ .cp = 0
′
c .C.rd = c.C.rd + 1
rufe auf:
xi
=
c.kcd[i]-te Funktion von k
npar(xi)
m
(gibt es, function declaration)
(number of kernel calls)
(kernel call definition)
(Kern k läuft)
(Funktionsaufruf)
(hat npar(xi ) Parameter ≤ 20)


















local memory für xi -te Funktion
j-ter
Paramter: c.vm(p).GP R[j] (j ≥ 1)

















Für kernel calls:
Semantik von return(e) nach rds zurückgeben.
c′ .C.rds(c′ .C.rd) = p
return(e) : Rückgabewert an GP R[1] von p
typ der Parameter
typ des Rückgabewerts
:
:
int
int
(aufrufenden Prozess merken)
7.2
111
CVM mit I/O-Devices
D(0)
D(d)
D(nd-1)
(I/O Devices)
Kern
k
vm(1)
vm(p)
vm(np-1)
Abbildung 53: Communicating Virtual Machine mit I/O Device
7.2.1
IS
ES
SP
Wiederholung: Interrupts
¤
0
= reset
Boot-Routine
=
=
=
1
2
=
=
ill
mal
3
4
=
=
pf f
pf ls
5
=
trap
6
7
8
9
10
11
=
=
=
=
=
=
XOV F
OV F
UNF
IN X
DBZ
IN V
12
=
timer
13
..
.
=
timer
=
timer
[6 : 11]
[13 : 31]
{1, 2, 12}
¸
¤
werden vom konkreten Kern behandelt
k-Funktion



 floating point


¤
#
Scheduler




 „goto“ im Benutzer-Programm



exti von D(d) (User Prozesse)
(IEEE - FP+XOVF)
(extern)
„special“ (Handler von Kern-Funktionen)
7.2.2
112
return
klassisch (C: C0 -Konfiguration)
Sei
C.pr
C ′ .rd
C.rds(rd)
=
=
=
c′ .m.ct[a]
=
aus kernel call
return(e); r
C.rd − 1
(m
| {z: a}) m ∈ {gm, hm, lms(c.rd − 1}
rds
va(C.e)
c′ .C.rd
c.C.rds(c.C.rd)
=
=
c′ .vm(p).GRP [1]
=
c.C.rd − 1
p
va(c.C.e)
| {z }
(!) typ(c.C.e)=int
7.2.3
Kernel Calls
c.cp
trap(c.vm(p))
< imm(c.vm(p)) >
c.kcd(i)
=
∨
=
=
p > 0
il(c.vm(p)) = 5
i
j
Sei
n
=
c.C.f d(j)
⇒
• c′ .cp
=
0
k läuft
Sei
n
• |c′ .C.rd
{z }
=
=
k.nparam
c.C.rd + 1
(# Parameter von k)
(neues lm und rds)
=
=
=
c.C.lms(rd′ )
h.st
c.vm(p).GP R[i]
(neues top local memory)
(Symbol table übernehmen)
=
=
p
n.body; c.C.pr
(Rückgabe an Prozess p)
rd′
tlm(c′ )
• tlm(c′ ).st
′
• tlm(c ).ct[ba(h, i)]
| {z }
i
• c′ .C.rds(rd)
• c′ .C.pr
7.2.3.1
Sei
(Benutzerprozess)
bin26 (i)
)
( trap
(k-Funktion mit Restriktor c.C.f d(j) behandelt trap i)
i = il(c.vm(p)) ∈ SP („special“)
c.shd : SP → [0 : c.C.nf − 1] (special handler definition)
j
j
=
=
..
.
c.shd(j)
c.shd(j)
Rest weiter wie trap
7.2.3.2
i = il(c.vm(p)) ∈ IS
c.ihd : IS → {0, 1}32
′
c .vm.P C = c.ihd[i]
(schlichtes goto)
7.2.3.3
i ∈ ES
113
c.hd
:
ES → {
p′
=
c′ .cp (= c.hd[i])
c.dbase
c.dbase(p)
c′ .v,10 [c.dbase(p′ )]
:
:
=
[0 : np − 1] → N
Start der data section
c.vm(p).GP R[10 : 1]
c′ .vm(p′ ).P C
=
032
1, . . . , np − 1
|
{z
}
}
auf ruf ender P rozess
(Aufruf des Prozesses)
dbase + 10
dbase(p')
GPR[1:10]
Code
Section
0
vm(p').m
Abbildung 54: vm(p′ ).m
7.2.4
114
„User-Functions“
k: C0 -Programm + startu + vorderfinierte
|
{z Funktionen}
z.B. alloc,f ree
• c.cp = 0
k läuft
• c.C.pr = setmasks(p, e); r
c′ .C.pr = r
c′ .vm(va(c.C.p)).SR = va(c.C, e)
Notation: x
e = va(c.C, x) (x: g-Ausdruck)
⇒ c′ .vm(e
p).SR = ee (Status-Register SR speichert Masken)
• copy(p1 , p2 , s1 , s2 , l)
von p1 (ab s1 ) nach p2 (ab s2 ) l Daten kopieren:
c′ .vm(pe2 )el (se2 ) = c.vm(pe1 )el (se1 )
• Handler-Definitionen (sethd(i, j) / setihd(i, j))
c′ .hd(ei) = e
j
• reset(p)
ptl(p) = 0 . . . (einfachste Primitive?)
• f ork(p, q)
q Kopie von p (einfachste Primitive?)
7.2.5
115
Devices
c.nd
c.dsize
:
:
number of devices
[0 : c.nd − 1 → N
(# Ports)
Definition: I/O-Port:
Adresse die von I/O-Devices belegt wird.
c.iop[p]
:
[0 : c.dsize − 1] → {0, 1}32
|
| {z }
{z
}
Adressen
(Speicher-iop)
Inhalt
iop verhält sich manchmal wie ein Speicher
c.alk[d] ∈ {0, 1}
(1: aktiv)
c′ .akt[d]
testen von c′ .akt[d]
typisch:
¾
Device-spezifisch
• externer Interrupt von Device d ⇒ akt[d] = 0
• Kommando an Device d ⇒ akt[d] = 1
Nur bei c.akt[d] = 0 (!):
• outcopy(p, d, s1 , s2 , l)
e e(se2 ) = c.vm(e
p)el (se1 )
c.iop(d)
l
′
e ei) = c.iop[d](
e ei) i ∈ [se2 + ei − 1 : se2 ]
c .iop[d](
• incopy(d, p, s1 , s2 , l)
c′ .vm(e
p)el (se2 ) = c.iop(deel (se1 )
c.akt[d] = 0 ∧ c.C.pr 6= outcopty(. . .)
c′ .iop[d](i) = c.iop[d](i)
|
{z
}
Speichersemantik
7.3
Definition: C0A (C0 mit Assembler-Code)
Konkreter Kern K ∈ C0A wird um den abstrakten Kern k herumprogrammiert:
• Syntax: neues Statement: asm(s) (Asembler-Marko, s : Folge von DLX0 -Instruktionen)
• Compilieren: code(asm(s)) = s
• (!) Semantik von C0A -Programmen (nutze abase vom Compiler)
• (!) kconsis(k, kbase, K) : K codiert k
• Konstruktion von K
• Simulationssatz
116
7.4
117
Konkreter Kern K
K ∈ C0A (= C0 + asm(s)8 )
7.4.1
Semantik
δA (cc9 ) → cc′ | cc.pr = asm(s); r (DLX0 -Konfuguration d sichtbar für K)
(! Geht nicht !)
δA (cc, d) = cc′
|
{z
}
Eingabe der C0A -Maschine
code(K) läuft auf physikalischer DLX0 -Maschine. Die Konfiguration der physikalischen Maschine nennen
wir d.
d.m (physikalischer Speicher)
dtop(0)
dbase(0)
(=SBASE)
Kcbase
data(K)
code(K)
12 K
8K
0
scratch
Boot
ROM
(read only memory)
vm(p').m
Abbildung 55: Memory Map
8 Folge
9C
von DLX0 -Instruktionen
0 -Konfiguration
7.4.2
118
Restriktionen an asm(s)
s liest/schreibt aus/in data(K) in Konfiguration d (ea(d) ∈ [dtop(0) : abase(0)])
⇒ ∃ x = (gm, j)s (globale g-Variable)
ea(d) = abase(6 d, x)
(bei globalen Variablen unabhängig von d)
Definition:
abase(x) = abase(d0 , x)
cc.pr = asm(s); r
δA (cc, d) = cc′
Es gelte d →∗s d′ , d.h.:
∃ T:
d0 → d1 → . . . → dT
=
d
↓
↓
↓
definiere:
cc0
cc1
ccT = cc′
Fall 1: store(di ) ∧ ea(di ) = abase(c)
(x gibt es durch die Restriktion) falls ea(di ) ∈ Data(K)
⇒ va(cci+1 , x) = d.GP R[RS1(di )]
Fall 2:
d
=
sonst
cci + 1 = cci
cc.pr = m; r (im Assembler-Makro)
⇒ cc′ .pr = body(m); r
(body(m) aus Makro, Definition: Syntax con C0A )
7.4.3
119
Datenstrukturen des konkreten Kerns K
• alle vom abstrakten Kern k
• globale Variable act (aktueller Prozess)
• Array von processed control Blöcken
pcb(p), p ∈ [1 : np − 1]
pcb:
GPR[31:1]
SPR[ : ]
vor allem ptl, pto
PC
spt 0
ihd[ : ]
swap page table origin
Handler Definition für IS
Abbildung 56: Processed Control Block
• array hd[ : ]: Handler-Definitionen für il ∈ ES
• page-table-array
(insgesamt: 4 × tvm / 4K = 4 × 4 GB / 4 k = 4 M B)
pp:
pt(1)
pcb(i).pto
pt(i)
pcb(i).ptl
Abbildung 57: Page Table Array
120
• swap memory page-table:
sm-pages: 1 MB Größe = 256 × 4Kpages
va = (spx(va), sbx(va))
| {z } | {z }
12 bit
20 bit
pp:
spt(1)
pcb(i).spto
spt(i)
sptl = ptl(i) / 256
Abbildung 58: Swap Page
• free list: verlinkte Liste der freien sm-pages
x: g-Variable, va(c, x), c: C0 -Konfiguration
val(e, x) e : physikalische DLX0 -Konfiguration
x global, elementar:
val(e, x) = e.b[abase(x)]
e → vm(e, p):
die von e codierte p-te user-Konfiguration
Komponenten:
vm(e, p).R CPU-Register (GPR, SPR, PC)
vm(e, p).m virtueller Speicher
½
vm(e, p).R
e.r :
va(e, pcb(p).R) :
p „läuft“ in Konfiguration e
sonst
p läuft in Konfiguration e ↔ emode = 1 ∧ va(e, act) = p
½
vm(e, p).m(va)
e.m[pma(e, p, a)] :
e.sm[sma(e, p, va)] :
valid(e, p, va)
sonst
physikalischer Speicher e.m ist Cache für swap memory sm.
pma(e, p, va)
ppx(e, p, va)
pte(e, p, va)
valid(e, p, va)
sma(e, p, va)
=
=
=
¾
(ppx(e, p, va), bx(va))
pte(e, p, va)[31 : 12]
va(e, P P [val(e, pcb(p).pto] + ppx(va))
Klausur-Aufgabe
7.5
121
Simulationssatz
gegeben:
C0 : Startkonfiguration von CVM
in1 , in2 , . . . (Inputs für physikalische Maschine)
Behauptung:
∃ c0 , c1 , c2 , . . . CVM-Rechnung
∃ cc0 , cc1 , cc2 , . . . Folge von C0 -Konfiguration für K
∃ d0 , d1 , d2 , . . . DLX0¾
-Rechnung (physikalische Maschine)
∃ s(0), s(1), s(2), . . .
Schrittzahlen
∃ t(0), t(1), t(2), . . .
¾
0
1
2
∃ abase , abase , abase , . . .
(bekannt!)
allocation
∃ kbase0 , kbase1 , kbase2 , . . . (bisher unbekannt!)
i
i
s(i)
∀ i : kconsis
| {z } (c .C, kbase , cc )
ebenfalls neu!
nach s(i) Schritten von K sind i Schritte von CVM bezüglich k simuliert
∀ i : consis(ccj , abasej , dt(j) )
nach t(j) Schritten von DLX0 sind j Schritte von K simuliert
(noch zu definieren: kconsis, kbase)
∀ i, ∀ p : ci .vm(p) = vm(dt(s(i)) , p)
∀ j : ccj+1 = δA (ccj , dt(j) )
„Kindereien“:
7.5.1
t(s(i))
ci .ptl(p)
, pcb(p).ptl)
¾ = va(d
ihd
Bonus-Aufgabe, Klausur
ha
Definition: konsis(cc, kbase, c)
konsis(cc, kbase, c)
↔
e − konsis(cc, kbase, c)
∧ p − konsis(cc, kbase, c)
∧ c − konsis(cc, c)

 ¯

 ¯¯
von
Konfiguration
c
V ar(c) = x ¯¯X Variable

 ¯ | {z }
(m,i)
kbase: V ar(c) → V ar(cc)
kbase(m, i) = (m, i) (gleiches m)
(m, j) von cc kodiert, (m, i) von c
7.5.2
Definition: e − konsis(c, kbase, cc)
Sei (m, i)s elementare g-Variable von c:
⇒
va(c, (m, i)s) = va(cc, (kbase(m, i))s)
7.5.3
122
Definition: p − konsis(c, kbase, cc)
Der heap von c ist isomorth zu einem subgraph von cc:
c
cc
kbase
m.ct
ba((m, j)s)
m' : a
m'.ct
a
va(c,x)
Abbildung 59: p − konsis(c, kbase, cc)
=
t∗
va(c, (m, j)s)
x
=
=
m′ : a
gv(c, m′ : a, t)
va(cc, (kalloc(m, j))s)
=
=
=
ba(cc, x)
ba(cc, gv(c, m′ : a, t))
ba(cc, gv(c, (m, j)s), t)
type((m, j)s)
{z
}
|
c
va(cc, (kalloc(m, j))s)
7.5.4
später!
Definition: c − konsis(c, cc)
7.6
1.
123
Korrekturen
c0
c1
c2 | CVM
0
1
cc
cc
cc2 | K
0
1
d
d
d2 | physikalische DLX0
konsis(ci .C, kbasei , ccs(i) )
c − konsis(ci .C, abasei , dt(i) )
2.
6
11
SR
IS
maskierbar durch Benutzer
CVM-Funktion in K: SR[11 : 6] = {0, 1}6
3.
C0 -Datenstruktur für K
1
lsi(p)
np−1
lsi
lsi(p):
page fault handler (pf f, pf ls)
Grund:
4.
7.6.1
last page swapped in for process p
swappen lsi(p) nicht raus
Terminierung bei zwei Page-Faults in einer Intruktion
c → c′ :
c.cp = p
JISR(c.vm(p))
il = (c.vm(p)) ∈ ES
handler:
prozess p′ = c′ .cp = c.hd(il) (wie bisher)
c.vm(p′ ).R = δd (c.vm(p)).R
R ∈ EHR = {EP C, EDAT A, ECAU SE} (error handling register)
Notation: body(. . . , . . .)
body(main, P ) : body von Funktion main in Programm P
7.7
124
body(main, k)
1. initk (initialisieren):
• Scheduler-DS (Datenstrukturen)
• create root (Haupt-Bestriebssystem-Prozess)
|
{z
}
Prozess 1
code, data (laden)
platz, zeit (zuweisen)
2. act = 1
3. while
1 do{zstartnextu}
|
loopa
7.8
body(main, K)
1. initK (initialisieren):
• Datenstrukturen für memory management
• leere Benutzerprozesse
2. initk
3. act = 1
4. while 1 do {startnextu, dispatch}
{z
}
|
7.9
|
{z
Makro’s
loopc
}
Definition: c − consis(c, cc)
c − consis(c, cc)
↔
c.pr = apr(cc.pr)
|
{z
}
aktrakter pr
cc.pr
r; loopc
(disp, startnextu nicht in r)
startnextu; disp; loopc
disp; loopc
Bemerkung: apr streicht disp
apr(cc.pr)
r; loopa
startnextu; loopa
loopa
7.10
125
Bootstrap
e.m
boot:
(physikalische Maschine)
scratch[1:0] = GPR[1:2]
reset?
nein
goto disp
ja
disp
code(K)
dispbase
load K
*code
*data
SBASE(0) = kcbase
scratch[3:2] = dbase, kcbase
kcbase
dispbase
GPR[2]
GPR[1]
goto kcbase
boot
Abbildung 60: Bootstrap
Bemerkung:
Nach boot und initk gilt der Simulationssatz für C0 (Induktions-Anfang)
startnextu:
pcb(act).R (CPU-Register restaurieren, R 6= P C)
e.EP C = pcb(act).EP C
rf e
disp:
1)
2)
CPU-Register in pcb(act) retten:¾
GP R[2 : 1] aus scratch[1 : 0]
(asm(. . .))
alle anderen aus CPU
il berechnen:
m in {pcb(act).ECA[j] = 1} (il 6= 0)
scratch
8K
Fälle:
a) il = 5 (trap)
i = < pcb(act).EDAT A > (kcall i)
Sei n = c.C.f d(kcall(i)).name
(Name d. C0 -Funktion von k, Handler von trap i)
npar = (
).npar ≤ 10 (#P arameter)
Aufruf:
n(pcb(act), GP R[npar : 1])
(!) JISR ist implementiert als Funktionsaufruf
b) il = 3 (pf f )
pf h(act, EP C) (page fault handler)
c) il = 4 (pf ls)
pf h(act, EDAT A)
d) il = 12 (timer)
call scheduler
Bemerkung:
• brauche I/O Port um aktuelle Zeit auszulesen
• ändert oft act
e) il ∈ ES Nächster Prozess: hd(il)
pcb(hd(il)).R = pcb(act).R
|
{z
}
R ∈ EHR
(Korrektur 4, Paramterübergabe)
R 6= EP C
pcb(hd(il)).EP C = 032 (Anfang von Code des Prozesses hd(il))
act = hd(il)
f) il ∈ IS = [11 : 6]
pcb(act).EP C = ihd(act, il)
126
ABBILDUNGSVERZEICHNIS
127
Abbildungsverzeichnis
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
Relation . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Gatter-Symbole . . . . . . . . . . . . . . . . . . . . . . . .
Schaltkreis - XOR Gatter . . . . . . . . . . . . . . . . . . .
Eingänge des Gatters . . . . . . . . . . . . . . . . . . . . .
Schaltkreis - Zyklen-Problem . . . . . . . . . . . . . . . .
Schaltkreis - AND Flip-Flop . . . . . . . . . . . . . . . . .
Tiefe (Formal) . . . . . . . . . . . . . . . . . . . . . . . . .
Schaltkreis - XOR-Gatters (Tiefe) . . . . . . . . . . . . . .
Schaltkreise - Darstellungssatz (Binäre Operationen) . . .
Schaltkreise - Darstellungssatz (Negation) . . . . . . . . .
Schaltkreise - Polynom . . . . . . . . . . . . . . . . . . . .
Schaltkreise - ∧ − 2 Baum . . . . . . . . . . . . . . . . . .
Schaltkreise - ∧ − n Baum . . . . . . . . . . . . . . . . . .
Vergleich - ∧−Reihe / ∧ − n Baum . . . . . . . . . . . . .
Schaltkreise - ∧ − n Baum, falls n keine Zweierpotenz ist
Addierer . . . . . . . . . . . . . . . . . . . . . . . . . . . .
n-bit Addierer . . . . . . . . . . . . . . . . . . . . . . . . .
Schaltkreis - 1-bit Addierer . . . . . . . . . . . . . . . . . .
Carry-Chain-Adder . . . . . . . . . . . . . . . . . . . . . .
Multiplexer . . . . . . . . . . . . . . . . . . . . . . . . . .
1-bit Multiplexer Schaltkreis . . . . . . . . . . . . . . . . .
n-bit Multiplexer . . . . . . . . . . . . . . . . . . . . . . .
Multiplexer Symbol . . . . . . . . . . . . . . . . . . . . . .
Conditional Carry Adder . . . . . . . . . . . . . . . . . .
Arithmetic Unit . . . . . . . . . . . . . . . . . . . . . . . .
Erweiterung der Notation . . . . . . . . . . . . . . . . . .
Beispiel: Erweiterung der Notation . . . . . . . . . . . . .
n-bit-twoc AU (auch für Binärzahlen) . . . . . . . . . . .
Arithmetic Logic Unit . . . . . . . . . . . . . . . . . . . .
Schaltkreis - Arithmetic Logic Unit . . . . . . . . . . . . .
Register . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Register (Beispiel) . . . . . . . . . . . . . . . . . . . . . . .
2a × d RAM . . . . . . . . . . . . . . . . . . . . . . . . . .
3 − P ort RAM . . . . . . . . . . . . . . . . . . . . . . . . .
DLX0 Instruktionssatz . . . . . . . . . . . . . . . . . . . .
DLX0 -Hardware Konfiguration in Stufen . . . . . . . . .
DLX0 -Beweis (c0 comp) . . . . . . . . . . . . . . . . . . . .
DLX0 -Beweis (adcomp) . . . . . . . . . . . . . . . . . . .
DLX0 -Beweis (aluoph ) . . . . . . . . . . . . . . . . . . . .
Spezifikation - n-Inc . . . . . . . . . . . . . . . . . . . . . .
nextP C . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
bjtakenh . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Beispiel - Arbeitsweise von Grammatiken . . . . . . . . .
Funktions-Stack . . . . . . . . . . . . . . . . . . . . . . . .
Funktions-Frame . . . . . . . . . . . . . . . . . . . . . . .
Heap und Stack im DLX0 -Memory . . . . . . . . . . . . .
Special Purpose Register . . . . . . . . . . . . . . . . . . .
Interrupt Service Routine (Aufbau) . . . . . . . . . . . . .
Bus-System . . . . . . . . . . . . . . . . . . . . . . . . . . .
Festplatte . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Devbase . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Communicating Virtual Machine . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
4
12
12
13
13
13
14
14
16
16
17
18
18
19
19
21
22
23
26
27
27
28
28
28
32
33
33
34
35
36
39
39
40
40
41
46
48
49
50
52
53
54
57
75
76
88
97
99
100
101
101
108
ABBILDUNGSVERZEICHNIS
53
54
55
56
57
58
59
60
Communicating Virtual Machine mit I/O Device
vm(p′ ).m . . . . . . . . . . . . . . . . . . . . . . .
Memory Map . . . . . . . . . . . . . . . . . . . .
Processed Control Block . . . . . . . . . . . . . .
Page Table Array . . . . . . . . . . . . . . . . . .
Swap Page . . . . . . . . . . . . . . . . . . . . . .
p − konsis(c, kbase, cc) . . . . . . . . . . . . . .
Bootstrap . . . . . . . . . . . . . . . . . . . . . . .
128
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
111
113
117
119
119
120
122
125

Systemarchitektur

Transcrição

Documentos relacionados

Aerolite Packable Rain Poncho

Raumplaner - Hotel Bauer

Neuheiten 2015/2016 - Stickservice Patrick Vogel

Dispos-a-Glove - Ansell Healthcare Europe

hinweise fakten service inklusive beschreibung schlafzimmer

www.busse-reitsport.de

Nissan Almera 2.2 16V DITD up1 N15 N15 (09/95

Protection Suit Schutzanzug

home pure - At Eco Windows And Doors

fujifilm x10 - Fotointern.ch