Buffer.h

Go to the documentation of this file.

 
#ifndef LLUVIA_CORE_BUFFER_BUFFER_H_
#define LLUVIA_CORE_BUFFER_BUFFER_H_
 
#include "lluvia/core/Object.h"
#include "lluvia/core/buffer/BufferUsageFlags.h"
#include "lluvia/core/error.h"
#include "lluvia/core/memory/Memory.h"
#include "lluvia/core/memory/MemoryAllocationInfo.h"
 
#include "lluvia/core/vulkan/vulkan.hpp"
 
#include <array>
#include <cstdint>
#include <iostream>
#include <memory>
#include <string>
#include <tuple>
#include <type_traits>
#include <vector>
 
namespace ll {
 
class Buffer;
class CommandBuffer;
class ComputeGraph;
class ComputeNode;
class Session;
 
class Buffer : public Object {
 
public:
    Buffer()                = delete;
    Buffer(const Buffer& b) = delete;
    Buffer(Buffer&& b)      = delete;
 
    ~Buffer();
 
    Buffer& operator=(const Buffer& buffer) = delete;
    Buffer& operator=(Buffer&& buffer)      = delete;
 
    ll::ObjectType getType() const noexcept override;
 
    ll::MemoryAllocationInfo getAllocationInfo() const noexcept;
 
    const std::shared_ptr<ll::Memory>& getMemory() const noexcept;
 
    uint64_t getSize() const noexcept;
 
    ll::BufferUsageFlags getUsageFlags() const noexcept;
 
    uint32_t getUsageFlagsUnsafe() const noexcept;
 
    bool isMappable() const noexcept;
 
    struct BufferMapDeleter {
 
        template <typename T>
        void operator()([[maybe_unused]] T* ptr) const
        {
            buffer->unmap();
        }
 
        ll::Buffer* buffer;
    };
 
    template <typename T>
    std::unique_ptr<T, ll::Buffer::BufferMapDeleter> map()
    {
 
        if (!m_memory->isPageMappable(m_allocInfo.page)) {
            throw std::system_error(createErrorCode(ll::ErrorCode::MemoryMapFailed), "memory page " + std::to_string(m_allocInfo.page) + " is currently mapped by another object or this memory cannot be mapped");
        }
 
        // remove array extend from T if present
        typedef typename std::conditional<std::is_array<T>::value, typename std::remove_all_extents<T>::type, T>::type baseType;
 
        auto ptr = m_memory->mapBuffer(*this);
 
        auto deleter   = ll::Buffer::BufferMapDeleter {};
        deleter.buffer = this;
 
        return std::unique_ptr<T, ll::Buffer::BufferMapDeleter> {static_cast<baseType*>(ptr), deleter};
    }
 
    template <typename T>
    void mapAndSet(T&& obj)
    {
 
        const auto objSize = sizeof(obj);
        if (objSize > getSize()) {
            ll::throwSystemError(ll::ErrorCode::MemoryMapFailed, "size of input object (" + std::to_string(objSize) + " bytes) is greater than size of buffer (" + std::to_string(getSize()) + " bytes)");
        }
 
        auto ptr = map<std::remove_const_t<std::remove_reference_t<T>>>();
 
        std::memcpy(static_cast<void*>(ptr.get()), &obj, objSize);
    }
 
    template <typename T>
    void mapAndSetFromVector(const std::vector<T>& vec)
    {
 
        const auto vecSize = vec.size() * sizeof(T);
        if (vecSize > getSize()) {
            ll::throwSystemError(ll::ErrorCode::MemoryMapFailed, "size of input vector (" + std::to_string(vecSize) + " bytes) is greater than size of buffer (" + std::to_string(getSize()) + " bytes)");
        }
 
        auto ptr = map<std::remove_const_t<std::remove_reference_t<T>>>();
 
        std::memcpy(static_cast<void*>(ptr.get()), vec.data(), vecSize);
    }
 
private:
    Buffer(const vk::Buffer vkBuffer, const ll::BufferUsageFlags usageFlags,
        const std::shared_ptr<ll::Memory>& memory, const ll::MemoryAllocationInfo& allocInfo,
        const uint64_t requestedSize);
 
    void unmap();
 
    vk::Buffer           m_vkBuffer;
    ll::BufferUsageFlags m_usageFlags;
 
    ll::MemoryAllocationInfo m_allocInfo;
 
    // the size requested for the buffer. It can
    // be less than allocInfo.size due to alignment
    // and size requirements for the given memory.
    uint64_t m_requestedSize;
 
    // Shared pointer to the memory this buffer was created from
    // This will keep the memory alive until this buffer is deleted
    // avoiding reference to a corrupted memory location.
    std::shared_ptr<ll::Memory> m_memory;
 
    friend class ll::CommandBuffer;
    friend class ll::ComputeGraph;
    friend class ll::ComputeNode;
    friend class ll::Memory;
    friend class ll::Session;
};
 
} // namespace ll
 
#endif // LLUVIA_CORE_BUFFER_BUFFER_H_