Memory.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Common/CompilerMacrosExport.h"
#include "../Common/CompilerMacrosType.h"
#ifndef SC_EXPORT_LIBRARY_MEMORY
#define SC_EXPORT_LIBRARY_MEMORY 0
#endif
#define SC_MEMORY_EXPORT SC_COMPILER_LIBRARY_EXPORT(SC_EXPORT_LIBRARY_MEMORY)
 
#include "../Common/Assert.h"
#include "../Common/CompilerMove.h"
#include "../Common/PlacementNew.h"
#include "../Common/PrimitiveDefinitions.h"
#if SC_COMPILER_FILC
#include <stdfil.h>
#endif
namespace SC
{
SC_DECLARE_ASSERT_PROVIDER(MemoryAssert, SC_MEMORY_EXPORT);
 
#define SC_MEMORY_ASSERT_RELEASE(e)        SC_ASSERT_PROVIDER_RELEASE(SC::MemoryAssert, e)
#define SC_MEMORY_ASSERT_DEBUG(e)          SC_ASSERT_PROVIDER_DEBUG(SC::MemoryAssert, e)
#define SC_MEMORY_TRUST_RESULT(expression) SC_MEMORY_ASSERT_RELEASE(expression)
 
struct SC_MEMORY_EXPORT Memory;
struct SC_MEMORY_EXPORT MemoryAllocator;
struct SC_MEMORY_EXPORT FixedAllocator;
} // namespace SC
 
struct SC::Memory
{
    static void* allocate(size_t numBytes, size_t alignment);
 
    static void* reallocate(void* memory, size_t numBytes);
 
    static void release(void* memory);
 
    static void move(void* dst, const void* src, size_t numBytes);
 
    static void set(void* dst, int c, size_t numBytes);
 
    static void copy(void* dst, const void* src, size_t numBytes);
};
 
struct SC::MemoryAllocator
{
    struct Statistics
    {
        size_t numAllocate   = 0; 
        size_t numReallocate = 0; 
        size_t numRelease    = 0; 
    };
    Statistics statistics; 
 
    template <typename T, typename... U>
    T* create(U&&... u)
    {
        void* rawMemory = allocate(nullptr, sizeof(T), alignof(T));
        if (rawMemory)
        {
#if SC_COMPILER_FILC
            const size_t pointerAlignment = sizeof(void*);
            const size_t address          = reinterpret_cast<size_t>(rawMemory);
            if ((address & (pointerAlignment - 1)) == 0 and (sizeof(T) & (pointerAlignment - 1)) == 0)
            {
                zsetcap(rawMemory, rawMemory, sizeof(T));
            }
#endif
            T* t = reinterpret_cast<T*>(rawMemory);
            placementNew(*t, forward<U>(u)...);
            return t;
        }
        return nullptr;
    }
 
    void* allocate(const void* owner, size_t numBytes, size_t alignment)
    {
        statistics.numAllocate += 1;
        return allocateImpl(owner, numBytes, alignment);
    }
 
    void* reallocate(void* memory, size_t numBytes)
    {
        statistics.numReallocate += 1;
        return reallocateImpl(memory, numBytes);
    }
 
    void release(void* memory)
    {
        if (memory != nullptr)
        {
            statistics.numRelease += 1;
        }
        return releaseImpl(memory);
    }
 
    virtual void* allocateImpl(const void* owner, size_t numBytes, size_t alignment) = 0;
 
    virtual void* reallocateImpl(void* memory, size_t numBytes) = 0;
 
    virtual void releaseImpl(void* memory) = 0;
 
    virtual ~MemoryAllocator() {}
};
 
struct SC::FixedAllocator : public MemoryAllocator
{
    FixedAllocator(void* memory, size_t capacityBytes);
 
    const void* data() const { return memory; }
 
    size_t size() const { return position; }
    size_t capacity() const { return capacityBytes; }
 
  protected:
    // Not using a span here to avoid depending on Span<T> in this header
    void*  memory        = nullptr;
    size_t capacityBytes = 0;
 
    void*  lastAllocation    = nullptr;
    size_t lastAllocatedSize = 0;
    size_t position          = 0;
 
    virtual void* allocateImpl(const void* owner, size_t numBytes, size_t alignment) override;
    virtual void* reallocateImpl(void* memory, size_t numBytes) override;
    virtual void  releaseImpl(void* memory) override;
};