instrumenting_memory_resource.hpp

/*
 * VecMem project, part of the ACTS project (R&D line)
 *
 * (c) 2021-2023 CERN for the benefit of the ACTS project
 *
 * Mozilla Public License Version 2.0
 */
 
#pragma once
 
// Local include(s).
#include "vecmem/memory/details/memory_resource_base.hpp"
#include "vecmem/memory/memory_resource.hpp"
#include "vecmem/vecmem_core_export.hpp"
 
// System include(s).
#include <cstddef>
#include <functional>
#include <memory>
#include <vector>
 
namespace vecmem {
 
// Forward declaration(s).
namespace details {
class instrumenting_memory_resource_impl;
}
 
class instrumenting_memory_resource final
    : public details::memory_resource_base {
 
public:
    VECMEM_CORE_EXPORT
    instrumenting_memory_resource(memory_resource& upstream);
    VECMEM_CORE_EXPORT
    instrumenting_memory_resource(instrumenting_memory_resource&& parent);
    instrumenting_memory_resource(const instrumenting_memory_resource&) =
        delete;
 
    VECMEM_CORE_EXPORT
    ~instrumenting_memory_resource();
 
    VECMEM_CORE_EXPORT
    instrumenting_memory_resource& operator=(
        instrumenting_memory_resource&& rhs);
    instrumenting_memory_resource& operator=(
        const instrumenting_memory_resource&) = delete;
 
    struct VECMEM_CORE_EXPORT memory_event {
 
        enum class type { ALLOCATION, DEALLOCATION };
 
        memory_event(type t, std::size_t s, std::size_t a, void* p,
                     std::size_t ns);
 
        type m_type;
 
        std::size_t m_size;
        std::size_t m_align;
 
        void* m_ptr;
 
        std::size_t m_time;
 
    };  // struct memory_event
 
    VECMEM_CORE_EXPORT
    const std::vector<memory_event>& get_events(void) const;
 
    VECMEM_CORE_EXPORT
    void add_pre_allocate_hook(std::function<void(std::size_t, std::size_t)> f);
 
    VECMEM_CORE_EXPORT
    void add_post_allocate_hook(
        std::function<void(std::size_t, std::size_t, void*)> f);
 
    VECMEM_CORE_EXPORT
    void add_pre_deallocate_hook(
        std::function<void(void*, std::size_t, std::size_t)> f);
 
private:
 
    VECMEM_CORE_EXPORT
    virtual void* do_allocate(std::size_t, std::size_t) override final;
    VECMEM_CORE_EXPORT
    virtual void do_deallocate(void* p, std::size_t,
                               std::size_t) override final;
 
 
    std::unique_ptr<details::instrumenting_memory_resource_impl> m_impl;
 
};  // class instrumenting_memory_resource
 
}  // namespace vecmem