Memory.h

Go to the documentation of this file.

 
#ifndef LLUVIA_CORE_MEMORY_MEMORY_H_
#define LLUVIA_CORE_MEMORY_MEMORY_H_
 
#include <array>
#include <cstdint>
#include <memory>
#include <string>
#include <tuple>
#include <vector>
 
#include "lluvia/core/vulkan/vulkan.hpp"
 
#include "lluvia/core/buffer/BufferUsageFlags.h"
#include "lluvia/core/memory/MemoryFreeSpaceManager.h"
#include "lluvia/core/memory/MemoryPropertyFlags.h"
 
namespace ll {
 
namespace vulkan {
    class Device;
} // namespace vulkan
 
// forward declarations
class Buffer;
class Image;
class ImageDescriptor;
class ImageView;
class ImageViewDescriptor;
class Session;
 
struct VkHeapInfo {
 
    uint32_t typeIndex;
 
    uint64_t size;
 
    ll::MemoryPropertyFlags flags;
 
    std::vector<uint32_t> familyQueueIndices;
};
 
class Memory : public std::enable_shared_from_this<ll::Memory> {
 
public:
    Memory()                     = delete;
    Memory(const Memory& memory) = delete;
    Memory(Memory&& memory)      = delete;
 
    Memory(const std::shared_ptr<ll::vulkan::Device>& device,
        const ll::VkHeapInfo&                         heapInfo,
        const uint64_t                                pageSize);
 
    ~Memory();
 
    Memory& operator=(const Memory& memory) = delete;
    Memory& operator=(Memory&& memory)      = delete;
 
    ll::MemoryPropertyFlags getMemoryPropertyFlags() const noexcept;
 
    uint64_t getPageSize() const noexcept;
 
    uint32_t getPageCount() const noexcept;
 
    bool isMappable() const noexcept;
 
    bool isPageMappable(const uint32_t page) const noexcept;
 
    std::shared_ptr<ll::Buffer> createBuffer(const uint64_t size);
 
    std::shared_ptr<ll::Buffer> createBuffer(const uint64_t size, const ll::BufferUsageFlags usageFlags);
 
    std::shared_ptr<ll::Buffer> createBufferWithUnsafeFlags(const uint64_t size, const uint32_t usageFlags);
 
    std::shared_ptr<ll::Image> createImage(const ll::ImageDescriptor& descriptor);
 
    std::shared_ptr<ll::ImageView> createImageView(
        const ll::ImageDescriptor&     imgDescriptor,
        const ll::ImageViewDescriptor& viewDescriptor);
 
private:
    impl::MemoryAllocationTryInfo getSuitableMemoryPage(const vk::MemoryRequirements& memRequirements);
    void                          releaseMemoryAllocation(const ll::MemoryAllocationInfo& allocInfo);
 
    void  releaseBuffer(const ll::Buffer& buffer);
    void* mapBuffer(const ll::Buffer& buffer);
    void  unmapBuffer(const ll::Buffer& buffer);
 
    void releaseImage(const ll::Image& image);
 
    std::shared_ptr<ll::vulkan::Device> m_device;
 
    const ll::VkHeapInfo m_heapInfo {};
    const uint64_t       m_pageSize {0u};
 
    std::vector<vk::DeviceMemory>                 m_memoryPages;
    std::vector<ll::impl::MemoryFreeSpaceManager> m_pageManagers;
    std::vector<bool>                             m_memoryPageMappingFlags;
 
    friend class ll::Buffer;
    friend class ll::Image;
};
 
} // namespace ll
 
#endif // LLUVIA_CORE_MEMORY_MEMORY_H_