source: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushGPInterpreter.cs @ 14727

namespace HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter {
  using System;
  using System.Collections.Generic;
  using System.Runtime.CompilerServices;
  using System.Threading;
  using System.Threading.Tasks;
  using HeuristicLab.Core;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Parser;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Stack;
  using HeuristicLab.Random;

  public class PushGpInterpreter : IPushGpInterpreter {
    private Task currentTask;

    public PushGpInterpreter(IReadonlyPushGpConfiguration config = null, IRandom random = null) {
      Random = random ?? new FastRandom();

      Configuration = config ?? new PushGpConfiguration();

      // setting the capacity of the stacks to max points ensures that there will be enough memory at runtime
      ExecStack = new PushGPStack<Expression>(Configuration.EvalPushLimit);

      CodeStack = new PushGPStack<Expression>(Configuration.EvalPushLimit) {
        IsEnabled = config.IsCodeStackEnabled
      };

      NameStack = new PushGPStack<string> {
        IsEnabled = config.IsNameStackEnabled
      };
      BooleanStack = new PushGPStack<bool> {
        IsEnabled = config.IsBooleanStackEnabled
      };
      IntegerStack = new PushGPStack<long> {
        IsEnabled = config.IsIntegerStackEnabled
      };
      FloatStack = new PushGPStack<double> {
        IsEnabled = config.IsFloatStackEnabled
      };

      CustomExpressions = new Dictionary<string, Expression>();
    }

    public PushGpInterpreter(int seed, PushGpConfiguration config = null)
      : this(config, new FastRandom(seed)) {
    }

    public IRandom Random { get; set; }

    public int ExecCounter { get; private set; }

    public bool IsPaused { get; private set; }

    public bool IsAborted { get; private set; }

    public bool IsRunning
    {
      get
      {
        return !ExecStack.IsEmpty &&
               !IsPaused &&
               !IsAborted &&
               (ExecCounter < Configuration.EvalPushLimit);
      }
    }

    public bool IsCompleted
    {
      get
      {
        return ExecStack.Count == 0;
      }
    }

    public bool CanStep
    {
      get
      {
        return !IsCompleted && !IsAborted && IsPaused;
      }
    }

    public IReadonlyPushGpConfiguration Configuration { get; protected set; }

    public IStack<Expression> CodeStack { get; private set; }

    public IStack<Expression> ExecStack { get; private set; }

    public IStack<string> NameStack { get; private set; }

    public IStack<bool> BooleanStack { get; private set; }

    public IStack<long> IntegerStack { get; private set; }

    public IStack<double> FloatStack { get; private set; }

    public IDictionary<string, Expression> CustomExpressions { get; private set; }

    public bool IsNameQuoteFlagSet { get; set; }

    public void Run(string code, bool stepwise = false) {
      var program = PushGPParser.Parse(code);
      Run(program, stepwise);
    }

    public Task RunAsync(string code, bool stepwise = false, CancellationToken token = default(CancellationToken)) {
      var program = PushGPParser.Parse(code);

      currentTask = RunAsync(program, stepwise, token);

      return currentTask;
    }

    public async Task RunAsync(
      PushProgram program,
      bool stepwise = false,
      CancellationToken token = default(CancellationToken)) {
      var expression = new ExecExpandExpression(program);

      await RunAsync(expression, stepwise, token);
    }

    public async Task RunAsync(
      Expression program,
      bool stepwise = false,
      CancellationToken token = default(CancellationToken)) {
      await Task.Run(() => Run(program, stepwise), token);
    }

    public void Run(PushProgram program, bool stepwise = false) {
      var expression = new ExecExpandExpression(program);

      Run(expression, stepwise);
    }

    public void Run(Expression program, bool stepwise = false) {
      IsPaused = stepwise;

      /* Push top expression so the loop is able to enter
       * If the top expression is a single statement then the loop has nothing to do
       * Otherwise the expand expression will be evaluated and pushes code onto the EXEC stack */
      ExecStack.Push(program);

      if (Configuration.TopLevelPushCode) CodeStack.Insert(0, program);

      // run top expression
      DoStep();

      Interpret();
    }

    public async Task AbortAsync() {
      if (IsAborted || IsCompleted) return;

      IsAborted = true;

      if (currentTask != null) await currentTask;
    }

    public async Task AbortAndResetAsync() {
      await AbortAsync();
      Reset();
    }

    public async Task PauseAsync() {
      if (IsPaused || IsCompleted) return;

      IsPaused = true;

      if (currentTask != null) await currentTask;
    }

    public async Task ResumeAsync() {
      if (IsPaused || !IsAborted) {
        IsPaused = false;
        await InterpretAsync();
      } else await currentTask;
    }

    public void Resume() {
      if (!IsPaused && IsAborted)
        return;

      IsPaused = false;
      Interpret();
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void Step() {
      if (!CanStep) return;
      DoStep();
      Finally();
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void Step(int count) {
      for (var i = 0; i < count; i++) Step();
    }

    public void PrintStacks() {
      PrintStack("EXEC", ExecStack);
      PrintStack("CODE", CodeStack);
      PrintStack("NAME", NameStack);
      PrintStack("BOOLEAN", BooleanStack);
      PrintStack("FLOAT", FloatStack);
      PrintStack("INTEGER", IntegerStack);

      if (CustomExpressions.Count == 0) return;
      Console.WriteLine("--------- Custom Expressions ---------");
      foreach (var ce in CustomExpressions) {
        Console.WriteLine("{0}: {1}", ce.Key, ce.Value);
      }
    }

    /// <summary>
    /// Clears stacks and
    /// </summary>
    public void Reset() {
      IsAborted = false;
      IsPaused = false;
      currentTask = null;

      Clear();
    }

    /// <summary>
    /// Clears stacks
    /// </summary>
    public void Clear() {
      ExecCounter = 0;

      ExecStack.Clear();
      CodeStack.Clear();

      NameStack.Clear();
      BooleanStack.Clear();
      IntegerStack.Clear();
      FloatStack.Clear();

      CustomExpressions.Clear();
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private void Interpret() {
      while (IsRunning) {
        DoStep();
        ExecCounter++;
      }

      Finally();
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private void Finally() {
      if (!IsCompleted)
        return;

      if (Configuration.TopLevelPopCode && (CodeStack.Count > 0))
        CodeStack.Pop();
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private void DoStep() {
      ExecStack.Pop().Eval(this);
    }

    private Task InterpretAsync() {
      currentTask = Task.Run(() => Interpret());

      return currentTask;
    }

    private void PrintStack<T>(string name, IStack<T> stack) {
      if (stack.IsEmpty) return;
      Console.WriteLine("--------- {0} ---------\n{1}\n", name, stack);
    }
  }
}