Rechnerstrukturen WS 2012/13

Transkript

1 Rechnerstrukturen WS 2012/13 Boolesche Funktionen und Schaltnetze Schaltnetze Rechner-Arithmetik Addition Bessere Schaltnetze zur Addition Carry-Look-Ahead-Addierer Multiplikation Wallace-Tree Hinweis: Folien teilweise a. d. Basis von Materialien von Thomas Jansen 29. Oktober 2012 Rechnerstrukturen º» Boole. Fkt. 1

2 Schaltnetze bis jetzt Diskussion (theoretischer) Grundlagen Wo bleibt die Hardware? kommt jetzt aber immer noch abstrakt Wunsch Realisierung boolescher Funktionen in Hardware klar brauchen Realisierung einer funktional-vollständigen Menge boolescher Funktionen Erinnerung Realisierung von NAND reicht aus +V x y Beobachtung x realisiert NAND(x, y) y Rechnerstrukturen º» Boole. Fkt. 2

3 Gatter Realisierung mit Transistoren... falsche Ebene! Grundlage hier einfache logische Bausteine (Gatter) Bausteine für Negation, Konjunktion, Disjunktion,... Spielregeln Eingänge mit Variablen oder Konstanten belegt nur Verbindungen von Ausgängen zu Eingängen keine Kreise Ergebnis heißt Schaltnetz Rechnerstrukturen º» Boole. Fkt. 3

4 Symbole für Gatter (1) Funktion DIN DIN EN IEEE y = x x y y x y x y = x 2 x 3 x 2 y 1 x 2 x 3 x 3 y x 2 x 3 y y = x 2 x 3 x 2 x 2 y y x 3 x 3 x 2 x 3 y Rechnerstrukturen º» Boole. Fkt. 4

5 Symbole für Gatter (2) Funktion DIN DIN EN IEEE x y = x 2 x 3 x 2 y 1 x 2 x 3 x 3 >1 y x 2 x 3 y y = x 2 x 3 x 2 x 2 >1 x 3 x 3 y y x 2 x 3 y y = x 2 x 2 y x 2 =1 y x 2 y y y x 2 x 2 x Rechnerstrukturen º» Boole. Fkt. 2 5 y = x 2 x 2 y

6 Schaltnetz-Bewertung Und jetzt beliebige Schaltnetze entwerfen? mindestens relevant Größe und Geschwindigkeit Schaltnetzgröße (= Anzahl der Gatter) wegen Kosten, Stromverbrauch, Verlustleistung, Zuverlässigkeit,... Schaltnetztiefe (= Länge längster Weg Eingang Ausgang) wegen Schaltgeschwindigkeit Fan-In (= max. Anzahl eingehender Kanten) wegen Realisierungsaufwand Fan-Out (= max. Anzahl ausgehender Kanten) wegen Realisierungsaufwand... (z. B. Anzahl Gattertypen, Testbarkeit, Verifizierbarkeit) Rechnerstrukturen º» Boole. Fkt. 6

7 Was wir schon wissen Jede boolesche Funktion kann mit einem {,, }- bzw. einem {,, }-Schaltnetz der Tiefe 3 realisiert werden. Beweis DNF, KNF oder RNF direkt umsetzen Probleme Fan-In des tiefsten Gatters kann extrem groß sein Größe des Schaltnetzes oft inakzeptabel Rechnerstrukturen º» Boole. Fkt. 7

8 Beispiel: DNF f bsp : B 3 B, Wertevektor (1,0,0,0,1,1,1,1) f(,x 2,x 3 ) = x 2 x 3 x 2 x 3 x 2 x 3 x 2 x 3 x 2 x 3 1 x 2 1 >1 f bsp x 3 1 Rechnerstrukturen º» Boole. Fkt. 8

9 Beispiel: RNF f bsp : B 3 B, Wertevektor (1,0,0,0,1,1,1,1) f(,x 2,x 3 ) = x 2 x 3 x 2 x 3 x 2 x 3 x 2 x 3 x 2 x 3 1 x 2 1 =1 f bsp x 3 1 Rechnerstrukturen º» Boole. Fkt. 9

10 Beispiel: KNF f bsp : B 3 B, Wertevektor (1,0,0,0,1,1,1,1) f(,x 2,x 3 ) = ( x 2 x 3 ) ( x 2 x 3 ) ( x 2 x 3 ) >1 x 2 1 >1 f bsp x 3 1 >1 Rechnerstrukturen º» Boole. Fkt. 10

11 eine weitere Beispielfunktion... Multiplexer aber eine in der Praxis sehr wichtige diesmal! MUX d ( y1,y 2,...,y d,x 0,,...,x 2 d 1) = x(y1 y 2 y d ) 2 Beispiel y 1 y 2 y 3 MUX 3 (y 1,y 2,y 3,x 0,,...,x 7 ) x x x x x x x 7 Rechnerstrukturen º» Boole. Fkt. 11

12 Multiplexer Warum ist MUX in der Praxis wichtig? direkte Speicheradressierung OBDD-Realisierung Welche Variablenordnung π? wohl sinnvoll Adressvariablen zuerst denn Wir müssen uns sonst alle Datenvariablen merken! Rechnerstrukturen º» Boole. Fkt. 12

13 OBDD-Realisierung MUX 3 Variablenordnung π = (y 1,y 2,y 3,x 0,,x 2,x 3,x 4,x 5,x 6,x 7 ) y y y y 3 y 3 y 3 y x 0 x 2 x 3 x 4 x 5 x 6 x jeweils x i realisieren x i Rechnerstrukturen º» Boole. Fkt. 13

14 Einfluss von π auf OBDD-Größe Beispiel MUX d gesehen Variablenordnung π = (y 1,y 2,...,y d,x 0,,...,x 2 d 1) Größe des reduzierten πobdds? oben vollständiger Binärbaum über y 1,y 2,...,y d d 1 = 2 d 1 Knoten unten je ein x i -Knoten und zwei Senken 2 d +2 Knoten zusammen 2 d 1+2 d +2 = 2 d+1 +1 Knoten Rechnerstrukturen º» Boole. Fkt. 14

15 Einfluss von π auf OBDD-Größe Beispiel MUX d gesehen Variablenordnung π = (y 1,y 2,...,y d,x 0,,...,x 2 d 1) Größe des reduzierten πobdd 2 d+1 +1 Betrachte Variablenordnung π = (x 0,,...,x 2 d 1,y 1,y 2,...,y d ) Größe des reduzierten πobdds? Behauptung x x {0,1} 2d : nach Lesen von x bzw. x verschiedene Knoten erreicht Beweis durch Widerspruch Rechnerstrukturen º» Boole. Fkt. 15

16 Widerspruchsbeweis zur OBDD-Größe Behauptung x x {0,1} 2d : nach Lesen von x bzw. x verschiedene Knoten erreicht Annahme für x x {0,1} 2d gleiche Knoten v erreicht Betrachte i = min{j x j x j } Betrachte y 1,y 2,...,y d mit (y 1 y 2 y d ) 2 = i Beobachtung MUX d (y 1,y 2,...,y d,x) = x i x i = MUX d (y 1,y 2,...,y d,x ) aber OBDD berechnet gleichen Wert, da gleicher Knoten erreicht also minimales OBDD für π = (x 0,,...,x 2 d 1,y 1,y 2,...,y d ) hat Größe mindestens 2 2d 1 (Binärbaum d. Tiefe 2 d ) d min. OBDD-Größe π = (d,x) min. OBDD-Größe π = (x,d) , Rechnerstrukturen º» Boole. Fkt. 16

17 Schaltnetz für MUX 3 x 0 x 2 x 3 x 4 >1 MUX 3 x 5 x 6 x y 1 y 2 y 3 Rechnerstrukturen º» Boole. Fkt. 17

18 Rechner-Arithmetik klar Rechnen zu können ist für Computer zentral. Was wollen wir hier rechnen? hier nur Grundrechenarten, aber keine Division, also Addition Subtraktion Multiplikation Womit wollen wir hier rechnen? mit ganzen Zahlen mit rationalen Zahlen (IEEE ) Rechnerstrukturen º» Boole. Fkt. 18

19 Addition Wie haben wir das in der Schule gelernt? 1. Summand Summand Übertrag Summe Übertragung auf Binärzahlen 1. Summand Summand Übertrag Summe Rechnerstrukturen º» Boole. Fkt. 19

20 Addition von Binärzahlen Beobachtungen zu den Überträgen 1+1 erzeugt einen Übertrag 0+0 eliminiert einen vorhandenen Übertrag 0+1 und 1+0 reichen einen vorhandenen Übertrag weiter Übertrag ist höchstens 1 Kann man Addition als boolesche Funktion ausdrücken? x y c s f HA : {0,1} 2 {0,1} 2 mit realisiert Addition mit Summenbit s und Übertrag c (Carry) Beobachtung c = x y s = x y Rechnerstrukturen º» Boole. Fkt. 20

21 c = x y s = x y Halbaddierer x y = 1 s c Größe 2 Tiefe 1 x y c s Drückt f HA : {0,1} 2 {0,1} 2 mit wirklich Addition aus? Beobachtung: Nur für isolierte Ziffern, vorheriger Übertrag fehlt! Rechnerstrukturen º» Boole. Fkt. 21

22 Realisierung von Addition als boolesche Funktion c alt x y c s f VA : {0,1} 3 {0,1} 2 mit realisiert Addition mit Summenbit s und Übertrag c (Carry) Beobachtung s = 1 Anzahl der Einsen ungerade s = c alt x y Beobachtung c = 1 Anzahl Einsen 2 direkte Realisierung c = x y x c alt y c alt aber für Realisierung im Schaltnetz Rechnerstrukturen º» Boole. Fkt. 22

23 Bessere Realisierung Schaltnetz Volladdierer bisher s = c alt x y c = x y x c alt y c alt Ziel für c 1 realisieren für (c alt,x,y) {011,101,110,111} Beobachtung x y = 1 genau eine 1 in x, y also c alt (x y) realisiert 101, 110 fehlt noch 011, 111 beides durch x y also s = c alt x y c = c alt (x y) x y Rechnerstrukturen º» Boole. Fkt. 23

24 s = x y c alt c = c alt (x y) x y Schaltnetz Volladdierer x y c alt = 1 = 1 s 1 c Größe 5, Tiefe 3 Rechnerstrukturen º» Boole. Fkt. 24

25 Vollständiger Addierer x 0 x 0 + y 0 s 1 s 0 y 0 HA s 0 s 1 x 0 + y 1 y 0 s 2 s 1 s 0 x 0 y 0 y 1 HA VA s 0 s 1 s 2 Rechnerstrukturen º» Boole. Fkt. 25

26 Vollständiger Addierer x 0 + y 1 y 0 s 2 s 1 s 0 x 0 y 0 y 1 HA VA s 0 s 1 s 2 x 2 x 0 + y 2 y 1 y 0 s 3 s 2 s 1 s 0 x 0 y 0 y 1 x 2 y 2 HA VA s 0 s 1 s 2 VA s 3 Rechnerstrukturen º» Boole. Fkt. 26

27 x 0 y 0 y 1 x 2 y 2 HA VA 1 Realisierung Addition s 0 s 1 s 2 VA 2... x n 1 y n 1. VA n 1 s n 1 s n Größe 2+(n 1) 5 = 5n 3 Tiefe 1+(n 1) 3 = 3n 2 Rechnerstrukturen º» Boole. Fkt. 27

28 Ergebnis: Ripple-Carry Addierer Realisierung Addition von natürlichen Zahlen sehr gut strukturiert Größe 5n 3 sehr klein Tiefe 3n 2 viel zu tief Warum ist unser Schaltnetz so tief? offensichtlich Überträge brauchen sehr lange Verbesserungsidee Überträge früher berechnen Erinnerung Struktureinsicht (x i,y i ) = (1,1) generiert Übertrag (x i,y i ) = (0,0) eliminiert Übertrag (x i,y i ) {(0,1),(1,0)} reicht Übertrag weiter Rechnerstrukturen º» Boole. Fkt. 28

29 Ausnutzen von Einsichten Struktureinsicht (x i,y i ) = (1,1) generiert Übertrag (x i,y i ) = (0,0) eliminiert Übertrag (x i,y i ) {(0,1),(1,0)} reicht Übertrag weiter Beobachtung sehr gut durch Halbaddierer realisierbar x i y i u i v i Übertrag eliminieren weiterreichen weiterreichen generieren also u i = 1 generiert Übertrag v i = 1 reicht Übertrag weiter zentrale Beobachtung alle HA in Tiefe 1 parallel realisierbar Rechnerstrukturen º» Boole. Fkt. 29

30 Notation f HA (x i,y i ) = (u i,v i ) Realisierung als Schaltnetz u i = 1 generiert Übertrag c i+1 v i = 1 reicht Übertrag c i+1 weiter c i = u i 1 u i 2 v i 1 u i 3 v i 2 v i 1 u 0 v 1 v 2 v i 1 = i 1 j=0 u j i 1 k=j+1 Gesamttiefe: 4 alle Halbaddierer (u i,v i ) Tiefe 1 alle Und-Gatter u j i 1 v k Tiefe 1 k=j+1 großes Oder-Gatter Tiefe 1 n -Gatter f. korr. Summenbits Tiefe 1 v k Rechnerstrukturen º» Boole. Fkt. 30

31 Realisierung als Schaltnetz Mit dem Ansatz u i = 1 generiert Übertrag c i+1 v i = 1 reicht Übertrag c i+1 weiter c i = u i 1 u i 2 v i 1 u i 3 v i 2 v i 1 u 0 v 1 v 2 v i 1 = i 1 j=0 u j i 1 k=j+1 beliebig lange Zahlen in Tiefe 4 addieren... Ist das fair gezählt? v k Nein! Begriff Anzahl Eingänge eines Gatters heißt Fan-In Problem Wir vergleichen Schaltnetz mit max. Fan-In 2 mit Schaltnetz mit max. Fan-In n. Ziel Vergleichbarkeit herstellen Rechnerstrukturen º» Boole. Fkt. 31

32 Vermeidung von großem Fan-In großen Fan-In systematisch verkleinern x 0 x 0 1 x 2 x 3 x 2 x 3 1 x 4 x 5 x 4 x 5 1 x 6 x 6 x 7 x 1 x x 8 x 9 x Beispiel ODER, Fan-In 16 Rechnerstrukturen º» Boole. Fkt

33 Vermeidung von großem Fan-In am Beispiel aus Fan-In 16 bei Tiefe 1 (Größe 1) wird Fan-In 2 bei Tiefe 4 bei Größe 15 Wie ist das allgemein? Größe bei jeder Stufe nur noch halb so viele Gatter n 2 + n 4 + n n Tiefe so oft halbieren, bis man bei 1 Gatter ist log 2 n Rechnerstrukturen º» Boole. Fkt. 33

34 Carry Look-Ahead Addierer (CLA) Realisierung Addition von natürlichen Zahlen gut strukturiert Größe n 2 ziemlich groß Tiefe 2log 2 n ziemlich flach Haben wir jetzt im Vergleich zum Ripple-Carry-Addierer gewonnen? n Ripple- Carry Größe Ripple- Carry Tiefe Carry Look-Ahead Größe Carry Look-Ahead Tiefe Rechnerstrukturen º» Boole. Fkt. 34

35 Noch einmal nachdenken... Wir wissen doch schon Jede boolesche Funktion in Tiefe 3 realisierbar! (DNF, KNF, RNF) Wieso nicht auf die Addition? klar geht in Tiefe 3 aber Größe inakzeptabel (exponentiell) Fazit vorhandenes Vorwissen ausnutzen, Normalformen nur bei kleinen oder unstrukturierten Funktionen Rechnerstrukturen º» Boole. Fkt. 35

36 Multiplikation direkt mit Binärzahlen also Multiplizieren heißt Nullen passend schreiben Zahlen passend verschoben kopieren viele Zahlen addieren Rechnerstrukturen º» Boole. Fkt. 36

37 Multiplikation als Schaltnetz Multiplikation ist Nullen passend schreiben Zahlen passend verschoben kopieren viele Zahlen addieren klar Nullen schreiben einfach und kostenlos, Zahlen verschieben und kopieren einfach und kostenlos, viele Zahlen addieren nicht ganz so einfach Rechnerstrukturen º» Boole. Fkt. 37

38 Addition vieler Zahlen klar Wir haben Addierer für die Addition zweier Zahlen. Wie addieren wir damit n Zahlen? erster Ansatz einfach nacheinander m 1 m 2 m 3 m 4 m 5 m n + + Tiefe (n 1) Tiefe(+) Schrecklich! klar sehr naiv + + merken in Schaltnetzen niemals alles nacheinander. + Was geht gleichzeitig? Rechnerstrukturen º» Boole. Fkt. 38

39 Addition von n Zahlen besserer Ansatz paarweise addieren m 1 m 2 m 3 m 4 m 5 m 6 m 7 m Anzahl Addierer = n 2 + n n Gesamtgröße n Größe(+) Tiefe also auf i-ter Ebene 2 log 2 (n) i Addierer log 2 (n) Ebenen Geht es vielleicht noch schneller? Gesamttiefe log 2 (n) 2log 2 (n) = 2log 2 (n) 2 Rechnerstrukturen º» Boole. Fkt. 39

40 Addition von n Zahlen noch schneller (triviale) Beobachtung Addition ersetzt zwei Zahlen durch eine Zahl gleicher Summe zentral für uns gleiche Summe Korrektheit weniger Zahlen Fortschritt (verrückte?) Idee Vielleicht ist es einfacher, drei Zahlen zu ersetzen durch zwei Zahlen gleicher Summe? klar immer noch gleiche Summe Korrektheit aber 3 2 statt 2 1 weniger Fortschritt Ist das schlimm? Rechnerstrukturen º» Boole. Fkt. 40

41 Wallace-Tree m 1 m 2 m 3 m 4 m 5 m 6 m 7 m 8 m 9 m 10 m 11 m 12 CSA CSA CSA CSA CSA CSA CSA CSA Carry Save Adder ( log 3/2 (n) Ebenen) klar nur sinnvoll, wenn CSA viel flacher als Addierer CSA CSA + Rechnerstrukturen º» Boole. Fkt. 41

42 Carry Save Adder gesucht Zahlen a,b mit a+b = x +y +z Beobachtung für x,y,z {0,1} schon bekannt x +y +z = 2 u +v (Volladdierer) Beobachtung Es genügt, das parallel für alle Stellen zu tun. x 3 x 2 x 0 + y 3 y 2 y 1 y 0 + z 3 z 2 z 1 z 0 (2u 3 +v 3 ) (2u 2 +v 2 ) (2u 1 +v 1 ) (2u 0 +v 0 ) u 3 u 2 u 1 u 0 + v 3 v 2 v 1 v 0 Rechnerstrukturen º» Boole. Fkt. 42

43 Korrektheit der CSA-Realisierung aus Volladdierer x i +y i +z i = 2u i +v i x +y +z = = = = ( n 1 x i 2 )+ i ( n 1 y i 2 )+ i ( n 1 i=0 i=0 i=0 n 1 ( (xi +y i +z i ) 2 i) i=0 n 1 ( (2ui +v i ) 2 i) i=0 ( n 1 u i 2 )+ i+1 ( n 1 i=0 i=0 ) v i 2 i ) z i 2 i Rechnerstrukturen º» Boole. Fkt. 43

44 Multiplikation mit Wallace-Tree klar für drei n-bit-zahlen reichen n Volladdierer also Größe 5n Tiefe 3 Gesamtgröße n 2 Gesamttiefe 3 log 3/2 (n) +2log 2 (n) 7,13log }{{}}{{} 2 (n) Wallce-Tree Addierer Fazit Multiplikation wesentlich teurer als Addition, aber nicht wesentlich langsamer! Rechnerstrukturen º» Boole. Fkt. 44