Allocator.h

/* Copyright (c) 2015-2016, Human Brain Project
 *                          Stefan.Eilemann@epfl.ch
 *                          grigori.chevtchenko@epfl.ch
 */

#ifndef ZEROBUF_ALLOCATOR_H
#define ZEROBUF_ALLOCATOR_H

#include <zerobuf/types.h>

namespace zerobuf
{
class Allocator
{
public:
    Allocator() {}
    virtual ~Allocator() {}
    virtual uint8_t* getData() = 0;
    virtual const uint8_t* getData() const = 0;
    virtual size_t getSize() const = 0;
    virtual void copyBuffer(const void* data, size_t size) = 0;
    virtual void compact(float /*threshold*/)
    {
        throw std::runtime_error("Compaction not implemented");
    }
    virtual bool isMovable() const { return false; } // allocation is moveable
    virtual bool isMutable() const { return true; }  // data is mutable
    virtual uint8_t* updateAllocation(size_t /*index*/, bool /*copy*/,
                                      size_t /*newSize*/)
    {
        throw std::runtime_error("Dynamic allocation not implemented");
    }

    template <class T>
    T* getItemPtr(const size_t offset)
    {
        return reinterpret_cast<T*>(getData() + offset);
    }

    template <class T>
    const T* getItemPtr(const size_t offset) const
    {
        return reinterpret_cast<const T*>(getData() + offset);
    }

    template <class T>
    T& getItem(const size_t offset)
    {
        return *getItemPtr<T>(offset);
    }

    template <class T>
    T getItem(const size_t offset) const
    {
        return *getItemPtr<T>(offset);
    }

    template <class T>
    T* getDynamic(const size_t index)
    {
        return reinterpret_cast<T*>(getData() + _getOffset(index));
    }

    template <class T>
    const T* getDynamic(const size_t index) const
    {
        return reinterpret_cast<const T*>(getData() + _getOffset(index));
    }

    uint64_t getDynamicOffset(const size_t index) const
    {
        return _getOffset(index);
    }

    size_t getDynamicSize(const size_t index) const { return _getSize(index); }
    void check(const size_t numDynamics) const
    {
        for (size_t i = 0; i < numDynamics; ++i)
            _checkIndex(i);
    }

protected:
    uint64_t& _getOffset(const size_t i)
    {
        _checkIndex(i);
        return getItem<uint64_t>(4 + i * 16);
    }
    uint64_t _getOffset(const size_t i) const
    {
        _checkIndex(i);
        return getItem<uint64_t>(4 + i * 16);
    }
    uint64_t& _getSize(const size_t i)
    {
        _checkIndex(i);
        return getItem<uint64_t>(4 + 8 + i * 16);
    }
    uint64_t _getSize(const size_t i) const
    {
        _checkIndex(i);
        return getItem<uint64_t>(4 + 8 + i * 16);
    }

    void _checkIndex(const size_t i) const
    {
        const uint64_t offset = getItem<uint64_t>(4 + i * 16);
        const uint64_t size = getItem<uint64_t>(4 + 8 + i * 16);
        if (offset + size > getSize())
            throw std::runtime_error(
                "Internal allocator error: dynamic #" + std::to_string(i) +
                " at " + std::to_string(offset) + " size " +
                std::to_string(size) + " exceeds allocation size " +
                std::to_string(getSize()));
        if (offset != 0 && offset < 4 + (i + 1) * 16)
            throw std::runtime_error(
                "Internal allocator error: dynamic #" + std::to_string(i) +
                " at " + std::to_string(offset) + " is within static section");
    }
};
}

#endif