Es soll losgehen. Ja, willkommen zur zweiten Rechnerstrukturenvorlesung.
Noch eine Frage, passt das mit der Helligkeit so oder
soll ich die Sonne noch versuchen auszusperren und die Verdunklung runterfahren?
Passt. Gut. Ja. Gut,
dann würde ich das jetzt erstmal so lassen,
also wenn es sonst doch zu doll werden sollte,
müssten sie sich nochmal melden
Gut, vorneweg noch mal kurz, was organisatorisch ist.
Ich hatte es letztes Mal ja, also sagen wir mal schon,
soweit angekündigt. Ich bin jetzt ja so gerade dabei,
noch zwei weitere Übungsgruppen zu organisieren, die jetzt am Montag
von 13 bis 14 Uhr und von 14 bis 15 Uhr stattfinden.
Wer die leitet und wo das dann genau stattfindet, das weiß ich noch nicht.
Das wird sich also moder früh entscheiden. Andererseits,
das hatte ich also jetzt ja auch letztes Mal schon soweit kurz angekündigt,
wird das so aussehen,
dass wir uns War der Einteilung in den Übungsgruppen bei den Parallelengruppen immer an,
sagen wir mal, also jetzt wirklich sämtliche Gruppen an diesen zuerst genannten Raum treffen.
Das heißt also, Montag wäre das dann also irgendwie,
alle die Montag von 12 bis 13 Uhr Übung haben, versammeln sich irgendwie
4D 1199. Dort sind dann eben die beiden Übungsgruppenleiter bzw. hier
werden dann eben entsprechend drei Übungsgruppenleiter und dann würde sich das
dann eben entsprechend in die Gruppen aufteilen.
Weiterhin habe ich bei den Übungen jetzt das erste Aufgabenblatt online gestellt.
Also entweder wie hier zu finden auf der Webseite.
Es sollte sonst auch im Prinzip Überstine verlinkt sein. Und gut,
ich denke mir, das wäre dann von ihnen aus
dann Montag oder Dienstag an der Übungsgruppe noch kurz anzusprechen.
Die Übungsgruppenleiter werden dann auch noch so ein bisschen was zur Arbeitsweise sagen,
eben nochmal allen naheliegen,
dass man nicht als Einzelkämpfer arbeitet,
sondern eben in Dreiergruppen
Gut, dann kann man das nochmal besprechen. Und Abgabetermin,
ich schreibe das dann auch hier immer jeweils mit dran,
beziehungsweise es steht auf den Blatt dann auch selber drauf,
wäre dann eben bis zum nächsten Freitag,
um 12 Uhr mittags, sagen wir mal so,
es sind immer irgendwie so Stichzeit bei den Übungsgruppenleitern und die werden dann noch entsprechend sagen,
wie sie das dann am liebsten hälten,
also am besten gleich in elektronischer Form, aber gut,
das denken wir,
kann man dann entsprechend klären.
Gut, damit wir für die Übungsgruppen jetzt noch ein wenig Stoff bekommen,
werde ich also jetzt nochmal entsprechend zu sehen,
dass ich jetzt noch ein bisschen rate.
Letztes Mal hatte ich ja aufgehört mit dem Gedankengang,
wo es darum geht, also dieses Semantic Gap zu beschreiben.
Das heißt, der Mensch in einer natürlichen Sprache hat halt
eben immer irgendwie dieses Kontextwissen. Die Maschine oder der Computer
arbeitet eben nur mit wirklich trivial einfachen Operationen und irgendwo dazwischen
muss man dann halt eine Übersetzung von der Sprache über
mehrere Zwischenstufen in die vergleichsweise einfache Sprache oder die einfachen Anweisungen
vornehmen,
die dann
ein Computer versteht
Gut, ich hatte dann eben hier noch ein bisschen was
für den Rückwirkungen gesagt. Grob so ein Schema,
wie das jetzt mit mehreren Ebenen aussieht, wäre jetzt also auf dieser Folie,
das hatte ich also hier aus dem Buch von Tarnbaum, Structured Computer Organization entnommen.
Wird das jetzt also hier gar nicht weiter vorlesen oder vorstellen,
weil drei Folien weiter kommt das dann nochmal mit einem
praktischen Beispiel und dann wird also ein bisschen klarer,
was mit diesen unterschiedlichen Ebenen gemeint ist.
Bei dieser Umsetzung jetzt von der Hochsprache oder von natürlichen Sprachen,
in denen man jetzt also quasi seine Algorithmen formuliert,
in das, was der Computer, die Maschine versteht.
Kann man jetzt eben immer sagen, dass jede Ebene quasi
ihre eigene Sprache oder Sprachsyntax hat. Und mit jeder,
sagen wir mal, höheren Ebene, die Sprachen oder das,
was man ausdrücken kann, eben auch vergleichsweise umfangreicher wird.
Für die Übersetzung zwischen diesen Ebenen gibt es jetzt zwei Mechanismen,
die dort als Übersetzer eingreifen können.
Zum einen kann ich das mit einem Compiler machen.
Dabei wird jetzt eben für jeden Befehl einer Sprache beispielsweise L1
Dieser Befehl übersetzt in eine Folge oder eine Menge einfacherer Befehle
, in eben einer nächstniedrigeren Ebene in der Sprache L0.
Und im Gegensatz dazu gibt es dann eben den Weg der Interpretation. Das heißt,
da hat man dann eben einen Interpreter,
der direkt zur Laufzeit eben ein Programm oder ein Algorithmus in einer Sprache,
also beispielsweise CL1,
ausführen kann und der dann eben zur Laufzeit eben für jeden Befehl L1 diesen umsetzt,
in Befehlsfolgen von L0 und die dann eben entsprechend interpretiert und ausführt.
Das führt uns dann zu dem Begriff der virtuellen Maschine,
und zwar ist eine virtuelle Maschine einfach dadurch gekennzeichnet,
dass ich sage, wenn ich jetzt einen Interpreter nehme,
für den sind die Befehle der Sprache,
die ja quasi ausführt,
erstmal nichts anderes als Daten,
die ja ebenentsprechend interpretiert und dann eben in so
eine Folge aus L0 umsetzen kann
Das heißt, der Interpreter stellt für die Sprache L1 eben eine virtuelle Maschine dar.
Das heißt, er kann eben zur Laufzeit, diese Sprache L1 ausführen.
Wenn ich nur mithilfe so eines Interpreters, ist es dann
eben letztendlich möglich, jegliche Art von Maschinen zu simulieren.
Und zwar eben dann auch entsprechend einfacheren Maschinen oder einfacherer Hardware M0. Wie gesagt,
der Programmierer muss sich dabei jetzt also nicht um diese Übersetzung zwischen diesen Schichten kümmern,
sondern das ist ja dann entsprechend in dem System vorgegeben.
Nachteil dieser Interpretation, ich denke mal,
das ist dann auch direkt klar, ist natürlich,
dass eine virtuelle Maschine vergleichsweise lahmsamer ist in der Abarbeitung,
weil natürlich jetzt also nicht eigentlich nativ,
also eine Sprache oder eine übersetzte Sprache L0 abgearbeitet wird,
sondern also eine andere Hardware,
da dann eben irgendwo zur Verfügung steht und die dann eben
diese Befehle aus L1 interpretieren muss und dann eben zur Ausführung bringt
Gut, also auch da ist es dann möglich,
so eine virtuelle Maschine jetzt über mehrere Ebenen, zumindest formal gesehen, hierarchisch aufeinander aufzubauen.
Irgendwann auf der alleruntersten Schicht brauche ich dann natürlich
nur lediglich irgendwelche Hardware, mit denen man arbeiten kann.
Gut, die ist es jetzt natürlich vergleichsweise abstrakt.
Ansonsten der Begriff der Interpretation oder Interpretativen aus Führung,
den gibt es dann ja also auch bei Programmen oder in der Programmierung dann eben auch.
Was man inzwischen aber ja eben auch sehr häufig hat,
ist eben, dass man also wirklich jetzt solche Virtualisierungsmechanismen,
also jetzt auch auf relativ sehr hohen abstrakten Ebenen hat,
wo man jetzt über virtuelle Maschinen wirklich einzeln oder unterschiedliche Hardware mit unterschiedlichen Betriebssystemen betreiben kann,
dass man da also jetzt wirklich auf der relativ hohen Betriebssystemebene
arbeitet und dann eben in oder mit seinem Rechner quasi jetzt ein Betriebssystem X irgendwie laufen hat,
also beispielsweise ein Linux und dann also in einer virtuellen Maschine,
also in Windows laufen hat oder umgekehrt oder was auch immer.
Also da lassen sich dann eben auf der Ebene dann auch Virtualisierung umsetzen. So,
wenn man sich jetzt diese Ebenen ansieht,
hat man eigentlich so als übliche Einteilung nach unten hin zur
Hardware eigentlich erstmal sowas wie irgendwelche elektrischen oder elektronischen Charlottelemente,
mit denen also im Prinzip jetzt in den Chips oder in den ICs gerechnet wird.
Das wären im Prinzip wie Transistoren, also Franziska-Ebene. Wenn ich die jetzt also geeignet zusammenschalte,
beziehungsweise sind sie geeignet, zusammengeschaltet,
habe ich dann eben irgendwie sowas wie einfache,
logische Grundschaltung, dass ich eben sage,
wenn ich jetzt diese vier Transistoren so und so zusammenschalte und die Transistoren von der und der Art sind,
dann verhält sich das Ganze wie ein Nantgatter.
Und dann bin ich jetzt eben von der Elektrotechnik,
also auf einmal jetzt in der Bulschen Algebar gelandet, habe dann eben Logikschaltung,
kann eine einfache Gatter oder sowas wie speichernde Elemente, also Flipflops aufbauen.
Und das wird dann eben wieder zu komplexeren Schaltungen zusammengefasst,
dass ich sage, wenn ich jetzt entsprechend viele Gatter zusammennehme, eignet miteinander verschalt.
Da habe ich dann eben sowas wie ein Adierer oder wie eine Alu.
Und man kommt dann eben zu solchen Elementen,
aus denen dann eben die sogenannte Mikroarchitektur gebildet wird.
Also dass wir jetzt quasi ein Prozessor oder irgendeine Hardware innen drin intern auf dem Silizium aufgebaut ist. Und das,
was dann eigentlich die Rechnerarchitektur umfasst, das ist,
sagen wir dann eben auch so das,
was wir dann hier gerade am Ende der Rechnerstrukturenvorlesung dann eben auch noch kennenlernen werden,
dass dann eben wirklich diese Schnittstelle von der Software,
wo man jetzt also von hier oben kommt,
runter auf die Hardware beziehungsweise auf die diese Elemente der Mikroarchitektur,
nicht um die Schnittstelle,
ist eben letztendlich definiert jetzt für einen Befehlssatz für einen bestimmten Prozessor XY,
der jetzt irgendwo mal im Computer arbeitet und eben für die entsprechenden Datentypen,
mit denen der jetzt rechnen kann.
Und wenn ich jetzt eine andere Hardware habe,
hätte ich dann eben entsprechend da dann einen anderen Befehlssatz und da eine andere Schnittstelle. Das,
was Sie sonst typischerweise natürlich jetzt bei der Informatik ja sehen,
ist von der Software, von dir oben kommt,
dass man jetzt eben sagt,
ich habe jetzt auf der Anwendungsebene irgendwo meine Hochsprachen,
will ich auch immer das sein mögen.
Nicht die werden dann eben durch ein Übersetzungssystem,
also ein Compiler typischerweise, dann eben auf Befehler der Assembler-Ebene runtergebrochen,
was dann also schon irgendwo und ganz in die Richtung Maschinenprogrammen geht.
Dann gibt es eben nochmal eine Umsetzung durch das Betriebssystem,
bevor dieses Programm dann eben auch wirklich ausgeführt werden kann.
Und wenn das Programm dann letztendlich zur Ausführung kommt,
dann ist man eben genau hier an der Stelle,
dass es dann eben wirklich auf dieser Hardware-Architektur laufen wird
So, hier haben wir jetzt das Ganze also nochmal etwas veranschaulicht mit solchen Ebenen. Das heißt,
man fängt also irgendwo oben an und hart sein Programm in irgendeiner Programmiersprache,
was dann eben durch einen Compiler übersetzt wird in ein Assembler-Programm,
jetzt in irgendeinem Assembler-Format,
also beispielsweise jetzt hier bei einer Linux-Kiste in das ELF-Format.
Anschließend sitzt da drunter dann noch ein Betriebssystem,
was dann dieses Format dann auch nochmal,
bevor es zur Ausführung kommt, teilweise umsetzen muss.
Also hier steht jetzt als Beispiel dann eben Windows.
Dabei passiert dann eben Folgendes. Nur damit eigentlich klar ist,
was hier das Betriebssystem immer noch macht oder warum man das eigentlich braucht.
Wenn ich als Programmierer irgendwas programmiere,
beziehungsweise es wären sie ja dann in der Softwareentwicklung entsprechend lernen
und ich habe dann eben beispielsweise sowas wie ein Array oder irgendeine Datenstruktur,
dann gehe ich als Programmierer von meinem Programmiermodell erstmal davon aus,
ich habe im Prinzip unendlich großen Adressraum,
nur für mich,
der fängt bei Null
an und geht bis irgendwas
So. Das passiert jetzt in meiner Hochsprache. Das wird also
durch den Compiler dann auch so übersetzt. Und das,
was also hier jetzt in diesem Assembler-Formaten dann eben stattfindet,
ist, dass die Programme auch erstmal einen Adressraum von 0 bis irgendwas haben.
Wenn das Programm dann aber wirklich zur Ausführung kommen soll und irgendwo in den Hauptspeicher geladen wird,
damit es also nachher vom Prozessor dann verarbeitet werden kann,
stimmen diese Adressen natürlich alle nicht,
weil also an diese Adresse dann also vielleicht schon was anderes liegt,
also im Zweifelsfall also erstmal irgendwo Teil des Betriebssystems.
Das heißt, bevor das Programm eben eigentlich in die Ausführung kommen kann,
muss da dann eben auch noch mal eine Umsetzung der Adressen erfolgen,
also dann eine bestimmte Umrechnung.
Da gibt es ja auch mehrere Mechanismen und einiges davon will ich
dann also am Ende dieser Vorlesung dann auch noch mit vorstellen.
Und anschließend dann eben mit diesen entsprechend modifizierten Adressen kann das Programm
dann eben auch wirklich richtig jetzt durch die Hardware ausgeführt werden,
beziehungsweise teilweise werden da auch noch bestimmte Befehle dabei, entsprechend auch noch etwas modifiziert.
Gut, bei der Ausführung Habe ich jetzt also hier quasi mein Programm,
was irgendwo am Hauptspeicher liegt, war es jetzt also wirklich mit Befehlen für irgendeinen Prozessor XY,
also beispielsweise Intel X86 jetzt also irgendwie aufgebaut ist, dann entsprechend abgearbeitet werden kann. Und bei dieser Abarbeitung auf der eigentlichen Hardware kann es dann eben noch sein,
also deswegen, also hier dieses Beispiel mit dem Intel Code,
dass dieses Programm teilweise von der Hardware auch nochmal modifiziert und übersetzt wird,
was in diesem Fall jetzt daran liegt,
dass der Assembler-Code von dem Intel-Prozessoren, ich sag mal jetzt,
von einem Architekturmodell ausgeht, was damals als PCs entstanden,
Anfang der 80er Jahre, üblichen Gang und Gäbe war,
was dann aber inzwischen also von deutlich moderneren,
neueren Konzepten, Stichwort dabei ist, also Pipelining,
dann abgelöst wurde und um das zu realisieren,
passiert hier jetzt eben noch das oder kann es eben passieren,
dass eben Teile des Codes,
die jetzt also quasi der Assembler erzeugt,
beziehungsweise die dann hier in den Hauptspeicher geladen werden,
dann eben von der Hardware nochmal entsprechend modifiziert werden und auch da nochmal eine Umsetzung erfolgt,
wo dann ein Befehl dann eben eine ganze Folge von Befehlen automatisch umgesetzt werden kann.
Gut, das also jetzt nur als Beispiel oder Motivation jetzt eben zu diesen Übersetzungsebenen,
wie gesagt, in der Regel kriegen wir davon,
wenn wir jetzt also programmieren oder mit dem Rechner arbeiten,
natürlich nicht direkt was mit, aber eben für das Grundverständnis,
wie jetzt also Software auf dem Rechner zur Abarbeitung kommt.
Und das ist ja das, was ich hoffe,
ihn hier also irgendwie mal vermitteln zu können, ist das dann also schon ein Entscheidender Faktor. So,
wenn man sich jetzt ansieht,
wie diese Ebenen jetzt mit irgendwelchen Vorlesungen aus dem,
meinetwegen Informatik-Bachelor-Studiengang irgendwo korreliert sind, dann kann man sagen nicht,
also das fummelt sie sonst in der Regel, arbeiten,
also bei Softwareentwicklung oder bei Algorithmen und Datenstrukturen, sofern sie das hören,
ist dann eigentlich immer die Anwendungsebene bei Rechnerstrukturen oder die Assembler-Ebene wird dann eben teilweise ein bisschen hier bei den Rechnerstrukturen noch mit.
Angesprochen, dann gibt es, oder gab es also früher in dem Bachelorstudiengang,
jetzt ist es, glaube ich, optional, Grundlagen der Systemsoftware,
da geht es im Prinzip auch um die Betriebssystemebene und alles,
was sich dann da drunter befindet,
also Rechnerarchitektur, Mikroarchitektur und Logikebene werde ich also sehr,
sehr kurz teilweise dann eben hier in Rechnerstrukturen noch ansprechen.
Früher gab es dann also im Studium noch eine Vorlesung,
Rechnerarchitektur, Mikrosystemtechnik, die diesen Tal dann eigentlich eher noch ein bisschen gezielter abdeckt,
beziehungsweise wo es dann also auch noch mal ein bisschen runtergeguckt wird.
Wie werden Schaltungen letztendlich aufgebaut? Gut, wie sieht das
Ganze jetzt also wirklich praktisch aus? Deswegen habe ich jetzt
noch mal kurz ein paar Beispiele, damit man jetzt einfach
noch mal so ein bisschen den Code zieht.
Wie gesagt, also hier wird jetzt also noch keine Programmiersprache,
also in diesem Fall jetzt C irgendwie vorausgesetzt.
Das ist einfach erst mal nur ein Beispiel dafür,
wie das Ganze letztendlich erstmal nur übersetzt werden kann. Das heißt also,
hier das klassische HelloWorld-Beispiel, das heißt also,
ich schreibe jetzt in irgendeiner Programmiersprache, in diesem Fall C,
also irgendwie so eine Anweisung, Print,
Pelle World und wenn das Ganze dann irgendwann mal auf dem Rechner zur Ausführung kommt,
sollte also dann irgendwo auch in einem Terminal-Fans oder wo auch immer dann also quasi dieser String mal ausgegeben werden.
Mir tut dieses sagenhafte Programm also nicht. Das würde ich
dann also letztendlich mit einem C-Compiler übersetzen,
wofür man dann also hier, je nachdem,
was man damit nachher weiter noch machen will,
dann eben eine von diesen Aufrufen benutzt
Und was dann dabei erzeugt wird,
wenn man sich das mal anzeigen lassen würde oder ausgeben lassen würde,
dann eben auf Assembler-Ebene,
wäre dann im Prinzip so ein Programm,
wo jetzt eben mein Hochsprachenprogramm übersetzt worden ist in Assembler-Befehle jetzt,
also für so ein X86-Prozessor in diesem Fall,
wo jetzt mit relativ einfachen Befehlen letztendlich dafür gesorgt wird,
dass also da nichts anderes passiert als das,
was sie in einem Hauptprogramm auch ist.
Es gehört hier nämlich so ein Nee, Prozedur oder ein Unterprogramm,
in diesem Fall, nämlich diese Printanweisung irgendwo aufgerufen.
Und das, was hier aus dem Assembler-Code rausfällt,
wie gesagt, den müssen sie erst mal noch nicht verstehen.
Dazu kommen wir später noch mal ein bisschen. Ist also
nichts anderes, als dass hier einiges an Vorbereitung passiert.
Hier ein Aufruf auf irgendwas und dieses irgendwas wäre dann in
diesem Fall dann also dieser Unterprogrammaufruf und nicht und hinterher,
am Ende wird dann quasi das Ergebnis dann irgendwo wieder zurückgeliefert.
So, das, was aus dem Kompilat letztendlich rauskommt,
das heißt also der Objektcode oder der Samblercode,
wenn ich den jetzt also in Maschinen und nicht in Menschen lesbarer Form mir ausgeben lasse.
Wäre dann also hier irgendwie sowas Schickes. Hummel natürlich also schon mal
rein gar nichts mehr anfangen kann. Dieses CSA-Fach jetzt erstmal
nur wirklich so ein Code, der dann nachher,
bevor es durch das Betriebssystem nochmal umgesetzt wird und in den Speicher geladen wird,
dann eben direkt vom Prozessor ausgeführt werden kann.
Ist quasi so zu lesen, also hier vorn lassen immer sowas wie Adressen,
nicht erzählt er einfach jetzt hier irgendwelche Adressen drauf.
Und hier stehen dann letztendlich irgendwelche Hexer-Dezimalwerte,
also irgendwelche Folgen aus Nullen und Einsen,
wenn ich das aufschlüsseln würde,
die dann eben in den Speicher geladen werden und dann von den Prozesse irgendwie interpretiert werden,
beziehungsweise von dem Prozessor eben abgearbeitet werden.
Und da war es dann eben, ich habe,
was weiß ich, da eben einen entsprechenden Befehl,
wo jetzt hier irgendwas adressiert wird und in ein bestimmtes Register geschrieben wird.
2004. Nicht das Ganze kann man dann quasi auch wieder disassemblieren,
zurückumrechnen, weil also sagen wir mal, dies,
wenn oder Maschinen oder Menschenlesbar und dies Maschinenlesbare ist quasi eins zu eins äquivalent.
Das heißt, dieses hier wäre jetzt also nichts anderes als dieser Krude-Code dann wieder zurückgerechnet.
Das sollte also hoffentlich ähnlich aussehen, wie sowas hier.
Und wenn das dann eben zur Ausführung kommt,
wird das dann eben nochmal umgesetzt und dann hat man eben dann auch wieder einen entsprechenden Maschinencode. Gut,
das wären jetzt eigentlich erstmal nur so grob oder von der Idee
her diese Übersetzungsebenen bei der Ausführung oder wenn das Ganze eben zur Ausführung kommt,
hatte ich ja schon gesagt,
gibt es eben die Möglichkeit,
dass eben entweder zu übersetzen durch eine entsprechend einfachere Maschine ausführen zu lassen oder eben durch ein Interpreter zur Laufzeit umzusetzen.
Dadurch kommt jetzt eigentlich raus oder das, was jetzt,
also auf dieser Folie eigentlich nur ausgedrückt wird, ist,
dass man letztendlich mitbekommt,
jetzt von der Funktionalität oder von dem,
was also da geleistet werden kann
Kann man eben sagen, Software und Hardware sind eigentlich logisch äquivalent.
Also ich kann das übersetzen, direkt auf dem Prozessor ausführen,
mein Code oder ich kann ihn quasi interpretieren und dann eben durch irgendwelche Software ausführen lassen.
Und das sollte sich dann eben nachher das Gleiche daraus ergeben. In diesem Satz,
das ist dann also hier auch aus dem Buch von dem Tarnenbaum,
wo dann also oder das Ganze wohl dann quasi dadurch zusammengefasst,
dass Karen Penetta Lenzer, also eben irgendwann mal postuliert hat,
also Hardware ist just patrified Software, also versteinerte Software,
Das heißt, oder damit sollte eben nur ausgedrückt werden von der Funktionalität sind Hardware und Software eben identisch.
So, und wenn man jetzt bei der Abarbeitung für irgendwas sich also jetzt wirklich entscheidet,
soll das in Hardware realisiert werden oder soll irgendwas in Software realisiert werden,
kann man jetzt eben sagen, okay,
das ist letztendlich von mehreren Faktoren abhängig, nämlich,
wie schnell möchte ich mal ein Ergebnis haben,
wie schnell soll das Ganze dann arbeiten oder abgearbeitet werden.
Also sagen wir mal sowas wie Performance, wie flexibel muss die Lösung sein. Das heißt,
wird da wieder auch irgendwie was aktualisiert oder kann ich sagen,
da ist ein bestimmtes Programm, das wird eben einmal festgelegt und dann nie wieder angefasst.
Denn dann könnte ich eben auch sagen, okay,
das muss sich jetzt nicht unbedingt in Software schreiben,
sondern es könnte dann eben auch beispielsweise durch irgendwie Hardware direkt abgearbeitet werden.
Und gerade so bei vielen Klein-Anwendungen jetzt, wo man sagt,
okay, da läuft wirklich nur ein bestimmter spezieller Algorithmus,
da wird nichts geändert und das ist eben jetzt nicht ein Universal einsetzbares Gerät,
wie jetzt also irgendwie ein PC oder eben irgendwo ein Rechner,
sondern das ist also irgendwo in einer Steuerungssoftware für irgendwas,
Smart Wing ist, also wenn man mit dem Auto verbaut,
dann kann man sich eben wirklich jetzt überlegen, okay,
mache ich das in Software auf dem Mikrocontroller,
wo irgendwas abgearbeitet wird oder nehme ich den Algorithmus und bringe den entsprechend in Hardware.
Und da gibt es dann eben unterschiedliche Anforderungen, wo man sagt,
gut, wenn das jetzt eben extrem schnell laufen soll,
ist eine Hardware-Realisierungsverein meistens deutlich teurer.
Dafür aber dann entsprechend schneller. Ich bin dann,
habe dann auch keine Probleme mit irgendwelchen Kopierschutz,
weil wenn ich so ein Chip aufschleifen und dann also mal nachgucken,
was ist da drin eigentlich realisiert und gemacht.
Das kann man also nicht ganz so einfach machen.
Nicht also irgendwo so ein Hardware-Programm, also aus dem Speichersicht
mal irgendwo runterziehen. Also gerade bei fest programmierten Sachen,
das kann man natürlich schon machen und da dann eben wieder
irgendwie was modifizieren oder Gut,
dann werde ich jetzt noch mal auf das eigentlich grundlegende Konzept von Rechnern oder Rechnerabarbeitung kommen.
Nämlich, dass von Neumann-Konzept eine Frage. Ja,
ich weiß, die Luft ist hier irgendwie so ein bisschen schwer.
Also Fenster, also es gibt hier irgendwie eine Belüftung auf.
Das sollte aber hoffentlich alles schon auf sein.
Ich denke mal, da können wir höchstens die Tür
noch aufmachen
Habt ihr da was oder? Hast du jetzt geguckt?
Boah. Aha. Gut, jetzt tut sich auch irgendwie
was bei der, oben bei den Klappen. Gut,
ja, also das von Neumann-Konzept ist eigentlich,
sagen wir mal, so das grundlegende Konzept,
was von Neumann beziehungsweise noch zwei Kollegen Morgly and Eggard 1945 entwickelt haben,
nachdem im Prinzip alle Rechner funktionieren in der Befehlsabarbeitung.
Und zwar haben sie also eine abstrakte Maschine postuliert mit vergleichsweise minimalem Hardwareaufwand,
das heißt also ein System aus einem Prozessor und Speicher
und eben irgendwie entsprechend noch Peripherie gereden,
weil man möchte natürlich in das System noch irgendwelche Werte,
was auch immer das ist mit irgendwelchen Medien reinbringen,
die sollen verarbeitet werden und es soll wieder irgendein Ergebnis
ausgegeben werden
Und das, was eigentlich jetzt neu oder grundlegend an diesem Konzept dann war, ist,
dass eben die Struktur, auf der das Ganze abgearbeitet wird,
eben unabhängig von dem Problem ist,
sondern dass das Problem wirklich durch einen austauschbaren Speicher einhalten,
nämlich also das Programm beschrieben wird.
Das ist für uns heute eigentlich selbstverständlich, dass wir sagen,
ja gut, ich habe hier irgendwie so eine Kiste,
die kann ich programmieren und die kann also mal dieses Programm starten,
mal jenes Programm starten und völlig unterschiedliche Anwendungen machen.
Wenn man sich ansieht,
was im Prinzip jetzt deutlich vorher eben mit Rechnern passiert ist,
ist, dass man in der Historie einfach nur ganz spezielle Maschinen für spezielle numerische Probleme gebaut hatte.
Und die konnten eben nur genau dieses eine Problem lösen und nichts anderes.
Das heißt, ich habe gleich noch ein paar Folien,
wo also ein paar historische Geräte mit drauf sind,
wo dann also auch mal beschrieben ist,
was die also gemacht haben, wie die aufgebaut waren.
Und da war es halt eben so auch alles,
was vorher entwickelt wurde, war dann eben gebaut worden,
um beispielsweise Tidentabellen zu berechnen, um beispielsweise in der Baustatik,
also irgendwelche statischen Formeln für Lasten und für die Berechnung von irgendwelchen Bausachen zu machen.
Das ist also das, wo Konrad Zuse, der nun im Prinzip
auch EM-Professor hier in Hamburg gewesen ist, letztendlich mit groß geworden ist.
Das ist nämlich eigentlich ein Bauingenieur und das,
was dort an relativ aufwendigen Berechnungen passieren muss,
wo man dann eben das Ganze auf Papier und mit Rechenschieber gemacht hat,
dafür hat er dann eben angefangen, die ersten Tüter zu programmieren,
wobei dann eben die allerersten Computer mit, die er entworfen hat,
eben auch nur entsprechend solche baustatischen Berechnungen machen konnten und nichts universell einsetzbar waren.
Das, was wir jetzt eigentlich ja immer gewohnt sind.
Gut, wie gesagt, das Programm oder das Problem
wird eben durch einen austauschbaren Speicherinhalt beschrieben.
Es gibt dazu dann eben einen gemeinsamen Speicher für Programme und für Daten.
Dieser Speicher ist fortlaufend adressiert und letztendlich können Programme wie Daten
manipuliert werden, beziehungsweise andersrum. Ich kann eben das,
was dort an Daten drinsteht, dann eben auch als Programm interpretieren und zur Ausführung bringen. So,
das ist eigentlich, sagen wir mal,
von der Grundidee her erstmal so ein Konzept,
was wir heute eigentlich nicht mehr haben, sondern wir sagen,
okay, also ich habe mein Programm und da rechne ich mit irgendwas und das,
was sich da als Programm zur Ausführung bringe,
ist von diesem, wo damit gerechnet wird, erstmal völlig unabhängig.
Nicht rein praktisch ist aber natürlich so,
dass sowohl dieses Programm als auch die Daten,
auf denen gerechnet wird oder womit das Programm arbeitet,
irgendwo nachher in der Hardware,
wenn auch in diesem Fall jetzt also bei modernen Computern noch über mehrere Schichten und über mehrere Cashes zusammen,
aber irgendwo nachher in der Hardware, in einem gemeinsamen Speicherland,
beziehungsweise gemeinsam nachher irgendwo auf der Festplatte rumliegen.
Gut, Bada,
Ausführung von Programm hat man dann eigentlich einen sehr typischen Befehlszyklus,
den ich also auch vielleicht nochmal an so einem kleinen Beispiel dann vorstellen werde,
wo man eben sagt,
der Befehl oder ein Befehl wird jetzt eben aus dem Speicher geholt von einer bestimmten Adresse, dekodiert.
Nicht und abhängig davon, was dort eben dekodiert würde,
wird dann durch die Hardware irgendeine Berechnung ausgeführt.
Anschließend setze ich dieser Zyklus fort, man holt dann eben
den nächsten Befehl und so weiter und so fort.
Und das Ganze ist eben enorm flexibel. Und wie gesagt,
alle Rechner basieren auf diesem Prinzip,
wobei inzwischen war dieses Konzept dann eben auch einige Nachteile hat,
die ich Ihnen, denke ich mal,
dann auch noch im Laufe der Vorlesung entsprechend vorstellen werde,
hat man da also noch sehr viel an Ergänzung,
Verbesserungen und so weiter mit reingebaut.
Aber im Prinzip vom Grundprinzip oder für so eine Art Minimalrechner
kann man sich eben immer auf so einen von Neumann-Rechner zurückziehen.
Gut, wie ist das Ganze erstmal von der Idee her aufgebaut? Gut,
jeder Autor hatte irgendwie jetzt seine eigene Vorstellung oder Visualisierung,
also dieses wäre jetzt also hier die Folie auch aus
dem Buch vom Tarnbaum
Wo eigentlich erst mal nur diese Unterteilung in diese zentralen Komponenten ist,
wo ich eben sage, ich habe einen Prozessor,
der in dieser Folge jetzt also hier diese beiden Teile unterfasst, umfasst.
In diesem Prozessor gibt es eben ein Steuerwerk,
also das, was hier im Englischen Control Unit heißt,
wo es darum geht, Befehle zu holen,
Befehle zu dekodieren und eben ein Rechenwerk,
was dann eben beispielsweise die Alu- und irgendwelche Register sind,
wo es dann eben darum geht,
mit Daten
zu arbeiten
Nicht, dann gibt es eben einen gemeinsamen Speicher,
der sowohl für Daten als auch für Programme genutzt wird.
Und zusätzlich gibt es dann noch irgendwelche Ein-Ausgabe,
ein Heim, wie auch immer das dann aussehen war.
Das Ganze ist verbunden dann eben durch ein oder mehrere Bussysteme,
was dann also sich mit diesen Fallen angedeutet ist.
Wie gesagt, bei anderen Grafiken ist es dann oft so,
dass es dann eben noch zentral wirklich jetzt
ein Bus oder eine Leitung quasi hier so quer rübergibt,
wo dann also letztendlich alle diese Komponenten andocken.
Gut, das ist dann immer nur eine Frage, wie man das Ganze letztendlich visualisiert.
Gut, ich hatte ja schon gesagt bei den Komponenten,
also der Prozessor oder das, was wir so als CPU kennen,
ist eben logisch unterteilt in zwei Teile, Steuerwerk und Operationswerk.
Das Steuerwerk ist eben der Teil,
wo es um die Abarbeitung von Befehlen geht,
wo jetzt eben die Befehle interpretiert werden,
beim Operationswerk geht es dann eben um die Bearbeitung von Daten und je nach unterschiedlichen Autor,
je nach unterschiedlicher Darstellung heißen die mal Steuerwerk und Operationswerk oder Rechenwerk und Leitwerk oder Befehlsprozesse und Datenprozessor.
Also wichtig ist eigentlich immer nur,
dass man also erst mal grob weiß, Unterteilung,
da eine Teil kümmert sich also um Programme,
der andere Teil kümmert sich um Daten.
Jeweils in diesen einzelnen Berechnungswerken gibt es dann eben noch einige ausgezeichnete Register oder Speicher,
die man braucht, um was zu machen und zwar in dem Steuerwerk
sowas wie Befehlszähler oder im Englischen dann Program-Counter.
Ein Befehlsregister. Er ist Traction-Register. Und im Operationswerk
habe ich dann eben typischerweise zum einen das Eigentliche,
die eigentliche Rechnende Einheit, also ein Schaltennetz,
was dann also die Alu-Aresmithic Logic Unit darstellt.
Und dann eben noch mindestens eins,
in der Regel sind das dann natürlich deutlich mehr Register,
also wo dann also Daten abgelegt werden und die dann
eben entsprechend für Berechnungen der Alu zur Verfügung stehen
Gut, dann gibt es eben den eigentlichen Speicher.
Auch da kann man dann immer noch unterteilen zwischen nur Lesespeicher,
also Read-Only-Memory und eben dem random Access-Memory, also im Rahmenspeicher,
den man dann eben auch entsprechend wieder beschreiben kann.
Also gerade in der Anfangszeit der Computer,
wo also dann Speicher entsprechend teuer war und wo man eben auch typischerweise viele Basisaufgaben,
also eben zum Beispiel Sachen, die man brauchte,
um so ein Rechner überhaupt erst mal zum Buten zu bringen,
Und das hat man dann eben in einem Speicher abgelegt,
der also letztendlich nur gelesen werden konnte.
Und wenn man jetzt Programme zur Ausführung bringt,
beziehungsweise mit den Programmen irgendwelche Daten verarbeitet,
die landen dann natürlich in einem Schreibriesespeicher, also in einem Rahmen.
Zusätzlich gibt es dann eben noch zu externe Speicher und
so weiter und so fort. Gut, das ist,
denke ich mal, jetzt alles nichts.
Neues. Dieses Minimalkonzept werden sie dann sicherlich auch noch
etwas genauer kennenlernen bei dem Rechnerstrukturpraktikum
Dort wird dann quasi als Visualisierung,
oder damit man das mal richtig sieht,
dann eine Primitiv-Machine prima eingesetzt, mit der man dann arbeiten kann,
die man dann selber auch ein bisschen mit programmieren soll,
die letztendlich nichts anderes ist,
als dann eben so ein minimaler Acht-Bit von Neumann-Rechner,
wo ich dann eben im Prinzip ein kleines Rahmen habe,
also einen Hauptspeicher, dann irgendwie ein paar kleine,
dann auch nur acht mit breitere Gistern, nämlich so ein Programmzähler,
das Befehlsregister, ein Adressregister, wo es darum geht,
also Adressen jetzt für die Speicheradressierung vorzuhalten und dann eben noch so ein ausgezeichnetes Akkumulatorregister,
wo dann also Zwischenergebnisse von arenthmetischen Operationen stattfinden.
Eine sehr einfache Alu und ein bisschen eine Ausgabe. So,
und das Ganze kann man dann eben auch,
beziehungsweise wenn sie dann eben da auf den Rechnern auch zur Ausführung bringen,
eben entweder, weil das also im Prinzip über so eine Gui in Java geschrieben ist,
also entweder sich runterladen und also direkt in der Java VM
zur Ausführung bringen oder eben entsprechend als Applet ihr ausführen lassen.
Wenn ich das Ganze jetzt hier entsprechend starte und dann also hier jetzt auf diese Seite gehe,
habe ich dann eben hier die Möglichkeit zu sagen,
ich habe jetzt eben diese Prima-Maschine und kann das jetzt eben entweder als Applet starten,
über so einen Webstart-Mechanismus,
also jetzt direkt hier mir runterladen oder man kann es dann eben auch über ansprechende Quellen zur Ausführung bringen.
Dieses gesamte Framework, also dieses Hades,
Hamburg Design System,
soll das Akronym
dann heißen
Ist also von einem Kollegen geschrieben worden,
der das Ganze dann also letztendlich als ereignisgesteuerte Simulation in Java geschrieben hat,
wo man dann eben sehr schön,
sehr flexibel von einfachen Gattern oder Funktionen der Bulschen Logik beziehungsweise von einfachen Funktionen,
die jetzt also in der Rechnerarchitektur vorkommen,
sich was zusammenbauen kann und das dann eben wirklich auch schon über
etwas komplexere Sachen dann eben wirklich bis zu so einem Minimalprozessor,
während Und damit kann man dann eben auch immer selber sehr gut interaktiv arbeiten und dort dann eben entsprechend noch mal so ein bisschen auch selber sehen,
was tut sich da jetzt,
wenn ich also jetzt an der Stelle im Speicher das und das habe und das dann eben mit dem Befehlssatz so und so zur Ausführung kommt.
Wie gesagt, das wird dann also in dem Rechner Strukturen,
Praktikum dann eben unter anderem auch massiv mit eingesetzt.
Ansonsten werde ich also bei den Tal nachher,
wo es also im Prinzip um einfache Wohlschauen Schaltung,
um Kodierennetze, um Flipflops und sowas geht,
teilweise dann auch immer noch solche Hades Beispiele mit zeigen.
Aber wie gesagt, das ist dann eigentlich immer eine sehr schöne Sache,
wo sie selber dann auch mal so ein bisschen mal mit rumspielen können.
Und wenn ich das jetzt also hier starte,
jetzt was ich hier beispielsweise als Applet,
dann würde also hier irgendwie so ein Fenster aufgehen,
wo man jetzt eben diese Minimalstruktur sieht und das kann man
dann eben über entsprechende Werkzeuge modifizieren,
damit irgendwie was machen und damit arbeiten
Wie gesagt, das nur als kleine Motivation, wie gesagt,
das wären sehr dann entsprechend noch selber häufiger einsetzen und da dann was mitmachen.
Ich weiß hiermit dann eigentlich nur gezeigt wird,
oder weswegen ich das jetzt hier einfach jetzt nur schon mal ein bisschen vorstelle,
ist das, wie man dieses Grundverständnis bei der Abarbeitung von Befehlen durch so eine von Neumann-Architektur,
dass ich das also jetzt hier einfach nur noch mal zeigen möchte,
nämlich diese verschiedenen Phasen, wo es darum geht,
Befehl holen, Befehl dekodieren,
auf dieser Hardware irgendwie was rechnen und dann eben letztendlich zur Ausführung bringen.
Und zwar, hier jetzt mal in den einzelnen Teilen nur grob skizziert. Vieles von dem,
was sich jetzt hier so ein bisschen vorstelle,
beziehungsweise wenn ich jetzt hier drüber rede, kann sein,
dass sie das jetzt also vielleicht noch nicht gehört haben oder dass einiges da dann auch neu sein wird.
Also nachher wird also ein Teil von diesem von Neumann-Konzept also auch nochmal wiederholt,
wenn ich dann also wirklich genau nochmal beschrieben habe,
was ist jetzt also hier ein endlicher Automat, was sind Multiplexer,
wie arbeiten, Register und so weiter und so fort.
Aber ich denke mir, vieles von den Begriffen oder einiges
von den Begriffen werden sie vielleicht eben auch schon gehört haben,
dass von da so ein bisschen Grundverständnis hoffentlich jetzt also auch schon da ist.
Bei der Abarbeitung, also wie gesagt,
Abarbeitung von Programmen durch von Neumann-Rechner, kann ich mir jetzt eben vorstellen,
das Programm liegt jetzt hier einfach irgendwo in dem Speicher mit drin,
soll jetzt durch diese Hardware irgendwo abgearbeitet werden.
Und jetzt weiß ich eben, Ich muss ein Befehl in
diesem Prozessor quasi jetzt in das Steuerwerk bringen.
Dazu gibt es dann eben hier ein Register. Das heißt,
hier wird einfach eine Adresse gespeichert. Mit dieser Adresse wird
jetzt eben hier dieser Speicher adressiert. Der Wert dieser Adresse,
das ist dann eben genau dieser Befehl,
der zur Abarbeitung kommen soll,
wird jetzt eben hier ausgelesen und landet dann eben hier in
einer Speicherstelle und in einem Register eben in diesem ausgewählten Befehlsregister
Anschließend wird eben dieser Befehl dekodiert. Das heißt,
hier gibt es irgendeine Logik, die jetzt diesen Inhalt interpretiert
und eben feststellt, dieser Befehl ist beispielsweise ein Additionsbefehl.
Und es sollen jetzt zwei Zahlen,
die an der und der Stelle irgendwo stehen, addiert werden.
Und das Ergebnis soll irgendwo anders hingeschrieben werden. Oder dieser
Befehl ist ein Sprungbefehl. Also muss ich dafür sorgen,
dass als nächster Befehl jetzt eben nicht der darauffolgende Befehl aus
dem Speicher gelesen wird, sondern eben irgendein ganz anderer.
Das ist dann eben
diese Dekodierung
In der Regel, wenn ich jetzt also keine Sprünge mache,
muss dann eben noch Folgendes passieren,
dass dann natürlich jetzt das ganze System schon wieder so weit vorbereitet wird,
dass irgendwann der nächste Befehl geholt werden kann.
Also muss ich irgendwo dafür sorgen, dass also dieser Befehlszieler,
aus dem hier die Adresse von meinem Befehl drinstehen hatte,
dass der quasi armer inkrementiert wird,
was dann also hier mit diesem roten Datenfahrt und hier irgendein Inkremente,
also der macht da nichts anderes als ein Plus 1
zu rechnen,
Mich dann bei der Abarbeitung des Befehls,
wenn das also jetzt beispielsweise eben so ein Additionsbefehl wäre,
müsste jetzt eben Folgendes passieren, dass das Steuerwerk,
das jetzt eben als Additionsbefehl interpretiert hat,
über diverse Ausgabeleitung, das ist das,
was hier also quasi mit diesen roten Pfeilen angedeutet ist,
wird jetzt dafür gesorgt, dass quasi jetzt von diesen Verbindungsstrukturen alles,
was jetzt hier irgendwo farbig hervorgehoben ist,
aktiv geschaltet wird.
Das heißt, in irgendeinem Register habe ich jetzt also
hier sowas wie eine Adresse, adressiert das Rahmen.
Dort wird also dann irgendein Datenwert ausgelesen. Der geht in
die Alu rein. Gleichzeitig habe ich hier einen Datenwert in diesem Akkumulator.
Die beiden werden miteinander verknüpfen. Das Ergebnis landet dann eben wieder hier drin. Gut,
das ist nicht das, womit jetzt aktuelle Rechner arbeiten,
weil die greifen also bei solchen Operationen überhaupt nicht auf den Speicher zu,
weil das wäre unendlich viel zu langsam.
Aber vom Grundverständnis beziehungsweise von dem,
wie jetzt eben so wirklich so eine Primitivmaschine arbeitet,
nach dem von Neumann-Konzept, kann man dann eben entsprechend damit solche Befehle abarbeiten.
Gut. Das heißt, das wäre jetzt eben irgendwie so
eine Berechnung. Und anschließend könnte man dann eben sagen,
das Ergebnis wird aus dem Akkumulator dann irgendwo in den Speicher geschrieben,
vorausgesetzt, ich habe hier dann irgendwie die passende Adresse drin stehen, um zu sagen, an welche Speicherstelle.
Das Ergebnis landet. Gut, sowas wie Sprungbefehle wären dann eben auch möglich. Bei Sprungbefehlen hatte ich ja gesagt,
wird der Programmzähler dann nicht inkrementiert, wie das also vorhin der Fall war,
sondern da wird dann eben aus irgendeinem anderen Register oder woher auch immer dann eben entsprechend so ein Datenfahrt, also das,
was wir eben hier mit diesem hervorgehobenen Fallen markiert ist,
geschaltet, der dann eben dafür sorgt,
dass der Programmzähler mit irgendeinem anderen Wert beschaltet wird und dann beim nächsten Mal den nächsten Befehl holen,
habe ich dann eben hier nicht die Folgeaddresse,
sondern eben nur ganz irgendeine ganz andere Adresse aus dem Hauptspeicher.
Gut, das Ganze, wie gesagt,
das würden Sie dann in dem Praktikum auch noch sehen,
kann man dann eben auch noch in so eine Art Instruction-Set-Simulator nachvollziehen,
das ist dann etwas, wo ich also hier jetzt wirklich immer sehe,
was ist in welchen Registern und hier was ist,
wo im Speicher und da kann man dann eben wirklich sagen,
mit jedem Takt, wo man dann einmal draufklickt,
springe ich dann entsprechend ein weiter und sieht dann wirklich Schritt für Schritt,
wie auf so einer Hardware letztendlich,
also einfach eben diese Vergleichsweise einfachen Befehle dann zur Ausführung kommen würden.
Das denken wir, ist dann schon ganz nett,
weil dann eben wirklich anschaulich mal so ein bisschen nachvollziehbar ist,
wie es ist überhaupt zum Computer rechnen kann.
Gut, dass wir jetzt eben eigentlich erstmal das,
was Grundidee dieses von Neumann-Konzepts ist. Wie gesagt,
ich werde das dann später,
oder deutlich später in der Vorlesung dann also nochmal aufgreifen,
wenn es dann also wirklich nochmal darum geht,
wie jetzt aktuelle Rechner arbeiten, wo da jetzt die Unterschiede zu diesem Grundkonzept sind.
Und wo wir dann eben auch noch sehen werden,
was waren da also letztendlich Probleme, wie wird das entsprechend anders realisiert.
Was kann man da noch machen? Gut,
jetzt habe ich hier noch einige Folien,
wo ich dann also letztendlich nochmal grob so ein bisschen was zur Historie vorstelle,
beziehungsweise bevor ich also ganz zurück in die Historie gehe,
habe ich hier noch mal ein bisschen was.
Also sagen wir mal so der erste Personal-Computer, also IBM-PC,
Anfang der 80er Jahre. Da sieht man eigentlich noch relativ stark,
dass da also sagen wir mal so ein Grundkonzept entspricht.
Da habe ich irgendwo ein Bussystem, und das sind eben angekoppelt
die CPU, die dann eben Grechenwerk und Steuerwerk enthält.
Dann eben der Speicher und dann eben irgendwie noch
sowas wie ein Ausgabegeräte für Monitor, Tastatur
CDROM-Laufwerke oder Festplattenlaufwerke. Und diese Komponenten,
die dann also hier teilweise an den Bus hängen,
sind dann eben auch noch modular,
beispielsweise so als Einsteckkarten ausgeführt, konnte man eben austauschen.
Das heißt, da gab es also dann die aller einfachsten Versionen.
Da war dann, was man sich heute immer auch immer
gar nichts mehr so richtig vorstellen kann, Bildschirmausgabe letztendlich zeichenbasiert.
Eine Zeichen schwarz-weiß. Dann gab es irgendwann die Luxusgeräte,
die konnten dann schon
16 Graustufen unterscheiden
Da hat man dann eben entsprechend einen anderen Monitor und einen
anderen Videocontroller reingesetzt und so weiter und so fort.
Gut, ursprünglich der erste Prototyp für so einen IBM-PC
sah sowas dann also irgendwie so aus.
Also irgendwie so ein Board, wo dann also irgendein,
ich sag mal, ein armes Schwein bündelweise Leitungen sich da zusammengefrankt hatte.
Und auf der anderen Seite sitzen dann eben diverse ICs,
die dann eben teilweise diese Logik realisieren.
Ich weiß man also hier so ein bisschen angedeutet sieht und dann
eben hier Plätze für diese Einsteckkarten, die dann quasi gegenüber von diesen Teilen hier sieht.
Und hier sieht man auch mal sehr schön,
das sind immer so mehr oder minder parallele Leitung, die dann hier quer rüber verbunden sind.
Das sind dann eben Teile dieses Bussystems. Gut,
knapp 20 Jahre später sah das Ganze dann so aus,
dass man dann eben nicht nur einen einzigen Bus hatte,
wie bei den ersten PCs, sondern da gab es dann also schon mehrere, die dann eben auch unterschiedlich schnell waren.
Das heißt, ich habe dann also mein CPU,
die dann also jetzt über ein sehr schnelles Bussystem irgendwo an den Hauptspeicher angeschlossen war,
Nicht dann gab es dann eben noch spezielle Chips,
die dann also quasi jetzt über Brückenfunktion das Ganze dann eben auf den PCI-Bus gebracht haben,
wo dann eben die ein Ausgabegeräte dran hingen,
die jetzt nur entsprechend schnell waren,
beziehungsweise hohe Datenraten lieferten.
Das waren also einmal so was wie Festplattencontroller,
also was wie in diesem Fall, also Scarcy,
das ist Small Computersystem Interface oder Video oder Netzwerkcontroller.
Und dann gab es dann eben nochmal irgendwo so eine Schnittstelle,
die dann eben mit irgendwelchen Bussen verbunden war,
wo dann eben vergleichsweise langsame
ein Ausgabegeräte dranhängen
Also vom Grundkonzept her hat sich nichts geändert. Man hat
das Ganze jetzt eben nur noch mal irgendwie in unterschiedliche Geschwindigkeiten aufgetrennt.
So, das wurde im Laufe der Zeit dann also immer weiter verfeinert,
ist heute im Prinzip eigentlich auch nicht anders.
Also hier dann noch mal als Beispiel an so ein Motherboard von 2005,
also hier mit Prozessorsorckel und da sieht man dann eben auch nur noch mal Nordsbridge und Sourcebridge.
Das sind eben diese beiden Chips, die jetzt also unterschiedliche Bussysteme voneinander trennen. Hat man heutzutage im Prinzip auch noch,
nur dass da dann teilweise einige von diesen Chips oder diesen Funktionen,
also auch schon in den Prozessor reingewandert sind,
dass also der Prozessor beispielsweise jetzt mit bestimmten Teilen direkt kommunizieren kann und eben diese Funktion,
dass dann also bestimmte, wo es Systeme rausgeführt werden,
da dann eben auch schon mit offene Selitionen mit drauf sind.
Wenn ich hier das Ganze dann nochmal für einen G33-Chipsatz,
zwei Jahre alt, inzwischen,
die Folie habe ich jetzt eigentlich auch nur deshalb genommen,
weil das war sagen wir noch einer der letzten, der letzten Chipsätze,
wo jetzt Zwei von diesen Brettchips drauf sind, nämlich einmal einer,
der jetzt also quasi die schnellen Verbindungen zum Hauptspeicher beziehungsweise zu irgendwie PCI Express-Ein- und Ausgaben,
also Grafiksystemen, zur Verfügung stellt,
wenn man dann eben hier noch eine Source-Podge,
die dann eben zu entsprechend langsameren Systemen geht.
Gut, das war es dann natürlich auch noch hinzugekommen ist,
was ja hier auf einer Folie nochmal draufstellt,
womit wir inzwischen ja eigentlich alle leben, ist, dass man dann sagt,
gut, ich habe jetzt eben nicht nur einen Prozessor,
sondern man hat inzwischen ja also schon Zwei, vier, sechs.
16. Oder noch mehr Prozessoren auf dem Silizium direkt mit drauf.
Die dann also quasi jetzt direkt auf dem Ship entsprechend schnelle Bussysteme haben.
Und dann eben nur noch nach außen hin jetzt ihm hier,
sagen wir mal, einige langsamere Schnittstellen zur Verfügung stellen.
Gut, ein anderer Trend, der dann,
sagen wir jetzt bis zur heutigen Entwicklung dann eben eigentlich auch geführt hat, ist eben,
dass teilweise diese Systeme auch noch deutlich kleiner geworden sind.
Ich hatte ja letztes Mal also bei diesem Motivationsfolien ja auch schon gezeigt,
nicht das, sagen wir mal, ein Handy,
also 10.000-faches der Rechenleistung hat, womit man also damals auf Mond gelandet ist.
Und als ein Beispiel für so eine Miniaturisierung,
als ich hier mal so ein Ship-Foto oder ein Foto von einer Platine von einem Smartphone,
das ist also hier in diesem Fall dann höchstwahrscheinlich ein etwas älteres Apple-Modell,
aber hier ist zumindest schon mal ein angebissener Apfel drauf zu sehen und was man an ihm hier auf dieser Platine eigentlich auch nur sieht,
ist eben letztendlich hier dann auch irgendwie so was wie CPU bzw. Prozess oder irgendwie was macht in diesem Prozessor,
ist dann teilweise auch schon der Speicher mit integriert.
Nicht, und dann habe ich hier noch sämtliche Add-on- und Zusatzchips,
die wir alle alle haben und benutzen, nicht,
das heißt also irgendwelche Sachen für Powermanagement, Stromverwaltung,
irgendwelche Module, die dann eben gebraucht werden,
um jetzt also die ganzen Funk-Antennen anzusteuern bzw. die verschiedenen Funksysteme,
weil ich habe ja jetzt also nicht nur irgendwie GSM20 ist,
sondern man hat dann ja eben auch noch Wi-Fi mit drauf.
Man hat dann eben noch GPS mit drauf.
Also noch irgendwie diverse Beschleunigungssensoren und so weiter und so fort.
Dann gibt es dann eben hier noch spezielle Prozessoren oder spezielle Teile,
die dann eben benutzt werden, um beispielsweise dann eben die Bildschirme anzusteuern,
den Chargescreen zu verwalten und so weiter und so fort.
Gut, das war damals auch noch getrennt auf mehrere Chips,
die dann auf einer Platine sitzen und da komme ich dann leicht zu.
Inzwischen packt man sowas dann alles auch noch hier in diesen
Prozess mit rein.
Jetzt war da aber noch
eine Frage
Gut, also die Frage war,
als ich jetzt hier eben auf der Folien jetzt gesagt habe,
Mehrkernprozessoren, Duel, Kork, Quardcore,
die Frage ging jetzt in die Richtung, dass das gefragt wurde,
Gut, also mit mehreren Kernen habe ich prinzipiell mehr Leistung.
Gut, auch dazu könnte man noch einiges sagen,
dass das also per se nicht nur nur bedingt stimmt,
aber gut, doch, okay, man hat mehr Leistung.
Zusätzlich ist es ja so, dass also bei vielen Prozessoren,
also Intel hat das dann ja, sagen wir mal,
auch sehr schön mit dem Hyper-Srading entsprechend dann vermarktet,
dass man dann eben neben den eigentlichen Kern dann eben noch
zusätzliche Kerne jetzt irgendwie vom Betriebssystem angezeigt bekommt und sich das System so verhält,
als ob es eben nicht nur vier, sondern acht Kerne hat.
Und die Frage war jetzt eben, also inwieweit das jetzt noch
Leistung abzieht von den vöbliebenen Kernen bzw. von dem Gesamtsystem.
Habe ich das so richtig verstanden
Gut, also die, da sieht das jetzt eben so aus,
dass, was dort quasi an Kern vorgestellt wird,
beziehungsweise dieses Konzept des Hyper-Sreading, beziehungsweise wenn man das als wissenschaftlich betrachtet,
nennt sich das Simultanio Smulty-Threading, ist folgendes, dass in den Recheneinheiten der CPUs,
in den Datenfaden mehrere Register oder Register mehrfach ausgelegt sind.
Da müsste jetzt, also sagen wir mal,
ein bisschen, Tafel haben wir nicht da,
müsste ich jetzt also sagen, ein bisschen vorgreifen,
weil es geht also im Prinzip darum, dass man sagt,
ich habe ja jetzt eben kurz nur vorgestellt,
also jetzt bei dem von Neuern Konzept,
ich habe jetzt also irgendwie Register,
ich habe jetzt also irgendwie eine Alu und eine Alu ist letztendlich sowas wie ein Schaltennetz,
da werfe ich zwei Zahlen rein, da kommt eine Zahl raus.
So, das funktioniert nur, wenn die Schaltung vergleichsweise langsam arbeiten,
weil die Zeit, die die Berechnung braucht,
damit diese zwei Zahlen durch die Alu addiert werden, ist schon relativ groß.
Das, was deswegen die gesamten Prozessoren machen, ist,
dass sie die Verarbeitung, die intern stattfindet bei dieser Befehlsabarbeitung,
nicht wie ich das jetzt eben erstmal so primitiv dargestellt habe,
in einem Schritt oder in einem Takt machen,
sondern die wählen jetzt in mehrere Schritte unterteilt.
Das heißt, in den Datenfaden in der Alu gibt es
dann eben etwas, was sich dann Pipeline nennt.
Das heißt, ich mache nicht die gesamte Addition in einem Stück,
sondern ich unterteile jetzt in mehrere Teilschritte, wo ich also erst nur ein Teil berechne.
Dann kommt ein Register, dann kommt wieder eine Teilberechnung und
dann kommt wieder ein Register. Und die Idee dahinter ist,
dass diese Berechnung jetzt eben schrittweise mit jedem Takt
von einem Register zum nächsten etwas weiter durchgeführt wird und weiterarbeitet
So, damit habe ich im Prinzip erst mal für die Gesamtberechnungszeit noch nichts gewonnen.
Gewinn tue ich dadurch was, dass ich sage,
ich kann jetzt mit jedem Takt eine neue Teilberechnung anfangen.
Und das ist der Trick gewesen, womit die Prozessorhersteller,
also irgendwann mal, um die 90er Jahre war das dann,
also da es geschafft haben von irgendwelchen Taktfrequenzen von 30 Megahertz,
auf einmal Maschinen rauszubringen, die ein paar hundert Megaherz-Taktfrequenz hatten,
wo da nämlich in den Datenfaden quasi diese Unterteilung ist.
Und das hat sich eben heute auch fortgeführt. Und wenn man jetzt sagt,
okay, wir haben jetzt also hier irgendwie so einen Prozessor,
also der ist hier im Notebook nicht,
aber also jetzt auf irgendeinem Desktop-Gerät,
also mit 3,4 Gigahertz getaktet wird, dann ist das die Grundtaktfrequenz.
Ich habe aber für die Berechnung einer Addition beispielsweise dann meinetwegen
acht Takte zur Verfügung, weil das einfach technisch gesehen immer
noch so lange braucht.
So, das ist jetzt erstmal
das vorneweg geplänkel
Warum ich in diese Alo-Register habe? Und jetzt habe ich
das Problem bei der Berechnung, dass ich beispielsweise das ganze System ist,
also mit einer Riesentaktfrequenz beheizen kann.
Und ich jetzt feststelle, für meine Berechnung,
ich muss irgendwelche Daten aus dem Speichern holen,
die jetzt nicht in irgendwelchen Registern sind.
So die es holen aus dem Speicher, dauert erstmal unendlich lange.
Jetzt kann ich natürlich diese Berechnung erstmal anhalten.
100.000 Takte warten oder noch ein paar mehr.
Dann habe ich den Wert aus dem Speicher und dann
kann ich weiterrechnen
Weil ich dann erst dieses Datum habe.
Ist natürlich fürchterlich ineffizient. Deswegen sagt man, gut,
beim normalen Rechner habe ich ja nicht nur einen rechenwilligen Prozess,
sondern ich habe mehrere.
Ich habe das Betriebssystem, das, was machen will.
Ich habe jetzt irgendwas, was jetzt hier Grafik und Ausgabe
macht. Ich habe jetzt hier meinen PDF-Reader. Im Hintergrund
läuft noch irgendein Job, der das und das macht.
Und die sind ja, werden jetzt ja quasi vorm Betriebssystem
her auf diesem Prozess irgendwo verteilt, zeitlich.
Und bei einer dieser Berechnungen wird jetzt quasi festgestellt,
da fehlt was und da
müsste ich jetzt anhalten
So, und jetzt kann man sagen,
diese Berechnung wird zurückgestellt, der nächste Prozess läuft los.
Wird auch gemacht. Wenn diese Berechnung jetzt aber schon zum Teil
in dieser Pipeline drin ist, und es wird festgestellt,
da fehlt was, dann muss ich quasi das Ganze rückgängig machen.
Und wenn der Prozess irgendwann später wieder neu startet,
das Ding nochmal wieder von vorne aufsetzen und diese Takte in die Pipeline tun. Und das,
was jetzt also bei diesem Hyper-Straading oder bei dem Multi-Threading generell passiert,
ist, dass ich sage, ich habe in dem Pipeline,
in der Pipeline nicht nur einen, sondern mehrere Registersätze,
Kann da irgendwie reinarbeiten, stell dann fest, da fehlt was.
Und da kann ich einfach diese Recheneinheiten von dem einen
auf den anderen Registersatz umschalten, rechne mit dem weiter.
Und irgendwann, wenn dieses erforderliche Daten beispielsweise da ist,
kann ich wieder zurückschalten und mit dem ersten weitermachen.
So, und dieser Faktor 2,
den jetzt eben beispielsweise hier die Internet-Prozessoren haben,
wo man dann sagt,
also ich habe eigentlich nur vier CPUs,
aber also hier
irgendwelche Tools geben mir acht an
Der steht eigentlich dafür,
dass ich eben quasi in diesen arthenmetischen Pipelines genau zwei Registersätze parallel habe und sich die Rechenwerke,
beziehungsweise dann auch nicht nur in den Pipelines,
sondern auch im Steuerwerk entsprechende Vorrichtungen habe,
die Rechenwerke dann eben so ausgeben,
als ob sie eigentlich zwei Kerne sind und man dadurch sehr schnell umschalten kann.
Nicht das erklärt dann diese Zahl. Das heißt dann,
in dem Fall also,
um jetzt auf die Frage zu antworten,
man hat mehr Rechenleistung oder mehr Durchsatz,
es nimmt von dem anderen
aber nichts weg
Gut, das war jetzt ein größerer Exkurs, aber gut,
schauen wir später. Ja, also Mobilgeräte, wie gesagt,
zum einen, weniger redet natürlich immer deutlich kleiner,
also hier jetzt eben alles auf Platine beziehungsweise dann auf ein System gebracht.
Gut, dann habe ich jetzt also nochmal ein bisschen Übersicht,
wo jetzt also einige alte Geräte, historische Sachen mit drauf sind,
wo man jetzt sieht, also im Prinzip irgendwann in langer,
langer Vorzeit wurden im Prinzip dann sowas wie irgendwie Abakurs als erste Rechenhilfen eingeführt.
Nicht, dann gab es also verschiedene mechanische Frechenmaschinen,
also von 1642, Plays Pascalen, Rechenwerk,
was Adil und Subtrahieren konnte.
Irgendwann 30 Jahre später hat dann also eine Mathematikerleitennetzung,
also eine Rechenmaschine vorgestellt, die vier Operationen konnte.
Das heißt, man konnte auch schon multiplizieren und dividieren.
Wenn ich 1837 von Barbarage an Alytical Engine,
damit wurden im Prinzip Tedentabellen
für die Schifffahrt berechnet
Nicht dann die ersten Maschinen von Konrad Zuse. Und dann in
den 40er-Jahren dann eben auch so die eine relativ breite Entwicklung,
wo dann eben auch parallel dann in Deutschland, Amerika,
wo auch immer, dann eben verschiedene erste Rechner aufkamen.
Und im Prinzip dann hier so die ersten Sparcher programmierbaren Rechner beziehungsweise
dann wohnen letztendlich nachher dann diese Konzepte von John von Neumann
entwickelt und dann dementsprechend auch umgesetzt.
Nicht vieles von dem, was es vorher da noch gab,
waren dann eben wirklich nur spezielle Rechner,
die dann eben für nur genau eine einzige Aufgabenstellung ausgelegt waren
So, jetzt folgen hier also noch so ein paar Folien,
wo das Ganze dann also nochmal so ein bisschen grafisch visualisiert ist,
nämlich also hier im Prinzip so ein ganz normaler Abakus,
mit dem man also Adien oder Subtrahieren kann.
Nicht dann eben so die ersten mechanischen Rechenmaschinen,
die in der Regel daran kranken,
dass das natürlich also irgendwo jetzt einfach von der Mechanik,
also sprich, wie jetzt also da irgendwelche Zahnräder ineinander geriffen,
so ungenau war, dass das also meistens nicht so richtig gut funktionierte.
Also hier dann auch nochmal in zeitlicher Einordnung, dann eben
die ersten Richtig, gut. Also wie gesagt, Leibniz,
die ersten Maschinen, die also auch multiplizieren, dividieren konnte.
Na gut, knapp 100 Jahre später war das Ganze mechanisch dann überhaupt erst richtig umsetzbar.
Nicht also vieles von denen wurde vorher erstmal nur als Modell gebaut,
hat dann aber doch nie so richtig funktioniert.
Nicht dann eben von Babbitch diese Difference Engine,
also Berechnung in autostadt Tabellen, was dann also vielleichtsweise aufwendige mechanische Monster waren,
die dann aus irgendwelchen Walzen und Trommeln und irgendwelchen Antrieben waren,
Zahnräder, die also ineinander griffen oder also irgendwelche Differenzialrechnungen im Prinzip machen sollten.
Nicht dann das Ganze in der ersten Version in einer Art Programmierung.
Das heißt, man konnte in diesen Maschinen dann eben auch
noch so was wie Parameter mit reinstecken.
Nicht die ersten Maschinen von Konrad Zuse, nicht am Anfang,
also 64 Register, 22 Bit, wurde also mechanisch gerechnet mit einem Lochfilm.
Da gibt es dann eben irgendwelche Stifte,
die dann quasi da reingreifen und da irgendwo entweder durchgehen oder nicht
Damit läuft, wenn letztendlich diese Steuerung der Berechnung,
nicht, dann gab es anschließend Zusätze 3. Da ist das
Ganze dann schon elektrisch umgesetzt mit 2000 Klackern in Relais,
die dann also irgendwie ein- und ausschalten können.
Und Loch filmt dann eben nur noch als Medium für
die Steuerung und Ausgabe. Dann eben verschiedene Modelle,
die dann letztendlich in Amerika auch entwickelt wurden,
wo man dann also anfängt,
also jetzt von Relais dann nachher, also auf Röhren umzusteigen.
Das ist so das, was man hier vorne noch so
ein bisschen sieht
Also im Prinzip verstärker euren Anyak,
Electronic Numerical Integrator und Computer, also auch ein Röhrenrechner,
der dann also letztendlich hier diesen gesamten Raum einnimmt. Programmierung passiert dadurch,
dass man quasi wie bei so einem Telefonsteckbrett einfach nur irgendwelche Kontakte von Hand,
also in diesem Tal jetzt hier reinstecken kann und dadurch ein bisschen was
an Funktionalität da drin umschaltet und das Ganze ist von der Idee her eben auch entwickelt worden,
also nach einem Zensus,
also nach einer Volkszählung,
statistische Daten zu erheben
War den ersten Rechner, gab es dann also auch
schon Computerbugs, also nee, eine Programmierung.
Ich weiß nicht, wer das hier irgendwie mal ausgegraben hat.
Mit dem Wortspiel ging es da dann eben darum,
das waren ja entweder Relais oder da dann auch noch irgendwelche späteren Elektronenröhren,
also irgendwas, was da also unter Hochspannung lief.
Da haben sich dann natürlich, weil das auch warm war,
also gerne mal irgendwelche Insekten rein verirrt,
die dann eben entweder in dem Relais hängen blieben oder
in den Röhren zum Kurzschluss geführt haben
Nicht, dann funktioniert da auch wieder nichts. Also alles,
was wir heute eigentlich kennen, einschalten und läuft,
gab es bei diesen Geräten nicht, weil wenn ich mir da vorstelle,
ich habe da also irgendein Gerät mit 2000 Röhren,
die da irgendwie vor sich hin blimmen und arbeiten,
in der Regel halten die nicht so lange und irgendeine von denen wird mehr oder minder immer kaputt sein.
Das heißt, da hat man dann also schon etwas andere Probleme. Gut,
das Ganze zieht sich dann eben hier noch entsprechend weiter fort,
jetzt mit irgendwelchen Bildern, denkt man,
das können sie sich dann also nochmal in Ruhe bei Interesse dann irgendwie nochmal ansehen.
Ansonsten kann man nur sagen, gut,
das ist also historisch eigentlich immer nur insofern mal ganz interessant oder ganz beeindruckend, wenn man sieht,
also wirklich, welche Schränke und was für Technik da so aufgefahren wurde,
um also irgendwie was zu berechnen, wo man sagen kann,
dass also wirklich jeder einfachste Taschenrechner, den es also irgendwo für zwei Cent als Giveaway gibt, deutlich leistungsfähiger.
Gut, dann sagen wir mal so eigentlich zu der Zeit,
als man überging, irgendwann nachher auf Transisto-Technik,
beziehungsweise dann eben die ersten Mikrocomputer aufkamen,
gab es dann eben schon entsprechende Verbesserungen,
dann also in den 60er Jahren,
beziehungsweise in den 70er Jahren, wo dann im Prinzip,
weiß man, 1964 diese IBMS 360-Rechnerfamilie rauskam,
das war das, was ich da gezeigt hatte,
also bei dem Apollo-Programm,
wo das dann also eine Firma,
also schon mal sich überlegt hatte,
ich biete jetzt unterschiedlich groß oder unterschiedlich schnelle Rechner an und
der Kunde kann eben entweder das Modell für drei oder für fünf Millionen kaufen und da dann eben noch vielleicht noch irgendwie das und das ein bisschen abgereden oder noch unterschiedliche Sachen haben.
Die Rechner sind aber alle untereinander quasi kompatibel. Und wenn ich
eben ein Programm entwickelt habe, was auf der einen Maschine läuft,
läuft es auf der anderen Maschine dann eben genauso.
Im Zweifelsfall dann aber natürlich schneller. Nicht dann Anfang der
70er Jahre kamen von Intel die ersten Mikroprozessoren,
beziehungsweise dann eben mit dem 8008 das erste Mikrocomputersystem, 8-Bit Wortbreite.
Nicht, dass es dann also ungefähr das,
was also hier in diesem Hade-Simulator dann möglich ist, Also unglaublich,
Zahlen von 0 bis 255 kann man damit dann also schon darstellen.
So in einem Wort, also das ist schon recht stark. Gut,
dann in den, wie gesagt, Anfang der 80er Jahre,
dann mit dem 80er, 88, dann der erste IBM-PC,
rechnet damit 16 Bit und irgendwann später dann eben die Entwicklung,
32 Bit, 64 Bit Wortbreite, Anfang der 90er Jahre,
das ist also auch ungefähr das, worauf ich eben schon angespielt hatte,
mit dem Deck Alpha kam dann,
wurde es dann also auf einmal möglich,
dass die Chips also auf deutlich schneller wurden.
Also vorher, beziehungsweise das, was dann also bei der Intel-Architekturen gab,
war die Taktfrequenz, also mal so bis maximal 75 Megahertz.
Und also Deck hat dann also als Bahnbrechende,
also mit einer ganz neuen Schaltungstechnik und ganz neuen Konzepten,
also gleichzeitig Rechner, die dann also irgendwie auf einmal mit 600 Megahertz liefen.
Und vieles von diesen Konzepten wurde dann eben auch in die
nächsten Prozesse und Generationen beispielsweise dann eben bei Intel auch mit eingebaut
Und die zogen dann da. Gut,
hier dann einfach jetzt nur noch mal so als zwei Benchmarks,
also im Prinzip 2006, kamen dann eben so die ersten Multi-Prozessoren,
auch in den Consumer-Markt, dann allerdings nicht im Bereich von Rechnern,
sondern im Bereich von Spiele, also die Sony PlayStation 3 ist im Prinzip acht kein Multi-Prozessor.
Erstaunlicherweise wurden dann diese Chips oder diese Teile dann eben
zum Beispiel auch damals in relativ vielen Supercomputern eingesetzt,
weil ja so eine eben entsprechend hohe Rechenleistung haben
Die dann eben in der PlayStation 3 im Prinzip für
die Grafik-Engine oder Grafikberechnungen eingesetzt wurden. Gut,
2006 kamen dann sowohl Intel als auch AMD dann mit zusätzlichen Unterstützungen für Virtualisierung,
jetzt eben auf der Prozesse-Ebene mit raus,
dass das dann eben auch nur entsprechende Hardware-Unterstützung deutlich schneller wird.
Gut, wenn man sich diese Historie jetzt ansieht,
kann man jetzt eben sagen, okay,
die ersten Computer, so in den 50er Jahren,
für die gab es eigentlich noch so gut
wie keine Software-Unterstützung
Gab es, also das, was ich davon an Schichtenmodell hatte,
eigentlich auch noch überhaupt nicht, sondern es gab also nur irgendeine Hardware,
auf der das läuft und irgendwo,
wo ich dann versuche, das Programm einzuhacken bzw. reinzustecken,
wie auch immer das gemacht wurde.
Und die eigentliche Programmierung wurde dann wirklich ein elementarer Maschinensprache gemacht.
Da gab es auch nicht diesen Unterschied,
dass es jetzt mehrere Programme zur Ausführung kam,
sondern es wurde nur dieses eine Programm irgendwie reinprogrammiert.
Das Ding wurde einmal irgendwie gestartet, hat da was berechnet
und dann wusste ich hinterher in dem und dem Speicherbereich,
habe ich letztendlich mal
ein Ergebnis
Um da dann die Programmierung noch zu vereinfachen,
kamen dann Anfang der 50er Jahre im Prinzip Konzepte der Mikroprogrammierung,
wo man also die Maschinensprache letztendlich aufgebohrt hatte, auf unglaublich komplexe Befehle.
Das sind dann nachher dann die, oder von der Grundidee her,
dann die Zisk-Rechner gewesen, steht dann für komplex Instruction-Set Computer,
wo ich mit einem Maschinenbefehl sagen kann, ich möchte,
den wird aus dem Speicher holen, Den wird dazu addieren.
Gleichzeitig soll dann also irgendwo noch in einem Register ein Autoinkrement stattfinden.
Und ich möchte dann das und das gleichzeitig noch mitmachen.
Damals hatten die Rechner dann da eben deutlich mehr Befehle bis zu über 300.
Sehr komplexe Adressierungsarten. Dadurch, dass aber eben auch noch
keine Unterstützung auf höheren Ebenen gab. Also das,
was wir jetzt eigentlich so als Compiler kennen und benutzen,
hatte man damit eben die Möglichkeit,
mit diesem Mikroprogramm mit diesen sehr mächtigen Befehlen eben quasi mit
dem Buffet oder mit einem Befehl schon sehr komplexe Berechnung anstellen zu können.
So war es also möglich, mit zwei oder drei Befehlen
quasi jetzt von einem zweidimensionalen Array alle Elemente auszulesen und aufzusummieren.
Wo man jetzt also mit einem sehr einfachen Befehlssatz sehr,
sehr viele Befehle braucht, das ging dort mit wenigen Befehlen.
Aber dadurch dann eben Er, der Mann,
mit dieser elementaren Maschinensprache programmiert hat, hat man ihm zugesehen,
dass er die Maschinensprache letztendlich nach oben hin erweitert.
So, irgendwann später wurden dann also im Zuge der Softwareentwicklung
dann eben wirklich vernünftige Compiler entwickelt. Es kamen Hochsprachen.
Das, womit wir jetzt eben eigentlich alle programmieren.
Und diese Notwendigkeit für diese unglaublich komplexen Befehle bestand eigentlich gar nicht mehr.
Nicht in dem Zufolge konnte man dann wieder zurückgehen zu elementaren
einfachen Befehlen
Das, was dann als Maschinencode zur Ausführung kommt, wird eben vom Compiler erzeugt.
Da muss ich mich jetzt nicht mehr drum kümmern.
Habe dann aber eben auf der anderen Seite dann auch wieder sehr performante Hardware,
die eben diese einfachen Befehle sehr einfach und sehr direkt abarbeiten kann.
Das ist eigentlich das Konzept, das also heutzutage allen Rechnern zugrunde liegt,
heißt dann eben Risk, Reduced Instruction Set Computer.
Und wie gesagt, diese Grundideen,
Sisk und Risk werde ich dann,
also wenn ich dann nachher oder später dann noch auf Befehlsätze
zu sprechen komme,
dann also auch nochmal kurz vorstellen gegeneinander
Sein. Gut, wie gesagt, also am Anfang eine Computerei,
direkte Programmierung auf Maschinensprache und man ist dann eben dazu übergangen,
diese zerskreicher zu bewegen.
Gut, gleichzeitig kamen dann eben auch die ersten Betriebssysteme auf,
weil am Anfang war es eben auch so,
dass der Rechner letztendlich immer nur von einer einzigen Person benutzt wurde.
Das war nämlich der Programmierer oder der Operator.
Das war dann also auch der einzige Eingeweite,
der also mit diesem riesen Schrankmonstrum da also irgendwie was machen konnte und umgehen konnte.
Was dann natürlich immer heißt,
dass die Maschine eigentlich nicht richtig gut ausgelastet ist und man
als Ehrenwender eben auch mit vielen anderen Sachen überfordert wird
Nicht dann entwickelten sich eigentlich daraus dann die ersten Betriebssysteme,
wo man dann gerade im Zuge so einer Effizienz dann sowas wie Badge-Modus eingeführt hatte,
was dann im Prinzip so in den 60er,
70er Jahren letztendlich kam,
dass man als Anwendung oder als Programmierer sein Programm dann auf Loch streifen oder Lochkarten irgendwo reinprogrammiert hatte,
hatte das dann irgendwo im Operating abgegeben und zwei Stunden später konnte man sich dann eben die Ausdrucke,
die dann also quasi aus dieser Berechnung rausgekommen sind,
irgendwo später wieder abholen.
Und da gab es dann eben diese Trennung von Operating und dem eigentlichen Programmierung.
Also dass das hier dann entsprechend angetagt ist. Das ist dann
eben diese Badge-Verarbeitung. Gleichzeitig wurde dann eben bei Betriebssystemen auch sowas eingeführt wie System Calls,
dass man dann eben auch eine Unterscheidung hat zwischen Befehlen,
die jetzt also nur für das Betriebssystem relevant sind und den Befehlen oder dem,
was also der Anwender machen darf,
war als Anwender oder als Programmierer darf ich natürlich jetzt eigentlich
auch nicht alles machen oder auf alles darauf zugreifen,
was der Prozessor theoretisch zur Verfügung hätte
Gut, geschichtlich gesehen, wenn das jetzt weiter geht,
also am Anfang, wie gesagt, diese ganz einfachen Systeme mit Röhren,
dann kamen eben entsprechend Transistoren, 1948 von Baden-Britton und Schockley erfunden.
Das Ganze wird deutlich kleiner,
die Rechner sind da jetzt nicht mehr mehrere Schränke,
sondern nur noch ein, so ein großer Schrank groß.
Nicht Anfang der 60er Jahre von Deck, PDP 1,
hat dann also schon 200 Kilo Herz-Tag-Frequenz, verlächere ich 120.000 Dollar.
Es gibt dann also schon so was wie Grafikdisplays,
wobei man also Grafikdisplay sich ja so vorstellen muss,
man konnte im Prinzip einen Lichtpunkt jetzt irgendwie beliebig übers Display steuern lassen.
Natürlich haben dann also die ersten Programmierer dann auch schon angefangen,
also irgendwie so was Pong-artiges oder wie auch immer man das nennen möchte,
also irgendwelche einfachen Spiele da zu programmieren.
Nachfolger, der dann also wirklich ein Verkaufsschlager wurde,
war ja auch unglaublich günstig,
war dann also ein PDP 8.
Das ist also hier
so ein Modell
Nicht gleichzeitig wurde dann eben diese gesamte Peripherie-Hardware auch deutlich kleiner.
Also bei den ersten Computern waren Maaßenspeicher im Prinzip Lochkarten,
Lochstreifen der Magnetband. Jetzt kam auf einmal sowas wie Festplatten auf.
Also auch das muss man sich noch ein bisschen anders vorstellen,
als das, was man heutzutage hat,
wo man jetzt also wirklich mit kleinen zweieinhalb Zollplatten oder mit Flash-Speichern arbeitet,
sondern das waren hier quasi solche Türme von acht Zoll großen Magnetscheiben,
in die dann also letztendlich kamen.
Also hier sieht man jetzt diese einzelnen Scheiben
und da griffen dann kamenartig Leseköpfe rein
Nicht, aber man konnte, also schon ganze fünf Megabyte, also auf Symptomen speichern.
Nicht mit einer lächerlichen halben Sekunde Zugriffszeit. Das ist also im Verglichen,
wie gesagt, mit irgendwelchen Lochkarten oder mit Magnetbändern,
die jetzt an irgendeine bestimmte Position gefahren werden. Natürlich schon ein Riesenfortschritt. Gut,
mit der Erfindung der ECs integrierten Schaltung,
wo ich jetzt also nicht nur einzelne Transistoren habe,
sondern schon hunderte,
wenn ich gar tausende Transistoren irgendwie auf einem Chip unterbringen kann,
kamen dann eben Vielleicht war sie erfolgreich ein Computer auf,
also beispielsweise die IBM 3060-Serie,
wo es dann eben unterschiedliche Modelle mit unterschiedlich großem Speicherausbau und unterschiedlichen Geschwindigkeiten gab und so weiter und so fort.
Ja,
und dann letztendlich ab den 70er Jahren als nächste Generation VLSI,
very lard scale integration,
wo dann im Prinzip ich deutlich mehr Transistoren auf dem Ship unterbringen kann,
wo man es dann also letztendlich erreicht,
dann eben
auch den gesamten Prozess auf einem Ship unterzubringen
Das, was wir heute kennen,
ich habe also quasi auf meinem Silizium-Plättchen von zweimal drei Zentimetern
sechs Kerne und relativ viel Speicher,
was also dann in Form von Cashes dort untergebracht ist und noch irgendwelche ein Ausgabecontroller gleichzeitig mit drauf.
Das war damals nicht, sondern das,
was ich letztes Mal da als, sagen wir mal,
musste ohne Werte, diese eine Einsteckkarte oder diese Platine hatte,
wo ich ja gesagt habe, das ist Teil der CPU gewesen.
Da kann man dann eben wirklich sagen, bei diesen ersten Computern,
wo das also wirklich noch Schrankgröße war,
da waren dann wirklich zig solcher Karten miteinander verbunden und alle
diese Karten zusammenstellten dann letztendlich eine einzelne CPU dar.
Gut, mit dieser steigenden Integrationsdichte konnten dann eben entsprechend immer mehr Funktionen
untergebracht werden und man erhält dadurch dann eben immer kleinere und mobile Geräte.
Gut, auch bei den schnelleren Rechnern,
Workstation geht das Ganze weiter, zwei Folien habe ich noch.
Also da ist jetzt hier noch als abschließende Folie letztendlich aus dem Tarnbaum auch letztendlich rausgezogen.
Nicht, wenn man sich heutzutage so ein Rechnerspektrum ansieht,
was gibt es da alles? Also wie gesagt,
die Preise sind einfach nur erstmal von der Relation zu sehen.
Nicht unbedingt absolut. Kann ich eben sagen,
ich habe auf der einen Seite sowas wie Wegwerfcomputer,
also sprich Aufklappen, Nudelnde Glückwunschkarte, die da irgendwelche Melodien abspielen.
Ich habe Mikrocontroller, die jetzt eben irgendwo zuhauf in Uhrenhaushaltsgeräten
oder Autos eingebaut werden. Ich habe irgendwie dann Personal Computer,
Was man also eben so als Desktop oder als Notebook hat.
Und das geht dann eben nach oben hin weiter bis zu irgendwelchen Workstation-Classern,
die man dann also quasi als Abteilungsrechner betreiben kann,
dann eben richtigen Großrechnern, die es also auch heute immer noch gibt,
wo entsprechende Verarbeitungsleistung gefragt wird, bis hin zu Supercomputern,
die auch heute immer noch entsprechend teuer sind,
wo man dann eben versucht,
jetzt irgendwie sowas wie gesamte Weltklimamodelle zu berechnen oder entsprechend aufwendige Simulationen.
Gut, damit werde ich jetzt für heute schließen,
dann schönes Wochenende,