Der ICFP ist ein jährlich stattfindender Programmierwettbewerb im Rahmen der International Conference on Functional Programming. Dieses Jahr hatten wir uns entschlossen am ICFP teilzunehmen. Die Aufgaben der letzten Jahre waren immer recht anspruchsvoll, wir waren sehr gespannt wie es dieses Jahr sein würde. Gerüchten zufolge sollte die etwas krumme Startzeit mit der Aufgabe zu tun haben … so war es dann auch 
Wir (Steffen, Kleiner und ich) trafen uns bei Steffen und warteten auf die Freigabe der Spezifikation.
Pünktlich um 20:00:16 ging es los bzw. ging es erstmal nicht los, denn der Webserver des Ausrichters war nicht mehr erreichbar … normal wenn knapp 300 Teams versuchen die Aufgabestellungen herunterzuladen. Das Problem war nach ein paar Minuten erledigt.
Nun ging es erstmal ans Lesen des 16 Seiten langen PDFs. Eine Kurzfassung:
- es galt eine VM zu programmieren, mit Grundbefehlen wie Addition, Subtraktion, Wurzel etc.
- auf dieser sollten herunterladbare Binardatein ladbar und ausführbar sein, ausführbar bedeutet alles geladenen Operationen nacheinander ausführen und Speicher verändern
- die VM sollte Art Input/Ouput Schnittstelle haben mit deren Hilfe ein Satellit auf seinem Weg um die Erde gesteuert werden sollte
- es gab insgesamt 5 Szenarien (erst 3, dann 4 und am Ende kam noch eine 5. Bonusaufgabe dazu), die unterschiedliche, jeweils immer “komplexere” Lösungen zum Thema “wie steuere ich einen Satelliten” erforderten
Die VM war detailiert beschrieben, es gab Daten und Befehle, das Binärformat musste geladen werden, die Befehle mussten ausgeführt werden usw.
Wir haben das Ganze mit Java umgesetzt.
Laut Specifikation muss die VM 32bit Operatoren und 64bit Daten halten, diese sind über einen 14bit Pointer adressiert, was eine maximale Anzahl von 16384 Einträgen ergibt. Es wird zwischen D-Operatoren (2 Paramtern) und S-Operatoren (1 Parameter) unterschieden:
Die Daten im “Orbit Executable Format” sind in 96 bit lange Frames aufgeteilt, bei gerade Frames (0, 2, 4, …) kommen erst die Daten (64 bit, double) und dann der Operationen (32 bit, int), bei ungerade Frames umgedreht:
Diese Frames werden durch den MemoryLoader in den Memory geladen. Dieser besteht aus zwei Listen (Operationen und Daten), einem Status-Bit, einem Output/Input Bereich:
Für die unterschiedlichen Operationen erzeugen wir während des Ladens konkrete Objekte die das Interfaces Instruction implementieren und entweder von DoubleInstruction oder SingleInstruction ableiten. Dadurch enthält unser Memory nach dem Laden bereits eine Liste von “ausführbaren” Objekten, die selbständig den Memory verändern können (eine Instruction kann aus dem Memory lesen bzw. in den Memory schreiben).
Gegen 1:00 konnten wir die Datei “bin1.obf” laden und ausführen. Als Ergebnis sahen wir allerdings nur “0.0.0″. Hmm 3 mal 0, das konnte nix sinnvolles sein … das Problem war nach einer weiteren halben Stunde gelöst …
Um 1:26 hatten wir das erste Szenario “Hohmann” am laufen. Mit 50000 Interationen konnten wir dann auch soviel Ausgabedaten erzeugen um in Openoffice mit einem XY-Diagramm eine KREIS zu sehen. WOW!!! Das war ein sinnvolles Ergebnis. Wir waren hell wach. Das war unser um die Erde kreisender Sputnik. Ziel war es nun via Input Steuerbefehle an den Sputnik zu senden um die einzelnen Szenarien zu erledigen.
Im ersten, dem Hohmann-Szenario, ging es nun darum einen Satelliten von seiner initialen Umlaufbahn auf eine höhere Umlaufbahn zu steuern. Die Mathematik war beschrieben und musste nur noch programmiert werden, Kleiner und Steffen machten sich an die Arbeit. Ich versuchte in der Zeit eine Visualisierung mit SWT zu programmieren. Pro Szenario gab es noch 4 unterschiedliche Konfigurationen die wir bewältigten mussten. Hier ist der Anfang und das Ende von Konfiguration 1002 zu sehen. Der Sputnik bewegt sicht von der inneren zur äusseren Umlaufbahn:
Die notwendigen Steuerbefehle galt es dann in einem weiteren Binärformat abzuspeichern und auf der ICFP-Homepage einzureichen. Die zu erreichende Punktezahl hing u.a. von der verbrauchten Zeit und dem verbrauchten Sprit des Sputniks ab. 6:15 hatten wir das erste Szenario geschafft!
Nun ging es ans zweit dem “Meet and Greet” Szenario. Dort galt es einen zweiten Satelliten anzufliegen. Die Mathematik war hier schon wesentlich schwieriger. Wir versuchten unser bestes. Aber irgendwie wollte es nicht so recht klappen. Wir waren knapp davor die Aufgabe zu lösen aber irgendwie fehlten immer ein paar huntert Meter zum Zielpunkt. Und da wir nun jeder über 24 Stunden nicht geschlafen hatten, beschlossen wir es erstmal sein zu lassen 
Immerhin hatten wir eine VM programmiert und einen Sputnik auf eine höhere Umlaufbauen gebracht. Zufrieden und müde trennten wir uns. Danke nochmal an Steffen für die Bereitstellung einer angenehmen Programmierumgebung 
Kleiner hat dann Sonntag noch rausgefunden, dass wir wirklich soooo knapp vor einer Lösung waren … leider hat uns die visualisierte Ausgabe getäuscht, dort waren alle Winkel umgedreht. Statt 150 Grad in die eine Richtung mussten wir in Wirklichkeit (360 – 150 = 210) in die andere Somit konnten wir dieses Jahr mit 8 gelösten Aufgaben glänzen was uns den 139. Platz einbrachte.
Das 3. Szenario “Eccentric Meet and Greet” war vergleichbar mit dem zweiten, nur hier befand sich der Ziel-Satellite nicht auf einer Kreisbahn sondern auf einer Eclipse um die Erde. Im 4. Szenaria “Operation Clear Skies” galt es 11 (!) Satelliten auf unterschiedlichen Umlaufbahnen anzufliegen. Der Mond war hier auch mit dabei Aber diese Szenarien werden wir wohl ausserhalb des Wettbewerbs hacken.
Vielleicht sind ja nächstes Jahr noch ein paar mehr dabei ?!
Hier noch ein paar Screenshots der anderen Szenarien:
