vk_render_graph.hh

Go to the documentation of this file.

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

 
#pragma once
 
#include <mutex>
#include <optional>
#include <pthread.h>
 
#include "BKE_global.hh"
 
#include "BLI_color_types.hh"
#include "BLI_map.hh"
#include "BLI_utility_mixins.hh"
#include "BLI_vector.hh"
#include "BLI_vector_set.hh"
 
#include "BKE_global.hh"
 
#include "vk_common.hh"
 
#include "vk_command_buffer_wrapper.hh"
#include "vk_command_builder.hh"
#include "vk_render_graph_links.hh"
#include "vk_resource_state_tracker.hh"
 
namespace blender::gpu::render_graph {
class VKScheduler;
 
class VKRenderGraph : public NonCopyable {
  friend class VKCommandBuilder;
  friend class VKScheduler;
  using DebugGroupNameID = int64_t;
  using DebugGroupID = int64_t;

  Vector<VKRenderGraphNodeLinks, 1024> links_;
  Vector<VKRenderGraphNode, 1024> nodes_;
  VKRenderGraphStorage storage_;

  VKResourceStateTracker &resources_;
 
  struct DebugGroup {
    std::string name;
    ColorTheme4f color;
 
    BLI_STRUCT_EQUALITY_OPERATORS_2(DebugGroup, name, color)
    uint64_t hash() const
    {
      return get_default_hash<std::string, ColorTheme4f>(name, color);
    }
  };
 
  struct {
    VectorSet<DebugGroup> groups;

    Vector<DebugGroupNameID> group_stack;

    bool group_used = false;

    Vector<Vector<DebugGroupNameID>> used_groups;

    Vector<DebugGroupID> node_group_map;
  } debug_;
 
 public:
  VKRenderGraph(VKResourceStateTracker &resources);
 
 private:
  template<typename NodeInfo> NodeHandle add_node(const typename NodeInfo::CreateInfo &create_info)
  {
    std::scoped_lock lock(resources_.mutex);
    static VKRenderGraphNode node_template = {};
    NodeHandle node_handle = nodes_.append_and_get_index(node_template);
#if 0
    /* Useful during debugging. When a validation error occurs during submission we know the node
     * type and node handle, but we don't know when and by who that specific node was added to the
     * render graph. By enabling this part of the code and set the correct node_handle and node
     * type a debugger can break at the moment the node has been added to the render graph. */
    if (node_handle == 267 && NodeInfo::node_type == VKNodeType::DRAW) {
      std::cout << "break\n";
    }
#endif
    if (nodes_.size() > links_.size()) {
      links_.resize(nodes_.size());
    }
    VKRenderGraphNode &node = nodes_[node_handle];
    node.set_node_data<NodeInfo>(storage_, create_info);
 
    VKRenderGraphNodeLinks &node_links = links_[node_handle];
    BLI_assert(node_links.inputs.is_empty());
    BLI_assert(node_links.outputs.is_empty());
    node.build_links<NodeInfo>(resources_, node_links, create_info);
 
    if (G.debug & G_DEBUG_GPU) {
      if (!debug_.group_used) {
        debug_.group_used = true;
        debug_.used_groups.append(debug_.group_stack);
      }
      if (nodes_.size() > debug_.node_group_map.size()) {
        debug_.node_group_map.resize(nodes_.size());
      }
      debug_.node_group_map[node_handle] = debug_.used_groups.size() - 1;
    }
    return node_handle;
  }
 
 public:
#define ADD_NODE(NODE_CLASS) \
  NodeHandle add_node(const NODE_CLASS::CreateInfo &create_info) \
  { \
    return add_node<NODE_CLASS>(create_info); \
  }
  ADD_NODE(VKBeginQueryNode)
  ADD_NODE(VKBeginRenderingNode)
  ADD_NODE(VKEndQueryNode)
  ADD_NODE(VKEndRenderingNode)
  ADD_NODE(VKClearAttachmentsNode)
  ADD_NODE(VKClearColorImageNode)
  ADD_NODE(VKClearDepthStencilImageNode)
  ADD_NODE(VKFillBufferNode)
  ADD_NODE(VKCopyBufferNode)
  ADD_NODE(VKCopyBufferToImageNode)
  ADD_NODE(VKCopyImageNode)
  ADD_NODE(VKCopyImageToBufferNode)
  ADD_NODE(VKBlitImageNode)
  ADD_NODE(VKDispatchNode)
  ADD_NODE(VKDispatchIndirectNode)
  ADD_NODE(VKDrawNode)
  ADD_NODE(VKDrawIndexedNode)
  ADD_NODE(VKDrawIndexedIndirectNode)
  ADD_NODE(VKDrawIndirectNode)
  ADD_NODE(VKResetQueryPoolNode)
  ADD_NODE(VKUpdateBufferNode)
  ADD_NODE(VKUpdateMipmapsNode)
  ADD_NODE(VKSynchronizationNode)
#undef ADD_NODE

  VKCopyBufferNode::Data &get_node_data(NodeHandle node_handle)
  {
    VKRenderGraphNode &node = nodes_[node_handle];
    BLI_assert(node.type == VKNodeType::COPY_BUFFER);
    return node.copy_buffer;
  }

  void debug_group_begin(const char *name, const ColorTheme4f &color);

  void debug_group_end();

  std::string full_debug_group(NodeHandle node_handle) const;

  NodeHandle next_node_handle()
  {
    return nodes_.size();
  }
 
  bool is_empty()
  {
    return nodes_.is_empty();
  }
 
  void debug_print(NodeHandle node_handle) const;

  void reset();
 
  void memstats() const;
 
 private:
};
 
}  // namespace blender::gpu::render_graph