src/commons/region.h

// TODO: use shared_ptr instead of custom ref counting?

#ifndef COMMONS_REGION_H
#define COMMONS_REGION_H

#include <limits>

// XXX: debug
#include <set>
#include <vector>
#include <pthread.h>

namespace commons
{

  using namespace std;

  const size_t default_chunk_size = 10000000;

  struct chunk
  {
    size_t size;
    char* data;
  };

  class mem_region
  {
  private:
    vector<chunk> chunks;
    const size_t chunk_size;
    size_t top;
    int    refcount;
    set<pthread_t> threads;

  public:
    mem_region() :
      chunk_size(default_chunk_size),
      top(0),
      refcount(0)
    {
      // cout << "created " << this << endl;
      chunks.push_back((chunk) {chunk_size, new char[chunk_size]});
    }

    ~mem_region()
    {
      // cout << "deleting" << endl;
      for (unsigned int i = 0; i < chunks.size(); i++) {
        delete [] chunks[i].data;
      }
    }

    void addref() { ++refcount; }
    void decref() { if (--refcount == 0) { delete this; } }

    void *alloc_mem(size_t n)
    {
      // pthread_t t = pthread_self();
      // if (threads.insert(t).second)
        // cout << this << " -- " << t << endl;

      chunk* last = &chunks.back();
      if (top + n > last->size) {
        size_t sz = max(n, chunk_size);
        chunk c = {sz, new char[sz]};
        if (n > chunk_size) {
          // cout << "insert " << this << endl;
          chunks.insert(chunks.begin(), c);
          return c.data;
        } else {
          // cout << "append " << this << endl;
          chunks.push_back(c);
          top = 0;
          last = &chunks.back();
        }
      }
      // cout << "ALLOC " << this << endl;
      size_t old_top = top;
      top += n;
      return last->data + old_top;
    }
  };

  template <class T>
  class region_alloc {
  public:
    // Type definitions.
    typedef T              value_type;
    typedef T*             pointer;
    typedef const T*       const_pointer;
    typedef T&             reference;
    typedef const T&       const_reference;
    typedef std::size_t    size_type;
    typedef std::ptrdiff_t difference_type;

    typedef mem_region     pool_type;

    template <class U>
    struct rebind {
      typedef region_alloc<U> other;
    };

    pointer address (reference value) const { return &value; }
    const_pointer address (const_reference value) const { return &value; }

    region_alloc() throw() {
      region = new pool_type;
      region->addref();
    }

    region_alloc(const region_alloc& src) throw() {
      region = src.region;
      region->addref();
    }

    template <class U>
    region_alloc (const region_alloc<U> &src) throw() {
      region = src.region;
      region->addref();
    }

    ~region_alloc() throw() { region->decref(); }

    size_type max_size() const throw()
    {
      return numeric_limits<size_t>::max() / sizeof(T);
    }

    pointer allocate(size_type num, const void* = 0)
    {
      return reinterpret_cast<pointer>(region->alloc_mem(num * sizeof(T)));
    }

    void construct(pointer p, const T& value) {
      new (static_cast<void*>(p)) T(value);
    }

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

    void deallocate(pointer p, size_type num) {}

    // TODO: why can't this be private? (cp ctor fails)
    pool_type  *region;
  };

  template <class T1, class T2>
  bool operator== (const region_alloc<T1>&, const region_alloc<T2>&) throw() {
    return true;
  }

  template <class T1, class T2>
  bool operator!= (const region_alloc<T1>&, const region_alloc<T2>&) throw() {
    return false;
  }

}

#endif

---