Core War – Krieg der Kerne

Hat der Kollege doch neulich seiner 12. Klass Core War 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ß, was Assembler ist, kann die Punkte 2 bis 4 überspringen.

1. Core War

Seit 30 Jahren gibt es das Spiel Core War. Dabei schreiben zwei Leute jeweils ein Programm in einer assemblerartigen Sprache. Zu jedem Programm gehört mehr oder weniger eine Endlosschleife, so dass das Programm immer weiter läuft und nie aufhört.
Die beiden Programme werden in denselben Arbeitsspeicher geladen. Danach wird jeweils abwechselnd eine Zeile vom einen, dann vom anderen Programm ausgeführt, und immer so weiter. Irgendwann überschreibt eines der Programme das andere, so dass jenes dann nicht mehr lauffähig ist – und damit hat das Programm, das übrig bleibt, gewonnen. Denn das Ziel ist, am Schluss das einzige Programm zu haben, das noch in lauffähigem Zustand ist. Daher auch der martialische Name Core War.

corewar_00

2. Prozessor und Assembler

In der 12. Klasse lernen Schüler, 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äuft – das Betriebssystem eingeschlossen – früher oder später in die eigene Programmiersprache des Prozessors übersetzt und dann von diesem ausgeführt.

Diese eigene Programmiersprache, oder jedenfalls die menschenfreundlich lesbare Version davon, heißt Assembler. So gut lesbar wie höhere Programmiersprachen ist Assembler allerdings bei weitem nicht, die Befehle sehen am Anfang ziemlich kryptisch aus. Trotzdem macht Schülern das Assembler-Programmieren meistens Spaß, da man dabei sehr kleinschrittig vorgeht und jeder Schritt klar ist und wenig Abstraktion erfordert – so dass eben selbst ein Prozessor ihn ausführen kann.

3. Der Arbeitsspeicher

Um das Spiel verstehen zu können, muss man allerdings erst den Arbeitsspeicher eines Computers verstehen. Der ist das Gedächtnis des Computers, und das wird immer dann gelöscht, wenn man den Rechner ausschaltet. (Beim Neustart müssen die Gedächtnisinhalte erst wieder von der Festplatte oder anderen Speichern geladen werden.) Man kann ihn sich vorstellen wie ein Tabellenkalkulationsdokument voller Zahlen:

corewar_01

Es gibt Zellen, die alle gleich groß sind und Platz jeweils für eine Zahl einer bestimmten Größe haben – sagen wir von 0 bis 255. (Für größere Zahlen muss man die Information dann auf mehrere Zellen verteilen.)
Ein 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ässt. Aber die Zellen werden eben nicht in der Form “A1” (für die Zelle links oben) und “J4” (für 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 Zellen im Arbeitsspeicher ausgeht. (Das wären etwas mehr als 4 Gigabyte. Wie groß der Arbeitsspeicher tatsächlich ist, also wie viele Zellen es gibt, hängt natürlich vom Rechner ab.)

Eigentlich – zumindest auf irgendeiner Ebene der Eigentlichheit – stehen die Zahlen dort im Binärsystem, also etwa “10111001”. Im Dezimalsystem entspricht das der Zahl “185”. Für uns spielt das keine große Rolle, aber das Beispiel oben sieht dann so aus:

corewar_02

4. Befehle und Daten

Bei den üblichen Rechnern liegen alle Informationen im gleichen Speicher, das Programm und die Daten. In einer Assemblersprache könnte es zum Beispiel eine Befehlszeile ADDIERE 45 15 geben – das soll heißen, addiere die Zahl 45 zur Zahl 15 und merke dir das Ergebnis im Kurzzeitgedächtnis. 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 auch eine ganz normale Zahl, da ja überhaupt nur Zahlen gespeichert werden können. Aber wenn der Prozessor angewiesen wird, diese Zelle als eine Zelle mit einem Befehl zu interpretieren, dann funktioniert die Zahl, die für ADDIERE steht, als Auftrag, dass er genau das mit den nächsten beiden Zahlen machen soll.

Viel mehr braucht man für Core War nicht zu wissen.

5. Der kleinste Core Warrior

Das kleinste funktionierende Core-War-Programm besteht nur aus einer Zeile:

MOV 0, 1

Wenn diese Zeile ausgeführt wird, heißt 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ächsten Zeile – das muss man nicht hinschreiben, das passiert automatisch, wenn man nichts anderes anweist. (Fußnote für die, die andere Assemblersprachen kennen: Ja, in Redcode stehen Befehle und Argumente in einer gemeinsamen Speicherzelle.)

Am Anfang sieht der Arbeitsspeicher so aus, als Nächstes wird der Befehl in Adresse 000 ausgeführt:

Adresse 000: MOV 0, 1
Adresse 001: (irgendwas)
Adresse 002: (irgendwas)

Danach sieht der Arbeitsspeicher so aus, als Nächstes wird der Befehl in Adresse 001 ausgeführt:

Adresse 000: MOV 0, 1
Adresse 001: MOV 0, 1
Adresse 002: (irgendwas)

Danach sieht der Arbeitsspeicher so aus, als Nächstes wird der Befehl in Adresse 002 ausgeführt:

Adresse 000: MOV 0, 1
Adresse 001: MOV 0, 1
Adresse 002: MOV 0, 1

Und so weiter. Das Programm läuft ewig, solange es nicht gestört wird.

6. Adressierungsarten und ein weiterer Kämpfer

An diesem Beispiel sieht man die unterschiedlichen Adressierungsarten, die es gibt:

Adresse 001: MOV  +3,  @+4
Adresse 002: ADD  #2,  +3
Adresse 003: JMP  -2
Adresse 004: DAT #1234
Adresse 005: DAT #10

Die erste Zeile sagt, dass die dritte Zeile (von der aktuellen aus gezählt, also Adresse 004) kopiert werden soll an die Adresse, die in der vierten Zeile steht (von der aktuellen aus gezählt, also in diesem Fall Adresse 005, wo #10 steht, also ist das Ziel der Kopieraktion die Adresse 010).
Die zweite Zeile sorgt dafür, dass die Zahl 2 zum Wert in der Adresse 3 Zeilen weiter addiert wird. Unter Adresse 005 steht danach also #12.
Die dritte Zeile sorgt dafür, dass der Befehlszähler danach nicht automatisch wie sonst auf die nächste 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ändert hat).

Den Unterschied zwischen +4, #4 und @+4 erkennt man vielleicht so:

  • JMP #4 heißt: Springe zu Adresse 4 – diese absolute Adressierung funktioniert in Redcode nicht. #4 bedeutet: Die Zahl 4 selbst, unmittelbar.
  • JMP +4 heißt: Springe zur Adresse 4 Zeilen weiter. Das heißt relative Adressierung (wird in Redcode auch “direkte Adressierung” genannt).
  • JMP @+4 heißt: Springe zu der Adresse (relativ betrachtet), die in der Adresse 4 Zeilen weiter steht. Das heißt indirekte Adressierung.

Diese Unterschiede gibt es auch bei richtigen Assemblersprachen.

7. Was ich sonst noch weiß

Nicht mehr viel. Aber man kann das ja mal Schülern zeigen. Richtig einsteigen wird man kaum, aber die Schüler sehen wenigstens, dass sie mit ihrem Assemblerwissen etwas anfangen können.
Hier ist die Wikipedia-Seite dazu, auf der auch ein Link zu einem ausführlichen deutschen Handbuch steht. Dort wird die Assemblersprache Redcode vorgestellt, in der Core-War-Programme geschrieben sind, es gibt außerdem Beispiele für verschiedene Angriffs- und Verteidigungstechniken.

5 Antworten auf „Core War – Krieg der Kerne“

  1. Danke für die Erinnerung an diese kleine Programm. Ich werde es mit meinen Schülern bestimmt auch einmal ausprobieren. Warum denkst du, dass du “nicht richtig einsteigen” wirst? Was stört dich?

  2. Ich glaube, das ist nur etwas für einige Schüler, die als Bonusaufgabe zu Hause Programme schreiben und dann – im Unterricht – gegeneinander antreten lassen können. Die meisten Schüler werden sich freuen, Asselmberbefehle wiederzuerkennen, aber der Ehrgeiz und die Geduld, sich in das System einzuarbeiten, fehlt wahrscheinlich. Und so richtig zum Lehrplan gehört es auch nicht. Wird sich zeigen beim Ausprobieren.

  3. Danke für die Formulierung “auf irgendeiner Ebene der Eigentlichheit stehen die Zahlen dort im Binärsystem”. Werde ich in meine Lehrermonologe mit aufnehmen.

  4. Die Eigentlichkeit bezog sich vermutlich auf den sehenswerten Vortrag von Jöran Muuß-Merholz
    http://media.ccc.de/browse/congress/2013/30C3_-_5467_-_de_-_saal_2_-_201312301245_-_warum_die_digitale_revolution_des_lernens_gescheitert_ist_-_joran_muuss-merholz.html

    Ich werde mal ein Projekt aus “Core Wars” machen und schauen, wie viele Schüler sich dafür interessieren. Für den Einstieg in die Assemblerprogrammierung ist es sicher eine dankbare und motivierende Umgebung.

  5. >Die Eigentlichkeit bezog sich vermutlich auf den sehenswerten Vortrag von Jöran Muuß-Merholz

    Kaum. Ich habs nicht so mit den Bildungsrevolutionären.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.