memory.hpp

Go to the documentation of this file.

#pragma once
 
#include <mutable/mutable-config.hpp>
#include <mutable/util/fn.hpp>
#include <cstdint>
#include <iostream>
#include <memory>
 
 
namespace m {
 
namespace memory {
 
struct Memory;
 
struct M_EXPORT Allocator
{
    friend struct Memory;
 
    private:
    int fd_; 
 
    public:
    Allocator();
    virtual ~Allocator();
 
    int fd() const { return fd_; }
 
    virtual Memory allocate(std::size_t size) = 0;
 
    protected:
    virtual void deallocate(Memory &&mem) = 0;
 
    Memory create_memory(void *addr, std::size_t size, std::size_t offset);
};
 
struct M_EXPORT AddressSpace
{
    friend void swap(AddressSpace &first, AddressSpace &second) {
        using std::swap;
        swap(first.addr_, second.addr_);
        swap(first.size_, second.size_);
    }
 
    private:
    void *addr_; 
    std::size_t size_; 
 
    private:
    AddressSpace() : addr_(nullptr), size_(0) { }
    public:
    AddressSpace(std::size_t size);
    ~AddressSpace();
    AddressSpace(const AddressSpace&) = delete;
    AddressSpace(AddressSpace &&other) : AddressSpace() { swap(*this, other); }
 
    void * addr() const { return addr_; }
    std::size_t size() const { return size_; }
 
    template<typename T>
    T as() const { return reinterpret_cast<T>(addr()); }
};
 
struct M_EXPORT Memory
{
    friend struct Allocator;
 
    private:
    Allocator *allocator_ = nullptr; 
    void *addr_ = nullptr; 
    std::size_t size_ = 0; 
    std::size_t offset_ = 0; 
 
    Memory(Allocator &allocator, void *addr, std::size_t size, std::size_t offset);
 
    public:
    friend void swap(Memory &first, Memory &second) {
        using std::swap;
        swap(first.allocator_, second.allocator_);
        swap(first.addr_,      second.addr_);
        swap(first.size_,      second.size_);
        swap(first.offset_,    second.offset_);
    }
 
    Memory() { }
    Memory(void *addr, std::size_t size) : addr_(addr), size_(size) { }
    ~Memory() { if (allocator_) allocator().deallocate(std::move(*this)); }
    Memory(const Memory&) = delete;
    Memory(Memory &&other) { swap(*this, other); }
 
    Memory & operator=(Memory &&other) { swap(*this, other); return *this; }
 
    Allocator & allocator() const { M_insist(allocator_); return *allocator_; }
    void * addr() const { return addr_; }
    std::size_t size() const { return size_; }
    std::size_t offset() const { return offset_; }
 
    template<typename T>
    T as() { return reinterpret_cast<T>(addr()); }
    template<typename T>
    const T as() const { return reinterpret_cast<T>(addr()); }
 
    void map(std::size_t size, std::size_t offset_src, const AddressSpace &vm, std::size_t offset_dst) const;
 
    void dump(std::ostream &out) const;
    void dump() const;
};
 
struct M_EXPORT LinearAllocator : Allocator
{
    private:
    std::size_t offset_ = 0; 
 
    std::vector<std::size_t> allocations_;
 
    public:
    LinearAllocator() { }
    ~LinearAllocator() { }
 
    Memory allocate(std::size_t size) override;
 
    std::size_t offset() const { return offset_; }
 
    private:
    void deallocate(Memory &&mem) override;
};
 
}
 
}