Re: a simple type-based C++ region allocator...

"Chris M. Thomasson" <no@spam.invalid> wrote in message
news:gfv4h3$cb5$1@aioe.org...


^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

ARGHH23$#@$@#!!!!

DAMNIT!!!!

Okay, I make error here... The call to flush should NOT be in the darn ctor
of the `flush_guard' object!

Sorry about that non-sense!

[...]

Here is full fixed code:
______________________________________________________________________
#include <cassert>
#include <cstdlib>
#include <new>
#include <list>

template<typename T, std::size_t BUFDEPTH = 1024>
class region_allocator {
  struct region {
    T m_buf[BUFDEPTH];
    std::size_t m_idx;

    void ctor() {
      m_idx = 0;
    }

    void dtor() {
      for (std::size_t i = 0; i < m_idx; ++i) {
        m_buf[i].~T();
      }
    }

    void* allocate() {
      std::size_t const idx = m_idx;
      if (idx + 1 > BUFDEPTH) {
        return NULL;
      }
      return (void*)&m_buf[idx];
    }

    void commit() {
      ++m_idx;
    }

    void flush() {
      dtor();
      ctor();
    }
  };

  std::list<region*> m_regions;

  struct allocation {
    region* m_region;
    void* m_mem;
  };

  region* prv_expand(){
    region* r = (region*)std::malloc(sizeof(*r));
    if (! r) {
      throw std::bad_alloc();
    };
    r->ctor();
    m_regions.push_front(r);
    return r;
  }

  inline void prv_allocate(allocation* const a) {
    typename std::list<region*>::iterator i;
    for (i = m_regions.begin(); i != m_regions.end(); ++i) {
      a->m_mem = (*i)->allocate();
      if (a->m_mem) {
        a->m_region = (*i);
        return;
      }
    }
    a->m_region = prv_expand();
    a->m_mem = a->m_region->allocate();
    assert(a->m_mem);
  }

  #define REGION_PRV_ALLOCATE(mp_params) \
    allocation a; \
    prv_allocate(&a); \
    T* const obj = new (a.m_mem) T mp_params; \
    a.m_region->commit(); \
    return obj

public:
  struct flush_guard {
    region_allocator& m_ralloc;

  public:
    flush_guard(region_allocator& ralloc) : m_ralloc(ralloc) {

    }

    ~flush_guard() {
      m_ralloc.flush();
    }
  };

  region_allocator() {
    prv_expand();
  }

  ~region_allocator() {
    flush();
    std::free(m_regions.front());
    m_regions.pop_front();
  }

  void flush() {
    std::size_t const depth = m_regions.size();
    for (std::size_t i = 1; i < depth; ++i) {
      region* const r = m_regions.back();
      r->dtor();
      std::free(r);
      m_regions.pop_back();
    }
    m_regions.front()->flush();
  }

  inline T* allocate() {
    REGION_PRV_ALLOCATE(());
  }

  template<typename P1>
  inline T* allocate(P1 p1) {
    REGION_PRV_ALLOCATE((p1));
  }

  template<typename P1, typename P2>
  inline T* allocate(P1 p1, P2 p2) {
    REGION_PRV_ALLOCATE((p1, p2));
  }

  template<typename P1, typename P2, typename P3>
  inline T* allocate(P1 p1, P2 p2, P3 p3) {
    REGION_PRV_ALLOCATE((p1, p2, p3));
  }

  // [and on and on for more params...];
};

/* Usage Example
______________________________________________________________*/
#include <cstdio>
#include <string>

class foo {
  unsigned const m_id;

public:
  foo(unsigned const id) : m_id(id) {
    std::printf("(%p)->foo::foo(%u)\n", (void*)this, id);
  }

  ~foo() {
    std::printf("(%p)->foo::~foo() - %u\n", (void*)this, m_id);
  }
};

class foo2 {
  unsigned const m_id;
  std::string const m_name;

public:
  foo2(unsigned const id, std::string const name)
    : m_id(id), m_name(name) {
    std::printf("(%p)->foo2::foo2(%u, %s)\n",
     (void*)this, id, name.c_str());
  }

  ~foo2() {
    std::printf("(%p)->foo2::~foo2() - %u, %s\n",
      (void*)this, m_id, m_name.c_str());
  }
};

struct node {
  node* m_next;

  node(node* next) : m_next(next) {
    std::printf("(%p)->node::node(%p)\n",
      (void*)this, (void*)next);
  }

  ~node() {
    std::printf("(%p)->node::~node(%p)\n",
      (void*)this, (void*)m_next);
  }
};

int main(void) {
  {
    region_allocator<foo, 2> foo_alloc;

    {
      region_allocator<foo, 2>::flush_guard fguard(foo_alloc);
      foo* f1 = foo_alloc.allocate(1);
      foo* f2 = foo_alloc.allocate(2);
      foo* f3 = foo_alloc.allocate(3);
      foo* f4 = foo_alloc.allocate(4);
    }

    foo* f1 = foo_alloc.allocate(5);
    foo* f2 = foo_alloc.allocate(6);
    foo* f3 = foo_alloc.allocate(7);
    foo* f4 = foo_alloc.allocate(8);

    {
      region_allocator<foo2> foo2_alloc;
      foo2* f2_1 = foo2_alloc.allocate(123, "Chris");
      foo2* f2_2 = foo2_alloc.allocate(456, "John");
      foo2* f2_3 = foo2_alloc.allocate(789, "Amy");
      foo2* f2_4 = foo2_alloc.allocate(777, "Kim");
      foo2* f2_5 = foo2_alloc.allocate(999, "Jane");
    }

    {
      region_allocator<unsigned, 64> int_alloc;

      unsigned* a1 = int_alloc.allocate(1);
      unsigned* a2 = int_alloc.allocate(2);
      unsigned* a3 = int_alloc.allocate(3);
      unsigned* a4 = int_alloc.allocate();

      *a4 = 123456789;

      std::printf("%u - %u - %u - %u\n", *a1, *a2, *a3, *a4);
    }
  }

  {
    region_allocator<node> node_alloc;
    node* head = NULL; // linked-list

    // fill
    for (unsigned i = 0; i < 512; ++i) {
      node* n = node_alloc.allocate(head);
      head = n;
    }

    // empty list
    head = NULL;
    node_alloc.flush();

    // refill
    for (unsigned i = 0; i < 2048; ++i) {
      node* n = node_alloc.allocate(head);
      head = n;
    }
  }

  return 0;
}
______________________________________________________________________

Sorry about that stupid non-sense!

;^(....