mem_pool.cpp

Go to the documentation of this file.

/*
 * Copyright (C) Sergey P. Derevyago, 2008-2009.
 *
 * Permission to copy, use, modify, sell and distribute this software is granted
 * provided this copyright notice appears in all copies.
 * This software is provided "as is" without express or implied warranty, and
 * with no claim as to its suitability for any purpose.
 *
 */

#include <ders/mem_pool.hpp>
#include <vector>
#include <stdio.h>
#include <ders/hash_vec.hpp>

namespace {

using namespace std;
using namespace ders;

struct mp_impl {
       static const size_t MOS1=256;
       static const size_t MOS2=8*1024;
       static const size_t SZVP=sizeof(void*);
       static const size_t SZVP8=SZVP*8;
       static const size_t HEADS1_SIZE=(MOS1-1)/SZVP+1;
       static const size_t HEADS2_SIZE=(MOS2-MOS1-1)/SZVP8+1;

       size_t max_chunk_size;
       size_t min_objs_in_chunk;
       vector<void*> chunks;
       void* heads1[HEADS1_SIZE];
       void* heads2[HEADS2_SIZE];
#ifndef NDEBUG
       hash_vec<void*, size_t> allocated;
#endif

       mp_impl(size_t mcs, size_t moic);
       ~mp_impl();

       void* new_chunk(size_t size);
       void format_new_chunk(void*& head, size_t size, size_t grid);
};

mp_impl::mp_impl(size_t mcs, size_t moic)
#ifndef NDEBUG
  : allocated(1001)
#endif
{
 assert(moic>=1);

 max_chunk_size=mcs;
 min_objs_in_chunk=moic;
 chunks.reserve(64);
 for (int i=0, end=HEADS1_SIZE; i<end; i++) heads1[i]=0;
 for (int i=0, end=HEADS2_SIZE; i<end; i++) heads2[i]=0;
}

mp_impl::~mp_impl()
{
 for (int i=0, end=chunks.size(); i<end; i++)
     operator delete(chunks[i]);
}

void* mp_impl::new_chunk(size_t size)
{
 chunks.reserve(chunks.size()+1);  // the following push_back mustn't throw
 chunks.push_back(operator new(size));

 return chunks.back();
}

void mp_impl::format_new_chunk(void*& head, size_t size, size_t grid)
{
 size_t size2=(size+grid-1)/grid*grid;

 size_t n=max_chunk_size/size2;
 if (n<min_objs_in_chunk) n=min_objs_in_chunk;

 typedef unsigned char uchar;
 uchar *first=static_cast<uchar*>(new_chunk(size2*n)),
       *last=first+size2*(n-1);

 for (uchar *ptr=first; ptr!=last; ptr+=size2)
     *reinterpret_cast<void**>(ptr)=ptr+size2;

 *reinterpret_cast<void**>(last)=head;
 head=first;
}

}  // unnamed

#define IMPL static_cast<mp_impl*>(impl)

namespace ders {  // ::ders

mem_pool::mem_pool(size_t max_chunk_size, size_t min_objs_in_chunk) :
  impl(new mp_impl(max_chunk_size, min_objs_in_chunk))
{
}

mem_pool::~mem_pool()
{
#ifndef NDEBUG
 for (int i=0; i<IMPL->allocated.size(); i++) {
     fprintf(stderr, "(%p,%d)", IMPL->allocated.key(i), (int)IMPL->allocated.
       val(i));
 }

 assert(IMPL->allocated.size()==0);
#endif
 delete IMPL;
}

void* mem_pool::allocate(size_t size)
{
 assert(size>0);
 void* ret;

 if (size<=mp_impl::MOS1) {
    void*& head=IMPL->heads1[(size-1)/mp_impl::SZVP];
    if (!head) IMPL->format_new_chunk(head, size, mp_impl::SZVP);

    ret=head;
    head=*reinterpret_cast<void**>(head);
 }
 else if (size<=mp_impl::MOS2) {
    void*& head=IMPL->heads2[(size-mp_impl::MOS1-1)/mp_impl::SZVP8];
    if (!head) IMPL->format_new_chunk(head, size, mp_impl::SZVP8);

    ret=head;
    head=*reinterpret_cast<void**>(head);
 }
 else ret=operator new(size);

#ifndef NDEBUG
 int pos=IMPL->allocated.insert(ret, size);
 assert(pos!=-1);
#endif
 return ret;
}

void mem_pool::deallocate(void* ptr, size_t size)
{
#ifndef NDEBUG
 int pos=IMPL->allocated.find(ptr);
 assert(pos!=-1);
 assert(IMPL->allocated.val(pos)==size);
 IMPL->allocated.erase(pos);
#endif

 if (size<=mp_impl::MOS1) {
    void*& head=IMPL->heads1[(size-1)/mp_impl::SZVP];

    *reinterpret_cast<void**>(ptr)=head;
    head=ptr;
 }
 else if (size<=mp_impl::MOS2) {
    void*& head=IMPL->heads2[(size-mp_impl::MOS1-1)/mp_impl::SZVP8];

    *reinterpret_cast<void**>(ptr)=head;
    head=ptr;
 }
 else operator delete(ptr);
}

}  // namespace ::ders

---