Changeset 3913 for trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Storable

Timestamp:

06/09/10 16:29:02 (15 years ago)

Author:

epitzer

Message:

Accelerate persistence: (#646)

• dynamically compile field and property accessors
• enable caching of compiled field and property accessors
• delay costly custom attribute retrieval by checking signatures first
• implement custom List<double> serializer
• log deserialization time span

Location:

trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Storable

Files:

• StorableReflection.cs (modified) (3 diffs)
• StorableSerializer.cs (modified) (9 diffs)

trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Storable/StorableReflection.cs

@@ -73 +73 @@
 
     private static object[] emptyArgs = new object[0];
+    private static Type[] objectArg = new[] { typeof(object) };
 
     public static IEnumerable<Hook> CollectHooks(HookType hookType, Type type) {
@@ -79 +80 @@
           yield return mi;
       foreach (MemberInfo memberInfo in type.GetMembers(DECLARED_INSTANCE_MEMBERS)) {
+        if (memberInfo.MemberType != MemberTypes.Method)
+          continue;
+        MethodInfo methodInfo = memberInfo as MethodInfo;
+        if (methodInfo.ReturnType != typeof(void))
+          continue;
+        if (methodInfo.GetParameters().Length > 0)
+          continue;
         foreach (StorableHookAttribute hook in memberInfo.GetCustomAttributes(typeof(StorableHookAttribute), false)) {
           if (hook != null && hook.HookType == hookType) {
-            MethodInfo methodInfo = memberInfo as MethodInfo;
-            if (memberInfo.MemberType != MemberTypes.Method || memberInfo == null)
-              throw new ArgumentException("Storable hooks must be methods");            
-            DynamicMethod dm = new DynamicMethod("", null, new[] { typeof(object) }, type);
-            ILGenerator ilgen = dm.GetILGenerator();
-            ilgen.Emit(OpCodes.Ldarg_0);
-            ilgen.Emit(OpCodes.Callvirt, methodInfo);
-            ilgen.Emit(OpCodes.Ret);
-            yield return (Hook)dm.CreateDelegate(typeof(Hook));            
+            yield return new Hook((o) => methodInfo.Invoke(o, emptyArgs));
           }
         }
@@ -99 +99 @@
     private static void AddMarkedMembers(Type type, List<StorableMemberInfo> storableMembers) {
       foreach (MemberInfo memberInfo in type.GetMembers(DECLARED_INSTANCE_MEMBERS)) {
-        foreach (StorableAttribute attribute in memberInfo.GetCustomAttributes(typeof(StorableAttribute), false)) {
-          storableMembers.Add(new StorableMemberInfo(attribute, memberInfo));
+        if (memberInfo.MemberType == MemberTypes.Field ||
+          memberInfo.MemberType == MemberTypes.Property) {
+          foreach (StorableAttribute attribute in memberInfo.GetCustomAttributes(typeof(StorableAttribute), false)) {
+            storableMembers.Add(new StorableMemberInfo(attribute, memberInfo));
+          }
         }
       }

trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Storable/StorableSerializer.cs

@@ -109 +109 @@
     /// <returns>An enumerable of <see cref="Tag"/>s.</returns>
     public IEnumerable<Tag> Decompose(object obj) {
-      foreach (var accessor in GetStorableAccessors(obj)) {
-        yield return new Tag(accessor.Name, accessor.Get());
+      foreach (var accessor in GetStorableAccessors(obj.GetType())) {
+        yield return new Tag(accessor.Name, accessor.Get(obj));
       }
     }
@@ -142 +142 @@
         memberDict.Add(iter.Current.Name, iter.Current);
       }
-      foreach (var accessor in GetStorableAccessors(instance)) {
+      foreach (var accessor in GetStorableAccessors(instance.GetType())) {
         if (memberDict.ContainsKey(accessor.Name)) {
-          accessor.Set(memberDict[accessor.Name].Value);
+          accessor.Set(instance, memberDict[accessor.Name].Value);
         } else if (accessor.DefaultValue != null) {
-          accessor.Set(accessor.DefaultValue);
+          accessor.Set(instance, accessor.DefaultValue);
         }
       }
@@ -160 +160 @@
 
     private static readonly object[] emptyArgs = new object[] { };
+    private static readonly object[] trueArgs = new object[] { true };
 
     private sealed class HookDesignator {
@@ -171 +172 @@
     }
 
-    private sealed class MemberCache : Dictionary<Type, IEnumerable<StorableMemberInfo>> { }
+    private sealed class AccessorListCache : Dictionary<Type, IEnumerable<DataMemberAccessor>> { }
+    private sealed class AccessorCache : Dictionary<MemberInfo, DataMemberAccessor> { }
 
     #endregion
@@ -177 +179 @@
     #region caches
 
-    private MemberCache storableMemberCache = new MemberCache();
+    private AccessorListCache accessorListCache = new AccessorListCache();
+    private AccessorCache accessorCache = new AccessorCache();
 
     private delegate object Constructor();
@@ -191 +194 @@
     #region attribute access
 
-    private IEnumerable<StorableMemberInfo> GetStorableMembers(Type type) {
-      lock (storableMemberCache) {
-        if (storableMemberCache.ContainsKey(type))
-          return storableMemberCache[type];
-        var storablesMembers = StorableReflection.GenerateStorableMembers(type);
-        storableMemberCache[type] = storablesMembers;
-        return storablesMembers;
+    private IEnumerable<DataMemberAccessor> GetStorableAccessors(Type type) {
+      lock (accessorListCache) {
+        if (accessorListCache.ContainsKey(type))
+          return accessorListCache[type];
+        var storableMembers = StorableReflection
+          .GenerateStorableMembers(type)
+          .Select(mi => GetMemberAccessor(mi));
+        accessorListCache[type] = storableMembers;
+        return storableMembers;
+      }      
+    }
+
+    private DataMemberAccessor GetMemberAccessor(StorableMemberInfo mi) {
+      lock (accessorCache) {
+        if (accessorCache.ContainsKey(mi.MemberInfo))
+          return new DataMemberAccessor(accessorCache[mi.MemberInfo], mi.DisentangledName, mi.DefaultValue);
+        DataMemberAccessor dma = new DataMemberAccessor(mi.MemberInfo, mi.DisentangledName, mi.DefaultValue);
+        accessorCache[mi.MemberInfo] = dma;
+        return dma;
       }
     }
@@ -209 +224 @@
         return c;
       }
-    }
+    }    
 
     private Constructor GetDefaultConstructor(Type type) {
       ConstructorInfo ci = type.GetConstructor(ALL_CONSTRUCTORS, null, Type.EmptyTypes, null);
       if (ci == null)
-        return null;
+        return null;      
       DynamicMethod dm = new DynamicMethod("", typeof(object), null, type);
       ILGenerator ilgen = dm.GetILGenerator();
@@ -227 +242 @@
           if (ci.GetParameters().Length != 1 ||
               ci.GetParameters()[0].ParameterType != typeof(bool))
-            throw new PersistenceException("StorableConstructor must have exactly one argument of type bool");
+            throw new PersistenceException("StorableConstructor must have exactly one argument of type bool");          
           DynamicMethod dm = new DynamicMethod("", typeof(object), null, type);
           ILGenerator ilgen = dm.GetILGenerator();
@@ -237 +252 @@
       }
       return null;
-    }
-
-    private IEnumerable<DataMemberAccessor> GetStorableAccessors(object obj) {
-      return GetStorableMembers(obj.GetType())
-        .Select(mi => new DataMemberAccessor(mi.MemberInfo, mi.DisentangledName, mi.DefaultValue, obj));
-    }
+    }    
 
     private void InvokeHook(HookType hookType, object obj) {