Allocators.h

Go to the documentation of this file.

#pragma once
 
 
#include "common/Assert.h"
#include <memory>
#include <mm_malloc.h>
 
NAMESPACE_SPH_BEGIN
 
struct MemoryBlock {
    void* ptr;
    std::size_t size;
 
    MemoryBlock() = default;
    MemoryBlock(void* ptr, const std::size_t size)
        : ptr(ptr)
        , size(size) {}
 
    INLINE static MemoryBlock EMPTY() {
        return { nullptr, 0 };
    }
};
 
class Mallocator {
public:
    INLINE MemoryBlock allocate(const std::size_t size, const std::size_t align) noexcept {
        MemoryBlock block;
        block.ptr = _mm_malloc(size, align);
        if (block.ptr) {
            block.size = size;
        } else {
            block.size = 0;
        }
        return block;
    }
 
    INLINE void deallocate(MemoryBlock& block) noexcept {
        _mm_free(block.ptr);
        block.ptr = nullptr;
    }
};
 
template <std::size_t TSize, Size TAlign = 16>
class StackAllocator : public Immovable, Local {
private:
    alignas(TAlign) uint8_t data[TSize];
 
    uint8_t* pos = data;
 
public:
    INLINE MemoryBlock allocate(const std::size_t size, const std::size_t UNUSED(align)) noexcept {
        SPH_ASSERT(size > 0);
 
        const std::size_t actSize = roundToAlignment(size);
        if (pos - data + actSize > TSize) {
            return MemoryBlock::EMPTY();
        }
 
        void* ptr = pos;
        pos += size;
        return { ptr, size };
    }
 
    INLINE void deallocate(MemoryBlock& block) noexcept {
        if (!block.ptr) {
            return;
        }
        if ((uint8_t*)block.ptr + block.size == pos) {
            pos = static_cast<uint8_t*>(block.ptr);
        }
        block = MemoryBlock::EMPTY();
    }
 
    INLINE bool owns(const MemoryBlock& block) const noexcept {
        return block.ptr >= data && block.ptr < data + TSize;
    }
 
private:
    INLINE constexpr static std::size_t roundToAlignment(const std::size_t value) noexcept {
        const std::size_t remainder = value % TAlign;
        return value + ((remainder == 0) ? 0 : (TAlign - remainder));
    }
};
 
template <typename TPrimary, typename TFallback>
class FallbackAllocator : private TPrimary, private TFallback {
public:
    INLINE MemoryBlock allocate(const std::size_t size, const std::size_t align) noexcept {
        MemoryBlock block = TPrimary::allocate(size, align);
        if (block.ptr) {
            return block;
        } else {
            return TFallback::allocate(size, align);
        }
    }
 
    INLINE void deallocate(MemoryBlock& block) noexcept {
        if (TPrimary::owns(block)) {
            TPrimary::deallocate(block);
        } else {
            TFallback::deallocate(block);
        }
    }
 
    INLINE const TPrimary& primary() const {
        return *this;
    }
 
    INLINE const TFallback& fallback() const {
        return *this;
    }
};
 
template <std::size_t TLimit, typename TSmall, typename TLarge>
class Segregator : private TSmall, private TLarge {
public:
    INLINE MemoryBlock allocate(const std::size_t size, const std::size_t align) noexcept {
        if (size <= TLimit) {
            return TSmall::allocate(size, align);
        } else {
            return TLarge::allocate(size, align);
        }
    }
 
    INLINE void deallocate(MemoryBlock& block) noexcept {
        if (block.size <= TLimit) {
            TSmall::deallocate(block);
        } else {
            TLarge::deallocate(block);
        }
    }
 
    INLINE bool owns(const MemoryBlock& block) const noexcept {
        if (block.size <= TLimit) {
            return TSmall::owns(block);
        } else {
            return TLarge::owns(block);
        }
    }
 
    INLINE const TSmall& small() const {
        return *this;
    }
 
    INLINE const TLarge& large() const {
        return *this;
    }
};
 
template <typename TAllocator>
class TrackingAllocator : private TAllocator {
private:
    std::size_t memory = 0;
 
public:
    INLINE MemoryBlock allocate(const std::size_t size, const std::size_t align) noexcept {
        MemoryBlock block = TAllocator::allocate(size, align);
        if (block.ptr) {
            memory += size;
        }
        return block;
    }
 
    INLINE void deallocate(MemoryBlock& block) noexcept {
        if (block.ptr) {
            memory -= block.size;
        }
        TAllocator::deallocate(block);
    }
 
    INLINE bool owns(const MemoryBlock& block) const noexcept {
        return TAllocator::owns(block);
    }
 
    INLINE std::size_t allocated() const {
        return memory;
    }
 
    INLINE const TAllocator& underlying() const {
        return *this;
    }
};
 
template <typename TResource>
class MemoryResourceAllocator {
private:
    TResource* resource = nullptr;
 
public:
    INLINE void bind(TResource& other) {
        resource = std::addressof(other);
    }
 
    INLINE MemoryBlock allocate(const std::size_t size, const Size align) noexcept {
        if (resource) {
            return resource->allocate(size, align);
        } else {
            return MemoryBlock::EMPTY();
        }
    }
 
    INLINE void deallocate(MemoryBlock& UNUSED(block)) noexcept {}
 
    INLINE bool owns(const MemoryBlock& block) const noexcept {
        if (resource) {
            return resource->owns(block);
        } else {
            return false;
        }
    }
};
 
template <typename TAllocator>
class MonotonicMemoryResource : public TAllocator {
    MemoryBlock resource;
    std::size_t position = 0;
 
public:
    MonotonicMemoryResource(const std::size_t size, const std::size_t align) {
        resource = TAllocator::allocate(size, align);
    }
 
    ~MonotonicMemoryResource() {
        TAllocator::deallocate(resource);
    }
 
    INLINE MemoryBlock allocate(const std::size_t size, const std::size_t UNUSED(align)) noexcept {
        if (position + size <= resource.size) {
            MemoryBlock block;
            block.ptr = (uint8_t*)resource.ptr + position;
            block.size = size;
            position += size;
            return block;
        } else {
            return MemoryBlock::EMPTY();
        }
    }
 
    INLINE bool owns(const MemoryBlock& block) const noexcept {
        return block.ptr >= resource.ptr && block.ptr < (uint8_t*)resource.ptr + resource.size;
    }
};
 
NAMESPACE_SPH_END