Changeset 1322

Timestamp:

03/10/09 17:10:47 (16 years ago)

Author:

epitzer

Message:

cached cloning. (#506)

Location:

branches/New Persistence Exploration/Persistence/Persistence

Files:

• NewSerializationTest.cs (modified) (5 diffs)
• Persistence.csproj (modified) (1 diff)
• StorableAttribute.cs (modified) (2 diffs)

branches/New Persistence Exploration/Persistence/Persistence/NewSerializationTest.cs

@@ -5 +5 @@
 using System.IO;
 
-namespace Persistence {
+namespace Persistence.Test {
 
   public class Root {
-
     [Storable]
     public int[] i = new int[] { 3, 4, 5, 6 };
@@ -40 +39 @@
     [Storable]
     public string name = "Serial";
+  }
+
+  public class CloneableRoot {
+    public int[] i = new int[] { 3, 4, 5, 6 };
+    public string s;
+    public ArrayList intArray = new ArrayList(new int[] { 1, 2, 3 });
+    public List<int> intList = new List<int>(new int[] { 321, 312, 321 });
+    public CloneableCustom c;
+    public List<CloneableRoot> selfReferences;
+    public double[,] multiDimArray = new double[,] { { 1, 2, 3 }, { 3, 4, 5 } };
+    public bool boolean = true;
+    public DateTime dateTime = new DateTime();
+    public KeyValuePair<string, int> kvp = new KeyValuePair<string, int>("test key", 123);
+    public Dictionary<string, int> dict = new Dictionary<string, int>();    
+    public object Clone(Dictionary<object, object> twins) {
+      if (twins.ContainsKey(this))
+        return twins[this];      
+      CloneableRoot cr = new CloneableRoot();
+      twins.Add(this, cr);
+      cr.i = this.i;
+      cr.s = this.s;
+      cr.intArray = new ArrayList(this.intArray);
+      cr.intList = new List<int>(this.intList);
+      cr.c = (CloneableCustom)c.Clone(twins);
+      cr.selfReferences = new List<CloneableRoot>();
+      for (int i = 0; i < this.selfReferences.Count; i++) {
+        cr.selfReferences.Add(this);
+      }
+      cr.multiDimArray = (double[,])this.multiDimArray.Clone();
+      cr.dateTime = new DateTime(this.dateTime.Ticks);
+      cr.kvp = new KeyValuePair<string, int>(this.kvp.Key, this.kvp.Value);
+      cr.dict = new Dictionary<string, int>(this.dict);
+      return cr;
+    }    
+  }
+
+  public class CloneableCustom {    
+    public int i;    
+    public CloneableRoot r;    
+    public string name = "Serial";
+    public object Clone(Dictionary<object, object> twins) {
+      if (twins.ContainsKey(this))
+        return twins[this];
+      CloneableCustom cc = new CloneableCustom();
+      twins.Add(this, cc);
+      cc.i = this.i;
+      cc.r = (CloneableRoot)this.r.Clone(twins);
+      cc.name = this.name;
+      return cc;
+    }
   }
 
@@ -52 +101 @@
     [Storable]
     private Nullable<double> dbl = null;
+  }
+
+  public class StorableObject {
+
+    [Storable]
+    Dictionary<int, string> dict;
+
+    public void Init() {
+      this.dict = new Dictionary<int, string>();
+      for (int i = 0; i < 1000000; i++) {
+        dict.Add(i, i.ToString());
+      }
+    }
+  }
+
+  public class CloneableObject : ICloneable {
+
+    Dictionary<int, string> dict;
+
+    public void Init() {
+      this.dict = new Dictionary<int, string>();
+      for (int i = 0; i < 1000000; i++) {
+        dict.Add(i, i.ToString());
+      }
+    }
+    public object Clone() {
+      CloneableObject clone = new CloneableObject();
+      clone.dict = new Dictionary<int, string>(this.dict);
+      return clone;
+    }
   }  
 
@@ -78 +157 @@
       DeSerializer deSerializer = new DeSerializer();        
       object o = deSerializer.DeSerialize(parser);
-      Root t = StorableAttribute.Clone(r);
+      Root t = CloningFactory.DefaultClone(r);
       Console.Out.WriteLine(Util.AutoFormat(o, true));      
     }
@@ -96 +175 @@
       DeSerializer deSerializer = new DeSerializer();
       object o = deSerializer.DeSerialize(parser);
-      Manager n = StorableAttribute.Clone(m);
+      Manager n = CloningFactory.DefaultClone(m);
       Console.Out.WriteLine(Util.AutoFormat(o, true));      
     }
 
+    public static void SpeedTest() {
+      StorableObject storable = new StorableObject();
+      CloneableObject cloneable = new CloneableObject();
+      Console.Write("initializing...");
+      storable.Init();
+      cloneable.Init();
+      Console.WriteLine("done");
+      List<StorableObject> storableClones = new List<StorableObject>();
+      List<CloneableObject> clonableClones = new List<CloneableObject>();
+      CloningFactory cloningFactory = new CloningFactory();
+      for (int i = 0; i < 100000; i++) {
+        Console.Write("cloning storable.. ");
+        storableClones.Add(cloningFactory.Clone(storable));
+        Console.WriteLine();
+        Console.Write("cloning cloneable.. ");
+        clonableClones.Add((CloneableObject)cloneable.Clone());
+        Console.WriteLine();
+      }
+    }
+
+    public static void SpeedTest2() {
+      Root r = new Root();
+      r.selfReferences = new List<Root>();
+      r.selfReferences.Add(r);
+      r.selfReferences.Add(r);
+      r.c = new Custom();
+      r.c.r = r;
+      r.dict.Add("one", 1);
+      r.dict.Add("two", 2);
+      r.dict.Add("three", 3);
+
+      CloneableRoot cr = new CloneableRoot();
+      cr.selfReferences = new List<CloneableRoot>();
+      cr.selfReferences.Add(cr);
+      cr.selfReferences.Add(cr);
+      cr.c = new CloneableCustom();
+      cr.c.r = cr;
+      cr.dict.Add("one", 1);
+      cr.dict.Add("two", 2);
+      cr.dict.Add("three", 3);      
+      List<Root> storableClones = new List<Root>();
+      List<CloneableRoot> clonableClones = new List<CloneableRoot>();      
+      CloningFactory cloningFactory = new CloningFactory();
+
+      DateTime start = DateTime.Now;
+      Console.Write("cloning storable.. ");
+      for (int i = 0; i < 100000; i++) {       
+        storableClones.Add(cloningFactory.Clone(r));                        
+      }
+      Console.WriteLine(new TimeSpan(DateTime.Now.Ticks - start.Ticks));
+
+      start = DateTime.Now;
+      Console.Write("cloning storable again.. ");
+      for (int i = 0; i < 100000; i++) {
+        storableClones.Add(cloningFactory.Clone(r));
+      }
+      Console.WriteLine(new TimeSpan(DateTime.Now.Ticks - start.Ticks));
+
+
+      start = DateTime.Now;
+      Console.Write("cloning cloneable.. ");
+      for (int i = 0; i < 100000; i++) {        
+        clonableClones.Add((CloneableRoot)cr.Clone(new Dictionary<object, object>()));
+      }
+      Console.WriteLine(new TimeSpan(DateTime.Now.Ticks - start.Ticks));
+      clonableClones.Clear();
+      
+    }
+
     public static void Main() {
-      Test1();
-      Test2();
+      //Test1();
+      //Test2();
+      //SpeedTest();
+      SpeedTest2();
       Console.In.ReadLine();
     }

branches/New Persistence Exploration/Persistence/Persistence/Persistence.csproj

@@ -13 +13 @@
     <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
-    <StartupObject>Persistence.NewSerializationTest</StartupObject>
+    <StartupObject>Persistence.Test.NewSerializationTest</StartupObject>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">

branches/New Persistence Exploration/Persistence/Persistence/StorableAttribute.cs

@@ -45 +45 @@
       }
       return autoStorableAccessors;
-    }
-
-    private static MethodInfo MemberwiseClone;
-
-    public static StorableAttribute() {
-      foreach (MethodInfo mi in typeof(object).GetMethods(BindingFlags.Instance | BindingFlags.NonPublic)) {
-        if (mi.Name == "MemberwiseClone") {
-          MemberwiseClone = mi;
-        }
-      }
-    }
-
-    public static T Clone<T>(T obj) {
-      List<ICompoundSerializer> compoundSerializers =
-        InterfaceInstantiatior.InstantiateAll<ICompoundSerializer>();
-      return Clone(obj, compoundSerializers);
-    }
-
-    public static T Clone<T>(T obj, IEnumerable<ICompoundSerializer> compoundSerializers) {
-      Dictionary<object, object> twins = new Dictionary<object, object>();      
-      return Clone(obj, twins, compoundSerializers);
     }    
-
-    public static T Clone<T>(T obj, Dictionary<object, object> twins,
-      IEnumerable<ICompoundSerializer> compoundSerializers) {
+  }
+
+  class CloningFactory {
+
+    private static CloningFactory instance = new CloningFactory();
+
+    public static T DefaultClone<T>(T obj) {
+      return instance.Clone(obj);
+    }
+
+    private List<ICompoundSerializer> compoundSerializers;
+
+    public CloningFactory(IEnumerable<ICompoundSerializer> compoundSerializers) {
+      this.compoundSerializers = new List<ICompoundSerializer>(compoundSerializers);
+    }
+
+    public CloningFactory() :
+      this(InterfaceInstantiatior.InstantiateAll<ICompoundSerializer>()) { }
+
+    delegate object CloneMethod(object obj, Dictionary<object, object> twins);
+
+    Dictionary<Type, CloneMethod> cloneMethods = new Dictionary<Type, CloneMethod>();
+
+    public T Clone<T>(T obj) {
+      Dictionary<object, object> twins = new Dictionary<object, object>();
+      return Clone(obj, twins);
+    }
+
+    public T Clone<T>(T obj, Dictionary<object, object> twins) {
       if (obj == null)
         return default(T);
+
       ValueType t = obj as ValueType;
-      if (t != null) {
+      if (t != null)
         return (T)obj;
-      }
+
       if (twins.ContainsKey(obj))
         return (T)twins[obj];
+
       ICloneable c = obj as ICloneable;
       if (c != null) {
-        T newClone = (T)c.Clone();      
+        T newClone = (T)c.Clone();
         twins[obj] = newClone;
         return newClone;
       }
-      T newInstance = (T)Activator.CreateInstance(obj.GetType());
-      twins[obj] = newInstance;
-      Dictionary<string, DataMemberAccessor> oldAccessors = GetAutostorableAccessors(obj);
-      if (oldAccessors.Count == 0) {        
-        foreach (ICompoundSerializer serializer in compoundSerializers) {
-          if ( serializer.CanSerialize(obj.GetType()) ) {
-            IEnumerable subObjects = serializer.Serialize(obj);
-            IEnumerable clonedSubObjects = Functional.Map(subObjects,
-              (x) => Clone(x, twins, compoundSerializers));
-            return (T)serializer.DeSerialize(clonedSubObjects, obj.GetType());
+
+      Type type = obj.GetType();
+      if (!cloneMethods.ContainsKey(type))
+        cloneMethods[type] = CreateCloneMethod(type);
+      return (T)cloneMethods[type](obj, twins);
+    }
+
+    private CloneMethod CreateCloneMethod(Type type) {
+      if (type.GetConstructor(new Type[] { type }) != null)
+        return CopyConstructorCloneMethod.Create(type);
+      foreach (ICompoundSerializer serializer in compoundSerializers)
+        if (serializer.CanSerialize(type))
+          return CompoundSerializerCloneMethod.Create(serializer, type, this);
+      return StorableAccessorCloneMethod.Create(type, this);      
+    }
+
+    class CopyConstructorCloneMethod {
+      public static CloneMethod Create(Type type) {
+        return new CopyConstructorCloneMethod(type).method;
+      }
+      private ConstructorInfo constructorInfo;
+      public CopyConstructorCloneMethod(Type type) {
+        this.constructorInfo = type.GetConstructor(new Type[] { type });
+      }
+
+      object method(object obj, Dictionary<object, object> twins) {
+        object newInstance = constructorInfo.Invoke(new object[] { obj });
+        twins.Add(obj, newInstance);
+        return newInstance;
+      }
+    }
+
+    class CompoundSerializerCloneMethod {
+      public static CloneMethod Create(ICompoundSerializer serializer,
+          Type type, CloningFactory factory) {
+        return new CompoundSerializerCloneMethod(serializer, type, factory).method;
+      }
+      private ICompoundSerializer serializer;
+      private Type type;
+      private CloningFactory factory;
+      public CompoundSerializerCloneMethod(ICompoundSerializer serializer,
+          Type type, CloningFactory factory) {
+        this.serializer = serializer;
+        this.type = type;
+        this.factory = factory;
+      }
+      object method(object obj, Dictionary<object, object> twins) {
+        return serializer.DeSerialize(
+          Functional.Map(
+            serializer.Serialize(obj),
+            (o) => factory.Clone(o, twins)),
+          type);
+      }
+    }
+
+    class StorableAccessorCloneMethod {
+
+      delegate object Getter(object target);
+      delegate void Setter(object target, object value);
+
+      struct FieldAccessor {      
+        public Getter Getter;
+        public Setter Setter;
+        public FieldAccessor(Getter getter, Setter setter) {
+          this.Getter = getter;
+          this.Setter = setter;
+        }
+      }
+
+      private const BindingFlags INSTANCE_MEMBERS =
+        BindingFlags.Instance |
+        BindingFlags.Public |
+        BindingFlags.NonPublic;
+
+      public static CloneMethod Create(Type type, CloningFactory factory) {
+        return new StorableAccessorCloneMethod(type, factory).method;
+      }
+
+      private List<FieldAccessor> fieldAccessors;
+      private CloningFactory factory;
+         
+      public StorableAccessorCloneMethod(Type type, CloningFactory factory) {
+        this.factory = factory;
+        this.fieldAccessors = new List<FieldAccessor>();
+        foreach (MemberInfo memberInfo in type.GetMembers(INSTANCE_MEMBERS)) {
+          foreach (object attribute in memberInfo.GetCustomAttributes(false)) {
+            StorableAttribute autoStorableAttribute =
+              attribute as StorableAttribute;
+            if (autoStorableAttribute != null) {
+              if (memberInfo.MemberType == MemberTypes.Field) {
+                FieldInfo fi = (FieldInfo)memberInfo;
+                fieldAccessors.Add(new FieldAccessor(
+                  fi.GetValue,
+                  fi.SetValue));
+              } else if (memberInfo.MemberType == MemberTypes.Property) {
+                PropertyInfo pi = (PropertyInfo)memberInfo;
+                fieldAccessors.Add(new FieldAccessor(
+                  (target) => pi.GetValue(target, null),
+                  (target, value) => pi.SetValue(target, value, null)));
+              }
+            }
           }
         }
-        // TODO: fallback with memberwise clone?
-        throw new ApplicationException("cannot continue cloning, reached a dead end");
-      }
-      Dictionary<string, DataMemberAccessor> newAccessors = GetAutostorableAccessors(newInstance);
-      foreach (KeyValuePair<string, DataMemberAccessor> nameAccess in oldAccessors) {
-        newAccessors[nameAccess.Key].Set(Clone(nameAccess.Value.Get(), twins, compoundSerializers));
-      }
-      return newInstance;
+      }
+      object method(object obj, Dictionary<object, object> twins) {
+        object newInstance = Activator.CreateInstance(obj.GetType());
+        twins.Add(obj, newInstance);
+        foreach (FieldAccessor fa in this.fieldAccessors) {
+          fa.Setter(newInstance, factory.Clone(fa.Getter(obj), twins));
+        }
+        return newInstance;
+      }
     }
   }
-
+  
   public interface IDataMemberAccessor {
     string Name { get; }
@@ -200 +299 @@
   }
 
-
-  
-
 }