Ja, ich hatte ja Freitag letzte Woche im Prinzip aufgehört mit dieser Kurzvorführung zu hart ist. Also sprich,
um das Werkzeug zu zeigen,
mit dem wir jetzt also hier in diesem,
beziehungsweise dann eben auch im nächsten Kapitel dann auch so ein bisschen arbeiten werden,
beziehungsweise wo dann im Prinzip dann die entsprechenden Beispiele einfach mal so ein bisschen auch visualisiert werden,
aber eben natürlich dann also auch nochmal logisch in der Simulation durchgespielt werden können.
Ansonsten seit Montag laufen dann ja also jetzt auch praktisch schon die Versuche,
die er dann teilweise dann eben auch oder zum größten Teil
eigentlich dann auch auf Hades aufbauen und diejenigen von ihnen,
die jetzt also da in den Kursen sind,
werden das dann dort entsprechend ja auch schon gesehen haben.
Ja gut, wie gesagt, beste Idee ist einfach immer runterladen,
selber ausprobieren, ein bisschen mit rumspielen,
dass man da einfach entsprechend zur Rat reinkommt.
Grundkomponenten und die grobe Funktionalität hatte ich also
schon mal
ganz kurz gezeigt
Hierzu auch nochmal Hinweis, also mit dieser Glow-Mode-Visualisierung,
also da geht es ihm letztendlich ja darum,
dass man in der Funktionalität einfach an der Farbe der Leitung dann eben schon sieht, welcher Wert dort im Prinzip drauf ist.
Ansonsten gibt es in Hades auch die Möglichkeit,
also das, was man eigentlich, sagen wir mal,
sonst so irgendwie aus digitalen oder analogen Simulatoren kennt,
dass man dort dann also im Prinzip solche Impulsdiagramme sich aufzeichnen lassen kann,
nicht wo man dann eben sagt,
also ich habe hier einen Eingang A und irgendein Ausgang B und nicht man hat dann eben irgendwie über die Zahl dann eben jetzt irgendwie so einen zeitlichen Verlauf,
wo man dann also sehen kann,
also beispielsweise beim Inverter,
was sich da tut.
Also auch dazu folgen da dann nochmal so ein bisschen Beispiele.
Hierzu auch nur nochmal kurzer Hinweis auf das,
was also jetzt hier mit diesen Default-Werten beziehungsweise mit diesen Farben
also letztendlich gemeint ist, war das, denke ich mal,
sicherlich also auch nicht so ad hoc.
Klar ist, wenn man jetzt nicht gerade,
also irgendwie schon aus dem Hardwareentwurf kommt.
Gut, also logisch, null logisch eins ist letztendlich klar
Was in Hades dann eigentlich auch immer noch mit dargestellt oder visualisiert wird,
sind Werte, denen noch nie irgendwie was zugewiesen wurde,
die werden dann im Prinzip dann, also die Leitung immer in einem Zyan gezeichnet.
Das ist, sagen wir mal, immer ganz sinnvoll,
kommt von der Idee her eigentlich dann eben auch von Digitalsimulatoren,
die jetzt also im Prinzip dann also auf Hardware-Beschreibungssprachen,
also auf VDL zum Beispiel arbeiten, wo man genau diese Datentypen dann nämlich so hat,
wo man jetzt sehen kann, wenn man jetzt also eine hinreichend komplexe Schaltung hat,
sieht man eben, ob irgendein Signal irgendeiner Leitung schon mal überhaupt was zugewiesen wurde.
Und dadurch kann man dann eben also,
sagen wir mal, sehr einfach sehen,
wenn das jetzt nicht funktioniert, also woran das liegt,
also ob das jetzt so quasi der eigene Fehler ist,
weil da jetzt also irgendwie was falsch kodiert oder in diesem Fall dann falsch verbunden habe,
oder eben irgendwie so war es, die gerade bei Hardes,
das ist mir ja dann am Freitag auch passiert, nicht,
also man Bringt jetzt also quasi auf dieser Oberfläche jetzt irgendwo seine Elemente zusammen,
meint,
die dann also mit einer Leitung zu verbinden.
Also eigentlich sollte sich was tun, nichts tut sich.
Und das sieht zwar so aus, ist aber dann eben doch nicht angeschlossen für den Simulator. Diese beiden Werte,
Treestate und Undyfined, da geht das im Prinzip um folgenden Hintergrund,
dass man sagt, das was wir jetzt hier eigentlich immer haben,
beziehungsweise jetzt in diesem oder am nächsten Kapitel letztendlich betrachten,
sind Schaltungen, wo man sagen kann,
ich habe halt eben irgendwie sowas wie Gatta,
also irgendwie zum Beispiel ein Inverter und dessen Ausgang geht dann eben an ein oder mehrere Eingänge von irgendwelchen anderen Gattern und so weiter.
Was man aber elektrisch oft tat, ist,
dass ich innerhalb meiner Schaltung,
die ich also letztendlich aufbaue und dann also auch irgendwie simulieren möchte,
ein Bussystem habe, Bussystem in dem Sinne,
wo man sagen kann, also beispielsweise,
wenn ich jetzt Hier irgendwie klassisch, nicht von Neumann-Konzept.
Und ich habe jetzt also hier irgendwie meine CPU.
Ich habe hier irgendwo... Ein Speicher und die sind jetzt
eben irgendwie über Adressboss. Und Datenbus miteinander verbunden. Und
Bruguki beim Adressbus, das ist letztendlich in eine Richtung.
Nicht wo ich also sage, kann, also okay,
ich möchte hier aus dem Speicher von der und der Adresse
irgendein Wort lesen oder in eine bestimmte Adresse ein Wort reinschreiben.
Bei den Daten habe ich aber im Prinzip eine Verbindung,
wo ich eben entweder beim Schreiben in den Speichern Datentrantransfer in
das Rahmen hinein habe, beim Lesen genauso umgekehrt. So,
und um jetzt diese Bidirektionalität dann eben irgendwie zu kennzeichnen,
beziehungsweise wenn man jetzt eben wirklich ein Bussystem nimmt,
wie es also auf den Rechnern, also typischerweise,
also irgendwo auf Platinen vorhanden ist,
wo ich dann eben sagen kann,
ich habe jetzt nicht nur zwei Komponenten angeschlossen,
sondern ich habe jetzt also noch
deutlich mehr Komponenten angeschlossen
Dafür braucht man dann eben sowas,
wie diese sogenannten Tree-State-Sachen, wo es letztendlich darum geht,
dass ich von der Grundidee quasi folgendes mache.
Also wenn das jetzt hier also mein Bus ist und ich habe hier irgendeinen Ausgang,
also beispielsweise jetzt also irgendein Register oder irgendwas,
was also von der CPU aus hier irgendwo auf
diesen Bus geht
Und irgendwo anders, also sei das jetzt ein RAM oder sei das jetzt irgendeine andere Komponente,
habe ich dann eben auch irgendein Element, was also hier auf diesen Bus geht.
Was jetzt natürlich nicht machen darf, ist, dass ich sage,
ja gut, der eine schreibt hier eine Null auf dem Bus,
und der andere schreibt eine Eins auf dem Bus,
und das, was man dann also hart nennt,
sich eben elektrisch gesehen, Kurzschluss,
und irgendwo hier drin werden, also irgendwelche Transistoren sehr,
sehr warm, und irgendwann lösen sie sich auf,
und das war es dann mit der Schaltung.
Deswegen gibt es dort dann spezielle Elemente,
die also letztendlich wie ein Schalter fungieren, wo man dann eben sagen kann,
ich kann hier quasi am Ausgang nicht nur null oder eins sagen,
sondern ich kann nur noch sagen, das Ding ist abgeklemmt.
Und dieses abgeklemmt, was ich eben brauche, um zu sagen,
okay, wenn ich den Datentransfer von der CPU zum Rahmen habe,
dann sind hier quasi die Schalter geschlossen, Daten können fließen und das,
was aus dem Rahmen sonst rausgehen würde, dort habe ich dann eben letztendlich diesen Trees-Day-Zustand.
Wenn ich ein Trees-State, wie der Name dann ja auch schon andeutet,
habe ich dann eben die Werte 0 und 1 und eben dieses Z für Schalter offen. Gut,
wie man das jetzt elektrisch realisiert, wie das dann entsprechend aussieht,
denkt mir das, brauchen wir jetzt also hier nicht weiter,
aber eben für solche Brustsysteme, eben diese Bidirektionalität,
brauche ich dann eben noch was anderes,
als jetzt eben nur eine logische Null oder eine logische 1. Andere Sache ist,
was man also in Simulatoren von irgendwelchen Schaltungen eben auch gerne hat,
ist, also eine Darstellung von irgendwelchen ungültigen Werten oder eben von dem,
was ich hier gerade beschrieben habe, irgendwie Kurzschlusssituationen.
Und um das zu zeigen, gibt es da dann eben noch diesen Wert X,
der genau so was, also auch noch mit andeuten kann. Gut,
ansonsten, wie gesagt, Schades einfach runterladen,
entsprechend starten und entweder durch die mitgelieferten Beispiele,
also ich habe ja in dieser ZIP-Datei also schon entsprechend viel mit drin,
was man dort also letztendlich laufen lassen kann,
dort also einfach entsprechend mal durchgehen oder eben hier selber irgendwelche Elemente,
irgendwelche Gatter nehmen,
kann die dann also hier irgendwie entsprechend anordnen und dann im Sechs,
so.
Miteinander verbinden und mit irgendwelchen Eingängen Ausgängen versehen und das Ganze
dann eben wirklich mal so durchspielen und damit dann eben entsprechend seine Schaltung aufbauen.
Gut, ja, was gibt es da so? Also sagen wir mal,
die üblichen Sachen, also von einfachem in Wärter und Gatta oder Gatta,
nennt Gatta, Norgatta, also hier jetzt in dieser Amerikanischen Symbolik,
wie gesagt, also jeder macht das immer so ein bisschen anders.
Also dort ist das dann dementsprechend so aufgebaut. Hier eben
auch nur nochmal der Hinweis nicht. Also das heißt,
hierhinter verbirgt sich dann eben der entsprechende Link,
über den man das Ganze jetzt quasi als Web-Applet starten kann,
was also auch geht, wo man dann auf der passenden Seite ist.
Ansonsten ist letztendlich dieser String dann nämlich genau das,
was man im Prinzip dann also hier unter Hades Bei Open quasi öffnen würde.
Achso, und jetzt hatte ich 10 Gates, 0-0 Gates,
so natürlich hier in den falschen Pfad irgendwie ausgewählt.
Also, ja. Und dort würde man an eben die
entsprechenden Sachen, so wie ich sie da jetzt hatte,
also dann eben direkt haben
Der Simulator, wenn man also hier an dieser Zeit sieht,
startet dann eben schon automatisch. Und das kann man also sehen.
Dass ein BAFA quasi den Eingang eins zu eins durchleitet und
ein Werter invertiert, naja gut, das ist also,
sagen wir jetzt nicht so sonderlich erhellend, aber gut,
also das eben so zu der einfachen Grundfunktion.
Nicht wie gesagt, damit kann man jetzt eben diese ganzen Grundschaltungen ausprobieren,
hier dann eben so verschiedene Beispiele,
also hier nochmal so ein Visualisierung der morgenschen Regeln, nicht dann gibt es
In der Regel von diesen Gatternern,
also auch noch unterschiedliche Varianten mit ein, zwei, drei oder vier Eingängen.
Das ist also jetzt hier, also im Beispiel der und,
beziehungsweise Nantgarda, dargestellt. Wenn man mehr Eingänge bräuchte,
hatte ich am Freitag auch schon kurz angesprochen,
wird das in der Regel, so wie hier angedeutet, mehrstufig realisiert.
Das heißt, also wenn ich jetzt eben und Gatter mit zwölf Eingängen brauche,
dann wird das also quasi über so eine Kaskade aus entweder zwei Stufen und gerade dann gemacht,
wie also auf der linken Seite.
Oder entsprechend der Regeln der Bullschnagelbradern, also durch einen entsprechenden Ausdruck,
der dann aber letztendlich genau das Gleiche macht wie dann.
Also da ist auf der rechten Seite. Wie gesagt,
Grund dafür ist dann eben auch wieder eine elektrische Schadungstechnik,
dass, sagen wir mal,
sogar da in typischer Weise nicht mehr als 4A-Eingänge,
zumindest jetzt also in dieser Form haben, wenn man mehr hätte,
wären die eben, sagen wir mal,
einfach elektrisch jetzt wieder so langsam beziehungsweise würden,
also zumindest also bei einigen Eingängen, also auch unsicher schalten, dass man das nicht macht.
Deswegen, also diese mehrstufige Sache. Gut, hier,
Norgatta, dann auch noch eine Sache, was ich dann,
also ein Hades auch findet,
was dann eigentlich auch wieder jetzt über die technische Realisierung von dem Ganzen dann mit reinkommt.
Da tauchen dann also sogenannte Komplexskatter auf, also das,
was wir hier zum Beispiel sehen,
also hier auf der linken Seite sowas wie so ein AOI-2-1, Norman das jetzt genannt.
Für uns ist das also letztendlich eine zweistufige Logik,
nämlich ein Hirn- und Gatter mit zwei Eingängen,
dessen Ausgang geht dann eben nochmal an ein Norgatter,
was dann eben zusätzlich auch nochmal einen zweiten Kontrolleingang hat.
Nicht nur um Klatur ist letztendlich so, dass man immer sagt,
End, or in Word, nicht zwei Eingänge bei dem End,
noch ein zusätzlicher bei dem Ohr und invertierend eben immer am Ausgang.
Da sind dann eben jetzt hier auch so einige verschiedene Typen
Realisiert. Grund dafür ist das hier unten auf der Folie
auch schon mit angegeben. In der Schaltungstechnik,
wie das Ganze jetzt wirklich also einzeln aus Transistoren nachher
so aufgebaut und also gefertigt wird, ist es so,
dass also im Prinzip so ein Gatter genauso aufwendig ist,
wie jetzt ein Normales nennt oder ein normales Norgatter.
Das heißt, wenn ich jetzt sage,
ich habe jetzt also irgendwie einen End- oder einen Norgatter mit drei Eingängen,
dann brauche ich dafür also sechs Transistoren,
um das zu bauen in CEMAs Schaltungstechnik,
brauche ich also für dieses Ding
hier eben genauso
Deswegen finden sich dann eben in solchen Bibliotheken für irgendwelche Werkzeuge,
mit denen man, also nachher dann also wirklich in den Schippentwurf reingeht,
dann eben auch immer zuhauf, also irgendwie irgendwelche Komplexskater. Wie gesagt,
für uns ist das immer irgendwie eine zweistufige Logik, nicht und gerade,
wenn man dann also irgendwie immer so an diese ganzen Lügungsaufgaben denkt,
also die jetzt das auch gerade wieder irgendwie rausgegangen sind,
wo es also dann darum ging,
da also jetzt irgendwie mit den konjunktiven, disjunktiven Normalformen,
also irgendwie rumzurechnen, muss man immer sagen, naja gut,
also irgendwas dann also auf solche Gatter abzubilden,
Muss man nicht zwingend machen,
weil das dann doch also irgendwie relativ umständlich zu rechnen ist.
Dafür kann man dann ja auch glücklicherweise sagen, ist dann also wieder Kollege Computer zuständig,
weil hat ja auch schon mal ganz kurz angedeutet, also die Art und Weise,
wie heutzutage eigentlich Hardware entworfen wird. Ist also jetzt nicht,
dass man also wie in Hardes irgendwie anfängt,
also mit so einem Schaltplan Editour jetzt,
also irgendwie einzelne Gatter zu nehmen und die irgendwie aneinanderzusetzen,
sondern dafür hat man dann eben auch ähnlich wie in Programmiersprachen Hardwarebeschreibungssprachen,
mit denen ich letztendlich sage,
was eine Schaltung machen soll und hinterher habe ich dann eben Programme,
die mir dieses Was dann eben automatisch in irgendwelche Gatter-Bibliotheken umsetzen,
wo dann eben unter anderem also sowas mit auftaucht.
Aber man selber muss sich dann also mit sowas dann nicht mit weiter rumschlagen.
Gut, dann hier nochmal XO, XNOR Gatter.
Also wie gesagt, da gibt es dann also alle möglichen Typen.
Auch dazu jetzt nochmal die Anmerkung,
auch mal so ein bisschen nochmal wieder so in diese ganze Schadungstechnik,
ja hier bei den Komplexka dann auch schon aufgefallen ist.
Also die haben in der Regel immer irgendwie einen invertierenden Ausgang.
Nicht auch da muss man sagen, in der Zehmausschaltungstechnik ist
es so, dass eigentlich alle Gatter invertieren am Ausgang.
Das heißt, ein Und-Gatter kann ich nicht bauen.
Und Und-Gatter ist ein Nant-Gatter unten in Wertter dahinter. Gut,
solange ich das nämlich selber minimieren muss als Schaltalgeberagen aus,
dockt dann ein Programm habe, was mir das automatisch umsetzt,
soll mich das eben alles nicht stören.
Nicht jedenfalls,
also das dazu
Da dann eben auch nochmal der Hinweis,
sowas wie ein Exklusiv-Oder-Gatter gibt es eben auch nicht in einfacher Realisierung jetzt irgendwo als Schaltung fertig,
sondern das wird dann eben nicht so umgesetzt,
sondern in der Regel dann eben auch über so eine mehrstufige Realisierung,
das heißt Entscheidungstechnik wäre das dann eigentlich sowas wie hier so
diese beiden Nancs hintereinander und diese Enverter nicht und das Ganze Sind jetzt also hier unterschiedliche Realisierungen,
die letztendlich aber alle irgendwie in Exklusiv-Oder von der Funktionalität her darstellen.
Wie gesagt, wenn man das ausprobieren will,
eben ganz einfach. Hier in Hades und der Exor-Variance,
ich kann dann eben hier irgendwie jetzt sein, seine Schaltung,
wo man dann eben überall mal gucken kann,
ob das dann eben auch entsprechend richtig tut.
Und wie man dann also hier Sieht.
Tun also alle vier Schaltungen letztendlich genau das Gleiche,
sind aber eben jeweils in unterschiedliche Schadungstechnik,
beziehungsweise entsprechend dahinter liegend, also unterschiedlicher Logik realisiert worden.
Gut, wie gesagt, sowas wie Exklusiv oder Gatter haben wir
ja also vorher schon in verschiedenen Beispielen zur Codierung zur Zahlendarstellung
relativ häufig irgendwo benutzt. Also zum Beispiel,
als ich hier jetzt um sowas wie Parität von vier Bits zu berechnen,
Ich fasse dann also typischerweise eben immer in so einer kaskadierten Lösung gemacht wird.
Das kann man dann natürlich beliebig weit aufblesen. Also jetzt hier in so einer Form,
wo man sagt, ich habe hier acht Dateneingänge,
wo dann eben im Prinzip dann über so eine dreistufige Realisierung im Prinzip,
also hier die Parität berechnet würden.
Und dann ist das Ganze zusätzlich nochmal wieder mit dem Exklusiv oder nochmal mit einem anderen Eingang,
beziehungsweise eigentlich mit zweien Versehen, wo ich dann eben sagen kann,
damit könnte ich das Ganze eben entweder auf zehn Bit erweitern oder ich nehme jetzt
Wenn ich jetzt noch mehr bräuchte, den Ausgang und füge den
dann eben hier mit rein, kann dann eben entsprechend noch größere Bäume aufbauen.
Dann Scheidungen, die man eben auch noch häufig findet,
multiplexer, sind uns im Prinzip im letzten Kapitel bei den Schaltennetzen,
also auch schon mal begegnet, als es also im Prinzip um die Darstellung ging in den Entscheidungsbäumen.
Da gab es mal so ein Beispiel mit Multiplexer,
kann man sich eben immer vorstellen, als ein Schaltnetz,
womit man also mit einem Steuereingang, beziehungsweise einen entsprechenden Vektor, also zwischen Dateneingängen ausgewählen kann und dann eben zu einem Ausgang umschaltet. Nicht also hier jetzt,
also die einfachste Variante,
wo dann im Prinzip über den Eingang S entweder A0 zum Ausgang geschaltet wird,
wenn es gleich Null ist oder A1,
wenn es gleich eins ist, nicht,
dass wir das Ganze an ihm jetzt wirklich erstmal so als Schaltfunktion aufgeschrieben was man da dann häufig macht,
weil dann sieht man also sehr viel einfacher,
die Funktionalität ist dann eben auch so eine Verwendung von Don't Cast in den entsprechenden Funktionstabellen,
wo ich dann eben hier direkt sehe, okay,
also wenn ich hier bei S gleich 0 bin,
bin ich eben unabhängig von A1 und der Ausgang,
ja, der Ausgang entspricht dann eben A0,
beziehungsweise hier entsprechende Ausgang dann eben A1. Oder man kann das noch ein bisschen kompakter schreiben,
indem ich dann eben quasi hier mit sowas wie Variablen arbeite und dann eben direkt sehe,
was dort also weitergeschaltet wird.
Gut, das gibt es dann natürlich jetzt nicht nur mit 2 zu 1,
sondern entsprechend mit N zu 1 Umschaltung, je nachdem,
wie viele Eingänge ich habe, bräuchte ich dann eben quasi, ja,
Lorhythmus 2 von Anne und davon also quasi dann aufgrund also die Obergrenze Steuereingänge,
um das also umzuschalten und dann eben habe ich einen Datenausgang,
also hier ist jetzt das Beispiel eines 4 zu 1 Multiplexers,
wo ich dann im Prinzip mit zwei Steuervariablen 0 1,
2 und 3 kontinuierlich einfach binär durchskodiert als Werte annehmen,
dann eben entweder A0, A1,
A2 oder A3 auf den Ausgang durchschalten.
Gut, Funktionalität ist eigentlich soweit. Klar, wie gesagt,
also auch dazu gibt es dann also verschiedene Beispiele,
die man da dann in Hardes durchspielen kann,
was man häufig dann findet, sind dann eben für Multiplexer. Solche Symbole,
also das, was ich dann teilweise auch schon hatte,
beziehungsweise was hier also auch schon mal aufgetaucht ist,
wo man dann, ich mach das mal hier oben,
Wenn ich also hier irgendwie seine Eingänge hat,
hier seinen Ausgang und hier mit den Steuereingängen dann eben quasi auswählt,
welche von den Eingängen dort entsprechend weitergeschaltet wird.
Auch da muss man sagen,
dass es dann immer nicht so ganz eindeutig,
häufig ist es, also von der Nummerier deswegen,
also immer ganz wichtig, Nummerierung, also 0-1,
2-3 Mal ist es andersrum,
nicht das wird dann immer aus so einem einfachen Symbol dann
immer nicht so ganz klar
Analog dazu gibt es dann Demultiplexer. Auch das ist dann,
wie also jetzt hier in diesem hartes Beispiel,
also das, was hier unten auftaucht,
dann eigentlich nichts anderes als genau das Gegenteil davon.
Ich habe einen Dateneingang und verteile das dann eben auf,
wenn ich jetzt eben hier entsprechend in Steuereingänge habe,
dann auf zwei hochennen Ausgänge.
Gut, auch das kann man dann eben
entsprechend sich ansehen
Beziehungsweise dann also hier in hartes Mal durchsimulieren. Also hier sind jetzt also
quasi so zwei solche Impulsquellen-Ahne, die ein bisschen länger langsam Takt generiert.
Ahne, die hier einen schnelleren Takt generiert. Und ich habe dann eben hier Multiplexer,
wo ich dann also quasi eben hier so ein 2 zu 1
Multiplexer eben entweder auf den schnellen oder auf den langsamen Takt umschalten kann,
hier mit so einem 4 zu 1 Multiplexer eben entweder das oder eben konstant 0 oder 1. Letztendlich habe So,
jetzt nehmen wir hier mal den schnellen Tag und hier wäre dann eben dem Multiplexer,
wo ich dann also quasi jetzt hier mit diesen beiden Steuerleitungen eine von den vier Ausgängen entsprechend auswählen kann.
Gut, wie gesagt,
dazu findet man dann häufig dann eben auch irgendwie dann nochmal größere Beispiele,
also hier dann eben auch nochmal so ein Web-Demo,
wo das dann also im Prinzip jetzt also so ein 8 zu 1,
multiplexer ist der, der dann also hier quasi jetzt mit diesen Dreikontrollvariablen also umschalten kann.
Zusätzlich gibt es da nochmal so ein Bit, womit das Ganze wieder ausgeblendet werden kann.
Und dann gibt es noch einen Ausgang invertiert oder nicht invertiert.
Gut, warum jetzt also hier dieses Beispiel,
beziehungsweise was hat das er sich hier oben zu sagen?
Also das mit diesen 74 irgendwas bezieht sich eigentlich auf etwas,
auf ihn mal so ein Muster ohne Wählen mitgebracht. Also wenn man Vielleicht mal also bei uns in der Informatik gibt es ja also unten im Keller von Haus C,
also auch sowas wie so ein Computermuseum,
was also ein emeritierter Professor,
also in relativ viel Arbeit an alten Sachen zusammengetragen hat,
wo dann teilweise also auch ganz interessante Schätze sind,
also auch teilweise wirklich alte funktionsfähige Computer,
das heißt also so die allerersten Apple 1 nicht,
aber in Apple 2 zumindest, aber der auch noch läuft,
nicht oder irgendwelche Artenkommodores, wo man also im Prinzip die Daten,
also per Data Sette,
also das war im Prinzip eine Kompaktkassette wo dann also statt Musik eben irgendwelche,
sag ich mal, Modemtöne drauf sind.
Und das wurde dann eben als Null oder Eins interpretiert.
Und das hat man dann also irgendwie einmal durchgespielt
und konnte dann also irgendwie da einzeln seine Bits,
also irgendwie in den Speicher reinbringen und damit also Programme laden.
Also das ist ganz spannend, was es dort gibt.
Also wenn mal wieder am Fachbereich,
also dort irgendwie Tag der offenen Tür ist oder sowas,
kann ich das also Ihnen nur empfehlen, sich also mal anzusehen.
Das ist also nicht verkehrt. Nee, also sowas,
was ich hier in der Hand halte,
das ist eben auch etwas, wo man sagen muss,
na gut, also heutzutage ist ein Computer, also eine CPU,
Ein einziger kleiner Ship, wo alles drin ist.
Und wenn ich so ein Mikrocontroller nehme, also das,
was zum Beispiel irgendwie so Aduino-Dimension ist,
dann habe ich also auf dem Ship die CPU,
da habe ich den Speicher drauf, da habe ich noch irgendwelche einen Ausgabeeinheiten drauf und, und, und.
Wie gesagt, vor, naja, 40 Jahren,
muss man jetzt sagen, war das noch nicht ganz so.
Da waren also Computer das, was sie ja ganz am Anfang mal so gesagt hatte.
Also letztendlich also irgendwelche großen Kisten, die also irgendwie mit irgendwas vollgesteckt waren.
In der Regel steckt dann also relativ viele von solchen Platinen drin.
Hier darauf sieht man also jetzt vergleichsweise sehr viele Chips.
Das sind eben diese typischen Chips, die man so in den,
also ich würde das hier irgendwie so in die 70er Jahre einordnen,
die man also in der Zeit hatte,
wo man dann sagen kann, okay,
also hier habe ich jetzt eben einige Logik-Gatter zusammengebaut und auf dieser Platine ist beispielsweise jetzt irgendwie ein Tal der CPU.
Noch nicht mal die gesamte CPU,
sondern mehrere und es wird dann eben hier entsprechend hinten über Steckkontakte
beziehungsweise es gab dann hier vorne auch noch irgendwie so Steckkontakte,
wo das Ganze dann eben entsprechend zusammengebaut war, eben auch noch miteinander verbunden.
Und wenn ich dann also irgendwie so ein paar Kuchenbleche damit
vollgemacht habe und die miteinander verbunden habe, dann ist das jetzt eh meine Alu.
Gut, und diese 74-Irgendwas-Dinger. Also hier mal so
ein Beispiel. Das waren also die, die eigentlich,
sagen wir mal jetzt so Ende der 60er bzw. in den 70er Jahren
die Teile waren, wo er aus dem Computer aufgebaut hat.
Was also wirklich losging mit aller Primitivster Funktionalität. Also der
Allerallfachste war 74-0-0. Wie man hier sieht,
das ist also im Prinzip dann so ein Dual-Inline-Gehäuse mit 14 Beinchen
und da drin befanden sich sozusagen dann vier nennt Gatta.
Und wenn man entsprechend viele von denen nimmt und irgendwie passend miteinander verbindet,
könnte man Und 16 Bit oder dann 32 Bit,
Adira und dann der Alu und insgesamt dann mit einem kompletten Rechner aufbauen.
Wird dann natürlich entsprechend aufwendig, nicht deswegen, also diese Dinger. Gut,
und deswegen, also nur hier der Hinweis,
also bei einigen von diesen Beispielen, die jetzt hier kommen,
finden sich dann immer 74 irgendwas,
das sind dann eben quasi immer diese Bauteilbezeichnungen, die sich dahinter verbergen.
Gut, ansonsten kann man nur sagen, okay,
ist historisch mal ganz nett, gehört zu haben,
muss man aber jetzt nicht mehr zwingend wissen.
Wie gesagt, ist dann also auch nicht in Übungsaufgaben oder in
irgendwelchen anderen Sachen von Irgendwas, was man als wissen müsste.
Gut, also wie gesagt, das ist das,
was sich jetzt hier als Beispiel verbindet. Nicht,
also das heißt also, diese Schaltung aus jetzt,
also diesen Gattern, so wie das zusammengebaut war,
war dann eben letztendlich ein so ein Baustein,
wie er da, also vielleicht schon auch irgendwo mit drauf ist.
Gut, Demultiplexer, also genau das Gleiche.
Also hier dann eben auch so ein Teil,
wo dann letztendlich hier mit vier Steuereingängen ein Eingang zu 16 Ausgängen dekodiert werden konnte.
Und was man dann häufig hat, ist,
also teilweise dann auch schon so ein Hades dann eben fertig,
sowas, wo das Gar nicht mehr jetzt als interner.
Das heißt, wie das jetzt also aus einzelnen Gattern aufgebaut ist,
gezeigt wird, sondern wo man dann eben nur noch so ein Symbol hat,
was dann eben hier letztendlich irgendwie so ein bisschen an so einen Chip erinnert.
Nicht also hier die vier Steuereingänge,
da kann ich dann eben quasi über so einen Schalter die
16 Kombinationen entsprechend eingeben und der Eingang wird dann eben hier an einen der 16 Ausgänge weitergeleitet.
Gut, wofür braucht man sowas? Im Prinzip findet sich das eben in jedem Speicher,
weil, wenn ich sage,
ich habe jetzt hier sowas wie so einen Rahmenspeicher,
ich möchte jetzt eine bestimmte Adresse adressieren, um zu sagen,
dort soll geschrieben, reingeschrieben werden oder von dort soll gelesen werden,
dann ist immer dieses hier vor letztendlich nichts anderes als so ein Demultiplexer,
mit dem ich dann eben diese entsprechende Adresse auswähle,
indem ich dann also hier über den Adressbus dann quasi sage,
von Adresse 0 bis 2 Wochen minus 1 kann ich dort
also jetzt quasi meine Speicherzahlen angeben
Gut, damit verlassen wir jetzt also diese hervorragenden historischen Beispiele.
Jetzt folgen hier noch einige ganz kleine Beispiele jetzt für wirklich so ein praktisches Schaltnetze.
Wie gesagt, Charleton jetzt hatte ich am Freitag schon eingeführt.
Kann man sich jetzt immer vorstellen, im Gegensatz zur Schaltfunktion, als ein Bündel von Schaltfunktionen.
Bei der Schaltfunktion habe ich im Prinzip nur einen Ausgang.
Beim Schaltnetz habe ich ebenentsprechend mehrere. Würde man dann eben sowas wie eine Bündelminimierung machen,
dazu folgen jetzt also hier so ein paar kleine Beispiele als erstes Angenommen,
wir haben jetzt also hier irgendwie so eine Schaltung,
wo ich also hier jetzt sieben LEDs draufbringe und ich möchte die jetzt so ansteuern,
dass sie dann quasi jetzt wie so ein elektronischer Würfel über Pseudo-Zufahrtszahlen mir da jetzt also irgendwie mal was würfeln.
Dann wäre jetzt also quasi die Funktionalität, dass ich sage,
ich muss eben entweder bei einer 1 dann eben hier diese mittlere LED,
bei einer 2 dann eben die und die hier und so weiter und so fort dann eben passend ansteuern. So,
von der Funktion, wenn ich das jetzt entwerfen würde,
würde man jetzt eben sagen, okay,
ich habe hier die Werte, angenommen ist,
dass das auch gar nichts gezeigt werden von 0 bis 6,
kodiere ich jetzt also hier einfach durchgezählt in 3bit und habe dann also hier als Ausgänge dann eben die Ansteuerung für die einzelnen Leuchttionen,
wo ich dann eben sage,
bei einer 1 soll eben diese Leuchttiode leuchten,
bei einer 0 soll sie nicht leuchten.
So und die Aufgabenstellung ist dann eben zu sagen,
okay, wie sieht jetzt also das Schaltnetz oder die Schaltung,
jetzt ist beispielsweise ein Hades,
also aus,
die genau das realisiert
So, und nicht das, was er jetzt machen würde,
ist, dass man jetzt eben entweder sagt, okay,
ich nehme jetzt für jeden diese Ausgänge die Funktionalität,
fange dann eben an,
wie das jetzt also quasi aktuell in den Übungsaufgaben ist,
dass jetzt also irgendwie ein KV-Diagramm einzutragen und dann eben entsprechend zu minimieren,
beziehungsweise dann eben zu gucken, welche Teile,
welche Therme kommen jetzt, eben vielleicht nicht nur in der einen,
sondern eben auch noch in irgendwelchen anderen Ausgangsfunktionen vor.
Gut, in dem Fall sieht man,
dass es also hier so gewisse Symmetrien gibt, nicht,
also X-1 und X-7 sind letztendlich die gleiche Funktion,
X2 und X6 und X3 und X5. Und wie man dann eigentlich auch schon relativ einfach,
also direkt einfach hier raussehend lesen kann.
Also X4 ist nichts anderes als das Eingangsbild Null.
X1 beziehungsweise X7 wäre B2 oder B1. Also wie gesagt,
also bei diesen kleinen Beispielen sieht man das dann immer noch vergleichsweise einfach.
X2 wäre Dann B2 und B1. Ich und X3 ist nichts anderes als B2. Ja gut,
und damit lande ich dann also letztendlich bei dieser Minimierung,
beziehungsweise wenn man das Ganze dann eben in Hades macht,
wäre das dann also diese Schaltung mit den beiden Gattern letztendlich nur.
Gut, nicht. Also auch das könnte man jetzt
eben nochmal starten simulieren. Gut, will ich jetzt also
mal drauf verzichten. Anderes Beispiel, das hatte ich
ganz am Anfang auch schon mal ganz kurz gezeigt,
ohne jetzt auf Hades
weiter einzugehen
Dualcode, Greycode-Umsetzung. Ich weiß ja dann,
also von der Funktionalität her immer sehr war,
dass man quasi zwei benachbarte Bits nimmt, mit einem Exklusiv-Oder letztendlich verknüpft.
Genau das ist also hier dann die entsprechende Hadesschaltung dazu.
Nicht, dass MSB bleibt und ansonsten würden eben quasi zwei Bits genommen. Und mit einem Exklusiv-Oder verknüpft,
beziehungsweise von der Funktionalität her war es so,
dass man sagen kann, okay,
wenn ich von 0 nach 1 oder von Arzt nach 0 einen Übergang habe,
erhalte ich eine 1, wenn das Bit gleich bleibt,
also 0-0 oder 1-1,
erhalte ich eine 0,
das ist eben
genau diese Schaltfunktion
Gut, dazu gab es dann eben dann auch wieder die Rückrechnung,
wo man dann eben vom Greycode in den Dualcode kommt,
was dann eben auch über exklusiv oder ist dann aber eben quasi jetzt von links nach rechts dann immer kettenweise weitergerechnet.
Nicht also auch dazu könnte man dann eben so eine harte Schaltung aufbauen, das Ganze dann eben einmal durchsimulieren, beziehungsweise sich ansehen. Etwas größeres Beispiel,
ich war es jetzt also quasi auf das vorletzte Kapitel nochmal zurückgreift,
da hatte ich ja den Hemmingcode vorgestellt,
also in diesem Fall ist es also 7-4 Hemmingcode,
wo man sagen kann, okay, ich habe 4 Nutzbits,
mache daraus insgesamt 7 Datenwitz, drei Prüfbitz,
nehme ich an, stelle 0-1 und vier und das,
was man, beziehungsweise 1, 2 und 4 eigentlich,
nach der Termine Lucui, Terminologie, die ich da hatte,
das, was man da dann eben machen kann, ist,
dass man das Ganze dann eben auch hier beispielsweise dann in Hades macht,
Prüfbildberechnung der Enco, da ist dieses hier,
also das sind quasi jetzt die Originalbitz,
dann läuft das quasi durch den Kanal.
In dem Kanal kann ich jetzt also Fehler erzeugen,
was ich also einfach hier dadurch mache,
dass ich hier das Ganze nochmal mit dem Exklusiv oder mit einzelnen Bits quasi so verknüpfe,
dass ich dann eben hier die Eingänge nochmal gezielt invertieren kann,
was dann eben das Auftreten eines fehlerhaften Bits bedeutet.
Habe dann hier quasi die Dekodierung, das,
was also in der Funktionalität dann beispielsweise dann jetzt
eben in der vorletzten Lügungsaufgabe mit drin war,
wo man dann also im Prinzip dieses Fehlersyndrom ermittelt
Und wenn das eben da ist, das dann eben gegebenenfalls,
also hier noch gezielt die Bits wieder invertiert werden,
um dann eben zu berechtigen zu kommen.
Gut, und das, wie gesagt,
werde ich jetzt nochmal
ganz kurz zeigen
Gut, also angenommen, ich habe jetzt also hier mal einen Eingang,
vier Bit, übertrage jetzt also hier als Datenwort,
1.001, taucht am Aufgang hier entsprechend auf.
Hier ist also mit diesen zusätzlichen drei Prüfbits und was man
jetzt eben machen kann, ist,
wenn ich jetzt eben hier an einer Stelle entsprechend einen Fehler
im Kanal hätte,
also dieses eine Bit wird jetzt invertiert
Halte dann eben dieses hier, das dann eben an dieser Stelle,
sondern also hier quasi über diesen Korrektur und dieses Fehlersyndrom dann eben entsprechend dafür gesorgt wird,
dass eben das entsprechende Bittern, also hier wieder zurückkorrigiert wird.
Dieser 7-4-Hamming-Code oder überhaupt die Heming-Codes sind ja immer so aufgebaut,
dass sie im Prinzip einen Heming-Abstand von 3 haben, das heißt einen einzelnen Einbitt-Fehler korrigieren können.
Nicht ansonsten können sie dann eben die Fehler nur erkennen. Das heißt,
wenn ich jetzt also hier noch irgendwo einen zweiten Fehler einbaue,
Da sieht man das,
also hier ist also die Korrektur schon nicht mehr klappt und man dann also hier letztendlich beim falschen Wert landet,
nicht, aber solange ich eben wirklich nur einen einzigen Fehler hier drin habe,
gut in diesem Fall in einem der Prüfbitz, nicht,
aber ich kann das also jetzt auch hier mit irgendeinem anderen mitmachen,
wird das dann eben auch alles entsprechend richtig korrigiert.
Nur eben, wie gesagt, für den Fall,
dass jetzt mehrere Fehler auftreten.
Funktioniert das nicht mehr
Gut, also das jetzt noch mal so als zum Beispiel
für eine etwas komplexere Schadung. Anderes Beispiel,
was zumindest teilweise jetzt also auch in der aktuellen Übungsaufgabe von heute,
also dann noch mal mit drankommen wird, sieben Segmentanzeige.
Also auch das etwas,
was eigentlich ein bisschen eher so in der Historie der Computer liegt,
wie wenn man das also heutzutage, also außer vielleicht,
also irgendwo auf dem Motherboard für irgendwelche Bios-Status-Meldungen,
also auch nicht mehr
so richtig hat
Wo man sagt, ich habe jetzt im Prinzip sieben Leuchtdioden,
wie hier oben rechts angedeutet, quasi von so angeordnet,
dass man damit dann eben irgendwo seine Ziffern von 0
bis 9 und eben vielleicht also auch schon einige Hackswerte,
sofern man das so einigermaßen hinkriegt, also ein großes A,
ein kleines B, großes C,
das D kann ich dann auch wieder nur irgendwie so klein machen.
Ich habe aber so ein paar Werte oder noch ein paar andere, alphanumerische Werte kriegt man damit hin.
Bei vielen klappt das aber nicht, also deswegen,
wie gesagt, das ist also wirklich nur für irgendwie so ganz einfache Ausgaben oder irgendwelche Lieberquerte. So,
und das, was dann da dann eben typischerweise auch als Aufgabenstellung hat,
ist, also dass man sagt, okay,
ich kriege jetzt, also beispielsweise,
wenn ich jetzt also mit hexadezimalen Zahlen irgendwie ankomme,
also sprich von 0 bis 15,
dann habe ich also letztendlich,
also irgendein 4-Bit-Eingangsvektor und möchte den dann eben in die Zahlen von 0 bis 9,
beziehungsweise die Hexziffern dann eben von zusätzlich dann eben noch von
A bis F irgendwie dort codieren,
würde dann als Funktionstabelle letztendlich also
irgendwie sowas geben
Und das, was man dort dann eben auch machen müsste,
wäre dann eben irgendwie eine entsprechende Minimierung,
wo man dann eben sagt,
okay, wie kriege ich hier das jetzt so hin,
dass ich also jetzt hier nicht nur eine Funktion,
also beispielsweise für dieses Segment A hier oben,
sondern also auch noch für alle anderen Segmente möglichst minimal hinkriege.
Ich finde das jetzt also wirklich komplett ausdekodiert wird,
also von 0 bis F wäre das diese Tabelle,
wenn ich jetzt also im Prinzip nur eine Ziffernanzeige mache,
dann würde man also quasi für die Fälle ab
Zehn oder A bis F dann eben entsprechend also mit Don't Cars in der Funktionstabelle arbeiten.
Gut, wie gesagt, also auch da kann man jetzt eine Minimierung versuchen. Wird natürlich,
sagen wir mal, für so eine vollständige Lösung mit sieben KV-Diagrammen,
also gelinde gesagt, mehr als unübersichtlich,
weil die Grundidee bei so einer Bündelminimierung ist,
dass ich sage,
ich habe jetzt also irgendeine Schleife in meinem KV-Diagramm und versuche dann eben zu gucken,
dass ich die nicht nur in dem habe,
sondern in dem auch noch und in dem auch noch.
Und dadurch hat man dann quasi Teiltherme,
die mehrfach benutzt werden. Das ist ja die Grundidee bei
der Bündelminimierung
Gut, wie gesagt, also ein ganz kleines Beispiel, Folk dazu als Übungsaufgabe.
Ansonsten findet man also in der Literatur irgendwelche Beispiele,
die dann also mehr oder minder wenig intuitiv sind,
wo man auch nur sagen kann, möchte man dann nicht zwingend machen.
Also hier dann eben auch nochmal so ein Beispiel für so eine Schaltung,
besonders sieben Segmentico, da ist dann also hier dann auch so als hardes Demo,
also jetzt einfach erstmal in zweistufig irgendwo raus kodiert,
wo ich dann im Prinzip dann also hier mit meinen Werten letztendlich die Ziffern von 0 bis 9 ausgeben kann,
was bei dieser Lösung dann aber eben auch schon gemacht wurde,
ist, ist, dass sich dann eben keine vollständige Hexerdezimalanzeige habe, sondern wirklich nur von 0 bis 9.
Hier hinten relativ viele Don't Cars. Deswegen kriegt man es überhaupt mit diesen und und oder Gattern überhaupt nur einigermaßen hin,
führt dann aber eben dazu, dass,
wenn ich das Ganze dann eben auch in der Schaltung simuliere,
Nicht, dass ich sagen kann, okay,
ich habe jetzt hier eins, zwei,
drei und so weiter, also dann bis hier quasi acht,
neun, so und wenn jetzt eben irgendwas nehme,
was dann also quasi von A bis F folgt,
kommt da jetzt eben irgendwie was anderes bei raus,
wo man sagen muss, na gut,
das ist dann mehr oder minder zufällig und erratisch,
weil das dann eben einfach aufgrund dieser Eigenschaften und Care entweder mal so oder mal so ausdekodiert wird.
Gut, also auch das kann man dann nochmal aus einem
auch fertiges Beispiel so einer integrierten Schaltung aus dieser 74er-Serie dann
irgendwo nehmen und simulieren, damit irgendwie was machen.
Also auch da ist es dann eben so,
Anzeige von 0 bis 9 ist dort also in dieser Schaltung definiert gewesen.
Alles andere ist dann eben letztendlich auch nur irgendwie über
die Minimierung,
sind Zufallsmuster
Gut, hier folgen dann auch noch so andere Beispiele,
wo du dann jetzt quasi so eine Sieben-Segment-Anzeige dann eben auch noch missbrauchen kann,
um jetzt nur irgendwelche anderen Buchstaben darzustellen.
Hier jetzt einfach mal irgendwie fest kodiert, was man damit
dann also irgendwie alles schreiben kann oder auch nicht schreiben kann.
Ja, gut, aber wie gesagt,
das ist also nicht so spannend,
ein in Anführungszeichen minimales Beispiel für so eine Sieben-Segment-Anzeige ist dieses hier,
was also aus dem Prinzip,
also aus dem Buch von Donald Knut
Wo man sieht, das ist also vergleichsweise mehr stufige Sache.
Also dieses sind jetzt, also die Segmente von A bis G.
Und beispielsweise kann man sagen,
also F beziehungsweise invertiert F wäre dann X8 nicht und X17,
nicht und X17, wäre X5 oder X6.
Und das heißt also im Prinzip,
aus diesen vier Eingangsvariablen werden dann immer irgendwie so mehrere Teiltherme gebildet,
die dann also häufig in irgendwelchen anderen Beispielen dann wiederverwendet werden.
Also wie gesagt,
also sowas zu machen,
so eine Bündelminimierung
Möchte man im Zweifelsfall nicht selber machen, sondern überlässt man dann eigentlich sinnigerweise irgendwelchen Computerprogrammen, die das machen nicht.
Also deswegen brauchen wir es damit jetzt also nicht weiter rumschlagen. Gut,
dann kommen wir jetzt aber nochmal zu den hartes Beispielen,
beziehungsweise zu den Schaltungsbeispielen, die dann eigentlich vor uns nochmal so ein bisschen relevanter sind,
wo es jetzt also nicht um irgendwelche, ja,
nicht mehr so ganz aktuellen sieben Segmentanzeigen oder irgendwelche Würfel geht,
sondern wo es darum geht,
also wie werden wir jetzt letztendlich im Computer irgendwelche Alu-Operationen realisiert,
dazu Folgen hier jetzt nochmal so ein paar Beispiele,
wo es darum geht, also im Prinzip verschiedene Adira.
Kurz zu beleuchten,
wie die im Prinzip funktionieren und dann eben für andere aratmetische Operationen,
Multiplikation, Quadratwurzel, also nur zu zeigen,
dass es da also auch Hardware-Lösungen gibt,
beziehungsweise dann eben nochmal so als abschließendes Beispiel,
so eine Grundideenverständnis dafür,
wie also dann eben wirklich so aus einzelnen Gattern dann also
auch komplette Recheneinheiten in so einer Alu dann aufgebaut werden können
Gut, Adira, also die Funktion oder Funktionalität geht ja letztendlich jetzt auf das zurück,
was also irgendwie im Kapitel 6, also unter dem Stichwort Arathmetik irgendwann mal aufgetaucht ist.
Wie wird das Ganze dann eben technisch realisiert? Das ist jetzt eben das, wo es also hier rumgeht. Halbaddira,
kann man jetzt eben erst mal sagen, das einfachste Schaltung berechnet,
also in der einen Bettsumme aus zwei Eingängen A und B. Und gut,
eben Dualsystem kann ich damit also quasi,
wenn ich zwei Eingänge habe, eben maximal zwei haben,
wenn ich das zusammen addiere,
demzufolge brauche ich dann eben nicht nur einen Ausgang für die Summe,
sondern ich habe dann eben auch noch einen Ausgang für einen Carry,
also einen Übertrag in die nächste spalte.
Nicht demzufolge gibt es da dann immer Summenausgang,
Carry-Ausgang und Carry wäre eben A und B-Summe wäre A exklusiv oder B. Nicht,
das ist dann also halb Adira,
warum heißt es jetzt halb Adira,
weil es ja natürlich auch noch einen Voll Adira gibt.
Und zwar hat voll addiere jetzt nicht zwei, sondern drei.
Ein Bit werte. Der dritte Einbitt wert wäre nämlich
ein Carry, der quasi jetzt in den Volladdierer reinläuft.
Also quasi dann zusätzlich als dritter Eingang hinzukommt. Das ist
dann eben dieses CI steht dann eben für Carry in.
Und auch der kann dann eben als Ausgang maximal den Wert drei erzeugen,
kodiert eben durch ein Summen-Bit und ein Carry-out.
Von der Funktion her kann man das dann eben hier einfach jetzt direkt ablesen.
Carry-out wäre, eben wenn mindestens zwei Betts gesetzt sind,
das heißt A und B oder A und Carrie in oder B und Carrie in.
Häufig wird dann eben quasi das immer noch in so einer Schreibweise notiert,
wo dann also quasi nach Destributiv gesetzt, dass Carrie in Asi immer ausgezogen wird.
Da habe ich A und B oder A oder B und Carrie in.
Und Summe eben exklusiv oder der drei Bits. Gut,
auch das hier dann nochmal zum Ansehen oder Nachspielenden, also letztendlich so in Gutterfunktion oder Gutterfunktionalität. So,
wenn ich jetzt also diese Einfach-Bausteine habe, halb addia,
voll addia, dann kann ich im Prinzip ein N-Bit-Adia dadurch aufbauen,
dass ich sage, okay, also für jede Stufe gilt,
beim niederwärtigsten Bit, da habe ich erstmal keinen Carry-In,
also rechne ich Arnul, exklusiv oder B-0 und erzeuge dann eben ein Carry,
der sich dort dann aus A und B ergibt.
In der nächsten Stufe kann ich dann eben abhängig von diesem
Carry-In und den jeweiligen Bits dann eben wieder mein Soom-Bit und
ein Carry-Out erzeugen und so weiter und so fort.
Und was an ihr dann schon sieht, ist, dass eben letztendlich generell gilt,
Summe ist dann eben exklusiv oder über die drei Bits.
Also im Prinzip die Volladdiara-Funktionalität, Übertrag dann eben auch entsprechend hier
nur in der niedrigsten Stufe brauche ich dann eben genau diesen Halber dir.
Gut, wenn ich jetzt ein Adira für Enbit haben möchte,
kann ich also im Prinzip natürlich,
also dieses oder diese Formel nehmen und den einfach direkt runterschreiben oder runterkodieren oder ein Haares eingeben, wie auch immer.
Was dort allerdings der Nachteil ist, was man hier schon sieht,
ist, dass letztendlich dieser Übertrag sich sukzessive,
also irgendwie war das letztendlich dann immer rekursiv definiert ist,
dass also quasi der Ausgangs-Carry einer Stufe dann eben sich berechnet aus A und B,
der jeweiligen Wert und dem Eingangs-Carry,
dass der dann also quasi jetzt über die einzelnen Teile irgendwo so durchläuft.
So, wenn ich das Ganze aufdrösel,
weil ich kann jetzt natürlich für die jeweiligen Carries dann also auch entsprechend einfach jetzt diese Formel nehmen,
dass dort also einsetzen,
sieht man das also im Prinzip so eine einfache Lösung,
also sprich und oder Logik nicht funktioniert,
weil im Prinzip abhängig von der Anzahl der Bits,
dem N, steigt dann dementsprechender Aufwand exponentiell an.
Das heißt, also man kann so eine einfache zweistufige Lösung, dort eben nicht machen.
Wie gesagt, Grund dafür ist diese rekusive Definition des Carry. Deswegen,
das, was man dort dann eben typischerweise macht,
das, was jetzt hier nur oben stehen,
was gleich auf der nächsten Folie vorstellen werde,
hat man eben sogenannte Ripple-Carry-Adira,
die im Prinzip genau das,
was eigentlich hier in diesen Formeln steht,
eins zu eins aus Halbaddira und Volladdira
direkt umsetzen
Dort werden im Prinzip dann eben einfach diese Volladdia genommen,
immer hintereinander geschaltet. Man hat dann eine sehr einfache Struktur,
die quasi auch minimal groß ist,
die aber den Nachteil hat, dadurch,
dass der Carrie dann ja eben quasi regulsiv definiert ist,
der sich eben im schlimmsten Fall dann also wirklich vom niederwärtigsten Bild bis Zum Ausgang in B-32 quasi jetzt irgendwie durcharbeiten kann.
Dass es letztendlich genau das, was passieren würde,
wenn ich jetzt also im Prinzip so eine Addition hier irgendwie an der Tafel rechne und ich sage,
okay, ich habe hier unten irgendwo einen Übertrag und dieser Übertrag
geht dann eben durch jede Stufe der Reihe nach durch.
Also genau das ist eben das, was technisch gesehen dann eben auch dieses Carrybit macht.
Führ dann eben dazu, dass also solche Ripple-Carry-Adira eben vergleichsweise langsam sind,
in dem Fall wächst die Laufzeit linear mit der Komplexität.
Deswegen sagt man immer, oh von Anne,
dass sie da eben diese lineare Abhängigkeit habe.
Jetzt im Folgenden würde ich gleich dann noch zwei andere Adira-Typen vorstellen.
Cary Look Ahead, das ist dann eine ganz andere Idee. Da wird das Ganze dann,
diese Cary-Berechnung dann quasi in so einem Baum ausgelagert,
ist vergleichsweise schnell, hat aber eben den Nachteil,
dass also quasi dann der Aufwand dann eben nicht nur aus irgendwie zwei exklusiv oder einem zwei und,
und zwar oder Gattern pro Stufe besteht.
Das, was nämlich letztendlich in einem Volladdia drin ist,
sondern der dann eben deutlich aufwendiger wird. Das heißt also,
der Hardware-Aufwand rein praktisch dann eben der Flächenbedarf für so eine Schadung wird eben entsprechend größer. Gut,
daneben gibt es dann noch diverse andere Formen,
also ein, werde ich dann also hier,
so Carys Select werde ich also hier auch noch kurz vorstellen,
wenn man in die Literatur guckt, kann man sagen,
es gibt also ungefähr so 10, 15 verschiedene Adiratymen,
wie man das Ganze dann letztendlich technisch realisieren kann.
Gut, ich hatte ja schon gesagt, Ribble Carry Adira
ist im Prinzip nichts anderes als so eine Kaskade einzelner Volladdierer.
Nicht, wo man dann eben sagte, Ausgangskarry einer Stufe
dient dann in der nächsten Stufe dann als Eingangskarry.
Und ist letztendlich dann relativ straight forward aufgebaut.
Nachteil bei dem Ganzen ist,
weswegen man Dame dann eben nicht ganz so glücklich ist und
weswegen es dann vielleicht überhaupt in diese ganzen anderen Typen gibt
Der Adira ist also in Prozessoren oder generell, sagen wir mal,
so in vielen Schaltungen, also häufig der Teil, der,
also in der Alu irgendwo mit drin ist, wo relativ viel gerechnet gemacht wird,
der dann aber letztendlich die Gesamttaktfrequenz der Schaltung eben entscheidend beeinflusst.
Also da spricht man immer von dem sogenannten kritischen Pfad. Also man kann sich immer vorstellen,
das, was ich letztendlich immer habe, ist,
dass ich zum Beispiel sage,
wenn ich jetzt also hier sowas wie nah Alu habe,
beziehungsweise also hier eben irgendwie so ein Adierschalennetz,
wenn ich und ich habe, also hier jetzt irgendwie mein,
was weiß ich jetzt, 32 Bit,
eingangs Vektor, soll hier also zwei Zahlen addieren.
Nicht, dass man sagen kann, okay,
also wodurch wird die Taktfrequenz der Schaltung entscheidend beeinflusst?
Man geht davon aus, also der Eingang hier kommt jetzt aus irgendeinem Speicherelement.
In der Regel ist das jetzt also hier nicht der Hauptspeicher,
sondern irgendwelche Register, die schon in der CPU
drin liegen
Und das Ergebnis muss natürlich auch irgendwo gespeichert werden. Das will ich jetzt auch
nicht über irgendwelche Datenbusse in Speicher irgendwo auf Motherboard machen,
sondern es wird auch erstmal nur in der CPU gespeichert.
Das heißt, es landet rein funktional gesehen dann eben auch in einem Register.
So, und das, was dann typischerweise hat,
ist dann quasi ein Synchronerentwurf, wo ich sagen kann,
ich habe hier also eine Clock, Verzögerung,
also das,
was dann eben letztendlich
die Taktfrequenz ist
Die tut was. Hier drin landen Werte für meine Operanten A und B.
Das Ganze geht dann also hier in dieses Charlotte-Netz,
in diesem Schaltennetz habe ich jetzt in den Gartern eben
irgendwelche Verzögerungen, weil eben so ein Nandgatter oder Norgatter eben nicht unendlich schnell ist.
Und wenn ich jetzt eben sage, okay,
ich habe jetzt wirklich sowas wie ein Volladdierer und davon jetzt noch 32 Stück hintereinander,
wo dann also die Charis da irgendwie durchgehen,
dann kostet das Zeit.
So, das heißt, irgendwann habe ich hier
meine Eingänge A und
Wenn ich das jetzt also mal in so ein Impulsdiagramm irgendwie umsetze,
kann man also sagen,
ich habe hier für A und für B irgendwie sowas,
wo also jetzt hier quasi mit dem Takt also irgendwie die Werte sich ändern.
Die bleiben dort jetzt also quasi erstmal konstant in diesen Registern drin.
Das, was dann also hier quasi an Rechnung passiert, dauert eine bestimmte Zeit.
Das heißt, irgendwann Es geht mir der Platz aus.
Irgendwann nach einer bestimmten Zeit wird sich hier am Ausgang der Wert ändern.
Und ich erhalte eben hier quasi jetzt das richtige Ergebnis. Also A plus B. So,
und das, was quasi dann die Taktfrequenz ist,
ist, dass sich dann eben erst,
wenn ich hier das richtige Ergebnis habe,
also quasi die Zeit in der Wahl von hier,
Bis hier, dann darf quasi der nächste Tag kommen,
sodass das Ergebnis dann eben auch hier in einem Register gespeichert wird und
ich dann eben beispielsweise die nächste Addition mache und dann dürfen sich eben auch wieder die Eingangswerte A und B ändern.
So, und diese Zeit, diese Verzögerung,
das bestimmt dann eben letztendlich die Taktfrequenz in den Prozessoren und das ist eben das,
was man dann also quasi als kritischen Pfad bezeichnen würde. So,
und wenn man sich jetzt eben anguckt,
wie sich also die ganzen Prozessorhersteller also letztendlich überbieten,
wo man jetzt sagt,
also ich möchte ja sich hier noch irgendwie ein paar hundert Megahertz da noch schneller und da noch schneller,
dann kann man sagen, okay,
das ist eben wirklich genau das Entscheidende,
wo man sagen kann,
also hua,
damit kann ich mich also von der Konkurrenz abheben und
das ist dann das entscheidende Verkaufsargument
Also das ist das, was dann eben dort letztendlich diese kritische Fahrt ist. Gut,
Ribble Carry, muss man jetzt eben sagen,
bis zehn Bits kann man damit noch irgendwie vernünftig arbeiten,
bei größeren Wortbreiten, was ja nun heute eigentlich typischerweise haben,
wo man jetzt sagt, also 32 Bit,
64 wird Wortbreite,
es ist so alles kein Thema.
Da würde man dann eben kein Ribble Carry letztendlich mehr einsetzen
Ach so, hier unten auch nur kurz,
Kommentar oder Anmerkung, ansonsten, wie gesagt,
nochmal der Verweis zurück, also auf das Kapitel Sarin Medik,
Überlauferkennung kann man dann eben im Prinzip auch über den Carry machen,
indem ich dann eben letztendlich gucke,
wie sie das Eingangscare in einer Stufe aus und wie sieht das Ausgangscarry aus und wenn sich das geändert hat,
dann habe ich da im Prinzip dann so einen Wechsel,
was dann also ein Überlauf wäre.
Gut, damit kann man dann eben im Prinzip,
also hier jetzt nochmal so ein Rippe Carry Adira,
also hier voll Adira mit drei Eingängen,
den beiden Ausgängen, dem Carry-Ausgang,
der dann quasi als Carry-In in die nächste Stufe geht und dementsprechenden Summenausgang nicht.
Und wer also hier für vier Bits, sind die dann also hier hintereinander geschaltet.
Und dann kann man das Ganze dann eben hier also auch
in Hades simulieren. Wie gesagt, das ist ein Beispiel,
also aus so einem anderen Buch, Chef na Schmitz,
beziehungsweise die haben sich dann quasi da jetzt an Norman gewandt,
also ob sie das benutzen können, findet sich
Bei den Beispielen, das ist dann also auch einer der Gründe,
weswegen das jetzt nicht, also ganz öffentlich im Netz sein sollte,
hier unter TI Online. Was also jetzt hier diese Schaltung ist,
nicht, und dann sich hier dann nochmal visualisiert,
dann quasi die entsprechenden Eingangswerte, hier der Ausgangswert nicht,
wo ich dann eben sagen kann, okay,
also ich rechne hier eins plus eins, das Ergebnis ist zwei,
eins plus drei, vier und so weiter und so fort,
nicht wo man da jetzt eben hier seine Funktionalität so einer einfachen Addition hat.
Und wie man dann eben hier immer sieht,
dieser Carrie, daher dann eben der Name,
geht dann ihm hier immer jeweils von einer Stufe zur nächsten.
So zur Veranschaulichung dieses Effekts,
wie das dann eben letztendlich bei mehr Stufen geht,
gibt es hier dann also auch noch,
ich weiß gar nicht,
wo ist denn jetzt hier das Beispiel Arisma Take Ethers
Dieses Beispiel Ripple, wo man jetzt eben hier sieht,
also hier sind jetzt also auch nochmal so ein Ripple-Carry-Adira jetzt für 8-Bit.
Hier jetzt also in dem Simulationsmodell,
also das sind jetzt immer jeweils Voll-Adira, AB, Carry
In, Summe und Carry Out. Ich hatte ja gesagt,
also die Elemente hier in Hardes können dann eben sowas wie Properties haben,
also Eigenschaften, gut,
also hier sieht man wieder Voll-Adira dann intern aufgebaut ist,
das war also im Prinzip dann die Schaltung aus den
einzelnen Gattern
Und was dort dann eben noch dahinter steht, ist,
dass die dann eben entsprechende vergleichsweise hohe Verzögerung haben und was man jetzt eben hier sieht,
ist, dass wenn ich das Ganze jetzt also hier eben so beschalte,
dass ich also quasi jetzt hier den Effekt hatte,
also dass ich hier also für A und B eben die Zahlen habe,
das immer jeweils im Bitt gesetzt ist und dann eben sowas,
wohnt Carrie in sich dann, also wirklich der Reihe nach als Übertrag dann,
also hier durchfortpflanzen würde, ich sieht man,
dass ich hier nochmal so in der Visualisierung,
was dann eben dieser Effekt ist mit dem Ripple,
wo sich das dann eben der Reihe nach da also irgendwie dann durch die einzelnen Stufen durcharbeitet.
Gut, und wie gesagt, das ist also dann der Grund dafür,
weswegen man das Ganze dann eben so rein praktisch dann
eben in solchen kritischen Fahnen nicht benutzt oder nicht benutzen sollte.
Gut, Addition, wie sieht das bei der Subtraktion aus? Gut,
auch da hatten wir also im Prinzip dann schon die entsprechende Logik oder die Schaltnetz da sind im Kapitel,
ist auch in Metikorz gehabt, wo man ja sagt,
okay, wenn ich jetzt eine Sozialdarstellung Zweierkompliment habe,
kann ich eben Die Subtraktionen ersetzen durch die Addition des entsprechenden der entsprechenden Zahl im Zweier-Kompliment.
Und die einfachste Bildung oder einfachste Art und Weise,
um das Zweier-Kompliment zu bilden, war ja also erstmal einer Kompliment erzeugen.
Das heißt also, alle Bits invertieren und plus eins einen drauf addieren. So,
und das ist jetzt eben eigentlich das,
was also hier der Trick ist, um das Ganze in Hardwares,
also entsprechend einfach zu machen, weil dieses einen drauf addieren,
kann ich eben einfach dadurch machen, dass ich sage,
okay, ich habe jetzt an der niederwärtigsten Positionen, kein Halbadira,
sondern spendiere da auch ein voller Adira und habe noch einen Carry in und dann kann ich dort eben noch ein zusätzliches Plus 1 rechnen.
Das heißt, ich muss jetzt nicht für eine Subtraktion eine Zahl erst umständlich ins Zweierkompliment umrechnen,
mit irgendeinem Schaltnetz und anschließend zu sagen, jetzt gehe ich in den Adira,
sondern ich muss jetzt einfach nur dafür sorgen,
dass ich quasi von B das einer Kompliment erzeuge,
alle Bits invertieren, mache ich in Hardware,
mit dem Exklusiv-Odergatter und muss dann eben noch plus eins,
das ist das Carry-In quasi in der niederwärtigsten Stelle.
Nicht damit kann man dann eben entsprechend, wie das hier unten an also angedeutet ist,
direkt mit einem und einer Schadung, also sowohl Adien als auch Subtrahieren.
Also auch hier dann das entsprechende Beispiel, also aus dem Schiffmann Schmitz,
beziehungsweise was man hier auch sieht, ist,
dass man damit dann also nicht nur addieren und subtrahieren kann,
sondern dadurch, dass sie quasi diese Komplimentbildung,
also das sind, also dort in der Terminologie jetzt,
also hier die Exklusiv-Oder-Gata,
dass es hier diese Komplimentbildung und das Carry-In quasi unabhängig voneinander sind und dadurch kann man dann eben auch noch,
indem ich B gleich null lasse, über entsprechende Kombinationen inkrementieren,
beziehungsweise Dekrement von der Zahl A machen.
Das heißt, man kann also hier über diese vier Kombinationen,
also Addition, Subtraktionen, Inkrement und Dekrement dann eben machen.
Das Gleiche, das Ganze dann eben mit
Vergleichsweise einfacher Hardware
Beziehungsweise die ist dann eben bis auf diese Exklusiv-Oder-Gattern eben jetzt
letztendlich nicht komplizierter als ein einzelner oder normaler Adira.
Gut, jetzt hatte ich ja gesagt,
also mit den kritischen Fahrten möchte man nicht haben,
also wie kriegt man jetzt also irgendwelche anderen Methoden hin,
also schnelle Adira jetzt, also hier als Stichwort.
Hierzu jetzt, also eben als erstes Beispiel in Carys
Select Adira
Anschließend nochmal ganz grob, die Idee sind das Carry Look erhetzt.
Und ansonsten, wie ich schon gesagt hatte,
es gibt also deutlich mehr Typen, mit denen man dann,
also im Prinzip so eine schnelle Addition in Hardware dann eben umsetzen kann.
So Carry Select ist im Prinzip,
oder dahinter steht folgende Idee, dass ich sage, das,
was beim Ribble Carry passt, ja passiert, ist,
dass ich in den höheren Stufen einfach auf die Scary immer warten muss.
Und das, was man letztendlich machen kann, ist,
dass man sagt, okay,
ich rechne quasi jetzt in den höheren Stufen Ähm...
Einfach zwei Ergebnisse aus. Und zwar einmal eins mit Carrie und Arme
eins ohne Carrie. Und hab dann nur einen Multiplexer,
mit dem ich dann eben sage, welches von den Ergebnissen richtig ist.
Und das mache ich jetzt aber nicht für ein einzelne Spits,
sondern das mache ich immer für Gruppen von Bits.
Das ist also das, was also letztendlich da von der
Grundidee dahinter steht. Ähm, und, ähm,
das, was man dann letztendlich hat, ist,
dass man sagt, okay,
wann kann ich jetzt entscheiden für so
eine Gruppe
Welches Ergebnis das Richtige ist. Okay,
wenn ich das eingangs Carry von den vorheugenden Teilen dann irgendwie schon ermittelt habe,
das heißt, okay,
man hat natürlich irgendwelche Laufzeiten für das Carry,
aber ich kann dann, wenn ich das Carry jetzt in einer bestimmten,
meinetwegen jetzt bei 32 Bild,
wenn ich jetzt also für die oberen 16 Bit,
schon das Ergebnis ausgerechnet habe,
mit dem Eingangs Carry und ohne Eingangs Carry quasi nach einer Kerreverzögerung von 8 schon sagen,
wie der Rest des Ergebnisses aussieht.
Dass das letztendlich da die Grundidee, das heißt,
da kann man eben sagen,
die Verzögerung reduziert sich dann eben auf die Verzögerung,
MBit Adiras und die Verzögerung durch die Multiplexe.
So, hier ist dann so ein ganzes Beispiel dafür. Und zwar acht Bit,
Adira, der ist jetzt hier unterteilt in eine Vier-Bit-Gruppe,
eine Drei-Bit-Gruppe und in ihm einfachen, ein Bett Adira.
Das heißt also, hier habe ich jetzt eben einmal diese Verzögerung,
unabhängig von dem Ergebnis,
würde jetzt hier bei dieser Drei-Bit-Gruppe quasi Eine Addition mit Eingangs Carry 0 berechnet werden,
Addition mit Eingangs Carry 1. Diese Gruppe selber funktioniert als Ripple-Carry-Adierer.
Das heißt, okay, das dauert natürlich etwas.
Auf der anderen Seite brauche ich natürlich die Zeit,
bis ich hier das Ergebnis habe.
Und bis das also hier die Multiplexer umgeschaltet hat.
Das heißt, im Idealfall habe ich,
wenn sich dieses Ergebnis hier durchgerippelt hat, die Multiplexer geschaltet
Den Eingangs-Carry vorher natürlich passend berechnet gehabt und habe dann also
quasi hier die richtigen Ergebnisse und wähle dann natürlich also von der Gruppe dann eben quasi jetzt den Ausgangs-Carry,
der mir das jetzt also für die nächste nochmal wieder größere Gruppe macht.
Und damit kann man dann eben solche ganzen Kaskaden aufbauen,
die dann eben letztendlich deutlich schneller sind,
nicht weil hier kann ich also jetzt grob erstmal sagen,
na gut, ich habe hier einmal Carry Verzögerung,
ich habe hier dann also irgendwie so eine Verzögerung und dann
habe ich hier also über die Vierbit eine Verzögerung,
aber im Großen und Ganzen habe ich dann also irgendwie so eine Gesamtverzögerung von vier und nicht von acht,
was man hiermit erreicht hat.
So je nachdem, wie man das jetzt also entsprechend aufteilt,
kriegt man das dann ganz gut hin.
Ein Nachteil bei dem ganzen Schema ist natürlich, dadurch,
dass sich also hier quasi fast die gesamte oder fast die Hälfte der Hardware also doppelt ausgelegt habe, zusätzliche Multiplexe,
also das Ding ist also schon mal doppelt so groß wie eine Rippelkerre Adira von der Fläche oder vom Aufwand.
Nichtsdestotrotz wird ganz gerne genommen, prominentes Beispiel ist der Arm-Mikroprozessor,
weil genau dort Ist sowas zum Beispiel mit drin? Also wo jetzt,
also hier im Prinzip sind es 32 Bit-Adierer dann eben auch über so eine Stufe aufgebaut lassen,
wo man sagt,
also hier habe ich im Prinzip die unteren Vierbit,
nicht dann habe ich hier schon so einen Carrie-Selec dann für die nächsten Vierbit,
dann hier für acht Betten,
Carrie-Selec und dann eben für die oberen 16 Bit dann eben nochmal entsprechenden Carrie-Selec,
wo man das dann eben über solche mehrstufige Logik
dann dementsprechend aufbauen kann
So eine andere Idee, was dann also noch schneller ist,
allerdings dann also vom Hardwareaufwand auch nochmal aufwendiger,
wäre dann der sogenannte Carry Look Ahead Adira.
Und zwar geht man da davon aus, dass man sagt, okay, wie wird der Carry gebildet?
Also die Funktion war ja in dieser rekursiven Formel A und B oder A oder B und Eingangs-Carry. Und hiermit,
wen jetzt, also letztendlich zwei Talfunktionen rausgezogen,
nämlich G und P für Generate und für Propergate,
von der Idee oder von der Funktionalität her,
kann man sagen, also Generate heißt, wenn beide Eingangswerte,
A und B, eine Eins sind,
dann muss ich nicht auf den Eingangs-Carry warten,
bin Carry in,
weil ich weiß,
es wird
eine Ausgangskarre erzeugt
Nicht der Carrie-In entscheidet da nur noch,
also ob das Summen mitgesetzt wird oder nicht,
aber es wird in jedem Fall ein Ausgangskerl gesetzt.
Daher der Name Generate war damit, also mit diesem Therm
A und B, erzeuge ich dann eben schon einen Ausgangskerry.
Und dann gibt es dann eben noch dieses Propergate,
wenn ich einen Eingangskerry habe, damit der zu einem Ausgangskerry wird,
muss entweder A oder B1 sein,
wenn beide Null sind,
kann ich gar
keinen Ausgangskerry erzeugen
Und deswegen eben diese beiden Funktionen, Generate und Propergate und die Funktion für den Ausgangscary
wäre dann eben G von N oder P von N und eingangs Carry.
So, und das, was man dann macht, ist,
dass man mit diesen Funktionen dann eben letztendlich in gesamten Baum aufbaut,
wo dann eben die Funktionalität immer so gemacht wird,
dass das quasi jetzt von zwei benachbarten Stufen über die Diese Funktion Generate und Papagate eben entschieden wird,
wird ein Eingangscary weitergeleitet, ja oder nein.
Wenn ich jetzt entsprechend N-Bits habe, muss ich natürlich entsprechend,
da ich jetzt immer nur zwei Stufen zusammenfasse,
die Tiefe des Baums machen.
Was man damit dann aber eben letztendlich hat, ist,
dass die Tiefe in dem Baum dann eben Logatmostuales von N ist.
Das ist dann eben auch die maximale Anzahl,
die ich letztendlich an Lorigat dann in der Verzögerung drin haben kann,
die mir dann eben also auch die Geschwindigkeit in so einem
kritischen Pfad beeinflusst
Gut, ein Bit-Adierer, hier jetzt also quasi realisiert mit A,
B und Eingangs-Curry und der generiert mir jetzt eben quasi das Zoom-Bit und
dann eben jetzt diese beiden Funktionen, Generate und Propergate.
Es gibt dann eben keinen Ausgangskarim mehr und dann gibt es aber eben noch eine Schaltung,
mit der man dann eben im Prinzip für dieses Curry Locker End machen kann,
wo ich dann eben sage,
wenn ich jetzt also hier einen Eingangs-Curry habe und von zwei benachbarten Stufen
Hier, Propergate, Generate, beziehungsweise dann eben eine Stufe weiter,
Propergate und Generate habe. Wie sieht das in der nächsten
Stufe des Baumes aus und wie sieht das resultierende Carry aus und das,
was ich hier quasi als Angangscarry habe, wird dann auch noch weitergeleitet. So,
und daraus kann man dann im Prinzip so einen gesamten Baum aufbauen,
das wäre jetzt,
also hier im Prinzip so ein Carry Look,
er hätte Adira für 16 Bit,
der dann also hier intern dann immer aus diesem diesen Funktionen aufgebaut ist und
dann für die eigentliche Addition dann eben hier für die einzelnen Bits A und B dann eben nochmal diese Teile hat,
die dann eben die ursprünglichen Generate und Parpagate,
die jeweiligen Stufe also hier erzeugen, nicht.
Und dann geht das dann also hier eben über diese Baumstruktur
dann quasi hier runter und mit der Verknüpfung von dem Carry in wird das dann eben hier wieder entsprechend zurückberechnet. Und das Ganze,
wie gesagt,
kann man dann eben auch als Hades-Schaltung Dann eben hier also auch irgendwie simulieren,
wo ich dann eben sage, okay, ich habe jetzt,
dass ich hier irgendwo meinen Eingangsvektor,
also jetzt um irgendwelche Kombinationen von A und B und kann man dann eben daraus jetzt,
dass ich hier meinen Ausgangswert berechnen,
in dem Fall wollte ich jetzt hier mal was durchgeschaltet und gut,
da sieht man dann eben,
wie er so hier die Carry-Berechnung
dann eben hier nachher in diesem Baum verlagert wird
Gut, das jetzt also auch nur relativ schnell,
also einfach jetzt nur mal um diese Grundidee zu veranschaulichen,
wie dann eben so eine schnelle Addition mit so einem Carry Luca Head Addira letztendlich funktionieren würde. Gut,
was dann dann teilweise noch macht oder machen kann,
also zum Beispiel mit solchen Addirern,
dass ich also auch noch zum Beispiel solche Bäume wie hier aufbaue,
um also was wie ein Bitcount zu realisieren,
wo ich jetzt quasi jetzt ein Volladdirer hier jetzt,
also brauche, um jetzt quasi einfach aus drei Eingängen zu erzählen,
wie viele Bits das sind und das dann eben auch über solche Baumstrukturen von dann entsprechend größeren Schaltungen wieder zusammensetze.
Also da kann man da dann eben auch entsprechend jetzt unterschiedliche Sachen machen.
Gut, zusammenfassend, sorry, eine Frage.
Sorry, es ist aquastisch nicht ganz angekommen
Also die Frage war jetzt, also in so einem Prozessor,
also wie das dort, also wirklich mit den Addierern aussieht,
welcher Varianten dort eingesetzt werden,
also nur einfache oder Mischvarianten, war das richtig?
Gut, Beispiel hatte ich ja also schon kurz gezeigt,
also im Prinzip, also bei Armprozessoren,
also mal als so ein typisches Beispiel für ein einfache Mikrocontroller,
da einfach ein Mikroprozessor,
Architektur,
da hat man also im Prinzip dann hier sowas
wie so ein Carrie Select Adira
Jetzt also hier so für 32 Bit.
Nun muss man sagen, okay, also ein AMV 6,
also der ist irgendwie so aus dem Jahre 2000 irgendwas.
Da ist also auch nicht mehr so ganz das aktuellste und die andere Sache ist,
das ist natürlich was, was typischerweise im eingebetteten System läuft,
wo man sagen kann,
naja gut,
in meinem Smartphone sah das jetzt ein Exinus irgendwas oder irgendwie ein anderer High-End-Qualkon-Prozessor,
kriege ich das Ding also vielleicht
noch bis 2,4 Gigahertz hochgezwirbelt
Ich denke mir, also da kommt man also vielleicht mit sowas dann also noch einigermaßen hin,
wobei man da dann teilweise auch noch andere Sachen macht. Bei dem,
was also sagen wir mal so im High-End-Computing drin ist,
beziehungsweise dann eben bis zu irgendwie dem,
was also sagen wir mal so bei schnelleren Desktop-Prozessoren eben auch schon üblich ist,
da würde man sowas dann teilweise nicht mehr einsetzen,
beziehungsweise da kommt dann eigentlich noch ein anderer Effekt hinzu.
Also hier Bei dem, was sie jetzt hier auch vorgestellt habe,
sieht das mit dem kritischen Pfad so aus.
Ich habe jetzt hier meinen Adira, sei das jetzt ein Carry Select,
sei das ein Ribble Carry oder ein Carry Look Ahead.
Und ich habe hier meine speichernden Elemente. Das,
was heutzutage eigentlich bei den Geräten passiert, ist,
dass die hier intern quasi innen drin im Adira auch schon irgendwelche speichernden Teile mit drin haben. Das ist etwas,
was sagen wir jetzt also relativ Ich müsste jetzt überlegen,
ich glaube, Kapitel 17, dann unter dem Stichwort Pipelining auftauchen wird,
wo es dann nämlich darum geht, dass man sagt,
naja, wenn man also in die Datenblätter von den Prozessoren reinguckt oder so,
dann sieht, okay, ich habe ein Additionsbefehl,
dann wird der eben auch nicht in einem Takt abgearbeitet,
was also hiermit ja quasi letztendlich implementiert wird,
sondern der dauert mehrere Takte.
Und dadurch wird dann quasi diese Zeit,
die hier drin ist, dann eben auch nochmal feiner unterteilt.
Nichtsdestotrotz versuchen die Hersteller natürlich innen drin,
dass so schnell wie möglich zu machen,
dass man das immer noch möglich schließlich hoch takten kann.
In der Regel würde ich dann aber vermuten, dass es
also dann eher so Carillooca-Head-Strukturen sind. Aber wie gesagt,
das ist eine Sache, also da halten sich die Hersteller
also relativ stark bedeckt, beziehungsweise kriegt man nur mit.
Okay, ich habe die und die Architektur und kann da
an die Alu was reintun und das Ergebnis habe ich nach so und so vielen Takten.
Und wie das Inneren aussieht, das will man der Konkurrenz
im Zweifelsfall nicht auf die Nase binden.
Also deswegen ist man da dann immer so ein bisschen,
ja, Gut, ja, das eigentlich zu dem Thema Adira,
diese Grundvarianten, also oder grob die Idee, was,
was sich dahinter verbirgt, das sollte also irgendwie hängen geblieben sein.
Freitag werde ich dann also noch so ein bisschen mit Alus
und dem Zeitverhalten von Schaltungen abschließen und dann sind wir eigentlich
mit diesem Kapitel dann auch so weit durch, dann,
ja,
schönen Feierabend