ComputeNode.h

Go to the documentation of this file.

 
#ifndef LLUVIA_CORE_NODE_COMPUTE_NODE_H_
#define LLUVIA_CORE_NODE_COMPUTE_NODE_H_
 
#include "lluvia/core/node/ComputeNodeDescriptor.h"
#include "lluvia/core/node/Node.h"
 
#include <cstdint>
#include <map>
#include <memory>
#include <string>
 
#include "lluvia/core/vulkan/vulkan.hpp"
 
namespace ll {
 
namespace vulkan {
    class Device;
} // namespace vulkan
 
class Buffer;
class CommandBuffer;
class Image;
class ImageView;
class Interpreter;
class Object;
class Program;
 
class ComputeNode : public Node, public std::enable_shared_from_this<ll::ComputeNode> {
 
public:
    ComputeNode()                        = delete;
    ComputeNode(const ComputeNode& node) = delete;
    ComputeNode(ComputeNode&& node)      = delete;
 
    ComputeNode(const std::shared_ptr<ll::vulkan::Device>& device,
        const ll::ComputeNodeDescriptor&                   descriptor,
        const std::weak_ptr<ll::Interpreter>&              interpreter);
 
    virtual ~ComputeNode();
 
    ComputeNode& operator=(const ComputeNode& node) = delete;
    ComputeNode& operator=(ComputeNode&& node)      = delete;
 
    ll::NodeType getType() const noexcept override;
 
    std::string getFunctionName() const noexcept;
 
    std::shared_ptr<ll::Program> getProgram() const noexcept;
 
    const ll::ComputeNodeDescriptor& getDescriptor() const noexcept;
 
    uint32_t getLocalX() const noexcept;
 
    uint32_t getLocalY() const noexcept;
 
    uint32_t getLocalZ() const noexcept;
 
    ll::vec3ui getLocalShape() const noexcept;
 
    uint32_t getGridX() const noexcept;
 
    void setGridX(const uint32_t x) noexcept;
 
    uint32_t getGridY() const noexcept;
 
    void setGridY(const uint32_t y) noexcept;
 
    uint32_t getGridZ() const noexcept;
 
    void setGridZ(const uint32_t z) noexcept;
 
    void setGridShape(const ll::vec3ui& shape) noexcept;
 
    void configureGridShape(const ll::vec3ui& globalShape) noexcept;
 
    ll::vec3ui getGridShape() const noexcept;
 
    bool hasPort(const std::string& name) const noexcept override;
 
    std::shared_ptr<ll::Object> getPort(const std::string& name) const override;
 
    void setPushConstants(const ll::PushConstants& constants) noexcept;
 
    const ll::PushConstants& getPushConstants() const noexcept;
 
    void bind(const std::string& name, const std::shared_ptr<ll::Object>& obj) override;
 
    void record(ll::CommandBuffer& commandBuffer) const override;
 
    void setParameter(const std::string& name, const ll::Parameter& value) override;
 
    const ll::Parameter& getParameter(const std::string& name) const override;
 
protected:
    void onInit() override;
 
private:
    void initPortBindings();
    void initPipeline();
 
    void bindBuffer(const ll::PortDescriptor& port, const std::shared_ptr<ll::Buffer>& buffer);
    void bindImageView(const ll::PortDescriptor& port, const std::shared_ptr<ll::ImageView>& imageView);
 
    std::vector<vk::DescriptorPoolSize> getDescriptorPoolSizes() const noexcept;
    uint32_t                            countDescriptorType(const vk::DescriptorType type) const noexcept;
 
    std::shared_ptr<ll::vulkan::Device> m_device;
 
    vk::DescriptorSetLayout m_descriptorSetLayout;
 
    vk::PipelineLayout m_pipelineLayout;
    vk::Pipeline       m_pipeline;
 
    vk::DescriptorSet  m_descriptorSet;
    vk::DescriptorPool m_descriptorPool;
 
    ll::ComputeNodeDescriptor m_descriptor;
 
    std::vector<vk::DescriptorSetLayoutBinding> m_parameterBindings;
 
    // specialization constants
    // vk::SpecializationInfo specializationInfo;
    // std::vector<vk::SpecializationMapEntry> specializationMapEntries;
    // // uint32_t local_x {1};
 
    std::map<std::string, std::shared_ptr<ll::Object>> m_objects;
 
    std::weak_ptr<ll::Interpreter> m_interpreter;
};
 
} // namespace ll
 
#endif /* LLUVIA_CORE_NODE_COMPUTE_NODE_H_ */