godotengine/godot
1
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2025-12-31 18:41:20 +00:00
Code Releases Wiki Activity

Use re-spirv in the Vulkan driver to optimize shaders.

Browse Source 
Includes contributions by Rémi to unify usage of SPIR-V Headers across the dependencies.

Co-authored-by: Rémi Verschelde <rverschelde@gmail.com>
This commit is contained in:
Dario
2024-11-14 13:46:57 -03:00
parent 5f12ada7a4
commit cf00643565
18 changed files with 9022 additions and 7724 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
drivers/metal/SCsub
View File

@@ -9,6 +9,7 @@ env_metal = env.Clone()
thirdparty_obj = []
thirdparty_spirv_headers_dir = "#thirdparty/spirv-headers/"
thirdparty_dir = "#thirdparty/spirv-cross/"
thirdparty_sources = [
"spirv_cfg.cpp",
@@ -22,6 +23,7 @@ thirdparty_sources = [
thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources]
env_metal.Prepend(CPPPATH=[thirdparty_dir, thirdparty_dir + "/include"])
env_metal.Prepend(CPPPATH=[thirdparty_spirv_headers_dir + "include/spirv/unified1"])
# Must enable exceptions for SPIRV-Cross; otherwise, it will abort the process on errors.
if "-fno-exceptions" in env_metal["CXXFLAGS"]:

8
drivers/vulkan/SCsub
View File

@@ -6,6 +6,8 @@ Import("env")
thirdparty_obj = []
thirdparty_dir = "#thirdparty/vulkan"
thirdparty_volk_dir = "#thirdparty/volk"
thirdparty_spirv_headers_dir = "#thirdparty/spirv-headers"
thirdparty_respirv_dir = "#thirdparty/re-spirv"
# Use bundled Vulkan headers
env.Prepend(CPPPATH=[thirdparty_dir, thirdparty_dir + "/include"])
@@ -50,6 +52,12 @@ elif env["platform"] == "macos" or env["platform"] == "ios":
env_thirdparty_vma.add_source_files(thirdparty_obj, thirdparty_sources_vma)
# Build re-spirv
env_thirdparty_respirv = env.Clone()
env_thirdparty_respirv.Prepend(CPPPATH=[thirdparty_spirv_headers_dir + "/include"])
env_thirdparty_respirv.disable_warnings()
thirdparty_sources_respirv = [thirdparty_respirv_dir + "/re-spirv.cpp"]
env_thirdparty_respirv.add_source_files(thirdparty_obj, thirdparty_sources_respirv)
env.drivers_sources += thirdparty_obj

206
drivers/vulkan/rendering_device_driver_vulkan.cpp
View File

@@ -50,6 +50,27 @@
#define PRINT_NATIVE_COMMANDS 0
// Enable the use of re-spirv for optimizing shaders after applying specialization constants.
#define RESPV_ENABLED 1
// Only enable function inlining for re-spirv when dealing with a shader that uses specialization constants.
#define RESPV_ONLY_INLINE_SHADERS_WITH_SPEC_CONSTANTS 1
// Print additional information about every shader optimized with re-spirv.
#define RESPV_VERBOSE 0
// Disable dead code elimination when using re-spirv.
#define RESPV_DONT_REMOVE_DEAD_CODE 0
// Record numerous statistics about pipeline creation such as time and shader sizes. When combined with enabling
// and disabling re-spirv, this can be used to measure its effects.
#define RECORD_PIPELINE_STATISTICS 0
#if RECORD_PIPELINE_STATISTICS
#include "core/io/file_access.h"
#define RECORD_PIPELINE_STATISTICS_PATH "./pipelines.csv"
#endif
/*****************/
/**** GENERIC ****/
/*****************/
@@ -1637,6 +1658,14 @@ Error RenderingDeviceDriverVulkan::initialize(uint32_t p_device_index, uint32_t
shader_container_format.set_debug_info_enabled(Engine::get_singleton()->is_generate_spirv_debug_info_enabled());
#if RECORD_PIPELINE_STATISTICS
pipeline_statistics.file_access = FileAccess::open(RECORD_PIPELINE_STATISTICS_PATH, FileAccess::WRITE);
ERR_FAIL_NULL_V_MSG(pipeline_statistics.file_access, ERR_CANT_CREATE, "Unable to write pipeline statistics file.");
pipeline_statistics.file_access->store_csv_line({ "name", "hash", "stage", "spec", "glslang", "re-spirv", "time" });
pipeline_statistics.file_access->flush();
#endif
return OK;
}
@@ -3760,6 +3789,8 @@ static VkShaderStageFlagBits RD_STAGE_TO_VK_SHADER_STAGE_BITS[RDD::SHADER_STAGE_
RDD::ShaderID RenderingDeviceDriverVulkan::shader_create_from_container(const Ref<RenderingShaderContainer> &p_shader_container, const Vector<ImmutableSampler> &p_immutable_samplers) {
ShaderReflection shader_refl = p_shader_container->get_shader_reflection();
ShaderInfo shader_info;
shader_info.name = p_shader_container->shader_name.get_data();
for (uint32_t i = 0; i < SHADER_STAGE_MAX; i++) {
if (shader_refl.push_constant_stages.has_flag((ShaderStage)(1 << i))) {
shader_info.vk_push_constant_stages |= RD_STAGE_TO_VK_SHADER_STAGE_BITS[i];
@@ -3846,9 +3877,20 @@ RDD::ShaderID RenderingDeviceDriverVulkan::shader_create_from_container(const Re
VkResult res;
String error_text;
Vector<uint8_t> decompressed_code;
Vector<uint8_t> decoded_spirv;
VkShaderModule vk_module;
for (int i = 0; i < shader_refl.stages_vector.size(); i++) {
PackedByteArray decoded_spirv;
const bool use_respv = RESPV_ENABLED && !shader_container_format.get_debug_info_enabled();
const bool store_respv = use_respv && !shader_refl.specialization_constants.is_empty();
const int64_t stage_count = shader_refl.stages_vector.size();
shader_info.vk_stages_create_info.reserve(stage_count);
shader_info.spirv_stage_bytes.reserve(stage_count);
shader_info.original_stage_size.reserve(stage_count);
if (store_respv) {
shader_info.respv_stage_shaders.reserve(stage_count);
}
for (int i = 0; i < stage_count; i++) {
const RenderingShaderContainer::Shader &shader = p_shader_container->shaders[i];
bool requires_decompression = (shader.code_decompressed_size > 0);
if (requires_decompression) {
@@ -3878,6 +3920,31 @@ RDD::ShaderID RenderingDeviceDriverVulkan::shader_create_from_container(const Re
memcpy(decoded_spirv.ptrw(), smolv_input, decoded_spirv.size());
}
shader_info.original_stage_size.push_back(decoded_spirv.size());
if (use_respv) {
const bool inline_data = store_respv || !RESPV_ONLY_INLINE_SHADERS_WITH_SPEC_CONSTANTS;
respv::Shader respv_shader(decoded_spirv.ptr(), decoded_spirv.size(), inline_data);
if (store_respv) {
shader_info.respv_stage_shaders.push_back(respv_shader);
} else {
std::vector<uint8_t> respv_optimized_data;
if (respv::Optimizer::run(respv_shader, nullptr, 0, respv_optimized_data)) {
#if RESPV_VERBOSE
print_line(vformat("re-spirv transformed the shader from %d bytes to %d bytes.", decoded_spirv.size(), respv_optimized_data.size()));
#endif
decoded_spirv.resize(respv_optimized_data.size());
memcpy(decoded_spirv.ptrw(), respv_optimized_data.data(), respv_optimized_data.size());
} else {
#if RESPV_VERBOSE
print_line("re-spirv failed to optimize the shader.");
#endif
}
}
}
shader_info.spirv_stage_bytes.push_back(decoded_spirv);
VkShaderModuleCreateInfo shader_module_create_info = {};
shader_module_create_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
shader_module_create_info.codeSize = decoded_spirv.size();
@@ -5508,26 +5575,104 @@ RDD::PipelineID RenderingDeviceDriverVulkan::render_pipeline_create(
"Cannot create pipeline without shader module, please make sure shader modules are destroyed only after all associated pipelines are created.");
VkPipelineShaderStageCreateInfo *vk_pipeline_stages = ALLOCA_ARRAY(VkPipelineShaderStageCreateInfo, shader_info->vk_stages_create_info.size());
thread_local std::vector<uint8_t> respv_optimized_data;
thread_local LocalVector<respv::SpecConstant> respv_spec_constants;
thread_local LocalVector<VkShaderModule> respv_shader_modules;
thread_local LocalVector<VkSpecializationMapEntry> specialization_entries;
#if RECORD_PIPELINE_STATISTICS
thread_local LocalVector<uint64_t> respv_run_time;
thread_local LocalVector<uint64_t> respv_size;
uint32_t stage_count = shader_info->vk_stages_create_info.size();
respv_run_time.clear();
respv_size.clear();
respv_run_time.resize_initialized(stage_count);
respv_size.resize_initialized(stage_count);
#endif
respv_shader_modules.clear();
specialization_entries.clear();
for (uint32_t i = 0; i < shader_info->vk_stages_create_info.size(); i++) {
vk_pipeline_stages[i] = shader_info->vk_stages_create_info[i];
if (p_specialization_constants.size()) {
VkSpecializationMapEntry *specialization_map_entries = ALLOCA_ARRAY(VkSpecializationMapEntry, p_specialization_constants.size());
for (uint32_t j = 0; j < p_specialization_constants.size(); j++) {
specialization_map_entries[j] = {};
specialization_map_entries[j].constantID = p_specialization_constants[j].constant_id;
specialization_map_entries[j].offset = (const char *)&p_specialization_constants[j].int_value - (const char *)p_specialization_constants.ptr();
specialization_map_entries[j].size = sizeof(uint32_t);
bool use_pipeline_spec_constants = true;
if ((i < shader_info->respv_stage_shaders.size()) && !shader_info->respv_stage_shaders[i].empty()) {
#if RECORD_PIPELINE_STATISTICS
uint64_t respv_start_time = OS::get_singleton()->get_ticks_usec();
#endif
// Attempt to optimize the shader using re-spirv before relying on the driver.
respv_spec_constants.resize(p_specialization_constants.size());
for (uint32_t j = 0; j < p_specialization_constants.size(); j++) {
respv_spec_constants[j].specId = p_specialization_constants[j].constant_id;
respv_spec_constants[j].values.resize(1);
respv_spec_constants[j].values[0] = p_specialization_constants[j].int_value;
}
respv::Options respv_options;
#if RESPV_DONT_REMOVE_DEAD_CODE
respv_options.removeDeadCode = false;
#endif
if (respv::Optimizer::run(shader_info->respv_stage_shaders[i], respv_spec_constants.ptr(), respv_spec_constants.size(), respv_optimized_data, respv_options)) {
#if RESPV_VERBOSE
String spec_constants;
for (uint32_t j = 0; j < p_specialization_constants.size(); j++) {
spec_constants += vformat("%d: %d", p_specialization_constants[j].constant_id, p_specialization_constants[j].int_value);
if (j < p_specialization_constants.size() - 1) {
spec_constants += ", ";
}
}
print_line(vformat("re-spirv transformed the shader from %d bytes to %d bytes with constants %s (%d).", shader_info->spirv_stage_bytes[i].size(), respv_optimized_data.size(), spec_constants, p_shader.id));
#endif
// Create the shader module with the optimized output.
VkShaderModule shader_module = VK_NULL_HANDLE;
VkShaderModuleCreateInfo shader_module_create_info = {};
shader_module_create_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
shader_module_create_info.pCode = (const uint32_t *)(respv_optimized_data.data());
shader_module_create_info.codeSize = respv_optimized_data.size();
VkResult err = vkCreateShaderModule(vk_device, &shader_module_create_info, VKC::get_allocation_callbacks(VK_OBJECT_TYPE_SHADER_MODULE), &shader_module);
if (err == VK_SUCCESS) {
// Replace the module used in the creation info.
vk_pipeline_stages[i].module = shader_module;
respv_shader_modules.push_back(shader_module);
use_pipeline_spec_constants = false;
}
#if RECORD_PIPELINE_STATISTICS
respv_run_time[i] = OS::get_singleton()->get_ticks_usec() - respv_start_time;
respv_size[i] = respv_optimized_data.size();
#endif
} else {
#if RESPV_VERBOSE
print_line("re-spirv failed to optimize the shader.");
#endif
}
}
VkSpecializationInfo *specialization_info = ALLOCA_SINGLE(VkSpecializationInfo);
*specialization_info = {};
specialization_info->dataSize = p_specialization_constants.size() * sizeof(PipelineSpecializationConstant);
specialization_info->pData = p_specialization_constants.ptr();
specialization_info->mapEntryCount = p_specialization_constants.size();
specialization_info->pMapEntries = specialization_map_entries;
if (use_pipeline_spec_constants) {
// Use specialization constants through the driver.
if (specialization_entries.is_empty()) {
specialization_entries.resize(p_specialization_constants.size());
for (uint32_t j = 0; j < p_specialization_constants.size(); j++) {
specialization_entries[j] = {};
specialization_entries[j].constantID = p_specialization_constants[j].constant_id;
specialization_entries[j].offset = (const char *)&p_specialization_constants[j].int_value - (const char *)p_specialization_constants.ptr();
specialization_entries[j].size = sizeof(uint32_t);
}
}
vk_pipeline_stages[i].pSpecializationInfo = specialization_info;
VkSpecializationInfo *specialization_info = ALLOCA_SINGLE(VkSpecializationInfo);
*specialization_info = {};
specialization_info->dataSize = p_specialization_constants.size() * sizeof(PipelineSpecializationConstant);
specialization_info->pData = p_specialization_constants.ptr();
specialization_info->mapEntryCount = specialization_entries.size();
specialization_info->pMapEntries = specialization_entries.ptr();
vk_pipeline_stages[i].pSpecializationInfo = specialization_info;
}
}
}
@@ -5546,12 +5691,41 @@ RDD::PipelineID RenderingDeviceDriverVulkan::render_pipeline_create(
pipeline_create_info.renderPass = render_pass->vk_render_pass;
pipeline_create_info.subpass = p_render_subpass;
// ---
#if RECORD_PIPELINE_STATISTICS
uint64_t pipeline_start_time = OS::get_singleton()->get_ticks_usec();
#endif
VkPipeline vk_pipeline = VK_NULL_HANDLE;
VkResult err = vkCreateGraphicsPipelines(vk_device, pipelines_cache.vk_cache, 1, &pipeline_create_info, VKC::get_allocation_callbacks(VK_OBJECT_TYPE_PIPELINE), &vk_pipeline);
ERR_FAIL_COND_V_MSG(err, PipelineID(), "vkCreateGraphicsPipelines failed with error " + itos(err) + ".");
#if RECORD_PIPELINE_STATISTICS
{
MutexLock lock(pipeline_statistics.file_access_mutex);
uint64_t pipeline_creation_time = OS::get_singleton()->get_ticks_usec() - pipeline_start_time;
for (uint32_t i = 0; i < shader_info->vk_stages_create_info.size(); i++) {
PackedStringArray csv_array = {
shader_info->name,
String::num_uint64(hash_murmur3_buffer(shader_info->spirv_stage_bytes[i].ptr(), shader_info->spirv_stage_bytes[i].size())),
String::num_uint64(i),
String::num_uint64(respv_size[i] > 0),
String::num_uint64(shader_info->original_stage_size[i]),
String::num_uint64(respv_size[i] > 0 ? respv_size[i] : shader_info->spirv_stage_bytes[i].size()),
String::num_uint64(respv_run_time[i] + pipeline_creation_time)
};
pipeline_statistics.file_access->store_csv_line(csv_array);
}
pipeline_statistics.file_access->flush();
}
#endif
// Destroy any modules created temporarily by re-spirv.
for (VkShaderModule vk_module : respv_shader_modules) {
vkDestroyShaderModule(vk_device, vk_module, VKC::get_allocation_callbacks(VK_OBJECT_TYPE_SHADER_MODULE));
}
return PipelineID(vk_pipeline);
}

12
drivers/vulkan/rendering_device_driver_vulkan.h
View File

@@ -41,6 +41,7 @@
#define _DEBUG
#endif
#endif
#include "thirdparty/re-spirv/re-spirv.h"
#include "thirdparty/vulkan/vk_mem_alloc.h"
#include "drivers/vulkan/godot_vulkan.h"
@@ -156,6 +157,13 @@ class RenderingDeviceDriverVulkan : public RenderingDeviceDriver {
PendingFlushes pending_flushes;
struct PipelineStatistics {
Ref<FileAccess> file_access;
Mutex file_access_mutex;
};
PipelineStatistics pipeline_statistics;
void _register_requested_device_extension(const CharString &p_extension_name, bool p_required);
Error _initialize_device_extensions();
Error _check_device_features();
@@ -437,9 +445,13 @@ public:
/****************/
private:
struct ShaderInfo {
String name;
VkShaderStageFlags vk_push_constant_stages = 0;
TightLocalVector<VkPipelineShaderStageCreateInfo> vk_stages_create_info;
TightLocalVector<VkDescriptorSetLayout> vk_descriptor_set_layouts;
TightLocalVector<respv::Shader> respv_stage_shaders;
TightLocalVector<Vector<uint8_t>> spirv_stage_bytes;
TightLocalVector<uint64_t> original_stage_size;
VkPipelineLayout vk_pipeline_layout = VK_NULL_HANDLE;
};

4
drivers/vulkan/rendering_shader_container_vulkan.cpp
View File

@@ -108,6 +108,10 @@ void RenderingShaderContainerFormatVulkan::set_debug_info_enabled(bool p_debug_i
debug_info_enabled = p_debug_info_enabled;
}
bool RenderingShaderContainerFormatVulkan::get_debug_info_enabled() const {
return debug_info_enabled;
}
RenderingShaderContainerFormatVulkan::RenderingShaderContainerFormatVulkan() {}
RenderingShaderContainerFormatVulkan::~RenderingShaderContainerFormatVulkan() {}

1
drivers/vulkan/rendering_shader_container_vulkan.h
View File

@@ -62,6 +62,7 @@ public:
virtual ShaderLanguageVersion get_shader_language_version() const override;
virtual ShaderSpirvVersion get_shader_spirv_version() const override;
void set_debug_info_enabled(bool p_debug_info_enabled);
bool get_debug_info_enabled() const;
RenderingShaderContainerFormatVulkan();
virtual ~RenderingShaderContainerFormatVulkan();
};