Changeset 13005

Timestamp:

10/15/15 12:18:42 (9 years ago)

Author:

ascheibe

Message:

#2377 applied and improved bburlacus patch

Location:

trunk/sources

Files:

• HeuristicLab.Analysis/3.3/PopulationSimilarityAnalysis/PopulationSimilarityAnalyzer.cs (modified) (5 diffs)
• HeuristicLab.Optimization.Operators/3.3/SolutionSimilarityCalculator.cs (modified) (4 diffs)
• HeuristicLab.Optimization/3.3/Interfaces/ISolutionSimilarityCalculator.cs (modified) (1 diff)

trunk/sources/HeuristicLab.Analysis/3.3/PopulationSimilarityAnalysis/PopulationSimilarityAnalyzer.cs

@@ -39 +39 @@
   public class PopulationSimilarityAnalyzer : SingleSuccessorOperator, IAnalyzer, ISimilarityBasedOperator {
     private const string DiversityResultNameParameterName = "DiversityResultsName";
+    private const string ExecuteInParallelParameterName = "ExecuteInParallel";
+    private const string MaxDegreeOfParallelismParameterName = "MaxDegreeOfParallelism";
 
     #region Backwards compatible code, remove with 3.4
@@ -71 +73 @@
       get { return (FixedValueParameter<StringValue>)Parameters[DiversityResultNameParameterName]; }
     }
+    public IFixedValueParameter<BoolValue> ExecuteInParallelParameter {
+      get { return (IFixedValueParameter<BoolValue>)Parameters[ExecuteInParallelParameterName]; }
+    }
+    public IFixedValueParameter<IntValue> MaxDegreeOfParallelismParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[MaxDegreeOfParallelismParameterName]; }
+    }
 
     public string DiversityResultName {
@@ -77 +85 @@
     }
 
+    public bool ExecuteInParallel {
+      get { return ExecuteInParallelParameter.Value.Value; }
+      set { ExecuteInParallelParameter.Value.Value = value; }
+    }
+
+    public int MaxDegreeOfParallelism {
+      get { return MaxDegreeOfParallelismParameter.Value.Value; }
+      set { MaxDegreeOfParallelismParameter.Value.Value = value; }
+    }
+
     [StorableConstructor]
     protected PopulationSimilarityAnalyzer(bool deserializing) : base(deserializing) { }
-    protected PopulationSimilarityAnalyzer(PopulationSimilarityAnalyzer original, Cloner cloner) : base(original, cloner) { }
+
+    protected PopulationSimilarityAnalyzer(PopulationSimilarityAnalyzer original, Cloner cloner)
+      : base(original, cloner) {
+      RegisterParametersEventHandlers();
+    }
+
     public PopulationSimilarityAnalyzer(IEnumerable<ISolutionSimilarityCalculator> validSimilarityCalculators)
       : base() {
@@ -89 +112 @@
       Parameters.Add(new LookupParameter<IntValue>("UpdateCounter", "The value which counts how many times the operator was called since the last update.", "PopulationDiversityAnalyzerUpdateCounter"));
       Parameters.Add(new FixedValueParameter<StringValue>(DiversityResultNameParameterName, "Specifies how the diversity results should be named.", new StringValue("PopulationDiversity")));
+      Parameters.Add(new FixedValueParameter<BoolValue>(ExecuteInParallelParameterName, "Specifies whether similarity calculations should be parallelized.", new BoolValue(false)));
+      Parameters.Add(new FixedValueParameter<IntValue>(MaxDegreeOfParallelismParameterName, "Specifies the maximum number of threads when calculating similarities in parallel.", new IntValue(-1)));
 
       var similarityCalculators = SimilarityCalculatorParameter.ValidValues;
-      foreach (var sc in validSimilarityCalculators)
+      foreach (var sc in validSimilarityCalculators) {
         similarityCalculators.Add(sc);
-
+      }
 
       ResultsParameter.Hidden = true;
       UpdateCounterParameter.Hidden = true;
+      ExecuteInParallelParameter.Hidden = true;
+      MaxDegreeOfParallelismParameter.Hidden = true;
+
+      RegisterParametersEventHandlers();
+    }
+
+    private void RegisterParametersEventHandlers() {
+      ExecuteInParallelParameter.Value.ValueChanged += Value_ValueChanged;
+      MaxDegreeOfParallelismParameter.Value.ValueChanged += Value_ValueChanged;
+    }
+
+    private void Value_ValueChanged(object sender, EventArgs e) {
+      var similarityCalculators = SimilarityCalculatorParameter.ValidValues;
+      foreach (var similarityCalculator in similarityCalculators) {
+        similarityCalculator.ExecuteInParallel = ExecuteInParallel;
+        similarityCalculator.MaxDegreeOfParallelism = MaxDegreeOfParallelism;
+      }
     }
 
@@ -113 +155 @@
         Parameters.Add(new ConstrainedValueParameter<ISolutionSimilarityCalculator>("SimilarityCalculator", "The similarity calculator that should be used to calculate solution similarity."));
 
-      SimilarityCalculatorParameter.ValidValues.Add(oldSimilarityCalculator);
+      if (oldSimilarityCalculator != null)
+        SimilarityCalculatorParameter.ValidValues.Add(oldSimilarityCalculator);
+
+      if (!Parameters.ContainsKey(ExecuteInParallelParameterName)) {
+        Parameters.Add(new FixedValueParameter<BoolValue>(ExecuteInParallelParameterName,
+          "Specifies whether similarity calculations should be parallelized.", new BoolValue(false)));
+        ExecuteInParallelParameter.Hidden = true;
+      }
+      if (!Parameters.ContainsKey(MaxDegreeOfParallelismParameterName)) {
+        Parameters.Add(new FixedValueParameter<IntValue>(MaxDegreeOfParallelismParameterName,
+          "Specifies the maximum number of threads when calculating similarities in parallel.", new IntValue(-1)));
+        MaxDegreeOfParallelismParameter.Hidden = true;
+      }
+
+      RegisterParametersEventHandlers();
       #endregion
     }

trunk/sources/HeuristicLab.Optimization.Operators/3.3/SolutionSimilarityCalculator.cs

@@ -22 +22 @@
 using System;
 using System.Linq;
+using System.Threading.Tasks;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -41 +42 @@
     [Storable]
     public string QualityVariableName { get; set; }
+    [Storable]
+    public bool ExecuteInParallel { get; set; }
+    [Storable]
+    public int MaxDegreeOfParallelism { get; set; }
     #endregion
 
@@ -48 +53 @@
     protected SolutionSimilarityCalculator(SolutionSimilarityCalculator original, Cloner cloner)
       : base(original, cloner) {
-      this.SolutionVariableName = original.SolutionVariableName;
-      this.QualityVariableName = original.QualityVariableName;
-    }
-    protected SolutionSimilarityCalculator() : base() { }
+      SolutionVariableName = original.SolutionVariableName;
+      QualityVariableName = original.QualityVariableName;
+      ExecuteInParallel = original.ExecuteInParallel;
+      MaxDegreeOfParallelism = original.MaxDegreeOfParallelism;
+    }
+
+    protected SolutionSimilarityCalculator() : base() {
+      ExecuteInParallel = false;
+      MaxDegreeOfParallelism = -1;
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (MaxDegreeOfParallelism == 0) {
+        ExecuteInParallel = false;
+        MaxDegreeOfParallelism = -1;
+      }
+    }
 
     public double[][] CalculateSolutionCrowdSimilarity(IScope leftSolutionCrowd, IScope rightSolutionCrowd) {
@@ -75 +94 @@
 
     public double[][] CalculateSolutionCrowdSimilarity(IScope solutionCrowd) {
-      if (solutionCrowd == null)
+      if (solutionCrowd == null) {
         throw new ArgumentException("Cannot calculate similarity because the provided crowd is null.");
-
+      }
       var individuals = solutionCrowd.SubScopes;
 
-      if (!individuals.Any())
+      if (!individuals.Any()) {
         throw new ArgumentException("Cannot calculate similarity because the provided crowd is empty.");
+      }
 
       var similarityMatrix = new double[individuals.Count][];
-      for (int i = 0; i < individuals.Count; i++) similarityMatrix[i] = new double[individuals.Count];
-
-      if (IsCommutative) {
-        for (int i = 0; i < individuals.Count; i++) {
-          for (int j = i; j < individuals.Count; j++) {
-            similarityMatrix[i][j] = similarityMatrix[j][i] = CalculateSolutionSimilarity(individuals[i], individuals[j]);
+      for (int i = 0; i < individuals.Count; i++) {
+        similarityMatrix[i] = new double[individuals.Count];
+      }
+
+      if (ExecuteInParallel) {
+        var parallelOptions = new ParallelOptions { MaxDegreeOfParallelism = MaxDegreeOfParallelism };
+        if (IsCommutative) {
+          Parallel.For(0, individuals.Count, parallelOptions, i => {
+            for (int j = i; j < individuals.Count; j++) {
+              similarityMatrix[i][j] =
+                similarityMatrix[j][i] = CalculateSolutionSimilarity(individuals[i], individuals[j]);
+            }
+          });
+        } else {
+          Parallel.For(0, individuals.Count, parallelOptions, i => {
+            for (int j = i; j < individuals.Count; j++) {
+              similarityMatrix[i][j] = CalculateSolutionSimilarity(individuals[i], individuals[j]);
+              if (i == j) continue;
+              similarityMatrix[j][i] = CalculateSolutionSimilarity(individuals[j], individuals[i]);
+            }
+          });
+        }
+      } else {
+        if (IsCommutative) {
+          for (int i = 0; i < individuals.Count; i++) {
+            for (int j = i; j < individuals.Count; j++) {
+              similarityMatrix[i][j] =
+                similarityMatrix[j][i] = CalculateSolutionSimilarity(individuals[i], individuals[j]);
+            }
           }
-        }
-      } else {
-        for (int i = 0; i < individuals.Count; i++) {
-          for (int j = i; j < individuals.Count; j++) {
-            similarityMatrix[i][j] = CalculateSolutionSimilarity(individuals[i], individuals[j]);
-            if (i == j) continue;
-            similarityMatrix[j][i] = CalculateSolutionSimilarity(individuals[j], individuals[i]);
+        } else {
+          for (int i = 0; i < individuals.Count; i++) {
+            for (int j = i; j < individuals.Count; j++) {
+              similarityMatrix[i][j] = CalculateSolutionSimilarity(individuals[i], individuals[j]);
+              if (i == j) continue;
+              similarityMatrix[j][i] = CalculateSolutionSimilarity(individuals[j], individuals[i]);
+            }
           }
         }

trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/ISolutionSimilarityCalculator.cs

@@ -30 +30 @@
     string SolutionVariableName { get; set; }
     string QualityVariableName { get; set; }
+    bool ExecuteInParallel { get; set; }
+    int MaxDegreeOfParallelism { get; set; }
 
     /// <summary>