AMReX_CArena.H

Go to the documentation of this file.

#ifndef BL_CARENA_H
#define BL_CARENA_H
#include <AMReX_Config.H>
 
#include <AMReX_Arena.H>
 
#include <atomic>
#include <cstddef>
#include <functional>
#include <iosfwd>
#include <map>
#include <mutex>
#include <set>
#include <string>
#include <unordered_set>
#include <vector>
 
namespace amrex {
 
class CArena
    :
    public Arena
{
public:
    CArena (std::size_t hunk_size = 0, ArenaInfo info = ArenaInfo());
 
    CArena (const CArena& rhs) = delete;
    CArena (CArena&& rhs) = delete;
    CArena& operator= (const CArena& rhs) = delete;
    CArena& operator= (CArena&& rhs) = delete;
 
    ~CArena () override;
 
    [[nodiscard]] void* alloc (std::size_t nbytes) final;
 
    [[nodiscard]] std::pair<void*,std::size_t>
    alloc_in_place (void* pt, std::size_t szmin, std::size_t szmax) final;
 
    [[nodiscard]] void*
    shrink_in_place (void* pt, std::size_t new_size) final;
 
    void free (void* vp) final;
 
    std::size_t freeUnused () final;
 
    [[nodiscard]] std::size_t freeableMemory () const;
 
    [[nodiscard]] std::size_t largestFreeBlock () const final;
 
    [[nodiscard]] bool hasFreeDeviceMemory (std::size_t sz) final;
 
    std::size_t heap_space_used () const noexcept;
 
    std::size_t heap_space_actually_used () const noexcept;
 
    std::size_t sizeOf (void* p) const noexcept;
 
    void PrintUsage (std::string const& name, bool print_max_usage) const;
 
    void PrintUsage (std::ostream& os, std::string const& name, std::string const& space) const;
 
    void ResetMaxUsageCounter () final {
        m_max_actually_used = 0;
    }
 
    constexpr static std::size_t DefaultHunkSize = 1024*1024*8;
 
protected:
 
    void* alloc_protected (std::size_t nbytes);
 
    std::size_t freeUnused_protected () final;
 
    class Node
    {
    public:
        Node (void* a_block, void* a_owner, std::size_t a_size, MemStat* a_stat=nullptr) noexcept
            :
            m_block(a_block), m_owner(a_owner), m_size(a_size), m_stat(a_stat) {}
 
        bool operator< (const Node& rhs) const noexcept
        {
            return std::less<>{}(m_block, rhs.m_block);
        }
 
        bool operator== (const Node& rhs) const noexcept
        {
            return m_block == rhs.m_block;
        }
 
        [[nodiscard]] void* block () const noexcept { return m_block; }
 
        void block (void* blk) noexcept { m_block = blk; }
 
        [[nodiscard]] std::size_t size () const noexcept { return m_size; }
 
        void size (std::size_t sz) noexcept { m_size = sz; }
 
        [[nodiscard]] void* owner () const noexcept { return m_owner; }
 
        [[nodiscard]] bool coalescable (const Node& rhs) const noexcept {
            return m_owner == rhs.m_owner;
        }
 
        [[nodiscard]] MemStat* mem_stat () const { return m_stat; }
 
        void mem_stat (MemStat* a_stat) noexcept { m_stat = a_stat; }
 
        struct hash {
            std::size_t operator() (const Node& n) const noexcept {
                return std::hash<void*>{}(n.m_block);
            }
        };
 
    private:
        void* m_block;
        void* m_owner;
        std::size_t m_size;
        MemStat* m_stat;
    };
 
    std::vector<std::pair<void*,std::size_t> > m_alloc;
 
    using NL = std::set<Node>;
 
    NL m_freelist;
 
//    NL m_busylist;
    std::unordered_set<Node, Node::hash> m_busylist;
    std::size_t m_hunk;
    std::atomic<std::size_t> m_used{0};
    std::size_t m_max_used{0};
    std::atomic<std::size_t> m_actually_used{0};
    std::size_t m_max_actually_used{0};
 
    mutable std::mutex carena_mutex;
 
    friend std::ostream& operator<< (std::ostream& os, const CArena& arena);
};
 
}
 
#endif /*BL_CARENA_H*/