Memory.h

Go to the documentation of this file.

#ifndef __LDK_MEMORY_HH__
#define __LDK_MEMORY_HH__

//   Copyright (C) 2003-2006 Lorien Dunn.
//
//   Contact: loriendunn AT users DOT sourceforge DOT net
//
//   This software is provided 'as-is', without any express or implied warranty.
//   In no event will the authors be held liable for any damages arising from
//   the use of this software.
//
//   Permission is granted to anyone to use this software for any purpose,
//   including commercial applications, and to alter it and redistribute it
//   freely, subject to the following restrictions:
//
//   1. The origin of this software must not be misrepresented; you must not
//   claim that you wrote the original software. If you use this software in a
//   product, an acknowledgment in the product documentation would be
//   appreciated but is not required.
//
//   2. Altered source versions must be plainly marked as such, and must not be
//   misrepresented as being the original software.
//
//   3. This notice may not be removed or altered from any source distribution.
//

#include "LDK/Types.h"
#include "LDK/Threading.h"
#include "LDK/TemplateMeta.h"
#include "LDK/Singletons.h"
#include "LDK/Exceptions.h"
#include <vector>
#include <list>

//not using <cname> headers because they cause
//compatibility issues when including normal c header files.
#include <string.h> //for memcpy,
#include <assert.h>

#ifdef DEBUG
#define LDK_TRACK_ALLOCATION
#endif //DEBUG

namespace LDK
{

//All memory will be aligned on 16 byte boundaries. Do not change.
#define BYTE_ALIGNMENT 16


//You might want to change these according to your needs.
//However if you do the whole library (and everything
//which uses it will need to be recompiled or things
//will get very strange indeed...
//Chunk sizes should be be powers of two or memory alignment
//will likely be completely wrong, and smaller than 16 bytes
//on 32-bit systems and 32 bytes on 64-bit systems
//will mean more space wasted than allocated for the Pools
//with the smaller chunkSizes.

#define LDK_SPARE_HEAPS 30
#ifdef THIRTY_TWO_BIT
#define LDK_HEAPSIZE_K 512
#define LDK_MINCHUNKSIZE 16
#elif defined SIXTY_FOUR_BIT
#define LDK_HEAPSIZE_K 1024
#define LDK_MINCHUNKSIZE 32
#endif //THIRTY_TWO_BIT

#define LDK_MAXCHUNKSIZE ((LDK_HEAPSIZE_K*1024)/2)

//do a little preprocessor sanity checking.
//Real power-of-2 and power-of-2 + 1/2-power-of-2 sanity
//checking is done with a template metaprogram.

#if LDK_HEAPSIZE_K % 2 != 0
    #error "LDK_HEAPSIZE_K must be even"
#endif //LDK_HEAPSIZE_K % 2 == 0

#if LDK_MAXCHUNKSIZE < LDK_MINCHUNKSIZE
    #error "LDK_MAXCHUNKSIZE < LDK_MINCHUNKSIZE"
#endif //LDK_MAXCHUNKSIZE < LDK_MINCHUNKSIZE

#if LDK_MINCHUNKSIZE % 2 != 0
    #error "LDK_MINCHUNKSIZE must be even"
#endif //LDK_MINCHUNKSIZE % 2 != 0

#if LDK_MAXCHUNKSIZE % 2 != 0
    #warning "LDK_MAXCHUNKSIZE must be even"
#endif //LDK_MAXCHUNKSIZE % 2 != 0

#if LDK_MAXCHUNKSIZE / 1024 > LDK_HEAPSIZE_K
    #error "LDK_MAXCHUNKSIZE / 1024 > HEAP_SIZE"
#endif //LDK_MAXCHUNKSIZE / 1024 > LDK_HEAPSIZE_K

#ifdef THIRTY_TWO_BIT
    #if LDK_MINCHUNKSIZE < 16
        #warning "minimum chunk size is less than housekeeping size"
    #endif //LDK_MINCHUNKSIZE < 16
#elif defined SIXTY_FOUR_BIT
    #if LDK_MINCHUNKSIZE < 32
        #warning "minimum chunk size is less than housekeeping size"
    #endif //LDK_MINCHUNKSIZE < 32
#endif //THIRTY_TWO_BIT

#define MAX_CHUNKS_PER_HEAP (LDK_HEAPSIZE_K/ LDK_MINCHUNKSIZE)


//Portability functions for allocating memory aligned on a
//particular byte boundary. This allocation system always
//uses 16-byte alignment. Memory allocated by this function
//is not tracked.
LDK_API void* alignedAlloc(size_t bytes, size_t align=BYTE_ALIGNMENT);
LDK_API void  alignedFree(void *mem);
//A wrapper function for alignedAlloc that places a Node structure
//prior to the usable memory.The Node structure makes the allocation
//able to be freed and realloced by LDK::dealloc and LDK::realloc.
inline void* bigAlloc(size_t size);

class LDK_API MetaPool;

namespace Details
{

class LDK_API Heap;
//                                                                    //
//      Struct Node. A header for a chunk and also a linked           //
//      list node. The list structure eliminates searching for        //
//      free chunks.                                                  //
//                                                                    //

struct LDK_API Node
{
    //Holds the actual size of the allocation to speed up realloc
    //and test if free
    size_t          mAllocSize;
    //next node in this heap
    Node*           mNext;
    //heap that owns this node (BIG freeChunk speedup)
    Heap*           mHeap;
    //Used to assert if a different thread to the allocating
    //thread attempts to delete this piece of memory
    size_t          mThreadID;
};


/*
** NB I use c-style casts in places because it is much
** easier to read. IMHO the reinterpret_cast syntax
** was never designed for such crazy casting.
*/

//Finds the mHeap member in the node that this memory
//belongs to.
inline Heap* getOwnerHeap(void* mem)
{
    // *(Heap**) (((char*)mem) - HeapOffsetIntoNodeInBytes);
    return *(Heap**) (((char*)mem) - sizeof(size_t) - sizeof(Heap*));
}

//returns the Node that owns this memory.
inline Node* getNode(void* mem)
{
    return (Node*)(((char*)mem) - sizeof(Node));
}

class LDK_API Pool;

//                                                                    //
//      Class Heap. Uses a very strange and (eventually) tangled      //
//      linked list of nodes and chunks that get allocated as         //
//      one block of ram, arranged like this:                         //
//                                                                    //
//      |--------------|    The tangle comes from nodes and chunks    //
//      |     Node     |    being reused, and the linked list means   //
//      |--------------|    there is no searching through the heap    //
//      |  Allocated   |    for a free node/chunk combination.        //
//      |    chunk     |    The nodes are headers for the chunks      //
//      |--------------|                                              //
//      |  Next Node   |                                              //
//      |--------------|                                              //
//      |Next Allocated|                                              //
//      |    chunk     |                                              //
//      |--------------|                                              //
//                                                                    //

class LDK_API Heap
{
    friend class LDK_API Pool;
    //the mem that gets split into Nodes and chunks
    void*   mMemory;
    //sizeof(Node) + chunkSize
    size_t  mNodeSize;
    //the next unused node
    Node*   mNextFree;
    //the last node in the heap
    Node*   mLastNode;
    //the size of the mem chunks this heap contains
    size_t  mChunkSize;
    //the noOfChunks in this heap that have been allocated
    size_t  mAllocCount;
    //the max allocs this heap can hold
    size_t  mMaxAllocs;
    //used in cleanup phase
    Pool*   mParent;
    //the requested heapSize
    const size_t mSizeInBytes;
    //size of the heap + sizeof the max possible no of nodes
    const size_t mRealSize;

    void setup(Pool* parent, size_t chunkSize);


public:

    //make sure this thing throws BadAllocError
    inline void* operator new(size_t size)
    {
        void* mem = malloc(size);
        if(!mem)
            throw LDK_BADALLOC_ERROR;
        return mem;
    }

    inline void operator delete(void* mem)
    {
        assert(mem);
        ::free(mem);
    }

    inline Heap(Pool* parent, size_t chunkSize, size_t size) :
     mMemory(NULL),
     mChunkSize(chunkSize),
     mSizeInBytes(size),
     mRealSize(size+(MAX_CHUNKS_PER_HEAP*sizeof(Node)))
    {
        mMemory = alignedAlloc(mRealSize);
        setup(parent, chunkSize);
    }

    inline ~Heap()
    {
        if(mMemory)
            alignedFree(mMemory);
    }

    //makes a node and chunk appear as one block of memory,
    //and a heap as an array of them. mNodeSize is sizeof(Node)
    //plus the size of the chunk.
    inline Node* operator[](size_t idx) const
    {
        return reinterpret_cast<Node*>((char*)mMemory + (idx*mNodeSize));
    }

    inline size_t chunkSize() const { return mChunkSize; }

    inline size_t sizeInBytes() const { return mSizeInBytes; }

    inline size_t allocCount() const { return mAllocCount; }

    inline size_t maxAllocs() const { return mMaxAllocs; }

    inline bool full() const { return !mNextFree; }

    inline bool empty() const { return mAllocCount == 0; }

    //Returns a free chunk from this heap and sets up the next
    //allocation. This method will never be called if mNextFree
    //is NULL
    inline void* allocChunk(size_t allocSize)
    {
        void *chunk = NULL;
        mNextFree->mAllocSize = allocSize;
        #ifndef NDEBUG
        mNextFree->mThreadID = currentThreadID();
        #endif
        chunk = (void*)(((char*)mNextFree) + sizeof(Node));
        mNextFree = mNextFree->mNext;
        mAllocCount++;
        return chunk;
    }

    //Frees a chunk of memory and sets up all the pointers so no
    //searching for free chunks is needed. This is what causes
    //the tangles in the list. When the heap this belongs to is
    //empty it gets passed to the parent pool for re-use.
    void freeChunk(void *mem);
};

//                                                                    //
//      Class Pool. Manages a vector of (equal chunkSize) heaps       //
//      for allocation, also facilitates recycling of heaps both      //
//      within itself and though MetaPool.                            //
//                                                                    //

class LDK_API Pool
{
protected:
    friend class LDK_API Heap;
    friend class LDK_API LDK::MetaPool; //g++-4.1 insists on LDK:: here... Odd.
    Heap* mCurrentHeap;
    Heap* mSpareHeap; //to avoid calling Heap::setup when there is no need
    size_t mChunkSize;
    MetaPool* mParent;
    const size_t mDefaultHeapSize;
#ifdef _MSC_VER
#pragma warning (disable : 4251)
#endif
    typedef std::vector<Heap*,MallocAllocator<Heap*> > HeapVector;
    HeapVector mHeaps;
#ifdef _MSC_VER
#pragma warning (default : 4251)
#endif

    //When a heap is completely empty try putting it in the
    //mSpareHeap member (so setup doesn't have to be called).
    //If mSpareHeap is already used, add the heap to a LIFO
    //in MetaPool for re-use elsewhere.
    void cleanup(Heap* h);

public:

    Pool(MetaPool* parent, size_t chunkSize, size_t defaultHeapSize);
    ~Pool();

    //Find a heap with a reasonable numer of free slots. If none
    //are free allocates a new heap as a last resort, hence could
    //throw BadAllocError. Implemented after MetaPool.
    void findHeap();

    //Returns a free chunk. Can throw BadAllocError.
    //Contains the only branches I can't remove in mempry present conditions.
    //Will trigger plenty more branches if mCurrentHeap is full though.
    inline void *allocChunk(size_t allocSize)
    {
        if(!mCurrentHeap || mCurrentHeap->full())
            findHeap();
        return mCurrentHeap->allocChunk(allocSize);
    }

    inline size_t chunkSize() const { return mChunkSize; }
    inline size_t noOfHeaps() const { return mHeaps.size(); }
    inline size_t defaultHeapSize() const { return mDefaultHeapSize; }
};



/***********************************************************************
**                                                                    **
**            Begin template metaprogramming                          **
**                                                                    **
***********************************************************************/

#define MIN_CHUNKSIZE LDK_MINCHUNKSIZE
#define MAX_CHUNKSIZE LDK_MAXCHUNKSIZE

//      Calculate (compile time) the number of pools required       //

template <int Size>
struct PoolCount
{
    enum { value = PoolCount<Size/2>::value + 1 };
};

//These terminates the above loop
template <>
struct LDK_API PoolCount<MIN_CHUNKSIZE>
{
    enum { value = 1 };
};

template <>
struct LDK_API PoolCount<(MIN_CHUNKSIZE+(MIN_CHUNKSIZE/2))>
{
    enum { value = 1 };
};

template <>
struct LDK_API PoolCount<(MIN_CHUNKSIZE+(MIN_CHUNKSIZE/3))>
{
    enum { value = 1 };
};

//provides easy acces to the compile time calculated number of
//pools
struct LDK_API NoOfPools
{
    enum
    {
        max = MAX_CHUNKSIZE,
        maxIsPowerOf2 = Meta::PowerOf2<max>::value,
        pwrOf2 = PoolCount<(maxIsPowerOf2 ? max : (max-(max/3)))>::value,
        notPwrOf2 = PoolCount<(maxIsPowerOf2 ? (max-(max/4)) : max)>::value,
        value = pwrOf2 + notPwrOf2
    };
};

//      Calculate (compile time) the chunkSize of the pool at Idx    //
template <int Idx>
class ChunkSize
{
    struct MinChunkPowerOf2
    {
        enum
        {
            powerOf2 = !(Idx%2),
            value = powerOf2 ? ChunkSize<Idx+1>::value - ChunkSize<Idx+1>::value/3 :\
                ChunkSize<Idx+1>::value - ChunkSize<Idx+1>::value/4
        };
    };
    struct MinChunkNotPowerOf2
    {
        enum
        {
            powerOf2 = Idx%2,
            value = powerOf2 ? ChunkSize<Idx+1>::value - ChunkSize<Idx+1>::value/3 :\
                ChunkSize<Idx+1>::value - ChunkSize<Idx+1>::value/4
        };
    };
public:
    enum
    {
        value = Meta::If<Meta::PowerOf2<MIN_CHUNKSIZE>::value, MinChunkPowerOf2,\
            MinChunkNotPowerOf2>::result::value
    };
};

//This terminates the above loop
template<>
class LDK_API ChunkSize<NoOfPools::value>
{
    struct LDK_API MaxChunkPowerOf2
    {
        enum { value = MAX_CHUNKSIZE + (MAX_CHUNKSIZE/2) };
    };
    struct LDK_API MaxChunkNotPowerOf2
    {
        enum { value = MAX_CHUNKSIZE + (MAX_CHUNKSIZE/3) };
    };
public:
    enum
    {
        value = Meta::If<Meta::PowerOf2<MAX_CHUNKSIZE>::value,\
            MaxChunkPowerOf2, MaxChunkNotPowerOf2>::result::value
    };
};

// Calculate (compile time) the best pool Idx to allocate Size bytes //
template
<
    int NoOfPools,
    int Size,
    int Idx=0
>
struct PoolIdxSearch
{
    enum
    {
        //will the requested alloc fit in a chunk?
        inRange = Size <=  MAX_CHUNKSIZE? true : false,
        //does the alloc fit in a pool, and it will fit in the current pool?
        fitsHereToo = (inRange && (Size < ChunkSize<Idx>::value)) ? true : false,
        //if it does return the current index, otherwise keep recursing
        value =  fitsHereToo ? Idx : PoolIdxSearch<NoOfPools,Size,Idx+1>::value
    };
};

//terminate the loop at NoOfPools::value, which means we have to use
//the run-time allocator because there isn't a pool large enough
template <int Size>
struct PoolIdxSearch<NoOfPools::value,Size,NoOfPools::value>
{
    enum { value = -1 };
};

#undef MIN_CHUNKSIZE
#undef MAX_CHUNKSIZE

/***********************************************************************
**                                                                    **
**              End template metaprogramming                          **
**                                                                    **
***********************************************************************/

} //namespace Details

//                                                                    //
//     Class MetaPool. Encapsulates multiple pools of different       //
//     chunkSizes, handles runtime searching for the best size        //
//     pool for an alloc, and manages recylcling of heaps between     //
//     pools with different chunkSizes.                               //
//                                                                    //
#ifdef _MSC_VER //non exported members
#pragma warning (disable : 4251)
#endif
class LDK_API MetaPool
{
private:

    friend class LDK_API Details::Pool;

    typedef Details::NoOfPools NoOfPools;

    //holds all the pools
    Details::Pool* mPools[NoOfPools::value];

    //some space to store empty heaps for re-use between
    //pools. Using a vector as a LIFO because of constant-time
    //pop_back() and ability to reserve space (which deque can't)

    typedef std::vector<Details::Heap*,MallocAllocator<Details::Heap*> > HeapVector;
    HeapVector mSpareHeaps;

    #ifdef LDK_TRACK_ALLOCATION
    struct TrackedAlloc
    {
        void* mMem;
        int   mLine;
        char  mFile[128];

        inline TrackedAlloc(const char* file=NULL, int line=0, void* mem=NULL)
        {
            mMem = mem;
            mLine = line;
            mFile[127]= '\0';
            strncpy(mFile,file,127);
        }
    };
    typedef std::list<TrackedAlloc,MallocAllocator<TrackedAlloc> > AllocList;
    AllocList mAllocs;
    #endif


    void addSpareHeap(Details::Heap* h);
    Details::Heap* findSpareHeap(size_t chunkSize);

public:
    #ifdef LDK_TRACK_ALLOCATION
    inline void trackAlloc(const char* file, int line, void* mem)
    {
        mAllocs.push_back(TrackedAlloc(file,line,mem));
    }

    inline void untrackAlloc(void* mem)
    {
        AllocList::iterator i = mAllocs.end();
        if(!mAllocs.empty())
        {
            i--;
            while(i != mAllocs.begin())
            {
                if((*i).mMem == mem)
                {
                    mAllocs.erase(i);
                    return;
                }
                i--;
            }
            if((*i).mMem == mem)
            {
                mAllocs.erase(i);
                return;
            }
        }
    }
    //called by ~MetaPool. Prints to the native stdout (not via the
    //VFileSystem).
    void dumpAllocs();
    #endif

    inline Details::Pool* pool(int idx)
    {
        return mPools[idx];
    }

    MetaPool();
    ~MetaPool();

    //Allocate size bytes (from a pool if possible). Can throw BadAllocError.
    void* alloc(const char* file, int line, size_t size);

    //Resize an allocation. This WILL crash if you pass it memory
    //that was not allocated through this allocation system.
    void* realloc(const char* file, int line, void *mem, size_t newSize);

    //Free an allocation. This WILL crash if you pass it memory
    //that was not allocated through this allocation system.
    void dealloc(void *mem)
    {
        if(mem)
        {
            #ifdef LDK_TRACK_ALLOCATION
            untrackAlloc(mem);
            #endif
            Details::Heap *h = Details::getOwnerHeap(mem);
            if(!h)
            {
                alignedFree(Details::getNode(mem));
                return;
            }
            h->freeChunk(mem);
        }
    }
};
#ifdef _MSC_VER
#pragma warning (default : 4251)
#endif

typedef Singleton<MetaPool> MemorySingleton;

//This struct will be the result of an If template if the
//requested size will fit in a pool.
template<int Idx>
struct CTAllocHelper
{
    inline static void* alloc(const char* file, int line, size_t size)
    {
        MetaPool& mp = MemorySingleton::instance();
        void* mem = mp.pool(Idx)->allocChunk(size);
        #ifdef LDK_TRACK_ALLOCATION
        mp.trackAlloc(file,line,mem);
        #endif
        return mem;
    }
};

//This struct will be the result of an If template if the
//requested size will not fit in a pool.
template<size_t Size>
struct RTAllocHelper
{
    inline static void* alloc(const char* file, int line, size_t)
    {
        void* mem = bigAlloc(Size);
        #ifdef LDK_TRACK_ALLOCATION
        MemorySingleton::instance().trackAlloc(file,line,mem);
        #endif
        return mem;
    }
};

/*
** Normal use API follows
*/


inline void* bigAlloc(size_t size) //add tracking
{
    void* mem = alignedAlloc(size+sizeof(Details::Node));
    Details::Node* n = reinterpret_cast<Details::Node*>(mem);
    n->mAllocSize = size;
    n->mNext = NULL;
    n->mHeap = NULL;
    #ifndef NDEBUG
    n->mThreadID = currentThreadID();
    #endif
    return (void*)((char*)mem+sizeof(Details::Node));
}



template<size_t Size>
inline void* alloc(const char* file, int line)
{
    const int idx =  Details::PoolIdxSearch<Details::NoOfPools::value,Size>::value;
    return Meta::If<idx!=-1,CTAllocHelper<idx>, \
        RTAllocHelper<Size> >::result::alloc(file,line,Size);
}
#define LDK_CTALLOC(size) LDK::alloc<size>(__FILE__,__LINE__)

#define LDK_CTTYPEALLOC(type,num) ((type*)LDK::alloc<sizeof(type)*num)>(__FILE__,__LINE__)

inline void* alloc(const char* file, int line, size_t size)
{
    return MemorySingleton::instance().alloc(file,line,size);
}
#define LDK_RTALLOC(size) LDK::alloc(__FILE__,__LINE__,size)

#define LDK_RTTYPEALLOC(type,num) ((type*)LDK::alloc(__FILE__,__LINE__,sizeof(type)*num))

inline void dealloc(void* mem)
{
    MemorySingleton::instance().dealloc(mem);
}

inline void* realloc(const char* file, int line, void *mem, size_t newSize)
{
    return MemorySingleton::instance().realloc(file,line,mem, newSize);
}
#define LDK_REALLOC(mem, newSize) LDK::realloc(__FILE__,__LINE__,mem,newSize)


template <class T>
inline T* create(const char* file, int line)
{
    void* mem = LDK::alloc<sizeof(T)>(file,line);
    try
    {
        return new (mem) T();
    }
    catch(std::exception& e)
    {
        LDK::dealloc(mem);
        throw e;
    }
    catch(...)
    {
        LDK::dealloc(mem);
        throw;
    }
};
#define LDK_CREATE0(Type) LDK::create<Type >(__FILE__,__LINE__)


template
<
    class T,
    typename C1
>
inline T* create(const char* file, int line, C1 c1)
{
    void* mem = LDK::alloc<sizeof(T)>(file,line);
    try
    {
        return new (mem) T(c1);
    }
    catch(std::exception& e)
    {
        LDK::dealloc(mem);
        throw e;
    }
    catch(...)
    {
        LDK::dealloc(mem);
        throw;
    }
};
#define LDK_CREATE1(Type,c1) LDK::create<Type >(__FILE__,__LINE__,c1)

template
<
    class T,
    typename C1,
    typename C2
>
inline T* create(const char* file, int line, C1 c1, C2 c2)
{
    void* mem = LDK::alloc<sizeof(T)>(file,line);
    try
    {
        return new (mem) T(c1,c2);
    }
    catch(std::exception& e)
    {
        LDK::dealloc(mem);
        throw e;
    }
    catch(...)
    {
        LDK::dealloc(mem);
        throw;
    }
};

#define LDK_CREATE2(Type,c1,c2) LDK::create<Type >(__FILE__,__LINE__,c1,c2)

template
<
    class T,
    typename C1,
    typename C2,
    typename C3
>
inline T* create(const char* file, int line, C1 c1, C2 c2, C3 c3)
{
    void* mem = LDK::alloc<sizeof(T)>(file,line);
    try
    {
        return new (mem) T(c1,c2,c3);
    }
    catch(std::exception& e)
    {
        LDK::dealloc(mem);
        throw e;
    }
    catch(...)
    {
        LDK::dealloc(mem);
        throw;
    }
};

#define LDK_CREATE3(Type,c1,c2,c3) LDK::create<Type >(__FILE__,__LINE__,c1,c2,c3)

template
<
    class T,
    typename C1,
    typename C2,
    typename C3,
    typename C4
>
inline T* create(const char* file, int line, C1 c1, C2 c2, C3 c3, C4 c4)
{
    void* mem = LDK::alloc<sizeof(T)>(file,line);
    try
    {
        return new (mem) T(c1,c2,c3,c4);
    }
    catch(std::exception& e)
    {
        LDK::dealloc(mem);
        throw e;
    }
    catch(...)
    {
        LDK::dealloc(mem);
        throw;
    }
};

#define LDK_CREATE4(Type,c1,c2,c3,c4) LDK::create<Type >(__FILE__,__LINE__,c1,c2,c3,c4)

template
<
    class T,
    typename C1,
    typename C2,
    typename C3,
    typename C4,
    typename C5
>
inline T* create(const char* file, int line, C1 c1, C2 c2, C3 c3, C4 c4, C5 c5)
{
    void* mem = LDK::alloc<sizeof(T)>(file,line);
    try
    {
        return new (mem) T(c1,c2,c3,c4,c5);
    }
    catch(std::exception& e)
    {
        LDK::dealloc(mem);
        throw e;
    }
    catch(...)
    {
        LDK::dealloc(mem);
        throw;
    }
};

#define LDK_CREATE5(Type,c1,c2,c3,c4,c5) LDK::create<Type >(__FILE__,__LINE__,c1,c2,c3,c4,c5)

template
<
    class T,
    typename C1,
    typename C2,
    typename C3,
    typename C4,
    typename C5,
    typename C6
>
inline T* create(const char* file, int line, C1 c1, C2 c2, C3 c3, C4 c4, C5 c5, C6 c6)
{
    void* mem = LDK::alloc<sizeof(T)>(file,line);
    try
    {
        return new (mem) T(c1,c2,c3,c4,c5,c6);
    }
    catch(std::exception& e)
    {
        LDK::dealloc(mem);
        throw e;
    }
    catch(...)
    {
        LDK::dealloc(mem);
        throw;
    }
};

#define LDK_CREATE6(Type,c1,c2,c3,c4,c5,c6) LDK::create<Type >(__FILE__,__LINE__,\
c1,c2,c3,c4,c5,c6)

template
<
    class T,
    typename C1,
    typename C2,
    typename C3,
    typename C4,
    typename C5,
    typename C6,
    typename C7
>
inline T* create(const char* file, int line, C1 c1, C2 c2, C3 c3, C4 c4, C5 c5, C6 c6, C7 c7)
{
    void* mem = LDK::alloc<sizeof(T)>(file,line);
    try
    {
        return new (mem) T(c1,c2,c3,c4,c5,c6,c7);
    }
    catch(std::exception& e)
    {
        LDK::dealloc(mem);
        throw e;
    }
    catch(...)
    {
        LDK::dealloc(mem);
        throw;
    }
};

#define LDK_CREATE7(Type,c1,c2,c3,c4,c5,c6,c7) LDK::create<Type >(__FILE__,__LINE__,\
c1,c2,c3,c4,c5,c6,c7)

template
<
    class T,
    typename C1,
    typename C2,
    typename C3,
    typename C4,
    typename C5,
    typename C6,
    typename C7,
    typename C8
>
inline T* create(const char* file, int line, C1 c1, C2 c2, C3 c3, C4 c4, C5 c5, C6 c6, C7 c7, C8 c8)
{
    void* mem = LDK::alloc<sizeof(T)>(file,line);
    try
    {
        return new (mem) T(c1,c2,c3,c4,c5,c6,c7,c8);
    }
    catch(std::exception& e)
    {
        LDK::dealloc(mem);
        throw e;
    }
    catch(...)
    {
        LDK::dealloc(mem);
        throw;
    }
};
#define LDK_CREATE8(Type,c1,c2,c3,c4,c5,c6,c7,c8) LDK::create<Type >(__FILE__,__LINE__,\
c1,c2,c3,c4,c5,c6,c7,c8)

template
<
    class T,
    typename C1,
    typename C2,
    typename C3,
    typename C4,
    typename C5,
    typename C6,
    typename C7,
    typename C8,
    typename C9
>
inline T* create(const char* file, int line, C1 c1, C2 c2, C3 c3, C4 c4, C5 c5, C6 c6, C7 c7, C8 c8, C9 c9)
{
    void* mem = LDK::alloc<sizeof(T)>(file,line);
    try
    {
        return new (mem) T(c1,c2,c3,c4,c5,c6,c7,c8,c9);
    }
    catch(std::exception& e)
    {
        LDK::dealloc(mem);
        throw e;
    }
    catch(...)
    {
        LDK::dealloc(mem);
        throw;
    }
};
#define LDK_CREATE9(Type,c1,c2,c3,c4,c5,c6,c7,c8,c9) LDK::create<Type >(__FILE__,__LINE__,\
c1,c2,c3,c4,c5,c6,c7,c8,c9)

template
<
    class T,
    typename C1,
    typename C2,
    typename C3,
    typename C4,
    typename C5,
    typename C6,
    typename C7,
    typename C8,
    typename C9,
    typename C10
>
inline T* create(const char* file, int line, C1 c1, C2 c2, C3 c3, C4 c4, C5 c5, C6 c6, C7 c7, C8 c8, C9 c9, C10 c10)
{
    void* mem = LDK::alloc<sizeof(T)>(file,line);
    try
    {
        return new (mem) T(c1,c2,c3,c4,c5,c6,c7,c8,c9,c10);
    }
    catch(std::exception& e)
    {
        LDK::dealloc(mem);
        throw e;
    }
    catch(...)
    {
        LDK::dealloc(mem);
        throw;
    }
};
#define LDK_CREATE10(Type,c1,c2,c3,c4,c5,c6,c7,c8,c9,c10) LDK::create<Type >(__FILE__,__LINE__,\
c1,c2,c3,c4,c5,c6,c7,c8,c9,c10)

template <class T>
inline void destroy(const T* o)
{
    //MSVC needs o to be const for SmartPointer :(
    T* obj = const_cast<T*>(o);
    if(obj)
    {
        obj->~T();
        LDK::dealloc(obj);
    }
}

#define LDK_ALLOCATORS \
inline void* operator new(size_t size)\
{\
    return LDK::alloc(size);\
}\
inline void operator delete(void* mem)\
{\
    LDK::dealloc(mem);\
}\
inline void* operator new[](size_t size)\
{\
    return LDK::alloc(size);\
}\
inline void operator delete[](void* mem)\
{\
    LDK::dealloc(mem);\
}


}//namespace LDK

#include "LDK/STLAllocator.h"
#include "LDK/STLMallocAllocator.h"

//clean up some macros
#undef BYTE_ALIGNMENT
#undef MAX_CHUNKS_PER_HEAP

#endif //__LDK_MEMORY_HH__

---