Changeset 8956

Timestamp:

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

Author:

abeham

Message:

#1985:

• Removed .resx file
• Fixed bugs

Location:

branches/RuntimeOptimizer

Files:

• HeuristicLab.Optimization.Views/3.3/HeuristicLab.Optimization.Views-3.3.csproj (modified) (1 diff)
• HeuristicLab.Optimization.Views/3.3/TimeLimitRunView.Designer.cs (modified) (7 diffs)
• HeuristicLab.Optimization.Views/3.3/TimeLimitRunView.cs (modified) (9 diffs)
• HeuristicLab.Optimization.Views/3.3/TimeLimitRunView.resx (deleted)
• HeuristicLab.Optimization/3.3/MetaOptimizers/TimeLimitRun.cs (modified) (18 diffs)

branches/RuntimeOptimizer/HeuristicLab.Optimization.Views/3.3/HeuristicLab.Optimization.Views-3.3.csproj

@@ -398 +398 @@
     </ProjectReference>
   </ItemGroup>
-  <ItemGroup>
-    <EmbeddedResource Include="TimeLimitRunView.resx">
-      <DependentUpon>TimeLimitRunView.cs</DependentUpon>
-    </EmbeddedResource>
-  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 

branches/RuntimeOptimizer/HeuristicLab.Optimization.Views/3.3/TimeLimitRunView.Designer.cs

@@ -50 +50 @@
       this.runsView = new HeuristicLab.Optimization.Views.RunCollectionView();
       this.openFileDialog = new System.Windows.Forms.OpenFileDialog();
+      this.snapshotButton = new System.Windows.Forms.Button();
       ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).BeginInit();
       this.tabControl.SuspendLayout();
@@ -109 +110 @@
       this.timeLimitTextBox.Size = new System.Drawing.Size(338, 20);
       this.timeLimitTextBox.TabIndex = 17;
-      this.timeLimitTextBox.Leave += new System.EventHandler(this.timeLimitTextBox_Leave);
       this.timeLimitTextBox.Validating += new System.ComponentModel.CancelEventHandler(this.timeLimitTextBox_Validating);
       // 
@@ -127 +127 @@
       this.snapShotsTextBox.Location = new System.Drawing.Point(69, 52);
       this.snapShotsTextBox.Name = "snapShotsTextBox";
-      this.snapShotsTextBox.Size = new System.Drawing.Size(148, 20);
+      this.snapShotsTextBox.Size = new System.Drawing.Size(142, 20);
       this.snapShotsTextBox.TabIndex = 17;
       // 
@@ -266 +266 @@
       this.openFileDialog.Title = "Open Optimizer";
       // 
+      // snapshotButton
+      // 
+      this.snapshotButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
+      this.snapshotButton.Location = new System.Drawing.Point(120, 440);
+      this.snapshotButton.Name = "snapshotButton";
+      this.snapshotButton.Size = new System.Drawing.Size(24, 24);
+      this.snapshotButton.TabIndex = 20;
+      this.snapshotButton.Text = "Snapshot";
+      this.snapshotButton.UseVisualStyleBackColor = true;
+      this.snapshotButton.Click += new System.EventHandler(this.snapshotButton_Click);
+      // 
       // TimeLimitRunView
       // 
-      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
+      this.Controls.Add(this.snapshotButton);
       this.Controls.Add(this.tabControl);
       this.Controls.Add(this.timeLimitTextBox);
@@ -283 +294 @@
       this.Controls.SetChildIndex(this.timeLimitLabel, 0);
       this.Controls.SetChildIndex(this.timeLimitTextBox, 0);
+      this.Controls.SetChildIndex(this.tabControl, 0);
       this.Controls.SetChildIndex(this.nameLabel, 0);
       this.Controls.SetChildIndex(this.nameTextBox, 0);
@@ -292 +304 @@
       this.Controls.SetChildIndex(this.executionTimeTextBox, 0);
       this.Controls.SetChildIndex(this.startButton, 0);
-      this.Controls.SetChildIndex(this.tabControl, 0);
+      this.Controls.SetChildIndex(this.snapshotButton, 0);
       ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).EndInit();
       this.tabControl.ResumeLayout(false);
@@ -320 +332 @@
     private RunCollectionView runsView;
     private System.Windows.Forms.OpenFileDialog openFileDialog;
+    private System.Windows.Forms.Button snapshotButton;
   }
 }

branches/RuntimeOptimizer/HeuristicLab.Optimization.Views/3.3/TimeLimitRunView.cs

@@ -25 +25 @@
 using System.Windows.Forms;
 using HeuristicLab.Common;
+using HeuristicLab.Common.Resources;
 using HeuristicLab.Core;
 using HeuristicLab.Core.Views;
@@ -45 +46 @@
     public TimeLimitRunView() {
       InitializeComponent();
+      snapshotButton.Text = String.Empty;
+      snapshotButton.Image = VSImageLibrary.Breakpoint;
     }
 
@@ -69 +72 @@
       try {
         if (Content == null) {
-          timeLimitTextBox.Tag = TimeSpan.FromSeconds(60);
-          timeLimitTextBox.Text = FormatTimeSpan((TimeSpan)timeLimitTextBox.Tag);
+          timeLimitTextBox.Text = FormatTimeSpan(TimeSpan.FromSeconds(60));
           snapShotsTextBox.Text = String.Empty;
           storeAlgorithmInEachSnapshotCheckBox.Checked = false;
@@ -77 +79 @@
           runsView.Content = null;
         } else {
-          timeLimitTextBox.Tag = Content.MaximumExecutionTime;
           timeLimitTextBox.Text = FormatTimeSpan(Content.MaximumExecutionTime);
           snapShotsTextBox.Text = String.Join(" ; ", Content.SnapshotTimes);
@@ -87 +88 @@
       } finally { SuppressEvents = false; }
     }
+
     protected override void SetEnabledStateOfControls() {
       base.SetEnabledStateOfControls();
@@ -99 +101 @@
     }
 
+    protected override void SetEnabledStateOfExecutableButtons() {
+      base.SetEnabledStateOfExecutableButtons();
+      snapshotButton.Enabled = Content != null && (Content.ExecutionState == ExecutionState.Started || Content.ExecutionState == ExecutionState.Paused);
+    }
+
     protected override void OnClosed(FormClosedEventArgs e) {
       if ((Content != null) && (Content.ExecutionState == ExecutionState.Started)) {
@@ -151 +158 @@
 
     #region Control events
-    private void timeLimitTextBox_Leave(object sender, EventArgs e) {
-      if (SuppressEvents) return;
-      SuppressEvents = true;
-      try {
-        timeLimitTextBox.Text = FormatTimeSpan((TimeSpan)timeLimitTextBox.Tag);
-      } finally { SuppressEvents = false; }
-    }
-
     private void timeLimitTextBox_Validating(object sender, CancelEventArgs e) {
       if (SuppressEvents) return;
@@ -179 +178 @@
           ts = GetTimeSpanFromFormat(value, text.Substring(length - 1, text.Length - (length - 1)).TrimStart());
         } else ts = TimeSpan.FromSeconds(value);
-        timeLimitTextBox.Tag = ts;
+        Content.MaximumExecutionTime = ts;
         e.Cancel = false;
         errorProvider.SetError(timeLimitTextBox, String.Empty);
@@ -252 +251 @@
       }
     }
+
+    private void snapshotButton_Click(object sender, EventArgs e) {
+      Content.Snapshot();
+    }
     #endregion
     #endregion

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();
     }