source: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreter.cs @ 15032

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


  public class PushInterpreter : IInternalPushInterpreter, IDisposable {
    private Task currentTask;
    private Expression currentProgram;

    public PushInterpreter(IReadOnlyPushConfiguration config = null, IRandom random = null, InterpreterPoolContainer poolContainer = null) {
      Random = random ?? new MersenneTwister();
      Configuration = config ?? new PushConfiguration();

      // setting the capacity of the Stacks to max points ensures that there will be enough memory at runtime
      ExecStack = new PushStack<Expression>(Configuration.MaxPointsInProgram);
      CodeStack = new PushStack<Expression>();
      NameStack = new PushStack<string>();
      BooleanStack = new PushStack<bool>();
      IntegerStack = new PushStack<long>();
      FloatStack = new PushStack<double>();
      CharStack = new PushStack<char>();
      StringStack = new PushStack<string>();
      IntegerVectorStack = new PushStack<IReadOnlyList<long>>();
      FloatVectorStack = new PushStack<IReadOnlyList<double>>();
      BooleanVectorStack = new PushStack<IReadOnlyList<bool>>();
      StringVectorStack = new PushStack<IReadOnlyList<string>>();
      PrintStack = new PushStack<string>();

      Stacks = new Dictionary<StackTypes, IPushStack> {
        { StackTypes.Exec, ExecStack },
        { StackTypes.Code, CodeStack },
        { StackTypes.Integer, IntegerStack },
        { StackTypes.Float, FloatStack },
        { StackTypes.Boolean, BooleanStack },
        { StackTypes.Char, CharStack },
        { StackTypes.String, StringStack },
        { StackTypes.Name, NameStack },
        { StackTypes.Print, PrintStack },
        { StackTypes.IntegerVector, IntegerVectorStack },
        { StackTypes.FloatVector, FloatVectorStack },
        { StackTypes.BooleanVector, BooleanVectorStack },
        { StackTypes.StringVector, StringVectorStack },
      };

      CustomExpressions = new Dictionary<string, Expression>();
      PoolContainer = poolContainer ?? new InterpreterPoolContainer();

      ConfigureStacks();
    }

    public PushInterpreter(int seed, IReadOnlyPushConfiguration config = null)
      : this(config, new FastRandom(seed)) {
    }

    public IReadOnlyDictionary<StackTypes, IPushStack> Stacks { get; private set; }

    public IRandom Random { get; set; }

    public long 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.IsEmpty || ExecCounter >= Configuration.EvalPushLimit;
      }
    }

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

    public InterpreterPoolContainer PoolContainer { get; private set; }

    public IReadOnlyPushConfiguration Configuration { get; protected set; }
    [PushStack(StackTypes.Code)]
    public IPushStack<Expression> CodeStack { get; private set; }
    [PushStack(StackTypes.Exec)]
    public IPushStack<Expression> ExecStack { get; private set; }
    [PushStack(StackTypes.Name)]
    public IPushStack<string> NameStack { get; private set; }
    [PushStack(StackTypes.Boolean)]
    public IPushStack<bool> BooleanStack { get; private set; }
    [PushStack(StackTypes.Integer)]
    public IPushStack<long> IntegerStack { get; private set; }
    [PushStack(StackTypes.Float)]
    public IPushStack<double> FloatStack { get; private set; }
    [PushStack(StackTypes.Char)]
    public IPushStack<char> CharStack { get; private set; }
    [PushStack(StackTypes.String)]
    public IPushStack<string> StringStack { get; private set; }
    [PushStack(StackTypes.IntegerVector)]
    public IPushStack<IReadOnlyList<long>> IntegerVectorStack { get; private set; }
    [PushStack(StackTypes.FloatVector)]
    public IPushStack<IReadOnlyList<double>> FloatVectorStack { get; private set; }
    [PushStack(StackTypes.BooleanVector)]
    public IPushStack<IReadOnlyList<bool>> BooleanVectorStack { get; private set; }
    [PushStack(StackTypes.StringVector)]
    public IPushStack<IReadOnlyList<string>> StringVectorStack { get; private set; }
    [PushStack(StackTypes.Print)]
    public IPushStack<string> PrintStack { get; private set; }

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

    public bool IsNameQuoteFlagSet { get; set; }

    public Task RunAsync(string code, CancellationToken token = default(CancellationToken)) {
      var program = PushParser.Parse(code);
      currentTask = RunAsync(program, token);
      return currentTask;
    }
    public async Task RunAsync(Expression expression, CancellationToken token = default(CancellationToken)) {
      await Task.Run(() => Run(expression), token);
    }

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

    public void Run(bool stepwise) {
      Run(PushProgram.Empty, stepwise);
    }

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

      /* Push top expression so the loop is able to enter
       * If the top expression is a single statement it gets evaluated in Run.
       * Otherwise the push program will be evaluated and the expressions of the program are pushed onto the EXEC stack.
       * Expanding the initial program is not counted in ExecCount */
      InitRun(expression);

      if (Configuration.TopLevelPushCode && CodeStack.IsEnabled)
        CodeStack.Push(expression);

      Run();
    }

    public bool CanRun(int count) {
      return ExecStack.Count >= count &&
             !IsPaused &&
             !IsAborted &&
             ExecCounter + count < Configuration.EvalPushLimit;
    }

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

      IsAborted = true;

      PoolContainer.DisposePools();

      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;
      Run();
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public bool Step() {
      if (!CanStep) return false;

      var successful = DoStep();

      if (IsCompleted)
        Finally();

      return successful;
    }

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

    /// <summary>
    /// Reset while interpreter
    /// </summary>
    public void Reset() {
      ExecCounter = 0;
      IsAborted = false;
      IsPaused = false;
      currentTask = null;
      currentProgram = null;

      Clear();
      ConfigureStacks();
    }

    private void ConfigureStacks() {
      foreach (var pair in this.Stacks) {
        pair.Value.IsEnabled = Configuration.IsStackEnabled(pair.Key);
      }

      // exec stack must always be enabled
      this.ExecStack.IsEnabled = true;
    }

    /// <summary>
    /// Clears Stacks and custom expressions
    /// </summary>
    public void Clear() {
      foreach (var stack in Stacks)
        stack.Value.Clear();

      CustomExpressions.Clear();
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private void Run() {
      // if no stack which is modifies the exec stack is enabled, unroll loop due to performance reasons
      if (!Configuration.IsStackEnabled(StackTypes.Exec)) {
        while (CanRun(10))
          DoTenSteps();
      }

      while (IsRunning)
        DoStep();

      if (IsCompleted)
        Finally();
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private void Finally() {
      if (Configuration.TopLevelPopCode && !CodeStack.IsEmpty && CodeStack.IsEnabled)
        CodeStack.Pop();

      PoolContainer.DisposePools();
    }

    private void InitRun(Expression expression) {
      ExecStack.Push(expression);

      if (!expression.IsProgram)
        return;

      DoStep();
      ExecCounter--;   // unpacking the initial program is not counted
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private bool DoStep() {
      ExecCounter++;
      return ExecStack.Pop().TryEval(this);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private void DoTenSteps() {
      ExecStack[0].TryEval(this);
      ExecStack[1].TryEval(this);
      ExecStack[2].TryEval(this);
      ExecStack[3].TryEval(this);
      ExecStack[4].TryEval(this);
      ExecStack[5].TryEval(this);
      ExecStack[6].TryEval(this);
      ExecStack[7].TryEval(this);
      ExecStack[8].TryEval(this);
      ExecStack[9].TryEval(this);

      ExecStack.Remove(10);
      ExecCounter += 10;
    }

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

      return currentTask;
    }

    public virtual void Dispose() {
      PoolContainer.DisposePools();
    }
  }
}