Changeset 6495 for trunk

Timestamp:

06/28/11 23:29:26 (13 years ago)

Author:

cneumuel

Message:

#1569 checked in test-case

Location:

trunk/sources/HeuristicLab/3.3/Tests

Files:

• AlgorithmExtensions.cs (modified) (2 diffs)
• CollectObjectGraphTest.cs (modified) (4 diffs)

trunk/sources/HeuristicLab/3.3/Tests/AlgorithmExtensions.cs

@@ -22 +22 @@
 using System;
 using System.Threading;
+using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Optimization;
 
 namespace HeuristicLab_33.Tests {
   public static class AlgorithmExtensions {
-    public static void StartSync(this IAlgorithm algorithm, CancellationToken cancellationToken) {
-      var executor = new AlgorithmExecutor(algorithm, cancellationToken);
+    public static void StartSync(this IExecutable executable, CancellationToken cancellationToken) {
+      var executor = new AlgorithmExecutor(executable, cancellationToken);
       executor.StartSync();
     }
@@ -37 +37 @@
   /// </summary>
   internal class AlgorithmExecutor {
-    private IAlgorithm algorithm;
+    private IExecutable executable;
     private AutoResetEvent waitHandle = new AutoResetEvent(false);
     private CancellationToken cancellationToken;
+    private Exception occuredException;
 
-    public AlgorithmExecutor(IAlgorithm algorithm, CancellationToken cancellationToken) {
-      this.algorithm = algorithm;
+    public AlgorithmExecutor(IExecutable executable, CancellationToken cancellationToken) {
+      this.executable = executable;
       this.cancellationToken = cancellationToken;
+      this.occuredException = null;
     }
 
     public void StartSync() {
-      algorithm.Stopped += new EventHandler(algorithm_Stopped);
-      algorithm.Paused += new EventHandler(algorithm_Paused);
+      executable.Stopped += new EventHandler(executable_Stopped);
+      executable.Paused += new EventHandler(executable_Paused);
+      executable.ExceptionOccurred += new EventHandler<EventArgs<Exception>>(executable_ExceptionOccurred);
 
       using (CancellationTokenRegistration registration = cancellationToken.Register(new Action(cancellationToken_Canceled))) {
-        algorithm.Start();
-        waitHandle.WaitOne();
+        executable.Start();
+        waitHandle.WaitOne(-1, false);
         waitHandle.Dispose();
       }
 
-      algorithm.Stopped -= new EventHandler(algorithm_Stopped);
-      algorithm.Paused -= new EventHandler(algorithm_Paused);
-      if (algorithm.ExecutionState == ExecutionState.Started) {
-        algorithm.Pause();
+      executable.Stopped -= new EventHandler(executable_Stopped);
+      executable.Paused -= new EventHandler(executable_Paused);
+      if (executable.ExecutionState == ExecutionState.Started) {
+        executable.Pause();
       }
       cancellationToken.ThrowIfCancellationRequested();
+      if (occuredException != null) throw occuredException;
     }
 
-    private void algorithm_Paused(object sender, EventArgs e) {
+    private void executable_Paused(object sender, EventArgs e) {
       waitHandle.Set();
     }
 
-    private void algorithm_Stopped(object sender, EventArgs e) {
+    private void executable_Stopped(object sender, EventArgs e) {
       waitHandle.Set();
+    }
+
+    private void executable_ExceptionOccurred(object sender, EventArgs<Exception> e) {
+      occuredException = e.Value; // after an exception occured the executable pauses
     }
 

trunk/sources/HeuristicLab/3.3/Tests/CollectObjectGraphTest.cs

@@ -25 +25 @@
 using System.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using HeuristicLab.Algorithms.GeneticAlgorithm;
 using HeuristicLab.Common;
@@ -30 +31 @@
 using HeuristicLab.Persistence.Default.Xml;
 using HeuristicLab.Problems.TestFunctions;
-using HeuristicLab.Random;
 using HeuristicLab.SequentialEngine;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -96 +96 @@
     [TestMethod]
     public void AlgorithmExecutions() {
-      var random = new MersenneTwister(0);
       var algs = new List<IAlgorithm>();
 
@@ -117 +116 @@
       }
     }
+
+    /// <summary>
+    /// Test the execution of many algorithms in parallel
+    /// </summary>
+    [TestMethod]
+    public void ParallelAlgorithmExecutions() {
+      int n = 60;
+      var tasks = new Task[n];
+
+      TestContext.WriteLine("creating tasks...");
+      for (int i = 0; i < n; i++) {
+        tasks[i] = new Task((iobj) => {
+          int locali = (int)iobj;
+          GeneticAlgorithm ga = new GeneticAlgorithm();
+          ga.Name = "Alg " + locali;
+          ga.PopulationSize.Value = 5;
+          ga.MaximumGenerations.Value = 5;
+          ga.Engine = new SequentialEngine();
+          ga.Problem = new SingleObjectiveTestFunctionProblem();
+          ga.Prepare(true);
+          Console.WriteLine("{0}; Objects before execution: {1}", ga.Name, ga.GetObjectGraphObjects().Count());
+          var sw = new Stopwatch();
+          sw.Start();
+          ga.StartSync(new CancellationToken());
+          sw.Stop();
+          Console.WriteLine("{0}; Objects after execution: {1}", ga.Name, ga.GetObjectGraphObjects().Count());
+          Console.WriteLine("{0}; ExecutionTime: {1} ", ga.Name, sw.Elapsed);
+        }, i);
+      }
+      TestContext.WriteLine("starting tasks...");
+      for (int i = 0; i < n; i++) {
+        tasks[i].Start();
+      }
+      TestContext.WriteLine("waiting for tasks to finish...");
+      Task.WaitAll(tasks);
+    }
   }
 }