C>>>>Киньте ссылкой в готовую реализацию, буду благодарен.

G_>Сам использую, особых проблем со скоростью освобождения не замечал (правда просто boost::pool в связке с перегруженными для класса операторами new/delete) Объектов в среднем 1-2М

#include <iostream>
#include <vector>
#include <ctime>
#include <boost\pool\object_pool.hpp>

struct X
{
    int i;
};

boost::object_pool<X> pool_alloc;

void* free_list=0;
X* new_x()
{
    if (free_list != NULL)                
    {                                    
        void * res = free_list;             
        free_list = *(void **)free_list;     
        return (X*)res;                           
    }                                        
    return new X;
}   
void delete_x(X* ptr)
{
    if (ptr == NULL) return;                       
    *(void **)ptr = free_list;                      
    free_list = ptr;  
}

const int n = 50000;
const int m = 10;
std::vector<X*> ptrs(n);

void run1()
{
    clock_t start = clock();
    for (int j=0; j<m; ++j)
    {
        for (int i=0; i<n; ++i)
        {
            ptrs[i] = pool_alloc.construct();
        }
        for (int i=0; i<n; ++i)
        {
            pool_alloc.destroy(ptrs[i]);
        }
    }
    clock_t finish = clock();
    printf ("Pool alloc takes %g sec.\n", (double)(finish - start) / CLOCKS_PER_SEC);
}

void run2()
{
    clock_t start = clock();
    for (int j=0; j<m; ++j)
    {
        for (int i=0; i<n; ++i)
        {
            ptrs[i] = new X;
        }
        for (int i=0; i<n; ++i)
        {
            delete ptrs[i];
        }
    }
    clock_t finish = clock();
    printf ("New/delete takes %g sec.\n", (double)(finish - start) / CLOCKS_PER_SEC);
}


int main()
{
    run1();
    run2();
    return 0;
}

Pool alloc takes 21.587 sec.
New/delete takes 0.04 sec.

C>Киньте ссылкой в готовую реализацию, буду благодарен.

#define STORAGE
//__declspec(thread)


namespace MWinnie
{

  namespace Detail
  {
    template <bool, class T1, class T2>
    struct SelectType: public T1
    {
    };

    template <class T1, class T2>
    struct SelectType<false, T1, T2> : public T2
    {
    };

    enum { USE_OPERATOR_NEW = 512 };

    struct SChunkHeader
    {
      SChunkHeader *m_pNext;
    };

    struct FreeBlock
    {
      FreeBlock *m_pNext;
    };

    struct SThreadAllocatorState
    {
      SThreadAllocatorState *m_pNext;
      void (*Cleaner)();
      SChunkHeader *m_pChunksHead;
      FreeBlock *m_pFirstFree;
    };

    STORAGE SThreadAllocatorState *pThreadAllocatorStates;


    //STATIC_ASSERT (идея Андрея Александреску)_____________________________
    template<bool>
    struct CompileTimeChecker
    {
      CompileTimeChecker(...);
      operator int();
    };
    template<> struct CompileTimeChecker<false> { operator int(); };

#define STATIC_ASSERT(expr, msg)                      \
    {                                      \
    class ERROR_##msg {};                          \
    (void)sizeof( ( int )CompileTimeChecker<(expr) != 0>((ERROR_##msg())));  \
    }


    template <size_t SIZE, size_t CHUNK_SIZE> class CFreeListSizedAllocator
    {

    private:

      STORAGE
        static SThreadAllocatorState ThreadAllocatorState;

      static void Cleaner()
      {
        SChunkHeader *pChunk = ThreadAllocatorState.m_pChunksHead;
        while (pChunk)
        {
          SChunkHeader *pNext = pChunk->m_pNext;
          delete[] (char*)pChunk;
          pChunk = pNext;
        }

        //std::cout << SIZE <<' ';
      }

      static __declspec(noinline) void NewChunk()
      {
        if (!ThreadAllocatorState.m_pChunksHead)
        {
          //добавляем себя в односвязный список аллокаторов, которым нужно сделать Clean при выходе из потока.
          ThreadAllocatorState.m_pNext = pThreadAllocatorStates;
          ThreadAllocatorState.Cleaner = Cleaner;
          pThreadAllocatorStates = &ThreadAllocatorState;
        }
        SChunkHeader *pNewChunk = (SChunkHeader*)new char[CHUNK_SIZE+sizeof(SChunkHeader)];
        pNewChunk->m_pNext = ThreadAllocatorState.m_pChunksHead;
        ThreadAllocatorState.m_pChunksHead = pNewChunk;
        char *pChunkStorage = (char *)(pNewChunk+1);

        // если здесь не компилится, значит не хватает размера чанка для хранения минимум 1 элемента
        STATIC_ASSERT((CHUNK_SIZE + sizeof(SChunkHeader)) > SIZE, CHECK_CHUNK_SIZE_FAILED);

        const size_t NumBlocksInChunk = CHUNK_SIZE/SIZE - 1;
        for (int i=NumBlocksInChunk; i >= 0 ; --i)
        {
          FreeBlock *pFree = (FreeBlock*)(pChunkStorage + i*SIZE);
          pFree->m_pNext = (FreeBlock*)ThreadAllocatorState.m_pFirstFree;
          ThreadAllocatorState.m_pFirstFree = pFree;
        }
      }

    public:

      static void *Allocate()
      {
        if (!ThreadAllocatorState.m_pFirstFree)
          NewChunk();
        FreeBlock *pFree = ThreadAllocatorState.m_pFirstFree;
        ThreadAllocatorState.m_pFirstFree = pFree->m_pNext;
        return pFree;
      }

      static void Deallocate(void *p)
      {
        FreeBlock *pFree = (FreeBlock*)p;
        pFree->m_pNext =  ThreadAllocatorState.m_pFirstFree;
        ThreadAllocatorState.m_pFirstFree = pFree;
      }
    };

#undef STATIC_ASSERT

    template <size_t SIZE, size_t CHUNK_SIZE>
    SThreadAllocatorState CFreeListSizedAllocator<SIZE, CHUNK_SIZE>::ThreadAllocatorState;

    template <size_t SIZE>
    class COperatorNewSizedAllocator
    {
    public:
      static void *Allocate()
      {
        return new char[SIZE];
      }

      static void Deallocate(void *p)
      {
        delete[] (char*)p;
      }
    };

    template <size_t SIZE, size_t CHUNK_SIZE = 4092>  class CSizedAllocator: public SelectType<
      SIZE <= USE_OPERATOR_NEW,
      CFreeListSizedAllocator<SIZE >= sizeof(FreeBlock) ? SIZE : sizeof(FreeBlock), CHUNK_SIZE>,
      COperatorNewSizedAllocator<SIZE> >
    {
    };

  }// namespace Detail

  void CleanThreadAllocatorState()
  {
    for (
      Detail::SThreadAllocatorState *pThreadState = Detail::pThreadAllocatorStates;
      pThreadState;
    pThreadState = pThreadState->m_pNext)
      pThreadState->Cleaner();
  };

  // MihaPro: 4092 = это 4K размер без 4х байт для указателя
  /*template <class T, size_t CHUNK_SIZE = 4092> class CFastPoolAllocator
  {
  public:
    typedef T *pointer;
    typedef const T *const_pointer;
    typedef ptrdiff_t difference_type;
    typedef T &reference;
    typedef const T &const_reference;
    typedef size_t size_type;
    typedef T value_type;

    template <class U, size_t CHUNK_SIZE>
    CFastPoolAllocator(const CFastPoolAllocator<U, CHUNK_SIZE> &in_Other) {};

    CFastPoolAllocator() {}

    pointer address(reference in_X) const { return &in_X; }
    const_pointer address(const_reference in_X) const { return &in_X; }
    size_type max_size() const { return size_t(-1)/sizeof(T); }

    pointer allocate(size_type in_Count = 1, void * = 0)
    {
      if (in_Count != 1)
        return (T*)new char[in_Count*sizeof(T)];
      return (T*)Detail::CSizedAllocator<sizeof(T), CHUNK_SIZE>::Allocate();
    }

    void deallocate(pointer p, size_type in_Count = 1)
    {
      if (in_Count != 1)
      {
        delete[] (char*)p;
        return;
      }
      Detail::CSizedAllocator<sizeof(T), CHUNK_SIZE>::Deallocate(p);
    }

    void construct(pointer out_p, const value_type &in_Val)
    {
      new (out_p)T(in_Val);
    }

    void destroy(pointer p)
    {
      p->~T();
    }

    template <class U>
    struct rebind
    {
      typedef CFastPoolAllocator<U, CHUNK_SIZE> other;
    };
  };*/
} //namespace MWinnie

struct AAAA
{
            void *operator new( size_t real_size)
            {
                return MWinnie::Detail::CSizedAllocator<sizeof(AAAA)>::Allocate();
            }
            void operator delete( void * p)
            {
                MWinnie::Detail::CSizedAllocator<sizeof(AAAA)>::Deallocate(p);
            }
};

Pool alloc takes 21.587 sec.
D14>New/delete takes 0.04 sec.
D14>

void run1()
{
    boost::object_pool<X> pool_alloc;
    clock_t start = clock();
    for (int j=0; j<m; ++j)
    {
        for (int i=0; i<n; ++i)
        {
            ptrs[i] = pool_alloc.construct();
        }
        //for (int i=0; i<n; ++i)
        //{
        //    pool_alloc.destroy(ptrs[i]);
        //}
    }
    clock_t finish = clock();
    printf ("Pool alloc takes %g sec.\n", (double)(finish - start) / CLOCKS_PER_SEC);
}

free_list = *(void **)free_list;//тут, как я понял, вы присваиваете указателю его же значение?

#include <iostream>
#include <vector>
#include <ctime>
#include <boost\pool\pool.hpp>

template<class Resource, int PoolSize>
class ResourcePool
{
public:
    static void* operator new(size_t size)
    {
        if(!s_pool || size != sizeof(Resource))
            return ::operator new(size);

        void* ptr = 0;
        {
            ptr = s_pool->malloc();
            if(!ptr)
            {
                static const std::bad_alloc nomem;
                throw nomem;
            }
            ++s_usecount;
            s_pool->set_next_size(PoolSize);
        }
        return ptr;
    }
    static void operator delete(void* ptr)
    {
        if(!s_pool)
            ::operator delete(ptr);
        else
        {
            --s_usecount;
            s_pool->free(ptr);
        }
    }
public:
    static void InitPool()
    {
        if(!s_pool)
        {
            s_pool = new boost::pool<>(sizeof(Resource), PoolSize);
        }
    }
    static void DestroyPool()
    {
        if(s_pool)
        {
            delete s_pool;
            s_pool = 0;
        }
    }
    static size_t UseCount()
    {
        return s_usecount;
    }
private:
    static void *operator new[](std::size_t);
    static void operator delete[](void*);
    static boost::pool<>* s_pool;
    static size_t s_usecount;
};
template<class Resource, int PoolSize>
boost::pool<>* ResourcePool<Resource, PoolSize>::s_pool(0);
template<class Resource, int PoolSize>
size_t ResourcePool<Resource, PoolSize>::s_usecount(0);


struct X : public ResourcePool<X, 100000>
{
    int i;
};

const int n = 500000;
const int m = 10;
std::vector<X*> ptrs(n);

void run()
{
    clock_t start = clock();
    for (int j=0; j<m; ++j)
    {
        for (int i=0; i<n; ++i)
        {
            ptrs[i] = new X;
        }
        for (int i=0; i<n; ++i)
        {
            delete ptrs[i];
        }
    }
    clock_t finish = clock();
    printf ("Run() takes %g sec.\n", (double)(finish - start) / CLOCKS_PER_SEC);
}

int _tmain(int argc, _TCHAR* argv[])
{
    printf("Running generic new/delete: ");
    run();

    printf("Running overloaded new/delete: ");
    X::InitPool();
    run();
    X::DestroyPool();

    return 0;
}

Running generic new/delete: Run() takes 0.788 sec.
Running overloaded new/delete: Run() takes 0.05 sec.

C>Киньте ссылкой в готовую реализацию, буду благодарен.

inline size_t slab_allocator_granularity_init()
{
    SYSTEM_INFO info = {};
    GetSystemInfo(&info);
    return (size_t)info.dwAllocationGranularity;
}

size_t const slab_allocator_granularity = slab_allocator_granularity_init();

template<typename T>
class slab_allocator
{
public:
    slab_allocator()
        : head_()
    {
    }

    void* allocate()
    {
        void* mem = head_;
        if (mem)
        {
            head_ = *(void**)mem;
            return (T*)mem;
        }
        else
        {
            return alloc_slow();
        }
    }

    void deallocate(void* mem)
    {
        *(void**)mem = head_;
        head_ = mem;
    }

private:
    static size_t const sz = sizeof(T) >= sizeof(void*) ? sizeof(T) : sizeof(void*);

    void* head_;

    __declspec(noinline)
    void* alloc_slow()
    {
        void* mem = VirtualAlloc(0, slab_allocator_granularity, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
        if (mem == 0)
            throw bad_alloc();
        char* head = 0;
        char* pos = (char*)mem;
        char* end = pos + slab_allocator_granularity;
        for (; pos + sz <= end; pos += sz)
        {
            *(char**)pos = head;
            head = pos;
        }
        head_ = head;
        return allocate();
    }

    slab_allocator(slab_allocator const&)
    void operator = (slab_allocator const&);
};