4. ** Brainfuck Interpreter Contest ** [abgeschlossen]

** Brainfuck Interpreter Contest ** [abgeschlossen]

  • B

    Einen Brainfuck-Compiler fände ich persönlich ziemlich interessant als Übungsprojekt. Für einen Contest ist es vielleicht ein bisschen viel.

    hustbaer schrieb:

    Parsen, optimieren, IL-Code generieren, JITen, ausführen. Ich wüsste, bis auf Java, jetzt keine Sprache/Plattform, wo das so problemlos und ohne gefrickel geht wie in C#.

    Wenn ich das richtig sehe, geht das über System.Reflection.Emit. Kommt man da mit der MSDN aus oder gibt es irgendwas anderes nützliches, was man sich anlesen sollte?

    0
  • R

    Bashar schrieb:

    Einen Brainfuck-Compiler fände ich persönlich ziemlich interessant als Übungsprojekt. Für einen Contest ist es vielleicht ein bisschen viel.

    hustbaer schrieb:

    Parsen, optimieren, IL-Code generieren, JITen, ausführen. Ich wüsste, bis auf Java, jetzt keine Sprache/Plattform, wo das so problemlos und ohne gefrickel geht wie in C#.

    Wenn ich das richtig sehe, geht das über System.Reflection.Emit. Kommt man da mit der MSDN aus oder gibt es irgendwas anderes nützliches, was man sich anlesen sollte?

    Es gehen drei Wege um dynamischen Code zu generieren:

    • System.Reflection.Emit (IL-Code): Ist am schwierigsten, da eigene Sprache, aber man hat die meiste Kontrolle über die Sprache. (siehe Assembler-Begründungen)
    • System.Codedom: Kann man eigenen Code als String einer .Net Sprache wie VB.Net, JScript oder C# compilieren, oder (fast) sprachenunabhängig Code über den jeweiligen Compiler der generieren, (es wird noch eine Sprache gebraucht die aus dem DOM Quelltext erzeugt). Dies wird bei XML-Serialiserung und offensichtlich vom WinForms-Designer verwendet.
    • System.Linq.Expressions (ab .Net 3.5 eingeschrängt und ab 4.0 vollständig): Ähnlich wie System.Codedom nur leichtgewichtiger und ohne umwege über einen Compiler und kann direkt Delegates zurückliefern.

    IL ist wie gesagt eine "eigene" Sprache und mächtiger als C# (ref return & multi indices & properties other_method). Ich vermute mal, dass Assembler für das Verständnis hilft, wobei IL eben ausschließlich stackbasiert ist.

    Außerdem kann man auch vorhanden Code via Reflector Ildasm oder ILSpy anschauen und beim letzteren mit dem Originalen vergleichen.

    Edit:
    Fürs weiterlesen:
    Verwalteter Code hinter den Kulissen, Teil 1

    0
  • ?

    Wie wäre es mit einem Primzahltester in Malbolge als Contest? Laufzeit: 4 Jahre 😉

    Irgendwas in Richtung Mathe-Parser, Solver, was weiß ich wäre schon interessant. Jetzt heißt es eine kleine, knackige und gut optimierbare Aufgabe zu finden.

    Rhombicosidodecahedron schrieb:

    Sonst SAT-Solver möglichst kurz (vorher Eingabeformat festlegen).

    Erster Gedanke: Das ist doch eine geile Idee!

    Etwas weiter überlegen:
    SAT-Solver sind beliebig komplex. Es würde wohl auf Durchprobieren aller Belegungen hinauslaufen. Aber ok, ein naiver Brainfuck-Interpreter kostet auch keine Hirnzellen. Die Aufgabe bestünde wieder im Verkürzen von Code. Hmmm...

    0
  • ?

    Sobald die Aufgabe in Richtung Optimierung der Laufzeit geht, sollte es kein bekanntes Problem sein. Beispiel Primzahltester: Dann packe ich meine alten Skripte aus, implementiere den besten Algorithmus und fertig. Das ist nichts.

    Wie wäre es mit sehr einfachen Bots die in irgendeiner Form gegeneinander antreten?

    0
  • F

    µ schrieb:

    Wie wäre es mit sehr einfachen Bots die in irgendeiner Form gegeneinander antreten?

    Daran hätte ich auch Interesse.

    0
  • R

    So in der Art?
    http://en.wikipedia.org/wiki/Core_War

    0
  • ?

    Sowas wie Core-War, ja.

    Das würde Einarbeitung erfordern (ich kenne mich auch noch nicht damit aus), oder wir arbeiten ein eigenes kleines Bot-Framework aus. Es könnte ja sehr einfach anfangen und im Laufe der Zeit erweitert werden.

    0
  • V

    Optimalerweise kann so ein Contest ohne Ende sein. Es gibt halt eine laufend aktualisierte Rangliste. Und

    Core-War ist Core-War. Man proggert da in Redcode. Nicht in C#.

    Gut ist Colobot bzw Ceebot. Extrem gut. Aber das Framework zu basteln, würde wohl den Rahmen sprengen.

    Mein liebstes Game wäre wohl http://en.wikipedia.org/wiki/Classic_Empire_(video_game) , da hat mir immer gefehlt, daß man ein wenig Scripten kann.

    Sehr hübsch als Basis wäre auch http://www.windowsgames.co.uk/slay.html
    Derselbe Autor haut auch ein klassisches Empire raus http://www.windowsgames.co.uk/mother.html

    Spannend fände ich, das http://en.wikipedia.org/wiki/Prisoner's_dilemma aufzusetzen. Extrem einfaches Framework. Und ich würde gerne wissen, on Tit For Tat wirklich so gut ist. Mir scheint, die Forschung ist dahingehend eingeschlafen.

    0
  • 3

    Vielleicht irgend ein Kartenspiel?

    Edit: Achja, bitte mal irgendwas, wo ich auch ne Chance habe, da Programm mal hinzubekommen 😃

    0
  • Administrator

    Mathematische Probleme in eingeschränkter Zeit mit bestmöglichem Ergebnis zu lösen sind auch immer wieder nette Aufgaben. Zum Beispiel gab es doch letzten was bei Spieleprogrammierer.de, wo eine Karte bestmöglichst in Nord und Süd aufgeteilt werden musste.
    http://www.spieleprogrammierer.de/32-programmier-contests/16101-14-planetenteilung-spezial-14-08-2011/

    Hauptproblem bei Contests ist halt immer dasselbe. Irgendwer muss es organisieren und das kostet meistens Zeit. Und am Ende wird es oft nicht mal gebührend geschätzt 😉

    Grüssli

    0
  • B

    So, der nicht optimierende Compiler läuft (knabbert gerade an "Primes100 (indirect)". Die Implementierung ist wie erwartet trivial 😉

    0
  • ?

    Generierst Du IL-Code?

    Her mit dem Code.

    0

  • BTW: ich hatte zwar erst vorgeschlagen IL Code zu generieren, das ist aber eigentlich doof.
    Erstmal hat der C# Compiler vermutlich selbst nen ganz netten Optimizer, den man nicht verschwenden sollte, und zweitens ist die Fehlersuche sicher einfacher, wenn man C# Code generiert statt IL Code.
    Bzw. auch die Suche nach neuen Patterns die man dem eigenen Optimizer anlernen könnte wird dadurch vermutlich viel einfacher.

    0
  • B

    OK, hier der erste lauffähige Versuch. CompilingEvaluator nimmt die Rolle des Interpreters ein, d.h. starten mit new TestSession<Brainfuck.CompilingEvaluator>().Run(); . Das Interface S musste ich public machen. Ob es auch ohne geht, weiß ich nicht, dazu müsste man den Code ja in dasselbe Assembly generieren.

    using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Collections.Generic;

namespace Brainfuck
{
    class SimpleCompiler
    {
        private static void GenerateCode(string program, MethodBuilder mBuilder)
        {
            ILGenerator ilgen = mBuilder.GetILGenerator();

            // Note: the types can't be changed arbitrarily. The Load and Store instructions have to be adjusted as well.
            Type pointerType = typeof(uint);
            Type dataType = typeof(short), dataArrayType = typeof(short[]);
            int dataSize = 32768;

            // Declare and initialize data pointer
            LocalBuilder pointer = ilgen.DeclareLocal(pointerType, false);
            ilgen.Emit(OpCodes.Ldc_I4_0);
            ilgen.Emit(OpCodes.Stloc, pointer);

            // Declare and initialize data array
            LocalBuilder dataArray = ilgen.DeclareLocal(dataArrayType, false);
            ilgen.Emit(OpCodes.Ldc_I4, dataSize);
            ilgen.Emit(OpCodes.Newarr, dataType);
            ilgen.Emit(OpCodes.Stloc, dataArray);

            // Declare parameter
            ParameterBuilder systemParam = mBuilder.DefineParameter(1, ParameterAttributes.In, "s");

            // Manage labels:
            // [ creates two labels: one for the current instruction and one for the instruction after the loop
            // ] jumps to the corresponding top of stack and marks the other one
            Stack<Label> labelStack = new Stack<Label>();

            for (int i = 0; i < program.Length; ++i)
            {
                switch (program[i])
                {
                    case '<':
                        // Decrease data pointer
                        ilgen.Emit(OpCodes.Ldloc, pointer);
                        ilgen.Emit(OpCodes.Ldc_I4_1);
                        ilgen.Emit(OpCodes.Sub);
                        ilgen.Emit(OpCodes.Stloc, pointer);
                        break;

                    case '>':
                        // Increase data pointer
                        ilgen.Emit(OpCodes.Ldloc, pointer);
                        ilgen.Emit(OpCodes.Ldc_I4_1);
                        ilgen.Emit(OpCodes.Add);
                        ilgen.Emit(OpCodes.Stloc, pointer);
                        break;

                    case '+':
                        // Increase current data
                        // Prepare Store
                        ilgen.Emit(OpCodes.Ldloc, dataArray);
                        ilgen.Emit(OpCodes.Ldloc, pointer);

                        // Load current data
                        ilgen.Emit(OpCodes.Ldloc, dataArray);
                        ilgen.Emit(OpCodes.Ldloc, pointer);
                        ilgen.Emit(OpCodes.Ldelem_I2);

                        // Increase
                        ilgen.Emit(OpCodes.Ldc_I4_1);
                        ilgen.Emit(OpCodes.Add);

                        // Now the result is on top of the stack, store it
                        ilgen.Emit(OpCodes.Stelem_I2);
                        break;

                    case '-':
                        // Decrease current data
                        // Prepare Store
                        ilgen.Emit(OpCodes.Ldloc, dataArray);
                        ilgen.Emit(OpCodes.Ldloc, pointer);

                        // Load current data
                        ilgen.Emit(OpCodes.Ldloc, dataArray);
                        ilgen.Emit(OpCodes.Ldloc, pointer);
                        ilgen.Emit(OpCodes.Ldelem_I2);

                        // Increase
                        ilgen.Emit(OpCodes.Ldc_I4_1);
                        ilgen.Emit(OpCodes.Sub);

                        // Now the result is on top of the stack, store it
                        ilgen.Emit(OpCodes.Stelem_I2);
                        break;                

                    case '[':
                        {
                            // Enter loop if current data != 0, skip loop otherwise
                            Label thisInstruction = ilgen.DefineLabel();
                            Label followingInstruction = ilgen.DefineLabel();

                            // Push two labels:
                            // thisInstruction: label to which the corresponding ] has to jump
                            // followingInstruction: label of the instruction after the corresponding ]
                            // only thisInstruction will be marked here
                            labelStack.Push(thisInstruction);
                            labelStack.Push(followingInstruction);
                            ilgen.MarkLabel(thisInstruction);

                            // Load current data
                            ilgen.Emit(OpCodes.Ldloc, dataArray);
                            ilgen.Emit(OpCodes.Ldloc, pointer);
                            ilgen.Emit(OpCodes.Ldelem_I2);

                            // Compare with 0 and branch
                            ilgen.Emit(OpCodes.Ldc_I4_0);

                            ilgen.Emit(OpCodes.Beq, followingInstruction);
                        }
                        break;

                    case ']':
                        {
                            // Jump to the beginning of the loop
                            // (Alternative implementation: Exit loop if current data == 0, jump to the beginning otherwise)

                            // Pop two labels:
                            // nextInstruction is the instruction after the loop, marked here
                            // loopBegin is the label that was marked when translating the corresponding [
                            Label nextInstruction = labelStack.Pop();
                            Label loopBegin = labelStack.Pop();
                            ilgen.Emit(OpCodes.Br, loopBegin);
                            ilgen.MarkLabel(nextInstruction);
                        }
                        break;

                    case '.':
                        {
                            // Write current data: 
                            // Call s.W(dataArray[pointer])
                            MethodInfo writeMethod = typeof(S).GetMethod("W");
                            ilgen.Emit(OpCodes.Ldarg, 1);

                            // Load current data
                            ilgen.Emit(OpCodes.Ldloc, dataArray);
                            ilgen.Emit(OpCodes.Ldloc, pointer);
                            ilgen.Emit(OpCodes.Ldelem_I2);

                            // Call shell.W
                            ilgen.Emit(OpCodes.Call, writeMethod);
                        }
                        break;

                    case ',':
                        {
                            // Read into current data: 
                            // Call s.R() and assign the result to dataArray[pointer]
                            MethodInfo readMethod = typeof(S).GetMethod("R");

                            // Prepare Store
                            ilgen.Emit(OpCodes.Ldloc, dataArray);
                            ilgen.Emit(OpCodes.Ldloc, pointer);

                            // Call shell.R()
                            ilgen.Emit(OpCodes.Ldarg, 1);
                            ilgen.Emit(OpCodes.Call, readMethod);

                            // Assign result
                            ilgen.Emit(OpCodes.Stelem_I2);
                        }    
                        break;
                }
            }
            ilgen.Emit(OpCodes.Ret);
        }

        public static void CompileAndRun(S system)
        {
            AssemblyName asmName = new AssemblyName("Brainfuck");
            AssemblyBuilder asmBuilder = 
                System.Threading.Thread.GetDomain().DefineDynamicAssembly(asmName, AssemblyBuilderAccess.Run);
            ModuleBuilder modBuilder = asmBuilder.DefineDynamicModule("Brainfuck.exe");
            TypeBuilder typeBuilder = modBuilder.DefineType(
                "Brainfuck", 
                TypeAttributes.Public | TypeAttributes.Class);

            MethodBuilder runMethodBuilder = typeBuilder.DefineMethod(
                "Run",
                MethodAttributes.HideBySig | MethodAttributes.Public,
                typeof(void),
                new Type[] { typeof(S) });

            GenerateCode(system.P, runMethodBuilder);

            Type brainfuckTempType = typeBuilder.CreateType();
            MethodInfo runMethod = brainfuckTempType.GetMethod("Run");
            ConstructorInfo ctor = brainfuckTempType.GetConstructor(Type.EmptyTypes);

            Object compiledProgram = ctor.Invoke(new object[] {});
            runMethod.Invoke(compiledProgram, new object[] { system });
        }
    }

    class CompilingEvaluator
    {
        public void R(S s)
        {
            SimpleCompiler.CompileAndRun(s);
        }
    }
}

    hustbaer: Das sagst du jetzt! 😃 Ich hatte mir das erst auch ein bisschen anders vorgestellt, nicht daran gedacht, dass das ja eine Stackmaschine ist.

    0
Anmelden zum Antworten