d75cf2efd4
Resource binding was over-complicated as I didn't understood the state manager and vulkan to make the correct decisions at that time. This refactor will remove a lot of the complexity and improves the performance. **Performance** The performance improvement is noticeable in complex grease pencil scenes. Grease pencil benchmark file picknick: - `NVIDIA Quadro RTX 6000` 17 fps -> 24 fps - `Intel(R) Arc(tm) A750 Graphics (DG2)` 6 -> 21 fps **Bottle-neck** The performance improvements originates from moving the update entry point from state manager to shader interface. The previous implementation (state manager) had to loop over all the bound resources and find in the shader interface where it was located in the descriptor set. Ignoring resources that were not used by the shader. But also making it hard to determine if descriptor sets actually changed. Previous implementation assumed descriptor sets always changed. When descriptor set changed a new descriptor set needed to be allocated. Most drivers this is a fast operation, but on Intel/Mesa this was measurable slow. Using an allocation pool doesn't fit the Vulkan API as you are only able to reuse when the layout matches exactly. Of course doable, but requires another structure to keep track of the actual layouts. **Solution** By using the shader interface as entry point we can: 1. Keep track if there are any changes in the state manager. If not and the layout is the same, the previous shader can be reused. 2. In stead of looping over each bound resource, we loop over bind points. **Future extensions** Bundle all descriptor set uploads just before use. This would be more in line with how 'modern' Vulkan should be implemented. This PR already separates the uploading from the updating and technically allows to upload more than one descriptor set. Instead of looking 1 set back we should measure if we can handle multiple or keep track of the different layouts resources to improve the performance even further. Optional use `VK_KHR_descriptor_buffer` when available. Pull Request: https://projects.blender.org/blender/blender/pulls/128068
122 lines
3.5 KiB
C++
122 lines
3.5 KiB
C++
/* SPDX-FileCopyrightText: 2022 Blender Authors
|
|
*
|
|
* SPDX-License-Identifier: GPL-2.0-or-later */
|
|
|
|
/** \file
|
|
* \ingroup gpu
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "gpu_context_private.hh"
|
|
|
|
#include "GHOST_Types.h"
|
|
|
|
#include "render_graph/vk_render_graph.hh"
|
|
#include "vk_common.hh"
|
|
#include "vk_debug.hh"
|
|
#include "vk_descriptor_pools.hh"
|
|
#include "vk_resource_pool.hh"
|
|
|
|
namespace blender::gpu {
|
|
class VKFrameBuffer;
|
|
class VKVertexAttributeObject;
|
|
class VKBatch;
|
|
class VKStateManager;
|
|
class VKShader;
|
|
class VKThreadData;
|
|
|
|
class VKContext : public Context, NonCopyable {
|
|
private:
|
|
VkExtent2D vk_extent_ = {};
|
|
VkFormat swap_chain_format_ = {};
|
|
GPUTexture *surface_texture_ = nullptr;
|
|
void *ghost_context_;
|
|
|
|
/* Reusable data. Stored inside context to limit reallocations. */
|
|
render_graph::VKResourceAccessInfo access_info_ = {};
|
|
|
|
VKThreadData &thread_data_;
|
|
|
|
public:
|
|
render_graph::VKRenderGraph &render_graph;
|
|
|
|
VKContext(void *ghost_window, void *ghost_context, VKThreadData &thread_data);
|
|
virtual ~VKContext();
|
|
|
|
void activate() override;
|
|
void deactivate() override;
|
|
void begin_frame() override;
|
|
void end_frame() override;
|
|
|
|
void flush() override;
|
|
void flush_render_graph();
|
|
void finish() override;
|
|
|
|
void memory_statistics_get(int *r_total_mem_kb, int *r_free_mem_kb) override;
|
|
|
|
void debug_group_begin(const char *, int) override;
|
|
void debug_group_end() override;
|
|
bool debug_capture_begin(const char *title) override;
|
|
void debug_capture_end() override;
|
|
void *debug_capture_scope_create(const char *name) override;
|
|
bool debug_capture_scope_begin(void *scope) override;
|
|
void debug_capture_scope_end(void *scope) override;
|
|
|
|
void debug_unbind_all_ubo() override;
|
|
void debug_unbind_all_ssbo() override;
|
|
|
|
bool has_active_framebuffer() const;
|
|
void activate_framebuffer(VKFrameBuffer &framebuffer);
|
|
void deactivate_framebuffer();
|
|
VKFrameBuffer *active_framebuffer_get() const;
|
|
|
|
/**
|
|
* Ensure that the active framebuffer isn't rendering.
|
|
*
|
|
* Between `vkCmdBeginRendering` and `vkCmdEndRendering` the framebuffer is rendering. Dispatch
|
|
* and transfer commands cannot be called between these commands. They can call this method to
|
|
* ensure that the framebuffer is outside these calls.
|
|
*/
|
|
void rendering_end();
|
|
|
|
render_graph::VKResourceAccessInfo &reset_and_get_access_info();
|
|
|
|
/**
|
|
* Update the give shader data with the current state of the context.
|
|
*/
|
|
void update_pipeline_data(render_graph::VKPipelineData &r_pipeline_data);
|
|
void update_pipeline_data(GPUPrimType primitive,
|
|
VKVertexAttributeObject &vao,
|
|
render_graph::VKPipelineData &r_pipeline_data);
|
|
|
|
void sync_backbuffer();
|
|
|
|
static VKContext *get()
|
|
{
|
|
return static_cast<VKContext *>(Context::get());
|
|
}
|
|
|
|
VKDescriptorPools &descriptor_pools_get();
|
|
VKDescriptorSetTracker &descriptor_set_get();
|
|
VKStateManager &state_manager_get() const;
|
|
|
|
static void swap_buffers_pre_callback(const GHOST_VulkanSwapChainData *data);
|
|
static void swap_buffers_post_callback();
|
|
|
|
private:
|
|
void swap_buffers_pre_handler(const GHOST_VulkanSwapChainData &data);
|
|
void swap_buffers_post_handler();
|
|
|
|
void update_pipeline_data(VKShader &shader,
|
|
VkPipeline vk_pipeline,
|
|
render_graph::VKPipelineData &r_pipeline_data);
|
|
};
|
|
|
|
BLI_INLINE bool operator==(const VKContext &a, const VKContext &b)
|
|
{
|
|
return static_cast<const void *>(&a) == static_cast<const void *>(&b);
|
|
}
|
|
|
|
} // namespace blender::gpu
|