trace_memory.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_MEMORY_TRACE_MEMORY_HPP__
#define NEFORCE_CORE_MEMORY_TRACE_MEMORY_HPP__

 
#include "NeForce/core/container/unordered_map.hpp"
#include "NeForce/core/system/console.hpp"
#include "NeForce/core/system/stacktrace.hpp"
NEFORCE_BEGIN_NAMESPACE__


template <typename T>
class trace_allocator {
    static_assert(is_allocable_v<T>, "allocator can`t alloc void, reference, function or const type.");
 
public:
    using value_type = T;
    using pointer = T*;
    using const_pointer = const T*;
    using reference = T&;
    using const_reference = const T&;
    using size_type = size_t;
    using difference_type = ptrdiff_t;

    template <typename U>
    struct rebind {
        using other = trace_allocator<U>;
    };
 
private:
    unordered_map<T*, stacktrace> traces_; 
 
public:
    trace_allocator() = default;

    trace_allocator(const trace_allocator& other) :
    traces_(other.traces_) {}

    trace_allocator& operator=(const trace_allocator& other) {
        if (_NEFORCE addressof(other) == this) {
            return *this;
        }
        traces_ = other.traces_;
        return *this;
    }

    ~trace_allocator() {
        if (!traces_.empty()) {
            _NEFORCE printcln(color::red(), "Memory leaks detected! \n");
            print_stacktrace();
        }
    }

    void print_stacktrace() const {
        for (auto& entry: traces_) {
            if (entry.first == 0) {
                continue;
            }
            _NEFORCE printcln(color::red(), "Leaked pointer: ", static_cast<void*>(entry.first));
            _NEFORCE printcln(color::red(), "Allocation stack trace:\n", entry.second);
        }
    }

    NEFORCE_NODISCARD NEFORCE_ALLOC_OPTIMIZE pointer allocate(const size_type n) {
        pointer ptr = allocator<T>().allocate(n);
        stacktrace st{};
        traces_[ptr] = _NEFORCE move(st);
        return ptr;
    }

    NEFORCE_NODISCARD NEFORCE_ALLOC_OPTIMIZE pointer allocate() { return this->allocate(1); }

    void deallocate(pointer p, const size_type n) noexcept {
        auto it = traces_.find(p);
        if (it != traces_.end()) {
            traces_.erase(it);
        }
        allocator<T>().deallocate(p, n);
    }

    void deallocate(pointer p) noexcept { this->deallocate(p, 1); }
};

template <typename T, typename U>
bool operator==(const trace_allocator<T>& lhs, const trace_allocator<U>& rhs) noexcept {
    return true;
}

template <typename T, typename U>
bool operator!=(const trace_allocator<T>& lhs, const trace_allocator<U>& rhs) noexcept {
    return false;
}
 // Stacktrace
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_MEMORY_TRACE_MEMORY_HPP__