Das Video kommt von YouTube: erst beim Abspielen verbindet sich die Seite mit YouTube (Google).

EIG: Die Registermaschine

Name: EIG: Die Registermaschine
Uploaded: 2023-05-09T09:15:00+00:00
Duration: 22 min 1 s
Channel: Harald Selke
Description: Die Registermaschine ist ein theoretisches Computermodell, das zeigt, wie einfach eine Maschine aufgebaut sein kann, die beliebige Algorithmen ausführen …

Harald Selke22:01 571 Aufrufe veröffentlicht 9. Mai 2023 Auf YouTube

Das Wichtigste aus dem Video

Tipp auf eine Zeit – das Video springt genau dorthin.

Transkriptautomatisch erstellt · 149 Zeilen

Herunterladen

Willkommen zur Einführung in die Informatik für Geisteswissenschaftler Dieses Video ist entstanden im Rahmen der gleichnamigen Veranstaltung an der Universität
Paderborn. In diesem Video möchte ich die Registermaschine vorstellen. Diese ist ein theoretisches Modell für einen Computer – sie existiert nicht
in Wirklichkeit, aber sie ist insofern ein sehr gutes theoretisches Modell, da sie uns zeigt, wie einfach eine Maschine aufgebaut sein kann, die in der Lage sein soll, beliebige
Algorithmen auszuführen. Sie ermöglicht es uns – zumindest vom Prinzip her –, die Algorithmen bzw. deren Konzepte, die wir in den letzten Vorlesungen bzw. Videos kennengelernt
bzw. angesprochen haben, auf eine Maschine zu übertragen. Diese Maschine ist einigermaßen ähnlich zu einem realen Computer – einem sehr einfachen realen Computer, muss man sagen.
Unsere Computer, die wir heutzutage haben, sind in der Regel erheblich komplexer aufgebaut, aber die Grundprinzipien sind genau die gleichen. Für diejenigen, die das Video zur Turingmaschine
gesehen haben, sind hier einige Dinge wiederzuerkennen. Wir haben auch hier ein Eingabe- und ein Ausgabeband, die hier etwas anders dargestellt sind. Auch die anderen Komponenten erinnern ein wenig
an die Turingmaschine, sind aber tatsächlich deutlich anders – das werden wir noch sehen. Wer das Video zur Turingmaschine nicht gesehen hat, hat nicht wirklich etwas verpasst – alles
Folgende wird auch so verständlich sein und ich werde das hier alles ausführlich erläutern. Nur kurz noch: Man kann zeigen, dass die Registermaschine und die Turingmaschine zueinander äquivalent
sind, das heißt, dass alles, was die eine Maschine berechnen kann, auch von der anderen Maschine berechnet werden kann. Das soll uns aber jetzt nicht weiter interessieren, sondern
nur eine Hintergrundinformation für diejenigen sein, die das Video zur Turingmaschine gesehen haben. Im weiteren Verlauf braucht uns die Turingmaschine aber hier nicht weiter zu interessieren.
Die Registermaschine ist also ein idealisierter Computer, der intern – in der Maschine selber – das Programm verwaltet. Dafür ist diese Maschine aus verschiedenen Komponenten aufgebaut,
die hier dargestellt sind. Das ist zum einen das Programm – also die formale Darstellung unseres Algorithmus in Form von elementaren Befehlen für die Maschine. Den Befehlssatz,
über den diese Maschine verfügt, werden wir gleich kennenlernen und dann auch sehen, wie einfach ein solcher Befehlssatz aufgebaut sein kann: Unsere Maschine verfügt über
gerade einmal zwölf verschiedene Befehle und ist damit in der Lage, jedes beliebige Programm dieser Welt auszuführen. Wir haben als zweite Komponente ein Eingabeband.
Wenn man das mit einem heutigen Computer vergleichen möchte, wäre das so etwas wie eine Tastatur. Hier allerdings muss die Eingabe vorab, also bevor die Ausführung des Programms beginnt,
komplett vorliegen. Wir können uns also nicht unterwegs überlegen, dass wir auf das Eingabeband noch einmal weitere Werte schreiben – wir haben hier kein interaktives System. Auf diesem
Eingabeband steht also unsere Eingabe, immer ein Wert in einer Zelle, also einem dieser Kästchen. Wir werden gleich noch sehen, wie wir diese Eingaben lesen können, so dass
unser Programm mit dem, was in der Eingabe steht, arbeiten kann. Das Gegenstück dazu ist das Ausgabeband; das wäre entsprechend vergleichbar mit dem
Monitor unseres Computers, oder eher einer an unseren Computer angeschlossenen Schreibmaschine. Auch dort haben wir wieder Zellen, in die immer jeweils ein Wert geschrieben werden
kann. Jeder Wert sowohl im Eingabeband als auch im Ausgabeband kann immer ein beliebig großer Wert sein, also eine beliebige Zahl sein. Hier merkt man schon, dass es sich um
ein theoretisches Modell handelt, denn wir haben hier keine Begrenzung, dass also nur Zahlen bis zu einer bestimmten Größe – mit je ein, zwei oder vier Byte beispielsweise
– in eine solche Zelle hinein passen würden. Für dieses theoretische Modell können wir beliebig große Zahlen, auch mit Nachkommastellen in jede einzelne Zelle packen. Wir betrachten
hier ohnehin nur kleine Programmbeispiele, so dass dies alles keine große Rolle spielen wird. Wir haben auf der rechten Seite in diesem
Bild dann noch die Register. Diese geben der Maschine ihren Namen – Registermaschine im Deutschen. Auf englisch heißt sie Random Access Machine – random access bedeutet,
dass wir jederzeit auf beliebige Register zugreifen können. Wie das funktioniert, werden wir gleich noch sehen. In diesen Registern kann ebenso wie im Eingabe- und Ausgabeband
in jeder Zelle immer ein beliebig großer Wert stehen – immer nur ein einziger Wert in jedem einzelnen Register, niemals mehrere Werte gleichzeitig. Das bedeutet, wann immer
wir einen neuen Wert in ein solches Register hineinschreiben, ist der alte Wert, der dort zuvor stand, unwiderruflich verloren. Wenn wir uns einen Wert also merken wollen, weil
wir ihn später noch brauchen, müssen wir daher auf jeden Fall dafür sorgen, dass wir ihn in einem separaten Register irgendwo speichern. Ansonsten ist der Wert wie gesagt verloren,
es gibt also keine Erinnerung in diesem Register. Ein Wert bleibt also so lange in einem Register erhalten, bis er überschrieben wird – dann aber ist er auch tatsächlich weg.
Die Steuerung des Ganzen übernimmt die endliche Kontrolleinheit, die wir da in der Mitte sehen. Die wird uns eigentlich gar nicht weiter interessieren, außer dass sie eben im Grunde die Logik dieser
Maschine in ihrem Inneren zusammenhält. Sie sorgt dafür, dass die Befehle dieser Maschine nacheinander abgearbeitet werden, also das Programm. Dafür besitzt die Maschine einen
Instruktionszähler, der anzeigt, welche Anweisung als nächstes ausgeführt werden soll. Die Anweisungen werden nacheinander ausgeführt: Wir beginnen mit dem Programmschritt Nummer
0 – hier sehen wir wieder, dass Informatiker gerne bei 0 anfangen zu zählen, wie wir das bei den Codierungen schon kennengelernt haben und uns das noch öfter wieder begegnen wird.
Der erste Programmschritt ist also der nullte Programmschritt, dann kommt der erste, dann der zweite, dann der dritte usw. – das ist die normale Reihenfolge. Wir werden sehen,
dass wir von dieser Reihenfolge abweichen können – dafür gibt es sogenannte Ablaufkontrollbefehle oder Sprungbefehle, die wir gleich noch kennenlernen werden.
Auf das Eingabeband zeigt ein Lesekopf. Ein Lesekopf ist im Grunde genommen wie früher bei einem Tonbandgerät oder Kassettenrekorder – falls Ihr solche Geräte noch kennt. Dabei
können wir nur den Wert in der Zelle an dieser einen Stelle, an der der Lesekopf steht, lesen. Der Wert bleibt auf dem Eingabeband stehen, aber wir können diese Zelle anschließend
nicht erneut lesen. Wenn wir eine Zelle ausgelesen haben, wandert der Wert in die endliche Kontrolleinheit hinein und der Lesekopf wird eine Zelle weitergesetzt. Hier würde der Lesekopf dann also auf der
zweiten Zelle stehen. Wir können den Lesekopf nie wieder zurücksetzen, das heißt, dass ein Wert, den wir einmal gelesen haben, gewissermaßen weg ist und wir nie wieder an diesen Wert
kommen. Wir haben ihn im Moment noch in der endlichen Kontrolleinheit und können ihn nun aber irgendwo ablegen, nämlich in einem Register. Wenn wir das nicht tun, ist der
Wert auf immer verloren. Wenn wir also mit der Eingabe irgendetwas anfangen wollen, müssen wir sie auf jeden Fall in irgendeinem Register speichern – alles andere wäre eine ziemlich
blöde Sache, weil wir dann eben wie gesagt mit unserer Eingabe gar nichts anfangen könnten. Das Gegenstück zum Lesekopf ist der Schreibkopf, der auf das Ausgabeband verweist. Auch der
zeigt auf eine bestimmte Zelle und wird von da aus automatisch immer um eine Zelle weiter bewegt, sobald ein Zeichen geschrieben worden ist. Das ist ähnlich wie bei einer Schreibmaschine:
Wenn wir eine Taste auf der Schreibmaschine drücken, wandert der Schreibkopf der Schreibmaschine automatisch eine Stelle weiter. Auf einer Schreibmaschine gibt es eine Rückschritttaste,
mit der wir wieder zurückgehen können, die gibt es hier nicht. Das heißt, wir kommen auch hier nicht wieder zurück: Ein einmal in die Ausgabe geschriebener Wert bleibt uns
auf ewig erhalten und wir können ihn nicht nachträglich überschreiben. Insofern unterscheidet sich das ein bisschen von einem Computermonitor, auf dem man an beliebige Stellen etwas schreiben
kann. Auf die Register haben wir wie gesagt einen sogenannten wahlfreien Zugriff – so übersetzt man den Begriff Random Access ins Deutsche.
Wahlfreier Zugriff bedeutet, dass wir die Register nicht in einer bestimmten Reihenfolge anspringen müssen, sondern sie beliebig adressieren können – also gerade das genaue Gegenteil
von dem, was bei Eingabe- und Ausgabeband möglich ist. Wir können jederzeit auf ein beliebiges Register zugreifen. Wir können zum Beispiel sagen, wir möchten etwas im
Register 0 speichern oder im Register 1 oder im Register 17 oder 42 oder wohin auch immer wir etwas speichern möchten. Das ist jederzeit möglich. Und wir können diese Register auch
wieder auslesen, also einen Wert von einem Register lesen, um dann irgendetwas damit zu machen – was wir alles machen können, werden wir uns noch angucken. Es gibt ein
besonderes Register, das ist das Register 0, der so genannte Akkumulator. Der verfügt über bestimmte besondere Funktionen. Nur in ihm können wir bestimmte Operationen durchführen,
deshalb dient er als eine Art Arbeitsregister für uns. Die anderen Register dienen ausschließlich dazu, dass wir Werte in ihnen speichern können. Im Akkumulator hingegen können wir bestimmte
Rechenoperationen und Vergleiche durchführen – die werden wir alle gleich noch kennenlernen. Damit haben wir jetzt die Grundbausteine dieser Maschine zusammen und werden uns gleich einmal
anschauen, was wir mit dieser Maschine nun anfangen können. Wir werden uns nämlich angucken, welche Befehle sie besitzt und wie diese Maschine diese Befehle dann abarbeitet.
Ganz kurz möchte ich noch einmal den Bezug zum Thema Algorithmen herstellen, das wir in einem der letzten Videos behandelt hatten. Wir haben hier eine Maschine, die im Grunde
genommen jeden beliebigen Algorithmus, den man formulieren kann, abarbeiten kann. Hier sind die Kriterien erfüllt, dass wir mit einem Programm, das wir für die Registermaschine
schreiben, das abgearbeitet werden kann und das auch irgendwann endet – und das ist wichtig: die Ausführung des Programms muss irgendwann auch beendet werden –, auch tatsächlich
einen Algorithmus für diese Maschine geschrieben haben. Unser Programm wird ausschließlich aus elementaren Anweisungen für das ausführende Organ bestehen
– also die endliche Kontrolleinheit oder die Registermaschine als Ganzes. Die Formulierung unseres Programms ist präzise und eindeutig, weil wir nur diese zwölf Befehle, die wir
gleich kennenlernen werden, zur Verfügung haben – sonst nichts. Und da ist klar definiert, was jeder einzelne dieser Befehle macht. Außerdem ist in jedem Schritt festgelegt, was als nächstes
zu geschehen hat und es gibt keine Wahlmöglichkeiten bei der Ausführung. Die Formulierung unseres Programms ist endlich, denn wir schreiben nur endlich viele Programmschritte auf – das
ist das Programm, das wir links stehen haben. Wir müssen natürlich dafür sorgen, dass die Maschine mit unserem Programm zu einem Ergebnis kommt – dann ist die Ausführung
auch nach endlich vielen Schritten abgeschlossen. Und unsere Programme sollen natürlich nicht nur eine einzige spezifische Berechnung durchführen – wenn wir zum Beispiel Zahlen addieren
wollen, nicht nur zwei Zahlen 3 und 7, sondern eben beliebige Zahlen addieren. Wenn wir das getan haben, haben wir einen Algorithmus für diese Maschine geschrieben. Vom Prinzip her
lässt sich jedes algorithmisch lösbare Problem durch ein Programm für die Registermaschine lösen – und umgekehrt kann man sagen, dass die Registermaschine eine symbolische Maschine
in dem Sinn ist, wie Sybille Krämer das formuliert hat – oder anders gesagt ein universeller Computer ist. Dass müsste man jetzt noch genauer nachweisen, aber den formalen Beweis
werden wir hier natürlich nicht führen. Schauen wir uns jetzt die Maschine einmal an und sehen uns die ersten vier Befehle dieses kleinen Programms an, das wir hier links stehen
haben. Die ersten, die wir hier sehen, sind die sogenannten Transportbefehle. Diese dienen dazu, dass wir Werte aus der Eingabe lesen und in die Register hinein transportieren
können, dass wir Werte aus den Registern auch in die Ausgabe transportieren können und dass wir Werte zwischen Registern hin und her schieben können. Das ist der Sinn
dieser Transportbefehle. Schauen wir uns das jetzt einmal ganz kurz an der Maschine an. Dafür gehe ich jetzt hinüber an meine Registermaschine und da probieren wir einmal aus, was diese
Transportbefehle, also die in den Programmzeilen 0 bis 3 machen, bevor wir uns dann den weiteren Befehlen zuwenden. Wir haben jetzt unsere Registermaschine mit
hier auf der linken Seite dem Programm, mit dem Instruktionszähler, mit dem Eingabeband, mit dem Lesekopf, dem Ausgabeband, mit dem Schreibkopf und hier auf der rechten Seite
den Registern. Das Programm läuft also nun los und führt den ersten Befehl aus. READ 0, das besagt also, dass etwas gelesen werden soll, gelesen werden – READ heißt immer
aus der Eingabe. Wir lesen also den Wert in der aktuellen Zelle, wo der Lesekopf gerade hinzeigt, den Wert 1 lesen wir also jetzt an dieser Stelle, der Lesekopf wandert einen
weiter, und diesen Wert 1, was machen wir mit dem? Wir speichern ihn im angegebenen Register, also im Register 0, also dem Akkumulator. Das heißt, hier landet also jetzt die 1.
Dann wird der zweite Befehl ausgeführt. Der besagt READ 1. Das heißt, wir gucken wieder, wo steht der Lesekopf? An dieser Position. Da steht eine 2, die merken wir uns. Der Lesekopf
wandert einen weiter. Der Wert 2 wird nun wo gespeichert? Im Register 1. Das heißt, hier haben wir also jetzt eine 2 stehen, den Wert, den wir gerade gelesen haben.
Nun kommt das Gegenstück zum READ-Befehl, dass ist der WRITE-Befehl. Der WRITE-Befehl bezieht sich auf das Ausgabeband, das heißt, an die Stelle, wo sich der Schreibkopf gerade
befindet, wird nun ein Wert geschrieben. Und zwar welcher Wert? WRITE 1 besagt, dass der Wert, der im Register 1 steht, geschrieben werden soll, also die Zahl 2 würde hier entsprechend
ausgegeben werden. Der Schreibkopf wandert einen weiter und damit ist auch dieser Befehl erledigt. Es kommt der nächste Befehl. Der LOAD-Befehl
und der STORE-Befehl beziehen sich immer darauf den Transport zwischen verschiedenen Registern. READ und WRITE beziehen sich auf Eingabe und Ausgabe, LOAD und STORE beziehen sich auf
den Transport zwischen Registern. LOAD 1 besagt nun also, dass der Wert aus dem Register 1 geladen werden soll, und zwar wohin? Nun, immer in den Akkumulator. LOAD bezieht sich
immer auf den Akkumulator. Das heißt, der Wert aus Register 1 wird nun also in den Akkumulator geschrieben. Hier steht also jetzt eine 2. Die in Register 1 bleibt stehen, die wird
dort nicht gelöscht, der Wert wird also hinüberkopiert. Und damit haben wir schon die wichtigsten dieser Transportbefehle kennengelernt, den STORE-Befehl kriegen wir gleich.
Damit haben wir die Transportbefehle jetzt soweit abgearbeitet, werden aber gleich noch ein paar Feinheiten dazu kennenlernen. Wir wenden uns dann als Nächstes den arithmetischen
Befehlen zu. Arithmetische Befehle sind einfach Rechenbefehle. Diese beziehen sich immer auf den Akkumulator, also das Register 0. Ich hatte schon gesagt, dass dieses ein besonderes
Register ist – hier zeigt sich das noch einmal. Wir haben vier Rechenarten, die wir ausführen können: Wir können addieren, subtrahieren, multiplizieren und dividieren.
Der erste Operand ist immer der Wert, der im Akkumulator steht, der zweite Operand ist immer der Wert, der hinter dem Befehl angegeben ist. Auch das werden wir uns jetzt an diesem
kleinen Programmbeispiel angucken, indem ich wieder zur Registermaschine hinüber gehe und die nächsten Befehle ausführe. Unser nächster Befehl in Zeile 4 besagt nun
ADD 1. Das bedeutet, wir sollen den Wert aus Register 1 nehmen und ihn addieren. Wozu? Nun, zu dem Wert, der im Akkumulator steht, das heißt, der Wert 2 wird zum Wert 2 hinzuaddiert
– in Register 1 verändert sich nichts, der bleibt stehen – aber der Wert im Akkumulator wird wieder überschrieben und jetzt eben durch den alten Wert 2 plus den neuen Wert,
der dazu addiert werden soll – 2 – also insgesamt 4 ersetzt werden, so dass wir also hier nun die Zahl 4 im Register 0 stehen haben, im Akkumulator stehen haben.
Dieser Wert soll jetzt, und da bekommen wir den nächsten Befehl, den wir uns noch nicht angeguckt hatten, in Zeile 5 gespeichert werden im Register 2 – das ist jetzt der STORE-Befehl.
Das heißt, mit STORE nehmen wir den Wert her, der im Akkumulator steht und speichern ihn in Register 2, das heißt, hier steht jetzt eine 4.
Und nun kommt wieder ein Lade-Befehl. Und der besagt, dass wir den Wert aus Register 2 erneut in den Akkumulator laden sollen. Da steht schon der Wert 4, das weiß unser
Programm aber sozusagen nicht – der Befehl ist in diesem Sinne also gerade im Grunde genommen an dieser Stelle überflüssig – so erscheint er zumindest, weil der Wert 4 erneut
hier hineingeschrieben wird. Das heißt, also im Grunde genommen wird hier die 4 einmal ausgelöscht und durch eine frische 4 sozusagen ersetzt. Das ist das, was der Befehl LOAD
2 an dieser Stelle macht. Da haben wir noch einmal zwei Transportbefehle gesehen. Jetzt kommt wieder ein arithmetischer Befehl. Da steht nun SUB =1. Und das ist ein
ganz feiner, aber wichtiger Unterschied. SUB 1 würde ja besagen, dass wir von dem Wert im Akkumulator den Wert aus Register 1 abziehen sollen – also 4 minus 2 rechnen sollten.
SUB =1 besagt aber, wir sollen nicht den Wert im Register 1 abziehen, sondern wir sollen tatsächlich den Wert 1 abziehen, also die Zahl eins her nehmen – =1 sagt also, nimm
mich wörtlich – die Zahl 1 soll also abgezogen werden. SUB =1 heißt also von der 4, von dem Wert, der aktuell im Akkumulator steht – das SUB bezieht sich ja immer auf den
Akkumulator – soll einer abgezogen werden. Das heißt, 4 minus 1 ergibt 3, so steht also jetzt hier der Wert 3 im Akkumulator. Und in Zeile 8 lautet der Befehl nun STORE
2, das heißt der Wert wird aus dem Akkumulator hergenommen und in Register 2 gespeichert und dann kommen wir zum nächsten Befehl und der heißt JGTZ 6 und den verstehen wir noch
nicht. Den gucken wir uns jetzt als nächstes an. Damit sind jetzt auch die Rechenbefehle, die arithmetischen Befehle, kein Geheimnis mehr
für uns und wir kommen zur letzten Kategorie von Befehlen. Das sind die sogenannten Sprungbefehle, mit denen wir eine Ablaufsteuerung erreichen können. Wir haben ja schon gesehen, dass
das Programm normalerweise Schritt für Schritt nacheinander ausgeführt wird: Zeile 0, Zeile 1, Zeile 2 und so weiter – außer eben, es kommt ein solcher Sprungbefehl.
Von diesen gibt es drei verschiedene und dazu noch einen HALT-Befehl. Was der HALT-Befehl macht, ist – so denke ich – relativ klar. Die anderen drei schauen wir uns einmal kurz
an. Der einfache Sprungbefehl – ein sogenannter unbedingter Sprung – heißt JUMP, und der springt immer. Sobald wir bei der Ausführung des Programms auf diesen Befehl stoßen, wird
ein Sprung ausgeführt – und zwar wohin? In die Programmzeile, die dahinter angegeben ist. JUMP 5 beispielsweise würde dafür sorgen, dass wir zur Programmzeile 5 springen und
dort mit der Ausführung weitermachen. Im Gegensatz dazu handelt es sich bei den beiden anderen Sprüngen um sogenannte bedingte Sprünge. Nur wenn eine bestimmte Bedingung
erfüllt ist, wird der Sprung ausgeführt, ansonsten wird einfach mit dem nächsten Befehl in der normalen Reihenfolge weitergemacht. Der eine dieser bedingten Sprünge heißt
Jump Zero. Dabei wird überprüft, ob der Wert, der im Akkumulator steht, gleich 0 ist. Hier sehen wir noch einmal die Sonderrolle des Akkumulators: Wir können nicht schauen,
ob in irgendeinem Register der Wert 0 steht, sondern nur, ob das im Akkumulator der Fall ist. Jump Zero sagt also, dass wir dann und nur dann, wenn der Wert, der aktuell im Akkumulator
gespeichert ist, gleich 0 ist, in die angegebene Programmzeile springen. Der dritte Sprung, den unsere Maschine beherrscht, heißt JGTZ – und das steht kurz für Jump
Greater Than Zero. Er besagt, wir springen genau dann, wenn der Wert, der gerade im Akkumulator steht, größer als 0 ist. Kleiner als 0 können wir nicht abfragen, wir können nur gleich
0 abfragen mit Jump Zero und größer als 0 mit Jump Greater Than Zero. Für alles andere müssen wir uns Tricks ausdenken, wie wir das hinbekommen.
Mit der Kenntnis der Sprungbefehle können wir also jetzt das Programm zu Ende spielen. Hier taucht nur Jump Greater Than Zero als einziger von den Sprungbefehlen auf, aber
die anderen funktionieren ähnlich, und wir werden die dann auch noch verstehen, wenn wir uns weitere Beispiele angucken. Jump Greater Than Zero 6 besagt also jetzt,
dass wir nachschauen sollen, welcher Wert im Akkumulator steht. Wenn dort ein Wert steht, der größer als 0 ist – Greater Than Zero –, und das ist der Fall: 3 ist größer
als 0, dann sollen wir zurück springen in Zeile 6 und nicht etwa mit der nächsten Zeile weitermachen. Das heißt, wir springen hier hin. Wir laden wieder den Wert aus dem Register
2, das ist die 3, die landet wieder im Akkumulator. Die steht schon da, macht nichts, wird hier also erneut eine 3 hineingeschrieben – ich spare mir das Weggewische und das Neuschreiben
jetzt an dieser Stelle. Dann wird anschließend wieder 1 abgezogen – nicht der Wert aus Register 1, sondern die Zahl 1 wird abgezogen. Das heißt, wir
haben jetzt hier eine 2 drin stehen und der Wert soll wieder in Register 2 gespeichert werden. Das heißt also, auch hier steht jetzt eine 2. Und es erfolgt wieder die Abfrage,
ob im Register 0 der Wert größer als 0 ist. Das ist der Fall, also springen wir wieder zurück in Zeile 6, laden wieder den Wert aus Register 2 und es passiert scheinbar wieder
nichts. Wir subtrahieren wieder 1. Und wir speichern den Wert aus dem Akkumulator wieder im Register 2. Wir überprüfen wieder, ob im Akkumulator
ein Wert größer als 0 steht. Das ist der Fall, also springen wir wieder in Zeile 6 zurück. Wir laden den Wert aus Register 2. Also kommt hier wieder eine frische 1 aus
Register 2 hinein. Wir subtrahieren wieder 1, dann haben wir hier jetzt 0 stehen. Dann wird der Wert aus dem Akkumulator in Register 2 gespeichert,
also steht auch hier jetzt eine 0 drin. Und es kommt wieder unsere Abfrage Jump Greater Than Zero. Wir müssen also gucken, steht im Akkumulator ein Wert, der größer als
0 ist. Das ist aber nicht der Fall, die Bedingung ist nicht erfüllt. Also machen wir nicht den Sprung in Zeile 6, sondern wir machen mit dem nächsten Befehl
dahinter weiter. Das ist genau das, was bei den bedingten Sprüngen passiert: Wenn die Bedingung nicht erfüllt ist, wird der Befehl dahinter als nächster ausgeführt. Das heißt,
wir sollen jetzt also den Wert aus Register 2 her nehmen und schreiben. Schreiben – wir erinnern uns – heißt, in das Ausgabeband schreiben. Der Kopf wandert einen weiter und
die nächste Anweisung wird ausgeführt. HALT – die Maschine hält an und unsere Programmausführung ist beendet. Nachdem wir das Programm also jetzt einmal
ausgeführt und damit die Grundfunktionalitäten dieser Maschine verstanden haben, schauen wir uns jetzt noch einmal die Werte und die Adressen an, mit denen wir es hier zu tun
haben. Wir hatten immer gesehen, das wir bei LOAD und WRITE, aber auch bei den Rechenbefehlen – den arithmetischen Befehlen – immer verschiedene Operanden angeben können. Die
eine Möglichkeit besteht darin, dass wir einfach eine Zahl dort angeben: LOAD 1 beispielsweise oder ADD 1. Das bezieht sich dann nicht auf die Zahl 1, sondern damit ist dann immer das
Register 1 gemeint. Wenn wir dagegen die Zahl 1 meinen, müssen wir das Gleichheitszeichen davor setzen. ADD =1 sagt also: Addiere den Wert 1 zu dem Wert im Akkumulator, also erhöhe
den Wert im Akkumulator um 1. ADD 1 hingegen sagt, addiere den Wert, der im Register 1 steht, zum Wert im Akkumulator. LOAD =0 ist damit eine Art Initialisierung: Wir belegen
damit ein Register vor, wir laden nämlich den Wert 0 in den Akkumulator und können ihn von da aus in einem anderen Register speichern. Damit könnten wir also zum Beispiel alle
unsere Register erst einmal mit dem Wert 0 füllen, wenn wir das denn wollen. Das kann mitunter sinnvoll sein, brauchen wir an dieser Stelle im Moment aber gerade nicht. Auch eine
Initialisierung mit 1 oder anderen Werten kann sinnvoll sein. Es gibt noch eine andere Art von Adressierung, nämlich die sogenannte indirekte Adressierung.
Die würde mit einem Sternchen markiert werden. STORE *1 würde bedeuten, dass nicht etwa der Wert aus dem Akkumulator im Register 1 gespeichert werden soll – das wäre ja STORE
1. STORE *1 besagt: Gucke nach, welcher Wert im Register 1 steht und nimm diesen Wert als Registernummer, wo du den Wert aus dem Akkumulator speichern sollst. Steht in Register 1 beispielsweise
eine 17, würde STORE *1 dafür sorgen, dass der aktuelle Wert aus dem Akkumulator im Register 17 gespeichert würde. Klingt kompliziert, ist ein bisschen komisch – aber keine Sorge:
Wir werden das in dieser Vorlesung nicht brauchen. Aber das ist tatsächlich ein sehr mächtiges Konstrukt, mit dem man sehr gut arbeiten kann, das sehr hilfreich ist und für bestimmte
Programme tatsächlich auch erforderlich ist, damit man sie mit der Registermaschine umsetzen kann. Das soll als erster kleiner Einblick in die
Registermaschine ausreichen. In den nächsten zwei Videos werden wir Programme für die Registermaschine entwerfen. Das eine wird ein Programm sein, mit dem wir Zahlen summieren
können, das andere ein Programm zur Berechnung von Potenzen. Tschüss bis zum nächsten Video.

Zum Nachlesen

RegistermaschineDie Registermaschine (RM) ist eine abstrakte Maschine der theoretischen Informatik. Registermaschinen sind Turing-vollständig, das heißt, … Mikroprogrammierte MinimalmaschineEin Maschinenbefehl hat die Länge eines Wortes. Je nach Befehl sind die ersten 4 Bit für die Befehlscodierung reserviert und die restlichen 20 Bit enthalten … Adressierung (Rechnerarchitektur)Adressierung ist in der Programmierung das Festlegen, auf welche Operanden (z. B. Datenfelder) sich ein Maschinenbefehl bezieht. Die Operanden können auf … Siemens 2002Der Siemens 2002 war ein Mitte der 1950er-Jahre von der Firma Siemens & Halske unter der Leitung des Informatikers Hans Kaufmann hergestellter Computer.