Session.h

Go to the documentation of this file.

 
#ifndef LLUVIA_CORE_SESSION_H_
#define LLUVIA_CORE_SESSION_H_
 
#include "lluvia/core/vulkan/vulkan.hpp"
 
#include <cstdint>
#include <map>
#include <memory>
#include <mutex>
#include <string>
#include <tuple>
#include <vector>
 
#include "lluvia/core/ComputeDimension.h"
#include "lluvia/core/SessionDescriptor.h"
#include "lluvia/core/device/DeviceDescriptor.h"
#include "lluvia/core/image/ImageDescriptor.h"
#include "lluvia/core/memory/MemoryPropertyFlags.h"
#include "lluvia/core/node/NodeBuilderDescriptor.h"
#include "lluvia/core/types.h"
 
namespace ll {
 
namespace vulkan {
    class Device;
    class Instance;
} // namespace vulkan
 
class Buffer;
class CommandBuffer;
class ComputeNode;
class ComputeNodeDescriptor;
class ContainerNode;
class ContainerNodeDescriptor;
class Duration;
class Image;
class Interpreter;
class Memory;
class Program;
 
class Session : public std::enable_shared_from_this<ll::Session> {
 
public:
    static std::vector<ll::DeviceDescriptor> getAvailableDevices();
 
    static std::vector<vk::LayerProperties> getVulkanInstanceLayerProperties();
 
    static std::vector<vk::ExtensionProperties> getVulkanExtensionProperties();
 
    static std::shared_ptr<ll::Session> create();
 
    static std::shared_ptr<ll::Session> create(const ll::SessionDescriptor& descriptor);
 
    Session(const Session& session) = delete;
    Session(Session&& session)      = delete;
 
    ~Session();
 
    Session& operator=(const Session& session) = delete;
    Session& operator=(Session&& session)      = delete;
 
    std::shared_ptr<ll::Memory> getHostMemory() const noexcept;
 
    std::shared_ptr<ll::Memory> getDeviceMemory() const noexcept;
 
    // const std::unique_ptr<ll::Interpreter>& getInterpreter() const noexcept;
 
    vk::PhysicalDeviceMemoryProperties getPhysicalDeviceMemoryProperties() const;
 
    std::vector<ll::MemoryPropertyFlags> getSupportedMemoryFlags() const;
 
    const ll::DeviceDescriptor& getDeviceDescriptor() const noexcept;
 
    bool isImageDescriptorSupported(const ll::ImageDescriptor& descriptor) const noexcept;
 
    std::shared_ptr<ll::Memory> createMemory(const ll::MemoryPropertyFlags& flags, const uint64_t pageSize, bool exactFlagsMatch = false);
 
    std::unique_ptr<ll::CommandBuffer> createCommandBuffer() const;
 
    std::unique_ptr<ll::Duration> createDuration() const;
 
    std::shared_ptr<ll::Program> createProgram(const std::string& spirvPath) const;
 
    std::shared_ptr<ll::Program> createProgram(const std::vector<uint8_t>& spirv) const;
 
    void setProgram(const std::string& name, const std::shared_ptr<ll::Program>& program);
 
    std::shared_ptr<ll::Program> getProgram(const std::string& name) const;
 
    std::vector<ll::NodeBuilderDescriptor> getNodeBuilderDescriptors() const;
 
    std::shared_ptr<ll::ComputeNode> createComputeNode(const ll::ComputeNodeDescriptor& descriptor);
 
    std::shared_ptr<ll::ComputeNode> createComputeNode(const std::string& builderName);
 
    ll::ComputeNodeDescriptor createComputeNodeDescriptor(const std::string& builderName) const;
 
    std::shared_ptr<ll::ContainerNode> createContainerNode(const ll::ContainerNodeDescriptor& descriptor);
 
    std::shared_ptr<ll::ContainerNode> createContainerNode(const std::string& builderName);
 
    ll::ContainerNodeDescriptor createContainerNodeDescriptor(const std::string& builderName) const;
 
    void run(const ll::CommandBuffer& cmdBuffer);
 
    void run(const ll::ComputeNode& node);
 
    void run(const ll::ContainerNode& node);
 
    void script(const std::string& code);
 
    void scriptFile(const std::string& filename);
 
    void loadLibrary(const std::string& filename);
 
    ll::vec3ui getGoodComputeLocalShape(ll::ComputeDimension dimensions) const noexcept;
 
    std::string help(const std::string& builderName) const;
 
    bool hasReceivedVulkanWarningMessages() const noexcept;
 
private:
    static uint32_t findComputeFamilyQueueIndex(vk::PhysicalDevice& physicalDevice);
 
    // Session objects should be created through factory methods
    Session(const ll::SessionDescriptor& descriptor);
 
    void initDescriptor();
    void initDevice();
 
    const ll::SessionDescriptor m_descriptor;
    ll::DeviceDescriptor        m_deviceDescriptor;
 
    std::shared_ptr<ll::vulkan::Instance> m_instance;
    std::shared_ptr<ll::vulkan::Device>   m_device;
 
    std::shared_ptr<ll::Interpreter> m_interpreter;
 
    std::map<std::string, std::shared_ptr<ll::Program>> m_programRegistry;
 
    std::shared_ptr<ll::Memory> m_hostMemory;
    std::shared_ptr<ll::Memory> m_deviceMemory;
};
 
} // namespace ll
 
#endif // LLUVIA_CORE_SESSION_H_