Changeset 8956 for branches/RuntimeOptimizer/HeuristicLab.Optimization/3.3

Timestamp:

11/28/12 01:59:10 (12 years ago)

Author:

abeham

Message:

#1985:

• Removed .resx file
• Fixed bugs

File:

• branches/RuntimeOptimizer/HeuristicLab.Optimization/3.3/MetaOptimizers/TimeLimitRun.cs (modified) (18 diffs)

branches/RuntimeOptimizer/HeuristicLab.Optimization/3.3/MetaOptimizers/TimeLimitRun.cs

@@ -26 +26 @@
 using System.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using System.Timers;
 using HeuristicLab.Collections;
@@ -55 +56 @@
     #endregion
 
-    private readonly Timer snapTimer;
-    private readonly Timer runTimer;
+    private Timer snapTimer, runTimer;
+    private readonly ManualResetEvent algorithmStarted = new ManualResetEvent(false);
     private readonly ManualResetEvent algorithmPaused = new ManualResetEvent(false);
     private readonly ManualResetEvent algorithmStopped = new ManualResetEvent(false);
+    [Storable]
+    private bool snapshotTimesDirty;
 
     [Storable]
@@ -81 +84 @@
         if (snapshotTimes == value) return;
         snapshotTimes = value;
-        snapshotTimesIndex = 0;
+        snapshotTimesDirty = true;
         OnPropertyChanged("SnapshotTimes");
       }
@@ -124 +127 @@
       set {
         if (algorithm == value) return;
-        if (algorithm != null) {
-          DeregisterAlgorithmEvents();
-          var runs = algorithm.Runs;
-          algorithm = null; //necessary to avoid removing the runs from the old algorithm
-          Runs.RemoveRange(runs);
-        }
+        if (algorithm != null) DeregisterAlgorithmEvents();
         algorithm = value;
         if (algorithm != null) {
           RegisterAlgorithmEvents();
-          Runs.AddRange(algorithm.Runs);
+          if (algorithm.ExecutionState == ExecutionState.Started) algorithmStarted.Set();
+          else algorithmStarted.Reset();
           if (algorithm.ExecutionState == ExecutionState.Paused) algorithmPaused.Set();
           else algorithmPaused.Reset();
@@ -167 +166 @@
 
     [StorableConstructor]
-    private TimeLimitRun(bool deserializing)
-      : base(deserializing) {
-      // the timer will not be serialized
-      snapTimer = new Timer() {
-        AutoReset = false,
-        Enabled = false,
-        Interval = double.MaxValue
-      };
-      runTimer = new Timer() {
-        AutoReset = false,
-        Enabled = false,
-        Interval = double.MaxValue
-      };
-    }
+    private TimeLimitRun(bool deserializing) : base(deserializing) { }
     private TimeLimitRun(TimeLimitRun original, Cloner cloner)
       : base(original, cloner) {
@@ -186 +172 @@
       snapshotTimes = new ObservableList<double>(original.snapshotTimes);
       snapshotTimesIndex = original.snapshotTimesIndex;
-      snapTimer = new Timer() {
-        AutoReset = original.snapTimer.AutoReset,
-        Enabled = original.snapTimer.Enabled,
-        Interval = original.snapTimer.Interval
-      };
-      runTimer = new Timer() {
-        AutoReset = original.runTimer.AutoReset,
-        Enabled = original.runTimer.Enabled,
-        Interval = original.runTimer.Interval
-      };
       snapshots = cloner.Clone(original.snapshots);
+      snapshotTimesDirty = original.snapshotTimesDirty;
       storeAlgorithmInEachSnapshot = original.storeAlgorithmInEachSnapshot;
       algorithm = cloner.Clone(original.algorithm);
       runs = cloner.Clone(original.runs);
+
+      snapTimer = new Timer() {
+        AutoReset = original.snapTimer.AutoReset,
+        Interval = original.snapTimer.Interval
+      };
+      runTimer = new Timer() {
+        AutoReset = original.runTimer.AutoReset,
+        Interval = original.runTimer.Interval
+      };
+      if (original.algorithm != null && original.algorithm.ExecutionState == ExecutionState.Started)
+        algorithmStarted.Set();
+      if (original.algorithm != null && original.algorithm.ExecutionState == ExecutionState.Paused)
+        algorithmPaused.Set();
+      if (original.algorithm != null && original.algorithm.ExecutionState == ExecutionState.Stopped)
+        algorithmStopped.Set();
+
       Initialize();
     }
@@ -215 +208 @@
         AutoReset = false,
         Enabled = false,
-        Interval = snapshotTimes[snapshotTimesIndex]
+        Interval = 100
       };
       runTimer = new Timer() {
@@ -224 +217 @@
       snapshots = new RunCollection();
       Runs = new RunCollection { AlgorithmName = Name };
+      Initialize();
     }
     public TimeLimitRun(string name)
@@ -237 +231 @@
         AutoReset = false,
         Enabled = false,
-        Interval = snapshotTimes[snapshotTimesIndex]
+        Interval = 100
       };
       snapshots = new RunCollection();
@@ -246 +240 @@
       };
       Runs = new RunCollection { AlgorithmName = Name };
+      Initialize();
     }
     public TimeLimitRun(string name, string description)
@@ -258 +253 @@
         AutoReset = false,
         Enabled = false,
-        Interval = snapshotTimes[snapshotTimesIndex]
+        Interval = 100
       };
       snapshots = new RunCollection();
@@ -267 +262 @@
       };
       Runs = new RunCollection { AlgorithmName = Name };
+      Initialize();
     }
 
@@ -276 +272 @@
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
+      // the timers will not be serialized
+      snapTimer = new Timer() {
+        AutoReset = false,
+        Enabled = false,
+        Interval = 100
+      };
+      runTimer = new Timer() {
+        AutoReset = false,
+        Enabled = false,
+        Interval = double.MaxValue
+      };
+      if (Algorithm != null && Algorithm.ExecutionState == ExecutionState.Started)
+        algorithmStarted.Set();
+      else algorithmStarted.Reset();
+      if (Algorithm != null && Algorithm.ExecutionState == ExecutionState.Paused)
+        algorithmPaused.Set();
+      else algorithmPaused.Reset();
+      if (Algorithm != null && Algorithm.ExecutionState == ExecutionState.Stopped)
+        algorithmStopped.Set();
+      else algorithmStopped.Reset();
       Initialize();
     }
@@ -281 +297 @@
     private void Initialize() {
       if (algorithm != null) RegisterAlgorithmEvents();
+      snapshotTimes.ItemsAdded += snapshotTimes_Changed;
+      snapshotTimes.ItemsMoved += snapshotTimes_Changed;
+      snapshotTimes.ItemsRemoved += snapshotTimes_Changed;
+      snapshotTimes.ItemsReplaced += snapshotTimes_Changed;
+      snapshotTimes.CollectionReset += snapshotTimes_Changed;
       snapTimer.Elapsed += snapshotTimer_Elapsed;
       runTimer.Elapsed += runTimer_Elapsed;
     }
 
-    private readonly object timerLock = new object();
+    private void snapshotTimes_Changed(object sender, EventArgs e) {
+      snapshotTimesDirty = true;
+    }
+
+    private readonly object snapshotLock = new object();
     private void snapshotTimer_Elapsed(object sender, ElapsedEventArgs e) {
-      lock (timerLock) {
-        runTimer.Stop();
-        if (Algorithm == null) return;
-        if (ExecutionState != ExecutionState.Started) return;
+      snapTimer.Stop();
+      lock (snapshotLock) {
+        try {
+          if (Algorithm == null) return;
+          if (ExecutionState != ExecutionState.Started) return;
+
+          var execTime = ExecutionTime;
+          if (snapshotTimesIndex < SnapshotTimes.Count &&
+              SnapshotTimes[snapshotTimesIndex] <= execTime.TotalMilliseconds) {
+            DoSnapshot();
+            snapshotTimesIndex++;
+            try {
+              Algorithm.Start();
+              algorithmStarted.WaitOne();
+            } catch (InvalidOperationException) { }
+          }
+        } catch { }
+        snapTimer.Start();
+      }
+    }
+
+    private void runTimer_Elapsed(object sender, ElapsedEventArgs e) {
+      snapTimer.Stop();
+      lock (snapshotLock) {
+        try {
+          Algorithm.Stop();
+          algorithmStopped.WaitOne();
+        } catch (InvalidOperationException) { }
+      }
+    }
+
+    private void FindNextSnapshotTimeIndex(TimeSpan reference) {
+      var index = 0;
+      while (index < snapshotTimes.Count && (snapshotTimes[index] - reference.TotalMilliseconds) <= 0) {
+        index++;
+      };
+      snapshotTimesIndex = index;
+    }
+
+    private void DoSnapshot() {
+      lock (snapshotLock) {
+        var wasPaused = Algorithm.ExecutionState == ExecutionState.Paused;
         var error = false;
-        try { Algorithm.Pause(); } catch (InvalidOperationException) { error = true; }
+        try {
+          Algorithm.Pause();
+          algorithmPaused.WaitOne();
+        } catch (InvalidOperationException) {
+          error = true;
+        }
         if (error && ExecutionState != ExecutionState.Paused) return; // Algorithm is either stopped or prepared
 
-        algorithmPaused.WaitOne();
         MakeSnapshot();
-        try { Algorithm.Start(); } catch (InvalidOperationException) { }
-      }
-    }
-
-    private void runTimer_Elapsed(object sender, ElapsedEventArgs e) {
-      lock (timerLock) {
-        runTimer.Stop();
-        snapTimer.Stop();
-        try { Algorithm.Stop(); } catch (InvalidOperationException) { }
-      }
-    }
-
-    private double? GetNextInterval(TimeSpan reference) {
-      double interval;
-      while ((interval = snapshotTimes[snapshotTimesIndex] - reference.TotalMilliseconds) <= 0) {
-        snapshotTimesIndex++;
-        if (snapshotTimesIndex >= snapshotTimes.Count) return null;
-      };
-      return interval;
+        if (!wasPaused) {
+          try {
+            Algorithm.Start();
+            algorithmStarted.WaitOne();
+          } catch (InvalidOperationException) { }
+        }
+      }
     }
 
     private void MakeSnapshot() {
-      string runName = ExecutionTime.ToString() + " " + algorithm.Name + " Snapshot";
+      string time = Math.Round(ExecutionTime.TotalSeconds, 1).ToString("0.0");
+      string runName = "Snapshot " + time + "s " + algorithm.Name;
       Run run;
       if (StoreAlgorithmInEachSnapshot) {
-        run = new Run(runName, algorithm);
+        var temporarilySetStoreFlag = !Algorithm.StoreAlgorithmInEachRun;
+        if (temporarilySetStoreFlag) Algorithm.StoreAlgorithmInEachRun = true;
+        run = new Run(runName, Algorithm);
+        if (temporarilySetStoreFlag) Algorithm.StoreAlgorithmInEachRun = false;
       } else {
         // duplicate code of Run.Initialize - necessary, because Algorithm property doesn't have a setter
@@ -339 +398 @@
     }
 
+    public void Snapshot() {
+      Task.Factory.StartNew(DoSnapshot);
+    }
+
     public void Prepare() {
       Prepare(false);
@@ -434 +497 @@
     }
     private void Algorithm_Paused(object sender, EventArgs e) {
+      algorithmStarted.Reset();
       algorithmPaused.Set();
       algorithmStopped.Reset();
@@ -439 +503 @@
     }
     private void Algorithm_Prepared(object sender, EventArgs e) {
+      algorithmStarted.Reset();
       algorithmPaused.Reset();
       algorithmStopped.Reset();
@@ -448 +513 @@
     }
     private void Algorithm_Started(object sender, EventArgs e) {
+      algorithmStarted.Set();
       algorithmPaused.Reset();
       algorithmStopped.Reset();
       var execTime = ExecutionTime;
-      var interval = GetNextInterval(execTime);
-      if (interval.HasValue) {
-        snapTimer.Interval = interval.Value;
-        snapTimer.Start();
+      if (snapshotTimesDirty) {
+        SnapshotTimes.Sort();
+        snapshotTimesDirty = false; // sort will mark it dirty again
+        FindNextSnapshotTimeIndex(execTime);
       }
       runTimer.Interval = (MaximumExecutionTime - execTime).TotalMilliseconds;
+      snapTimer.Start();
       runTimer.Start();
       OnStarted();
     }
     private void Algorithm_Stopped(object sender, EventArgs e) {
+      algorithmStarted.Reset();
       algorithmPaused.Reset();
       algorithmStopped.Set();
-      snapTimer.Stop();
-      runTimer.Stop();
-      MakeSnapshot();
-      var snapshotsRun = new Run() { Name = algorithm.Runs.Last().Name };
-      foreach (var s in snapshots)
-        snapshotsRun.Parameters.Add(s.Name, s);
-      Runs.Add(snapshotsRun);
+      lock (snapshotLock) {
+        snapTimer.Stop();
+        runTimer.Stop();
+        MakeSnapshot();
+      }
+      var cloner = new Cloner();
+      var algRun = cloner.Clone(Algorithm.Runs.Last());
+      var clonedSnapshots = cloner.Clone(snapshots);
+      try {
+        algRun.Results.Add("Snapshots", clonedSnapshots);
+      } catch (ArgumentException ex) {
+        // TODO strategy?
+      }
+      Runs.Add(algRun);
+      Algorithm.Runs.Clear();
       OnStopped();
     }