VirtualMemory.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Common/PrimitiveDefinitions.h"
#include "../Memory/Memory.h"
namespace SC
{
struct SC_MEMORY_EXPORT VirtualMemory;
struct SC_MEMORY_EXPORT VirtualAllocator;
} // namespace SC
 
struct SC::VirtualMemory
{
    VirtualMemory()                                = default;
    VirtualMemory(const VirtualMemory&)            = delete;
    VirtualMemory(VirtualMemory&&)                 = delete;
    VirtualMemory& operator=(const VirtualMemory&) = delete;
    VirtualMemory& operator=(VirtualMemory&&)      = delete;
    ~VirtualMemory() { release(); }
 
    [[nodiscard]] static size_t roundUpToPageSize(size_t size);
 
    [[nodiscard]] static size_t getPageSize();
 
    [[nodiscard]] bool reserve(size_t maxCapacityInBytes);
 
    void release();
 
    [[nodiscard]] bool commit(size_t sizeInBytes);
 
    [[nodiscard]] bool decommit(size_t sizeInBytes);
 
    [[nodiscard]] size_t size() const { return committedBytes; }
 
    [[nodiscard]] size_t capacity() const { return reservedBytes; }
 
    [[nodiscard]] void* data() { return memory; }
 
    [[nodiscard]] const void* data() const { return memory; }
 
  private:
    size_t reservedBytes  = 0; 
    size_t committedBytes = 0; 
 
    void* memory = nullptr; 
};
 
struct SC::VirtualAllocator : public FixedAllocator
{
    VirtualAllocator(VirtualMemory& virtualMemory);
 
  protected:
    VirtualMemory& virtualMemory;
 
    virtual void* allocateImpl(const void* owner, size_t numBytes, size_t alignment) override;
    virtual void* reallocateImpl(void* memory, size_t numBytes) override;
 
    void syncFixedAllocator();
};