Das hat etwas zu Verspätung, geht's los, bitte ich zu entschuldigen.
Heute haben wir die technischen Schwierigkeiten vor meiner Autopanne,
schon vor der Prelizal Arrived. Ja, also ich hatte
letzten Freitag ja im Prinzip aufgehört mit den Beispielen zu den Schaltnetzen
und hatte da als ein sehr einfaches Beispiel eben schon diesen Würfeldekoda vorgestellt.
Dann das nächste Beispiel jetzt eben für ein sehr einfaches Schaltnetz,
wäre jetzt eben auch was, wo ich ja im Prinzip
die Funktion auch schon in dem Kapitel 7 zur Kodierung vorgestellt hatte.
Nämlich im Prinzip die Umwandlung von Dualcode in Grecode beziehungsweise umgekehrt.
Und dort hatte ich also schon vorgestellt,
dass man die entsprechenden Kodierungen beziehungsweise die entsprechenden Werte eben dadurch sehr einfach bekommt,
dass man im Prinzip benachbarte Bits dann über eine Exklusiv- oder Funktion
miteinander verbindet und das Ganze dann eben entsprechend in Hades umgesetzt
Wäre das dann eben diese Schaltung beziehungsweise die Umwandlung von Greycode in die Dualcode dann entsprechend diese Schaltung.
Und wenn ich das Ganze jetzt hier einmal wirklich als Programm entsprechend öffne,
So, das wäre jetzt also hier das Beispiel zur Umwandlung von Dualcode in Grecode.
Und wenn ich jetzt also hier beispielsweise als Eingangswert den Vector sechs eingebe,
also binärkodiert, null, 1, 1, null,
wäre das dann eben in der Grecodierung null 1, 01.
Das Verfahren oder die Idee dahinter hatte ich ja also in dem entsprechenden Beispiel,
wissen wir es in dem Kapitel, also auch schon vorgestellt,
dass man quasi immer von zwei benachbarten Bits guckt,
ob sich eben der Wert ändert, wenn sich der Wert ändert,
also sprechen Übergang von 0 nach 1 oder von 1 nach 0,
wird das eben entsprechend als 1 kodiert,
andernfalls bleibt das eben als null kodiert.
Und das kann man dann eben technisch gesehen dann direkt mit
solchen Exklusiv-Odergattern aufbauen. Und das Ganze jetzt eben entsprechend zurückgerechnet,
also sprich von Greycode in Dualcode
Dann eben nicht, also hier nochmal als Beispiel,
also 0, 1,
0,1 wäre jetzt eben der entsprechende Wert für den,
für eine Biene kodierte 6,
wenn ich jetzt also hier dieses andere Beispiel jetzt entsprechend öffne und hier als Eingabe Vector eben diese 0-1,
0-1 angebe.
Und das dann ebenentsprechend jetzt hier quasi durch dieses Schaltnetz zurückdekodiert wird,
sieht man das dann eben hier entsprechend dual,
auf wie die 6 rauskommen würde
Gut, ein Etwas Größeres Beispiel,
was also thematisch auch noch zu dem Bereich der Codierung gehört,
wäre dann im Prinzip der Hemming-Code,
also je jetzt als Beispiel für ein 7-4-Hemming-Code,
das heißt also vier Nutzbits werden, um drei Prüfbits so ergänzt,
dass eben mit den sieben Bits Einbittfehler korrigiert werden können.
Und das Ganze würde dann eben als Hades-Schaltung So aussehen,
beziehungsweise ich gehörte das jetzt also auch gleich mal hier nochmal am praktischen Beispiel zeigen.
Die Schaltung ist also im Prinzip so aufgebaut,
dass ich hier auf der linken Seite mein Eingangsvektor habe,
in diesem Fall jetzt also hier als erst mal vorangestellter Wert, also eine binäre.
9. Anschließend werden über die entsprechenden Prüfsummen, wie sie also
der Hemmingodierung zugrunde legen, dann eben noch drei zusätzliche Prüfbitz eingefügt.
Das Ganze wird dann eben durch einen Kanal übertragen.
Also hier diese sieben Bits. Zusätzlich habe ich jetzt noch die Möglichkeit,
über diese Exklusiv-Odergatta zu tun,
als ob in einem Kanal irgendwo Fehler hinzugefügt werden,
indem ich quasi jetzt hier ein von diesen sieben Eingängen entsprechend auf eins schalte,
kann ich eben hier ein Fehler erzeugen,
beispielsweise jetzt hier also bei diesem Bit.
Und das führt dann eben dazu, dass es also
quasi jetzt hier nach der Übertragung hier eben ein Bettfehler aufgetreten ist.
Und hier wäre jetzt eben die entsprechende Dekoda-Logik zu dem Hemming-Code,
die das Ganze dann eben entsprechend in so ein Prüfwort umsetzt,
das dann hier dekodiert wird und dafür sorgt,
dass dann eben hier das entsprechende verfälschte Bit eben hier wieder gekippt wird und ich dann eben hier trotzdem an der Ausgabe das richtige Ergebnis erhalte.
Und wie gesagt, das Ganze funktioniert jetzt eben für Einbettfehler,
je nachdem, wo ich die jetzt also hier einbaue,
sieht man dann eben,
wie sich dann also demzufolge dann also auch hier dieses Prüfwort
und eben diese entsprechende Schaltung hier ändert
Nichtsdestotrotz bleibt natürlich dann, also der Richt-Ausgabe-Wert,
natürlich jetzt richtig,
solange ich jetzt also nur Einbitt-Fehler erzeuge,
weil das ist natürlich jetzt also die Grundlage von dieser Schadung,
wenn ich jetzt also beispielsweise jetzt hier noch einen zweiten Fehler mit einbaue,
dann sieht man,
dass der Hermingo das natürlich dann nicht mehr korrigieren kann und
hier hinterher dann letztendlich dann also wirklich was völlig Falsches
bei rauskommt
Ja, also das jetzt nochmal als Beispiel für jetzt eine,
doch deutlich größere Hardesschaltung,
wo man dann aber eben auch sieht, also sprich all das,
was ich vorher eigentlich so bei diesen ganzen Bereichen Zahndarstellung,
Codierung und so weiter eben gesagt habe,
wie man das jetzt eben hier wirklich in Form von solchen technischen Bauelementen und in Form von Charlottenetzen,
die dann also jetzt wirklich aus entsprechenden Gattern aufgebaut sind,
dann eben auch technisch realisieren könnte.
Anmerkung nur noch zu der Schaltung hier, Ich denke mir,
das wird jetzt, also hier bei der relativ schnellen Vorführung,
wo ich also hier nur im Prinzip,
also die fertige Schaltung aufrufe und mal ein bisschen rumklicke,
nicht weiter aufgefallen sein.
Im Prinzip sieht das aber so aus,
also wenn sie es nochmal genau untersuchen und dann vielleicht drüber stolpern,
dass also hier irgendwie dieses Prüfwort und also auch diese Prüfbezieher ein bisschen anders aussehen.
Das liegt jetzt im Prinzip daran, dass diese Schaltung,
sagen wir jetzt nicht genau, dem Schema entspricht,
wie ich jetzt,
also vorher auf den Folien den Helming-Code eingeführt habe,
sondern hier sind die Prüfbitze im Prinzip
ein bisschen anders
Generiert, beziehungsweise insgesamt auch etwas anders in die Bits einsortiert. Also deswegen,
falls sie sich da selber nochmal vertiefen wollen und also nicht wundern,
wenn das vielleicht auch ein bisschen anders aussieht, als das,
was ich vorher auf den Folien da noch stehen hatte.
Gut, dann ein anderes Beispiel, wo sie ja dann
ja auch schon seit Freitag die eine kleine Übungsaufgabe zu haben.
Sieben Segmentanzeige
Das also ja auch nur etwas, was man so mal
so auf Computern oder irgendwelchen kleinen Geräten, also relativ häufig hat.
Nicht, wo ich dann sage, ich habe im Prinzip
sieben einzeln ansteuerbare Leuchtsegmente, also beispielsweise sowas wie Leuchtdioden.
Und man kann damit dann im Prinzip die Ziffern von 0
bis 9 und zumindest solange man sich nicht,
also jetzt an irgendwie einer gemischten Großkleinschreibung stört,
also auch noch Hexziffern beziehungsweise einige andere Ziffern entsprechend mit Anzeigen.
Und gerade so bei Ja, sagen wir etwas, einfacheren Hardware-Ausgaben,
wo ich jetzt also nicht irgendwie ein Monitor oder ein großes Display brauche,
sondern wo es also wirklich nur um so ein bisschen Status oder DeBug-Informationen geht,
wird sowas dann natürlich dann auch immer ganz gerne verwendet.
So,
rein technisch gesehen handelt es sich da aber jetzt eben um letztendlich sieben Schaltfunktionen,
das heißt also je Ausgang eine Schaltfunktion und in diesem Fall
war es ja auch so,
dass also in der einen Übungsaufgabe im Prinzip
ihre Aufgabe dann war also jetzt für zwei dieser Segmente
in diesem Fall jetzt hier A und
Da entsprechende Schaltungen sich zu überlegen und zu minimieren. Das,
was ich jetzt hier gleich noch ein bisschen vorstelle, geht,
also sagen wir jetzt natürlich noch ein bisschen darüber hinaus,
weil da kommen jetzt also nochmal so die Ideen mit rein,
dort dann eben auch eine Bündelminimierung zu machen,
das heißt jetzt eben nicht nur zu sagen,
ich betrachte jetzt also eine oder zwei Funktionen getrennt voneinander,
sondern ich versuche das Ganze eben wirklich so zu minimieren,
dass ich eben für alle.
Für alle sieben Schaltfunktionen eben mit möglichst wenig Hardwareaufwand auskomme. So,
wenn man sich die Funktion selber jetzt ansieht,
im Prinzip einfach erstmal so aufgelistet, jetzt für so eine Darstellung,
hätte ich jetzt also von der exerdizimale Anzeige,
also sprich Die Ziffern von 0 bis 9 und dann eben noch A bis F. Entsprechend.
Hier für meine Segmente, diese Werte, wenn ich jetzt,
also die Hexer, den sezimalen Werte weglasse,
was ja also zum Beispiel auch eine Übungsaufgabe gefragt war,
kann man an ihm hier hinten entsprechend mit Don't care time arbeiten und Damit dann seine Funktion beschreiben.
Gut, Aufgabenstellung, wie gesagt,
hier jetzt sowas wie so eine Bündelminimierung, nämlich,
dass man wirklich versucht, jetzt in den KV-Diagramm auch alle
KV-Diagramme gemeinsam zu betrachten und dann eben möglichst auch gemeinsame Schleifen in allen Diagrammen zu finden und auszunutzen.
Wie gesagt, bei der Übungsaufgabe war jetzt nicht danach gefragt,
beziehungsweise bei diesem Beispiel, was sie jetzt dieses Jahr gewählt habe,
wird das also auch gar nicht vorkommen,
beziehungsweise da kann man das also nicht ausnutzen.
Insgesamt kann man eigentlich auch schon sagen, dass da mal so eine Bündelminimierung,
also selbst bei so vergleichsweise einfachen Beispiel, letztendlich nicht trivial ist,
beziehungsweise dann eigentlich auch nur mit Heuristiken gelöst werden kann.
Also das heißt also Minimierungsverfahren, wo ich letztendlich versuche,
also irgendwie was zu finden,
was möglichst gut passt und ausprobiere und dann nachher irgendwann,
also froh bin,
also eine halbwegs vernünftige Lösung bekommen zu haben
Nicht, aber letztendlich ist das von dahinter liegenden Mathematik dann eben auch schon wieder so eine Problemstellungsklasse,
wo man sagt, zumindest wenn die Beispiele hinreichen,
großen kann man da jetzt nicht beliebig gut werden.
Gut, also wie gesagt,
also eine so eine gemeinsame Lösung als Schaltnetz aufgebaut,
beziehungsweise dann also jetzt hier so in Hades implementiert,
wäre dann also zum Beispiel so eine Lösung,
wo ich dann eben jetzt wirklich sage, also hier sind meine entsprechenden Eingangswerte,
die ich dann jeweils in negierter und nicht negierter Form vorliegen habe.
Und dann wird dann im Prinzip über so eine zweistufige Kodierung,
wo ich jetzt also hier bestimmte und und oder Therme,
dann eben entsprechend im Prinzip eine disjunktive Form bilde,
dann eben hier die Ansteuerung dieser sieben Segmentanzeige vorgenommen.
Und auch das Ganze können wir dann natürlich
entsprechend in Hades simulieren. Das ist jetzt hier natürlich wieder
nur Tschüss
Falsches Beispiel, sorry. Ja, das ist immer das Schöne,
wenn man das jetzt also hier doch irgendwie in den Beispielen.
Ja, ja, ja. Ja, ja. Ja
, ja. Ja, ja. Ja, ja.
Ja. Ja. Ja. Ja. Ja. Ja
. Ja. Ja. Ja. Ja. Ja.
. Ja. Ja. ja. ja auch rauf,
äh, rauf, äh, rauf. Ja, ja,
ja, das war jetzt, also quasi hier mit dem Eingangswektor null,
entsprechend wird jetzt also hier eine Null angezeigt,
nicht entwende ich jetzt hier quasi der Reihe nach eins Zwei,
drei, vier, fünf und so weiter durchgehe, würde ich jetzt eben hier die jeweiligen Hexadezimalwerte bekommen.
Wobei diese Lösung jetzt hier eben,
wie man jetzt hier auch gerade sieht, also schon so aufgebaut ist,
dass sie im Prinzip nur für eine BCD-Dekodierung,
das heißt also nur für die Zahl 0 bis 9 vernünftig funktioniert und bei allem größeren.
Das heißt also, wenn ich jetzt also hier auf die
zehn oder Hexer dezimal A gehe, habe ich dann jetzt eben hier irgendeinen Zufallswert. Das heißt,
das ist eben jetzt auch schon wieder ein klassisches Ergebnis von einer Minimierung,
wo ich eben an den Stellen dann eben entsprechend Don't Catharme benutzt habe und wenn jetzt eben solche nicht vorgesehenen Eingaben vorkommen,
führt das dann dazu, dass er,
sondern in dem Zufolge natürlich dann im Ausgang auch irgendwelche Zufallswert beziehungsweise in diesem Fall jetzt,
also eine unsinnige Anzeige auftaucht
Gut, sowas gibt es dann eben entsprechend auch schon fertig,
also auch da zu Simulationsmodelle und so weiter und so fort,
die will ich jetzt also nicht auch noch hier irgendwie versteckt im Dateisystem suchen.
Ich aber also dazu,
falls ihr dann also selber damit also auch ein bisschen was machen wollen,
beziehungsweise vielleicht dann eben auch für irgendwelche anderen Übungsaufgaben oder irgendwelche Sachen,
gibt es dann eben auch fertige Bauelemente,
also in diesen Files,
also so ein IC auch aus dieser 74er-Baureihe,
also in diesem Fall
4,9, der dann im Prinzip genau so eine Dekodierung dann
schon macht für 0 bis 9 und für die Ziffern
oder für die Werte von A bis F,
dann eben auch aufgrund der Bündelminimierung irgendwelche zufälligen Muster erzeugt.
Zusätzlich gibt es hier dann eben noch einen Eingang zum Dunkeltasten,
mit denen ich dann also quasi insgesamt
die Anzeige ausschalten kann.
Nicht weitere Beispiele
Wären dann eben auch,
dass sich also jetzt zum Beispiel diese Anzeige benutze,
um zumindest sofern das möglich ist,
also irgendwelche Buchstaben oder Teile von Buchstaben darzustellen, nicht was,
also wie gesagt, dann eingeschränkt geht für A, B,
C, D, E, F, gut sind angedeutet,
das G kriegt man dann auch noch hin, H-I und wie gesagt,
so einige Buchstaben kann man dann eben auch anzeigen,
nicht bei einigen anderen funktioniert das dann natürlich nicht,
dann eben weggelassen, aber ihm hier die ersten 16 möglichen Buchstaben,
wie man also hiermit auch noch irgendwie darstellen kann,
sind dann also hier auch mal in Form so einer Bündelminimierung oder in Form so einer Minimierung quasi kodiert worden und könnte man also hier auch noch mal simulieren.
Hier auch noch mal so ein Beispiel,
auch von meinem Kollegen Norman Henrich,
der also die Sades gemacht hat,
wo man dann eben sieht,
wie dann also quasi hier mit diesen sieben Segmenten dann zeigen,
auch jetzt in diesem Fall jetzt hier einfach über fest angeschlossen an 0 und 1,
also irgendwelche Sachen ausgegeben werden oder wo dann also hier
quasi über einen Zähler auch irgendwelche Werte raufzählen oder laufen
Gut, ich hatte ja schon gesagt,
also diese mehrstufige Realisierung jetzt insgesamt von so einer 7-Segmentanzeige,
wenn ich die dann eben wirklich versuche insgesamt zu minimieren,
ist eben letztendlich nicht so ganz trivial, weil, wie gesagt,
dieses Problem dann eben auch schon so eine Problemklasse gehört,
wo es also mathematisch dann da so nicht mehr so ganz einfach ist,
zu sagen, also das ist jetzt die in Anführungszeichen beste oder günstigste Lösung,
sondern also da macht man also ähnlich wie bei der Minimierung von Charlottenetzen dann eben auch Ansätze,
dass man also quasi häufig verwendete Teilfunktionen versucht zu implementieren,
weil man sagt, na gut,
die brauche ich also da und da und da.
Und baut das dann entsprechend daraus auf. Also eine auch etwas abstruse Lösung aus dem Buch von Donald Evan Knuth,
The Art of Computer Programming,
also hier jetzt nur quasi in Schaltalgobarscher, Notation,
sieht dann eben so aus,
dass quasi jetzt von den vier Eingängen jetzt,
also hier irgendwie nochmal 15 zusätzliche Funktionen irgendwie gebildet werden,
die jetzt also über irgendwelche und oder und X-Ohr-Kombinationen von der
jeweils zwei Eingängen arbeiten und die dann wieder entsprechend zusammengefasst werden und das führt dann im Prinzip dann hier zu den Ausgängen für so eine sieben-Segment-Anzeige,
wobei die dann eigentlich auch teilweise noch invertiert sind
Gut, dann kommen wir jetzt eigentlich wieder zu etwas praktischeren Beispielen,
nämlich zur Umsetzung von logischen arathmetischen Operationen.
Ich hoffe, eingangs hatte ich jetzt ja bei den Beispielen
ja im Prinzip so Sachen zur Kuldierung gebracht.
Jetzt gehen wir also im Prinzip in der Vorlesung,
also noch ein bisschen weiter zurück, nämlich zur Arathmetik.
Und das heißt, da werde ich jetzt also noch mal beschreiben,
wie jetzt im Prinzip Addition, Subtraktion, eben wirklich als Text technisches Realisierung,
also in Form eines Schaltennetzes möglich sind.
Das heißt wirklich auf unterer Gatta-Ebene wird da also im Prinzip
angedeutet, wie Computer letztendlich rechnen können.
Dazu werde ich dann eben einige von den Adira-Typen vorstellen und werde auch noch,
wobei das dann nur ganz kurz auch noch auf einige andere Funktionen eingehen,
also Multiplikation,
Quadratwurzel und so im Ausblick dann noch mal ein bisschen was
zu Schieberoperationen beziehungsweise zu artmetisch-logischen Einheiten,
also zu Alus sagen
Gut, bei der Addition als allereinfachste Form, das,
was man eigentlich erst mal braucht, würde man dann eigentlich erst mal mit einem Halbadira anfangen.
Das heißt, ich habe zwar Eingangsbits, A und B,
die werden quasi als einstellige Zahlen addiert und können dann dazu führen,
dass ich eben maximal bis zwei gezielt habe.
Das heißt, ich habe ein Summenbit und ein Übertragsbit,
was dann eben quasi aus diesen beiden Eingängen hier mein Übertragsbett,
CO steht dann für Carrie Out und mein Summenbett S
habe und die Funktion kann ich eben direkt hier aus der Funktionstabelle ablesen.
Das heißt,
der Carrie wäre A und B und die Summe wäre die Exklusiv-Oder-Verknüpfung von A und B. Gut,
als Volladierer bezeichnet man jetzt eben die Summe und den Übertrag von Drei Bits,
beziehungsweise genauer genommen eigentlich eben von,
oder funktional genommen eigentlich von zwei Eingangs Bits und Eingangsübertrag,
dass der dann quasi an der entsprechenden Stelle eben noch als drittes Bit hinzukommen könnte.
Das heißt, ich habe hier eben zwei Schaltfunktionen für Carry Out und Summe,
die dann eben mit diesen acht Eingangskombinationen arbeiten und wenn ich
daraus jetzt eben die Funktion für Carry, beziehungsweise Summe ablese.
Nicht dann wäre quasi der Carry jede Unkombination von zwei Gesetzten Bits,
das heißt also A und B oder A und Carry in oder B und Carry in,
was also quasi dieser Ausdruck ist,
beziehungsweise was man noch häufig findet,
ist,
dass man dann also quasi über Distributivgesetz dann,
also die ist Carry in hier
noch rauszieht und dann eben zu diesen Thermen kommt
Warum man die dann ganz gerne verwendet,
werde ich nachher noch kurz vorstellen,
wo ich dann noch ein bisschen auf bestimmte Adira-Typen eingehe.
Und die Summe wäre dann eben die Exklusiv-Oder-Verknüpfung von A,
Exklusiv oder B, Exklusiv oder Carry.
Gut, damit kann ich dann eben entsprechend auch einfach
über Zusammenschalen der entsprechenden Gadda dann eben mein Einbett halbartigerer bzw.
mein Einbett Volladdira aufbauen
Und hätte dann eben hier die entsprechenden Gatta-Funktionen. So,
wenn ich jetzt nicht nur ein Bit,
sondern N bezahlen, addieren möchte,
würde das Ganze dann ihm so aufgebaut werden,
dass ich ihm sage,
für die Summe an einer Stelle Anne ergibt die sich eben
als das Exklusiv oder der entsprechenden Eingangsbits,
er ist exklusiv oder des Carrie-Eingangs
Beziehungsweise eben für die niederwärtigste Stelle wäre das, weil ich
da jetzt also keinen Carrie-Eingang habe. Eben dieser Term,
dann für die nächste Stelle dann eben A1, Exklusiv oder B1,
exklusiv oder C1 und so weiter und so fort.
Und der Übertrag beziehungsweise der Carrie würde sich dann hiermit
diesen Term ergeben beziehungsweise allgemeiner gesprochen, kann man sagen,
dass der Carrie dann eben rekursiv definiert ist.
Das heißt, der Ausgangskarianerstufe wäre dann eben AN und BN oder,
und dann eben geklammert, AN oder BN und der entsprechende Eingangs-Carry.
So, damit könnte ich jetzt theoretisch ein NBit-Adira,
also 32 oder 64 mit Adira, auch als zweistufige Schaltung realisieren. Nicht,
weil dann muss ich also hier quasi nur diese Formel nehmen,
das entsprechend einsetzen, ausrechnen, Dieter oder entsprechend Auflösen,
die Therme und kann das also wirklich direkt in beispielsweise des juktiver Form als so ein und oder Netzwerk aufbauen.
Nachteil, weswegen man das natürlich nicht macht,
das Ganze sowieso auch nicht so richtig funktioniert, ist natürlich,
dass der Carry, wie ich ja gerade schon gesagt habe,
letztendlich rekursiv definiert ist.
Das heißt, der Aufwand steigt eben exponentiell an und für
eben den Endenausgang oder einen Ausgang in,
sind dann eben letztendlich zwei hoch, zwei in minus eins, minterme erforderlich.
Das heißt, wenn ich damit da sitze,
irgendwie ein 32-Bit-Addierer aufbauen möchte, das als zweistufige Schaltung,
ist das also überhaupt nicht praktikabel.
Deswegen setzt man an ihm solche Schaltungen bzw. Addiernetze entsprechend anders oben.
Da gibt es es sehr viele, sehr unterschiedliche Typen.
Ich werde jetzt also im Großen und Ganzen eigentlich erstmal nur zwei oder zwei Klassen vorstellen,
von der Idee her nämlich, also einmal sowas wie ein Ripple-Carry-Adira,
wo ich eben linear angeordnete Struktur habe,
die vergleichsweise minimal klein ist, sehr einfach zu implementieren ist.
Andererseits Nachteil bei dem Ganzen ist eben,
dass die eben auch vergleichsweise langsam ist,
weil die Laufzeit quasi linear mit der Wortbreite ansteigt
Als ein mögliches anderes Extrem, würde ich dann also nochmal kurz Carillo Ahead Adira vorstellen.
Die basieren im Prinzip auf einer baumartigen Struktur zur Berechnung der Überträge,
haben den Vorteil, dass sie eben sehr schnell sind oder
sehr schnell sein können. Nachteil ist natürlich,
also durch diese Baumstruktur sind die dann eben vergleichsweise aufwendig in der technischen Realisierung,
das heißt, ich brauche dann eben deutlich mehr Gatta,
beziehungsweise dann eben auch Hardwarefläche im Vergleich zu solchen Ripple Carry,
Adi Iran.
Das heißt, wenn ich da jetzt das jetzt eben irgendwie
als Maß nehme, während ich dann eben auch vergleichsweise teuer.
Gut, daneben gibt es dann auch diverse Mischformen,
also was wie irgendwelche Block-Carry-Look-Ahead, Ripple Block, Parallel Prefix-Adder.
Es gibt nur noch diverse andere Ideen,
wie man jetzt mit Carries und Überträgen umgeht
Ja, sowas wie Cary Select, Conditional Summ,
wo ich im Prinzip einfach Summen oder Talsummen wilde unter der
Annahme der Cary wird schon eins sein oder der Cary wird
null sein und am Ende wähle ich dann einfach aus,
welche von denen das ist.
Ja, also insgesamt, wenn man in die Literatur geht,
zur Arrathmetik von Rechneranlagen,
also da findet man so Größenordnungsmäßig 15,
16 unterschiedliche IDA-Typen für mögliche Implementierung jetzt für Signed bzw. Unsigned
Gut, also hier jetzt Vorstellung der, sag mal erst mal, beiden gebordlichsten Typen. Zum einen der Ribble-Carry-Adira,
ist eben direkt aufgebaut,
letztendlich einfach durch so eine Kaskade von Volladdierern,
wo ich dann sage, ich habe immer Volladdierer,
die berechnen jetzt eben aus zwei Bit,
A und B, meinen Zahn und einem Carry-In,
dann eben ein Summenbit und ein Carry Out und das Carry Out,
einer entsprechenden Stufe bildet dann eben das Carry in der nächsten weiteren Stufe,
was dann eben natürlich nur noch dazu führt,
dass quasi das höchstwertigste Bit mit seinem Carry in letztendlich verarten muss,
bis alle anderen vorhergehenden Stufen,
den Carry eben auch passend berechnet haben, nicht demzufolge,
habe ich eben diesen Effekt,
dass diese Gesamtverzögerung linear mit der Anzahl der Stufen anwächst,
beziehungsweise dadurch ergibt sich dann eben auch dieser Name Ripple Carry Adira,
weil sich eben im schlimmsten Fall quasi so ein Übertrag
der Reihe nach über die einzelnen Stellen durchrippelt
Nun ist es natürlich so, dass wenn ich jetzt sage,
gut, also, wenn ich jetzt eben sage,
möglichst hohe Performance ist essentiell,
ist eben so ein Repel Carry Adira nicht so gut geeignet,
in heutiger Schadungstechnik, also ein Semos-Technologie,
setzt man die dann in der Regel noch so bis ungefähr 10 Bit-Wort-Breite ein,
danach was anderes, beziehungsweise dann geht man eigentlich zu solchen Blog,
Ripple, Carry, Adi ran über,
beziehungsweise arbeitet dann mit anderen Schaltungen.
Nicht, weil, wie gesagt,
da gibt es dann eben deutlich effizientere Lösungen.
Gut, wie sieht grundsätzlich so ein Ripple-Carry-Adira aus?
Also auch hier das entsprechende hartes Beispiel
Das wollte ich
leicht zeigen
Musik Musik Musik Tschüss
Musik Das tut mir leid.
Irgendwie sollte ich die Beispiele nochmal ein bisschen anders sortieren,
dass ich das nochmal wiederfinde
Gut, das ist jetzt jetzt was anderes, aber...
Ach, in einem Schiff von meinen Schmerzen oder für so
einen Westone
Hua, so. Also, wie gesagt,
hier jetzt, im Prinzip, zwar eingangswerte,
also beispielsweise jetzt hier fünf, plus zwei.
Und wie gesagt, aufgebaut an ihm über,
dass eigentlich Das entscheiden wir jetzt hier nur klassisch eben so eine Kette aus Volladdierern,
wo ich quasi jetzt hier in der untersten Stufe als Carrie ändern,
erst mal hier konstant eine Null angelegt habe.
Und dann werden dann eben hier einfach nur die entsprechenden mit niederwärtigstes Bit des ersten,
beziehungsweise des zweiten Operanten genommen,
bilden dann eben das entsprechende Summbit und das Übertragsbit
geht dann eben quasi in den Carri-Eingang der nächsten Stufe und
so weiter und so fort
Und gut, wenn ich jetzt eben hier irgendwelche Beispiele hätte,
also zum Beispiel 5 plus 3, dann sieht man also eben entsprechend sehr gut,
wo ich dann hier jetzt der Reihe nach immer meine Überträge hätte,
wenn ich die dann dazu führen,
dass ich dann eben insgesamt das Ergebnis logischerweise an die Acht erhalte.
Gut, das also zum Ripple Carry Adira, das eine Beispiel,
was ich eben auch schon aus Versehen aufgemacht hatte.
Also da ist es eben nochmal sehr schön gezeigt,
wo jetzt im Prinzip acht Volladdierer in so einer Kaskade angeordnet sind,
die dann eben, sagen wir jetzt eben auch,
künstlich für die Simulation so tun, als ob sie jetzt also besonders langsam rechnen, beziehungsweise besonders langsam Carry erzeugen.
Und da sieht man dann eben vergleichsweise gut, wie So,
da sieht man jetzt also vergleichsweise gut, wie jetzt,
wenn ich also meine Eingänge hier entsprechend beschalte und jetzt also hier an,
dadurch, dass ich also quasi hier dieses eine Bild jetzt eben auch gleich noch umschalte,
da dann eben einen Übertrag erzeugt wird,
wie der sich dann eben der Reihe nach über die Schaltung ausbreitet und dann eben dazu führt,
dass dann eben nach vergleichsweise langer Zeit der sich dann eben wirklich jetzt,
also in diesem Beispiel daneben bis zu allem insgesamt Carry Out,
fortgepflanzt hat.
Gut, das zum Aufbau von Ripple Carry Adirian,
wie gesagt, vergleichsweise einfach umzusetzen, aber eben Nachteil,
diese Durchlaufzeit für den Carry.
Wenn wir uns jetzt also im Prinzip noch die anderen Schaltfunktion beziehungsweise,
sag mal, andere Eigenheiten der Art Metik ansehen.
Vielleicht haben wir jetzt natürlich das Nächste, dass man sich fragt,
okay, wie kriege ich jetzt eine Subtraktion technisch dann auch umgesetzt?
Und jetzt kommt eigentlich die Erklärung dafür,
warum man jetzt also irgendwie immer dieses komisch aufgebaute Zweier-Kompliment hat,
mit dem man rechnet. Weil da ist nämlich,
sagen wir mal jetzt,
das vergleichsweise schicke oder der Trick dabei,
dass sich das also im Prinzip mit identischer Hardware
für eine Addition dann eben auch entsprechend subtrahieren lässt
Im Zweierkompliment mache ich ja nichts anderes,
als dass ich jetzt sage, okay,
wenn ich eigentlich A minus B rechnen möchte,
kann ich das Zweierkompliment von B bilden und da ist einfach zu A hin zu addieren.
Das heißt, ich führe das eben wieder auf technisch gesehen,
eben auf eine Addition zurück und das Zweierkompliment einer Zahl bekomme ich dadurch,
dass ich sage, gut,
ich invertiere alle Bits,
dann habe ich genau das einer Kompliment und muss
noch eine Eins hin zu addieren
So in dieser Eins hinzuaddieren,
kann ich ganz einfach dadurch machen, indem ich sage,
wenn ich jetzt also ab ander niederwärtigsten Stelle jetzt eben keinen Halbadi-Rai benutze,
sondern auch einen Volladierer, der dann eben noch einen Carry innen hat,
dann wäre diese Eins hin zu addieren,
eben dass Carry in dem niederwärtigsten wird.
Und dadurch kann man dann eben sehr einfach quasi diese Subtraktion realisieren,
indem ich sage, ich habe eben ganz normale Adira,
also in Form so eines Ripple Carry Adiras,
invatierender Bits,
bildet das einer Kompliment,
Carry Eingang in den niedrigsten Stufe
Wäre dann eben die Addition von 1 noch. Und das
Ergebnis wäre dann eben A plus B negiert plus 1,
was dann also nach der Definition A minus B ist.
Nicht und so, arbeiten dann eben auch relativ viele AD-Werke,
die es dann eben teilweise auch schon in Form solcher vorgefertigten Bausteine,
also in diesem Fall 74,
83 gibt,
was dann so ein Vierbild Adira ist
Wo dann auch schon angedeutet ist, wo ich dann also
mit diesem Baustein eben nicht nur Addition und Subfraktion machen kann,
sondern eben auch schon einige andere, sehr einfache Funktionen.
Dazu werde ich mich jetzt erstmal auf die Suche nach der Schaltung begeben,
was in diesem Fall jetzt aber etwas schneller gehen könnte
So, jetzt hat es mal geklappt. Also, wie gesagt,
das hier eben so ein Adiernetz für Fearbit mit Carrie Anne und Carrie Out.
Dieses hier ist jetzt also nun ein etwas anderes Schaltbild,
ist aber im Prinzip nichts anderes als ein Exklusiv oder.
Das heißt, hiermit könnte ich jetzt eben für meinen Operanten B,
wenn ich das eben hier entsprechend über diesen Komplimenteingang umschalte,
diesen gesamten Vector, der jetzt also quasi den Wert Null hat,
invertieren, also in dieses Fallland zu dem Wert F.
Und zusätzlich habe ich dann eben hier noch einen zusätzlichen Eingang
getrennt von dem hier für Carrie Anne. Damit kann ich jetzt also erreichen,
dass ich mit diesem Vierbitt Adira, je nach Beschaltung,
eben zwei Zahlen A plus B addieren kann, dass ich,
wenn Komplimenteingang und Carrie in den Eingang beide auf eins gesetzt sind,
a minus b rechnen kann.
Und dass sich dann eben über die anderen beiden Kombinationen von Kompliment und Carrie in eben rechnen kann,
a plus b plus eins,
beziehungsweise a minus b minus eins,
beziehungsweise wenn ich eben meinen zweiten Wert b oder meinen Vektor B auf null setze,
kann ich damit im Prinzip von a Inkrement bzw. ein
Dekrement durchführen
Das heißt also,
ich kann jetzt hier also sehr einfach zum Beispiel A auf vier Sätzen,
könnte dann eben unter Verwendung dieses Carry-Ins ab plus plus rechnen,
habe dann eben hier quasi als Ergebnis fünf oder könnte A minus eins rechnen,
hätten also hier als Ergebnis drei,
also A minus BB ist jetzt Höher Null, minus eins,
beziehungsweise wenn ich jetzt eben ganz normal angenommen 4 minus 3 rechnen würde.
Nicht, dass wir jetzt hier 4 plus 3,
liefern mehr als Ergebnis 7. Und wenn ich die beiden einschalte,
demzufolge dann 4 minus 3 als Ergebnisarbeits. Gut,
damit sieht man also im Prinzip,
wie jetzt also mit so einem Adierschaltennetz,
ihm vergleichsweise einfach schon sehr, oder einige einfache,
atometische Funktionen, nämlich Addition, Subtraktion und sowas wie ein Autoinkrement,
Autodekrement,
wie man das ja nun beispielsweise aus den Programmiersprachen her auch kennt,
dann eben auch technisch realisiert werden kann
Gut, jetzt hatte ich ja immer nur die sehr einfach
aufgebauten Ripple-Carry-Adira vorgestellt für schnelle Additionen. Ich hatte ja schon gesagt,
also die Adira sind häufig eben in diesem kritischen Pfad,
möchte ich jetzt eben irgendwelche schnelleren Schaltungen einsetzen.
Dazu werde ich jetzt also noch Zwei Beispiele, ein bisschen
genauer vorstellen. Zum einen im sogenannten Carrie Select Adira,
basiert von der Idee her im Prinzip auch auf einer Ripple-Carry-Adition,
die ich dann aber immer zu Gruppen zusammenfasse,
die dann auch immer größer werden.
Und dann eben diesen Carry-Luca-Head Adira. Ansonsten hatte ich also
schon gesagt, es gibt dann also noch deutlich mehr Adiotypen.
Es gibt dann noch spezielle Adira, die man häufig auch braucht,
die dann eben nicht nur zwei Operanten,
sondern auch noch mehr Operanten
benutzen können
Beispielsweise, oder ein Beispiel werde ich nachher noch kurz zeigen,
also beim Multiplizierwerken hat man sowas in der Regel. Letztendlich sind die Art und Weise,
welche Adira es gibt, wie die umgesetzt werden,
dann auch immer noch stark technologieabhängig, war alles das,
was ich jetzt hier vorstelle, bezieht sich eigentlich auf das,
was wir jetzt, so als Schadungstechnik haben,
also sprich Moss beziehungsweise Cemos-Technologie, so zu Beginn der Computertechnik,
als man noch irgendwie andere Schaltungstechniken oder elektrisch gesehen,
also andere Schaltungstechniken verwendet.
Hertha hatte man dann auch teilweise noch andere Adiertypen,
die dann beispielsweise jetzt bei der Berechnung der Carries dann auch wieder anders vorgegangen sind,
weil die Schaltung da dann bestimmte elektrische Eigenschaften im Prinzip dieser Schaltungstechnik
dann auch wieder anders ausgenutzt haben.
Gut, das, was sie jetzt eben noch,
oder nächstes Mal ein Adiertypen, die ich jetzt noch kurz vorstelle,
also der Carrie Select Adira sieht im Prinzip so auf,
dass ich sage,
ich bilde eigentlich immer Gruppen von Rippe Carry Adierern
Das heißt, ein Adira-Film, eine Zahl mit Nbit-Wortbreite,
wird jetzt dann irgendwie kleinere Gruppen aufgeteilt,
die dann immer irgendwie M-I-Bits jetzt beinhalten sollen.
Und in jeder dieser Gruppen habe ich jetzt zwei komplette Adira oder Adira-Werke,
wovon innerhalb der einen Gruppe quasi gerechnet wird,
A plus B, mit der impliziten Annahme,
es gibt keinen Carif, von da drunter liegenden Stufe.
Und in der zweiten Gruppe wird gerechnet A plus B plus 1,
das heißt, da nehme ich eben an,
es kommt ein Carian
So, und innerhalb der Gruppe habe ich dann eben ganz normal eine Ripple-Carry-Addition. Und irgendwann,
wenn ich quasi von einer davorliegenden Stufe weiß,
es kam ein Carry oder es kam kein Carry,
muss ich dann hier nur noch das,
ich sag mal jetzt richtige Ergebnis auswählen, nämlich entweder das,
wo ich ohne Carry gerechnet habe oder das,
wo ich mit Carry gerechnet habe.
Das heißt, da gibt es dann eben noch
entsprechende 2 zu 1 Multiplexer,
die dann eben
das richtige Ergebnis auswählen
So, in der Gruppe selber
habe ich dann ja auch irgendwo einen Carry berechnet.
Nicht, und der bildet dann eben wieder den Eingangscarry der nächstfolgenden Gruppe.
Diese Grundidee oder dieser Aufbau führt dann eben dazu,
dass sich die Verzögerung dann jetzt eben verringert auf die Verzögerung
eines MBit Adiras
Plus der Verzögerung, die ich dann eben noch für
diese Auswahl des richtigen Ergebnisses beziehungsweise des richtigen Carries brauche.
Das heißt also, die durch die Multiplexe entstehen.
Aber ich habe jetzt eben nicht mehr die Gesamtverzögerung,
die jetzt von N abhängig ist.
Als praktisches Beispiel wäre hier also jetzt nochmal eine entsprechende Hades-Schaltung.
Wie gesagt, das finden Sie dann auch in oder können
sich also auch in den Hades-Beispielen dann entsprechend raussuchen.
Also das werde ich jetzt also hier jetzt nicht größer vorstellen.
Was man jetzt aber eben sieht, ist,
dass ich sage, gut, ich habe hier als niederwendigstes Bit,
also im Prinzip einen ganz normalen Adira, der erzeugt dann quasi Ausgangssumme und einen Übertrag.
Dann gibt es eben hier eine Dreiergruppe, wo ich dann
eben hier Ripple-Carry-Addition für 3-Bit-Mache. Und zwar einmal eine Addition,
wo ich ihm quasi diese 3-Bit mit einem Eingangs-Carry von null
berechne und nochmal mit natürlich dann doppeltem Hardware-Aufwand.
Nochmal eine 3-Bit-Addition, wo ich dann mit Mahlgangs-Carry von 1 rechne.
Und damit wären dann im Prinzip zwei Überträge und zwei entsprechende
Summenvektoren berechnet
Und über Multiplexer wird dann eben der richtige Übertrag, beziehungsweise die richtige Summe ausgewählt.
Und der Multiplexer wird dann quasi von diesem Carry,
der da vorgehenden Stufe in diesem Fall ist, von diesem einzelnen Bit angesteuert.
So, das Ganze ist dann eben hier jetzt kaskadiert.
Es gibt anschließend dann eben nochmal so eine Vierer-Gruppe,
wo dann jetzt eben wieder dieser Ausgangs-Carry dann eben den entsprechenden Teil auswählt.
Nicht in der Trick ist jetzt eben quasi diese Aufteilung in die Gruppen so zu wählen, dass eben die Gesamtverzögerung minimal ist. Letztendlich habe ich aber eben erreicht,
dass ich jetzt eben sage,
habe jetzt eben nicht mehr als langsamstes,
wie bei einer 8-Betrippel-Carry-Addition, also ein Carry,
der sich quasi jetzt durch sämtliche 8-Bit irgendwo durchhangeln muss,
sondern hier werden ja diese Gruppen alle immer schon parallel berechnet und man muss dann eben quasi das Ganze eben nur noch so machen,
dass Wenn diese Berechnung hier fertig ist oder hier eben durchgerippelt ist,
ich dann eben dafür auch sorgen muss,
dass ich quasi hier schon das Richtige ausgewählt habe und hier dann eben auch diesen richtigen Carrie dann also auch direkt zur passenden Auswahl zur Verfügung stehen habe.
Aber in diesem Beispiel habe ich dann eben letztendlich die Geschwindigkeit knapp verdoppelt,
weil also hier der längste Pfad jetzt eben nicht mehr bestimmen oder jetzt eben nur noch bestimmt wird,
also durch das Durchrippeln des Carries, durchs Vierbitt,
beziehungsweise eben hier diesen Carrie dann eben hier ein Multiplexer und dann eben entsprechend hier diesen Multiplexer.
Gut, das Ganze, damit man also auch sieht,
dass es eben auch wirklich so eingesetzt wird,
also hier nochmal als Beispiel aus dem Buch von Förber,
Arm, System oder Chip Architecture, also in dem Armprozessor,
beziehungsweise in der V6-Version von dem Arm,
ist eben genauso ein Carrie Select Adira benutzt,
jetzt eben für 32-Bit-Additionen, wo man dann eben sieht,
okay, es gibt dann also hier eine Gruppe von 4-Bit.
Nicht die nächste Gruppe ist dann auch wieder 4-Bit breit und
anschließend gibt es dann eben eine 8-Bit und eine 16-Bit-Gruppe.
Aber man hat eben schon deutlich weniger Verzögerung,
eben hier nur noch im Sinne jetzt von maximal Dadurch,
dass es hier dann auch nochmal weiter kaskadiert ist,
dann eben nur noch maximal 4bit plus diverse Multiplexer im Vergleich zu den 32bit,
die sonst eben bei einer Republicare Addition auftreten würden.
Gut ein anderes Prinzip,
womit nur der Nasa mal eigentlich die schnellsten ADA-Schaltnetze aufbauen kann,
wäre dann eben der sogenannte Carrilog Ahead Adira,
wie der Name schon sagt,
Look Ahead versucht man jetzt eben möglichst schnell festzustellen oder
welchen Bedingungen kann an einer bestimmten Stelle überhaupt ein Carri
auftauchen oder nicht
Wenn wir uns jetzt nochmal die Funktionen des Volladiras ansehen,
dann war der Cerry ja quasi rekursiv definiert durch,
dadurch, dass ich sage,
ihm der Ausgangscarry ist A und B oder B und der Eingangscarry,
das führt dann eben, war genau dieser Klammerung,
dann nehme ich auch schon dazu, dass man sagt,
ich kann hier eigentlich zwei Hilfsfunktionen definieren,
nämlich einmal eine namens Generate und einmal eine für Propergate.
Und die Funktion ergibt sich jetzt eben eigentlich direkt aus dem englischen Namen,
weil wenn ich weiß, AS1 und BS1,
dann erhalte ich also auf alle Fälle ein, Carrie.
Unabhängig von meinem Eingangs-Carrie, deswegen eben Generate,
beziehungsweise wenn ich eben sage AS1 oder BS1,
das ist jetzt eben dieses Propergate-Signal, dann habe ich nur dann einen Carrie,
wenn ich eben auch einen Eingangs-Carrie habe.
Ich weiß aber, dass in dem Fall Adleich null und B gleich null.
Ich eben gar keinen Carry Out mehr haben kann, egal wie der Eingangsterry aussieht. Nicht,
das heißt, je nachdem,
ob ich hier jetzt eine Eins bzw. an dieser Stelle eine Null habe,
kann man dann eben auch in höheren Stufen der Rektoren dann eben schon sagen,
wie sich der Carry vielleicht weiterentwickeln wird.
Das heißt, ich kann jetzt also die Care-Generierung,
dann im Prinzip, wenn ich jetzt diese beiden Hilfsfunktionen habe,
eben umschreiben in diesen Thermen, indem ich dann eben sage,
Carrie ist dann einfach nur Generate oder Roppergate und Eingangs-Carry.
Und das Aufbauen dieser Funktion bzw. dann ihm die eigentliche Berechnung von dem Ganzen,
kann man dann eben sehr schön in so eine Baumstruktur umsetzen,
wobei die Tiefe des Baums dann eben quasi Lugarettmash bzw. Lugarett
musst du alles dann eben von NS by Wortbreite in,
na gut, das ist jetzt hier ein bisschen ungünstig mit Großen beschrieben, aber okay.
Gut, dementsprechend schnell wird da die Adias-Schaltung. So,
wenn ich das jetzt technisch aufbaue, wie gesagt,
die Funktionen sind ja da gerade beschrieben worden, kann ich dann eben sagen,
okay, also als Funktionsblock für die Summenberechnung habe ich Carrie-Eingang
Und meine beiden Witze A und B, bin ich,
und aus denen berechne ich dann eben ganz normal meinen Zoom-Bit,
als entsprechende Exklusiv-Oder-Verknüpfung von Carry-In, B-N und A-N.
Und dann habe ich eben nur noch diese beiden Hilfsfunktionen,
Generate und Propergate.
Das heißt, das Ganze entspricht dann grob gesehen,
also erstmal sowas wie Äquivalent zum Volladdiara.
Nur, dass eben jetzt hier keine Berechnung vom Carry-Out passiert,
sondern nur Generate und Propergate für ein Bit
erzeugt werden
Und dann gibt es eben entsprechende Funktionen,
mit denen ich dann jeweils von zwei benachbarten Bits,
die Generate und Propagate-Signale zusammenfassen kann und eben aus zwei
dieser Signale dann eben ein entsprechendes Ausgangssignal machen kann,
für eine nächst höhere Stufe beziehungsweise dann eben auch der
entsprechende Carry
erzeugt wird
Nee, und da kann ich jetzt eben sagen,
der Ausgangs-Carry ist im Prinzip genau dann gegeben,
wenn ich jetzt eben sage,
ich habe mein Propergate und ein Eingangs-Carry.
Das ist genau diese Funktion. Oder ich habe eben
ein Generate-Signal. Dann habe ich auf alle Fälle
auch eben
einen Ausgangs-Carry
Dieses Carrie-Signal wird an ihm hier entsprechend. Für die nächst höhere Stufe weitergeleitet.
Und die Zusammenfassung jetzt von zwei Bits, I und J,
für eine nächst höhere Stufe jetzt für Propergate wäre eben,
dass ich von einer niederwärtigeren Stufe quasi ein Propergate-Signal habe.
Und dass ich von meiner aktuellen Stufe ein Propergate-Signal habe,
genau dann hätte ich dann eben auch eine Stufe da
drüber,
wie dann ein Propergate
Für das Generate,
das wird eben nur genau dann erzeugt,
wenn ich eben in einer niederwärtigeren Stufe eben ein Generate habe und in meiner aktuellen Stufe ein Propergate,
das heißt also hier weiß ich,
es wird ein Carry erzeugt und ein Bit oder eine Stelle da drüber habe ich zusätzlich noch das Propergate an,
nur genau dann kann eben dieses Generate auch entsprechend weitergeleitet werden,
das wäre jetzt,
also dieses Own und Gatta oder eben in der aktuellen Stufe
wird eben mein Generate erzeugt,
das wäre dann eben hier entsprechend dieses Oder
So,
und wenn ich jetzt diese beiden Funktionen oder Funktionsblöcke habe,
nämlich einmal,
dass ich quasi jetzt als Äquivalent zum Fall Adira meine beiden Bits
einer Zahl und ein Carry Inn zusammenfasse und eben eine Summe
oder ein Summenbit und eben diese beiden Signale Generate und Propaget
erzeuge und dann eben als Funktionsblöcke zum Aufbau dieses Baumes dann eben Diese Struktur habe,
mit der ich dann jetzt eben quasi von zwei benachbarten Bits
aus Generate und Propergate dann eben für die nächst höhere Stufe Generate und Propergate erzeugen kann und dann eben letztendlich zwei Carribits mir erzeuge.
Das führt dann da zu,
dass ich aus dem Ganzen dann eben wirklich so einen gesamten
großen Adierbaum aufbauen kann
So das, was ich hier eben auf der Folie hatte,
die ich jetzt mal eben so schnell nonchalant weggeklickt habe.
Ist also im Prinzip genau das, was ich gerade eben
schon anhand des Skrimatics oder des Charles Plans erklärt habe.
Ich hatte dieser Funktionsblock, berechnet quasi jetzt immer
aus den Generate und Propagatesignalen von zwei Stufen und einem Curry-In-Signal
dann eben die entsprechenden Werte für die nächste höhere Stufe.
Und das Ganze führt dann eben dazu,
dass ich hier immer diese Funktionsblöcke habe,
die dann immer jeweils Zwei von diesen Teilen an zu einem.
Zusammenfasse und hier quasi als Adira oder als Adirianetze dann eben diese Summenfunktionsblöcke haben,
die mir dann eben ein Summenbett und in der, in Anführungszeichen,
niedrigsten Stufe des Baumes dann eben Generate und Propergate-Signale erzeugen.
Nicht, dass wir dann also quasi die Funktionsweise von
dem Ganzen nicht. Und hier sieht man dann immer wieder
entsprechend das dann immer hier in Gruppen zusammengefasst wird,
nicht und hinter jeder dieser Blöcke Oder hinter jedem diese Blöcke verbirgt sich dann.
Also quasi hier sowas, was dann letztendlich dieser Schadung entspricht,
wo ich dann eben hier aus den jeweiligen Werten zwei Generate
und Propergate-Signale dann eben zu einem Gruppen Generate und Propergate-Signal zusammenfasse.
Gut, und das wäre jetzt also eben so ein
Beispiel für ein 16-Bit, Carry Look Ahead Adira.
Und also auch das Ganze
Könnte man dann irgendwo ein Haar, das nochmal simulieren,
das ist hier natürlich jetzt wieder in einem für anderen Verzeichnis.
Und wie gesagt, also hier kann ich jetzt eben entsprechend irgendwelche Bit Vektoren einstellen.
Wenn ich jetzt hier, also irgendwie was einstelle, wo dann auch wirklich mal ein bisschen Carrie erzeugt wird, der sich dann also hier durchrippelt. Wie gesagt,
dann würde man,
wenn man das jetzt also entsprechend anhand der Schaltung nachvollzieht,
dann eben sehen,
wie dann eben aus diesen entsprechenden Generate bzw. Propagate Signalen,
das dann eben hier immer in diesen Stufen zusammengefasst wird und dann quasi letztendlich nachher in dem Baum dann hier in der tiefsten Stufe Oder,
nein, andersrum, also jetzt hier quasi eigentlich schon eine Wurzel des Baumes,
wenn man das so rumsieht, dann eben hier dafür sorgt,
dass eben hier ein Carrie erzeugt wird,
was dann also letztendlich jetzt hier bei diesen Zahlenbeispielen dafür sorgt,
dass ich dann eben hier genau entsprechend diesen Ausgangswert 100 bekomme
Gut, das war jetzt, das ist nochmal relativ schnell oder kompakt dargestellt, im Prinzip jetzt der Carry Look Ahead Adira. Ja,
jetzt habe ich hier nur noch einige weitere allgemeinere arathmetische Funktion,
nicht zum einen hier nur nochmal kurz angedeutet,
Ich hatte ja also auch schon ganz am Anfang bei diesen Bitsheebereien vorgestellt,
also was man vielleicht häufiger mal braucht,
also gerade so im Bereich dann eben auch von Kodierung und Periti-Generierung,
sowas wie dieses Bitcoin-Problem, wo ich jetzt eben feststellen möchte innerhalb eines Wortes,
wie viele Eins-Bits gesetzt sind, nicht,
also auf sowas könnte man einfach jetzt, wie hier angedeutet,
im Prinzip in so einen Adierbaum umsetzen,
wo ich dann im Prinzip sage, ich habe jetzt hier,
benutze hier jeweils ganz normale Volladira,
Wobei ich jetzt aber eben den Carry in auch einfach wie ein x-beliebigen Dateneingang benutze.
Das heißt also,
jeder dieser Adira berechnet aus drei Eingangsbits eine Summe und ein Carry out,
welchen dieses hier oder diese Blöcke sollen dann im Prinzip Adira,
also beispielsweise jetzt als Ripple Carry Adira oder wie auch immer,
für zwei Bezahlen darstellen.
Das heißt, ich nehme dann jetzt also hier dieses Ergebnis,
was dann ja letztendlich von bis drei gehen kann.
Als eine, zwei Bezahl, dies ist hier als zweite,
zwei Bezahl, die wird in dem Zufolge jetzt hier addiert.
Kann dann eben maximal eine drei bezahlen, nämlich hier zwei Ausgangsbitten und einen Ausgangs-Carry erhalten.
Und das mache ich hier auf der Seite entsprechend genauso.
Und dieses Add 3 soll dann eben im Prinzip ein addierer für drei bezahlen sein,
nicht wo ich jetzt aber im Prinzip damit dann mit diesem dreistufigen Baum letztendlich hier jetzt für zwölf Eingangsbits,
die Anzahl der gesetzten Ein- bis Ein-Bits, entsprechend direkt ausrechnen kann.
Gut, nochmal zusammenfassend, halb Adira, wird jetzt im Prinzip aufgebaut, so für das Summbit. A exklusiv oder B, voll Adira,
habe ich dann eben noch zusätzlich den Carry-Eingang und für den Ausgangs-Carry der wird dann eben im Prinzip immer berechnet,
als A und B,
beziehungsweise hier dann eben als A und B oder A und C A und Carry in oder B uns im Carry in,
beziehungsweise wenn ich das dann eben, wie jetzt hier angedeutet,
über diese Hilfsfunktion Generate und Propagate entsprechend anders geklammert hätte,
hätte ich dann eben Generate oder Propagate und Carry in
Gut, Bäm. Rippel, Carry, Adiera, wie gesagt,
voll Adiera, kaskadiert. Verzögerung wächst eben linear mit der Wortbreite.
Das heißt, da sind Größenordnungen, U von innen. Bei diesem Carry-Select-Prinzip,
wo ich jetzt immer diese Gruppen von Ripple, Carry,
Adiera anbilde, schafft man das,
wenn man das jetzt also entsprechend schlau partitioniert,
dass die Verzögerung im Prinzip in der Größenordnung Wurzel-Anne wächst und beim Carry-Look Ahead-Prinzip Durch den baumartigen Aufbau habe ich dann eben ein lugarhythmisches Anwachsen der Verzögerung.
Und was dann eben auch möglich ist,
was ich ja also schon gezeigt hatte,
dann eben auch an diesem einen Beispiel,
wo es dann also um die Subtraktion geht,
dass man dann eben durch die Zweierkomplimentbildung beziehungsweise durch die entsprechende Berechnung,
die dann dahinter steht,
dann eben auch sehr einfach sowas wie Inkrement oder Dekrement
von Zahlen bestimmen kann
Gut, für die Multiplikation geht es also sehr weit zurück.
Wie war das, Multiplikation im Binärsystem? Ist ja im Prinzip auch erstmal immer nur gucken,
wenn ich am Multiplicator-Ebene 1 habe, wird eben eine Multiplikant entsprechend verschoben,
genommen und hinzuaddiert, wenn ich eine Null habe,
brauche ich ihn eben nicht zu nehmen. Das heißt,
eine Multiplikation kann technisch gesehen dann eben auch so aufgesetzt werden,
dass wenn ich das jetzt also nicht durch wiederholtes Adieren und Schieben mache,
was dann quasi ein sequenzielles Verfahren wäre,
dass sich das eben so aufbaue, dass ich im Prinzip Talprodukte bilde,
indem ich dann eben mit so einer Unverknüpfung quasi den Multiplikator entsprechend ausblenden kann,
mit dem entsprechenden Bett des Multiplikaten,
dann habe ich eben einen ganzen Satz von diesen Talprodukten,
die muss ich dann eben entsprechend ihrer Stellenwertigkeit verschoben,
aufaddieren.
Nicht um das Ganze könnte man dann eben auch als Schaltnetz umsetzen,
wo ich dann eben einmal, also hier für dieses Ausmaskieren,
entsprechend viele Ungatter benötige und dann eben noch in Quadratvoll Adira,
die ich dann eben bräuchte, um diese Teilprodukte aufzuaddieren.
Und anschließend kann es eben noch sein,
dass eben entsprechend viele Überträge auftreten und da muss dann eben
noch ein Adira für die gesamte Wortbreite auftauchen.
Gut, inzwischen, also früher hat man Multiplikationen eben wirklich
nur durch wiederholtes Addieren und Schieben gemacht und im Reddit-Bereich,
wo ich jetzt also keine spezielle Hardware dafür habe,
wird das also auch immer noch so gemacht.
Bei größeren Rechner bzw. Prozessoren hat man natürlich also spezielle Multiplikationswerke,
die sowas machen. Da kann man dann eben sagen,
das ist dann also in CMOS-Technik,
wenn man also entsprechend bereit ist,
die Fläche dafür zu spendieren,
also kein Problem
Gut, für kleine Schaltungen macht das natürlich keinen Spaß,
kann ich ja auch sagen, okay,
also da nehme ich jetzt also einfach die Schaltfunktion,
fange da einfach eine Minimierung an und setze das halt zweistufiges Schaltnetz um,
also das geht auch, wie gesagt,
also hier, das wäre jetzt,
das sind zweimal zwei Bildmultiplizierer als zweistufiges Schaltnetz,
dann eben quasi jetzt hier von den zwei Bezahlen A
und B hier vier Ausgangsbits erzeugen kann
In der Regel sehen diese oder sehen Hardware-Multiplizierer aber eben so aus,
wie das eigentlich dann auch der Funktion her entsprechen würde.
Das heißt, wie ich das also auf dem Papier rechnen würde,
dass ich nämlich im Prinzip dann wirklich solche Array-artigen Strukturen habe,
wo ich dann eben immer sage, ich habe hier mein Multiplikanten,
der geht quasi hier immer parallel an alle Stufen rein.
In jeder Stufe kann ich den dann quasi jetzt mit einem
entsprechenden Bild des Multiplikators entweder komplett ausmaskieren. Das heißt,
wenn dieses Bit null ist, dann tut sich da nichts.
Und wenn das Bit 1 ist, dann muss sich das irgendwo nachher dazu addieren.
Und das entspricht dann eigentlich auch genau dem,
wie ich das also jetzt auf dem Papier rechnen würde. Und in dem Fall,
also jetzt hier so technisch realisiert als Array,
würde das dann eben so aussehen,
dass jeder dieser Blöcke intern jetzt eben quasi genau diese Funktion macht,
dass ich also hier mit so einem Ondgatta eben dieses entsprechende Bit X ausmaskieren kann,
wenn dies Y eben entsprechend jetzt null ist.
Das heißt, da wird dann eben nichts dazu addiert.
Ansonsten müsste ich jetzt eben an dieser Stelle dieses Bild dazu addieren und dann habe ich eben hier einen Adira,
der eben aus einem Teilprodukt, einen Carrie-Eingang und diesem Bit,
sofern es denn gesetzt ist,
dann eben wieder ein entsprechendes Summen mit Destalproduktes eben ein Carry-Ausgang erzeugt,
nicht in das Ganze,
ist dann eben entsprechend dieser Stellenwertigkeit dann immer so gegeneinander verschoben.
Und das müsste ich dann eben jetzt hier für alle vier mal vier
Bits dann quasi in so eine Matrix von 16 dieser Blöcke umsetzen.
Und am Ende habe ich dann letztendlich hier ein entsprechendes
Talprodukt und dann eben noch so ein Carry-Vektor.
Dafür brauche ich dann eben auch nochmal einen entsprechend breiten Adira,
der dann also als Rippelkerry Carry Lockerhead oder was auch immer realisiert ist,
der mir dann quasi aus diesem P Vector und diesem Carry
Out Vectoren hier dann eben wirklich die entsprechenden Zahlen und allen gesamten Carry Out berechnen kann.
Gut, das wäre also jetzt nur so grob vorgestellt
der Aufbau, eben vom Multiplizierer.
Also auch dazu gibt es dann also ein entsprechendes Hades Beispiel anhand dessen sehe
ich dann also nochmal so ein bisschen vergegenwärtigen könnten,
dass das Ganze überhaupt funktioniert.
Wie gesagt, ich wollte ja eigentlich nur grob die
Grundidee skizzieren
Das dahinterstehende Prinzip eben eigentlich genau dem entspricht,
wie man das eben auch auf dem Papier machen würde.
Nicht nur, dass es jetzt eben hier eben in so
ein Array von entsprechend vielen voll Adierern umgesetzt ist.
Gut weitergehende Schwierigkeiten, beziehungsweise was da noch dahinter hängt,
nicht wie verfahre ich mit negativen Zahlen,
beziehungsweise wie kriegt man sowas vielleicht also auch noch ein bisschen besser und ein bisschen schöner realisiert.
Da kann ich dann also auch nur Was also jetzt hier
auf der nächsten Folie drauf ist, auf die entsprechende Literatur verweisen,
also ob das nun von Armos Omondi oder Korn oder Spaniol ist.
Nicht also Arithmetik in Rechenanlagen, nennt sich das Ganze.
Da sind dann wirklich für Multiplikationsalgorithmen für Divisionsalgorithmen für Wurzel ziehen,
für irgendwelche Trigger und nometrischen Funktionen, was auch immer,
die entsprechenden Algorithmen mit drauf und mit drin.
Wie gesagt, ich werde das jetzt hier einfach aus Zeitgrund nicht weiter vertiefen,
weil, kann ich auch nur sagen,
also rein praktisch werden wir das jetzt hier also auch nicht
Weiter brauchen. Und ja, damit möchte ich mich erstmal
für die Geduld bedanken und dann für heute Schluss machen.
Dann müssen wir morgen