vk_device.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include "BLI_utility_mixins.hh"
#include "BLI_vector.hh"
 
#include "render_graph/vk_render_graph.hh"
#include "render_graph/vk_resource_state_tracker.hh"
#include "vk_buffer.hh"
#include "vk_common.hh"
#include "vk_debug.hh"
#include "vk_descriptor_pools.hh"
#include "vk_descriptor_set_layouts.hh"
#include "vk_pipeline_pool.hh"
#include "vk_resource_pool.hh"
#include "vk_samplers.hh"
 
namespace blender::gpu {
class VKBackend;
 
struct VKWorkarounds {
  bool not_aligned_pixel_formats = false;
 
  bool shader_output_viewport_index = false;
 
  bool shader_output_layer = false;
 
  struct {
    bool r8g8b8 = false;
  } vertex_formats;
 
  bool fragment_shader_barycentric = false;
 
  bool dynamic_rendering_unused_attachments = false;
};
 
class VKThreadData : public NonCopyable, NonMovable {
  static constexpr uint32_t resource_pools_count = 3;
 
 public:
  pthread_t thread_id;
  uint32_t resource_pool_index = UINT32_MAX;
  std::array<VKResourcePool, resource_pools_count> resource_pools;
 
  int32_t rendering_depth = 0;
 
  VKThreadData(VKDevice &device, pthread_t thread_id);
  void deinit(VKDevice &device);
 
  VKResourcePool &resource_pool_get()
  {
    if (resource_pool_index >= resource_pools.size()) {
      return resource_pools[0];
    }
    return resource_pools[resource_pool_index];
  }
 
  void resource_pool_next()
  {
    if (resource_pool_index == UINT32_MAX) {
      resource_pool_index = 1;
    }
    else {
      resource_pool_index = (resource_pool_index + 1) % resource_pools_count;
    }
  }
};
 
class VKDevice : public NonCopyable {
 private:
  VkInstance vk_instance_ = VK_NULL_HANDLE;
  VkPhysicalDevice vk_physical_device_ = VK_NULL_HANDLE;
  VkDevice vk_device_ = VK_NULL_HANDLE;
  uint32_t vk_queue_family_ = 0;
  VkQueue vk_queue_ = VK_NULL_HANDLE;
  std::mutex *queue_mutex_ = nullptr;
 
  VKSamplers samplers_;
  VKDescriptorSetLayouts descriptor_set_layouts_;
 
  Vector<std::reference_wrapper<VKContext>> contexts_;
 
  VmaAllocator mem_allocator_ = VK_NULL_HANDLE;
 
  VkPhysicalDeviceProperties vk_physical_device_properties_ = {};
  VkPhysicalDeviceDriverProperties vk_physical_device_driver_properties_ = {};
  VkPhysicalDeviceMemoryProperties vk_physical_device_memory_properties_ = {};
  VkPhysicalDeviceFeatures vk_physical_device_features_ = {};
  VkPhysicalDeviceVulkan11Features vk_physical_device_vulkan_11_features_ = {};
  VkPhysicalDeviceVulkan12Features vk_physical_device_vulkan_12_features_ = {};
  Array<VkExtensionProperties> device_extensions_;
 
  debug::VKDebuggingTools debugging_tools_;
 
  /* Workarounds */
  VKWorkarounds workarounds_;
 
  std::string glsl_patch_;
  Vector<VKThreadData *> thread_data_;
 
 public:
  render_graph::VKResourceStateTracker resources;
  VKDiscardPool orphaned_data;
  VKPipelinePool pipelines;
  VKBuffer dummy_buffer;
 
  struct {
    /* Extension: VK_KHR_dynamic_rendering */
    PFN_vkCmdBeginRendering vkCmdBeginRendering = nullptr;
    PFN_vkCmdEndRendering vkCmdEndRendering = nullptr;
 
    /* Extension: VK_EXT_debug_utils */
    PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabel = nullptr;
    PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabel = nullptr;
    PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectName = nullptr;
    PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessenger = nullptr;
    PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessenger = nullptr;
  } functions;
 
  VkPhysicalDevice physical_device_get() const
  {
    return vk_physical_device_;
  }
 
  const VkPhysicalDeviceProperties &physical_device_properties_get() const
  {
    return vk_physical_device_properties_;
  }
 
  const VkPhysicalDeviceFeatures &physical_device_features_get() const
  {
    return vk_physical_device_features_;
  }
 
  const VkPhysicalDeviceVulkan11Features &physical_device_vulkan_11_features_get() const
  {
    return vk_physical_device_vulkan_11_features_;
  }
 
  const VkPhysicalDeviceVulkan12Features &physical_device_vulkan_12_features_get() const
  {
    return vk_physical_device_vulkan_12_features_;
  }
 
  VkInstance instance_get() const
  {
    return vk_instance_;
  };
 
  VkDevice vk_handle() const
  {
    return vk_device_;
  }
 
  VkQueue queue_get() const
  {
    return vk_queue_;
  }
  std::mutex &queue_mutex_get()
  {
    return *queue_mutex_;
  }
 
  const uint32_t queue_family_get() const
  {
    return vk_queue_family_;
  }
 
  VmaAllocator mem_allocator_get() const
  {
    return mem_allocator_;
  }
 
  VKDescriptorSetLayouts &descriptor_set_layouts_get()
  {
    return descriptor_set_layouts_;
  }
 
  debug::VKDebuggingTools &debugging_tools_get()
  {
    return debugging_tools_;
  }
 
  const debug::VKDebuggingTools &debugging_tools_get() const
  {
    return debugging_tools_;
  }
 
  const VKSamplers &samplers() const
  {
    return samplers_;
  }
 
  bool is_initialized() const;
  void init(void *ghost_context);
  void reinit();
  void deinit();
 
  eGPUDeviceType device_type() const;
  eGPUDriverType driver_type() const;
  std::string vendor_name() const;
  std::string driver_version() const;
 
  bool supports_extension(const char *extension_name) const;
 
  const VKWorkarounds &workarounds_get() const
  {
    return workarounds_;
  }
 
  const char *glsl_patch_get() const;
  void init_glsl_patch();
 
  /* -------------------------------------------------------------------- */
  VKThreadData &current_thread_data();
 
  VKDiscardPool &discard_pool_for_current_thread();
 
  void context_register(VKContext &context);
  void context_unregister(VKContext &context);
  Span<std::reference_wrapper<VKContext>> contexts_get() const;
 
  void memory_statistics_get(int *r_total_mem_kb, int *r_free_mem_kb) const;
  static void debug_print(std::ostream &os, const VKDiscardPool &discard_pool);
  void debug_print();
 
 private:
  void init_physical_device_properties();
  void init_physical_device_memory_properties();
  void init_physical_device_features();
  void init_physical_device_extensions();
  void init_debug_callbacks();
  void init_memory_allocator();
  void init_functions();
 
  void init_dummy_buffer();
 
  /* During initialization the backend requires access to update the workarounds. */
  friend VKBackend;
};
 
}  // namespace blender::gpu