Changeset 13349 for branches/Async/HeuristicLab.Algorithms.DataAnalysis

Timestamp:

11/23/15 21:18:26 (8 years ago)

Author:

jkarder

Message:

#2258: added StartAsync to IExecutable

Location:

branches/Async/HeuristicLab.Algorithms.DataAnalysis/3.4

Files:

• CrossValidation.cs (modified) (6 diffs)
• FixedDataAnalysisAlgorithm.cs (modified) (1 diff)

branches/Async/HeuristicLab.Algorithms.DataAnalysis/3.4/CrossValidation.cs

@@ -25 +25 @@
 using System.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using HeuristicLab.Collections;
 using HeuristicLab.Common;
@@ -39 +40 @@
   [StorableClass]
   public sealed class CrossValidation : ParameterizedNamedItem, IAlgorithm, IStorableContent {
+    private readonly ManualResetEvent signaler = new ManualResetEvent(true);
+
     public CrossValidation()
       : base() {
@@ -265 +268 @@
       Prepare();
     }
-
     public void Start() {
-      if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused))
-        throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState));
-
-      if (Algorithm != null) {
-        //create cloned algorithms
-        if (clonedAlgorithms.Count == 0) {
-          int testSamplesCount = (SamplesEnd.Value - SamplesStart.Value) / Folds.Value;
-
-          for (int i = 0; i < Folds.Value; i++) {
-            IAlgorithm clonedAlgorithm = (IAlgorithm)algorithm.Clone();
-            clonedAlgorithm.Name = algorithm.Name + " Fold " + i;
-            IDataAnalysisProblem problem = clonedAlgorithm.Problem as IDataAnalysisProblem;
-            ISymbolicDataAnalysisProblem symbolicProblem = problem as ISymbolicDataAnalysisProblem;
-
-            int testStart = (i * testSamplesCount) + SamplesStart.Value;
-            int testEnd = (i + 1) == Folds.Value ? SamplesEnd.Value : (i + 1) * testSamplesCount + SamplesStart.Value;
-
-            problem.ProblemData.TrainingPartition.Start = SamplesStart.Value;
-            problem.ProblemData.TrainingPartition.End = SamplesEnd.Value;
-            problem.ProblemData.TestPartition.Start = testStart;
-            problem.ProblemData.TestPartition.End = testEnd;
-            DataAnalysisProblemData problemData = problem.ProblemData as DataAnalysisProblemData;
-            if (problemData != null) {
-              problemData.TrainingPartitionParameter.Hidden = false;
-              problemData.TestPartitionParameter.Hidden = false;
+      StartAsync().Wait();
+    }
+    public async Task StartAsync() {
+      await StartAsync(new CancellationToken());
+    }
+    public async Task StartAsync(CancellationToken cancellationToken) {
+      signaler.Reset();
+      await Task.Run(() => {
+        if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused))
+          throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState));
+
+        if (Algorithm != null) {
+          //create cloned algorithms
+          if (clonedAlgorithms.Count == 0) {
+            int testSamplesCount = (SamplesEnd.Value - SamplesStart.Value) / Folds.Value;
+
+            for (int i = 0; i < Folds.Value; i++) {
+              IAlgorithm clonedAlgorithm = (IAlgorithm)algorithm.Clone();
+              clonedAlgorithm.Name = algorithm.Name + " Fold " + i;
+              IDataAnalysisProblem problem = clonedAlgorithm.Problem as IDataAnalysisProblem;
+              ISymbolicDataAnalysisProblem symbolicProblem = problem as ISymbolicDataAnalysisProblem;
+
+              int testStart = (i * testSamplesCount) + SamplesStart.Value;
+              int testEnd = (i + 1) == Folds.Value ? SamplesEnd.Value : (i + 1) * testSamplesCount + SamplesStart.Value;
+
+              problem.ProblemData.TrainingPartition.Start = SamplesStart.Value;
+              problem.ProblemData.TrainingPartition.End = SamplesEnd.Value;
+              problem.ProblemData.TestPartition.Start = testStart;
+              problem.ProblemData.TestPartition.End = testEnd;
+              DataAnalysisProblemData problemData = problem.ProblemData as DataAnalysisProblemData;
+              if (problemData != null) {
+                problemData.TrainingPartitionParameter.Hidden = false;
+                problemData.TestPartitionParameter.Hidden = false;
+              }
+
+              if (symbolicProblem != null) {
+                symbolicProblem.FitnessCalculationPartition.Start = SamplesStart.Value;
+                symbolicProblem.FitnessCalculationPartition.End = SamplesEnd.Value;
+              }
+              clonedAlgorithm.Prepare();
+              clonedAlgorithms.Add(clonedAlgorithm);
             }
-
-            if (symbolicProblem != null) {
-              symbolicProblem.FitnessCalculationPartition.Start = SamplesStart.Value;
-              symbolicProblem.FitnessCalculationPartition.End = SamplesEnd.Value;
-            }
-            clonedAlgorithm.Prepare();
-            clonedAlgorithms.Add(clonedAlgorithm);
           }
-        }
-
-        //start prepared or paused cloned algorithms
-        int startedAlgorithms = 0;
-        foreach (IAlgorithm clonedAlgorithm in clonedAlgorithms) {
-          if (startedAlgorithms < NumberOfWorkers.Value) {
-            if (clonedAlgorithm.ExecutionState == ExecutionState.Prepared ||
-                clonedAlgorithm.ExecutionState == ExecutionState.Paused) {
-
-              // start and wait until the alg is started 
-              using (var signal = new ManualResetEvent(false)) {
-                EventHandler signalSetter = (sender, args) => { signal.Set(); };
-                clonedAlgorithm.Started += signalSetter;
-                clonedAlgorithm.Start();
-                signal.WaitOne();
-                clonedAlgorithm.Started -= signalSetter;
-
-                startedAlgorithms++;
+
+          //start prepared or paused cloned algorithms
+          int startedAlgorithms = 0;
+          foreach (IAlgorithm clonedAlgorithm in clonedAlgorithms) {
+            if (startedAlgorithms < NumberOfWorkers.Value) {
+              if (clonedAlgorithm.ExecutionState == ExecutionState.Prepared ||
+                  clonedAlgorithm.ExecutionState == ExecutionState.Paused) {
+
+                // start and wait until the alg is started 
+                using (var signal = new ManualResetEvent(false)) {
+                  EventHandler signalSetter = (sender, args) => { signal.Set(); };
+                  clonedAlgorithm.Started += signalSetter;
+                  clonedAlgorithm.StartAsync(cancellationToken);
+                  signal.WaitOne();
+                  clonedAlgorithm.Started -= signalSetter;
+
+                  startedAlgorithms++;
+                }
               }
             }
           }
-        }
-        OnStarted();
-      }
+          OnStarted();
+        }
+      }, cancellationToken);
     }
 
@@ -671 +682 @@
           IAlgorithm preparedAlgorithm = clonedAlgorithms.FirstOrDefault(alg => alg.ExecutionState == ExecutionState.Prepared ||
                                                                                 alg.ExecutionState == ExecutionState.Paused);
-          if (preparedAlgorithm != null) preparedAlgorithm.Start();
+          if (preparedAlgorithm != null) preparedAlgorithm.StartAsync();
         }
         if (ExecutionState != ExecutionState.Stopped) {
@@ -714 +725 @@
       pausePending = false;
       ExecutionState = ExecutionState.Paused;
+      signaler.Set();
       EventHandler handler = Paused;
       if (handler != null) handler(this, EventArgs.Empty);
@@ -726 +738 @@
       runs.Add(new Run(string.Format("{0} Run {1}", Name, runsCounter), this));
       ExecutionState = ExecutionState.Stopped;
+      signaler.Set();
       EventHandler handler = Stopped;
       if (handler != null) handler(this, EventArgs.Empty);

branches/Async/HeuristicLab.Algorithms.DataAnalysis/3.4/FixedDataAnalysisAlgorithm.cs

@@ -70 +70 @@
     }
 
-    public override void Start() {
-      base.Start();
+    public override async Task StartAsync(CancellationToken cancellationToken) {
+      await base.StartAsync(cancellationToken);
       var cancellationTokenSource = new CancellationTokenSource();
 
       OnStarted();
-      Task task = Task.Factory.StartNew(Run, cancellationTokenSource.Token, cancellationTokenSource.Token);
-      task.ContinueWith(t => {
-        try {
-          t.Wait();
-        }
-        catch (AggregateException ex) {
+      using (var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationTokenSource.Token, cancellationToken)) {
+        Task task = Task.Factory.StartNew(Run, cts.Token, cts.Token);
+        await task.ContinueWith(t => {
           try {
-            ex.Flatten().Handle(x => x is OperationCanceledException);
+            t.Wait();
           }
-          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();
+        });
+      }
     }
     private void Run(object state) {