Gut. Ja, ich hatte vorgestern ja angefangen,
jetzt also bei den Schaltnetzen, einige typische Beispiele zu beschreiben.
Generell, was es erstmal ist, wie man dort letztendlich
die Minimierung macht. Das ist also grob gesagt dann immer,
darum geht es sowas wie eine Bündelminimierung zu machen.
Das heißt, ich habe einen ganzen Satz von Schaltfunktionen,
die dann eben möglichst gemeinsam minimiert werden sollen,
sodass man dann eben versuchen kann,
dort gemeinsame Teiltherme zu finden
Bei den, sagen wir jetzt eher praxisrelevanten Beispielen,
hatte ich dann ja angefangen, gesagt,
dass dort eigentlich so was wie Schaltnetze für Addition,
Subtraktion, beziehungsweise Alu eigentlich die Sachen sind,
die uns jetzt natürlich interessieren, weil das dann eben auch,
sagen wir mal, Grundbestandteile, so eine Rechnerarchitektur sind.
Multiplexer als andere Komponente hatte ich ja im Prinzip auch schon kurz vorgestellt. So,
bei den eigentlichen Rechenwerken, also Addition bzw. Subtraktion,
Hatte ich ja schon gesagt, wie im Prinzip jetzt die Addition mit halb Adiran und Voll Adiran im Prinzip erstmal funktioniert. Und ja,
da ist es jetzt eben so, dass man sagen kann,
es gibt eben einen ganzen Satz unterschiedliche Adia oder Adia-Typen,
die müssen sie jetzt also auch nicht zwingend für die Prüfung oder so weiter wissen,
sondern was man eigentlich grob wissen sollte,
ist im Prinzip sowas wie jetzt, also dieses allereinfachste Prinzip,
so ein Ripple-Carry-Adia funktioniert, die beiden anderen Typen,
die jetzt also hier in der Vorlesungen in den Unterlagen quasi noch vorgestellt werden.
Also da geht es eigentlich nur darum,
dass man grob die Idee einfach mitbekommt, wie das Ganze funktioniert,
dass man da dann noch mal so ein bisschen sehen kann,
warum das vielleicht eben auch funktionieren kann bzw. rechnen kann.
Gut, insgesamt gibt es da sehr einen ganzen Satz unterschiedlicher Varianten.
Allereinfachste ist eben erst mal straightforward, wie man das eigentlich
jetzt also auch so beim Rechnen von Hand machen würde. Das,
was sich dann also Ripple Carry Adira nennt,
wo man eben sagt, ich habe also lauter einzelne Volladierer,
berechne quasi in jeder Stufe,
das heißt also für jedes Bitpaar letztendlich aus zwei Eingangsblitz A und B und einem gegebenenfalls vorhandenen Eingangscary,
also einem Carry Inn, dann eben ein Summenbit und ein Carry Out.
Und beim Ripple Carry Adira,
das ist eben das wohl dann der Name eigentlich auch herkommt,
sieht es dann eben so aus,
dass bei benachbarten Stufen dann eben letztendlich das Carry Out der Einstufe dann das Carry in der nächsten höheren Stufe entsprechend ist.
Und demzufolge ist es dann natürlich so, dass man sagen kann,
die gesamte Verzögerung, wenn ich jetzt sage,
das Ding soll jetzt eben irgendwie möglichst schnell arbeiten, wächst letztendlich mit der Anzahl der Stufen nicht. Das heißt,
wenn ich sowas habe, wie ein 32-Bit-Adierer und ich mache dann also irgendwie ein 64-Bit-Adierer,
in dem ich dann also letztendlich nochmal 32 folladiere,
dahinter setze, dann wird das Ganze eben entsprechend doppelt so langsam,
nicht deswegen sieht es da dann eigentlich immer so aus,
dass man, heutzutage, wenn man jetzt sagt,
die Rechner sollen eigentlich möglichst schnell arbeiten, so was wie so Ripple,
Carrie eben immer nur für kleinere Wortbreiten nimmt und dann eben irgendwelche von den anderen Ideen, die dann also jetzt gleich noch kurz vorgestellt werden.
Ansonsten, was man da dann eben auch immer noch machen kann bei der Addition,
also generell, das gilt nicht nur Frippekehrte,
sondern auch für andere, die ja ist,
dass man sagen kann, wie kann ich einen Überlauf erkennen,
weil das ist ja immer das Problem,
wenn ich jetzt da so mit einer begrenzten Wortbreite rechne,
sei das nicht, oder typischerweise dann eben im Zweierkompliment,
dass man dort dann eben sagen kann,
wenn sich Das Carry Out,
der vorletzten Stufe und das Carry Out der letzten Stufe voneinander unterscheiden,
dann habe ich ihm arathmetisch gesehen einen Überlauf,
wird dann eben bei einigen Prozessoren dann teilweise auch irgendwo in irgendwelchen speziellen Registern gespeichert,
kann man dann eben auch programmiertechnisch abfragen.
Ansonsten ist man aber immer als Programmierer selber dafür verantwortlich,
dass man eben weiß,
bei den und den Datentypen rechne ich mit der Wortbreite und habe dann eben entsprechend meine maximal darstellbare Zahl,
dass ich dann eben auch wirklich sicher sein kann,
dass wenn ich zwei große Zahlenzahlen addiere,
dann Ergebnis habe, was dann eben in dem Zahlenbereich,
in der Zahlendarstellung dann eben also auf einmal einer negativen Zahl entspricht,
dass man das dann eben auch entsprechend kennzeichnet.
Gut, also Ripple Carry, Adira, wie gesagt,
einfach eben in Form von Volladdierern, die dann also immer
letztendlich die Eingänge über die jeweiligen Paare von Bits haben.
Und dann gibt es eben hier ein Carry In,
ein Carry Out und dieser Carry Out Ripple sich dann hier so durch.
Das ist jetzt hier die Grafik,
die also unter anderem dann also auch in so einem Hochfahren,
Chefmann Schmidt, zur technischen Informatik mit drin ist.
So ein bisschen praktischer sieht man das Ganze dann noch,
also auch gerade dieser Effekt mit diesem Durchrippeln bei diesem Beispiel,
wo jetzt also in diesem Fall jetzt hier also acht Volladierer mal zusammengeschaltet sind.
Das können wir jetzt also hier auch mal verlassen,
alle einmal kurz mit Hades öffnen
So, nicht, dass wir jetzt also hier entsprechend dieses Beispiel.
So, und was man hier jetzt also sieht,
das sollen jetzt die beiden Angangszahlen sein, B und A, jeweils 8 Bit breit.
Und wenn ich jetzt eben so eine Situation herstelle,
wo ich also hier zum Beispiel mal irgendwie so lauter einzelne Bits setze und anschließend,
indem ich jetzt also in diesem Fall B,
also nochmal einen größer mache, wo sich dann also letztendlich dann der,
das Carry-Signal hierzu durchschreppeln würde, sieht man dann eben hier sehr schön,
wie zeitlich nacheinander wirklich dann überhaupt erst die richtigen Ergebnisse einprudeln und im Laufe dieses Umschaltens dann eben auch dieses Carry-Signal dann hier sukzessive dann einen richtigen Wert annimmt.
Gut, in dem Fall wird das eben dadurch erreicht,
dass man in diesem Fall jetzt hier bei diesen Komponenten, das hatte ich also vorgestern,
als ich Hades vorgestellt hatte, also auch noch nicht gezeigt. Nicht,
wenn ich hier so einen Adira nehme, mir den angucke,
der ist in diesem Fall jetzt also auch hierarchisch aufgebaut,
also hier aus einzelnen Teilelementen und jetzt also hier von diesem Element ansehe,
welche Eigenschaften es dann hat,
dann kann man hier eben sowas wie so ein Gate-Delay einstellen,
das ist jetzt in diesem Fall einfach nur künstlicher Wert,
der dann aber in der Simulation eben für diese simulierte Zeit mit benutzt wird,
um zu sagen, wie lange dauert das?
Und wenn ich den dann eben entsprechend raufsetze,
dann kann man dort eben entsprechend genau diesen Effekt erreichen.
Gut, das wollte ich jetzt gar nicht ganz beendet werden, aber okay. Ja,
wie gesagt, das jetzt zu dem Ripple Carry, Adira,
also wie gesagt, da kann man also entsprechend sehen, wie langsam das Ganze funktioniert. Und das ist eben der Grund,
weswegen man sich dort dann eigentlich eben bei kleineren Wortweiten beschränkt,
weil heutzutage sage ich, okay, der Prozessor soll möglichst schnell getaktet werden,
möglichst große Performance haben, weil das ist im Zweifelsfall zumindest,
wenn man so bei einer gewissen Preiskategorie angekommen ist,
dann immer das Verkaufsargument, um zu sagen,
also da sind wir noch besser als der Mitbewerber und demzufolge sehen natürlich dann die Chip-Hersteller schon zu,
dass sie also gerade bei solchen Schaltnetzen,
die dann eben insgesamt letztendlich die Taktrate beeinflussen,
da dafür sorgen,
dass man das Ganze möglichst schnell macht.
Gut, dass wir jetzt also prinzipiell erst mal Addition,
wie kann ich jetzt subtrahieren? Da kommt uns eben letztendlich
genau diese Eigenschaft zugute, wie das Zweierkompliment aufgebaut ist.
Nur dass man eben letztendlich als Zahlendarstellung in den Rechnern eben typischerweise immer mit Zweierkomplimentzahlen arbeitet und eine Subtraktion dann eben durch Additionen des entsprechenden Kompliments,
der Zahl realisiert und das Zweierkompliment konnte also dadurch immer sehr einfach gebildet werden,
dass man sagt, ich invertiere alle Bits,
dann habe ich das eine Kompliment und ich muss noch einen hinzuaddieren, dann habe ich das zweier Kompliment.
Und das kann man letztendlich gratis machen, indem man sagt,
ich habe jetzt einfach meine Schaltung, in der ich,
das sieht man also dann hier sehr schön,
in der ich dann eben sagen kann,
ich habe hier jetzt beispielsweise 4 Bit für A,
4 Bit für B und wenn es gerechnet werden soll,
A minus B, dann werden eben die Werte von B,
jeweils Mittweise invertiert, kann man dadurch erreichen,
dass sich das beispielsweise mit einem Signal, was mir jetzt angeht,
soll komplementiert werden oder nicht.
In diesem Fall dann so ein Exklusiv-Oder-Garter benutze,
was nämlich sagt, wenn dieser Eingang null ist,
dann ist der Ausgang das, was der Eingang hier ist,
wenn der Eingang eins ist,
dann wird hier aus der Einzelne null und aus der null eine Eins,
das ist dann eben genau, dass das Bild entsprechend gekippt wird.
So, das heißt,
dass an dieser Stelle habe ich damit dann das eine Kompliment berechnet,
Und anschließend kann ich dann also hier in der Alu,
also in diesem Fall jetzt also ein Vier-Bit Adira,
dann eben noch sagen, in der niederwärtigsten Stufe nehme ich jetzt eben keinen Halbaddira,
sondern Volladdira.
Das heißt, habe dort auch noch einen Carry in.
Und wenn dieses Carry in dann eben auch noch auf eins gesetzt wird,
dann ist das eben genau dieses Plus eins,
was dann letztendlich hier für diese Atometik noch benutzt wird.
Nicht, dass sich also eben statt A-B-A
plus B-Bitweise invertiert,
plus A
eins rechne
Gut, auch das wollte ich jetzt hier noch einmal schnell mit Hades zeigen,
weil wie gesagt, da kann man dann eigentlich immer sehr schön auch grafisch sehen, wie das Ganze funktioniert, dass es in diesem Fall ist. Also hier dieses Beispiel,
so wenn ich jetzt also für A beispielsweise einstelle,
den Wert 6 und für B beispielsweise 2, und jetzt erstmal nichts weitermache,
dann wird also hier im Prinzip eine normale Addition durchgeführt,
nämlich A plus B, nicht und abhängig davon,
wie ich jetzt also letztendlich diese beiden Leitung, Kompliment und Carrie in beschalte,
kann ich dann eben hier rechnen, A minus B,
in dem dann also hier raus mitweise invertiert, Carrie in gleich 1,
das Ganze dann eben gerechnet wird und das Ergebnis runderall überall ist,
dann also auch tatsächlich vier.
Und zudem kann man dann eben noch sowas rechnen,
VR minus B minus 1, wenn das Carrie in gleich Null ist,
beziehungsweise A plus B plus 1, wenn ich jetzt,
also hier quasi addiere und dann Carrie in,
also auch noch mit anhabe.
Nicht, das heißt, dadurch kann man dann eben sehr einfach mit einem Adira,
sowohl Addieren als auch Subtrahieren,
indem ich das dann eben mit solchen Exklusiv- oder Gattern das zweite Argument letztendlich mitweise inraptieren kann.
Gut, wie kommt man jetzt aber zu schnellen Adierern,
wenn man jetzt sagt,
also ich habe also letztendlich ihm genau dieses Problem einer großen Wortbreite,
womit wir nun typischerweise rechnen, sind ja eigentlich 32 Bit oder 64 Bezahlen-Darstellung.
Und wie gesagt, da gibt es also sehr viele unterschiedliche Varianten.
Über sich findet sich dann also beispielsweise dann ja sich erst auf dieser Seite,
unter anderem mit das, was ich jetzt hier so ein bisschen skizzieren werde,
sind also im Prinzip zwei der geborglichsten Typen.
Einmal sogenannter Carry Select Ada. Da ist die Grundidee,
dass man sagt,
ich bilde Gruppen von Ripple Carry Addierern und rechne dann jeweils für eine relativ kleine Wortbreite aus,
A plus B, beziehungsweise A plus B plus 1. Das heißt,
ich warte jetzt gar nicht auf den Carry einer vorhergehenden Stufe,
sondern ich rechne einfach unter der Annahme,
dass ich einmal in Carry gleich Null habe und einmal unter der Annahme,
dass ich in Carry gleich eins habe.
Das heißt, man erhält dann also auf einmal zwei Ergebnisse.
Ist dann also auch der doppelte Hardware-Aufwand.
So und anschließend gibt es dann eben einen Multiplexer,
womit dann also entschieden wird, welches ist das richtige Ergebnis.
Und der wird dann eben von dem Carry Out der niederwertigeren Stufe
letztendlich umgeschaltet. Das Ganze wird im Prinzip, klar,
wenn man sich also hier sowas ansieht, also ich habe,
also in diesem Fall jetzt hier so ein 8-Bit-Carry-Select-Adira, also wie gesagt,
Carry-Select, deswegen war ich eben mit diesem Multiplexer eins von zwei möglichen Ergebnissen auswähle.
So auf unterste Stufe habe ich einen ganz normalen Ripple-Carry-Adira,
dann gibt es hier quasi einen Blog,
wo eben einmal A plus B mit dem Carry Null und einmal A
plus B mit dem Carry 1 berechnet wird und dann über Multiplexer
wird eben entweder dieses oder dieses Teil Ergebnis ausgegeben und eben auch der jeweilige Carry Out,
entweder von dieser oder von dieser Stufe genommen.
Und diese Multiplexer werden jetzt eben über den Carry Out, der niederrennstufe letztendlich dann beschaltet.
So, und das Ganze wird dann also kaskadiert aufgebaut,
indem dann also diese Stufen nachher also immer länger werden.
Das heißt also, hier gibt es dann also ein Bett,
dann dann so ein Drei-Bit-Block, dann vier-Bit-Block und so weiter.
Und das kann man dann also, letztendlich ist das dann technologieabhängig,
dass man wissen muss, wie schnell ist das Ganze,
wie schnell sind also hier diese einzelnen Charles-Sachen,
dass man dann eben letztendlich ausrechnen kann,
wie man hier diese Partitionierung am sinnigsten machen kann.
Das ist also die Grundidee von diesem Carry Select Adira.
So hört sie jetzt natürlich erstmal so ein bisschen exotisch an.
Die meisten von ihnen werden sowas in der Hosentasche haben,
im Smartphone, weil solche Adias sind eben beispielsweise in einem Arm-Prozessor mit drin.
Also das, was letztendlich bei, ja, sagen wir mal,
Grundlage jetzt eigentlich aller CPUs in Smartphones mit drin ist,
beziehungsweise bei vielen anderen Geräten eingebetteten Geräten, nicht wo im Prinzip genau sowas gemacht wird.
Da hat man also hier einmal so eine Vier-Bit-Gruppe,
mich dann anschließend dann eben,
wo es nur eine normale Addition ist und dann aber hier immer die Auswahl dann über solche Gruppen,
wo dann eben jeweils Ohne und miteingangscary gerechnet wird und das Ganze wird dann eben über Kaskaden von Multiplex,
sondern eben irgendwie ausgewählt,
sodass man da dann immer so Gruppen hat von Vierbitt,
die nächsten vier, wird dann acht,
wird dann 16-Bit und so weiter,
bis man dann also letztendlich seine gesamte Wortbreite damit erschlagen hat.
Ein anderes Prinzip oder eine andere Idee wäre der sogenannte Carrilog Ahead Adira.
Da geht es also nochmal so ein bisschen darum, zu gucken,
wenn man jetzt also an die reinen Schaltfunktionen geht, wodurch kann Carrie erzeugt werden?
So und da war es ja so,
also Carrie ergibt sich also quasi Entweder dadurch, dass ich sage,
die beiden Eingangsbits, A und B sind eins,
dann weiß ich, ich habe einen Carry.
Oder einer von den beiden ist eins und ich habe einen Carry N.
So und da kann man jetzt eben quasi zwei Hilfsfunktionen generieren,
nämlich einmal A und B,
was dann quasi Gener for Generate steht,
weil das ist nämlich der Fall,
wo ich also schon unabhängig von dem Carry In entscheiden kann,
es wird ein Carry erzeugt,
da muss ich also jetzt nicht
auf irgendwas warten
Und dann gibt es quasi diesen Ausdruck,
der sich da ein Propergate nennt, wo man sagen kann,
wenn aus diesem Oder-Ausdruck letztendlich eine Null rauskommt.
Das heißt, beide Eingänge sind null,
dann kann nie ein Carryout erzeugt werden.
Nicht weil ein Carry in letztendlich hiermit dann nie ein Ausgangskarry ergibt.
Wenn einer von den beiden eins ist, gut,
dann ist das der einzige Fall,
wo ich dann also auf den Eingangskarry warten muss
So, das heißt, dann kann man diese Funktion für den Carry also letztendlich umschreiben, als Generate oder Propagate und Eingangs-Carry. So,
und jetzt ist der Trick, dass man sagt,
mit diesen Funktionen mache ich dann eben folgendes,
dass ich daraus dann einen Baum hier in den Folien,
ist ja jetzt also quasi immer beschrieben mit Baum,
der sich dann also quasi immer um mit zwei Teilästen verzweigt,
dass man dann eben quasi einen Baum aufbaut,
wo dann also immer aus Gruppen von Generate und Propagate-Signalen dann eben für die nächsten Stufen entsprechende Informationen generiert werden,
also kann Carrie aufgebaut werden oder nicht.
So, die Tiefe des Baums ist Logarithmus Duales von N,
war ich, wenn ich jetzt also doppelt verzweige,
dann habe ich da eben entsprechend die Basis 2 da mit drin und demzufolge skaliert das jetzt in Bezug auf die Wortbreite,
nicht während ich beim Ripple Carry Adira quasi linear skaliere,
dann eben mit Logarithmus Duales 2 von der Wortbreite, das heißt,
dadurch hat man eigentlich einen vergleichsweise sehr schnellen Adiera beziehungsweise sehr schnelle Möglichkeit,
sowas umzusetzen.
Gut, hier sind jetzt nochmal nur die Hades-Schaltung,
das werde ich jetzt mal kurz überspringen,
wie jetzt also im Prinzip also ein Volladdierer aussieht,
der dann eben entsprechend summen wird und diese beiden Signale hat.
Nicht, dann gibt es dann also einen Funktionsblock,
der dann eben letztendlich aus Eingangs-Carry und den Propergate und Generate
Signalen von zwei Stufen dann eben Ein Ausgangscurry generiert und eben die entsprechenden Signale dann eben zusammenfasst.
Nicht hin daraus darf es jetzt eigentlich hier das Interessante,
kann man dann eben so einen Gesamtaddierer aufbauen, der dann,
wo man dann eben sagen kann, also hier unten,
das sind jeweils ganz normal Volladdierer und ansonsten habe ich hier dann aber immer diese Elemente,
die dann also quasi Generate und Propa geht von zwei Stufen zusammenfassen und mit einem Eingangscurry dann eben berechnen,
ob dann entsprechend jetzt neue erstellt werden.
Dadurch kann man dann mit vergleichsweise weniger Gattern, dann eben sehr schnell diese Carry-Berechnung machen. Wenn ich das jetzt natürlich vergleiche mit einem Ribble-Carry-Adierer,
sieht man eben auch,
also wieder immer irgendwie sehr schön diesen typischen Tret auf,
den man, also den man eigentlich bei den meisten Hardware-Schaltungen irgendwo mit hat,
dass man sagen kann, also ich kann meine Schaltung eben,
wenn ich sage, das ist Tee für die Laufzeit und das ist also irgendwie A,
die Fläche, der Aufwand, die Anzahl der Gatter,
wie auch immer ich das nennen möchte.
Also sprich, wie viel Aufwand muss ich in die Hardware stecken?
Da kann ich eben sagen, okay,
Sowas wie so ein Ripple-Carry-Adira, der würde sich hier bewegen.
Das heißt, er hat also vergleichsweise wenig Hardware-Aufwand,
weil da brauche ich bei 32 Bits, 32 Volladdira.
Der ist aber eben vergleichsweise langsam. Und auf der
anderen Seite habe ich dann sowas wie einen Carry-Look Ahead-Adira,
der quasi hier in Bezug auf die Zeit mit Logorithmus Duales
von der Wortbreite irgendwie skaliert,
deutlich schneller ist,
der aber deutlich mehr Hardware-Aufwand benötigt
Sagen wir mal, alle anderen Adiratypen befinden sich dann also auch hier irgendwo.
Also typischerweise hat man hier dann immer irgendwie solche Kurven,
auf denen dann also die einzelnen unterschiedlichen Varianten liegen,
wo man eben sagen kann,
je nach Aufgabenstellung soll das relativ kleines System,
die kleine CPU sein, die mir also die Kaffeemaschine steuert,
dann muss das Ding nicht also unendlich schnell sein.
Dann kann ich also hier sowas nehmen,
wo ich also sehr wenig Hardwareaufwand benötige,
wenn ich das in einer CPU von irgendeinem Desktop-Rechner einsätze,
der mit gut 4 Gigahertz getaktet wird,
dann muss ich eben entsprechend aufwendigere Lösungen, wie sowas dann eben benutzen.
Habe dann aber eben mal eine sehr schnelle Realisierung.
Und das ist dann immer so ein typischer Tritt oft,
den man also bei beliebig vielen anderen schallt,
Funktionen beziehungsweise Schaltennetzen eigentlich auch immer hat,
dass man dann eben immer entscheiden muss, wonach gehe ich da.
Gut, ansonsten, wie gesagt,
also auch das könnte man jetzt also hier nochmal mit Hades vorführen,
funktioniert dann also entsprechend auch Additionen, Subtraktionen von Zahlen.
Ich habe dann hier also quasi auch noch Eingangs Kerry gut für die Subtraktionen, die Exklusivgatter entsprechend fehlen hier. Gut,
was man häufig auch hat, ist,
dass man dann also noch mehrere operanten summieren muss,
da kann man jetzt also auch irgendwie dann so was wie hier angedeutet,
irgendwie so baumartige Strukturen sich überlegen,
also indem ich jetzt einfach ein Volladdierran nehme und nicht nur die beiden Elemente A und B,
sondern also auch den Carry Innern als zusätzlichen und dann
kann ich das in irgendwie so Bäumen zusammenfassen,
um damit beispielsweise was wie ein Bitcount
zu berechnen
Bitcoin war ja Codierung, Hemmingabstand, die Anzahl der Eins sind in einem Wort.
Gut, das jetzt erstmal nur zu den Adia-Netzen. Wie gesagt,
Ripple Carry, das sollte man also grob verstanden haben,
ist aber eben vergleichsweise langsam.
Carry select ist schon vom Aufwand von der Verzögerung eben schon
um einiges schneller, skaliert also im Prinzip mit Wurzelfonänen.
Carry Look Ahead ist also mit einer der schnellsten Typen,
ist aber dann also vom Hardware auf und das auch deutlich aufwendiger.
Ja, und eine Subaktion erreiche ich eben durch Addition,
das war ja Kompliments, nicht,
und das war ja Kompliment, hat er hier gezeigt,
kriegt man also relativ einfach durch Bedvises, Invertieren und Carrien.
Gut, daneben, wie sieht das jetzt mit anderen arathmetischen Funktionen aus?
Kann ich die auch in irgendwelche Schaltnetze umsetzen? Da muss
man sagen, ja, im Prinzip geht das alles.
Ist ja immer die Frage, wie häufig oder wie oft braucht man das?
Und wie viel Hardwareaufwand möchte man dafür spendieren? Ich wahr,
ich kann natürlich sagen, wenn ich also beispielsweise zwei Zahlen
multiplizieren möchte, dann kann ich das eben einfach dadurch machen
Wie ich das also jetzt ja auch irgendwie hier an der Tafel oder sonstig rechnen würde,
dass ich eben sage, ich addiere und ich schiebe immer,
indem ich dann eben entsprechend Teilprodukte bilde und das Ganze dann eben immer jeweils aufsummiere.
Das heißt also,
im Prinzip kann ich eine Multiplikation eben auch mit einem stinknormalen Rechenwerk realisieren,
wo ich eben eine Addition habe und wo ich eben irgendwie so ein Bitweises Schieben um eins habe.
Nicht, dass genügt letztendlich schon. Ich kann aber eben auch entsprechende Hardware aufbauen,
die in dem Sinne auch nichts anderes macht als das,
was ich eben auch bei einer Multiplikation jetzt von Hand an der Tafel machen würde.
Nicht, dass wenn ich jetzt also hier irgendwie zwei Zahlen habe.
Nicht, dass ich dann ja eigentlich rechnen würde,
okay, ich nehme hier die Zahl.
Nicht, dann hätte ich hier entsprechend diese Zahl dann
eben jeweils
Verschoben und müsste die dann eben entsprechend passend addieren. Nicht,
dass ich dann letztendlich genau dieses nachbilde,
indem ich daraus also auch direkt so eine Art Hardware-Struktur mache,
wo ich dann, gut,
also ich kann das natürlich atometisch auflösen in ein zweistufiges Schaltennetz,
macht jetzt natürlich keinen Sinn, wenn ich größere Wortbreiten habe.
Ansonsten hat man typischerweise genau sowas wie das hier angedeutet ist,
also im Prinzip dann so eine re-artige Struktur,
wo ich dann also über eine Addition letztendlich dann und durch Laufen
so einer Kaskade dann eben genau diese Talprodukte dann immer berechne und
am Ende dann eben nur noch über eine finale Addition von zwei Talprodukten dann eben ein Gesamtergebnis bestimmen muss.
Also dieses hier entsprechend nicht, grob gesagt,
also eigentlich genau dem, was ich hier habe,
nur dass es hier jetzt also quasi andersrum gezeichnet ist,
wenn ich das jetzt also hier so rum, also nach links verschieben würde,
das wäre dann also letztendlich genau dieses Äquivalent zu dieser Hardware-Struktur.
Gut, das heißt also im Prinzip Multiplikation kann ich dann eben auch über spezielle Hardware machen wird in Standardprozessoren dann,
also auch immer noch mit angeboten, weil wie gesagt,
dann möchte man das natürlich möglichst schnell machen bei billigen Kleinen,
Rechnern für eingesbettete Systeme, hat man sowas dann natürlich nicht,
sondern da würde man das dann eben entsprechend über Software machen.
So, daneben kann man aber auch immer noch über,
also gerade solche re-artigen Strukturen noch beliebig viele andere Funktionen machen,
also zum Beispiel kann ich also hier in die Quadratwurzeln der Zahl ziehen,
man kann im Prinzip sowas wie eine Division mit noch ein bisschen mehr auf und im Prinzip genauso machen,
Frage ist halt eben immer, Wie häufig brauche ich so eine Operation?
Und eben sowas wie die Quadratwurzel einer Zahl zu berechnen,
passiert eben relativ selten. Deswegen wird dann also,
sagen wir mal, so eine Hardware-Struktur,
also im Prinzip kommt man das eben auch mit Volladdieren und Exklusiv- oder Gatter,
also relativ einfach hin, wird sowas dann eben immer entsprechend nicht realisiert.
Gut, das eigentlich nochmal kurz zusammengefasst zu den Arten und Weisen,
wie jetzt also wirklich adatometische Rechenwerke aufgebaut sind,
wie man das macht
Wenn man da jetzt das noch weiter vertiefen möchte,
also irgendwie immer in den Anhängen der einzelnen Kapitel habe ich dann immer noch so ein bisschen Verweise auf irgendwelche Literatur,
da findet sich also auch relativ viel,
wo dann eben auch genau die ganze Mathematik dahinter noch beschrieben ist,
warum das funktioniert,
warum bestimmte Sachen vernünftig oder effizient also gemacht werden können,
nicht wahr, also da gibt es dann doch relativ viel noch an speziellen Themen,
die ich jetzt also hier einfach aus Zeitgründen gar nicht weiter behandelt habe,
nicht,
also zum einen für Multiplikationen werden dann typischerweise die Zahlen dann noch umkodiert und dann über Gruppen sowas gerechnet,
dass ich dann eben quasi aus Folgen von Einsen lauter Nullen mache und dann dafür eine Stelle höher eine Einsätze.
Und dann gibt es eben auch noch einen ganzen Satz von Algorithmen,
die es also für Multiplikation, die Vision genommen werden können,
wo man dann also im Prinzip dann also auch über Arrays von Funktionseinheiten damit einiges machen kann.
Gut, bei dem,
was man sonst in Hardware-Einheiten jetzt also vielleicht noch an entsprechenden Schaltnetzen findet,
ich auch nur kurz aufgezählt, also eines,
was häufig noch irgendwie vorkommt, ist etwas,
was sich also prioritätsencoder oder priority encoder nennt.
Da geht es darum, dass sich also hier im Prinzip
ein Schaltennetz habe, was also folgende Funktion realisiert.
Ich habe hier also irgendwie beispielsweise vier Eingangsvariablen und wenn X3 gesetzt ist,
dann wird quasi hier, weil extra jetzt eben die höchste Priorität hat,
ist es egal,
was alle anderen hier haben,
wird eben als Ausgang drei ausgegeben,
wenn X2 gesetzt ist und X3 nicht
Dann wird zwei ausgegeben und so weiter. Also die Schaltfunktion ist logischerweise,
also hier auch entsprechend vollständig in diesem, in dieser Funktionstabelle beschrieben.
Nicht das wird beispielsweise benutzt in den CPUs,
um für die Interratbehandlung unterschiedliche Prioritäten zu unterscheiden, wo man eben sagen kann,
es gibt also beispielsweise Interrats mit einer sehr hohen Priorität.
Es gibt welche mit einer sehr niedrigeren Priorität. Nicht wenn was passiert,
wenn mehrere gleichzeitig auftreten, nicht der mit der hohen Priorität muss abgearbeitet werden,
weil das ist jetzt beispielsweise irgendwie Prozess,
wo vom Betriebssystem aus irgendwie was veranlasst werden muss, eine seelenniedrigere Priorität,
wäre dann eben der Benutzer, hat eine Taste gedrückt.
Das wären dann also die Sachen und da sieht es dann eben so aus,
dass man also mit solchen Schalten netzen,
wo das dann eben letztendlich also auch in Hardware abgearbeitet wird,
dann eben dafür gesorgt wird,
dass,
wenn jetzt also irgendwas mit einer sehr hohen Priorität auftaucht,
die Elemente mit der niedrige Priorität quasi erstmal maskiert sind bzw.
nicht weiter betrachtet werden müssen
Gut nicht, also auch dafür kann man sich dann also irgendwie Schaltennetze überlegen,
also sprich hieraus Funktionstabellen aufstellen, KV-Diagramme minimieren und so weiter,
will ich jetzt aber nicht weiter größer beschreiben.
Eine andere Sache, die dann auch noch interessant ist,
das sollte man eigentlich auch immer wissen, ist,
wie sieht das jetzt mit Schieben und Schiebeoperation aus?
Bei den logischen Operationen hatte ich ja schon gesagt,
haben wir dann typischerweise was wie ein Linksschieben, ein Rechtsschieben,
beim Rechtsschieben wird ja dann immer noch unterschieden zwischen logischem Schieben und Arithmetischen schieben.
Was war da nochmal der Unterschied? Das ist akustisch nicht. Ja. Genau, völlig richtig. Also beim logischen Schieben wird quasi,
wenn ich jetzt rechts schiebe,
vorne immer eine Null eingefügt beim Arithmetischen Schieben,
dann eben das höchstwertigste Bit entsprechend vervielfacht,
weil das ist eben genau das, wo ich also sage,
wenn ich mein Element jetzt als Zahl interpretiere und ich habe eine positive Zahl,
dann ist das höchstwertigste Bit eine Null, okay,
dann ändert sich da im Vergleich zum logischen Schieben auch nichts.
Wenn das aber eine negative Zahl ist, Zahlendarstellung ist eben immer Zweierkompliment,
beginnt das mit einer Eins und wenn ich das dann entsprechend schiebe,
müsste dann diese Eins vervielfacht werden,
da darf ich jetzt nicht vorne eine Null reinschieben,
deswegen gibt es da beim Rechtsschieben immer diese Unterteilung,
dass man das eben auch entsprechend mag.
Gut, um so ein Schieben zu realisieren,
beziehungsweise um das dann eben auch um beliebige Wortbreiten zu machen.
Gibt es dann also auch immer relativ trickreiche Schaltungen,
um jetzt so ein Schieben auch um Variable mitbereiten zu realisieren.
Also wie gesagt,
bislang haben wir das ja nur irgendwie als Java-Operator oder C-Operator irgendwie kennengelernt,
wird in der Regel aber eben auch direkt in Hardware in der CPU unser Rechner realisiert werden.
Das, was man dort hat, ist etwas,
was sich dann immer Battleshifter nennt.
Und zwar ist da die Idee, dass man sagt,
ich habe wird das hier gleich mal mit Hades direkt öffnen.
Nee,
den wollte ich nicht
So, das, was man dort dann also eben macht,
ist, dass man sagt,
ich habe jetzt also hier beispielsweise bei acht Eingangsbits die Möglichkeit,
die um null bis sieben zu schieben.
Das wird also hier quasi durch drei Bit kodiert.
Das ist dann so eine dreistufige Schaltung. Hier habe ich Multiplexer,
mit denen ich eben mein Eingangsbit entweder durchleiten kann oder um
eine Stufe oder an eine Stelle verschiebe.
Hier habe ich die Möglichkeit, es durchzuleiten um zwei Stellen
zu verschieben. Und hiermit habe ich die Möglichkeit,
es durchzuleiten oder um Breiisch der Blödsinn vier Stellen zu verschieben.
Das heißt, man hat immer die entsprechenden Zweierpotenzen. Das heißt,
wenn ich jetzt also hier irgendwie so einen Bit-Vector habe,
gehen aus wieder, dann wird er also hier entsprechend um einen verschoben.
Hier um Zwahl verschoben. Und wenn ich das dann eben entsprechend Jahren gegeben habe,
nicht das heißt, das entspricht dann eben auch Direktionalbinärkodierung,
kann ich dann eben sagen, wenn ich also um drei Stellen verschieben möchte,
werden dann eben entsprechend über diese beiden Bits,
erste und die zweite Stufe realisiert ihm genau dieses letztendlich dann machen.
So nicht. Und je nachdem, wenn ich jetzt so
mit größeren Wortbreiten bin, hätte ich da also noch mehr Stufen nicht.
Und dadurch kann man dann,
wenn man das dann also noch passend aufbaut und nochmal anders verdrahtet,
dann also sowohl links schieben, als auch rechts schieben,
als auch eben Unterscheidungen eben zwischen logischem,
laratmetischen Schieben direkt in Hardware realisieren.
Gut, wie gesagt, damit kann man eben im Prinzip all diese Schiebeoperationen
Diese Rotate-Befehle, ich wurde also die außen geschobenen Bits dann,
also letztendlich wieder reingehen, entsprechend direkt umsetzen.
Gut, dann jetzt noch abschließend als letztes zu der
Alu-Arithmeter-schlogischen Einheit oder Englisch-Aresmith Hegulogic Unit.
Das ist eben letztendlich das Schaltnetz oder das Rechenwerk in unseren CPUs,
in unseren Prozessoren,
was für die Berechnung verantwortlich ist
Das, was man dort typischerweise macht,
also mal so als Minimalumfang, ist, dass man sagt,
also ich kann damit addieren und subtrahieren.
Gut, wie das geht, haben wir schon kennengelernt.
In der Regel hat man da dann eben noch mitweise logischer Operationen.
Das heißt also, Negation, also sprich ein Eingangswektor wird mitweise negiert oder invertiert.
Kann man ja mit dir exklusiv oder gar dann erreichen. Dann eben sowas wie ein Bidvises und Bidvises oder,
also all das, was man eben braucht,
um zum Beispiel solche Maskierungen zu machen,
wie wir sie also am Anfang in diesen Spielen dann eben auch schon kennengelernt haben,
Schieberoperationen und gegebenenfalls eben bei den aufwendigeren Alus hat man dann eben auch noch entsprechende Hardware-Einheiten, die direkt eine Multiplikation machen.
Gut, Adien, Subrahieren haben wir ja schon kennengelernt, die Folien wiederholen sich. So,
wenn ich jetzt sage, ich möchte jetzt nicht nur Adien subtrahieren,
sondern ich möchte jetzt also auch noch sowas wie einige Bitweise-Operationen machen,
dann kann ich das natürlich also einfach straightforward dadurch realisieren,
dass ich sage, okay,
ich nehme hier so eine Adira Ich kann dann eben mit Komplimentbildung und Carrie innen dann eben hier raus,
also sowohl Addition als auch Syrp-Traktionen berechnen und für irgendwelche Bitweisen-Operationen habe ich dann eben noch die Möglichkeit,
je nachdem, was ich dort benötige,
entweder zwei Bit mit dem Mund zu verknüpfen,
mit dem oder zu verknüpfen mit dem Exklusiv-Oder und so weiter und das,
was man dann eben nur machen muss, ist,
dass man dann eben über entsprechende Steuerleitung und multiplexer eben entweder das Ergebnis so eine Alu für Addition und Subtraktion oder das Ergebnis dieser Stufe,
dieser Stufe oder dieser Stufe dann eben in den Ausgang geht,
sodass ich durch diese vier Steuerleitungen dann eben letztendlich diese Befehle dann hier unterscheiden kann,
nämlich also diese drei Bittweisen-Operationen und dann eben noch diese Alu-Operation.
So, ist jetzt noch vergleichsweise umständlich,
wenn man das also wirklich direkt in Hardware optimieren würde,
dann würde man das also dann noch ein bisschen anders oder noch ein bisschen schlauer machen,
indem man die ganzen Sachen noch zusammenfasst.
Das führt dann dazu, dass man dann solche sehr übersichtlichen Schaltung bekommt,
die man dann also im Zweifelsfalls,
also hier nicht mal eben schnell irgendwie von der Logik her nachvollziehen kann will und auch nicht zwingend nicht muss.
Also von daher keine Angst, sowas wird weder in Übungsaufgaben
noch in der Klausur in irgendwas rankommen. Ist jetzt eigentlich nur so ein Beispiel,
also in diesem Fall jetzt also auch von so einem 74er-Baustein,
also für eine sehr einfache 4-Bit-Alu,
die kann man dann aber über mehrere von den Dingern dann also auch noch größer machen,
dass man einfach mal sieht, welche Funktionen es da gibt.
Also da gibt es dann eben Die Standardarenthmetischen Funktionen,
Addition und Subtraktion, ich habe dann aber eben auch noch irgendwelche Bitweisen-Operationen,
nicht XOR oder und so weiter, je nachdem,
wie die Eingangskombination jetzt dieser Steuereingänge sind, wird letztendlich,
also hieraus über entsprechende Schaltalgebranche Kombination dann immer die entsprechende Funktion letztendlich gewählt.
So wie man sieht, sind das natürlich teilweise Sachen,
Vielleicht nicht zwingend brauchen, also sowas wie A oder B plus A und Nicht-B.
Das ergibt sich in dem Fall jetzt eben wirklich hier nur
irgendwo aus dem Schalten, das aus den Schaltalgewaschen ausdrücken.
Nicht aber einfach nur, um zu zeigen,
dass man dann eben über solche Minimierung, weil wie gesagt,
also sowas hier funktioniert eben auch für jetzt für alle möglichen Operationen nicht,
aber damit bewegt man sich,
also irgendwo in dem Tal,
wo man sagen würde,
das Ganze ist eben doch vergleichsweise umständlich,
vergleichsweise flächenaufwendig
Und über Minimierung war, hier kann ich sagen,
das ist hier irgendwie so ein vierstufiges Schaltnetz.
Nicht so was ist dann hier dann schon ein bisschen weiter optimiert.
Gut, und wie gesagt, daraus kann man dann eben komplett größere Alus dann zusammenbauen.
Also das ist jetzt hier in dem Beispiel dieser 74er-Bausteine,
funktioniert aber im Prinzip genauso mit solchen Elementen dann eben auch in dem,
was wir so als CPUs haben.
Gut, ja, jetzt verlassen wir ja mal die abschreckenden Skematics.
Kommen wir jetzt nochmal so zu dem Problem bzw. zu der Sache mit dem Zeitverhalten von Schaltungen. Vorher haben wir immer kennengelernt,
Bulschalge war, Bulsche Ausdrücke, ich da kann ich jetzt eben immer sagen,
ich habe da so irgendwie ein Schalalgebaschen Ausdruck,
kann Ihnen berechnen, was dort aber noch nicht weiter betrachtet wird,
ist dann eben letztendlich, wenn ich das irgendwie technisch realisiere,
was ich zumindest so auf unerster Ebene in Hardware in der Alu ja irgendwo dann mal machen muss,
wenn das also in den Computer verbaut werden soll,
wie wird das Zeitverhalten modelliert bzw. woraus ergibt sich das
Das, was jetzt hier so ein bisschen noch mal kurz vorstellen werde, beziehungsweise motivieren möchte,
ist eben eigentlich noch mal, welche Grundprinzipien sind da,
worauf muss man vielleicht achten beim Entwurf. Ansonsten ist es natürlich so,
dass sowas wie das Zeitverhalten von Schaltungen letztendlich immer von der verwendeten Technologie abhängt,
wo man sagen kann, gut, heutzutage 2019,
C-Mos-Schaltungstechnik mit den und den Strukturbreiten bei dem und dem Hersteller kann ich eben sagen,
ein Inverter, werden sich der Eingang von 0 nach 1 ändert,
dann ändert sich der Ausgang von 1 nach 0,
so und so viele Pico-Sekunden später.
So, wenn ich das in einer anderen Schaltungstechnik habe,
wenn ich das in zwei, drei Jahren mir vielleicht nochmal wieder ansehe,
habe ich demzufolge dann aber natürlich ein ganz anderes Zeitverhalten,
weil sich natürlich die Technologie verändert hat. Das,
was wir ja jetzt eigentlich auch immer gesehen haben,
was zumindest so die letzten 40, 50 Jahre,
Herr Wald schon, entsprechend gut funktioniert hat, Moore Slaw,
dass eben die Schaltung bislang immer noch exponentiell schneller geworden sind,
wobei man da jetzt eben auch sagen muss,
zumindest in den letzten drei, vier Jahren ist dieses exponentielle Wachstum eben deutlich langsamer geworden.
Hat teilweise aber eher andere Gründe,
hat die auch schon mal kurz gesagt,
dass man da nämlich im Prinzip dann mit der Leistungsaufnahme Probleme
bekommt und die Schaltung dann also irgendwie da nicht mehr richtig kühlen kann.
Aber sagen wir mal, wenn man sich so ansieht,
wie jetzt zwischen meinetwegen 1990 und sagen wir mal,
2012, 2013, also irgendwie die Schaltung schneller geworden sind.
Also da war das wirklich ein schönes exponentielles Wachstum.
Nicht, da fingen wir irgendwie so bei 10,
20, mega 30 Megahertz an. Dann ging das also irgendwie
ein paar hundert, dann war das auf einmal Gigahertz.
Nicht heutzutage kann man sagen, na gut, Standard, Desktop, CBU.
Da kriegt man die dann also zumindest so in der Einzelkernperformance
dann eben auch schon bis auf 5 Gigahertz und so weiter Geschwindigkeit.
Bloß, da muss ich eben auch sagen, naja gut,
also Dreigiger Herzrechner gab es vor fünf Jahren genauso schon.
Das heißt, da habe ich jetzt eben nicht mehr dies exponentielle Wachstum gehabt.
Sondern die Schaltungen sind in den letzten Jahren auch immer noch schneller geworden,
aber eben nicht mehr so extrem, wie das früher der Fall gewesen ist.
Gut, aber jetzt erstmal nochmal generell,
wie kann ich also ein Zeitverhalten modellieren und welche Auswirkungen
hat das Zeitverhalten auf die Funktion der Schaltung,
weil das ist dann nämlich also auch etwas,
wo man sich da also auch nochmal ein bisschen Gedanken
drüber machen sollte
Bislang haben wir immer kennengelernt, also wirklich rein algebranche Ausdrucke.
Da habe ich also keinerlei zeitliche Abhängigkeit. Das,
was wir hier jetzt noch so ein bisschen kennenlernen werden,
beziehungsweise was dann Übungsaufgaben auch auftauchen wird, ist eine Art Einheitsverzögerung. Das heißt,
wenn ich jetzt sage, ich habe hier zwei Gatter,
also beispielsweise ein und Gatter und hier jetzt also irgendwie ein Odergatter,
nicht, dass ich sage, okay,
dieses hat eben eine Verzögerung, um irgendwie einen Wert Ciao.
Und hier eben irgendwie genauso tau. Und dem zuvor kann
ich dann eben sagen, von dem Eingang bis hier,
wenn sich da jetzt irgendwie was ändern sollte,
irgendwie durchribbelt, habe ich dann eben zwei tau.
Und dann kann man nämlich immer wieder wunderbar sagen, technologieabhängig,
ob das jetzt irgendwie 30 oder 25 oder 5 Dikosekunden sind,
kann ich damit dann eigentlich immer ganz gut skalieren oder damit dann eben entsprechend rechnen.
Rein praktisch stimmt sowas nicht, sondern da muss man dann
eben auch schon unterscheiden, Welche Gatter sind das?
Weil einige sind ein bisschen schneller als andere.
Die sind dann eben doch nicht alle identisch mit den Schaltgeschwindigkeiten.
Dann müsste ich eigentlich jetzt noch weitergehen und sagen,
hier bei den Gattern, wie sind die jetzt wirklich irgendwo auf dem Ship benutzt?
Weil da gibt es eben auch einen feinen Unterschied.
Ob dieser Ausgang nur hier in den einen einzigen Eingang reingeht oder das hatte ich ja gesagt,
als Motivation für diesen Buffer,
wenn dieser Ausgang jetzt eben noch in fünf andere Gatter reingeht,
dann wird also diese Verzögerung hier eben auch deutlich größer,
abhängig davon, wie groß letztendlich diese Last dahinter ist.
Nicht, das kann man dann eben auch noch mit berücksichtigen,
dann muss man eben eigentlich auch noch elektrisch gesehen unterscheiden,
schaltet das von 0 nach 1 oder von 1 nach 0,
weil das ist auch jetzt über die Transistorschaltungstechnik motiviert dann eben
auch im Zweifelsfall nicht identisch bzw. man versucht es einigermaßen identisch zu machen,
skaliert dann aber letztendlich mit der Last dann also auch
wieder so ein bisschen
So, dann kommt jetzt etwas hinzu, was sich,
sagen wir jetzt auch,
in den letzten zehn Jahren zunehmend als Problem- oder Problemstellung entwickelt hat,
dass man jetzt eben sagen muss, gut,
also das, was wir hier immer betrachten, sind,
und das sind erstmal die ganz einfachen Modelle, Gatterverzögerungsmodelle,
wo ich dann sagen kann, okay,
ich habe hier irgendwie einen Inverter oder einen Untkarta, was auch immer, das braucht eine bestimmte Zeit.
Inzwischen ist es aber so, dass,
wenn ich mir jetzt angucke, auf dem Silitiumship,
wo diese Gatta dann also nachher in der Fertigung irgendwo aufgebaut worden sind,
ist eben schon ein entscheidenden Unterschied macht,
ob diese beiden Gatta quasi direkt zusammen irgendwo liegen oder ob dieses zweite Gatta jetzt also hier vielleicht in einer anderen Ecke liegt und ich hier also irgendwie noch eine relativ lange Leitung dazwischen habe.
Man versucht jetzt natürlich beim Layout irgendwie Elemente, die direkt miteinander verbunden sind, auch nah beieinander zu platzieren. Andererseits als Optimierungsproblem. Nicht,
wenn ich jetzt sage, auf dem Silizium sind irgendwie 18 Milliarden Transistoren drauf,
dann kann ich nicht sagen, ich finde sowas wie ein globales Optimum,
wo ich also jetzt wirklich die beste Lösung mir gedacht habe,
sondern man kann eben wirklich nur versuchen, mit irgendwelchen Schätzverfahren,
mit irgendwelchen Heuristiken möglichst gute Lösungen zu machen,
wo ich eben sowas habe,
weil eben letztendlich das Problem ja dann wieder ist,
wenn also der Ausgang dieses Gatters woanders irgendwo hier benötigt wird nicht,
dann kann ich das zwar hier entschieben, habe dann aber die lange Leitung.
Das heißt, das sind dann eben Verfahren,
wo man letztendlich dann immer nur sagen kann, okay,
ich versuche dann eine möglichst gute Variante hinzukriegen,
nicht aber zumindest an einigen Stellen muss man eben so solche Langleitungen realisieren und das kostet dann eben entsprechend Zeit.
So und da ist es dann eben auch so,
also früher war es eben letztendlich so, dass die Garterverzögerung,
der entscheidende Teil sind, inzwischen ist es eben so,
die Strukturen werden immer kleiner, die einzelnen Transisturenelemente werden immer schneller.
Und inzwischen sind eben solche Leitungen, also teilweise dann eben schon das Problem.
Kritisch ist das dann also gerade noch bei Taktsignalen,
ist dann etwas, wo ich dann, also ein, ja,
im nächsten Cup wieder noch mal so ein bisschen drauf reingehen würde.
So, ansonsten Zeitverhalten jetzt eigentlich genauer modellieren,
kann man eben sagen, okay,
ich habe jetzt eben nicht nur Gatoverzögerung, so nach Blauen und Leitungslaufzeiten.
Oder wenn man das ganz genau macht,
dann muss man eben wirklich in die Elektrotechnik reingehen und sagen,
okay, das ist jetzt hier nicht mehr Bundgatta,
sondern das sind sechs Transistoren mit den und den Eigenschaften.
Und dann habe ich dann einen elektrischen Simulator,
mit dem ich dann also das Ganze letztendlich durch das Lösen von Differenzialleichungssystem
berechne und kann dann eben wirklich genau darüber dann sagen,
wie sich das Ganze verhält. Gut,
solche Verzögerungen sind dann also in Hades eben auch in Form von diesen Eigenschaften oder Properties mit drin,
waren ja eben in dem Beispiel von diesem Ripple-Carry-Adira, also auch schon mit da,
dass ich eben für Syngatta sagen kann, wie lange es irgendwie verzögern soll.
Im Prinzip kann man den Leitungen in Hades dann auch noch solche Leitungsverzögerungen angeben. Nicht,
wie gesagt, es gibt in der Modellierung, je nachdem,
was man da betrachtet, dann eben immer dieses Grundkonzept,
Leitungsverzögerung oder eben Gatterverzögerung und rein praktisch hat man eigentlich eben immer eine Kombination aus beidem.
Ja, ich hatte ja schon gesagt, früher war es eben so,
die Leitungslaufzeiten konnten, grob gesagt, vernachlässigt werden, inzwischen stimmt das eben nicht mehr.
Das ist jetzt hier so eine Folie,
die eigentlich auch schon vergleichsweise alt ist, nämlich von 1997,
wo es also im Prinzip darum geht zu zeigen,
hier diese schwarze Linie zeigt, wie mit der Verbesserung der Ship-Technologie,
also in diesem Fall jetzt, also als Mikron 650 Nanometer bis 100 Nanometer,
die Gatta quasi immer schneller wurden.
Wenn ich jetzt aber im Prinzip eine gleich lange Leitung habe und dann gucke,
wie die Leitungslaufzeiten dann immer raufgehen, dann sieht man das letztendlich,
das, was sich hier an Geschwindigkeit gewinne, eben in solchen Fällen,
wo ich also irgendwie so globale Leitungen habe zwischen Bauelementen und das jetzt quasi auch mitskaliere,
dann eben gefühlt diese Laufzeiten auf den Leitungen letztendlich das Ganze auffressen und dann eben dazu führen,
dass zumindest für globale Leitungen, also dann sogar die Schaltung eher langsamer werden.
Gut, rein praktisch muss dann eben sagen, okay,
diese Situation hat man natürlich nicht, also das heißt,
wenn ich jetzt immer sage, 18 Milliarden Transistoren,
dann sind das jetzt natürlich Das,
was man jetzt also irgendwie so als große CPUs hat und die sind eben so aufgebaut,
dass man sagt, okay, ich habe hier meine 8 oder 16,
wie viel auch immer, einzelnen CPUs, einzelne Rechenkerne,
nicht und jeder von denen ist natürlich irgendwo lokal aufgebaut und ich habe jetzt also keine wirklich so großen globalen Leitungen, die dann also komplett quer über den Chip gehen.
Das Problem ist eben nur, wenn ich jetzt sage,
okay, ich habe dann sowas wie High Performance Computing,
sprich irgendwie sowas, was also diese Superrechner sind,
wo ich dann sagen kann, okay,
wie sind einzelne Rechenkerne miteinander verbunden und wie gesagt,
noch schlimmer wird das ja, wenn er sagt, okay,
ich habe jetzt nicht nur in einem, einer CPU,
also einem Stück Silizium, also das Ganze,
wo ich da jetzt meinetwegen meine 32 Kanne mit drin habe,
sondern ich habe jetzt eben ein ganzes Reckfall mit einigen hunderten oder einigen tausend Rechnern und diese CPU soll jetzt mit irgendeinem,
mit einer anderen CPU, die jetzt also auch irgendwo in diesem Reck verbaut ist,
also irgendwelche Daten austauschen,
wie kriegt man das dann eben entsprechend sinnvoll hin und vor allen Dingen dann eben,
wie schnell kriegt man das hin
Gut, wie gesagt, wir werden hier eigentlich immer in den Beispielen mit so einfachen Gatterverzögerungen arbeiten.
Und das dann eben immer einfach als vielfache so nah,
jetzt nicht weiter Normierten, Grundverzögerung, Tau letztendlich arbeiten.
Auch da muss ich dann aber dann immer sagen,
gibt es ja auch noch unterschiedliche Modelle,
nämlich AMA unterschiedliche Schalzeiten, abhängig von der Art der Gatter,
unterschiedliche Schalzeiten, abhängig davon,
wie ich von 0 nach 1 oder von 1 nach 0 wechsel,
wie viele Eingänge das hat und eben wie viele Ausgänge nachfolgender Gatta.
Oder wenn das ein Ausgang so und so viele Nachfolgende Gatta letztendlich treiben muss.
Ja, dazu auch noch mal kurz ein Hinweis zur Sache,
wie schnell kann ich solche Chips überhaupt takten oder was ergibt
sich da im Prinzip als Problem oder Problematik.
Also nehmen wir jetzt also einmal die Lichtgeschwindigkeit,
Nichtgeschwindigkeit im Vakuum
Ich lasse mir die Nachkommastellen mal weg, 300.000 Kilometer pro Sekunde.
Das heißt, in einer Nano-Sekunde 30 Zentimeter. So,
Nano-Sekunde, hört sich an, ja gut, das ist eine Milliardster Sekunde.
Wenn ich das in Takt umrechne, ist das ein Gigaherz.
Das ist Standard, das benutzen wir alle täglich.
Das heißt, bei einem Gigaherztag Im Vakuum letztendlich,
wenn ich Strom einschalte, komme ich genau 30 Zentimeter weit.
In metallen, weil die einen Innenwiderstand haben, ist es
noch ein bisschen langsamer, in Halbleitern eigentlich noch langsamer.
Wenn ich jetzt sage, 20 Zentimeter pro Nanosekunde ist das auch noch sehr optimistisch.
Das heißt, man kann jetzt eben sagen, beim Gigahertz-Tag kommt man irgendwie 20 Zentimeter wahr. Wenn ich jetzt sage,
ich habe so ein Stück Silizium,
wo jetzt also mein Prozessor drauf ist,
und sage dreimal drei Zentimeter, dann kann ich eben einfach sagen,
wenn ich von dieser Stelle des Chips zu dieser Stelle des Chips eine Leitung habe und die jetzt also einfach nur optimal durchgeht,
dann habe ich hiermit,
komme ich dann eben in der Ausbreitung hier auf eine Geschwindigkeiten,
sein Signal, dass ich dann eben sagen kann, okay,
dass man schon also unterhalb von 10 Gigahertz Takt rate.
Das zeigt eben eigentlich auch, dass es dann eben auch wirklich entscheidend ist,
dass ich jetzt nicht globale Leitung,
also hier irgendwie rüberführe und irgendeinen Ausgang hier mit dem Ausgang hier kommunizieren soll,
weil das würde dann eben entsprechend die Aktrate begrenzen.
Gut, glücklicherweise haben wir das noch nicht,
sondern ich habe dann hier quasi meinen eigenen einzelnen Rechenkern,
meine einzelne CPU, mein Chor,
der lokal da natürlich also entsprechend eine kleinere Fläche belegt und
wo man dann also da dann noch einigermaßen mit hinkommt.
Gleiches gilt letztendlich dann auch, also auch auf die Platine bezogen,
weil wenn ich jetzt sage,
ich habe also im Prinzip im Rechner die Platine,
wo die CPU drauf sitzt, ich habe dann also irgendwie Leitung,
Schnittstellen zu externen Komponenten zum Speicher.
Nicht auch da kann man sagen,
bei einer entsprechenden Größe der Platine kann ich da mit einem Gigahertz-Tag
dann also schon mal nicht mehr über die Leitung gehen,
weil dafür dann ASA einfach das Motherboard dann schon zu groß ist.
Nicht das zeigt eigentlich nur noch mal so ein bisschen,
dass man da inzwischen teilweise eben schon so auch an den physikalischen Grenzen so weit dran ist,
dass man sagen kann,
ich kann jetzt also nicht beliebig groß meine Chips machen und damit also irgendwie alles machen,
weil einfach aufgrund der Tatsache Lichtgeschwindigkeit ist,
nun eben auch mal nur endlich und ein Signal,
was von der einen Ecke zur anderen Ecke gehen soll,
braucht dann eben auch eine gewisse Zeit,
dass man das nicht berücksichtigt.
Gut, wie wird sowas immer rein praktisch gezeigt?
Dazu habe ich dann typischerweise immer das, was man so
als Impulsdiagramm kennt oder sieht im Englischen dann immer Wayform genannt.
Das ist dann eben letztendlich nichts anderes,
als dass ich jetzt von irgendeinem Gatter Und die Werte nehme und
mir das Ganze dann quasi über die Zeit hinweg angucke.
Das heißt, wenn ich jetzt also hier dieses Signal habe,
dass ich dann eben Prinzip so ein Diagramm habe,
wo man dann eben sieht,
wie sich das hier über die Zeit von null nach eins,
wieder nach null irgendwie ändert.
Und hier unten habe ich dann eben als Maßstab die Zeit
und hier ist eben irgendwelche, ja,
entweder analogen oder eben rein digitalen Werte 0 und 1,
wie auch immer ich
das dann interpretieren möchte
Das findet man dann eben relativ häufig. Das wird uns
also auch in Übungsaufgaben und das wird uns auch in der Klausur begegnen.
Wie gesagt, hier haben wir es als Zeitmodell immer nur was vergleichsweise sehr Einfaches.
Ich hatte jetzt gesagt, es gibt sowas wie so eine Einheitsverzögerung.
Das ist also hier in dieser Grafik so ein bisschen so dadurch skizziert,
dass ich quasi hier immer so meine Zeitschritte Tee habe und dann eben entsprechend Vielfache von Tee.
So und wenn ich jetzt also hier zum Beispiel ein Eingangssignal A und B habe,
die haben jetzt hier also irgendwie dann immer so einen bestimmten zeitlichen Verlauf.
Ich nenne es also letztendlich hier immer angedeutet, wie würden A und B,
A oder B nicht A oder A und Nicht A aussehen. So,
und das, was jetzt eben hier sich jetzt also aus dieser zeitlichen Verzögerung ergibt,
ist, dass man sagen kann,
wenn ich so ein Impulsdiagramm erstellen soll,
wenn ich damit also jetzt irgendwie arbeite,
wenn danach gefragt ist in irgendwelchen Übungsaufgaben,
dass man sich quasi immer anguckt,
wie sind die Werte in diesem Schritt hier oder zu diesem Zeitpunkt,
also beispielsweise A ist 0 und B ist
Und das wäre dann eben der entsprechende Wert, ein Raster weiter.
Das heißt, hier habe ich dann eben als Ausgangswert hieraus ergebend den Wert null.
Deswegen haben diese ganzen Impulsdiagramme am Anfang dann immer auch diesen zuhörenfarbigen Carsten,
der also letztendlich sowas wie ein Undefiniert zeigen soll,
also nach Motto,
da habe ich zwar einen 1 oder einen 0 rein technisch gesehen,
wo es dieser Wert hier würde sicher ergeben,
aus dem Wert DNA quasi hier hat und den wir
hier hat
Deswegen ist hier dann immer dieses Ziernfarbige,
das ist so ein bisschen hart, das motiviert war,
da ist es dann eben auch immer so ein undefinierter,
so farbig gekennzeichnet.
So, ansonsten ist das also wirklich immer straightforward entsprechend abzulesen.
Wie gesagt, ganz einfach solche Sachen, wenn ich hier
habe A. Und hier nicht ahne ich, dann entspricht das.
Also letztendlich nichts anderem als diesem Verlauf einmal gespiegelt und um einen
nach rechts verschoben und hier vorne habe ich da jetzt eben noch keinen Wert.
Also das heißt also aus Dieser Null ergibt sich diese Eins aus der Eins,
ergibt sich hier einen Tag später die Null und so weiter.
Das heißt also, dieser Verlauf ist genau dieses hier. So,
was ich jetzt aber aus dem Zeitlichen heraus ergibt,
wenn ich jetzt eben mit solchen Verzögerungen arbeite, ist folgendes,
wenn ich jetzt also hier als Ausdruck bilde,
A und Nicht
A. Was wäre dann letztendlich
der Wert
Aus der Bulschen Algebra weiß ich A und Nicht A, ist eigentlich immer Null. So,
wenn ich das jetzt hier aber einmal durchspiele, kommt wirklich das raus,
dass also hier zwischenzeitlich mal werde von eins auftauchen,
nämlich beispielsweise dadurch,
dass Nicht A ja quasi hier um einen verzögert ist,
dass ich diese eins hier ergibt daraus,
dass A schon auf eins gewechselt hat
Nicht A, aber ja auch erst einen Tag später,
dadurch auf Null wechselt. Das heißt, Kia,
dieser Wert ergibt sich aus dem Wert von Nicht A und dem Zugehörigen Wert von A.
Und dann habe ich eben sehr wohl am Ausgang mal zwischenzeitlich
so eine Eins mit drin. Ja, und wie gesagt,
das kann man je nach Schaltung dann eben in unterschiedlichen Varianten provozieren.
Das heißt, durch dies Einführen von Zeit habe ich dann
eben auf einmal in mein Schaltfunktion oder in meinen Schaltnetzen eben zwischenzeitlich,
also irgendwie solche falschen Werte.
Das Ganze nennt sich dann eben Hazard. Das heißt,
nicht im Englischen Glitch, das heißt eben, dass bei,
abhängig von der Funktion der Schaltung, nicht und abhängig davon,
welche Eingänge oder was sich ändert,
eben zwischenzeitlich,
also auch mal irgendwie falsche Werte oder Sachen
auftauchen können
Das lässt sich nicht vermeiden. Das haben alle unsere Schaltungen,
das haben alle Rechner, das haben alle CPUs.
Da kommen zwischenzeitlich, wenn da zwei plus dreimal gerechnet wird,
kommt da eben zwischenzeitlich meinetwegen auch mal 25 raus.
Bloß irgendwann nach einer gewissen Zeit habe ich dann eben wieder
das richtige Ergebnis, die fünf.
Und hoffentlich warte ich dann eben auch lange genug,
um dann eben mit diesem richtigen Ergebnis mit der Fünf weiterzurechnen und nicht mit irgendwas,
was ich dann also zwischenzeitlich durch so ein Hazard heraus ergibt.
Das ist also auch der Grund, weswegen CPUs eben eine bestimmte Tagfrequenz typischerweise haben.
Und man kann die noch so ein bisschen höher setzen und so
ein bisschen irgendwie dran drehen mit einigen Tricks da rein. Irgendwann ist es aber eben so,
dass beim Übertakten einfach eben folgendes zum Tragen kommt,
dass ich eben genau solche Effekte habe, dass ich irgendwo Hazards,
die in der Schaltung immer drin sind, die sich nicht vermeiden lassen,
die einfach über das Zeitverhalten kommen, sich eben so auswirken,
dass wenn die Taktperiode zu klein ist,
dass sie dann also auf einmal bei so einem falschen Wert, bei so einem Glitch Quasi das Ergebnis Speicher und damit weiterrechne.
Und dann würde meine Schaltung nicht mehr funktionieren,
beziehungsweise formal gesehen habe ich dann eben so etwas wie ein Hazard-Fehler.
Das heißt, das kommt dann eben zu einem Fehlverhalten. Gut,
dieser Hazards kann man unterscheiden in statische und dynamische Hazards,
statische Hazard, das war das,
was also gerade eben bei dem A und Nicht-A aufgetreten ist.
Also der Ausgangswert soll sich eigentlich nicht ändern.
Zwischenzeitlich taucht aber mal irgendwie so ein falscher Wert auf,
ein dynamischer Hazard wäre,
wenn sich der Ausgangswert von 0 nach 1 ändert
Was aber passiert ist, dass er sich eben nicht nur einmal ändert,
sondern zwischenzeitlich so ein paar Mal hin und her wechselt.
Das wäre dann also die Unterscheidung in statisch und dynamischer Hassatz
, Beispiele folgen gleich dazu.
Und dann gibt es noch Unterscheidungen in Strukturhassatz und Funktionshassatz,
die sich also einmal ergeben, wie die Schaltung aufgebaut ist.
Strukturhassatz, die kann man teilweise noch so ein bisschen funktional angehen oder da,
also was gegen machen, Funktionshassatz sind Hassatz,
die haben alle Schaltungen,
da kann man also auch nichts weiter
gegen machen
Beispiele, wie gesagt, folgen jetzt gleich. Hier erstmal die Veranschaulichung,
was sind statische, was sind dynamische Hazards,
also ein statischer Nullhazard wäre,
das Ergebnis soll die ganze Zeit konstant Null sein,
es taucht aber mal so ein Spike auf,
das war ihm genau dieses Beispiel mit dem A und nicht A,
statischer Eines Hazard,
genau das Gegenteil,
ein dynamischer Nullhazard ist der Ausgang soll von Eins nach Null wechseln,
macht das aber gegebenenfalls mehrfach und beziehungsweise umgekehrt Wechsel von 0
nach Eins wäre dann ein dynamischer Eins Hazard
Nur als Hinweis, weil da bin ich also vor
ein paar Jahren dann selber auch mal drauf reingefallen.
In der Literatur ist es immer so, dass der eine Autor
das so beschreibt, der andere Autor das so beschreibt.
Also dass wir das jetzt hier klassifiziert ist mit 0 und 1 Hazard,
entspricht eigentlich dem, was, sagen wir jetzt,
größtenteils in der Literatur jetzt also zu Rechnerstrukturen irgendwo so mit drin ist.
Nicht, wo man dann eben immer sagt, den,
in Anführungszeichen, richtigen Wert, das ist das, was ich hiermit beschreibe.
Das heißt also, es soll hier eine Null rauskommen,
es soll hier eine Eins rauskommen, nicht in dem Zufolge,
werden die dann als Null und als Eins-Haser klassifiziert.
Und zwischenzeitlich kommt das andere. Teilweise finden sich aber eben auch Beispiele,
wo dann also hier diese Benahmsung umgekehrt wäre,
da wäre sowas dann hier, nämlich ein Eins-Hasard,
wo dann also quasi der Name sich dann also aus diesem falschen Wert heraus ergibt.
Also das nur als Hinweis, aber wie gesagt, das Ist,
man ist hier jetzt in den Folien und wenn das also auch weiter benötigt wird,
dann eigentlich immer so gemeint,
dass dann also quasi wie hier der richtige Wert die Bezeichnung für den Hasatan letztendlich beschreibt.
Gut, Struktur Hasat ist jetzt eben etwas,
wo im Prinzip der Hasat durch die Schaltung hervorgerufen wird, wie die aufgebaut ist.
Der tritt eben auch auf, haben wir eben auch schon als Beispiel,
wenn sich also auch nur eine einzige Variable ändert.
Also hier als Beispiel jetzt, dass es für Einshazard,
nicht A oder A und A. Und ich habe also hier beispielsweise so einen Wertewechsel,
dass dann also im Ergebnis zwischenzeitlich mal eine Null auftaucht. Wodurch passiert das? Dadurch,
dass in diesem Fall letztendlich das dieses Nicht-A quasi schneller aktiv wird,
das heißt,
wenn der Wert von Null nach Eins geht und der hier schnell quasi am Ausgang eine Null erzeugt und schneller ist,
als dieser Ausdruck hier,
der letztendlich dann also quasi oder einfach nur das A wäre,
dass das dann dazu führt,
dass ich hierüber erst eine Null habe und erst später,
der hier dann eben entsprechend wechselt von 0 nach 1 und erst wenn diese spätere,
dieser spätere Wechsel hier stattgefunden hat,
dann eben wieder
das richtige Ergebnis anliegt
Gut, bei seinen Struktur-Hassers, die kann man eben
häufig durch eine Modifikation der Schaltung beseitigen. Gut,
also in diesem Fall würde man also diese Schaltal-Gebranchen-Ausdruck minimieren und sagen,
okay, da kommt halt immer eine Eins raus.
Im Prinzip passiert das aber eben auch bei anderen Beispielen. Gut,
auch dazu gibt es dann also hier so ein Tal in Hades,
wo man das Ganze sich dann also nochmal in der Simulation aussehen,
ansehen kann.
Also jetzt für diese ganz einfachen Struktur, Hazard
Nicht wo ich jetzt,
also wenn ich jetzt das beispielsweise hier wie ändere,
zwischenzeitlich mal eben hier das Ergebnis dann eben nicht die ganze Zeit konstant eins ist,
sondern zwischenzeitlich dann,
also zumindest bei dem Einwechsler mal eine Null auftaucht und wie gesagt,
man kann das dann noch künstlich durch entsprechend größere Verzögerungen
machen,
dass das dann eben entsprechend lange dauert
Ist dann also hier irgendwie der richtige Wert dann wieder da ist.
Gut, hier sieht man das Ganze dann eben auch nochmal in so einer Form von Impulsdiagramm. Auch das,
nur auch als Hinweis, auch das hatte ich jetzt noch nicht vorgestellt,
kann man sich direkt in Hades ansehen,
weil dazu kann ich dann eben auch sagen,
ich habe hier jetzt irgendwie mein Signal,
kann hier Jetzt von einem Signal, also beispielsweise,
wenn ich jetzt hier dieses Ausgangssignal nehme, sagen,
at probe, dann wird das ja sie quasi entsprechend mitgeträgt.
Nicht das Ganze kann ich dann also hier beispielsweise jetzt
auch von dem Ahrgangssignal machen. So, und dann könnte
ich Simulation zurücksetzen. Einmal neu starten und anhalten. Und
wenn man sich jetzt also hier diese Way-Forms dazu ansieht,
Dann sollte da eigentlich jetzt der Effekt hier irgendwo sichtbar sein.
Das ist natürlich wieder der schöne Vorfall-Effekt,
also Simulator
nochmal zurücksetzen
Nochmal neu starten, anhalten. Ach so. Zurücksetzen,
so. Starten, laufen lassen. So, und dann
sollte ich hier natürlich das Ganze einmal irgendwie ausgelöst haben.
So, das war natürlich der Fehler. So, so
ein Fitry Load. So, und dann sieht man hier,
dann nimm ich entsprechend dann also dann auch als Way Form,
wie sich das Ganze ändert.
Also in diesem Fall also hier die Änderung des
Eingangssignals von 1 nach 0 und dann eben hier entsprechend dieser
Hazard an diesem Netz, N6, Eingangssignal war in 7.
In diesem Fall sind das jetzt natürlich noch keine sprechenden Namen.
Ich kann den Netzen hier auch noch Namen geben,
dann würde ich das also hier also auch noch entsprechend oder direkt unter den Namen ein bisschen anschaulicher sehen. Gut,
das heißt also darüber kann man dann eben mit diesem Simulator sich das Ganze dann eben auch nochmal mit solchen zeitlichen Verzögerungen ansehen,
wo man dann eben sieht, wie sich Hersatz auswirken,
kann man dann eben wirklich bis in Extrem machen,
wo ich dann also beispielsweise über so eine Kette von Nant-Guttern dafür sorge,
dass also hier der Reihe nach so eine ganze Folge von Hazards generiert wird,
die sich dann eben erst, wenn alles durchlaufen ist,
entsprechend beruhigt.
Das wäre dann dieses hier, wo ich dann eben sage,
wenn Ich also hier den Wechsel habe,
dass dann eben erst mal ein ganzer Satz von Hazards gestartet wurden,
dass hier ein paar Mal blink bist,
dann eben der richtige Wert am Hausgang und passend wieder anliegt.
Gut, das wäre dann also dazu das Entsprechende Impulsdiagramm,
wenn man sich das dann eben entsprechend mit anzeigen lässt.
Gut, wodurch sind Strukturhazards, wenn ich jetzt,
also sag mal jetzt nicht solche trivialen Funktionen habe,
die ich dann sowieso zu 1 oder 0 irgendwie minimieren kann,
wodurch sind Strukturhazards
letztendlich gekennzeichnet
Nehmen wir jetzt wieder Funktionen im KV-Diagramm. Ich habe hier
eine Funktion X2 und X1 nicht oder X1 und X0. Also
im Prinzip hier in disjunktiver, minimierter Form, diese beiden schleifen.
Und ich habe einen Übergang jetzt von dem Vektor 101,
also X2 X1,
nicht X0,
also dieser Stelle nach X2 X1
Entsprechend dann nach dieser Stelle eigentlich hier rüber. So,
wie man jetzt sieht, würde, wenn sich jetzt dieser Wert ändert,
also X1 von 0 nach 1 wechselt,
sollte der Ausgang gleich bleiben.
Was aber hier rein technisch gesehen passiert, ist,
dass einmal die einsamen Ausgang aus diesem Therm heraus erzeugt wird
und einmal die Eins im Ausgang aus diesem Therm
heraus erzeugt wird
Nicht. Und wenn jetzt also quasi dieses und,
Kater und dieses und Gatter, unterschiedliche Schaltzeiten,
unterschiedliche Verzögerungen haben, kann es eben sein,
dass bei dem Wechsel von hier nach hier letztendlich dieses Gatter erst abschaltet,
eine Null erzeugt, bevor dieses Gatter hier anschaltet und wieder eine Eins erzeugt.
Und dann habe ich in diesem Fall dann einen statischen Eins-Hasar,
nämlich der Ausgang sollte eins bleiben.
Zwischenzeitlich ist aber mal so eine Null aufgetreten
Nicht, dass wir jetzt also hier das Ganze in der
Simulation einmal kurz gezeigt mit den entsprechenden Probes hier angezeigt,
wo man dann irgendwie für die Funktion elf dann mal kurz diesen Wert null hier im Ausgang sieht.
Also wie gesagt, sowas kann man sich dann eben auch immer entsprechend
mal schnell mit Hades aufbauen, durchsimulieren, möchte ich damit zeigen.
Gut, in dem Fall kann ich jetzt natürlich sagen,
okay, wenn ich mit diesem Strukturhase nicht leben kann,
kriege ich den so rum gesehen natürlich noch weg,
indem ich da jetzt sage, ja, was eigentlich kontraproduktiv ist.
Also vorher habe ich meine Schaltfunktion genommen, KV-Diagramm,
habe die minimiert, um dann möglichst wenig Gattern,
möglichst wenig Aufwand, das Ganze zu realisieren.
Jetzt störe ich mich also auf einmal an dem Hazard,
der da auftritt. Jetzt kann ich natürlich sagen,
okay, ich füge jetzt einfach nochmal einen Schaltagabbau schon aus,
so, nämlich also hier diese grüne Schleife mit hinzu,
die dann dafür sorgt, was letztendlich über diesen Therm hier,
wenn ich also diesen Wechsel habe, konstant immer eine Eins erzeugt wird.
Das heißt, damit habe ich natürlich dann in dem Fall diesen Strukturhazard beseitigt,
Aber was in diesem Fall dann natürlich kontraproduktiv ist,
ich habe deutlich höheren Hardware-Aufwand, als jetzt bei so einer minimalen Realisierung.
Also das ist eigentlich erstmal das, was zu Strukturhassatz
zu sagen ist. Wie gesagt, in diesem Fall,
Strukturhassa hat dadurch hervorgerufen, dass sich eine einzige Eingangsvariable ändert.
Gut, wenn ich das jetzt hier aber mache,
hier die Simulation dazu, wunderbar, es taucht kein Hasan mehr auf.
Was ich nicht loswerde, sind sogenannte Funktionshaseharz,
nämlich Sachen, wo sich Zwei Eingangsvariablen beispielsweise ändern.
Sprich, deswegen der Name Funktionshasar,
das Ganze ist eben eine Eigenschaft, der Schaltfunktion selber.
Und das kann ich also auch durch Einfügen zusätzliche Schleifen oder
was weiß ich was nicht wegkriegen.
So, also ich bin wieder an dieser Stelle 101.
Und zwei Angangsvariablen ändern sich, nämlich X1 und X2.
Das heißt, ich gehe, also auf dieser Stelle hier
So, und das, was hier jetzt natürlich passiert,
ist, dass sich bei diesem Wechsel von hier, nach hier im KV-Diagramm quasi,
ja, von dieser Schleife hier in diese Schleife hier reinlaufe.
Was aber im Zweifelsfall nie stattfinden wird, ist,
dass ich dann eben wirklich eine absolute Gleichzeitigkeit oder Gleichartiges Verhalten in diesem Wechsel an den Eingängen haben werde. Das heißt also,
selbst wenn die Verzögerungszeiten dieser Gatter die diese Schleifen erzeugen,
identisch sind, werde ich rein technisch gesehen, dadurch,
dass ich X2 und X1 nie wirklich gleichzeitig ändern,
eben entweder hier rüber laufen,
dann habe ich keinen Hazard oder ich werde hier rüber laufen über diese Null,
nämlich wenn sich also erst X2 ändert und dann X1 und dann habe ich immer einen Hazard und den kriege ich also auch nie weg.
Das heißt, also diese Funktionshazarz ergeben sich jetzt also wirklich
aus der Funktion, aus den Schaltfunktionen, mehrere Eingangsvariablen ändern sich
Und demzufolge kann es dann eben immer sein,
dass ich, weil die sich dann nie gleichzeitig ändern,
dass ich dann eben zwischenzeitlich,
also jetzt aus meiner Schaltfunktion irgendwelche Werte erhalte,
die dann quasi hier so gar nicht richtig sind oder gar nicht mit drin sind.
Nicht, dass das auch nochmal so einer der Gründe,
weswegen eben so bei einigen Sachen sowas wie einschrittige Codes ganz nett sind,
also wenn ich jetzt sowas wie zum Beispiel mir wie ein Zähler denke,
nicht beim allenschrittigen Code,
ändert sich nur genau ein einziges Bild,
da habe ich so
eine Situation nicht
Wenn ich binär zähle und sage, ich gehe von drei nach vier,
habe ich 0-1-1,
vier wäre 1-0-0,
dann ändern sich also in diesem Fall dann schon drei Bit.
Nicht, das heißt, da werde ich immer sowas,
weil diese drei Bits sich natürlich nie hundertprozentig gleichzeitig ändern,
immer sowas wie Funktionshersatz dann mit drin haben,
wenn damit dann quasi mit diesem Zählerstand irgendwie weitergerechnet wird oder irgendwas damit gemacht wird.
Gut, also das erst nochmal im Hinterkopf mal zum Thema Zeitverhalten,
Wasser mit diesen Hasars auf sich hat.
Ja, und damit sind wir dann also auch pünktlich mit
diesem Kapitel soweit fertig. Dann kann ich inzwischen wieder aufmachen
. Jetzt ist die Sonne auch weg. Nein,
es ist noch ein bisschen Sonne draußen.
Wünsche ich allen ein schönes Wochenende und nächsten Mittwoch
sehen wir uns wieder