Allocators.hpp

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

#include "hmbdc/Compile.hpp"
#include "hmbdc/Exception.hpp"

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

#include <stdexcept>
#include <string>
#include <iostream>
#include <utility> 
#include <mutex>

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

#include <sys/mman.h>
#include <sys/stat.h>        /* For mode constants */

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_);
        cur_ = ((char*)cur) + sizeof(T);
        T *res;
        if (runCtor_) {
            res = ::new (cur)T(std::forward<Args>(args)...);
            msync(cur, sizeof(T), MS_SYNC);
        } 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 offset, size_t len
        , bool& tryOwn);
    ~ShmBasePtrAllocator();

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

    auto& fileLock() {
        return lock_;
    }

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

/**
 * @brief similar to ShmBasePtrAllocator but using dev memory
 * @details typically PCIe BAR
 */
struct DevMemBasePtrAllocator
: BasePtrAllocator {
    DevMemBasePtrAllocator(char const* devName, size_t offset, size_t len
        , bool own);
    ~DevMemBasePtrAllocator();

    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:
    size_t len_;
    void* addr_;
    bool own_;
    boost::interprocess::file_lock lock_;
    int fd_ = -1;
};

/**
 * @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() {
        static DefaultAllocator ins;
        return ins;
    }
};

inline
ShmBasePtrAllocator::
ShmBasePtrAllocator(char const* name, size_t offset, size_t len, bool& tryOwn)
: BasePtrAllocator()
, len_(len)
, addr_(NULL)
, own_(false) {
    using namespace std;
    if (name[0] != '/') {
        name_ = string("/") + name;
    } else {
        name_ = name;
    }

    string devName = string("/dev/shm") + name_;
    int oflags = O_RDWR;
    if (tryOwn) {
        oflags |= O_CREAT | O_EXCL;
    }

    int fd = shm_open(name, oflags, 0660);
    if (fd < 0 && tryOwn) {
        oflags = O_RDWR;
        fd = shm_open(name, oflags, 0660);
        tryOwn = false;
    }
    if (fd >= 0) {
        if (tryOwn) {
            own_ = true;
            if (ftruncate(fd, len)) {
                HMBDC_THROW(std::runtime_error, 
                    "error when sizing ipc transport errno=" << errno);

            }
        }
        struct stat st;
        stat(devName.c_str(), &st);
        if (len != (size_t)st.st_size) {
            HMBDC_THROW(std::runtime_error, "file not expected size - unmatch?");
        }
        void* base = mmap(NULL, len, PROT_READ|PROT_WRITE, MAP_SHARED
            , fd, offset);
        if (base != MAP_FAILED) {
            set(base, len, own_);
            addr_ = base;
            lock_ = boost::interprocess::file_lock(devName.c_str());
            close(fd);
            return;
        }
    }

    HMBDC_THROW(std::runtime_error
        , "error when creating file errno=" << errno);
}

inline
ShmBasePtrAllocator::
~ShmBasePtrAllocator() {
    munmap(addr_, len_);
    if (own_) {
        shm_unlink(name_.c_str());
    }
}

inline
DevMemBasePtrAllocator::
DevMemBasePtrAllocator(char const* devName, size_t offset, size_t len, bool own)
: BasePtrAllocator()
, len_(len)
, addr_(NULL)
, own_(false) {
    if (offset % getpagesize() || len_ % getpagesize()) {
        HMBDC_THROW(std::out_of_range, "address not at page boundary devName="
            << devName << "@" << offset << ':' << len_);
    }
    int oflags = O_RDWR | O_SYNC;
    fd_ = open(devName, oflags);
    addr_ = (uint32_t*)mmap(NULL, len_, PROT_READ | PROT_WRITE, MAP_SHARED
        , fd_, offset);
    if (addr_ == MAP_FAILED) {
        HMBDC_THROW(std::runtime_error
            , "cannot map RegRange " << devName << '@' << offset << ':' << len_);
    }
    own_ = own;
    set(addr_, len, own_);
    lock_ = boost::interprocess::file_lock(devName);
}

inline
DevMemBasePtrAllocator::
~DevMemBasePtrAllocator() {
    munmap(addr_, len_);
    close(fd_);
}

}}