FXMemoryPool.h

Go to the documentation of this file.

/********************************************************************************
*                                                                               *
*                              Custom Memory Pool                               *
*                                                                               *
*********************************************************************************
*        Copyright (C) 2003-2009 by Niall Douglas.   All Rights Reserved.       *
*       NOTE THAT I DO NOT PERMIT ANY OF MY CODE TO BE PROMOTED TO THE GPL      *
*********************************************************************************
* This code is free software; you can redistribute it and/or modify it under    *
* the terms of the GNU Library General Public License v2.1 as published by the  *
* Free Software Foundation EXCEPT that clause 3 does not apply ie; you may not  *
* "upgrade" this code to the GPL without my prior written permission.           *
* Please consult the file "License_Addendum2.txt" accompanying this file.       *
*                                                                               *
* This code is distributed in the hope that it will be useful,                  *
* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.                          *
*********************************************************************************
* $Id:                                                                          *
********************************************************************************/

#if !defined(FXDEFS_H) && !defined(DOXYGEN_SHOULD_SKIP_THIS)
#include "fxdefs.h"
#else

#ifndef FXMEMORYPOOL_H
#define FXMEMORYPOOL_H

#ifdef _MSC_VER
// This is a totally braindead warning :(
#pragma warning(disable: 4290) // C++ exception specification ignored except it's not nothrow
#endif

#include <string.h>
#include <new>


namespace FX {

class FXMemoryPool;
class QThread;

extern FXAPI FXMALLOCATTR void *malloc(size_t size, FXMemoryPool *heap=0, FXuint alignment=0) throw();
extern FXAPI FXMALLOCATTR void *calloc(size_t no, size_t size, FXMemoryPool *heap=0, FXuint alignment=0) throw();
extern FXAPI FXMALLOCATTR void *realloc(void *p, size_t size, FXMemoryPool *heap=0) throw();
extern FXAPI void free(void *p, FXMemoryPool *heap=0) throw();

template<typename T> inline FXMALLOCATTR T *malloc(size_t size, FXMemoryPool *heap=0, FXuint alignment=0) throw();
template<typename T> inline T *malloc(size_t size, FXMemoryPool *heap, FXuint alignment) throw() { return (T *) FX::malloc(size, heap, alignment); }
template<typename T> inline FXMALLOCATTR T *calloc(size_t no, size_t size, FXMemoryPool *heap=0, FXuint alignment=0) throw();
template<typename T> inline T *calloc(size_t no, size_t size, FXMemoryPool *heap, FXuint alignment) throw() { return (T *) FX::calloc(no, size, heap, alignment); }
template<typename T> inline FXMALLOCATTR T *realloc(T *p, size_t size, FXMemoryPool *heap=0) throw();
template<typename T> inline T *realloc(T *p, size_t size, FXMemoryPool *heap) throw() { return (T *) FX::realloc((void *) p, size, heap); }
template<typename T> inline void free(T *p, FXMemoryPool *heap=0) throw() { FX::free((void *) p, heap); }
#if defined(DEBUG)
extern FXAPI FXMALLOCATTR void *malloc_dbg(const char *file, const char *function, int lineno, size_t size, FXMemoryPool *heap=0, FXuint alignment=0) throw();
extern FXAPI FXMALLOCATTR void *calloc_dbg(const char *file, const char *function, int lineno, size_t no, size_t size, FXMemoryPool *heap=0, FXuint alignment=0) throw();
extern FXAPI FXMALLOCATTR void *realloc_dbg(const char *file, const char *function, int lineno, void *p, size_t size, FXMemoryPool *heap=0) throw();

template<typename T> inline FXMALLOCATTR T *malloc_dbg(const char *file, const char *function, int lineno, size_t size, FXMemoryPool *heap=0, FXuint alignment=0) throw();
template<typename T> inline T *malloc_dbg(const char *file, const char *function, int lineno, size_t size, FXMemoryPool *heap, FXuint alignment) throw() { return (T *) malloc_dbg(file, function, lineno, size, heap, alignment); };
template<typename T> inline FXMALLOCATTR void *calloc_dbg(const char *file, const char *function, int lineno, size_t no, size_t size, FXMemoryPool *heap=0, FXuint alignment=0) throw();
template<typename T> inline T *calloc_dbg(const char *file, const char *function, int lineno, size_t no, size_t size, FXMemoryPool *heap, FXuint alignment) throw() { return (T *) calloc_dbg(file, function, lineno, no, size, heap, alignment); };
template<typename T> inline FXMALLOCATTR T *realloc_dbg(const char *file, const char *function, int lineno, T *ptr, size_t size, FXMemoryPool *heap=0) throw();
template<typename T> inline T *realloc_dbg(const char *file, const char *function, int lineno, T *ptr, size_t size, FXMemoryPool *heap) throw() { return (T *) realloc_dbg(file, function, lineno, (void *) ptr, size, heap); };
}
// Just to keep non FX namespace users happy
inline FXMALLOCATTR void *malloc_dbg(const char *file, const char *function, int lineno, size_t size) throw() { return malloc(size); }
inline FXMALLOCATTR void *calloc_dbg(const char *file, const char *function, int lineno, size_t no, size_t size) throw() { return calloc(no, size); }
inline FXMALLOCATTR void *realloc_dbg(const char *file, const char *function, int lineno, void *ptr, size_t size) throw() { return realloc(ptr, size); }
namespace FX {
extern FXAPI bool printLeakedBlocks() throw();
#endif
// This one caught me out for a while
inline FXMALLOCATTR char *strdup(const char *str) throw();
inline char *strdup(const char *str) throw()
{
    size_t len=strlen(str);
    void *ret=FX::malloc(len+1);
    if(!ret) return NULL;
    memcpy(ret, str, len+1);
    return (char *) ret;
}
extern FXAPI void failonfree(void *p, FXMemoryPool *heap=0) throw();
extern FXAPI void unfailonfree(void *p, FXMemoryPool *heap=0) throw();

template<typename T, int alignment> class aligned_allocator
{
public:
    typedef T *pointer;
    typedef const T *const_pointer;
    typedef T &reference;
    typedef const T &const_reference;
    typedef T value_type;
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;
    T *address(T &r) const { return &r; }
    const T *address(const T &s) const { return &s; }
    size_t max_size() const { return (static_cast<size_t>(0) - static_cast<size_t>(1)) / sizeof(T); }
    template <typename U> struct rebind {
        typedef aligned_allocator<U, alignment> other;
    };
    bool operator!=(const aligned_allocator &other) const { return !(*this == other); }
    bool operator==(const aligned_allocator &other) const { return true; }

    void construct(T *const p, const T &t) const {
        void * const pv = static_cast<void *>(p);
        new (pv) T(t);
    }
    void destroy(T *const p) const {
        p->~T();
    }
    aligned_allocator() { }
    aligned_allocator(const aligned_allocator &) { }
    template <typename U> aligned_allocator(const aligned_allocator<U, alignment> &) { }

    T *allocate(const size_t n) const {
        void *pv = malloc(n * sizeof(T), 0, alignment);
        if (pv == NULL) throw std::bad_alloc();
        return static_cast<T *>(pv);
    }
    void deallocate(T *p, const size_t n) const {
        free(p, 0);
    }
    template <typename U> T * allocate(const size_t n, const U * /* const hint */) const {
        return allocate(n);
    }
private:
    aligned_allocator &operator=(const aligned_allocator &);
};


} // namespace

inline FXDLLPUBLIC FXMALLOCATTR void *operator new(size_t size, FX::FXMemoryPool *heap, FX::FXuint alignment=0) throw(std::bad_alloc);
inline FXDLLPUBLIC void *operator new(size_t size, FX::FXMemoryPool *heap, FX::FXuint alignment) throw(std::bad_alloc)
{
    void *ret;
    if(!(ret=FX::malloc(size, heap, alignment))) throw std::bad_alloc();
    return ret;
}
inline FXDLLPUBLIC FXMALLOCATTR void *operator new[](size_t size, FX::FXMemoryPool *heap, FX::FXuint alignment=0) throw(std::bad_alloc);
inline FXDLLPUBLIC void *operator new[](size_t size, FX::FXMemoryPool *heap, FX::FXuint alignment) throw(std::bad_alloc)
{
    void *ret;
    if(!(ret=FX::malloc(size, heap, alignment))) throw std::bad_alloc();
    return ret;
}
inline FXDLLPUBLIC void operator delete(void *p, FX::FXMemoryPool *heap) throw()
{
    if(p) FX::free(p, heap);
}
inline FXDLLPUBLIC void operator delete[](void *p, FX::FXMemoryPool *heap) throw()
{
    if(p) FX::free(p, heap);
}
#ifdef DEBUG
inline FXDLLPUBLIC FXMALLOCATTR void *operator new(size_t size, const char *file, const char *function, int lineno, FX::FXMemoryPool *heap, FX::FXuint alignment) throw(std::bad_alloc);
inline FXDLLPUBLIC void *operator new(size_t size, const char *file, const char *function, int lineno, FX::FXMemoryPool *heap, FX::FXuint alignment) throw(std::bad_alloc)
{
    void *ret;
    if(!(ret=FX::malloc_dbg(file, function, lineno, size, heap, alignment))) throw std::bad_alloc();
    return ret;
}
inline FXDLLPUBLIC FXMALLOCATTR void *operator new[](size_t size, const char *file, const char *function, int lineno, FX::FXMemoryPool *heap, FX::FXuint alignment) throw(std::bad_alloc);
inline FXDLLPUBLIC void *operator new[](size_t size, const char *file, const char *function, int lineno, FX::FXMemoryPool *heap, FX::FXuint alignment) throw(std::bad_alloc)
{
    void *ret;
    if(!(ret=FX::malloc_dbg(file, function, lineno, size, heap, alignment))) throw std::bad_alloc();
    return ret;
}
inline FXDLLPUBLIC void operator delete(void *ptr, const char *file, const char *function, int lineno, FX::FXMemoryPool *heap, FX::FXuint alignment) throw()
{
    if(ptr) FX::free(ptr, heap);
}
inline FXDLLPUBLIC void operator delete[](void *ptr, const char *file, const char *function, int lineno, FX::FXMemoryPool *heap, FX::FXuint alignment) throw()
{
    if(ptr) FX::free(ptr, heap);
}
#endif

namespace FX {


struct FXMemoryPoolPrivate;
class FXAPI FXMemoryPool
{
    friend FXAPI void *malloc(size_t size, FXMemoryPool *heap, FXuint alignment) throw();
    friend FXAPI void *malloc_dbg(const char *file, const char *function, int lineno, size_t size, FXMemoryPool *heap, FXuint alignment) throw();
    friend FXAPI void *calloc(size_t no, size_t _size, FXMemoryPool *heap, FXuint alignment) throw();
    friend FXAPI void *calloc_dbg(const char *file, const char *function, int lineno, size_t no, size_t _size, FXMemoryPool *heap, FXuint alignment) throw();
    friend FXAPI void *realloc(void *p, size_t size, FXMemoryPool *heap) throw();
    friend FXAPI void *realloc_dbg(const char *file, const char *function, int lineno, void *p, size_t size, FXMemoryPool *heap) throw();
    friend FXAPI void free(void *p, FXMemoryPool *heap) throw();
    FXMemoryPoolPrivate *p;
    FXMemoryPool(const FXMemoryPool &);
    FXMemoryPool &operator=(const FXMemoryPool &);
public:
    static const FXuval minHeapVirtualSpace=1024*1024;
    struct Statistics
    {
        FXuval arena;       
        FXuval freeChunks;  
        FXuval fastChunks;  
        FXuval mmapRegions; 
        FXuval mmapBytes;   
        FXuval maxAlloc;    
        FXuval totalFast;   
        FXuval totalAlloc;  
        FXuval totalFree;   
        FXuval keepCost;    
        Statistics(FXuval a, FXuval b, FXuval c, FXuval d, FXuval e, FXuval f,
            FXuval g, FXuval h, FXuval i, FXuval j) : arena(a), freeChunks(b), fastChunks(c),
            mmapRegions(d), mmapBytes(e), maxAlloc(f), totalFast(g), totalAlloc(h),
            totalFree(i), keepCost(j) { }
    };
    FXMemoryPool(FXuval maximum=(FXuval)-1, const char *identifier=0, QThread *owner=0, bool lazydeleted=false);
    ~FXMemoryPool();
    FXuval size() const throw();
    FXuval maxsize() const throw();
    FXMALLOCATTR void *malloc(FXuval size, FXuint alignment=0) throw();
    FXMALLOCATTR void *calloc(FXuint no, FXuval size, FXuint alignment=0) throw();
    void free(void *blk, FXuint alignment=0) throw();
    FXMALLOCATTR void *realloc(void *blk, FXuval size) throw();
    static FXMemoryPool *poolFromBlk(void *blk) throw();
public:
    static FXMALLOCATTR void *glmalloc(FXuval size, FXuint alignment=0) throw();
    static FXMALLOCATTR void *glcalloc(FXuval no, FXuval size, FXuint alignment=0) throw();
    static void glfree(void *blk, FXuint alignment=0) throw();
    static FXMALLOCATTR void *glrealloc(void *blk, FXuval size) throw();
    static bool gltrim(FXuval left) throw();
    static Statistics glstats() throw();
    static FXString glstatsAsString();
public:
    static FXMemoryPool *current();
    static void setCurrent(FXMemoryPool *heap);

    struct MemoryPoolInfo
    {
        bool deleted;           
        QThread *owner;     
        const char *identifier; 
        FXuval maximum;         
        FXuval allocated;       
    };
    static QMemArray<MemoryPoolInfo> statistics();
};

class FXMemPoolHold
{
    FXMemoryPool *oldheap;
public:
    FXMemPoolHold(FXMemoryPool *newheap) : oldheap(FXMemoryPool::current()) { FXMemoryPool::setCurrent(newheap); }
    ~FXMemPoolHold() { FXMemoryPool::setCurrent(oldheap); }
};

} // namespace

extern "C" FXAPI FXMALLOCATTR void *tnfxmalloc(size_t size);
extern "C" FXAPI FXMALLOCATTR void *tnfxcalloc(size_t no, size_t size);
extern "C" FXAPI FXMALLOCATTR void *tnfxrealloc(void *p, size_t size);
extern "C" FXAPI void tnfxfree(void *p);

// Okay back in the global namespace. Define replacement new/delete but weakly
// (side effect of inline) so the linker can elide all duplicates and leave one
// in each binary. Ensure it's public visibility on ELF.
inline FXDLLPUBLIC FXMALLOCATTR void *operator new(size_t size) throw(std::bad_alloc);
inline FXDLLPUBLIC void *operator new(size_t size) throw(std::bad_alloc)
{
    void *ret;
    if(!(ret=FX::malloc(size))) throw std::bad_alloc();
    return ret;
}
inline FXDLLPUBLIC FXMALLOCATTR void *operator new[](size_t size) throw(std::bad_alloc);
inline FXDLLPUBLIC void *operator new[](size_t size) throw(std::bad_alloc)
{
    void *ret;
    if(!(ret=FX::malloc(size))) throw std::bad_alloc();
    return ret;
}
inline FXDLLPUBLIC void operator delete(void *p) throw()
{
    if(p) FX::free(p);
}
inline FXDLLPUBLIC void operator delete[](void *p) throw()
{
    if(p) FX::free(p);
}


#endif
#endif

---

(C) 2002-2009 Niall Douglas. Some parts (C) to assorted authors.