einfuhrung in die informatik 2¨home.in.tum.de/~gufler/files/info2.pdf · 2002-11-30 · kapitel 1...

Einfuhrung in die Informatik 2

Benjamin Gufler

Erstellt mit LATEX

Inhaltsverzeichnis

II Rechnerstruktur, Hardware, Maschinennahe Program-mierung 1

1 Codierung / Informationstheorie 51.1 Codes / Codierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

1.1.1 Binarcodes einheitlicher Lange . . . . . . . . . . . . . . . . . 51.1.2 Codes variabler Lange . . . . . . . . . . . . . . . . . . . . . . 61.1.3 Serien-/ Parallelwortcodierung . . . . . . . . . . . . . . . . . 71.1.4 Codebaume . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.2 Codes und Entscheidungsinformation . . . . . . . . . . . . . . . . . . 81.3 Sicherung von Nachrichtenubertragung . . . . . . . . . . . . . . . . . 9

1.3.1 Codesicherung . . . . . . . . . . . . . . . . . . . . . . . . . . 91.3.2 Ubertragungssicherheit . . . . . . . . . . . . . . . . . . . . . . 10

2 Binare Schaltnetze und Schaltwerke 112.1 Boolesche Algebra / Boolesche Funktionen . . . . . . . . . . . . . . . 11

2.1.1 Boolesche Funktionen . . . . . . . . . . . . . . . . . . . . . . 112.1.2 Partielle Ordnung auf BF . . . . . . . . . . . . . . . . . . . . 13

2.2 Normalformen boolescher Funktionen . . . . . . . . . . . . . . . . . . 132.2.1 Das boolesche Normalformtheorem . . . . . . . . . . . . . . . 132.2.2 Vereinfachte Normalformen (DNF) . . . . . . . . . . . . . . . 14

2.3 Schaltnetze . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152.3.1 Schaltfunktionen und Schaltnetze . . . . . . . . . . . . . . . . 152.3.2 Darstellung von Schaltnetzen . . . . . . . . . . . . . . . . . . 162.3.3 Halbaddierer . . . . . . . . . . . . . . . . . . . . . . . . . . . 182.3.4 Arithmetische Schaltnetze . . . . . . . . . . . . . . . . . . . . 202.3.5 Zahldarstellung . . . . . . . . . . . . . . . . . . . . . . . . . . 212.3.6 Weitere arithmetische Operationen . . . . . . . . . . . . . . . 242.3.7 Schaltnetze zur Ubertragung von Information . . . . . . . . . 24

2.4 Schaltwerke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252.4.1 Schaltwerksfunktionen . . . . . . . . . . . . . . . . . . . . . . 252.4.2 Schaltfunktionen als Schaltwerksfunktionen . . . . . . . . . . 262.4.3 Schaltwerke . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262.4.4 Schaltwerksfunktionen und endliche Automaten . . . . . . . . 262.4.5 Schaltwerke zum Speichern: Verzogerungsnetze . . . . . . . . 272.4.6 Klassen von Schaltwerken . . . . . . . . . . . . . . . . . . . . 282.4.7 Komposition von Schaltwerken und Schaltnetzen . . . . . . . 29

3 Aufbau von Rechenanlagen 313.1 Strukturierter Aufbau von Rechenanlagen . . . . . . . . . . . . . . . 31

3.1.1 Der Rechnerkern . . . . . . . . . . . . . . . . . . . . . . . . . 333.1.2 Speichereinheit . . . . . . . . . . . . . . . . . . . . . . . . . . 333.1.3 E/A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

III

IV INHALTSVERZEICHNIS

3.1.4 Befehle und Daten auf Maschinenebene . . . . . . . . . . . . 333.1.5 Operandenspezifikation und Adressrechnung . . . . . . . . . . 353.1.6 Der Befehlszyklus . . . . . . . . . . . . . . . . . . . . . . . . 37

3.2 Hardwarekomponenten . . . . . . . . . . . . . . . . . . . . . . . . . . 38

4 Maschinennahe Programmierung 394.1 Maschinennahe Programmiersprachen . . . . . . . . . . . . . . . . . 39

4.1.1 Binarworter als Befehle . . . . . . . . . . . . . . . . . . . . . 404.1.2 Der Befehlsvorrat der MI . . . . . . . . . . . . . . . . . . . . 404.1.3 Einfache Maschinenprogramme . . . . . . . . . . . . . . . . . 414.1.4 Assemblersprachen . . . . . . . . . . . . . . . . . . . . . . . . 434.1.5 Ein- und Mehradressform . . . . . . . . . . . . . . . . . . . . 444.1.6 Unterprogrammtechniken . . . . . . . . . . . . . . . . . . . . 45

4.2 Adressiertechniken und Speicherverwaltung . . . . . . . . . . . . . . 474.2.1 Konstante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 474.2.2 Operandenversorgung uber Register . . . . . . . . . . . . . . 484.2.3 Absolute Adressierung . . . . . . . . . . . . . . . . . . . . . . 484.2.4 Relative Adressierung . . . . . . . . . . . . . . . . . . . . . . 484.2.5 Indizierung, Zugriff auf Felder . . . . . . . . . . . . . . . . . . 484.2.6 Symbolische Adressierung . . . . . . . . . . . . . . . . . . . . 494.2.7 Geflechtsstrukturen und indirekte Adressierung . . . . . . . . 504.2.8 Speicherverwaltung . . . . . . . . . . . . . . . . . . . . . . . . 524.2.9 Stackverwaltung von blockstrukturierten Sprachen . . . . . . 52

4.3 Techniken maschinennaher Programmierung . . . . . . . . . . . . . . 544.3.1 Auswertung von Ausdrucken / Termen . . . . . . . . . . . . . 554.3.2 Maschinennahe Realisierung von Ablaufstrukturen . . . . . . 56

Teil II

Rechnerstruktur, Hardware,Maschinennahe

Programmierung

1

3

Stichworte:

• Zeichenweise Darstellung von Information → Codierung

• Schaltungen / Schaltwerke - Schaltlogik

• Rechnerstrukturen: Aufbau von Rechneranlagen

• Maschinennahe Programmierung

Kapitel 1

Codierung /Informationstheorie

In der Codierung studieren wir die Darstellung von Information durch Zeichenfolgen(vgl. �formale Sprache�).

1.1 Codes / Codierung

Wir konzentrieren uns stark auf eine Darstellung durch zwei Zeichen (Bits - BinaryDigits).

B = {L, 0}BnMenge der Binarworter der Lange n (n - Bit - Worter)

Sei A ein Alphabet (linear geordneter endlicher Zeichensatz), B ein Alphabet.

c : A → B Code / Codierungc : A∗ → B∗ Wortcodierung

Wichtig auf einer Codierung ist die Umkehrbarkeit:

d : {c(a) : c ∈ A} → A

mit d(c(a)) = a. Voraussetzung: c injektiv.Binarcodierung:

c : A → B∗

Achtung: B∗ ist lexikographisch linear geordnet (0 < L).

1.1.1 Binarcodes einheitlicher Lange

Wir betrachten nun fur gegebenes n ∈ N die Abbildung c : A → Bn.Achtung: Wir setzen voraus, dass c injektiv ist, aber nicht notwendigerweise surjek-tiv.Fur zwei Codeworter aus Bn konnen wir nach dem �Abstand� fragen, wir sprechenvon �Hamming-Abstand�:

hd : BntimesBn → N0

hd(〈a1, . . . , an〉 , 〈b1, . . . , bn〉) =n∑

i=1

d(ai, bi)

5

6 KAPITEL 1. CODIERUNG / INFORMATIONSTHEORIE

wobei fur x, y ∈ B gilt

d(x, y) =

{1 falls x 6= y

0 falls x = y

Auf dieser Basis definieren wir einen Hammingabstand fur einen Binarcode c:

hd(c) = min {hd(c(a), c(b)) : a, b ∈ A ∧ a 6= b}

hd(c) = 0 c nicht injektiv.Um den Hammingabstand hoch zu halten, benutzt man Paritatsbits.

Beispiel Gegeben sei eine Codierung c : A → Bn mit hd(c) ≥ 1. Gesucht ist eineCodierung c′ : A → Bn+1 mit hd(c) ≥ 2. Wir definieren:

pb : Bn → B, pb(b) =

{L falls die Quersumme von b gerade ist0 sonst

und fur a ∈ Ac′(a) = c(a) ◦ 〈pb(c(a))〉

Behauptung: hd(c′) ≥ 2Beweis: Seien a, a′ ∈ A, a 6= a′ gegeben.1. Fall: hdc(a, a′) ≥ 2 ⇒ hdc′(a, a′) ≥ 22. Fall: hdc(a, a′) = 1. Dann gilt pb(a) 6= pb(a′), da die Quersumme von a gerade ist,wenn die Quersumme von a′ ungerade ist und umgekehrt. Also ist hdc′(a, a′) = 2.

Wichtiges Thema der Codierung: Kryptographie: Verschlusselung von Nach-richten.Weiteres Thema: Codierung der Ziffern.Direkter Code: c : {0, . . . , 9} → B4

z c(z) 1-aus-10-Code0 0000 000000000L1 000L 00000000L02 00L0 0000000L003 00LL 000000L0004 0L00 00000L00005 0L0L 0000L000006 0LL0 000L0000007 0LLL 00L00000008 L000 0L000000009 L00L L000000000

1.1.2 Codes variabler Lange

Wir betrachten nun Codes, bei denen die Codeworter unterschiedliche Langen be-sitzen.

Beispiele

• altes Fernsprechwahlsystem:

1 7→ L02 7→ LL0...

0 7→ LLLLLLLLLL0

• Morsecode

1.1. CODES / CODIERUNG 7

1.1.3 Serien-/ Parallelwortcodierung

Bei der Ubertragung von binar codierter Information unterscheiden wir zwei Situa-tionen:

• ein Draht / sequentielle Ubertragung

• n Drahte (n > 1) / parallele Ubertragung

Bei Ubertragung eines Wortes w ∈ A∗ mit Binarcodierung c : A → B∗ einfachstesVorgehen:

c∗ : A∗ → B∗

c∗ (〈a1, . . . , an〉) = c(a1) ◦ c(a2) ◦ · · · ◦ c(an)

Kritische Frage: Ist c∗ injektiv, wenn c injektiv ist?Nein! Gegenbeispiel: Seien a1, a2 ∈ A mit a1 6= a2, c(a1) =< L > und c(a2) =<LL >. Dann ist c∗(< a1a1a1 >) =< LLL >= c∗(< a1a2 >).Frage: Unter welchen Voraussetzungen ist die Antwort ja?Antwort:

1. Codes gleicher Lange

2. die Fano-Bedingung gilt

Fano-Bedingung von Coole: Kein Codewort c(a1) fur a1 ∈ A ist Prafix eines Code-worts c(a2) fur a2 ∈ A mit a1 6= a2.Behauptung: Gilt fur c die Fano-Bedingung, so ist c∗ injektiv.Beweis (durch Widerspruch): Seien a = 〈a1, . . . , an〉 , b = 〈b1, . . . , bm〉 ∈ A∗, a 6= bund c∗(a) = c∗(b). O.B.d.A. sei n < m. Sei i so gewahlt, dass ak = bk fur 1 ≤ k ≤ iund n = i oder ai+1 6= bi+1.1. Fall: ai+1 6= bi+1; dann gilt c(ai+1) Prafix von c(bi+1) oder c(bi+1) Prafix vonc(ai+1). Widerspruch zur Fano-Bedingung.2. Fall: n = i; dann gilt (wegen m > n) c∗(〈bi+1, . . . , bm〉) = ε. Widerspruch zurFano-Bedingung.

Parallelwortcodierung:

c : A → Bn

c‖∗ : A∗ → (Bn)∗

c‖∗(〈a1, . . . , ak〉) = 〈c(a1)〉 ◦ · · · ◦ 〈c(ak)〉

Beispiel L0L0

00LL

L000

L 0 L0 0 0L L 00 L 0

Trivial: c‖∗ injektiv, falls c injektiv.

1.1.4 Codebaume

Codes lassen sich durch Tabellen oder durch Codebaume (s. Abb. (1.1)) darstellen.

A B C DL 0LL 0L0 00

Trivialerweise ist fur Codes, dargestellt durch Codebaume, stets die Fano-Bedin-gung gegeben.


L 0

L 0

L 0

A

B C

D

Abbildung 1.1: Codebaum

1.2 Codes und Entscheidungsinformation

Kernfrage: Wie viel Information tragt eine Nachricht?Prinzip: Um so ungewohnlicher (seltener) eine Information ist, desto mehr Infor-mationsgehalt hat sie. Dafur setzen wir gegebenenfalls Wahrscheinlichkeiten furNachrichten voraus. Eine stochastische Nachrichtenquelle fur ein endlichesAlphabet A erzeugt eine Folge von Zeichen aus A, bei der zu jedem Zeitpunkt dieWahrscheinlichkeiten fur jedes Zeichen einer vorgegebenen zeitunabhangigen Wahr-scheinlichkeitsverteilung entsprechen.Beobachtung: Seltene Zeichen tragen viel Information, haufige Zeichen wenig.Gegeben: A Alphabet, p : A → [0, 1] Wahrscheinlichkeiten (d.h.

∑a∈A p(a) = 1 und

p(a) > 0∀a ∈ A).Mittlerer Entscheidungsgehalt (Entropie):

H =∑a∈A

p(a) ld(

1p(a)

)Entropie: Maß fur �Gleichverteilung� der Wahrscheinlichkeiten: H groß ⇔ Wahr-scheinlichkeiten etwa gleichverteilt, H klein ⇔ starke Unterschiede in den Wahr-scheinlichkeiten.

Beispiel

Zeichen i p(i) Ha 1

2 1b 12

a 34 ≈ 0, 8b 14

Seien fur die Zeichen aus A Wahrscheinlichkeiten p : A → [0, 1] sowie eine Binarco-dierung c : A → B gegeben. Wir konnen die mittlere Wortlange L berechnen als

L =∑a∈A

p(a)|c(a)|

wobei |c(a)| die Lange von c(a) bezeichnet. Um L klein zu halten, codieren wir Zei-chen mit großen Wahrscheinlichkeiten mit kurzen Codewortern. Großere Spielraumeerhalten wir, wenn wir nicht Einzelzeichen, sondern Worter aus A∗ codieren. →Huffman-AlgorithmusJede Menge M ⊆ A von Zeichen hat auch eine Wahrscheinlichkeit p(M) =

∑a∈M p(a).

Es ist p(A) = 1. Ziel: A so in zwei disjunkte Teilmengen A0 und AL aufteilen, dassp(A0) ≈ 1

2 ≈ p(AL) ist.

1.3. SICHERUNG VON NACHRICHTENUBERTRAGUNG 9

Beispieli p(i)a 3

4b 1

4

i p(i)aa 9

16ab 3

16ba 3

16bb 1

16

L =1m

∑w∈Am

p(w)|c(w)|

Shannonsches Codierungstheorem:

1. Fur beliebige Wortcodes gilt H ≤ L.

2. Der Wert L − H kann durch geschickte Wahl der Wortcodes beliebig kleingemacht werden.

Redundanz eines Codes: L−HRelative Redundanz eines Codes: 1− H

LGesetz von Merkel: Die Reaktionszeit t einer Versuchsperson, um aus n Gegenstandeneinen bestimmten auszuwahlen, lasst sich berechen durch

t = 200 + 180 ld(n)[msec]

1.3 Sicherung von Nachrichtenubertragung

Beim Ubertragen von Nachrichten sind zwei Aspekte von besonderer Bedeutung:

• Kapazitat: Wie viele Informationseinheiten pro Zeiteinheit konnen ubertragenwerden?

• Storung: Wie hoch ist die Wahrscheinlichkeit, dass Daten fehlerhaft uber-tragen werden?

1.3.1 Codesicherung

Diskreter Kanal ohne Speicher: Ubertragt Binarwerte, wobei Storungen auftretenkonnen, deren Wahrscheinlichkeiten zu jedem Zeitpunkt gleich sind (vgl. stochasti-sche Nachrichtenquelle).Irrtumswahrscheinlichkeiten:

p0 Wahrscheinlichkeit, dass das Zeichen 0 als L ubertragen wirdpL Wahrscheinlichkeit, dass das Zeichen L als 0 ubertragen wird

einseitige Storung: (p0 = 0 ∧ pL > 0) ∨ (p0 > 0 ∧ pL = 0)symmetrische Storung: p0 = pL

In manchen Fallen fuhrt eine Storung nicht zu einer Veranderung L zu 0 oder 0zu L, sondern fuhrt auf ein Zeichen, das als fehlerhaft erkannt werden kann (Ver-lustzeichen). Wir erhalten eine Ubertragung von Zeichen aus {0, L} in Zeichen aus{0, L,⊥} (⊥: Fehlerzeichen).Ziel bei Kanalen mit Ubertragungsfehlern: Die Wahrscheinlichkeit fur Fehler sollmoglichst klein gehalten werden, d.h. Fehler sollen erkannt und korrigiert werden(durch Redundanz).Lemma: Hat ein Code Hammingabstand h, so konnen Storungen, die weniger als hZeichen betreffen, sicher erkannt werden.Idee: Pruf- / Paritatsbits einsetzen


1.3.2 Ubertragungssicherheit

Kanale haben beschrankte Ubertrangugskapazitat:s1: Anzahl der Zeichen, die ein Kanal pro Zeiteinheit ubertragts0: Anzahl der Zeichen, die pro Zeiteinheit ubertragen werden sollenR = s0

s1: Senderate

R < 1: Uberkapazitat, d.h. Codesicherung durch Redundanz moglichR > 1: Unterkapazitat: Nachricht kann nur in Teilen ubertragen werden, kommt�gestort� an.

Beispiel R = 13 → wir ubertragen statt der Einzelzeichen jedes Zeichen drei Mal

hintereinander. Bei Storungen mit pE < 0, 5 decodieren wir wie folgt:

000, 00L, 0L0, L00 → 0

Die Fehlerrate sei p fur Einzelzeichenubertragung; dann ist 3p2 − 2p3 die Wahr-scheinlichkeit einer Storung bei DreifachubertragungLiegt die Ubertragungsrate bei 14

16 , dann konnen wir 14-Bit-Worter als 16-Bit-Worter mit 2 Paritatsbits ubertragen.Falls R ≥ 1 ist, reicht die Kapazitat nicht aus. Trotzdem konnen wir Nachrichten(gestort) ubertragen.

Beispiel R = 3, d.h. wir sollen drei Mal so viel Nachrichten ubertragen, alsmoglich ist.Idee: Drei Bits werden auf ein Bit komprimiert (Mehrheitstechnik. s.o.) und beimEmpfang wieder in drei gleiche Bits umgewandelt.Irrtumswahrscheinlichkeit: (R > 1)

pE =p

R+

R− 12R

Kapitel 2

Binare Schaltnetze undSchaltwerke

Zur Darstellung diskreter (�symbolischer�) Information reichen zwei Werte (�Bits�)aus. Zur Darstellung �technischer� Art bits es viele Moglichkeiten:

• elektrische:

– Spannung / keine Spannung

– Strom / kein Strom

– Licht / kein Licht

• mechanische:

– Wasser / kein Wasser

– Dampf / kein Dampf

Wir betrachten im Weiteren nicht die technische Darstellung von Bits, sondern stu-dieren, wie wir bestimmte Information (Zahlen, Datenstrukturen) durch Bitsequen-zen darstellen konnen und wir wir Verarbeitungsvorgange durch boolesche Funktio-nen realisieren konnen.

2.1 Boolesche Algebra / Boolesche Funktionen

Die Wahrheitswerte bilden mit den Operationen ¬, ∨ und ∧ eine boolesche Algebra.Pradikate bilden ebenfalls eine boolesche Algebra: Statt einer Pradikatsdarstellungp : M → B konnen wir stets eine Mengendarstellung S ⊆ M verwenden. JedesPradikat uber M definiert genau eine Teilmenge von M und umgekehrt.Sp = {x ∈ M : p(x)}: p(x) = (x ⊂ Sp)Allgemein gilt: ∧ ∼ ∩, ∨ ∼ ∪, ¬ ∼ Komplement und ⇒∼⊆.

2.1.1 Boolesche Funktionen

n-stellige boolesche Funktion: f : Bn → B

Beispiel:

1. 0-stellige boolesche Funktionen: Bn = {ε}Es gibt genau zwei 0-stellige boolesche Funktionen: true, false.

11

12 KAPITEL 2. BINARE SCHALTNETZE UND SCHALTWERKE

2. 1-stellige boolesche Funktionen: f : B → B

true konstant Lfalse konstant 0x Identitat¬x Negation

3. 2-stellige boolesche Funktionen: f : B2 → B

true Konstantenfalsex Projektioneny

¬x negative Projektionen¬y

x ∨ y Disjunktionx ∧ y Konjunktionx ∨ ¬y Inverse Implikation, Subjunktion¬x ∨ y Implikation

(x ∧ y) ∨ (¬x ∧ ¬y) Aquivalenz(x ∧ ¬y) ∨ (¬x ∧ y) Antivalenz¬(x ∨ y) nor¬(x ∧ y) nandx ∧ ¬y Bisubtraktion¬x ∧ y

4. 3-stellige boolesche Funktionen: f : B3 → B. . .

Anzahl der n-stelligen booleschen Funktionen 2(2n)

Fur jedes n ∈ N bilden die n-stelligen booleschen Funktionen eine boolesche Algebra.BFn: Menge der booleschen Funktionen der Stelligkeit n.Seien f, g ∈ BFn. Dann sind (¬f), (f ∧ g) ∈ BFn und es gilt:

• (¬f)(x1, . . . , xn) = ¬f(x1, . . . , xn)

• (f ∧ g)(x1, . . . , xn) = f(x1, . . . , xn) ∧ g(x1, . . . , xn)

• (f ∨ g)(x1, . . . , xn) = f(x1, . . . , xn) ∨ g(x1, . . . , xn)

Außerdem ist (f ∧ ¬f), (f ∨ ¬f) ∈ BFn.Wie lassen sich boolesche Funktionen darstellen?

1. Durch Formeln oder Aussagenlogik:Sei f ∈ BFn. Dann konnen wir f(x1, . . . , xn) durch die aussagenlogischenTerme uber den Identifikatoren x1, . . . , xn (z.B.: f(x1, x2, x3) = x1∨(¬x1∧x2))darstellen.

2.2. NORMALFORMEN BOOLESCHER FUNKTIONEN 13

2. Durch Tabellen:

x1 0 0 0 0 L L L Lx2 0 0 L L 0 0 L Lx3 0 L 0 L 0 L 0 Lf(x1, x2, x3) 0 0 L L L L L L

3. Entscheidungsdiagramme (Baume)

2.1.2 Partielle Ordnung auf BF

Fur eine beliebige boolesche Algebra definieren wir eine partielle Ordnung f ≥ gdurch f ≥ g ⇔def f = f ∧ g. Aus den Gesetzen der booleschen Algebra lasst sichnachweisen, dass ≥ eine partielle Ordnung ist. f ≥ g ist gleichbedeutend mit f ⇒ g.f ∨¬f ist kleinstes Element: true (schwachste Aussage). f ∧¬f ist großtes Element:false (starkste Aussage).

2.2 Normalformen boolescher Funktionen

Eine boolesche Funktion kann immer durch boolesche Terme dargestellt werden. Esexistieren viele syntaktisch verschiedene Terme, die die gleiche Funktion darstellen:

(¬x1 ∧ ¬x2) ∨ (x1 ∧ x2) ≡ (x1 ⇒ x2) ∧ (x2 ⇒ x1) ≡ (¬x1 ∨ x2) ∧ (¬x2 ∨ x1)

Wir behandeln im Weiteren folgende Fragen:

1. Gibt es einheitliche Termdarstellungen fur BF (�Normalformen�)?

2. Wie konnen wir aus einer Tabellen- oder Entscheidungsbaumdarstellung eineTermdarstellung bekommen?

3. Wir konnen wir besonders einfache und kurze Termdarstellungen bekommen?

Diese Fragen sind auch fur die technische Realisierung von booleschen Funktio-nen durch Schaltungen entscheidend, da Termdarstellungen direkt in Schaltungenumgesetzt werden konnen.

2.2.1 Das boolesche Normalformtheorem

Ziel: Wir wollen fur beliebige boolesche Funktionen eine Termnormalform definierenund zeigen, wie diese aus einer Tabelle erzeugt werden kann.Wir definieren eine disjunktive Normalform (DNF):

〈def〉 ::= 〈kf〉 {∨ 〈kf〉}∗|0|L〈kf〉 ::= 〈literal〉 {∧ 〈literal〉}∗

〈literal〉 ::= {¬} 〈id〉

Beispiel

(x1 ∧ ¬x2 ∧ x3 ∧ ¬x4) ∨ (¬x1 ∧ x2 ∧ x3 ∧ x4) ∨ (∧x1 ∧ ¬x2 ∧ x3 ∧ ¬x4)

Als Identifikatoren wahlen wir x1, . . . , xn. In der vollstandigen DNF kommt in jedemLiteral jeder Identifikator genau ein Mal vor.Hilfskonstruktion: Seien b1, . . . , bn ∈ B. Wir definieren einen Term

minterm(b1, . . . , bn) = (v1 ∧ · · · ∧ vn)

wobei

vi =

{xi falls bi = L

¬xi falls bi = 0


Beispielminterm(0, L, L, 0, L) = (¬x1 ∧ x2 ∧ x3 ∧ ¬x4 ∧ x5)

Theorem: Fur f ∈ BFn gilt:

f(x1, . . . , xn) =∨

b1,...,bn∈B(f (b1, . . . , bn) ∧minterm (b1, . . . , bn))

Beweis: durch Induktion uber n.

Beispiel

x1 L L L L 0 0 0 0x2 L L 0 0 L L 0 0x3 L 0 L 0 L 0 L 0

f(x1, x2, x3) L L 0 0 0 L 0 0

f(x1, x2, x3) =(L ∧ x1 ∧ x2 ∧ x3) ∨ (L ∧ x1 ∧ x2 ∧ ¬x3)∨ (0 ∧ x1 ∧ ¬x2 ∧ x3) ∨ (0 ∧ x1 ∧ ¬x2 ∧ ¬x3)∨ (0 ∧ ¬x1 ∧ x3 ∧ x3) ∨ (L ∧ ¬x1 ∧ x2 ∧ ¬x3)∨ (0 ∧ ¬x1 ∧ ¬x2 ∧ x3) ∨ (0 ∧ ¬x1 ∧ ¬x2 ∧ ¬x3)

=(x1 ∧ x2 ∧ x3) ∨ (x1 ∧ x2 ∧ ¬x3) ∨ (¬x1 ∧ x2 ∧ ¬x3)

Analog zur disjunktiven gibt es die konjunktive Normalform (KNF); die Rollen von�und� und �oder� sind dort vertauscht.Die DNF beantwortet die am Eingang gestellten Fragen. Jede boolesche Funktionhat eine eindeutige vollstandige DNF.

2.2.2 Vereinfachte Normalformen (DNF)

Die vollstandige DNF lasst sich oft weiter vereinfachen.

Regeln zur Vereinfachung

. . . ∨ (t1 ∧ · · · ∧ ti−1 ∧ xi ∧ ti+1 ∧ · · · ∧ tn) ∨ . . .

∨(t1 ∧ · · · ∧ ti−1 ∧ ¬xi ∧ ti+1 ∧ · · · ∧ tn) ∨ . . .

⇒ · · · ∨ (t1 ∧ · · · ∧ ti−1 ∧ ti+1 ∧ · · · ∧ tn) ∨ . . .

Beispiel

(x1 ∧ x2 ∧ x3) ∨ (x1 ∧ x2 ∧ ¬x3) ∨ (¬x1 ∧ x2 ∧ ¬x3)=(x1 ∧ x2) ∨ (¬x1 ∧ x2 ∧ ¬x3)

Nun konnen Terme folgender Gestalt auftreten: . . .∨ (t1∧ t2)∨· · ·∨ (t1)∨ . . . . DieseTerme konnen ersetzt werden durch . . . ∨ (t1) ∨ . . . .Durch diese Regeln kann von der vollstandigen DNF zur vereinfachten DNF uber-gegangen werden.

Binare Entscheidungsdiagramme

Da die Identifikatoren geordnet sind (x1, . . . , xn) konnen wir Entscheidungsbaumefur boolesche Funktionen konstruieren.

• n = 0, d.h. f ∈ BF0; der Entscheidungsbaum ist ein �Blatt� b ∈ B, und zwar

L falls f(ε) = L

0 falls f(ε) = 0

2.3. SCHALTNETZE 15

Abbildung 2.1: Beispiel eines Schaltplans

• n > 0: Wir definieren den Entscheidungsbaum wie folgt:

EBL EB0

L 0

wobei EBL der Entscheidungsbaum der booleschen Funktion fL ∈ BFn−1 mit

fL(x1, . . . , xn−1 = f(L, x1, . . . , xn−1)

und EB0 der Entscheidungsbaum zur booleschen Funktion f0 ∈ BFn−1 mit

f0(x1, . . . , xn−1) = f(0, x1, . . . , xn−1)

seien.

2.3 Schaltnetze

Zur Realisierung von boolschen Funktionen (wir sprechen ab jetzt von Schaltfunk-tionen) konnen Schaltnetze verwendet werden. Schaltnetze entsprechen gerichteten,azyklischen Graphen mit Eingangen und Ausgangen.Definition: Ein Schaltnetz mit n Eingangen und m Ausgangen ist ein gerichteter,azyklischer Graph mit n Eingangskanten und m Ausgangskanten, dessen Knotenmit den Namen boolscher Funktionen markiert sind.Schaltnetze sind mit boolschen Termen eng verwandt. Jeder boolsche Term lasstsich als ein Schaltnetz darstellen. Die so entstehenden Schaltnetze haben jedochdie Eigentumlichkeit, dass jede Kante genau ein Ziel hat. Deshalb fuhren wir imFolgenden neben boolschen Termen eine Funktionaltermdarstellung fur boolscheFunktionen ein, durch die beliebige Schaltnetze mit Kanten mit Mehrfachziel (Ver-zweigung) dargestellt werden konnen.Im Folgenden behandeln wir eine Reihe boolscher Funktionen, ihre Darstellungdurch boolsche Terme und durch Funktionsterme (funktionale Terme). Funktions-terme sind durch Verknupfungen aus Grundfunktionen aufgebaut. Die Verknupfun-gen entsprechen der graphischen Darstellung durch Schaltnetze.

Der Schaltplan, gegeben durch das Schaltnetz, kann direkt in eine technischeRealisierung umgesetzt werden.

2.3.1 Schaltfunktionen und Schaltnetze

Schaltfunktion: f : Bn → Nm, m,n ∈ N.Schaltglied: (s. Abb. 2.2) Ein Schaltnetz besteht aus einer Menge von Schaltgliedern,die uber Kanten verbunden sind. Es entsteht ein gerichteter Graph. In Schaltnetzensind keine Zyklen zugelasen. Jede Kante hat genau eine Quelle, unter Umstandenaber mehrere Ziele, d.h. Kanten konnen sich verzweigen.


...n...

...m...

f

Abbildung 2.2: Schaltglied

&

...n...

Abbildung 2.3: Konjunktions-Schaltglieder

• Konjunktion: logisches �und� (s. Abb. 2.3)

• Disjunktion: logisches �oder� (s. Abb. 2.4)

• Negation: (s. Abb. 2.5)

Sei ein Schaltnetz mit n Eingangen und m Ausgangen gegeben. Wird fur jedesSchaltglied des Netzes eine Schaltfunktion angegeben, so definiert das Schaltnetzselbst wieder eine Schaltfunktion aus SFm

n . In einem Schaltnetz entspricht

• jedes Schaltglied einer Schaltfunktion

• jede Kante einem Wahrheitswert

2.3.2 Darstellung von Schaltnetzen

Es gibt zwei grundlegende Moglichkeiten, Schaltnetze durch Formeln darzustellen:

1. benannte Kanten

2. Kombination (Komposition) von Schaltgliedern

Benannte Kanten: Jeder Knoten in einem Netz (vgl. Abb. 2.6) entspricht einerGleichung (y1, . . . , ym) = f(x1, . . . , xn). Dieses Darstellungsverfahren eignet sichgut fur kleine Schaltnetze ohne Regelmaßigkeiten.

Besser fur große Schaltnetze mit starken Regelmaßigkeiten eignen sich kombi-natorische Schreibweisen.

...n...

>= 1

Abbildung 2.4: Disjunktions-Schaltglieder

2.3. SCHALTNETZE 17

1

Abbildung 2.5: Negations-Schaltglieder

x1

y1

xn

ym

f

...

...

Abbildung 2.6: Benannte Kanten

1. Parallele Komposition (s. Abb. 2.7): Seien f1 ∈ SFm1n1

und f2 ∈ SFm2n2

. Dann istf = (f1 ‖ f2) ∈ SFm1+m2

n1+n2, und es gilt f(x1, . . . , xn1+n2) = (y1, . . . , ym1+m2),

wobei

f1(x1, . . . , xn1) = (y1, . . . , ym1)f2(xn1+1, . . . , xn1+n2) = (ym1+1, . . . , ym1+m2)

2. Sequentielle Komposition (s. Abb. 2.8): Seien f1 ∈ SFmn , f2 ∈ SFm′

m . Es istf = (f1 ◦ f2) ∈ SFm′

n mit f(x1, . . . , xn) = f2(f1(x1, . . . , xn)).

Eigenschaften: ‖, ◦ sind assoziativ, aber nicht kommutativ.

Zusatzfunktionen

• Projektion

πni ∈ SF1

n 1 ≤ i ≤ n

πni (x1, . . . , xn) = xi

• Identitat

I ∈ SF11 In ∈ SFn

n

I(x) = x In(x1, . . . , xn) = (x1, . . . , xn)

...

...

...

...

f1 f2

f

Abbildung 2.7: Parallele Komposition


...

...

f1

f2

...

n

m

m’

f

Abbildung 2.8: Sequentielle Komposition

• Verzweigung

V ∈ SF21 Vn ∈ SF2n

n

V (x) = (x, x) Vn(x1, . . . , xn) = (x1, . . . , xn, x1, . . . , xn)

• Permutation

P ∈ SF22 Pn ∈ SFn

n

P (x1, x2) = (x2, x1) Pn(x1, . . . , xn) = (x2, . . . , xn, x1)

• Tupelung

f1 ∈ SFm1n , f2 ∈ SFm2

n

[f1, f2] ∈ SFm−1+m2n [f1, f2] = (Vn ◦ (f1 ‖ f2))

• SenkenU ∈ SF0

1 Un ∈ SF0n

• KonstantenK(0),K(L) ∈ SF1

0 Kn(0),Kn(L) ∈ SFn0

2.3.3 Halbaddierer

Der Halbaddierer ist ein Schaltglied HA ∈ SF22; HA(a, b) = (u, s).

a 0 L 0 Lb 0 0 L Ls 0 L L 0u 0 0 0 L

s = (¬a ∧ b) ∨ (a ∧ ¬b) Antivalenzu = a ∧ b

Diese Gleichungen fuhren auf den Aufbau gemaß Abbildung 2.9.Umformung ergibt: s = ¬(¬(a∨b)∨(a∧b)). Damit kann der Halbaddierer effizienteraufgebaut werden (s. Abb. 2.10).

2.3. SCHALTNETZE 19

a b

su

Abbildung 2.9: Ineffiziente Schaltung fur Halbaddierer

a b

u s

Abbildung 2.10: Effizientere Schaltung fur Halbaddierer


VA

a cb

su

Abbildung 2.11: Volladdierer

HA

HA

VA

a b c

su

Abbildung 2.12: Volladdierer aus Halbaddierern

2.3.4 Arithmetische Schaltnetze

Beim Addieren von Binarworten, die Zahlen binar darstellen, verwenden wir Voll-addierer (s. Abb. 2.11).Tabelle:a 0 L 0 L 0 L 0 Lb 0 0 L L 0 0 L Lc 0 0 0 0 L L L Ls 0 L L 0 L 0 0 Lu 0 0 0 L 0 L L Ln-stellige Binaraddition in Binarzahldarstellung:

+2 ∈ SFn2n : 〈an . . . a1〉+2 〈bn . . . b1〉 = 〈sn . . . s1〉

Zuzuglich wird ein Ubertrag u erzeugt: u = 〈un+1 . . . u1〉 mit u1 = 0.Es gilt

(uk+1, sk) = VA(ak, bk, uk)

Dies definiert s1, . . . , sn, d.h. das Ergebnis 〈sn . . . s1〉 (s. Abb. 2.13). un+1 zeigt an,ob die Arithmetik ubergelaufen ist.

Induktive Definition eines Addiernetzes:

AN1 = VAANn+1 = (I2 ‖ An)(VA ‖ In)

2.3. SCHALTNETZE 21

VA VA VA

un+1

0b1a1b2a2bnanun

sn s2 s1u2u3

...

Abbildung 2.13: Addiernetz fur zwei n-Bit-Worte

(vgl. Abb. 2.14)

Analog definieren wir die Binarsubtraktion −2 : (Bn)2 → Bn, 〈an . . . a1〉 −2

〈bn . . . b1〉 = 〈sn . . . s1〉.

si = (ai ∧ ¬bi ∧ ¬ui) ∨ (¬ai ∧ bi ∧ ¬ui) ∨ (¬ai ∧ ¬bi ∧ ui) ∨ (ai ∧ bi ∧ ui)u1 = 0

ui+1 = (¬ai ∧ bi) ∨ (¬ai ∧ ui) ∨ (bi ∧ ui)

Achtung: Der Ubertrag reprasentiert nun einen �negativen� Wert.Bemerkung: Falls un+1 = L ist, dann gilt b >2 a (>2: (Bn)2 → B).Die Subtraktion liefert als �Abfallprodukt� den Großenvergleich von a und b.

2.3.5 Zahldarstellung

Positive Zahlen (naturliche Zahlen im Intervall [0, 2n − 1]) stellen wir durch dieubliche Gewichtdarstellung dar:

w (〈an . . . a1〉) =n∑

i=1

w(ai)2i−1

wobei w(L) = 1 und w(0) = 0 seien.Zur Darstellung negativer Zahlen: Statt Darstellung der Zahl durch den Absolut-

wert und ein Vorzeichen wahlen wir eine Darstellung mit einem negativen Gewicht.

Einerkomplementdarstellung

c1 : [−2n + 1, 2n − 1] → Bn+1

d1 : Bn+1 → [−2n + 1, 2n − 1]d1(c1(z)) = z ∀z ∈ [−2n + 1, 2n − 1]

d1(〈bn+1 . . . b1〉) = (−2n + 1)w(bn+1 +n∑

i=1

w(bi)2i−1

Achtung: Wir erhalten zwei Darstellungen der Null!

d1( 〈0 . . . 0〉︸︷︷︸positive Null

) = 0 = d1( 〈L . . . L〉︸︷︷︸negative Null

) = −2n + 1 +n∑

i=1

2i−1

Die Vorteile der Einerkomplementdarstellung sehen wir, wenn wir arithmetischeOperationen ausfuhren.


b1bnan

a1 u

s1sn

AN n

u’

bn+1an+1

sn+1u’’

AN n+1

b1bnan

a1 u

s1snu’

AN n

...

...

...

...

VA

Abbildung 2.14: zur induktiven Definition des Addiernetzes

2.3. SCHALTNETZE 23

Beispiel: Komplementbildung

d1(〈bn+1 . . . b1〉) = z ⇒ c1(−z) = 〈¬bn+1 . . .¬b1〉

Addition in der Einerkomplementdarstellung: Wir definieren

〈sn+2 . . . s1〉 = 〈0an+1 . . . a1〉+2 〈0bn+1 . . . b1〉〈rn+2 . . . r1〉 = 〈an+1an+1 . . . a1〉+2 〈bn+1bn+1 . . . b1〉+2 〈0 . . . 0sn+2〉

Behauptung: Bei der Addition der durch a und b in Einerkomplementdarstellunggegebenen Zahlen tritt genau dann ein Uberlauf auf (d.h. die Summe der Zahlenliegt außerhalb von [−2n + 1, 2n − 1]), falls rn+1 6= rn+2.an+1 an+1 an . . . a1

bn+1 bn+1 bn . . . b1

sn+1 sn . . . s1

• 1. Fall: an+1 = bn+1 = 0, d.h. beide Zahlen sind positiv, d.h. Uberlauf genaudann, wenn un+1 = L, rn+2 = 0 ⇒ rn+2 6= rn+1.

• 2. Fall: an+1 6= bn+1, d.h. eine negative und eine positive Zahl werden addiert.Gilt un+1 = 0, dann ist rn+1 = rn+2 = L. Gilt un+1 = L, dann ist rn+1 =r+2 = 0.

• 3. Fall: an+1 = bn+1 = L. Beide Zahlen sind negativ. Nur wenn un+1 = List, findet kein Uberlauf statt. Dann gilt rn+1 = rn+2 = L; sonst gilt rn+1 6=rn+2 ⇒ Uberlauf

Ergebnis: In Einerkomplementdarstellung konnen wir praktisch ohne Aufwand dasKomplement bilden (negieren des Zahlenwerts) und bei Addition der Zahlen un-abhangig von der Frage, ob eine der Zahlen (oder beide) negativ ist, ein einfachesAddiernetz verwenden. Zusatzlich konnen wir noch durch Verwendung eines zusahli-chen Bits einen arithmetischen Uberlauf feststellen.

Zweierkomplementdarstellung

c2 : [−2n, 2n − 1] → Bn+1

d2 : Bn+1 → [−2n, 2n − 1]

d2(〈bn+1 . . . b1〉) = −2nw(bn+1) +n∑

i=1

w(bi)2i−1

Bemerkungen:Nur eine Darstellung der Null! d2(〈L . . . L〉) = −1.Komplementbildung:

d2(〈bn+1 . . . b1〉) = z ⇒ c2(−z) = 〈¬bn+1 . . .¬b1〉+2 〈0 . . . 0L〉

(Einer ruckt auf bei der Komplementbildung.)Dafur wird die Addition einfacher:

〈rn+1 . . . r1〉 = 〈an+1an+1 . . . a1〉+2 〈bn+1bn+1 . . . b1〉

Wieder gilt: rn+2 6= rn+1 ⇔ Uberlauf bei Addition.Achtung: Kein �Einerrucklauf� bei Addition!


2.3.6 Weitere arithmetische Operationen

Auch Multiplikation und Division von Binarzahlen konnen wir durch Schaltnetzedarstellen. Wir beschranken uns auf positive Zahlen.

Multiplikation

∗2 : Bm × Bn → Bm+n, 〈am . . . an〉 ∗2 〈bn . . . b1〉 = 〈pm+n . . . p1〉.Zur Definition von p verwenden wir eine Hilfsdefinition fur ri =

⟨rim+n+ . . . ri

1

⟩mit

rik =

{ak−i+1 ∧ bi falls i ≤ k ≤ m + i− 10 sonst

Damit gilt 〈pm+n . . . p1〉 =⟨rnm+n . . . rn

1

⟩+2 · · ·+2

⟨r1m+n . . . r1

1

⟩.

Division

/2 : Bm × Bn → Bm−n+1 fur m ≥ n; 〈am . . . a1〉 /2 〈bn . . . b1〉 = 〈qm−n+1 . . . q1〉.Wir setzen 〈am . . . a1〉 <2 〈bn . . . b10〉 voraus. Dies kann durch anfugen fuhrendenNullen (falls 〈bn . . . b1〉 6= 〈0 . . . 0〉) immer erreicht werden. Wir definieren eine Folgevon Binarworten

⟨rin . . . ri

0

⟩durch

⟨r0n . . . r0

0

⟩= 〈am . . . am−n+1〉. Gilt

⟨rin . . . ri

0

⟩≥2

〈0bm . . . b1〉, so gilt

qm−n−i+1 = L⟨ri+1n . . . ri+1

0

⟩= rest(

⟨rin . . . ri

0

⟩−2 〈0bm . . . b1〉) ◦ 〈am−n−i+2〉

Sonst ist

qm−n−i+1 = 0⟨ri−1n . . . ri

0

⟩=

⟨rin−1 . . . ri

0am−n−i+2

⟩Fazit: Alle arithmetischen Operationen auf naturlichen, ganzen Zahlen und Binar-bruchen (Fixpunktschreibweise) konnen durch Schaltnetze realisiert werden.Achtung: Genauigkeit beschrankt - wir rechnen in einem endlichen Teilbereich derZahlen.Gleiches gilt fur Operationen der Aussagenlogik.

2.3.7 Schaltnetze zur Ubertragung von Information

Wir konnen uber Leitungen Nachrichten ubertragen. Sind unterschiedliche Partneran einer Ubertragung beteiligt, so besteht oft der Wunsch, dass Nachrichten gezieltvon einem Partner zum anderen ubertrangen werden (Bsp. Telefon, E-Mail). DiesErfordert eine Adressierung der Nachrichten (im Bsp. Telefonnummern, E-Mail-Adressen).Wir betrachten als elementares Beispiel Schaltungen mit Steuerleitungen. Sei {1, . . . , n}die Menge der Teilnehmer und c : {1, . . . , n} → Bm eine Codierfunktion, die jedemTeilnehmer einen Binarcode zuordnet. Weiter sei d : Bm → {1, . . . ,m}. Forderung:d(c(i)) = i∀i ∈ {1, . . . , n}.Einfaches Beispiel: 1 - aus - n - Code

c(i) =

⟨0 . . . 0︸︷︷︸

i−1

10 . . . 0︸︷︷︸n−i

⟩Sei ferner eine weniger redundante Binarcodierung c′ fur {1, . . . , n} gegeben:

c′ : {1, . . . , n} → Bj

DF : Bj → Bn

DF(c′(i))0c(i)∀1 ≤ i ≤ n

2.4. SCHALTWERKE 25

DF

Teilnehmer 1 Teilnehmer n

. . ....k ...k

k. . .

...j

...n

Abbildung 2.15: Multiplexer

Eine Schaltung wie in Abbildung 2.15 bledent aus n Eingangsbundeln der Breitek alle bis auf eines aus; welches weitergegeben wird, bestimmt die Adresse fur DF.Diese Schaltung nennen wir Multiplexer:

MX : Bj × Bk·n → Bk

Demultiplexer:DMX : Bj × Bk → Bk·m

2.4 Schaltwerke

Bisher haben wir Schaltnetze betrachtet. Diese hatten keine Zyklen. Nun betrachtenwir Schaltwerke. Diese sind wie Schaltwerke, allerdings sind nun Zyklen zugelassen.In der Praxis wird eine Schaltung nicht nur ein Mal benutzt (d.h. es wird nicht nurein Binarwort eingegeben), sondern nacheinander wird eine Folge von Binarworterneingegeben und an den Ausgangen entsteht eine Folge von Binarworten.

2.4.1 Schaltwerksfunktionen

Schaltfunktion: f : Bn → Bm

Schaltwerksfunktion: g : (Bn)∗ → (Bm)∗, wobei |g(x)| = |x| fur x ∈ (Bn)∗, d.h.jedes Eingabewort wird auf ein Ausgabewort abgebildet.

Beispiel: Schaltwerksfunktionx1 . . . xn y1 . . . ym Zeitpunkt (Takt)

(x1) L 0 L 0 1 (y1)(x2) 0 L 0 L 2 (y2)(x3) L 0 L 0 3 (y3)(x4) 0 L 0 L 4 (y4)(x5) 0 L 0 L 5 (y5)(x6) L L L L 6 (y6)

......

......

......

...Achtung: Zwischen xi und yj durfen auch fur i 6= j Abhangigkeiten bestehen.Wichtig: Zeitflusseigenschaft (Kausalitat): Ausgaben zum Zeitpunkt j durfen hochs-tens von Eingaben zum Zeitpunkt i ≤ j abhangen.


Prafixordnung auf (Bn)∗: Fur x, y ∈ (Bn)∗ gelte

x v y ⇔def ∃z ∈ (Bn)∗ : x ◦ z = y

Die Kausalitat entspricht der Prafix-Monotonie: x v x′ ⇒ g(x) v g(x′).Schaltwerksfunktion: g : (Bn)∗ → (Bm)∗ mit |g(x)| = |x| ∀x ∈ (Bn)∗ und g prafix-monoton (d.h. Kausalitat ist gegeben).

2.4.2 Schaltfunktionen als Schaltwerksfunktionen

Gegeben sei eine Schaltfunktion f : Bn → Bm. Wir definieren eine Schaltwerksfunk-tion

f∗ : (Bn)∗ → (Bm)∗

durch

f∗(⟨x1, x2, . . . , xk

⟩) :=

⟨f(x1), f(x2), . . . , f(xk)

⟩Die Schaltwerksfunktion f∗ hat die Eigenschaft, dass die Ausgabe f(xk) zum Zeit-punkt k lediglich von der Eingabe xk zum Zeitpunkt k abhangt. Die Funktion�speichert� nichts von den fruheren Eingaben. Solche Schaltwerksfunktionen hei-ßen auch kombinatorisch, die anderen sequentiell.

2.4.3 Schaltwerke

Ein Schaltwerk ist ein gerichteter Graph mit Knoten, die Schaltwerksfunktionenentsprechen, und Kanten, die Leitungen entsprechen. Jetzt sind Zyklen zugelassen.In der Praxis werden wir jedoch nur eingeschrankt Zyklen betrachten.

2.4.4 Schaltwerksfunktionen und endliche Automaten

Ein endlicher Automat hat einen Zustand aus einer endlichen Zustandsmenge state.Er bekommt in einem gegebenen Zustand eine Eingabe aus einer Eingabemenge inund erzeugt eine Ausgabe y aus einer Ausgabemenge out und einen �neuen� Zu-stand aus state. Wir sprechen von einem Zustand.Wir stellen die Zustandsubergange durch eine Zustandsubergangsfunktion

δ : state× in → state× out

dar.Bei Schaltwerken betrachten wir Automaten, bei denen alle drei Mengen durchBinarworter dargestellt werden (z,m, n ∈ N):

δ : Bz × Bn → Bz × Bm

Solche Automaten lassen sich kompakt durch Zustandsubergangsdiagramme dar-stellen.

Beispiel: B2 × B2 → B2 × B2. Zustandsubergangsdiagramm: s. Abb. 2.16.Achtung: Bestimmte Binarkombinationen treten als Zustande und Eingange nicht

auf.Die Kreise stellen die Zustande dar. Ein Pfeil vom Kreis σ1 zum Kreis σ2 mitBeschriftung x/y steht fur δ(σ1, x) = (σ2, y).Ein Zustandsubergang besteht in einem Wechsel von einem Zustand σ1 zu einemZustand σ2. Ausgelost wird der Ubergang von einer Eingabe x und er erzeugt eineAusgabe y.Schaltwerke konnen in ihrem Verhalten durch

2.4. SCHALTWERKE 27

00/0L0L/0L

00/L0L0/L00L L0

0L/0L

L0/L0

Abbildung 2.16: Zustandsubergangsdiagramm

• Automaten mit Ein-/Ausgabe

• Schaltwerksfunktion

beschrieben werden. Dabei gilt: jede Schaltewerksfunktion definiert einen Automa-ten.

Automaten definieren Schaltwerksfunktionen

Gegeben sei δ : state × in → state × out. Jeder Zustand σ ∈ state definiert eineSchaltwerksfunktion fσ : in∗ → out∗ wie folgt: Seien a ∈ in, x ∈ in∗ und b ∈ out.

fσ(〈a〉 ◦ x) = 〈b〉 ◦ fσ′(x) ⇔ delta(σ, a) = (σ′, b)

fσ beschreibt das Ein-/Ausgabeverhalten des Automaten, wenn er im Zustand σ�gestartet� wird.

Beispiel: obiger Automat Es gilt fL0(〈00〉 ◦ x) = 〈L0〉 ◦ fL0(x) und f0L(〈00〉 ◦x) = 〈oL〉 ◦ f0L(x), d.h. fσ(〈00〉 ◦ x) = 〈σ〉 ◦ fσ(x) (Lesegleichung: Durch Eingabevon 〈00〉 wird der Zustand ausgegeben (�gelesen�) und beibehalten).Fur σ, σ′ ∈ {0L,L0} gilt fσ(〈σ′〉 ◦x) = 〈σ′〉 ◦ fσ′(x) (Schreibgleichung: Der Zustandσ′ wird geschrieben: Die Eingabe von σ′ ∈ {0L,L0} fuhrt dazu, dass der Automatin den Zustand σ′ ubergeht).Fazit: Der Automat speichert durch seinen Zustand genau ein Bit, das beliebig oftgelesen oder uberschrieben werden kann.

Schaltwerksfunktionen definieren Automaten

Wir ordnen einer Schaltwerksfunktion f : in∗ → out∗ einen Automaten δf : SWF×in → SWF × out zu. Dabei steht SWF fur die Menge der Schaltwerksfunktioonenin∗ → out∗. Dabei gelte fur g, g′ ∈ SWF, a ∈ in, b ∈ out: δf (g, a) = (g′, b), wobei bund g′ definiert sind durch g(〈a〉 ◦ x) = 〈b〉 ◦ g′(x) fur alle x ∈ in∗.Da g eine Schaltwerksfunktion ist, ist b durch a eindeutig bestimmt. Es gilt g′(x) =rest(g(〈a〉 ◦ x)). Jede Funktion f ∈ SWF definiert einen Zustand des Automaten.Jedes Schaltwerk kann in seinem Verhalten entweder als Automat mit Ein-/Ausgabeoder als Schaltwerksfunktion beschrieben werden - die Darstellungen sind ineinanderuberfuhrbar.

2.4.5 Schaltwerke zum Speichern: Verzogerungsnetze

Ruckkopplung: das Flip-Flop (s. Abb. 2.17)Es gilt Qneu = ¬(r ∨Q), Qneu = ¬(s ∨Q).

Beispiel fur das Schalten des Flip-Flops:

• Schreiben:


s

rQ

Q

Abbildung 2.17: Flip-Flop: Nor-Latch

s L L L L L . . .r 0 0 0 0 0 . . .Q 0 0 L L L . . .Q L 0 0 0 0 . . .

Qneu 0 L L L L . . .Qneu 0 0 0 0 0 . . .

Idee: Wir wiederholen die gleiche Eingabe aus s und r, bis die Q, Q stabili-sieren.

• Lesen:s 0 0 0 0 . . .r 0 0 0 0 . . .Q 0 0 0 0 . . .Q L L L L . . .

Qneu 0 0 0 0 . . .Qneu L L L L . . .

Das Flip-Flop ahnelt in seinem Schaltverhalten stark dem Automaten, den wirim vorhergehenden Beispiel beschrieben haben. Allerdings treten beim SchreibenZwischenzustande auf. Das Flip-Flop stabilisiert sich nach einem Zwischenschritt.Allgemeine Feststellung:

1. Bei komplizierten Schaltungen konnen vorher Zwischenschritte erforderlichsein, um einen stabilen Zustand und eine stabile Ausgabe zu erreichen.

2. Unter gewissen Umstanden tritt keine Stabilisierung ein.

Bei Schaltungen, die sich stabilisieren, ergeben sich zwei Sichten:

• Mikrosicht: Automat, Schaltwerksfunktion, in der der Stabilisationsvorgangsichtbar ist.

• Makrosicht: Abstraktion der Mikrosicht. Wir wiederholen in der Mikrosichtdie Eingabe, bis Stabilisierung eintritt, und nehmen die vorliegende Ausgabeals Ausgabe und den dann vorliegenden Zustand als neuen Zustand. Die Zahl,wie oft die Eingabe wiederholt wird, bis eine Stabilisierung erreicht wird,bestimmt die Frequenz und den Takt der Schaltung.

2.4.6 Klassen von Schaltwerken

Typischerweise baut man nicht Schaltwerke mit beliebig komplizierten, verzoge-rungsfreien Ruckkopplungsleitungen, sondern verwendet Flip-Flops zur Realisierungvon Speichern und verwendet sonst nur verzogerte Ruckkopplungen.

2.4. SCHALTWERKE 29

Verzogerung (delay):

Dn : (Bn)∗ → (Bn)∗ a ∈ Bn

Dan(〈x1 . . . xn〉) = 〈ax1 . . . xn−1〉

d.h. die Ausgabe ist um einen Takt verzogert.

2.4.7 Komposition von Schaltwerken und Schaltnetzen

Aus Speichergliedern (Flip-Flops) und Verzogerungsgliedern konnen wir, unter Ver-wendung der Konzepte aus den Schaltnetzen, beliebig komplizierte und machtigeSchaltungen aufbauen:

• Speicher

• Verarbeitungswerke

• Ubertragungsnetze

Damit lassen sich durch Schaltungen Bausteine (Chips) realisieren, aus denen dannRechner aufgebaut werden konnen.

Kapitel 3

Aufbau von Rechenanlagen

Eine Rechenanlage kann zunachst als riesiges Schaltwerk begriffen werden. DieseSichtweise zeigt uns, wie wir uns die Realisierung einer Rechenanlage vorstellenkonnen, ist aber fur die Nutzung und �Programmierung� nicht sehr hilfreich. Pro-gramme entsprechen auf Schaltwerksebene bestimmten gespeicherten Binkombina-tionen (Bitwortern).Fur das Entwickeln großerer Programme brauchen wir eine strukturierte Sicht aufdie Rechenanlage, durch die Programme greifbarer werden.

3.1 Strukturierter Aufbau von Rechenanlagen

Das Grobkonzept eines Rechners (von-Neumann-Architektur) ist sein 50 Jahrenpraktisch unverandert. Eine Rechenanlage besteht demnach aus:

• Rechnerkern / Prozessor / CPU

• Speicher

• Verbindungshardware (Bussysteme)

• Peripherie (Ein-/Ausgabevorrichtungen)

Wir sind im Weiteren primar an der Programmierung von Rechenanlagen inter-essiert. Somit interessiert uns die physikalische Struktur nur insoweit, als sie dieProgramme auf Maschinenebene beeinflusst.Dabei stellt sich die Frage, mit welchen Mitteln die Struktur einer Rechenanlagemodelliert wird. Wir verwenden die Idee der Zustandsmaschine um eine Rechenan-lage zu beschreiben. Dabei konzentrieren wir uns auf die Zustandsubergange, diedurch die Ausfuhrung von Befehlen ausgelost werden. Der Zustand einer Rechen-anlage ist gegeben durch die Belegung ihrer Speicherzellen und Register (speziellezusatzliche Speicherzellen fur besondere Aufgaben).Zur Erlauterung der Struktur einer Rechenanlage und ihrer Programmierung ver-wenden wir eine Maschine MI (angelehnt an die VAX von Digital). Die Bestandtei-le des Rechners, insbesondere seine Speicherzellen und Register, stellen wir durchProgrammvariable geeigneter Sorten dar und die Wirkungsweise der Programme /Befehle durch zuweisungsorientierte Programme, die auf diesen Programmvariablenarbeiten.

Wichtig: Im Speicher stehen Programme und Daten!Der Modellmaschine MI besteht im Prinzip aus vier Rechnerkernen, zwei E/A-

Prozessoren, dem Arbeitsspeicher und dem Bussystem.

31

32 KAPITEL 3. AUFBAU VON RECHENANLAGEN

Rechnerkern

Steuerwerk RechenwerkE/A−Prozessoren Peripherie

Bus (Verbindung)

Speichereinheit

Abbildung 3.1: Schematischer Aufbau eines von-Neumann-Rechners

. . .

. . .

Arbeitsspeicher E/A 1 E/A 2Rechnerkern

Adressbus

Datenbus

Steuerbus

Plattenspeicher Terminals

Abbildung 3.2: Spezifische Rechnerarchitektur der MI

3.1. STRUKTURIERTER AUFBAU VON RECHENANLAGEN 33

3.1.1 Der Rechnerkern

Rechnerkern: Hardware-Betriebsmittel, welches autonom den Kontrollfluss steu-ert (entscheidet, welcher Befehl ausgefuhrt wird) und die Datentransformationenausfuhrt. Der Rechnerkern wird in Steuerewerk und Rechenwerk unterteilt.Das Steuerwerk enthalt den Taktgeber und die Register, die die Information enthal-ten, die fur die Ablaufsteuerung erforderlich ist (Befehlszahler, . . . ). Das Steuerwerkerzeugt auch die Steuersignale fur die Ansteuerung des Rechenwerks.Das Rechenwerk enthalt die Operandenregister und die Schaltnetze/-werke zurAusfuhrung der Operationen. Damit bestimmt das Rechenwerk den Befehlsvorrat.Die Register im Rechnerkern sind Speicherzellen mit extrem kurzen Zugriffszeiten.Die Bestandteile der MI werden durch folgende Deklarationen von Programmvaria-blen charakterisiert:16 Register fur 32-Bit-Worter: var [0:31] array bit R0, ..., R15Aufgaben:R0 : R13 frei verwendbar fur Programmierung

R14 Zeiger fur Stapel (stack pointer, SP)R15 Befehlszahler (program counter, PC)

Zusazlich im Steuerewerk:var [0:7] array bit IR Instruktionsregistervar [0:31] array bit PSL Prozessorstatusregister

Weitere Hilfsregister fur Steuer-/Rechenwerk:var [0:31] array bit tmp0, ..., tmp3 Hilfsregister fur die ALUvar [0:7] array bit am legt Adressiermodus festvar [0:31] array bit adr fur die Adressrechnungvar [0:31] array bit index fur die Indexrechnung

Die Anzahl der Register in einem Rechnerkern kann sehr stark schwanken (fruheroft nur ein Register: Akkumulator, heute ganze Registerbanke).

3.1.2 Speichereinheit

Die Speichereinheit besteht aus einer Folge von Speicherzellen, auf die uber Adres-sen zugegriffen wird.MI:var [0:232 − 1] array [0:7] array bit M Speichervar [0:31] array bit MAR Speicheradressregistervar [0:31] array bit MBR speicherregister

3.1.3 E/A

Die Ein-/Ausgabe erfolgt uber Peripheriegerate durch die E/A-Prozessoren. (ge-naueres spater)

3.1.4 Befehle und Daten auf Maschinenebene

Auf Maschinenebene werden alle Daten und Befehle durch Bitworter dargestellt(Binardarstellung). Ein Befehl ist ein Binarwort, das im Hauptspeicher gespeichertwerden kann und bei Ausfuhrung (laden in den Rechnerkern und Interpretation)eine Zustandsanderung der Maschine bewirkt.Bestandteile eines Befehls:

• Charakterisierung der Operation

• Charakterisierung der Operanden


Wir unterscheiden eine ganze Reihe unterschiedlicher Befehlsarten.Die Operanden kennzeichnen die Werte, mit denen wir arbeiten: Sie werden immerdurch Bitworter dargestellt, konnen aber ganz unterschiedliche Werte bezeichnen:

• Adressen

• Zahlen

• Charakter

Darstellung von Zahlen durch Bitworter:naturliche Zahlen Binarschreibweiseganze Zahlen ZweierkomplementdarstellungFixpunktdarstellung Darstellung von Zahlen aus [−1, 1[Gleitpuntkdarstellung Darstellung von Zahlen durch Wert und Exponent

Festpunktdarstellung: Zweierkomplementdarstellung (32 Bit), Multiplikation mit2−31.Gleitpunktdarstellung: b = 〈b0b1 . . . bnbn+1 . . . bn+m〉 mit b0: Vorzeichen, b1 . . . bn

Exponent, bn+1 . . . bn+m Mantisse.Wir berechnen den dargestellten Zahlenwert mit Hilfe folgender Hilfswerte:

e =n∑

i=1

2n−iw(bi)

v =m∑

i=1

2−iw(bn+1)

Es gilt 0 ≤ e < 2n, 0 ≤ v < 1.

exp = e− 2n−1 + 1 ⇒ −2n−1 + 1 ≤ exp ≤ 2n−1

man = 1 + v ⇒ 1 ≤ man < 2

Falle der Interpretation:

• Normalfall: −2n−1 + 1 < exp < 2n−1. Wir erhalten als dargestellt Zahl(−2)w(b0) · 2exp ·man

• Darstellung der Null: e = 0 ∧ v = 0

• Unterlauf: e = 0 ∧ v 6= 0

• Uberlauf: e = emax = 2n − 1 ∧ v = 0

• Fehlerfall: e = emax = 2n − 1 ∧ v 6= 0

Unterlauf, Uberlauf und Fehlerfall sind keine gultigen Zahldarstellungen.Auf Maschinenebene werden alle Daten durch Bitsequenzen dargestellt.Sorte Kennung Wortlangesort byte = [0:7] array bit B 8sort half-word = [0:15] array bit H 16sort word = [0:31] array bit W 32sort floating-point = [0:31] array bit F 32 (8 + 23)sort double-float = [0:63] array bit D 64 (11 + 52)

Problem: Einer Ziffernfolge 37216 ist nicht mehr anzusehen, ob sie in Oktal-, Dezimal-oder Hexadezimaldarstellung ist.Ausweg: (37216)8 oktal, (37216)10 dezimal, (37216)16 hexadezimalKonvention: Wir verwenden Dezimaldarstellung und geben Oktal- und Hexadezi-maldarstellung explizit an.


Auch Befehle werden auf Maschinenebene durch Bitsequenzen darstestellt. Beque-mer und lesbarer sind Darstellungen, bei denen die Teile des Befehls durch Namenudn Dezimalzahlen dargestellt werden.Bestandteile eines Befehls:

• Operation: Angabe, welche Umformung bzw. welche Umspeicherung ausgefuhrtwird

• Operandenspezifikation: Angabe, mit welchen Werten / Speicherzellen / Re-gistern dabei gearbeitet wird

Syntax:〈command〉 ::= 〈instructionPart〉 {〈opPart〉 {, 〈opPart〉}∗}

Es gibt Maschinen mit starrem Befehlsformat (festgelegte Lange der Bitsequenz).Nachteil: Jeder Befehl hat die gleiche Anzahl von Bits fur Operandenspezifikationenzur Verfugung. Vorteil: Jeder Befehl passt genau in eine Speicherstelle, das Ansteu-ern von Befehlen wird einfacher.Die MI hat flexible Befehlsformate.Der Instruktionsteil (Operationsangabe) des Befehls wird im Rechnerkern (im Steu-erwerk) in Steuerbits umgesetzt, die die entsprechenden Umformungen und Umspei-cherungen auslosen.

3.1.5 Operandenspezifikation und Adressrechnung

Jeder Befehl arbeitet mit bestimmten Werten (Bitsequenzen) und bestimmten Spei-cherplatzen / Registern. Wir sprechen von Operanden.

Beispiel: Einfachste Art der Operandenspezifikation: wir geben das Register WR9 (W: Kennung, R9: Register) oder die Speicherzelle W 1743 direkt an. Damitwerden die Speicherzellen 1743-1746 angesprochen.

Die einfachste Form der Angabe von Operanden ist die direkte (absolute) Adres-sierung: Es werden Register / Adresse explizit angegeben. Weil wir an mehr Flexibi-litat interessiert sind und uns in einem Programm nicht festlegen wollen, an welcherStelle im Speicher es (�absolut�) steht, verwenden wir kompliziertere Adressierver-fahren. Dazu verwenden wir eine Operandenspezifikation. Dies ist eine Anga-be, aus der wir die Operanden berechnen konnen (Adressrechnung). Jeder Operandentspricht einer �Lokation� (einem Speicherplatz oder Register; genauer: einemAusschnitt aus einem Speicher / Register oder einer Folge). Ein Operand bestimmteinen bestimmten Platz (Lokation) in der Maschine, an der eine Bitsequenz gespei-cher ist.sort operand = register (type k, nat n) | memo (type k, nat n)sort type = {B, H, W, F, D}Eine Operandenspezifikation ist ein syntaktischer Ausdruck, der angibt, wie derOperand zu berechnen ist. Jede Operandenspezifikation wird bei Ausfuhrung ei-nes Befehls im Befehlszyklusin einen Operanden umgerechnet. Dazu verwenden wirfolgende Hilfsprozeduren:

1 fct val = (operand x) seq bit:2 if x in register then R[n(x)][32-wl(k(x)):31]

else get (wl(k(x))/8, n(x))4 fi

6 fct get = (nat i, nat n) seq bit:if i = 0 then empty

8 else conc (M[n], get(i-1, n+1))fi


Adressierarten:

• direkte Adressierung: Die absolute Adresse (oder das Register) wird imAdressteil angegeben.

• direkte Angabe des Operandenwerts im Befehl als Binar-, Hexadezi-mal- oder Dezimalzahl.

• relative Adressierung: Zum Adressteil im Befehl wird der Inhalt einesRegisters addiert.

• indirekte Adressierung / Adresssubstitution: Die Speicherzelle, dieuber den Adressteil angesteuert wird, enthalt selbst eine Adresse der Spei-cherzelle, die den Operanden bildet.

• Indizierung: Zur ermittelten Adresse wird ein weiterer Wert addiert (typi-sche Anwendung: hochzahlen eines Zahlers in einer Wiederholungsanweisungzum Zugriff auf Feldelemente)

BNF-Syntax der MI-Operandenspezifikation:

〈opPart〉 ::= 〈absoluteAddress〉| 〈immediateOp〉| 〈register〉| 〈relativeAddress〉| 〈indexedRelativeAddress〉| 〈indirectAddress〉| 〈indexedIndirectAddress〉| 〈stackAddress〉

Ein Teil der Adressierart wird durch folgende Werte bestimmt:

1 sort operandSpec = opspec (nat reg, bool isr, bool idr,2 incr icr, nat rel, indexSpec int)

sort indexSpec = {-} | reg (nat)4 sort incr = {-1 | 0 | 1 }

• absolute Adressierung:

〈absoluteAddress〉 ::= 〈intexp〉 (�integer expression�)

• Operand als Wert:〈immediateOp〉 ::= I 〈intexp〉

• Register als Operand:

〈register〉 ::= R0| . . . |R15|PC|SP

• relative Adresse:

〈relativeAddress〉 ::= {〈intexp〉+}! 〈register〉

• indizierte relative Adressierung:

〈indexedRelativeAddress〉 ::= 〈relativeAddress〉〈index〉〈index〉 ::= / 〈register〉 /


• indirekte Adressierung:

〈indirectAddress〉 ::=!(〈relativeAddress〉)|!! 〈register〉

• indizierte indirekte Adressierung:

〈indexedIndirectAddress〉 ::= 〈indirectAddress〉〈index〉

• Stack-Adressierung:

〈stackAddress〉 ::= −! 〈register〉 |! 〈register〉+

3.1.6 Der Befehlszyklus

Der Befehlszyklus bezeichnet die Folge der Schritte, die bei der Ausfuhrung einesBefehls ausgefuhrt werden. Die Maschinen durchlaufen immer wieder die gleicheSequenz von Schritten und fuhren dabei jeweils einen Befehl aus. Wir beschreibenden Befehlszyklus wiederum durch ein Programm. In der MI besteht ein Befehl auseinem Operationsteil und bis zu vier Operanden.In der Maschine ist der Operationsteil durch ein Byte reprasentiert. In diesem Bytesind die folgenden Informationen verschlusselt:fct args = (byte) nat Anzahl der Operandenfct kenn = (byte) type Kennungfct result = (byte) bool Wird ein Resultat erzeugt?

Der Befehlszyklus der MI entspricht dem folgenden Programm.

1 while not(stop) do2 fetch_operator;

if 1 <= args(IR) then4 fetch_operand (kenn(IR), tmp1[32-wl(kenn(IR)):31])

fi;6 if 2 <= args(IR) then

fetch_operand (kenn(IR), tmp2[32-wl(kenn(IR)):31])8 fi;

if 2 <= args(IR) then10 fetch_operand (kenn(IR), tmp3[32-wl(kenn(IR)):31])

fi;12 execute (IR);

if result (IR) then14 put_result

fi16 od

18 proc fetch_operator =:fetch (B, R15, IR);

20 R15 := R15 + 1

22 proc fetch = (type k, [0:31] array bit adr,var array[0:wl(k)-1] array bit r):

24 MAR := adr;for i := 1 to wl(k)/8 do

26 MBR[(i-1)*8:i*8-1] := M[MAR];MAR := MAR + 1

28 od;r := MBR[0:wl(k)-1]


30

proc put = (type k, [0:31] array bit adr,32 var array[0:wl(k)-1] array bit r):

MAR := adr;34 MBR[0:wl(k)-1] := r;

for i := 1 to wl(k)/8 do36 M[MAR] := MBR[(i-1)*8:i*8-1];

MAR := MAR + 1;38 od

Fur die Adressrechnung zur Ermittlung der Operanden benotigen wir eine weitereInformation, die aus dem Byte ermittelt wird, das den Adressiermodus bestimmt:fct reg = (byte) nat Registerzahlfct isr = (byte) bool steht Operand im Register?fct isrel = (byte) bool relative Adressierung?fct idr = (byte) bool indirekte Adressierung?fct isidx = (byte) bool Indexadressierung?fct icr = (byte) incr Registerinkrement / -dekrement

Bei der Ausfuhrung eines Befehls (execute) wird nicht nur ein Ergebnis berechnetund zuruckgeschrieben. Es werden auch bestimmte Bits in einem zusatzlichen Re-gister (dem Prozessorstatusregister) gesetzt. Dabei sind folgende vier Bits fur unsvon besonderer Bedeutung:C carry UbertragV overflow UberlaufZ zero Resultat ist NullN negative Resultat ist negativ

Die Schritte zum Bereitstellen der Operanden und der Abspeicherung des Resultatssind fur alle Befehle, abhangig von der Zahl der Argumente und der Frage, ob einResultat anfallt, gleich. Die Wirkung eines Befehls wird durch die Rechenvorschriftproc execute = (byte): ...beschrieben.

3.2 Hardwarekomponenten

Wir unterscheiden folgende Bestandteile einer Rechenanlage:

• Prozessor

• Speicher

– Hauptspeicher

– Hintergrundspeicher

– Speichermittel fur das Archivieren

• Eingabegerate

• Ausgabegerate

• Datenubertragungsgerate / Netze

Kapitel 4

MaschinennaheProgrammierung

Die im letzten Kapitel eingefuhrten Programmstrukturen beschreiben am Beispielder MI die Wirkungsweise eines Rechners. Nun fuhren wir die einzelnen Befehle ein,beschreiben ihre Wirkung und formulieren erste kurze Maschinenprogramme.Grundsatzliche Feststellungen:

• Ein Maschinenprogramm ist eine endliche Folge von Befehlen, die zur Aus-fuhrungszeit im Hauptspeicher stehen. Damit hat jeder Befehl eine absoluteund eine relative Adresse.

• Diese Befehle werden, gesteuert durch den IC (PC) nacheinander ausgefuhrt.

• Jedes Programm, das nicht in Maschinensprache geschrieben ist, muss

– von Hand oder durch ein Ubersetzungsprogramm (Compiler) in Maschi-nensprache ubersetzt werden, bevor es ausgefuhrt werden kann, oder

– ein Interpretationsprogramm (Interpreter) angegeben werden; dies istein in Maschinensprache gegebenes Programm, das das Programm inProgrammiersprache durchlauft und dabei die entsprechenden Befehleausfuhrt.

4.1 Maschinennahe Programmiersprachen

Struktur, Form und Umfang eines Befehlssatzes und der einzelnen Befehle wirddurch den Rechnerkern gepragt.Maschinenprogramme sind Folgen von Befehlen und weisen somit keine besondereStruktur auf. Es ist Aufgabe des Programmierers, Maschinenprogramme struktu-riert zu schreiben. Deshalb:

! Trickreiche Programmierung vermeiden!

! Transparente Programmstrukturierung anstreben!

! Ausreichend dokumentieren!

! Umfangreiche Programme in Programmteile strukturieren!

39

40 KAPITEL 4. MASCHINENNAHE PROGRAMMIERUNG

4.1.1 Binarworter als Befehle

In der MI entspricht ein Programm zur Ausfuhrungszeit einer Folgt von Bytes imSpeicher. In dieser Form ist ein Programm fur Menschen praktisch unlesbar.

〈binaryMachineCommand〉 ::= 〈byte〉∗

〈binaryAddress〉 ::={0|L}8L

〈binaryMachineProgramm〉 ::={〈binaryAddress〉〈byte〉}∗

|{〈binaryAddress〉〈binaryMachineCommand〉}

Wir vermeiden diese Form der Befehlsangabe und wahlen eine etwas lesbarere. Da-bei werden Befehle durch Angabe der Befehlsbezeichnung, des Typs der Operandenund der Adressen in Dezimalschreibweise beschrieben.

4.1.2 Der Befehlsvorrat der MI

Die Wirkung eines Befehls wird durch die Rechenvorschrift execute im Befehlszy-klus festgelegt. Dabei werden gewisse Hilfsregister / Spezialregister und insbeson-dere das PSL (Prozessorstatusregister) geandert.Beispiele fur Befehle der MI:

• Transportbefehle - Umspeichern von InformationenMOVE W 1000, 2000Es wird der Inhalt der Speicherzellen 1000 - 1003 in tmp1 geladen, in tmp0umgesetzt und in die Speicherzellen 2000 - 2003 zuruckgespeichert.MOVE B 1000, 2000Der Inhalt der Speicherzelle 1000 wird mit Hilfe der temporaren Register indie Zelle 2000 geschrieben.MOVE B 1000, R4R4[24:31] wird durch das Byte in Zelle 1000 uberschrieben.MOVEA 1000, 2000(�move address�) ist wirkungsgleich zu MOVE W I1000, 2000: der Wert (dieAdresse) 1000 wird den Speicherzellen 2000 - 2003 zugewiesen.CLEAR B R7Dieser Befehl bewirkt das Uberschreiben von R7[24:31] durch das Byte 0016.

• Logische OperationenOR W R8, 3001, R1bewirkt bitweise Disjunktion der 32 Bit in R8 mit den 32 Bit in 3001 - 3004; dasResultat wird in Register R1 geschrieben. Typische Anwendung: Maskierenvon Werten.

• Arithmetische OperationenADD, SUB, MULT, DIVWirkung entsprechend der Zahldarstellung (gesteuert uber die Kennung), s.spater

• VergleichsoperationenCMP W 3007, R6Dieser Befehl dient dazu, gewisse Bits im PSL zu setzen. Im Beispiel werdendie 32 Bit in den Zellen 3007 - 3010 in tmp1 und die 32 Bit aus R6 in tmp2geschrieben. Dann wird tmp1 mit tmp2 verglichen:

1 Z := (tmp1 = tmp2)2 N := (tmp1 < tmp2)

4.1. MASCHINENNAHE PROGRAMMIERSPRACHEN 41

• In Sprungbefehlen konnen wir nun auf die so gesetzten Bits Bezug nehmen.JUMP 5000Einfacher (unbedingter) Sprung: der Befehlszahler wird mit Adresse 5000 be-legt.JEQ 5000(�jump equal�): Der Befehlszahler wird mit Adresse 5000 belegt, falls Z=Lgilt; anderenfalls hat der Befehl keine Wirkung.

• Shiftbefehle erlauben es, die Bits in einem Operanden zu verschieben. (imBsp: Rechtsshift um 2 Bit)

LL000L0L 0LLL000L

Zwei Bits werden frei und konnen entweder durch Nachziehen von 0 oder Lbelegt werden oder durch kreisformiges Durchschieben.

Dieser Befehlssatz ist nur ein Ausschnitt der wichtigsten Befehle der MI. Reale Ma-schinen haben oft erheblich umfangreichere Befehlssatze, wobei oft nur Abkurzun-gen fur Befehle oder das Zusammenfassen mehrerer Befehle zu einem dadurchmoglich wird.Wir haben als wichtige Befehle nur die ausgeklammert, die fur die Systemprogram-mierung von Bedeutung sind.

4.1.3 Einfache Maschinenprogramme

Zur Ausfuhrungszeit der Programme stehen Daten und Programme gleichermaßenbinar codiert im Speicher. Dabei ist es ratsam, Daten und Programme in getrenntenSpeicherbereichen abzulegen.

Beispiel: SpeicherorganisationAdresse (hex) Verwendung0000 0000 reserviert0000 0400

Programmspeicher3FFF FFFF4000 0000

Kontrollbereich (Daten, Stack)7FFF FFFF8000 0000

SystembereichBFFF FFFFC000 0000

reserviert fur SystemprogrammeFFFF FFFF

Die im Beispiel verwendeten Adressen sind �virtuell�, d.h. die tatsachlich im Haupt-speicher vorhandene Menge von Adressen ist erheblich kleiner. Zur Ausfuhrungszeitwerden den virtuellen Adressen richtige Adressen zugeordnet. Ein Teil der Datensteht im Hintergrundspeicher und wird bei Bedarf in den Hauptspeicher geladen.Zur Erhohung der Lesbarkeit unserer Programme arbeiten wir mit Adressen, ohneuns um die Frage zu kummern, ob diese virtuell oder real sind, und verwenden inProgrammen symbolische Adressen fur Sprungbefehle.

Beispiele fur Maschinenprogramme


1. Berechnen des Maximums zweier Zahlen: Seien zwei Zahlen (32 Bit) im Spei-cher durch die Adressen in den Registern R1 und R2 gegeben. Das Maximumder Zahlen soll in Register R0 geschrieben werden.

1 CMP W !R1, !R22 JLE max2

MOVE W !R1, R04 JUMP ende

max2: MOVE W !R2, R06 ende:

2. Durchsuchen eines Speicherabschnitts. Gegeben seien Adressen in R0 und R1,wobei R0 ¡ R1 gelte. Der Speicher von R0 bis R1 soll nach einem 32-Bit-Wert,der in R2 steht, durchsucht werden. Falls der Wert gefunden wird, ist dieAdresse dazu in das Register R3 zu schreiben. Anderenfalls wird 0 nach R3geschrieben.Bei etwas komplizierteren Aufgaben ist es hilfreich, die Losung zuerst als pro-blemorientiertes Programm zu formulieren und dann erst das MI-Programmzu schreiben.

1 R3 := R0;2 suche: if M[R3] = R2 then goto ende

else R3 := R3 + 4;4 if R3 <= R1 then goto suche

fi;6 R3 := 0

fi8 ende:

Umsetzung in ein MI-Programm:

1 MOVE W R0, R32 suche: CMP W !R3, R2

JEQ ende4 ADD W I4, R3

CMP W R3, R16 JLE suche

CLEAR W R38 ende:

3. Sortieren der Inhalte eines Speicherbereichs.Aufgabe: Man sortiere die Bytes im Speicher zwischen der Adresse in R0 undder Adresse in R1 aufsteigend. R2, . . . , R11 durfen als Hilfsregister verwendetwerden.Wir verwenden einen einfachen Algorithmus:

1 R2 := R0;2 while R2 < R1 do

if M[R2] > M[R2+1] then4 M[R2], M[R2+1] := M[R2+1], M[R2];

if R0 < R2 then R2 := R2 - 1 fi6 else R2 := R2 + 1

fi8 od


Wir brechen das Programm in Sprungbefehle auf:

1 R2 := R0;2 m_while: if R2 >= R1 then goto ende fi;

R3 := R2 + 1;4 if M[R2] > M[R3] then goto vertauschen fi;

R2 := R3;6 goto m_while;

vertauschen: R4[24:31] := M[R2];8 M[R2] := M[R3];

M[R3] := R4[24:31];10 if R0 = R2 then goto m_while;

R2 := R2 - 1;12 goto m_while;

ende:

Nun ist das Schreiben des MI-Programms einfach:

1 MOVE W R0, R22 loop: CMP W R1, R2

JLE ende4 ADD W I1, R2, R3

CMP B !R3, !R36 JLT vertauschen

MOVE W R3, R28 JUMP loop

vertauschen: MOVE B !R2, R410 MOVE B !R3, !R2

MOVE B R4, !R312 CMP W R0, R2

JEQ loop14 SUB W I1, R2

JUMP loop16 ende:

4.1.4 Assemblersprachen

Assemblersprachen sind maschinennahe Programmiersprachen, die durch gering-fugige Erweiterung reiner Maschinensprachen entstehen. Die Umsetzung von As-semblersprachen in reine Maschinensprachen erfolgt durch Programme, sogenannteAssemblierer (engl. assembler). Typische Erweiterungen in Assembler sind:

• mehrfache Marken

• eingeschrankte arithmetische Ausdrucke

• direkte Operanden (in der MI ohnehin vorgesehen)

• symbolische Adressierung (analog zu Programmvariablen)

• Segmentierung (Bindungs- und Gultigkeitsbereiche fur Namen)

• Definition und Einsetzung von Substitutionstexten (�Makros�)

• Substitution von Makros = Makroexpansion

Uber die geschickte Einfuhrung von Makros konnen wir auf bestimmte Anwen-dungssituationen zugeschnittene �Assemblerstile� definieren.


4.1.5 Ein- und Mehradressform

Eine wesentliche Charakteristik einer Maschinensprache ist die Anzahl der Operan-den pro Befehl.

• starres Befehlsformat: einheitliche Zahl von 0, 1, 2, 3 Operanden pro Befehl

• flexibles Befehlsformat (siehe MI): Befehle haben zwischen 0 und n ∈ N Ope-randen

Bei starrem Befehlsformat sprechen wir von Einadressform, wenn jeder Befehl genaueinen Operanden enthalt (entsprechend Zwei- und Dreiadressform). Wir erhalten beiDreiadressform folgende Syntax:

〈befehl〉 ::= 〈register〉 ::=[〈operand〉| − 〈operand〉|AC

| 〈operand〉〈operator〉〈operand〉]|ififif 〈bedingung〉 then gotothen gotothen goto 〈marke〉 fififi

|skip|gotogotogoto 〈marke〉

〈befehlsfolge〉 ::={{〈marke〉}∗ 〈befehl〉}∗

〈speed〉 ::= 〈konstante〉|AC

|h[1]|h[2]| . . .|a|b| . . .

〈bedingung〉 ::= 〈register〉 = 0| 〈register〉 6= 0| 〈register〉 < 0| 〈register〉 ≤ 0

〈operator〉 ::={+,−, ∗, /, . . .}〈register〉 ::=AC

|a|b| . . .|h[1]|h[2]| . . .

Wir sprechen von einem Programm in Einadressform, wenn in jedem Befehl außerAC hochstens eine weitere Registerangabe auftritt. Der AC ist das zentrale Rechen-register, auf dem alle Berechnungen ausgefuhrt werden.Achtung: Dreiadressformen konnen immer in Einadressformen ubersetzt werden.

Beispiel

a := b + c Dreiadressform

wird umgeschrieben in

AC := b

AC := AC + c

a := AC


4.1.6 Unterprogrammtechniken

Wird eine Folge von Befehlen an mehreren Stellen in einem Maschinenprogrammbenotigt, so bietet es sich an, das Programm nicht mehrfach zu schreiben, sondern

• ein Makro zu definieren

• ein Unterprogramm zu definieren, d.h. ein Programmstuck, auf das uber eineMarke gesprungen werden kann, und das uber einen Rucksprung verlassenwird.

Beim Springen in ein Unterprogramm sind folgende Daten zu �ubergeben� (d.h.abzuspeichern, so dass das Unterprogramm darauf Zugriff hat):

• Rucksprungadresse

• Parameter

Beim Rucksprung sind unter Umstanden gewisse Resultate aus dem Unterprogramman das aufrufende Programm zu ubergeben. Techniken zur Ubergabe der Daten:

• Abspeichern in bestimmten Zellen im Unter- oder Hauptprogramm

• Abspeichern in Registern

• Abspeichern im Stack

Wichtig: Einheitliche, fur das ganze Programm gultige Regeln fur die Ubergabe derParameter und Rucksprungadresse festlegen.Geschlossenes Unterprogramm: Ansprung erfolgt uber Anfangsadresse, Rucksprunguber die vor Ansprung angegebene Adresse.Rekursives Unterprogramm: Aus dem Unterprogramm wird die Anfangsadresse an-gesprungen. Dann muss die Ruckkehradrese im Stack verwaltet werden.Beim offenen Einbau eines Unterprogramms (insbesondere beim Einsatz von Ma-kroexpansion) kann Rekursion nicht behandelt werden. Die MI sieht spezielle Be-fehle fur Unterprogrammaufrufe vor, die jedoch auch durch Befehle ersetzt werdenkonnen, die den Stack manipulieren und durch Sprungbefehle:

• CALL speichert den aktuellen Stand des Befehlszahlers (Register PC) im Stackab und setzt den Befehlszahler auf die angegebene Adresse.

• RET bewirkt die Ruckkehr an die Adresse hinter der Aufrufstelle. Diese wirdaus dem Stack in den PC geladen und der Stack wird zuruckgesetzt.

Beispiel: Aufruf eines Unterprogramms zur Berechnung der FakultatMOVE W ..., R0 (Argument in R0 ablegen)CALL fac (Unterprogramm aufrufen)MOVE W R2, ... (Resultat abspeicher)Wichtig: Durch Unterprogrammaufrufe werden Teile des Speichers und der Registerverandert. Fur die Nutzung eines Unterprogramms ist es wichtig zu wissen:

• wie Parameter / Resultat ubergeben werden

• welche Teile des Speichers / der Register durch das Unterprogramm verandertwerden

Bei einer strukturierten Programmierung auf Maschinenebene kommt der systema-tischen Nutzung von Unterprogrammen eine entscheidende Bedeutung zu. Unter-programme sind sorgfaltig zu dokumentieren.


Im allgemeinen Fall arbeitet das Hauptprogramm mit allen Registern. Das gleichegilt fur das Unterprogramm. Deshalb ist es naheliegend, vor dem Aufruf des Un-terprogramms alle Register zu �retten� (im Speicher zwischenzuspeichern). Dannkann das Unterprogramm alle Register frei nutzen. Nach Rucksprung werden diealten Registerwerte restauriert. Bei der MI gibt es einen speziellen Befehl zum Ret-ten der Register im Stack:PUSHR bewirkt ein Abspeichern der Register R14 bis R0 auf dem Stack entsprechendder folgenden Befehlssequenz:

1 SUB W I4, R142 MOVE W R14, !R14

SUB W I4, R144 MOVE W R13, !R14

...

Der Stackpointer wird insgesamt um 60 dekrementiert und die Registerinhalte wer-den im Stack gespeichert.Der Befehl POPR bewirkt das Restaurieren der Register aus dem Stack. Der Stack-pointer wird um 60 erhoht.Ratsam ist es, bei der Verwendung von Unterprogrammen eine einheitliche �Stan-dardschnittstelle� zu nutzen. Prinzipien:

• Im aufrufenden Programm werden die Parameter des Unterprogramms in derReihenfolge pn, . . . , p1 auf dem Stack abgelegt. Fur ein Ergebnis wird eben-falls Speicherplatz im Stack reserviert. Dann erfolgt der Aufruf des Unterpro-gramms. Die Ruckkehradresse steht im Stack.

• Im Unterprogramm werden die Registerwerte gesichert. Der nun erreichteStackpointer-Stand wird in R13 abgelegt. R13 dient also als Basisadresse furden Stackpointer-Stand zur Aufrufzeit. In R12 tragen wir die Basisadresse derParameter ein. Bei der Ruckkehr aus dem Unterprogramm konnen wir dieseBasisadresse verwenden, um den alten Stack-Pegel wiederherzustellen.

• Nach der Ausfuhrung des Unterprogramms wird uber POPR der Registerzu-stand wiederhergestellt und uber RET erfolgt der Rucksprung.

• Nach Ruckkehr stehen die Parameter und das Resultat im Stack. Nach Zuruck-setzen des Stacks um die Parameter steht das Resultat zu Beginn des Stacksund kann abgespeichert werden.

Also:

1 ...2 MOVE kn pn, -!SP

...4 MOVE k1 p1, -!SP

CALL up6 ADD W I..., SP

...8

up: PUSHR10 MOVE W SP, R13

MOVEA 64+!R13, R1212 ...

MOVE W R13, SP14 POPR

RET

4.2. ADRESSIERTECHNIKEN UND SPEICHERVERWALTUNG 47

Beispiel: ggt

1 MOVE W I0, -!SP2 MOVE W ..., -!SP

MOVE W ..., -!SP4 CALL ggt

ADD W I8, SP6 MOVE W !SP+, ...

8 ggt: PUSHRMOVE W SP, R13

10 MOVEA 64+!R13, R12CMP W 4+!R12, !R12

12 JNE elsethen: MOVE W !R12, 8+!R12

14 JUMP rueckelse: JLT op1lop2

16 SUB W 4+!R12, !R12JUMP reccall

18 op1lop2: SUB W !R12, 4+!R12reccall: MOVE W I0, -!SP

20 MOVE W !R12, -!SPMOVE W 4+!R12, -!SP

22 CALL ggtADD W I8, SP

24 MOVE W !SP+, 8+!R12rueck: MOVE W R13, SP

26 POPRRET

4.2 Adressiertechniken und Speicherverwaltung

In hoheren Programmiersprachen werden Datenstrukturen zur strukturierten Dar-stellung von Informationen verwendet:

• Grunddatentypen

• Enumerationssorten

• Records

• Union

• Array

• rekursive Datensorte

• Referenzen

Im Folgenden interessiert uns die Frage, wie wir diese Datenstrukturen auf Maschi-nenebene darstellen und darauf zugreifen konnen.

4.2.1 Konstante

Eine Konstante entspricht einer Operandenspezifikation, die einen Wert reprasen-tiert, ohne dabei auf Register oder den Speicher Bezug zu nemen. In der MI schrei-ben wir z.B. I 2735. Zur Ausfuhrungszeit ist der Wert 2735 in Binardarstellung im


Hauptspeicher abgelegt. Zur Ausfuhrungszeit des entsprechenden Befehls zeigt derBefehlszahler in der Adressrechnung auf die Adresse im Hauptspeicher, unter derder Wert abgelegt ist.

4.2.2 Operandenversorgung uber Register

Bei der Operandenversorgung uber Register sind die Zugriffszeiten in der Regelgeringer als beim Zugriff auf den Hauptspeicher. In der MI: Rn, 0 ≤ n ≤ 15.

4.2.3 Absolute Adressierung

Im Befehl wird die Adresse als Wert angegeben. Dies bedeutet, dass das Programmbzw. seine Daten im Hauptspeicher fixiert sind, d.h. die Lage im Hauptspeicherfestgelegt ist. Dies bedeutet eine Inflexibilitat, die zu vermeiden ist. Absolute Adres-sierung macht hochstens fur eine Reihe von �Systemprogrammen� Sinn.

4.2.4 Relative Adressierung

Idee: Wir adressieren relativ zu einer frei festlegbaren Anfangsadresse fur

• den Programmcode

• die Daten

Ein Maschinenprogramm heißt relativ adressiert, wenn es keine Adressteile bzw.zur Verwendung als Adressteile vorgesehene Operandenteile enthalt, die auf eineabsolute Lage des Programms oder seiner Daten im Speicher Bezug nehmen. Nurdann konnen wir das Programm und seine Daten an beliebigen Stellen im Speicheransiedeln.Fur die Methodik wichtige Frage: Ist die Tatsache, dass ein Maschinenprogrammrelativ adressiert ist, einfach zu erkennen und zu uberprufen (Codierstandards)?In der MI ist naturlich syntaktisch erkennbar, ob ausschließlich mit relativer Adres-sierung in der Operandenspezifikation gearbeitet wird. Dies garantiert allerdingsnoch nicht, dass das Programm relativ adressiert ist. (Achtung: Unterschied Syntax/ Semantik!)

4.2.5 Indizierung, Zugriff auf Felder

In hoheren Programmiersprachen verwenden wir Felder ([n:m] array m a). Wirbehandeln nun die Frage, wie solche Felder in einer Maschine (im Hauptspeicher)abgelegt werden und wie systematisch darauf zugegriffen wird. Wir legen die Ele-mente eines Felds konsekutiv im Speicher ab. Um den Zugriff zu organisieren, ver-wenden wir folgende Darstellung:Adresse Inhalt4711 4711 + 1− n fiktive Anfangsadresse a0 fur a[0]4712 a[n]4713 a[n+1]

......

4711+m a[m]Fur den Index k, n ≤ k ≤ m, erhalten wir durch k + a0 die Adresse des Feldele-ments. Sei α die Anfangsadresse des Felds. Dann schreiben wir in die Speicherzelledie fiktive Adresse α + 1− n.Vorteil: Wenig Speicher fur Verwaltungsinformationen zum Feld, uniformer Zugriff.Nachteil: keine vollstandigen Informationen zur Uberprufung, ob der Index außer-halb der Indexgrenzen liegt.


In der MI: Enthalt R0 die fiktive Anfangsadresse des Felds und R1 den Index k, sowird auf a[k] durch !R0/R1/ zugegriffen. Enthalt R0 hingegen die effektive Anfangs-adresse des Felds, so erfolgt der Zugriff auf das k-te Feldelement durch !!R0/R1/.Diese Zugriffstechnik ist problemlos mit der relativen Adressierung kombinierbar.Die Zugriffstechnik setzt voraus, dass zur Ausfuhrungszeit beim �Anlegen� desFelds (auf dem Stack) die Feldgrenzen festliegen und sich nicht mehr andern.Mehrstufige Felder konnen nach dem selben Prinzip behandelt werden: Sei [n1:m1,..., ni:mi] array m a mit nq ≤ mq fur 1 ≤ q ≤ i gegeben. Wir verwenden fol-gendes Schema:

Adresse Inhalt4711 a0 fiktive Adresse von a[0, ..., 0]4712 s1 Spanne m1 − n1

......

...4711+i-1 si−1 Spanne mi−1 − ni−1

4711+i a[n1, ..., ni] erstes FeldelementFiktive Anfangsadresse:

a0 = α + i− (n1 + s1(n2 + s2(. . . )))

Adresse des Elements a[k1, ..., ki] (mit nq ≤ kq ≤ mk fur 1 ≤ q ≤ i):

a0 + k1 + s1(k2 + s2(. . . ))

Beispiel: Einfacher Algorithmus auf Feldern (alle Feldelemente addieren)

1 v := 0;2 for i := 1 to n do

v := v + a[i]4 od

Werte in der MI:R0 Anfangsadresse der Feldelemente (zeigt auf das erste Feldelement a[1])R1 ZahlerR2 AbbruchswertR3 Aufnahme des Resultats

1 MOVE W I n, R22 CLEAR W R3

CLEAR W R14 for: CMP W R2, R1

JLT ende6 ADD W !R0/R1/, R3

ADD W I 1, R18 JUMP for

ende: HALT

4.2.6 Symbolische Adressierung

Auch die relative Adressierung ist noch sehr fehleranfallig, da der Programmiererin Registern und Zahlen sein Programm verstehen muss. Bequemer und wenigerfehleranfallig ist das Arbeiten in Programmen mit frei gewahlten Bezeichnungen. BeiAssemblerprogrammen sprechen wir von symbolischen Adressen. Bei frei gewahlenBezeichnungen sind folgende Prinzipien zu beachten:

• �sprechende� Bezeichnungen


• �data dictionary� anlegen: ein Verzeichnis aller Begriffe und deren Bedeutung

• Codierungsstandards fur die Wahl von Bezeichnungen

Vor der Ausfuhrung des Programms werden die Bezeichnungen vom Assembliererdurch Adressen ersetzt. Dazu benutzt man eine Datenstruktur �Adressbuch�, inder die Beziehung Bezeichnung – relative Adresse festgelegt ist. Dabei ist darauf zuachten, dass diese Zuordnung so gewahlt ist, dass das Programm effizient ist:

• wenig Speicher verbraucht

• kurze Ausfuhrungszeiten hat

Dazu werden Programme gezielt optimiert (unter Einsatz von Pipelining und Ca-ching).

4.2.7 Geflechtsstrukturen und indirekte Adressierung

Bei problemorientierten Programmiersprachen findet sich das Konzept Referenz /Verweis / Zeiger / Pointer. Auf der MI-Ebene bilden wir Referenzen auf Adressenab. Die Referenz auf einen Wert oder eine Variable wird zu der Adresse der Speicher-zelle, die diesen Wert enthalt oder diese Variable reprasentiet. Bei umfangreichenDatenpaketen / -strukturen (beispielsweise Feldern) entsprechen die Referenzen denAnfangsadressen des Datenpakets.Referenzen entsprechen den Konzept der �indirekten Adressierung�. Referenzen /Verweise bieten große Vorteile fur die Effizienz von Programmen:

• Statt großer Datenpakete konnen wir in Prozedur- / Unterprogrammaufrufendie Verweise / Anfangsadresse ubergeben.

• In Geflechtsstrukturen konnen wir gewisse Daten, die fur eine Reihe von Pro-grammelementen bedeutsam sind, einheitlich verwalten (data sharing).

Beispiel: Eine Typvereinbarung fur Pointer / Records, aus der wir verketteteListen (aber auch Baume) aufbauen konnen, lautet wie folgt:

1 type2 rlist = ^slist;

list = record4 inhalt: s;

naechster, letzter: rlist6 end;

Die Abbildung auf den Speicher (MI) konnte - unter der Annahme, dass der Typ sder Kennung W entspricht - so aussehen, dass ein Knoten aus 3 * 4 Bytes besteht,von denen je ein 4-Byte-Block die Adresse �naechster�, �letzter� und den abge-legten Wert enthalt.Wir nehmen an, dass durch die Listenelemente eine zweifach verkettete Liste auf-gebaut wird, wobei im ersten Element der Verweis �letzter� nil ist und im letztenListenelement der Verweis �naechster� nil ist.Durchlaufen der Liste:

1 zeiger := listenanfang;2 while zeiger <> nil do

if zeiger^.inhalt = suchmuster then4 goto gefunden

fi;


6 zeiger := zeiger^.naechsterod

8 goto nicht_gefunden

Darstellung in der MI:R0 ZeigerR1 ListenanfangR2 Suchmusteradresse

1 MOVE W R1, R02 loop: CMP W I 0, R0

JEQ nicht_gefunden4 CMP W !R2, 8+!R0

JEQ gefunden6 MOVE W !R0, R0

JUMP loop

Programm fur das Anhangen eines Listenelements am Ende der Liste:

1 if listenanfang <> nil then2 zeiger := listenanfang;

while zeiger^.naechster <> nil do4 zeiger := zeiger^.naechster

od;6 zeiger^.naechster := neu;

neu^.letzter := zeiger;8 neu^.inhalt := ...;

neu^.naechster := nil10 else

listenanfang := neu;12 neu^.letzter := zeiger;

neu^.inhalt := ...;14 neu^.naechster := nil

fi

R0 ZeigerR2 ListenanfangR3 neuR4 inhalt

1 MOVE W R2, R02 CMP W I 0, R0

JNE loop4 CLEAR W !R3

CLEAR W 4+!R36 MOVE W R4, 8+!R3

MOVE W R3, R28 JUMP ende

loop: CMP W I 0, !R010 JEQ listenende

MOVE W !R0, R012 JUMP loop

listenende: MOVE W R3, !R014 CLEAR W !!R0

MOVE W R0, 4+!!R016 MOVE W R4, 8+!!R0


4.2.8 Speicherverwaltung

Fur die Ausfuhrung eines Maschinenprogramms mit komplexen Daten ist eine Spei-cherorganisation erforderlich. Darunter verstehen wir die Systematik der Ablage vonProgramm und Daten im Speicher. Ziele dabei sind:

• effiziente Nutzung des Speichers

• einfache, gut handhabbare Strukturen

Beobachtungen:

• Praktisch alle Programme benotigen wahrend ihrer Ausfuhrung zusatzlichenSpeicherplatz, der stuckweise belegt und wieder freigegeben wird.

• Oft werden Speicherplatze in der umgekehrten Reihenfolge, in der sie belegtwerden, wieder freigegeben (Stack-Prinzip) - der zuletztbelegte Platz wirdzuerst wieder freigegeben.

• Fur gewisse Datenstrukturen eignet sich das Stack-Prinzip nicht (Zeiger- /Referenzstrukturen).

Damit nutzen wir drei Arten der Verwaltung von Speicher:

• statischer Speicher: Hier werden alle Daten abgelegt, die uber die gesamteLaufzeit des Programms benotigt werden.

• Stack: Hier werden alle Daten abgelegt, die nach dem Stack-Prinzip benotigtund freigegeben werden. Bei der Blockstruktur wird beim Betreten einesBlocks der Speicher fur die lokalen Variablen (bei Prozeduraufrufen fur Para-meter) bereitgestellt und beim Verlassen des Blocks wieder freigegeben.

• Listenspeicher (Heap): Hier werden alle Daten abgelegt, deren Speicherplatzenicht im Stack verwaltet werden konnen. Dabei wird im Quellprogramm in derRegel Speicherplatz explizit angefordert (Kreieren von Objekten, new/allocatezum Bereitstellen von Speicher fur Zeiger). Die Freigabe von Speicher erfolgt:

– entweder explizit (�deallocate�)Vorteil: Der Programmierer kann die Speicherverwaltung kontrollieren.Nachteil: Erhohte Komplexitat der Programme, Gefahr ins Leere zeigen-der Referenzen (�dangling references�).

– oder implizit durch Speicherbereinigung (�garbage collection�). Dabeiwird durch Erreichbarkeitsanalyse festgestellt, auf welche Zeigerelemen-te / Objekte noch zugegriffen werden kann; die nicht mehr erreichbarenwerden entfernt.Vorteil: erheblich einfacher, keine Fehlergefahr durch Zeiger ins Leere.Nachteil: weniger effizient, Echtzeitverhalten der Programme kaum vor-hersagbar.

4.2.9 Stackverwaltung von blockstrukturierten Sprachen

Eine Programmiersprache heißt blockstrukturiert, wenn lokale Variablen /Konstanten verwendet werden, die in abgegrenzten Bindungsbereichen deklariertwerden, soweit keine Referenzen / Zeiger auftreten. Fur lokale Bezeichner / Varia-blen unterscheiden wir:

• Deklaration / Bindung (genau ein Mal)

• benutzendes Auftreten


Da die gleiche Bezeichnung in unterschiedlichen Bindungsbereichen gebunden wer-den kann, ist die Zuordnung zwischen Bindung und Nutzung wichtig (vgl. stati-sche gegen dynamische Bindung). Blockstrukturen entsprechen Klammerstrukturen.Durch Durchnummerieren der Blockklammern kann jeder Block eindeutig gekenn-zeichnet werden. Durch dieses Verfahren konnen wir Blocke eindeutig kennzeichnen.Blockschachtelungstiefe (BST): Anzahl der einen Block umfassenden Blocke + 1.Die Blocke definieren einen Baum.

Beispiel: Die Blockstruktur

1 begin2 begin

begin4 end

begin6 end

end8 begin

end10 end

entspricht dem Baum

1.1.1 1.1.2

1.1 1.2

1

In diesem Fall bestimmt die statische Struktur der Blocke die Struktur des Stacks.

Beispiel: Blockorientiertes Programm mit Prozeduraufruf

1 | // 12 proc p =:

| // 1.14 ...

| // 1.16

| // 1.28 ...

| // 1.210

| // 1.312 ...

p;14 ...

| // 1.316 | // 1

Hier unterscheiden wir fur jeden Abschnitt im Stack (der den lokalen Variableneines Blocks entspricht) den statischen Vorganger (in der Aufschreibung der nachsteumfassende Block) und den dynamischen Vorganger (in der Ausfuhrung der nachsteumfassende Block) (s. Abb 4.1).

In der Speicherorganisation fur blockorientierte Sprachen verwenden wir einenStack, in dem jeweils auch der Verweis auf den statischen und dynamischen Vorgan-ger sowie die Blockschachtelungstiefe abgelegt wird. Ein Prozeduraufruf entspricht


1 . . .

1.3

1.1

1 1 1 1 1

1.3 1.3

Abbildung 4.1: Blocke auf dem Stack

imer dem Betreten eines Blocks.Jeder Speicherabschnitt auf dem Stack enthalt schematisch folgende Informationen:

• statischer Vorganger

• dynamischer Vorganger

• Blockschachtelungstiefe

• Ruckkehradresse (bei Prozeduraufrufen)

• Parameter (bei Prozeduraufrufen)

• Resultat (bei Prozeduraufrufen)

• lokale Variablen

4.3 Techniken maschinennaher Programmierung

Ein komplexes maschinennahes Programm kann kaum in einem Anlauf gleich alsMaschinenprogramm geschrieben werden. Geschickter ist es, zunachst ein problem-orientiertes Programm zu schreiben, dies zu analysieren und zu verifizieren unddann in ein Maschinenprogramm umzusetzen. Die Umsetzung erfolgt

• entweder per Hand

• oder durch ein Ubersetzungsprogramm (Compiler)

Typische Bestandteile hoherer Programmiersprachen:

• Datenstrukturen

• Blockstrukturen

• Ablaufstrukturen

– Ausdrucke

– Zuweisungen

– if - then - else

– Wiederholungsanweisungen

– Funktionen, Prozeduren

Maschinennahe Umsetzung:

• Speicherung

• Umsetzung in Konzepte maschinennaher Sprachen (s.u.)

4.3. TECHNIKEN MASCHINENNAHER PROGRAMMIERUNG 55

4.3.1 Auswertung von Ausdrucken / Termen

Ein Ausdruck besteht aus einem Gebirge von Funktionsaufrufen.

abs(ab− cd) + ((e− f)(g − j))

a b

*

c d

*

-

abs

e f

-

g j

-

*

+

Zugehoriges Single-Assignment-Programm:

1 h1 := a * b;2 h2 := c * d;

h3 := h1 - h2;4 h4 := abs (h3);

h5 := e - f;6 h6 := g - j;

h7 := h5 * h6;8 h8 := h4 + h7;

oder:

1 h1 := a * b;2 h2 := c * d;

h1 := h1 - h2;4 h1 := abs (h1);

h2 := e - f;6 h3 := g - j;

h2 := h2 * h3;8 h1 := h1 + h2;

Zur Optimierung des Speicherbedarfs beim Auswerten von Ausdrucken verwendenwir statt Hilfsvariablen einen Stack. Operationen finden immer auf dem ersten Ele-ment des Stacks statt. Deshalb kann das erste Element auch in einer speziellenHilfsvariable AC gehalten werden.Operationen:

• lege �Wert� auf den Stack

• fuhre ein- oder zweistellige Operation auf dem Stack aus

Das Arbeiten auf dem Stack zur Auswertung eines Ausdrucks kann einfach durchdie Postfix-Darstellung des Operatorbaums erreicht werden.

im Beispiel: a b * c d * - abs e f - g j - * +

1 AC := a2 push AC; AC := b

AC := top * AC; pop4 push AC; AC := c


push AC; AD := d6 AC := top * AC; pop

AC := top - AC; pop8 AC := abs (AC)

...

In der MI konnen wir ohne Verwendung eines Registers direkt auf dem Stack arbei-ten:

1 MOVE W a, -!SP2 MULT W !SP+, !SP

...

Wir schreiben nun ein Programm, das einem kleinen Ausschnitt aus einem Compilerentspricht. Es nimmt die Umsetzung von Ausdrucken in eine Sequenz von Opera-tionen auf dem Stack vor. (Das erzeugte Programm legt schließlich das Ergebnis inAC ab, der Stack ist nach Ausfuhrung des Programms wieder im Anfangszustand.)Wir benotigen eine Datenstruktur zur Darstellung von Operatorbaumen.

1 sort expr = nullary (symbol sym)2 | mono (op op, expr e0)

| duo (expr e1, op op, expr e2)

Dabei nehmen wir an, dass die Sorten symbol (Menge der Identifikatoren fur Werte)und op (Operationssymbole) gegeben sind.Im Folgenden wird ein Programm angegeben, das einen Operatorbaum als Ein-gang nimmt und ein Stackprogramm zur Auswertung des durch den Operatorbaumgegebenen Ausdrucks ausdruckt:

1 proc eaf = (expr e):2 if e in nullary then

print ("AC := ", sym(e))4 elif e in mono then

eaf (e0(e));6 print ("AC := ", op(e), "AC")

else8 eaf (e1(e));

print ("push AC");10 eaf (e2(e));

print ("AC := top ", op(e), "AC");12 print ("pop")

fi

4.3.2 Maschinennahe Realisierung von Ablaufstrukturen

Eine Zuweisung

1 x := E

wird umgesetzt in (sei e der Operatorbaum zu E):

1 eaf (e);2 x := AC

Die bedingte Anweisung

1 if E = 0 then S1 else S2 fi

wird wie folgt umgesetzt (sei e der Operatorbaum zu E):

4.3. TECHNIKEN MASCHINENNAHER PROGRAMMIERUNG 57

1 eaf (E);2 if AC = 0 then

goto t4 fi

.....6 (Maschinencode fuer S2)

.....8 goto ende

t: .....10 (Maschinencode fuer S1)

.....12 ende:

Die Wiederholungsanweisung

1 while E <> 0 do S od

wird zu:

1 while: eaf (e);2 if AC = 0 then

goto ende4 fi

....6 (Maschinencode fuer S)

....8 goto while

ende:

Im Folgenden schreiben wir ein Programm, das die Umsetzung (Ubersetzung) eineswhile / if - Programms in ein maschinennahes Programm vornimmt. Wir benotigeneine Sorte zur Reprasentation von Programmen:

1 sort statement = assign (symbol x, expr e)2 | if (expr cond, statement st, statement se)

| while (expr e, statement s)4 | seq (statement s1, statement s2)

Im Ubersetzungsvorgang werden zusatzlich Marken fur Sprunge benotigt. Wir neh-men an, dass wir zu einer gegebenen Marke m in der Sorte label Uber eine Funktion

1 fct next = (label) label

verfugen, so dass m, next(m), next(next(m)), . . . eine Folge unterschiedlicher Mar-ken liefert (Generator fur Marken).Programm fur das Erzeugen eines maschinennahen Programms:

1 proc gen = (statement z, var label m):2 if z in assign then

eaf (e(z));4 print (x(z), " := AC")

elif z in seq then6 gen (s1(z), m);

gen (s2(z), m)8 elif z in if then

label me := m;10 label mt := next (m);


m := next (mt);12 eaf (cont(z));

print ("if AC = 0 then goto ", mt, " fi");14 gen (se(z), m);

print ("goto ", me);16 print (mt, ":");

gen (st(z), m);18 print (me, ":")

else20 label mw := m;

label ma := next (m);22 m := next (ma);

print (mw, ":");24 eaf (c(z));

print ("if AC = 0 then goto ", ma, "fi");26 gen (s(z), m);

print ("goto ", mw);28 print (ma, ":")

fi

einfuhrung in die informatik 2¨home.in.tum.de/~gufler/files/info2.pdf · 2002-11-30 · kapitel 1...

Documents