memory.h

Go to the documentation of this file.

// -*- mode: c++; tab-width: 4; indent-tabs-mode: t; eval: (progn (c-set-style "stroustrup") (c-set-offset 'innamespace 0)); -*-
// vi:set ts=4 sts=4 sw=4 noet :
//
// Copyright 2011, The TPIE development team
// 
// This file is part of TPIE.
// 
// TPIE is free software: you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License as published by the
// Free Software Foundation, either version 3 of the License, or (at your
// option) any later version.
// 
// TPIE 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.  See the GNU Lesser General Public
// License for more details.
// 
// You should have received a copy of the GNU Lesser General Public License
// along with TPIE.  If not, see <http://www.gnu.org/licenses/>


#ifndef __TPIE_MEMORY_H__
#define __TPIE_MEMORY_H__

#include <tpie/config.h>
#include <tpie/util.h>
#include <boost/thread/mutex.hpp>
#include <boost/unordered_map.hpp>
#include <boost/type_traits/is_polymorphic.hpp>
#include <utility>
#include <fstream>

namespace tpie {

namespace bits {
    class atomic_int;
}

struct out_of_memory_error : public std::bad_alloc {
    const char * msg;
    out_of_memory_error(const char * s) : msg(s) { }
    virtual const char* what() const throw() {return msg;}
};


class memory_manager {
public:
    enum enforce_t {
        ENFORCE_IGNORE,
        ENFORCE_DEBUG,
        ENFORCE_WARN,
        ENFORCE_THROW
    };

    size_t used() const throw();
   
    size_t available() const throw();

    inline size_t limit() const throw() {return m_limit;}
    
    void set_limit(size_t new_limit);

    void set_enforcement(enforce_t e);

    inline enforce_t enforcement() {return m_enforce;}

    void register_allocation(size_t bytes);

    void register_deallocation(size_t bytes);

    memory_manager();   

    std::pair<uint8_t *, size_t> __allocate_consecutive(size_t upper_bound, size_t granularity);

#ifndef TPIE_NDEBUG
    // The following methods take the mutex before calling the private doubly
    // underscored equivalent.
    void register_pointer(void * p, size_t size, const std::type_info & t);
    void unregister_pointer(void * p, size_t size, const std::type_info & t);
    void assert_tpie_ptr(void * p);
    void complain_about_unfreed_memory();
#endif


private:
    std::auto_ptr<bits::atomic_int> m_used;
    size_t m_limit;
    size_t m_maxExceeded;
    size_t m_nextWarning;
    enforce_t m_enforce;

#ifndef TPIE_NDEBUG
    boost::mutex m_mutex;

    // Before calling these methods, you must have the mutex.
    void __register_pointer(void * p, size_t size, const std::type_info & t);
    void __unregister_pointer(void * p, size_t size, const std::type_info & t);
    void __assert_tpie_ptr(void * p);
    void __complain_about_unfreed_memory();

    boost::unordered_map<void *, std::pair<size_t, const std::type_info *> > m_pointers;
#endif
};

void init_memory_manager();

void finish_memory_manager();

memory_manager & get_memory_manager();

inline void __register_pointer(void * p, size_t size, const std::type_info & t) {
#ifndef TPIE_NDEBUG
    get_memory_manager().register_pointer(p, size, t);
#else
    unused(p);
    unused(size);
    unused(t);
#endif
}

inline void __unregister_pointer(void * p, size_t size, const std::type_info & t) {
#ifndef TPIE_NDEBUG
    get_memory_manager().unregister_pointer(p, size, t);
#else
    unused(p);
    unused(size);
    unused(t);
#endif
}

inline void assert_tpie_ptr(void * p) {
#ifndef TPIE_NDEBUG
    if (p)
        get_memory_manager().assert_tpie_ptr(p);
#else
    unused(p);
#endif
}

#ifndef DOXYGEN
template <typename T, bool x=boost::is_polymorphic<T>::value >
struct __object_addr {
    inline void * operator()(T * o) {return static_cast<void *>(o);}
};

template <typename T>
struct __object_addr<T, true> {
    inline void * operator()(T * o) {return dynamic_cast<void *>(o);}
};
#endif

template <typename D, typename T>
inline D ptr_cast(T * t) { return reinterpret_cast<D>(__object_addr<T>()(t)); }


template <typename T>
inline T * __allocate() {
    if(!boost::is_polymorphic<T>::value) return reinterpret_cast<T *>(new uint8_t[sizeof(T)]);  
    uint8_t * x = new uint8_t[sizeof(T)+sizeof(size_t)];
    *reinterpret_cast<size_t*>(x) = sizeof(T);
    return reinterpret_cast<T*>(x + sizeof(size_t));
}

template <typename T>
inline size_t tpie_size(T * p) {
    if(!boost::is_polymorphic<T>::value) return sizeof(T);
    uint8_t * x = ptr_cast<uint8_t *>(p);
    return * reinterpret_cast<size_t *>(x - sizeof(size_t));
}


template <typename T>
struct array_allocation_scope_magic {
    size_t size;
    T * data;
    inline array_allocation_scope_magic(size_t s): size(0), data(0) {
        get_memory_manager().register_allocation(s * sizeof(T) );
        size=s;
    }

    inline T * allocate() {
        data = new T[size];
        __register_pointer(data, size*sizeof(T), typeid(T));
        return data;
    }

    T * finalize() {
        T * d = data;
        size = 0;
        data = 0;
        return d;
    }

    inline ~array_allocation_scope_magic() {
        if(size) get_memory_manager().register_deallocation(size*sizeof(T));
    }
};

template <typename T>
struct allocation_scope_magic {
    size_t deregister;
    T * data;
    inline allocation_scope_magic(): deregister(0), data(0) {}
    
    inline T * allocate() {
        get_memory_manager().register_allocation(sizeof(T));
        deregister = sizeof(T);
        data = __allocate<T>();
        __register_pointer(data, sizeof(T), typeid(T));
        return data;
    }

    T * finalize() {
        T * d = data;
        deregister = 0;
        data = 0;
        return d;
    }
    
    inline ~allocation_scope_magic() {
        if (data) __unregister_pointer(data, sizeof(T), typeid(T));
        delete[] reinterpret_cast<uint8_t*>(data);
        if (deregister) get_memory_manager().register_deallocation(deregister);
    }
};

template <typename T>
inline T * tpie_new_array(size_t size) {
    array_allocation_scope_magic<T> m(size);
    m.allocate();
    return m.finalize();
}


#ifdef DOXYGEN
template <typename T, typename Args>
inline T * tpie_new(Args args);

#elif defined(TPIE_CPP_VARIADIC_TEMPLATES) && defined(TPIE_CPP_RVALUE_REFERENCE)

template <typename T, typename ... Args>
inline T * tpie_new(Args &&... args) {
    allocation_scope_magic<T> m; 
    new(m.allocate()) T(std::forward<Args>(args)...);
    return m.finalize();
}

#else
#include <tpie/memory.inl>
#endif

template <typename T>
inline void tpie_delete(T * p) throw() {
    if (p == 0) return;
    get_memory_manager().register_deallocation(tpie_size(p));
    uint8_t * pp = ptr_cast<uint8_t *>(p);
    __unregister_pointer(pp, tpie_size(p), typeid(*p));
    p->~T();
    if(!boost::is_polymorphic<T>::value) 
        delete[] pp;
    else
        delete[] (pp - sizeof(size_t));
}

template <typename T>
inline void tpie_delete_array(T * a, size_t size) throw() {
    if (a == 0) return;
    get_memory_manager().register_deallocation(sizeof(T) * size);
    __unregister_pointer(a, sizeof(T) * size, typeid(T) );
    delete[] a;
}

template <typename T>
struct auto_ptr_ref {
    T * m_ptr;
    explicit inline auto_ptr_ref(T * ptr) throw(): m_ptr(ptr) {};
};

template <typename T>
class auto_ptr {
private:
    T * elm;
    // auto_ptr(const auto_ptr & o) {unused(o); assert(false);}
    // auto_ptr & operator = (const auto_ptr & o) {unused(o); assert(false);}
public:
    typedef T element_type;

    // D.10.1.1 construct/copy/destroy:
    explicit inline auto_ptr(T * o=0) throw(): elm(0){reset(o);}    
    inline auto_ptr(auto_ptr & o) throw(): elm(0) {reset(o.release());}
    template <class Y> 
    inline auto_ptr(auto_ptr<Y> & o) throw(): elm(0) {reset(o.release());}
    
    inline auto_ptr & operator =(auto_ptr & o) throw() {reset(o.release()); return *this;}
    template <class Y>
    inline auto_ptr & operator =(auto_ptr<Y> & o) throw() {reset(o.release()); return *this;}
    inline auto_ptr & operator =(auto_ptr_ref<T> r) throw() {reset(r.m_ptr); return *this;}

    inline ~auto_ptr() throw() {reset();}

    // D.10.1.2 members:
    inline T & operator*() const throw() {return *elm;}
    inline T * operator->() const throw() {return elm;}
    inline T * get() const throw() {return elm;}    
    inline T * release() throw () {T * t=elm; elm=0; return t;} 
    inline void reset(T * o=0) throw () {
        if (o == elm) return;
        tpie_delete<T>(elm);
        assert_tpie_ptr(o);
        elm=o; 
    }

    // D.10.1.3 conversions:
    inline auto_ptr(auto_ptr_ref<T> r) throw(): elm(0)  {reset(r.m_ptr);}
    
    template <class Y> 
        inline operator auto_ptr_ref<Y>() throw() {return auto_ptr_ref<Y>(release());}

    template<class Y> 
        inline operator auto_ptr<Y>() throw() {return auto_ptr<Y>(release());}
};

template <class T>
class allocator {
private:
    typedef std::allocator<T> a_t;
    a_t a;
public:
    typedef typename a_t::size_type size_type;
    typedef typename a_t::difference_type difference_type;
    typedef typename a_t::pointer pointer;
    typedef typename a_t::const_pointer const_pointer;
    typedef typename a_t::reference reference;
    typedef typename a_t::const_reference const_reference;
    typedef typename a_t::value_type value_type;

    allocator() throw() {}
    allocator(const allocator & a) throw() {unused(a);}
    template <typename T2>
    allocator(const allocator<T2> & a) throw() {unused(a);}

    template <class U> struct rebind {typedef allocator<U> other;};

    inline T * allocate(size_t size, const void * hint=0) {
        get_memory_manager().register_allocation(size * sizeof(T));
        T * res = a.allocate(size, hint);
        __register_pointer(res, size, typeid(T));
        return res;
    }

    inline void deallocate(T * p, size_t n) {
        if (p == 0) return;
        __unregister_pointer(p, n, typeid(T));
        get_memory_manager().register_deallocation(n * sizeof(T));
        return a.deallocate(p, n);
    }
    inline size_t max_size() const {return a.max_size();}

#ifdef TPIE_CPP_RVALUE_REFERENCE
#ifdef TPIE_CPP_VARIADIC_TEMPLATES
    template <typename ...TT>
    inline void construct(T * p, TT &&...x) {a.construct(p, x...);}
#else
    #ifdef __clang__
        //push the current warning state
        #pragma clang diagnostic push
        //disable warning about "rvalue references are a C++11 extension
        #pragma clang diagnostic ignored "-Wc++11-extensions" 
    #endif
    template <typename TT>
    inline void construct(T * p, TT && val) {a.construct(p, val);}
    #ifdef __clang__
        //restore the warning state
        #pragma clang diagnostic pop
    #endif
#endif
#endif
    inline void construct(T * p) {
#ifdef WIN32
#pragma warning( push )
#pragma warning(disable: 4345)
#endif
        new(p) T();
#ifdef WIN32
#pragma warning( pop )
#endif
    }
    inline void construct(T * p, const T& val) {a.construct(p, val);}
    inline void destroy(T * p) {a.destroy(p);}    
    inline pointer address(reference x) const {return &x;}
    inline const_pointer address(const_reference x) const {return &x;}
};

template <typename T>
inline bool operator==(const tpie::allocator<T>&, const tpie::allocator<T>&) {return true;}
  
template<typename T>
inline bool operator!=(const tpie::allocator<T>&, const tpie::allocator<T>&) {return false;}


size_t consecutive_memory_available(size_t granularity=5*1024*1024);

} //namespace tpie

namespace std {
template <typename T>
void swap(tpie::auto_ptr<T> & a, tpie::auto_ptr<T> & b) {
    T * t =a.release();
    a.reset(b.release());
    b.reset(t);
}
} //namespace std

#endif //__TPIE_MEMORY_H__