vk_resource_state_tracker.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 "BLI_map.hh"
#include "BLI_vector.hh"
 
#include "vk_common.hh"

// #define VK_RESOURCE_STATE_TRACKER_VALIDATION
 
namespace blender::gpu::render_graph {
 
class VKCommandBuilder;
struct VKRenderGraphLink;
class VKScheduler;
 
using ResourceHandle = uint64_t;

using ModificationStamp = uint64_t;

struct ResourceWithStamp {
  ResourceHandle handle;
  ModificationStamp stamp;
};

enum class VKResourceType { NONE = (0 << 0), IMAGE = (1 << 0), BUFFER = (1 << 1) };
ENUM_OPERATORS(VKResourceType, VKResourceType::BUFFER);

enum class ResourceOwner {
  APPLICATION,

  SWAP_CHAIN,
};

struct VKResourceBarrierState {
  VkAccessFlags vk_access = VK_ACCESS_NONE;
  /* Last known pipeline stage. Will be reset by the last write. Reads will accumulate flags. */
  VkPipelineStageFlags vk_pipeline_stages = VK_PIPELINE_STAGE_NONE;
  VkImageLayout image_layout = VK_IMAGE_LAYOUT_UNDEFINED;
 
  bool is_new_stamp() const
  {
    return bool(vk_access &
                (VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
                 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT | VK_ACCESS_TRANSFER_WRITE_BIT |
                 VK_ACCESS_HOST_WRITE_BIT | VK_ACCESS_MEMORY_WRITE_BIT));
  }
};

class VKResourceStateTracker {
  /* When a command buffer is reset the resources are re-synced.
   * During the syncing the command builder attributes are resized to reduce reallocations. */
  friend class VKCommandBuilder;
  friend struct VKRenderGraphLink;
  friend class VKScheduler;

  struct Resource {
    VKResourceType type;
    union {
      struct {
        VkBuffer vk_buffer = VK_NULL_HANDLE;
      } buffer;
 
      struct {
        VkImage vk_image = VK_NULL_HANDLE;
        uint32_t layer_count = 0;

        VkImageLayout vk_image_layout = VK_IMAGE_LAYOUT_UNDEFINED;
      } image;
    };

    ModificationStamp stamp = 0;

    ResourceOwner owner = ResourceOwner::APPLICATION;

    VKResourceBarrierState barrier_state;
 
#ifndef NDEBUG
    const char *name;
#endif

    void reset_image_layout()
    {
      BLI_assert(type == VKResourceType::IMAGE);
      barrier_state.image_layout = image.vk_image_layout;
    }

    bool has_multiple_layers()
    {
      if (type == VKResourceType::BUFFER) {
        return false;
      }
      return image.layer_count > 1;
    }
  };
 
  Map<ResourceHandle, Resource> resources_;
  Vector<ResourceHandle> unused_handles_;
  Map<VkImage, ResourceHandle> image_resources_;
  Map<VkBuffer, ResourceHandle> buffer_resources_;
 
 public:
  std::mutex mutex;

  void add_buffer(VkBuffer vk_buffer, const char *name = nullptr);

  void add_image(VkImage vk_image,
                 uint32_t layer_count,
                 VkImageLayout vk_image_layout,
                 ResourceOwner owner,
                 const char *name = nullptr);

  void remove_image(VkImage vk_image);

  void remove_buffer(VkBuffer vk_buffer);

  ResourceWithStamp get_image_and_increase_stamp(VkImage vk_image);

  ResourceWithStamp get_buffer_and_increase_stamp(VkBuffer vk_buffer);

  ResourceWithStamp get_buffer(VkBuffer vk_buffer) const;

  ResourceWithStamp get_image(VkImage vk_image) const;

  void reset_image_layouts();

  VKResourceType resource_type_get(ResourceHandle resource_handle) const
  {
    return resources_.lookup(resource_handle).type;
  }
 
 private:
  static ResourceWithStamp get_stamp(ResourceHandle handle, const Resource &resource);

  static ResourceWithStamp get_and_increase_stamp(ResourceHandle handle, Resource &resource);
 
  ResourceHandle create_resource_slot();
 
#ifdef VK_RESOURCE_STATE_TRACKER_VALIDATION
  void validate() const;
#endif
};
 
}  // namespace blender::gpu::render_graph