vk_command_builder.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2024 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
#pragma once
 
#include "BLI_set.hh"
 
#include "vk_common.hh"
#include "vk_render_graph_node.hh"
#include "vk_scheduler.hh"
 
namespace blender::gpu::render_graph {
class VKRenderGraph;
 
struct LayeredImageBinding {
  VkImage vk_image;
  VkImageLayout vk_image_layout;
  uint32_t layer;
  uint32_t layer_count;
};

class VKCommandBuilder {
 private:
  Vector<VkBufferMemoryBarrier> vk_buffer_memory_barriers_;
  Vector<VkImageMemoryBarrier> vk_image_memory_barriers_;
 
  struct Barrier {
    IndexRange buffer_memory_barriers;
    IndexRange image_memory_barriers;
 
    VkPipelineStageFlags src_stage_mask = VK_PIPELINE_STAGE_NONE;
    VkPipelineStageFlags dst_stage_mask = VK_PIPELINE_STAGE_NONE;
 
    bool is_empty() const
    {
      return buffer_memory_barriers.is_empty() && image_memory_barriers.is_empty();
    }
  };

  struct LayeredImageTracker {
    VKCommandBuilder &command_builder;
    LayeredImageTracker(VKCommandBuilder &command_builder) : command_builder(command_builder) {}

    Set<VkImage> layered_attachments;
 
    struct TrackedImage {
      VkImage vk_image;
      VkImageLayout vk_image_layout;
      uint32_t layer;
      uint32_t layer_count;
    };
    Vector<TrackedImage> layered_bindings;

    void begin(const VKRenderGraph &render_graph, NodeHandle node_handle);

    inline bool contains(VkImage vk_image) const
    {
      return layered_attachments.contains(vk_image);
    }

    void update(VkImage vk_image,
                uint32_t layer,
                uint32_t layer_count,
                VkImageLayout old_layout,
                VkImageLayout new_layout,
                Barrier &r_barrier);

    void end(Barrier &r_barrier, bool use_local_read);

    void suspend(Barrier &r_barrier, bool use_local_read);

    void resume(Barrier &r_barrier, bool use_local_read);
  };

  using GroupNodes = IndexRange;

  using Barriers = IndexRange;
  using BarrierIndex = int64_t;

  Vector<GroupNodes> group_nodes_;
  Vector<Barriers> group_pre_barriers_;
  Vector<Barriers> group_post_barriers_;
  Vector<Barriers> node_pre_barriers_;

  Vector<Barrier> barrier_list_;
 
 public:
  void build_nodes(VKRenderGraph &render_graph,
                   VKCommandBufferInterface &command_buffer,
                   Span<NodeHandle> node_handles);

  void record_commands(VKRenderGraph &render_graph,
                       VKCommandBufferInterface &command_buffer,
                       Span<NodeHandle> node_handles);
 
 private:
  void groups_init(const VKRenderGraph &render_graph, Span<NodeHandle> node_handles);

  void groups_extract_barriers(VKRenderGraph &render_graph,
                               Span<NodeHandle> node_handles,
                               bool supports_local_read);

  void groups_build_commands(VKRenderGraph &render_graph,
                             VKCommandBufferInterface &command_buffer,
                             Span<NodeHandle> node_handles);

  void build_pipeline_barriers(VKRenderGraph &render_graph,
                               NodeHandle node_handle,
                               VkPipelineStageFlags pipeline_stage,
                               LayeredImageTracker &layered_tracker,
                               Barrier &r_barrier,
                               bool within_rendering = false);
  void reset_barriers(Barrier &r_barrier);
  void send_pipeline_barriers(VKCommandBufferInterface &command_buffer,
                              const Barrier &barrier,
                              bool within_rendering);
 
  void add_buffer_barriers(VKRenderGraph &render_graph,
                           NodeHandle node_handle,
                           VkPipelineStageFlags node_stages,
                           Barrier &r_barrier);
  void add_buffer_barrier(VkBuffer vk_buffer,
                          Barrier &r_barrier,
                          VkAccessFlags src_access_mask,
                          VkAccessFlags dst_access_mask);
  void add_buffer_read_barriers(VKRenderGraph &render_graph,
                                NodeHandle node_handle,
                                VkPipelineStageFlags node_stages,
                                Barrier &r_barrier);
  void add_buffer_write_barriers(VKRenderGraph &render_graph,
                                 NodeHandle node_handle,
                                 VkPipelineStageFlags node_stages,
                                 Barrier &r_barrier);
 
  void add_image_barriers(VKRenderGraph &render_graph,
                          NodeHandle node_handle,
                          VkPipelineStageFlags node_stages,
                          LayeredImageTracker &layered_tracker,
                          Barrier &r_barrier,
                          bool within_rendering);
  void add_image_barrier(VkImage vk_image,
                         Barrier &r_barrier,
                         VkAccessFlags src_access_mask,
                         VkAccessFlags dst_access_mask,
                         VkImageLayout old_image_layout,
                         VkImageLayout new_image_layout,
                         VkImageAspectFlags aspect_mask,
                         uint32_t layer_base = 0,
                         uint32_t layer_count = VK_REMAINING_ARRAY_LAYERS);
  void add_image_read_barriers(VKRenderGraph &render_graph,
                               NodeHandle node_handle,
                               VkPipelineStageFlags node_stages,
                               LayeredImageTracker &layered_tracker,
                               Barrier &r_barrier,
                               bool within_rendering);
  void add_image_write_barriers(VKRenderGraph &render_graph,
                                NodeHandle node_handle,
                                VkPipelineStageFlags node_stages,
                                LayeredImageTracker &layered_tracker,
                                Barrier &r_barrier,
                                bool within_rendering);
 
  struct DebugGroups {
    int64_t active_debug_group_id = -1;
    int debug_level = 0;
  };

  void activate_debug_group(VKRenderGraph &render_graph,
                            VKCommandBufferInterface &command_buffer,
                            DebugGroups &debug_groups,
                            NodeHandle node_handle);

  void finish_debug_groups(VKCommandBufferInterface &command_buffer, DebugGroups &debug_groups);
 
 private:
  void layer_tracking_begin(const VKRenderGraph &render_graph, NodeHandle node_handle);

  void layer_tracking_update(VkImage vk_image,
                             uint32_t layer,
                             uint32_t layer_count,
                             VkImageLayout old_layout,
                             VkImageLayout new_layout);

  void layer_tracking_end(VKCommandBufferInterface &command_buffer);

  void layer_tracking_suspend(VKCommandBufferInterface &command_buffer);

  void layer_tracking_resume(VKCommandBufferInterface &command_buffer);
 
  bool node_has_input_attachments(const VKRenderGraph &render_graph, NodeHandle node);
 
  std::string to_string_barrier(const Barrier &barrier);
};
 
}  // namespace blender::gpu::render_graph