{"id":5970,"date":"2014-03-01T08:08:09","date_gmt":"2014-03-01T07:08:09","guid":{"rendered":"https:\/\/www.herr-rau.de\/wordpress\/?p=5970"},"modified":"2014-03-01T08:08:09","modified_gmt":"2014-03-01T07:08:09","slug":"core-war-krieg-der-kerne","status":"publish","type":"post","link":"https:\/\/www.herr-rau.de\/wordpress\/2014\/03\/core-war-krieg-der-kerne.htm","title":{"rendered":"Core War – Krieg der Kerne"},"content":{"rendered":"
(5 Kommentare.<\/a>)<\/small> <\/div>

Hat der Kollege doch neulich seiner 12. Klass Core War<\/em> vorgestellt. Gute Idee. Das hatte ich mir schon zu Studienzeiten mal angeschaut, aber dann doch zu wenig begriffen. Inzwischen geht es etwas besser. Wer eh wei\u00df, was Assembler ist, kann die Punkte 2 bis 4 \u00fcberspringen.<\/p>\n

1. Core War<\/strong><\/p>\n

Seit 30 Jahren gibt es das Spiel Core War. Dabei schreiben zwei Leute jeweils ein Programm in einer assemblerartigen Sprache. Zu jedem Programm geh\u00f6rt mehr oder weniger eine Endlosschleife, so dass das Programm immer weiter l\u00e4uft und nie aufh\u00f6rt.
\nDie beiden Programme werden in denselben Arbeitsspeicher geladen. Danach wird jeweils abwechselnd eine Zeile vom einen, dann vom anderen Programm ausgef\u00fchrt, und immer so weiter. Irgendwann \u00fcberschreibt eines der Programme das andere, so dass jenes dann nicht mehr lauff\u00e4hig ist – und damit hat das Programm, das \u00fcbrig bleibt, gewonnen. Denn das Ziel ist, am Schluss das einzige Programm zu haben, das noch in lauff\u00e4higem Zustand ist. Daher auch der martialische Name Core War.<\/p>\n

\"corewar_00\"<\/p>\n

2. Prozessor und Assembler<\/strong><\/p>\n

In der 12. Klasse lernen Sch\u00fcler, wie ein Prozessor funktioniert und mit dem Arbeitsspeicher des Computers zusammenarbeitet. Der Prozessor ist das Teil am Rechner, was rechnet und das Rechnen organisiert. Letztlich wird jedes Computerprogramm, das auf einem Rechner l\u00e4uft – das Betriebssystem eingeschlossen – fr\u00fcher oder sp\u00e4ter in die eigene Programmiersprache des Prozessors \u00fcbersetzt und dann von diesem ausgef\u00fchrt. <\/p>\n

Diese eigene Programmiersprache, oder jedenfalls die menschenfreundlich lesbare Version davon, hei\u00dft Assembler<\/em>. So gut lesbar wie h\u00f6here Programmiersprachen ist Assembler allerdings bei weitem nicht, die Befehle sehen am Anfang ziemlich kryptisch aus. Trotzdem macht Sch\u00fclern das Assembler-Programmieren meistens Spa\u00df, da man dabei sehr kleinschrittig vorgeht und jeder Schritt klar ist und wenig Abstraktion erfordert – so dass eben selbst ein Prozessor ihn ausf\u00fchren kann.<\/p>\n

3. Der Arbeitsspeicher<\/strong><\/p>\n

Um das Spiel verstehen zu k\u00f6nnen, muss man allerdings erst den Arbeitsspeicher eines Computers verstehen. Der ist das Ged\u00e4chtnis des Computers, und das wird immer dann gel\u00f6scht, wenn man den Rechner ausschaltet. (Beim Neustart m\u00fcssen die Ged\u00e4chtnisinhalte erst wieder von der Festplatte oder anderen Speichern geladen werden.) Man kann ihn sich vorstellen wie ein Tabellenkalkulationsdokument voller Zahlen:<\/p>\n

\"corewar_01\"<\/p>\n

Es gibt Zellen, die alle gleich gro\u00df sind und Platz jeweils f\u00fcr eine Zahl einer bestimmten Gr\u00f6\u00dfe haben – sagen wir von 0 bis 255. (F\u00fcr gr\u00f6\u00dfere Zahlen muss man die Information dann auf mehrere Zellen verteilen.)
\nEin Unterschied ist der, dass so ein Arbeitsspeicher nicht zweidimensional angeordnet ist wie Schiffeversenken oder eben Tabellenkalkulation, sondern eine lange Reihe von Zellen ist, alle hintereinander und alle durchnummeriert. Grafisch abgebildet wird er meist trotzdem in zweidimensionaler Form, weil er sich so einfach leichter darstellen l\u00e4sst. Aber die Zellen werden eben nicht in der Form „A1“ (f\u00fcr die Zelle links oben) und „J4“ (f\u00fcr eine Zelle weiter rechts und weiter unten) bezeichnet, sondern sie haben fortlaufende Nummern: Nummer 0 ist die erste Zelle, und Nummer 4294967295 ist die letzte Zelle, wenn man von 232<\/sup> Zellen im Arbeitsspeicher ausgeht. (Das w\u00e4ren etwas mehr als 4 Gigabyte. Wie gro\u00df der Arbeitsspeicher tats\u00e4chlich ist, also wie viele Zellen es gibt, h\u00e4ngt nat\u00fcrlich vom Rechner ab.)<\/p>\n

Eigentlich – zumindest auf irgendeiner Ebene der Eigentlichheit – stehen die Zahlen dort im Bin\u00e4rsystem, also etwa „10111001“. Im Dezimalsystem entspricht das der Zahl „185“. F\u00fcr uns spielt das keine gro\u00dfe Rolle, aber das Beispiel oben sieht dann so aus:<\/p>\n

\"corewar_02\"<\/p>\n

4. Befehle und Daten<\/strong><\/p>\n

Bei den \u00fcblichen Rechnern liegen alle Informationen im gleichen Speicher, das Programm und die Daten. In einer Assemblersprache k\u00f6nnte es zum Beispiel eine Befehlszeile ADDIERE 45 15 geben – das soll hei\u00dfen, addiere die Zahl 45 zur Zahl 15 und merke dir das Ergebnis im Kurzzeitged\u00e4chtnis. Diese Elemente, also der Befehle ADDIERE und die beiden Zahlen, liegen hintereinander im Arbeitsspeicher. ADDIERE sieht dort aus wie eine ganz normale Zahl, und ist<\/em> auch eine ganz normale Zahl, da ja \u00fcberhaupt nur Zahlen gespeichert werden k\u00f6nnen. Aber wenn der Prozessor angewiesen wird, diese Zelle als eine Zelle mit einem Befehl zu interpretieren, dann funktioniert die Zahl, die f\u00fcr ADDIERE steht, als Auftrag, dass er genau das mit den n\u00e4chsten beiden Zahlen machen soll. <\/p>\n

Viel mehr braucht man f\u00fcr Core War nicht zu wissen.<\/p>\n

5. Der kleinste Core Warrior<\/strong><\/p>\n

Das kleinste funktionierende Core-War-Programm besteht nur aus einer Zeile:<\/p>\n

MOV 0, 1<\/pre>\n
Wenn diese Zeile ausgef\u00fchrt wird, hei\u00dft das: Kopiere („move“) die Zeile, die von der aktuellen 0 entfernt ist, in die Zeile, die von der aktuellen 1 entfernt ist. Und mach weiter bei der n\u00e4chsten Zeile – das muss man nicht hinschreiben, das passiert automatisch, wenn man nichts anderes anweist. (Fu\u00dfnote f\u00fcr die, die andere Assemblersprachen kennen: Ja, in Redcode stehen Befehle und Argumente in einer gemeinsamen Speicherzelle.)<\/p>\n
Am Anfang sieht der Arbeitsspeicher so aus, als N\u00e4chstes wird der Befehl in Adresse 000 ausgef\u00fchrt:<\/p>\n
Adresse 000:<\/em> MOV 0, 1\r\nAdresse 001:<\/em> (irgendwas)\r\nAdresse 002:<\/em> (irgendwas)<\/pre>\n
Danach sieht der Arbeitsspeicher so aus, als N\u00e4chstes wird der Befehl in Adresse 001 ausgef\u00fchrt:<\/p>\n
Adresse 000:<\/em> MOV 0, 1\r\nAdresse 001:<\/em> MOV 0, 1\r\nAdresse 002:<\/em> (irgendwas)<\/pre>\n
Danach sieht der Arbeitsspeicher so aus, als N\u00e4chstes wird der Befehl in Adresse 002 ausgef\u00fchrt:<\/p>\n
Adresse 000:<\/em> MOV 0, 1\r\nAdresse 001:<\/em> MOV 0, 1\r\nAdresse 002:<\/em> MOV 0, 1<\/pre>\n
Und so weiter. Das Programm l\u00e4uft ewig, solange es nicht gest\u00f6rt wird.<\/p>\n
6. Adressierungsarten und ein weiterer K\u00e4mpfer<\/strong><\/p>\n
An diesem Beispiel sieht man die unterschiedlichen Adressierungsarten, die es gibt:<\/p>\n
Adresse 001:<\/em> MOV  +3,  @+4\r\nAdresse 002:<\/em> ADD  #2,  +3\r\nAdresse 003:<\/em> JMP  -2\r\nAdresse 004:<\/em> DAT #1234\r\nAdresse 005:<\/em> DAT #10<\/pre>\n
Die erste Zeile sagt, dass die dritte Zeile (von der aktuellen aus gez\u00e4hlt, also Adresse 004) kopiert werden soll an die Adresse, die in der vierten Zeile steht (von der aktuellen aus gez\u00e4hlt, also in diesem Fall Adresse 005, wo #10 steht, also ist das Ziel der Kopieraktion die Adresse 010).
\nDie zweite Zeile sorgt daf\u00fcr, dass die Zahl 2 zum Wert in der Adresse 3 Zeilen weiter addiert wird. Unter Adresse 005 steht danach also #12.
\nDie dritte Zeile sorgt daf\u00fcr, dass der Befehlsz\u00e4hler danach nicht automatisch wie sonst auf die n\u00e4chste Zeile zeigt, sondern auf die Zeile 2 Zeilen vor der aktuellen (in diesem Fall also Adresse 001, wo wir wieder von vorne beginnen, nur dass sich das in Adresse 005 stehende Kopierziel ge\u00e4ndert hat).<\/p>\n
Den Unterschied zwischen +4, #4 und @+4 erkennt man vielleicht so:<\/p>\n