Ja, willkommen bei der zweiten Rechnerstrukturvorlesung. Wie ich sehe
, haben wir alle auch hier den abgeänderten Hörsaal gefunden.
Von daher denke ich mir, kommen wir jetzt entsprechend weitermachen. Ja,
aufgehört hatte ich am Mittwoch ja mit dieser Beschreibung der unterschiedlichen Abstraktionsebenen in einem Rechner,
wo man dann eben sagen kann,
ich habe hier unten letztendlich irgendwo mal eine reale Hardware und habe dann darauf aufbauend unterschiedliche Ebenen von Maschinen,
die dann eben entweder interpretativ oder über kompilierende Mechanismen,
entsprechende höhere Sprachen der übergeordneten Ebenen abarbeiten können.
Warum das Ganze überhaupt? Hintergrund war eben dieses Samantic Gap,
wo man jetzt sagt, dass eben letztendlich nach diesem Grundverständnis,
was ein Computer eben machen und ausführen kann,
wirklich sehr primitive, sehr einfache Befehle nur vorhanden sind,
also sprich Registerinhalt von irgendwas, woanders hin transferieren,
während man auf der anderen Seite natürlich mit objektorientierten Programmiersprachen beziehungsweise mit irgendwelchen Programmen,
die da drauf aufbauen und dann natürlich dann also dann richtig viel können,
letztendlich eigentlich mit dem Computer irgendwie arbeiten möchte.
Gut, abgeschlossen hatte ich im Prinzip mit dieser Idee der virtuellen Maschine,
dass man eben sagt,
bei der Einteilung dieser Ebenen stellt also beispielsweise dann eben
so was wie Interpreter eine Art virtuelle Maschine zur Verfügung.
Das heißt, für ein Programm in einer Sprache
L1 ist es also letztendlich bei der Ausführung unerheblich,
ob das jetzt letztendlich schon direkt auf der Hardware läuft.
Das heißt also eigentlich, also auf der Ebene Null
oder ob es jetzt eben hier einen interpretativen Mechanismus gibt,
der ihm das hier bereitstellt.
Und das Ganze lässt sich dann eben auch teilweise
noch weiter nach oben hin fortführen
Das ist eben auch das,
was sie vielleicht also auch schon als Virtualisierungssoftware kennen,
wo man dann eben sagt,
ich habe jetzt beispielsweise im Userspace in meinem Betriebssystem,
also irgendwelche Programme,
mit denen ich quasi so tun kann,
als ob ich in einem Rechner dann eben nochmal irgendwie einen eigenen Rechner oder irgendeine eigene Hardware habe mit eigenen Festplatten,
mit Prozesse, mit irgendwelchen Grafikeinheiten,
eine Ausgabeeinheiten und man kann dann in dieser virtualisierten Umgebung dann eben wirklich Betriebssysteme installieren oder eben auch Programme laufen lassen.
Gut, das ist jetzt mehr in Richtung Software und Softwareentwicklung
wird uns vielleicht dann nachher noch bei dem Teil mit der Assembler-Programmierung begegnet,
weil ich dann sowas da,
also beispielsweise dann eben auch noch unter anderem mit einsetzen werde.
Ich habe das eigentlich nur mal als Randbemerkungsziel der virtualisierten Maschine. Gut,
was sind eigentlich so die typischen Ebenen, die man jetzt so in den Lehrbüchern,
wenn man jetzt also Tarnbaum nimmt und da also vorne mal reinguckt, dann findet? Das,
was wir eigentlich jetzt immer kennen, ist die Anwendungsebene,
das heißt also irgendwelche Hochsprachen, mit denen letztendlich programmiert wird,
dann da drunter liegend die Assembler-Ebene, also das,
was man als Anwendungsprogrammierer sieht, wenn man jetzt beispielsweise für einen X86-Prozess,
also irgendwie einen Intel-Manuals nachguckt, was es dort also letztendlich an der Sembler-Befehlen gibt.
Im Prinzip da drohender ist dann noch so was wie Betriebssystemebene,
wo dann also noch Verwaltung, also Systemprogrammierung stattfindet und eine Verwaltung von einigen anderen Sachen. Und da schadet sich dann letztendlich dadurch,
dass man eben sagen kann, okay, war da Sembler-Ebene,
beziehungsweise wenn ich jetzt selber Assembler programmieren würde, beziehungsweise bei dem,
was also irgendein Compiler aus meinem C-Programm beispielsweise heraus generiert,
sind halt keine direkten Zugriffe auf Hardware-Einheiten möglich, aus Sicherheitsgründen,
sondern dazwischen ist eben quasi noch das Betriebssystem oder das,
was ich dann benutze,
um jetzt also zum Beispiel sowas wie die Tastatur oder einen Bildschirm anzusprechen,
wären dann eben irgendwelche System-Calls,
womit man dann also quasi über den Mechanismusbetriebssystem dann letztendlich dann also irgendwie auf die Hardware durchgreifen kann.
Gut, dann da drunter befindet sich dann eigentlich das,
was man so grob gesagt erstmal so als Rechenarchitektur bezeichnet,
beziehungsweise dass es dann eben letztendlich die gesamte Schnittstelle zwischen Software und Hardware, wo dann quasi auf
Und dass da Maschinenebene quasi jetzt beschrieben wird,
welche Befehle gibt es, wie werden die ausgeführt,
was ist also quasi das hematische Konzept dahinter. Dann,
um das Ganze zu realisieren,
gibt es dann die sogenannte Mikroarchitektur,
das ist dann eben wirklich das,
wo man also dann schon in den Prozessor reingucken würde oder in den Computer und dann eben guckt,
welche Hardware-Einheiten gibt es, wie sind die miteinander verschaltet.
Das wird uns dann also später auch noch in
einem Kapitel im Rahmen der Rechnerstruktur und Vorlesung
Dann, darunter, Logik-Ebene. Das ist dann also wirklich das,
wie aus irgendwelchen logischen Gattern, nennen Gatter, Norgatta und so weiter,
jetzt also irgendwelche Hardware-Eineinheiten dieser Mikroarchitektur quasi aufgebaut werden.
Auch das werden wir dann noch in einem Tal der Rechnerstrukturenvorlesung
genauer sehen. Ansonsten sind das jetzt hier natürlich Sachen,
wo man sagen muss,
also normalerweise als Informatiker begegnete einem das dann nicht so direkt,
weil da sind die Schaltungen das Ganze letztendlich schon vorgegeben und
man muss sich dann eigentlich mit dem internen Aufbau der Hardware
nicht weiter beschäftigen
Und dann könnte man das Ganze noch weiter runtergehen und sagen,
gut, also im Prinzip also auch irgendwie sowas wie so ein Endgatter oder ein Inverter,
ist also jetzt bei Standard-C-Mos-Technologie aus,
irgendwie beispielsweise in Wörtern, eben aus zwei Transistoren aufgebaut,
die so und so miteinander verschaltet werden,
dass es dann eben letztendlich Elektrotechnik,
die sich dahinter verbirgt und um das jetzt als Ebene dann quasi noch voll zu machen,
gibt es dann noch sowas wie physikalische Ebene,
wo es dann also darum geht,
wie kriege ich das Ganze und letztendlich in Silizium gegossen,
das heißt, welche Biometrien sind dahinter.
Gut, das oder diesen Teil unterhalb der Logik-Ebene werde ich vielleicht noch haben,
ganz am Ende werden wir jetzt also noch irgendwie sehr viel Zeit haben,
kurz anreisen, Interesse halber,
ansonsten werde ich also vielleicht die entsprechenden Folien oder Unterlagen dann also noch so als Add-on-By-Interesse, also irgendwie zur Verfügung stellen.
Gut, hier nochmal die entsprechende Grafik,
also aus dem Buch von Enrotanenbaum, wo dann also quasi jetzt diese Ebenen,
also hier auch nochmal so aufgezeichnet sind, also wie gesagt,
das womit wir jetzt arbeiten, ist, als Unterstes,
also letztendlich die Ship Hardware, digitale Logik,
dann eben Die Mikroarchitektur, was daneben nimmt.
Der internen Realisierung dann schon so ein bisschen weiterentspricht.
Befehlssatz. Also das, was wir dann also sagen,
man soll es unterstes eigentlich bei der Programmierung sehen.
Nicht anschließend dann eben darauf aufbauen an, wie auch immer,
geartetes Betriebssystem, Assemblersprache und dann eigentlich das, womit wir jetzt arbeiten.
Ich muss die Folien mal überarbeiten,
weil also irgendwie diese Beispiele mit Smalltalk und Visual Basic gefallen mir nicht,
aber gut, jedenfalls, also da hat man dann seine Programmiersprachen. Gut,
wie ist das Ganze jetzt in den Bachelorstudiengang eingeordnet,
also diese oberen Ebenen, Anwendungsebene,
das ist also letztendlich Softwareentwicklung und Algorithmen und Datenstrukturen,
Betriebssystemebene ist also in Grundlagen der Systemprogrammierung so ein bisschen mit drin und Assembler-Ebene wird also quasi jetzt grob mit einem Kapitel,
also hier in dieser Vorlesung mit behandelt und diese Sachen also bis zur Logik-Ebene letztendlich dann eigentlich auch noch mit.
Gut, wie sieht das rein praktisch aus
Immer wieder das allgemein beliebte Hello World in C,
also sprich einfach das Programm, wo einfach jetzt also irgendwo eine Handstring ausgegeben wird.
Hier jetzt quasi als Quellcode, den könnte man dann mit einem Compiler,
in diesem Fall also mit der Gnu-To-Chain, mit dem Gnu-Compiler übersetzen,
in Assembler-Code bzw. eine Objektdatei erzeugen oder eben daraus,
also sowas wie ein Executable draus machen,
was man dann eben letztendlich ausführen lässt.
Und damit wäre man jetzt eben hier in dem Bereich,
also einmal hier und dann eben letztendlich bis zum, bis hier ersatz. Gut,
wenn ich mir jetzt den Assembler-Code, den der Compiler rausmeißt,
da so ansehen, dann sieht man,
dass er so quasi jetzt hier irgendwo aus dem,
ein Aufruf dieser Bibliotheksfunktion, hier dann also schon irgendwelche,
wie auch immer,
Gard und abstrusen Assembler-Befehle bei rausgekommen sind,
was sich dahinter verbirgt
Wie gesagt, müssen sie jetzt noch nicht wissen. Muss dann auch sonst unbedingt wissen,
also ein bisschen in die Assembler-Programmierung einfachen Beispielen, werden wir einsteigen,
aber das dann eigentlich auch nicht weiter genauer machen oder weiter vertiefen.
Letztendlich ist hier darin eigentlich nichts anderes als hier mit Call,
quasi sowas wie ein Aufruf, der quasi dem entspricht,
was also hier dann diese Printfunk oder das Print 11,
also quasi aus dem Standard-IO ist,
dass man da dann eben eine vorgehende Bibliotheksroutine aufruft.
So, das, was an Objektcode dabei rauskommt,
Ist halt dann eben wirklich einfach nur hier einmal gelistet.
Irgendwie so eine Folge von Null und Einsen.
Jetzt kodiert ein Hexer Dezimaldarstellung. Nicht,
da kann man schon sagen, ja gut,
damit kann man normalerweise so als Mensch schon nichts mehr anfangen.
Nicht hier das Ganze da nochmal disassembliert. Das ist dann
quasi jetzt also den Objektcode wieder zurück übersetzt in Assembler-Code,
wo man dann sieht,
okay,
dieses Ganze sollte eigentlich ähnlich
dem HelloWorld.s aussehen
Und der Maschinencode, also das ist eigentlich Executable,
ist dann quasi das Ganze noch irgendwie ein bisschen,
sieht eigentlich ähnlich aus, wie der Objektcode,
das Ganze nur nochmal umergänzt, also jetzt um weitere Betriebssysteme,
Aufrufe und einige Sachen dahinter.
Gut, das sind eigentlich schon alles Sachen,
die gucken wir natürlich logischerweise nicht mehr an, es seien,
man hat also jetzt irgendwie ganz schwere Debug-Probleme,
da kann man sich sowas sein.
Gut, also das eigentlich nur nochmal als Veranschaulichung, diese unterschiedlichen Ebenen.
Das, worauf das Ganze aufbaut,
also deswegen hier eigentlich auch nur nochmal so ein bisschen dieser Kommentare,
diese Anmerkung da von einer Frau, Castring, glaube ich, Panetta Lance.
Hardware ist versteinerte Software. Damit ist eigentlich das gemeint,
was sich also vorhin schon kurz angedeutet habe. Also wenn ich also irgendwie sowas habe,
wie eine Sprache auf einer bestimmten Ebene und die wird ausgeführt,
sah das jetzt durch realer Hardware oder sah das durch eine virtuelle Maschine,
dann ist das für diese Sprache letztendlich nicht unterscheidbar,
was ich da drunter befindet.
Demzufolge kann man eben sagen, Software und Hardware sind eigentlich logisch gesehen equer Land,
nicht deswegen, also dieser entsprechender Ausspruch, nicht zumindest bezogen ist,
also auf die Ausführungen in höheren Ebenen. Daraus kam,
sorry, daraus kann man dann eben auch schließen oder das Ganze entsprechend weitertreiben,
dass man eben sagt, Hardware und Software sind eigentlich logisch experient,
das heißt eigentlich für jedes Problem, also auch für jeden Algorithmus,
kann ich den eben auch genauso in Hardware realisieren.
Also wir sind jetzt eigentlich immer gewöhnt, dass wir sagen,
ja gut, also Computer ist programmierbar,
ich schreibe irgendwie mein Programm und habe dann eben entsprechend diesen Ablauf,
genauso gut kann das Ganze aber eben auch direkt in spezielle Hardware umgesetzt werden.
Warum macht man das nicht? Weil sich das einfach aus Kostengründen nicht lohnt,
beziehungsweise eigentlich nur genau dann interessant wird,
wenn es letztendlich um irgendwelche besonderen Anforderungen an Performance oder sowas geht,
wo man dann eben zum Beispiel sagen kann,
also für bestimmte Verarbeitungsaufgaben oder für bestimmte Anforderungen hinsichtlich der Spezifikation,
also Leistungsaufnahme zum Beispiel oder sowas,
da komme ich eben jetzt mit einer Standardlösung nicht hin.
Also beispielsweise nehmen wir jetzt mal irgendwie so Hörgerät, da wird also jetzt irgendwie Schal aufgenommen,
liegt mit einem digitalen Filter irgendwie entsprechend verarbeitet, irgendwas mitgemacht.
Dann kann man sagen, na gut, also das,
was dahinter steht, also im Prinzip so ein digitales Filter zu realisieren,
das kann ich also im Prinzip mit dir im x-beliebigen Prozessor machen.
Ich muss, wenn ich das Ding,
also mit einer kleinen Knopfbatterie, also irgendwo betreibe,
im Ohr trage, dann kann ich da also nicht,
also hier irgendwie so eine große Desktop- oder Laptop-CPU einsetzen,
sondern braucht da entsprechende kleinere Einheiten,
die dann aber eben auch noch zumindest für diese Aufgabenstellung
die entsprechende Rechenleistung zur Verfügung stellen
Dafür kann es sich dann eben schon lohnen,
also auch nochmal ein bisschen spezielle Hardware zu entwickeln.
Nachteil bei dem Ganzen ist natürlich, Computer,
Software, es ändert sich was an der Spezifikation,
ich möchte irgendwie was anders machen, ich ändere mein Programm.
Wenn das in Hardware gegossen ist,
habe ich keine Chance, da irgendwie was zu machen,
dann muss man das also quasi dann wieder neu realisieren,
neu fertigen.
Das sind dann also irgendwie Kosten,
die irgendwie so im siebenstelligen Bereich liegen,
das heißt,
da lohnt sich das dann eben nicht
Also deswegen, aber letztendlich kann man immer sagen,
Hardware und Software sind Äquivalent.
Wir sehen natürlich in der Regel immer nur die Software-Realisierung. Gut,
dann werde ich jetzt erst noch mal so ein bisschen dieses grundlegende Konzept vorstellen,
wie Computer eigentlich arbeiten oder wie die Digitalrechner arbeiten.
Wurde 1905 von John Four Neumann und den Herrn Maukley und Eckardt
entwickelt bzw. in einem Paper vorgestellt,
läuft aber eigentlich immer unter von Neumann-Konzept
Das, was dort beschrieben wurde, ist quasi eine abstrakte Maschine mit einem minimalen Hardwareaufwand.
Das heißt, ich habe ein Gesamtsystem von Prozessor,
Speicher, irgendwelchen Peripherie-Geräten. Und das Problem,
das jetzt also irgendwie mithilfe dieser Maschine gelöst wird,
wird durch einen austauschbaren Speichereinhalt, also durch ein Programm beschrieben.
Und das, was eigentlich letztendlich damals neu war,
für uns heute Selbstverständlich ist, ist,
dass man eben sagt, Struktur dieser Maschine.
Also das heißt, wie die aufgebaut ist. Es ist
eben unabhängig von den Problemen beziehungsweise unabhängig von den Programmen.
Wir sind jetzt eigentlich heute gewohnt, dass man sagt,
ich habe einen Computer, ich habe irgendeine Aufgabenstellung,
ich möchte Textverarbeitung machen, ich möchte im Web brausen, ich möchte spielen.
Ich schreibe das entsprechende Programm, das läuft alles auf der gleichen Hardware.
Dieses Konzept ist letztendlich das,
was also dann auch Grundidee oder das Neue an diesem Vernonern-Konzept war,
weil vorher war es eben so,
es gab zwar schon sowas wie elektronisch oder zumindest elektrische Rechner,
die waren dann aber eben von der Hardware für spezielle Aufgabenstellung
her konstruiert
Das heißt, es gab eben beispielsweise beim hydrografischen Institut,
also irgend so ein elektrischer Rechner,
der konnte dann also quasi mit Mondphasen und sonstigen Teen-Kalender berechnen,
also sprich wie der Teen-Hub irgendwie sich passend bewegt.
Der konnte aber eben auch nur genau das machen,
wenn man jetzt irgendeine andere Aufgabe hätte, müsste man,
hätte man die Hardware umbauen müssen,
nicht mit dem Verneumann-Konzept wurde eben dieser universelle Rechner letztendlich damit beschrieben.
Gut, wie ist er aufgebaut? Von der Grundidee her
kann man eben sagen, man hat erstmal einen gemeinsamen Speicher
für Programme und Daten
Dieser gemeinsame Speicher ist fortlaufend adressiert. Im ursprünglich von neuem Konzept,
beziehungsweise wie das damals realisiert wurde, ist es eben auch so,
dass es keinen Unterschied gibt zwischen Programmen und Daten.
Das heißt, ich habe in meinem Speicher, also irgendein Binärwort,
also eine Folge aus 001 und ich weiß nicht,
ob dieses Wort eine Zahl ist, eine Zeichenfolge,
HelloWorld oder ob dieses Wort irgendein Befehl für die Maschine ist.
Sondern diese Interpretation ergibt sich dann eigentlich erst dadurch,
dass man dann also sagt, also durch irgendwelche übergeordneten Mechanismen,
Betriebssystem oder irgendwelche Konventionen, die man festlegt,
sagt man, alles, was in diesem Speicherbereich ist,
ist Programm und alles, was in diesem Speicherbereich ist,
das sind irgendwelche Daten von den Programmen.
Ganz am Anfang war es eben auch so,
dass man dann also auch noch gesagt hat,
also Programme können wie Daten manipuliert werden.
Das heißt, da gab es dann eben auch die Möglichkeit
und wurde also auch gemacht, selbst modifizierende Programme zu schreiben,
also ein Programm,
das sich selber quasi umschreibt
Das sind dann also Mechanismen,
also die hat man heute nicht mehr oder möchte man nicht mehr haben,
weil mit sowas kann man dann nämlich im Prinzip letztendlich,
also irgendwie Sicherheitslücken ausnutzen, Viren machen, Sonstiges,
war eben genau diese Interpretation, ist dieser String,
eine Zahl oder eine Daten,
also das String aus Null und Einsen, ist das eine Zahl,
ist das ein Dort ein Wort oder ist das ein Befehl von dem Prozessor,
ist eben das, wo man sagen kann, okay,
also ich schreibe jetzt also irgendwie so ein Vektor aus Null und Einsen,
eine bestimmte Stelle im Programm und wenn ich dann den Computer dazu bringen kann,
an dieser Stelle quasi seine Programme Abarbeitung loslaufen zu lassen,
dann interpretiert er das eben jetzt auf einmal nicht mehr als Zahl,
sondern als Befehle und dann kann ich also irgendwie beliebigen Unsinn mitmachen.
Also im Prinzip können Daten dann eigentlich auch als Programme ausgeführt werden. Gut,
und das war es dann eben auch in dem Phonama-Konzept drin ist,
dass es dann quasi die Abarbeitung dieser ganzen Sachen dann eben über so ein Willfieldszyklus,
also das heißt, so eine Abfolge von einzelnen Schritten passiert.
Die Befehle, die irgendwo im Speicher liegen,
werden irgendwo geholt
In einem Prozessor dort irgendwo interpretiert, dekodiert, ausgeführt.
Anschließend, wenn das fertig ist, wird der nächste Befehl geholt und so weiter und so fort.
So, damit ist man eben letztendlich enorm flexibel. So,
alles, was wir eigentlich so an Rechnern kennen, basiert auf diesem Prinzip. Wobei man eben sagen muss,
das, was wir heutzutage, die Rechner können und machen,
also über so ein Grundprinzip von John von Neumann,
also deutlich hinausgehen, weil eben,
also auch gerade so diese den gemeinsamen Speicher von Programmen und Daten hat man konzeptuell eigentlich nicht mehr,
die einzelne Abarbeitung der Befehle,
wie sie also jetzt gleich also auch nochmal kurz skizziere,
wird so eigentlich auch nicht mehr gemacht,
sondern bei aktuellen Prozessoren hat man da dann eben auch andere Prinzipien,
also Pipelining wäre dann da beispielsweise das Stichwort.
Das würde ich dann aber auch noch so ein bisschen im Laufe der Vorlesung
kurz weiter vorstellen nicht, aber dieses grundsätzliche hier John von Neumann-Konzept,
das sollte dann eigentlich grob bekannt sein.
Gut, wie sie da rechnen, Entschuldigung,
wie sieht der Rechner da jetzt eigentlich aus? Wie gesagt,
ich habe Das, was dann die eigentliche CPU, der Prozessor ist,
logisch wird das dann eigentlich immer noch unterteilt in zwei Teile, Steuerwerk und Rechenwerk.
Das eine ist dafür zuständig, quasi den Befehlen irgendwie zu interpretieren.
Und das Rechenwerk ist derjenige Teil,
wo dann also irgendwie so eine Recheneinheit, Alu, Arismathed,
Logic Unit drin ist, die dann also irgendwelche Berechnungen damit macht.
Und irgendwelche Register neu berechnet, beziehungsweise teilweise gibt es ja
noch diverse Spezialregister. Dann gibt es eben den Speicher,
wo im Prinzip die Programme drin liegen,
gemeinsam genutzt und vielleicht noch für Ein- und Ausgabe
irgendwelche Werke
Und das Ganze ist dann in der Regel durch irgendwelche Bussysteme miteinander verbunden.
Also hier sind das jetzt immer irgendwie so getrennte Leitungen,
kann aber auch irgendwie sowas wie zentraler aus sein.
Gut, der Prozessor hatte ja schon grob gesagt,
es ist logisch unterteilt, immer in diese zwei Teile. Steuerwerk,
das ist eben der Teil, der letztendlich dafür verantwortlich ist,
ein Befehl irgendwie aus dem Speicher zu holen,
in ein eigenes Register, Befehlsregister, das heißt,
das muss also da schon mal irgendwo vorhanden sein.
Und es muss auch ein Befehlszähler geben, quasi ein Zähler,
der nichts anderes ist, als die Adresse der Speicherzelle,
wo jetzt quasi der nächste zu holende Befehl drin steht.
Denn das, was das Steuerwerk dann macht,
ist dann eben quasi hier von dieser Adresse aus dem Speicher
ein Datentransfer eben in dieses Befehlsregister.
Da habe ich dann mein Befehlswort, das wird dann quasi jetzt irgendwie interpretiert,
wo dann festgestellt wird, es soll beispielsweise irgendwie zwei Zahlen,
woher geholt werden und addiert werden.
Und das geht dann eben letztendlich über irgendwelche Kontrolleitungen,
Steuerleitungen an, den Datenfahrt oder das Operationswerk,
wo dann also quasi einmal gerechnet wird und wo es dann eben noch irgendwelche Register gibt.
Der Speicher hier dann eigentlich auch nur so als ein allgemeiner Block bezeichnet,
wird dann teilweise auch noch beliebig weit unterteilt.
Zum einen habe ich eben das,
was man eigentlich einen Hauptspeicher hat,
lese und schreibbar
Dann noch einmal das Rahmen random Access Memory abgekürzt.
Teilweise gibt es dann immer noch so was wie Speicherbereiche, die jetzt nur gelesen werden können.
Das ist dann Rom, Read-Only-Memory. Wird dann also zum Beispiel benutzt,
um jetzt also quasi so dafür zu sorgen,
dass ein Rechner oder ein Rechensystem entweder guten oder anlaufen kann,
beziehungsweise wenn ich jetzt also so was wie irgendein kleines Ahlengebettetes System habe,
also was weiß ich, den Mikrocontroller,
der jetzt mal eine Waschmaschine steuert,
dann ist dort quasi das Programm,
weil es ja nicht andauernd geändert werden muss,
dann eben auch in so einem Read-Only-Speicher mit drin
Früher waren das also Halbleiterspeicher,
die dann quasi einmal fest irgendwie so programmiert worden sind.
Inzwischen sind das eigentlich typischerweise irgendwelche wiederprogrammierbaren Bausteine, Flash-Speicher,
womit man dann eben auch noch die Inhalte entsprechend austauschen kann.
Das ist also beispielsweise das, was man jetzt machen würde,
wenn man jetzt also irgendwie auf Motherboard und wie Wyos
flasht oder irgendwelchen anderen Komponenten da sowas macht
Ich dann gibt es immer noch entsprechend externe Speicher,
Massensparicher, Festplatten beziehungsweise inzwischen Solid State Disk, CDs,
Magnetbänder, was auch immer.
Und was wir dann natürlich typischerweise haben, irgendwelche ein Ausgabegeräte,
Monitortastatur, Maus-Touchpad, was auch immer man sich daran denkt.
Gut, hier nochmal, historisches Bild. Dieser Herr,
der ist John von Neumann, dieser komische Kasten im Hintergrund.
Das ist also ein elektrisch mit Relace aufgebauter Rechner.
Gut, dazu
Komme ich gleich nochmal so ein paar historische Teile, zumindest fotomäßig vorzustellen. Gut, dieses Grundkonzept des von Neumann-Rechners kann man sich veranschaulichen, im Prinzip über so eine Simulation. Dazu gibt es,
oder hat also im Prinzip dann da eine Kollege von mir,
also hier mit den Hades, so ein Simulationsprogramm mitgebaut,
beziehungsweise damit lassen sich beliebige Sachen simulieren,
unter anderem dann aber eben auch so ein Rechner,
den er dann jetzt also quasi prima genannt hat, Primitive Machine,
was dann eben wirklich so minimale Acht mit von Neumann-Rechner ist,
mit einem sehr kleinen Hauptspeicher, 256 Wordener 8 Bit,
mit einigen 8 Bit-Registern,
also was also wirklich genau diesen Minimalsatz entspricht, einfach ein Alu,
die Addition inkrementieren und shiften kann und einen sehr einfachen Befehlsatz.
Das Ganze kann man sich dann quasi als Web-Applet dann also auch irgendwo in seinem Frauhauser dann also irgendwo starten,
sofern man da also hier entsprechende Zertifikate anerkennt und sonst da alles Mögliche macht und kann dann eben wirklich das Ganze hier einmal interaktiv laufen lassen,
da ich das jetzt hier gerade natürlich wieder das passende Plugin nicht drin habe,
tut sich da bei mir jetzt erstmal nichts,
aber das ist im Prinzip das, was sie da dann dahinter verbirgt,
dann würde man sonst nämlich eigentlich sowas sehen.
Das ist also jetzt wirklich hier dieser Minimalrechnerrahmen,
das ist also der Hauptspeicher, Steuerwerk, das ist dieser Teil,
der dafür sorgt, dass quasi jetzt der Inhalt,
der irgendwo in dem Befehlsregister gelandet ist,
entsprechend als Befehl interpretiert wird.
Dann gibt es eben hier ein Programmzähler,
der dann eben letztendlich die einzelnen Befehle durchgeht.
Wenn ich jetzt einen Befehl abarbeite zum nächsten gehe, muss ich diesen Programmzähler logischerweise erhöhen.
Dafür gibt es dann also ein Inkremente, das heißt,
also man kann dann also quasi hier rüber das Ganze erhöhen.
Es gibt dann eben ein Aal und eine Recheneinheit, in der gerechnet wird und dieser Tal ja rechts entspricht dann letztendlich dem Operationswerk. So wie das im Einzelnen abläuft,
wird dann natürlich noch irgendwo später im Laufe der Vorlesung,
wenn ich dann also diese einzelnen Kästen und ihre Funktionsweise noch ein bisschen genauer vorstelle,
sicherlich noch klarer,
also da müssen sie jetzt also nicht Angst haben,
wenn sie jetzt denken,
was soll das denn jetzt hier alles werden,
beziehungsweise sowas wird in,
allerdings dann schon in etwas komplexerer Art in Form dann eben auch Teil des Rechnerstrukturenpraktikums wären,
wo es da dann eben auch inhaltlich darum geht,
so ein bisschen an dieser Schnittstelle von einfachem Befehlssatz und irgendwie Hardware und dessen Abarbeitung seine Versuche zu machen.
So dieses Grundkonzept von diesem Fonds-Neumann-Rechner lässt sich aber hier also
relativ einfach eigentlich zeigen. Wie gesagt, Grundkonzept ist,
ich habe minimale, einfache Hardware und die ändert sich auch nicht.
Die bleibt eben immer identisch und nur durch den Inhalt,
den ich hier im Rahmen habe, kann ich dann meine unterschiedlichen Probleme oder meine Algorithmen beschreiben. Und das,
was man da jetzt eben macht, ist,
dass man sagt, ich habe jetzt diese unterschiedlichen Schritte,
ein Befehl wird irgendwo aus dem Speicher geholt, er wird dekommentiert,
der nächste Befehl soll später geholt werden, es wird dieser Befehl irgendwie interpretiert,
es wird was gerechnet, das Ergebnis wird vielleicht irgendwo hingegangen und ich kann auch irgendwie sowas wie Sprünge machen.
Und die Idee ist, dass das,
was hier jetzt quasi immer farbig dargestellt ist,
dass das dann eben letztendlich den Ablauf von dem Ganzen realisiert,
dass man eben sagt,
ich habe immer die gleiche Hardware und je nachdem,
in welchen Schritt der Abarbeitung ich bin,
habe ich dann eben unterschiedliche Datenpfade,
die ich dann also quasi hier über diese Multiplexer,
kann man sich also quasi jetzt einfach für Datenworte als Weichen vorstellen,
wo man dann eben bestimmte Funktionen schalten kann,
dass man darüber dann eben sagen kann,
Ich habe hier dann eben alles entsprechend so realisiert,
dass man diese einzelnen Schritte in ihrer Gesamtheit dann eben umsetzen kann.
Also beispielsweise, wenn es darum geht, einen Befehl zu holen,
habe ich hier in diesem Programm-Counter, also den Programmzieler,
die Adresse von dem Befehl, gehe dann eben hier an den Speicher,
das entsprechende Wort wird gelesen, landet dann eben hier in dem Befehlsregister.
Anschließend wird das dann eben dekodiert,
das heißt also aus dem Befehlsregister geht das dann hier rein,
abhängig davon, was das für ein Befehl ist, was da machen soll,
werden jetzt eben hier diese ganzen Steuerleitungen mit irgendwelchen Werten belegt,
das sind quasi die ganzen Leitungen, die jetzt eben zum Beispiel diese Multiplexer-Schalen,
die jetzt eben der Alu sagen, Adire oder Subtrahio oder macht die und die Operation und so weiter und so fort.
Nicht dann kommt eben als Vorbereitung für den nächsten Befehl,
dass der Programmzähler inkrementiert wird,
das heißt also hierüber wird eben der Inhalt hier plus eins gerechnet,
nicht anschließen soll, dann also,
wenn das beispielsweise ein Befehl war,
wo also der Inhalt hier neu berechnet werden soll und dazu dann also von einer Adresse im Rahmen ein Datenwort hinzuaddiert wird,
wo dann eben quasi ja aus dem Inhalt dieses Registers,
also hier das entsprechende, die entsprechende Speicherzelle gelesen,
das Ganze geht dann eben durch die Alu,
die dann eben so beschaltet wird,
dass sie also eine Addition da ausführt und das andere Argument ist dann also quasi hier der Inhalt dieses Registers und das Ergebnis landet dann eben auch wieder hier.
So und so kann man dann im Prinzip also
sehr einfach für diesen sehr einfachen Befehlsatz dann,
also seine einzelnen Schritte machen
So und das entspricht jetzt so in dieser Minimalform dann eben eigentlich
schon dem, was also in dem von Neumann-Konzept drin ist.
Gut, hier sind dann eben jetzt noch weitere Schritte,
wie jetzt dann also zum Beispiel das Ergebnis von dem Akku wieder irgendwie ins Rahmen geschrieben wird,
wie Sprünge gemacht werden und so weiter und so fort.
Gut, das Ganze kann man dann eben auch jetzt quasi in der Funktionsweise simulieren,
auch beispielsweise eben, wie jetzt also auf Assembler-Ebene,
also das ist dann ein Screenshot von dem entsprechenden Simulator dahinter,
wo man dann eben sieht, also hier Inhalt,
dieser ausgewählten Register-Program-Counter, Adressregister und so weiter.
Und dieses ist dann hier jetzt quasi ein Ausschnitt von dem Speicherinhalt.
Und was man dann mit so einem Simulator eben machen kann,
ist, das war, wenn man jetzt eben so ein entsprechendes Programm hätte.
Gut, hier sind die Inhalte jetzt, also als Dezimalzahlen dargestellt.
Ich kann das,
aber man konnte das dann eben auch in Assembler umschalten oder in irgendeiner Exeduzimaldarstellung,
wo man dann eben wirklich sieht,
also an den Stellen habe ich jetzt hier quasi meine
Befehle und an den Stellen habe ich irgendwelche Daten,
auf denen ich rumrechne
Gut, das eigentlich erst mal so zu diesem grundlegenden,
ganz einfachen John-For-Norman-Konzept oder für Norman-Konzept. Das ist eben letztendlich das,
was die dann eigentlich auch immer irgendwie so ein bisschen im Hinterkopf haben müssten,
wenn es also darum geht, also wie kann ein Computerbefehler abarbeiten?
Wie gesagt, Erweiterung und das, was heutzutage
so aktuell ist, folgen dann später noch. Gut,
um das Ganze jetzt nochmal so ein bisschen abzurunden,
ich will mir jetzt gucken, okay, wie sind jetzt,
damit habe ich jetzt ja erstmal nur so ganz einfach CPU nicht.
Wir sind dann also eigentlich generell so Rechner aufgebaut.
Also das ist hier aus dem Buch Fontanenbaum, wobei ich das jetzt sagen muss,
okay, das entspricht dann also irgendwie dem Ersten IBM-PC
1901. Da gab es eben auch so ein zentrales Bussystem,
CPU-Speicher, Videocontroller, Pastatur, CD-ROM, Festplattencontroller.
Das heißt also, das ist hier irgendwie Ein- und Ausgabe,
CPU und Sparchen, das Ganze über so ein Bussystem,
ist es eigentlich genau dieses von neuem Konzept so umgesetzt.
Gut, damals erste Ach, Bitt, Mikroprozessor,
der dann da entsprechend gearbeitet hat, also 80,
86, nicht mit 512 Kilowatt Rahmen.
War dann also das Allereinfachste, hier das Ganze als Original-Prototypen-Platine,
schön die einzelnen Leitungen irgendwie von Hand gerappt,
sprich also irgendwie über so eine Wickeltechnik miteinander verbunden.
Also muss man sagen, so hat man also im Prinzip also in den 80er Jahren irgendwelche Prototypen gemacht,
dass das Ganze dann eben entsprechend später von oben drauf,
sieht also schon deutlich anders aus als ein Motherboard heutzutage.
Für diejenigen,
die sich vielleicht selber mal einen Rechner konfiguriert haben,
so was wir dann mal gesehen haben,
nicht also inzwischen ist das eigentlich nur noch relativ viel Slords,
der Sorgel für die CPU, das ist in diesem Fall,
also hier ja die CPU und alles andere hier rundherum ist hier im Prinzip Speicher,
damals also noch wirklich einen kleinen einzelnen Chips und nicht so in fertigen Modulen und dieses hier entspricht dann eigentlich dem,
was früher mal Chipsatz war.
Das heißt also, die Schnittstelle zwischen CPU zum Bussystem, zu diesem Controllern.
Inzwischen ist das eigentlich auch alles schon in die CPU reingewandert.
Früher waren das noch Einzelne, Teile,
also hier sieht man immer ganz in PCU-Bus-System, also die CPU,
die dann also quasi über so ein Controller angeschlossen wurden.
Hauptspeicher hat dann eben schon getrennt, das Bussystem.
Und dann gab es dann eben hier noch unterschiedliche,
schnellere oder langsamere Poste, über die dann da das ganze System angeschlossen wurde.
Nicht so sah das Ganze. Also vor elf Jahren aus
Da war es dann schon so ein bisschen näher anders geht,
was man heutzutage da noch sieht. Und wie gesagt,
das, was also hier so North Bridge und South Bridge ist,
das ist inzwischen eigentlich auch alles in die CBU reingewandert,
beziehungsweise ja, ein Äquivalent zu South Bridge gibt es noch,
aber das sind dann im Prinzip so aktuelle Sachen, 2010.
Gut, inzwischen muss man sagen, wie hat sich
das Ganze letztendlich verändert im Vergleich zu den allerersten Systemen.
Diese Bussysteme sind von der Übertragungsleistung, immer leistungsfähiger geworden,
dass man eben immer mehr Daten zwischen CPU und speichert,
zum Videosystem oder irgendwie nach draußen bekommen kann.
Ursprünglich kann man sich das eben wirklich als einen einzelnen Bus nehmen,
der dann also jetzt letztendlich hier dann auch,
wie man sich dann sicherlich auch vorstellen kann, sowas wie eine Engstelle bildet.
Später wurde das dann eben schon in mehrere Busse getrennt,
wo dann eben im Prinzip der Speicher dann also eigentlich mehr
oder man da schon direkt mit der CPU kommuniziert und es dann eben Sachen gibt für Schnellern oder für langsameren Datentransfer.
Und inzwischen muss man eben sagen, sind diese Systeme dann sowieso noch ganz anders getrennt.
Das heißt, also Speicher hängt dann direkt über eigene Systeme hier daran. Und alles,
was dann also in Richtung Festplatten oder so geht,
beziehungsweise die anderen Sachen, also auch gerade so Grafikeinheiten,
sind dann also Punkt zu Punkt Verbindung eigentlich nicht mehr klassische Bussysteme.
Gut, hier sieht man eben schon so ein bisschen angedeutet,
also wer dann eben immer höhere Daten raten letztendlich damit erreicht
und so weiter
Gut, heutzutage, wo ist man da angekommen?
Hier war es immer noch eine einzelne CPU mit Rechenwerksteuerwerk und so weiter.
Inzwischen haben wir Mehrkernprozessoren, also im Desktop-Bereich, sag ich mal,
erst mal so mit vier bis acht Kernen typischerweise dabei.
Bei Workstations, die etwas größeren Xeons gehen inzwischen bis 24 Kerne.
Und was ich eben schon gesagt hatte, eben diese gesamten
Verbindungen sind jetzt eben mehr oder minder eins zu eins Direktverbindung.
Also das, was man hier auch immer sieht, dass also jetzt wirklich direkt Verbindung zu irgendwie den einzelnen Systemen angedeutet sind. Das andere,
was sich geändert hat,
wir haben eben nicht nur die klassische graue Kiste dem PC,
sondern mobile Geräte, das ist angeblich ein von dem ersten Apple A iPhone,
das Motherboard, wo man dann eben sieht,
wie das Ganze da dann eben entsprechend aussieht,
wo man dann im Prinzip den Rechner, also hier,
das wäre dann quasi CPU ansprechend, wo man dann eben sagt,
also entsprechend den Rechner und alles an sonstigen Systemen,
also hier Speichersysteme, die sind dann hier auch noch mit drin.
Und ansonsten habe ich dann aber noch rundherum relativ viel an Peripherie auf sowas,
System Ornership, werde ich dann also auch gleich nochmal kurz eingehen.
Gut, hierzu nochmal abschließend in diesem Kapitel eine grobe Übersicht,
keine Angst, das wird also jetzt nicht mit irgendwelchen Jahreszahlen
oder überhaupt irgendwo in der Klausur abgefragt.
Ich habe es einfach einfach nur mal so,
um das noch mal zu zeigen, zu veranschaulichen,
wo wir eigentlich heute gelandet sind.
So eine grobe Übersicht über die Geschichten. Also irgendwann kann man sagen,
so ganz früher hatte man eigentlich sowas wie ein Abakurs als erste Rechenhilfe.
Dann gab es also im Prinzip irgendwelche mechanischen Maschinen,
die also überhaupt nicht erst mal addieren subtrahieren konnten.
Irgendwann konnte man also auch noch multiplizieren und zumindest so ein bisschen teilen.
Dann hat Konrad Zuse, Ehrendoktor des Fachbereichs,
auch 1937, dann sag mal seinen ersten programmierbaren Rechner gebaut
Nicht 19.39, den noch mechanisch.
Dann eben eine Version elektromechanisch, also sprich mit Relais.
In den 40er Jahren gab es dann also quasi die ersten
Rechner, die mit Elektronenröhren betrieben wurden.
Und ja, das Ganze entwickelte sich dann eben entsprechend weiter.
Wie gesagt, hier sowas wie ein einfacher ABBA-Kurs,
also jetzt einfach
nur als Rechenhilfe
Besten mechanischen Rechenmaschinen, wo man dann quasi über irgendwelche Drehwalzen und irgendwelche Register,
die man da hin und her schaltet,
im Prinzip so was wie Additionen, Subtraktionen machen kann.
Später kamen dann eben noch die verbleibenden zwei Grundrechenarten dazu.
1822 hat Charles Babage dann, so eine Maschine,
also das ist jetzt hier ein Nachbau, gebaut,
mit der man dann also im Prinzip dann also schon
sowas wie logaritmieren und ein paar andere Sachen machen konnte,
die dann eben letztendlich dafür gedacht ist,
nautische Tabellen zu berechnen
Nicht, dann kam später sowas wie frei programmierbare,
Rechner, also frei programmierbar in dem Sinne,
ich addiere, ich subtrahiere, ich mache das,
ich nehme davon jetzt irgendwie einen Logarithmus und ich kann vielleicht noch was zwischenspeichern.
Also im Prinzip das, was man so beim Programmier, da war ein Taschenrechner machen kann.
Das Ganze, wo dann also letztendlich dann mit Lochkarten gesteuert,
in der Regel scheiterten diese Maschinen an der Mechanik. Nicht deswegen,
also steht auch auf Unvollendet oder sonstige,
weil, also das ist halt einfach das Problem nicht,
das sind also irgendwelche elektrischen, irgendwelche mechanischen Teile,
wo dann also die Zahnräder entsprechende ineinander greifen und dementsprechender Raddrehung,
ich sage, das ist eben 01, 2,
3, 4, 5. So,
und wenn das jetzt also irgendwo ein bisschen hakt oder nicht sauber gefertigt worden ist,
funktionierte das nicht.
Das ist dann,
dass hier ein Bild der Zusatz-Het 1 auch noch mechanisch,
die dann also im Prinzip auch über so einen Lochstreifen gesteuert wurde.
Das ist dann die Z3. Hier dann quasi elektromechanisch so über Telefonrelais gesteuert.
Hat also schon die Speicherkapazität von 64 Registern und in jenerer
riemigen Register kann man dann eine 22 Bitzahl ablegen
Wenn ich dann so die ersten Rechner, die dann danach kamen,
waren dann eben, wie hier zu sehen,
also mit Röhren bestückt und hatten dann eben auch schon einen großen Magnetspeicher,
in diesem Fall nannte sich das Trommelspeicher,
kann man sich dann also vorstellen, wie so eine schnell rotierende Trommel,
wo dann auf der Oberfläche dann eben auch Magnetinformationen abgelegt ist,
von der Speicherkapazität her, sagen wir mal, vernachlässigbar,
aber damals halt das, was man dann auch oft sieht,
sind dann Genjag, 1946 gebaut,
das ist dann im Prinzip so ein Röhrenrechner,
der Rechner ist letztendlich, muss man auch mal sagen,
also dieser ganze Raum, also das ist,
also hier dann alles voll mit irgendwelchen Röhren und dann gibt es für die Bedienung dann eben diese Programmierschränke,
das heißt, man hat hier drin jetzt,
nicht die sind dann über solche Kabel angeschlossen,
die Möglichkeit, also hier einfach sehr,
sehr viele Steckkontakte zu schalten und dann eben entweder ist es über einen Stecker durch verbunden,
dann ist es quasi eine Eins oder ist es über einen Stecker, da steckt kein Stecker drin, ist es nicht durchverbunden, ist es dann quasi eine Null.
Und so kann man dann also hier irgendwie sowas wie so einen Rom-Inhalt,
also alles recht, oh, nehmen wir mal Rüdereien programmieren.
Nicht zu der Zeit kamen dann auch die ersten Computerbugs auf,
beziehungsweise daher heißt es dann eigentlich auch Bug,
was für uns so selbstverständlich ist,
weil die Dinge arbeiteten also mit ganz früher eben letztendlich mit Relais,
elektromechanisch.
Später dann mit Röhren, auch da ist es so,
die Röhren erzeugen wunderbar schön Wärme
Das sah also irgendwie kuschelig warm, lockt Insekten an,
die fliegen da irgendwie rein, da die Röhren, ja,
prinzipbedingt irgendwo dann für die eigentliche Funktionsweise irgendwo auch eine Hochspannung benötigen,
kann es dann also sein, dass,
wenn sich da also irgendwo mal so eine Motte rein verirrt,
die dann da entsprechend Kurzschluss verursacht,
beziehungsweise in diesem Fall dann eben hier in so einem Zettel,
also von einem der Betreiber dann da rausgesucht,
also Morte must in relay, Panel F,
Relay 70, ne,
wo dann also im Prinzip die dann eben an von elektrischen Kontakten irgendwo erquämend hatte.
Gut, so geht das Ganze dann weiter. Also wie gesagt,
das sind immer so diese,
also wenn man da jetzt also mal in den,
ich hatte das ja in den Quellen mit angegehen, gegeben,
also da da mal irgendwie so durch diese Bildarchive da aussehen,
anfängende computertechnik da, also mal so ein bisschen durchguckt nicht.
Das sind dann also wirklich immer solche Schränke voll mit Elektronenrollen.
Gut, wie hat sich das Ganze dann letztendlich weiterentwickelt?
In den 50er Jahren kamen also schon die ersten Pipeline-Konzepte auf,
1964, das erste Modell dieser IBMS 360-Familie. Das ist das,
was ich also letzte beim letzten Termin da quasi da als Großreichenzentrum in Houston,
bei der Apollo 11-Mission vorgestellt hatte,
nicht der Raum mit diesen roten Schränken,
dann 1972 dann quasi der erste Acht-Bit, Mikrocomputer,
dann 78,
der 80,
86 darauf kommen oder damit kam dann quasi letztendlich in den
1981 dann eben der erste IBM-PC dann somit raus und dann eben 1980 gab es zu diesem Prozess dann den passenden Co-Prozessor, der dann Fließkommer-Berechnung machen konnte.
Auch das ist etwas, wo wir sagen, na gut,
das ist für uns heute selbstverständlich. Also wenn wir jetzt irgendwie Programmierung machen,
irgendwas schreiben, dann sagt man, gut,
also ich habe jetzt also irgendwo als Datentypen irgendwelche ganzen Zahlen,
Entedron, ich habe irgendwelche Fließkommer-Zahlen,
wo ich dann eben quasi mit Kommazahn arbeiten kann.
Wie die aufgebaut sind, folgt auch noch später in
der Vorlesung
Bei den ersten Computern gab es das nicht. Da gab es also wirklich immer
nur ganze Zahlen, beziehungsweise das, was diese Fließkomma-Formate sind,
hat man sich dann eben selber aus irgendwie mehreren Zahlen einzeln zurechtgebaut.
Die Prozessoren selber konnten eben auch nur mit den ganzen Zahlen rechnen. Das heißt,
wenn man jetzt irgendwie mit Fließkommazahlen was rechnen möchte,
hat man dann eben auch immer nur einfach jetzt eine Folge von Befehlen genommen,
die dann also letztendlich später eben in irgendwelche Bibliotheken gegangen sind,
womit man dann eben gesagt hat, okay,
damit kann ich jetzt Zwei solcher Zahlen addieren und eigentlich sind das aber lauter einzelne Schritte,
die dann eben dafür sorgen,
dass das Ganze dann eben auf der Hardware passiert,
die dann eigentlich jetzt nur mit ganzen Zahlen rechnen kann.
Gut, und dieser 80, 87,
das war dann eben quasi so eine Art Co-Prozessor,
dafür hatten also die allerersten Motherboards dann auch irgendwo immer noch so einen leeren Sockel mit drauf,
den konnte man dann also nochmal für teuer Geld dazukaufen,
reindrücken, dann war der Rechner also zumindest bei Fließkommerberechnung,
also gleich deutlich schneller,
weil dann wurde also das nicht mehr über eine Bibliothek
gemacht,
sondern über die entsprechende Hardware
Also das ist auch nochmal so ein Zeichen dafür,
also wo ich jetzt gesagt hatte, Unterscheidung,
Hardware oder Software ist letztendlich expalent, ist dann immer nur Kostenfrage,
Preis, Frage, was auch immer.
Gut, dann kam im Prinzip 1992 die ersten 64-Bit-Systeme auf,
dann auch mit Risskonzept, der Galpha insofern ganz interessant war,
der hat dann nämlich dafür gesorgt,
dass die Rechner also auf einmal deutlich schneller wurden,
die IBM-PCs damals so irgendwo so im Bereich von dran hat.
Nee, doch, irgendwie so ein 300-Mega-Herz,
so ein Deck Alpha
Wo dann also auf einmal irgendwie deutlich über ein Gigahertz getaktet,
deutlich höhere Performance, was aber daran liegt,
dass da intern, inneren eben ganz anders aufgebaut ist.
Diese Konzepte wurden dann aber später auch von anderen Rechnern beziehungsweise Architekturen übernommen. Gut,
dann kam sowas wie, also irgendwie Erweiterung, Richtung Multimedia,
also das heißt, dass man dann eben auf einmal irgendwelche Video-Audiosignalverarbeitung auf dem PC machen möchte.
Nicht ganz früher hat man damit so ein bisschen Textverarbeitung gemacht,
eine bessere Schreibmaschine war das und ein paar einfache Sachen,
ein paar einfache Grafiken, Und das,
was heute eigentlich ist, dass ich hier irgendwie was streamen,
Datenstrom dekodieren oder andersrum, also Datenstrom erzeugen,
war einfach nicht möglich,
weil dafür also die Hardware dann auch nicht von der Rechenleistung her nicht ausreichte.
Also dann Ende der 90er Jahre hat die Hardware das entsprechend hergegeben,
wo dann eben auch entsprechend ein Befehlsatz mit reingebracht und so weiter.
Nicht dann mehr Kernsysteme kamen dann 2006 raus, nicht erstaunlicherweise,
wie bei vielen Sachen dann eben auch erstmal spielemäßig Sony Playstation.
Erstaunlicherweise wurden die Dinger oder die Prozessoren dann also auch eine Zeit lang in Supercomputern eingesetzt,
weil das eben die ersten Systeme waren,
wo ich da so nach einem Gehäuse dann eben entsprechend so
ein Mehrkernsystem habe und realisieren kann und die also zumindest damals also hinsichtlich der Fließkomma-Rechenleistung,
also relativ unschlagbar waren.
Und später kamen noch so Virtualisierungskonzepte mit hinzu. Gut,
wie sieht das mit der Programmierung aus? Wie hat sich
das dann eben auch noch so ein bisschen entwickelt?
Nicht bei den ersten Computern, 50er Jahren kann man sagen,
gut, da gab es eigentlich noch keine Softwareunterstützung.
Alles, was wir jetzt heute machen,
was sie dann eigentlich auch im Rahmen des Informatikstudiums lernen werden,
Programmiersprachen, die entsprechenden Konzepte dazu wahr nicht,
sondern man hat einfach auf elementarer Maschinenebene programmiert.
Also das, was heutzutage dann Assembler-Programmierung wäre,
nicht wo man immer sagt, na,
will ich nicht machen, muss sie nicht machen.
Die Hardware da war damals dann eben natürlich noch vergleichsweise einfach
und langsam, also entsprechend kompliziert, Run-Technik.
Und das, was dann dort eigentlich auch gemacht wurde für
die Programmierung, ist dann irgendwie sogenannte Mikroprogrammierung.
Das heißt, da wurde dann eben dieses Konzept realisiert,
dass man in der Maschinensprache oder in dieser Assembler-Sprache eben einen
Befehl hat und dieser Befehl in mehreren kleinen einzelnen Schritten abgearbeitet wird.
Also das, was ich gerade eben auch schon ein bisschen
in dieser Prima gezeigt habe, Befehl holen Das Ergebnis landet irgendwo im Befehlsregister,
wird dann anschließend dekodiert, anschließend wir in irgendwelche Steuerleitungen gesetzt,
anschließend wird dann eben Befehlszähler nochmal ekrementiert, dann wird also abhängig von dem,
was der Befehl dann quasi aussagt, beispielsweise mit der Alu irgendwas gerechnet.
Das entspricht dann eigentlich so ein Mikroprogramm. Das heißt also,
ich habe immer für jeden Maschinenbefehl mehrere einzelne Schritte,
mehrere einzelne Takte und kann dann sagen, nach so und
so viel Teilschritten ist dann überhaupt erst der gesamte Befehl abgearbeitet.
Und die Abfolge dieser Teilschritte, das ist dann eben
dieses Mikroprogramm
Und in diesem Mikroprogramm stellt quasi dann Interpreter für das,
für diese, für den entsprechenden Befehlssatz, also für die Assembler-Sprache da.
Damit kann man dann eben sehr einfache Hardware realisieren und das ist dann
eben auch die Grundidee von den sogenannten Sisk-Maschinen-Komplex, Instruction-Set Computer,
wo man also dann auf der Assembler-Ebene sehr komfortable Befehlsätze hat,
die sehr viel können.
Also wenn man also heutzutage okay, ich muss jetzt mal so ein bisschen vorgreifen.
Das wird dann also erst irgendwie später kommen. Ich aber,
wenn man heutzutage Assembler sieht, beziehungsweise das,
was wir jetzt also benutzen werden,
sind das also diese sehr einfachen elementaren Befehle.
Hole irgendwas aus dem Speicher, tu das in den Register R15.
Anschließend der nächste Befehl, nimm den Inhalt von Register
R15 und inkrementiere den und schreibe das Ergebnis in R12.
Diese ganz einfachen Schritte. Das, was Diese CIS-Gerechner können
komplex instruction set computer ist, dass man sagen kann,
ich habe einen Befehl, der entspricht quasi dem,
was man heutzutage in der Programmierung mit einer Vorschleife macht.
Ich initialisiere einen Zähler, ich durchlaufe irgendein ganzes Array,
summiere alle Teile dieses Arrays auf und gleichzeitig inkrementiere ich natürlich
irgendwo dann meinen Schleifenindex und so weiter und so fort.
Dafür gab es einen einzelnen Befehl, der das gemacht hat.
Gut, warum? Wie gesagt, damals Programmierung in Maschinensprache.
Jetzt möchte man natürlich irgendwo mit dem Programm ein bisschen was ausdrücken.
Deswegen war die Maschinensprache quasi jetzt über diese Mikroprogrammierung so aufgebohrt worden,
dass man quasi mit diesem Befehlen dann,
also quasi sehr viele komplexe, mächtige Sachen machen konnte,
weil damals gab es eben noch keine Hochsprachen.
Heutzutage sieht das anders aus. Da gibt es Programmiersprachen,
die das quasi liefern, diese Komplexität oder diese Beschreibung auf
diesen höheren Abstraktionsebenen. Und es gibt eben Compiler,
die mir das übersetzen in die entsprechenden ganz einfachen primitiven Maschinenbefehle
Und heutzutage ist es eben so, das,
was also diese CIS-Rechner sind, ist quasi,
oder von der Grundidee her eigentlich, ausgestorben.
Nicht wahr sich dann also ab den 90er Jahren dann eigentlich
entsprechend andere Risskonzepte durchgesetzt haben. Auch dazu werde ich dann
noch genauer was sagen, wenn es dann also nachher,
also ein bisschen so um die Instruction-Set, also ein Befehlssatz geht.
Gut, auch historisch gesehen, die ersten Betriebssysteme.
Auch da muss man sagen, gut,
also ganz früher die ersten Rechner wurden eben von einer
einzigen Person benutzt
Der Anwender war der Programmierer und war der Operator.
Der hat also quasi ungefähr sein Programm jetzt in so
einen Ähnlichen klar, also irgendwie dann reingesteckt.
Hat das Ding also irgendwie gestartet. Und wenn da jetzt
nicht gerade irgendwo eine Motte im Relais festhing,
dann hat er da also irgendwie was berechnet und in irgendwelchen
Registern konnte man irgendwas auslesen oder sich noch ausdrucken lassen.
Führt natürlich dazu, dass also diese unendlich großen teuren Maschinen
natürlich nicht richtig ausgelastet werden.
Und man also doch relativ viel technische Arbeit und alles
mögliche andere
machen muss
Später kam dann eben letztendlich als Zwischenschicht Betriebssysteme hinzu,
die sogenannten System-Calls, dann eben der Batch-Betrieb, das heißt,
man hat also seine Programme irgendwo jetzt geschrieben,
hat die irgendwo abgegeben, die liefen durch.
Und ein paar Stunden später konnte man sich also seine Ergebnisse abholen.
Also der klassische Batch-Betrieb war dann eigentlich so das,
was man so hatte in den,
ich sag jetzt mal so 60er Jahren,
Lochstreifen oder Lochkarten
Also die Programmierung war, dass man sich also im Programm oder Idee,
also irgendwo auf dem Zettel skizziert hat, irgendwas gemacht hat,
also an so einer Maschine so einem Kartenstanzer gesessen hat und da jetzt also quasi die einzelnen Programmbefehle,
jeder Programmbefehl war dann eine Lochkarte,
da jetzt also irgendwie reingetippt hat,
anschließend hat man dann also hinterher dann so ein Stapel Lochkarten gehabt,
hat den also irgendwo im Operating abgegeben,
nicht und die haben das dann,
also wenn der Rechner mal gerade nicht ausgelastet war,
dann eben entsprechend das Ding reingefüttert,
durchlaufen lassen,
irgendwo waren dann also hoffentlich Ausgaben,
wo man dann also so ein Stapel Papier rausbekommen hatte und
den konnte man sich dann so ein paar Stunden später abholen
Gut, die nächste Generation,
der Rechner war da im Prinzip nach den Release und den Röhrenden,
also quasi mit Transvestoren,
möglich durch die Erfindung der Transvestoren 48 von Buddy in Bradon & Shockley,
sind dann deutlich schneller und zuverlässiger als Röhren,
nicht damit wohnen, die Rechner also auf einmal sehr viel kleiner,
also ein Beispiel Digital Equipment Corporation,
die PDP1. Nicht da hatte man also schon unendlich viel Speicher,
4000 Worte, die dann jeweils 18 Bittbreit waren.
Also auch das sind also irgendwelche Mengen oder Dimensionen,
wo man sagen kann, das geht heutzutage also irgendwo im CPU-Kern irgendwo mitunter,
liefen mit 200 Kilohertz-Taktfrequenz, kosteten dann nur noch 120.000 Dollar.
Und es gab schon sowas für so eine Art grafische Ausgabe,
wie bei allen solchen Sachen haben da natürlich,
also die Programmierer dann auch gesagt, naja,
also um das Thema zu testen,
müssen wir eine anspruchsvolle Anwendung machen,
haben da also da auch schon irgendwie die ersten Computerspiele,
also irgendwas,
was so Marke Pong,
was dann also irgendwie so über die Dinger flitzte,
da rein programmiert
Nachfolger von dem Ganzen, war dann die PDP 8,
kostet dann nur noch 16.000 Dollar. Das war dann eigentlich so der erste Rechner,
der dann schon so ein bisschen so diesen direkten von Neumann-Konzept entsprach.
Also ein Muss-System war für die damalige Zeit, also für sehr erfolgreich.
Wenn man also irgendwie auf Wikipedia oder an irgendwelchen anderen Quellen da mal nachguckt und dann mal sieht,
also wie komplex, sage ich mal,
jetzt die CPU so einer PDP 8 war,
das war dann also irgendwie sowas im Bereich von,
ich glaube, irgendwie so 20.000 Transistoren oder so,
nicht wo man sagen kann, auch das sind also irgendwo Dimensionen,
werde ich also, ja, heute vielleicht auch noch zu kommen.
Nicht, das sind also irgendwo so Dimensionen,
wo man sagen kann, naja gut,
also inzwischen die großen CPUs ist man jetzt also irgendwie im Bereich von 8 Milliarden Transistoren,
also das zeigt eben eigentlich auch schon,
wie sich das Ganze so ein bisschen entwickelt hat.
Nicht Speicherung damals eigentlich genauso. Ich hatte gesagt,
ganz früher eben sowas wie Lochkarten oder Lochstreifen, das ist also sowas hier.
Ich wurde dann also quasi dann immer hier jeweils Ein so
ein Streifen aus entweder fünf oder in diesem Fall dann acht,
solchen gestanzten Punkten dann eben quasi für eine einzelne Zahl oder ein einzelnes Zeichen eines Zeichensatzes steht.
Dann kamen später Magnetbänder, Magnettrommel, dann so die ersten Festplatten.
Das ist also hier dieses Tal, nächste Dimension von einer Waschmaschine ungefähr.
Ich fünf mega weit spare ich ja, 600 Millisekunden Zugriffszeit.
Das heißt, wenn ich jetzt also irgendwie was davon lesen möchte,
dauert das eine halbe Sekunde. Also auch das sind Dimensionen, die da recht behandlung sind. Gut,
später kamen dann die ICs, Entegrated Circles,
1958 von Philipp Noise und ich glaube John Cavy,
entwickelt, womit man dann im Prinzip auf einem Stück Silizium,
jetzt eben nicht nur ein Transistor,
sondern entsprechend mehrere realisieren kann und dieses mehrere geht eben bis zu inzwischen,
also die Zahl habe ich dann gleich noch, 30 Milliarden Transistoren Nicht,
wo man dann sagen kann, gut, also damals fing das eben mit Arnim Dutzenden Hunderten an.
Nicht also im Prinzip erstmals mit realisiert bei dieser IBM 360-Serie.
Hier sieht man noch so ein paar technische Eigenschaften von den unterschiedlichen Maschinen.
Wie gesagt, interessant dann, also auch nur sowas. Also wie man hier so sieht,
also bei dem Top-Modell der Reihe, Zykluszahl, 250 Nano-Sekunden,
wenn ich das in Faktfrequenz von 4 Megahertz,
heutzutage sagen wir, na gut,
also wenn ich hier so den entsprechend gut gekühlten ausgestatteten Desktop habe,
nicht dann ist man nur mit 4 Gigahertz dabei,
dass da so ein Faktor tausende der Nase
dazwischen liegt
Gut, und dann kam ihm nach diesen ersten Sachen,
VLSI, Very Large Scale Integration, da spricht man eben quasi von,
wenn man jetzt mehr als 10.000 Transistoren pro Shipart.
Führt dann eben dazu, dass man eben sagen kann,
der gesamte Prozessor passt auf einen Ship,
weil auch das muss man sagen,
nicht früher die Rechner, weswegen waren das solche Schränke,
weil die CPU war jetzt eben nicht ein kleiner schwarzer Käfer,
sondern also zwei Schränke voll mit irgendwelchen Steckbrettern von irgendwie
so kleinen ICs,
war dann eben letztendlich die eine CPU
Nicht gut, damit hat man dann eben erreicht,
dass man also eine deutlich steigende Integrationsdichte hat, immer mehr Funktionen realisieren kann.
Und das führt dann eben letztendlich dann zu dem,
wo wir jetzt also heute angekommen sind. Und gut,
wo stehen wir inzwischen? Also man hat also Massenfertigung,
sehr billige Prozessoren, durch die Miniaturisierung eben entsprechend kleine Geräte.
Gut, das ist ja auch nur so die erste Workstation,
also dann schon, vielleicht zwar auch immer noch irgendwie so in Dezentergröße,
aber das ist dann eigentlich so das,
was dann so mit dann kam
Gut, generell die Rechner, wo sind wir eben heute?
Hier einmal nur irgendwie auch, ich glaube,
aus dem Tarnbaum ist das, rausgenommen, wo man eben sagt,
okay, ich habe eigentlich ein sehr, sehr breites Spektrum.
Ich kann sagen, ich habe also irgendwie die Glückwunschpostkarte,
also irgendwie so ein Teil, was ich aufklappe,
was also irgendwie so ein Mieb irgendwie vor sich hin trötet,
mit so einem Pierzug Vega, die darf nichts kosten,
50 Cent.
Ich habe die Mikrocontroller, die jetzt also im Prinzip in irgendwelchen Kleingeräten für Steuerung eingebaut wird.
Ich habe dann meine mobilen Computer, ich habe dann Personal Computer von bis. Nicht,
dann landet man also quasi bei Workstations,
Großrechner und ihm das, was dann die Supercomputer sind,
also die dann also irgendwo in Dimensionen preislich sind,
wo man dann also quasi dann entsprechend einige zig Millionen braucht,
um ein Nasen- und System zu realisieren.
Gut, damit habe ich jetzt nämlich eigentlich die Überleitung zu dem,
was ich heute noch kurz vorstellen werde,
Moas Law
Mit Mors Law ist quasi diese Wachstum oder die Wachstumskurve gemeint,
die sich eigentlich dort ergibt, wo man jetzt eben sagt,
okay, wie hat sich die Mikroelektronik oder generell die Computertechnik weiterentwickelt.
Und das, was wir ja immer sehen, dass man sagt,
okay, ich kriege eigentlich immer bessere Technologie, immer kleinere Transistoren,
dadurch, dass die Materialkosten proportional zur Schifffläche sind,
das ist also auch mal so ein ganz interessanter Faktor,
kann man also auch mal grob sagen,
also im Großen und Ganzen bleiben Computerpreise eigentlich stabil
Also ich kann sagen, vor,
sagen wir mal so Ende der 80er Jahre konnte man eben
irgendwo so einen PC kaufen mit Monitor und mit irgendwas und
ist dafür dann also irgendwie etwas über 1000 marktlos geworden.
Inzwischen kann man sagen, gut,
wenn ich jetzt also irgendwie so einen PC kaufe,
dann bin ich also auch irgendwo so im Bereich zwischen 500 und 1000 Euro.
Gut, der heute kann,
um Größenordnungen mehr und ist schneller, aber das,
was innen drin ist,
eigentlich so diese Preissache,
also das ist
relativ konstant geblieben
Gut, führt eben dazu, Technologie wird immer kleiner.
Die Chips bleiben im Großen und Ganzen immer gleich oder ähnlich groß,
beziehungsweise okay, also in den letzten Jahren sind sie teilweise noch ein bisschen gewachsen,
ist zurzeit aber auch relativ zum Stillstand gekommen.
Das heißt also, ich habe eigentlich entweder die gleiche Funktion und
immer kleinere und billigere Chips oder die Größe bleibt gleich und ich kriege dann immer leistungsfähigere Systeme.
So, und das, was Gordon Moore,
1965 dann quasi als und war es immer so als Moore Slow gilt,
ist, dass man eben, oder dass er dann festgestellt hat,
also die Speicherkappe, also die Kapazität von ICs,
vervierfacht sich ungefähr alle drei Jahre.
Das führt dazu,
wenn man sich das dann eben mal so überlegt,
irgendwas in einer bestimmten Zeit, vervierfacht sich immer,
ich grabe eigentlich ein, exponentielles Wachstum.
Das heißt, insgesamt die absolute Anzahl wächst exponentiell
Also die Frage war also, ob das heutzutage auch noch
so gilt und dass das nun gerade bei CPUs inzwischen nicht mehr ganz so gilt.
Auch da muss man eigentlich sagen, ja, das ist,
also dafür gibt es dann teilweise noch andere Gründe,
beziehungsweise es kommt darauf an, was man als Kenngröße nimmt.
Wenn ich als Kenngröße nehme, die Speicherkapazität,
dann gilt das auch immer noch,
wenn ich als Kenngröße nehme sowas wie Transistoranzahl, geht das auch immer noch.
Wenn ich als Kenngröße nehme, sowas wie Taktfrequenz,
dann ist dieses exponentielle Wachstum abgeschwächt worden,
was aber eigentlich jetzt eher einen anderen Problem liegt,
dass man die Systeme nicht mehr gekühlt bekommt.
Wenn man die Rechenleistung nimmt, gilt das exponentielle Wachstum auch immer noch,
ist jetzt allerdings auch ein bisschen abgeschwächte. Gut,
werde ich gleich noch ein paar Grafiken zu vorstellen oder so nicht,
aber also grob gesagt, man kann immer noch so sagen,
so ungefähr gilt das noch.
So, wie gesagt, also das Ursprungspaper von Gordon Burg,
also da ging es wirklich nur um die Transistoren in Speicherchefs,
also die reine Speicherkapazität
Und warst da dann auch noch festgestellt hat, ist,
dass man eben bei einer bestimmten Integrationsdichte irgendwo so eine Kostenoptimum hat.
Was ist damit gemeint? Die Chips wären ja so irgendwie
auf solchen Wave-Un produziert. Also früher waren das mal solche Selitium-Scheiben,
also irgendwie so von Zoom-Durchmesser, inzwischen sind wir 45 Zentimetern,
16 Saulwaver. Und die Frage ist jetzt,
in einer Technologie kriege ich darauf jetzt eben,
wenn ich jetzt eine bestimmte Größe habe,
immer mehr Transistoren,
immer mehr Funktionen unter
So, und jetzt ist es immer so, dass bei der Fertigung
Fertigungsfehler auftreten können. Das passiert dann zwar in irgendwelchen Reihenräumen,
es kann aber immer noch mal sein, dass also was weiß ich,
also irgendwo das einzelne Staubkorn da drin ist.
Und auf dem Wafer letztendlich aufschlägt so. Das heißt,
wenn dort sowas passiert, ist die entsprechende Komponente oder das,
was man dort fertigen möchte, defekt.
So, und jetzt kann man eben sagen, okay,
wie groß mache ich eigentlich die Chips daraus?
Wenn ich die Chips klein mache Und ich habe jetzt so eine statistische Verteilung,
wo ich sage, da ist ein Effekt, da ist ein Effekt,
da ist ein Effekt, dann betrifft er Defekt.
Ja, nur relativ wenig Siliziumfläche, weil ich dann ja also
eben bei kleinen Chips dann eben wirklich nur diese einzelnen Chips kaputt habe.
Wenn ich jetzt sage, letztendlich der gesamte Wafer ist das
Chip und das ist ein einziger Defektor auf, dann ist dieser komplette Wafer kaputt.
In dem Zufolge kann man sagen,
es gibt dann so eine Art Badewannenkurve,
also so eine U-förmigen Verlauf, wo man sagen kann,
also für eine bestimmte Technologie habe ich dort ein Kostenminimum,
wie weit ich
die Integration mache
Und das führt dazu, dass man eben sagt,
also auch wenn es technologisch machbar ist,
heute die Chips,
also jetzt nicht nur irgendwie vier bis sechs Quadratzentimeter groß zu machen,
sondern man könnte also aus so einem Wafer natürlich also auch irgendwie so einen Chip rausschneiden,
der also noch noch deutlich mehr kerne und noch deutlich mehr Rechenleistung hat,
aber es lohnt sich eben aufgrund dieser Fehler nicht.
Nicht, das ist also eigentlich auch etwas,
was in dem Original Paper von Gordon Moore mit drin ist,
das ist im Prinzip in diesen Grafiken zu sehen,
wo ich dann also quasi jetzt für so
eine Technologie dann immer das jeweilige Kostenminimum habe
Gut, ansonsten Moas Gesetz,
also das, was er da also beobachtet hat,
also das ist also aus dem Originalpaper, zu sehen,
nicht also hier die Anzahl der Jahre oder hier die Jahre,
die sich entwickeln, hier dann also eine logarithmische Skala,
wo ich dann eben die Funktion drin habe.
Logarithmische Skala heißt dann eben entsprechend dieses Hier sind irgendwie die Exponenten,
also was weiß ich, 10 hoch 1, 10 hoch 2,
10 hoch 3, also 100.000 und so weiter.
Das heißt, wenn ich ein exponentielles Wachstum habe und das
in so eine logarithmische Skala eintrage,
kriegt man in der Regel eine schöne Grade.
Und genau das ist das, was also in diesem Paper
drin stand, was Gordonmoor dann eben gefunden hat.
Und die Frage, die uns jetzt natürlich wieder interessieren,
könnte es, okay, wird das noch so weitergehen?
Das ist das, was sie jetzt also mit diesem Kapitel
noch so ein bisschen kurz beleuchten werde.
Noch kann man sagen, das war auch das,
was jetzt so ein bisschen hier diese Frage war, läuft dieses Wachstum immer noch?
Es gibt dann immer so ein Zusammenschluss, ITAS,
International Technology Roadmap for Sammy Conductors von den ganzen großen Chip-Herstellern und so ein paar anderen Thinktanks,
die also jährlich quasi immer so einen Report rausgeben.
Kann man also hier entsprechend abrufen,
wie sich die Technologie letztendlich,
wie sich das Ganze dann eben letztendlich entwickelt,
zurzeit geht das also bis etwas übers Jahr 2030 hinaus
und welche Probleme auftreten werden
Also wenn man da also so Technologe in der Technik mal
interessiert ist oder so, lohnt es sich da also mal reinzugucken.
Gut, ansonsten kann man sich eben sagen, Moas Law,
also hier eben nochmal Anzahl der Transistoren pro Speichership.
Also jetzt, auch hier sieht man Anzahl der Jahre,
hier eben auch wieder zu beachten, diese logarithmische Skala,
nicht 1, 10, 100.000, 10.000, 100.000 Millionen und so weiter.
Nicht, wo man dann eben sieht,
wie die Anzahl der Transistoren auf den Speicherships gewachsen ist.
Und auch da kann man dann eben irgendwie versuchen,
so eine gerade reinzumatchen und sie dann eben,
man hat irgendwie so ein jährliches Wachstum von 60 Prozent
Ähnliches gilt dann eben auch für die Prozessoren,
also hier in diesem Fall an der Grafik,
also aus dem Tarnbaum, bei den Prozessoren eines bekannten Chipherstellers,
wo man dann eben sieht, bis in diesem Fall dann also 2010,
wie sich das entwickelt hat, wenn man jetzt guckt,
okay, wie geht das also letztendlich weiter zurzeit.
Gut, die letzten Zahlen, die ich jetzt also gefunden habe,
wobei das jetzt also nicht der aktuell neueste Xeon-Chip von Intel ist,
aber Anfang dieses Jahres vorgestellt ist in Broadwell, E5-Version 4 mit 7,2 Milliarden Transistoren,
Nun ist das alles nicht nur auf einen Hersteller beschränkt.
Es gibt also auch noch Alternativen von Spark M7,
von Oracle, früher mal San Microsystems,
wurden dann also aufgekauft aus dem letzten Jahr,
also der größte Ship liegt, also über 10 Milliarden Transistoren,
aber auch das ist natürlich noch nicht Ende der Fahnenstange,
wo man zurzeit also ist, ist eigentlich schon eher bei den Grafikrecheneinheiten,
deswegen also hier jetzt GPU,
nicht also die neuesten Pascal Chips von Nvidia,
da ist man sogar 15,3 Milliarden Transistoren.
Und auch da geht noch was drüber,
wenn man sogenannte FPGAs nimmt von Yps von Altera,
beziehungsweise die wurden vor,
ich glaube, zwei Jahren von Intel aufgekauft,
von denen die ganz große Serie ist derzeit bei über 30 Milliarden Transistoren,
die da drauf sind.
Also die Frage war, wofür die Abkürzung FPGA steht,
hätte ich jetzt also auch gleich noch gebracht,
ist ein Akronym für Field Programmable Gate Array
Ist eine Art Technologie, mit der man programmierbar,
also in Hardware programmierbare Chips machen kann.
Also bei normalen CPUs oder Grafikkarten oder so,
sagt man ja, okay,
ich habe an dieser Stelle einen Register und ich habe an dieser Stelle
eine Alu und die sind so und so miteinander verschaltet und das wird in Silizium gegossen, The Face.
Bei FBGAs kann man eben sagen, ich beschreibe das,
was die Hardware tun soll und anschließend habe ich die Möglichkeit,
quasi generische Hardware-Einheiten so zu programmieren,
dass sie sich eben entsprechend dieser Beschreibung verhalten.
Das heißt, ich kann das, was dann eben auch
diese Trennung zwischen Hardware und Software ist, damit also letztendlich dann überwinden.
Ich kann dann eben auch sagen, ich kann also wirklich
speziell mal einen Algorithmus eins zu eins in Hardware übersetzen.
Warum macht man das nicht für alles?
Also zum einen sind die Dinger also nicht ganz billig.
Zum anderen arbeiten die dann also auch mit deutlich anderen Taktfrequenzen,
weil diese Unkonfigurierbarkeit der Hardware wird natürlich dadurch erreicht,
dass sich jetzt also nicht so ausgeknautschte Designs und spezielle Datenpfade habe,
wie das jetzt bei Standards, CPUs der Fall ist,
sondern dadurch, dass sie quasi alles können müssen.
Also man hat da innen drin Blöcke, denen kann ich eben sagen,
du bist ein Adierer oder denen kann ich sagen,
du bist ein Register oder denen kann ich sagen,
du bist ein Teil von einem Speicher.
Aber dadurch, dass sie quasi alles können müssen, ist das da nicht optimal.
Die Dinger werden benutzt, entweder für sehr spezielle Anwendungen,
also wo die zum Beispiel jetzt in den letzten in der letzten Zeit,
ja sagen wir mal, erfolgreich waren, war,
also irgendwie so Bitcoin-Mining, wo man eben sagt,
ich nehme Algorithmus, gieße den direkt irgendwie in Hardware um.
Solche Sachen. Ansonsten wird mit sowas Prototyping gemacht. Wenn also irgendwie eine Firma,
Intel oder Nvidia,
also einen neuen Prozessor oder eine neue Grafikrecheneinheiten macht,
dann sagen die jetzt natürlich nicht,
also ich überlege mir jetzt also irgendwie so ein Hardware-Design,
er zeugt da draußen, also irgendwie für mit Vorlaufkosten,
also irgendwie für mehrere Millionen,
also ein Stück Silizium und stelle hinterher fest,
oh schade,
der rechnet falsch
Und dieses Prototyping kann man dann eben auf solchen FPGAs machen,
beziehungsweise entsprechenden Schränken, die dann also voll sind mit solchen Dingern.
Quasi eine Art Hardware-Emulation,
die verhalten sich dann eben wirklich wie der Prozessor oder wie die Grafikreicheneinheit,
laufen natürlich noch nicht mit der vollen Geschwindigkeit,
sind also noch deutlich langsamer, aber man kann eben auf solchen Emulationssystemen,
also schon ein Betriebssystem buten.
Oder eben OpenGL-Bench-Markt durchlaufen lassen oder irgendwie sowas. Das dauert
dann zwar unendlich lange, aber im Prinzip geht das.
Und wenn das quasi da drauf gelaufen ist, dann weiß man,
okay, jetzt lohnt sich diese Investition in die eigentliche Chipfertigung,
weil eine neue Hardware-Architektur, mein Befehlssatz.
Alles, was ich mir da überlegt habe, wird eben funktionieren.
Also dafür sind solche FPGAs ganz gut. Wie gesagt,
also vielleicht ganz am Ende, wenn noch entsprechend Zeit ist und
nochmal so ein bisschen was zu dem Bereich Hardwareentwurf kommt,
kann ich dazu also dann auch nochmal deutlich genauer was sagen.
Gut, Kosten pro Komponente hatte ich ja schon vorgestellt. Ja,
dann würde ich jetzt noch mit dieser einen Folie abschließen,
weil das ist also etwas,
was dann im Zweifelsfall noch zumindest für die Übungsaufgabe
interessant sein könnte
An, und zwar, wie gesagt, Moas Law.
Ich habe dieses exponentielle Wachstum. So,
und wenn ich jetzt also sage,
wie entwickelt sich die Leistung oder die Rechnung,
die Performance von den Rechnern nicht, dann kann ich eben sagen,
okay, ich habe zu einem bestimmten Zeitpunkt,
nämlich jetzt, eine bestimmte Leistung L. Noll.
Und hier ist es beispielsweise mal drin, dass sich diese Leistung alle 18 Monate verdoppelt.
Nicht, dann würde die Leistung zu einem Zeitpunkt demzufolge dann sein,
zwei hoch, Tee durch 18, mal L.0.
Damit kann man dann eben sehr einfach ausrechnen,
wie sich das Ganze letztendlich dann über die Jahre entwickelt,
wenn ich jetzt eben quasi ein Verhältnis habe, meinetwegen jetzt für Doppelung alle 18 Monate.
Und je nachdem, also ob man jetzt irgendwie Tagfrequenz,
sparliche Kapazität oder was auch immer nimmt,
sind dann natürlich hier entsprechend andere Zahlen anzusetzen, aber letztendlich ist das das,
womit man dann also solche exponentiellen Anstiege berechnen kann. Und wie gesagt,
das wäre jetzt also hier sowas wie Wachstum für die Prozessorleistung,
nicht wo man sieht,
also nach einem Jahr bin ich dann eben 1,5-8 Mal so schnell,
nicht nach drei Jahren bin ich dann eben quasi viermal,
nicht das ist ja das,
was das in der ursprünglichen Formel von Gordon War drin stand,
also für Vierfachung der Speichekapazität, alle drei Jahre,
nicht und so weiter und so fort.
Also nach sechs Jahren habe ich dann 16 Mal so viel
Speichekapazität und so weiter. Gut, ja, den Rest
dieses Kapitels werde ich dann entsprechend nächstes Mal weiter vorstellen.
Jetzt habe ich sie schon fünf Minuten zu lange bespaßt.
Dann kann ich jetzt nur sagen,
ein schönes Wochenende und das soll es
dann gewesen sein