Ticket #2020: MemoryPool_BucketAlloc.patch

lib/allocators/memory_pool.cpp

@@ +1 @@
+/* Copyright (c) 2013 Wildfire Games
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#include "precompiled.h"
+#include "memory_pool.h"
+
+
+#if MSC_VERSION // VC++
+    #define threadlocal __declspec(thread)
+#else // all others (GCC, CLANG, etc..) use __thread
+    #define threadlocal __thread
+#endif
+static threadlocal global_pool_t* _tls_pools = NULL;    // storage array for thread-local pools
+
+
+/** 
+ * Edit these values according to memory tuning data
+ * Each value represents a COUNT HINT of nodes to initially allocate per pool
+ * Buckets [0..24]      4 8 12 16 20 24 
+ * Buckets [25..64]     32 40 48 56 64 
+ * Buckets [65..128]    80 96 112 128 
+ * Buckets [129..256]   160 192 224 256 
+ * Buckets [257..1024]  384 512 640 768 896 1024
+ */
+enum E_TLS_POOLS_RESERVE_COUNT_HINTS
+{
+    POOL_4 = 4096,
+    POOL_8 = 4096,
+    POOL_12 = 4096,
+    POOL_16 = 2048,
+    POOL_20 = 1024,
+    POOL_24 = 512,
+
+    // strings that don't fit std::string static buffer fall here first
+    // so give 32 a good reserve
+    POOL_32 = 512,
+    POOL_40 = 224,
+    POOL_48 = 192,
+    POOL_56 = 160,
+    POOL_64 = 128,
+
+    // this is a pretty allocator intensive range:
+    POOL_80 = 128,
+    POOL_96 = 96,
+    POOL_112 = 64,
+    POOL_128 = 64,
+
+    POOL_160 = 48,
+    POOL_192 = 48,
+    POOL_224 = 48,
+    POOL_256 = 48,
+
+    // these esoteric ranges need a lot more tuning:
+    POOL_384 = 48,
+    POOL_512 = 32,
+    POOL_640 = 24,
+    POOL_768 = 24,
+    POOL_896 = 16,
+    POOL_1024 = 16,
+};
+
+
+
+// lookup table for _tls_pools [4..1024]
+// element index: ((TSIZE+3)/4)-1
+static unsigned char _pool_indices[256] = 
+{
+    // 0..24
+    // 4 8 12 16 20 24 
+    0,  // 4 (4)
+    1,  // 8 (8)
+    2,  // 12 (12)
+    3,  // 16 (16)
+    4,  // 20 (20)
+    5,  // 24 (24)
+
+    // 25..64
+    // 32 40 48 56 64 
+    6,      // 28 (32)
+    6,      // 32 (32)
+    7,      // 36 (40)
+    7,      // 40 (40)
+    8,      // 44 (48)
+    8,      // 48 (48)
+    9,      // 52 (56)
+    9,      // 56 (56)
+    10,     // 60 (64)
+    10,     // 64 (64)
+
+    // 65..128
+    // 80 96 112 128 
+    11,     // 68 (80)
+    11,     // 72 (80)
+    11,     // 76 (80)
+    11,     // 80 (80)
+        12,     // 84 (96)
+        12,     // 88 (96)
+        12,     // 92 (96)
+        12,     // 96 (96)
+    13,     // 100 (112)
+    13,     // 104 (112)
+    13,     // 108 (112)
+    13,     // 112 (112)
+        14,     // 116 (128)
+        14,     // 120 (128)
+        14,     // 124 (128)
+        14,     // 128 (128)
+
+    // 129..256
+    // 160 192 224 256 
+    15, 15, // (160)
+    15, 15, // (160)
+    15, 15, // (160)
+    15, 15, // (160)
+        16, 16, // (192)
+        16, 16, // (192)
+        16, 16, // (192)
+        16, 16, // (192)
+    17, 17, // (224)
+    17, 17, // (224)
+    17, 17, // (224)
+    17, 17, // (224)
+        18, 18, // (256)
+        18, 18, // (256)
+        18, 18, // (256)
+        18, 18, // (256)
+
+    // 257..1024
+    // 384 512 640 768 896 1024
+    19, 19, 19, 19, // 384
+    19, 19, 19, 19, // 384
+    19, 19, 19, 19, // 384
+    19, 19, 19, 19, // 384
+    19, 19, 19, 19, // 384
+    19, 19, 19, 19, // 384
+    19, 19, 19, 19, // 384
+    19, 19, 19, 19, // 384
+
+    20, 20, 20, 20, // 512
+    20, 20, 20, 20, // 512
+    20, 20, 20, 20, // 512
+    20, 20, 20, 20, // 512
+    20, 20, 20, 20, // 512
+    20, 20, 20, 20, // 512
+    20, 20, 20, 20, // 512
+    20, 20, 20, 20, // 512
+
+    21, 21, 21, 21, // 640
+    21, 21, 21, 21, // 640
+    21, 21, 21, 21, // 640
+    21, 21, 21, 21, // 640
+    21, 21, 21, 21, // 640
+    21, 21, 21, 21, // 640
+    21, 21, 21, 21, // 640
+    21, 21, 21, 21, // 640
+    
+    22, 22, 22, 22, // 768
+    22, 22, 22, 22, // 768
+    22, 22, 22, 22, // 768
+    22, 22, 22, 22, // 768
+    22, 22, 22, 22, // 768
+    22, 22, 22, 22, // 768
+    22, 22, 22, 22, // 768
+    22, 22, 22, 22, // 768
+    
+    23, 23, 23, 23, // 896
+    23, 23, 23, 23, // 896
+    23, 23, 23, 23, // 896
+    23, 23, 23, 23, // 896
+    23, 23, 23, 23, // 896
+    23, 23, 23, 23, // 896
+    23, 23, 23, 23, // 896
+    23, 23, 23, 23, // 896
+
+    24, 24, 24, 24, // 1024
+    24, 24, 24, 24, // 1024
+    24, 24, 24, 24, // 1024
+    24, 24, 24, 24, // 1024
+    24, 24, 24, 24, // 1024
+    24, 24, 24, 24, // 1024
+    24, 24, 24, 24, // 1024
+    24, 24, 24, 24, // 1024
+};
+
+
+
+
+static void _tls_pools_init()
+{
+    #define DYNAMIC_POOL(SIZE) global_pool_t(SIZE, POOL_##SIZE)
+
+    // allocate storage for all the pools ( we never free this )
+    _tls_pools = (global_pool_t*)malloc(sizeof(global_pool_t) * 25);
+    _tls_pools[0] = DYNAMIC_POOL(4);
+    _tls_pools[1] = DYNAMIC_POOL(8);
+    _tls_pools[2] = DYNAMIC_POOL(12);
+    _tls_pools[3] = DYNAMIC_POOL(16);
+    _tls_pools[4] = DYNAMIC_POOL(20);
+    _tls_pools[5] = DYNAMIC_POOL(24);
+    _tls_pools[6] = DYNAMIC_POOL(32);
+    _tls_pools[7] = DYNAMIC_POOL(40);
+    _tls_pools[8] = DYNAMIC_POOL(48);
+    _tls_pools[9] = DYNAMIC_POOL(56);
+    _tls_pools[10] = DYNAMIC_POOL(64);
+    _tls_pools[11] = DYNAMIC_POOL(80);
+    _tls_pools[12] = DYNAMIC_POOL(96);
+    _tls_pools[13] = DYNAMIC_POOL(112);
+    _tls_pools[14] = DYNAMIC_POOL(128);
+    _tls_pools[15] = DYNAMIC_POOL(160);
+    _tls_pools[16] = DYNAMIC_POOL(192);
+    _tls_pools[17] = DYNAMIC_POOL(224);
+    _tls_pools[18] = DYNAMIC_POOL(256);
+    _tls_pools[19] = DYNAMIC_POOL(384);
+    _tls_pools[20] = DYNAMIC_POOL(512);
+    _tls_pools[21] = DYNAMIC_POOL(640);
+    _tls_pools[22] = DYNAMIC_POOL(768);
+    _tls_pools[23] = DYNAMIC_POOL(896);
+    _tls_pools[24] = DYNAMIC_POOL(1024);
+}
+
+
+
+global_pool_t* _get_tls_pool(unsigned int requestSize)
+{
+    if(!_tls_pools) // this thread has not initialized the _tls_pools array?
+    {
+        _tls_pools_init(); // initialize the pools for this thread
+    }
+
+    // calculating the index: alignto4(requestSize) / 4  -  1
+    const uint32_t index = (uint32_t)_pool_indices[ ((requestSize + 3) >> 2) - 1 ];
+    return &_tls_pools[index];
+}

lib/allocators/memory_pool.h

@@ +1 @@
+/* Copyright (c) 2013 Wildfire Games
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef INCLUDED_MEMORY_POOL
+#define INCLUDED_MEMORY_POOL
+
+
+/**
+ * @author Jorma Rebane
+ * @date 2013.06.27
+ *
+ * We're using a SIZE based Pool.
+ * This is useful if you use memory pools a lot and want
+ * to share the pools accross many different types.
+ *
+ * The STL-compatible bucket_allocator<T> is an interface on top of a
+ * collection of Thread-Local memory pools, indexed by the request size in bytes.
+ * The maximum request size for bucket_allocator<T> is 1024 bytes. For all other cases
+ * the standard malloc is used instead.
+ */
+
+#include <lib/debug.h> // ENSURE
+#include <stdlib.h> // malloc/free
+#include <string.h> // memmove
+#include <stdint.h> // uint32_t
+#include <memory>   // std::allocator
+
+
+
+
+#define ENABLE_POOL_DEBUGGING_DEBUG 1 // enable pool debugging in Debug mode?
+#define ENABLE_POOL_DEBUGGING_RELEASE 0 // enable pool debugging in Release mode?
+
+
+// For auto-calculating the initial capacity of pools. Very crude.
+// This is why you should always 'know better' and give a size hint to your pool!
+#define POOL_AUTOSIZE(TSIZE) ((TSIZE <= 128) ? 8192/TSIZE : (8192*2)/TSIZE)
+
+
+// maximum bucket size for the global allocator
+#define POOL_MAX_BUCKET_SIZE 1024
+
+
+
+
+
+
+
+
+// dummy type for setting the dynamic_pool GC value
+typedef bool pool_gc_t;
+const pool_gc_t use_gc = (pool_gc_t)true;
+const pool_gc_t no_gc = (pool_gc_t)false;
+
+
+#ifdef NDEBUG // release?
+    #define POOL_NDEBUG !ENABLE_POOL_DEBUGGING_RELEASE // is pool debugging disabled? pool:no-debug
+    #define POOL_DEBUG ENABLE_POOL_DEBUGGING_RELEASE // is pool debugging enabled? pool:debug
+#else
+    #define POOL_NDEBUG !ENABLE_POOL_DEBUGGING_DEBUG // is pool debugging disabled? pool:no-debug
+    #define POOL_DEBUG ENABLE_POOL_DEBUGGING_DEBUG // is pool debugging enabled? pool:debug
+#endif
+
+
+#define POOL_GUARDBYTES ((void*)0xCAFED00D)
+
+
+
+
+
+/**
+ * Our memory pool is a SIZE based pool, meaning you specify the size
+ * of a single object as the template parameter.
+ * If the pool has no more available elements, alloc() returns NULL.
+ * You can return objects to the pool by using  dealloc().
+ * You can clear the state of the pool with clear() - this will make the
+ * allocator forget its free list resets the available number of objects.
+ */
+class pool
+{
+public:
+#if MSC_VERSION
+    #pragma warning(push)
+    #pragma warning(disable:4200)
+#endif
+    // Size of the actual pool object is 20 bytes,
+    // the allocated data follows right after the pool.
+    // We could use ushort for available/freed, but that would
+    // misalign the data. This favors newer x86/x64 model performance.
+
+    unsigned sizeOf;    // sizeof each element
+    unsigned available; // number of unhanded allocations
+    unsigned freed;     // number in free list
+
+
+    struct node
+    {
+    #if POOL_NDEBUG
+        union {
+            node* next; // free list next pointer
+            char data[];    // the actual data
+        };
+    #else
+        // We need the debug facility to detect writes into deleted handles
+        // Writing into a handle after deleting it will cause the freed 
+        // list to segfault. This will allow us to catch that.
+        node* next;     // free list next pointer
+        union {
+            void* guard;    // guard bytes
+            char data[];    // the actual data
+        };
+    #endif
+    };
+
+
+    node* list;     // free list pointer
+    char* end;      // pointer to the end of the buffer (first invalid address)
+    char buffer[];// the actual buffer contained in this object
+#if MSC_VERSION
+    #pragma warning(pop)
+#endif
+
+public:
+
+    /**
+     * Creates a new pool<TSIZE> object. Pool is a variable size object
+     * allocated as sizeof(pool) + TSIZE*capacity + alignto(8192)
+     * @param capacity Number of objects to reserve space for
+     * @param size_of Size of each element
+     * @return A new pool object
+     */
+    static pool* create(unsigned capacity, unsigned size_of)
+    {
+        #if POOL_DEBUG
+            size_of += sizeof(node*); // debug mode needs room for an extra ptr
+        #else
+            if(size_of < sizeof(node*))
+                size_of = sizeof(node*); // ensure minimum size of node* is achieved for release mode
+        #endif
+        if(size_of % 4 != 0) // have to align to 4 byte boundary?
+            size_of = size_of + 4 - size_of % 4;
+
+        // calculate size of this structure + buffer size
+        int allocSize = sizeof(pool) + size_of * capacity;
+        // align alloc size to a 8192 byte chunk
+        allocSize = (allocSize % 8192) ? allocSize + 8192 - (allocSize % 8192) : allocSize;
+
+        // now calculate the 'usable' buffer size for our end pointer
+        int usableBuffer = (allocSize - sizeof(pool));  // pool struct is not usable space
+        usableBuffer -= usableBuffer % size_of;         // remove any misaligned bytes from the end
+
+        pool* p = (pool*)malloc(allocSize);
+        p->sizeOf = size_of;
+        p->available = usableBuffer / size_of;          // number of nodes available
+        p->freed = 0;
+        p->list = NULL;
+        p->end = p->buffer + usableBuffer;
+        return p;
+    }
+
+    /**
+     * Clears the current state of the pool and resets
+     * all the variables of the pool
+     */
+    inline void clear()
+    {
+        available = (end - buffer) / sizeOf;
+        freed = 0;
+        list = NULL;
+    }
+
+    /**
+     * Destroys the pool
+     */
+    inline static void destroy(pool* p)
+    {
+        free(p);
+    }
+
+    // unsafe version for dynamic_pool
+    inline void* _alloc_new()
+    {
+        #if POOL_NDEBUG
+            return (buffer + sizeOf * --available); 
+        #else
+            return ((node*)(buffer + sizeOf * --available))->data;
+        #endif
+    }
+
+    // unsafe version for dynamic_pool
+    inline void* _alloc_freed() // gets from the freed list
+    {
+        --freed;
+        #if POOL_NDEBUG
+            void* ptr = (void*)list;
+        #else
+            ENSURE(list->guard == POOL_GUARDBYTES && "Invalid write to dealloc()-ed pointer detected!");
+            void* ptr = list->data;
+        #endif
+        list = list->next; // unshift the linked list
+        return ptr;
+    }
+
+    // unsafe version for dynamic_pool
+    inline void _dealloc(void* ptr)
+    {
+        ++freed;
+        #if  POOL_NDEBUG
+            ((node*)ptr)->next = list;  // shift the linked list
+            list = (node*)ptr;          // store the beginning of the linked list
+        #else
+            node* n = (node*)((char*)ptr - sizeof(void*));
+            n->guard = POOL_GUARDBYTES;
+            n->next = list;
+            list = n;
+        #endif
+    }
+
+    /**
+     * @return A new object from this pool, or NULL if no more handles available.
+     */
+    inline void* alloc() // gets a new item
+    {
+        if(freed) 
+        {
+            --freed;
+            #if  POOL_NDEBUG
+                void* ptr = (void*)list;
+            #else
+                ENSURE(list->guard == POOL_GUARDBYTES && "Invalid write to dealloc()-ed pointer detected!");
+                void* ptr = list->data; 
+            #endif
+            list = list->next; // unshift the linked list
+            return ptr;
+        } 
+        else if(available) 
+        {
+            #if POOL_NDEBUG
+                return (buffer + sizeOf * --available); 
+            #else
+                return ((node*)(buffer + sizeOf * --available))->data;
+            #endif
+        }
+        return NULL; // its empty
+    }
+
+    /**
+     * Deallocates a pointer
+     * @param ptr Pointer 
+     */
+    inline void dealloc(void* ptr) // puts into the freed list
+    {
+        ++freed;
+        #if POOL_NDEBUG
+            ((node*)ptr)->next = list;  // shift the linked list
+            list = (node*)ptr;          // store the beginning of the linked list
+        #else
+            ENSURE(is_owner(ptr) && "Given pointer does not belong to this pool!");
+            node* n = (node*)((char*)ptr - sizeof(void*));
+            n->guard = POOL_GUARDBYTES;
+            n->next = list;
+            list = n;
+        #endif
+    }
+
+    /**
+     * @return TRUE if the pointer is in range of this pool
+     */
+    inline bool is_owner(void* ptr) const
+    {
+        return buffer <= ptr && ptr < end;
+    }
+
+    /**
+     * @return Number of objects currently allocated
+     */
+    inline unsigned alloc_count() const
+    {
+        return ((end - buffer) / sizeOf) - (available + freed); // reserved - free
+    }
+
+    /**
+     * @return Number of objects available to allocate
+     */
+    inline unsigned free_count() const
+    {
+        return available + freed;
+    }
+
+    /**
+     * @return Number of objects reserved
+     */
+    inline unsigned reserve_count() const
+    {
+        return (end - buffer) / sizeOf;
+    }
+
+    /**
+     * @return Number of objects currently allocated
+     */
+    inline unsigned alloc_bytes() const
+    {
+        return (end - buffer) - (available + freed) * sizeOf; // reserved - free
+    }
+
+    /**
+     * @return Number of objects available to allocate
+     */
+    inline unsigned free_bytes() const
+    {
+        return (available + freed) * sizeOf;
+    }
+
+    /**
+     * @return Number of objects reserved
+     */
+    inline unsigned reserve_bytes() const
+    {
+        return end - buffer;
+    }
+};
+
+
+
+
+
+
+
+
+/**
+ * Dynamic pool is a memory pool that dynamically increases it size
+ * to handle more and more requests whenever needed.
+ *
+ * @param GC [no_gc] Set to [use_gc] if you wish this dynamic_pool to trigger 
+ *           garbage collection if a pool* gets empty
+ */
+template<pool_gc_t GC = no_gc> class dynamic_pool
+{
+public:
+    pool** pools;
+    unsigned pools_count;
+    unsigned pools_capacity;
+    unsigned pool_sizeOf;       // size in bytes of each element
+    unsigned pool_sizehint;     // size hint for pool objects in number of elements
+
+
+    /**
+     * Creates a new pool and automatically calculates pool size (quite aggressively).
+     */
+    inline dynamic_pool(unsigned sizeOf) : pools(0), pools_count(0), pools_capacity(0), 
+        pool_sizeOf(sizeOf), pool_sizehint(POOL_AUTOSIZE(sizeOf))
+    {
+    }
+
+    /**
+     * Creates a new pool with the given pool size hint
+     */
+    inline dynamic_pool(unsigned sizeOf, unsigned poolSizeHint) : pools(0), pools_count(0), pools_capacity(0), 
+        pool_sizeOf(sizeOf), pool_sizehint(poolSizeHint)
+    {
+    }
+
+    /**
+     * Destroys the entire pool
+     */
+    inline ~dynamic_pool()
+    {
+        destroy();
+    }
+
+    /**
+     * This function destroys all the pools in this dynamic_pool
+     * The container array for pool objects is also destroyed
+     */
+    void destroy()
+    {
+        int i = pools_count;
+        if(!i) return; // early return if no pools
+        while(i)
+            pool::destroy(pools[--i]);
+
+        free(pools);
+        pools = NULL;
+        pools_count = 0;
+        pools_capacity = 0;
+    }
+
+    /**
+     * @return A new memory block of size <TSIZE>
+     */
+    void* alloc() // gets a new handle
+    {
+        int i = pools_count;
+        while(i) // backwards iteration
+        {
+            pool* p = pools[--i];
+            if(p->freed) // any in the 'freed' list?
+                return p->_alloc_freed();
+            else if(p->available) // any in the buffer itself?
+                return p->_alloc_new();
+        }
+
+        if(pools_count == pools_capacity)
+        {
+            pools_capacity += 4; // this is really bad
+            pools = (pool**)realloc(pools, sizeof(pool*) * pools_capacity);
+        }
+        pool* p = pool::create(pool_sizehint, pool_sizeOf);
+        pools[pools_count++] = p;
+        return p->_alloc_new(); // this will definitely succeed
+    }
+
+    /**
+     * Deallocates a pointer by returning it to the pool
+     */
+    void dealloc(void* ptr) // deletes an existing handle
+    {
+        int i = pools_count;
+        while(i) // backwards iteration
+        {
+            pool* p = pools[--i];
+            if(p->is_owner(ptr)) // belongs to this pool?
+            {   
+                p->_dealloc(ptr); // good. put it there.
+
+                // @note We need general garbage collection for the _global_pool objects
+                // run garbage collection if and only if:
+                // 1) GC is enabled for this template
+                // 2) there are more than 1 pools
+                // 3) the pool is now empty
+                if(GC && pools_count != 1 && p->alloc_count() == 0)
+                    erase_at(i);
+                return;
+            }
+        }
+
+        // on the global bucket_allocator this happens if you dealloc() from wrong thread
+        // otherwise it's an invalid pointer or belongs to another pool
+        ENSURE(false && "Pointer does not belong to this dynamic_pool!");
+    }
+
+    /**
+     * Clears all the pools. (!) Does NOT free any memory (!) Pools have their max capacity restored!
+     */
+    void clear()
+    {
+        for(int i = pools_count; i; )
+            pools[--i]->clear();
+    }
+
+    /**
+     * Destroys pools that are empty
+     */
+    void clean_pools()
+    {
+        int i = pools_count;
+        if(!i) return; // early return to avoid the free block in the end
+        while(i)
+        {
+            pool* p = pools[--i];
+            if(p->alloc_count() == 0)
+            {
+                erase_at(i);
+                continue;
+            }
+        }
+        if(pools_count == 0)
+        {
+            free(pools), pools = NULL;
+            pools_capacity = 0;
+        }
+    }
+
+
+private:
+    void erase_at(int i) // erases the pool at the given index
+    {
+        pool** at = pools + i;
+        pool::destroy(*at);
+        if(int itemsToShift = pools_count - i - 1)
+            memmove(at, at + 1, itemsToShift * sizeof(pool*)); // unshift the pools array
+        --pools_count;
+    }
+
+
+public:
+    /**
+     * @return Number of currently allocated objects
+     */
+    unsigned alloc_count() const
+    {
+        unsigned count = 0;
+        for(unsigned i = 0; i < pools_count; ++i)
+            count += pools[i]->alloc_count();
+        return count;
+    }
+    
+    /**
+     * @return Number of objects available for allocation
+     */
+    unsigned free_count() const
+    {
+        unsigned count = 0;
+        for(unsigned i = 0; i < pools_count; ++i)
+            count += pools[i]->free_count();
+        return count;
+    }
+
+    /**
+     * @return Total number of objects reserved
+     */
+    unsigned reserve_count() const
+    {
+        unsigned count = 0;
+        for(unsigned i = 0; i < pools_count; ++i)
+            count += pools[i]->reserve_count();
+        return count;
+    }
+
+    /**
+     * @return Number of bytes currently allocated
+     */
+    unsigned alloc_bytes() const
+    {
+        unsigned numBytes = 0;
+        for(unsigned i = 0; i < pools_count; ++i)
+            numBytes += pools[i]->alloc_bytes();
+        return numBytes;
+    }
+
+    /**
+     * @return Number of bytes available for allocation
+     */
+    unsigned free_bytes() const
+    {
+        unsigned numBytes = 0;
+        for(unsigned i = 0; i < pools_count; ++i)
+            numBytes += pools[i]->free_bytes();
+        return numBytes;
+    }
+
+    /**
+     * @return Number of bytes reserved for allocations
+     */
+    unsigned reserve_bytes() const
+    {
+        unsigned numBytes = 0;
+        for(unsigned i = 0; i < pools_count; ++i)
+            numBytes += pools[i]->reserve_bytes();
+        return numBytes;
+    }
+};
+
+
+
+
+
+/**
+ * Global pools use garbage collection (automatic cleanup on low capacity)
+ */
+typedef dynamic_pool<use_gc> global_pool_t;
+
+
+
+
+
+/**
+ * Gets a Thread-Local-Storage Pool suitable for the specified size request.
+ * @note This only works for requestSize range [0, 1024]. Otherwise undefined behaviour. Use wisely.
+ * @param requestSize Size of the memory request in bytes.
+ * @return A Thread-Local-Storage Pool for this size request.
+ */
+global_pool_t* _get_tls_pool(uint32_t requestSize);
+
+
+
+
+
+/**
+ * A bucket allocator is a special allocator that divides allocations into fixed-size memory pools.
+ * These pools are thread-local, so an assertion failure is triggered if delete is called from a wrong thread.
+ * @note This special allocator pools allocations between [4..1024] bytes
+ * @note General vector allocator for STL
+ */
+template<class T> class bucket_allocator : public std::allocator<T>
+{
+public:
+    typedef size_t      size_type;
+    typedef ptrdiff_t   difference_type;
+    typedef T*          pointer;
+    typedef const T*    const_pointer;
+    typedef T&          reference;
+    typedef const T&    const_reference;
+    typedef T           value_type;
+    template<class X> struct rebind { typedef bucket_allocator<X> other; };
+
+    inline bucket_allocator() throw()  {}
+    inline bucket_allocator(const bucket_allocator& a) throw() : std::allocator<T>(a) {}
+    template<class X> inline bucket_allocator(const bucket_allocator<X>&) throw()  {}
+    inline ~bucket_allocator() throw()  {}
+    inline bucket_allocator select_on_container_copy_construction() const throw() { return *this; }
+
+    inline pointer address(reference x) const throw()  { return &x; }
+    inline const_pointer address(const_reference x) const throw()  { return &x; }
+    inline size_type max_size() const throw()  { return size_t(-1) / sizeof(T); }
+    inline void construct(pointer p, const_reference v) { ::new(p) T(v); }
+    inline void destroy(pointer p) { p->~T(); (void)p; }
+
+    /**
+     * @note This should be tested for all vectors:
+     * @note The size 1024 bytes is deduced from MTuner profiling data. Everything over that seems to be irrelevant.
+     */
+    pointer allocate(size_type n)
+    {
+        const uint32_t requestSize = n * sizeof(T); // requested bytes
+        if(requestSize <= POOL_MAX_BUCKET_SIZE) // default MAX: 1024 bytes
+        {
+            return (pointer)_get_tls_pool(requestSize)->alloc();
+        }
+        void* mem = malloc(requestSize);
+        if(!mem)
+        {
+            throw std::bad_alloc();
+        }
+        return (pointer)mem;
+    }
+
+    void deallocate(pointer p, size_type n)
+    {
+        const uint32_t requestSize = n * sizeof(T); // requested bytes
+        if(requestSize <= POOL_MAX_BUCKET_SIZE) // default MAX: 1024 bytes
+        {
+            return _get_tls_pool(requestSize)->dealloc(p);
+        }
+        free(p);
+    }
+};
+
+
+
+
+
+#endif // INCLUDED_MEMORY_POOL
+ No newline at end of file

lib/allocators/tests/test_allocators.h

@@ -25 +25 @@
 #include "lib/allocators/dynarray.h"
 #include "lib/byte_order.h"
 
+#include "lib/ps_stl.h"
+#include "lib/timer.h" // for the performance measurements
+
 class TestAllocators : public CxxTest::TestSuite 
 {
 public:
+
     void test_da()
     {
         DynArray da;
@@ -37 +41 @@
         TS_ASSERT_OK(da_set_size(&da, 1000));
         TS_ASSERT_OK(da_free(&da));
     }
+
+
+    void test_pool_gc()
+    {
+        static const int ITERS = 3000;
+        static void* pointers[ITERS];
+        
+        dynamic_pool<use_gc> mempool(sizeof(int), 1024); // the pool we're testing
+
+        // try to allocate way over pool limits:
+        for(int i = 0; i < ITERS; ++i)
+        {
+            pointers[i] = mempool.alloc();
+        }
+
+        TS_ASSERT(mempool.pools_count > 1); // pools count should be more than 1
+
+        // now lets deallocate all the pointers
+        for(int i = ITERS; i != 0; )
+        {
+            mempool.dealloc(pointers[--i]);
+        }
+
+        TS_ASSERT(mempool.pools_count == 1); // pools count MUST be 1 now
+
+        printf("\npool_gc done.\n");
+    }
+
+
+    // @note If these don't crash, then the allocator works pretty well :)
+    void test_stl_containers()
+    {
+        ps::vector<int> vec;
+        
+        // fill it up
+        for(int i = 0; i < 32; ++i)
+            vec.push_back(i);
+        
+        // now we test afterwards to make sure reallocs didn't change stuff
+        for(int i = 0; i < 32; ++i)
+            TS_ASSERT(vec[i] == i);
+
+        ps::vector<int>  vec2 = vec;
+        vec2 = vec;
+        ps::vector<int>  vec3 = ps::vector<int> ();
+        vec3 = ps::vector<int>();
+
+
+        // @note pretty much same as ps::vector test above
+
+        ps::map<int, int> map;
+        for(int i = 0; i < 32; ++i)
+            map[i] = i;
+        for(int i = 0; i < 32; ++i)
+            TS_ASSERT(map[i] == i);
+
+        ps::map<int, int> map2 = map;
+        map2 = map;
+        ps::map<int, int> map3 = ps::map<int, int>();
+        map3 = ps::map<int, int>();
+
+        printf("stl containers done.\n");
+    }
+
+
+
+
+
+#define PERF_ITERS 120000 // 120k iters
+#define FRAG_ITERS 40000 // 40k iters
+
+    struct int1x { int x; };
+    struct int2x { int x, y; };
+    struct int3x { int x, y, z; };
+
+
+    // @note Tests the random allocation speed of the stock allocator
+    void test_std_alloc_fragmented_DISABLED()
+    {
+        static int1x* pointers1[FRAG_ITERS];
+        static int2x* pointers2[FRAG_ITERS];
+        static int1x* pointers11[FRAG_ITERS];
+
+        double start = timer_Time();
+        for(int i = 0; i < FRAG_ITERS; ++i)
+        {
+            pointers1[i] = new int1x;
+            pointers2[i] = new int2x;
+            int3x* frag = new int3x;
+            delete frag;
+            pointers11[i] = new int1x;
+
+        }
+        for(int i = FRAG_ITERS; i != 0; )
+        {
+            --i;
+            delete pointers1[i];
+            delete pointers2[i];
+            delete pointers11[i];
+        }
+        double elapsed = timer_Time() - start;
+        printf("std_alloc fragmented:     %dms\n", int(elapsed*1000));
+    }
+
+    // @note Tests the growing speed of the stock allocator
+    void test_std_alloc_growshrink_DISABLED()
+    {
+        static int* pointers[PERF_ITERS]; // array for perf test pointers
+
+        double start = timer_Time();
+        for(int i = 0; i < PERF_ITERS; ++i)
+        {
+            pointers[i] = new int;
+        }
+        for(int i = PERF_ITERS; i != 0; )
+        {
+            delete pointers[--i];
+        }
+        double elapsed = timer_Time() - start;
+        printf("std_alloc growshrink:     %dms\n", int(elapsed*1000));
+    }
+
+
+    // @note Tests the temporary new/delete speed of the stock allocator
+    void test_std_alloc_temporaries_DISABLED()
+    {
+        double start = timer_Time();
+        for(int i = 0; i < PERF_ITERS; ++i)
+        {
+            volatile int* temp = new int;
+            *temp = 0;
+            delete temp;
+        }
+        double elapsed = timer_Time() - start;
+        printf("std_alloc temporaries:    %dms\n", int(elapsed*1000));
+    }
+
+
+
+
+    // @note Tests the random allocation speed of the bucket allocator
+    void test_tls_bucket_fragmented_DISABLED()
+    {
+        static int1x* pointers1[FRAG_ITERS];
+        static int2x* pointers2[FRAG_ITERS];
+        static int1x* pointers11[FRAG_ITERS];
+
+        bucket_allocator<int1x> first;
+        bucket_allocator<int2x> second;
+        bucket_allocator<int3x> third;
+
+        // @todo This doesn't exactly simulate frags yet
+        double start = timer_Time();
+        for(int i = 0; i < FRAG_ITERS; ++i)
+        {
+            pointers1[i] = first.allocate(1);
+            pointers2[i] = second.allocate(1);
+            int3x* frag = third.allocate(1);
+            third.deallocate(frag, 1);
+            pointers11[i] = first.allocate(1);
+        }
+        for(int i = FRAG_ITERS; i != 0; )
+        {
+            --i;
+            first.deallocate(pointers1[i], 1);
+            second.deallocate(pointers2[i], 1);
+            first.deallocate(pointers11[i], 1);
+        }
+        double elapsed = timer_Time() - start;
+        printf("tls_bucket fragmented:    %dms\n", int(elapsed*1000));
+    }
+
+
+    // @note Tests the growing speed of the bucket allocator
+    void test_tls_bucket_growshrink_DISABLED()
+    {
+        static int* pointers[PERF_ITERS]; // array for perf test pointers
+        bucket_allocator<int> balloc;
+        
+        double start = timer_Time();
+        for(int i = 0; i < PERF_ITERS; ++i)
+        {
+            pointers[i] = balloc.allocate(1);
+        }
+        for(int i = PERF_ITERS; i != 0; )
+        {
+            balloc.deallocate(pointers[--i], 1);
+        }
+        double elapsed = timer_Time() - start;
+        printf("tls_bucket growshrink:    %dms\n", int(elapsed*1000));
+    }
+
+
+    // @note Tests the temporary new/delete speed of the bucket allocator
+    void test_tls_bucket_temporaries_DISABLED()
+    {
+        bucket_allocator<int> balloc;
+
+        double start = timer_Time();
+        for(int i = 0; i < PERF_ITERS; ++i)
+        {
+            int* temp = balloc.allocate(1);
+            *temp = 0;
+            balloc.deallocate(temp, 1);
+        }
+        double elapsed = timer_Time() - start;
+        printf("tls_bucket temporaries:   %dms\n", int(elapsed*1000));
+    }
+
+
+
+
+
+
+
+
+    template<class Vector> void stress_vector()
+    {
+        Vector vec;
+        for(int i = 0; i < 32; ++i)
+            vec.push_back(i);
+        Vector vec2 = vec;
+        vec2 = vec;
+        Vector vec3 = Vector();
+        vec3 = Vector();
+    }
+    template<class String> void stress_string()
+    {
+        String str;
+        for(int i = 0; i < 32; ++i)
+            str.push_back('A');
+        String str2 = str;
+        str2 = str;
+        String str3 = String();
+        str3 = String();
+    }
+    template<class Map> void stress_map()
+    {
+        Map map;
+        for(int i = 0; i < 32; ++i)
+            map[i] = i;
+        Map map2 = map;
+        map2 = map;
+        Map map3 = Map();
+        map3 = Map();
+    }
+    template<class Set> void stress_set()
+    {
+        Set set;
+        for(int i = 0; i < 32; ++i)
+            set.insert(i);
+        Set set2 = set;
+        set2 = set;
+        Set set3 = Set();
+        set3 = Set();
+    }
+
+
+#define STRESS_ITERS 1000
+
+    void test_STD_STL_stresstest_DISABLED()
+    {
+        double start = timer_Time();
+        for(int i = 0; i < STRESS_ITERS; ++i)
+        {
+            stress_vector<std::vector<int> >();
+            stress_vector<std::list<int> >();
+            stress_string<std::string>();
+            stress_map<std::map<int, int> >();
+            stress_set<std::set<int> >();
+            stress_map<stl_unordered_map<int, int> >();
+            stress_set<stl_unordered_set<int> >();
+        }
+        double elapsed = timer_Time() - start;
+        printf("stress_test std::stl:     %dms\n", int(elapsed*1000));
+    }
+
+    void test_PS_STL_stresstest_DISABLED()
+    {
+        double start = timer_Time();
+        for(int i = 0; i < STRESS_ITERS; ++i)
+        {
+            stress_vector<ps::vector<int> >();
+            stress_vector<ps::list<int> >();
+            stress_string<ps::string>();
+            stress_map<ps::map<int, int> >();
+            stress_set<ps::set<int> >();
+            stress_map<ps::unordered_map<int, int> >();
+            stress_set<ps::unordered_set<int> >();
+        }
+        double elapsed = timer_Time() - start;
+        printf("stress_test ps::stl:      %dms\n", int(elapsed*1000));
+    }
+
 };

lib/ps_stl.h

@@ +1 @@
+/* Copyright (c) 2013 Wildfire Games
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#pragma once
+#ifndef INCLUDED_PS_STL
+#define INCLUDED_PS_STL
+
+/**
+ * @author Jorma Rebane
+ * @date 2013.06.27
+ * @note Pyrogenesis STL wrapper
+ * @note This file contains STL container wrappers with custom allocators.
+ * @note It's a quick fix to increase STL container performance.
+ */
+
+#include "allocators/memory_pool.h"
+
+#include <vector>
+#include <string> // this one gets used sooo much
+#include <sstream>
+#include <list>
+#include <map>
+#include <set>
+#if HAVE_CPP0X // unordered variants only came out in C++11
+    #include <unordered_map>
+    #include <unordered_set>
+    #define stl_hash std::hash
+    #define stl_unordered_map std::unordered_map
+    #define stl_unordered_set std::unordered_set
+#else
+    #include <boost/unordered_map.hpp>
+    #include <boost/unordered_set.hpp>
+    #define stl_hash boost::hash
+    #define stl_unordered_map boost::unordered_map
+    #define stl_unordered_set boost::unordered_set
+#endif
+
+
+
+#ifndef USE_POOL_ALLOCATORS     // you can define this as an override to enable/disable the pool allocator
+#define USE_POOL_ALLOCATORS 1   // by default we enable pool allocator
+#endif
+
+
+#if USE_POOL_ALLOCATORS
+#define BUCKET_ALLOCATOR(...) , bucket_allocator< __VA_ARGS__ >
+#else
+#define BUCKET_ALLOCATOR(...)
+#endif
+
+
+#ifndef HAS_CPP11_TEMPLATE_ALIASING
+// if C++11 && (clang 3.0+ or gcc 4.7+)
+#define HAS_CPP11_TEMPLATE_ALIASING HAVE_CPP0X && (CLANG_VERSION >= 300 || GCC_VERSION >= 470)
+#endif
+
+namespace ps {
+
+
+
+
+    /**
+     * @note std::string wrappers with the bucket_allocator
+     */
+    typedef std::basic_string<char, std::char_traits<char> BUCKET_ALLOCATOR(char) > string;
+    typedef std::basic_string<wchar_t, std::char_traits<wchar_t> BUCKET_ALLOCATOR(wchar_t) > wstring;
+    typedef std::basic_stringstream<char, std::char_traits<char> BUCKET_ALLOCATOR(char) > stringstream;
+    typedef std::basic_stringstream<wchar_t, std::char_traits<wchar_t> BUCKET_ALLOCATOR(wchar_t) > wstringstream;
+
+
+    /**
+     * String conversion for compatibility with std::string
+     */
+    inline string to_string(const std::string& s) { return string(s.c_str(), s.length()); }
+    inline wstring to_string(const std::wstring& s) { return wstring(s.c_str(), s.length()); }
+
+
+    /**
+     * Unsafe re-casting. Be careful with this!!
+     */
+    inline const string& string_ref(const std::string& s) { return *(const string*)&s; }
+    inline const wstring& string_ref(const std::wstring& s) { return *(const wstring*)&s; }
+
+
+
+
+
+#if HAS_CPP11_TEMPLATE_ALIASING
+
+    template<class T> 
+        using psvector = std::vector<T BUCKET_ALLOCATOR(T)>;
+
+
+    template<class T> 
+        using list = std::list<T BUCKET_ALLOCATOR(T)>;
+
+
+    template<class Key, class T, class Pred = std::less<Key>> 
+        using map = std::map<Key, T, Pred BUCKET_ALLOCATOR(std::pair<const Key, T>)>;
+
+
+    template<class T, class Pred = std::less<T>> 
+        using set = std::set<T, Pred BUCKET_ALLOCATOR(T)>;
+
+
+    template<class Key, class T, class Hash = stl_hash<Key>, class Pred = std::equal_to<Key>> 
+        using unordered_map = std::unordered_map<Key, T, Hash, Pred BUCKET_ALLOCATOR(std::pair<const Key, T>)>;
+
+
+    template<class Key, class Hash = stl_hash<Key>, class Pred = std::equal_to<Key>> 
+        using unordered_set = std::unordered_set<Key, Hash, Pred BUCKET_ALLOCATOR(Key)>;
+
+#else // !HAS_CPP11_TEMPLATE_ALIASING
+
+
+    /**
+     * Overrides std::list and plugs in a bucket_allocator as the allocator.
+     * @note The bucket_allocator allocates from global thread-local memory pools based on the chunk size. 
+     */
+    template<class T> class vector 
+        :public std::vector<T BUCKET_ALLOCATOR(T) >
+    {
+    public:
+        typedef std::vector<T BUCKET_ALLOCATOR(T) > base;
+
+        inline vector() : base() {}
+        inline explicit vector(size_t count) : base(count) {}
+        inline vector(size_t count, const T& value) : base(count, value) {}
+        template<class Iter> inline vector(Iter first, Iter last) : base(first, last) {}
+
+
+        inline vector(const vector& right) : base(right) {}
+        inline vector& operator=(const vector& right) { base::operator=(right); return *this; }
+    #if HAVE_CPP0X
+        inline vector(const vector&& right) : base(std::move(right)) {}
+        inline vector& operator=(const vector&& right) { base::operator=(std::move(right)); return *this; }
+    #endif
+    };
+
+
+
+
+
+    /**
+     * Overrides std::list and plugs in a bucket_allocator as the allocator.
+     * @note The bucket_allocator allocates from global thread-local memory pools based on the chunk size. 
+     */
+    template<class T> class list 
+        :public std::list<T BUCKET_ALLOCATOR(T) >
+    {
+    public:
+        typedef std::list<T BUCKET_ALLOCATOR(T) > base;
+
+        inline list() : base() {}
+        inline explicit list(size_t count) : base(count) {}
+        inline list(size_t count, const T& value) : base(count, value) {}
+        template<class Iter> inline list(Iter first, Iter last) : base(first, last) {}
+
+
+        inline list(const list& right) : base(right) {}
+        inline list& operator=(const list& right) { base::operator=(right); return *this; }
+    #if HAVE_CPP0X
+        inline list(const list&& right) : base(std::move(right)) {}
+        inline list& operator=(const list&& right) { base::operator=(std::move(right)); return *this; }
+    #endif
+    };
+
+
+
+
+
+    /**
+     * Overrides std::map and plugs in a bucket_allocator as the allocator.
+     * @note The bucket_allocator allocates from global thread-local memory pools based on the chunk size. 
+     */
+    template<class Key, class T, class Pred = std::less<Key> > class map 
+        :public std::map<Key, T, Pred BUCKET_ALLOCATOR(std::pair<const Key, T>) >
+    {
+    public:
+        typedef std::map<Key, T, Pred BUCKET_ALLOCATOR(std::pair<const Key, T>) > base;
+
+        inline map() : base() {}
+        inline explicit map(const Pred& pred) : base(pred) {}
+        template<class Iter> inline map(Iter first, Iter last) : base(first, last) {}
+        template<class Iter> inline map(Iter first, Iter last, const Pred& pred) : base(first, last, pred) {}
+
+
+        inline map(const map& right) : base(right) {}
+        inline map& operator=(const map& right) { base::operator=(right); return *this; }
+    #if HAVE_CPP0X
+        inline map(const map&& right) : base(std::move(right)) {}
+        inline map& operator=(const map&& right) { base::operator=(std::move(right)); return *this; }
+    #endif
+    };
+
+
+
+
+
+    /**
+     * Overrides std::set and plugs in a bucket_allocator as the allocator.
+     * @note The bucket_allocator allocates from global thread-local memory pools based on the chunk size. 
+     */
+    template<class T, class Pred = std::less<T> > class set 
+        :public std::set<T, Pred BUCKET_ALLOCATOR(T) >
+    {
+    public:
+        typedef std::set<T, Pred BUCKET_ALLOCATOR(T) > base;
+
+        inline set() : base() {}
+        inline explicit set(const Pred& pred) : base(pred) {}
+        template<class Iter> inline set(Iter first, Iter last) : base(first, last) {}
+        template<class Iter> inline set(Iter first, Iter last, const Pred& pred) : base(first, last, pred) {}
+
+
+        inline set(const set& right) : base(right) {}
+        inline set& operator=(const set& right) { base::operator=(right); return *this; }
+    #if HAVE_CPP0X
+        inline set(const set&& right) : base(std::move(right)) {}
+        inline set& operator=(const set&& right) { base::operator=(std::move(right)); return *this; }
+    #endif
+    };
+
+
+
+
+
+    /**
+     * Overrides std::unordered_map and plugs in a bucket_allocator as the allocator.
+     * @note The bucket_allocator allocates from global thread-local memory pools based on the chunk size. 
+     */
+    template<class Key, class T, class Hash = stl_hash<Key>, class Pred = std::equal_to<Key> > class unordered_map 
+        :public stl_unordered_map<Key, T, Hash, Pred BUCKET_ALLOCATOR(std::pair<const Key, T>) >
+    {
+    public:
+        typedef stl_unordered_map<Key, T, Hash, Pred BUCKET_ALLOCATOR(std::pair<const Key, T>) > base;
+
+        inline unordered_map() : base() {}
+        inline explicit unordered_map(size_t buckets) : base(buckets) {}
+        inline unordered_map(size_t buckets, const Hash& hashArg) : base(buckets, hashArg) {}
+        inline unordered_map(size_t buckets, const Hash& hashArg, const Pred& keyArg) : base(buckets, hashArg, keyArg) {}
+        template<class Iter> inline unordered_map(Iter first, Iter last) : base(first, last) {}
+        template<class Iter> inline unordered_map(Iter first, Iter last, size_t buckets) : base(first, last, buckets) {}
+        template<class Iter> inline unordered_map(Iter first, Iter last, size_t buckets, const Hash& hashArg) : base(first, last, buckets, hashArg) {}
+        template<class Iter> inline unordered_map(Iter first, Iter last, size_t buckets, const Hash& hashArg, const Pred& keyArg) : base(first, last, buckets, hashArg, keyArg) {}
+
+
+        inline unordered_map(const unordered_map& right) : base(right) {}
+        inline unordered_map& operator=(const unordered_map& right) { base::operator=(right); return *this; }
+    #if HAVE_CPP0X
+        inline unordered_map(const unordered_map&& right) : base(std::move(right)) {}
+        inline unordered_map& operator=(const unordered_map&& right) { base::operator=(std::move(right)); return *this; }
+    #endif
+    };
+
+
+
+
+
+    /**
+     * Overrides std::unordered_set and plugs in a bucket_allocator as the allocator.
+     * @note The bucket_allocator allocates from global thread-local memory pools based on the chunk size. 
+     */
+    template<class Key, class Hash = stl_hash<Key>, class Pred = std::equal_to<Key> > class unordered_set 
+        :public stl_unordered_set<Key, Hash, Pred BUCKET_ALLOCATOR(Key) >
+    {
+    public:
+        typedef stl_unordered_set<Key, Hash, Pred BUCKET_ALLOCATOR(Key) > base;
+
+        inline unordered_set() : base() {}
+        inline explicit unordered_set(size_t buckets) : base(buckets) {}
+        inline unordered_set(size_t buckets, const Hash& hashArg) : base(buckets, hashArg) {}
+        inline unordered_set(size_t buckets, const Hash& hashArg, const Pred& keyArg) : base(buckets, hashArg, keyArg) {}
+        template<class Iter> inline unordered_set(Iter first, Iter last) : base(first, last) {}
+        template<class Iter> inline unordered_set(Iter first, Iter last, size_t buckets) : base(first, last, buckets) {}
+        template<class Iter> inline unordered_set(Iter first, Iter last, size_t buckets, const Hash& hashArg) : base(first, last, buckets, hashArg) {}
+        template<class Iter> inline unordered_set(Iter first, Iter last, size_t buckets, const Hash& hashArg, const Pred& keyArg) : base(first, last, buckets, hashArg, keyArg) {}
+
+
+        inline unordered_set(const unordered_set& right) : base(right) {}
+        inline unordered_set& operator=(const unordered_set& right) { base::operator=(right); return *this; }
+    #if HAVE_CPP0X
+        inline unordered_set(const unordered_set&& right) : base(std::move(right)) {}
+        inline unordered_set& operator=(const unordered_set&& right) { base::operator=(std::move(right)); return *this; }
+    #endif
+    };
+#endif // HAS_CPP11_TEMPLATE_ALIASING
+
+
+
+
+
+#undef BUCKET_ALLOCATOR
+
+
+
+} // namespace ps
+
+#endif // INCLUDED_PS_STL
+ No newline at end of file

ps/CStr.h

@@ -54 +54 @@
 
 #include <string>
 #include "ps/utf16string.h"
+#include <lib/ps_stl.h>
 
 class CStr8;
 class CStrW;
@@ -67 +68 @@
 
     // CONSTRUCTORS
 
-    CStr() {}
-    CStr(const tchar* String) : std::tstring(String) {}
-    CStr(const tchar* String, size_t Length) : std::tstring(String, Length) {}
-    CStr(const std::tstring& String) : std::tstring(String) {}
+    inline CStr() {}
+    inline CStr(const tchar* String) : std::tstring(String) {}
+    inline CStr(const tchar* String, size_t Length) : std::tstring(String, Length) {}
+    inline CStr(const std::tstring& String) : std::tstring(String) {}
+    inline CStr(const ps::tstring& String) : std::tstring(String.c_str(), String.length()) {}
+#if HAVE_CPP0X
+    inline CStr(const std::tstring&& rvalue) : std::tstring(std::move(rvalue)) {}
+    // have to do a full-copy from ps:: strings, since the allocators don't match:
+    inline CStr(const ps::tstring&& rvalue) : std::tstring(rvalue.c_str(), rvalue.length()) {}
+#endif
 
     /**
      * Repeat: Named constructor, to avoid overload overload.
@@ -344 +351 @@
     size_t GetSerializedLength() const;
     u8* Serialize(u8* buffer) const;
     const u8* Deserialize(const u8* buffer, const u8* bufferend);
+
+#ifdef _UNICODE
+#define _unimemcmp wmemcmp
+#define _unimemicmp wcscasecmp
+#else
+#define _unimemcmp memcmp
+#define _unimemicmp strncasecmp
+#endif
+
+    inline bool StartsWith(const CStr& str) const
+    {
+        return length() >= str.length() && _unimemcmp(c_str(), str.c_str(), str.length()) == 0;
+    }
+    template<size_t SIZE> inline bool StartsWith(const tchar (&const_literal)[SIZE]) const
+    {
+        return _unimemcmp(c_str(), const_literal, (SIZE/sizeof(tchar)) - 1) == 0;
+    }
+
+    template<size_t SIZE> inline bool Equals(const tchar (&const_literal)[SIZE]) const
+    {
+        return length() == ((SIZE/sizeof(tchar)) - 1) &&
+            _unimemcmp(c_str(), const_literal, (SIZE/sizeof(tchar)) - 1) == 0;
+    }
+
+    template<size_t SIZE> inline bool EqualsIgnoreCase(const tchar (&const_literal)[SIZE]) const
+    {
+        return length() == ((SIZE/sizeof(tchar)) - 1) && 
+            _unimemicmp(c_str(), const_literal, (SIZE/sizeof(tchar)) - 1) == 0;
+    }
+
+#undef _unimemicmp
+#undef _unimemcmp
+
 };
 
+/**
+ * Basic string hashing for use with std::map
+ */
 static inline size_t hash_value(const CStr& s)
 {
     return s.GetHashCode();
 }
 
+
+
+
+
 #endif