Seminararbeit Sommersemester 2017

Schaltkreise für die Addition Seminararbeit Sommersemester 2017 Bearbeitet von: Maximilian Breymaier (Matrikelnummer: 57214) Christoph Mantsch (Matrikelnummer: 57266) Betreuer: Prof. Dr. Thomas Thierauf Hochschule für Technik und Wirtschaft Aalen Fakultät Elektronik und Informatik Studiengang Informatik

Zusammenfassung Die vorliegende Arbeit gibt einen Überblick über die Ezienz verschiedener Additionsschaltkreise. Dabei werden deren Grundlagen und Funktionsweisen erläutert und veranschaulicht. ˆ Vorstellung von Ripple-Carry, Carry-Look-Ahead und Carry-Save Additionsschaltkreisen ˆ Simulation der Additionsschaltkreise mithilfe von Software ˆ Vergleich der Laufzeit und Gröÿe der Schaltkreise ˆ Der Ripple-Carry Addierer hat die geringste Komplexität ˆ Der Carry-Look-Ahead Addierer weist die geringste Laufzeit auf ˆ Der Carry-Save Addierer kann viele Zahlen gleichzeitig berechnen, ist jedoch ohne weitere Additionsmethode nicht funktionsfähig

Inhaltsverzeichnis Abbildungsverzeichnis............................. 3 Tabellenverzeichnis............................... 4 1 Einleitung 5 1.1 Motivation................................. 5 1.2 Problemstellung und -abgrezung..................... 5 1.3 Ziel der Arbeit.............................. 5 1.4 Vorgehen.................................. 5 2 Technische Grundlagen 6 2.1 Gatterlaufzeit............................... 6 2.2 Funktionen................................ 6 2.3 Logikgatter................................ 7 2.4 Additionsgatter.............................. 8 2.4.1 Halbaddierer........................... 8 2.4.2 Volladdierer............................ 9 3 Hauptteil 11 3.1 Ripple-Carry Addition.......................... 11 3.1.1 Schaltkreis............................. 11 3.1.2 Laufzeit und Aufwand...................... 12 3.2 Carry-Look-Ahead Addition....................... 12 3.2.1 Theorie.............................. 13 3.2.2 Schaltkreis............................. 15 3.2.3 Laufzeit und Aufwand...................... 17 3.3 Carry-Save Addition........................... 18 3.3.1 Schaltkreis............................. 18 3.3.2 Laufzeit und Aufwand...................... 19 3.4 Vergleich.................................. 19 4 Zusammenfassung und Ausblick 21 4.1 Erreichte Ergebnisse........................... 21 4.2 Ausblick.................................. 21 5 Literaturverzeichnis 22

Abbildungsverzeichnis 2.1 UND-Gatter................................ 7 2.2 ODER-Gatter............................... 7 2.3 XOR-Gatter................................ 8 2.4 Halbaddierer................................ 8 2.5 Volladdierer................................ 9 3.1 Schaltung des Ripple-Carry Addierers.................. 12 3.2 Beispiel für Carry-Status......................... 14 3.3 Berechnung Generate und Propagate.................. 15 3.4 Carrylogik................................. 16 3.5 Schaltung des Carry-Look-Ahead Addierers............... 17 3.6 Schaltung des Carry-Save Addierers................... 18 3.7 Carry-Save mit Ripple-Carry Addierer................. 19

Tabellenverzeichnis 2.1 Wahrheitstabelle für UND-Gatter.................... 7 2.2 Wahrheitstabelle für ODER-Gatter................... 7 2.3 Wahrheitstabelle für XOR-Gatter.................... 8 2.4 Wahrheitstabelle für Halbaddierer.................... 9 2.5 Wahrheitstabelle für Volladdierer.................... 10 3.1 Ermittlung des Carry-Status....................... 13 3.2 Fortführung des Carry-Status...................... 13 3.3 Beispiel für Präxberechnung...................... 15 3.4 Vergleich der Schaltkreise........................ 19

1 Einleitung 1.1 Motivation Um eine bestmögliche Auswahl bei der Addition mittels eines Computers zu treen, müssen verschiedene Schaltkreise, die zu diesem Zweck dienen, in ihrer Ezienz (Gröÿe und Berechnungsdauer) untersucht und verglichen werden. 1.2 Problemstellung und -abgrezung Es werden verschiedene Ansätze zur Addition untersucht. Der Versuchsablauf wird mittels einer Software simuliert und nicht physisch aufgebaut. 1.3 Ziel der Arbeit Ziel ist es, aus den vorgestellten Schaltkreisen den eektivsten zu bestimmen. 1.4 Vorgehen Zunächst werden die Grundlagen der Digitaltechnik, die zum Aufbau eines Schaltkreises notwendig sind, vorgestellt. Dies umfasst logische Operatoren wie UND-, ODER-, XOR-Gatter und deren Zusammenschluss zu Halb- und Volladdierern. Mit diesem Vorwissen werden die verschiedenen Schaltkreise (Ripple-Carry, Carry-Look- Ahead und Carry-Save) in ihren grundlegenden Arbeitsweisen erklärt, mit der Software LogikSim aufgebaut und zuletzt miteinander verglichen.

2 Technische Grundlagen 2.1 Gatterlaufzeit Jedes Logikgatter einer Schaltung benötigt eine bestimmte Zeit zur Verarbeitung der Signale vom Eingang zum Ausgang. Diese Zeit liegt ein einzelnes Gatter üblicherweise im Nanosekundenbereich. Die Laufzeit wird jedoch kontinuierlich gröÿer, je mehr Gatter hintereinander geschaltet sind. Hat ein Gatter beispielsweise eine Gatterlaufzeit von 100ns, so wird bei Hintereinanderschalten von sechs Gattern dieses Typs bereits eine Laufzeit von 600ns benötigt. 2.2 Funktionen Zur binären Additionsrechnung werden grundlegend zwei Funktionen verwendet, Majority und Parity. Die Majority-Funktion gibt den Wert aus, der bei den Eingängen am häugsten vertreten ist. Die Parity gibt den Wert 1 aus, wenn eine ungerade Anzahl an 1en bei den Eingangssignalen vertreten ist. majority(a, b, c) = (a b) (b c) (a c) parity(a, b, c) = a b c Die Funktionen könnten theoretisch mit mehreren Eingängen arbeiten, für den Zweck dieser Arbeit sind drei Eingänge jedoch ausreichend.

2 Technische Grundlagen 7 2.3 Logikgatter Zur Realisierung der Additionsverfahren, die in dieser Arbeit vorgestellt werden, sind drei Typen Logikgatter erforderlich: UND-Gatter Abbildung 2.1: UND-Gatter a b S 0 0 0 0 1 0 1 0 0 1 1 1 Tabelle 2.1: Wahrheitstabelle für UND-Gatter ODER-Gatter Abbildung 2.2: ODER-Gatter a b S 0 0 0 0 1 1 1 0 1 1 1 1 Tabelle 2.2: Wahrheitstabelle für ODER-Gatter

2 Technische Grundlagen 8 XOR-Gatter Abbildung 2.3: XOR-Gatter a b S 0 0 0 0 1 1 1 0 1 1 1 0 Tabelle 2.3: Wahrheitstabelle für XOR-Gatter 2.4 Additionsgatter 2.4.1 Halbaddierer Ein Halbaddierer ist der grundlegendste Schaltkreis zur Addition von zwei Bits. Als Eingang werden zwei Bits übergeben, die mithilfe eines UND-Gatters ein Summenbit und mittels eines XOR-Gatters ein Übertragsbit (Carry) ausgeben. Abbildung 2.4: Halbaddierer

2 Technische Grundlagen 9 a b C S 0 0 0 0 0 1 0 1 1 0 0 1 1 1 1 0 Tabelle 2.4: Wahrheitstabelle für Halbaddierer 2.4.2 Volladdierer Die erweiterte Variante eines Halbaddierers ist der Volladdierer, der einen Eingang mehr besitzt. Ein Volladdierer besteht aus zwei Halbaddierern und einem ODER- Gatter. Das resultierende Übertragsbit lässt sich durch die Majority-Funktion bestimmen, das Summenbit durch die Parity-Funktion. Abbildung 2.5: Volladdierer

2 Technische Grundlagen 10 a b Cin Cout S 0 0 0 0 0 0 0 1 0 1 0 1 0 0 1 0 1 1 1 0 1 0 0 0 1 1 0 1 1 0 1 1 0 1 0 1 1 1 1 1 Tabelle 2.5: Wahrheitstabelle für Volladdierer Zunächst wird das Summenbit und das Übertragsbit des ersten Halbaddierers mit den Eingängen a und b ausgegeben. Das Summenbit und der Carry-in sind nun die Eingänge des zweiten Halbaddierers und geben das Summenbit des Volladierers und ein weiteres Übertragsbit aus. Die Übertragsbits der Halbaddierer geben mit dem ODER-Gatter den Carry-out des Volladdierers aus.

3 Hauptteil 3.1 Ripple-Carry Addition Die einfachste Additionsmethode ist die Ripple-Carry Addition (dt. rieselnder Übertrag). Sie funktioniert nach dem klassischen Prinzip der schriftlichen Addition bzw. Schulmethode. Hierbei werden die Zahlen stellenweise von der niederwertigsten zur höchstwertigsten Stelle zusammenaddiert, wobei jeweils der Übertrag übernommen und mit der nächsthöheren Stelle mitaddiert wird. 1 1 0 1 + 1 0 1 1 1 1 0 0 0 Zunächst werden die letzten Stellen der beiden Binärzahlen addiert. Entsteht hierbei ein Übertrag, wird dieser in die Berechnung der nächsten Stelle übernommen und dort mit den entsprechenden Stellen der beiden Zahlen aufaddiert. Auf diese Weise wird so lange verfahren, bis sämtliche Stellen abgearbeitet sind. 3.1.1 Schaltkreis Diese Vorgehensweise der Addition nutzt der Ripple-Carry Addierer direkt in Form eines Schaltkreises. Für jede zu addierende Stelle wird ein Volladdierer benötigt, lediglich für die niederwertigste Stelle ist ein Halbaddierer ausreichend. Für n-bit Zahlen werden demnach n-1 Volladdierer und ein Halbaddierer benötigt.

3 Hauptteil 12 Abbildung 3.1: Schaltung des Ripple-Carry Addierers An der Stelle 0 werden A0 und B0 addiert. Das Ergebnis S0 wird ausgegeben und der Übertrag C0 an den nächsten Volladdierer übergeben und mit A1 und B1 addiert. Dies geschieht bis zum letzten vorhandenen Volladierer, bei dem sowohl das Ergebnis, wie auch der Übertrag ausgegeben werden. Der Übertrag hat hierbei den höheren Stellenwert. In Abb. 3.1 werden die selben Zahlen berechnet, wie bei der gezeigten Schulmethodik, beim Vergleich sieht man, dass das selbe Ergebnis erzielt wird. 3.1.2 Laufzeit und Aufwand Der Ripple-Carry Addierer berechnet sequentiell. Dadurch, dass der Volladdierer an der Stelle n abhängig von dem an der Stelle n-1 ist, wird die Berechnungszeit mit jedem zusätzlichen linear gröÿer. Bei n-bit Zahlen wäre die Laufzeit O(n). Da für n-bit-zahlen auch nur n Gatter notwendig sind ist die Gröÿe des Schaltkreises ebenfalls bei O(n). 3.2 Carry-Look-Ahead Addition Der Ripple-Carry Addierer hat durch seinen sequentiellen Ablauf eine hohe Laufzeit. Um die Laufzeit zu verkürzen muss man von einer sequentiellen zu einer parallelen Lösung nden. Eine dieser Lösungen ist der Carry-Look-Ahead Addierer. Der Carry- Look-Ahead Addierer wird auch als Parallelrechner mit Übertragsvorausberechnung bezeichnet.

3 Hauptteil 13 3.2.1 Theorie Carry-Status Da Überträge durch die Majority-Funktion entstehen, kann man, ohne die Berücksichtigung des vorherigen Übertrags die Aussage stellen: c i = c i 1 = b i 1 (wenn a i 1 = b i 1 ) So wird ein Übertrag erzeugt (c i = 1) oder der Übertrag auf 0 gezwungen, da selbst der Carry c i 1 allein keinen erzeugen kann. Ersteres wird als Generate, letzteres als Kill bezeichnet. Gilt a i 1 b i 1, so wird nur der vorherige Übertrag c i 1 weitergeleitet, d.h. c i = c i 1 a i 1 b i 1 c i Carry-Status 0 0 0 k 0 1 c i 1 p 1 0 c i 1 p 1 1 1 g Tabelle 3.1: Ermittlung des Carry-Status Durch dieses Prinzip können Carry-Status durch die vorherigen bestimmt werden. Schaltet man beispielsweise zwei Volladdierer hintereinander (V A i und V A i+1 ) werden folgende Status für c i+1 kombiniert: F A i+1 k p g k k k g F A i p k p g g k g g Tabelle 3.2: Fortführung des Carry-Status Somit ergibt sich ein Operator für Carry-Status, der nicht kommutativ ist.

3 Hauptteil 14 Abbildung 3.2: Beispiel für Carry-Status Präx-Berechnung Mit dem Carry-Status-Operator (Zeichen ) denieren wir nun x 0 = k k wenn a i 1 = b i 1 = 0 x i = p wenn a i 1 b i 1 g wenn a i 1 = b i 1 = 1 für i = 1,..., n und y 0 = k y i = y i 1 x i = x 0 x 1 x 2... x i für i = 1,..., n Hierbei ist y i der Präx für x 0... x n. Die Berechnung der Werte y 0, y 1,..., y n wird als Präx-Berechnung bezeichnet. y i = k impliziert c i = 0, y i = g impliziert c i = 1 und y i = p tritt nicht auf. Für a = 1001 und b = 1011 sieht das Ergebnis wie folgt aus:

3 Hauptteil 15 i 5 4 3 2 1 a i 1 0 0 1 b i 1 0 1 1 x i g k p g k y i g k g g k c i 1 0 1 1 0 Tabelle 3.3: Beispiel für Präxberechnung 3.2.2 Schaltkreis Erste Phase: Generate und Propagate Für jede Bitstelle wird ein Halbaddierer benötigt, der einen Generate und einen Propagate ausgibt. g i = a i b i p i = a i b i Abbildung 3.3: Berechnung Generate und Propagate Zweite Phase: Carrylogik Die Carrylogik zieht dabei alle Möglichkeiten in Betracht, wie ein Übertragsbit entstehen kann. Mithilfe des Generates g i und des Propagates p i kann nun die Carrylogik den Carry c i+1 ermitteln. c i+1 = g i p i c i

3 Hauptteil 16 Abbildung 3.4: Carrylogik Beispiel der Carryermittlung bei 3-Bit Wörtern: c 1 = g 0 p 0 c 0 c 2 = g 1 p 1 c 1 = g 1 p 1 g 0 p 1 p 0 c 0 c 3 = g 2 p 2 c 2 = g 2 p 2 g 1 p 2 p 1 c 1 = g 2 p 2 g 1 p 2 p 1 g 0 p 2 p 1 p 0 c 0 Beispiel der Carry-Ermittlung an c2 Der Carry c 2 wird mit der Formel c 2 = g 1 p 1 g 0 p 1 p 0 c 0 berechnet. Das heiÿt, es wird entweder g 1 = 1, p 1 g 0 = 1 oder p 1 p 0 c 0 = 1 gelten. Entsteht ein Übertragsbit durch g 1, sind a 1 und b 1 aktiv, wodurch p 1 = 0 sein muss und dadurch ein Übertragsbit durch die anderen Möglichkeiten ausgeschlossen ist. 1 x + 1 y C 1 0 0 Für den Fall, dass p 1 = 1 ist (d.h. g 1 muss 0 sein), gilt entweder a 1 = 1 oder b 1 = 1. Damit hier ein Übertragsbit entstehen kann, gibt es zwei Möglichkeiten: ˆ g 0 = a 0 b 0 = 1 p 1 g 0 = 1 (Übertragsbit durch g 0 ) 0 1 + 1 1 C 1 1 0 ˆ p 0 = a 0 b 0 = 1 und c 0 = 1 (Fall nicht praxisbezogen, da c 0 nie den Wert 1 hat)

3 Hauptteil 17 Dritte Phase: Summenlogik Zuletzt wird der ermittelte Carry c i mit dem zuvor ermittelten Propagate p i zu einer Summe s i mittels eines XOR-Gatters zusammengefügt (Summenlogik). Der höchstwertige Carry steht hierbei für sich alleine. s i = c i p i Abbildung 3.5: Schaltung des Carry-Look-Ahead Addierers 3.2.3 Laufzeit und Aufwand Der Carry-Look-Ahead Addierer arbeitet im Bezug auf die Bitstellen parallel, jedoch gibt es trotzdem mehrere Stufen, die sequentiell abgearbeitet werden müssen. Dies sind die Ebene, in der die Generates und Propagates erstellt werden, die Carrylogik und die Summenlogik. Die Gröÿe des Carry-Look-Ahead Addierer steigt mit jeder Bitstelle schneller, da die Carrylogik in den höheren Bitstellen alle darunterliegenden Propagates und Generates mitberechnen muss. Es ergibt sich hieraus eine Laufzeit von O(log(n)) bei einer Gröÿe von O(n).

3 Hauptteil 18 3.3 Carry-Save Addition Mittels Ripple-Carry und Carry-Look-Ahead lassen sich jeweils nur zwei Zahlen addieren. Um eine gröÿere Anzahl an Zahlen zu addieren ist es erforderlich, diese in mehreren Durchläufen nach und nach aufzuaddieren. Mit dem Carry-Save Addierer können mehrere Zahlen zunächst auf zwei Zahlen reduziert werden und somit in einem Schritt zusammenaddiert werden. Da die Ausgabe des Carry-Save Addierers zwei Zahlen sind, macht diese Methode erst ab drei Zahlen Sinn. Die Ergebnisse des Carry-Save Addierers müssen noch mit einem konventionellen Addierer (bspw. die bereits erwähnten Ripple-Carry oder Carry-Look-Ahead) zusammenaddiert werden. 1 1 1 + 1 0 1 + 1 1 0 C 1 1 1 0 S 1 0 0 Die erste Übertragsstelle ist immer 0. Von jeder Stelle wird die Parity und Majority erstellt und ausgegeben, wobei die Majority jeweils für die nächsthöhere Übertragsstelle gilt. 3.3.1 Schaltkreis Zur Realisierung des Carry-Save Addierers werden für n-bit Zahlen nur n Volladdierer benötigt. Abbildung 3.6: Schaltung des Carry-Save Addierers

3 Hauptteil 19 Für jede Stelle wird ein entsprechendes Übertrags- und Ergebnisbit ausgegeben. Diese müssen noch mittels einer anderen Additionsmethode zusammenaddiert werden. Je nach Anforderung kann hierfür ein Ripple-Carry, Carry-Look-Ahead oder ein anderer Addierer verwendet werden. Abbildung 3.7: Carry-Save mit Ripple-Carry Addierer 3.3.2 Laufzeit und Aufwand Da jede Bitstelle für sich einen Übertrag und ein Ergebnis ausgibt, arbeitet der Carry-Save Addierer parallel. Jede Bitstelle benötigt einen Volladdierer, demnach ist die Laufzeit O(1) und die Gröÿe O(n). Dennoch muss beachtet werden, dass sowohl Laufzeit, wie auch Gröÿe sich ändern je nachdem welche Methode zur Addition der beiden Zahlen verwendet wird. 3.4 Vergleich Ripple-Carry Carry-Look-Ahead Carry-Save Laufzeit O(n) O(log(n)) O(1) Gröÿe (Anzahl Gatter) O(n) O(n) O(n) Tabelle 3.4: Vergleich der Schaltkreise

3 Hauptteil 20 Der Carry-Look-Ahead Addierer ist von der Laufzeit der Beste. Der Carry-Save Addierer sticht besonders durch seine konstante Laufzeit hervor, jedoch ist er nicht ohne anderen Addierer funktionsfähig. Den Ripple-Carry Addierer zeichnet das besonders einfache Schaltungsdesign aus, jedoch hat er durch die sequentielle Funktionsweise die höchste Laufzeit der drei betrachteten Methoden.

4 Zusammenfassung und Ausblick 4.1 Erreichte Ergebnisse Von den vorgestellten Schaltkreisen zur Addition stellt sich keiner als der Ezienteste heraus. Durch die konstante Laufzeit und der Eigenschaft viele Zahlen gleichzeitig zu berechnen wäre der Carry-Save Addierer theoretisch der Beste der drei getesteten Schaltkreise. Aufgrund der zwei Ergebniswerte, die zusätzlich von einer anderen Additionsart verrechnet werden müssen, ist der Carry-Save Addierer von der Laufzeit der verwendeten Additionsart abhängig. 4.2 Ausblick Die Eigenschaft des Carry-Save Addierers viele Zahlen mit geringer Laufzeit zu verrechnen gibt die Grundlage für einen Schaltkreis zur Multiplikation (unter der Voraussetzung von gleichen Zahlen an den Eingängen). Die Ezienz dieses Schaltkreises zur Multiplikation kann in einer folgenden Arbeit untersucht und mit anderen existierenden Schaltkreisen verglichen werden.

5 Literaturverzeichnis [1] Arithmetic Circuits.pdf. Buchauszug zur Verfügung gestellt von Prof. Dr. Thierauf.