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

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, IPooledObject {
    T Get(bool reset = true);
  }

  public class ManagedPoolProvider<T> where T : class, IPooledObject {
    private readonly ConcurrentStack<T[]> partitions = new ConcurrentStack<T[]>();
    private readonly ObjectPool<IManagedPool<T>> managedPools;
    private readonly BinaryFormatter binaryFormatter = new BinaryFormatter();
    private byte[] dummyPartition;

    private readonly Func<T> factory;

    public readonly int PartitionSize;
    public readonly int MaxParitionCount;
    public const int DefaultMaxInstanceCount = 65536;

    public ManagedPoolProvider(int partitionSize, Func<T> factory, int? maxPartitionCount = null) {
      PartitionSize = partitionSize;
      MaxParitionCount = maxPartitionCount ?? DefaultMaxInstanceCount / PartitionSize;
      this.factory = factory;

      managedPools = new ObjectPool<IManagedPool<T>>(() => new ManagedPool<T>(this), MaxParitionCount);
    }
    public int InstanceCount { get { return partitions.Count * PartitionSize; } }

    private void InitDummyPartition(Func<T> factory) {
      var temp = new T[PartitionSize];

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

      using (var memoryStream = new MemoryStream()) {
        binaryFormatter.Serialize(memoryStream, temp);
        dummyPartition = memoryStream.ToArray();
      }
    }

    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 : CloneDummyPartition();
    }

    private T[] CloneDummyPartition() {
      if (dummyPartition == null)
        InitDummyPartition(factory);

      using (var memoryStream = new MemoryStream(dummyPartition)) {
        memoryStream.Seek(0, SeekOrigin.Begin);

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

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

    private class ManagedPool<T> : IManagedPool<T> where T : class, IPooledObject {
      private readonly ManagedPoolProvider<T> provider;
      private readonly IList<T[]> partitions = new List<T[]>();
      private T[] currentPartition;
      private int entryIndex;

      public ManagedPool(ManagedPoolProvider<T> provider) {
        this.provider = provider;
        entryIndex = provider.PartitionSize;
      }

      public T Get(bool reset = true) {
        if (entryIndex == provider.PartitionSize) {
          currentPartition = provider.GetPartition();
          partitions.Add(currentPartition);
          entryIndex = 0;
        }

        var entry = currentPartition[entryIndex++];

        if (reset) entry.Reset();

        return entry;
      }

      public void Dispose() {
        provider.ReleasePartitions(partitions.ToArray());
        partitions.Clear();
        entryIndex = provider.PartitionSize;
        provider.managedPools.Free(this);
      }
    }
  }
}