source: branches/Async/HeuristicLab.DebugEngine/3.3/DebugEngine.cs @ 13349

Last change on this file since 13349 was 13349, checked in by jkarder, 4 years ago

#2258: added StartAsync to IExecutable

File size: 11.2 KB
RevLine 
[4747]1#region License Information
2/* HeuristicLab
[12012]3 * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
[4747]4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
[4871]23using System.Linq;
[4903]24using System.Threading;
[5193]25using System.Threading.Tasks;
[4743]26using HeuristicLab.Common;
27using HeuristicLab.Core;
28using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
29
30namespace HeuristicLab.DebugEngine {
31
32  [StorableClass]
33  [Item("Debug Engine", "Engine for debugging algorithms.")]
[4871]34  public class DebugEngine : Executable, IEngine {
[4743]35
[4903]36    #region Construction and Cloning
[4871]37
[4743]38    [StorableConstructor]
[4903]39    protected DebugEngine(bool deserializing)
40      : base(deserializing) {
[4946]41      InitializeTimer();
[4871]42    }
[4946]43
[4903]44    protected DebugEngine(DebugEngine original, Cloner cloner)
45      : base(original, cloner) {
[4871]46      if (original.ExecutionState == ExecutionState.Started) throw new InvalidOperationException(string.Format("Clone not allowed in execution state \"{0}\".", ExecutionState));
47      Log = cloner.Clone(original.Log);
48      ExecutionStack = cloner.Clone(original.ExecutionStack);
[4947]49      OperatorTrace = cloner.Clone(original.OperatorTrace);
[4946]50      InitializeTimer();
51      currentOperation = cloner.Clone(original.currentOperation);
[4871]52    }
[4743]53    public DebugEngine()
54      : base() {
[4871]55      Log = new Log();
56      ExecutionStack = new ExecutionStack();
[4993]57      OperatorTrace = new OperatorTrace();
[4946]58      InitializeTimer();
[4743]59    }
60
[4871]61    public override IDeepCloneable Clone(Cloner cloner) {
62      return new DebugEngine(this, cloner);
[4743]63    }
64
[4946]65    private void InitializeTimer() {
[5240]66      timer = new System.Timers.Timer(250);
[4946]67      timer.AutoReset = true;
68      timer.Elapsed += new System.Timers.ElapsedEventHandler(timer_Elapsed);
69    }
70
[4871]71    #endregion
[4743]72
[4871]73    #region Fields and Properties
74
75    [Storable]
[5001]76    public ILog Log { get; private set; }
[4871]77
78    [Storable]
[5001]79    public ExecutionStack ExecutionStack { get; private set; }
[4871]80
[4993]81    [Storable]
82    public OperatorTrace OperatorTrace { get; private set; }
83
[5193]84    private CancellationTokenSource cancellationTokenSource;
85    private bool stopPending;
[4871]86    private DateTime lastUpdateTime;
87    private System.Timers.Timer timer;
[4903]88
[4871]89    [Storable]
90    private IOperation currentOperation;
[5002]91    public IOperation CurrentOperation {
[4871]92      get { return currentOperation; }
93      private set {
[4946]94        if (value != currentOperation) {
95          currentOperation = value;
96          OnOperationChanged(value);
97        }
[4871]98      }
[4743]99    }
100
[4871]101    public virtual IAtomicOperation CurrentAtomicOperation {
102      get { return CurrentOperation as IAtomicOperation; }
103    }
104
105    public virtual IExecutionContext CurrentExecutionContext {
[4903]106      get { return CurrentOperation as IExecutionContext; }
[4871]107    }
108
[4947]109    public virtual bool CanContinue {
110      get { return CurrentOperation != null || ExecutionStack.Count > 0; }
111    }
112
113    public virtual bool IsAtBreakpoint {
114      get { return CurrentAtomicOperation != null && CurrentAtomicOperation.Operator != null && CurrentAtomicOperation.Operator.Breakpoint; }
115    }
116
[4871]117    #endregion
118
119    #region Events
120
121    public event EventHandler<OperationChangedEventArgs> CurrentOperationChanged;
122    protected virtual void OnOperationChanged(IOperation newOperation) {
123      EventHandler<OperationChangedEventArgs> handler = CurrentOperationChanged;
124      if (handler != null) {
125        handler(this, new OperationChangedEventArgs(newOperation));
126      }
127    }
128
129    #endregion
130
131    #region Std Methods
132    public sealed override void Prepare() {
133      base.Prepare();
134      ExecutionStack.Clear();
135      CurrentOperation = null;
[4996]136      OperatorTrace.Reset();
[4871]137      OnPrepared();
138    }
139    public void Prepare(IOperation initialOperation) {
140      base.Prepare();
141      ExecutionStack.Clear();
142      if (initialOperation != null)
143        ExecutionStack.Add(initialOperation);
144      CurrentOperation = null;
[4996]145      OperatorTrace.Reset();
[4871]146      OnPrepared();
147    }
148    protected override void OnPrepared() {
149      Log.LogMessage("Engine prepared");
150      base.OnPrepared();
151    }
152
[4909]153    public virtual void Step(bool skipStackOperations) {
[4871]154      OnStarted();
[5193]155      cancellationTokenSource = new CancellationTokenSource();
156      stopPending = false;
[9343]157      lastUpdateTime = DateTime.UtcNow;
[4871]158      timer.Start();
[5193]159      try {
160        ProcessNextOperation(true, cancellationTokenSource.Token);
161        while (skipStackOperations && !(CurrentOperation is IAtomicOperation) && CanContinue)
162          ProcessNextOperation(true, cancellationTokenSource.Token);
163      }
164      catch (Exception ex) {
165        OnExceptionOccurred(ex);
166      }
[4871]167      timer.Stop();
[9343]168      ExecutionTime += DateTime.UtcNow - lastUpdateTime;
[5193]169      cancellationTokenSource.Dispose();
170      cancellationTokenSource = null;
171      if (stopPending) ExecutionStack.Clear();
172      if (stopPending || !CanContinue) OnStopped();
173      else OnPaused();
[4871]174    }
175
[13349]176    public override async Task StartAsync(CancellationToken cancellationToken) {
177      await base.StartAsync(cancellationToken);
[5193]178      cancellationTokenSource = new CancellationTokenSource();
179      stopPending = false;
[13349]180      using (var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationTokenSource.Token, cancellationToken)) {
181        Task task = Task.Factory.StartNew(Run, cts.Token, cts.Token);
182        await task.ContinueWith(t => {
[5193]183          try {
[13349]184            t.Wait();
[5193]185          }
[13349]186          catch (AggregateException ex) {
187            try {
188              ex.Flatten().Handle(x => x is OperationCanceledException);
189            }
190            catch (AggregateException remaining) {
191              if (remaining.InnerExceptions.Count == 1) OnExceptionOccurred(remaining.InnerExceptions[0]);
192              else OnExceptionOccurred(remaining);
193            }
[5193]194          }
[13349]195          cancellationTokenSource.Dispose();
196          cancellationTokenSource = null;
[5193]197
[13349]198          if (stopPending) ExecutionStack.Clear();
199          if (stopPending || !CanContinue) OnStopped();
200          else OnPaused();
201        });
202      }
[4871]203    }
[4903]204
[4871]205    protected override void OnStarted() {
206      Log.LogMessage("Engine started");
207      base.OnStarted();
208    }
209
210    public override void Pause() {
211      base.Pause();
[5193]212      cancellationTokenSource.Cancel();
[4871]213    }
214
215    protected override void OnPaused() {
216      Log.LogMessage("Engine paused");
217      base.OnPaused();
218    }
219
220    public override void Stop() {
221      CurrentOperation = null;
222      base.Stop();
[5193]223      if (ExecutionState == ExecutionState.Paused) {
224        ExecutionStack.Clear();
225        OnStopped();
226      } else {
227        stopPending = true;
228        cancellationTokenSource.Cancel();
229      }
[4871]230    }
[4903]231
[4871]232    protected override void OnStopped() {
233      Log.LogMessage("Engine stopped");
234      base.OnStopped();
235    }
236
237    protected override void OnExceptionOccurred(Exception exception) {
238      Log.LogException(exception);
239      base.OnExceptionOccurred(exception);
240    }
241
242    private void Run(object state) {
[5193]243      CancellationToken cancellationToken = (CancellationToken)state;
244
[4871]245      OnStarted();
[9343]246      lastUpdateTime = DateTime.UtcNow;
[4871]247      timer.Start();
[5193]248      try {
249        if (!cancellationToken.IsCancellationRequested && CanContinue)
250          ProcessNextOperation(false, cancellationToken);
251        while (!cancellationToken.IsCancellationRequested && CanContinue && !IsAtBreakpoint)
252          ProcessNextOperation(false, cancellationToken);
253        cancellationToken.ThrowIfCancellationRequested();
254      }
255      finally {
256        timer.Stop();
[9343]257        ExecutionTime += DateTime.UtcNow - lastUpdateTime;
[4871]258
[5193]259        if (IsAtBreakpoint)
260          Log.LogMessage(string.Format("Breaking before: {0}", CurrentAtomicOperation.Operator.Name));
261      }
[4871]262    }
263
264    private void timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e) {
[5240]265      System.Timers.Timer timer = (System.Timers.Timer)sender;
266      timer.Enabled = false;
[9343]267      DateTime now = DateTime.UtcNow;
[4871]268      ExecutionTime += now - lastUpdateTime;
269      lastUpdateTime = now;
[5240]270      timer.Enabled = true;
[4871]271    }
272    #endregion
273
274    #region Methods
275
276
[4947]277
[4743]278    /// <summary>
279    /// Deals with the next operation, if it is an <see cref="AtomicOperation"/> it is executed,
280    /// if it is a <see cref="CompositeOperation"/> its single operations are pushed on the execution stack.
281    /// </summary>
282    /// <remarks>If an error occurs during the execution the operation is aborted and the operation
283    /// is pushed on the stack again.<br/>
284    /// If the execution was successful <see cref="EngineBase.OnOperationExecuted"/> is called.</remarks>
[5193]285    protected virtual void ProcessNextOperation(bool logOperations, CancellationToken cancellationToken) {
286      IAtomicOperation atomicOperation = CurrentOperation as IAtomicOperation;
287      OperationCollection operations = CurrentOperation as OperationCollection;
288      if (atomicOperation != null && operations != null)
289        throw new InvalidOperationException("Current operation is both atomic and an operation collection");
[4871]290
[5193]291      if (atomicOperation != null) {
292        if (logOperations)
293          Log.LogMessage(string.Format("Performing atomic operation {0}", Utils.Name(atomicOperation)));
294        PerformAtomicOperation(atomicOperation, cancellationToken);
295      } else if (operations != null) {
296        if (logOperations)
297          Log.LogMessage("Expanding operation collection");
298        ExecutionStack.AddRange(operations.Reverse());
299        CurrentOperation = null;
300      } else if (ExecutionStack.Count > 0) {
301        if (logOperations)
302          Log.LogMessage("Popping execution stack");
303        CurrentOperation = ExecutionStack.Last();
304        ExecutionStack.RemoveAt(ExecutionStack.Count - 1);
305      } else {
306        if (logOperations)
307          Log.LogMessage("Nothing to do");
[4743]308      }
[5193]309      OperatorTrace.Regenerate(CurrentAtomicOperation);
[4871]310    }
311
[5193]312    protected virtual void PerformAtomicOperation(IAtomicOperation operation, CancellationToken cancellationToken) {
[4743]313      if (operation != null) {
314        try {
[5193]315          IOperation successor = operation.Operator.Execute((IExecutionContext)operation, cancellationToken);
[4871]316          if (successor != null) {
[4996]317            OperatorTrace.RegisterParenthood(operation, successor);
[4871]318            ExecutionStack.Add(successor);
[4743]319          }
[4904]320          CurrentOperation = null;
[4743]321        }
[5193]322        catch (Exception ex) {
323          if (ex is OperationCanceledException) throw ex;
324          else throw new OperatorExecutionException(operation.Operator, ex);
325        }
[4743]326      }
327    }
328
[4871]329    #endregion
[4743]330  }
331}
Note: See TracBrowser for help on using the repository browser.