source: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Data/Pool/ManagedPoolProvider.cs @ 14746

using System.Collections.Generic;

namespace HeuristicLab.Problems.ProgramSynthesis.Push.Data.Pool {
  using System;
  using System.Collections.Concurrent;
  using System.IO;
  using System.Linq;
  using System.Runtime.Serialization.Formatters.Binary;

  public interface IManagedPool<T> : IDisposable where T : class {
    T Get();
  }

  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 readonly int MaxParitionCount;
    public const int DefaultMaxInstanceCount = 65536;

    public ManagedPoolProvider(int partitionSize, int maxPartitionCount = -1) {
      PartitionSize = partitionSize;

      if (maxPartitionCount <= 0) {
        MaxParitionCount = DefaultMaxInstanceCount / PartitionSize;
      }

      managedPools = new ObjectPool<IManagedPool<T>>(() => new ManagedPool2<T>(this));
    }

    public void InitDummyPartition(Func<T> factory) {
      DummyPartition = new T[PartitionSize];

      for (var i = 0; i < PartitionSize; i++) {
        DummyPartition[i] = factory();
      }
    }

    public int InstanceCount { get { return partitions.Count * PartitionSize; } }

    public void ReleasePartitions(params T[][] partition) {
      if (partitions.Count <= MaxParitionCount && partition.Length > 0)
        partitions.PushRange(partition);
    }

    private T[] GetPartition() {
      T[] partition;
      return partitions.TryPop(out partition) ? partition : DeepArrayCopy(DummyPartition);
    }

    private readonly BinaryFormatter binaryFormatter = new BinaryFormatter();
    private T[] DeepArrayCopy(object objectToCopy) {
      using (var memoryStream = new MemoryStream()) {
        binaryFormatter.Serialize(memoryStream, objectToCopy);
        memoryStream.Seek(0, SeekOrigin.Begin);

        return (T[])binaryFormatter.Deserialize(memoryStream);
      }
    }

    public IManagedPool<T> CreatePool() {
      return managedPools.Allocate();
    }

    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();
        entryIndex = provider.PartitionSize;
        provider.managedPools.Free(this);
      }
    }
  }
}