Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
07/28/17 16:47:42 (7 years ago)
Author:
jkarder
Message:

#2258: merged r15287 into stable

Location:
stable
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • stable

  • stable/HeuristicLab.Optimization

  • stable/HeuristicLab.Optimization/3.3/Algorithms/Algorithm.cs

    r14800 r15292  
    2424using System.Drawing;
    2525using System.Linq;
     26using System.Threading;
     27using System.Threading.Tasks;
    2628using HeuristicLab.Collections;
    2729using HeuristicLab.Common;
     
    203205    }
    204206    public virtual void Start() {
     207      Start(CancellationToken.None);
     208    }
     209    public virtual void Start(CancellationToken cancellationToken) {
    205210      if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused))
    206211        throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState));
     212    }
     213    public virtual async Task StartAsync() { await StartAsync(CancellationToken.None); }
     214    public virtual async Task StartAsync(CancellationToken cancellationToken) {
     215      await AsyncHelper.DoAsync(Start, cancellationToken);
    207216    }
    208217    public virtual void Pause() {
  • stable/HeuristicLab.Optimization/3.3/Algorithms/BasicAlgorithm.cs

    r15061 r15292  
    2121
    2222using System;
     23using System.Linq;
    2324using System.Threading;
    24 using System.Threading.Tasks;
    2525using HeuristicLab.Common;
    2626using HeuristicLab.Core;
     
    7171    }
    7272
    73     public override void Start() {
    74       base.Start();
    75       CancellationTokenSource = new CancellationTokenSource();
     73    public override void Start(CancellationToken cancellationToken) {
     74      base.Start(cancellationToken);
     75      CancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
    7676      pausePending = false;
    7777      OnStarted();
    7878
    79       Task task = Task.Factory.StartNew(Run, CancellationTokenSource.Token, CancellationTokenSource.Token);
    80       task.ContinueWith(t => {
    81         try {
    82           t.Wait();
    83         }
    84         catch (AggregateException ex) {
    85           try {
    86             ex.Flatten().Handle(x => x is OperationCanceledException);
    87           }
    88           catch (AggregateException remaining) {
    89             if (remaining.InnerExceptions.Count == 1) OnExceptionOccurred(remaining.InnerExceptions[0]);
    90             else OnExceptionOccurred(remaining);
    91           }
    92         }
    93         CancellationTokenSource.Dispose();
    94         CancellationTokenSource = null;
    95         if (pausePending) OnPaused();
    96         else OnStopped();
    97       });
     79      try {
     80        Run((object)cancellationTokenSource.Token);
     81      } catch (OperationCanceledException) {
     82      } catch (AggregateException ae) {
     83        OnExceptionOccurred(ae.InnerExceptions.SingleOrDefault() ?? ae);
     84      } catch (Exception e) {
     85        OnExceptionOccurred(e);
     86      }
     87
     88      CancellationTokenSource.Dispose();
     89      CancellationTokenSource = null;
     90      if (pausePending) OnPaused();
     91      else OnStopped();
    9892    }
    9993
  • stable/HeuristicLab.Optimization/3.3/Algorithms/EngineAlgorithm.cs

    r14186 r15292  
    168168      }
    169169    }
    170     public override void Start() {
    171       base.Start();
    172       if (engine != null) engine.Start();
     170    public override void Start(System.Threading.CancellationToken cancellationToken) {
     171      base.Start(cancellationToken);
     172      if (engine != null) engine.Start(cancellationToken);
    173173    }
    174174    public override void Pause() {
  • stable/HeuristicLab.Optimization/3.3/MetaOptimizers/BatchRun.cs

    r14186 r15292  
    2323using System.Collections.Generic;
    2424using System.Drawing;
     25using System.Threading;
     26using System.Threading.Tasks;
    2527using HeuristicLab.Collections;
    2628using HeuristicLab.Common;
     
    237239        batchRunAction = BatchRunAction.Prepare;
    238240        // a race-condition may occur when the optimizer has changed the state by itself in the meantime
    239         try { Optimizer.Prepare(clearRuns); }
    240         catch (InvalidOperationException) { }
     241        try { Optimizer.Prepare(clearRuns); } catch (InvalidOperationException) { }
    241242      } else {
    242243        ExecutionState = ExecutionState.Stopped;
     
    244245    }
    245246    public void Start() {
     247      Start(CancellationToken.None);
     248    }
     249    public void Start(CancellationToken cancellationToken) {
    246250      if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused))
    247251        throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState));
     
    249253      batchRunAction = BatchRunAction.Start;
    250254      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) { }
     255      for (int i = repetitionsCounter; i < repetitions; i++) {
     256        // a race-condition may occur when the optimizer has changed the state by itself in the meantime
     257        try { Optimizer.Start(cancellationToken); } catch (InvalidOperationException) { }
     258        if (ExecutionState == ExecutionState.Paused || ExecutionState == ExecutionState.Stopped) break;
     259        Optimizer.Prepare();
     260      }
     261    }
     262    public async Task StartAsync() { await StartAsync(CancellationToken.None); }
     263    public async Task StartAsync(CancellationToken cancellationToken) {
     264      await AsyncHelper.DoAsync(Start, cancellationToken);
    254265    }
    255266    public void Pause() {
     
    260271      if (Optimizer.ExecutionState != ExecutionState.Started) return;
    261272      // a race-condition may occur when the optimizer has changed the state by itself in the meantime
    262       try { Optimizer.Pause(); }
    263       catch (InvalidOperationException) { }
     273      try { Optimizer.Pause(); } catch (InvalidOperationException) { }
    264274    }
    265275    public void Stop() {
     
    273283      }
    274284      // a race-condition may occur when the optimizer has changed the state by itself in the meantime
    275       try { Optimizer.Stop(); }
    276       catch (InvalidOperationException) { }
     285      try { Optimizer.Stop(); } catch (InvalidOperationException) { }
    277286    }
    278287
     
    395404      else if (repetitionsCounter >= repetitions) OnStopped();
    396405      else if (batchRunAction == BatchRunAction.Pause) OnPaused();
    397       else if (batchRunAction == BatchRunAction.Start) {
    398         Optimizer.Prepare();
    399         Optimizer.Start();
    400       } else if (executionState == ExecutionState.Started) {
     406      else if (batchRunAction == BatchRunAction.Start) return;
     407      else if (executionState == ExecutionState.Started) {
    401408        // if the batch run hasn't been started but the inner optimizer was run then pause
    402409        OnPaused();
  • stable/HeuristicLab.Optimization/3.3/MetaOptimizers/Experiment.cs

    r14186 r15292  
    2525using System.Linq;
    2626using System.Threading;
     27using System.Threading.Tasks;
    2728using HeuristicLab.Collections;
    2829using HeuristicLab.Common;
     
    181182      foreach (IOptimizer optimizer in Optimizers.Where(x => x.ExecutionState != ExecutionState.Started)) {
    182183        // a race-condition may occur when the optimizer has changed the state by itself in the meantime
    183         try { optimizer.Prepare(clearRuns); }
    184         catch (InvalidOperationException) { }
     184        try { optimizer.Prepare(clearRuns); } catch (InvalidOperationException) { }
    185185      }
    186186    }
    187187    public void Start() {
     188      Start(CancellationToken.None);
     189    }
     190    public void Start(CancellationToken cancellationToken) {
    188191      if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused))
    189192        throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState));
     
    192195      experimentStarted = true;
    193196      experimentStopped = false;
    194       IOptimizer optimizer = Optimizers.FirstOrDefault(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused));
    195       if (optimizer != null) {
     197      IOptimizer optimizer;
     198      while ((optimizer = Optimizers.FirstOrDefault(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused))) != null) {
    196199        // 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       }
     200        try { optimizer.Start(cancellationToken); } catch (InvalidOperationException) { }
     201        if (ExecutionState == ExecutionState.Paused || ExecutionState == ExecutionState.Stopped) break;
     202      }
     203    }
     204    public async Task StartAsync() { await StartAsync(CancellationToken.None); }
     205    public async Task StartAsync(CancellationToken cancellationToken) {
     206      await AsyncHelper.DoAsync(Start, cancellationToken);
    200207    }
    201208    public void Pause() {
     
    208215      foreach (IOptimizer optimizer in Optimizers.Where(x => x.ExecutionState == ExecutionState.Started)) {
    209216        // a race-condition may occur when the optimizer has changed the state by itself in the meantime
    210         try { optimizer.Pause(); }
    211         catch (InvalidOperationException) { }
     217        try { optimizer.Pause(); } catch (InvalidOperationException) { }
    212218      }
    213219    }
     
    222228        foreach (var optimizer in Optimizers.Where(x => (x.ExecutionState == ExecutionState.Started) || (x.ExecutionState == ExecutionState.Paused))) {
    223229          // a race-condition may occur when the optimizer has changed the state by itself in the meantime
    224           try { optimizer.Stop(); }
    225           catch (InvalidOperationException) { }
     230          try { optimizer.Stop(); } catch (InvalidOperationException) { }
    226231        }
    227232      } else {
     
    357362      try {
    358363        ExecutionTime = Optimizers.Aggregate(TimeSpan.Zero, (t, o) => t + o.ExecutionTime);
    359       }
    360       finally {
     364      } finally {
    361365        Monitor.Exit(locker);
    362366      }
     
    379383          if (Optimizers.All(x => (x.ExecutionState == ExecutionState.Stopped) || (x.ExecutionState == ExecutionState.Prepared))) OnStopped();
    380384        } else {
    381           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();
    383           } else if (Optimizers.All(x => x.ExecutionState == ExecutionState.Stopped)) OnStopped();
     385          if (experimentStarted && Optimizers.Any(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused))) return;
     386          else if (Optimizers.All(x => x.ExecutionState == ExecutionState.Stopped)) OnStopped();
    384387          else if (Optimizers.Any(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused)) && Optimizers.All(o => o.ExecutionState != ExecutionState.Started)) OnPaused();
    385388        }
  • stable/HeuristicLab.Optimization/3.3/MetaOptimizers/TimeLimitRun.cs

    r14186 r15292  
    2525using System.Drawing;
    2626using System.Linq;
     27using System.Threading;
    2728using System.Threading.Tasks;
    2829using HeuristicLab.Collections;
     
    238239    }
    239240    public void Start() {
    240       Algorithm.Start();
     241      Start(CancellationToken.None);
     242    }
     243    public void Start(CancellationToken cancellationToken) {
     244      Algorithm.Start(cancellationToken);
     245    }
     246    public async Task StartAsync() { await StartAsync(CancellationToken.None); }
     247    public async Task StartAsync(CancellationToken cancellationToken) {
     248      await AsyncHelper.DoAsync(Start, cancellationToken);
    241249    }
    242250    public void Pause() {
  • stable/HeuristicLab.Optimization/3.3/Problems/SingleObjectiveHeuristicOptimizationProblem.cs

Note: See TracChangeset for help on using the changeset viewer.