Allocators.hpp

#include "hmbdc/Copyright.hpp"
#pragma once 

#include "hmbdc/Compile.hpp"

#include <boost/align/align.hpp>
#include <boost/interprocess/sync/file_lock.hpp>

#include <iostream>
#include <utility> 
#include <mutex>

#include <fcntl.h>           /* For O_* constants */
#include <malloc.h>


namespace hmbdc { namespace os {

/**
 * @brief helping allocating object and its aggregated objects in a continouse memory
 * @details the class working with this cannot have significant dtor (dtor that does more than
 * just freeing memory)
 */
struct BasePtrAllocator {
    enum {
        fromHeap = false,
    };
    BasePtrAllocator()
    : cur_(NULL)
    , size_(0)
    , runCtor_(false)
    {}

    BasePtrAllocator(void* base, size_t size, bool runCtor = true)
    : cur_((char*)base)
    , size_(size)
    , runCtor_(runCtor)
    {}

    BasePtrAllocator(BasePtrAllocator const&) = delete;
    BasePtrAllocator& operator = (BasePtrAllocator const&) = delete;
    virtual ~BasePtrAllocator(){}

    template <typename T, typename ...Args>
    T* allocate(size_t alignment, Args&&... args) {
        auto cur = boost::alignment::align(alignment, sizeof(T), cur_, size_);
        T *res;
        if (runCtor_) {
            cur_ = ((char*)cur) + sizeof(T);
            res = ::new (cur)T(std::forward<Args>(args)...);
        } else {
            res = static_cast<T*>(cur);
        }
        return res;
    }

    void * memalign(size_t alignment, size_t size) {
        auto res = boost::alignment::align(alignment, size, cur_, size_);
        cur_ = ((char*)cur_) + size_;
        return res;
    }

    template <typename T> void unallocate(T* ptr){
        if (runCtor_) {
            ptr->~T();
        }
    }
    void free(void*){}

protected:
    void set(void* base, size_t size, bool runCtor = true) {
        cur_= base;
        size_ = size;
        runCtor_ = runCtor;
    }

private:
    void* cur_;
    size_t size_;
    bool runCtor_;
};

/**
 * @brief helping allocating object and its aggregated objects in a continouse shared memory
 * @details the class working with this cannot have significant dtor (dtor that does more than
 * just freeing memory)
 */
struct ShmBasePtrAllocator
: BasePtrAllocator {
    ShmBasePtrAllocator(char const* name, size_t len
        , int oflags = O_RDWR | O_CREAT | O_EXCL);
    ~ShmBasePtrAllocator();

    template <typename T, typename ...Args>
    T* allocate(size_t alignment, Args&&... args) {
        std::lock_guard<decltype(lock_)> g(lock_);
        return BasePtrAllocator::allocate<T>(alignment
            , std::forward<Args>(args)...);
    }

    auto& fileLock() {
        return lock_;
    }

private:
    std::string name_;
    size_t len_;
    void* addr_;
    bool own_;
    boost::interprocess::file_lock lock_;
};

/**
 * @brief the default vanilla allocate
 */
struct DefaultAllocator {
    enum {
        fromHeap = true,
    };
    template <typename ...NoUses>
    DefaultAllocator(NoUses&& ...){}

    template <typename T, typename ...Args>
    T* allocate(size_t alignment, Args&&... args) {
        // return new T(std::forward<Args>(args)...);
        auto space = memalign(alignment, sizeof(T));
        return new (space) T(std::forward<Args>(args)...);
    }

    void* memalign(size_t alignment, size_t size) {
        auto res = ::memalign(alignment, size);
        if (!res) {
            throw std::bad_alloc();
        }
        return res;
    }

    template <typename T> 
    void 
    unallocate(T* ptr){
        ptr->~T();
        this->free(ptr);
        // delete ptr;
    }
    void free(void* ptr){
        ::free(ptr);
    }
    static DefaultAllocator instance;
};

}}