JeAllocator

JeAllocator.hpp

#ifndef __JeAllocator__HEADER__
#define __JeAllocator__HEADER__

#define JEMALLOC_NO_DEMANGLE 1
#include "jemalloc/jemalloc.h"

template<typename T>
class JeAllocator {
public : 
    //    typedefs
    typedef T value_type;
    typedef value_type* pointer;
    typedef const value_type* const_pointer;
    typedef value_type& reference;
    typedef const value_type& const_reference;
    typedef std::size_t size_type;
    typedef std::ptrdiff_t difference_type;

public : 
    //    convert an allocator<T> to allocator<U>
    template<typename U>
    struct rebind {
        typedef JeAllocator<U> other;
    };

public : 
    JeAllocator() {}
    ~JeAllocator() {}
    JeAllocator(const JeAllocator&) {}
    template<typename U>
    JeAllocator(const JeAllocator<U>&) {}

    //    address
    inline pointer address(reference r) { return &r; }
    inline const_pointer address(const_reference r) { return &r; }

    //    memory allocation
    inline pointer allocate(size_type cnt, 
       typename std::allocator<void>::const_pointer = 0) 
    { 
      return reinterpret_cast<pointer>(je_malloc(cnt * sizeof (T) )); 
    }
    inline void deallocate(pointer p, size_type) { 
	je_free(p);
    }

    //    size
    inline size_type max_size() const { 
        return std::numeric_limits<size_type>::max() / sizeof(T);
 }

    //    construction/destruction
    inline void construct(pointer p, const T& t) { new(p) T(t); }
    inline void destroy(pointer p) { p->~T(); }

    inline bool operator==(JeAllocator const&) { return true; }
    inline bool operator!=(JeAllocator const& a) { return !operator==(a); }
};    //    end of class JeAllocator 

#endif