Teil II 2.2 Standard-Schaltnetze als Grundlage für Rechner Addier- und Multiplizierwerke – Halb-Addierer, Voll-Addierer – Multiplizierer Schaltnetze zur Auswahl von Adress- und Datenleitungen – Multiplexer – Demultiplexer Schaltnetze zum Vergleich von Datenwörtern – Komparator Codierer und Decodierer Programmierbare Schaltnetze (PLA) arithmetisch-logische Einheit (ALU) – parametrisierbare Schaltnetze – arithmetische Einheiten und ALUs

(charkteristische DMFF ) Schaltnetze Definition: Schaltnetze Ein Schaltnetz F ist die technische Realisierung einer n-stelligen m-wertigen booleschen Funktion f: {0, 1}n → {0, 1}m wobei f aus m 1-wertigen booleschen Schaltfunktionen fi : {0, 1}n → {0, 1} aufgebaut ist. Ein Schaltnetz bildet somit ein n-Tupel von Eingabevariablen e = (e1 .... en ) ab auf ein m-Tupel (a1 .... am ) von Ausgabevariablen. Schreibweise: f(e) = f(e1 .... en ) → (f1(e), f2(e), ... , fm(e)) = (a1 .... am ) = f(e) Schaubild: e1 e2 . . . en f1(e1 ... en) f2(e1 ... en) fm(e1 ... en) Schaltnetz F (charkteristische DMFF ) e f(e) . . . Anmerkung: Schaltnetze haben „kombinatorisches“ Schaltverhalten. Das heißt, die Ausgabewerte hängen nur von den Werten der Eingänge ab.

Entwurf vs. Analyse von Schaltnetzen Beschreibung des Anendungsproblems Für F Funktionsgleichung oder Wertetabelle aufstellen Blockschaltbilder durch Detailaufbau ersetzen Falls F m-wertig, F aufteilen in f1, .., fm In der „Gatter-Ansicht“ von den Ausgängen her beschreibenden Term für die Schaltfunktion rekonstruieren. Minterme und DNF fi aufstellen DMFF = DMFf1 ... DMFfm bestimmen DMFF bestimmen 2-stufiges Schaltnetz ableiten und zeichnen (evtl. Gatter gemeinsam nutzen) charakteristische DMFF Wertetabelle für F

Halb-Addierer =1 HA & Definition: Ein Halb-Addierer ist ein Schaltnetz, das als Eingabe zwei binäre Ziffern e1 und e2 erhält, diese addiert und das Ergebnis mit zwei Ausgängen darstellt: s (arithmetische Summe) c (Carry, Übertrag) Charakteristische DMFHA : s = e1e'2 + e'1e2 = e1  e2 = DMFS c = e1e2 = DMFC Werte-Tabelle Realisierung mit: UND-Gatter plus XOR-Gatter Blockschaltbild: e1 e2 c s 0 0 0 0 0 1 0 1 1 0 0 1 1 1 1 0 e1 e2 =1 & c s e1 e2 c HA s

Voll-Addierer Aufgabe: Gegeben: zwei n-stellige Binärzahlen: x=(xn-1 .... x0) und y=(yn-1 .... y0) Gesucht: Schaltnetz zur Berechnung der Summe: x + y (Beachte: das Zeichen „+“ steht hier für die Addition!) Ansatz: modularer Aufbau aus Addierern für die einzelnen Ziffern xi und yi Problem: an den Stellen i > 0 muss eventuell ein Übertrag aus der Addition der vorangegangenen Stelle (i-1) berücksichtigt werden. x + y = (ex,n-1 . . . ex,1ex,0) + (ey,n-1 . . . ey,1ey,0) = (sn sn-1 . . . s1 s0) . . . u.U. Übertrag pro Ziffer evtl. Gesamt-Übertrag => Halb-Addierer können nicht verwendet werden, da sie nur 2 Eingänge haben. Wegen evtl. Übertrag braucht man einen weiteren Eingang!

Aufstellung einer Wertetabelle für Addierer an Stelle i x + y = (ex,n-1 . . . ex,1ex,0) + (ey,n-1 . . . ey,1ey,0) = (sn sn-1 . . . s1 s0) evtl. Gesamt-Übertrag . . . u.U. Übertrag pro Ziffer Werte-Tabelle für FVA Funktionsgleichungen für si und ci si = (ex,i  ey,i )  ci-1 (ungerade Eingänge) ci = e'x,i ey,ici-1+ex,i e'y,ici-1+ ex,i ey,ic'i-1 + ex,iey,ici-1 = (ex,i  ey,i ) ci-1 + ex,i ey,i ex,i ey,i ci-1 ci si 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

Abbilden der Addier-Funktion auf ein Schaltnetz Funktionsgleichungen für si und ci si = (ex,i  ey,i )  ci-1 Idee: Ein XOR-Gatter lässt sich ci = (ex,i  ey,i ) ci-1 + ex,i ey,i gemeinsam nutzen. Blockschaltbild: Voll-Addierer (FA = Full Adder) Realisierung von FVA =1 =1 FA ci ci-1 si ex,i ey,i si & 1 ci & ex,i ey,i ci-1

Alternative: Aufbau des Voll-Addierers aus zwei Halb-Addierern Ansatz: Komposition der Funktion der FVA aus der Funktion FHA Realisierung von FVA durch Kopplung zweier Halb-Addierer 1. Halb-Addierer 2. Halb-Addierer ex,i ey,i ci-1 si ci

Parallel-Addierer (für n-stellige Binärzahlen) Ausgangssituation: x + y = (ex,n-1 . . . ex,1ex,0) + (ey,n-1 . . . ey,1ey,0) = (sn sn-1 . . . s1 s0) evtl. Gesamt-Übertrag . . . Ansatz: Ein Addierer für zwei n-stellige Binärzahlen lässt sich realisieren, indem man n Voll-Addierer parallel anordnet zu einem Addierer, bei dem der Übertrag von rechts nach links durchläuft. Verdrahtung gemäß folgendem Schema: ex,n ey,n ex,3 ey,3 ex,2 ey,2 ex,1 ey,1 c3 c2 c1 c0 = 0 cn-1 cn FA FA FA FA . . . sn s3 s2 s1

n-Bit Parallel-Addierer a + b = (ea,3ea,2 ea,1ea,0) + (eb,3eb,2 eb,1eb,0) = s Blockschaltbild (n=4) b a 3 2 1 0 3 2 1 0 4-Bit-PA c 3 2 1 s Addierer mit durchlaufendem Übertrag werden auch als Ripple-Carry Addierer bezeichnet (Ripple = „Durchplätschern“). Weil der Übertrag durch alle Glieder durchgereicht wird, ergeben sich lange Schaltzeiten (proportional zur Stelligkeit n). => Nur der Aufbau ist parallel, nicht die Arbeitsweise! Frage: Kann man auch echt parallel addieren? Antwort: Ja, siehe Vertiefungsfoliensatz

Modularer Aufbau komplexer Schaltungen Komplexe Schaltungen werden aus Moduln aufgebaut. Auf höheren Ebenen abstrahiert man vom Aufbau elementarer Module. Details werden in einer "Black-Box" versteckt. a1 ... a4 b1 b4 y1 y2 y3 Schaltnetz F Ebene 3 (als Black-Box) Schritt 2 (gemischt) Ebene 1 (alle Details) a = 1-Bit-Komp < b > a3 a2 a1 a0 b3 b2 b1 b0 & 1 ai = bi y1 y2 y3 a b D-FF 2 D-FF 1 D-FF 0 1 & D2 D1 D0 e D-FF 2 D-FF 1 D-FF 0 1 & D2 D1 D0 e D-FF 2 D-FF 1 D-FF 0 1 & D2 D1 D0 e

Paralleler (4-Bit) Mulitplizierer Multiplikation: B3B2B1B0 * A3A2A1A0 = P7P6P5P4P3P2P1P0 & & & & 4-Bit Multiplizierer = &

Paralleler (4-Bit) Mulitplizierer Beispiel: B3B2B1B0 * A3A2A1A0 = P7P6 ... P1P0 1 0 1 1 * 0 1 0 1 = 0 0 1101 1 1 B3 B2 B1 B0 A0 A1 A2 A3 & & & & = 1 0 1 1 * 1 + 1 0 1 1 * 0 + 1 0 1 1 * 1 P7 P6 P5 P4 P3 P2 P1 P0

Auswahl-Schaltnetze a0 e0 a1 e1 e a2 e2 a a3 e3 s1 s0 s1 s0 = a3 = e2 4:1-Multiplexer 1:4-Demultiplexer a0 e0 X X a1 e1 e a2 e2 a X a3 e3 X s1 s0 s1 s0 = a3 1 = e2 1 Anmerkungen: Der am Eingang anliegende Wert X wird unverändert durchgeschaltet.

Multiplexer e0 e1 e2 e3 4:1- Mux a s1 s0 Motivation: Für Steuerungsaufgaben benötigt man Schaltnetze, mit denen man aus einem Leitungsbündel (aus n Leitungen) gezielt eine auswählen kann. Die Auswahl einer bestimmten Leitung soll dabei über Eingabe ihrer binär codierten Nummer erfolgen. Definition: Ein m:1-Multiplexer ist ein Schaltnetz, das aus m = 2n Eingängen e0 ...em-1 den Eingang ei auswählt und unverändert zum Ausgang a durchreicht, dessen Index i mit der Binärzahl übereinstimmt, die an den Steuereingängen s0 ...sn-1 anliegt. Blockschaltbild: 4:1- Multiplexer e0 e1 e2 e3 4:1- Mux a s1 s0

Schaltnetz für 4:1-Multiplexer Werte-Tabelle: Die Belegung der Eingabeleitungen e0e1e2e3 ist für die Logik des Schaltnetzes ohne Bedeutung. Es genügt die (weit weniger aufwendige) Modellierung der Funktion f(s0, s1) = a gemäß: s1 s0 a 0 0 e0 0 1 e1 1 0 e2 1 1 e3 & e0 & e1 1 a & e2 & e3 1 1 s1 s0

Demultiplexer a0 a1 a2 a3 e 1:4- Demux s1 s0 Definition: Ein 1:m-Demultiplexer ist ein Schaltnetz, das ein am Eingang e anliegendes Signal unverändert zu dem Ausgang i durchleitet, dessen Index i mit der Binärzahl übereinstimmt, die an den Steuereingängen s0 ...sn-1 anliegt. a0 a1 a2 a3 e 1:4- Demux s1 s0 Blockschaltbild: 1:4- Anmerkungen: Demultiplexer ist Gegenstück zum Multiplexer. Mit n Steuerleitungen kann man 2n Datenleitungen steuern => Für m Datenleitungen benötigt man log2(m) Steuerleitungen.

Vergleich von Binärwörtern: Komparator Motivation: Eine weitere grundlegende Schaltung wird zum Vergleich von n-stelligen Binärwörtern a, b Î {0, 1}n benötigt. Je nach Bedarf entwirft man Schaltnetze für den Test auf: a = b, a < b, a > b bzw. Kombinationen davon. Definition: Ein n-Bit-Komparator vergleicht zwei binärcodierte Zahlen a und b und stellt das Ergebnis an seinen Ausgängen bereit. Beispiel: 1-Bit-Komparator (a, b Î {0, 1}1 Test auf =, < und >) Werte-Tabelle: b a y1 y2 y3 a=b a < b a > b 0 0 1 0 0 0 1 0 0 1 1 0 0 1 0 1 1 1 0 0 DMF's für y1, y2 und y3 ableiten

Schaltnetz für 1-Bit-Komparator DMF: Als Übungsaufgabe! Schaltnetz: & 1 y1 & & y2 & y3 a b y1 a Blockschaltbild: = 1-Bit-Komp < > y2 b y3

Schaltnetz für 4-Bit-Komparator ai = bi a b y1 y2 y3 & a3 ? b3 a = 1-Bit-Komp < b > & a2 ? b2 a = 1-Bit-Komp < b > 1 & a1 ? b1 & a = 1-Bit-Komp < b > a0 ? b0 & a = 1-Bit-Komp < b > 1 & & a3 a2 a1 a0 b3 b2 b1 b0

Codierer Motivation: Man kann n-stellige Binärwörter von einem Schaltnetz zu einem anderen mit n parallelen Leitungen übertragen. Bei langen Binärwörtern ist dies jedoch unpraktisch, da man zu dicke Kable brauchen würde. Beispiel: Fernsteuerung (über Kabel) von n Lampen. Schalter für Auswahl 1:n Wie kann man Leitungen einsparen? n Lampen A B .... .... Frage: Welche Schaltfunktionen müssen die Bauteile A und B erfüllen, um zur Übertragung mit weniger als n Leitungen auszukommen?

Codierer Codierer Code c : E -> A Lösungsansatz: Man codiert das zu übertragende n-stellige Binärwort a als m-stelliges Binärwort b wobei m < n ist. Voraussetzung ist dabei, dass sich das Eingabewort e als m-stelliges Binärwort darstellen lässt und dass, jeweils immer nur einer der Eingänge den Wert 1 hat. Dies ist der Fall, wenn man n = 2m Eingänge und m Ausgänge hat und weiß, dass jeweils immer nur einer der Eingänge den Wert 1 hat. Ausgangs-Variable a=(a1 .... am) Eingangs-Variable e=(e1 .... en) .... Codierer .... Code c : E -> A Das heißt, Zeichen des Codes E {0, 1}n werden abgebildet auf Wörter aus A = {0, 1}m.

Codierer Definition: Ein Codierer ist ein Schaltnetz, das ein n-stelliges binäres Eingabezeichen auf ein m-stelliges binäres Codewort abbildet. Beispiel: 8:3-Codierer (8 Eingänge, 3 Ausgänge) Anwendung: Gegeben sind 8 Eingansleitungen, von denen jeweils nur eine aktiv (=1) ist. Codierer soll als 3-stellige Binärzahl angeben, welcher Eingang aktiv ist. e7 e6 e5 e4 e3 e2 e1 e0 a2 a1 a0 dezimal 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 1 0 0 0 1 0 2 0 0 0 0 1 0 0 0 0 1 1 3 0 0 0 1 0 0 0 0 1 0 0 4 0 0 1 0 0 0 0 0 1 0 1 5 0 1 0 0 0 0 0 0 1 1 0 6 1 0 0 0 0 0 0 0 1 1 1 7 Werte-Tabelle für 8:3-Codierer:

Codierer Problem: Für die 8 Eingänge gibt es insgesamt 28 verschiedene Belegungen. In der Werte-Tabelle werden aber nur 8 berücksichtigt. Was ist, wenn ein anderer Eingabewert anliegt ? Ausweg: Führe Prioritisierung ein, d.h. berücksichtige nur das höchste gesetzte BIT (MSB-Priorität, Most Significant BIT) e7 e6 e5 e4 e3 e2 e1 e0 a2 a1 a0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 x 0 0 1 0 0 0 0 0 1 x x 0 1 0 0 0 0 0 1 x x x 0 1 1 0 0 0 1 x x x x 1 0 0 0 0 1 x x x x x 1 0 1 0 1 x x x x x x 1 1 0 1 x x x x x x x 1 1 1 Werte-Tabelle für 8:3-Codierer Unterhalb der Diagonalen stehen nur x-Einträge (für „don't care“ ). Man kann x nach freier Wahl mit 0 oder 1 belegen, da diese Stelle nichts an der Abbildung ändert.

Schaltnetz-Entwurf für 8:3-Codierer Ansatz: Die Erstellung der DNF's wird für a2 a1 und a0 sehr umfangreich. Da MSB-Priorität eingeführt wurde, ergibt sich eine wesentliche Vereinfachung => DMF durch Termumformung bestimmen. e7 e6 e5 e4 e3 e2 e1 e0 a2 a1 a0 für a2 für a1 für a0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 x 0 0 1 e'7 ...e'2 e1 0 0 0 0 0 1 x x 0 1 0 e'7 ...e'3 e2 0 0 0 0 1 x x x 0 1 1 e'7 ...e'4 e3 e'7 ...e'4 e3 0 0 0 1 x x x x 1 0 0 e'7 e'6 e'5 e4 0 0 1 x x x x x 1 0 1 e'7 e'6 e5 e'7 e'6 e5 0 1 x x x x x x 1 1 0 e'7 e6 e'7 e6 1 x x x x x x x 1 1 1 e7 e7 e7 a2 = e7 + e'7 e6 + e'7 e'6 e5 + e'7 e'6 e'5 e4 a1 = e7 + e'7 e6 + e'7 ...e'4 e3 + e'7 ...e'3 e2 a0 = e7 + e'7 e'6 e5 + e'7 ...e'4 e3 + e'7 ...e'2 e1

Schaltnetz-Entwurf für 8-3-Codierer Nach Vereinfachung: a2 = e7 + e'7 e6 + e'7 e'6 e5 + e'7 e'6 e'5 e4 => e7 + e6 + e5 + e4 (wegen Abarbeitung von links nach rechts) a1 = e7 + e'7 e6 + e'7 ...e'4 e3 + e'7 ...e'3 e2 => e7 + e6 + e3 + e2 (wegen Abarbeitung von links nach rechts) a0 = e7 + e'7 e'6 e5 + e'7 ...e'4 e3 + e'7 ...e'2 e1 => e7 + e5 + e3 + e1 (wegen Abarbeitung von links nach rechts) Blockschaltbild: 8:3-Codierer 0 2 1 1 2 0 7 8 : 3 coder a e . . V Ausgang V zeigt an, ob eine gültige Eingangskombination anlag

Decodierer Definition: Ein Decodierer (für Zählcodierung) bildet eine m-stellige Binärzahl e so auf 2m Ausgänge ab, dass genau der Ausgang 1 wird, dessen Index durch die Binärzahl e gegeben ist. Ein m:n-Decodierer ist somit das Gegenstück zum n:m-Codierer. Beispiel: 3:8-Deodierer (3Eingänge, 23 = 8 Ausgänge) Index e2 e1 e0 a7 a6 a5 a4 a3 a2 a1 a0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 1 0 2 0 1 0 0 0 0 0 0 1 0 0 3 0 1 1 0 0 0 0 1 0 0 0 4 1 0 0 0 0 0 1 0 0 0 0 5 1 0 1 0 0 1 0 0 0 0 0 6 1 1 0 0 1 0 0 0 0 0 0 7 1 1 1 1 0 0 0 0 0 0 0 Werte-Tabelle für 3:8-Decodierer:

Schaltnetz-Entwurf für 8-3-Codierer Blockschaltbild: 3:8-Decodierer e 3 : 8 decoder a . . Kontrolleingang E steuert, zu welchem Zeitpunkt die Decodierung erfolgen soll. E Kopplung von Codierer und Decodierer zur Informationsübertragung a 8 : 3 coder 3 : 8 decoder e . . . . . . E V

Programmierbare Schaltnetze Motivation: Der physische Aufbau eines Schaltnetzes aus Elementargattern und Moduln ist aufwändig. Abhilfe bieten sog. PLA-Bausteine (Programmable Logic Array). Prinzip: Liegt eine n-stellige m-wertige boolesche Funktion in einer disjunktiven Form (z.B. in DNF oder DMF) vor, so lässt diese sich stets mit einem 2-stufigen Schaltnetzwerk realisieren, wobei: – die erste Stufe aus UND-Gattern besteht und – die zweite Stufe aus ODER-Gattern Man wählt eine matrix-artige Anordnung (Logikfeld), das in einen UND-Bereich sowie in einen ODER-Bereich unterteilt wird. – Im UND-Bereich stehen alle Eingänge unverändert sowie negiert zur Verfügung. – Aus dem ODER-Bereich werden die Ausgänge herausgeführt. DMF's für y1, y2 und y3 ableiten

PLA-Schema zur Realisierung eines Schaltnetzes UND-Bereich ODER-Bereich Minterme der DMF & . . . M1 M2 & . . . . . . . . . . . . . . . & . . . 1 1 1 DMF's für y1, y2 und y3 ableiten 1 1 1 e1 e2 . . . en n Eingänge a1 a2 . . . am m Ausgänge Anmerkung: Auch eine nur durchzuführende Eingangsvariable ei wird über die Gatter geleitet.

PLA-Schema zur Realisierung eines Schaltnetzes Beispiel: Gegeben: 2-wertige Funktion f(a, b, c) = (z1, z2) mit: z1 = ab' + a'c +a'bc = ab' + a'c + a'cb = ab' +a'c z2 = a(b +c') + b(a' + c) +ab' = a + b (nachrechnen!) UND-Matrix ODER-Matrix ab' + a'c a b DMF's für y1, y2 und y3 ableiten a b c z1 z2 Eingänge Ausgänge

Lernprogramm für den Schaltnetz-Entwurf Quelle: Lern-CD zum Buch: Rechnergrundlagen. Von der Binärlogik zum Schaltwerk von Rainer Kelch.

Varianten programmierbarer Schaltnetze PLA (Programmable Logic Array) UND- und ODER-Feld programmierbar PAL (Programmable Array Logic) UND-Feld fest, ODER-Feld programmierbar PROM (Programmable Read Only Memory) EPROM (Erasable Programmable Read-Only-Memory), EEPROM (Electrically EPROM) FPGA (Field Programmable Gate Array) (wie PLA jedoch mit nachgeschaltetem Speicherelement) Lösch-fenster UND-Feld ODER-Feld PLA programmierbar programmierbar PAL festverdrahtet programmierbar PROM festverdrahtet programmierbar FPGA programmierbar programmierbar Code zum Booten eines PCs steckt in einem PROM DMF's für y1, y2 und y3 ableiten

Parametrisierbare Schaltnetze Motivation: Hält man in einer mehr-stelligen boolesche Funktion f: {0, 1}n → {0, 1} mit f(e) = f(e1 .... en ) → a die Eingabewerte 2 bis n konstant, so erhält man eine 1-stellige Funktion fe2e3...en(e1) → a In diesem Fall betrachtet man die Eingabewerte e2 .... en als Parameter und nur e1 als Funktionsvariable, die auf einen Ausgabewert abgebildet werden soll. Über die Parameter hat man dann eine Möglichkeit geschaffen, das Verhalten der einstelligen Funktion fe2e3...en(e1) → a zu steuern. Diese Technik bildet die Grundlage der Realisierung von Befehlen einer programmierbaren Steuereinheit. DMF's für y1, y2 und y3 ableiten Definition: Ein parametrisierbares Schaltnetz ermöglicht es über Steuerleitungen dieselbe Schaltung für unterschiedliche Schaltfunktionen zu nutzen.

Aufbau einer Arithmetischen Einheit Ziel: Ein Bauteil, das über Steuereingänge verfügt, über die man flexibel einstellen kann, welche Schaltfunktion f das Bauteil auf Eingabedaten anwenden soll. d Eingabeleitungen für Daten f s Steuerleitungen m Ausgabeleitungen für Daten Vorteil: Im Gegensatz zu einer programmierbaren Baugruppe (vgl. PLA), könnte man die Schaltfunktion ändern, ohne dabei den Schaltungsaufbau (d.h., die interne Verdrahtung) zu ändern Idee zur Realisierung: Realisierung durch eine parametrisierte Schaltung. Dazu unterteilt man die Eingabewerte einer mehrstelligen boolesche Funktion f: {0, 1}n → {0, 1}m mit f(e) = f(e1 .... en ) → (a1 .... am ) = a in s Steuereingaben F0 ... Fs und d Dateneingaben D0 ... Dd mit s+d = n. Man erhält so die d-stellige parametrisierte Funktion: f(F0 , ..., Fs, D0 , ..., Dd) → a oder alternativ: fF0...Fs(D0 .... Dd) → a DMF's für y1, y2 und y3 ableiten

Parametrisierbare Schaltnetze F0 F1 fF0,F1(x) Interpretation von fF0,F1 0 0 0 Nullfunktion 0 1 x' Negation 1 0 x Identität 1 1 1 Einsfunktion Beispiel: fF0,F1(x) = y Schaltnetz zur Realisierung von fF0,F1(x) = y Eingabeleitung x F0 F1 Verwendung als Steuerleitungen & & 1 fF0,F1(x) = y = F0x + F1 x' Ausgabeleitung y

Kernzelle einer Arithmetischen Einheit (AU) Ansatz: Kombination einer parametrisierten Schaltung mit einem Voll-Addierer, wobei die parametrisierte Schaltung einem Eingang des Voll-Addierers vorgeschaltet wird. Ausgabe fF0,F1(xi , yi) hängt ab von: den Eingabevariablen xi und yi, den beiden Steuerparametern F0 und F1 mit denen eine Funktion fF0,F1 ausgewählt wird, dem Parameter ci (Carry) signalisiert, ob bei der Addition ein Übertrag zu berücksichtigen ist, dem zusätzlichem Ausgabewert ci+1 der angibt, ob bei einer durchgeführten Addition ein Übertrag aufgetreten ist. F0 F1 fF0,F1(xi , yi) 1 & FA xi yi ci+1 ci pi AU

Kernzelle einer Arithmetischen Einheit (AU) F0 F1 AU xi yi ci+1 ci fi 2er-Komplement (vgl. Kapitel 1.2) Blockschaltbild der AU 00 (0) 11 (-1) 01 (1) 10 (-2) die von einer AU erzeugten Funktionen F0 F1 ci pF0,F1(yi) Interpretation von fF0,F1,ci(xi, yi) 0 0 0 0 xi 0 0 1 0 xi + 1 (Inkrement) 0 1 0 ¬ yi xi – yi im 1er-Komplement 0 1 1 ¬ yi xi – yi im 2er-Komplement: xi+(2n - yi +1) 1 0 0 yi xi + yi 1 0 1 yi xi + yi + 1 1 1 0 1 xi + 1 1 1 1 1 xi (= xi + 2n)

Aufbau einer n-stelligen Arithmetischen Einheit (AU) aus n einstelligen AUs xn-1 yn-1 xi yi x0 y0 F0 F1 ... ... & & & & & & 1 1 1 pn-1 pi p0 cn FA ci+1 FA c1 FA cn-1 ci ... c0 ... fn-1 fi f0 Kernzelle einer n-stelligen AU an der Stelle i, mit 0  i  n-1

n-Bit AUs AU AU AU n-AU n-AU n-stellige AU mit Blockschaltbildern xn-1 yn-1 xi yi x0 y0 F0 F1 cn AU cn-1 ci+1 AU ci c1 AU c0 . . . . . . fn-1 fi f0 Blockschaltbilder der n-stelligen AU x y x = (x0, ... xi, ... xn-1) y = (y0, ... yi, ... yn-1) n n Eingang c0 ist Überflüssig und wird daher weggelassen. F0 F1 n-AU cn . . . . . . F0 F1 cn n-AU n . . . f = (f0, ... fi, ... fn-1 ) Erg = fF0,F1(x,y)

ALU Definition: Eine arithmetisch-logische Einheit (ALU) ist eine parametrisierte Schaltung, die einen Minimalsatz von sowohl logischen als auch arithmetischen Funktionen realisiert. – „Minimalsatz an logischen Funktionen“ bedeutet, dass ein vollständiges Operatorsystem realisiert ist. – Für die Arithmetik muss mindestens die Addition realisiert sein. Anmerkungen: Eine ALU kann zwei Operanden wahlweise eine logische oder eine arithmetische Verknüpfung zuweisen und diese ausführen. Dateneingänge Blockschaltbild: ALU 16 16 N (Vorzeichenbit) Z (Flag für Wert 0) Steuereingänge ALU 16 Datenausgang

Erweiterung zur ALU (Arithmetische-Logische Einheit) Ziel: erweitere die AU um logische Grundfunktionen, die dann ebenfalls über die Steuereingänge ausgewählt werden können. Ansatz: ergänze weitere Steuerleitung F2 ergänze „Vorschalt-Logik“ des Voll-Addierers xi yi F2 F0 F1 & & & & Anmerkung: Von den 16 möglichen Werten der 3 Steuereingänge F0 F1 F2 und des Eingangs ci werden durch die Verbindung von F2 und ci über ein UND-Gatter nur 4 weitere genutzt. Eingang c0 ist Überflüssig und wird daher weggelassen. 1 1 qi pi ci+1 FA & ci fi

Von der ALU(F0F1 F2) erzeugte Funktionen F0 F1 ci F2 pF0,F1(yi) qF0,F1,F2(xi, yi) fi(xi, yi) Bezeichnung Logische Funktionen 0 0 - 0 0 xi  yi xi  yi Disjunktion 0 1 - 0 ¬ yi xi  ¬yi xi  yi Konjunktion 1 0 - 0 yi xi xi  yi Antivalenz (XOR) 1 1 - 0 1 xi xi Komplement Arithm. Funktionen 0 0 0 1 0 xi xi Identität (Transfer) 0 0 1 1 0 xi xi + 1 Inkrement 0 1 0 1 ¬ yi xi xi – yi Sub. 1er-Komplement 0 1 1 1 ¬ yi xi xi – yi Sub. 2er-Komplement 1 0 0 1 yi xi xi + yi Addition 1 0 1 1 yi xi xi + yi + 1 Addition mit Übertrag 1 1 0 1 1 xi xi – 1 Dekrement 1 1 1 1 1 xi xi Identität (Transfer)  = NAND

Entwicklung von Intel CPUs Core i7 Core i7 3,2 GHz 731 000 000 T Core 2 Duo 2.33 GHz 291 000 000 T Pentium D 3.6 GHz 291 000 000 T Pentium 66 MHz 3 100 000 T Intel 4004 108 KHz 2 300 T Intel 486 25 MHz 1 200 000 T ... Statt wie bisher 775 besitzt der Core i7 nunmehr 1366 Signalkontakte. Im Vergleich zum Vorgänger Core 2 holt Intel bei gleicher Taktfrequenz bis zu 42 Prozent mehr Rechenleistung aus dem Core i7 – ntel Nehalem: 731 Millionen Transistoren auf 263 Quadratmillimetern 1971 1989 1993 2006 2005 2008 Quelle: www.intel.com

Aufbau des Pentium-3-Prozessors von Intel Teil des Steuerwerks Cache für Befehle Steuerung für Adress- & Datenbusse Ganzzahl- Rechenwerk Cache für Daten Gleitpunkt- Rechenwerk TLB: Translation Lookaside Buffer; BTB: Branch Trace Logic Teil des Steuerwerks

Aufbau des Core-i7-Prozessors von Intel 4 Prozessorkerne 4 Prozessorkerne Anschluss des Hauptspeicher Quick Path Interconnect" (QPI). Serielles Interface zur Datenübertragung, z.B. zur Grafikkarte jeder Kern mit je 256 KByte L2-Cache Von allen 4 Kernen gemeinsam genutzter (shared) L3-Cache (8 MByte)

Quelle: Forschungszentrum Jülich Super-Computer Idee Man schaltet viele CPUs zu einem Super-Computer zusammen und lässt diese synchronisiert komplexe Berechnungen ausführen. Beispiel: Blue Gene Serie von IBM 180 Gigaflop/s Node Book = 64 CPUs 5.6 Teraflop/s Rack = 2048 CPUs Blue Gene /L 45.6 Teraflop/s JUBL= 8 Racks = 16348 CPUs ab 2008: Blue Gene /P mit über 1 Billiarde Operationen/Sek Card = 4 CPUs 11.2 Gigaflop/s Node = 2 CPUs Quelle: Forschungszentrum Jülich 5.6 Gigaflop/s