Vorgestern, als letztes dann also noch kurz die Grundidee zu Hardware multiplizieren vorgestellt,
wo man im Prinzip jetzt ähnlich wie bei der schriftlichen Multiplikation
eben im Prinzip über eine re-artige Struktur seine Multiplikanten eben entsprechend
aufaddieren kann und die dabei dann eben passend verschoben sind,
entsprechende Stellenwertigkeit.
Sehr gut, ja,
das hatten wir auch noch nicht
Ja, ich sag ja jeden Tag, also irgendwie Projektor einschalten,
hilft in diesem Fall. Sorry, das kommt davon,
wenn man also irgendwie spät dran ist, natürlich irgendwie hektisch alles aufbaut,
kann sich nur noch ein paar Sekunden handeln.
Gut, ich kann auch mal trotzdem weiterreden,
weil letztendlich gibt es da keine Neuphorie oder sowas.
Gut, also das hatte ich ja im Prinzip kurz vorgestellt.
Ansonsten gab es dann also mal jetzt
noch eine Hurra
Ähm, nachfolgend dann also nochmal eine Folie,
wo dann im Prinzip ein ähnliches Verfahren auch angesetzt ist,
wo man dann sieht, also wie man quasi jetzt,
das Umgekehrte, in dieser Phase jetzt hier eine Quadratwurzel berechnen kann,
zu zahlen.
Also auch das geht dann über solche rehaartigen Strukturen,
wo ich dann also Adir und damit arbeite.
Wie gesagt, also auch für einige andere Funktionen gibt es
dann eben entsprechende Spezial-Hardware. Aus Zeitgründen, das war eigentlich das,
womit ich jetzt letztes Mal aufgehört hatte
Gibt es da dann eigentlich jetzt also gerade bei diesem Bereich Multiplikationen dann auch relativ viel,
wo wir jetzt einfach mal vorher jetzt nicht darauf eingehen können,
beziehungsweise wo man dann also doch wirklich sehr stark ins Detail gehen würde.
Nicht, das sind einmal so Bereiche,
das nennt sich Bußkodierung, da geht es letztendlich darum,
dass man bestimmte Tricks anwendet, wo man sagt,
also anstatt mit einer Zahl zu multiplizieren,
die jetzt also aus einer ganzen Folge von Einsen besteht,
nämlich Eine Folge von Nullen und eine Stelle weiter eine Eins.
Das heißt, eine Um-eins größere Zahl und muss dann aber nochmal wieder einen abziehen.
Dadurch kann man dann aber eben teilweise auch Rechenschritte einsparen und das kann man dann also sowohl,
oder kann man in diesem Fall dann eben auch beim Multiplikanten,
also passend machen, das nennt sich dann als Bußkodierung als Idee.
Nicht für diese re-artigen Strukturen, das, was sich dahinter verbirgt,
das ist eine sogenannte Carrie-Safe-Adiera, das sind im Prinzip Adiera,
wo ich im Prinzip immer aus drei Eingangsvektoren Zwei Ergebniswerktoren,
nämlich in Summen und ein Übertrags, also ein Carry-Vector generiere,
der wird dann aber nicht schon dazugerechnet,
sondern wird dann irgendwie nur eine Stufe weitergereicht.
Und wie gesagt, also die Multiplikation von negativen Zahlen,
das heißt also, wenn ich jetzt eben mit einem Zweier-Kompliment rechne,
da muss man dann eben auch noch entsprechende zusätzliche Abfragen treffen bzw. zumindest an der obersten Stelle im Bett des Multiplizierers,
da dann also auch noch einige Sachen anders handhaben. Grundsätzlich,
wenn man Da also nochmal weitersehen will,
also im Prinzip in der Literatur, Arhythmetik in Rechenanlagen,
findet sich da dann also einiges an entsprechender Spezial-Hardware,
was jetzt auch nicht weiter behandelt wird, sind die sogenannten Coordic-Algorithmen,
basieren im Prinzip auch auf einer Grundidee,
wie ich sie also gleich noch beim Schieben vorstellen werde,
wo man im Prinzip über bestimmte Moltiplexer-Netzwerke einfach sagen kann,
ich kann eben um ein Bit, um zwei Bit,
um vier Bit,
also sprich immer um irgendwie zweier Potenzen schieben und wenn ich das Ganze geeignet beschalte,
erhalte ich dadurch dann eben ein beliebig konfigurierbaren Schiebealgorithmus.
Das ist also das, was ich gleich noch vorstellen werde.
Wenn ich das jetzt noch verbinde mit arrithmetischen Operationen,
Additionen und Subtraktionen und eben dieses Schieben,
dann kommt man eben zu dieser Klasse von Algorithmen,
wo man dann also auch bestimmte,
also gerade so Winkelfunktionen entsprechend mit behandeln kann.
Gut, jetzt habe ich hier noch einige weitere Allgemeine Schaltnetze,
wie man sie also dann eben auch häufig in Computerhardware noch findet.
Also wie gesagt, Schiebeoperationen kommt gleich noch.
Vorher nochmal sowas, was sich also Priority and Coder nennt
Das ist eigentlich auch ein Vergleichsweise einfaches oder einfaches Handhabbares Schaltennetz.
Wird zum Beispiel benutzt für sowas wie Behandlung von Interraprioritäten. Das heißt,
wenn ich in meinem Computersystem im Prozessor irgendwie sage,
aufgrund unterschiedlicher Bedingungen,
also ein Wort wird irgendwie im Speicher nachgefragt,
ist nicht im Cash, muss erst von einer Platte gelesen werden.
Es kommen irgendwelche externen Daten über eine beispielsweise USB-Schnittstelle rein oder
was auch immer, werden ja also laufend im Rechnerbetrieb
irgendwelche Interraps ausgelöst mit
unterschiedlich hoher Priorität
Wo man dann eben immer sagt,
der laufende Rechenweg wird für einen Interrab dann ihm quasi unterbrochen.
Und da gibt es dann eben noch unterschiedliche Prioritätsebenen,
wo man dann eben sagt, also irgendwas,
was also jetzt wirklich sehr wichtig ist,
also was quasi zum zentralen Betrieb des Rechners und zum Betriebssystem gehört,
ist natürlich also ganz anders priorisiert,
als wenn ich jetzt also irgendwie über die serielle Schnittstelle
eines Modems,
also irgendwelche Daten reinbekomme
Gut, und Priority and Coder ist dann im Prinzip etwas,
wo ich dann einfach eine NBit-Eingabe in eine Dualkodierung umsetzt in diesem Fall.
Von der Funktion her sieht das das eben so aus,
dass wenn ein Bit in aktiv ist,
also gleich eins ist, werden alle niedrigeren Bits ignoriert.
Und die Ausgabe des Ganzen ist quasi jetzt die duale Kodierung
der Stelle oder der Spits, wo die eins gesetzt ist.
Also sprich, als Priority Encoder mit vier Eingängen,
wo das eben so aussehen, dass wenn also beispielsweise X3 gleich eins ist,
ist es eben egal, wie die anderen Eingangswerte aussehen.
Nicht deswegen hier das Sternchen als Door Care. Und die
Ausgabe wurde dann eben quasi hier den Index 3 dieses Eingangs ausgeben.
In anderen Fällen oder im anderen Fall,
wenn der dann eben null ist,
der Index oder eben hier diese Interableitung 2 quasi aktiv ist,
ist es egal, was sich da drunter befindet.
Es würde als Ausgang dann eben quasi zwei ausgegeben werden und
so weiter und so fort
Was man hier auch noch sieht im Prinzip mit dieser Don't-Care-Beschreibung,
also letztendlich ist das Ganze unabhängig vom niederwärtigsten Bild.
Das heißt also, dies X-0 kann dann eigentlich auch rein logisch entfallen. So,
und wenn ich mir jetzt also hier diese Funktionstabelle nehme,
kann ich das natürlich also direkt einfach mit Bullshit al-gebytes irgendwie in so eine zweistufige Logik umsetzen,
beziehungsweise dies jetzt sogar als Mehrstufige Logik,
würde dann eben zu folgendem Schaltnetz mit entsprechender Funktion führen.
Hier sieht man das jetzt in einer minimierten Form,
wo eben dieser Eingang X.0 letztendlich wegoptimiert wurde,
wenn ich jetzt solche Prioritätsencoder eben auch noch brauche für deutlich mehr Interrapts,
könnte man sich dann eben noch so eine Lösung ausdenken,
wo man das Ganze und eben noch um zusätzliche Eingänge auch noch kasperdierbar macht.
Und dann wäre eben die Idee, dass man dieses X.0
dann eben auch noch quasi auskodiert und eben eine entsprechende Leitung für eine Kaskadierung vorsieht.
Und so lassen sich dann eben auch entsprechend noch größere Prioritätssynkoda,
also hier beispielsweise als 8 zu 3 machen. Gut,
wie gesagt, also die Grundfunktion ist eben einfach,
erst mal diese Maskierung in den Eingangsbit-Factor, wo ich dann eben sage,
wenn an einer bestimmten Stelle eine Eins da ist, wird alles da drunter maskiert.
Das Schieben oder ein arathmetisches Schieben würde man dadurch am günstigsten realisieren,
dass man sagt, also wenn ich jetzt Beispielsweise jetzt hier um 0 bis 3 bis Schiebe.
Ich habe jetzt eine Anzahl von Dateneingängen,
die ihr eine Anzahl von Daten ausgehen, QI,
dass man das also wie jetzt hier angedeutet,
also eine Kaskade aus 2 zu 1-Motiplexern aufbaut,
wobei ich dann eben immer sage, dass wenn ein Schiebebit nicht gesetzt ist,
wird eben der Eingang direkt weitergeleitet, wenn es gesetzt ist,
wird der Eingang eben quasi genau um ein kaskadiert weitergeleitet.
Das heißt, dann gehe ich eben genau hier auf diesen
anderen Eingang der nächst höheren Stufe und schiebe eben hier an dieser Stelle entsprechend eine Null rein.
Und mit der Kaskadierung arbeitet man eben so,
dass man eben in der ersten Ebene letztendlich genau um null oder um ein Bit schieben kann.
In der nächsten Ebene dann eben gleich um zwei Bit schieben kann.
Und wenn ich jetzt eben noch weiterschieben würde,
so wie das hier angedeutet ist,
Beispielsweise jetzt um maximal acht Bit, das heißt,
da baue ich dann eben drei Leitungen zum Dekodieren und einen dreistufigen Aufbau,
hätte ich dann diese Schaltung, die, wenn man sie jetzt in Hades simuliert, Gut sieht man hier so einigermaßen.
Gut, nicht, dann wäre das jetzt also hier die Schadung,
jetzt habe ich hier mal ein Witmus, da,
also hier die höheren, werdigsten Bits sind alle null,
dann 1-1, 0-1. Nicht das Ganze,
es wird jetzt hier um null verschoben, die umzufolge hätte ich das jetzt eben hier einfach nur eins zu eins zum Ausgang weitergeleitet.
Ich und der entsprechende Datenfahrt ist halt immer,
dass es der Eingang dann immer direkt weitergeschaltet ist,
ohne dass dort irgendwas geschoben wird. Denn wenn ich das Ganze jetzt eben um,
naja, das ist jetzt hier das höchstwertigste Bild,
so, also jetzt hier um einen schieben würde, Nicht,
dann würde ihm hier quasi in dieser ersten Schiebestufe dafür gesorgt,
dass das Ganze jetzt eben hier immer über diesen Weg einweiterläuft.
Wenn ich das jetzt also hier um zwei schieben würde,
würde es dann eben jetzt in dieser zweiten Stufe entsprechend hierhin weitergeschoben und so weiter und so fort.
Nicht drei wäre dann eben Kombination dieser ersten beiden Stufen
Beispielsweise Schieben um 4 wurde das Ganze dann
eben hier in dieser letzten Stufe hierhin bewegen. Gut,
und wenn ich jetzt eben noch weiterschiebe in diesem Beispiel,
sieht man dann eben auch wieder natürlich also hier irgendwelche höherwertigeren
Bits dann im Zweifelsfall dann auch hier aus diesem Ausgangswort rausfallen
Gut, dieses Grundprinzip, das Ganze nennt sich also Barrolshif da,
nur nochmal zum Begriff, stand da so gerade eben auch auf einer Folie mit drauf.
Also dieses Grundprinzip lässt sich dann eben genauso für alle anderen Schieberoperationen anwenden.
Ich hatte das jetzt quasi hier als ein Linksschieben beschrieben bzw. implementiert,
das geht aber eben genauso auch als ein Rechtsschieben,
wobei beim Rechtsschieben war ja die Sache,
da muss man dann eben unterscheiden, zwischen dem logischen Schieben,
wo im Prinzip dann also von links eine Null in das,
most significant bit reingeschoben wird und dem Arrogmetischen schieben,
wo ich dann eben dieses höchstwertigste Bit eben entsprechend vervielfachen muss.
Oder genauso würden sich dann eben auch irgendwelche Rotate-Operationen implementieren lassen,
wo ich dann quasi das Ergebnis oder das,
was also letztendlich rausgeschoben wird,
dann eben auf der linken Seite Start der Null
dann entsprechend da reinbringen würde
Wie gesagt, damit sind natürlich dann alle diese Schieberoperationen,
wie man sie jetzt eben auch aus den Programmiersprachen kennt und wie ich sie ja dann eingangs,
also auch gerade bei diesen ganzen Bit-Operationen auf der arrangmetischen Ebene vorgestellt habe, direkt in Hardware realisierbar.
Und man kann dann also wirklich in einem Takt um eine beliebige Wortbreite schieben.
Nachteil bei dem Ganzen ist, wenn ich jetzt sage,
ich habe also 64 Bit-Wortbreite und kann dort also wirklich,
also jede Art von Schieberoperation mit jedem beliebigen Offset implementieren,
dass das gar dann eben vom Hardware-Aufwand doch schon etwas umständlicher wird,
weswegen dann teilweise Prozessoren oder auch gerade einfachere Prozessoren,
wo man das also jetzt nicht direkt braucht,
dann eben wirklich nur Schiebeeinheiten, um einige feste Offsets vorgegeben haben.
Und wenn ich dann eben beliebige Schiebewerte mit angebe,
quasi jetzt in meiner Programmiersprache,
Has und Java oder C,
würde das dann quasi vom Compiler umgesetzt werden,
eben in eine Folge von Assembler befehlen,
die dann also quasi jetzt für diesen entsprechenden Befehlssatz
das Ganze implementieren kann
Gut, ganz allgemein gesprochen. Das,
womit natürlich jetzt also Computer irgendwo rechnen,
ist dann eigentlich das Zusammenfassen aller möglicher Operationen,
die ich jetzt also hier schon so vorgestellt habe, in eine Alu,
steht dann als Akronym immer für Arismatic Logic Unit oder Arimittisch logischer Einheit,
wo ich dann also eben sowohl Arithmetische Operationen, also Additionen,
Subtraktionen, aber eben auch irgendwelche logischen Operationen,
also Bitvises und oder exklusiv oder teilweise dann eben auch diese Schieberoperation dann eben direkt mit auswählen kann und zwischen denen unterscheiden kann.
In der Regel ist natürlich sowas wie so eine Alu dann eigentlich in Prozessoren,
die zentrale Recheneinheit, mit der dann eben wirklich die Hardware,
die entsprechenden Operationen ausführt.
Gut, je nach Typ hat man dann eben sehr unterschiedliche Funktionsumfänge.
Nicht das, was typischerweise eben vorhanden sind,
sind also natürlich, also Addition und Subtraktion im Zweier-Kompliment.
Wie ich ja letzte Vorlesung dann eigentlich auch schon gesagt hatte oder gezeigt hatte,
Brauche ich da jetzt keine Unterscheidung zwischen Scient oder Unsigned-Darstellung,
also sprich, ob ich jetzt mit Zweierkompliment oder nur mit normalen Enwiger-Zahlen rechne,
weil dadurch, dass ich das Ganze dann eben so erweitere,
dass man eben die Subtraktion direkt durch die Addition des Zweierkompliments ersetzt,
hat man dann eigentlich nur noch an der niederwärtigsten Stelle eben diesen Carry in und das entsprechende Bidvisor invatieren und hat das eigentlich dann in eurem Rechenwerk mit erschlagen.
Nicht, dann hat man typischerweise noch sowas wie
irgendwelche Bitweisen,
logischen Operationen
Also invertieren und oder X-Ohr,
was auch immer und ihm vielleicht irgendwelche Schiebeoperationen und gelegentlich dann eben noch sowas wie Multiplikation,
wobei Multiplikation dadurch dann schon immer rausfällt,
dass es meistens vom Hardwareaufbau oder von der Hardwarestruktur,
also schon so stark eigentlich von irgendwelchen anderen Operationen hier abweicht,
dass das dann meistens immer extra Rechenwerke sind,
die dann also in Hardware wirklich
eine Multiplikation vornehmen
Gut,
so war es wie eine Division oder eine Integer-Division,
selbst wenn man sich ja so auf diesen in Anführungszeichen einfachen Fall an der Integer-Division nur beschränkt,
sind dann eigentlich selten verfügbar,
weil da dann eigentlich vom Rechenwerk eben auch schon wieder so aussieht,
dass man das dann also,
wenn es da also überhaupt irgendwelcher Hardware-Werke gibt,
das dann also wirklich als separate Einheit einbaut
Gut, Addition und Subtraktion hatte ich ja eben schon gesagt,
da hat man dann eben in der Regel Addition exklusiv oder Garda zum Invertieren des Operanten B,
nicht mit der Steuerleitung,
wird das dann eben quasi aktiviert,
beziehungsweise dann wird dann eben entsprechend auch dieses Carry-In gesetzt und die Subtraktion wird dann eben letztendlich durch diesen Ausdruck ersetzt,
der dann also lässt im Prinzip Liebe schreiben und das Zweierkompliments ist und was sich also auch schon gezeigt hatte,
also damit lassen sich dann eben genauso gut auch Inkrement und Dekrementfunktion jetzt auf einem Operanten zeigen.
Wie gesagt,
diese eine Folie oder dieses Beispiel aus dem Schiff,
man schmilzt zeitlich ja nur vorgestern schon gezeigt,
wo man jetzt hier im Prinzip hier zwei Operanten A und B
hat und eben hier entsprechend mit diesem Vier-Bett-Rechen-Werk,
eine Addition ausführen kann und die Subtraktion dann eben dadurch macht,
dass sich das hier quasi mit Exklusiv-Oder-Gattern
mitweise invertiere und dadurch dann eben entsprechend die Subtraktion ausführe
Gut, das werde ich jetzt so sehen. Nicht nochmal aufrufen. Wenn man jetzt sagt,
ich möchte diese Alu jetzt eben nehmen und noch um irgendwelche Bitweisen-Operationen erweitern,
dann kann ich das natürlich straightforward machen und sagen,
naja gut, also ich nehme jetzt einfach hier diesen bestehenden Teil,
Addition, Subtraktion,
jetzt brauche ich also für irgendwelche Bitweisen-Operationen noch sowas wie ein Exklusiv-Oder,
oder unten und,
und baue dann quasi einfach als Paralleläste zudem hier eben noch so ein Bitweises,
exklusiv oder ein Bitvises oder ein Bitvises und ihm jetzt wirklich in Form von Gattern auf und habe dann eben hier am Ausgang der Schaltung eben einfach entsprechende Multiplexer,
wo ich dann eben sage,
ich nehme entweder das Ergebnis aus der Alu oder ich nehme das Ergebnis,
was also quasi jetzt hier aus diesem Ex-Ohr fällt,
aus dem oder oder aus dem und und kann damit dann eben die entsprechenden Funktionen,
die jetzt also hier unten aufgelistet sind,
direkt ausführen
Gut, das ist natürlich die Vergleichsweise trivial und aufwändige Realisierung,
dass man einfach jetzt eben entsprechend viele Parallele Rechenwerke für die Operation,
die man in seiner Alu implementieren möchte, direkt eins zu eins umsetzt.
Und dann eben über ein Multiplexer das passende Resultat auswählt.
In der Praxis sieht das so aus,
dass man dann natürlich noch versucht, das,
was jetzt eigentlich an Schaltnetzen hinter diesen Funktionen steht,
eben über eine entsprechende Bündelminiminiminierung so zu optimieren,
dass ich quasi dann eben über entsprechende Gatter,
die also hier sowieso schon irgendwo in dem Adierer mit drin sind,
dann eben bei passender Beschaltung von irgendwelchen Steuervariablen dann eben auch noch sowas wie eine Exklusiv-Oder-Funktion direkt ausführen kann.
Nicht, weil die beispielsweise hier schon irgendwo in der Berechnung der Summe
mit drin steckt. Nicht, das heißt, das,
was man da dann eben in der Regel macht, sind dann eben irgendwie passende Bündelminimierungen.
Also hier zum Beispiel, also auch so eines ICs aus der 74er-Wau-Reihe,
wo man dann eben über so eine Einfachere Realisierung,
also in einer ersten Stufe, irgendwelche einfachen Beweisen,
logischen Operationen und Komplimente bildet und dann eben eine zweite Stufe in diesem Fall jetzt also hier als Carillook Ahead Adira arbeitet.
Nicht, also sagen wir mal,
jetzt hier so eine Art Gatter-Realisierung ist jetzt natürlich nicht mehr so einfach,
irgendwie direkt von Hand zu entwerfen oder das mal eben also irgendwie so auf dem Papier sich zu minimieren,
aber im Prinzip könnte man sowas machen und Wie gesagt,
also früher als wirklich diese Bausteine so entworfen wurden,
als es da also auch noch vergleichsweise wenig Entwurfswerkzeuge gab,
die einen da also unterstützt haben,
hat man das dann eben auch entsprechend so gemacht.
Also so kann ich jetzt immer nur sagen, das,
was man hier letztendlich sieht, ist also irgendwo so ein buntes Sammelsurium von irgendwelchen Gattern,
wo dann also hier eigentlich angedeutet, auch nur zu sehen ist,
also eben so eine erste Stufe, also hier irgendwie sowas mit und,
und, oder, dass sie dann also quasi wie irgendeine disjunktive Form aus, wo jetzt also hier bestimmte Funktionen berechnet werden.
Und die werden dann also hier in dieser zweiten Stufe dann noch irgendwo jetzt mit weiter benutzt und jetzt sorgen dann diverse Ausgänge. Letztendlich das,
was bei den ganzen jetzt rauskommt, ist,
dass man sagen kann, ich habe dann hier vier Steuerleitungen,
mit denen man in diesem Fall jetzt also dann 16 unterschiedliche Funktionen sich erzeugen kann,
zusätzlich hier eben auch noch einen Kontrolleingang,
wo ich dann eben unterscheide zwischen logischen Funktionen und arathmetischen Funktionen Und damit erhält man dann eben wirklich,
sagen wir mal, so ein ganzes, so ein Syrium von Funktionen,
wo ich dann eben wirklich, also alle mitweisen,
logischen Funktionen von direkten, direkter Ausgabe von Konstanten,
also dann einfach den Wert Null und dem Wert 1,
einfach dem Weiterleiten von irgendwelchen Ausgängen,
aber dann eben auch den X-Or oder entsprechenden Unverknüpfungen,
ich dann eben diverse Kombinationen,
logischer Verknüpfung zwischen diesen beiden Vier-Bit-Werktoren habe und eben auch diverse adathmetische Funktionen,
mit denen man dann rechnen kann.
Und wenn ich dann sowas habe,
zum Beispiel, dann kann man damit dann eben wirklich,
nicht also in diesem Fall,
dass ich immer so einfach so durch das entsprechende Schalssymbol ergänzt,
dann eben so eine ganze Satz von Rechenoperationen mit dieser Vergleichsweise
einfachen Alu ausführen
Gut, Els,
weitere Idee, also dieses hier war jetzt eine 4-Bit-Arlo,
jetzt kann man natürlich sagen, na gut,
also damit kann man jetzt natürlich noch nicht so richtig weit rechnen,
nicht also selbst bei irgendwelchen kleinen Mikroprozessoren oder irgendwelchen kleinen Minimalbeispielen
möchte man natürlich irgendwie ein bisschen sinnvollere Wortbreiten haben,
als also irgendwie nur Zahlen von 0 bis 15 beziehungsweise von minus 8 bis 7 zu betrachten.
Dafür gibt es dann eben in diesem Fall jetzt also noch so einen zweiten Ship,
der dann es erlaubt, dass sich dann also quasi jetzt In diesem Fall jetzt drei von diesen vier Bit Alus nehme.
Dieser zweite Schritt ergänzt dann quasi die Carrioca-Head-Generierung,
die also hier dann schon drin ist,
eben noch um die notwendigen Stufen,
um aus dem Ganzen dann eben wirklich so eine Zwölf-Bit-Alu zu machen,
wo ich dann eben sage,
mit dem berechne ich dann eben die obersten Vier-Bit,
hier dann eben die nächsten vier und hier dann eben die niederwettigsten Vierbett.
Und damit lassen sich dann eben auch schon mit entsprechend größerem,
auch schon natürlich,
aber dann eben auch schon etwas größere Schaltung oder
größere Alu-Rechenwerke aufbauen
Gut. Ja, was ich bislang jetzt noch nicht angesprochen hatte,
bei dem Ganzen war ja irgendwo etwas, was ja dann also zumindest,
wenn man also zu realer Hardware übergeht und sagt,
also ich habe hier irgendwo ein Stück Silizium,
was also nachher so rechnen soll,
wie ich sie jetzt eigentlich mit dem zeitlichen Verhalten von irgendwelchen Schaltungen aussieht.
Ich war bislang hatte ich immer gesagt, na gut,
also man schaltet am Eingang was ein und Das pflanzt sich jetzt also
irgendwo durch die Gatta fort und ich habe dann am Ausgang passend jetzt mal ein Ergebnis.
Dazu werde ich jetzt also nochmal auf ein paar Folien,
sagen wir mal so, einige Grundideen vorstellen,
wo es also im Prinzip jetzt um die Modellierung von Zeit geht bzw. das Zeitfahrten von Schaltung,
weil das, was sie natürlich letztendlich physikalisch dahinter verbirgt,
wenn ich mir jetzt ansehe,
wie die CPU jetzt also hier meinetwegen in meinem Notebook irgendwo rechnet,
wo halt eben irgendwelche Spannungspegel zwischen 0 und 2,5 Volt irgendwie hin und her schalten.
Und das eine ist eine Null und das andere ist eine Eins,
wo dann also wirklich irgendwelche Ströme fließen und irgendwelche Kondensatoren umgeladen werden.
Da sieht es eben so aus, dass das Ganze natürlich dann,
wie man ja auch aus eigener Erfahrung weiß, nicht beliebig schnell geht,
sondern eben mit einer bestimmten Taktfrequenz, je höher, desto schneller.
Und die wird dann eben letztendlich dann auch vorgegeben über das,
was eben innen drin beispielsweise jetzt in der CPU an Gattern verbaut ist,
die dann irgendwo auch ein zeitliches Verhalten haben.
Das heißt also, der Ausgang schaltet eben nicht beliebig schnell,
sondern es dauert eben eine gewisse Zeit, bis sich da was tut.
In der Regel kann man, je nachdem,
wie detailliert man da das Zeitverhalten betrachtet, also sagen wir so unterschiedliche Abstraktionen unterscheiden.
Also alles, was ich bislang vorgestellt hatte,
beziehungsweise alles, womit man also ja auch bei,
oder ganz normal jetzt in der Algebra arbeitet,
sind jetzt eben wirklich direkte algebraische Ausdrücke,
wo ich also keinerlei Zeit verhalten habe
Dann kann man, sagen wir mal,
sowas wie so ein einfaches, fundamentales Modell nehmen,
wo ich sage, also jedes Gatter oder jeder,
jede Funktion hat halt eben eine bestimmte Einheitsverzögerung.
Nicht diese Einheitsverzögerung hat erstmal einen Wert.
Ciao. Und wenn ich zwei Gatter hintereinander geschaltet habe,
hat die eben die vierte oder hat das Ganze dann eben
die Verzögerung von Zweitau
Damit kann man dann also vergleichsweise einfach rechnen,
hat dann aber eben schon immer so eine Grundidee oder sowas eine grobe Vorstellung von zeitlichem Verhalten von Entscheidungen.
Das ist also auch das, was dann also nachher beispielsweise noch in den Übungsaufgaben mit benötigt wird. So,
wenn man das Ganze jetzt also noch genau unterscheiden möchte,
dann kann man dann eben sagen,
es haben nicht alle Gatter die gleiche Verzögerung,
sondern es gibt dann eben Unterscheidungen,
wo ich sage eben ein Nennt Gutra mit vier Eingängen,
hat er, hatte eben eine andere Verzögerung,
als jetzt also beispielsweise ein Inverter,
wo ich dann eben sagen kann,
abhängig von der Art der Schaltung habe ich dann eben individuelle Gartenverzögerungen.
Nicht, wo ich dann eben auch wirklich schon so ein bisschen genauer
die elektrischen oder die schaltungstechnischen Unterschiede zwischen den verschiedenen Garttern mit berücksichtigen kann.
Und das ist also beispielsweise auch das,
was man also in Hades ja direkt dann auch machen kann,
beziehungsweise was sich das dann auch gleich zeigen werde in den Beispielen. Ich hatte ja schon mal eingangs,
als ich also das Hades grundsätzlich vorgestellt habe, gesagt,
also dass wenn ich jetzt hier also irgendein Element,
also in diesem Fall nehme ich jetzt einfach mal hier diesen Multiplexer,
wenn man den jetzt eben oder von dem sich die Eigenschaften ansieht,
das heißt also einmal Kontextsensitivrechte Maustaste und in dem Menü dann eben das Edit wählt,
dann kriegt man dann eben quasi jetzt als Eigenschaft von diesem Multiplexe, also irgendeinen Bezeichner für die Instanz.
Gut, der interessiert nicht. Und dann gibt es aber
im Prinzip dann hier etwas, was sich Gate Delay nennt,
was dann eben einfach genau jetzt so eine Einheitsverzögerung für dieses Element ist.
Nicht in der Bibliothek von diesen ganzen Gattern sind diese Gate Delays
quasi alle identisch mit einem Wert irgendwie mehr oder minder sinnvoll vorbesetzt.
Das hat jetzt noch nichts mit irgendwelchen technischen Eigenschaften zu tun,
weil, wie gesagt, die sind da natürlich letztendlich davon abhängig,
mit welcher Technologie das dann auch wieder umgesetzt wird
Und da könnte man aber jetzt eben den einzelnen Garten dann,
wenn man das jetzt wirklich genauer modellieren möchte,
dann eben auch verschiedene individuelle Verzögerungszeiten zuweisen. Gut,
wenn man jetzt noch ein bisschen weiter in der Detaillierung runtergeht,
kann man sagen, das, was inzwischen eigentlich interessant ist,
also sind eigentlich gar nicht mehr die Garterverzögerungszeiten,
sondern Leitungslaufzeiten
Dazu werde ich also auf der nächsten Folian gleich noch mal ein bisschen was vorstellen,
weil da hat uns inzwischen Moas Law,
also auch wieder relativ beeindruckend, erwischt,
weil,
sagen wir mal,
so bis zu einer Größenordnung von Mikrometerbereich in den kleinsten Strukturen war es eigentlich immer entscheidend,
wie groß die Gata-Verzögerungszeiten sind und alles,
was also in dem Ship oder nachher in der Implementation an Leitung
dazwischen war,
war vernachlässigbar
Inzwischen ist es eigentlich so, dass die Gatterverzögerungszeiten,
also seit Submikrometer-Bereich, also sprich so,
ich sag mal so, ja, mit den 90er-Jahre,
sieht das eben so aus, dass eigentlich die Gatterverzögerungszeiten,
also deutlich kleiner sind,
als diese Leitungslaufzeiten und es eben wirklich entscheidend nachher ist,
wie wirklich nachher auch im Layout die Leitungen gelegt sind,
was sich dort auswirkt
Das heißt, wenn man das jetzt also eigentlich wirklich noch genauer modellieren möchte,
also der Einfachheit halber rechnen, wie jetzt immer noch mit Gatterverzögerung,
aber wenn man das wirklich genauer modellieren möchte, müsste man eigentlich sowas wie Leitungslaufzeiten berücksichtigen.
Und wenn man das also ganz genau haben möchte, dann müsste man sich wirklich ansehen, wie sieht das Ganze schaltungstechnisch aus. Das heißt,
da kann ich jetzt nicht mehr sagen,
ich habe hier irgendwie einen Gatter,
also ein Inverter und dessen Ausgang geht,
also meinetwegen jetzt an den Eingang A eines Nancutters,
sondern dann müsste ich mir jetzt wirklich auch ansehen,
welche Transistoren sind da wie miteinander verbunden,
mit welchen Metalllagen,
wie lang sind dann eben die Leitungen aufgrund dieser Leitungslänge,
kann man dann quasi so als Ersatzschaltbild dann auch so was wie eine Kapazität extrahieren und das Ganze führt dann also zum relativ großen und aufwendigen elektrischen Schaltnetz,
was man dann letztendlich über einen analog Simulator berechnen könnte bzw. simulieren könnte,
wo ich dann eben sage,
also meinetwegen der Ausgang dieses Nantgutters schadet dann eben von 0 nach 1 und wie wirkt sich das jetzt da an dem Eingang aus?
Und das führt dann dazu, dass also rein mathematisch gesehen man dann,
also so einen ganzen Satz von Differenzialgleichungssystemen erhält für Spannung und für Ströme,
die man dann eben entsprechend lösen muss. Gut,
das ist etwas, was wir jetzt also hier,
ich sag mal, glücklicherweise gar nicht mehr machen,
weil das ist also dann etwas,
was eben in dem Bereich der Elektrotechnik fällt, beziehungsweise als Physiker,
wenn sie da, wer also neben Verphysik hat,
da dann also vielleicht nun mal drüber stolpern.
Also wie gesagt, das sind dann entsprechend spezielle Sachen.
Gut, ich hatte ja schon gesagt, Kartoffelzögerung beziehungsweise Leitungslaufzeiten.
Also die Grundidee, wie gesagt, war früher waren die Gartaverzögerungen eben deutlich größer als die Leitungslaufzeiten.
Inzwischen ist es eigentlich umgekehrt. Nichtsdestotrotz werden wir eigentlich immer noch jetzt,
also hier auch mit dem Hades, also erstmal damit arbeiten,
dass wir jetzt ersatzweise quasi die Schaltung,
immer noch durch Gatterlaufzeiten modellieren,
wenn man da jetzt also irgendwo Zeiten betrachten, nicht weil,
also auch da kann ich natürlich sowas wie so eine Annahme machen,
indem ich dann einfach sage,
irgendwelche Leitungslaufzeiten schlage ich einfach hier auf das Gatter mit rauf und tue dann eben so,
als ob das dann eben zusätzlich nur entsprechend langsamer wäre.
Auch dazu gibt es dann also hier noch so ein entsprechendes hartes Beispiel Nicht,
also wie gesagt, mit dem Leitungslaufzeiten ist jetzt eben wirklich gemeint,
dass ich eben von einem Punkt der Schaltung hier zu irgendeinem anderen Punkt gehe,
Leitung,
ein Stück Leitung dazwischen habe und man sich das also wirklich so vorstellen kann,
dass wenn ich hier am Allgang umschalte,
das eben nicht beliebig schnell läuft,
sondern sich dann eben auch so schrittweise über die Leitung
entsprechend fortpflanzt
Im Gegensatz dazu, Gattaverzögerung, wie gesagt, dass man eben sagt,
Eingang ändert sich und das Gatta hat dann eben eine bestimmte Verzögerung,
bis sich dann der Ausgang ändert.
Gut, und wenn man das ihm genau nimmt,
wäre es dann immer jeweils eine Kombination aus beidem.
Nicht, womit ich das dann eben wirklich entsprechend genauer berücksichtigen müsste.
Aber wie gesagt, also das ist immer davon abhängig,
also jetzt vom Abstraktionsgrad Weswegen untersuche ich jetzt die Schaltung und kann ich
eben mit entsprechend vereinfachten Modellen leben oder muss ich da jetzt eben etwas genauere Modelle nehmen,
wo ich dann eben noch Leitungsverzögerungen zusätzlich mit berücksichtige.
Wummelt es dann aber eben auch möglich ist,
also wirklich auch mit so einem Digitalsimulator,
was sich dahinter ja verbirgt, so zu tun hat,
ob die Schaltung jetzt eben irgendein analoges Verhalten hat,
wo jetzt eben der Reihe nach quasi jetzt eben aufgrund hier
einer Spannungsänderung sich eben der Impuls quasi fortpflanzen würde.
Gut, hier habe ich jetzt nur noch mal eine Folie rausgesucht,
die ist also auch schon etwas älter, Ende der 90er Jahre.
Auch von so einem Konsortium, was also Zusammenschluss der Shiphersteller ist,
wo eben noch mal, also genau diese Idee oder Grundsortidee jetzt,
also von diesen Gatterverzögerung und den Leitungslaufzeiten aufgezeichnet ist,
abhängig jetzt oder in Relation hier zu der Strukturbreite,
weil wie gesagt, also das ist jetzt hier von
1997. Ich hatte ja eben schon gesagt, also Mitte der 90er Jahre
ist man also in einem Bereich unterhalb von einem Mikrometer gegangen.
Ich finde, hier haben wir jetzt also im Prinzip gerade so
den Schritt aufgezeichnet von 650 Nanometer bis zu 100 Nanometer runter. Und das,
was also beispielsweise jetzt hier diese schwarze Kurve ist,
ist eben dann wirklich die Gatterverzögerungszeit, wo man dann eben sieht,
also je kleiner die Strukturen werden,
starte ich dann eben hier irgendwo im Bereich von 17 Pico-Sekunden
und irgendwie wird das Ganze dann eben immer schneller und ich lande dann eben,
also meinetwegen jetzt, also hier irgendwie so bei drei Pico-Sekunden.
Toll, wunderbar. Auf der anderen Seite habe ich aber eben den Effekt,
dass mit immer kleiner werdenden Strukturen,
was also entsprechend jetzt entweder diese rote oder diese Blaulinie sind,
die Leitungslaufzeiten, die jetzt also quasi hier immer noch vernachlässigbar klein sind,
eben immer größer werden
Je nachdem, ob ich das jetzt also für Aluminium oder für Kupferleitungen betrachte,
haben die dann eben auch noch entsprechend unterschiedliche Eigenschaften.
Und man kann dann also auch noch mit einigen anderen technischen Tricks da also auch noch mit einwirken. Interessant oder das,
was eigentlich jetzt Aussage von dem Ganzen ist,
ist aber eben, dass man eben sieht,
quasi in der Summe, das heißt,
die kleiner werdenden Gatterlaufzeiten und die immer größer werden in Leitungslaufzeiten,
hat man dann eben so ein Verhalten,
wo also die Schaltung erst irgendwie immer schneller oder virtuell gesehen
immer schneller geworden sind,
dann aber eben durch die steigenden Gatterlaufzeiten letztendlich immer langsamer werden
Inzwischen sieht das so aus, also heutzutage aktuelle Prozessoren oder aktuelle Schaltungen,
die jetzt also gerade so Bleeding-Edge-Fertigung sind, sind also jetzt nicht,
also hier hört das bei 100 Nanometern auf.
Zurzeit ist man jetzt also im Bereich von 28 beziehungsweise 22 Nanometern.
Das heißt, da hat sich dann also auch nochmal einiges getan.
Gut, aufgrund anderer Tricks konnte man da noch einigermaßen entgegenwirken,
weil letztendlich muss man auch immer sagen,
es kommt immer darauf an, wie lange die Leitung sind.
Wenn ich jetzt also quasi nur benachbarte Gatter habe und einen
Ausgang eines Inverters in ein, meinetwegen und Gatter reingeht,
das direkt daneben liegt, da habe ich eine sehr kurze Leitung.
Wenn die Strukturen immer kleiner werden und die Gatter also quasi zusammenschrumpfen,
schrumpft auch der Abstand zwischen diesen beiden.
Das heißt, bei diesen lokalen Leitungen erreiche ich es,
dass also quasi dieser Effekt mit denen immer langsamer werdenden Leitungen da noch nicht zuschlägt.
Problem ist aber immer, dass globale Leitung, das heißt also Leitungen,
die dann also wirklich von einer Ecke des ICs zur anderen Ecke gehen,
also sowas wie zum Beispiel Taktleitung,
dass man da dann eben wirklich Probleme hat.
Und gerade beim Takt ist es eben so, dass inzwischen,
also bei aktuellen Tagtraten oberhalb von 3 Gigahertz,
also es eben nicht mehr möglich ist,
also innerhalb eines Taktes,
ein Signal von einer Ecke des Chips auf die andere Ecke
des Chips
zu kriegen
Gut, also das nochmal so ein bisschen zum technischen Hintergrund,
beziehungsweise das habe ich dann gleich auch nochmal zwei Motivationsfolien. Wie gesagt,
bei dem, was wir jetzt betrachten oder was jetzt,
also auch hiermit Hades gemacht wird, da gehen wir eben immer davon aus,
dass wir einfach jetzt nur mit Gartenverzögerung arbeiten und diese Gartenverzögerung dann also letztendlich irgendwelche Vielfache so einer Grundverzögerung, 1000.
Also man rechnet häufig bei dieser ganzen Skalierung immer mit irgendwelchen Größen Tao Alpha,
was weiß ich auch immer, wo ich dann eben sagen kann,
okay, wenn ich jetzt von einem Prozess,
meinetwegen 45 Nanometer Prozess zum nächst kleineren 35 Nanometer Prozess übergehe,
dann kann ich eben quasi alle Größenordnungen,
das heißt, wie groß irgendwelche Strukturen sind,
ja immer um einen konstanten Faktor skalieren,
deswegen rechnet man dann immer quasi gerne mit irgendwelchen Grundwerten
und dann irgendwelchen Skalierungsfaktoren,
an denen man dann eben einfach
nur drehen kann
Gut, Leitungslaufzeiten werden wir jetzt also letztendlich immer ignorieren,
was man dann in der Praxis eigentlich auch immer noch braucht,
was wir jetzt hier auch nicht weiter betrachten,
sind jetzt eben noch diese Gatterabeingegenschalzeit,
wo ich eben abhängig von der Funktion unterscheide,
dass ich beispielsweise in Wärter zeitlich gesehen anders verhält als nennt,
Gatter oder Norgatter, was man dann auch noch hat,
unterschiedliche Schalzeiten, also sprich,
ob ich am Ausgang von 0-0 nach 1 oder von 1 nach 0 umschalte,
auch das kann unterschiedlich schnell passieren, Unterschiede,
je nachdem, ob ein Gatta eben zwei,
drei oder vier Eingänge besitzt und eben Unterschiede,
die sich also aus der Struktur der Schaltung ergeben oder aus der Struktur des Schaltennetzes,
wo ich dann eben sage,
meinetwegen ist dieser Ausgang des Inverters geht es eben nicht nur an das eine und Gatta,
sondern du gehst gleichzeitig an fünf und Gatta.
Auch dann würde man, wenn man das genau untersucht,
elektrisch eben wirklich Unterschiede auch im Schalverhalten haben und müsste das
dann eben auch entsprechend mit berücksichtigen
Das Ganze, also die Anzahl nachfolgender Schaltung wird im Englischen
dann immer als Fanout bezeichnet. Nicht also das hier nur
noch mal zur Erklärung, dieses kursiv gesetzten Begriffs. Gut,
ich hatte eben schon mal die eine Folie so ein bisschen Motivation,
also hier auch noch mal zu den Taktraten oder zu dem Ganzen,
also auch noch mal war es,
also also sieht,
wo wir jetzt eigentlich heutzutage technisch gesehen da schon stehen
Wenn man sich jetzt also mal überlegt,
Lichtgeschwindigkeit beziehungsweise genauer gesagt muss man also sagen, Lichtgeschwindigkeit im Vakuum,
ist also irgendwo so im Bereich 300.000 Kilometer pro Sekunde.
Das heißt, in einer Nanosekunde kann sich ihm ein Signal um 30 Zentimeter letztendlich nur ausbreiten.
Das gilt dann eigentlich jetzt nur für Radiowellen beziehungsweise im Vakuum,
wenn ich jetzt sage, also ich habe ein Strom,
der in mit einem Metalldraht fließt,
dann wäre dort also letztendlich die Ausbratungsgeschwindigkeit also noch langsamer,
beziehungsweise ein Halblat, dann ist es ja auch nochmal ein bisschen langsamer.
Also jetzt nun mal beliebig grob geschätzt, kann man dann sagen,
also dass man also irgendwo so bei 20 Zentimeter pro Tag eine Sekunde.
Das heißt, eine Nanosekunde entspricht, wenn ich das jetzt
also quasi als Kehrwert nehme, einem Gigahertz tagt.
Das heißt, Prozesse mit einem Gigahertz-Takt würde jetzt eben sagen,
Der schaltet einmal von 0 nach 1 irgendwo um und das Signal kommt,
quasi bevor es wieder vielleicht zurückschaltet, 20 Zentimeter Wahrheit. Das heißt,
wenn ich jetzt eben mir mal betrachte,
was kriege ich jetzt eben auf einen Prozess und mit zwei Zentimeter Diagonale,
was also in völlig mit heutigen Mehrkernprozessoren oder mit dem,
was also teilweise eine GPUs möglich ist, ja,
also auch noch vergleichsweise klein, dann kann man eben sagen,
okay, also bei zwei Zentimeter Diagonale Kommt man an eh maximal auf 10 Gigahertz-Tag-Tradrate,
wenn ich jetzt eben sage,
es soll ein Signal einmal quer über den Ship bewegt werden.
Nicht bei einer Platine, also sprich beispielsweise beim Motherboard,
20 Zentimeter Krantenlänge sieht man da,
ist man da sowieso schon relativ schnell am Ende.
Nicht also nochmal, auch nur nochmal als Vergegenwärtigung nicht.
Also wir reden hier bei Prozessoren über Computern und immer,
oder sind das ja eigentlich gewöhnt, jetzt also irgendwie mit Gigaherzweisen,
Taktraten zu arbeiten und zu rechnen.
Nicht auf der anderen Seite das,
was man so klassisch noch als UKW-Radio hat.
Also da liegen die Frequenzen oder Frequenzbereiche,
also noch im 100-Megaherz-Bereich. Das sind dann also schon
Größenordnungen weniger
Gut, Quintessenz von dem Ganzen,
was ihr also auch schon gesagt habt,
so prinzipiell kann es eben auch heute schon sein,
dass eben so ein Signal eines Taktes eben nicht von einer Ecke des ICs zur anderen gelangen kann,
beziehungsweise dass man dann eben auch sagt,
dass man dann eben auch sagen muss,
wenn ich jetzt irgendwelche Taktsignale habe,
die jetzt an mehreren Stellen auf meiner Fläche von dem IC irgendwo was machen sollen,
ich jetzt also Dafür sorgen muss,
dass die jetzt nicht quasi an der linken und eineren Ecke erzeugt werden und sich dann also irgendwie über den IC ausbreiten,
sondern man muss dann eben auch schon mit vergleichsweise viel Aufwand dafür sorgen,
dass die quasi an einer zentralen Stelle erzeugt werden und dann also gleichmäßig über die gesamte Schaltung so verteilt werden,
dass eben überall da, wo sie auch abgefragt werden,
dann auch möglichst gleichzeitig eintreffen.
Gut zum zeitlichen Ablauf von Schaltungen, beziehungsweise um den zu veranschaulichen,
nutzt man dann eben immer etwas, was dann im engen Deutschen übersetzt,
sich Impulsdiagramm nennt. Im Englischen heißt es dann immer Wayform,
nicht also sprich so eine zeitliche Darstellung der logischen Werte,
in diesem Fall dann eben als so eine Abstraktion des tatsächlichen Verlaufs,
wo ich dann eben sage,
die Zeit läuft irgendwie von links nach rechts und die Schaltfunktionen sind dann eben irgendwo beispielsweise jetzt von oben nach unten oder wie auch immer aufgelistet.
Das Ganze ist eigentlich vergleichbar mit Messwerten an so einem Ostseeloskop,
wenn ich das Ganze jetzt wirklich analog betrachten würde oder messwerden an einem Lorgic State Analyzer jetzt für digitale Werte. Nicht gleichzeitig,
oder was man da dann eben noch machen kann,
ist also die Darstellung mehrerer logischer Werte, wo ich dann eben sage,
ich mache eben nicht nur eine Unterscheidung zwischen 0 und 1,
sondern ich habe jetzt eben noch irgendwelche zusätzlichen Funktionen für diesen Wert,
zäht für hoch um mich, das braucht nur für Bussysteme,
werde ich im übernächsten Kapitel dann nochmal ansprechen,
So war es wie noch nicht initialisiert oder sowas,
wo ich dann also Fehlerzustände mit kodieren kann.
Nächstes Impulsdiagramm sieht dann eben typischerweise so aus,
dass man eben wirklich sieht, ich habe jetzt hier irgendwelche Kurven,
wo ich ihn hier unten, also letztendlich die Zeit habe,
in welcher Zeit einer halt auch immer,
in diesem Fall jetzt also einfach Tee, zwei T3T4T,
also sprich vielfacher irgendwie einer diskreten Zeiteinheit.
Und hier dann eben irgendwelche Pegel,
die dann letztendlich sowas wie einer logischen Null oder einer
logischen Eins entsprechen
Zeitlich gesehen. Und dass ich dann eben sage, gut,
das Ganze habe ich jetzt eben hier für zwei Eingangssignale, A und B.
Und in diesem Fall habe ich jetzt eben hier als Shart-Funktion einmal
die Unverknüpfung von A und B oder eben hier die Oder-Verknüpfung dieser beiden Eingänge.
Und das, was jetzt eben hier noch mit angedeutet ist,
ist, dass das Ergebnis jetzt eben um eine,
in diesem Fall konstante Zeit anhat,
also um A,
T verzögert ist
Das heißt, wenn ich hier jetzt irgendeinen Wert habe,
dann erscheint er quasi hier im Ausgang eben genau um INT verzögert.
Also sprich, war diesen Linien oder Kästchen, sofern man
das hier einigermaßen sehen kann. Letztendlich genau ein Kästchen später,
das heißt also hier hätte ich dann eben als Funktion A und B,
ist als Ergebnis null, entspricht dann quasi dieser Ausgabe.
Hier hätte ich dann also jetzt beispielsweise bei der Oder-Verknüpfung A oder BS0 hier dann eben Adlerch 1,
B-Lich 0 wäre dann eben genau hier dieser Eins-Wert und so weiter.
Das heißt, das wäre dann immer die logische Funktion genau um ein Kästchen versetzt. Und um anzudeuten,
dass man zu Beginn dieser Betrachtung letztendlich noch nicht weiß,
was ist jetzt hier in der Historie vorher passiert,
gibt es dann eben hier noch diesen Zieren eingefärbten Bereich,
der dann eben dafür steht, dass man sagt,
na gut,
also je nachdem, was hier vorher gewesen ist,
habe ich eben hier entweder eine Eins oder eine Null gehabt,
aber ich weiß es einfach nicht und deswegen ist das
hier nochmal entsprechend andersfarbig markiert
Nicht, dass also die Art und Weise,
wie solche Impulsdiagramme, also hier in diesem Beispiel zu lesen sind.
Und das wird dann zum Beispiel jetzt also auch in der aktuellen Übungsaufgabe,
da er dann noch vorkommt. Ja. Gut,
solche, beziehungsweise dazu vielleicht auch nochmal auch nochmal als Anmerkung,
also solche Impulsdiagramme beziehungsweise solche Sachen, kann ich mir auch Direkt,
das hatte ich eingangs ja auch kurz gezeigt, also mit dem Hades direkt erzeugen lassen.
Das heißt, zur Lösungs- und Erübungsaufgaben könnte man also
das Ganze zum Beispiel auch ein Hades einfach machen,
simulieren und sich anzeigen lassen, die Ausgabe entsprechend nehmen.
Also nehmen wir jetzt hier mal dieses Beispiel mit diesem Gatter.
Da gibt es eben die Möglichkeit zu sagen, den Simulator mal wieder starten.
Ich setze jetzt hier auf diesem Signal. Genau,
es findet sich dann also hier unter Wire at Probe.
Dann geht hier eben auch so ein entsprechendes Tal jetzt für Impulsdiagramme auf.
Würde ich dann jetzt also hier für diese Eingänge und den Ausgang einmal entsprechend machen. Und das war wirklich schön, das Ganze noch mal zurücksetzen. So,
und wenn ich die Simulation jetzt also hier laufen lasse,
und das Ganze dann eben so mache,
dass ich hier auch mal was tut,
und mir das dann also hier hinterher ansehe,
dann habe ich im Prinzip jetzt eben genau diesen Effekt,
dass ich dann Eben diese Impuls,
die errahme Seen und hier hat man dann eben noch die Möglichkeit,
also in den Impuls, die er kam,
wenn man jetzt hier gerade sieht, dann noch entsprechend rein beziehungsweise rauszuzoomen.
Gut, jetzt habe ich hier das natürlich gerade geschafft,
also so weit rein zu zoomen,
dass man da jetzt also gar nichts mehr sah,
beziehungsweise dann also immer nur in so einem Bereich war nicht,
aber hier sieht man dann eben
genau diesen Effekt
Wo dann also hier einmal die Garterverzögerung sichtbar ist und dann
eben auch jetzt hier, also nach einem Schalten der A-Eingänge,
dann also beispielsweise hier dieser Ausgangswertewechsel von 0 nach 1 mit entsprechender Verzögerung zu diesem Ereignis hier stattfindet.
Gut, die Bezeichner hier, das also auch nochmals anmerken,
sind jetzt hier natürlich ein bisschen unsinnig,
weil die werden jetzt hier einfach nur da rein nach automatisch vergeben.
Es gibt dann also eben auch die Möglichkeit,
also in dem Hades oder wenn man das jetzt anlegt,
dem also auch noch irgendwie ein bisschen sinnigeren Namen zu geben nicht.
Das heißt, da würde man also hier wirklich A,
B und meinetwegen A, N,
B oder wie auch immer man das Ganze nennen möchte,
entsprechend eingeben und würde dann eben wirklich in diesem Impuls,
die ja Gups, in diesem Impulsdiagramm das dann eben entsprechend schick beschriftet, ausgegeben bekommen.
Gut, im Zusammenhang jetzt mit dem Zeitverhalten von Schaltung,
möchte ich jetzt noch auf den Begriff der Hazards eingehen,
weil das ist also auch noch eine, sagen wir mal,
entscheidendes oder ein typisches Verhalten jetzt von Charlotte-Netzen,
was also auch gerade für die Funktion von Schaltnetzen also sehr kritisch ist.
Und zwar versteht man unterm Hazard eben die Eigenschaft,
dass eine Schaltfunktion bei bestimmten Kombinationen von Verzögerungen,
beziehungsweise bei bestimmten Kombinationen von Eingabewerten.
Am Ausgang der Schaltung dann eben irgendwie sowas wie ein Fehlverhalten
oder zumindest wie ein zeitliches Fehlverhalten für eine bestimmte Zeit aufweist.
Und ein Hazard-Fehler entsteht daraus,
wenn eben dieses Fehlverhalten aufgrund seines Hazards letztendlich dann also
auch zu einem falschen Verhalten der Schaltung insgesamt,
also zum Beispiel zum falschen Speicher von irgendwelchen Werten führt
Grundsätzlich kann man sagen, beziehungsweise das werde ich also
auch gleich mal hier mit einigen einfachen Trivialbeispielen zeigen.
Grundsätzlich kann man sagen, also jede Schaltung,
also auch wirklich ganz einfachste Schaltnetze erzeugen Haarsatz,
die werden immer Hazards erzeugen.
Die Frage ist eben nur, führt dieser Hazar dann eben auch wirklich zum Hazard-Fehler?
Gut, was verbirgt sich dahinter? Wird gleich noch ein
bisschen anschaulicher? Dazu nochmal vorher vier Begriffe. Je nachdem,
wie die Hazard sich am Ausgang zeigen und erscheidet man
zwischen statischen und zwischen dynamischen Hazards.
Ein statischer Hazard ist, dass man sagt,
also ich möchte am Ausgang irgendwo einen konstanten Wert haben.
Es tritt aber zwischenzeitlich kurzzeitig mal ein anderer Wert auf.
Beim dynamischen Hazard kann man sagen, der Ausgang soll sich ändern.
Also beispielsweise ein Wertewechsel von 0-1 oder von 1 nach 0.
Es findet aber nicht nur einmal, sondern mehrfachen Wertewechselstart.
Das heißt also einmal diese Unterscheidung statisch und dynamisch,
je nachdem,
was am Ausgang passiert
Das andere ist dann noch eine Unterscheidung zwischen Struktur und Funktionshasar,
wo ich einmal unterscheide,
dass beim Strukturhasar die Struktur oder der Aufbau der Schaltung dafür verantwortlich ist,
dass sich beim Umschalten eines Eingabewerts eben so ein Hasard einstellt.
Funktionshasard ist letztendlich durch die logische Funktion der Schaltung bedingt
Was sich dahinter verbirgt, beziehungsweise was jetzt überhaupt Hazard ist.
Dazu jetzt also erst mal die passenden Beispiele. Nicht also dieses Statische und das Dynamische,
also angenommen, ich habe, oder ich erwarte hier konstant,
dass eine Leitung oder ein Signal eben immer null ist,
wenn das zwischenzeitlich mal quasi für so einen kurzen Peak 1 wird,
dann spricht man eben von einem statischen Eins-Hazard umgekehrt,
wenn es immer die ganze Zeit eins sein soll und mal kurz ein Noll-Peak kommt,
dann habe ich eben einen statischen Null-Hazard.
Mit dem dynamischen Ein Wertewechsel von 1 nach 0. Fürth wird erwartet,
es kommt aber dann eben zum Zweifachen oder, nein,
also Dreifachen oder eben Mehrfachen Wertwechsel.
Und dann würde man eben von einem dynamischen Einsersatz sprechen.
Umgekehrt wäre das Ganze dann eben ein dynamischer Nullhazard
Ja, das wäre jetzt erst mal so die Unterscheidung,
was ich zwischen starte oder was mit statischen und dynamischen Hassatz gemeint ist.
So, böse Erkältung. Interessanter ist jetzt eigentlich jetzt
diese Unterscheidung jetzt zwischen Struktur und Funktionshassa,
ein Strukturhassaat wird jetzt eben bedingt durch die gewählte Struktur der Schaltung,
die dann dazu führt, dass ein Hazard auftritt,
selbst wenn sich also nur eine einzige Variable ändern kann.
Also als Beispiel, wir haben hier eine ganz triviale Funktion,
Funktion von A liefert nicht A oder A und A.
So die Funktion ist also ein bisschen unsinnig,
weil rein praktisch gesehen kann man sagen,
egal wie A aussieht,
das Ergebnis wird eigentlich immer
eine Eins sein
Weil wenn A.0 ist, dann liefert dieser Term eine Eins.
Und wenn A.1 ist, liefert dieser Term eine Eins.
Also im Prinzip kommt dort immer F.&As gleich eins raus.
Nichtsdestotrotz, wenn ich das jetzt also wirklich aus Gattern aufbaue,
also sprich aus dem Ungatter, haben oder Gatter und Werder.
Und ich habe jetzt eben im zeitlichen Verlauf Folgendes,
dass ich da Eingang quasi jetzt von null nach Eins ändert.
Und die jetzt eben sage,
aufgrund der Verzögerungszeiten Schaltet dieses Nicht-A quasi jetzt schneller den Eingang ab,
nämlich der Eingang ändert sich jetzt von 0 nach 1. Das heißt,
nicht A würde dann von 1 nach 0 schalten,
führt dann dazu, dass dieser vordere Therm 0 ist.
Und das geht jetzt schneller als dass dieser Therm hier
von 0 nach 1 schaltet
Dann würde das im Ergebnis dazu führen,
dass ich hier auf einmal so einen statischen Nullhazard erzeugt habe,
nämlich quasi einen kurzen Peak hier auf so eine Null.
Und sowas kann man also vergleichsweise einfach in solchen Beispielen quasi sich erzeugen.
Ich hatte die logische Funktion,
also aller dieser Beispiele ist eben letztendlich entweder es kommt eine Null oder es kommt eine Eins raus,
konstant,
aber dadurch,
dass ich also hier eben den Eingang immer um eine einen
in Wärter oder hier im Extremfall jetzt über mehrere in Wärter verzögert habe,
erreiche ich das eben quasi beim Umschalten von 0
nach 1 beziehungsweise von Arzt und 0. Ich
am Ausgang dann so
einen Strukturhasat mir erzeugen kann
So, das wäre jetzt also hier dieses Beispiel für ein Heinz Hazard,
wo ich jetzt eben aufgrund dieser Verzögerung hier erreiche,
dass wenn ich den Eingang quasi von 0 nach 1 schalte,
am Ausgang eben kurzfristig dieser eine Hazard auftritt, Im anderen Fall,
wenn ich den Eingang jetzt quasi zurückschalte, passieren nichts.
Ja, aber in dem Fall passiert das. Hier habe ich
das Ganze umgekehrt. Da wird jetzt eben ein Nullhasar erzeugt. Und hier ist dieser erste Fall,
dadurch, dass ich jetzt eben hier entsprechend viele in Wärter mit einer Verzögerung drin habe,
sieht man jetzt eben sehr schön,
wie dann quasi letztendlich diese Ausbreitung die dann einmal hier direkt erfolgt und einmal eben durch diese In-Werder-Kette dazu führt,
dass sich am Ausgang an eben genau diesen Hazard in der Schaltung beobachten kann.
Gut, das wäre jetzt also ein klassisches Beispiel für Strukturhazards. Also hier wäre dann,
also wenn ich das Ganze,
also die Simulation jetzt eben noch mit entsprechenden Probs versehen hätte,
das dann eben in Form so eines Impulsdiagramms wo man dann eben wirklich sieht,
wie dieses Umschalten des Eingangs dazu führt,
dass es eben in dem einen Fall quasi sich hier direkt auswirkt,
in einem anderen Fall dann eben über die Verzögerung dann eben
hier verzögert auftritt und dadurch dann über diese Differenzen der Zeiten dann dementsprechend hier ein Hassard erzeugt.
Wie gesagt, also bei dem,
also auch dabei oder bei den ganzen Beispielen generell kann ich sehen,
also auch immer nur animieren oder ermutigen,
einfach selber mit dem Hades ein bisschen rumspielen und entsprechend ausprobieren
Da sieht man das dann ganz gut. Extrem zu
dem Ganzen kann man sich das also jeder noch vorstellen,
mit so einer Kette aus Nantguttern, mit sehr langen Verzögerungszeiten.
Wo ich dann mit dem Umschalten des A eingangs dann nämlich
auch gleich eine gesamte Folge von Hasatz mir erzeugen kann.
Nicht je nachdem, wie viele Nantgutter ich habe,
habe ich dann eben entsprechend viele. Hasatz,
die sich dann hier auswirken, wo sich dann eben die
einzelnen Gatterlaufzeiten in diesem Fall dann eben entsprechend addieren würden.
Und wenn man sich das jetzt, also jemand mit dem
Hades ansieht, hätte ich dann eben hier als Ergebnis.
Nicht, jetzt ist es auch so entsprechend initialisiert. Und wenn ich dann hier umschalte,
dann würde an ihm hier bei dieser Verzögerung entsprechend langen Verzögerungszeit,
die jetzt hier eingestellt ist, also in diesem Fall 0,5 Sekunden,
sieht man dann, wie das dazu führt, dass Ergebnis,
dann entsprechender Anzahl dieser Endgatta, viele Wechsel stattfinden,
die dann eben zur entsprechenden Hazards hier im Ausgang führen.
Gut, Impulsdiagramm. Wie gesagt, könnte man
das Ganze dann eben auch entsprechend beobachten.
Nicht, dass man da dann eben eine Folge dieser
dynamischen Nullhazards sehen würde
Gut, solche Strukturhersatz grundsätzlich erstmal die Frage,
woher kommen die denn jetzt eigentlich,
wenn ich mir das jetzt mal irgendwie überlege?
Dazu, wie gesagt, da hatten wir jetzt eben,
also hier vielleicht weise triviale Beispiele, nicht nehmen wir jetzt,
also hier auch eine sehr einfache Funktion.
Also in diesem Fall X2,
X1 nicht oder X1,
Im KVdiagramm minimiert werden, dass die beiden schleifen.
Nicht, dass also jetzt irgendwie ein disjunktiver Form.
Wenn ich jetzt also einen Übergang habe von dieser Stelle,
also sprich X2, X0 nicht, X1,
also kann ich hier immer ablesen quasi über die Indizes X2,
X0 nicht, X1, das ist dann eben genau diese eins.
Auf diese Stelle, also sprich X2, X1,
X0, Das heißt, das,
was also hier mit diesem Fall angedeutet ist, das heißt,
also X1 ändert sich von 0 nach 1. Ein einbettiger Übergang.
Was aber er bewirkt, dass ich mich quasi hier von dieser Schleife,
beziehungsweise also hier von diesem Term, zu dieser Schleife,
also sprich zu diesem Term bewege, in der Funktion.
Und wenn ich dann von den Gatterverzögerungszeiten das Ganze eben so habe,
dass dieses Gatter quasi schneller abschaltet, als dieses Gatter einschaltet,
habe ich eben dann einen statischen Null-Hasard,
weil ich quasi von dem Ausgangswert 1 zwischenzeitlich mal kurz vielleicht eine Null habe,
weil dieser Therm hier schon abgeschaltet hat,
der aber eigentlich noch nicht aktiv geworden ist.
Dann habe ich im Ausgang eine Null und der
dann also verzögert erst wieder einschaltet und das heißt,
damit hat man dann eben genau Diesen Fall letztendlich erzeugt.
Und genau dieses Prinzip liegt auch allen anderen Beispielen,
also beispielsweise jetzt hier in diesem Inverter, als Beispiel dann letztendlich genauso zugrunde.
Das heißt, das ist so ein Strukturhase hat eben
immer so ein entsprechender Übergang zwischen solchen Thermen einer Funktion.
Gut, wenn ich das Ganze jetzt eben aufbaue und mit Hade simuliere,
mit entsprechenden Props, würde man dann eben quasi jetzt diese Schaltung haben.
Nicht das Ganze direkt aufgebaut. Und hier simuliert. Und
wenn ich da jetzt eben die Garterververzögerung so gewählt habe,
dass eben diese eine Therm hier entsprechende Größe,
Verzögerung hat, hätte,
als der hier,
würde man dann eben am Ausgang eben genau dieses Verhalten
der Funktion mit diesem statischen Nullhazard
hier beobachten können
Hm. So, jetzt sind wir gerade wieder schlau.
Wie vertan? So, also hier waren wir. Gut,
was kann man jetzt machen, um diese Hazards zu beseitigen?
Strukturhazards sind wie der Name jetzt eigentlich sagt,
eben bedingt durch die Struktur der Schaltung. Das heißt,
das, was ich machen kann,
um in diesem Fall diesen Hazard zu beseitigen,
wäre etwas, was allem zu wieder läuft,
was wir vorher immer in den Übungen gefragt haben,
wo ich dann immer sage, ich möchte eine möglichst minimale Implementierung irgendeiner Charlotte-Funktion oder irgendeine Schaltnetzes haben.
Also wenn ich jetzt,
also in diesem Fall jetzt dieses Beispiel nehme,
könnte ich sagen,
okay, ich realisiere das in des juktiver Form,
aber jetzt eben nicht in minimaler Form mit diesen beiden Schleifen,
sondern ich füge jetzt eben noch diese grüne Schleife mit hinzu
Was dann eben noch dieser Term X2X0 wäre.
Und wenn man das dann eben noch entsprechend eingebaut hat,
würde das dann eben dazu führen,
dass dann letztendlich damit der Strukturhazard beseitigt ist.
Allerdings natürlich in diesem Fall dann eben auf Kosten einer entsprechenden,
zusätzlichen Gatterrealisierung, also sprich höheren Hardwarekosten als das,
was also da in so einer minimalen Lösung
wieder zugrunde liegen würde
Ey. Gut, auch das könnten wir dann durch
entsprechende Simulationen sich dann nochmal ansehen, verifizieren. Also,
dass wir jetzt also dann hier die Schaltung quasi als Hades
Beispiel mit dieser einen zusätzlichen Schleife dann eben entsprechender als in
der dissunktiven Form mit dem Olagard haben wir drei Eingängen,
nicht nur dann in der Simulation angezeigt,
sieht man,
dass der Ausgang dann eben hier letztendlich immer konstant auf eins
verbleiben würde
Gut, etwas anders sieht das jetzt bei sogenannten Funktionsersersatz aus.
Funktionshazard treten eben auf, wenn sich mehrere Eingangswerte gleichzeitig ändern und
dann eben auch wieder abhängig von den Eigenschaften der Schaltfunktionen.
Das Problem, was dem eigentlich zugrunde liegt und weswegen es
auch bei Strukturhersatz nicht sinnvoll ist,
also mit zusätzlicher Hardware, die Hazards zu beseitigen,
weil also spätestens bei Funktionshersatz kann man das
nicht mehr machen
Das Problem, was eigentlich dem Ganzen zugrunde liegt,
ist, dass man sagt, wenn ich Funktionen habe,
wo sich jetzt eben zwei oder einfach mehrere,
in diesem Fall jetzt aber eben minimiert auf zwei Eingangsferiablen,
gleichzeitig ändern, dann wird man eben wirklich in der Realität feststellen können,
sowas wie eine absolute Leichtzeitigkeit gibt es eben nicht.
Das heißt, Sowas wie Funktionshasarz lassen sich eben nicht durch irgendwelche zusätzlichen Maßnahmen,
wie auch immer die aussehen müssen, beseitigen.
Und man kann dann eben nur sagen,
die Schaltung oder die Verwendung der Schaltung muss eben so sein,
dass sie nicht weiter stören.
Als Beispiel sei es eben hier genannte Übergang von diesem Term hier,
also X2, X1, nicht X-0, zu diesem Term hier oben.
Also X2 nicht, X1, X-0,
das heißt in diesem Fall ändern sich eben X2 und in Anführungszeichen gleichzeitig eben X1.
Und da diese Gleichzeitigkeit nie stattfindet,
werde ich eben in der Regel nicht eine Änderung von dieser Eins auf diese Eins haben,
sondern je nachdem, wie die zeitlichen Abhängigkeiten sind,
eben entweder ein Pfad hier rüber oder ein Pfad hier rüber.
Und je nachdem, welches von diesen Eingängssignalen sich jetzt schneller
oder langsamer ändert, habe ich eben bei diesem grün gezeichneten
Pfad keinen Hazard
Wenn es aber eben so ist,
dass sich eben erst X2 und dann X1 ändert,
habe ich eben auch hier wieder einen statischen Null, Hazard.
Das heißt, da lässt sich dieser Hazard eben nicht vermeiden.
Und deswegen, also auch die Aussage von vorhin,
und das ist in der Regel auch gar nicht sinnvoll ist,
also aufgrund der Funktionshaarsatz, die man gar nicht vermeiden kann,
also irgendwas mit dem Strukturarsatz zu machen.
Gut, damit ist dieses Kapitel vorher da abgeschlossen.
Nächste Woche geht es dann mit Schaltwerken
weiter und bis dann