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/tpie_export.h>
#include <tpie/config.h>
#include <tpie/util.h>
#include <tpie/resource_manager.h>
#include <mutex>
#include <unordered_map>
#include <type_traits>
#include <utility>
#include <memory>
#include <atomic>
#include <typeindex>
 
namespace tpie {
 
struct memory_digest_item {
    std::string name;
    size_t count;
    size_t bytes;
    std::type_info * ti;
};
 
struct type_allocations {
    std::atomic_size_t bytes;
    std::atomic_size_t count;
    type_allocations() noexcept: bytes(0), count(0) {}
    type_allocations(const type_allocations & o) noexcept {bytes = (size_t)o.bytes; count = (size_t)o.count;}
    type_allocations(type_allocations && o) noexcept {bytes = (size_t)o.bytes; count = (size_t)o.count;}
    type_allocations & operator=(const type_allocations & o) noexcept {bytes = (size_t)o.bytes; count = (size_t)o.count; return *this;}
    type_allocations & operator=(type_allocations && o) noexcept {bytes = (size_t)o.bytes; count = (size_t)o.count; return *this;}
};
 
class TPIE_EXPORT memory_manager final : public resource_manager {
public:
    memory_manager();   
 
    std::pair<uint8_t *, size_t> __allocate_consecutive(size_t upper_bound, size_t granularity);
 
    void register_typed_allocation(size_t bytes, const std::type_info & t);
    void register_typed_deallocation(size_t bytes, const std::type_info & t);
    
    void register_allocation(size_t bytes, const std::type_info & t) {
        register_increased_usage(bytes);
#ifndef TPIE_NDEBUG
        register_typed_allocation(bytes, t);
#else
        unused(t);
#endif
    }
 
    void register_deallocation(size_t bytes, const std::type_info & t) {
        register_decreased_usage(bytes);
#ifndef TPIE_NDEBUG
        register_typed_deallocation(bytes, t);
#else
        unused(t);
#endif
    }
 
    std::string amount_with_unit(size_t amount) const override {
        return pretty_print_size(amount);
    }
 
    void complain_about_unfreed_memory();
    std::unordered_map<std::type_index, memory_digest_item> memory_digest();
protected:
    void throw_out_of_resource_error(const std::string & s) override;
 
    std::atomic_size_t m_mutex;
    std::unordered_map<std::type_index, type_allocations> m_allocations;
};
 
void init_memory_manager();
 
void finish_memory_manager();
 
TPIE_EXPORT memory_manager & get_memory_manager();
 
#ifndef DOXYGEN
template <typename T, 
    bool x=std::is_polymorphic<T>::value
>
struct __object_addr {
    void * operator()(T * o) {return const_cast<void*>(static_cast<const void*>(o));}
};
 
template <typename T>
struct __object_addr<T, true> {
    void * operator()(T * o) {return const_cast<void*>(dynamic_cast<const 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(!std::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(!std::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;
    array_allocation_scope_magic(size_t s): size(0), data(0) {
        get_memory_manager().register_allocation(s * sizeof(T), typeid(T) );
        size=s;
    }
 
    T * allocate() {
        data = new T[size];
        return data;
    }
 
    T * finalize() {
        T * d = data;
        size = 0;
        data = 0;
        return d;
    }
 
    ~array_allocation_scope_magic() {
        if(size) get_memory_manager().register_deallocation(size*sizeof(T), typeid(T) );
    }
};
 
template <typename T>
struct allocation_scope_magic {
    size_t deregister;
    T * data;
    allocation_scope_magic(): deregister(0), data(0) {}
    
    T * allocate() {
        get_memory_manager().register_allocation(sizeof(T), typeid(T));
        deregister = sizeof(T);
        data = __allocate<T>();
        return data;
    }
 
    T * finalize() {
        T * d = data;
        deregister = 0;
        data = 0;
        return d;
    }
    
    ~allocation_scope_magic() {
        delete[] reinterpret_cast<uint8_t*>(data);
        if (deregister) get_memory_manager().register_deallocation(deregister, typeid(T));
    }
};
 
template <typename T>
inline T * tpie_new_array(size_t size) {
    array_allocation_scope_magic<T> m(size);
    m.allocate();
    return m.finalize();
}
 
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();
}
 
template <typename T>
inline void tpie_delete(T * p) throw() {
    if (p == 0) return;
    get_memory_manager().register_deallocation(tpie_size(p), typeid(*p));
    uint8_t * pp = ptr_cast<uint8_t *>(p);
    p->~T();
    if(!std::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, typeid(T));
    delete[] a;
}
 
struct tpie_deleter {
    template <typename T>
    void operator()(T * t) {
        tpie_delete(t);
    }
};
 
template <typename T>
using unique_ptr=std::unique_ptr<T, tpie_deleter>;
 
template <typename T, typename ... TT>
inline unique_ptr<T> make_unique(TT && ... tt) {
    return unique_ptr<T>(tpie_new<T>(std::forward<TT>(tt)...));
}
 
class memory_bucket {
public:
    memory_bucket(): count(0) {}
    
    std::atomic_size_t count;
    std::string name;
};
 
class memory_bucket_ref {
public:
    explicit memory_bucket_ref(memory_bucket * b=nullptr) noexcept: bucket(b) {}
    explicit operator bool() const noexcept {return bucket != nullptr;}
    memory_bucket_ref(const memory_bucket_ref & o)  = default;
    memory_bucket_ref(memory_bucket_ref && o) = default;
    memory_bucket_ref & operator=(const memory_bucket_ref & o) = default;
    memory_bucket_ref & operator=(memory_bucket_ref && o) = default;
    memory_bucket & operator*() noexcept {return *bucket;} 
    const memory_bucket & operator*() const noexcept {return *bucket;} 
    memory_bucket * operator->() noexcept {return bucket;} 
    const memory_bucket * operator->() const noexcept {return bucket;}
    friend bool operator ==(const memory_bucket_ref & l, const memory_bucket_ref & r) noexcept {return l.bucket == r.bucket;}
    friend bool operator !=(const memory_bucket_ref & l, const memory_bucket_ref & r) noexcept {return l.bucket != r.bucket;}
private:
    memory_bucket * bucket;
};
 
template <class T>
class allocator {
private:
    typedef std::allocator<T> a_t;
    a_t a;
public:
    memory_bucket_ref bucket;
 
    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;
 
    typedef std::true_type propagate_on_container_copy_assignment;
    typedef std::true_type propagate_on_container_move_assignment;
    typedef std::true_type propagate_on_container_swap;
    
    allocator() = default;
    allocator(memory_bucket_ref bucket) noexcept : bucket(bucket) {}
    allocator(const allocator & o) noexcept : bucket(o.bucket) {}
    template <typename T2>
    allocator(const allocator<T2> & o) noexcept : bucket(o.bucket) {}
    allocator(allocator && o) noexcept : bucket(std::move(o.bucket)) {}
    template <typename T2>
    allocator(allocator<T2> && o) noexcept : bucket(std::move(o.bucket)) {}
 
    allocator & operator=(const allocator & o) noexcept {bucket = o.bucket; return *this;}
    template <typename T2>
    allocator & operator=(const allocator<T2> & o) noexcept {bucket = o.bucket; return *this;}
    allocator & operator=(allocator && o) noexcept {bucket = std::move(o.bucket); return *this;}
    template <typename T2>
    allocator & operator=(allocator<T2> && o) noexcept {bucket = std::move(o.bucket); return *this;}
 
    template <class U> struct rebind {typedef allocator<U> other;};
 
    T * allocate(size_t size, const void * hint=0) {
        get_memory_manager().register_allocation(size * sizeof(T), typeid(T));
        if (bucket) bucket->count += size * sizeof(T);
        T * res = a.allocate(size, hint);
        return res;
    }
 
    void deallocate(T * p, size_t n) {
        if (p == 0) return;
        if (bucket) bucket->count -= n * sizeof(T);
        get_memory_manager().register_deallocation(n * sizeof(T), typeid(T));
        return a.deallocate(p, n);
    }
    size_t max_size() const noexcept {return a.max_size();}
 
    template <typename U, typename ...TT>
    void construct(U * p, TT &&...x) {a.construct(p, std::forward<TT>(x)...);}
 
    // void construct(T * p) {
    //  new(p) T();
    // }
    // void construct(T * p, const T& val) {a.construct(p, val);}
    template <typename U>
    void destroy(U * p) {
        p->~U();
    }
    pointer address(reference x) const noexcept {return &x;}
    const_pointer address(const_reference x) const noexcept {return &x;}
 
 
    friend bool operator==(const allocator & l, const allocator & r) noexcept {return l.bucket == r.bucket;}
    friend bool operator!=(const allocator & l, const allocator & r) noexcept {return l.bucket != r.bucket;}
 
    template <typename U>
    friend class allocator;
 
        
};
 
TPIE_EXPORT size_t consecutive_memory_available(size_t granularity=5*1024*1024);
 
} //namespace tpie
 
#endif //__TPIE_MEMORY_H__