source: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP.Cli/Program.cs @ 14517

using System;
using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks;
using HeuristicLab.Algorithms.PushGP.Generators;
using HeuristicLab.Algorithms.PushGP.Interpreter;
using HeuristicLab.Algorithms.PushGP.Parser;

namespace HeuristicLab.Algorithms.PushGP.Cli {

  using HeuristicLab.Algorithms.PushGP.Data.Random;
  using HeuristicLab.Algorithms.PushGP.Expressions;
  using HeuristicLab.Algorithms.PushGP.Simplifier;

  class Program {
    static void Main(string[] args) {
      //SimpleTest();
      //Stepwise().Wait();
      //PerformanceTestInterpreter();
      //PerformanceParallelTestInterpreter();
      //PerformanceTestCodeGenerator();
      TestRobustness();
      //TestPool();
      //TestPoolPerformance();
      //TestSimplifier();

      Console.WriteLine("\nPress any key to continue...");
      Console.ReadKey();
    }

    static void SimpleTest() {
      var interpreter = new PushGpInterpreter();

      interpreter.Interpret("5 INTEGER.DUP INTEGER.+");

      interpreter.PrintStacks();
    }

    static async Task Stepwise() {
      var interpreter = new PushGpInterpreter();

      interpreter.InterpretAsync("( 0 2 CODE.QUOTE ( 1 INTEGER.+ 0 3 CODE.QUOTE ( 1 INTEGER.+ INTEGER.* ) CODE.DO*RANGE INTEGER.+ ) CODE.DO*RANGE )", true).Wait();

      while (!interpreter.IsCompleted) {
        Console.Clear();
        interpreter.PrintStacks();
        interpreter.Step();

        var input = Console.ReadKey();
        if (input.Key == ConsoleKey.Escape) {
          break;
        } else if (input.Key == ConsoleKey.Spacebar) {
          await interpreter.ResumeAsync();
        }
      }

      Console.Clear();
      interpreter.PrintStacks();
    }

    static void PerformanceTestInterpreter() {
      var program = PushGPParser.Parse("( 5 INTEGER.DUP INTEGER.+ )");

      var interpreter = new PushGpInterpreter();
      var sw = new Stopwatch();

      sw.Start();
      for (var i = 0; i < 60000000; i++) {
        interpreter.Interpret(program);
        interpreter.Clear();
      }
      sw.Stop();

      Console.WriteLine(sw.Elapsed);
    }

    static void PerformanceParallelTestInterpreter() {
      var program = PushGPParser.Parse("( 5 INTEGER.DUP INTEGER.+ )");
      //var program = new ExecExpandExpression(new Expression[]
      //{
      //  new IntegerPushExpression(5),
      //  new IntegerDuplicateExpression(),
      //  new IntegerAddExpression()
      //});

      var sw = new Stopwatch();
      var iterations = 100;
      var amount = 600000;
      var pool = new PushGpInterpreterPool(iterations);

      sw.Start();
      Parallel.For(0, iterations, i => {
        using (var interpreter = pool.GetInstance()) {

          for (var j = 0; j < amount; j++) {
            interpreter.Interpret(program);
            interpreter.Clear();
          }
        }
      });
      sw.Stop();

      Console.WriteLine(sw.Elapsed);
    }

    static void PerformanceTestCodeGenerator() {
      var sw = new Stopwatch();

      sw.Start();
      var expressions = CodeGenerator.RandomCode(3000000);
      sw.Stop();

      Console.WriteLine(string.Format("Generated {0} in {1}", expressions.Count(), sw.Elapsed));
    }

    static void TestRobustness() {
      var sw = new Stopwatch();
      var parallism = Environment.ProcessorCount;
      var maxProgramSizeLimit = 100;
      var partitionSize = 100000;
      RandomFactory.Seed = 1337;

      var execCounters = new int[parallism];
      var config = new Configuration { EvalPushLimit = 500 };
      var pool = new PushGpInterpreterPool(config);

      sw.Start();
      Parallel.For(0, parallism, i => {
        using (var interpreter = pool.GetInstance()) {
          for (var j = 0; j < partitionSize; j++) {
            var program = CodeGenerator.RandomProgram(maxProgramSizeLimit);

            interpreter.Interpret(program);

            execCounters[i] += interpreter.ExecCounter;
            interpreter.Clear();
          }
        }
      });
      sw.Stop();

      Console.WriteLine("ExecCount: {0}", execCounters.Sum());
      Console.WriteLine("Duration: {0}", sw.Elapsed);
    }

    static void TestPool() {
      var pool = new PushGpInterpreterPool();
      var normal = new PushGpInterpreter();
      int id;

      using (var interpreter = pool.GetInstance()) {
        interpreter.Interpret("( 1 2 INTEGER.+ )");

        id = interpreter.GetHashCode();
        if (id == normal.GetHashCode()) Console.WriteLine("equal 1");
      }

      using (var interpreter = pool.GetInstance())
      using (var interpreter2 = pool.GetInstance()) {
        interpreter.Interpret("( 1 2 INTEGER.+ )");
        if (id == interpreter.GetHashCode()) Console.WriteLine("equal 2");
        if (id == interpreter2.GetHashCode()) Console.WriteLine("equal 3");
      }
    }

    static void TestPoolPerformance() {
      var sw = new Stopwatch();
      var iterations = 100000000;

      sw.Start();
      for (var i = 0; i < iterations; i++) {
        var interpreter = new PushGpInterpreter();
        interpreter.Clear();
      }
      sw.Stop();

      Console.WriteLine(sw.Elapsed);

      var pool = new PushGpInterpreterPool();
      sw.Restart();
      for (var i = 0; i < iterations; i++) {
        using (var interpreter = pool.GetInstance()) {
          interpreter.Clear();
        }
      }
      sw.Stop();

      Console.WriteLine(sw.Elapsed);
    }

    static void TestSimplifier() {
      var interpreter = new PushGpInterpreter();
      var program = PushGPParser.Parse("( 5 INTEGER.DUP FLOAT.+ INTEGER.+ )") as ExecExpandExpression;
      var simplifier = new RandomSimplifier() { Trys = 10 };

      var simplerProgram = simplifier.Simplify(
        program,
        solution => {
          interpreter.Clear();
          interpreter.Interpret(solution);
          return interpreter.IntegerStack.Top == 10;
        });

      Console.WriteLine(simplerProgram);
    }
  }
}