#region License Information
/* HeuristicLab
* Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
*
* This file is part of HeuristicLab.
*
* HeuristicLab is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* HeuristicLab is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with HeuristicLab. If not, see .
*/
#endregion
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using HeuristicLab.Collections;
using HeuristicLab.Common;
using HeuristicLab.Common.Resources;
using HeuristicLab.Core;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
namespace HeuristicLab.Optimization {
///
/// A run in which an algorithm is executed for a certain maximum time only.
///
[Item("Timelimit Run", "A run in which an optimizer is executed a certain maximum time.")]
[Creatable(CreatableAttribute.Categories.TestingAndAnalysis, Priority = 115)]
[StorableClass]
public sealed class TimeLimitRun : NamedItem, IOptimizer, IStorableContent, INotifyPropertyChanged {
public string Filename { get; set; }
#region ItemImage
public static new Image StaticItemImage {
get { return VSImageLibrary.Event; }
}
public override Image ItemImage {
get { return (Algorithm != null) ? Algorithm.ItemImage : VSImageLibrary.ExecutableStopped; }
}
#endregion
private bool pausedForSnapshot = false;
private bool pausedForTermination = false;
[Storable]
private TimeSpan maximumExecutionTime;
public TimeSpan MaximumExecutionTime {
get { return maximumExecutionTime; }
set {
if (maximumExecutionTime == value) return;
maximumExecutionTime = value;
OnPropertyChanged("MaximumExecutionTime");
}
}
[Storable]
private int snapshotTimesIndex;
[Storable]
private ObservableList snapshotTimes;
public ObservableList SnapshotTimes {
get { return snapshotTimes; }
set {
if (snapshotTimes == value) return;
snapshotTimes = value;
snapshotTimes.Sort();
FindNextSnapshotTimeIndex(ExecutionTime);
OnPropertyChanged("SnapshotTimes");
}
}
[Storable]
private bool storeAlgorithmInEachSnapshot;
[Storable]
public bool StoreAlgorithmInEachSnapshot {
get { return storeAlgorithmInEachSnapshot; }
set {
if (storeAlgorithmInEachSnapshot == value) return;
storeAlgorithmInEachSnapshot = value;
OnPropertyChanged("StoreAlgorithmInEachSnapshot");
}
}
[Storable]
private RunCollection snapshots;
public RunCollection Snapshots {
get { return snapshots; }
set {
if (snapshots == value) return;
snapshots = value;
OnPropertyChanged("Snapshots");
}
}
#region Inherited Properties
public ExecutionState ExecutionState {
get { return (Algorithm != null) ? Algorithm.ExecutionState : ExecutionState.Stopped; }
}
public TimeSpan ExecutionTime {
get { return (Algorithm != null) ? Algorithm.ExecutionTime : TimeSpan.FromSeconds(0); }
}
[Storable]
private IAlgorithm algorithm;
public IAlgorithm Algorithm {
get { return algorithm; }
set {
if (algorithm == value) return;
if (algorithm != null) DeregisterAlgorithmEvents();
algorithm = value;
if (algorithm != null) {
RegisterAlgorithmEvents();
}
OnPropertyChanged("Algorithm");
Prepare();
}
}
[Storable]
private RunCollection runs;
public RunCollection Runs {
get { return runs; }
private set {
if (value == null) throw new ArgumentNullException();
if (runs == value) return;
runs = value;
OnPropertyChanged("Runs");
}
}
public IEnumerable NestedOptimizers {
get {
if (Algorithm == null) yield break;
yield return Algorithm;
foreach (var opt in Algorithm.NestedOptimizers)
yield return opt;
}
}
#endregion
[StorableConstructor]
private TimeLimitRun(bool deserializing) : base(deserializing) { }
private TimeLimitRun(TimeLimitRun original, Cloner cloner)
: base(original, cloner) {
maximumExecutionTime = original.maximumExecutionTime;
snapshotTimes = new ObservableList(original.snapshotTimes);
snapshotTimesIndex = original.snapshotTimesIndex;
snapshots = cloner.Clone(original.snapshots);
storeAlgorithmInEachSnapshot = original.storeAlgorithmInEachSnapshot;
algorithm = cloner.Clone(original.algorithm);
runs = cloner.Clone(original.runs);
Initialize();
}
public TimeLimitRun()
: base() {
name = ItemName;
description = ItemDescription;
maximumExecutionTime = TimeSpan.FromMinutes(.5);
snapshotTimes = new ObservableList(new[] {
TimeSpan.FromSeconds(5),
TimeSpan.FromSeconds(10),
TimeSpan.FromSeconds(15) });
snapshotTimesIndex = 0;
snapshots = new RunCollection();
Runs = new RunCollection { OptimizerName = Name };
Initialize();
}
public TimeLimitRun(string name)
: base(name) {
description = ItemDescription;
maximumExecutionTime = TimeSpan.FromMinutes(.5);
snapshotTimes = new ObservableList(new[] {
TimeSpan.FromSeconds(5),
TimeSpan.FromSeconds(10),
TimeSpan.FromSeconds(15) });
snapshotTimesIndex = 0;
Runs = new RunCollection { OptimizerName = Name };
Initialize();
}
public TimeLimitRun(string name, string description)
: base(name, description) {
maximumExecutionTime = TimeSpan.FromMinutes(.5);
snapshotTimes = new ObservableList(new[] {
TimeSpan.FromSeconds(5),
TimeSpan.FromSeconds(10),
TimeSpan.FromSeconds(15) });
snapshotTimesIndex = 0;
Runs = new RunCollection { OptimizerName = Name };
Initialize();
}
public override IDeepCloneable Clone(Cloner cloner) {
if (ExecutionState == ExecutionState.Started) throw new InvalidOperationException(string.Format("Clone not allowed in execution state \"{0}\".", ExecutionState));
return new TimeLimitRun(this, cloner);
}
[StorableHook(HookType.AfterDeserialization)]
private void AfterDeserialization() {
Initialize();
}
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;
}
private void snapshotTimes_Changed(object sender, CollectionItemsChangedEventArgs> e) {
if (e.Items.Any()) snapshotTimes.Sort();
FindNextSnapshotTimeIndex(ExecutionTime);
}
public void Snapshot() {
if (Algorithm == null || Algorithm.ExecutionState != ExecutionState.Paused) throw new InvalidOperationException("Snapshot not allowed in execution states other than Paused");
Task.Factory.StartNew(MakeSnapshot);
}
public void Prepare() {
Prepare(false);
}
public void Prepare(bool clearRuns) {
Algorithm.Prepare(clearRuns);
}
public void 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() {
Algorithm.Pause();
}
public void Stop() {
Algorithm.Stop();
}
#region Events
protected override void OnNameChanged() {
base.OnNameChanged();
runs.OptimizerName = Name;
}
public event PropertyChangedEventHandler PropertyChanged;
private void OnPropertyChanged(string property) {
var handler = PropertyChanged;
if (handler != null) handler(this, new PropertyChangedEventArgs(property));
}
#region IExecutable Events
public event EventHandler ExecutionStateChanged;
private void OnExecutionStateChanged() {
var handler = ExecutionStateChanged;
if (handler != null) handler(this, EventArgs.Empty);
}
public event EventHandler ExecutionTimeChanged;
private void OnExecutionTimeChanged() {
var handler = ExecutionTimeChanged;
if (handler != null) handler(this, EventArgs.Empty);
}
public event EventHandler Prepared;
private void OnPrepared() {
var handler = Prepared;
if (handler != null) handler(this, EventArgs.Empty);
}
public event EventHandler Started;
private void OnStarted() {
var handler = Started;
if (handler != null) handler(this, EventArgs.Empty);
}
public event EventHandler Paused;
private void OnPaused() {
var handler = Paused;
if (handler != null) handler(this, EventArgs.Empty);
}
public event EventHandler Stopped;
private void OnStopped() {
var handler = Stopped;
if (handler != null) handler(this, EventArgs.Empty);
}
public event EventHandler> ExceptionOccurred;
private void OnExceptionOccurred(Exception exception) {
var handler = ExceptionOccurred;
if (handler != null) handler(this, new EventArgs(exception));
}
#endregion
#region Algorithm Events
private void RegisterAlgorithmEvents() {
algorithm.ExceptionOccurred += Algorithm_ExceptionOccurred;
algorithm.ExecutionTimeChanged += Algorithm_ExecutionTimeChanged;
algorithm.ExecutionStateChanged += Algorithm_ExecutionStateChanged;
algorithm.Paused += Algorithm_Paused;
algorithm.Prepared += Algorithm_Prepared;
algorithm.Started += Algorithm_Started;
algorithm.Stopped += Algorithm_Stopped;
}
private void DeregisterAlgorithmEvents() {
algorithm.ExceptionOccurred -= Algorithm_ExceptionOccurred;
algorithm.ExecutionTimeChanged -= Algorithm_ExecutionTimeChanged;
algorithm.ExecutionStateChanged -= Algorithm_ExecutionStateChanged;
algorithm.Paused -= Algorithm_Paused;
algorithm.Prepared -= Algorithm_Prepared;
algorithm.Started -= Algorithm_Started;
algorithm.Stopped -= Algorithm_Stopped;
}
private void Algorithm_ExceptionOccurred(object sender, EventArgs e) {
OnExceptionOccurred(e.Value);
}
private void Algorithm_ExecutionTimeChanged(object sender, EventArgs e) {
if (snapshotTimesIndex < SnapshotTimes.Count && ExecutionTime >= SnapshotTimes[snapshotTimesIndex]
&& !pausedForSnapshot) {
pausedForSnapshot = true;
Algorithm.Pause();
}
if (ExecutionTime >= MaximumExecutionTime && !pausedForTermination) {
pausedForTermination = true;
if (!pausedForSnapshot) Algorithm.Pause();
}
OnExecutionTimeChanged();
}
private void Algorithm_ExecutionStateChanged(object sender, EventArgs e) {
OnExecutionStateChanged();
}
private void Algorithm_Paused(object sender, EventArgs e) {
var action = pausedForTermination ? ExecutionState.Stopped : (pausedForSnapshot ? ExecutionState.Started : ExecutionState.Paused);
if (pausedForSnapshot || pausedForTermination) {
pausedForSnapshot = pausedForTermination = false;
MakeSnapshot();
FindNextSnapshotTimeIndex(ExecutionTime);
}
OnPaused();
if (action == ExecutionState.Started) Algorithm.Start();
else if (action == ExecutionState.Stopped) Algorithm.Stop();
}
private void Algorithm_Prepared(object sender, EventArgs e) {
snapshotTimesIndex = 0;
snapshots.Clear();
OnPrepared();
}
private void Algorithm_Started(object sender, EventArgs e) {
OnStarted();
}
private void Algorithm_Stopped(object sender, EventArgs e) {
var cloner = new Cloner();
var algRun = cloner.Clone(Algorithm.Runs.Last());
var clonedSnapshots = cloner.Clone(snapshots);
algRun.Results.Add("TimeLimitRunSnapshots", clonedSnapshots);
Runs.Add(algRun);
Algorithm.Runs.Clear();
OnStopped();
}
#endregion
#endregion
private void FindNextSnapshotTimeIndex(TimeSpan reference) {
var index = 0;
while (index < snapshotTimes.Count && snapshotTimes[index] <= reference) {
index++;
};
snapshotTimesIndex = index;
}
private void MakeSnapshot() {
string time = Math.Round(ExecutionTime.TotalSeconds, 1).ToString("0.0");
string runName = "Snapshot " + time + "s " + algorithm.Name;
var changed = false;
if (StoreAlgorithmInEachSnapshot && !Algorithm.StoreAlgorithmInEachRun) {
Algorithm.StoreAlgorithmInEachRun = true;
changed = true;
} else if (!StoreAlgorithmInEachSnapshot && Algorithm.StoreAlgorithmInEachRun) {
Algorithm.StoreAlgorithmInEachRun = false;
changed = true;
}
var run = new Run(runName, Algorithm);
if (changed)
Algorithm.StoreAlgorithmInEachRun = !Algorithm.StoreAlgorithmInEachRun;
snapshots.Add(run);
}
}
}