Changeset 14745 for branches/PushGP/HeuristicLab.PushGP/TestPooling/Pool/ManagedPoolProvider.cs

Timestamp:

03/11/17 12:42:31 (7 years ago)

Author:

pkimmesw

Message:

#2665 Merged ExecExpandExpression and PushProgram due to performance reasons, Tested managed object pooling

File:

• branches/PushGP/HeuristicLab.PushGP/TestPooling/Pool/ManagedPoolProvider.cs (modified) (1 diff)

branches/PushGP/HeuristicLab.PushGP/TestPooling/Pool/ManagedPoolProvider.cs

@@ -1 @@
-//using System;
+using System;
 
-//namespace TestPooling.Pool {
-//  using System.Collections.Concurrent;
-//  using System.Threading.Tasks;
+namespace TestPooling.Pool {
+  using System.Collections.Concurrent;
+  using System.Collections.Generic;
+  using System.IO;
+  using System.Linq;
+  using System.Runtime.Serialization.Formatters.Binary;
 
-//  public class ManagedPoolProvider<T> where T : class {
-//    private static readonly volatile ConcurrentStack<T[]> partitions = new ConcurrentStack<T[]>();
-//    private readonly Func<T> Factory;
-//    public readonly int PartitionSize;
+  public class ManagedPoolProvider<T> where T : class {
+    private readonly ConcurrentStack<T[]> partitions = new ConcurrentStack<T[]>();
+    private readonly ObjectPool<IManagedPool<T>> managedPools;
+    private T[] DummyPartition;
+    public readonly int PartitionSize;
 
-//    public ManagedPoolProvider(int partitionSize, Func<T> factory) {
-//      PartitionSize = partitionSize;
-//      Factory = factory;
-//    }
+    public int InstanceCount { get { return partitions.Count * PartitionSize; } }
 
-//    public T[] GetPartition() {
-//      T[] partition;
+    public ManagedPoolProvider(int partitionSize) {
+      PartitionSize = partitionSize;
+      managedPools = new ObjectPool<IManagedPool<T>>(() => new ManagedPool2<T>(this));
+    }
+    public void InitDummyPartition(Func<T> factory) {
+      DummyPartition = new T[PartitionSize];
 
-//      return partitions.TryPop(out partition) ? partition : CreatePartition();
-//    }
+      for (var i = 0; i < PartitionSize; i++) {
+        DummyPartition[i] = factory();
+      }
+    }
 
-//    public void ReleasePartitions(params T[][] partition) {
-//      partitions.PushRange(partition);
-//    }
+    public void ReleasePartitions(params T[][] partition) {
+      if (partition.Length > 0) partitions.PushRange(partition);
+    }
 
-//    public T CreateEntry() {
-//      return Factory();
-//    }
+    private T[] GetPartition() {
+      T[] partition;
+      return partitions.TryPop(out partition) ? partition : DeepArrayCopy(DummyPartition);
+    }
 
-//    private T[] CreatePartition() {
-//      //return new T[PartitionSize];
+    private static T[] DeepArrayCopy(object objectToCopy) {
+      using (var memoryStream = new MemoryStream()) {
+        var binaryFormatter = new BinaryFormatter();
 
-//      var partition = new T[PartitionSize];
+        binaryFormatter.Serialize(memoryStream, objectToCopy);
+        memoryStream.Seek(0, SeekOrigin.Begin);
 
-//      Parallel.For(0, PartitionSize, i => partition[i] = Factory());
+        return (T[])binaryFormatter.Deserialize(memoryStream);
+      }
+    }
 
-//      return partition;
-//    }
+    public IManagedPool<T> CreatePool() {
+      return managedPools.Allocate();
+    }
 
-//    public ManagedPool<T> CreatePool() {
-//      return new ManagedPool<T>(this);
-//    }
-//  }
-//}
+    private class ManagedPool2<T> : IManagedPool<T> where T : class {
+      private readonly ManagedPoolProvider<T> provider;
+      private readonly IList<T[]> partitions = new List<T[]>();
+      private T[] currentPartition;
+      private int entryIndex;
+
+      public ManagedPool2(ManagedPoolProvider<T> provider) {
+        this.provider = provider;
+        entryIndex = provider.PartitionSize;
+      }
+
+      public T Get() {
+        if (entryIndex == provider.PartitionSize) {
+          currentPartition = provider.GetPartition();
+          partitions.Add(currentPartition);
+          entryIndex = 0;
+        }
+
+        return currentPartition[entryIndex++];
+      }
+
+      public void Dispose() {
+        provider.ReleasePartitions(partitions.ToArray());
+        partitions.Clear();
+        provider.managedPools.Free(this);
+      }
+    }
+  }
+}