oinky 0.1.0

data/ext/include/oinky/nky_pool.hpp

@@ -0,0 +1,760 @@
+//  This source is distributed under the terms of the MIT License.  Refer 
+//  to the 'LICENSE' file for details.
+//  
+//  Copyright (c) Jacob Lacouture, 2012
+
+namespace Oinky
+{
+namespace Utils
+{
+using namespace Oinky::Errors;
+
+class nky_malloc_t
+{
+    bool in_teardown;
+public:
+    nky_malloc_t() : in_teardown(false) {}
+
+    void *malloc(uint32 size) {
+        OINKY_ASSERT(!in_teardown);
+        OINKY_ASSERT(size);
+        //  easy for now...
+        void *ptr = ::malloc(size);
+        if (!ptr) {
+            throw_error(no_resources());
+        }
+        return ptr;
+    }
+    
+    void free(void *ptr) {
+        //  For the simple allocator, obviously, we are dealing with the 
+        //  global heap, so we can't just stop freeing memory, whether in
+        //  teardowon or not.
+        ::free(ptr);
+    }
+    
+    //  Advise the allocator of future allocation.
+    //  If the allocator needs to allocate another block, it should
+    //  allocate enough to handle this set of requests.  The request
+    //  group is specified with two parameters.  One the total number of
+    //  anticipated requests, and two the aggregate size of those requests
+    //  in bytes.  This allows the allocator to compute its internal overhead
+    //  requirements more accurately than if we received only the aggregate
+    //  byte count.
+    void prepare(uint32 objcount, uint32 totalsize) {}
+
+    //  Stop tracking memory allocation.  Free can be no-op, as the entire
+    //  allocator will be torn down shortly.  No more allocations should occur.
+    //  Calling this method is idempotent.
+    void teardown() {
+        in_teardown = true;
+    }
+};
+
+//
+//  This is the dumbest pool allocator I could think of, but it works, and 
+//  it's a lot faster than malloc.
+//
+//  I can barely believe I had to write this myself, but every public 
+//  implementation I could find was significantly over or under-engineered.
+//
+class pool_allocator
+{
+    typedef boost::intrusive::list_base_hook<> list_entry;
+    typedef boost::intrusive::list<list_entry> blocklist_t;
+    
+    struct freerange
+    {
+        //  Size of run in bytes.
+        uint32 bytes : 30;
+        //  Is it free.
+        uint32 free : 1;
+        //  Is it in the free list.  (It might not be, even if it's free)
+        uint32 in_list : 1;
+        
+        static freerange zero() {
+            freerange x;
+            x.bytes = x.free = x.in_list = 0;
+            return x;
+        }
+        
+        static freerange free_in_list(uint32 bytes) {
+            freerange x;
+            x.free = x.in_list = 1;
+            x.bytes = bytes;
+            return x;
+        }
+
+        static freerange free_no_list(uint32 bytes) {
+            freerange x;
+            x.free = 1;
+            x.in_list = 0;
+            x.bytes = bytes;
+            return x;
+        }
+        
+        bool operator==(const freerange &other) const {
+            return (bytes == other.bytes) &&
+                (free == other.free) &&
+                (in_list == other.in_list);
+        }
+    };
+    
+    struct inter_space_header {
+        freerange left;
+        freerange right;
+        
+        inter_space_header *get_next() {
+            OINKY_ASSERT(right.bytes);
+            char *ptr = ((char *)(this + 1)) + right.bytes;
+            return (inter_space_header *) ptr;
+        }
+        
+        inter_space_header *get_previous() {
+            OINKY_ASSERT(left.bytes);
+            char *ptr = ((char *)(this - 1)) - left.bytes;
+            return (inter_space_header *) ptr;
+        }
+        
+        static inline const inter_space_header *block(const char *ptr) { return (const inter_space_header *)ptr; }
+        
+        static void validate_block(const inter_space_header *any) {
+            const char *begin  =(const char *)any;
+            while (block(begin)->left.bytes) {
+                //  Can't be in the list unless it's free.
+                OINKY_ASSERT(!block(begin)->left.in_list || block(begin)->left.free);
+                const char *p = begin - block(begin)->left.bytes - sizeof(inter_space_header);
+                OINKY_ASSERT(block(p)->right == block(begin)->left);
+                //  No two consecutive blocks may be in the list.
+                OINKY_ASSERT(!block(p)->left.in_list || !block(begin)->left.in_list);
+                begin = p;
+            }
+            uint32 length = *(const uint32 *)(begin - 4);
+            const char *end  =(const char *)any;
+            while (block(end)->right.bytes) {
+                //  Can't be in the list unless it's free.
+                OINKY_ASSERT(!block(end)->left.in_list || block(end)->left.free);
+                const char *n = end + block(end)->right.bytes + sizeof(inter_space_header);
+                OINKY_ASSERT(block(n)->left == block(end)->right);
+                //  No two consecutive blocks may be in the list.
+                OINKY_ASSERT(!block(n)->left.in_list || !block(end)->left.in_list);
+                end = n;
+            }
+            end += sizeof(inter_space_header);
+            OINKY_ASSERT(length == (end - begin));
+        }
+    };
+    
+    enum constants_ec { 
+        //  A free block will not be returned to the free space map unless
+        //  it is at least this large.
+        MIN_FREE_BLOCK_SIZE = 1024
+    };
+    
+    BOOST_STATIC_ASSERT(sizeof(list_entry) < MIN_FREE_BLOCK_SIZE);
+    
+    void *allocate_from_block(inter_space_header *hdr, uint32 required)
+    {
+        //  Headers should always be 8-byte aligned.
+        OINKY_ASSERT((((size_t)(char *)hdr) & 7) == 0);
+            
+        //  Preconditions.  This block should no longer be linked.
+        inter_space_header *next = hdr->get_next();
+        OINKY_ASSERT(!hdr->right.in_list);
+        OINKY_ASSERT(hdr->right.free && next->left.free);
+        OINKY_ASSERT(hdr->right.bytes == next->left.bytes);
+        OINKY_ASSERT(hdr->right.bytes >= required);
+        
+        //  
+        char *ptr = (char *)(hdr + 1);
+        required = (required + 7) & ~7;
+
+        //  If the remaining section is too small, we won't even bother 
+        //  remembering it.
+        if (hdr->right.bytes - required < 64) {
+            //  Forget this section.  We'll just over-allocate.
+            BOOST_STATIC_ASSERT(sizeof(inter_space_header) * 2 + sizeof(list_entry) <= 64);
+        } else {
+            //  Otherwise, we will turn the right portion into a new section and 
+            //  put it on the free list.
+            inter_space_header *ih = (inter_space_header *)(ptr + required);
+            ih->right.bytes = hdr->right.bytes - required - sizeof(inter_space_header);
+            ih->right.free = ih->right.in_list = 1;
+            freespace.push_front(* ::new(ih + 1) list_entry());
+            next->left = ih->right;
+            next = ih;
+            
+            hdr->right.bytes = required;
+        }
+        
+        hdr->right.free = 0;
+        next->left = hdr->right;
+        
+        return ptr;
+    }
+    
+    void free_internal(void *ptr) {
+        //  All user ptrs are 8-byte aligned.
+        OINKY_ASSERT((((size_t)ptr) & 7) == 0);
+        
+        inter_space_header *lh = ((inter_space_header *) ptr) - 1;
+        inter_space_header *rh = lh->get_next();
+
+        //  We don't need this anymore.
+        ptr = NULL;
+        
+        OINKY_ASSERT(lh->right == rh->left);
+        OINKY_ASSERT((lh->right.free | lh->right.in_list) == 0);
+        
+        //  Mark the block free.
+        lh->right.free = rh->left.free = 1;
+
+        //  Merge center block with the left if it's free.
+        if (lh->left.free) {
+            OINKY_ASSERT(lh->left.bytes);
+            inter_space_header *llh = lh->get_previous();
+            llh->right.bytes += lh->right.bytes + sizeof(inter_space_header);
+            rh->left = llh->right;
+            lh = llh;
+        }
+        
+        //  If the right is free, merge it.
+        if (rh->right.free) {
+            OINKY_ASSERT(rh->right.bytes);
+            inter_space_header *rrh = rh->get_next();
+            
+            //  If the right is in the list, remove it.
+            if (rh->right.in_list) {
+                //  Remove the right from the list.
+                OINKY_ASSERT(rh->right.free && rh->right.bytes);
+                list_entry *le = (list_entry *)(rh + 1);
+                blocklist_t::iterator j = blocklist_t::s_iterator_to(*le);
+                freespace.erase(j);
+            }
+        
+            lh->right.bytes += rh->right.bytes + sizeof(inter_space_header);
+            rrh->left = lh->right;
+            rh = rrh;
+        }
+        
+        //  Now we are ready to insert in the list.  We should have fully
+        //  merged by now.
+        OINKY_ASSERT((lh->left.free | rh->right.free) == 0);
+        
+        //  Should still be consistent.
+        OINKY_ASSERT(lh->right == rh->left);
+        
+        //  If we are in the list already, or below the size threshold for 
+        //  insertion, then exit.
+        if (lh->right.in_list || (lh->right.bytes < MIN_FREE_BLOCK_SIZE)) {
+            return;
+        }
+        
+        //  Now insert in the free list.  We insert in the back to keep the
+        //  front stable, so that we maximize locality on newly allocated objects.
+        freespace.push_back(* ::new(lh + 1) list_entry());
+        lh->right.in_list = rh->left.in_list = 1;
+    }
+    
+    void *allocate_from_block_list(uint32 required)
+    {
+        blocklist_t::iterator i = freespace.begin();
+        blocklist_t::iterator e = freespace.end();
+        while (i != e) {
+            list_entry *hook = &(*i);
+            inter_space_header *hdr = ((inter_space_header *)hook) - 1;
+            //  Why else would it be in this list?
+            OINKY_ASSERT(hdr->right.free && hdr->get_next()->left.free);
+            OINKY_ASSERT(hdr->right.in_list && hdr->get_next()->left.in_list);
+            OINKY_ASSERT(!hdr->left.in_list && !hdr->get_next()->right.in_list);
+            uint32 available = hdr->right.bytes;
+            
+            //  We should have merged during free.
+            OINKY_ASSERT(!hdr->left.free);
+            OINKY_ASSERT(!hdr->get_next()->right.free);
+            
+            //  If this block is too small and can't be merged.
+            if (available < required) {
+                //  Remove from the free list if it's not worth saving.
+                if (available < MIN_FREE_BLOCK_SIZE) {
+                    hdr->right.in_list = 0;
+                    hdr->get_next()->left.in_list = 0;
+                    blocklist_t::iterator j = i;
+                    ++i;
+                    freespace.erase(j);
+                } else {
+                    //  Otherwise try the next block.
+                    ++i;
+                }
+                continue;
+            }
+
+            //  This block will be large enough.
+            freespace.erase(i);
+            hdr->right.in_list = 0;
+            hdr->get_next()->left.in_list = 0;
+
+            //  We found a large enough block.
+            return allocate_from_block(hdr, required);
+        }
+        
+        //  If we got here, then we have no block large enough.  Allocate one.
+        inter_space_header *newblk = add_allocation(required);
+        return allocate_from_block(newblk, required);
+    }
+
+    inter_space_header *add_allocation(uint32 totalsize)
+    {
+        if (totalsize < total_allocation >> 1) {
+            totalsize = total_allocation >> 1;
+        }
+        if (totalsize < MIN_FREE_BLOCK_SIZE << 1) {
+            totalsize = MIN_FREE_BLOCK_SIZE << 1;
+        }
+        if (totalsize < min_target_alloc) {
+            totalsize = min_target_alloc;
+        }
+        
+        //  User allocations are always multiples of 8 bytes.
+        totalsize = (totalsize + 7) & ~7;
+        
+        //  Allocate 8 extra bytes so that even if we get misaligned data from 
+        //  malloc, we can fix it.
+        totalsize += sizeof(void *) + 4 + (2 * sizeof(inter_space_header)) + 8;
+        
+        char *ptr = (char *) ::malloc(totalsize);
+        if (!ptr) {
+            throw_error(no_resources());
+        }
+        total_allocation += totalsize;
+        
+        //  This list entry must be at the exact beginning of the allocation,
+        //  however aligned.
+        *(void **)ptr = allblocks;
+        allblocks = ptr;
+        
+        //  Skip the block list pointer.
+        uint32 prefix_size = sizeof(void *) + 4;
+        //  Ensure all headers and allocations are 8-byte aligned.
+        prefix_size += 8 - (((size_t)ptr + prefix_size) & 7);
+        
+        //  Now move the pointer and adjust the byte count.
+        ptr += prefix_size;
+        totalsize -= prefix_size;
+        totalsize &= ~7;
+        //  Now write the usable size.  (This is purely for debugging)
+        *(((uint32*)ptr)-1) = totalsize;
+        
+        inter_space_header *hdr = (inter_space_header *) ptr;
+        hdr->left = freerange::zero();
+        hdr->right = freerange::free_no_list(totalsize - (2 * sizeof(inter_space_header)));
+        hdr->get_next()->left = hdr->right;
+        hdr->get_next()->right = freerange::zero();
+        
+        return hdr;
+    }
+    
+    void destroy()
+    {
+        while (allblocks) {
+            void *ptr = allblocks;
+            allblocks = *(void **)allblocks;
+            ::free(ptr);
+        }
+        //  Don't bother unlinking.  Just short circuit the list destructor.
+        ::new(&freespace) blocklist_t();
+    }
+    
+    //  Linked list of allocated blocks.  (These are not freed until the 
+    //  pool is destroyed.)
+    void *allblocks;
+    //  Linked list of free space regions.
+    blocklist_t freespace;
+    
+    //  Keep track of how much we've allocated in total.  We'll grow by a percentage.
+    uint32 total_allocation;
+    uint32 min_target_alloc;
+    bool in_teardown;
+    
+public:
+    pool_allocator() : allblocks(NULL), total_allocation(0), min_target_alloc(0), in_teardown(false) {}
+    
+    ~pool_allocator() 
+    {
+        destroy();
+    }
+
+    void *malloc(uint32 size) {
+        OINKY_ASSERT(!in_teardown);
+        OINKY_ASSERT(size);
+        //  easy for now...
+        return allocate_from_block_list(size);
+    }
+    
+    void free(void *ptr) {
+        //  If we're in teardown, then we don't bother freeing each object 
+        //  individually.  We know the pool will soon be destroyed completely.
+        if (!in_teardown) {
+            free_internal(ptr);
+        }
+    }
+    
+    //  This can be called on any pointer returned by malloc but not yet freed.
+    //  It will validate the block pointers to the left and right of the 
+    //  allocated object.  It's obviously more manual and less definitive than
+    //  valgrind, but it's a lot faster too.
+    inline void validate_pool_allocation(const void *ptr) const
+    {
+#ifdef DEBUG    
+        OINKY_ASSERT((((size_t)ptr) & 7) == 0);
+        inter_space_header::validate_block(((const inter_space_header *)ptr)-1);
+#endif        
+    }
+
+    //  Advise the allocator of future allocation.
+    //  If the allocator needs to allocate another block, it should
+    //  allocate enough to handle this set of requests.  The request
+    //  group is specified with two parameters.  One the total number of
+    //  anticipated requests, and two the aggregate size of those requests
+    //  in bytes.  This allows the allocator to compute its internal overhead
+    //  requirements more accurately than if we received only the aggregate
+    //  byte count.
+    void prepare(uint32 objcount, uint32 totalsize) {
+        min_target_alloc = totalsize + ((objcount + 1) * sizeof(inter_space_header));
+    }
+
+    //  Stop tracking memory allocation.  Free can be no-op, as the entire
+    //  allocator will be torn down shortly.  No more allocations should occur.
+    //  Calling this method is idempotent.
+    void teardown() {
+        in_teardown = true;
+    }
+};
+
+//  This allows us to be more lazy/rigorous depending on whether our allocator
+//  can clean up after us.  The default is to be rigorous, so it derives
+//  from false_type.
+template<typename T>
+struct is_pooled_allocator : boost::false_type {};
+
+template<>
+struct is_pooled_allocator<pool_allocator> : boost::true_type {};
+
+//#################################################
+//##  Here is where we activate one allocator or the other at compile-time.
+
+//  The malloc allocator leaks cursor contexts, but it's useful if you suspect 
+//  a bug and want to leverage valgrind or some other such tool.
+//
+//typedef nky_malloc_t nky_allocator_t;
+
+//  The custom pool allocator relies on the same synchronization requirements
+//  as the database instance that owns it.  It's entirely unsynchronized,
+//  and it offers locality advantages even in many-instance concurrent 
+//  scenarios, where all the dynamic objects related to a particular database 
+//  are located near each other.
+typedef pool_allocator nky_allocator_t;
+
+
+//  This is basically a clone of std::vector, except it uses the DB memory
+//  allocator instead of the heap.
+template<typename T>
+class db_vector
+{
+    nky_allocator_t *alloc;
+    uint32 count;
+    uint32 reserved;
+    T* values;
+
+    void destroy()
+    {
+        //  This calls the element destructors.
+        resize(0);
+        //  Now free the memory.
+        if (values) {
+            alloc->free(values);
+            values = NULL;
+            reserved = 0;
+        }
+    }
+    
+public:
+    db_vector(const db_vector<T> &src) {
+        //  Deep copy.
+        ::new(this) db_vector<T>(src.alloc, src.begin(), src.end());
+    }
+    db_vector &operator=(const db_vector<T> &src) {
+        if (this == &src) return *this;
+        //  Construct into a tmp, so that if it raises, we are still valid.
+        db_vector tmp(src);
+        //  Nothing else can raise, so now we can safely destroy
+        //  ourselves.
+        destroy();
+        //  And transfer from tmp to self.
+        alloc = tmp.alloc;
+        count = tmp.count;
+        reserved = tmp.reserved;
+        values = tmp.values;
+        //  Make sure tmp destruction is a no-op.
+        tmp.values = NULL;
+        tmp.reserved = tmp.count = 0;
+        return *this;
+    }
+    
+    db_vector(nky_allocator_t *_alloc, uint32 _count = 0) : 
+    alloc(_alloc),
+        count(0),
+        reserved(0),
+        values(NULL)
+    {
+        //  This creates a vector of the given size, with all elements
+        //  default constructed.
+        if (_count) {
+            resize(_count);
+        }
+    }
+
+    template<typename ITR>
+    void assign(ITR begin, ITR end)
+    {
+        resize(std::distance(begin,end));
+        T *v = values;
+        for (ITR i = begin; i != end; ++i, ++v) {
+            *v = *i;
+        }
+    }
+    
+    template<typename ITR>
+    db_vector(nky_allocator_t *_alloc, ITR begin, ITR end) : 
+    alloc(_alloc),
+        count(0),
+        reserved(0),
+        values(NULL)
+    {
+        uint32 tsize = std::distance(begin,end);
+        //  This does not invoke any constructors.
+        reserve(tsize);
+        
+        //  copy construct
+        T* v = values;
+        try {
+            for (ITR i = begin; i != end; ++i, ++v) {
+                ::new(v) T(*i);
+                ++count;
+            }
+        } catch (...) {
+            while (count) {
+                --count;
+                values[count].~T();
+            }
+            throw;
+        }
+    }
+    
+    ~db_vector()
+    {
+        destroy();
+    }
+    
+    std::size_t size() const { return count; }
+    void resize(uint32 newsize) { 
+        reserve(newsize);
+
+        //  Init the new values.
+        if (newsize > count) {
+            //  default construct
+            while (count<newsize) {
+                ::new(values + count) T();
+                ++count;
+            }
+        } else {
+            while (count > newsize) {
+                values[count-1].~T();
+                --count;
+            }
+        }
+    }
+    void reserve(uint32 newsize) { 
+        if (reserved < newsize) {
+            //  alloc
+            T* nv = (T*) alloc->malloc(sizeof(T) * newsize);
+            //  copy construct
+            int i;
+            try {
+                for (i=0;i<count;++i) {
+                    ::new(nv + i) T(values[i]);
+                }
+            } catch (...) {
+                while (i > 0) {
+                    --i;
+                    nv[i].~T();
+                }
+                alloc->free(nv);
+                throw;
+            }
+            //  Now use new bufer.
+            //  This only changes reservation, not size.
+            if (values) {
+                for (i=0;i<count;++i) {
+                    values[i].~T();
+                }
+                alloc->free(values);
+            }
+            values = nv;
+            reserved = newsize;
+        }
+    }
+    
+    nky_allocator_t *allocator() const { return alloc; }
+    
+    typedef T* iterator;
+    typedef const T* const_iterator;
+    const T* begin() const { return values; }
+    const T* end() const { return values + count; }
+    T* begin() { return values; }
+    T* end() { return values + count; }
+    
+    T& operator[](int x) { return begin()[x]; }
+    const T& operator[](int x) const { return begin()[x]; }
+};
+
+//  Like the above, but cannot ever grow its allocation.  It does not 
+//  instantiate T's copy-constructor.  It can still be resized.
+template<typename T>
+class db_fixed_vector : boost::noncopyable
+{
+    nky_allocator_t *alloc;
+    uint32 count;
+    uint32 reserved;
+    T* values;
+    
+public:
+    db_fixed_vector(nky_allocator_t *_alloc, uint32 _count = 0) : 
+    alloc(_alloc),
+        count(0),
+        reserved(0),
+        values(NULL)
+    {
+        reserve(_count);
+        //  This creates a vector of the given size, with all elements
+        //  default constructed.
+        try {
+            while (count < _count) {
+                ::new(values + count) T();
+                ++count;
+            }
+        } catch (...) {
+            while (count) {
+                --count;
+                values[count].~T();
+            }
+            throw;
+        }
+    }
+    
+    template<typename ITR>
+    db_fixed_vector(nky_allocator_t *_alloc, ITR begin, ITR end) : 
+    alloc(_alloc),
+        count(0),
+        reserved(0),
+        values(NULL)
+    {
+        uint32 tsize = std::distance(begin,end);
+        //  This does not invoke any constructors.
+        reserve(tsize);
+        
+        //  construct.  This can be copy-constuct or whatever.  Note that
+        //  this method doesn't instantiate the copy constructor unless 
+        //  someone calls it with an ITR that evaluates to T.
+        T* v = values;
+        try {
+            for (ITR i = begin; i != end; ++i, ++v) {
+                ::new(v) T(*i);
+                ++count;
+            }
+        } catch (...) {
+            while (count) {
+                --count;
+                values[count].~T();
+            }
+            throw;
+        }
+    }
+    
+    ~db_fixed_vector()
+    {
+        //  This calls the element destructors.
+        resize(0);
+        //  Now free the memory.
+        if (values) {
+            alloc->free(values);
+            values = NULL;
+            reserved = 0;
+        }
+    }
+    
+    std::size_t size() const { return count; }
+    void resize(uint32 newsize) { 
+        if (count && (newsize > reserved)) {
+            throw_error(invalid_argument());
+        }
+
+        //  Init the new values.
+        if (newsize > count) {
+            reserve(newsize);
+            
+            //  default construct
+            while (count<newsize) {
+                ::new(values + count) T();
+                ++count;
+            }
+        } else {
+            while (count > newsize) {
+                --count;
+                values[count].~T();
+            }
+        }
+    }
+    void reserve(uint32 newsize) { 
+        if (count && newsize) {
+            OINKY_ASSERT(false);
+            throw_error(invalid_argument());
+        }
+        if (newsize <= reserved) {
+            return;
+        }
+        OINKY_ASSERT(count == 0);
+        
+        //  NOTE:  We don't actually care if we've already reserved.
+        //  The point is that we can't copy-construct, which only requires
+        //  that count==0 || newsize == 0.
+        //OINKY_ASSERT(reseved == 0);
+        //OINKY_ASSERT(!values);
+        if (values) {
+            alloc->free(values);
+            values = NULL;
+            reserved = 0;
+            count = 0;
+        }
+        if (newsize) {
+            //  alloc.  We don't construct until resize.
+            values = (T*) alloc->malloc(sizeof(T) * newsize);
+            reserved = newsize;
+        }
+    }
+    
+    typedef T* iterator;
+    typedef const T* const_iterator;
+    const T* begin() const { return values; }
+    const T* end() const { return values + count; }
+    T* begin() { return values; }
+    T* end() { return values + count; }
+    
+    T& operator[](int x) { return begin()[x]; }
+    const T& operator[](int x) const { return begin()[x]; }
+};
+
+
+} //namespace Utils
+} //namespace Oinky
+