Changeset 6737 for branches/PersistenceSpeedUp/HeuristicLab.Persistence/3.3/Core

Timestamp:

09/12/11 10:12:50 (13 years ago)

Author:

epitzer

Message:

#1530 Split type and serializer tokens and include special handling for CachedTypeSerializer (this should also fix #1527)

Location:

branches/PersistenceSpeedUp/HeuristicLab.Persistence/3.3/Core

Files:

• CachedTypeSerializer.cs (added)
• DeSerializer.cs (modified) (9 diffs)
• GeneratorBase.cs (modified) (2 diffs)
• ReverseTypeCache.cs (added)
• Serializer.cs (modified) (14 diffs)
• Tokens/SerializerToken.cs (added)
• Tokens/TypeToken.cs (modified) (2 diffs)
• TypeCache.cs (added)
• TypeMapping.cs (deleted)

branches/PersistenceSpeedUp/HeuristicLab.Persistence/3.3/Core/DeSerializer.cs

@@ -32 +32 @@
   /// instantiates objects and fills in values.
   /// </summary>
-  public class Deserializer {
+  public sealed class Deserializer {
 
     /// <summary>
@@ -40 +40 @@
     private class Midwife {
 
+      public string Name { get; private set; }
       public int? Id { get; private set; }
       public bool MetaMode { get; set; }
@@ -53 +54 @@
       }
 
-      public Midwife(Type type, ICompositeSerializer compositeSerializer, int? id) {
+      public Midwife(Type type, ICompositeSerializer compositeSerializer, int? id, string name) {
         this.type = type;
         this.compositeSerializer = compositeSerializer;
         this.Id = id;
+        this.Name = name;
         MetaMode = false;
         metaInfo = new List<Tag>();
@@ -82 +84 @@
 
     private readonly Dictionary<int, object> id2obj;
-    private readonly Dictionary<Type, object> serializerMapping;
     private readonly Stack<Midwife> parentStack;
-    private readonly Dictionary<int, Type> typeIds;
-    private Dictionary<Type, object> serializerInstances;
+    private ReverseTypeCache typeCache;
 
     /// <summary>
@@ -93 +93 @@
     /// </summary>
     /// <param name="typeCache">The type cache.</param>
-    public Deserializer(
-      IEnumerable<TypeMapping> typeCache) {
+    public Deserializer(ReverseTypeCache typeCache) {
+      this.typeCache = typeCache;
       id2obj = new Dictionary<int, object>();
       parentStack = new Stack<Midwife>();
-      typeIds = new Dictionary<int, Type>();
-      serializerMapping = new Dictionary<Type, object>();
-      serializerInstances = new Dictionary<Type, object>();
-      foreach (var typeMapping in typeCache) {
-        AddTypeInfo(typeMapping);
-      }
-    }
-
-    /// <summary>
-    /// Adds additionaly type information.
-    /// </summary>
-    /// <param name="typeMapping">The new type mapping.</param>
-    public void AddTypeInfo(TypeMapping typeMapping) {
-      if (typeIds.ContainsKey(typeMapping.Id))
-        return;
-      try {
-        Type type = TypeLoader.Load(typeMapping.TypeName);
-        typeIds.Add(typeMapping.Id, type);
-        Type serializerType = TypeLoader.Load(typeMapping.Serializer);
-        object serializer;
-        if (serializerInstances.ContainsKey(serializerType)) {
-          serializer = serializerInstances[serializerType];
-        } else {
-          serializer = Activator.CreateInstance(serializerType, true);
-          serializerInstances.Add(serializerType, serializer);
-        }
-        serializerMapping.Add(type, serializer);
-      } catch (PersistenceException) {
-        throw;
-      } catch (Exception e) {
-        throw new PersistenceException(string.Format(
-          "Could not add type info for {0} ({1})",
-          typeMapping.TypeName, typeMapping.Serializer), e);
-      }
     }
 
@@ -157 +123 @@
         } else if (t == typeof(TypeToken)) {
           Type((TypeToken)token);
+        } else if (t == typeof(SerializerToken)) {
+          Serializer((SerializerToken)token);
         } else {
           throw new PersistenceException("invalid token type");
@@ -173 +141 @@
 
     private void Type(TypeToken token) {
-      AddTypeInfo(new TypeMapping(token.Id, token.TypeName, token.Serializer));
+      typeCache.AddType(token.Id, TypeLoader.Load(token.TypeName));
+    }
+
+    private void Serializer(SerializerToken token) {
+      typeCache.AddSerializer(token.Id, TypeLoader.Load(token.Serializer));
     }
 
     private void CompositeStartHandler(BeginToken token) {
       InstantiateParent();
-      Type type = typeIds[(int)token.TypeId];
+      Type type = typeCache.GetType(token.TypeId);
       try {
-        parentStack.Push(new Midwife(type, (ICompositeSerializer)serializerMapping[type], token.Id));
+        parentStack.Push(new Midwife(type, typeCache.GetCompositeSerializer(token.TypeId), token.Id, token.Name));
       } catch (Exception e) {
         if (e is InvalidCastException || e is KeyNotFoundException) {
@@ -195 +167 @@
 
     private void CompositeEndHandler(EndToken token) {
-      Type type = typeIds[(int)token.TypeId];
       Midwife midwife = parentStack.Pop();
       if (midwife.Obj == null)
         CreateInstance(midwife);
       midwife.Populate();
-      SetValue(token.Name, midwife.Obj);
+      SetValue(midwife.Name, midwife.Obj);
     }
 
     private void PrimitiveHandler(PrimitiveToken token) {
-      Type type = typeIds[(int)token.TypeId];
       try {
-        object value = ((IPrimitiveSerializer)serializerMapping[type]).Parse(token.SerialData);
+        object value = typeCache.GetPrimitiveSerializer(token.TypeId).Parse(token.SerialData);
         if (token.Id != null)
           id2obj[(int)token.Id] = value;
@@ -214 +184 @@
           throw new PersistenceException(String.Format(
             "Invalid primitive serializer configuration for type \"{0}\".",
-            type.AssemblyQualifiedName), e);
+            typeCache.GetType(token.TypeId).AssemblyQualifiedName), e);
         } else {
           throw new PersistenceException(String.Format(
             "Unexpected exception while trying to parse object of type \"{0}\".",
-            type.AssemblyQualifiedName), e);
+            typeCache.GetType(token.TypeId).AssemblyQualifiedName), e);
         }
       }

branches/PersistenceSpeedUp/HeuristicLab.Persistence/3.3/Core/GeneratorBase.cs

@@ -57 +57 @@
       if (type == typeof(TypeToken))
         return Format((TypeToken)token);
+      if (type == typeof(SerializerToken))
+        return Format((SerializerToken)token);
       throw new ApplicationException("Invalid token of type " + type.FullName);
     }
@@ -116 +118 @@
     protected abstract T Format(TypeToken typeToken);
 
+    protected abstract T Format(SerializerToken serializerToken);
   }
 }

branches/PersistenceSpeedUp/HeuristicLab.Persistence/3.3/Core/Serializer.cs

@@ -23 +23 @@
 using System.Collections;
 using System.Collections.Generic;
-using System.Reflection;
+using System.Linq;
 using System.Text;
 using HeuristicLab.Persistence.Auxiliary;
@@ -44 +44 @@
   /// and traverses the object graph while the enumerator is iterated
   /// </summary>  
-  public class Serializer : IEnumerable<ISerializationToken> {
-
+  public sealed class Serializer : IEnumerable<ISerializationToken> {
+
+    #region Nested Types
     private class ReferenceEqualityComparer : IEqualityComparer<object> {
 
@@ -59 +60 @@
 
     }
-
+    #endregion
+
+    #region Fields
     private readonly object obj;
     private readonly string rootName;
     private readonly Dictionary<object, int> obj2id;
-    private readonly Dictionary<Type, int> typeCache;
     private readonly Configuration configuration;
     private readonly bool isTestRun;
     private readonly List<Exception> exceptions;
+    private readonly Stack<string> objectGraphTrace;
+    private readonly CachedTypeSerializer typeSerializer;
+    private readonly TypeCache typeCache;
+    #endregion
 
     /// <summary>
@@ -80 +86 @@
     public bool InterleaveTypeInformation { get; set; }
 
-    /// <summary>
-    /// Contains a mapping of type id to type and serializer.
-    /// </summary>
-    /// <value>The type cache.</value>
-    public List<TypeMapping> TypeCache {
-      get {
-        BuildTypeCache();
-        return externalTypeCache;
-      }
+    public TypeCache TypeCache {
+      get { return typeCache; }
     }
 
@@ -95 +94 @@
     /// necessary to deserialize the object graph again.    
     /// </summary>
-    public List<string> RequiredFiles {
-      get {
-        BuildTypeCache();
-        return requiredFiles;
-      }
-    }
-
-    private List<TypeMapping> externalTypeCache;
-    private List<string> requiredFiles;
-    private void BuildTypeCache() {
-      externalTypeCache = new List<TypeMapping>();
-      Dictionary<Assembly, bool> assemblies = new Dictionary<Assembly, bool>();
-      foreach (var pair in typeCache) {
-        string serializer = null;
-        IPrimitiveSerializer f = configuration.GetPrimitiveSerializer(pair.Key);
-        if (f != null) {
-          serializer = f.GetType().AssemblyQualifiedName;
-          assemblies[f.GetType().Assembly] = true;
-        } else {
-          ICompositeSerializer d = configuration.GetCompositeSerializer(pair.Key);
-          serializer = d.GetType().AssemblyQualifiedName;
-          assemblies[d.GetType().Assembly] = true;
-        }
-        externalTypeCache.Add(new TypeMapping(pair.Value, pair.Key.AssemblyQualifiedName, serializer));
-        assemblies[pair.Key.Assembly] = true;
-      }
-      Dictionary<string, bool> files = new Dictionary<string, bool>();
-      foreach (Assembly a in assemblies.Keys) {
-        files[a.CodeBase] = true;
-      }
-      requiredFiles = new List<string>(files.Keys);
-    }
-
-    public IEnumerable<Type> SerializedTypes {
-      get {
-        return typeCache.Keys;
-      }
-    }
+    public IEnumerable<string> GetRequiredFiles() {
+      HashSet<string> files = new HashSet<string>();
+      foreach (var t in typeCache.Types) {
+        files.Add(t.Assembly.CodeBase);
+        Type serializer = typeCache.GetSerializer(typeCache.GetOrCreateId(t));
+        if (serializer != null)
+          files.Add(serializer.Assembly.CodeBase);
+      }
+      return files;
+    }
+
+    public IEnumerable<Type> SerializedTypes { get { return typeCache.Types; } }
 
     /// <summary>
@@ -139 +112 @@
     /// <param name="obj">The object to serialize.</param>
     /// <param name="configuration">The configuration.</param>
-    public Serializer(object obj, Configuration configuration) :
-      this(obj, configuration, "ROOT") { }
+    public Serializer(object obj, Configuration configuration)
+      : this(obj, configuration, "ROOT") { }
 
     /// <summary>
@@ -163 +136 @@
       this.obj = obj;
       this.rootName = rootName;
-      this.configuration = configuration;
       obj2id = new Dictionary<object, int>(new ReferenceEqualityComparer()) { { new object(), 0 } };
-      typeCache = new Dictionary<Type, int>();
+      typeCache = new TypeCache();
       this.isTestRun = isTestRun;
       this.exceptions = new List<Exception>();
+      this.objectGraphTrace = new Stack<string>();
+      this.typeSerializer = new CachedTypeSerializer(typeCache);
+      this.configuration = new Configuration(
+        configuration.Format,
+        configuration.PrimitiveSerializers,
+        new[] { typeSerializer }.Concat(configuration.CompositeSerializers));
     }
 
@@ -206 +184 @@
     }
 
-    private Stack<string> objectGraphTrace = new Stack<string>();
 
     private IEnumerator<ISerializationToken> Serialize(string name, object obj) {
-
       object value = obj;
       if (value == null)
@@ -216 +192 @@
       if (obj2id.ContainsKey(value))
         return ReferenceEnumerator(name, obj2id[value]);
-      bool emitTypeInfo = false;
-      if (!typeCache.ContainsKey(type)) {
-        typeCache.Add(type, typeCache.Count);
-        emitTypeInfo = InterleaveTypeInformation;
-      }
-      int typeId = typeCache[type];
+      int typeId = typeCache.GetOrCreateId(type);
       int? id = null;
       if (!type.IsValueType) {
@@ -230 +201 @@
         objectGraphTrace.Push(name);
         IPrimitiveSerializer primitiveSerializer = configuration.GetPrimitiveSerializer(type);
-        if (primitiveSerializer != null)
+        if (primitiveSerializer != null) {
+          typeCache.SetSerializer(typeId, primitiveSerializer.GetType());
           return PrimitiveEnumerator(
             name,
             typeId,
             primitiveSerializer.Format(value),
-            id,
-            emitTypeInfo);
+            id);
+        }
         ICompositeSerializer compositeSerializer = configuration.GetCompositeSerializer(type);
+        typeCache.SetSerializer(typeId, compositeSerializer.GetType());
         if (compositeSerializer != null)
           return CompositeEnumerator(
@@ -244 +217 @@
             id,
             typeId,
-            compositeSerializer.CreateMetaInfo(value),
-            emitTypeInfo);
-        throw CreatePersistenceException(type, "Could not determine how to serialize a value.");
-      }
-      catch (Exception x) {
+            compositeSerializer.CreateMetaInfo(value));
+        throw CreatePersistenceException(type, "Could not determine how to serialize a value.", null);
+      } catch (Exception x) {
         if (isTestRun) {
           exceptions.Add(x);
@@ -255 +226 @@
           throw;
         } else {
-          throw CreatePersistenceException(type, "Uncaught exception during serialization: " + x.Message);
+          throw CreatePersistenceException(type, "Uncaught exception during serialization: ", x);
         }
-      }
-      finally {
+      } finally {
         objectGraphTrace.Pop();
       }
     }
 
-    private PersistenceException CreatePersistenceException(Type type, string message) {
+    private PersistenceException CreatePersistenceException(Type type, string message, Exception x) {
       StringBuilder sb = new StringBuilder();
       sb.Append(message)
@@ -295 +265 @@
     }
 
-    private IEnumerator<ISerializationToken> PrimitiveEnumerator(string name,
-        int typeId, ISerialData serializedValue, int? id, bool emitTypeInfo) {
-      if (emitTypeInfo) {
-        var mapping = TypeCache[typeId];
-        yield return new TypeToken(mapping.Id, mapping.TypeName, mapping.Serializer);
+    private IEnumerator<ISerializationToken> PrimitiveEnumerator(string name, int typeId, ISerialData serializedValue, int? id) {
+      if (InterleaveTypeInformation) {
+        if (typeCache.HasUnpublishedType)
+          yield return typeCache.PublishUnpublishedType();
+        if (typeCache.HasUnpublishedSerializer)
+          yield return typeCache.PublishUnpublishedSerializer();
       }
       yield return new PrimitiveToken(name, typeId, id, serializedValue);
     }
 
-    private IEnumerator<ISerializationToken> CompositeEnumerator(
-        string name, IEnumerable<Tag> tags, int? id, int typeId, IEnumerable<Tag> metaInfo,
-        bool emitTypeInfo) {
-      if (emitTypeInfo) {
-        var mapping = TypeCache[typeId];
-        yield return new TypeToken(mapping.Id, mapping.TypeName, mapping.Serializer);
+    private IEnumerator<ISerializationToken> CompositeEnumerator(string name, IEnumerable<Tag> tags, int? id, int typeId, IEnumerable<Tag> metaInfo) {
+      if (InterleaveTypeInformation) {
+        if (typeCache.HasUnpublishedType)
+          yield return typeCache.PublishUnpublishedType();
+        if (typeCache.HasUnpublishedSerializer)
+          yield return typeCache.PublishUnpublishedSerializer();
       }
       yield return new BeginToken(name, typeId, id);
@@ -335 +306 @@
         }
       }
-      yield return new EndToken(name, typeId, id);
+      yield return new EndToken();
     }
   }

branches/PersistenceSpeedUp/HeuristicLab.Persistence/3.3/Core/Tokens/TypeToken.cs

@@ -40 +40 @@
 
     /// <summary>
-    /// The full type name of the serialized used to
-    /// serialize the type.
-    /// </summary>
-    public readonly string Serializer;
-
-    /// <summary>
     /// Initializes a new instance of the <see cref="TypeToken"/> class.
     /// </summary>
@@ -52 +46 @@
     /// <param name="serializer">The full name of the serializer
     /// used to serialize the type.</param>
-    public TypeToken(int id, string typeName, string serializer) {
+    public TypeToken(int id, string typeName) {
       Id = id;
       TypeName = typeName;
-      Serializer = serializer;
     }
   }