Rechnerstrukturen, Skript zur Vorlesung an der RWTH Aachen...KAPITEL 1 Grundlegende Konzepte Wir...

Rechnerstrukturen

Skript zur Vorlesung an der RWTH-Aachen

Lehrstuhl für Informatik IV

Prof. Dr. O. Spaniol

Dr. Mesut GünesRalf Wienzek

Inhaltsverzeichnis

1 Grundlegende Konzepte 1

1.1 Funktionelle Einheiten eines Rechners. . . . . . . . . . . . . . . . 1

1.2 Speicher. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

1.3 Programmausführung. . . . . . . . . . . . . . . . . . . . . . . . . 4

1.3.1 Von-Neumann-Prinzip. . . . . . . . . . . . . . . . . . . . 4

1.3.2 Alternative Modelle . . . . . . . . . . . . . . . . . . . . . 5

1.3.3 Pipelining. . . . . . . . . . . . . . . . . . . . . . . . . . . 5

1.3.4 Ausführungssteuerung. . . . . . . . . . . . . . . . . . . . 6

1.4 Datenübertragung. . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.4.1 Leitungen. . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.4.2 Busse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2 Informationsdarstellung 9

2.1 Allgemeines zur Darstellung ganzer Zahlen. . . . . . . . . . . . . 9

2.1.1 Stellenwertcodierung. . . . . . . . . . . . . . . . . . . . . 10

2.2 Codierungen für ganze Zahlen. . . . . . . . . . . . . . . . . . . . 11

2.2.1 Betrag- und Vorzeichen. . . . . . . . . . . . . . . . . . . . 11

2.2.2 2-Komplement. . . . . . . . . . . . . . . . . . . . . . . . 12

2.2.3 1-Komplement. . . . . . . . . . . . . . . . . . . . . . . . 13

2.2.4 Transformation von negativen Zahlen. . . . . . . . . . . . 14

2.2.5 Addition und Subtraktion. . . . . . . . . . . . . . . . . . . 15

2.2.6 Überlaufproblematik. . . . . . . . . . . . . . . . . . . . . 16

2.3 Darstellung rationaler Zahlen. . . . . . . . . . . . . . . . . . . . . 17

2.3.1 Festkommazahlen. . . . . . . . . . . . . . . . . . . . . . 17

2.3.2 Gleitkommazahlen. . . . . . . . . . . . . . . . . . . . . . 18

i

ii Inhaltsverzeichnis

2.3.3 Addition und Subtraktion bei Gleitkommazahlen. . . . . . 20

2.3.4 Multiplikation und Division bei Gleitkommazahlen. . . . . 21

2.4 Darstellung von Zeichen. . . . . . . . . . . . . . . . . . . . . . . 22

2.4.1 Codierung mit Umschaltsymbolen. . . . . . . . . . . . . . 22

2.4.2 Codierung durch Bitstrings. . . . . . . . . . . . . . . . . . 23

2.4.3 Darstellung von Dezimalziffern. . . . . . . . . . . . . . . 24

2.5 Erkennung und Behebung von Bitfehlern. . . . . . . . . . . . . . . 25

2.5.1 Hamming-Distanz. . . . . . . . . . . . . . . . . . . . . . 26

3 Maschinennahe Programmierung 29

3.1 Darstellung von Befehlen. . . . . . . . . . . . . . . . . . . . . . . 29

3.1.1 Aufbau eines Befehlswortes. . . . . . . . . . . . . . . . . 29

3.1.2 Befehlstypen. . . . . . . . . . . . . . . . . . . . . . . . . 33

3.1.3 Befehlssätze. . . . . . . . . . . . . . . . . . . . . . . . . 34

3.1.4 Verwendung zusätzlicher Register und Registerbefehle. . . 34

3.2 Adressierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

3.2.1 Direkte Adressierung. . . . . . . . . . . . . . . . . . . . . 35

3.2.2 Indirekte Adressierung durch Basisregister und Relative Di-stanz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

3.2.3 Indexregister zur indirekten Adressierung. . . . . . . . . . 36

3.2.4 Indexregister mit Adressmodifikation. . . . . . . . . . . . 37

3.2.5 Unterschiedliche Adressmodi. . . . . . . . . . . . . . . . 37

3.2.6 Indirekte Adressierung. . . . . . . . . . . . . . . . . . . . 37

3.2.7 Modifizierung von Befehlen. . . . . . . . . . . . . . . . . 38

3.3 Leistungsfähigkeit von Adressiertechniken. . . . . . . . . . . . . . 38

3.3.1 Berechnung durch ein Programm. . . . . . . . . . . . . . 38

3.3.2 Endlichkeit der realen Maschine. . . . . . . . . . . . . . . 39

3.3.3 Beliebig große Funktionswerte sollen berechenbar sein. . . 42

3.4 Unterprogramme. . . . . . . . . . . . . . . . . . . . . . . . . . . 42

3.4.1 Einstufige, nichtrekursive Unterprogramme. . . . . . . . . 43

3.4.2 Mehrstufige, nichtrekursive Unterprogramme. . . . . . . . 44

3.4.3 Mehrstufige, eventuell rekursive Unterprogramme. . . . . 44

4 Bausteine und Komponenten von Rechensystemen 47

4.1 Schaltfunktionen, Bausteinsysteme und Boolesche Algebra. . . . . 47

Inhaltsverzeichnis iii

4.1.1 Entwurf und Realisierung von Schaltfunktionen. . . . . . . 49

4.1.2 Atom, Minterm und Maxterm. . . . . . . . . . . . . . . . 54

4.1.3 Boolesche Ausdrücke. . . . . . . . . . . . . . . . . . . . . 56

4.2 Normalformen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

4.2.1 Disjunktive Normalform (DNF). . . . . . . . . . . . . . . 59

4.2.2 Konjunktive Normalform (KNF). . . . . . . . . . . . . . . 60

4.2.3 Komplementfreie Ringsummenentwicklung (KRE). . . . . 60

4.3 Synthese von Schaltkreisen, Minimierung. . . . . . . . . . . . . . 62

4.3.1 Eingeschränktes Minimierungsproblem. . . . . . . . . . . 63

4.3.2 Quine-McCluskey-Algorithmus. . . . . . . . . . . . . . . 64

4.3.3 Karnaugh-Diagramme. . . . . . . . . . . . . . . . . . . . 70

4.4 Schaltwerke und Speicherelemente. . . . . . . . . . . . . . . . . . 71

4.4.1 Speicherelemente. . . . . . . . . . . . . . . . . . . . . . . 72

5 Die Arithmetisch-Logische Einheit 79

5.1 Addition und Subtraktion. . . . . . . . . . . . . . . . . . . . . . . 80

5.1.1 Halbaddierer. . . . . . . . . . . . . . . . . . . . . . . . . 80

5.1.2 Volladdierer. . . . . . . . . . . . . . . . . . . . . . . . . . 81

5.1.3 Carry-Ripple-Addierer. . . . . . . . . . . . . . . . . . . . 82

5.1.4 Serieller Addierer. . . . . . . . . . . . . . . . . . . . . . . 84

5.1.5 Von-Neumann-Addierer. . . . . . . . . . . . . . . . . . . 86

5.1.6 Erweiterungen des Von-Neumann-Addierers. . . . . . . . 90

5.1.7 Carry-Look-Ahead-Addierer. . . . . . . . . . . . . . . . . 93

5.1.8 Carry-Skip-Addierer. . . . . . . . . . . . . . . . . . . . . 95

5.1.9 Conditional-Sum-Addierer. . . . . . . . . . . . . . . . . . 99

5.2 Multiplikation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102

5.2.1 Serielle Multiplikation . . . . . . . . . . . . . . . . . . . . 103

5.2.2 Multiplikatorcodierung. . . . . . . . . . . . . . . . . . . . 105

5.2.3 Adder-Tree und Pipelining. . . . . . . . . . . . . . . . . . 108

5.3 Division . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110

5.3.1 Serielle Division . . . . . . . . . . . . . . . . . . . . . . . 110

5.3.2 Iterative Division. . . . . . . . . . . . . . . . . . . . . . . 115

5.3.3 Iterative Berechnung von Quadratwurzeln. . . . . . . . . . 119

5.4 Arithmetik bei redundanter Zahlendarstellung. . . . . . . . . . . . 122

iv Inhaltsverzeichnis

5.4.1 SDNR-Darstellung für die Addition. . . . . . . . . . . . . 122

5.4.2 Gemischtes SDNR-Verfahren. . . . . . . . . . . . . . . . 124

5.4.3 SRT-Verfahren zur seriellen Division. . . . . . . . . . . . 125

Abbildungsverzeichnis

1.1 Komponenten eines Rechners. . . . . . . . . . . . . . . . . . . . . 2

1.2 Pipelining von Befehlen . . . . . . . . . . . . . . . . . . . . . . . 5

1.3 Ausführungssteuerung mit Interruptsignalen. . . . . . . . . . . . . 6

1.4 Zwei-Bus-Architektur. . . . . . . . . . . . . . . . . . . . . . . . . 7

1.5 Unibus-Architektur . . . . . . . . . . . . . . . . . . . . . . . . . . 8

1.6 Pufferung des Buszugangs. . . . . . . . . . . . . . . . . . . . . . 8

2.1 Kodierung einer Gleitkommazahl. . . . . . . . . . . . . . . . . . . 18

3.1 Befehlsstrukturen. . . . . . . . . . . . . . . . . . . . . . . . . . . 31

3.2 Indirekte Adressierung mit Basisregister und relativer Distanz. . . 36

3.3 Algorithmus zur Berechnung vonh0,h1, . . . . . . . . . . . . . . . . 41

3.4 Aufruf und Beenden von Unterprogrammen. . . . . . . . . . . . . 43

3.5 Einstufiger Unterprogrammaufruf. . . . . . . . . . . . . . . . . . 44

3.6 Mehrstufiger Unterprogrammaufruf. . . . . . . . . . . . . . . . . 44

4.1 Karnaugh-Diagramme. . . . . . . . . . . . . . . . . . . . . . . . 70

4.2 Schaltkreis und Schaltwerk. . . . . . . . . . . . . . . . . . . . . . 72

4.3 Takt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

4.4 RS-Flipflop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

4.5 Schaltung des RS-Flipflops. . . . . . . . . . . . . . . . . . . . . . 74

4.6 Schaltsymbole für das RS-Flipflop. . . . . . . . . . . . . . . . . . 75

4.7 Earle Latch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

4.8 Schaltung des Earle Latch. . . . . . . . . . . . . . . . . . . . . . 76

4.9 Hazards. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

4.10 Taktflanke. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77

v

vi Abbildungsverzeichnis

5.1 Addition nach Schulmethode. . . . . . . . . . . . . . . . . . . . . 80

5.2 Symbol für einen Halbaddierer. . . . . . . . . . . . . . . . . . . . 80

5.3 Schaltung für den Halbaddierer. . . . . . . . . . . . . . . . . . . . 81

5.4 Schaltung und Schaltsymbol eines Volladdierers. . . . . . . . . . . 82

5.5 Carry-Ripple-Addierwerk. . . . . . . . . . . . . . . . . . . . . . . 83

5.6 Serielles Addierwerk. . . . . . . . . . . . . . . . . . . . . . . . . 84

5.7 Von-Neumann-Addierwerk. . . . . . . . . . . . . . . . . . . . . . 86

5.8 Ablaufsteuerung. . . . . . . . . . . . . . . . . . . . . . . . . . . . 88

5.9 Dioden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

5.10 Diodenmatrix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90

5.11 Kurznotation des Von-Neumann-Addierers. . . . . . . . . . . . . . 91

5.12 Carry-Save-Addierer. . . . . . . . . . . . . . . . . . . . . . . . . 91

5.13 Lineare Verschaltung von CSAs. . . . . . . . . . . . . . . . . . . 92

5.14 Wallace Tree . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93

5.15 Carry-Look-Ahead-Addierer für Gruppengröße 4. . . . . . . . . . 94

5.16 Gruppe eines Carry-Skip-Addierers. . . . . . . . . . . . . . . . . 96

5.17 Schaltung zum Carry-Skip-Addierer zweiter Ordnung. . . . . . . . 98

5.18 Kombination von Carry-Skip und Carry-Look-Ahead. . . . . . . . 99

5.19 Gruppen bei der Conditional-Sum-Addition. . . . . . . . . . . . . 99

5.20 Schema zur seriellen Multiplikation. . . . . . . . . . . . . . . . . 104

5.21 Multiplikation als Addition im Adder-Tree. . . . . . . . . . . . . . 109

5.22 Pipelining durch Adder-Tree. . . . . . . . . . . . . . . . . . . . . 109

5.23 Adder-Tree für Einzelmultiplikation. . . . . . . . . . . . . . . . . 110

5.24 Serielle Multiplikation und Division. . . . . . . . . . . . . . . . . 111

5.25 Table-Look-Up-Methode. . . . . . . . . . . . . . . . . . . . . . . 115

5.26 Newton-Verfahren. . . . . . . . . . . . . . . . . . . . . . . . . . . 116

KAPITEL 1

Grundlegende Konzepte

Wir befassen uns in dieser Vorlesung mit digitalen und programmgesteuertenRe-chensystemen. Der Rechner akzeptiert digitale Eingabedaten (Eingangsargumente),verarbeitet sie mit einem Programm, das in seinem Speicher steht, und produziert di-gitale Ausgabedaten. Nimmt man vereinfachend an, dass die Eingabedaten imSpei-cher stehen und die Ergebnisse ebenfalls im Speicher abgelegt werden, dann bewirktein Programm eine Transformation des alten Speicherinhaltes in einen neuenSpei-cherinhalt.

Rechnersysteme unterscheiden sich grundlegend voneinander bezüglich Größe, Ge-schwindigkeit, Zahl anschließbarer beziehungsweise bedienbarer Geräte oder Benut-zer und ihrer Kosten. Eine mögliche Klassifizierung von Rechnersystemenist dieFolgende, wobei die Grenzen zwischen den Klassen fließend sind:

• Supercomputer

• Workstation

• Personal Computer

• Prozessrechner

• Personal Digital Assistant (PDA)

• Smartphone

1.1 Funktionelle Einheiten eines Rechners

Ein Rechnersystem besteht aus folgenden Einheiten, die sich aufgrundihrer Funktioninnerhalb des Systems voneinander unterscheiden.

Die Eing- und die Ausgabeeinheit bilden die Schnittstellen zur Außenwelt. DerPro-zessor(Central Processing Unit, CPU) hat Aufgaben der Steuerung und Arithme-tik. Er vereinigt demnach dieSteuereinheit(Control Unit) und dieRecheneinheit

1

2 Kapitel 1. Grundlegende Konzepte

(Arithmetic Logical Unit, ALU). Eine weitere wichtige Einheit ist derSpeicher. Aufihn wird später eingegangen. Abbildung1.1veranschaulicht die Zusammenarbeit dereinzelnen Komponenten.

Es gibt erweiterte Konzepte, bei denen mehrere Rechner zusammenarbeiten, wobeidiese dann durch einKommunikationsnetz verbunden sind.

Eingabe

Ausgabe

Datenprozessor

Befehlsprozessor

Speicher

Daten

Steuerinformationen

Mensch, elektr. Gerät, Leitungen zu anderen Rechnern

Rechner Außenwelt

CPU

RAM

ROM

Abbildung 1.1: Komponenten eines Rechners

Ein Rechensystem verarbeitet Informationen, die im Speicher gehalten werden. Manunterscheidet zwei Arten von Informationen. Zum einenBefehle, die Aktivitäten desProzessors anstoßen, und auf der anderen Seite Daten, die manipuliertwerden. EinProgramm ist dabei eine Folge von Befehlen. Typische Daten sind zum Beispiel Zah-len und Zeichen, die in geeigneter Codierung im Speicher abgelegt werden. Da sichein Programm meist auch im Speicher befindet, sind die Codierungen der Befehleauch als Daten auffassbar.

DerProzessorverarbeitet Informationen im einfachsten Fall nach folgendem Ablauf:

1. Befehl (aus dem Speicher) holen

2. Befehl interpretieren

3. Aufgrund der Interpretation des Befehls nötige Operanden holen

4. Befehl (Operation) ausführen

Anschließend wird dieser Ablauf mit dem nächsten Befehl durchgeführt.

Die Bearbeitung erfolgt sequenziell, das heißt, die Befehle werden nacheinander undjeder für sich zu einem Zeitpunkt ausgeführt.

Es gibt Befehle, deren Aufgabe es ist, nicht den nachfolgenden, sondern einen ananderer Stelle im Speicher befindlichen Befehl anzustoßen (so genannter Sprungbe-fehl). Ferner dienen Vergleichsbefehle dazu, Fallunterscheidungenzu bilden, so dassaufgrund eines Speicherzustandes eine bestimmte Aktion ausgeführt wird.

1.2. Speicher 3

Üblicherweise werden ein Programm (oder auch mehrere) und die dazugehörigenDaten im Speicher gehalten. Zu diesem Zweck enthält der Speicher eine Menge vonadressierbarenSpeicherzellen(Worten).

Zur Unterscheidung zwischen Daten und Befehlen muss man entweder die Speicher-zelle markieren (zum Beispiel ein gesondertes Bit des Wortes zur Verfügung stellenwie: 1 steht für Datum und 0 steht für Befehl) oder den aktuellen CPU-Zustand in-terpretieren.

Die folgende Abbildung zeigt den Speicher, der in zwei Abschnitte zur Aufnahmevon Programmen und Rechendaten aufgeteilt ist.

Adresse Inhalt0...

... ProgrammspeicherPN1−1

0...

... RechenspeicherRN2−1

Wir nehmen also ohne wesentliche Einschränkung an, dass wir zwei SpeicherP undR haben, die jeweils von Null ab adressiert werden. Den Inhalt der Speicherzellenkennzeichnen wir im Fall eines

• Befehls mitπ(i): aktueller Inhalt von Zellei in P

• Datums durchρ( j): aktueller Inhalt der Zellej in R

1.2 Speicher

Man unterscheidet im Wesentlichen drei Arten von Speicher. DerHauptspeicher(Primary Memory, Main Memory) ist direkt adressierbar mit nahezu gleicher Zu-griffszeit pro Zelle (typische Werte liegen bei einigen Nanosekunden).Er wird dem-nach auch alsRandom Access Memory(RAM) bezeichnet. EinenHintergrundspei-cher (Secondary Memory) verwendet man zur Speicherung relativ selten benötig-ter Informationen. Er ist langsamer bezüglich der Zugriffszeit. Da er nicht die teu-ren und schnellen Speicherbausteine verwendet, ist er wesentlich billigerund daherauch in größerem Umfang verfügbar. Als Beispiel ist Festplattenspeicher zu nennen.Der Pufferspeicher (Cache Memory) zeichnet sich dadurch aus, dass er besondersschnell, dafür aber auch teuer ist. Aus diesem Grund ist er relativ klein.Seine be-sondere Eignung liegt in der Pufferung (vom Prozessor) besonders häufig benutzterBefehle und Daten.

Neben den Speichertypen gibt es dieRegister. Es handelt sich dabei um Zellen mitbesonders kurzen Zugriffszeiten. Den Registern werden bestimmte Sonderaufgabenzugeordnet, wie sie im Folgenden beispielhaft aufgeführt sind. Dabeiunterscheidenwir der Einfachheit halber nicht zwischen Registername und Registerinhalt.


DasAkkumulatorregister (der Akkumulator, Bezeichnung durchα) dient der kurz-fristigen Speicherung von Informationen. Es wird für den Transfer vom und zumSpeicher benutzt. Verwendung findet es zum Beispiel bei der Ausführung arithmeti-scher Operationen.

Eine typische Befehlsfolge unter Verwendung des Akkumulators ist die folgende:

1 α = ρ(0)2 α = α+ρ(1)3 α = α+ρ(2)4 ρ(0) = α

Dieses Programm sorgt für eine Addition der Inhalte der ersten drei Rechenspeicher-zellen. Die Summe wird in die erste Speicherzelle geschrieben.

DasIndexregister (bezeichnet mitγ) wird bei der indizierten Adressierung verwen-det, die in Kapitel3 eingeführt wird.

Nicht zu verwechseln sind dasBefehlsregister(Instruction Register, IR) und dasBefehlszählregister(Program Counter, PC) auch mitβ bezeichnet). Das Befehlsre-gister enthält den Befehl, der momentan ausgeführt wird. Dahingegen steht im Be-fehlszählregister die Adresse des zur Zeit ausgeführten Befehls. Ist die Ausführungdes einen Befehls abgeschlossen und soll der nächste Befehl ausgeführt werden, sowird der Inhalt des Befehlszählregisters inkrementiert(β = β+1).

DasSpeicheradressregister(Memory Address Register, MAR) enthält die Adres-se einer Speicherzelle, während dasSpeicherdatenregister(Memory Data Register,MDR) das Datum dieser durch das Speicheradressregister angesprochenen Speicher-zelle enthält.

Darüber hinaus gibt es noch eine architekturabhängige Vielzahl vonAllzweckregi-stern, die meist mitR0,R1,R2, . . . bezeichnet werden. Sie werden für unterschiedlicheZwecke eingesetzt, zum Beispiel für die Durchführung von Rechenoperationen.

1.3 Programmausführung

Es gibt verschiedene Konzepte zur Ausführung von Befehlen und somit zur Manipu-lation von Daten.

1.3.1 Von-Neumann-Prinzip

Die konventionelle Programmausführung erfolgt nach demVon-Neumann-Prinzip.Es wird zu einem Zeitpunkt ein Befehl auf ein Datum angewandt. Man nennt denzugehörigen Rechner auchSISD-Rechner(Single Instruction Single Data).

Die Ausführung eines Befehls geschieht in vier Schritten:

1. Hole nächsten Befehl in dasBefehlsregister(IR).

Die Adressedes Befehls steht imBefehlszählregisterβ; demzufolge enthältβ zu Beginn der Programmausführung die Startadresse.

1.3. Programmausführung 5

2. Interpretiere den Befehl.

Es wird der Typ des Befehls ermittelt und die Anzahl nötigerOperandenbe-stimmt.

3. Hole den beziehungsweise die benötigten Operanden.

4. Führe den Befehl aus.

Der Hole-Befehl (Load) beschreibt einen Datentransfer zwischen Speicher und Pro-zessor. Er hat die Formα = ρ(i) und bedeutet »Lade Datum von Speicherzellei in denAkkumulator «. Entsprechend lautet der Befehl für einen Speichere-Befehl (Store)ρ(k) = α.

1.3.2 Alternative Modelle

Neben dem SISD-Prinzip gibt es folgende andere Typen, die hier nur kurz genanntwerden. DerSIMD-Rechner (Single Instruction Multiple Data) gestattet die Anwen-dung eines Befehls zu einem Zeitpunkt auf mehrere Daten. Es gibt Rechnertypen, diehierzu mehrere Prozessoren verwenden, welche zum Beispiel einen gemeinsamenSpeicher nutzen (Shared Memory Model). Ein weiteres Modell stellt derMIMD-Rechner dar (Multiple Instruction Multiple Data), selten wird derMISD-Rechner(Multiple Instruction Single Data) verwendet.

1.3.3 Pipelining

Die Befehlsausführung nach demVon-Neumann-Prinzip in vier Schritten kann be-schleunigt werden, wenn man Schritt 1 und 2 des nachfolgenden Befehls mit denSchritten 3 und 4 des aktuell auszuführenden Befehls kombiniert. Abbildung 1.2zeigt, dass der Prozessor nach der Interpretation des Befehlsi (Schritt 2) zusätz-lich zu dessen weiterer Bearbeitung (Schritte 3 und 4) den Befehl(i + 1) holt undinterpretiert.

Zeit Befehl 1 Befehl 2 Befehl 30 Hole Befehl 11 Interpretiere Befehl 12 Operanden holen Hole Befehl 23 Befehl 1 ausführen Interpretiere Befehl 24 Operanden holen Hole Befehl 35 Befehl 2 ausführen Interpretiere Befehl 3... . . .

Abbildung 1.2: Pipelining von Befehlen

Zu beachten ist allerdings, dass die Ausführung von Befehli (Schritt 4) unter Um-ständen erst den Befehl(i+1) festlegen kann. In diesem Fall ist irrtümlich der falsche


Befehl (i + 1) ausgeführt worden, was zu ungewünschten Folgen führen kann. Dernun richtige Befehl(i +1) muss, sofern noch möglich, ausgeführt werden.

1.3.4 Ausführungssteuerung

Neben den Befehlen zum Datentransfer zwischen Prozessor und Speicher werdenauch die Ein-/Ausgabegeräte (Input/Output, I/O) über E/A-Befehle vom Prozessorangesteuert. Ihre Tätigkeit können solche Endgeräte dann weitgehendunabhängigvom Prozessor ausführen. Eine wichtige Aufgabe hat der Prozessor bei der Koordi-nation dieser Geräte. Hierzu senden die Endgeräte so genannteInterrupt -Signale,die den Prozessor in der Ausführung eines anderen Programms unterbrechen. Aufdiese Weise kann von der normalen Befehlsausführung abgewichen werden (sieheAbbildung1.3).

Beispiele für derartige Unterbrechungen des Prozessors sind eine Alarmmeldung,die eine Reaktion innerhalb einer nicht zu überschreitenden Zeitspanne (Deadline)erfordert, oder eine Fertigmeldung eines langsamen Endgerätes. Der vergleichsweiseschnelle Prozessor bedient normalerweise viele langsame Endgeräte gleichzeitig, ermuss also zwischen gleichzeitig laufenden Programmen umschalten.

Programm 1 Programm 2 Prozessorsteuerprogramm

(Betriebssystem)

Initiiere E/A-Operation 1 für Programm 1

Schalte um zu Programm 2

E/A 1 meldet „fertig“ durch Interruptsignal

Unterbreche Programm 2 und rette seine relevanten Informationen

Schalte um zu Programm 1

Abbildung 1.3: Ausführungssteuerung mit Interruptsignalen

1.4. Datenübertragung 7

1.4 Datenübertragung

1.4.1 Leitungen

Die Kommunikation besteht im Wesentlichen im Transfer von Daten und Steue-rinformationen zwischen den funktionellen Einheiten des Rechners, insbesonderezwischen Prozessor, Speicher und E/A-Geräten. Sie erfolgt über Leitungen, welchedie Einheiten verbinden. Physikalisch gesehen sind Leitungen meist drahtgebunden.Aber auch andere Möglichkeiten sind gegeben wie etwa Funkstrecken.

Informationstransport auf einer Leitung erfolgt in der Regel sequenziell, d.h. ein Bitwird nach dem anderen auf die Leitung gebracht und ebenso empfangen. Der paralle-le Transport bedeutet, dass mehrere Bits gleichzeitig über ein Bündel vonLeitungengesendet werden. Ein solches Bündel wird auch alsBus bezeichnet.

1.4.2 Busse

Ein Rechnerbusbesteht aus einer Menge vonLeitungen. Ein Bus ist im Rechnerals öffentliches Transportmedium für mehrere Einheiten aufzufassen, die über diesenmiteinander verknüpft sind. Der Zugriff auf den Bus, also die Busbenutzung, wirddaher auch als Multiple Access (MA) bezeichnet und muss durch Konventionen inForm von Protokollen geregelt werden.

Busse lassen sich nach den Einheiten charakterisieren, die sie miteinanderverbinden.Ebenso gibt es verschiedene Busarchitekturen, welche die Zuordnung von Bussen anEinheiten beschreiben. Abbildung1.4zeigt eine Architektur mit zwei Bustypen: DerDatenbus dient der Kommunikation zwischen Prozessoreinheit und dem Speicher.Ein eigener Rechnerbus sorgt für die Kommunikation des Prozessors mit den E/A-Geräten.

Speicher

CPU E/A-Gerät E/A-Gerät

Rechnerbus

Datenbus

Abbildung 1.4: Zwei-Bus-Architektur

Einfacher, aber weniger leistungsfähig als diese Zwei-Bus-Architekturist die Ver-wendung eines gemeinsamen Busses – so genannterUnibus – für alle Kommunika-tionsaufgaben zwischen allen Einheiten (siehe Abbildung1.5).


Speicher CPU E/A-Gerät E/A-Gerät

Bus für Daten, Befehle, Steuerung...

Abbildung 1.5: Unibus-Architektur

Ein grundlegendes Problem ist die unterschiedliche Geschwindigkeit, mit der dieKomponenten arbeiten, die an einen gemeinsamenBusangeschlossen sind, zum Bei-spiel: schnelle CPU und langsames E/A-Gerät. Benutzt eine langsame EinheitdenBus, so ist er für eventuell längere Zeit für andere Einheiten blockiert.Dies erklärtauch, warum der Unibus nicht sehr leistungsfähig ist.

Erforderlich sind also Hilfsmittel, welche die Geschwindigkeitsunterschiede glätten,um weniger Busse verwenden zu können. Ein Lösungsansatz bestehtim Einsatz vonPufferregistern zwischen dem Bus und den angeschlossenen Geräten (siehe Abbil-dung 1.6). Auf diese Weise kann zum Beispiel eine schnelle CPU viele langsameEndgeräte wechselweise bedienen. Der Bus ist allerdings nur solangenicht blockiert,bis der Puffer voll ist.

CPU Drucker

schnell

Puffer E/A

langsam schnell

Puffer- register

CPU

Abbildung 1.6: Pufferung des Buszugangs

KAPITEL 2

Informationsdarstellung

In diesem Kapitel werden Darstellungsformen und Codierungen für Zahlen und Zei-chen eingeführt. Wir betrachten sowohl gebräuchliche Formen der Darstellung vonganzen und Gleitkommazahlen als auch Codierungen von Zeichen, denen keine arith-metische Bedeutung zugeordnet ist.

Die Darstellung eines Datums findet meist in einem Speicherwort statt. Es sind auchHalb- oder Doppelwortdarstellungen gängig. Ein Speicherwort ist somitals Infor-mationseinheit des Rechners zu verstehen. Die Wortlänge ist dabei abhängig vomRechner; es handelt sich in der Regel um Potenzen von 2 (16, 32, 64 Bit). Bei Groß-rechnern findet man auch exotische Werte wie 50- oder 60-Bit-Darstellungen.

2.1 Allgemeines zur Darstellung ganzer Zahlen

Es gilt, eine Darstellung für ganze Zahlen zu finden, so dass sich eine vernünftigeZuordnung zwischenCodierung und dem Wert der Zahl ergibt. An eine Codierungwerden im Allgemeinen folgende Anforderungen gestellt:

• Zunächst sollten alle positiven und negativen Zahlen eines Intervalls[−x;y]dargestellt werden können.

• Dabei sollten in etwa gleich viele positive wie negative Zahlen darstellbar sein.

• Die Darstellung sollte – abgesehen von wenigen Ausnahmen – eindeutig sein,das heißt, zwei unterschiedlicheCodewortebeschreiben auch zwei untersch-iedliche Werte.

• Eine wichtige Forderung ist die Durchführbarkeit von Rechenoperationen inder Codierung.

• Eine eher technische Forderung liegt darin, dass die Unterscheidung zwischenpositiver und negativer Zahl möglichst am Anfang des Codeworts getroffenwerden kann. Der Rest wird als Codierung des Stellenwerts aufgefasst.

9

10 Kapitel 2. Informationsdarstellung

2.1.1 Stellenwertcodierung

Die Stellenwertcodierung ist ein gebräuchliches Beispiel für eine vernünftige Zu-ordnung. Das bekannteste Beispiel ist dasDezimalsystem. Man ordnet einem Code-wort (an−1, . . . ,ai , . . . ,a0) einen Wert zu, der sich ergibt als:

W(an−1, . . . ,ai , . . . ,a0) =n−1

∑i=0

ai ·di

Dabei bezeichnet mand alsBasisundai mit 0≤ ai ≤ d−1 alsStellenwert.

Gebräuchliche Basen sindd = 2,8,10,16. DasZahlensystemwird entsprechend derdurch die Basis gegebenen Codierung alsBinär -, Oktal -, Dezimal- oderHexade-zimal-System bezeichnet. In der folgenden Tabelle sind die vier gebräuchlichstenZahlensysteme mit ihren Basen und Alphabeten aufgelistet.

Zahlensystem Basisd Zahlenalphabet

Binär 2 {0,1}Oktal 8 {0,1,2,3,4,5,6,7}Dezimal 10 {0,1,2,3,4,5,6,7,8,9}Hexadezimal 16 {0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F}

Jede Hexadezimalziffer wird in binärer Darstellung durch vier Bits dargestellt. ImFolgenden betrachten wir jedoch dasBinärsystem.

Wir verwenden nun die Stellenwertfunktion W, die eine Unterscheidung zwischennegativer und positiver Zahl aufgrund des ersten Bitsan−1 zulässt:

W : {0,1}n→ Z

W(an−1, . . . ,ai , . . . ,a0) = (an−1,Sn−2,0)

mit

Sj,i =j

∑k=i

ak ·2k (2.1)

Man bezeichnetan−1 alsVorzeichenbit und legt fest:

W(an−1,an−2, . . . ,ai , . . . ,a0) =

{

+Sn−2,0 falls an−1 = 0

−Sn−2,0 falls an−1 = 1

DieseCodierung erlaubt eine Darstellung von maximal 2n verschiedenen Zahlen. Dadurch das erste Bit aber eine Unterscheidung zwischen positiven und negativen Zah-len getroffen wird und die 0 sowohl als positive als auch negative Zahl interpretiertwird, ist die betragsgrößte Zahl 2n−1−1.

2.2. Codierungen für ganze Zahlen 11

2.2 Codierungen für ganze Zahlen

In diesem Abschnitt werden dreiCodierungenfür ganze Zahlen eingeführt. Die Dar-stellung positiver ganzer Zahlen ist in allen drei Codierungen gleich. Sie unterschei-den sich in der Codierung negativer Zahlen und der 0, der damit zusammenhängendenSymmetrie und der Größe des Zahlenbereiches. Ferner sind die Rechenoperationenauf diesen Codierungen unterschiedlich zu handhaben. AlsRechenoperationenwer-den zunächst nur dieAddition und Subtraktion vorgestellt. In Abschnitt2.3 überrationale Zahlen werden auch die Multiplikation und Division eingeführt.

Bei der Beschreibung der einzelnen Codierungen wird von einern-stelligenBinär-zahl der Form(bn−1, . . . ,b0) ausgegangen und die SummeSj,i aus2.1verwendet.

2.2.1 Betrag- und Vorzeichen (B+V-Codierung)

Positive und negative Zahlen

Eine positive Zahl liegt dann vor, wennbn−1 = 0 ist. Dann ergibt sich der Wert derBinärzahl als:

WBV(bn−1, . . . ,b0) = +Sn−2,0 (2.2)

Bei negativen Zahlen ist dasVorzeichenbit auf 1 gesetztbn−1 = 1. Der Wert ist dann:

WBV(bn−1, . . . ,b0) =−Sn−2,0

Eine negative betragsgleiche Zahl erhält man aus einer positiven, indemman dasVorzeichenbit kippt, d.h. von 0 auf 1 setzt.

Beispiel: Zahlen in der B+V-Darstellung

Sein = 6, es ist WBV(001101) = +13 und WBV(101110) =−14.Sei (b2,b1,b0) = (011) gegeben mit WBV(011) = +3, dann ergibt sich für (111) der WertWBV(111) =−3.

Zahlenbereich und Zahlenverlängerung

Der Zahlenbereich in der B+V-Codierung ist symmetrisch und reicht bei einern-stelligen Binärzahl von−(2n−1−1) bis+(2n−1−1). Deshalb hat die 0 zwei Darstel-lungen, nämlich(bn−1, . . . ,b0) = (0, . . . ,0) und(bn−1, . . . ,b0) = (1,0, . . . ,0).

Will man einen-stellige Binärzahl aufm Stellen (m> n) erweitern, so füllt man dieZahl nach demVorzeichenbit an der Stelle(n−2) mit Nullen auf.

Beispiel: Zahlenverlängerung

Sei n = 5 mit a = (11010) gegeben. Die aufm = 7 Stellen erweiterte Zahl lauteta′ =(1001010).


2.2.2 2-Komplement

Der Wert W2K(bn−1, . . . ,b0) einer ganzen Zahl in der 2-Komplement-Codierung er-gibt sich nach folgender Formel

W2K(bn−1, . . . ,b0) = Sn−2,0−bn−1 ·2n−1 (2.3)

Im Falle, dassbn−1 = 1 ist, wird also durch Subtraktion eine negative Zahl errechnet.


Positive ganze Zahlen haben die gleiche Binärdarstellung im 2-Komplement wie inder B+V-Codierung.

Eine negative Zahl ergibt sich aus der Formel2.3, wennbn−1 = 1 ist. Andererseits er-hält man den Wert einer negativen Binärzahl in 2-Komplement-Codierung wie folgt.

Gegeben seib = (bn−1, . . . ,b0) mit W2K(bn−1, . . . ,b0) < 0.

1. Man kippe alle Bits vonb, es ergibt sichbneu.

2. Eine 1 addieren:bneu= bneu+1n mit 1n = (0, . . .0,1).

3. Zugehörigen Wert in B+V-Codierung bestimmen:U = WBV(bneu).

4. Der Dezimalwert vonb ist dann−U : W2K(b) =−U .

Diese Art der Berechnung versagt nur für(bn−1, . . . ,b0) = (1,0, . . . ,0). Nach derzweiten Methode ergibt sich der Wert−0. Der Dezimalwert nach Formel2.3 ist je-doch W2K(1,0, . . .0) =−2n−1.

Beispiel: Zahlen in der 2-Komplement-Darstellung

Sein = 7 undb = (b6, . . . ,b0) = (1010110). Nach Formel2.3ergibt sich:

W2K(b6, . . . ,b0) = 1·24 +1·22 +1·21− (1·26) = 22−64=−42

Nach der zweiten Methode ergibt sich:

1. Kippen:bneu= 0101001

2. 1 addieren:bneu= 0101010

3. U = WBV(bneu) = 1·25 +1·23 +1·21 = 42

4. Dezimalwert ist W2K(b) =−U =−42


DerZahlenbereichim 2-Komplement ist asymmetrisch. Er reicht bei einern-stelligenBinärzahl von−(2n−1) bis+(2n−1−1). Die 0 hat also nur eine Darstellung, nämlich

(bn−1, . . . ,b0) = (0, . . . ,0)


Will man einen-stellige Binärzahl aufm Stellen(m> n) erweitern, so füllt man dieZahl vorne an der Stellen mit demVorzeichenbit auf.

Beispiel: Zahlenverlängerung beim 2-Komplement

Sei n = 5 mit a = (11010) gegeben. Die aufm = 7 Stellen erweiterte Zahl lauteta′ =(1111010).

2.2.3 1-Komplement

Der Wert W1K(bn−1, . . . ,b0) einer ganzen Zahl in der 1-Komplement-Codierung er-gibt sich nach folgender Formel:

W1K(bn−1, . . . ,b0) = Sn−2,0−bn−1 · (2n−1−1) (2.4)

Im Falle, dassbn−1 = 1 ist, wird durch Subtraktion eine negative Zahl errechnet.


Positive ganze Zahlen haben die gleiche Binärdarstellung im 1-Komplement wie inder B+V-Codierung.

Eine negative Zahl ergibt sich aus der Formel2.4, wennbn−1 = 1 ist. Andererseits er-hält man den Wert einer negativen Binärzahl in 1-Komplement-Codierung wie folgt.

Gegeben seib = (bn−1, . . . ,b0) mit W1K(bn−1, . . . ,b0) < 0.

1. Man kippe alle Bits vonb, es ergibt sichbneu.

2. Zugehörigen Wert in B+V-Codierung bestimmen:U = WBV(bneu).

3. Der Dezimalwert vonb ist dann−U : W1K(b) =−U .

Beispiel: Darstellung negativer Zahlen in der 1-Komplement-Darstellung

Sein = 7 undb = (b6, . . . ,b0) = (1001010). Nach der Formel2.4ergibt sich:

W1K(b6, . . . ,b0) = (1·23 +1·21)−1· (26−1) = 10−63=−53

Nach der zweiten Methode ergibt sich:

1. Kippen:bneu= 0110101

2. U = WBV(bneu) = 1·25 +1·24 +1·22 +1·20 = 53

3. Dezimalwert ist W1K(b) =−U =−53


Die Asymmetrie der 2-Komplement-Codierung ist behoben. Der symmetrischeZah-lenbereichreicht nun von−(2n−1−1) bis+(2n−1−1).


DieZahlenverlängerungim 1-Komplement funktioniert genauso wie im 2-Komplement:Vorne das Vorzeichenbit beliebig oft anfügen.

2.2.4 Transformation von negativen Zahlen

Wir betrachten in diesem Abschnitt die Transformation von negativen Zahlen voneiner Codierung zur anderen. Dabei seib= (bn−1, . . . ,b0) eineBinärzahl in der B+V-Codierung. Wenn das Vorzeichenbitbn−1 = 1 ist, dann haben wir eine negative Zahl.

Transformation zum 1-Komplement

Man kippt alle Bits vonbbis auf das Vorzeichenbit. Formal führt man einExklusives-Oder (Operationszeichen⊕) zwischenbn−1 undbi für alle Stelleni ∈ {0, . . . ,(n−2)}durch. Die Zahlc = (cn−1, . . . ,c0) im 1-Komplement ergibt sich durch

cn−1 = bn−1 und

ci = bn−1⊕bi für alle i ∈ {0, . . . ,(n−2)}

Diese Transformation funktioniert auch in umgekehrter Richtung, also vom1-Komple-ment zur B+V-Codierung.

Transformation zum 2-Komplement

Man verfährt zunächst wie bei der Transformation zum 1-Komplement. Nach derBerechnung vonc = (cn−1, . . . ,c0) wird in einem weiteren Schrittg = c+ 1n mit1n = (0, . . .0,1) berechnet.g ist die Darstellung in der 2-Komplement-Codierung.

Auch diese Transformation funktioniert in umgekehrter Richtung, also vom2-Komp-lement zur B+V-Codierung.

Beispiel: Transformation von Zahlen

Seib = (10110) eine negative Zahl mit WBV(10110) =−6.Transformation zum 1-Komplement und zurück.

b = 10110 B+V-CodierungAlle Bits bis auf das Vorzeichenbit kippen.

c = 11001 1-Komplement-CodierungAlle Bits bis auf das Vorzeichenbit kippen.

b = 10110 B+V-CodierungTransformation zum 2-Komplement und zurück.


b = 10110 B+V-CodierungAlle Bits bis auf das Vorzeichenbit kippen.

1100100001 1n drauf addieren

g = 11010 2-Komplement-CodierungAlle Bits bis auf das Vorzeichenbit kippen.

1010100001 1n drauf addieren

b = 10110 B+V-Codierung

2.2.5 Addition und Subtraktion

Zwei Binärzahlena = (an−1, . . . ,a0) und b = (bn−1, . . . ,b0) werden addiert, indemman sie nach Schulmethode komponentenweise addiert.

an−1 an−2 . . . a2 a1 a0

bn−1 bn−2 . . . b2 b1 b0

sn sn−1 sn−2 . . . s2 s1 s0

Im Falle, dass die Addition an der(n−1)-ten Stellen einen Übertragsn liefert, mussdieser besonders behandelt werden. Die einzelnen Codierungen unterscheiden sichbei der Behandlung des Übertrages.

B+V-Codierung

Die B+V-Codierung ganzer Zahlen ist ungünstig bezüglich derAddition . Eine Mög-lichkeit, diese durchzuführen, besteht darin, die Summandena undb in die Darstel-lung im1-Komplementzu transformieren und dort die Addition durchzuführen. DieSummes liegt dann im 1-Komplement vor und wird auf gleiche Weise zurück in dieB+V-Codierung überführt.

2-Komplement

Die Addition wird beim2-Komplement nach Schulmethode durchgeführt, falls einÜbertrag an der(n−1)-ten Stelle entsteht, wird dieser Gesamtübertrag ignoriert.

Beispiel: Addition im 2-Komplement

Seien die Summandena = (1101101) und b = (0011001) gegeben. Die Summes ergibtsich dann wie folgt:

1101101 W2K(a) =−190011001 W2K(b) = +25

1|0000110 W2K(0000110) = +6Der Übertrag wird ignoriert!


Die Subtraktion kann auf dieAddition zurückgeführt werden, indem mana−b alsa+(−b) auffasst. Also mussb in eine negative Zahl umgeformt werden. Anschlie-ßend verfährt man man wie bei Addition beschrieben.

1-Komplement

Die Addition wird auch hier nach Schulmethode durchgeführt, falls ein Übertrag ander (n− 1)-ten Stelle entsteht, wird ein so genannterEnd-Around-Carrydurchge-führt. Die herausfallende Stellesn = 1 wird gestrichen, dann allerdings auf die bishe-rige Summes addierts= s+1n mit 1n = (0, . . . ,0,1). Wenn im1-Komplement einGesamtübertrag sn = 1 entsteht, dann gilt, dass dieser sowohl den Wertsn ·2n alsauch den Wertsn ·20 = sn ·1 hat, weil man modulo(2n−1) rechnet, denn

sn ·2n = sn · (2n−1)+sn = sn mod(2n−1) = sn ·20 mod(2n−1)

Beispiel: Addition im 1-Komplement

Seien die Summandena = (1101101) und b = (0011001) gegeben. Die Summes ergibtsich dann wie folgt:

1101101 W1K(a) =−180011001 W1K(b) = +25

1|0000110 W1K(0000110) = +6 mit s= (0000110)0000001 Da Übertrag 1n drauf addieren0000111 W1K(0000111) = 7.

Die Subtraktion kann auch hier wieder auf die Addition einer negativen Zahl zu-rückgeführt werden.

2.2.6 Überlaufproblematik

Wie die vorangehenden Abschnitte und das folgende Beispiel zeigen, kann es bei derAddition zu einem Überlauf kommen.

Beispiel: Überlaufproblematik

Die Summe vona = (01010) undb = (01100) ist s= (10110). Im 2-Komplement ist derDezimalwert W2K(s) =−10. Das korrekte Ergebnis lautet aber: W2K(a)+W2K(b) = +22.Zwischen beiden Ergebnissen liegt eine Differenz von 32= 2n = 25. Dies lässt sich damitbegründen, dass im 2-Komplement mod 2n gerechnet wird. Das Ergebnis W2K(s) =−10ist also bis auf Vielfache von 2n richtig.

Die Zahlenverlängerung stellt eine mögliche Abhilfe gegen Überlauf. Bei der2-Komplement- und1-Komplement-Darstellung verdoppelt man dasVorzeichenbit.Jeder Summand beginnt dann mit zwei gleichen Bits. Sind die ersten beiden BitsderSumme verschieden, ist das Ergebnis sicherheitshalber zu prüfen.

2.3. Darstellung rationaler Zahlen 17

Beispiel: Überlaufabhilfe

Verlängerea = (01010) zu a′ = (001010) undb = (01100) zu b′ = (001100). Die Summeist danns= (010110). Eine Überprüfung ergibt, dass das Ergebnis korrekt ist.

Der Nachteil dieser Vorgehensweise liegt in einer höherenRedundanz; man ver-schenkt ein Bit und kann somit nur halb so viele Zahlen darstellen, wie die Bitwort-länge erlaubt. Vorteilhaft ist die Einfachheit dieser Methode.

Ein Kriterium für die Unmöglichkeit eines Überlaufs ist ein Vergleich der Vorzei-chen beider Summanden: Ein Überlauf ist unmöglich, wenn die Vorzeichen unter-schiedlich sind, oder formal: Sinda = (an−1, . . . ,a0) undb = (bn−1, . . . ,b0) die zweiSummanden, dann ist ein Überlauf genau dann unmöglich, wennan−1 6= bn−1 . An-schaulich lässt sich dies dadurch begründen, dass die Summe einer negativen undeiner positiven Zahl nicht denZahlenbereichüberschreiten wird.

2.3 Darstellung rationaler Zahlen

Die obigen Abschnitte haben die Darstellung von ganzen Zahlen eingeführt. Diezugehörigen Rechenoperationen sind die Addition und Subtraktion, wobei letzteresich auf die Addition zurückführen lässt. Will man nun Zahlen dividieren, so reichenganze Zahlen nicht aus. In diesem Abschnitt werden Darstellungsformen rationalerZahlen eingeführt.

2.3.1 Festkommazahlen

Es gibt zwei Arten derFestkommadarstellung.

(1) Zu einer Binärzahlb = (bn−1, . . . ,b0,b−1, . . . ,b−m) stellt man sich ein Kommazwischenb0 undb−1 vor. Der Wert ergibt sich nach folgender Formel

WFK(bn−1, . . . ,b0,b−1, . . . ,b−m) =n−1

∑i=−m

bi ·di (2.5)

Ganze Zahlen haben in dieser Darstellung das gedachte Komma ganz rechts, dasheißt, nach der Stelleb−m.

(2) Eine andere Möglichkeit besteht darin, den Zahlenbereich auf ein offenes Inter-vall (−1,+1) einzuschränken. Die Binärzahl hat die Form

b = (b0,b1, . . . ,bn)

wobeib0 dasVorzeichenbit ist und der Wert vonb sich nach folgender Formelberechnet

WFK(b) =

{

+∑ni=1

12i falls b0 = 0

−∑ni=1

12i falls b0 = 1

(2.6)


Die Werte−1 und 1 sind auf diese Weise nicht darstellbar, denn die größte dar-stellbare Zahl ist 1− 1

2n .

Beispiel: Festkommazahlen bei einem offenen Intervall

Sein = 4 undb = (b0,b1,b2,b3,b4). Die kleinste darstellbare Zahl ist WFK(00001) =116 und die größte darstellbare Zahl ist WFK(01111) = 15

16.

2.3.2 Gleitkommazahlen

Abbildung 2.1 zeigt die Darstellung einerGleitkommazahl. Der Darstellung einerrationalen Zahl durchMantissea und Exponente liegt der folgende Satz für reelleZahlen zugrunde.

Mantisse a Exponent e

Zahlenwert

gedachtes Komma (Mantisse)

gedachtes Komma (Exponent)

Abbildung 2.1: Kodierung einer Gleitkommazahl

Satz: Darstellung von Gleitkommazahlen

1. Jede Zahlz ist darstellbar in der Form

z= a·de

mit der Mantissea, dem Exponenteneund der Basis der Zahlendarstellungd.

2. Eine Zahlz 6= 0 ist eindeutig darstellbar als

z= a·de

wobei 1d ≤ |a| < 1. Diese Darstellung heißt dannnormalisierte Darstellung mit

Mantissea und Exponente.


Beispiel: Gleitkommazahlen

Es soll die Dezimalzahl 5 in die normalisierte Darstellung zur Basis 2 gebracht werden

5 = 5·20

= 2,5·21

= 1,25·22 (1.01000| 0010)= 0,625·23 (0.10100| 0011) normalisierte Darstellung= 0,3125·24 (0.01010| 0100) . . .

Somit hat die Dezimalzahl 5 die normalisierte Darstellung:

5 = (2−1 +2−3) ·23

mit Mantissea = (0.10100) und Exponente= (0011) zur Basis Basis 2, denn12 ≤| 0,625|< 1.

Dieses Beispiel legt die Basis 2 zugrunde. Es sind aber auch andere Basen möglich,wie zum Beispield = 16 (hexadezimal).

Für d = 2 erhält man folgende größte, kleinste und betragskleinste Zahl, wenn manden Exponenten im2-Komplement fünfstellig und die Mantisse siebzehnstellig dar-stellt:

Exponent:größter 01111 W2K(01111) = +15kleinster 10000 W2K(10000) =−16

Seien fürα ·2x, α ∈ [−1;+1) undx∈ [−16;+15].

Binäre Darstellung:größte Zahl (1− 1

216) ·215

kleinste Zahl −1·215

betragskleinste Zahl 1·2−16

Die Zahlen liegen mit zunehmender Entfernung von Null weiter auseinander, wohin-gegen sie um die Null extrem dicht liegen, vorausgesetzt, der Zahlenbereich ist sym-metrisch gehalten. Wegen der Binärinterpretation des Exponenten lässt sich dieserdichte Dezimalzahlenbereich verschieben. Denkt man sich zum Beispiel den Expo-nenten um jeweils 8 größer, alsox∈ [−8;+23], so ist der dichte Bereich ins Positiveverschoben.

Die Mantissenlänge erweitert nicht den Zahlenbereich, sondern sie erhöht die Genau-igkeit der Darstellung. Trotzdem sind irrationale Zahlen immer nur ungenau darstell-bar.

Das IEEE-754-Format

DasIEEE-754 legt ein Format für die Darstellung von Gleitkommazahlen fest, dashäufig benutzt wird. Es gibt eine Version mit 32 Bit und eine mit 64 Bit. Im Folgendenwird die Version mit 32 Bit beschrieben.


1 2 30 1 2 3 4 5 6 7 89 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1

VZ Exponente Mantissea

Das erste Bit ist ein Vorzeichenbit, wobei 0 eine positive und 1 eine negative Zahl be-deutet. Die folgenden acht Bits bilden den Exponentene. Die Basis des Exponentenist 2. Der Exponent wird in der Excess-127-Darstellung gespeichert.In dieser Dar-stellung muss vom Exponenten 127 subtrahiert werden, um den eigentlichen Wertdes Exponenten zu erhalten. Die letzten 23 Bits bilden die Mantissea. Die Mantisseist auf die Darstellung 1, . . . normalisiert, wobei die 1 vor dem Komma steht. Die 23Bits nehmen die 1 nicht auf, sondern nur die Zahlen nach dem Komma!

Definition: Gleitkommazahl im IEEE-754-Format

Eine Gleitkommazahl im IEEE-754-Format repräsentiert dieZahl n mit

n = VZ 1,a·2e−127

Beispiel: Gleitkommazahl im IEEE-754-Format

Die Zahln =−0,75 wird dargestellt als

1︸︷︷︸

−01111110︸︷︷︸

126−127=−1

10000000000000000000000︸︷︷︸

(1,5)10

2.3.3 Addition und Subtraktion bei Gleitkommazahlen

Bei der Addition zweier Zahlenz1 = a1 ·de1 undz2 = a2 ·de2 ist zu beachten, dass dieExponenten gleich sind. Man geht wie folgt vor:

1. Exponenten anpassen (den kleineren an den größeren)

2. Operation (gemäß der vorangehenden Abschnitte) ausführen

3. Postnormalisieren(Summendarstellung normalisieren)

Auf diese Weise kann es zu einem Genauigkeitsverlust und einer Teilauslöschung beibegrenzter Stellenanzahl kommen.

Beispiel: Addition und Subtraktion bei normalisierten Gleitkommazahlen

1) Seienz1 = (0,1101) ·24 undz2 = (0,1011) ·22 im 2-Komplementgegeben.

(a) Exponentenanpassung

z2 = (0,0010)11·24 wobei die herausfallenden Einsen auf die letzte Stelle gerun-det werdenz2 = (0,0011)

(b) Addition

s= (0,1101) ·24 +(0,0011) ·24 = (1,0000) ·24


(c) Postnormalisierungs= (0,1000) ·25, da|W2K(1,0000)|= 1

Der sich ergebende Dezimalwert ist ungenau WGK(0,1000) ·25 = 0,5·25 = 16

Der korrekte Wert ist

WGK((0,1101) ·24)+WGK((0,1011) ·22) =(

12

+14

+116

)

·24 +

(12

+18

+116

)

·22 = 13+2,75

= 15,75

2) Die Zahlz2 = 0,9986·1039 soll vonz1 = 0,1002·1040 subtrahiert werden.

Exakt ergibt sich(1,002−0,9986) ·1039 = 0,0034·1039 = 0,34·1037.

(a) Anpassung vonz2 an den größeren Exponenten

z2 wird zu 0,09986·1040, aufgrund der begrenzten Stellenanzahl muss die Zahlgerundet werdenz2 = 0,0999·1040

(b) Subtraktion

0,1002·1040−0,0999·1040 = 0,0003·1040

(c) Postnormalisierung0,3000·1037

Im Vergleich zum exakten Wert liegt ein großer Fehler vor.

Im Extremfall wird dieMantissedurch Rundungsfehler zu Null und ist nicht mehrpostnormalisierbar. Gleichzeitig kann der Exponent groß bleiben. In diesem Fallspricht man von einer so genanntenDirty Zero, da die Zahl dann Null ist, obwohlsich der echte Wert von Null unterscheidet.

2.3.4 Multiplikation und Division bei Gleitkommazahlen

Für die Multiplikation beziehungsweise Division eignet sich die Darstellung mitMantisse und Exponent besser. Hier muss keine Exponentenanpassung stattfinden.Man geht wie folgt vor:

1. Mantissenmultiplizieren beziehungsweise dividieren

2. Exponenten addieren beziehungsweise subtrahieren

3. Postnormalisierungwie oben. Hierzu reicht maximal einLinksshift bei derMultiplikation beziehungsweise einRechtsshiftbei derDivision aus.

(a1 ·de1) · (a2 ·de2) = (a1 ·a2) ·de1+e2 mit1d2 ≤| a1 ·a2 |< 1

a1 ·de1

a2 ·de2=

a1

a2·de1−e2 mit | a1

a2|< d


Beispiel: Division von Gleitkommazahlen

−0,9·105

0,75·108 =−1,2·10−3 =−0,12·10−2

Der letzte Schritt entsteht durch Postnormalisierung, indem die Mantisse nach rechts geshif-tet und der Exponent korrigiert wird.

2.4 Darstellung von Zeichen

In diesem Abschnitt werden Darstellungsformen von Zeichen eingeführt. Es werdenhier keine Forderungen an die Interpretierbarkeit für Rechenoperationen dieser Zei-chen gestellt.

Zeichen sind zum Beispiel Buchstaben, Ziffern, Sondersymbole und Steuerzeichen.Zeichen werden als Folge von Bits (Bitstring) codiert. Ein Wort (Speicherelement)enthält meist mehrere Zeichen in codierter Form.

Es gibt zwei grundsätzlich unterschiedliche Codierungsarten, die in denfolgendenAbschnitten vorgestellt werden. Die zugrundeliegende Frage ist hierbei: Wie vieleBits benötigt man, um ein Zeichen eindeutig darzustellen?

2.4.1 Codierung mit Umschaltsymbolen

Bei dieserCodierung gibt es keine eindeutige Zuordnung zwischen Zeichen unddem codierenden Bitstring. Man verwendet kurze Bitstrings und kann hiermit weni-ge Zeichen codieren. Um weitere Zeichen darstellen zu können, fasst man diese alseine weitere Gruppe von Zeichen auf. Ferner verwendet manUmschaltsymbole, dieanzeigen, welcher Gruppe die Zeichen angehören, die die nächsten Bitsdes Bitstringscodieren.

Darzustellen seien die 26 Buchstaben des Alphabets (in Form von Großbuchstaben)und die zehn Ziffern sowie weitere Sonderzeichen. Will man jedes Zeichendurchfünf Bits codieren, so kann man 25 = 32 verschiedene Zeichen codieren. Dies reichtoffenbar nicht aus, um der Anforderung gerecht zu werden.

Nach der obigen Methode führe man zweiUmschaltsymbole(11111) und(11010)ein, die anzeigen, dass von jetzt ab nur Buchstaben beziehungsweise nur Ziffern oderSonderzeichen imBitstring folgen. Trifft man also auf ein Umschaltsymbol, so wer-den die im Bitstring folgenden 5-Bit-Folgen entsprechend dem vorangehenden Um-schaltsymbol interpretiert. Diese Codierung erlaubt die Darstellung von 30Buchsta-ben sowie 30 Ziffern und Sonderzeichen, wenn man die beiden Umschaltsymboleberücksichtigt.

Eine Erweiterung wäre die Unterscheidung zwischen Groß- und Kleinschreibung.Hierzu müssten zwei weitere Umschaltsymbole eingeführt werden: Umschalten Groß-nach Kleinschreibung und Klein- nach Großschreibung bei Buchstaben. Günstiger istin diesem Fall die Einführung von insgesamt drei Umschaltsymbolen für Großbuch-

2.4. Darstellung von Zeichen 23

staben, Kleinbuchstaben und Sonderzeichen bzw. Ziffern.

Zu beachten ist bei dieser Codierung, dass ohne Kenntnis des im Bitstringzuletzt vor-gekommenen Umschaltsymbols einer Bitfolge kein eindeutiges Zeichen zugeordnetwerden kann.

Dem Vorteil der Darstellbarkeit vieler Zeichen als kurze Bitfolgen steht dieVerlän-gerung des Bitstrings durch die eingestreuten Umschaltsymbole gegenüber. Zudemverkleinern viele Umschaltsymbole die Gruppen der tatsächlich zu codierenden Zei-chen.

Eine Aufgabe der Informationstheorie ist die Darstellung einer gegebenen Informa-tionsmenge mit möglichst wenigen Bits. Eine Idee liegt darin, häufig vorkommendeZeichen oder Zeichenkombinationen wie zum Beispiele oderenmit kurzen Bitfol-gen zu codieren, für seltene Zeichen wieq verwendet man längere Folgen.

DieHuffman-Codierung basiert auf der relativen Häufigkeit des Gebrauchs von Zei-chen. Die Häufigkeit deutscher Buchstaben ergibt abnehmend das folgende Kunst-wort:

E N R I S T U D A

2.4.2 Codierung durch Bitstrings

Bei dieser Codierung ordnet man jedern-stelligen Bitfolge genau ein Zeichen zu.Somit sind 2n verschiedene Zeichen codierbar.

Beispiel: Codierung durch Bitstrings

Die Darstellung der 26 Großbuchstaben, 26 Kleinbuchstabenund 10 Ziffern ist mit sechsBits möglich.

Standardzeichensätze verwenden sieben beziehungsweise acht Bits (ein Byte) proZeichen. Zu nennen ist derASCII-Code (American Standard Code for InformationInterchange), welcher sieben Bits verwendet. DerEBCDIC-Code (Extended BinaryCoded Decimal Interchange Code) verwendet acht Bits. In Tabellen lassen sich dieseCodierungen nachschlagen.

Die Darstellung von ASCII-Zeichen auf Bytebasis (Erweiterung auf 8 Bits) ermög-licht die Einrichtung einer Übertragungskontrolle. In der 8-stelligen Bitfolge(b7, . . . ,b0)codieren die Bitsb6, . . . ,b0 das Zeichen, während das so genannte Parity-Bitb7 dieAnzahl der Einsen auf eine gerade Zahl(b0 + . . .+ b7) mod 2= 0 ergänzt. Für dieFolge(b6, . . . ,b0) = (001101) ist b7 = 1. Ein Bitfehler ist definiert als Kippen einesBits. Ein solcher Fehler ist dadurch erkennbar, dass die Summe derbi mod 2 gleicheins ist. Somit sind Doppelfehler, das heißt Kippen von zwei Bits einer Bitfolge, nichterkennbar. Erkennbar sind: 1-Bit-, 3-Bit-,. . . (2k+1)-Bit-Übertragungsfehler.


2.4.3 Darstellung von Dezimalziffern

Zur Darstellung der zehn Ziffern 0,1, . . . ,9 benötigt man mindestens vier Bits, da mitdrei Bits nur 23 = 8 Zeichen codierbar sind.

BCD-Code

Die Ziffern werden wie folgt imBCD-Code (Binary Coded Decimal) dargestellt: 0durch 0000, 1 durch 0001, . . . und 9 durch 1001, wobei sechs Redundanzen 1010, . . .,1111 auftreten.

In ASCII und EBCDIC sind die Ziffern so dargestellt, dass sie bezüglich der Bitsb3b2b1b0 gerade den BCD-Code haben. Bei aufeinanderfolgenden Dezimalziffern isteine Unterdrückung vonb7b6b5b4 möglich, womit eine dichtere Packung erreichtwerden kann. Überprüfen Sie das ;-)

3-Excess-Code

Der redundante Bereich wird hier auf die Bitfolgen(0000), (0001) und(0010) sowieauf (1101),(1110) und (1111) verteilt. Eine Dezimalzahli wird hier also im BCD-Code als Dezimalzahl(3+ i) dargestellt.

000000010010

}

redundant

0011 codiert die 00100 codiert die 10101 codiert die 2

......

1100 codiert die 9110111101111

}

redundant

Ein Vorzug dieser Darstellung ist die Möglichkeit, eine Ziffera in die komplementäreZiffer b durch einfaches Kippen der Bits zu überführen, wobeia komplementär zubist, wenna+b = 9.

Gray-Code

DerGray-Code ist formal folgendermaßen definiert:

Eine Abbildung aller Dezimalzahleni mit 0≤ i ≤ 2n−1 für n≥ 1 durch BitfolgenWn(i) der Längen sei durch Induktion übern wie folgt erklärt:

1. W1(0) = 0 undW1(1) = 1

2.5. Erkennung und Behebung von Bitfehlern 25

2. Wn+1(i) =

{

0Wn(i) falls 0≤ i ≤ 2n−1

1Wn(2n+1−1− i) falls 2n≤ i ≤ 2n+1−1

Anschaulich konstruiert man eine Folge von Gray-Code-Ziffern, indemman einenBlock von untereinander stehenden Ziffern nach unten spiegelt und vor die Binärzah-len des oberhalb der Spiegelachse befindlichen Blocks 0 und unterhalb der Spiege-lachse 1 schreibt:

Beispiel: Gray-Code

Für n = 2 Bits lange WorteW2 ergibt sich:

0 0 00 1 11 1 21 0 3

Für n = 3 Bits lange WorteW3 erhält man:

0 00 00 01 10 11 20 10 31 10 41 11 51 01 61 00 7

Das Charakteristikum dieser Codierung besteht darin, dass sich beim Übergang vonder Dezimalzahli nach(i +1) die zugehörigen Binärzahlen im Gray-Code an genaueiner Stelle unterscheiden.

2.5 Erkennung und Behebung von Bitfehlern

Die Behandlung von Bitfehlern spielt insbesondere im Bereich der Datenkommuni-kation eine große Rolle, da die Übertragung von Bits häufig durch äußereEinflüssegestört wird. Daher hat man Codes eingeführt, durch die man in der Lageist, auftre-tende Bitfehler

• zu erkennen

• zu erkennen und zu beheben

Bei einer entsprechendenCodierung verwendet man aus der Menge aller möglichen(binären) Worten der Längen nur Folgen mit speziellen Eigenschaften, also eineTeilmenge der möglichen Codeworte.

Ein einfaches Beispiel für einen fehlererkennenden und behebenden Code ist dasHinzufügen vonParitätsbits. Diese zusätzlichen Bits werden gerade so gewählt, dass


sie sich mit der Gruppe der Bits, auf die sie sich jeweils beziehen, derart ergänzen,dass sich eine gerade Anzahl von Einsen pro Gruppe ergibt. Analog zudieser gera-den Parität kann man natürlich auch ungerade Parität vereinbaren. ManunterscheidetLängsparität undQuerparität , je nachdem, ob es sich bei der Gruppe um eine auf-einanderfolgende Bitreihe handelt oder aber um allei-ten Positionen innerhalb einergrößeren Anzahl von Bitreihen. Gemeinsam angewendet bieten Längs-und Quer-parität ein Mittel, einzelne Bitfehler zu lokalisieren und zu korrigieren. Bis zudreiBitfehler werden sicher erkannt. Es kann allerdings in pathologischen Sonderfällenund einer darüber hinausgehenden Häufung von Fehlern dazu kommen, dass diesenicht erkannt werden.

Beispiel: Fehlerekennung durch Paritätsbits

10111001 1 Längsparität00101000 010010001 1Querparität

Wird nun aus der fettgedruckten Eins aufgrund eines Übertragungsfehlers eine Null, sokann dieser Fehler anhand der zugehörigenLängs- undQuerparitätsbits erkannt und be-hoben werden.Kippen die fettgedruckten Bits des folgenden Beispiels, sowird dies nicht erkannt.

10111001 1 Längsparität00101000 010010001 1Querparität

2.5.1 Hamming-Distanz

Die Hamming-Distanzbeschreibt ein Abstandsmaß zwischen zwei binären Worten,das durch die Anzahl der Stellen bestimmt ist, an denen sich die Worte unterscheiden.

Seiena = (an−1, . . . ,a0) undb = (bn−1, . . . ,b0) binäre Worte der Längen. Dann ist

d(a,b) = d((an−1, . . . ,a0),(bn−1, . . . ,b0)) =n−1

∑i=0

| ai−bi |

die Hamming-Distanz. Je größerd(a,b) ist, desto mehr Störungen sind notwendig,um a in b zu verwandeln.

Die Hamming-Distanz eines Codes ist definiert als

HD = min(d(a,b))

wobeia undb zulässige Codeworte unda 6= b.

Bei der Paritätsbitcodierung gilt alsoHD = 2. Im Extremfall sind die zulässigen Co-dewörter{(0, . . . ,0);(1, . . . ,1)}, somit gilt hierHD = n, wennn die Länge der Wörterbeschreibt.

2.5. Erkennung und Behebung von Bitfehlern 27

Wenn ein Code eine Hammingdistanz von 2t +1 hat, dann gibt es um jedes Codeworteinen Einzugsbereich der Größet. Die Wörter innerhalb dert-Kugel entsprechen da-bei Störungen des Codeworts von maximalt Bits. Geht man davon aus, dass Stö-rungen weniger wahrscheinlich sind als korrekte Übertragungen, so kann man eineempfangene Folge dem nächstliegenden Codewort zuordnen (Maximum LikelihoodDecision). Damit hat man die Möglichkeit, bis zut Bitfehler zu korrigieren. Tretenjedoch mehr alst Bitfehler auf, so wird die Entscheidung fehlerhaft.

Bei Codes der Hamming-Distanz 2t sind bis zut−1 Bitfehler erkennbar und korri-gierbar.t Bitfehler sind erkennbar, aber nicht mehr korrigierbar. Das einfachste Bei-spiel hierfür ist wieder die Paritätsbitcodierung mitt = 1.

Beispiel: Fehlererkennung/-korrektur

Es werde der folgende Code definiert:Zeichen Codierung

A 00000000E 11000011R 00000111S 11100000T 00111010U 11111111

Dann ist die Hamming-Distanz des Codes3. Somit gilt hier t = 1, es können also 2-Bit-Fehler erkannt und 1-Bit-Fehler korrigiertwerden.

KAPITEL 3

Maschinennahe Programmierung

In diesem Kapitel wird die maschinennahe Programmierung vorgestellt. Wir betrach-ten die Darstellung vonBefehlenund verschiedene Arten derSpeicheradressierung.Schließlich wird erklärt, was es heißt, Programme undUnterprogramme auszufüh-ren.

3.1 Darstellung von Befehlen

Die Speicherung eines Befehls findet meist in einem Wort statt, manchmal auch ineinem Halbwort oder Doppelwort. Die Interpretation einerBitfolge setzt in einemSpeicherwort eine Strukturierung voraus, die den gewünschten Befehl identifiziert.

3.1.1 Aufbau eines Befehlswortes

Der Aufbau einesBefehlswortesist im Allgemeinen folgendermaßen:

Format Opcode Adresse 1 . . . Adressek

Format

Das Format legt einerseits die Struktur derAdresscodierungfest; es gibt an, an wel-cher Binärstelle die Adressen beginnen und wie lang sie sind. Andererseits legt esRegeln zurBefehlsausführungfest, das heißt, die Zahl der Operanden, Vorrangrege-lungen oder etwa implizite Operanden wie zum Beispiel denAkkumulator oderStack. Oft ist das Format implizit durch denOpcodegegeben.

Opcode

Der Opcode definiert die auszuführende Operation. Aufgrund seines Codes kann zumBeispiel ein Holebefehl (Code sei 001011) von einem Additionsbefehl(011011) un-

29

30 Kapitel 3. Maschinennahe Programmierung

terschieden werden.

Man unterscheidet Operationen nach ihrer Stelligkeit, das heißt, anhand der zu ihrerAusführung benötigtenOperanden.

Beispiel: Opcodes

Nullstellige Operation HALT (Stop derProgrammausführung)Einstellige Operation a =−bZweistellige Operation a = b opcMehrstellige Operation Vektoroperation

Adresstypen

Man unterscheidet zwei Typen von Adressen:

1) Operandenadressen geben die Quell- und Zieladressen der Operanden an. Dabeikann die Adresse zum Beispiel eine Konstante sein.

Beispiel: Adressen

a = b+c

b undc sind Quelladressen unda ist eine Zieladresse.

2) Die Folgebefehlsadresse zeigt an, an welcher Adresse sich die nach diesem Befehlauszuführende Instruktion befindet.

Die Quell- und Zieladressen können fehlen, wenn sich die auszuführende Operationauf spezielle Register oder auf denStackbezieht. Dies wird aus demOpcodeersicht-lich. Die Folgebefehlsadresse fehlt, wenn von der sequenziellen Befehlsausführungnicht abgewichen wird. Anhand der Operanden-Zahl lassen sichBefehlsstrukturenunterscheiden (siehe Abbildung3.1). Die Bezeichnung(x+y)-Befehl bedeutet, dassder Befehlx Operandenadressen (ohne Register) undy Folgebefehlsadressen verwen-det.

Beispiel: (1+0)-Befehle

α = ρ(i) Opcode1,Operandiα = α+ρ( j) Opcode2,Operandjρ(k) = α Opcode3,Operandk

Dabei spricht man vonMnemonischer-Darstellung(Assemblerbefehl) und dem Quell-code, bzw. vonBinärdarstellung (Objektform) undObjektcode. Der Unterschiedzwischen Quellcode und Objektcode liegt unter anderem in der besserenLesbarkeitder Programme im Quellcode, während die Darstellung im Objektcode maschinen-näher ist.

Ein Assemblerist ein Programm, welches Quellcode in Objektcode umwandelt. Mitdiesem Begriff identifiziert man auch häufig die Assemblersprache.

3.1. Darstellung von Befehlen 31

Befehlsstruktur Adressen Wirkung (Beispiel) Folgebefehl

3 + 1 a, b, c, d ρ(a) =ρ(b) op ρ(c) d3 + 0 a, b, c ρ(a) =ρ(b) op ρ(c) β+12 + 1 a, b, d ρ(a) =ρ(b) op ρ(a) d2 + 0 a, b ρ(a) =ρ(b) op ρ(a) β+11 + 1 a, d α = α op ρ(a) d1 + 0 a α = α op ρ(a) β+10 + 1 d goto d d0 + 0 keine Stackbefehl β+1

α steht für denAkkumulator ,β bezeichnet denBefehlsfolgezählerundρ(i) ist der Wert (Datum) in SpeicherzelleiHäufig benutzt und ökonomisch, da nur auf maximal eine Adresse zugegriffen werdenmuss, sind(1+0)-Befehle und(0+0)-Adressbefehle.

Abbildung 3.1: Befehlsstrukturen

(2+ y)-Adressbefehle sind aufwändiger und ungebräuchlich, sie lassen sich außer-dem als eine Folge von(1+y)- und(0+1)-Adressbefehlen darstellen.

Beispiel: (2+1)-Befehlssequenz

Der (2+1)-Befehlα = ρ(i)−ρ(k); goto h lässt sich durch folgende Sequenz simulieren:α = ρ(i) (1+0)-Befehlα = α−ρ(k) (1+0)-Befehlgoto h (0+1)-Befehl

Stack

Außer den vorgestellten Befehlen gibt es so genannteStackbefehle, die auf demStackarbeiten. Beim Stack handelt sich um eine Datenstruktur, die nach dem LIFO-Prinzip (Last In First Out) organisiert ist. Ein Stack ist ein Stapel von Informations-einheiten, in die Informationen (Elemente) abgelegt werden. Dabei kann nur auf dasoberste Element zugegriffen werden. Es gibt zwei Operationen zur Veränderung desStacks.

• Push legt ein neues Element auf den Stack, das heißt, an die oberste Position(τ, Top of Stack).

• Pop entnimmt das oberste Element, wobei das entnommene Element ausgege-ben wird.

Es gibt auch eine Variante, bei der das oberste Element nicht ausgegeben wird.In diesem Fall gibt es zusätzlich die Operation Top, welche es erlaubt, dasoberste Element des Stacks zu lesen, ohne dass es entfernt wird.


Ein Stackwird als Folgeσ = (σ(0),σ(1), . . .σ(τ)) notiert.

τ σ(τ)...

...i σ(i)...

...2 σ(1)

1 σ(0)

Beispiel: Simulation von Stackbefehlen

Der Push-Befehl vollzieht folgende Instruktionen:

τ = τ+1

σ(τ) = α

Pop lässt sich folgendermaßen ausdrücken:

α = σ(τ)τ = τ−1

Sei nunstackadd die Operation, welche die obersten Stackelemente addiert,eliminiert unddie Summe als oberstes Element ablegt:

α = σ(τ)τ = τ−1

σ(τ) = α+σ(τ)

Anwendung finden Stacks bei der Auswertung arithmetischer Ausdrücke. Die Aus-führung arithmetischer Operationen in Infixnotation(a opb) hängt von Präzedenz-regeln und der Assoziativität der Operationen ab, wenn man von einer Klammerungabsieht. Die Umgekehrt Polnische Notation (UPN) legt die Auswertung von Aus-drücken eindeutig durch die Reihenfolge derOperandenundOperationen fest. Beidieser sukzessiven Auswertung im UPN-Ausdruck geht man von links nach rechts inVerbindung mit Push, Pop und Stackφ vor, wobeiφ ∈ {add,sub,mult,div,exp} ist.Zur Auswertung eines Infixausdrucks wandelt man diesen zunächst ineinen UPN-Ausdruck um. Hier stehen die Operationen hinter den Operanden.

Beispiel: Infixausdruck

Sei der Infix-Ausdruckx = a+[(b−c) ·d] ↑ (e· f )−g gegeben.In UPN:x = abc−d ·e f· ↑+g−Stackoperationen: Zu Beginn sei der Stack leer!

1 push a2 push b3 push c4 stacksub5 push d

3.1. Darstellung von Befehlen 33

6 stackmult7 push e8 push f9 stackmult

10 stackexp11 stackadd12 push g13 stacksub14 pop x

3.1.2 Befehlstypen

Man unterscheidet folgende dreiBefehlstypennach ihren unterschiedlichen Aufga-ben:

a) Datentransfer

Für den Datentransfer gibt es denLadebefehlα = ρ(i), der Daten aus dem Spei-cher in denAkkumulator holt, und den Befehlρ( j) = α zum Speichern für dieumgekehrte Richtung.

b) Arithmetische und logische Operationen

Beispiel für eine arithmetische Operation ist die Additionα = α+ρ(i).

DerShiftbefehl zum Schieben von Bits in einem Speicherwort kann ebenfalls alsarithmetische Operation aufgefasst werden. Ein Shift nach links verdoppelt denWert (wenn man von Überträgen absieht).

Beispiel: Arithmetische und logische Operationen

SHRα, i führt einen Rechts-Shift des Akkumulatorinhalts umi Bits durch.

shr 2 , (0110111) = (0001101)

c) Steuerbefehle

• ein unbedingter Sprung

goto j

• ein bedingter Sprung

if <Bedingung> then goto k

<Bedingung> ist zum Beispielα < 0 oderα = γ.

• ein Vergleich und Überspringen der nächsten Operation (Skip) bei Gleich-heit

• ein Unterprogrammaufruf

call <Unterprogrammname/-adresse>

• ein Unterprogrammrücksprung

return


3.1.3 Befehlssätze

Eine Menge von Befehlen eines Rechnermodells bezeichnet man alsBefehlssatz.Die meisten Befehle sind durch (eine Folge von) anderen Befehlen ersetzbar, alsosimulierbar.

Es gibt nun die Tendenz zu möglichst großen Befehlssätzen mit komplexenOpera-tionen. Hier lassen sich kurze Programme bei Ausnutzung des vollenBefehlssatzesschreiben, denn es ist unnötig, umfangreichere Befehle durch eine Folge von wenigermächtigen Befehlen zusammenzusetzen. Ein Rechner, der dieser Tendenz entspricht,ist derComplete Instruction Set Computer(CISC)

Die RISC-Architektur (Reduced Instruction Set Computer) verfolgt gerade die um-gekehrte Tendenz. Kleinere Befehlssätze lassen eine effizientere undschnellere Rea-lisierung des Rechners zu.

Ferner geht man davon aus, dass komplexe Befehle selten eingesetzt werden undbei Bedarf simuliert werden können; bei Beachtung des seltenen Eintretens ist derLeistungsverlust gering. Die schnelle Realisierung der häufigen Grundoperationenführt im Allgemeinen zu einer Leistungsverbesserung.

Beispiel: Befehlssimulation

Ein bedingter Sprung soll durch einen Vergleich-und-Skip-Befehl ersetzt werden.Die Wirkung vonskip α+ besteht darin, den nächsten Befehl zu überspringen, wennα≥0.Zu simulieren ist:if α < 0 then goto r

Simulation durch:[skip α+; goto r]; falls alsoα≥ 0 ist, wirdgoto r übersprungen.

3.1.4 Verwendung zusätzlicher Register und Registerbefehle

Zusätzlich zum Akkumulator können weitere RegisterR0,R1, . . . zu speziellen Zweckenbenutzt werden, zum Beispiel als Indexregisterγ.

In Registerbefehlenkönnen bis zu drei dieser Register angesprochen werden:

• 0-Registerbefehle

Hierzu zählen die bisherigen Befehle. Im Falle der Verwendung des Akkumu-lators (Register) wird dieser nicht explizit genannt, sondern durch denOpcodeimplizit angesprochen.


Beispiel eines solchen Befehls ist die Besetzung desIndexregisterszur indi-zierten Adressierung:γ = ρ(i). DerOpcodehat die Form:

Opcode 0 i

3.2. Adressierung 35


Ein Beispiel ist die Anwendung von Rechenoperationen auf Registerinhalte:Ri = Ri −Rj oder die Zuweisung (Laden) von Registerinhalten: LoadRi ,Rj ,mit der Wirkung:Ri = Rj . Der Opcode ist folgendermaßen aufgebaut:

Opcode i j


Analog lässt sich auch mit drei Registern rechnen:Ri = Rj +Rk.

Die Verwendung von 3-Adressregisterbefehlen ist sinnvoll, weil dieseBefehleschnell ausführbar sind und kurze Adressen haben.

Beispiel: Registerbefehle

Seien 8 RegisterR0, . . . ,R7 gegeben. Die Registernummern werden mit Adressteilen zu je3Bits codiert, also insgesamt durch 3·3= 9 Bits. Dementsprechend ist der Opcode wie folgtaufgebaut:

Opcode 010 001 101

3.2 Adressierung

In diesem Abschnitt werden Techniken zum Ansprechen von Informationen imSpei-cher vorgestellt. Das Ansprechen von Speicher bezeichnet man auch als adressieren.

3.2.1 Direkte Adressierung (absolute Adressierung)

Bei der direkten Adressierung wird eine Speicherzelle durch Angabe der Adresseadressiert. Hat diese eine Länge vonk Bits, so können 2k Adressen angesprochenwerden. Man notiert diese direkte Adressierung in der Formα = ρ(100), wobei hierbeispielhaft derAkkumulator den Inhalt der Speicherzelle 100 erhält.

Der Vorteil dieser Technik liegt im einfachen und übersichtlichen Zugriffauf denSpeicher. Ein schwer wiegender Nachteil besteht aber darin, dass einzu kleinerAdressraum ansprechbar ist. Außerdem ist der Anteil der Adresse am Befehlswortrelativ hoch.

3.2.2 Indirekte Adressierung durch Basisregister und Relative Distanz

Diese Technik behebt die Nachteile der direkten Adressierung. Ein Befehl ist folgen-dermaßen aufgebaut:

Opcode Nummer des Basisregistersi Relative Distanzj

mBits r Bits


Dabei stehen für die Nummer des Basisregistersm Bits und für die relative Distanzr Bits zur Verfügung. Istm= 3, so können die RegisterR0, . . . ,R7 der Längeh alsBasisregister fungieren (siehe Abbildung3.2).

Opcode 5 j =1024

m r

angesprochene Adresse

Gesamtblock für R

5 mit 16

Blöcken und jeweils

2 12 =4096 Bytes

Basisadresse R 5

R 0

R 7

R 5

13

h=4 Bits

Beispiel zu indirekter Adressierung r=12, m=3, h=4

Block für R 5 =0 Block für R 5 =1

Block für R 5 =15

Block für R 5 =13

Abbildung 3.2: Indirekte Adressierung mit Basisregister und relativer Distanz

Die Größe des adressierbaren Speichers ergibt sich somit aus:

Registerzahl 2m m= 3 → 8 RegisterRegisterinhalt 2h h = 4 → 16 Blöcke pro RegisterRel. Verschiebung 2r r = 12 → 0≤ j ≤ 4095

Es sind demnach 2m ·2h ·2r Speicherzellen mit einerm+ r Bit langen Adresse an-sprechbar (im Beispiel also 219). Mit direkter Adressierung sind dagegen nur 2m+r

Adressen ansprechbar. Die Wortlänge des Befehls wurde eigentlich umh Bits verlän-gert durch den Zugriff auf dash-Bit-RegisterRi .

Durch Verwendung vernünftig großer Registerlängen ist ein fast unbeschränkt großerSpeicherbereich auf diesem Wege adressierbar.

Bisher war dieBasisadressefest. Durch Änderung dieser Adressen ist eine weitereFlexibilisierung möglich.

3.2.3 Indexregister zur indirekten Adressierung

Seiγ ein Indexregister. Durch geeignete Belegungen vonγ lassen sich praktisch be-liebige Adressen angeben. Im Zusammenhang mit diesem Register kann man zumBeispiel folgendeBefehlstypenverwenden:

• α = ρ(γ)

• ρ(γ) = α

3.2. Adressierung 37

• γ = γ−1

Anwendung findet das Indexregister bei der Bearbeitung von linearen Listen, Schlei-fen und ähnlichem ohne Änderung des Adressteils eines Befehls.

Beispiel: Indexregister in einer Schleife

1 γ = 1000 //Vorbesetzung2 ANFANG : .3 . //Andere Operationen denkbar4 α = ρ(γ) // Nacheinander werden ρ(1000),. . .5 . // ρ(999), . . . ,ρ(1) angesprochen6 .7 .8 γ = γ−19 if γ > 0 then goto ANFANG

3.2.4 Indexregister mit Adressmodifikation

Um zwischen direkter und indizierter Adressierung wählen zu können, bietet sichdiese Technik an. Der Befehl hat die folgende Struktur:

Opcode j Adresse

j kann dabei zum Beispiel mit 3 Bits codiert sein und gibt folgende Situationenan:

j = 0 Befehl ohne Adressmodifikation, Befehlα = ρ(Adresse)j ∈ {1, . . .7} Adressmodifikation mit Indexregisterγ j , Befehlα = ρ(Adresse +γ j )

3.2.5 Unterschiedliche Adressmodi

Ferner sind Modifikationen derAdressedenkbar. So wird je nach Modus zum Bei-spiel das Indexregister automatisch inkrementiert, wenn über dieses eine Adressie-rung vorgenommen wird.

3.2.6 Indirekte Adressierung

Eine weitere Variante ist die indirekte Adressierung, bei der die Adresseeiner Spei-cherzelle als Inhalt einer anderen Speicherzelle ermittelt wird. Ein Holebefehl hatdann die Formα = ρ(ρ(i)) während er bei direkter Adressierungα = ρ(i) lautete.

In einem Befehl ist die Kennzeichnung, obα = ρ(i) oderα = ρ(ρ(i)) gemeint ist,durch dasI -Bit möglich; zum Beispiel zeigtI = 0 die direkte undI = 1 dieindirekteAdressierungan.


Beispiel: Indirekte Adressierung

Bearbeitung der Zellen 100,99, . . . ,1 mit indirekter Adressierung:

1 α = 1002 START :3 ρ(200) = α // Hilfsspeicherzelle 2004 α = ρ(ρ(200))5 .6 .7 .8 α = ρ(200)9 α = α−1

10 if α > 0 then goto START

3.2.7 Modifizierung von Befehlen

Der Inhalt des Adressteils eines Befehls wird hier modifiziert, also etwa inkrementiertoder dekrementiert. Die Wirkung besteht darin, dass das Programm während seinesDurchlaufs verändert wird. Dies ist zum Teil undurchschaubar unddaher gefährlich.

3.3 Leistungsfähigkeit von Adressiertechniken

Satz: Mächtigkeit von Adressiertechniken

Die Adresstechniken, welche indirekte Adressierung erlauben, besitzen die volle Funktio-nalität der absoluten Adressierung, bzw. sind sogar noch stärker.

Beweisidee:

1. Jede der Techniken kann durch jede andere simuliert werden.

2. Problem: siehe nachfolgende Vermutung!

Ist die direkte Adressierung schwächer als eine indirekte Adressierung? Unter schwä-cher ist dabei zu verstehen, dass es ein Problem gibt, zu dessen Lösung ein Programmmit indirekter Adressierung existiert, aber keines, welches allein mit direkterAdres-sierung auskommt.

Es stellt sich heraus, dass diese Behauptungnicht allgemein gilt, sondern von derEndlichkeit des Rechnermodells abhängt.

3.3.1 Berechnung durch ein Programm

Zur Diskussion der Vermutung müssen wir uns mit der Frage befassen, was ein Pro-gramm eigentlich berechnet.

3.3. Leistungsfähigkeit von Adressiertechniken 39

Ein (terminierendes) Programm soll eine Fragestellung universell lösen,das heißt,ein und dasselbe Programm wird auf verschiedene Argumentkombinationenange-setzt (siehe Beispiel: Additionsprogramm). Es bewirkt im Wesentlichen eine Trans-formation eines alten Rechenspeicherinhalts in einen neuen Rechenspeicherinhalt. ImWesentlichen soll heißen: Ein- und Ausgabe nur vom oder zum Speicher; Register,Flags und Statusinformationen sind nur für Hilfszwecke vorgesehen, also unerheb-lich für das Start- beziehungsweise Endergebnis. Damit kann man ein Programm alseine Abbildung vom Rechenspeicher in den Rechenspeicher (RSP) auffassen.

f : RSP→ RSP

Beispiel: Additionsprogramm

1 γ = 1002 α = 0 //Initialisierung: Anfangssumme3 α = α+ρ(γ) //Indirekte Adressierung4 γ = γ−15 if γ > 0 then goto 26 ρ(1) = α7 HALT

In diesem kurzen Programm sei es erlaubt, Zahlen als Label zuverwenden, die an sich keineAussage über die Programmstruktur zulassen. Daher sollte man bei längeren Assemblerpro-grammen aussagekräftige Label verwenden. Die Wirkung des Programms ist in folgenderAbbildung dargestellt.

RSPalt

01 ρ(1)

100 ρ(100)

M−1

RSPneu

0 =1 neu ← ρ(1)alt +ρ(2)alt + · · ·+ρ(100)alt

= = heißt unveränderter Inhalt

100 =

M−1 =

3.3.2 Endlichkeit der realen Maschine

Wir betrachten zunächst die Berechenbarkeit, die auf der Endlichkeit einer realenMaschine basiert. Jede Rechenspeicherzelle ist endlich groß, daher ist auch jedes Pro-grammspeicherwort endlich groß. Diese obere Schranke soll nicht vergrößert werdenkönnen (etwa durch längere Worte).

Die Information einer Rechenspeicherzelle sei o.B.d.A. eine ganze Zahl, die kleinstedarstellbare Zahl sei mit MINZAHL und die größte darstellbare Zahl mit MAXZAHLbezeichnet.

Ein Programm, dasM Speicherzellen verwendet, ist auffassbar als Abbildung

f : D→ D′, wobeiD,D′ ⊆ [MINZAHL : MAXZAHL ]M


Beispiel: Additionsprogramm

Das vorige Additionsprogramm hatte 100 Eingangsargumenteund 1 Ausgangswert, alsogilt hierD = [MINZAHL : MAXZAHL] 100 undD’ = [MINZAHL : MAXZAHL] 1.

Satz: Realisierbarkeit von Abbildungen durch Programme

Jede Abbildungf : D→ D′ mit D,D′ ⊆ [MINZAHL : MAXZAHL]M ist realisierbar durchein Programm, welches (außer Steuerbefehlen wie START, STOP,. . .) auskommt mit:

α = ρ(i) für i, j ∈ [0, . . . ,M−1]ρ( j) = α i und j sind absolute Adressen, keine Variablenα = k k ist Konstanteα = α±1 In-/Dekrementierung des Akkumulatorinhaltsif α < 0 then goto jif α = 0 then goto jif α > 0 then goto j

Dieses Programm kommt insbesondere ohne indirekte Adressierung und miteinemsehr kleinen Befehlssatz aus.

Beweis:

Beweis (für jedes Programm, also für jede Abbildungf ):Die Abbildung f bewirkt: f (ρ(0)alt , . . . ,ρ(M−1)alt) = (ρ(0)neu, . . . ,ρ(M−1)neu),wobei:ρ(k)neu= hk(ρ(0)alt , . . . ,ρ(M−1)alt). Das heißt, der neue Wert ergibt sich aus denalten Werten (im Extremfall aus allen alten Werten).

Beispiel: voriges Additionsprogramm

k 6= 1: ρ(k)neu= hk(. . .) = ρ(k)alt

k = 1: ρ(1)neu= h1(ρ(1)alt , . . . ,ρ(100)alt) = ρ(1)alt + . . .+ρ(100)alt

also:

h1(ρ(1)alt , . . . ,ρ(100)alt) =

5050 fallsρ(i)alt = i, 1≤ i ≤ 100

0 falls ρ(i)alt = 0, 1≤ i ≤ 100

. . . andere Fälle

Die Programmwirkung ist also beschreibbar durch Abbildungenh0,h1, . . .hM−1.

Abbildung3.3zeigt, wie die Eingangsargumenteρ(i)alt schichtweise im Baum abge-fragt werden. Somit ist jede Kombination von Eingabeargumenten durch einen Pfadim Baum gegeben. An den Blättern erhält man aufgrund der Funktionenh1 bishM−1

und der durch den Pfad gegebenen Eingangswerte die Ausgabeargumente.

Das folgende Programm realisiert diese schichtenweise Abfrage der Eingangsargu-mente im Wesentlichen unter Verwendung bedingter Sprünge. Die Ausgabeargumen-te werden im letzten Abschnitt des Programms eingetragen.

Sei zur Abkürzung: MINZAHL =−Q und MAXZAHL = +Q.

0: α = ρ(0)1: if α = 0 then goto [ Stufe 2 , Wert 0] Label mit Nummer 4Q+12: if α < 0 then goto (2Q+2)3: α = α−1

3.3. Leistungsfähigkeit von Adressiertechniken 41

(0)

(1) (1) (1)

(2)

(M-1)

=Maxzahl=Minzahl

Stufe 1:

Abfrage von(0)

alt

=Minzahl

Eintragen

h0(Min,…,Min,Min)

h1(Min,…,Min,Min)

.

.

.

hM-1

(Min,…,Min,Min)

Eintragen

h0(Min,…,Min,Min,Max)

h1(Min,…,Min,Min,Max)

.

.

.

hM-1

(Min,…,Min,Min,Max)

=Maxzahl=Minzahl

=Minzahl+1

Stufe M:

Abfrage von(M-1)

alt

Abbildung 3.3: Algorithmus zur Berechnung vonh0,h1, . . .

4: if α = 0 then goto [ Stufe 2 , Wert 1]5: α = α−16: if α = 0 then goto [ Stufe 2 , Wert 2].2Q: if α = 0 then goto [ Stufe2 , Wert Q - 1]2Q+1: goto [ Stufe 2 , Wert Q]2Q+2: α = α+12Q+3: if α = 0 then goto [ Stufe 2 , Wert - 1].4Q -1: if α = 0 then goto [ Stufe 2 , Wert - Q + 1]4Q: goto [ Stufe 2 , Wert - Q]4Q+1 [ Baumorganisat ion Stufe 1 , 2 , . . . , M]

Letzte Stufe zur Eintragung der Ergebnisse :

α = h0(−Q, . . . ,−Q) zum Beispiel : α = +17ρ(0) = αα = h1(−Q, . . . ,−Q) zum Beispiel : α =−3ρ(1) = α.α = h(M−1)(−Q, . . . ,−Q)

ρ(M−1) = α.α = h0(−Q,−Q,−Q,−Q+1)ρ(0) = α.


3.3.3 Beliebig große Funktionswerte sollen berechenbar sein

Ein Beispiel ist die Addition beliebig großer Zahlen. Das Programm ist jetzt eineAbbildung:

f : [MINZAHL : MAXZAHL]∗→ [MINZAHL : MAXZAHL]∗

Das * zeigt an, dass es beliebig viele Rechenspeicherzellen gibt.

Satz: Indirekte Berechnung von Abbildungen durch Programme

Es gibt Abbildungen, die nur durch Programme mit indirekterAdressierung berechenbarsind.

Diese Programme enthalten also Befehle der Artρ(ρ(i)) = α oderρ(γ) = α.

Beweis:

Ein Programm ohne indirekte Adressierung spricht nur festeRechenspeicherzellen durchBefehle der Formρ(i) = α an. Jedes Programm P hat eine maximale, von ihm angespro-chene Rechenspeicheradresse ADMAX(P). Hinter ADMAX(P) kann im Rechenspeichernichts geändert werden. Daher sind alle Probleme, die hinter ADMAX(P) etwas ändern,von P nicht bearbeitbar.

Beispiel: Beispiel für Existenz solcher Probleme

Suche die erste 0 im Rechenspeicher und ersetze sie durch 1.Hier kann nämlich die erste 0 hinter ADMAX(P) liegen.Annahme: Es existiere ein Programm P ohne indirekte Adressierung.Man betrachte die Rechenspeicherbelegung, bei der keine 0 in den Speicherzellen mit einerAdresse kleiner/gleich ADMAX(P) steht.Für diese Speicherbelegung versagt das SuchprogrammP.Also ein Widerspruch.Mit indirekter Adressierung geht es sehr einfach:

1 γ =−12 γ = γ+13 α = ρ(γ)4 if ( α 6= 0) then goto 15 ρ(γ) = 16 HALT

3.4 Unterprogramme

Beim Programmaufbau aus Modulen werden oft benutzte Teile alsUnterprogramm(UP) zusammengefasst. Diese können auch in Form einerUnterprogrammbiblio-thek abgerufen werden, was der Wiederverwendbarkeit dient. In diesemAbschnittwerden nun Probleme aufgezeigt, die sich bei der Handhabung solcherUnterpro-gramme auf maschinennaher Ebene ergeben.

Ein Unterprogramm habe die folgende Form:

3.4. Unterprogramme 43

Name, Parameter← Aufruf.

UP ..

Ergebnisse → Rücksprung

Unterprogramme sind möglicherweise mehrstufig verschachtelt, das heißt, einUnter-programm ruft ein anderes oder sich selbst auf. Einen Ablauf einer solchen Aufruf-kette zeigt die Abbildung3.4.

Hauptprogramm

Z e i

t

UP1

UP2

UP3

UP4

UP5

UP6

Abbildung 3.4: Aufruf und Beenden von Unterprogrammen

Die Pfeile→ kennzeichnen die Unterbrechung des Unterprogramms der Ebenei undden Aufruf des Unterprogramms der Stufe(i + 1). Die Pfeile in umgekehrter Rich-tung zeigen die Beendigung des Unterprogramms der Stufe(i +1) und den Wieder-eintritt in das aufrufende Unterprogramm der Stufei an.

Ein Problem ist es nun, die richtige Einsprungstelle für den Wiedereintritt zuverwal-ten. Die unterschiedlichen Techniken bedingen folgende Kategorien vonUnterpro-grammen.

3.4.1 Einstufige, nichtrekursive Unterprogramme

Die Speicherposition des aufrufenden Programms wird im Registerδ gespeichert.Ein Unterprogrammaufruf durch call legt die Adressse descall -Befehls, alsodes aufrufenden Programms, inδ ab. Einreturn aus dem Unterprogramm führt zueinem Sprung an die nächste Adresse nach der geretteten Programmadresse inδ.

Weil nur eine Zelle (Register) zur Verwaltung der Adresse des aufrufenden Pro-gramms verwendet wird, kann auch nur eine Verzweigung in ein Unterprogrammdurchgeführt werden. Daher nennt man diese Programme einstufig. Insbesondere istRekursion unmöglich (siehe Abbildung3.5).


Unterprogramm

j: .

.

.

.

.

return

k: call j

.

.

.

Seiteneffekt: =k; goto j

Seiteneffekt: goto

Abbildung 3.5: Einstufiger Unterprogrammaufruf

3.4.2 Mehrstufige, nichtrekursive Unterprogramme

Bei dieser Technik hat jedesUnterprogramm eine eigene Rücksprungadresse. Sieist an einer speziellen Stelle dessen gespeichert und gibt an, an welcherStelle indem aufrufenden (Unter-) Programm fortzufahren ist, wenn das aufgerufene Unter-programm selbst beendet ist. In Abbildung3.6 ist diese Rücksprungadresse an derersten Stelle des aufgerufenen Unterprogramms abgelegtρ( j).

i: call j

.

.

.

j: [Zunächst frei für Rücksprungadresse]

j+1: Start UP

.

.

.

return

Wirkung: (i):=i+1; goto j+1;

d.h. rette Rücksprungadresseim ersten (dafür frei zuhaltenden) UP-Befehl

Wirkung: goto (j)

Abbildung 3.6: Mehrstufiger Unterprogrammaufruf

Eine Voraussetzung für die Funktionsfähigkeit dieser Technik bestehtdarin, dass dasUnterprogramm sich nicht selbst aufruft (reentrent ist); in diesem Fallewürde dieRücksprungadresse überschrieben werden.

3.4.3 Mehrstufige, eventuell rekursive Unterprogramme

Zunächst wird ein Beispiel eines typischen rekursiven Unterprogrammsgegeben. Eshandelt sich um die rekursive Berechnung der Fakultätsfunktion(n!).

1 int fakultaet ( int n) {

3.4. Unterprogramme 45

2 if (n ==0 || n ==1) {3 return 1;4 }5 else {6 return n* fakultaet (n -1);7 }8 }

Ein Aufruf von f (n) = f akultaet(n) zieht die folgende Kette von rekursiven Unter-programmaufrufen nach sich:

f (n)ruft auf−→ f (n−1)

ruft auf−→ f (n−2)ruft auf−→ . . . f (1)

f (n)zurück←− f (n−1)

zurück←− f (n−2)zurück←− . . . f (1)

Die Technik des letzten Abschnitts ist nicht anwendbar, da nur eine Speicherzelle fürdie Rücksprungadresse vorgesehen ist. An dieser Stelle müssten also beliebig vieleStellen für Rücksprungadressen zur Verfügung stehen, anhand derer man ablesenkann, welche die nächste Rücksprungadresse ist. Hierfür eignet sichder Stack, wobeidie letzte Rücksprungadresse das Topelement ist.

Rekursive Aufrufe werden also über einenStackmit den Operationen Push und Popverwaltet, wobei folgende Register verwendet werden.

• δ1: Register, dessen Inhalt auf die oberste Stackposition (Topelement) zeigt(fürPush und Pop).

• δ2: Befehlszählregister(enthält Adresse des aktuellen Befehls).

• RL: Das so genannteLinkageregister ist ein beliebiges Register zum Auslesender Parameter im Unterprogramm und Speichern der Rücksprungadresse.

Der call - undreturn -Befehl haben dann die Wirkung:

• call RL,dst [push RL; RL = δ2 +1; goto dst]

• return RL [pop RL; δ2 = RL]

Dabei istdst die erste Adresse des aufgerufenen Unterprogramms:

dst :<Unterprogramm - Anweisungen >

Der call -Befehl sichert den aktuellen Wert des Linkageregisters auf dem Stack undsetztRL auf die Adresse des ersten Parameters.

Das Unterprogramm liest die Parameter mittels Autoinkrementadressierung über RL,so dassRL anschließend auf den nächsten Befehl zeigt. Dieser ist die Rücksprung-adresse. Derreturn -Befehl setzt das Befehlszählregister auf die Rücksprungadresseund holt den alten Wert vonRL vom Stack.


Eine andere Organisationsform für die Verwaltung der Ein- und Ausgabeparameterverwendet zwei besondere Register:REING undRRESULT sollen die Rechenspeicher-adressen enthalten, in denen die Eingangsparameter beginnen beziehungsweise abwo die Ergebnisse zurückzuschreiben sind. Diese müssen (bei Aufruf des Unterpro-gramms) geeignet vorbesetzt werden. Die Eingangsparameter werden sofort über-nommen (das heißt, es ist hierfür kein Stack notwendig).RRESULT wird über einenStack verwaltet. Der zugehörige Unterprogrammaufruf sieht schematischwie folgtaus.

Hauptprogramm..Vorbesetzung RResult

PUSH RResult→ ResultstackVorbesetzung REING

call dst [ Wirkung α = δ2 +1;Pushα→ Rücksprungstack ]..- - -----dst :α = REING

Übernahme Eingangsargumente..α = Oberstes Element Resultstackα = ρ(α)Übergabe Ergebnisse

return [ Wirkung : α =Oberstes Element des Rücksprungstacks ;goto α]

REING und RRESULT verweisen auf den Beginn der Eingangs- bzw.Ergebnispara-meterblöcke.

Damit man weiß, wie viele Argumente zu übergeben sind, kann man in der erstenZelle dieser Bereiche jeweils die Anzahl der zu übergebenden Parameterplus dieLänge selbst speichern.

REING k=LängeArgument 1Argument 2

...Argumentk−1

...RRESULT k = 2

Ergebnis

KAPITEL 4

Bausteine und Komponenten vonRechensystemen

In diesem Kapitel wird die rechnerinterne Verarbeitung von Informationen mittelsSchaltungen, SchaltkreisenundSchaltwerkenbetrachtet.

4.1 Schaltfunktionen, Bausteinsysteme und Boolesche Algebra

Die Aufgabe einer Schaltung besteht in der Transformation (binär dargestellter) Ein-gangssignale in (binär dargestellte) Ausgangssignale. Eine Schaltung istdaher miteinem Programm vergleichbar, mit dem Unterschied, dass die Transformation durchdie Schaltung fest verdrahtet ist. Eine Schaltfunktion beschreibt die Zuordnung vonAusgangswerten zu Eingangswerten.

Beispiel: LED-Dezimalzähler

Als erstes Beispiel für eine Schaltung wird ein LED-Zähler betrachtet. Der LED-Zählerbesteht aus 7 Strichen, die leuchten oder nicht leuchten.

x 0

x 1

x 2

x 4

x 5

x 6

x 3

Beispielsweise lässt sich die 7 durch Aufleuchten der Striche x0,x5 undx6 darstellen. Diesentspricht dem Setzen von Bits(x0,x1, . . . ,x6) = (1,0,0,0,0,1,1). Dem entsprechend istder 4(0,1,0,1,0,1,1) zugeordnet. Ein LED-Zähler soll nun von 0 bis 9 mod 10 zählen.Ermuss also zur aktuellen Zahli (Eingangswert) den Nachfolger(i +1) mod 10 (Ausgangs-wert) erzeugen, wie folgende Abbildung veranschaulicht.

47

48 Kapitel 4. Bausteine und Komponenten von Rechensystemen

Schaltung, Schaltkreis, Schaltznetz

x 0

x 1

x 2

x 3

x 4

x 5

x 6

x 0,Neu

x 1,Neu

x 2,Neu

x 3,Neu

x 4,Neu

x 5,Neu

x 6,Neu

Definition: Schaltung

Die Wirkung einerSchaltungwird durch einen-stelligeSchaltfunktion mit k Ausgängenbeschrieben.

f : Bn−→ Bk mit B = {0,1}

n -stellige Schaltfunktion

x 0

x n-1

y 0

y k-1

Möglicherweise kann nur ein Teil aller denkbaren Eingangssignale (Kombinationenderxi in Form von(x0,x1, . . . ,xn−1) vorkommen. In diesem Fall gilt:f : Bn⊃D→Bk.

Auf dem EingangsbereichBn\D ist dieSchaltfunktion undefiniert und somit in ihrenAusgangswerten frei wählbar. Diesen Bereich bezeichnet man auch als Don’t Care-Bereich.

Beispiel: Schaltfunktion

Beim LED-Zähler werden nur 10 Kombinationen der 27 möglichen benutzt. Es ist zumBeispiel dem Leuchten der Striche drei, vier und sechs keineZahl sinnvoll zuzuordnen.

Einen-stelligeSchaltfunktion kann in Form einer Tabelle angegeben werden, indemman in die linke Spalte die definierten Eingangswerte und in die rechte Spalte die dieFunktion definierenden Ausgangswerte schreibt:

Eingänge Ausgängexn−1, . . . ,x0 yk−1, . . . ,y0

0. . .0 . . ....

... 2n Zeilen inklusive Don’t Cares1. . .1 . . .

4.1. Schaltfunktionen, Bausteinsysteme und Boolesche Algebra 49

Im Falle, dass die Funktionn-stellig und jede Komponente binär ist, sind maximal 2n

Werte des Definitionsbereichs und dem entsprechend viele Ausgangswerte denkbar.

Beispiel: Rückwärtszähler im 3-Excess-Code

Die folgende Tabelle zeigt die Schaltfunktion für einen Rückwärtszähler im3-Excess-Code, der in Abschnitt2.4 eingeführt wurde. Die Aufgabe besteht in der Beschreibungder Funktion:

f : B4 → B4

[i]3-Excess 7→ [(i−1) mod 10]3-Excess

Dezimaler Wert x3 x2 x1 x0 y3 y2 y1 y0 Dezimaler Wert

0 0 0 1 1 1 1 0 0 91 0 1 0 0 0 0 1 1 02 0 1 0 1 0 1 0 0 13 0 1 1 0 0 1 0 1 24 0 1 1 1 0 1 1 0 35 1 0 0 0 0 1 1 1 46 1 0 0 1 1 0 0 0 57 1 0 1 0 1 0 0 1 68 1 0 1 1 1 0 1 0 79 1 1 0 0 1 0 1 1 8

0 0 0 00 0 0 10 0 1 0 Don’t Care1 1 0 1 Werte1 1 1 01 1 1 1

Eine Schaltfunktion mit k Ausgängen ist darstellbar durchk Schaltfunktionen aufdem gleichen Definitionsbereich mit je einem Ausgang:

f : Bn→ Bk entspricht

f0 Bn→ B...

fk−1 Bn→ B

Aus diesem Grund kann man sich auf Schaltfunktionen mit einem Ausgang beschrän-ken.

4.1.1 Entwurf und Realisierung von Schaltfunktionen

In diesem Abschnitt werdenBausteineeingeführt, die es gestatten, binäre Eingangs-werte in binäre Ausgangswerte zu überführen. Man kann sie als Operationen aufBauffassen. Es bestehen nun die Fragen

• WelcheBausteinesind notwendig, um bestimmte Eigenschaften derSchalt-funktion wiederzugeben?


• Wie kann man eine Schaltfunktion mit möglichst wenigen Bausteinen darstel-len, um den Realisierungsaufwand und damit die Kosten gering zu halten?

Dabei soll der Entwurf möglichst systematisch sein. Besonders einfacheSchaltfunk-tionen lassen sich als Grundbausteine (Bausteinfunktionen) zur Zusammensetzungkomplexerer Funktionen verwenden. In der folgenden Tabelle sind einige Symbolefür solche Grundbausteine dargestellt.

Name Definition Symbol

Konjunktion(AND)

ANDn : Bn→ BAND(x0, . . . ,xn−1) = 1⇔x0 · . . . ·xn−1 = 1

Disjunktion (OR)

ORn : Bn→ BOR(x0, . . . ,xn−1) = 0⇔x0 + . . .+xn−1 = 0

Negation (NOT)NOT : B→ BNOT(x) = 1−x = x

NAND

NANDn : Bn→ BNAND(x0, . . . ,xn−1) = 1⇔x0 · . . . ·xn−1 = 0

NOR

NORn : Bn→ BNOR(x0, . . . ,xn−1) = 1⇔x0 + . . .+xn−1 = 0

XOR

XORn : Bn→ BXOR(x0, . . . ,xn−1) = (x0 + . . . + xn−1)mod 2

EQUIV EQUIVn : (x0, . . . ,xn−1) = XORn

Schwellenelemente

σk : Bn→ Bσk(x0, . . . ,xn−1) = 1⇔x0 + . . .+xn−1≥ k

Die XOR-Funktion (auchEXOR) kann als Parityfunktion verwendet werden, wiezum Beispiel im Abschnitt über Darstellung von Zeichen in Kapitel2 beschrieben.Die EXOR-, NOT- und EQUIV -Funktion sind keine Schwellenelemente. Für daslogischeAND schreibt man∧, ∩ oder·. Das OR wird als∨, ∪ oder+ geschrieben.AND bindet stärker als OR.

Definition: Bausteinsystem

Eine Menge vonBausteinfunktionen, aus denen sich beliebige Schaltfunktionen zusam-mensetzen lassen, heißtBausteinsystem.


Beispiel: Einige Bausteinsysteme

Bausteinsystem Nachweis

{AND2,OR2,NOT} Disjunktive und konjunktive Normalform{AND2,NOT} OR2(x,y) = NOT(AND2(NOT(x),NOT(y))){OR2,NOT} AND2(x,y) = NOT(OR2(NOT(x),NOT(y))){NAND2} NOT(x) = NAND2(x,x),AND2 = NOT(NAND2){NOR2} Analog zu{NAND2}{AND2,XOR2,1} Komplementfreie Ringsummenentwicklung{σk,NOT} σ1 = ORn,σn = ANDn

Schaltfunktionen lassen sich mit diesen Grundbausteinen zu beliebigen neuen Schalt-funktionen zusammensetzen.

Zusammensetzung Neue Schaltfunktion Definition

f g

x 0 x n-1

x 0 x n-1

f g ( f ·g) : Bn→ B( f · g)(x0, . . . ,xn−1) =AND2( f (. . .),g(. . .))

f g

x 0 x n-1

x 0 x n-1

f+ g ( f ∪g) : Bn→ B( f ∪ g)(x0, . . . ,xn−1) =OR2( f (. . .),g(. . .))

f

x 0 x n-1

x 0 x n-1

f

f (x0, . . . ,xn−1) = NOT( f (. . .))

Definition: Gleichheit von Schaltfunktionen

Zwei Schaltfunktionenf : D→ B und g : D→ B heißen genau dann gleich, wenn sie füralle zulässigen Argumentkombinationen das gleiche Ergebnis liefern:

f = g⇔ f (x0, . . . ,xn−1) = g(x0, . . . ,xn−1) für alle (x0, . . . ,xn−1) ∈ D

Eigenschaften des Zusammensetzungsprozesses von Schaltfunktionen:

f ∧g = g∧ f F1: Kommutativität f ∨g = g∨ f( f ∧g)∧h = f ∧ (g∧h) F2: Assoziativität ( f ∨g)∨h = f ∨ (g∨h)f ∧ (g∨h) = ( f ∧g)∨ ( f ∧h) F3: Distributivität f ∨ (g∧h) = ( f ∨g)∧ ( f ∨h)f ∧ ( f ∨g) = f F4: Absorbtion f ∨ ( f ∧h) = ff ∧ (g∨ g) = f F5: Komplement f ∨ (g∧ g) = f

Definition: Boolesche Algebra

Eine MengeA mit drei Operationen


• · : A×A→ A

• + : A×A→ A

• ¯ :A→ A

heißtBoolesche Algebra(A, ·,+, ¯) genau dann, wenn die Axiome F1 bis F5 erfüllt sind.

Hieraus kann man folgern, dass die Menge der Schaltfunktionen mit den OperationenAND2, OR2 undNOT eine Boolesche Algebra bilden.

Es sind auch andereAxiomensystemedenkbar, wie zum Beispiel eines, welchesdie Kommutativität(K), die Distributivität(D), das neutrale Element(N) und dieKomplementfunktion (C) umfasst. Dabei gibt es Entsprechungen zwischen(K) undF1 sowie(D) und F3. Die anderen Axiome lauten:

(N) Es gibt neutrale Elemente 0,1∈ A mit f +0 = f und f ·1 = f

(C) Die Komplementfunktion zuf erfüllt: f + f = 1 und f · f = 0 für alle f ∈ A

Satz: Äquivalenz zwischen Axiomensystemen

Die Axiome F1 bis F5 sind äquivalent zu den Axiomen(K), (D), (N) und(C).

Andere Bausteinsysteme verwenden die Schaltfunktionen 0 und 1.

0 : Bn→ B mit 0(x0, . . . ,xn−1) = 0

1 : Bn→ B mit 1(x0, . . . ,xn−1) = 1

für alle (x0, . . . ,xn−1) ∈ Bn

Andere Beispiele für Boolesche Algebren sind:

• Aussagenkalkül, wobei eine Aussage den Wahrheitswertwahr oder falschannimmt. Dabei lassen sich Aussagen wie Schaltfunktionen zusammensetzen.

• Mengenalgebramit den Operationen Durchschnitt, Vereinigung und Komple-mentmenge.

Satz: Satz von Stone

Jede endliche Boolesche Algebra(A, op 1, op 2, op 3) ist isomorph zu einer Mengenalge-bra(℘(M),∪,∩, ¯). Das heißt, es gibt eine Bijektionϕ : A→℘(M) mit

ϕ(x op 1 y) = ϕ(x)∪ϕ(y)

ϕ(x op 2 y) = ϕ(x)∩ϕ(y)

ϕ( op 3 x) = ϕ(x)

Beachten Sie, dass℘(M) die Potenzmenge vonM ist.

Die folgende Skizze veranschaulicht die Aussage des Satzes, wobei hier beispielhaftop 1 und∪ aufgeführt werden.


x,yϕ−−−−→ ϕ(x),ϕ(y)

y op 1

y∪

x op 1yϕ−−−−→ ϕ(x)∪ϕ(y)

Das Diagramm ist kommutativ: man kann in derMengenalgebraebenso rechnen wiein der AlgebraA. Daher kann man alle Eigenschaften endlicher Boolescher Mengenals Eigenschaften von Mengenalgebren interpretieren. Dies kann dem leichteren Ver-ständnis von Aussagen dienen.

Beispiel: Schaltfunktion vs. Boolesche Algebra

Die Aussage(F3)DUAL f ∨ (g∧ h) = ( f ∨ g)∧ ( f ∨ h) wird in der folgenden Abbildungdeutlich.

g

h

f

Weitere Eigenschaften endlicher Boolescher Algebren sind somit aus Axiomen oderauch durch mengentheoretische Interpretation herleitbar, wie etwa:

a∧0 = 0 a∨1 = 1

a∧a = a a∨a = a

a∧b = a∨ b a∨b = a∧ b (Gesetz von de Morgan)

a∪b = b⇔a∩b = a⇔

ab = 0⇔a∪b = 1⇔

b⊃ a (mengentheoretische Interpretation)

¯a = a 0 = 1 1 = 0

Eine weitere Folgerung aus dem Satz von Stone ist der folgende Satz.

Satz: Anzahl der Elemente einer Booleschen Algebra

Jede endliche Boolesche Algebra hat eine Elementanzahl, die eine Zweierpotenz ist.


Beispiel: Anzahl der Elemente einer Schaltfunktion

SeiS(D) die Menge dern-stelligen Schaltfunktionen mitD Zeilen:

S(D) = { f | f : Bn⊃ D→ B}

Dann hatS(D) 2|D| Elemente. Diese Elemente stellen alle kombinatorisch denkbaren Wer-tebereiche dern-stelligen Schaltfunktion dar.Beweis: Jede derD Zeilen ist unabhängig von den anderen mit dem Ausgangswert 0bezie-hungsweise 1 besetzbar. Insbesondere gilt:S(Bn) = 22n

. Sein= 2, so ergeben sich 222= 16

Schaltfunktionen, wie in folgender Tabelle aufgeführt:

x1 x0 f0 f1 f2 f3 f4 f5 f6 f7 f8 f9 f10 f11 f12 f13 f14 f15

0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 10 1 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 11 0 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 11 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

Die Funktionenf0 bis f15 tragen ihrer Bedeutung nach folgende Namen:

Funktion Bezeichnung

f0 NULLf1 ANDf2 x→ yf3 Projektion aufxf4 y→ xf5 Projektion aufyf6 XORf7 ORf8 NORf9 EQUIVf10 Projektion auf ¯yf11 y→ xf12 Projektion auf ¯xf13 x→ yf14 NANDf15 EINS

Eine 4-stellige Schaltfunktion sei durch die folgende Funktionstabelle gegeben.

x3 x2 x1 x0 f

0 0 0 0 10 1 0 1 00 1 1 0 00 1 1 1 11 0 1 1 0

Mit | D |= 5 gibt es genau 25 = 32 Schaltfunktionenf0, . . . , f31.

4.1.2 Atom, Minterm und Maxterm

In diesem Abschnitt betrachten wir kleinste und größteSchaltfunktionen.


Definition: Atom einer Booleschen Algebra

a∈A mit a 6= 0 heißtAtom einer Booleschen Algebra(A, ·,+, ¯) genau dann, wenna·b=

a odera·b = 0, für alleb∈ A (a·b 6= 0⇒ a·b = a)

Atome einer Booleschen Algebra sind die kleinsten Elemente, die multipliziert miteinem anderen Element entweder das Element selbst oder Null ergeben.In Men-genalgebren℘(A) sind die Atome gerade die einelementigen Mengen mit∩.

Definition: Minterm

Ein Minterm ist eine atomare Schaltfunktion, die an genau einer Stelle 1ist.

Hat eine Schaltfunktion in ihrer Funktionstabelle genau eine 1, so ist sie ein Minterm:

xn−1 . . .x0 f

0. . .0 0...

...... 0

εn−1 . . .ε0 1... 0...

...1. . .1 0

Die Schaltfunktionf hat dann die Form:

f = xε00 ·x

ε11 · . . . ·x

εn−1n−1, wobeixεi

i =

{

xi wenn εi = 1

xi wenn εi = 0


Beispiel: Minterm

Sei die Funktionf4 durch folgende Funktionstabelle gegeben.

x1 x0 f40 0 00 1 11 0 01 1 0

Dann istx1 ·x0 ein Minterm.

Ein zum Minterm dualer Begriff ist der des Maxterms, also der größten Schaltfunk-tion ungleich der 1-Funktion.

Definition: Maxterm

Ein Maxterm ist eine atomare Schaltfunktion, die an genau einer Stelle 0ist.

Eine Schaltfunktion, die in ihrer Funktionstabelle genau eine 0 enthält, ist ein Max-term:

xn−1 . . .x0 f

0. . .0 1...

...... 1

εn−1 . . .ε0 0... 1

...1. . .1 1

Die Schaltfunktionf hat dann die Form:

f = xε00 +xε1

1 + . . .+xεn−1n−1, wobeixεi

i =

{

xi wenn εi = 1

xi wenn εi = 0

Minterme und Maxterme ermöglichen standardisierte Darstellungen von Schaltfunk-tionen, so genannte Normalformen, welche im nächsten Abschnitt vorgestellt wer-den.

4.1.3 Boolesche Ausdrücke

Bisher wurden Schaltfunktionen über Funktionstabellen mit Eingängen(x0, . . . ,xn−1)und Ausgangf (x0, . . . ,xn−1) definiert. Jetzt werdenx0, . . . ,xn−1 und f als Varia-blen interpretiert. Wir gehen also von Schaltfunktionen mit Eingängenx0, . . . ,xn−1

zu Booleschen Funktionen inx0, . . . ,xn−1 über. Da Schaltfunktionen eine BoolescheAlgebra bilden, dürfen wir Boolesche Ausdrücke mit den Rechenregelnder Boole-schen Algebraumformen.


Definition: Boolescher Ausdruck

SeiX = {0,1,x0, . . . ,xn−1} eine Menge von Booleschen Variablen mit den Atomen 0 und1.Die Boolesche Ausdrückek-ter Stufe überX sind dann induktiv wie folgt definiert:

Stufe 0 : Elemente vonXStufe(k+1) : (w0 ·w1 · . . . ·wr−1),

(w0 +w1 + . . .+wr−1) oderw,

wobeiw,wi Boolesche Ausdrücke sind mit maxi(Stufe(wi)) = k und Stufe(w) = k.

Hierbei ist die Stufenzahl gleich der Klammertiefe und gleich der Anzahl hinterein-ander zu durchlaufender AND-, OR- und NOT-Schaltungen.

Zusammenhang zwischen Booleschen Ausdrücken und Schaltfunktionen

Der Zusammenhang zwischen Booleschen Ausdrücken und Schaltfunktionen wirddurch die folgenden Aussagen beschrieben.

a) Jedem Booleschen Ausdruck entspricht eindeutig eine Schaltfunktion

SeiB(X) = {Boolesche Ausdrücke überX = {x0, . . . ,xn−1}},S(Bn) ={Schaltfunktionenf : Bn→ B} und ϕ : B(X)→ S(Bn) eine Abbildung,die wie folgt induktiv definiert ist:

ϕ(0) = NULL NULL ist eine Schaltfunktion: 0ϕ(1) = EINS EINS ist eine Schaltfunktion: 1ϕ(xi) = xi Projektion aufi-te Komponenteϕ((w1·w2)) = AND(ϕ(w1),ϕ(w2))ϕ((w1 +w2)) = OR(ϕ(w1),ϕ(w2))ϕ((w)) = NOT(ϕ(w))

Die Funktionstabelle eines Booleschen Ausdrucks ist eindeutig. Umgekehrt giltdies aber nicht.

b) Zu jeder Schaltfunktion gibt es unendlich viele Boolesche Ausdrücke

Zwei Boolesche Ausdrücke heißen äquivalent, wenn sie dieselbe Schaltfunktiondefinieren. Seiena,b∈ B(X) Boolesche Ausdrücke,a ist äquivalent zub (a≡ b)genau dann, wennϕ(a) = ϕ(b).

Man sieht sofort:a äquivalentb, soferna in b mit Hilfe der Rechenregeln derBooleschen Algebra umwandelbar ist.

Beispiel: Umformungen

x1 ·x2 +x1 · x2 +x1 ·x2

≡ x1 ·x2 +x1 · x2 +x1 ·x2 +x1 ·x2 wegena≡ a+a≡ x1 ·x2 +x1 ·x2 +x1 · x2 +x1 ·x2 wegen(K)≡ (x1 +x1) ·x2 +x1 · (x2 +x2) wegen(D)≡ 1·x2 +x1 ·1 wegena+ a = 1≡ x2 +x1 wegen(K) unda·1 = a≡ x1 +x2 wegen(K)


Hierbei sind alle Booleschen Ausdrücke äquivalent. Außerdem handelt es sichbei dem letzten Ausdruck offenbar um einen besonders einfachen und billig zurealisierendenBooleschen Ausdruck.

c) Aus der Menge der Booleschen Ausdrücke kann man einen suchen,der die Schalt-funktion am billigsten bzw. am schnellsten realisiert.

Um einen Booleschen Ausdruck zu finden, der dem ersten Kriterium genügt, istes erforderlich ein Kostenmaß zu definieren, das eine Entscheidung erlaubt. Umdas zweite Kriterium zu benutzen muss man analog ein Zeitmaß einführen.

Ergänzung für unvollständig definierte Schaltfunktionen

Ist einen-stellige Schaltfunktion nicht auf dem gesamten Bereich definiert, d.h.f :Bn ⊃ D→ B, Bn\D 6= ∅, wenn alsoDon’t Care-Bedingungen vorliegen, dann hei-ßen zwei Boolesche Ausdrücke äquivalent, wenn sie aufD dieselbeSchaltfunktionrealisieren.

Don’t Cares sind beliebig besetzbar, das heißt, man darfMinterme , die sich nurauf Bn\D beziehen (also aufD die Nullfunktion liefern), beliebig hinzufügen oderweglassen.

Zwei Boolesche Ausdrücke liefern dieselbe Schaltfunktionf : D→ B genau dann,wenn sie ineinander überführbar sind.

Beispiel: Schaltfunkion vs. Boolescher Ausdruck

Sei eine Schaltfunktion durch folgende Funktionstabelle gegeben:

x2 x1 x0 f

0 0 0 00 0 1 00 1 0 00 1 1 11 0 0 11 0 1 11 1 0 Don’t Care1 1 1 Don’t Care

Ein Boolescher Ausdruck fürf ist zum Beispiel:

x2x1x0 +x2x1x0 +x2x1x0

Durch Umformungen erhält man einen einfacheren Ausdruck:

4.2. Normalformen 59

≡ x2x1x0 +x2x1x0 +x2x1x0 +x2x1x0 +x2x1x0

Don’t Cares hinzufügen, sie werden mit 1 besetzt

≡ x2x1x0 +x2(x1x0 + x1x0 +x1x0 +x1x0)

≡ x2x1x0 +x2

≡ x2x1x0 +x2 +x2x1x0

Don’t Care hinzufügen

≡ (x2 +x2)x1x0 +x2

≡ x1x0 +x2

Im Beispiel werden Don’t Cares hinzugefügt. Es kann auch sinnvoll sein, sie weg-zulassen. Trivialbeispiel: NULL :D→ B, hier wäre es sinnlos, Don’t Cares auf 1 zusetzen.

4.2 Normalformen

In diesem Abschnitt werden standardisierte Darstellungen von Schaltfunktionen durchBoolesche Ausdrückeeingeführt, die aus einer Funktionstabelle systematisch herge-leitet werden können.

4.2.1 Disjunktive Normalform (DNF)

Hier wird ein Boolescher Ausdruck zu einer Schaltfunktion als Vereinigung derMin-terme dargestellt.

Definition: Einschlägiger Index

Die Zeilennummerε einer Funktionstabelle zu einer Schaltfunktionf heißteinschlägigerIndex zu f : Bn→ B, falls f (ε0, . . . ,εn−1) = 1 ist.

Definition: ε-ter Minterm

Seiε ein Index vonf . Dann heißt die Funktionmε : Bn→ B, definiert durch

mε(x0, . . . ,xn−1) = xε00 ·x

ε11 · . . . ·x

εn−1n−1

ε-ter Minterm von f .Dabei sei

xε jj =

{

x j falls ε j = 1

x j falls ε j = 0


Definition: Disjunktive Normalform (DNF)

Sei I die Menge der einschlägigen Indizes zu einerSchaltfunktion f . Die DisjunktiveNormalform zu f ist dann definiert als Disjunktion vonMintermen[

ε∈I

mε

4.2.2 Konjunktive Normalform (KNF)

Definition: ε-ter Maxterm

Sei ε Index von f : Bn→ B, und seimε der ε-te Minterm von f . Dann heißt die FunktionMε : Bn→ B definiert durch

Mε(x0, . . . ,xn−1) = mε(x0,x1, . . . ,xn−1)

ε-ter Maxterm von f . Kurz schreibt manMε = mε

Eine Schaltfunktion wird als Durchschnitt der Maxterme dargestellt. Sie lässtsichaus der DNF herleiten.

AusNF( f ) =

[{ε| f (ε)=1}

xε00 ·x

ε11 · . . . ·x

εn−1n−1

folgt

NF( f ) =[

{ε| f (ε)=0}xε0

0 ·xε11 · . . . ·x

εn−1n−1 = ∏

{ε| f (ε)=0}xε0

0 ∪xε11 ∪ . . .∪xεn−1

n−1 De Morgan

Somit ergibt sich die konjunktive Normalform fürf :

NF( f ) = ∏{ε| f (ε)=0}

xε00 ∪xε1

1 ∪ . . .∪xεn−1n−1

Definition: Konjunktive Normalform (KNF)

SeiJ = {ε | f (ε) = 0} eine Menge von Indizes zu einer Schaltfunktionf . Die KonjunktiveNormalform zu f ist dann definiert als

KNF( f ) = ∏{ε∈J}

(

xε00 ∪xε1

1 ∪ . . .∪xεn−1n−1

)

Wenn f nur aufD definiert ist, betrachtet man nur die Produkt- bzw. VereinigungsbildungbezüglichD.

4.2.3 Komplementfreie Ringsummenentwicklung (KRE)

Aus der vollständigen disjunktiven Normalform lässt sich eine weitere Normalformherleiten, die aus⊕, · und 1 besteht. Dabei stellt⊕ das Symbol für das Exklusive-Or

4.2. Normalformen 61

dar. 1 ist eine Basisfunktion. Eine Schaltfunktionf hat dann die Darstellung:

KRE( f ) = a0⊕a1 ·x1⊕ . . .⊕an ·xn⊕an+1 ·x1 ·x2⊕an+2 ·x1 ·x3⊕ . . ....

a2n−1 ·x1 · . . . ·xn

mit ai ∈ {0,1}

Es gibt somit 2n Disjunktionsglieder. Ferner gibt es 22nverschiedene Schaltfunktio-

nen, daai entweder mit 0 oder 1 belegt ist. Liegt die disjunktive Normalform einerSchaltfunktionf vor, so erhält man nach folgender Vorgehensweise dieKRE( f ) :

a) Ersetze in DNF∪ durch⊕.

Dies ist erlaubt, da Mintermea,b die Bedingunga·b = 0 für a 6= b erfüllen.

b) Ersetze ¯xi durch (1⊕xi)

c) Ausmultiplizieren

d) Zusammenfassena⊕a = 0;a·a = a

Das Ergebnis ist eindeutig bestimmt und von der oben angegebenen Form. Zum Um-gang mit dem exklusiven Oder⊕ seien folgende Rechenregeln angegeben:

• x⊕1 = x, x⊕0 = x

• x⊕x = 0, x⊕ x = 1

• x⊕y = y⊕x

• x⊕ (y⊕z) = (x⊕y)⊕z

• x · (y⊕z) = x ·y⊕x ·z

• 0⊕0⊕ . . .⊕0 = 0

• 1⊕1⊕ . . .⊕1 =

{

1 wennn ungerade

0 wennn geraden ist dabei die Anzahl der Einsen.

Beispiel: Normalformen DNF, KNF und KRE

Zum Abschluss dieses Abschnitts werden die drei Normalformen durch ein Beispiel illu-striert. Sei hierzu die Schaltfunktion durch folgende Funktionstabelle gegeben:


x2 x1 x0 f

0 0 0 00 0 1 10 1 0 00 1 1 01 0 0 01 0 1 11 1 0 01 1 1 1

Disjunktive NormalformMinterme zu den einschlägigen Indizes sind:

m1(x2,x1,x0) = x2 · x1 ·x0

m5(x2,x1,x0) = x2 · x1 ·x0

m7(x2,x1,x0) = x2 ·x1 ·x0

⇒ DNF( f ) = x2 · x1 ·x0 +x2 · x1 ·x0 +x2 ·x1 ·x0

Konjunktive Normalform

KNF( f ) = (x2 +x1 +x0) · (x2 + x1 +x0) · (x2 + x1 + x0) · (x2 +x1 +x0) · (x2 + x1 +x0)

Komplementfreie Ringsummenentwicklung

KRE( f ) = x2 · x1 ·x0⊕x2 · x1 ·x0⊕x2 ·x1 ·x0

= (1⊕x2) · (1⊕x1) ·x0⊕x2 · (1⊕x1) ·x0⊕x2 ·x1 ·x0

= x2⊕x1 ·x0⊕x2 ·x0⊕x2 ·x1 ·x0⊕x2 ·x0⊕x2 ·x1 ·x0⊕x2 ·x1 ·x0

= x0⊕x1 ·x0⊕x2 ·x1 ·x0

Es gilt: ϕ(DNF( f )) = ϕ(KNF( f )) = ϕ(KRE( f ))

4.3 Synthese von Schaltkreisen, Minimierung

Für jedeSchaltfunktion gibt es unendlich vieleBoolesche Ausdrückeund damitunendlich vieleSchaltkreise, welche sie realisieren.

Beispiel: Darstellung von Schaltfunktionen

x1 ·x2 +x1 · x2 +x1 ·x2 undx1 +x2 sind Ausdrücke für dieselbe Schaltfunktion OR.

Um den einfachsten und billigsten Booleschen Ausdruck und den ihn realisierendenSchaltkreis (bzgl.AND, ORundNOT) zu finden, muss man einKostenmaßdefinie-ren.

Wir setzen dazu (sehr vereinfachend): Kosten Boolescher Ausdrücke = Anzahl derEingänge in AND- beziehungsweise OR-Gatter des entsprechenden Schaltkreises.Die Negationen, Überkreuzungen, Leitungsduplikationen, Leitungslängen, Ausgän-

4.3. Synthese von Schaltkreisen, Minimierung 63

ge, Gatter usw. bleiben unberücksichtigt.

Definition: Kostenfunktion

EineKostenfunktion k : B(X)→ N0 sei definiert durch:

• k(xi) = k(0) = k(1) = 0 (Leitungen sind kostenlos)

• k(w0 + . . .+wr−1) = k(w0 · . . . ·wr−1) = ∑r−1i=0 k(wi)+ r

r = Anzahl der Eingänge in das Gatter dieser Stufe

• k(w) = k(w) (Negation ist kostenlos)

Nach dieser Definition kostet eine Konjunktion (AND) beziehungsweise Disjunktion (OR)mit r Eingängenr Einheiten zuzüglich der Kosten vorgeschalteter Schaltkreise (Gatter).

Beispiel: Kosten von Schaltfunktionen

k(x1 · (x2 +x3) ·x4 +x1) = k(x1 · (x2 +x3) ·x4)+k(x1)+2

= k(x1)+k((x2 +x3))+k(x4)+3+k(x1)+2

= k(x1)+k(x2)+k(x3)+2+k(x4)+3+k(x1)+2

= 0+0+0+2+0+3+0+2

= 7

Wie oben schon erwähnt gibt es zu einer Schaltfunktion unendlich viele BoolescheAusdrückea0,a1, . . . mit ϕ(ai) = f . DasAllgemeine Minimierungsproblem bestehtdarin einen Ausdrucka∗ ∈ ϕ−1( f ) mit den geringsten Kosten bezüglich obiger Defi-nition: k(a∗) ≤ k(b) für alle b∈ ϕ−1( f ) zu finden. Dieses Problem ist bisher jedochungelöst. Deshalb wird im nächsten Abschnitt eine eingeschränkte Variante mit Lö-sungsansätzen vorgestellt.

4.3.1 Eingeschränktes Minimierungsproblem

Das Ziel beim eingeschränkten Minimierungsproblem ist die Bestimmung einer bil-ligsten zweistufigen Realisierung, das heißt, eine Realisierung, bei der nur maximalzwei AND- bzw. OR-Gatter hintereinander durchlaufen werden. Die konjunktive unddie disjunktive Normalform gehören zu diesen zweistufigen Realisierungen.

Im Folgenden beschränken wir uns auf zweistufige Realisierungen, welche aus derdisjunktiven Normalform ableitbar sind. Hierbei wird erst einAND- und dann einOR-Gatter durchlaufen. Solche Realisierungen heißen Polynome.

Definition: Minimalpolynom

P(X) ist die Menge der polynomialen Booleschen Ausdrücke über den Booleschen Varia-blenX = {x0, . . . ,xr−1} :

P(X) = {p | p = a0 + . . .+am−1; p = 1;p = 0 mit ai = xεi0i0· . . . ·xεir−1

ir−1}


ai heißtMonom.Ein billigstes Polynom zur Realisierung vonf heißtMinimalpolynom von f .Ein Monoma heißtImplikant von f genau dann, wennϕ(a)≤ f (≤-komponentenweise)

Beispiel: Minimalpolynom

Sei die Schaltfunktionf durch die folgende Funktionstabelle gegeben.

x2 x1 x0 f ϕ(a1) ϕ(a2)

0 0 0 0 0 00 0 1 0 0 00 1 0 1 0 00 1 1 1 0 01 0 0 1 1 01 0 1 0 0 11 1 0 1 1 01 1 1 0 0 0

Aus der Funktionstabelle folgt:

a1 = x2x1x0 +x2x1x0 = x2x0 unda2 = x2x1x0

a1 ist Implikant von f ; a2 nicht, daϕ(a2(1,0,1)) = 1 � 0 = ϕ( f (1,0,1)).

Alle Minterme zu den einschlägigen Indizes einer Schaltfunktion sind auchImpli-kanten derselben. Kürzere Implikanten überdecken mehr Einsen vonf und sindbilliger als längere. Da ein Polynom vonf gerade eine Überdeckung vonf durchImplikanten ist, werden für eine billige Realisierung kürzeste Implikanten gesucht.

Definition: Primimplikant

a heißtPrimimplikant von f genau dann, wenna Implikant von f und kein Teilmonomvona Implikant ist.

Beispiel: Implikanten von Schaltfunktionen

Seienx ·α ·y undx · α ·y Implikanten vonf . Es gilt also:

ϕ(x ·α ·y)≤ f undϕ(x · α ·y)≤ f

Dann erhält man einen minimalen Implikanten vonf :

⇒ ϕ(x ·α ·y+x · α ·y) ≤ f Kosten: 2· (k(x)+k(y)+k(α))+8⇒ ϕ(x · (α+ α) ·y) ≤ f⇒ ϕ(x ·y) ≤ f Kosten:k(x)+k(y)+2

4.3.2 Quine-McCluskey-Algorithmus

Es wird nun ein Algorithmus vorgestellt, der eine Lösung des eingeschränkten Mini-mierungsproblems ist. Der Algorithmus besteht aus zwei Phasen.

Phase a)Bestimme allePrimimplikanten von f .


Phase b) Setze hieraus eine billigsteÜberdeckungvon f zusammen, das heißt, su-che eine billigste Gesamtüberdeckung derMinterme (ohne jene, die durchDon’t Cares entstanden sind) durch geschickte Auswahl einer Menge von Pri-mimplikanten.

Phase a): Prinzip zum Auffinden von Primimplikanten

Starte mit Mintermen und Don’t Cares vonf . Nutze dabei die Nachbarschaftsbezie-hung – wie oben gezeigtx · y = x ·α · y+ x · α · y – so oft wie möglich aus. DiesesVerfahren liefert alle Primimplikanten.

Zur Systematik:

1. Ersetzexεii durchεi und ergänze fehlende Variablen durch „–“ an der entsprechen-

den Stelle.

x5x3x0 entspricht „0−−1−0“.

2. Nachbarn sind nur in Monomen möglich, die sich bezüglich ihres Gewichts,d.h.der Anzahl der enthaltenen Einsen, um genau Eins unterscheiden. Daher sollteman dieMonomenach dem Gewicht vorsortieren. Dazu kann z.B. dasHamming-Gewicht eines binären Vektorsvi genutzt werden:

Weight= w(v) =n

∑i=1

vi

Phase b): Überdeckung vonf aus Primimplikanten

1. Man erstellt eine Matrix mit

• Primimplikantenp j als Zeilen und

• Mintermenmi der DNF (ohne Don’t Cares) als Spalten.

m1 m2 m3 . . .

p1 1p2 1p3 1... 1

Der Matrixeintraga jr = 1 genau dann, wenn der Primimplikantp j den Mintermmr überdeckt, d.h. der Minterm stimmt in allen Komponenten mit dem Primim-plikanten überein. An Stellen, wo der Primimplikant ein− hat, kann im Minterman gleicher Stelle beliebiges (1 oder 0) stehen.


Beispiel: Überdeckungsmatrix

1−1− überdeckt 1110,1010,1011 und 1111.00− überdeckt nicht 1011, denn es muss gelten:ϕ(a· b)≥ ϕ(a· b·c·d).

Mit a = 1,b = 0,c = 1 undd = 1 ist die „rechte Seite“, aber nicht die „linke Seite“erfüllt.

2. EinPrimimplikant heißt wesentlich genau dann, wenn es einen Mintermmi gibt,der nur von diesem Primimplikanten überdeckt wird. In der entsprechenden Ma-trixspalte befindet sich nur eine 1. Ein wesentlicher Primimplikant muss zumMi-nimalpolynom gehören, er ist unverzichtbar. Alle zusätzlich überdeckten Minter-me der Matrix sind zu streichen, weil sie schon überdeckt sind.

3. Istϕ(mi)≤ ϕ(mj), so streichemj , denn jedeÜberdeckungvonmi liefert mj mit.

. . . mi . . . mj . . .

p1 1 1p2

p3 1 1p4 1...

4. Ist ϕ(pr) ≤ ϕ(ps), wörtlich ps leistet mehr alspr , undk(pr) ≥ k(ps), so streichepr , dennps ist billiger und leistungsfähiger.

m1 m2 m3 . . ....pr 1 1...ps 1 1 1...

Mit den Schritten 2,3 und 4 (evtl. iteriert) wird die Bestimmung einer Überdeckungoft ein eindeutig bestimmter Vorgang. Manchmal müssen aber mehrere Möglichkei-ten geprüft und eine insgesamt billigste Lösung ausgewählt werden.

Beispiel: Gray-Code-Addierer

In diesem Beispiel sollen Boolesche Ausdrücke für die Realisierung eines Addierers zwei-stelliger Gray-Code-Zahlenx1x0 und y1y0 mittels Quine-McCluskey-Algorithmus be-stimmt werden.


x 0 x 1 y 0 y 1

z 0 z 1 c

Die Schaltfunktion sei durch folgende Funktionstabelle gegeben:

x1 x0 y1 y0 c z1 z0

0 0 0 0 0 0 00 0 0 1 0 0 10 0 1 1 0 1 10 0 1 0 0 1 00 1 0 0 0 0 10 1 0 1 0 1 10 1 1 1 0 1 00 1 1 0 1 1 01 1 0 0 0 1 11 1 0 1 0 1 01 1 1 1 1 1 01 1 1 0 1 1 11 0 0 0 0 1 01 0 0 1 1 1 01 0 1 1 1 1 11 0 1 0 1 0 1

Schaltfunktion und Minimalpolynom für c:Sei In die Tabelle der Implikanten der Längen, wobei sich die Länge aus der Anzahl an0-en und 1-en ergibt. Die Minterme sind in der Tabelle zeilenweise nach Gewicht sortiert.

I4 I3 I21001 10−1 1−1−1010 101−0110 1−10

−1101011 1−111110 111−1111

Man vergleiche jeden Minterm einer Gewichtsgruppe mit jedem der darunter befindlichenGruppe. Falls sich diese an genau einer Stelle unterscheiden, so schreibe man an diese Stelleeinen−: 1001 und 1011 ausI4 führen zu 10−1 in I3. Befinden sich in den Mintermen−,so müssen diese an den gleichen Stellen auftreten: 1−10 und 1−11 ausI3 ergibt 1−1− inI2. Als Primimplikanten erhält man diejenigen Implikanten, welche nicht weiter reduziertwerden können, hier: 10−1,−110 ausI3 und 1−1− ausI2.


Die Überdeckungsmatrix lautet:

1001 1010 0110 1011 1110 1111

10−1 1 1−110 1 11−1− 1 1 1 1

Wie man erkennt, sind alle Primimplikanten wesentlich. DasMinimalpolynom ist also:

MPc = x1 ·y1 +x1 · x0 ·y0 +x0 ·y1 · y0

Schaltfunktion und Minimalpolynom für z1:Zunächst die Primimplikanten ermitteln:

I4 I3 I20010 001− 0−1−1000 0−10 1−0−

1−00100−

1100 110− 11−−0101 11−0 −1−11001 −101 1−−10011 01−1 −−110110 1−01 −11−

10−10−11−011011−−110

1101 11−10111 −1111011 1−111110 111−1111

Überdeckungsmatrix:

0010 1000 1100 0101 1001 0110 0011 1011 1101 0111 1110 1111

0−1− 1 1 1 11−0− 1 1 1 111−− 1 1 1 1−1−1 1 1 1 11−−1 1 1 1 1−−11 1 1 1 1−11− 1 1 1 1

Wesentliche Primimplikanten sind: 0−1−,1−0− und−1−1. Sie überdecken alle Min-terme bis auf 1011 und 1110. Nach Streichen der bisher überdeckten Minterme bleibt:


1011 1110

11−− 11−−1 1−−11 1−11− 1

Jede Überdeckung benutzt zwei Primimplikanten und ist gleich teuer, so dass die Wahlbeliebig ist.Das Minimalpolynom hat die Form:

MPz1 = x1 ·y1 +x1 · y1 +x0 ·y0 +Y

mit Y ∈ {x1 ·x0 +x1 ·y0,x1 ·x0 +y1 ·y0,x0 ·y1 +x1 ·y0,x0 ·y1 +y1 ·y0}Schaltfunktion und Minimalpolynom für z0:Die Primimplikanten ergeben sich durch folgende Tabelle:

I4 I30100 010−0001 −100

0−0100−1

0101 11−00011 101−1100 1−101010 −01110111110

Alle Implikanten der letzten Spalte sind Primimplikanten.Überdeckungsmatrix:

0100 0001 0101 0011 1100 1010 1011 1110

010− 1 1−100 1 1

0−01 1 100−1 1 111−0 1 1101− 1 1

1−10 1 1−011 1 1

In jeder Spalte stehen zwei, d.h. mehr als eine, Einsen, alsoliegt kein wesentlicher Pri-mimplikant vor. Da kein Primimplikant wesentlich ist (allegleich teuer), beginnen wir mit010−:


0100 0001 0101 0011 1100 1010 1011 1110

010− 1 1−100 1 1

0−01 1 100−1 1 111−0 1 1101− 1 1

1−10 1 1−011 1 1

Von 101−, 1−10 und−011 wählt man 101−, weil dieser Primimplikant 1010 und 1011überdeckt und diejenigen Minterme, welche 1− 10 und−011 überdecken, bereits abge-deckt sind. Wesentliche Primimplikanten sind somit: 010−,00−1,11−0 und 101−. Aus-gehend von 010− (entsprichtx0) ergibt sich folgendes eindeutiges Minimalpolynom:

MPz0 = x1 ·x0 · y1 + x0 · x0 ·y0 +x1 ·x0 · y0 +x1 · x0 ·y1

Beginnt man mit−100 statt mit 010−, dann entsteht in eindeutiger Weise:

MPz0 = x0 · y1 · y0 + x1 · y1 ·y0 + x0 ·y1 ·y0 +x1 ·y1 · y0

Beide Minimalpolynome sind gleich teuer.

4.3.3 Karnaugh-Diagramme

Ein Karnaugh-Diagramm (siehe Abbildung4.1) einer Booleschen Funktionf : Bn→B mit n ∈ {3,4} ist eine graphische Darstellung der Funktionstabelle vonf durcheine Matrix der Größe 2×4 für n = 3 bzw. 4×4 für n = 4, deren Spalten mit denmöglichen Belegungen der Variablenx0 undx1 und deren Zeilen mit den Belegungender Variablenx2 (n = 3) bzw. x2 und x3 (n = 4) beschriftet sind. Die Reihenfolgeder Beschriftung erfolgt so, dass sich zwei zyklisch benachbarte Zeilen/Spalten nurin genau einer Komponente unterscheiden (Gray-Code).

x 1 x 0 00

00

01

01

11

11

10

10

x 3 x 2

x 1 x 0 00

0

01

1

11 10 x 2

Abbildung 4.1: Karnaugh-Diagramme

4.4. Schaltwerke und Speicherelemente 71

Vorgehen zur Bestimmung eines Minimalpolynoms

• An den Matrixelementen, deren Beschriftung eineinschlägiger Indexfür dieFunktion f ist, eine 1 eintragen.

• Maximale 1-er-Blöcke der Form 2s×2r finden, so dass jede 1 mindestens ein-mal überdeckt ist. Dabei müssen auch zyklische Überdeckungen beachtet wer-den.

• Summe über den Termen, die den Blöcken entsprechen, bilden.

• Falls möglich, zusätzlichDon’t Cares ausnutzen, indem im ersten Schritt inden entsprechenden Feldern auch der Wert 1 zugeordnet wird. Damitsind mehrEinsen vorhanden und evtl. größereResolutionsblöckemöglich. Don’t Caresbrauchen allerdings nicht vollständig überdeckt zu werden.

Beispiel: Karnaugh-Diagramm

1

1

1 1

1 1

1

1

D D

x 1 x 0 00

0

01

1

11 10 x 2

x 1 x 0 00

00

01

01

11

11

10

10

x 3 x 2

1

D

1 D

x 1 x 0

x 2 x 1

x 2 x 0

x 2 x 1 x 0

f 1 = x 1 x 0 + x 2 x 1 f 2 = x 2 x 0 + x 2 x 1 x 0

4.4 Schaltwerke und Speicherelemente

Die bisherigen Betrachtungen waren weitgehend theoretischer Natur. Für die Reali-sierung von Schaltfunktionen wurde der Begriff des Booleschen Ausdrucks einge-führt sowie eine Minimierung dessen bezüglich einer einfachen Kostenfunktion. DesWeiteren wurden Schaltkreise betrachtet, wobei die Zeit außerhalb der Betrachtungblieb. In diesem Abschnitt wird eineTaktung eingeführt, um dieSchaltfunktion inihrer Realisierung alsSchaltwerk zu diskreten Zeitpunkten auf die Eingangsargu-mente anzuwenden.


Definition: Schaltkreis und Schaltwerk

Schaltkreisebestehen aus Eingangsleitungen,Schaltnetzund Ausgangsleitungen.Schalt-werke bestehen aus Schaltkreisen, Speicherelementen und Taktleitungen (siehe Abbil-dung4.2)

Schaltkreise

Speicher- elemente

Takt sonstige Eingangs- leitungen

sonstige Ausgangs- leitungen

Abbildung 4.2: Schaltkreis und Schaltwerk

Schaltwerke befinden sich zu gegebener Zeit in einem ZustandQ. Ein solcher Zu-stand ist etwa durch die Werte der Ausgangsleitungen zu diesem Zeitpunktcharakte-risiert. Zustände ändern sich nur zu bestimmten diskreten Zeitpunkten, bei Eintreffeneines Taktes (siehe Abbildung4.3), das heißt, wenn eine 1 auf der Taktleitung anliegt.

1

0

T

T=1

T=0

Flanke

Zeit

Abbildung 4.3: Takt

4.4.1 Speicherelemente

BinäreSpeicherelementesind kleinste logische Bausteine zur Aufbewahrung (Spei-cherung) einer Information. Es wird hier nur einer der Zustände 0 oder1 gespeichert.Sie sind als Schaltwerke realisiert. Dabei ist ein ZustandQ(n) durch den gespeichertenWert und durch die Werte auf den Ausgangsleitungen imn-ten Taktzyklus bestimmt.


Der gespeicherte Wert steht über eine Ausgangsleitung zur Verfügung; meist gibt eseine zusätzliche Leitung, an derQn anliegt.

RS-Flipflop

Dieses Speicherelement besitzt zwei besondere Eingänge zum Setzen (auf 1; Set) undRücksetzen (auf 0; Reset) des Inhalts (siehe Abbildung4.4). Der NameFlipflop rührtvon der Geräuschentwicklung der ersten Relais-Schaltwerke her, die zur Realisierungvon Speicherelementen verwendet wurden.

Q (n)

R S

T

Q (n+1)

Abbildung 4.4: RS-Flipflop

Sei dasRS-Flipflop durch folgende Funktionstabelle beschrieben.

R S Qn+1

0 0 Qn

0 1 11 0 01 1 Don’t Care

SeiT derTakt mit den beiden Zuständen:

T Auswirkung

0 Zustand ändert sich nicht1 Zustand kann sich ändern

Unter Einbeziehung des jeweils aktuellen ZustandesQ(n) ergibt sich folgende Tabellefür die Schaltfunktion vonQ(n+1), wenn ein Takt anliegt(T = 1), sonst(T = 0) ändertsich nichts:


R S Qn Qn+1

0 0 0 00 0 1 10 1 0 10 1 1 11 0 0 01 0 1 01 1 0 Don’t Care1 1 1 Don’t Care

Die Schaltfunktion fürQ(n+1) ergibt sich zu

Q(n+1) = T ·Q(n) +T · (S+ R·Q(n)) (Torschaltung, if T = 0 then. . . else. . . )

= T ·Q(n) +T ·S+T · R·Q(n) + T · R·Q(n)

= T ·Q(n) +T ·S+ R·Q(n)

= (T + R) ·Q(n) +T ·S

= (T ·R) ·Qn ·T ·S (NAND−Darstellung)

Analog lässt sich fürQn+1 eine Schaltfunktion angeben

Qn+1 = (T ·S) ·Qn · (T ·R)

R T S

Q Q

Abbildung 4.5: Schaltung des RS-Flipflops

Entscheidend für die Speichereigenschaft des Elements ist dieRückkopplung inner-halb der Schaltung (siehe Abbildung4.5). Der konstante WertQ zirkuliert, solangeT nicht geändert wird. In Abbildung4.6sind zwei unterschiedliche Symbole für dasRS-Flipflop dargestellt.


R T S

Q Q

RS-FlipFlop

S

T

Q

Abbildung 4.6: Schaltsymbole für das RS-Flipflop

Earle Latch

Beim Earle Larch handelt es sich um ein vereinfachtes Speicherelement (siehe Ab-bildung4.7). Es speichert den alten Zustand solangeT = 0 und übernimmt den neuenZustand von der EingangsleitungD, sobaldT = 1. Dabei darf sichD nicht ändern,währendT = 1 ist.

Earle Latch

T

Q

D

Abbildung 4.7: Earle Latch

Q(n+1) =

{

Qn falls T = 0

D falls T = 1

Die Schaltfunktion wird durch folgenden Booleschen Ausdruck beschrieben:

Q(n+1) = T ·Q(n) +T ·D= T ·Q(n) +T ·D+D ·Q(n)

D ·Q(n) ist mathematisch gesehen überflüssig, da er in den beiden anderen Termenabgedeckt wird. Er wird jedoch für die technische Realisierung — insbesondere imHinblick auf denTakt — benötigt (siehe Abbildung4.8).


T D

Q

Abbildung 4.8: Schaltung des Earle Latch

Verwendung des ZusatztermsD · Q(n):Hierfür sind zwei Gründe zu nennen:

1) Hazards

Eine Realisierung wird nie perfekt dem theoretischen Modell genügen. So könnenbei der Taktung Ungenauigkeiten (Laufzeitunterschiede) auftreten (siehe Abbil-dung4.9).

T

Zeit

Es kann kurzzeitig sein! T=T=0

Abbildung 4.9: Hazards

2) Nicht perfekteTaktflanken

Ein weiteres Problem besteht darin, dass die Taktflanken, die beim Wechsel desTaktes vonT = 0 aufT = 1 entstehen, nicht senkrecht sind. Daher ist die Interpre-tation des Wertes vonT ungenau über eine Zeitspanne nicht vernachlässigbarerLänge (siehe Abbildung4.10).


Zeit

T=0 T undef. T=1

Abbildung 4.10: Taktflanke

OhneD ·Q(n) könnte nach der ersten Taktphase(T = 1) kurzzeitigT = T = 0 geltenund damitQ(n+1) = T ·Q+ T ·D = 0 unabhängig vonD, in der zweiten Taktphase(T = 1) gilt: Q(n+1) = T ·Q∪T ·D = 0 (unabhängig vonD).

KAPITEL 5

Die Arithmetisch-Logische Einheit

In diesem Kapitel werden Rechenwerke für dieAddition , Multiplikation undDivi-sion besprochen. Dabei werden insbesondere für die Addition verschiedene Metho-den vorgestellt.

Zentraler Bestandteil derArithmetisch-Logischen Einheit (Arithmetic-Logical Unit,ALU ) ist eine schnelle Hardware zur Ausführung der arithmetischen Grundfunktio-nen

• Addition (Subtraktion)

• Multiplikation

• Division

Interessant sind neben der Ausführungsgeschwindigkeit auch die Kosten dieserRe-chenwerke. Beide Kriterien lassen sich durch die Wahl geeigneter Methoden zurAddition, Multiplikation und Division entscheidend beeinflussen.

Die einfachsteAdditionsmethodebei Stellenwertcodierung im 2-Komplement istaus der Schule bekannt. Man addiert zwei ganzzahlige,n-stellige Summanden kom-ponentenweise und reicht den Übertrag zur nächsten Komponente weiter:

Summand 1: an−1 an−2 . . . a0

Summand 2: bn−1 bn−2 . . . b0

Summe: sn−1 sn−2 . . . s0

Ein Addierwerk, das diese Methode realisiert, ist in Abbildung5.1zu sehen.

Beispiel: Addition nach Schulmethode

1 0 1 1 0+ 1 0 0 1 1

(1) 0 1 0 0 1

79

80 Kapitel 5. Die Arithmetisch-Logische Einheit

+

b0a0

s0c0

+

b1a1

s1c1

+

bn-1an-1

sn-1=cn-1sn

...

Abbildung 5.1: Addition nach Schulmethode

5.1 Addition und Subtraktion

Im Folgenden werden zunächst mit demHalbaddierer (Halfadder, HA ) und demVolladdierer (Fulladder, FA) zwei Additionskomponenten eingeführt, aus denensich viele Rechenwerke zusammensetzen lassen. Einige dieser Rechenwerke werdendann im Anschluss diskutiert.

5.1.1 Halbaddierer

HA

ba

sc

Abbildung 5.2: Symbol für einen Halbaddierer

Der Halbaddierer wird als Schaltkomponente durch das in Abbildung5.2dargestellteSymbol notiert. Er besitzt zwei Eingängea undb, für welche die Summes und derÜbertragc (Carry) berechnet werden soll. Um den Halbaddierer durch eine Schaltungzu realisieren, sollen zunächstBoolesche Ausdrückefür c unds entwickelt werden.Deren Funktionstabellen sind gegeben durch:

a b s c

0 0 0 00 1 1 01 0 1 01 1 0 1

5.1. Addition und Subtraktion 81

Hieraus ergeben sich dieMinimalpolynome als

c = a·bs = a·b+a·b ( ≡ a⊕b )

Obwohl es sich um eine Minimalpolynomdarstellung handelt, ist diese Darstellungnicht kostenminimal:

Übertragc SummesLaufzeit (Gatterstufen) 1 2Kosten nach Def. aus Kap.4 (Zahl der Eingänge) 2 6

Eine bessere Realisierung wird erreicht durch:

s= a·b+a·b≡ (a+b) · (a+b)≡ (a+b) ·c, dac = a·b

Man beachte, dass es sich nicht um einMinimalpolynom handelt, weil kein klam-merfreier Ausdruck vorliegt.

Übertragc SummesLaufzeit (Gatterstufen) 1 2Kosten nach Def. aus Kap.4 (Zahl der Eingänge) 2 4

DerHalbaddierer lässt sich somit durch die in Abbildung5.3dargestellteSchaltungrealisieren.

ba

sc

Abbildung 5.3: Schaltung für den Halbaddierer

5.1.2 Volladdierer

DerVolladdierer verfügt über einen weiteren Eingangcin. Dieser ist verwendbar, umeinenÜbertrag aus der Summierung der vorhergehenden Komponenten zu verarbei-ten. Wie in Abbildung5.4 gezeigt, kann ein Volladdierer durch zwei Halbaddiererrealisiert werden (Klammerung:(a+b)+cin).


ba

s

HA1 FA

HA2

cin

cout

ba cin

scout

Abbildung 5.4: Schaltung und Schaltsymbol eines Volladdierers

Die Kosten ergeben sich aus den Kosten derHalbaddierer und des zusätzlichenOR-Gatters:

KostenFA = 2·KostenHA +2 = 14

Die Laufzeit hängt ebenso von der der Halbaddierer ab und beträgt 4 Stufen, wennalle Eingänge gleichzeitig anliegen, oder 2 Stufen, wenncin später eintrifft.

Logik des Volladdierers

Als Boolesche Ausdrückefür den Übertrag und die Summe erhält man:

cout = 1 ⇔ a+b+cin ≥ 2

s= 1 ⇔ a+b+cin = 1 mod 2

also:

cout = a·b+(a⊕b) ·cin

= a·b+(a+b) ·cin

s = (a⊕b)⊕cin

= a·b·cin +a·b·cin +a·b·cin +a·b·cin

Die Kosten betragenk(s) = 16, das heißt dieser Ausdruck ist für eine praktischeRealisierung nicht empfehlenswert.

5.1.3 Carry-Ripple-Addierer

DerCarry-Ripple-Addierer ist einAddierwerk , welches gemäß Abbildung5.5ausn in Serie geschalteten Volladdierern aufgebaut ist. Es handelt sich um einen Paral-leladdierer.


Addiert wird in der 2-Komplement-Darstellung. EineSubtraktion kann ebenfallsdurchgeführt werden, indem alle Bits des zweiten Summandenb gekippt undc−1 auf1 gesetzt werden. Also:a+b setztc−1 := 0 unda−b setztc−1 := 1 voraus.

b0a0

s0

bn-2an-2

sn-2

bn-1an-1

sn-1

...

c-1

FA0FAn-2FAn-1

Abbildung 5.5: Carry-Ripple-Addierwerk

Logik

DerBoolesche Ausdruckfür den Übertragci zumVolladdierer FA(i+1) lautet:

ci = ai ·bi +(ai⊕bi) ·ci−1

= ai ·bi +(ai +bi) ·ci−1

Sei zur Abkürzung:ki := ai ·bi (Konjunktion ) unddi := ai +bi (Disjunktion ) defi-niert.

Dann hat der Boolesche Ausdruck die Form:

ci = ki +di ·ci−1

Die verwendeteRekursionsformel hat ihren Start mitc−1 und ist eine Funktion derForm

ci = f (ki ,di ,ci−1, . . . ,c−1) für i = 0, . . . ,n−1.

Laufzeit

Die Rekursionsformel zeigt, dass sich Zwischenergebnisse durch Eintreffen einesÜbertrags von rechts ändern können. Dies führt in der Schaltung zu einer Laufzeit-erhöhung. Diemaximale Laufzeit beträgt etwa 2·n Gatterstufen. Dies ist der Fall,wenn ein Übertrag ganz rechts entsteht und durch alle Stellen propagiert(fortgeleitet)wird.

Beispiel: Subtraktion mit hoher Laufzeit


Seib= (000101011) vona= (100101011) zu subtrahieren. Also istc−1 = 1,bwird gekipptund aufa addiert (2-Komplement):

1 0 0 1 0 1 0 1 1+ 1 1 1 0 1 0 1 0 0 c−1 = 1

(1) 1 0 0 0 0 0 0 0 0

Eine Propagationskette ist ein Abschnitt zwischen zwei Stellen, an denen beideSummanden die gleichen Werte haben. Innerhalb einer solchen Kette wird einauf-tretender Übertrag weitergeleitet. Beim Komponentenpaar (0,0) wird der Übertragaufgefangen und beim Paar (1,1) entsteht sowieso ein Übertrag, d.h. ankommenderein Übertrag von rechts muss nicht mehr weitergeleitet werden.

Beispiel: Propagationsketten

Die Zahlen(0101101101) und(0110100111) haben folgende Propagationsketten:

2 34

0

0

1

1

1

0 1

0 1

1

0

0 1

0 1

1

1

0

1

1

2 3

Die Laufzeit beträgt 4· 2+ 2, da die maximale Propagationskette die Länge 4 hat. Diezusätzliche 2 ergibt sich aus der Tatsache, dass der rechteVolladdierer zwei Gatterstufenmehr braucht.

Falls 0 und 1 gleich häufig und unabhängig voneinander auftreten, gilt: DieLängeder längsten Propagationskette ist im Mittel log2(n) und im schlechtesten Falln lang.

5.1.4 Serieller Addierer

Die serielle Addition entspricht dem handschriftlichen Addieren mit Übertrag. Die-sesAddierwerk enthält nur einenVolladdierer , in den dien-stelligenBinärzahlenkomponentenweise geleitet werden. In jedem Takt werden Komponentenai und bi

addiert, die berechnete Summenkomponentesi gespeichert und ein gegebenenfallsentstehenderÜbertrag c bei der Addition der Komponentenai+1 und bi+1 berück-sichtigt. Realisiert werden kann ein solches Addierwerk gemäß Abbildung5.6, alsomit einem Volladdierer, zwein-stelligen Schieberegistern und einem 1-stelligen Re-gister zur Aufnahme des Übertrags.

.....a0an-1

cFA.....b0bn-1

.....s0sn-1

Abbildung 5.6: Serielles Addierwerk


Mikroprogramm

Der Vorgang des seriellen Addierens lässt sich durch ein so genanntesMikropro-gramm beschreiben. Sei hierzuZ eine Zählvariable, welche dieTakte zählt. Siewird mit n initialisiert. Die SteuervariableV gibt an, ob eine Addition(V = 0) oderSubtraktion(V = 1) durchgeführt werden soll, wodurch eine Berechnung in der 2-Komplement-Arithmetik realisiert wird. Zu beachten ist, dass die in eckigen Klam-mern stehenden Befehle eines Mikroprogramms parallel ausgeführt werden, also ineinemTakt .

Mikroprogramm: Serielle Addition

0 : [ ( an−1 . . .a0) := Summand1 ;( bn−1 . . .b0) := Summand2 ;Z := n; c := V ]

1 : [ bi := bi⊕V , für i = 0, . . . ,n−1 ]// falls V=1 wird b komponentenweise gekippt// => Subtr. im 2-Komplement

2 : [ ai := ai+1; bi := bi+1 ( für i = 0, . . . ,n−2)// => Rechtsshift von a und bc := cFA( a0 , b0 , c); an−1 := sFA( a0 , b0 , c);Z := Z -1; bn−1 := 0 ]

3 : if Z > 0 thengoto 2

4 : Stop

In Programmzeile 2 werden(2·n+2) Operationenparallel ausgeführt.

Beispiel: Serielle Addition

Seiena = (011) undb = (010) zu addieren:1.Takt (Z=3)

011010 c = 0

2.Takt (Z=2)1 | 010 | 01 c = 0

3.Takt (Z=1)01 | 000 | 0 c = 1

Ergebnis (Z=0)101000 c = 0


5.1.5 Von-Neumann-Addierer

Bei demVon-Neumann-Addierwerk handelt es sich um ein einfaches getaktetesParalleladdierwerk (siehe Abbildung5.7). Es ist ausn parallel arbeitenden Halbad-dierern aufgebaut. JedemHalbaddierer sind die Registerai undbi zugeordnet. DasRegister 1(an−1 . . .a0) dient der Speicherung der Zwischensumme. Es enthält auchdie Endsumme. Das Register 2(bn−1 . . .b0) speichert die von den Halbaddierern ge-bildeten Überträge.

Summen und Überträge derHA werden solange in die Register 1 beziehungsweiseRegister 2 zurückgeschrieben, bis Register 2 den Wert Null enthält.

HA

an-1

HA HA HA

c

...

an-2 a1 a0

b0b1bn-2bn-1

Abbildung 5.7: Von-Neumann-Addierwerk

Beispiel: Von-Neumann-Addition mit Dezimalzahlen

Sei dieses Verfahren auf zwei Dezimalzahlen angewandt. Siebefinden sich in den zweiRegistern:

a = (98725)

b = (17282)

Es ergeben sich folgende Registerinhalte, wobei die Berechnung einer Stelle mit Übertraghervorgehoben ist:

a 9 8 7 2 5b 1 7 2 8 2a 0 5 9 0 7b 1 1 0 1 0 0a 1 1 5 0 0 7b 0 0 1 0 0 0a 1 1 6 0 0 7b 0 0 0 0 0 0

Seien W(a) und W(b) die Dezimalwerte der Inhalte der Registera undb. Das Ver-fahren ist korrekt, weil die Invarianzeigenschaft W(a)+W(b) = Summenwert unab-


hängig vom aktuellen Takt gilt. Das Verfahren terminiert, weil pro Takt mindestensein Bit des Registersb zu Null wird. Man kann zeigen, dass wenn Nullen und Einsenin a undb gleichverteilt und unabhängig voneinander sind, das Verfahren im Mittelnach log2n Takten stoppt. Es benötigt maximal(n+1) Takte.

Bei derSubtraktion im 2-Komplement werden alle Bits vonb gekippt und im zwei-ten Takt wirdb0 = 1 gesetzt.

Beispiel: Binäre Von-Neumann-Addition

Für a = (11110101)2 = (−11)10 undb = (11100101)2 = (−27)10 ist a−b zu berechnen.Hierzu wirdb zunächst invertiert:b′ = (00011010)2.Nach von-Neumann:

Takt 1 1111010100011010————

Takt 2 1110111100100001 c−1 = 1, da Subtraktion im 2-Komplement————

Takt 3 1100111001000010————

Takt 4 1000110010000100 Gesamtübertrag ignorieren (2-Komplement)————

Takt 5 0000100000001000————

Takt 6 0000000000010000————

Takt 7 00010000 Die Summe hat den Wert W(a) = 16.00000000 Stopp, weil Register 2 den Inhalt(0. . .0) hat.

Realisierung und Ablaufsteuerung durch ein Mikroprogramm

Wie für dieserielle Addition wird nun für die Von-Neumann-Addition einMikro-programm angegeben. Anschließend wird dieses in einer Diodenmatrix fest verdrah-tet. Das Programm addiert (bzw. subtrahiert) binäre Zahlen in der 2-Komplement-Darstellung. Um Überläufe zu erkennen, wird das Vorzeichen verdoppelt. Wiederumwerden die in eckigen Klammern stehenden Befehle parallel ausgeführt.

Mikroprogramm: Von-Neumann-Addition

0 : [ A=( an−1 . . .a0) := Summand1 ;B=( bn−1 . . .b0) := Summand2 ;V := 0 , fal ls Addit ion ; V := 1 , fal ls Subtrakt ion ]

1 : [ bi := bi ⊕ V für i = 0, . . . ,n−1 ]// falls V=1 wird b komponentenweise gekippt

2 : if B ∪ V 6= 0 then[ ai := ai ⊕ bi für i = 0, . . . ,n−1;


bi+1 := ai · bi für i = 0, . . . ,n−2;b0 := V ; V := 0; goto 2 ]

else[ V := an−1 ⊕ an−2; goto 3 ]

3 : if V 6= 0 thengoto 5

4 : Stop ohne Überlaufwarnung5 : Stop mit Überlaufmeldung

Ablaufsteuerung

Für die Steuerung des Ablaufs eines Programms in hardwarenaher Formsind folgen-de Schritte umzusetzen:

a) Es muss festgestellt werden, welcherTakt vorliegt.

b) Es muss erkannt werden, welcher Teiltakt vorliegt (und welche Bedingungen auf-grund der Registerzustände gegeben sind).

c) Es ist die Nummer des folgenden Taktes zu berechnen.

d) DieMikrooperationen (Mikrobefehle) sind auszuführen.

e) Die durch die Mikrooperationen beeinflussten Register sind zu takten.

Taktmatrix Steuermatrix Bedingungen DecodierungAdresse

Folgeadresse

Befehlsausführung Eingabe Startadresse(zu Beginn)

Abbildung 5.8: Ablaufsteuerung

Ablaufsteuerungen werden durchDiodenmatrizenoderPLA ’s (Programmable Lo-gic Array) realisiert. Dies sind Felder sich kreuzender Leitungen (siehe Abbildung5.9).Die Ausgangsleitungen stehen orthogonal zu den Eingangsleitungen. Eingangswertewerden mittels spezieller Dioden auf die Ausgangswerte umgesetzt. Der verknüp-fende Kreis zwischen Eingangs- und Ausgangsleitungen bildet ein OR, das heißt,eine auf der Eingangsleitung anliegende Eins wird auf die gesamte Ausgangsleitungübertragen. Der Strich hingegen hat den Charakter eines logischen AND: Die Aus-gangsleitung hat nur dann den Wert Eins, wenn mindestens alle über den Strich ansie angeschlossenen Eingangsleitungen eine Eins haben.

Diesen Schritten sind in einer fest verdrahteten Realisierung eines Mikroprogrammsfolgende Teilmatrizen zugeordnet (siehe Abbildung5.8):


Eingangsleitungen

= Und = Oder

(Keine Diode am Kreuzungspunkt => keine Wirkung)

a

b

c

d

e

Abbildung 5.9: Dioden

a) Decodiermatrix

b) Bedingungsmatrix

c) Adressmatrix für die Codierung der nächsten Programmadresse

d) Steuermatrix

e) Taktmatrix

Als Beispiel wird nun das Mikroprogramm derVon-Neumann-Addition in eineDiodenmatrix umgesetzt (siehe Abbildung5.10). Man trägt Bedingungen im Pro-gramm in dieBedingungsmatrix ein und verknüpft sie als Eingänge mit den verti-kalen Eingangsleitungen.

Zu den Eingängen zählen auch die Leitungen der Decodiermatrix. Sie liefern die Pro-grammadresse desMikroprogrammbefehls . Auch sie werden über Und-Dioden mitden vertikalen Leitungen verknüpft. Die Verknüpfungspunkte entsprechen dabei derbinär codierten Adresse. Zu den Ausgangsleitungen zählen die Taktmatrix, Steuer-matrix und die Adressmatrix.

Die Leitungen dieser Matrizen werden über Oder-Dioden mit den vertikalenEin-gangsleitungen verknüpft. Die Adressmatrix dient der Bestimmung der folgendenProgrammadresse. In der Steuermatrix werden die Mikrooperationen derMikropro-grammzeile angestoßen. Die Taktmatrix liefert den Takt für die in den angestoße-nen Befehlen verwendeten Register. Die Ausgangsleitungen der letzten drei Matrizensind deswegen durch Oder-Dioden mit den vertikalen Leitungen verknüpft, weil nureine vertikale Leitung eine Eins zu führen braucht, um einen Mikroprogrammbefehlzu realisieren.


Taktmatrix(Takten derangesprochenenRegister)

Signal “Überlauf”

Signal “kein Überlauf”

b := V0

V := 0

V := a aÅn-1 n-2

b := a bii+1 . i

a := a bii iÅ

b := b Vii Å

V = 0

ÈB V = 0

TA

TB

TV

x0

x1

x2

B := Summand 2

A := Summand

0 1 2,then2,else

3,then3, else

4 5

Steuermatrix(Anstoß zumAusführen derangesprochenenMikrooperationen)

Adressmatrix(BerechnungFolgeadresse)

Bedingungsmatrix

x x x = 000012

Decodiermatrix:

Anfangsbesetzung(hier nicht gezeigt):

d.h. Startadresse = 0

Taktnummer (Adresse)

Abbildung 5.10: Diodenmatrix

5.1.6 Erweiterungen des Von-Neumann-Addierers

In diesem Abschnitt wird die Von-Neumann-Addition derart erweitert, dass manmehrere Summanden addieren kann. Dies wird durchPipelining oder Parallelität(Adder-Tree) realisiert. Abbildung5.11zeigt eine abkürzende Notation eines Von-Neumann-Addierwerks, die im Folgenden verwendet werden soll.

Carry-Save-Addierer

Eine erste Erweiterung besteht darin, im Von-Neumann-Addierer dieHalbaddierergegenVolladdierer auszutauschen. Aufgrund des somit gewonnenen Eingangs (sie-he Kurznotation in Abbildung5.12, insgesamt hat man nun 3·n Eingänge und 2·nAusgänge) ist es möglich, nach jedemTakt einen neuen Summanden in dasAddier-


HA HA... HA-Feld

AB

C S

von-Neumann Kurznotation

Abbildung 5.11: Kurznotation des Von-Neumann-Addierers

werk einzubringen.

FA-Feld

neuer Summand(pro Takt je ein neuer Summand)

Abbildung 5.12: Carry-Save-Addierer

Das erhaltene Volladdiererfeld wird alsCarry-Save-Addierer (CSA) bezeichnet (inder Kurznotation werden zur Vereinfachung auch Einfachpfeile verwendet). Die Ad-dition vonm Zahlen ist nun inm Takten möglich, wenn man diese wie folgt in denAddierer einbringt:

Takt 1: Die ersten drei Summanden werden bearbeitet.Takt 2: Summanden 1 bis 4 werden bearbeitet.

...Taktm−2: Summanden 1 bis m werden bearbeitet.Taktm−1: Auslaufen der Addition nach Von-Neumann-Addition

Taktm: Abhängig von der Länge der größtenPropagationskette,weiteres Auslaufen der Addition;bei Wortlängen im Mittel (log2n) Takte.

EineAnwendungbesteht in der konventionellen Multiplikation durch eine Folge von


Additionen (Schulmethode), wie im Abschnitt über die Multiplikation näher nochbe-schrieben wird. Zur Verdeutlichung dieses Prinzips soll an dieser Stelle die folgendeSkizze genügen:

• • • • • • •• • • • • • •

• • • • • • •• • • • • • •

• • • • • • •Produkt • • • • • • • • • • • •

Adder-Tree (Wallace Tree)

Um einenAdder-Tree zur parallelen (und somit beschleunigten) Addition aufzu-bauen, bedarf es der Verwendung mehrererCSAs, die miteinander verschaltet sind.Hierzu wird dieTaktung aufgetrennt und es werden so viele CSAs hintereinanderge-schaltet, wie aufgrund der Summandenzahl erforderlich ist (siehe Abbildung5.13).

CSA

neuer Summand

Takt

Summands2 s3s1

s4

sm

CSA2

CSAm-2

abschließendeAddition

CSA1

...

Abbildung 5.13: Lineare Verschaltung von CSAs

Auf diese Weise hat man bezüglich der Laufzeit keinen Gewinn gemacht. Ordnet man


jedoch die CSAs in einem Baum an, so ist es möglich, die Addition in jeder Schichtdes Baums parallel durchzuführen (siehe Abbildung5.14).

Adder Tree

...

...

Beispiel: m=12

CSAc s

Abbildung 5.14: Wallace Tree

Die Laufzeitdes Adder-Trees fürm Summanden ergibt sich aus der Tatsache, dassim Wesentlichen durch jeden CSA 3 Eingänge auf 2 Ausgänge abgebildet werden,wobei jedoch die Anzahl der Eingänge nicht immer ein Vielfaches von 3 seinmuss.

Sei m die Anzahl aller Eingänge (an den Blättern des Baums oben). Dann beträgtdie Anzahl der Ausgänge nach deri-ten Stufe ungefähr(2

3)i ·m. Für die Laufzeitist die Stufenzahlx gesucht, so dass nach derx-ten Stufe zwei Ausgänge vorliegen:(2

3)x ·m= 2.

Man erhält:x · log2(23) = log2(

2m)⇒ x =

log2(m2 )

log2(32)≈ 1,72· log2m.

5.1.7 Carry-Look-Ahead-Addierer

Die bereits kennen gelernteCarry-Ripple-Addition ist langsam, weil sien Vollad-dierer in Serie verwendet. Hierbei entsteht ein Übertragsengpass, weil jeder Voll-addierer auf den Übertrag seines rechten Nachbarn warten muss, um sein korrektesErgebnis bilden und weiterleiten zu können (siehe Abbildung5.5).


Seiendi := ai +bi undki := ai ·bi wiederum als Abkürzungen der Disjunktion bzw.Konjunktion zweier Stellen definiert. Im Abschnitt5.1.3wurde bereits eine Rekursi-onsformel für den Übertrag an der Stellei hergeleitet:

ci = ai ·bi +(ai +bi) ·ci−1 = ki +di ·ci−1

Die Rekursionsformel für den Übertrag wird nun aufgelöst, um die Addition durchdirekte Berechnung des Übertragsci aus den(2 · k+ 1) Wertenci−k,a j ,b j für j =(i−k+1), . . . , i zu beschleunigen:

ci = ki +di ·ci−1

= ki +di · (ki−1 +di−1 ·ci−2)

= ki +di ·ki−1 +di ·di−1 ·ci−2

= . . .

= ki +di ·ki−1 +di ·di−1 ·ki−2 +di ·di−1 ·di−2 ·ki−3 + . . .+di · . . . ·d1 ·k0

+di · . . . ·d0 ·c−1

Für großei ist diese Vorgehensweise zu teuer und unrealisierbar. Daher beschränktman sich auf machbare Gruppen und verknüpft diese nach dem Prinzip der Carry-Ripple-Addition , wie in Abbildung5.15anhand eines 12-stelligen Addierwerks füreine Gruppengröße von 4 gezeigt.

s2s3 s1

c3

Gruppe1Gruppe2 Gruppe0

b0a0b3a3

s0

c7c11

c-1

Abbildung 5.15: Carry-Look-Ahead-Addierer für Gruppengröße 4

Ein Carry-Look-Ahead-Addierer arbeitet im Gegensatz zu einemCarry-Ripple-Addierer also nicht mit einzelnen Bits, sondern mit ganzen Bitgruppen.

Der Übertragc7 beispielsweise hat die Form:

c7 = k7 +d7 ·k6 +d7 ·d6 ·k5 +d7 ·d6 ·d5 ·k4 +d7 ·d6 ·d5 ·d4 ·c3

Die Laufzeit wird jeweils im Worst-Case von 2·n bei derCarry-Ripple-Additionauf 2· ng bei derCarry-Look-Ahead-Addition verringert, wobeig die Gruppengrößeund n

g die Gruppenanzahl ist.n bezeichnet wie oben die Anzahl der Stellen der zu


addierenden Zahlen und somit die Anzahl der Eingänge des Addierers.Sie wird umden Faktor der Gruppengröße verkürzt.

Die erzielte Beschleunigung wird bezahlt durch

• höhere Kosten innerhalb der Gruppen und

• zusätzliche Vorbereitungslaufzeiten, umki unddi bereitzustellen, weil diese so-fort benötigt werden. Diese Vorbereitungslaufzeiten wirken sich allerdings erstdann aus, wenn man das Prinzip auf die 2. Ordnung erweitert, das heißt zur Bil-dung von Supergruppen übergeht, indem manCarry-Look-Ahead-Addiererhintereinanderschaltet.

5.1.8 Carry-Skip-Addierer

Die Carry-Skip-Addition ist eine Verbesserung der Addition nach dem Carry-Look-Ahead-Prinzip. Die aufwändige Schaltlogik derCarry-Look-Ahead-Addition istnicht in jeder derng Gruppen nötig. Man berechnet die Überträge einer Gruppe wie

bei Carry-Ripple in maximal 2·g Gatterstufen und leitet die Überträge beschleunigtdurch einen einfachen Zusatzschaltkreis über die Gruppen hinweg.

Carry-Skip für eine konstante Gruppengröße g

Sei j ∈ {0, . . . , ng−1} der Gruppenindex. Ferner seien folgende Abkürzungen einge-

führt:

• D j := d( j+1)g−1 · . . . ·d jg und

• K j := k( j+1)g−1 +d( j+1)g−1 ·k( j+1)g−2 + . . .d( j+1)g−1 · . . . ·d jg+1 ·k jg

Hierbei sinddi undki wie üblich definiert:

di := ai +bi , ki := ai ·bi

Ist K j = 1, so ist in Gruppej ein Übertrag entstanden. Es gilt für den Gesamtübertagc j der Gruppe j:

c j = K j +D j ·c j−1

Bei Carry-Skip wird ein Übertragc j einer Gruppe wie folgt berechnet, wobei zweiFälle unterschieden werden:

a) D j ·c j−1 = 0 undK j = 1 (Übertrag entsteht erst in Gruppe j): Dann istc j = K j = 1und wird wie bei Carry-Ripple in maximal 2·g Gatterstufen berechnet.


b) D j ·c j−1 = 1 (Übertrag wird weitergeleitet): Hier liegt der für die Gesamtlaufzeitungünstigste Fall vor. Der Übertrag wird mitD j in zwei zusätzlichen Gatterstufenweitergeleitet.

Abbildung5.16zeigt die Schaltung einer Gruppe desCarry-Skip-Addierers .

bjgajg

sjgs(j+1)g-2s(j+1)g-1

...

cj-1

FA1FAg-1FAg

sjg+1

FA2cj Kj

Dj

Abbildung 5.16: Gruppe eines Carry-Skip-Addierers

Betrachten wir nun dieLaufzeit und Kosten des Addierers. Der Worst-Case derLaufzeit liegt dann vor, wenn:

a0 = b0 = 1,c−1 = 0 und für allei = 1, . . . ,(n−2) gilt : ai⊕bi = 1.

Das bedeutet, der Übertrag entsteht nur in Gruppe 0, wird nicht sofortweitergeleitet(daD0 ·c−1 = 0) und läuft maximal lange. In diesem Fall ist die Laufzeit:

τ = 2·g+1 + 2· (ng−2) + 2·g

Berechnung Übertragsweiterleitung Berechnung vonvonK0, c0 über(n

g−2) innere Gruppen sn−1

τmin entsteht als Minimum (nachg ableiten, gleich Null setzen,. . .) für:

g = gopt =

√n2

Man erhält:

τmin = 4·√

2·√

n−3

Die Kosten lassen sich direkt aus der Schaltung ablesen (siehe Abbildung5.16). Zu-sätzlich zu den imVolladdierer enthaltenen OR-Gattern benötigt man pro Gruppeein AND-Gatter mitg Eingängen fürD j und zwei Gatter (OR, AND) mit jeweilszwei Eingängen für die Ermittlung vonc j .

Die KostenkCarry−Skip ergeben sich somit aus den KostenkCarry−Ripple und den Zu-satzkosten der Gatter:

kCarry−Skip= kCarry−Ripple+ng· (g+2·2) = 14·n+n+

4·ng

= 15·n+4·ng


Carry-Skip mit variabler Gruppengröße

Aus dem letzten Abschnitt wird ersichtlich, dass folgender ungünstiger Fall auftretenkann: Der Übertrag entsteht in der Gruppe ganz rechts (in Abbildung5.16), läuftschnell über die inneren Gruppen und langsam in der letzten Gruppe ganz links.

Eine Idee zur Behebung der Laufzeitunterschiede zwischen den an den Rändern undin der Mitte liegenden Gruppen besteht nun darin, kleinere Gruppen an den beidenRändern und höhere Gruppengrößen zur Mitte hin zu wählen. Dabei istzu beachten,dass der Größenunterschied von Gruppe zu Gruppe nicht beliebig seindarf: Fallsdie Gruppengröße um mehr als 1 zwischen zwei benachbarten Gruppendifferiert,entsteht ein anders gearteter ungünstigster Fall.

Beispiel: Laufzeiten bei variabler Gruppengröße

Sei i eine Gruppe der Größei. Unter den Kasten wird die Laufzeit innerhalb der Gruppenotiert. Die Gesamtlaufzeit wird für den Worst-Case angenommen.

Fall 1: Drei gleich große Gruppen7 7 714 2 15 Gesamtlaufzeit: 31

Fall 2: Drei Gruppen abnehmender Größe8 7 616 2 13 Gesamtlaufzeit: 3116 15 Gesamtlaufzeit: 31

Fall 3: Abweichung der Gruppengröße um mehr als 19 7 518 2 11 Gesamtlaufzeit: 3118 15 Gesamtlaufzeit: 33

Somit liegt hier ein neuer Worst-Case vor, wenn man in der zweiten Gruppe beginnt.

Daher darf nur eine Steigerung der Gruppengröße von beiden Rändern nach innenpro Gruppe um jeweils den Wert 1 stattfinden. Dies ist aber nicht für alle Längen zuaddierender Zahlen perfekt möglich: Die Summe der Gruppengrößen mussn erge-ben, und gleichzeitig muss der Addierer laufzeitoptimal sein. Daher müssen am Randgegebenenfalls einzelne Kleingruppen entfernt werden. Einige Beispiele zeigen auch,dass unter Umständen eine Gruppe aus der Mitte wegzunehmen ist.

Beispiel: Beispiele verschiedener Gruppengrößen

Die Gruppen werden mit ihrer Größe in einem Tupel notiert.

1) Fürn = 56 :Hier liegt einer der wenigen optimalen Fälle vor.Gruppengrößen:(1,2,3,4,5,6,7,7,6,5,4,3,2,1)Laufzeit: maximal 29 Gatterstufen.

2) Fürn = 50 :In diesem Fall ist die Aufteilung nicht so günstig möglich. Man kann von der Situationim ersten Beispiel ausgehend die Gruppen an den Rändern entfernen:(3,4,5,6,7,7,6,5,4,3)oder die drei Gruppen ganz links streichen:(4,5,6,7,7,6,5,4,3,2,1)oder die rechten drei Gruppen wegnehmen:


(1,2,3,4,5,6,7,7,6,5,4).In allen drei Fällen hat man die gleiche Laufzeit von 29 Gatterstufen wie bein = 56.

3) Fürn = 44 :Hier liegt ein Fall vor, bei dem man ausgehend von(1,2,3,4,5,6,7,6,5,4,3,2,1) zum einen die Gruppen an den Rändern streichen und diemittlere 7er- gegen eine 6er-Gruppe tauschen sollte:(2,3,4,5,6,6,6,5,4,3)oder an einem Rand Gruppen streicht und in der Mitte zwei Gruppen verkleinert:(3,4,5,6,6,5,5,4,3,2,1).Die Laufzeit beträgt 27 Gatterstufen wie fürn = 49.

Die Laufzeitτn einesn-Bit-Carry-Skip-Addierers mit variabler Gruppengröße istmaximal für:

τn =

{

2· ⌈√

4·n+1⌉−1 fallsm2 < n≤m· (m+1) , m∈ N

2· ⌈√

4·n⌉−1 falls (m−1) ·m< n≤m2 , m∈ N

Insgesamt gilt also:τn≈ 4·√n.

Im Vergleich dazu war die minimale Laufzeit bei konstanter Gruppengröße:

τkonst.min = 4·

√2·√

n−3.

Gemessen in unserem Kostenmaß aus Kapitel4 sind die Kosten fast gleich.

Verallgemeinerungen und Kompromisse

Man kann Gruppen von Carry-Skip-Addierern hintereinander schalten und erhält ei-ne so genannteSupergruppe. Aus mehreren solcher Supergruppen lässt sich danneinCarry-Skip-Addierer zweiter Ordnung zusammensetzen (siehe Abbildung5.17).

Abbildung 5.17: Schaltung zum Carry-Skip-Addierer zweiter Ordnung

Eine Ordnungserhöhung lohnt sich aber nur für sehr große Längender zu addieren-den Zahlen. Sonst fällt der Gewinn geringer aus als der Aufwand für die zusätzliche


Logik, die zur Koordination nötig ist.

Ferner lässt sich auch die Technik desCarry-Skip-Addierers mit der einesCarry-Look-Ahead-Addierers kombinieren (siehe Abbildung5.18). Die Anzahl der zu-sätzlichen Gatter ist hier jedoch größer.

Abbildung 5.18: Kombination von Carry-Skip und Carry-Look-Ahead

5.1.9 Conditional-Sum-Addierer

Wie bei der Carry-Look-Ahead-Addition werden hier ganze Gruppenbearbeitet, al-lerdings in verschiedenen Gruppengrößen, nämlich zuerst in 1er, dann in 2er, 4er,. . .Gruppen. Es findet also immer eine Verdopplung der Gruppengröße statt,die durchdie Zusammenfassung zweier benachbarter Gruppen erfolgt, wie in Abbildung5.19skizziert. Diese Zusammenfassung kann parallel realisiert werden.

Abbildung 5.19: Gruppen bei der Conditional-Sum-Addition

Die Conditional-Sum-Addition zeichnet sich dadurch aus, dass sie bei derZusam-menfassung zweier Gruppen die Entstehung eines Übertrags explizit berücksichtigt.

Eine Gruppe wird durch 4 Einträge repräsentiert:


c0 | S0 ← 0: Kein Carry von rechtsc1 | S1 ← 1: Carry von rechts

mit c0,c1 ∈ {0,1} und S0,S1 ∈ {0,1}∗. Die Länge vonS0 und S1 variiert je nachGruppengröße.

Bei der Betrachtung einer Gruppe werden zwei Fälle unterschieden:

1. Für den Fall, dass die rechte Nachbargruppe keinen Übertrag liefert, lautet dasErgebnis der betrachteten Gruppe (c0,S0), wobeic0 den Übertrag undS0 dieSummenbits darstellen.

2. Für den Fall, dass die rechte Nachbargruppe einen Übertrag weitergibt, lautetdas Ergebnis der betrachteten Gruppe (c1,S1).

Zusammenfassung zweier Gruppen

Die Zusammenfassung zweier Gruppen geht sehr systematisch. Die GruppenA undB werden zu einer neuen GruppeABwie folgt zusammengefasst:

GruppeA GruppeBc0

A | S0A c0

B | S0B ← 0: Kein Carry von rechts

c1A | S1

A c1B | S1

B ← 1: Carry von rechts

Neue GruppeABc0

AB | S0AB ← 0: Kein Carry von rechts

c1AB | S1

AB ← 1: Carry von rechts

Die Länge vonS∗AB ist dabei die Summe der Längen vonS∗A undS∗B.

Betrachten wir zunächst die obere Zeile der neuen Gruppe, d.h. den Fall, in demrechts kein Übertrag anliegt. Als rechte Hälfte der SummenbitsS0

AB können dann dieSummenbitsS0

B der GruppeB übernommen werden. Nun ist zu unterscheiden, obGruppeB einen Übertrag an GruppeA weiterleiten würde, was durchc0

B angezeigtwird. Ist c0

B = 0 werden als linke Hälfte der SummenbitsS0AB die Bits S0

A und alsÜbertragc0

AB das Bitc0A übernommen. Istc0

B = 1 muss für die GruppeA ein einge-hender Übertrag berücksichtigt werden, d.h. als linke Hälfte vonS0

AB wird S1A und als

Übertragc0AB wird c1

A übernommen.

Die untere Zeile der neuen Gruppe ergibt sich analog.


Die formalen Regeln für die Zusammenfassung zweier Gruppen lauten somit (hierbeisei◦ der Konkatenationsoperator):

c0AB =

c0A, falls c0

B = 0

c1A, falls c0

B = 1

c1AB =

c0A, falls c1

B = 0

c1A, falls c1

B = 1

S0AB =

S0A◦S0

B, falls c0B = 0

S1A◦S0

B, falls c0B = 1

S1AB =

S0A◦S1

B, falls c0B = 0

S1A◦S1

B, falls c0B = 1

Oder kürzer (füri ∈ {0,1}):

ciAB = c

ciB

A

SiAB = S

ciB

A ◦SiB

Die Angabe einer Schaltlogik für diese Zusammenfassung ist relativ einfach. In derStufe 0 ist jede Gruppe ein Bitpaar(ai ,bi). Die Gruppengröße ist 1.

Die Logik für die Stufe 0 lautet daher:

c0 = ai ·bi

c1 = ai +bi

S0 = S1

S1 = ai⊕bi⊕1 = ai ·bi +ai ·bi = c0 +c1

Die Logik höherer Stufen bedeutet die Umsetzung der Fallunterscheidungen durcheineTorschaltung:

x :=

α, falls γ = 0

β, falls γ = 1

wird durch die Schaltung

x := γ ·α+ γ ·β


realisiert.

Die Kosten dieser Schaltung nach der Definition aus Kapitel4 betragen 6.

Beispiel: Conditional-Sum-Addition

Die Zahlena = (1101000110) und b = (0101011001) sind zu addieren (cin = 0) bzw. zusubtrahieren (cin = 1).

Stufe 1 1 0 1 0 0 0 1 1 0 a0 1 0 1 0 1 1 0 0 1 b

0 0 1 1 0 0 0 1 0 0 0 0 1 0 1 0 1 0 1 0 1 cin = 01 0 1 1 0 1 1 1 0 1 1 0 1 0 1 0 1 0 1 0 cin = 1

1 1 0 0 0 1 0 0 0 1 0 1 1 0 1 1 cin = 01 0 1 0 1 1 0 1 0 1 0 0 1 0 0 cin = 1

2 1 0 0 0 1 0 0 1 0 1 1 1 1 cin = 01 0 1 0 1 0 1 0 1 0 0 0 0 cin = 1

3 1 0 0 0 1 0 0 1 1 1 1 1 cin = 01 0 1 0 1 0 1 0 0 0 0 0 cin = 1

4 1 0 0 1 0 0 1 1 1 1 1 cin = 01 0 0 1 0 1 0 0 0 0 0 cin = 1

Laufzeitbetrachtungen

Dieser Additionsalgorithmus ist fast optimal, denn es ist beweisbar, dass(log2n) eineuntere Schranke für die Laufzeit der Addition zweier n-stelliger Zahlen ist.

• Man benötigt(⌈log2n⌉+2) Stufen für die Addition, wobei die letzte Stufe fürdie Auswahl des Endergebnisses nötig ist, das heißt, der Summe oder Differenzje nach cin.

• Man braucht 2· (⌈log2n⌉+ 2) Gatterstufen, denn es sind für jede Stufe je einAND- und einOR-Gatter mit jeweils zwei Eingängen nötig.

Neben der günstigen Laufzeit besteht ein weiterer Vorteil darin, dass gleichartige undbillige Gatter verwendet werden (AND2, OR2). Außerdem ist ein symmetrischer undsynchroner Ablauf möglich.

5.2 Multiplikation

In diesem Abschnitt werden Verfahren zurMultiplikation zweierBinärzahlen dis-kutiert. Zunächst wird die Multiplikation nach der Schulmethode betrachtet, anschlie-ßend werden beschleunigte Methoden vorgestellt.

Die Darstellung derBinärzahlen erfolgt in derBetrag+Vorzeichen-Codierung. Sieeignet sich gut, weil die Multiplikation auf die Addition zurückgeführt wird. Das Vor-zeichenbit der Produktbinärzahl ergibt sich durch Anwendung des XOR-Operatorsauf die Vorzeichenbits desMultiplikanden undMultiplikators .

5.2. Multiplikation 103

Folgende Bezeichnungen werden vereinbart:

Faktor 1: Multiplikand MD = (MDn−1 . . .MD0)Faktor 2: Multiplikator MQ = (MQn−1 . . .MQ0)

Beide Faktoren müssenvorzeichenlossein. Um vorzeichenbehaftete Werte zumul-tiplizieren oder zudividieren, geht man daher in drei Schritten vor:

1. Abfrage der Vorzeichen und Werte vorzeichenlos machen.

2. Multiplikation (Division) mit den vorzeichenlosen Werten.

3. Aus den bei Schritt 1 ermittelten Vorzeichen das Vorzeichen des Ergebnisses er-rechnen (XOR).

5.2.1 Serielle Multiplikation

Eine erste Idee besteht darin, die Multiplikation auf eine Folge von Additionenzu-rückzuführen. Dazu wird die so genannteMultiplikationsmatrix gebildet, derenZeilen addiert werden:

• • • • • •• • • • • •

MD i ·MQ j • • • • • • j• • • • • •

• • • • • •Produkt: • • • • • • • • • • •

i

Beispiel: Multiplikationsmatrix

SeienMD = 0111 undMQ = 1011.Für j ∈ {0, . . . ,3} schreibt man in diej-te Zeile der Matrix den umj Bits nach linksverschobenen Wert vonMD, falls MQ j = 1 ist. Sonst wird die Zeile mit entspre-chend vielen Nullen besetzt. Anschließend werden die Zeilen komponentenweise addiert(Schulmethode).

0 1 1 10 1 1 1

0 0 0 00 1 1 1

0 1 0 0 1 1 0 1

Realisierung

Für das doppelt so lange Produkt brauchen wir zwei miteinander verbundene Regi-ster der Längen. Die einzelnen Additionen sind jeweils um ein Bit gegeneinanderverschoben.

Addiert wird:


• Eine 0, falls das betreffende MultiplikatorbitMQ j 0 ist.

• MD, falls das betreffende Multiplikatorbit 1 ist.

Im Allgemeinen wird alsoMD ·MQi addiert, wobeii die Nummer des aktuellen Mul-tiplikatorbits ist.

Um die oben skizzierte relative Verschiebung zu realisieren, kann man entweder dasZwischenergebnis festhalten undMD ·MQi um ein Bit nach links verschieben, oderman hältMD ·MQi fest und verschiebt das Zwischenergebnis um ein Bit nach rechts.

Wir wählen die zweite Möglichkeit und verwenden das RegisterMQ als zweite Hälf-te des Produktregisters. Dadurch wird derMultiplikator im Verlaufe dern Multipli-kationsschritte überschrieben. Ferner steht das aktuelle Multiplikationsbitimmer inMQ0 (siehe Abbildung5.20).

+

MQ MQ0MP

MD

Zwischenprodukt(Zu Beginn = 0)

Abbildung 5.20: Schema zur seriellen Multiplikation

Das Mikroprogramm für dieserielle Multiplikation lautet:

Mikroprogramm: Serielle Multiplikation

0 : [ MD := Mult ip l ikand ; MQ := Mult ip l ikator ;MP := 0; Z := n ]

1 : [ Z := Z -1;if MQ0=1 then

MP := MP + MD ]2 : [ shr( MP, MQ );

if Z > 0 thengoto 1 ]

3 : Stop

Hierbei bezeichnetMP dasPartialprodukt . Die Operationshr(MP,MQ) veranlassteinen Rechtsshift des gekoppelten Registers(MP,MQ) um 1 Bit, wobei links Nul-len aufgefüllt werden (Betrag+Vorzeichen-Darstellung) und wird rechts rausgescho-ben. Falls nicht Betrag+Vorzeichen-, sondern 2-Komplement-Darstellung verwendetwird, dann wird links das Vorzeichen nachgefüllt. Die 1-Komplement-Codierung istwegen desEnd-Around-Carries ungeeignet.


Beispiel: Serielle Multiplikation

SeienMD = 0111 undMQ = 1011. Am Anfang istMP = 0000.Vorbelegung MD : 0111

MP |MQ : 0000| 1011 Z := 4

1. Durchlauf

MP := MP+MD : 0111| 1011 Z := 3

shr(MP,MQ) : 0011| 1101

2. Durchlauf

MP := MP+MD : 1010| 1101 Z := 2

shr(MP,MQ) : 0101| 0110

3. Durchlauf

Nur shr(MP,MQ) : 0010| 1011 Z := 1

4. Durchlauf

MP := MP+MD : 1001| 1011 Z := 0

shr(MP,MQ) : 0100| 1101Ergebnis: 01001101

5.2.2 Multiplikatorcodierung

Die serielle Multiplikation kann dadurch beschleunigt werden, dass die Additionvon Nullzeilen nicht ausgeführt wird (wie im obigen Mikroprogramm bereitsreali-siert).

Ein erweiterter Ansatz besteht darin, dass ein Shift über Blöcke von Nullen und Ein-sen des Multiplikators durchgeführt wird. Hat derMultiplikator die FormMQ =. . .01k0. . . (. . . ,0, k Einsen, 0, . . .), so kann man unter Zuhilfenahme einer aufwändi-gen Zusatzlogikk Zyklen zusammenfassen.

Beispiel: Zusammenfassung von Zyklen

SeiMQ = . . .011110. . ., wobei die rechte Eins die Nummeru∈ {0, . . . ,n−1} im Bitwortträgt.Eine herkömmliche Berechnung hat die Form:

. . . 0 1 1 1 1 0 . . .| | | |

( 8 + 4 + 2 + 1 ) ·2u ·MD

Insgesamt wird also 15·2u ·MD addiert. Dies ist darstellbar alsAddition von 16·2u ·MDund anschließender Subtraktion von 1·2u ·MD. Statt der vier Additionen wird man günsti-gerweise eineSubtraktion (−1) und eine Addition(+16) durchführen.

AngenommenMQ habe die FormMQ = . . .01k0. . . und man betrachtetMQ von


links nach rechts. Trifft man auf die linke 0, so addiert man 2k ·MD auf dasPartial-produkt . Die erstenk−1 Einsen werden anschließend überlaufen. Tritt die Situationauf, dass man auf einer 1 stehend als nächstes Bit eine 0 erhält, so subtrahiert manMD vom Partialprodukt. Bei der Realisierung dieses Vorgehens besteht einProblemjedoch darin, zu erkennen, wie lang der Einser-Block ist.

Eine einfache Variante der seriellen Multiplikation ist dasVerfahren von Booth.Hierbei handelt es sich um ein serielles Prüfen desMultiplikators , wobei man sichnicht nur das aktuelle Bit vonMQ (MQ0) ansieht, sondern zusätzlich das vorherigeBit, das hier mitMQ−1 bezeichnet werden soll. Die durchzuführenden Aktionen sindin folgender Tabelle zusammengefasst:

MQ0 MQ−1 Wirkung

0 0 shr (Shift über Nullen)0 1 +1·MD und shr1 0 −1·MD und shr1 1 shr (Shift über Einsen)

Das Verfahren ist nur dann günstig, wenn inMQ längere Blöcke von Nullen oderEinsen auftreten. Es ist ungünstig, wenn Nullen und Einsen häufig wechseln.

Das Verfahren von Booth bezeichnet man auch alsMultiplikatorcodierung derGruppengröße 1, da es einen Spezialfall einer allgemeineren Multiplikatorcodie-rung darstellt. Betrachten wir nun den allgemeinen Fall der Gruppengrößeh:

MQh−1 . . .MQ0

Für dieMultiplikatorcodierung muss zusätzlich dasKorrekturbit MQ−1 betrachtetwerden:

MQh−1 . . .MQ0 |MQ−1

Falls MQ(h−1) = 1, addiert man stattx = 2h−1 ·MQh−1 +2h−2 ·MQh−2 + . . .+MQ0

x = 2h−2h−1 ·MQh−1 +2h−2 ·MQh−2 + . . .+MQ0

Dies wird jedoch auf zwei Zyklen verteilt, indem zunächst−2h−1 ·MQh−1 + 2h−2 ·MQh−2+ . . .+MQ0 addiert, anschließend um h Stellen nach rechts geshiftet und dann1·MD addiert wird. Die Information, ob eine Korrektur von 1·MD aus dem vorheri-gen Zyklus durchgeführt werden muss, kann anhand vonMQ0 abgelesen werden. Imzweiten Zyklus wird 2h also korrigiert durch:

x′ =−2h−1 ·MQh−1 +2h−2 ·MQh−2 + . . .+2·MQ1 +MQ0 +MQ−1


Aufgrund des Shifts über die Gruppe wird durchMQ−1 die Korrektur vorgenommen.

Das Verfahren von Booth arbeitet mit einer Gruppengröße von 1. Somit gilt hierx′ ∈ {−1,0,1}.Als ein weiteres Beispiel soll nun dieMultiplikatorcodierung mit Gruppengröße 2betrachtet werden. Hierbei fasst man zwei Multiplikatorbits(MQ1,MQ0) zusammen.Dadurch gibt es nur die vier folgenden Möglichkeiten:

(MQ1,MQ0) Operation

(0,0) addiere 0·MD(0,1) addiere 1·MD(1,0) addiere 2·MD(1,1) addiere 3·MD

und schiebe (MP,MQ) anschließend um 2 Bits nach rechts. Die Anzahl der Additio-nen kann somit halbiert werden. Im Falle, dass 2·MD addiert werden muss, führtman einen Linksshift vonMD um ein Bit und eine anschließendeAddition durch.

Der kritische Fall ist der letzte, wenn(MQ1, MQ0) = (1,1) ist. Dann muss das Drei-fache des Multiplikators addiert werden. Dieses Vielfache benötigt eine eigene Ad-dition (2+1) zu seiner Berechnung. Eine effiziente Lösung besteht nun darin, 3 als4−1 = (+1) ·22 +(−1) ·20 zu interpretieren. Die Wertigkeit von 22 ist im nächstenZyklus, d.h. nach zweifachem Rechtsshift des Partialprodukts, 20. Man wird im Fall(MQ1, MQ0) = (1,1) im Zyklus i fälschlicherweise(−1) ·MD addieren. Dies wirdim Zyklus (i + 1) korrigiert, indem dann 4·MD zusätzlich zu der dort anliegendenAddition addiert wird. Aufgrund des Rechtssshifts über die Gruppenlänge (2 Bits) istdann aber nurMQ−1 ·MD zu addieren (MQ−1 war im Zyklusi MQ1; +4 entsprichtim nächsten Zyklus, der eine um den Faktor 22 = 4 höhere Wertigkeit hat, genau demWert+1).

Dieses Verfahren lässt sich auch anwenden, falls(MQ1,MQ0) = (1,0); hier wird imZyklus i (−2) ·MD addiert und im Zyklus(i +1) durchMQ−1 ·MD korrigiert:

+2 = 4 − 2Korrektur addiere

(−2) ·MD

Insgesamt kann man immer dann so vorgehen, wennMQ1 = 1 und somit im darauffolgenden ZyklusMQ−1 = 1 ist. Dies hat den Vorteil, dass nur ein Bit zu prüfen ist,statt wie im Fall(MQ1,MQ0) = (1,1) beide.

Die folgende Tabelle zeigt die Aktionen, die in Abhängigkeit von (MQ1, MQ0, MQ−1)zu vollziehen sind.


MQ1 MQ0 MQ−1 Operation:Addierex ·MD mit x = . . .

0 0 0 00 1 0 11 0 0 -2 (statt 2);

spätere Korrektur: 41 1 0 -1 (statt 3);

spätere Korrektur: 40 0 1 1 = 0 + Korrektur: 1 (4)0 1 1 2 = 1 + Korrektur: 1 (4)1 0 1 -1 = -2 (statt 2) + Korrektur: 1 (4)

spätere Korrektur: 41 1 1 0

-1 (statt 3) + Korrektur: 1 (4)spätere Korrektur: 4

Es gilt:x= (−2·MQ1+MQ0+MQ−1) ·MD mit−2≤ x≤ 2. Somit sind allex-Wertedurch Inversion und Shift erhältlich.

Beispiel: Multiplikatorcodierung mit Gruppengröße 2

MQ = 0 0 1 0 0 1 1 0 1 1 1 1 0

MQ-1

+1 0-1+2-2 = x-1

5.2.3 Adder-Tree und Pipelining

Eine weitere Möglichkeit, um eine Beschleunigung der Multiplikation zu erhalten, istdie Verwendung einesAdder-Trees, mit dem die benötigten Additionsschritte einerMultiplikationsoperation parallelisiert werden können. Hieru werde je dreiZeilen derMultiplikationsmatrix in CSAs eines Adder-Trees gegeben (siehe Abbildung5.21).

Diese Vorgehensweise eignet sich, ummehrere Multiplikationen nacheinanderauszuführen. Ein Beispiel ist die Bildung der Summe∑k

i=1ai ·bi . Die Multiplika-tionen werden gemäß Abbildung5.22 stufenweise durch denAdder-Tree geführt(Pipelining).

Pipeline pro Einzelmultiplikation zusammen mit Multiplikatorcodierung

Um für eine einzelneMultiplikation ähnlich vorgehen zu können, wird derMul-tiplikator (zum Beispiel 60 Bits lang) in Gruppen zerlegt. Die Gruppen werdennacheinander in den Adder-Tree gegeben. Dafür eignet sich besonders eine Grup-pengröße von 12 Bits. Auf jede Gruppe wird die Multiplikatorcodierung angewen-det, wodurch die Zahl der Vielfachen auf die Hälfte verringert wird, im Beispiel auf


Adder Tree

...CSA CSA

Abschließende Additionz.B. Carry-Look-Ahead

Sehr schnell!Aber: Teuer;pro Multiplikationist zu geg. Zeitpunktnur eine Stufe desAdder-Trees aktiv

Abbildung 5.21: Multiplikation als Addition im Adder-Tree

Mult. i

Mult. (i+1)

Mult. (i+2)Mult. (i+3)

Abbildung 5.22: Pipelining durch Adder-Tree

6. Die Gruppen (im Beispiel 5) werden in einen kleinen Adder-Tree (6 Eingänge)gegeben. DieserAdder-Tree muss Rückkopplungen aufweisen, die den errechnetenWert (mit gleichzeitigem Rechtsshift um die Gruppengröße) mit dem nachfolgendenneuen Wert zusammen verarbeiten (siehe Abbildung5.23). Von den Rückkopplungenhängt die Laufzeit ab.

Ist die Rückkopplungsschleife bis oben zu den Blättern des Adder-Trees gelegt, soist keine hohe Taktfrequenz möglich. EinAdder-Tree mit kurzerRückkopplungs-leitung ist dagegen schneller.


zusätzliche CSAsfür Rückkopplungs-eingänge mit Shiftum 12 Stellen

Rückkopplung

Gr 1

Gr 1

Gr 1

Gr 2

Gr 2

Gr 3

Gr 2+ Gr 1

Gr 3

Gr 4

Zeit

Abbildung 5.23: Adder-Tree für Einzelmultiplikation

5.3 Division

Wie bei derMultiplikation wird zunächst mit derseriellen Division ein einfachesDivisionsverfahren vorgestellt. In einem weiteren Abschnitt wird mit deriterativenDivision eine wesentlich elegantere Methode betrachtet, welche für die iterative Be-rechnung vonQuadratwurzeln modifiziert wird. Es seien folgende Abkürzungeneingeführt:

DR: DivisorDD: DividendDE: Quotient

5.3.1 Serielle Division

Die serielle Divisionstellt eine Analogie zurseriellen Multiplikation dar. Sie ent-steht durch Umkehrung des entsprechenden Vorgangs bei der Multiplikation (sieheAbbildung5.24).

Es besteht folgende Analogie:

ProduktMultiplikant

= MultiplikatorDividendDivisor

= Quotient

Das folgendeMikroprogramm beschreibt die Division nach derSchulmethodefürden binären Fall. Seien(DD,DE) = [DDn−1, . . . ,DD0,DEn−1, . . . ,DE0] das Dividen-denregister,(DR)= [DRn−1, . . . ,DR0] das Divisorregister und(DE)= [DEn−1, . . . ,DE0]das Quotientenregister.(DD,DE) ist also doppelt so lang wieDR(ggf. auffüllen). DieZahlendarstellung erfolgt im 2-Komplement. Ferner wird vereinbart, dassDividendund Divisor normiert und positiv sind. Es gilt: 0≤W(DD) < W(DR) < 1.

5.3. Division 111

MQ MQ0MP

MD

serielleMultiplikation

bedingteAddition

DE

0

DD

Divisor DR

serielleDivision

bedingteSubtraktion Quotientenbit q

doppelt langer Dividend

Abbildung 5.24: Serielle Multiplikation und Division

Mikroprogramm: Division gemäß Schulmethode

0 : [ ( DD, DE ) := Dividend ; DR := Divisor ; Z := n ]1 : [ Z := Z - 1;

if DD ≥ DR thenq := 1; DD := DD - DR

elseq := 0 ]

2 : [ DE0 := q;if Z > 0 then

shl ( DD , DE ); goto 1else

shl ( DE ) ]3 : Stop

Die wesentliche Fallunterscheidung lautet: IstDD≥ DR, so subtrahiereDR von DDund setze dasQuotientenbit q0 gleich 1, ansonsten führe keine Subtraktion durchund setzeq0 auf 0.

Am Ende der Programmausführung steht im RegisterDD derPartialrest derDivisi-on, undDE enthält denQuotienten. DerDivisionsrestist halb so groß wie der Parti-alrest, daher wendet man den letzten Shift nur noch auf dasQuotientenregisterDEan. Für die Korrektheit des Verfahrens wurde vorausgesetzt, dass0≤W(DD,DE) <W(DR) < 1 gilt. Diese Variante wird auch alsNon-Performing-Division bezeichnet.


Eine andere Variante ist dieNon-Restoring-Division. Sie unterscheidet sich von obi-ger Variante dadurch, dass in Zeile 1 immerDR von DD subtrahiert wird und dieseSubtraktion gegebenenfalls wieder rückgängig gemacht wird. Anstelle der Abfrage,obDD≥ DR ist, mit der Konsequenz

• falls ja, Subtraktion undq := 1

• falls nein, nurq := 0

kann man auch wie folgt vorgehen (für W(DR) > 0):

• falls W(DD,DE)≥ 0, subtrahiereDR, ansonsten addiereDR

• falls das Ergebnis (neuer Wert von(DD,DE)) ≥ 0, q := 1, ansonstenq := 0

• falls am Ende der entstehende Rest negativ ist, korrigiere durchAddition vonDR.

Mikroprogramm: Non-Restoring-Division

0 : [ ( DD, DE ) := Dividend ; DR := Divisor ;Z := n ; DE0 := 1 ]

1 : [ Z := Z - 1;if DE0 = 1 then

DD := DD - DRelse

DD := DD + DR ]2 : [ DE0 := DDn−1;

if Z > 0 thenshl ( DD , DE ); goto 1

elseshl ( DE ); if DDn−1 = 1 then DD := DD + DR ]

3 : Stop

In Zeile 1 istDE0 das umgekehrte Vorzeichen des vorherigenQuotientenbits.

Korrektheitsüberlegungen

Geht man davon aus, dass die erstgenannte Methode (Non-Performing) korrekt arbei-tet, d.h. Zahlen richtig dividiert, so kann man zur Überprüfung der Korrektheit derzweiten Methode (Non-Restoring) diese an der ersten messen.

Nach der ersten Methode führt man folgende Operationen aus:

Quotientenbits 1 0 . . . 0 1↓ ↓ ↓ ↓

Vergleich: Vergleich: Vergleich: Zuletzt:Subtraktion Keine Keine Subtraktion

Operation OperationDer Partialrest ist stets nicht negativ.

5.3. Division 113

Nach der zweiten Methode geht man wie folgt vor:

Quotientenbits 1 0 . . . 0 1↓ ↓ ↓ ↓ ↓

Partialrest positiv negativ . . . negativ positiv↓ ↓ ↓ ↓ ↓

Subtraktion Subtraktion Addition Addition Addition

Bei jedem Quotientenbit 1 sind die Partialreste beider Methoden gleich groß;an denStellen, wo die Quotientenbits 0 sind, allerdings nicht:

Position (k−1) . . . 1 0Quotientenbits 0 . . . 0 1

↓ ↓ ↓ ↓Keine . . . Keine Subtraktion

Operation Operation

Insgesamt ergibt sich:−20 ·DR=−DR.

Position (k−1) . . . . . . 1 0Quotientenbits 0 . . . . . . 0 1

↓ ↓ ↓ ↓ ↓Subtraktion Addition . . . Addition Addition

Hier erhält man:(−2k−1 +2k−2 + . . .+20) ·DR=−DR.

Beispiel: Non-Restoring-Division

(DD,DE) := (0.10001110010), W(DD,DE) = 569/210≈ 0,55566. . .,DR := 0.11110, W(DR) = 30/25≈ 0,9375.Die Voraussetzung 0≤W(DD,DE) < W(DR) < 1 ist erfüllt.

DD DE010001 110011-DR110011100111 10011|0+DR000101001011 0011|01-DR101101011010 011|010+DR111000110000 11|0100+DR001110011101 1|01001-DR111111

010010 Shift von DE, da Rest negativ.+DR011101 010010 Rest= 29

25 · 125 , Quotient= 18· 1

25 = 0,5625


Beschleunigungsversuche

Die Multiplikatorcodierung ist in vergleichbar einfacher und leistungsfähiger Formnicht auf die Division übertragbar (niemand hat bisher ein solches Konzept gefun-den).

Es besteht jedoch die Möglichkeit,spezielle Divisorvielfachezu verwenden. Diegrundlegende Idee dabei ist, dass dieDivision schnell ist, wenn der neuePartialrestmöglichst betragsklein ist. Falls sichDD (alter Partialrest) undDR stark unterschei-den, bringt der nächste ZyklusDD−DRoderDD+DR (oderNOOP) noch nicht vielim Sinne eines kleinen Partialrests. Stellt man denDivisor (DR) demDividenden(DD) in einer Matrix gegenüber, so kann man drei Fälle unterscheiden:

DR

DD |DD|≪DR:Bilde DD:=DD-0,5·DR, falls DD≥ 0

DD+0,5·DR, falls DD< 0

Ist |DD|≈ DR:Operation wie üblich:

DD := DD-DR, falls DD≥ 0,DD := DD+DR, falls DD< 0.

|DD|≫DR:Bilde DD:=DD-2·DR, falls DD≥ 0DD+2·DR, falls DD< 0

Man versucht also, ein geeignetes Vielfaches vonDR einzusetzen.

Beispiel: Divisorvielfache

Sei 0< W(DD) < W(DR). Bilde DD := DD−0,5 ·DR und berechne zwei Quotientenbits(00 und 01) je nachdem, ob das Ergebnis negativ oder positiv ist. Hier ist das{1

2,1,2}-System verwendet worden. Es gibt auch Ansätze, ein{3

4,1, 32}- oder ein{5

8,1, 54}-System

zu verwenden. Dabei ist der letzte Ansatz besser als der zweite, und dieser ist besser alsdas{1

2,1,2}-System in folgendem Sinn: Der Betrag des neuen Partialrests ist im Mittelmöglichst klein. Daher ist die Zahl der im Mittel pro Zyklus berechenbaren Quotientenbitsbei dem{5

8,1, 54}-System am höchsten.

Ein Kompromiss ist dieTable-Look-Up-Methode. Sie arbeitet mit einer Matrix überDivisor und Dividend. Es wird ein Näherungsquotient aufgrund der ersten Bits vonDividend undDivisor bestimmt. Dieser Näherungsquotient kann als Startwert in ite-rativen Verfahren zur Division verwendet werden. Sollenk Bits berücksichtigt wer-den, müssen in der Tabelle 2k ·2k = 22k Elemente gespeichert werden (siehe Abbil-dung5.25).

5.3. Division 115

k

Divisor 0. 0. 0.0 ... x ... 10 ... x ... 10 ... x ... 1

0 . 0 0 0...

0 . y y y...

0 . 1 1 1

Dividend

2 Spalten, wennBits berücksichtigt

k

Näherungsquotient

Abbildung 5.25: Table-Look-Up-Methode

5.3.2 Iterative Division

In diesem Abschnitt wird ein iteratives Verfahren zurDivision vorgestellt. Man gehtdabei von der Rückführung der Division auf eine Folge von Multiplikationen undAdditionen aus. Da die Division im Allgemeinen seltener benötigt wird als dieMul-tiplikation , ist diese Rückführung der Konstruktion einer eigenen Divisionshardwarevorzuziehen und rechtfertigt ein schnelles, aber teuresMultiplizierwerk .

Man geht von einem Startwertx0 aus und wendet auf jeden Wertxi eine rekursiveIterationsvorschrift ϕ an, welche den Wertxi+1 liefert:

x0→ x1 := ϕ(x0)→ x2 := ϕ(x1)→ . . .→ xi+1 := ϕ(xi)→ . . .

Unter geeigneter Wahl des Startwertes konvergiertϕ gegen einen Grenzwert. Giltx = ϕ(x), so heißt ¯x Fixpunkt von ϕ.

Definition: Konvergenz mit Ordnung m

Seix0 ein geeignet gewählter Startwert undm∈ N0.ϕ konvergiert mit Ordnung m gegen einen Grenzwertx, wenn für den Iterationsfehlerεi := xi−x gilt: εi+1 = O(εm

i ).

Ist m = 1, so konvergiertϕ mit linearer Geschwindigkeit gegen den Grenzwert; istm= 3, so konvergiertϕ mit kubischer Geschwindigkeit gegen ¯x.

Beispiel: Regula Falsi

Sei f eine Funktion, die eineNullstelle besitzt. Man geht von zwei Stellenx0 undx1 aus,für die gilt: f (x0) < 0 und f (x1) > 0 oder umgekehrt. In jedem Schritt legt man eine Geradedurch die Punkte, welche durch die zwei Stellen und ihre Funktionswerte gebildet werden.Dann betrachtet man den Schnittpunkt der Geraden mit derx-Achse.Seienxi undxi+1 die betrachteten Stellen mitxi < xi+1. Man wendet folgendeIterations-vorschrift an:if f (Schnittstelle) = 0 then Nullstelle := Schnittstelle;if f (Schnittstelle)< 0 thenxi := Schnittstelle;


if f (Schnittstelle)> 0 thenxi+1 := Schnittstelle;Das Verfahren konvergiert mit linearer Geschwindigkeit, ist also von der Ordnungm= 1.

Beispiel: Newton-Verfahren

Dieses Verfahren dient ebenfalls der iterativen Ermittlung einer Nullstelle einer Funktionf .Man geht von einer Startstellex0 aus und erhältxi+1 durch Anwendung derIterationsvor-schrift ϕ(x) = x− f (x)

f ′(x) aufxi (siehe Abbildung5.26).

f

x0x1x2x

Abbildung 5.26: Newton-Verfahren

Das Newtonverfahren konvergiert quadratisch, also mit Ordnungm= 2 gegen eineNullstelle x von f (x), sofernx0 geeignet gewählt wird undf ′(x) 6= 0 ist.

Das Newton-Verfahren wird nun verwendet, um ein elegantes Verfahren zurDivisionzu konstruieren. Dabei wird1b ausb wie folgt errechnet:

• Suche eine Funktionf (x), die 1b alsNullstelle besitzt.

• Berechneϕ(x) = x− f (x)f ′(x) aufxi , wobeiϕ(x) keine Division enthalten soll.

• Führe die Iterationxi+1 = ϕ(xi) so oft wie nötig durch, bis Konvergenz imRahmen der erzielbaren Genauigkeit eintritt.

Versuch 1:

Geht man von der Funktionf (x) = x− 1b mit Nullstelle 1

b aus, so erhält man keinebrauchbareIterationsvorschrift :

ϕ(x) = x− f (x)f ′(x)

= x− x− 1b

1=

1b

Der Fixpunkt1b muss vorher bekannt sein.

5.3. Division 117

Versuch 2:

Sei f (x) =−1x +b. Diese Funktion hat auch die Nullstelle1

b. Die Iterationsvorschriftϕ lautet:

ϕ(x) = x− f (x)f ′(x)

= x− −1x +b1x2

= x− (−x+b·x2)

= 2·x−b·x2

= (2−b·x) ·x

Mit dieserIterationsvorschrift hat man eine divisionsfreie Formel erhalten. Die Di-vision ist hiermit auf zwei Multiplikationen und eine Subtraktion zurückgeführt wor-den, die zum Beispiel im 2-Komplement leicht zu handhaben ist. Fürb∈ [1

2 : 1] liegtbeispielsweise die Mantisse einernormalisierten Gleitkommazahl vor.

Die Divisionsvorschrift ist also:

Startwert: x0 := 1 oderx0 := Wert nachTable-Look-Up (Näherungswert für1b)

Iterationsvorschrift:ϕDiv(x) = (2−b·x) ·x

Beispiel: Iterative Division

Seienb = 0,85; x0 = 1.Dann ergeben sich folgende Näherungswerte, wobei an diesendas quadratische VerhaltendesNewton-Verfahrenszu erkennen ist:

x1 = (2−0,85·1) ·1 = 1,15

x2 = 1,175875

x3 = 1,1764703

x4 = 1,1764706. . . .

x4 stellt einen relativ genauen Wert von10,85 dar. Ein besserer Startwert ist 0,8, denn hiererhält man obige Näherungswerte schon einen Schritt früher:

x∗1 = 1,171875

x∗2 = 1,1764526

x∗3 = 1,1764705. . . .

ϕDiv konvergiert quadratisch gegen1b. Der Iterationsfehler des(i +1)-ten Schrittes ist

kleiner oder gleich Null (es liegt also quadratische Konvergenz von unten vor):

εi+1 = xi+1− x = (2−b·xi) ·xi−1b

=−b·(

xi−1b

)2

=−b· ε2i ≤ 0, falls 0< b < 1.


Anschaulich bedeutet dies eine Verdopplung der Zahl korrekter Bits (Stellen, Zif-fern) bei jedem Übergang vonxi zu xi+1. Der (i + 1)-te Schritt bringt also sovielwie die ersteni Schritte zusammen. Da das Verfahren nur bei hinreichend genauemAusgangswert konvergiert (dann allerdings schnell!), ist der Startmit einem gutenNäherungswert aus der Table-Look-Up-Tabelle sehr zweckmäßig.

Bei verkürzter ungenauer Berechnung der Multiplikationenxi+1 = (2−b · xi) · xi istdie Zeit pro Iterationsschritt kürzer. Die Konvergenzgeschwindigkeitist dafür aberetwas schlechter als quadratisch. Für eine kürzere Multiplikation verwendet man dieSchreibweise(2−b·xi)Tr (Truncated). (2−b·xi)Tr enthält nur die relevantesten Bitsvon (2−b·xi).

Ein Vorteil besteht darin, dass(2−b·xi)Tr mit Multiplikatorcodierung auf wenige,z.B. 6, Vielfache codiert und in einem kleinenAdder-Tree verarbeitet werden kann.Ferner wird die Bildung von(2−b·xi) vereinfacht.

AEGP (Anderson-Earle-Goldschmidt-Power)

Ein Nachteil der bisherigen IterationsvorschriftϕDiv(x) = (2−b ·x) ·x besteht darin,dass die zwei aufeinanderfolgenden Multiplikationen pro Iterationsschritt eine Paral-lelisierung verhindern.

Ziel ist es, eine gleichschnelle Konvergenz durch zwei parallele Multiplikationen zuerzielen. Eine Idee besteht darin, dass die erste Multiplikation entfällt, wennb = 1ist. Das Verfahren konvergiert dann für jeden sinnvollen Startwert zum Grenzwert 1.

Das Verfahren lautet:

d0 = Startwertdi+1 = (2−di) ·di

Beispiel: Konvergenz von di+1 = (2−di)di

d0 = 1,5

d1 = 0,5·1,5 = 0,75

d2 = 1,25·0,75= 1− (0,25)2 = 1− 116

Ein unbrauchbarer Startwert wäred0 = 5.

Für die Berechnung eines Quotientenab betrachtet man zwei parallele Folgen:

• Folge 1 mit Startwertb und

• Folge 2 mit Startwerta.

Prinzipiell führt man solange eineMultiplikation der aktuellen Werte von Folge 1und 2 mit dem gleichen Faktor durch, bis Folge 1 den Grenzwert Eins erreicht hat

5.3. Division 119

(im Rahmen der Genauigkeit). Wenn dies der Fall ist, dann wurde durch Folge 2 derWert desQuotienten a

b approximiert:

ab

=a· r0

b· r0=

a· r0 · r1

b· r0 · r1= . . . =

a· r0 · r1 · . . . r i

b· r0 · r1 · . . . r i

a· r0 · . . . r i konvergiert also gegenab, wennb· r0 · . . . r i gegen 1 konvergiert.

Es gilt insgesamt:

Folge 1 Folge 2Startwert d0 := b x0 := aIterationsvorschrift di+1 := di · (2−di) xi+1 := xi · (2−di)

Konvergenz quadratisch gegendE = 1 xE = a

b

In einer Realisierung sind nun zweiMultiplikationen (di · (2−di) undxi · (2−di))pro Iterationsschritt umzusetzen. Sind zweiMultiplizierwerke vorhanden, so kannman die Multiplikationen parallel ausführen. Stattdessen könnte man auch dasPipe-lineprinzip verwenden:

Pipeline A: di xi di+1 xi+1 di+2

Pipeline B: xi−1 di xi di+1 xi+1

Zeit→

Ferner kann man die verkürzten Formen(di · (2−di))Tr und(xi · (2−di))Tr in einenAdder-Tree geben, wobei man dann zunächst ungenau aber schnell rechnet und imletzten Schritt die Folge 2 genau berechnet.

5.3.3 Iterative Berechnung von Quadratwurzeln

Um dieQuadratwurzel einer ZahlN zu berechnen, kann man ähnlich vorgehen wiebei der iterativen Division. Man verwendet wieder das Newton-Verfahren mit einergeeigneten Funktionf , welche

√N als Nullstelle besitzt.

Wählt manf (x) = x2−N, so ergibt sich folgendeIterationsvorschrift für das itera-tive Wurzelziehen:

xi+1 = ϕ(xi) = xi−f (xi)

f ′(xi)= xi−

x2i −N2·xi

=12·(

xi +Nxi

)

Das Verfahren konvergiert quadratisch gegen√

N.

Beispiel: Iterative Berechnung der Quadratwurzel aus 2

SeiN = 2 undx0 = 100 (ziemlich schlechter Startwert).Es ergibt sich folgende Näherungsfolge:


x0 = 100

x1 =12· (100+

2100

)≈ 50 (ungenau)

x2 ≈ 25

x3 ≈ 12

x4 ≈ 6

x5 ≈ 3

x6 ≈ 12· (3+

23)≈ 1,83 (ungenau gerechnet ergäbe sich: 1,5)

x7 ≈ 1,46

x8 ≈ 1,4149. . . (schon recht genau)

Ein großer Nachteil des Verfahrens besteht darin, dass es nicht divisionsfrei ist, daNxi

in jedem Schritt berechnet wird. Daher kommt man wieder auf eineAEGP-verwandteMethode zurück.

Man verwendet hier die Folgen(di) und(xi) mit:

d0 := N, di+1 := di · r2i

x0 := N, xi+1 := xi · r i

wobeir i = 1+ 12 ·(1−di) ist. Die hier vorliegende Division durch 2 kann durch einen

Rechtsshiftrealisiert werden. Es gilt, dassdn = d0 · r20 · r2

1 · . . . r2n−1 quadratisch gegen

1 konvergiert, wobei auch hier wieder ein geeigneter Startwert vorausgesetzt sei.

Satz:

Die Folge(xi) konvergiert quadratisch gegen√

N:

xn = x0 · r0 · r1 · . . . rn−1→ x0 ·1√d0

=N√N

=√

N

Beispiel: Berechnung der Quadratwurzel aus 2

SeiN = 2 und somitd0 = x0 = 2. Man erhält die Folgen(di),(xi) und(r i):d0 = 2 x0 = 2 r0 = 1+ 1

2 · (1−2) = 12

d1 = 2· 14 = 1

2 x1 = 2· 12 = 1 r1 = 1+ 1

2 · (1− 12) = 5

4d2 = 25

32 x2 = 54 r2 = 1+ 7

64d3 = 0,9614943 x3 = 1,3867187 r3 = 1,0192528d4 = 0,998872 x4 = 1,4134169 r4 = 1,0005635d5 = 0,999989 x5 = 1,4142133 r5 = 1,0000005

5.3. Division 121

Beweis:

Es gilt:

xn = x0 · r0r1 · . . . · rn−1 = N · r0r1 · . . . · rn−1→√

N

⇔ r0r1 · . . . · rn−1→1√N

⇔ (r0r1 · . . . · rn−1)2→ 1

N⇔ N · (r0r1 · . . . · rn−1)

2 = d0 · (r0r1 · . . . · rn−1)2 = dn→ 1

Es ist also zu zeigen, dass(di+1) gegen 1 konvergiert.

Zunächst ist:di+1 = di · (1+ 12 · (1−di))

2 = di · (2−di +14 · (1−di)

2).

Hilfssatz:Eine Iterationsvorschrift xi+1 := ϕ(xi) konvergiert genau dann mit Ordnungmgegenx, d.h. fürεi = xi − x gilt εi+1 = O(εm

i ), wennϕ(x) = x und ϕ′(x) = . . . =ϕ(m−1)(x) = 0 undϕ(m)(x) 6= 0.

Taylorentwicklung des Fehlers:

εi+1 = xi+1− x = ϕ(xi)− x = ϕ(x+ εi)− x

=∞

∑k=0

ϕk(x)k!· εk

i − x =∞

∑k=1

ϕk(x)k!

εki +ϕ(x)− x

Daher:εi+1 = O(εmi )⇔ ϕ(x) = x undϕ′(x) = . . . = ϕm−1(x) = 0 undϕ(m)(x) 6= 0. �

Es bleibt noch zu zeigen, dassdi+1 = di · (2− di +14 · (1− di)

2) quadratisch gegenx = 1 konvergiert.

Die Iterationsvorschrift lautet hier:

di+1 = ϕ(di) mit ϕ(x) = x ·(

2−x+14· (1−x)2

)

,

Ableitungen:

ϕ′(x) = 1·[

2−x+14· (1−x)2

]

+x ·[

−1+14·2· (1−x) · (−1)

]

ϕ′′(x) =−2+6·x4

(di) konvergiert gegen 1, weilϕ(1) = 1,ϕ′(1) = 0 undϕ′′(1) 6= 0 ist:

ϕ(1) = 1· (2−1+0) = 1 = x,

ϕ′(1) = 1· (2−1+0)+1· (−1+0) = 0,

ϕ′′(1) =−12.

�


5.4 Arithmetik bei redundanter Zahlendarstellung

Die letzten Abschnitte haben gezeigt, dass einÜbertrag in ungünstigen Fällen einelange Laufzeit der Rechenoperation bewirkt. Der Übertrag kann sich zum Beispielauf die gesamte Addition auswirken. In diesem Abschnitt werden Zahlendarstellun-gen für dieAddition und für dieDivision besprochen, die auf Kosten einer erhöhtenRedundanz eine beschleunigte Durchführung der Operationen ermöglichen.

5.4.1 SDNR-Darstellung für die Addition

Die grundlegende Idee besteht darin, eine oder mehrere zusätzlicheRedundanzzif-fern einzuführen, in denen sich derÜbertrag fängt, falls er überhaupt entsteht. Manführt zum Beispiel eine zusätzliche 2 zu den binären Ziffern 0 und 1 ein.Die Aus-gangszahlen könnte man binär darstellen und das Ergebnis ternär interpretieren. Dieswird im folgenden Abschnitt präzisiert.

Die Zahlendarstellung ist inStellenwertform zu einerBasisd. Dabei sind im codie-renden Bitwort nun nicht mehr nur die Ziffern 0, . . . ,d−1 zulässig, sondern positiveund negative Ziffernαi ∈ [−r1 : +r2], r1, r2 > 0:

WSDNR(αn−1,αn−2, . . . ,α0) =n−1

∑i=0

αi ·di

Um die Notation im Folgenden übersichtlicher zu gestalten, wird−x alsx notiert.

Beispiel: Wert einer SDNR-Zahl zur Basis d = 10

WSDNR(2314) = 2000−300+10−4 = 1706.

Definition: SDNR (Signed Digit Number Representation)

Eine Zahlendarstellung zu einer Basisd, die folgende Eigenschaften hat, heißt SDNR:

1. Symmetrie:r1 = r2 = r

2. Für αi sollen mindestensd verschiedene Werte möglich sein. Der Übertrag (+1 oder−1) aus der Stelle(i−1) soll sich in der Stellei fangen.

Dies ist erfüllt, wenn 2· r +1≥ d+2 gilt, also⌊d2⌋+1≤ r;

2· r +1 ist die Anzahl möglicher Ziffern.

3. Fürαi sollen höchstensd nicht-negative Werte zulässig sein, alsor ≤ d−1.

Das Vorzeichen des Wertes einer SDNR-Zahl ist gleich dem Vorzeichender von linksgesehen ersten Ziffer der Zahl, die nicht 0 ist.

Aus der obigen Definition die (Nicht-)Existenz von SDNR-Darstellungen zube-stimmten Basen abgeleitet werden:

a) Für die Basisd = 2 gibt es keine SDNR-Darstellung:

⌊d2⌋+1≤ r ≤ d−1 (Bedingung 2 und 3) liefert fürd = 2 :

5.4. Arithmetik bei redundanter Zahlendarstellung 123

1+1≤ r ≤ 2−1, also 2≤ 1, was zu einem Widerspruch führt.

b) Für die Basisd = 3 ist eineSDNR-Darstellungmöglich:

⌊32⌋+1≤ r ≤ 3−1, folglich: r = 2 ist hier eindeutig bestimmt.

Somit ist dieCodierung festgelegt:

WSDNR(αn−1,αn−2, . . . ,α0) =n−1

∑i=0

αi ·3i mit αi ∈ [−2 : +2].

Beispiel: SDNR-Addition

Es werden die Zahlen(2122012) und (1221222) addiert. Dabei wird das jeweilige Sum-menbit in der oberen und das Übertragsbit in der unteren Zeile notiert, wobei das Über-tragsbit einer Stelle eine Stelle weiter links geschriebenwird. Diese Notation wurde schonbei derVon-Neumann-Addition verwendet. Im ersten Schritt der Addition wird daraufgeachtet, dass die Summenbitssi ∈ [−1 : +1] sind.

2 1 2 2 0 1 21 2 2 1 2 2 21 0 1 1 1 0 1

0 1 1 0 1 1 1 00 1 1 0 0 1 1

Die fettgedruckten Ziffern zeigen, wie mans2 = 2 vermeiden kann: 2= 3·1−1. Auf dieseWeise kann im zweiten Schritt der Addition kein Übertrag mehr entstehen.

Im allgemeinen Fall bildet man die Summenbitssi im ersten Schritt so, dass sie denZiffernbereich nicht bis oben beziehungsweise unten ausfüllen:si ∈ [−(r−1) : +(r−1)]. Der Übertrag+1 oder−1 fängt sich dann im zweiten Schritt. Die Addition fürdie Basisd und⌊d

2⌋+1≤ r ≤ d−1 geschieht wie folgt:

αn−1 · · · α0

+ βn−1 · · · β0

σn−1 · · · σ0 Zwischensumme+ cn−1 cn−2 · · · c0 0 Vorläufiger Übertrag

sn sn−1 · · · s0 Summe

Dabei sind:αi ,βi ,si ∈ [−r : +r],σi ∈ [−(r−1) : +(r−1)] undci ∈ [−1 : +1].

Für Schritt 1 sind folgende Formeln denkbar:

Seiwmax∈ [(d− r) : (r−1)], zum Beispiel alsowmax= r−1.

Setzeci =

+1 falls αi +βi > wmax

0 sonst

−1 falls αi +β1 <−wmax

und setzeσi = αi + βi − ci ·d, wegen der Invarianzeigenschaft:αi + βi = ci ·d+ σi .Dann ist| σi |< r für i = 0, . . . ,(n−1) erfüllt und somit ist Schritt 2 ohne Überträgemöglich.


5.4.2 Gemischtes SDNR-Verfahren

Die Addition von Zahlen in der SDNR-Darstellung geht sehr schnell. Zu beachtenist allerdings, dass die Zahlen zunächst in dieser Form codiert sein müssen. Der Auf-wand für diese Codierung muss daher berücksichtigt werden. Günstig ist es, das Ver-fahren zu verallgemeinern, so dass eine Addition von Zahlen durchgeführt werdenkann, wobei eine Zahl in SDNR-Darstellung zur Basisd und die andere in normalerStellenwertcodierung zur Basisd vorliegt:

An−1 · · · A0 SDNR-Zahl+ bn−1 · · · b0 d-näre Zahl

Tn−1 · · · T0 Zwischensumme+ cn−1 cn−2 · · · c0 0 Vorläufiger Übertrag

Sn Sn−1 · · · S0 Summe

Die großen Buchstaben kennzeichnen Ziffern einer SDNR-Zahl, d.h.Ai ∈ [−(d−1) : +(d−1)]; die kleinen Buchstaben bezeichnen Ziffern einerd-nären Zahl, alsobi ∈ [0 : (d−1)].

Die Formeln für Schritt 1 und Schritt 2 derAddition lauten:

Schritt 1:

Setze

ci =

{

1 wennAi +bi ≥ d−1

0 sonst,

Ti = Ai +bi−ci ·d ∈ [−(d−1) : +(d−2)]

Schritt 2:

SetzeSi = Ti +ci−1 ∈ [−(d−1) : +(d−1)], ohne weiteren Übertrag.

Dieses gemischte Verfahren funktioniert auch bei Codierung zur Basisd = 2. Hierliegt obiges Schema mit entsprechender Wahl der Ziffernbereiche zugrunde:

Ai ∈ {−1,0,+1},bi ∈ {0,1},Ti ∈ {−1,0},ci ∈ {0,1} für i = 0, . . . ,(n−1) undSi ∈{−1,0,1} für i = 0, . . . ,n.

Ai ,Ti undci werden binär codiert (bi liegt binär vor undSi wird umgewandelt):

• Ai auf zwei Binärstellen, wobei sich als Darstellungsform Betrag+Vorzeicheneignet:

ai,1 ai,2 Ai

0 0 +00 1 +11 0 -01 1 -1


• ci undTi können auf einer Binärstelle codiert werden.

Für die Realisierung der Berechnung eignen sich folgende Formeln:

a) Ai = ai,2 · (1−2·ai,1), alsoai,2 = Ai mod 2

b) ci = 1⇔ Ai +bi ≥ 1⇔ Ai = 1∨Ai = 0∧bi = 1

Formel:ci = ai,1 ·ai,2 +ai,2 ·bi

c) Ti =−1⇔ Ai +bi = 1 mod 2⇔ ai,2 +bi = 1 mod 2

Formel:Ti =−(ai,2⊕bi); | Ti |= ai,2⊕bi

d) Formeln fürSi = (si,1; si,2) :

si,2 = 1⇔ Si 6= 0⇔ Ti +ci−1 = 1 mod 2⇔ | Ti | ⊕ci−1 = 1,

also:si,2 =| Ti | ⊕ci−1 = ai,2⊕bi⊕ci−1

si,1 =| Ti | oder auchsi,1 = ci−1

Die zwei unterschiedlichen Möglichkeiten beruhen auf der Redundanz der Zahlen-darstellung.

5.4.3 SRT-Verfahren zur seriellen Division

Dieses Verfahren ist benannt nach Sweeney, Robertson und Tocher und es verbessertdas Prinzip der seriellen Division in der Form, dass der neuePartialrest möglichstbetragsklein gewählt wird. Das Prinzip der seriellen Division besteht ausfolgendenSchritten:

• Subtrahiere vomDividendenein geeignetes Vielfaches desDivisors.

• BestimmeQuotientenbit(s) in Abhängigkeit von dieser Subtraktion.

• Wiederhole diesen Vorgang so lange mit jeweils neuem kleineren Partialrest,bis der Partialrest näherungsweise Null ist (bis also der Quotient vollständigberechnet ist).

Die Folge der PartialresteX im Verlaufe einer Divisionsoperation zur Basisd istgegeben durch:

Xn := W(DD,DE) Wert von Register(DD,DE)

X j := d · (X j+1−q j ·W(DR)) für alle j = (n−1), . . . ,0

Dabei istq j ∈ {−(d−1), . . . ,0, . . . ,(d−1)} ein Quotientenbit. DiesesQuotientenbitist nun so zu wählen, dassX j möglichst betragsklein wird, das heißt, für alleq′j gilt:| X j(q j) |≤| X j(q′j) |.


SRT-Division im binären Fall

Man kann folgende zwei Varianten unterscheiden: DasSRT1-Verfahren ist ziemlichgenau, aber aufwändiger als dasSRT2-Verfahren, welches dafür ungenauer arbeitet.

SRT1:

Es sei vorausgesetzt, dass12 ≤W(DR) < 1 ist. Dann istSRT1 definiert durch:

Xn := W(DD,DE)

X j := 2· (X j+1−q j ·W(DR)), für j = (n−1), . . . ,0, mit:

q j :=

+1, falls X j+1 > 12 ·W(DR)

0, sonst

−1, falls X j+1 <−12 ·W(DR)

SRT2:

Es ist wieder vorausgesetzt, dass12 ≤W(DR) < 1 ist. Dann istSRT2 definiert durch:

Xn := W(DD,DE)

X j := 2· (X j+1−q j ·W(DR)), für j = (n−1), . . . ,0, mit:

q j :=

+1, falls X j+1≥ 12

0, sonst

−1, falls X j+1 <−12

Hier ist also die Bestimmung vonq j einfacher, denn es muss kein expliziter Vergleichdurchgeführt werden, sondern es reicht, die ersten beiden Bits zu prüfen:

Seienx j+1n−1 und x j+1

n−2 die ersten beiden Bits vonX j+1. Dann wirdq j wie folgt be-stimmt:

q j :=

+1, falls x j+1n−1 = 0 und x j+1

n−2 = 1

0, falls x j+1n−1 = x j+1

n−2

−1, falls x j+1n−1 = 1 und x j+1

n−2 = 0

Mikroprogramm zur SRT-Division

Es wird nun ein Mikroprogramm für dieSRT-Division angegeben. Hierzu seien fol-gende Bezeichnungen vereinbart:

• Register:

(DD,DE): Doppelt langer Dividend

DR : Divisor


DE : positive Quotientenbits

DH : negative Quotientenbits

Falls an der Stellej kein Quotientenbit aufzunehmen ist, giltDE j =DH j = 0.

• Zähler:

Z (wie früher)

Das Mikroprogramm für nicht-negative Faktoren 0≤W(DD,DE) < W(DR) < 1 lau-tet:

Mikroprogramm: SRT-Division

0 : [ ( DD , DE ) := Dividend ; DR := Divisor ;DH := 0; Z := n ]

1 : [ Z := Z - 1; q := - DDn−1 + DDn−2;if DDn−1 6= DDn−2 thenif DDn−1 = 1 then

DD := DD + DRelse

DD := DD - DR ]2 : [ ( DE0 , DH0) :=

if q = 1 then(1 ,0)

elseif q = -1 then

(0 ,1)else

(0 ,0)if Z > 0 then

shl ( DD , DE ); shl ( DH ); goto 1else

shl ( DE ); shl ( DH ) ]3 : DE := DE - DH4 : Stop

In DH werden die negativen Quotientenbits als Einsen abgelegt. Daher kann im letz-ten Schritt subtrahiert werden, um das Ergebnis zu dekonvertieren.

Index

Überdeckung,65, 66Übertrag,16, 81, 84, 1221-Komplement,15, 162-Komplement,12, 15, 16, 19, 20, 833-Excess-Code,24, 49

Adder-Tree,90, 92, 108, 109, 118, 119Addierwerk,82, 84, 91Addition, 11, 15, 16, 79, 105, 107, 112,

122, 124serielle,84, 87

Additionsmethode,79Adresscodierung,29Adresse,4, 35, 37Adressmatrix,89Adressmodifikation,37AEGP,118, 120Akkumulator,4, 5, 29, 31, 33, 35ALU, 79AND, 50ASCII-Code,23Assembler,30Atom, 55Aussagenkalkül,52Axiomensystem,52

B+V-Codierung,sieheBetrag+VorzeichenBasis,10, 122Basisadresse,36Baustein,49

-funktion,50-system,50

BCD-Code,24Bedingungsmatrix,89Befehl,2, 29

-ausführung,29-strukturen,30

-typen,33, 36-wort, 29

Befehlsfolgezähler,31Befehlsregister,4Befehlssatz,34Befehlszählregister,4, 45Betrag+Vorzeichen,11, 15, 102Binär

-darstellung,30-system,10-zahl,11, 14, 84, 102

Bitfehler,27Bitfolge, 29Bitstring,22Boolesche Algebra,52, 56Boolescher Ausdruck,58, 59, 62, 80, 82,

83Booth

Verfahren von,106Bus,7, 8

Carry,sieheÜbertragCarry-Look-Ahead-Addierer,94, 95, 99Carry-Ripple-Addierer,82, 93, 94Carry-Save-Addierer,91Carry-Skip-Addierer,95, 96, 99

n-Bit-, 98zweiter Ordnung,98

CISC,34Codewort,9Codierung,9–11, 22, 25, 123CSA,sieheCarry-Save-Addierer

Decodiermatrix,89Dezimalsystem,10Diodenmatrix,88, 89Disjunktion,83

129

130 Index

Disjunktive Normalform,60Dividend,110, 114, 125Division, 21, 79, 103, 111, 114–116, 122

iterative,110Non-Performing-,111Non-Restoring-,112serielle,110

Divisionsrest,111Divisor, 110, 114, 125DNF, sieheDisjunktive NormalformDon’t Care,48, 58, 65, 71

Earle Larch,75EBCDIC-Code,23einschlägiger Index,59, 71End-Around-Carry,104EQUIV, 50Ergebnisparameterblöcke,46EXOR,14, 50

FA, sieheFulladderFestkommadarstellung,17Fixpunkt,115Flipflop, 73Fulladder,80, 81, 83, 84, 90, 96

Gleitkommazahl,18Gray-Code,24, 70

HA, sieheHalfadderHalbaddierer,sieheHalfadderHalfadder,80, 81, 86, 90

Kosten,82Hamming-Distanz,26Hamming-Gewicht,65Hauptspeicher,3Hazards,76Hexadezimalsystem,10Hintergrundspeicher,3Huffman-Codierung,23

IEEE-754-Format,19Implikant,64Indexregister,4, 34indirekte Adressierung,37Interrupt,6Iterationsvorschrift,115–117, 119, 121

KNF, sieheKonjunktive NormalformKommunikationsnetz,2Komplementfreie Ringsummenentwicklung,

61Komplementfunktion,52Konjunktion,83Konjunktive Normalform,60Korrekturbit,106Kostenfunktion,63Kostenmaß,62KRE, sieheKomplementfreie Ringsum-

menentwicklung

Längsparität,26Ladebefehl,33Leitung,7Linkageregister,45Linksshift,21

Mantisse,18, 19, 21Maxterm,56Mengenalgebra,52, 53Mikro

-befehl,88, 89-operation,88-programm,85, 87, 110

MIMD-Rechner,5Minimalpolynom,64, 66, 81Minimierungsproblem,63Minterm,55, 58–60, 64, 65MISD-Rechner,5Mnemonische Darstellung,30Monom,64, 65Multiplikand, 102, 103Multiplikation, 21, 79, 102, 103, 108, 110,

115, 118, 119serielle,104, 105, 110

Multiplikationsmatrix,103Multiplikator, 102–106, 108Multiplikatorcodierung,106, 114, 118

Gruppengröße 1,106Multiplizierwerk, 115, 119

NAND, 74Newton-Verfahren,117normalisierte Darstellung,18, 19normalisierte Gleitkommazahl,117

Index 131

NOT, 50Nullstelle,115, 116

Objektcode,30Oktalsystem,10Opcode,29, 30, 34Operanden,5, 30, 32Operationen,32, 34

Paralleladdierer,82, 86Paritätsbit,25Partialprodukt,104, 106Partialrest,111, 114, 125Pipelining,90, 108, 119PLA, sieheProgrammable Logic ArrayPostnormalisierung,20, 21Primimplikant,64

wesentlich,66Programmable Logic Array,88Programmausführung,30Propagationskette,84, 91Prozessor,1, 2Pufferregister,8Pufferspeicher,3

Quadratwurzel,110, 119Querparität,26Quine-McCluskey,66Quotient,110, 111, 119Quotientenbit,111, 112, 125Quotientenregister,111

Rückkopplung,74Rückkopplungsleitung,109rationale Zahlen,17Recheneinheit,1Rechenoperationen,11Rechenwerk,79Rechnerbus,sieheBusRechtsshift,21, 120Redundanz,17Redundanzziffern,122Register,3

-befehl,34Allzweck-, 4Befehls-,4

Rekursion,43

Rekursionsformel,83, 94Resolutionsblock,71RISC,34RS-Flipflop,73

Schaltfunktion,48, 49, 54, 58, 60, 62, 71Schaltkreis,47, 62, 72Schaltnetz,72Schaltung,47, 48Schaltwerk,47, 71, 72Schulmethode,103, 110SDNR-Darstellung,123Shiftbefehl,33SIMD-Rechner,5SISD-Rechner,4Speicher,2, 35

-adressierung,29-adressregister,4-datenregister,4

Speicherelement,72Speicherzellen,3Stack,29–32, 45

-befehl,31Stellenwert,10

-codierung,10, 79-form, 122

Steuereinheit,1Steuermatrix,89Stone

Satz von,52Subtraktion,11, 16, 83, 87, 105Supergruppe,98

Table-Look-Up,114, 117Takt,71, 73, 75, 85, 88, 90, 92Taktflanke,76Taktmatrix,89Torschaltung,74, 101

Umschaltsymbol,22Unibus,sieheBusUnterprogramm,29, 42, 44

-aufruf,43-bibliothek,42

Vektoroperation,30Volladdierer,sieheFulladder

132 Index

Von-Neumann-Addition, 86, 123-Adierer,89-Prinzip,4, 5

Vorzeichenbit,10, 11, 13, 16, 17

Wallace Tree,sieheAdder-Tree

Zahlenbereich,11–13, 17Zahlensystem,10Zahlenverlängerung,14, 16

Rechnerstrukturen, Skript zur Vorlesung an der RWTH Aachen...KAPITEL 1 Grundlegende Konzepte Wir...

Documents

Transcript of Rechnerstrukturen, Skript zur Vorlesung an der RWTH Aachen...KAPITEL 1 Grundlegende Konzepte Wir...