Index: /branches/PerformanceComparison/HeuristicLab.Optimization.Views/3.3/IOptimizerView.cs
===================================================================
--- /branches/PerformanceComparison/HeuristicLab.Optimization.Views/3.3/IOptimizerView.cs	(revision 15329)
+++ /branches/PerformanceComparison/HeuristicLab.Optimization.Views/3.3/IOptimizerView.cs	(revision 15330)
@@ -137,5 +137,5 @@
     #region Control events
     protected virtual void startButton_Click(object sender, EventArgs e) {
-      Content.Start();
+      Content.StartAsync();
     }
     protected virtual void pauseButton_Click(object sender, EventArgs e) {
Index: /branches/PerformanceComparison/HeuristicLab.Optimization.Views/3.3/ResultCollectionView.cs
===================================================================
--- /branches/PerformanceComparison/HeuristicLab.Optimization.Views/3.3/ResultCollectionView.cs	(revision 15329)
+++ /branches/PerformanceComparison/HeuristicLab.Optimization.Views/3.3/ResultCollectionView.cs	(revision 15330)
@@ -21,4 +21,5 @@
 
 using System;
+using System.Windows.Forms;
 using HeuristicLab.Core;
 using HeuristicLab.Core.Views;
@@ -58,4 +59,14 @@
       }
     }
+
+    protected override void Item_ToStringChanged(object sender, EventArgs e) {
+      if (InvokeRequired) {
+        Invoke(new EventHandler(Item_ToStringChanged), sender, e);
+        return;
+      }
+
+      base.Item_ToStringChanged(sender, e);
+      Application.DoEvents();
+    }
   }
 }
Index: /branches/PerformanceComparison/HeuristicLab.Optimization/3.3/Algorithms/Algorithm.cs
===================================================================
--- /branches/PerformanceComparison/HeuristicLab.Optimization/3.3/Algorithms/Algorithm.cs	(revision 15329)
+++ /branches/PerformanceComparison/HeuristicLab.Optimization/3.3/Algorithms/Algorithm.cs	(revision 15330)
@@ -24,4 +24,6 @@
 using System.Drawing;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using HeuristicLab.Collections;
 using HeuristicLab.Common;
@@ -203,6 +205,13 @@
     }
     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 AsyncHelper.DoAsync(Start, cancellationToken);
     }
     public virtual void Pause() {
Index: /branches/PerformanceComparison/HeuristicLab.Optimization/3.3/Algorithms/BasicAlgorithm.cs
===================================================================
--- /branches/PerformanceComparison/HeuristicLab.Optimization/3.3/Algorithms/BasicAlgorithm.cs	(revision 15329)
+++ /branches/PerformanceComparison/HeuristicLab.Optimization/3.3/Algorithms/BasicAlgorithm.cs	(revision 15330)
@@ -21,6 +21,6 @@
 
 using System;
+using System.Linq;
 using System.Threading;
-using System.Threading.Tasks;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -57,4 +57,5 @@
       : base(original, cloner) {
       results = cloner.Clone(original.Results);
+      initialized = original.initialized;
     }
     protected BasicAlgorithm()
@@ -71,29 +72,26 @@
     }
 
-    public override void Start() {
-      base.Start();
-      CancellationTokenSource = new CancellationTokenSource();
+    public override void Start(CancellationToken cancellationToken) {
+      base.Start(cancellationToken);
+      CancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
       pausePending = false;
       OnStarted();
 
-      Task task = Task.Factory.StartNew(Run, CancellationTokenSource.Token, CancellationTokenSource.Token);
-      task.ContinueWith(t => {
-        try {
-          t.Wait();
-        }
-        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;
-        if (pausePending) OnPaused();
-        else OnStopped();
-      });
+      try {
+        Run((object)cancellationTokenSource.Token);
+      }
+      catch (OperationCanceledException) {
+      }
+      catch (AggregateException ae) {
+        OnExceptionOccurred(ae.InnerExceptions.SingleOrDefault() ?? ae);
+      }
+      catch (Exception e) {
+        OnExceptionOccurred(e);
+      }
+
+      CancellationTokenSource.Dispose();
+      CancellationTokenSource = null;
+      if (pausePending) OnPaused();
+      else OnStopped();
     }
 
Index: /branches/PerformanceComparison/HeuristicLab.Optimization/3.3/Algorithms/EngineAlgorithm.cs
===================================================================
--- /branches/PerformanceComparison/HeuristicLab.Optimization/3.3/Algorithms/EngineAlgorithm.cs	(revision 15329)
+++ /branches/PerformanceComparison/HeuristicLab.Optimization/3.3/Algorithms/EngineAlgorithm.cs	(revision 15330)
@@ -169,7 +169,7 @@
       }
     }
-    public override void Start() {
-      base.Start();
-      if (engine != null) engine.Start();
+    public override void Start(System.Threading.CancellationToken cancellationToken) {
+      base.Start(cancellationToken);
+      if (engine != null) engine.Start(cancellationToken);
     }
     public override void Pause() {
Index: /branches/PerformanceComparison/HeuristicLab.Optimization/3.3/MetaOptimizers/BatchRun.cs
===================================================================
--- /branches/PerformanceComparison/HeuristicLab.Optimization/3.3/MetaOptimizers/BatchRun.cs	(revision 15329)
+++ /branches/PerformanceComparison/HeuristicLab.Optimization/3.3/MetaOptimizers/BatchRun.cs	(revision 15330)
@@ -23,4 +23,6 @@
 using System.Collections.Generic;
 using System.Drawing;
+using System.Threading;
+using System.Threading.Tasks;
 using HeuristicLab.Collections;
 using HeuristicLab.Common;
@@ -237,6 +239,5 @@
         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;
@@ -244,4 +245,7 @@
     }
     public void Start() {
+      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));
@@ -249,7 +253,14 @@
       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 { Optimizer.Start(); }
-      catch (InvalidOperationException) { }
+      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) {
+      await AsyncHelper.DoAsync(Start, cancellationToken);
     }
     public void Pause() {
@@ -260,6 +271,5 @@
       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() {
@@ -273,6 +283,5 @@
       }
       // 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) { }
     }
 
@@ -395,8 +404,6 @@
       else if (repetitionsCounter >= repetitions) OnStopped();
       else if (batchRunAction == BatchRunAction.Pause) OnPaused();
-      else if (batchRunAction == BatchRunAction.Start) {
-        Optimizer.Prepare();
-        Optimizer.Start();
-      } 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();
Index: /branches/PerformanceComparison/HeuristicLab.Optimization/3.3/MetaOptimizers/Experiment.cs
===================================================================
--- /branches/PerformanceComparison/HeuristicLab.Optimization/3.3/MetaOptimizers/Experiment.cs	(revision 15329)
+++ /branches/PerformanceComparison/HeuristicLab.Optimization/3.3/MetaOptimizers/Experiment.cs	(revision 15330)
@@ -25,4 +25,5 @@
 using System.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using HeuristicLab.Collections;
 using HeuristicLab.Common;
@@ -110,4 +111,5 @@
     private bool experimentStarted = false;
     private bool experimentStopped = false;
+    private ManualResetEventSlim allOptimizerFinished; // this indicates that all started optimizers have been paused or stopped
 
     public Experiment()
@@ -181,9 +183,11 @@
       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() {
+      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));
@@ -192,10 +196,18 @@
       experimentStarted = true;
       experimentStopped = false;
-      IOptimizer optimizer = Optimizers.FirstOrDefault(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused));
-      if (optimizer != null) {
+      allOptimizerFinished = new ManualResetEventSlim(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(); }
-        catch (InvalidOperationException) { }
-      }
+        try { optimizer.Start(cancellationToken); } catch (InvalidOperationException) { }
+        if (ExecutionState == ExecutionState.Paused || ExecutionState == ExecutionState.Stopped) break;
+      }
+
+      allOptimizerFinished.Wait();
+    }
+    public async Task StartAsync() { await StartAsync(CancellationToken.None); }
+    public async Task StartAsync(CancellationToken cancellationToken) {
+      await AsyncHelper.DoAsync(Start, cancellationToken);
     }
     public void Pause() {
@@ -208,6 +220,5 @@
       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) { }
       }
     }
@@ -222,6 +233,5 @@
         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 {
@@ -357,6 +367,5 @@
       try {
         ExecutionTime = Optimizers.Aggregate(TimeSpan.Zero, (t, o) => t + o.ExecutionTime);
-      }
-      finally {
+      } finally {
         Monitor.Exit(locker);
       }
@@ -364,5 +373,8 @@
     private void optimizer_Paused(object sender, EventArgs e) {
       lock (locker)
-        if (Optimizers.All(x => x.ExecutionState != ExecutionState.Started)) OnPaused();
+        if (Optimizers.All(x => x.ExecutionState != ExecutionState.Started)) {
+          OnPaused();
+          allOptimizerFinished.Set();
+        }
     }
     private void optimizer_Prepared(object sender, EventArgs e) {
@@ -377,10 +389,17 @@
       lock (locker) {
         if (experimentStopped) {
-          if (Optimizers.All(x => (x.ExecutionState == ExecutionState.Stopped) || (x.ExecutionState == ExecutionState.Prepared))) OnStopped();
+          if (Optimizers.All(x => (x.ExecutionState == ExecutionState.Stopped) || (x.ExecutionState == ExecutionState.Prepared))) {
+            OnStopped();
+            allOptimizerFinished.Set();
+          }
         } 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)).Start();
-          } 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();
+          if (experimentStarted && Optimizers.Any(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused))) return;
+          else if (Optimizers.All(x => x.ExecutionState == ExecutionState.Stopped)) {
+            OnStopped();
+            allOptimizerFinished.Set();
+          } else if (Optimizers.Any(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused)) && Optimizers.All(o => o.ExecutionState != ExecutionState.Started)) {
+            OnPaused();
+            allOptimizerFinished.Set();
+          }
         }
       }
Index: /branches/PerformanceComparison/HeuristicLab.Optimization/3.3/MetaOptimizers/TimeLimitRun.cs
===================================================================
--- /branches/PerformanceComparison/HeuristicLab.Optimization/3.3/MetaOptimizers/TimeLimitRun.cs	(revision 15329)
+++ /branches/PerformanceComparison/HeuristicLab.Optimization/3.3/MetaOptimizers/TimeLimitRun.cs	(revision 15330)
@@ -25,4 +25,5 @@
 using System.Drawing;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using HeuristicLab.Collections;
@@ -238,5 +239,12 @@
     }
     public void Start() {
-      Algorithm.Start();
+      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) {
+      await AsyncHelper.DoAsync(Start, cancellationToken);
     }
     public void Pause() {
