class SemiLocalPool : ISubPool
    {
        private const int SHARED_PRIME = 50;

        private const int LOCAL_PRIME = 20;
        private const int LOCAL_MAX = 1000;

 
        [ThreadStatic]
        private static Stack<object> t_localPool;

 
        private Type m_type;
        private Stack<object> m_sharedPool;

 
        public SemiLocalPool(Type type)
        {
            m_sharedPool = new Stack<object>(SHARED_PRIME);

            m_type = type;
 
            for (int i = 0; i < SHARED_PRIME; i++)
            {
                object sharedObj = Activator.CreateInstance(m_type);

                m_sharedPool.Push(sharedObj);
            }
        }
 
        public static void Init()

        {
            t_localPool = new Stack<object>(LOCAL_PRIME);
        }
 
        public object Allocate()

        {
            // first, try to allocate from the local pool
            if (t_localPool.Count > 0)
            {
                object localObj = t_localPool.Pop();

                return localObj;
            }
 
            int allocated = 0;
 
            lock (m_sharedPool)

            {
                // pass objects from shared to local pool
                for (; m_sharedPool.Count > 0 && allocated < LOCAL_PRIME - 1; allocated++)

                {
                    object sharedObj = m_sharedPool.Pop();
                    t_localPool.Push(sharedObj);
                }
 
                // prime share pool

                if (m_sharedPool.Count == 0)
                {
                    for (int i = 0; i < SHARED_PRIME; i++)

                    {
                        // bad practice: holding the lock while executing external code
                        object sharedObj = Activator.CreateInstance(m_type);

                        m_sharedPool.Push(sharedObj);
                    }
                }
            }
 
            // if the shared pool didn't contain enough elements, prime the remaining items

            for (; allocated < LOCAL_PRIME - 1; allocated++)
            {
                object newAlloc = Activator.CreateInstance(m_type);

                t_localPool.Push(newAlloc);
            }
 
 
            object fromLocal = Activator.CreateInstance(m_type);

            return fromLocal;
        }
 
        public void Free(object obj)

        {
            // first return to local pool
            if (t_localPool.Count < LOCAL_MAX)
            {
                t_localPool.Push(obj);

                return;
            }
 
            // only after reaching LOCAL_MAX push back to the shared pool
            lock (m_sharedPool)

            {
                m_sharedPool.Push(obj);
            }
        }
    }

    public class CategorizedMainPool

    {
        private Dictionary<string, SimpleMainPool> m_main;

 
        public CategorizedMainPool(Tuple<string, Type[]>[] pooledCategories)

        {
            m_main = new Dictionary<string, SimpleMainPool>();

 
            foreach (Tuple<string, Type[]> curCategory in pooledCategories)

            {
                SimpleMainPool curSub = new SimpleMainPool(curCategory.Item2);

                m_main.Add(curCategory.Item1, curSub);
            }
        }
 
        public object Allocate(string category, Type type)

        {
            SimpleMainPool sub = m_main[category];
 
            object pooledObj = sub.Allocate(type);
            return pooledObj;

        }
 
        public void Free(string category, object obj)
        {

            SimpleMainPool sub = m_main[catagory];
            sub.Free(obj);
        }
    }