Changeset 15065 for branches/Async/HeuristicLab.Optimization/3.3

Timestamp:

06/26/17 09:45:36 (7 years ago)

Author:

jkarder

Message:

#2258: refactored async methods

• synchronously called IExecutables are now executed in the caller's thread
• removed old synchronization code from unit tests

Location:

branches/Async/HeuristicLab.Optimization/3.3

Files:

• Algorithms/Algorithm.cs (modified) (1 diff)
• Algorithms/BasicAlgorithm.cs (modified) (2 diffs)
• Algorithms/EngineAlgorithm.cs (modified) (2 diffs)
• MetaOptimizers/BatchRun.cs (modified) (8 diffs)
• MetaOptimizers/Experiment.cs (modified) (8 diffs)
• MetaOptimizers/TimeLimitRun.cs (modified) (5 diffs)

branches/Async/HeuristicLab.Optimization/3.3/Algorithms/Algorithm.cs

@@ -204 +204 @@
       Prepare();
     }
-    public void Start() {
-      StartAsync().Wait();
-    }
-    public async Task StartAsync() {
-      await StartAsync(CancellationToken.None);
-    }
-    public virtual async Task StartAsync(CancellationToken cancellationToken) {
+    public virtual void Start() {
+      Start(CancellationToken.None);
+    }
+    public virtual void Start(CancellationToken cancellationToken) {
       if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused))
         throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState));
+    }
+    public virtual async Task StartAsync() { await StartAsync(CancellationToken.None); }
+    public virtual async Task StartAsync(CancellationToken cancellationToken) {
+      await Task.Factory.StartNew((ct) => Start((CancellationToken)ct), cancellationToken, cancellationToken);
     }
     public virtual void Pause() {

branches/Async/HeuristicLab.Optimization/3.3/Algorithms/BasicAlgorithm.cs

@@ -61 +61 @@
     }
 
-    public override async Task StartAsync(CancellationToken cancellationToken) {
-      await base.StartAsync(cancellationToken);
+    public override void Start() {
+      base.Start();
       CancellationTokenSource = new CancellationTokenSource();
 
       OnStarted();
-      using (var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationTokenSource.Token, cancellationToken)) {
-        Task task = Task.Factory.StartNew(Run, cts.Token, cts.Token);
-        await task.ContinueWith(t => {
+      Task task = Task.Factory.StartNew(Run, cancellationTokenSource.Token, cancellationTokenSource.Token);
+      task.ContinueWith(t => {
+        try {
+          t.Wait();
+        } catch (AggregateException ex) {
           try {
-            t.Wait();
+            ex.Flatten().Handle(x => x is OperationCanceledException);
+          } catch (AggregateException remaining) {
+            if (remaining.InnerExceptions.Count == 1) OnExceptionOccurred(remaining.InnerExceptions[0]);
+            else OnExceptionOccurred(remaining);
           }
-          catch (AggregateException ex) {
-            try {
-              ex.Flatten().Handle(x => x is OperationCanceledException);
-            }
-            catch (AggregateException remaining) {
-              if (remaining.InnerExceptions.Count == 1) OnExceptionOccurred(remaining.InnerExceptions[0]);
-              else OnExceptionOccurred(remaining);
-            }
-          }
-          CancellationTokenSource.Dispose();
-          CancellationTokenSource = null;
-          OnStopped();
-        });
-      }
+        }
+        CancellationTokenSource.Dispose();
+        CancellationTokenSource = null;
+        OnStopped();
+      });
     }
 
@@ -110 +106 @@
       try {
         Run(cancellationToken);
-      }
-      finally {
+      } finally {
         timer.Elapsed -= new System.Timers.ElapsedEventHandler(timer_Elapsed);
         timer.Stop();

branches/Async/HeuristicLab.Optimization/3.3/Algorithms/EngineAlgorithm.cs

@@ -22 +22 @@
 using System;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.PluginInfrastructure;
-using ExecutionContext = HeuristicLab.Core.ExecutionContext;
 
 namespace HeuristicLab.Optimization {
@@ -171 +168 @@
       }
     }
-    public override async Task StartAsync(CancellationToken cancellationToken) {
-      await base.StartAsync(cancellationToken);
-      if (engine != null) await engine.StartAsync(cancellationToken);
+    public override void Start(System.Threading.CancellationToken cancellationToken) {
+      base.Start(cancellationToken);
+      if (engine != null) engine.Start(cancellationToken);
     }
     public override void Pause() {

branches/Async/HeuristicLab.Optimization/3.3/MetaOptimizers/BatchRun.cs

@@ -41 +41 @@
   [StorableClass]
   public sealed class BatchRun : NamedItem, IOptimizer, IStorableContent {
-    private readonly ManualResetEvent signaler = new ManualResetEvent(true);
-    private CancellationToken cancellationToken;
-
     public string Filename { get; set; }
 
@@ -242 +239 @@
         batchRunAction = BatchRunAction.Prepare;
         // a race-condition may occur when the optimizer has changed the state by itself in the meantime
-        try { Optimizer.Prepare(clearRuns); }
-        catch (InvalidOperationException) { }
+        try { Optimizer.Prepare(clearRuns); } catch (InvalidOperationException) { }
       } else {
         ExecutionState = ExecutionState.Stopped;
@@ -249 +245 @@
     }
     public void Start() {
-      StartAsync().Wait();
-    }
-    public async Task StartAsync() {
-      await StartAsync(CancellationToken.None);
-    }
+      Start(CancellationToken.None);
+    }
+    public void Start(CancellationToken cancellationToken) {
+      if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused))
+        throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState));
+      if (Optimizer == null) return;
+      batchRunAction = BatchRunAction.Start;
+      if (Optimizer.ExecutionState == ExecutionState.Stopped) Optimizer.Prepare();
+      for (int i = repetitionsCounter; i < repetitions; i++) {
+        // a race-condition may occur when the optimizer has changed the state by itself in the meantime
+        try { Optimizer.Start(cancellationToken); } catch (InvalidOperationException) { }
+        if (ExecutionState == ExecutionState.Paused || ExecutionState == ExecutionState.Stopped) break;
+        Optimizer.Prepare();
+      }
+    }
+    public async Task StartAsync() { await StartAsync(CancellationToken.None); }
     public async Task StartAsync(CancellationToken cancellationToken) {
-      this.cancellationToken = cancellationToken;
-      signaler.Reset();
-      await Task.Run(async () => {
-        if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused))
-          throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState));
-        if (Optimizer == null) return;
-        batchRunAction = BatchRunAction.Start;
-        if (Optimizer.ExecutionState == ExecutionState.Stopped) Optimizer.Prepare();
-        // a race-condition may occur when the optimizer has changed the state by itself in the meantime
-        try { await Optimizer.StartAsync(cancellationToken); }
-        catch (InvalidOperationException) { }
-        signaler.WaitOne();
-      }, cancellationToken);
+      await Task.Factory.StartNew((ct) => Start((CancellationToken)ct), cancellationToken, cancellationToken);
     }
     public void Pause() {
@@ -276 +271 @@
       if (Optimizer.ExecutionState != ExecutionState.Started) return;
       // a race-condition may occur when the optimizer has changed the state by itself in the meantime
-      try { Optimizer.Pause(); }
-      catch (InvalidOperationException) { }
+      try { Optimizer.Pause(); } catch (InvalidOperationException) { }
     }
     public void Stop() {
@@ -289 +283 @@
       }
       // a race-condition may occur when the optimizer has changed the state by itself in the meantime
-      try { Optimizer.Stop(); }
-      catch (InvalidOperationException) { }
+      try { Optimizer.Stop(); } catch (InvalidOperationException) { }
     }
 
@@ -342 +335 @@
       batchRunAction = BatchRunAction.None;
       ExecutionState = ExecutionState.Paused;
-      signaler.Set();
       EventHandler handler = Paused;
       if (handler != null) handler(this, EventArgs.Empty);
@@ -350 +342 @@
       batchRunAction = BatchRunAction.None;
       ExecutionState = ExecutionState.Stopped;
-      signaler.Set();
       EventHandler handler = Stopped;
       if (handler != null) handler(this, EventArgs.Empty);
@@ -413 +404 @@
       else if (repetitionsCounter >= repetitions) OnStopped();
       else if (batchRunAction == BatchRunAction.Pause) OnPaused();
-      else if (batchRunAction == BatchRunAction.Start) {
-        Optimizer.Prepare();
-        Optimizer.StartAsync(cancellationToken);
-      } else if (executionState == ExecutionState.Started) {
+      else if (batchRunAction == BatchRunAction.Start) return;
+      else if (executionState == ExecutionState.Started) {
         // if the batch run hasn't been started but the inner optimizer was run then pause
         OnPaused();

branches/Async/HeuristicLab.Optimization/3.3/MetaOptimizers/Experiment.cs

@@ -39 +39 @@
   [StorableClass]
   public sealed class Experiment : NamedItem, IOptimizer, IStorableContent {
-    private readonly ManualResetEvent signaler = new ManualResetEvent(true);
-    private CancellationToken cancellationToken;
-
     public string Filename { get; set; }
 
@@ -185 +182 @@
       foreach (IOptimizer optimizer in Optimizers.Where(x => x.ExecutionState != ExecutionState.Started)) {
         // a race-condition may occur when the optimizer has changed the state by itself in the meantime
-        try { optimizer.Prepare(clearRuns); }
-        catch (InvalidOperationException) { }
+        try { optimizer.Prepare(clearRuns); } catch (InvalidOperationException) { }
       }
     }
     public void Start() {
-      StartAsync().Wait();
-    }
-    public async Task StartAsync() {
-      await StartAsync(CancellationToken.None);
-    }
+      Start(CancellationToken.None);
+    }
+    public void Start(CancellationToken cancellationToken) {
+      if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused))
+        throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState));
+      if (Optimizers.Count == 0) return;
+
+      experimentStarted = true;
+      experimentStopped = false;
+      IOptimizer optimizer;
+      while ((optimizer = Optimizers.FirstOrDefault(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused))) != null) {
+        // a race-condition may occur when the optimizer has changed the state by itself in the meantime
+        try { optimizer.Start(cancellationToken); } catch (InvalidOperationException) { }
+        if (ExecutionState == ExecutionState.Paused || ExecutionState == ExecutionState.Stopped) break;
+      }
+    }
+    public async Task StartAsync() { await StartAsync(CancellationToken.None); }
     public async Task StartAsync(CancellationToken cancellationToken) {
-      this.cancellationToken = cancellationToken;
-      signaler.Reset();
-      await Task.Run(async () => {
-        if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused))
-          throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState));
-        if (Optimizers.Count == 0) return;
-
-        experimentStarted = true;
-        experimentStopped = false;
-        IOptimizer optimizer = Optimizers.FirstOrDefault(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused));
-        if (optimizer != null) {
-          // a race-condition may occur when the optimizer has changed the state by itself in the meantime
-          try { await optimizer.StartAsync(cancellationToken); }
-          catch (InvalidOperationException) { }
-        }
-        signaler.WaitOne();
-      }, cancellationToken);
+      await Task.Factory.StartNew((ct) => Start((CancellationToken)ct), cancellationToken, cancellationToken);
     }
     public void Pause() {
@@ -223 +215 @@
       foreach (IOptimizer optimizer in Optimizers.Where(x => x.ExecutionState == ExecutionState.Started)) {
         // a race-condition may occur when the optimizer has changed the state by itself in the meantime
-        try { optimizer.Pause(); }
-        catch (InvalidOperationException) { }
+        try { optimizer.Pause(); } catch (InvalidOperationException) { }
       }
     }
@@ -237 +228 @@
         foreach (var optimizer in Optimizers.Where(x => (x.ExecutionState == ExecutionState.Started) || (x.ExecutionState == ExecutionState.Paused))) {
           // a race-condition may occur when the optimizer has changed the state by itself in the meantime
-          try { optimizer.Stop(); }
-          catch (InvalidOperationException) { }
+          try { optimizer.Stop(); } catch (InvalidOperationException) { }
         }
       } else {
@@ -276 +266 @@
     private void OnPaused() {
       ExecutionState = ExecutionState.Paused;
-      signaler.Set();
       EventHandler handler = Paused;
       if (handler != null) handler(this, EventArgs.Empty);
@@ -283 +272 @@
     private void OnStopped() {
       ExecutionState = ExecutionState.Stopped;
-      signaler.Set();
       EventHandler handler = Stopped;
       if (handler != null) handler(this, EventArgs.Empty);
@@ -374 +362 @@
       try {
         ExecutionTime = Optimizers.Aggregate(TimeSpan.Zero, (t, o) => t + o.ExecutionTime);
-      }
-      finally {
+      } finally {
         Monitor.Exit(locker);
       }
@@ -396 +383 @@
           if (Optimizers.All(x => (x.ExecutionState == ExecutionState.Stopped) || (x.ExecutionState == ExecutionState.Prepared))) OnStopped();
         } else {
-          if (experimentStarted && Optimizers.Any(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused))) {
-            Optimizers.First(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused)).StartAsync(cancellationToken);
-          } else if (Optimizers.All(x => x.ExecutionState == ExecutionState.Stopped)) OnStopped();
+          if (experimentStarted && Optimizers.Any(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused))) return;
+          else if (Optimizers.All(x => x.ExecutionState == ExecutionState.Stopped)) OnStopped();
           else if (Optimizers.Any(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused)) && Optimizers.All(o => o.ExecutionState != ExecutionState.Started)) OnPaused();
         }

branches/Async/HeuristicLab.Optimization/3.3/MetaOptimizers/TimeLimitRun.cs

@@ -41 +41 @@
   [StorableClass]
   public sealed class TimeLimitRun : NamedItem, IOptimizer, IStorableContent, INotifyPropertyChanged {
-    private readonly ManualResetEvent signaler = new ManualResetEvent(true);
-
     public string Filename { get; set; }
 
@@ -241 +239 @@
     }
     public void Start() {
-      StartAsync().Wait();
-    }
-    public async Task StartAsync() {
-      await StartAsync(CancellationToken.None);
-    }
+      Start(CancellationToken.None);
+    }
+    public void Start(CancellationToken cancellationToken) {
+      Algorithm.Start(cancellationToken);
+    }
+    public async Task StartAsync() { await StartAsync(CancellationToken.None); }
     public async Task StartAsync(CancellationToken cancellationToken) {
-      signaler.Reset();
-      await Task.Run(async () => {
-        await Algorithm.StartAsync(cancellationToken);
-        signaler.WaitOne();
-      }, cancellationToken);
+      await Task.Factory.StartNew((ct) => Start((CancellationToken)ct), cancellationToken, cancellationToken);
     }
     public void Pause() {
@@ -295 +290 @@
     public event EventHandler Paused;
     private void OnPaused() {
-      if (!pausedForSnapshot && !pausedForTermination) signaler.Set();
       var handler = Paused;
       if (handler != null) handler(this, EventArgs.Empty);
@@ -301 +295 @@
     public event EventHandler Stopped;
     private void OnStopped() {
-      signaler.Set();
       var handler = Stopped;
       if (handler != null) handler(this, EventArgs.Empty);
@@ -351 +344 @@
     private void Algorithm_Paused(object sender, EventArgs e) {
       var action = pausedForTermination ? ExecutionState.Stopped : (pausedForSnapshot ? ExecutionState.Started : ExecutionState.Paused);
-      bool pausedByLimit = pausedForSnapshot || pausedForTermination;
-      if (pausedByLimit) {
+      if (pausedForSnapshot || pausedForTermination) {
+        pausedForSnapshot = pausedForTermination = false;
         MakeSnapshot();
         FindNextSnapshotTimeIndex(ExecutionTime);
       }
       OnPaused();
-      if (pausedByLimit) pausedForSnapshot = pausedForTermination = false;
-      if (action == ExecutionState.Started) Algorithm.StartAsync();
+      if (action == ExecutionState.Started) Algorithm.Start();
       else if (action == ExecutionState.Stopped) Algorithm.Stop();
     }