- Timestamp:
- 11/23/15 21:18:26 (9 years ago)
- Location:
- branches/Async
- Files:
-
- 21 edited
Legend:
- Unmodified
- Added
- Removed
-
branches/Async/HeuristicLab.Algorithms.Benchmarks/3.3/BenchmarkAlgorithm.cs
r12504 r13349 302 302 } 303 303 public void Start() { 304 StartAsync().Wait(); 305 } 306 public async Task StartAsync() { 307 await StartAsync(new CancellationToken()); 308 } 309 public async Task StartAsync(CancellationToken cancellationToken) { 304 310 cancellationTokenSource = new CancellationTokenSource(); 305 311 OnStarted(); 306 Task task = Task.Factory.StartNew(Run, cancellationTokenSource.Token, cancellationTokenSource.Token); 307 task.ContinueWith(t => { 308 try { 309 t.Wait(); 310 } 311 catch (AggregateException ex) { 312 using (var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationTokenSource.Token, cancellationToken)) { 313 Task task = Task.Factory.StartNew(Run, cts.Token, cts.Token); 314 await task.ContinueWith(t => { 312 315 try { 313 ex.Flatten().Handle(x => x is OperationCanceledException);316 t.Wait(); 314 317 } 315 catch (AggregateException remaining) { 316 if (remaining.InnerExceptions.Count == 1) OnExceptionOccurred(remaining.InnerExceptions[0]); 317 else OnExceptionOccurred(remaining); 318 catch (AggregateException ex) { 319 try { 320 ex.Flatten().Handle(x => x is OperationCanceledException); 321 } 322 catch (AggregateException remaining) { 323 if (remaining.InnerExceptions.Count == 1) OnExceptionOccurred(remaining.InnerExceptions[0]); 324 else OnExceptionOccurred(remaining); 325 } 318 326 } 319 } 320 321 cancellationTokenSource.Dispose(); 322 cancellationTokenSource = null; 323 OnStopped(); 324 }); 325 } 326 327 328 cancellationTokenSource.Dispose(); 329 cancellationTokenSource = null; 330 OnStopped(); 331 }); 332 } 333 } 327 334 private void Run(object state) { 328 335 CancellationToken cancellationToken = (CancellationToken)state; -
branches/Async/HeuristicLab.Algorithms.DataAnalysis.Views/3.4/CrossValidationView.cs
r12012 r13349 216 216 217 217 private void startButton_Click(object sender, EventArgs e) { 218 Content.Start ();218 Content.StartAsync(); 219 219 } 220 220 private void pauseButton_Click(object sender, EventArgs e) { -
branches/Async/HeuristicLab.Algorithms.DataAnalysis/3.4/CrossValidation.cs
r13238 r13349 25 25 using System.Linq; 26 26 using System.Threading; 27 using System.Threading.Tasks; 27 28 using HeuristicLab.Collections; 28 29 using HeuristicLab.Common; … … 39 40 [StorableClass] 40 41 public sealed class CrossValidation : ParameterizedNamedItem, IAlgorithm, IStorableContent { 42 private readonly ManualResetEvent signaler = new ManualResetEvent(true); 43 41 44 public CrossValidation() 42 45 : base() { … … 265 268 Prepare(); 266 269 } 267 268 270 public void Start() { 269 if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused)) 270 throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState)); 271 272 if (Algorithm != null) { 273 //create cloned algorithms 274 if (clonedAlgorithms.Count == 0) { 275 int testSamplesCount = (SamplesEnd.Value - SamplesStart.Value) / Folds.Value; 276 277 for (int i = 0; i < Folds.Value; i++) { 278 IAlgorithm clonedAlgorithm = (IAlgorithm)algorithm.Clone(); 279 clonedAlgorithm.Name = algorithm.Name + " Fold " + i; 280 IDataAnalysisProblem problem = clonedAlgorithm.Problem as IDataAnalysisProblem; 281 ISymbolicDataAnalysisProblem symbolicProblem = problem as ISymbolicDataAnalysisProblem; 282 283 int testStart = (i * testSamplesCount) + SamplesStart.Value; 284 int testEnd = (i + 1) == Folds.Value ? SamplesEnd.Value : (i + 1) * testSamplesCount + SamplesStart.Value; 285 286 problem.ProblemData.TrainingPartition.Start = SamplesStart.Value; 287 problem.ProblemData.TrainingPartition.End = SamplesEnd.Value; 288 problem.ProblemData.TestPartition.Start = testStart; 289 problem.ProblemData.TestPartition.End = testEnd; 290 DataAnalysisProblemData problemData = problem.ProblemData as DataAnalysisProblemData; 291 if (problemData != null) { 292 problemData.TrainingPartitionParameter.Hidden = false; 293 problemData.TestPartitionParameter.Hidden = false; 271 StartAsync().Wait(); 272 } 273 public async Task StartAsync() { 274 await StartAsync(new CancellationToken()); 275 } 276 public async Task StartAsync(CancellationToken cancellationToken) { 277 signaler.Reset(); 278 await Task.Run(() => { 279 if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused)) 280 throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState)); 281 282 if (Algorithm != null) { 283 //create cloned algorithms 284 if (clonedAlgorithms.Count == 0) { 285 int testSamplesCount = (SamplesEnd.Value - SamplesStart.Value) / Folds.Value; 286 287 for (int i = 0; i < Folds.Value; i++) { 288 IAlgorithm clonedAlgorithm = (IAlgorithm)algorithm.Clone(); 289 clonedAlgorithm.Name = algorithm.Name + " Fold " + i; 290 IDataAnalysisProblem problem = clonedAlgorithm.Problem as IDataAnalysisProblem; 291 ISymbolicDataAnalysisProblem symbolicProblem = problem as ISymbolicDataAnalysisProblem; 292 293 int testStart = (i * testSamplesCount) + SamplesStart.Value; 294 int testEnd = (i + 1) == Folds.Value ? SamplesEnd.Value : (i + 1) * testSamplesCount + SamplesStart.Value; 295 296 problem.ProblemData.TrainingPartition.Start = SamplesStart.Value; 297 problem.ProblemData.TrainingPartition.End = SamplesEnd.Value; 298 problem.ProblemData.TestPartition.Start = testStart; 299 problem.ProblemData.TestPartition.End = testEnd; 300 DataAnalysisProblemData problemData = problem.ProblemData as DataAnalysisProblemData; 301 if (problemData != null) { 302 problemData.TrainingPartitionParameter.Hidden = false; 303 problemData.TestPartitionParameter.Hidden = false; 304 } 305 306 if (symbolicProblem != null) { 307 symbolicProblem.FitnessCalculationPartition.Start = SamplesStart.Value; 308 symbolicProblem.FitnessCalculationPartition.End = SamplesEnd.Value; 309 } 310 clonedAlgorithm.Prepare(); 311 clonedAlgorithms.Add(clonedAlgorithm); 294 312 } 295 296 if (symbolicProblem != null) {297 symbolicProblem.FitnessCalculationPartition.Start = SamplesStart.Value;298 symbolicProblem.FitnessCalculationPartition.End = SamplesEnd.Value;299 }300 clonedAlgorithm.Prepare();301 clonedAlgorithms.Add(clonedAlgorithm);302 313 } 303 } 304 305 //start prepared or paused cloned algorithms306 int startedAlgorithms = 0;307 foreach (IAlgorithm clonedAlgorithm in clonedAlgorithms) {308 if (startedAlgorithms < NumberOfWorkers.Value) {309 if (clonedAlgorithm.ExecutionState == ExecutionState.Prepared ||310 clonedAlgorithm.ExecutionState == ExecutionState.Paused) { 311 312 // start and wait until the alg is started313 using (var signal = new ManualResetEvent(false)) {314 EventHandler signalSetter = (sender, args) => { signal.Set(); };315 clonedAlgorithm.Started += signalSetter;316 clonedAlgorithm.Start();317 signal.WaitOne();318 clonedAlgorithm.Started -= signalSetter; 319 320 startedAlgorithms++;314 315 //start prepared or paused cloned algorithms 316 int startedAlgorithms = 0; 317 foreach (IAlgorithm clonedAlgorithm in clonedAlgorithms) { 318 if (startedAlgorithms < NumberOfWorkers.Value) { 319 if (clonedAlgorithm.ExecutionState == ExecutionState.Prepared || 320 clonedAlgorithm.ExecutionState == ExecutionState.Paused) { 321 322 // start and wait until the alg is started 323 using (var signal = new ManualResetEvent(false)) { 324 EventHandler signalSetter = (sender, args) => { signal.Set(); }; 325 clonedAlgorithm.Started += signalSetter; 326 clonedAlgorithm.StartAsync(cancellationToken); 327 signal.WaitOne(); 328 clonedAlgorithm.Started -= signalSetter; 329 330 startedAlgorithms++; 331 } 321 332 } 322 333 } 323 334 } 324 }325 OnStarted();326 } 335 OnStarted(); 336 } 337 }, cancellationToken); 327 338 } 328 339 … … 671 682 IAlgorithm preparedAlgorithm = clonedAlgorithms.FirstOrDefault(alg => alg.ExecutionState == ExecutionState.Prepared || 672 683 alg.ExecutionState == ExecutionState.Paused); 673 if (preparedAlgorithm != null) preparedAlgorithm.Start ();684 if (preparedAlgorithm != null) preparedAlgorithm.StartAsync(); 674 685 } 675 686 if (ExecutionState != ExecutionState.Stopped) { … … 714 725 pausePending = false; 715 726 ExecutionState = ExecutionState.Paused; 727 signaler.Set(); 716 728 EventHandler handler = Paused; 717 729 if (handler != null) handler(this, EventArgs.Empty); … … 726 738 runs.Add(new Run(string.Format("{0} Run {1}", Name, runsCounter), this)); 727 739 ExecutionState = ExecutionState.Stopped; 740 signaler.Set(); 728 741 EventHandler handler = Stopped; 729 742 if (handler != null) handler(this, EventArgs.Empty); -
branches/Async/HeuristicLab.Algorithms.DataAnalysis/3.4/FixedDataAnalysisAlgorithm.cs
r12012 r13349 70 70 } 71 71 72 public override void Start() {73 base.Start();72 public override async Task StartAsync(CancellationToken cancellationToken) { 73 await base.StartAsync(cancellationToken); 74 74 var cancellationTokenSource = new CancellationTokenSource(); 75 75 76 76 OnStarted(); 77 Task task = Task.Factory.StartNew(Run, cancellationTokenSource.Token, cancellationTokenSource.Token); 78 task.ContinueWith(t => { 79 try { 80 t.Wait(); 81 } 82 catch (AggregateException ex) { 77 using (var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationTokenSource.Token, cancellationToken)) { 78 Task task = Task.Factory.StartNew(Run, cts.Token, cts.Token); 79 await task.ContinueWith(t => { 83 80 try { 84 ex.Flatten().Handle(x => x is OperationCanceledException);81 t.Wait(); 85 82 } 86 catch (AggregateException remaining) { 87 if (remaining.InnerExceptions.Count == 1) OnExceptionOccurred(remaining.InnerExceptions[0]); 88 else OnExceptionOccurred(remaining); 83 catch (AggregateException ex) { 84 try { 85 ex.Flatten().Handle(x => x is OperationCanceledException); 86 } 87 catch (AggregateException remaining) { 88 if (remaining.InnerExceptions.Count == 1) OnExceptionOccurred(remaining.InnerExceptions[0]); 89 else OnExceptionOccurred(remaining); 90 } 89 91 } 90 }91 cancellationTokenSource.Dispose();92 cancellationTokenSource = null;93 OnStopped();94 } );92 cancellationTokenSource.Dispose(); 93 cancellationTokenSource = null; 94 OnStopped(); 95 }); 96 } 95 97 } 96 98 private void Run(object state) { -
branches/Async/HeuristicLab.Clients.Hive/3.3/Tasks/EngineTask.cs
r12012 r13349 81 81 public override void Start() { 82 82 Item.Prepare(initialOperation); 83 Item.Start ();83 Item.StartAsync(); 84 84 } 85 85 -
branches/Async/HeuristicLab.Clients.Hive/3.3/Tasks/OptimizerTask.cs
r12012 r13349 101 101 OnTaskStopped(); 102 102 } else { 103 Item.Start ();103 Item.StartAsync(); 104 104 } 105 105 } -
branches/Async/HeuristicLab.Clients.OKB.Views/3.3/RunCreation/Views/OKBAlgorithmView.cs
r12012 r13349 325 325 } 326 326 private void startButton_Click(object sender, EventArgs e) { 327 Content.Start ();327 Content.StartAsync(); 328 328 } 329 329 private void pauseButton_Click(object sender, EventArgs e) { -
branches/Async/HeuristicLab.Clients.OKB/3.3/RunCreation/EmptyAlgorithm.cs
r12012 r13349 21 21 22 22 using System; 23 using System.Threading; 24 using System.Threading.Tasks; 23 25 using HeuristicLab.Common; 24 26 using HeuristicLab.Core; … … 80 82 throw new InvalidOperationException(string.IsNullOrEmpty(exceptionMessage) ? "Cannot prepare an EmptyAlgorithm." : exceptionMessage); 81 83 } 82 public override void Start() {84 public override async Task StartAsync(CancellationToken cancellationToken) { 83 85 throw new InvalidOperationException(string.IsNullOrEmpty(exceptionMessage) ? "Cannot start an EmptyAlgorithm." : exceptionMessage); 84 86 } -
branches/Async/HeuristicLab.Clients.OKB/3.3/RunCreation/OKBAlgorithm.cs
r12504 r13349 25 25 using System.IO; 26 26 using System.Linq; 27 using System.Threading; 28 using System.Threading.Tasks; 27 29 using HeuristicLab.Clients.Access; 28 30 using HeuristicLab.Collections; … … 250 252 } 251 253 public void Start() { 254 StartAsync().Wait(); 255 } 256 public async Task StartAsync() { 257 await StartAsync(new CancellationToken()); 258 } 259 public async Task StartAsync(CancellationToken cancellationToken) { 252 260 CheckUserPermissions(); 253 261 if (!ClientInformation.Instance.ClientExists && storeRunsAutomatically) { 254 262 throw new MissingClientRegistrationException(); 255 263 } 256 Algorithm.Start();264 await Algorithm.StartAsync(cancellationToken); 257 265 } 258 266 public void Pause() { -
branches/Async/HeuristicLab.Core/3.3/Engine.cs
r12012 r13349 82 82 } 83 83 84 public override void Start() {85 base.Start();84 public override async Task StartAsync(CancellationToken cancellationToken) { 85 await base.StartAsync(cancellationToken); 86 86 cancellationTokenSource = new CancellationTokenSource(); 87 87 stopPending = false; 88 Task task = Task.Factory.StartNew(Run, cancellationTokenSource.Token, cancellationTokenSource.Token); 89 task.ContinueWith(t => { 90 try { 91 t.Wait(); 92 } 93 catch (AggregateException ex) { 88 using (var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationTokenSource.Token, cancellationToken)) { 89 Task task = Task.Factory.StartNew(Run, cts.Token, cts.Token); 90 await task.ContinueWith(t => { 94 91 try { 95 ex.Flatten().Handle(x => x is OperationCanceledException);92 t.Wait(); 96 93 } 97 catch (AggregateException remaining) { 98 if (remaining.InnerExceptions.Count == 1) OnExceptionOccurred(remaining.InnerExceptions[0]); 99 else OnExceptionOccurred(remaining); 94 catch (AggregateException ex) { 95 try { 96 ex.Flatten().Handle(x => x is OperationCanceledException); 97 } 98 catch (AggregateException remaining) { 99 if (remaining.InnerExceptions.Count == 1) OnExceptionOccurred(remaining.InnerExceptions[0]); 100 else OnExceptionOccurred(remaining); 101 } 100 102 } 101 }102 cancellationTokenSource.Dispose();103 cancellationTokenSource = null;104 if (stopPending) executionStack.Clear();105 if (executionStack.Count == 0) OnStopped();106 else OnPaused();107 } );103 cancellationTokenSource.Dispose(); 104 cancellationTokenSource = null; 105 if (stopPending) executionStack.Clear(); 106 if (executionStack.Count == 0) OnStopped(); 107 else OnPaused(); 108 }); 109 } 108 110 } 109 111 protected override void OnStarted() { -
branches/Async/HeuristicLab.Core/3.3/Executable.cs
r12012 r13349 22 22 using System; 23 23 using System.Drawing; 24 using System.Threading; 25 using System.Threading.Tasks; 24 26 using HeuristicLab.Common; 25 27 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable; … … 82 84 ExecutionTime = TimeSpan.Zero; 83 85 } 84 public virtual void Start() { 86 public void Start() { 87 StartAsync().Wait(); 88 } 89 public async Task StartAsync() { 90 await StartAsync(new CancellationToken()); 91 } 92 public virtual async Task StartAsync(CancellationToken cancellationToken) { 85 93 if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused)) 86 94 throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState)); -
branches/Async/HeuristicLab.Core/3.3/Interfaces/IExecutable.cs
r12012 r13349 21 21 22 22 using System; 23 using System.Threading; 24 using System.Threading.Tasks; 23 25 using HeuristicLab.Common; 24 26 … … 30 32 void Prepare(); 31 33 void Start(); 34 Task StartAsync(); 35 Task StartAsync(CancellationToken cancellationToken); 32 36 void Pause(); 33 37 void Stop(); -
branches/Async/HeuristicLab.DebugEngine/3.3/DebugEngine.cs
r12012 r13349 174 174 } 175 175 176 public override void Start() {177 base.Start();176 public override async Task StartAsync(CancellationToken cancellationToken) { 177 await base.StartAsync(cancellationToken); 178 178 cancellationTokenSource = new CancellationTokenSource(); 179 179 stopPending = false; 180 Task task = Task.Factory.StartNew(Run, cancellationTokenSource.Token, cancellationTokenSource.Token); 181 task.ContinueWith(t => { 182 try { 183 t.Wait(); 184 } 185 catch (AggregateException ex) { 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 => { 186 183 try { 187 ex.Flatten().Handle(x => x is OperationCanceledException);184 t.Wait(); 188 185 } 189 catch (AggregateException remaining) { 190 if (remaining.InnerExceptions.Count == 1) OnExceptionOccurred(remaining.InnerExceptions[0]); 191 else OnExceptionOccurred(remaining); 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 } 192 194 } 193 }194 cancellationTokenSource.Dispose();195 cancellationTokenSource = null; 196 197 if (stopPending) ExecutionStack.Clear();198 if (stopPending || !CanContinue) OnStopped();199 else OnPaused();200 } );195 cancellationTokenSource.Dispose(); 196 cancellationTokenSource = null; 197 198 if (stopPending) ExecutionStack.Clear(); 199 if (stopPending || !CanContinue) OnStopped(); 200 else OnPaused(); 201 }); 202 } 201 203 } 202 204 -
branches/Async/HeuristicLab.Optimization.Views/3.3/IOptimizerView.cs
r12012 r13349 137 137 #region Control events 138 138 protected virtual void startButton_Click(object sender, EventArgs e) { 139 Content.Start ();139 Content.StartAsync(); 140 140 } 141 141 protected virtual void pauseButton_Click(object sender, EventArgs e) { -
branches/Async/HeuristicLab.Optimization/3.3/Algorithms/Algorithm.cs
r12012 r13349 24 24 using System.Drawing; 25 25 using System.Linq; 26 using System.Threading; 27 using System.Threading.Tasks; 26 28 using HeuristicLab.Collections; 27 29 using HeuristicLab.Common; … … 202 204 Prepare(); 203 205 } 204 public virtual void Start() { 206 public void Start() { 207 StartAsync().Wait(); 208 } 209 public async Task StartAsync() { 210 await StartAsync(new CancellationToken()); 211 } 212 public virtual async Task StartAsync(CancellationToken cancellationToken) { 205 213 if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused)) 206 214 throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState)); -
branches/Async/HeuristicLab.Optimization/3.3/Algorithms/BasicAlgorithm.cs
r11878 r13349 61 61 } 62 62 63 public override void Start() {64 base.Start();63 public override async Task StartAsync(CancellationToken cancellationToken) { 64 await base.StartAsync(cancellationToken); 65 65 CancellationTokenSource = new CancellationTokenSource(); 66 66 67 67 OnStarted(); 68 Task task = Task.Factory.StartNew(Run, cancellationTokenSource.Token, cancellationTokenSource.Token); 69 task.ContinueWith(t => { 70 try { 71 t.Wait(); 72 } catch (AggregateException ex) { 68 using (var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationTokenSource.Token, cancellationToken)) { 69 Task task = Task.Factory.StartNew(Run, cts.Token, cts.Token); 70 await task.ContinueWith(t => { 73 71 try { 74 ex.Flatten().Handle(x => x is OperationCanceledException); 75 } catch (AggregateException remaining) { 76 if (remaining.InnerExceptions.Count == 1) OnExceptionOccurred(remaining.InnerExceptions[0]); 77 else OnExceptionOccurred(remaining); 72 t.Wait(); 78 73 } 79 } 80 CancellationTokenSource.Dispose(); 81 CancellationTokenSource = null; 82 OnStopped(); 83 }); 74 catch (AggregateException ex) { 75 try { 76 ex.Flatten().Handle(x => x is OperationCanceledException); 77 } 78 catch (AggregateException remaining) { 79 if (remaining.InnerExceptions.Count == 1) OnExceptionOccurred(remaining.InnerExceptions[0]); 80 else OnExceptionOccurred(remaining); 81 } 82 } 83 CancellationTokenSource.Dispose(); 84 CancellationTokenSource = null; 85 OnStopped(); 86 }); 87 } 84 88 } 85 89 … … 106 110 try { 107 111 Run(cancellationToken); 108 } finally { 112 } 113 finally { 109 114 timer.Elapsed -= new System.Timers.ElapsedEventHandler(timer_Elapsed); 110 115 timer.Stop(); -
branches/Async/HeuristicLab.Optimization/3.3/Algorithms/EngineAlgorithm.cs
r12012 r13349 22 22 using System; 23 23 using System.Linq; 24 using System.Threading; 25 using System.Threading.Tasks; 24 26 using HeuristicLab.Common; 25 27 using HeuristicLab.Core; 26 28 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable; 27 29 using HeuristicLab.PluginInfrastructure; 30 using ExecutionContext = HeuristicLab.Core.ExecutionContext; 28 31 29 32 namespace HeuristicLab.Optimization { … … 168 171 } 169 172 } 170 public override void Start() {171 base.Start();172 if (engine != null) engine.Start();173 public override async Task StartAsync(CancellationToken cancellationToken) { 174 await base.StartAsync(cancellationToken); 175 if (engine != null) await engine.StartAsync(cancellationToken); 173 176 } 174 177 public override void Pause() { -
branches/Async/HeuristicLab.Optimization/3.3/MetaOptimizers/BatchRun.cs
r12504 r13349 23 23 using System.Collections.Generic; 24 24 using System.Drawing; 25 using System.Threading; 26 using System.Threading.Tasks; 25 27 using HeuristicLab.Collections; 26 28 using HeuristicLab.Common; … … 39 41 [StorableClass] 40 42 public sealed class BatchRun : NamedItem, IOptimizer, IStorableContent { 43 private readonly ManualResetEvent signaler = new ManualResetEvent(true); 44 41 45 public string Filename { get; set; } 42 46 … … 244 248 } 245 249 public void Start() { 246 if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused)) 247 throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState)); 248 if (Optimizer == null) return; 249 batchRunAction = BatchRunAction.Start; 250 if (Optimizer.ExecutionState == ExecutionState.Stopped) Optimizer.Prepare(); 251 // a race-condition may occur when the optimizer has changed the state by itself in the meantime 252 try { Optimizer.Start(); } 253 catch (InvalidOperationException) { } 250 StartAsync().Wait(); 251 } 252 public async Task StartAsync() { 253 await StartAsync(new CancellationToken()); 254 } 255 public async Task StartAsync(CancellationToken cancellationToken) { 256 signaler.Reset(); 257 await Task.Run(async () => { 258 if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused)) 259 throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState)); 260 if (Optimizer == null) return; 261 batchRunAction = BatchRunAction.Start; 262 if (Optimizer.ExecutionState == ExecutionState.Stopped) Optimizer.Prepare(); 263 // a race-condition may occur when the optimizer has changed the state by itself in the meantime 264 try { await Optimizer.StartAsync(cancellationToken); } 265 catch (InvalidOperationException) { } 266 signaler.WaitOne(); 267 }, cancellationToken); 254 268 } 255 269 public void Pause() { … … 326 340 batchRunAction = BatchRunAction.None; 327 341 ExecutionState = ExecutionState.Paused; 342 signaler.Set(); 328 343 EventHandler handler = Paused; 329 344 if (handler != null) handler(this, EventArgs.Empty); … … 333 348 batchRunAction = BatchRunAction.None; 334 349 ExecutionState = ExecutionState.Stopped; 350 signaler.Set(); 335 351 EventHandler handler = Stopped; 336 352 if (handler != null) handler(this, EventArgs.Empty); … … 397 413 else if (batchRunAction == BatchRunAction.Start) { 398 414 Optimizer.Prepare(); 399 Optimizer.Start ();415 Optimizer.StartAsync(); 400 416 } else if (executionState == ExecutionState.Started) { 401 417 // if the batch run hasn't been started but the inner optimizer was run then pause -
branches/Async/HeuristicLab.Optimization/3.3/MetaOptimizers/Experiment.cs
r13000 r13349 25 25 using System.Linq; 26 26 using System.Threading; 27 using System.Threading.Tasks; 27 28 using HeuristicLab.Collections; 28 29 using HeuristicLab.Common; … … 38 39 [StorableClass] 39 40 public sealed class Experiment : NamedItem, IOptimizer, IStorableContent { 41 private readonly ManualResetEvent signaler = new ManualResetEvent(true); 42 40 43 public string Filename { get; set; } 41 44 … … 186 189 } 187 190 public void Start() { 188 if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused)) 189 throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState)); 190 if (Optimizers.Count == 0) return; 191 192 experimentStarted = true; 193 experimentStopped = false; 194 IOptimizer optimizer = Optimizers.FirstOrDefault(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused)); 195 if (optimizer != null) { 196 // a race-condition may occur when the optimizer has changed the state by itself in the meantime 197 try { optimizer.Start(); } 198 catch (InvalidOperationException) { } 199 } 191 StartAsync().Wait(); 192 } 193 public async Task StartAsync() { 194 await StartAsync(new CancellationToken()); 195 } 196 public async Task StartAsync(CancellationToken cancellationToken) { 197 signaler.Reset(); 198 await Task.Run(async () => { 199 if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused)) 200 throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState)); 201 if (Optimizers.Count == 0) return; 202 203 experimentStarted = true; 204 experimentStopped = false; 205 IOptimizer optimizer = Optimizers.FirstOrDefault(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused)); 206 if (optimizer != null) { 207 // a race-condition may occur when the optimizer has changed the state by itself in the meantime 208 try { await optimizer.StartAsync(cancellationToken); } 209 catch (InvalidOperationException) { } 210 } 211 signaler.WaitOne(); 212 }, cancellationToken); 200 213 } 201 214 public void Pause() { … … 261 274 private void OnPaused() { 262 275 ExecutionState = ExecutionState.Paused; 276 signaler.Set(); 263 277 EventHandler handler = Paused; 264 278 if (handler != null) handler(this, EventArgs.Empty); … … 267 281 private void OnStopped() { 268 282 ExecutionState = ExecutionState.Stopped; 283 signaler.Set(); 269 284 EventHandler handler = Stopped; 270 285 if (handler != null) handler(this, EventArgs.Empty); … … 380 395 } else { 381 396 if (experimentStarted && Optimizers.Any(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused))) { 382 Optimizers.First(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused)).Start ();397 Optimizers.First(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused)).StartAsync(); 383 398 } else if (Optimizers.All(x => x.ExecutionState == ExecutionState.Stopped)) OnStopped(); 384 399 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
r13321 r13349 25 25 using System.Drawing; 26 26 using System.Linq; 27 using System.Threading; 27 28 using System.Threading.Tasks; 28 29 using HeuristicLab.Collections; … … 40 41 [StorableClass] 41 42 public sealed class TimeLimitRun : NamedItem, IOptimizer, IStorableContent, INotifyPropertyChanged { 43 private readonly ManualResetEvent signaler = new ManualResetEvent(true); 44 42 45 public string Filename { get; set; } 43 46 … … 238 241 } 239 242 public void Start() { 240 Algorithm.Start(); 243 StartAsync().Wait(); 244 } 245 public async Task StartAsync() { 246 await StartAsync(new CancellationToken()); 247 } 248 public async Task StartAsync(CancellationToken cancellationToken) { 249 signaler.Reset(); 250 await Task.Run(async () => { 251 await Algorithm.StartAsync(cancellationToken); 252 signaler.WaitOne(); 253 }, cancellationToken); 241 254 } 242 255 public void Pause() { … … 282 295 public event EventHandler Paused; 283 296 private void OnPaused() { 297 if (!pausedForSnapshot && !pausedForTermination) signaler.Set(); 284 298 var handler = Paused; 285 299 if (handler != null) handler(this, EventArgs.Empty); … … 287 301 public event EventHandler Stopped; 288 302 private void OnStopped() { 303 signaler.Set(); 289 304 var handler = Stopped; 290 305 if (handler != null) handler(this, EventArgs.Empty); … … 336 351 private void Algorithm_Paused(object sender, EventArgs e) { 337 352 var action = pausedForTermination ? ExecutionState.Stopped : (pausedForSnapshot ? ExecutionState.Started : ExecutionState.Paused); 338 if (pausedForSnapshot || pausedForTermination) {339 pausedForSnapshot = pausedForTermination = false;353 bool pausedByLimit = pausedForSnapshot || pausedForTermination; 354 if (pausedByLimit) { 340 355 MakeSnapshot(); 341 356 FindNextSnapshotTimeIndex(ExecutionTime); 342 357 } 343 358 OnPaused(); 344 if (action == ExecutionState.Started) Algorithm.Start(); 359 if (pausedByLimit) pausedForSnapshot = pausedForTermination = false; 360 if (action == ExecutionState.Started) Algorithm.StartAsync(); 345 361 else if (action == ExecutionState.Stopped) Algorithm.Stop(); 346 362 } -
branches/Async/HeuristicLab.Problems.QuadraticAssignment.Algorithms/3.3/RobustTabooSearch.cs
r13173 r13349 22 22 using System; 23 23 using System.Linq; 24 using System.Threading; 25 using System.Threading.Tasks; 24 26 using HeuristicLab.Analysis; 25 27 using HeuristicLab.Common; … … 338 340 } 339 341 340 public override void Start() {342 public override async Task StartAsync(CancellationToken cancellationToken) { 341 343 if (ExecutionState == ExecutionState.Prepared) { 342 344 int dim = Problem.Weights.Rows; … … 350 352 GlobalScope.Variables.Add(new Variable("MoveQualityMatrix", new DoubleMatrix(dim, dim))); 351 353 } 352 base.Start();354 await base.StartAsync(cancellationToken); 353 355 } 354 356
Note: See TracChangeset
for help on using the changeset viewer.