Changeset 13180 for trunk/sources/HeuristicLab.Problems.ExternalEvaluation/3.4/EvaluationCache.cs

Timestamp:

11/16/15 16:45:17 (8 years ago)

Author:

pfleck

Message:

#1674

• ProtoBuff QualityMessages
  • Changed the QualityMessage to be able to be used for single- and multi-objective problems.
  • The new SingleObjectiveQualityMessage and MultiObjectiveQualityMessage now "inherits" from QualityMessages to be able to be used in a polymorph manner.
  • This is done via protobuf's nested extensions (see ​http://www.indelible.org/ink/protobuf-polymorphism/).
• EvaluationCache
  • The EvaluationCache now now stores the QualityMessage instead of a single double. This way the cache can be used for single- and multi-objective problems and additionally opens the possibility to extend the quality message with any data. (previously extended data was lost when the cache was persisted and loaded again)
  • When deserializing an older version of the cache a new single objective quality message is created from the double value. This way, no compatibility is broken and version must not be incremented.
• Adapted the ExternalEvaluationProblem to the changes of the EvaluationCache and the QualityMessage.
• Added a MultiObjectiveExternalEvaluationProblem on basis of the ExternalEvaluationProblem and added a IExternalEvaluationProblem interface.

File:

• trunk/sources/HeuristicLab.Problems.ExternalEvaluation/3.4/EvaluationCache.cs (modified) (11 diffs)

trunk/sources/HeuristicLab.Problems.ExternalEvaluation/3.4/EvaluationCache.cs

@@ -30 +30 @@
 using System.Text.RegularExpressions;
 using System.Threading;
+using Google.ProtocolBuffers;
 using HeuristicLab.Common;
 using HeuristicLab.Common.Resources;
@@ -47 +48 @@
 
       public readonly string Key;
-      public double Value;
-
-      public CacheEntry(string key, double value) {
-        Key = key;
-        Value = value;
+
+      private QualityMessage message;
+      private byte[] rawMessage;
+
+      public byte[] RawMessage {
+        get { return rawMessage; }
+        set {
+          rawMessage = value;
+          message = null;
+        }
       }
 
       public CacheEntry(string key) {
         Key = key;
+      }
+
+      public QualityMessage GetMessage(ExtensionRegistry extensions) {
+        if (message == null && rawMessage != null)
+          message = QualityMessage.ParseFrom(ByteString.CopyFrom(rawMessage), extensions);
+        return message;
+      }
+      public void SetMessage(QualityMessage value) {
+        message = value;
+        rawMessage = value.ToByteArray();
       }
 
@@ -69 +85 @@
       }
 
+      public string QualityString(IFormatProvider formatProvider = null) {
+        if (formatProvider == null) formatProvider = CultureInfo.CurrentCulture;
+        if (RawMessage == null) return "-";
+        var msg = message ?? CreateBasicQualityMessage();
+        switch (msg.Type) {
+          case QualityMessage.Types.Type.SingleObjectiveQualityMessage:
+            return msg.GetExtension(SingleObjectiveQualityMessage.QualityMessage_).Quality.ToString(formatProvider);
+          case QualityMessage.Types.Type.MultiObjectiveQualityMessage:
+            var qualities = msg.GetExtension(MultiObjectiveQualityMessage.QualityMessage_).QualitiesList;
+            return string.Format("[{0}]", string.Join(",", qualities.Select(q => q.ToString(formatProvider))));
+          default:
+            return "-";
+        }
+      }
+      private QualityMessage CreateBasicQualityMessage() {
+        var extensions = ExtensionRegistry.CreateInstance();
+        ExternalEvaluationMessages.RegisterAllExtensions(extensions);
+        return QualityMessage.ParseFrom(ByteString.CopyFrom(rawMessage), extensions);
+      }
+
       public override string ToString() {
-        return string.Format("{{{0} : {1}}}", Key, Value);
-      }
-    }
-
-    public delegate double Evaluator(SolutionMessage message);
+        return string.Format("{{{0} : {1}}}", Key, QualityString());
+      }
+    }
+
+    public delegate QualityMessage Evaluator(SolutionMessage message);
     #endregion
 
@@ -126 +162 @@
 
     #region Persistence
+    #region BackwardsCompatibility3.4
     [Storable(Name = "Cache")]
     private IEnumerable<KeyValuePair<string, double>> Cache_Persistence {
-      get {
-        if (IsPersistent) {
-          return GetCacheValues();
-        } else {
-          return Enumerable.Empty<KeyValuePair<string, double>>();
-        }
-      }
+      get { return Enumerable.Empty<KeyValuePair<string, double>>(); }
       set {
-        SetCacheValues(value);
-      }
+        var rawMessages = value.ToDictionary(kvp => kvp.Key,
+          kvp => QualityMessage.CreateBuilder()
+            .SetSolutionId(0)
+            .SetExtension(
+              SingleObjectiveQualityMessage.QualityMessage_,
+              SingleObjectiveQualityMessage.CreateBuilder().SetQuality(kvp.Value).Build())
+            .Build().ToByteArray());
+        SetCacheValues(rawMessages);
+      }
+    }
+    #endregion
+    [Storable(Name = "CacheNew")]
+    private IEnumerable<KeyValuePair<string, byte[]>> CacheNew_Persistence {
+      get { return IsPersistent ? GetCacheValues() : Enumerable.Empty<KeyValuePair<string, byte[]>>(); }
+      set { SetCacheValues(value); }
     }
     [StorableHook(HookType.AfterDeserialization)]
@@ -149 +193 @@
     protected EvaluationCache(bool deserializing) : base(deserializing) { }
     protected EvaluationCache(EvaluationCache original, Cloner cloner)
-      : base(original, cloner) {
+        : base(original, cloner) {
       SetCacheValues(original.GetCacheValues());
       Hits = original.Hits;
@@ -190 +234 @@
     }
 
-    public double GetValue(SolutionMessage message, Evaluator evaluate) {
+    public QualityMessage GetValue(SolutionMessage message, Evaluator evaluate, ExtensionRegistry extensions) {
       var entry = new CacheEntry(message.ToString());
       bool lockTaken = false;
@@ -205 +249 @@
             Monitor.Exit(cacheLock);
             OnChanged();
-            return node.Value.Value;
+            return node.Value.GetMessage(extensions);
           } else {
             if (!waited && activeEvaluations.Contains(entry.Key)) {
@@ -217 +261 @@
               OnChanged();
               try {
-                entry.Value = evaluate(message);
+                entry.SetMessage(evaluate(message));
                 Monitor.Enter(cacheLock, ref lockTaken);
                 index[entry] = list.AddLast(entry);
                 Trim();
-              }
-              finally {
+              } finally {
                 if (!lockTaken)
                   Monitor.Enter(cacheLock, ref lockTaken);
@@ -231 +274 @@
               }
               OnChanged();
-              return entry.Value;
+              return entry.GetMessage(extensions);
             }
           }
         }
-      }
-      finally {
+      } finally {
         if (lockTaken)
           Monitor.Exit(cacheLock);
@@ -250 +292 @@
     }
 
-    private IEnumerable<KeyValuePair<string, double>> GetCacheValues() {
+    private IEnumerable<KeyValuePair<string, byte[]>> GetCacheValues() {
       lock (cacheLock) {
-        return index.ToDictionary(kvp => kvp.Key.Key, kvp => kvp.Key.Value);
-      }
-    }
-
-    private void SetCacheValues(IEnumerable<KeyValuePair<string, double>> value) {
+        return index.ToDictionary(kvp => kvp.Key.Key, kvp => kvp.Key.RawMessage);
+      }
+    }
+
+    private void SetCacheValues(IEnumerable<KeyValuePair<string, byte[]>> value) {
       lock (cacheLock) {
-        list = new LinkedList<CacheEntry>();
-        index = new Dictionary<CacheEntry, LinkedListNode<CacheEntry>>();
+        if (list == null) list = new LinkedList<CacheEntry>();
+        if (index == null) index = new Dictionary<CacheEntry, LinkedListNode<CacheEntry>>();
         foreach (var kvp in value) {
-          var entry = new CacheEntry(kvp.Key) { Value = kvp.Value };
+          var entry = new CacheEntry(kvp.Key) { RawMessage = kvp.Value };
           index[entry] = list.AddLast(entry);
         }
@@ -274 +316 @@
               "\"{0}\", {1}",
               Regex.Replace(entry.Key, "\\s", "").Replace("\"", "\"\""),
-              entry.Value));
+              entry.QualityString(CultureInfo.InvariantCulture)));
           }
         }