/* Copyright (c) 2020-2024 The Khronos Group Inc. * Copyright (c) 2020-2024 Valve Corporation * Copyright (c) 2020-2024 LunarG, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "gpu/instrumentation/gpu_shader_instrumentor.h" #include "gpu/core/gpu_state_tracker.h" #include "gpu/spirv/module.h" #include "chassis/chassis_modification_state.h" #include "gpu/shaders/gpu_error_codes.h" #include "spirv-tools/optimizer.hpp" #include "utils/vk_layer_utils.h" #include "state_tracker/descriptor_sets.h" #include <cassert> #include <regex> #include <fstream> namespace gpu { // Trampolines to make VMA call Dispatch for Vulkan calls static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL gpuVkGetInstanceProcAddr(VkInstance inst, const char *name) { … } static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL gpuVkGetDeviceProcAddr(VkDevice dev, const char *name) { … } static VKAPI_ATTR void VKAPI_CALL gpuVkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties) { … } static VKAPI_ATTR void VKAPI_CALL gpuVkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties) { … } static VKAPI_ATTR VkResult VKAPI_CALL gpuVkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory) { … } static VKAPI_ATTR void VKAPI_CALL gpuVkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator) { … } static VKAPI_ATTR VkResult VKAPI_CALL gpuVkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData) { … } static VKAPI_ATTR void VKAPI_CALL gpuVkUnmapMemory(VkDevice device, VkDeviceMemory memory) { … } static VKAPI_ATTR VkResult VKAPI_CALL gpuVkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges) { … } static VKAPI_ATTR VkResult VKAPI_CALL gpuVkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges) { … } static VKAPI_ATTR VkResult VKAPI_CALL gpuVkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) { … } static VKAPI_ATTR VkResult VKAPI_CALL gpuVkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) { … } static VKAPI_ATTR void VKAPI_CALL gpuVkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements) { … } static VKAPI_ATTR void VKAPI_CALL gpuVkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements) { … } static VKAPI_ATTR VkResult VKAPI_CALL gpuVkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer) { … } static VKAPI_ATTR void VKAPI_CALL gpuVkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator) { … } static VKAPI_ATTR VkResult VKAPI_CALL gpuVkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage) { … } static VKAPI_ATTR void VKAPI_CALL gpuVkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) { … } static VKAPI_ATTR void VKAPI_CALL gpuVkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions) { … } static VkResult UtilInitializeVma(VkInstance instance, VkPhysicalDevice physical_device, VkDevice device, bool use_buffer_device_address, VmaAllocator *pAllocator) { … } void SpirvCache::Add(uint32_t hash, std::vector<uint32_t> spirv) { … } std::vector<uint32_t> *SpirvCache::Get(uint32_t spirv_hash) { … } ReadLockGuard GpuShaderInstrumentor::ReadLock() const { … } WriteLockGuard GpuShaderInstrumentor::WriteLock() { … } std::shared_ptr<vvl::Queue> GpuShaderInstrumentor::CreateQueue(VkQueue handle, uint32_t family_index, uint32_t queue_index, VkDeviceQueueCreateFlags flags, const VkQueueFamilyProperties &queueFamilyProperties) { … } // These are the common things required for anything that deals with shader instrumentation void GpuShaderInstrumentor::PreCallRecordCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice, const RecordObject &record_obj, vku::safe_VkDeviceCreateInfo *modified_create_info) { … } // In charge of getting things for shader instrumentation that both GPU-AV and DebugPrintF will need void GpuShaderInstrumentor::PostCreateDevice(const VkDeviceCreateInfo *pCreateInfo, const Location &loc) { … } void GpuShaderInstrumentor::Cleanup() { … } void GpuShaderInstrumentor::PreCallRecordDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator, const RecordObject &record_obj) { … } void GpuShaderInstrumentor::ReserveBindingSlot(VkPhysicalDevice physicalDevice, VkPhysicalDeviceLimits &limits, const Location &loc) { … } void GpuShaderInstrumentor::PostCallRecordGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *device_props, const RecordObject &record_obj) { … } void GpuShaderInstrumentor::PostCallRecordGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *device_props2, const RecordObject &record_obj) { … } // Just gives a warning about a possible deadlock. bool GpuShaderInstrumentor::ValidateCmdWaitEvents(VkCommandBuffer command_buffer, VkPipelineStageFlags2 src_stage_mask, const Location &loc) const { … } bool GpuShaderInstrumentor::PreCallValidateCmdWaitEvents( VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers, const ErrorObject &error_obj) const { … } bool GpuShaderInstrumentor::PreCallValidateCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfoKHR *pDependencyInfos, const ErrorObject &error_obj) const { … } bool GpuShaderInstrumentor::PreCallValidateCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfo *pDependencyInfos, const ErrorObject &error_obj) const { … } void GpuShaderInstrumentor::PreCallRecordCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout, const RecordObject &record_obj, chassis::CreatePipelineLayout &chassis_state) { … } void GpuShaderInstrumentor::PostCallRecordCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout, const RecordObject &record_obj) { … } void GpuShaderInstrumentor::PostCallRecordCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule, const RecordObject &record_obj, chassis::CreateShaderModule &chassis_state) { … } void GpuShaderInstrumentor::PreCallRecordShaderObjectInstrumentation( VkShaderCreateInfoEXT &create_info, const Location &create_info_loc, chassis::ShaderObjectInstrumentationData &instrumentation_data) { … } void GpuShaderInstrumentor::PreCallRecordCreateShadersEXT(VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkShaderEXT *pShaders, const RecordObject &record_obj, chassis::ShaderObject &chassis_state) { … } void GpuShaderInstrumentor::PostCallRecordCreateShadersEXT(VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkShaderEXT *pShaders, const RecordObject &record_obj, chassis::ShaderObject &chassis_state) { … } void GpuShaderInstrumentor::PreCallRecordDestroyShaderEXT(VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks *pAllocator, const RecordObject &record_obj) { … } void GpuShaderInstrumentor::PreCallRecordCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines, const RecordObject &record_obj, PipelineStates &pipeline_states, chassis::CreateGraphicsPipelines &chassis_state) { … } void GpuShaderInstrumentor::PreCallRecordCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines, const RecordObject &record_obj, PipelineStates &pipeline_states, chassis::CreateComputePipelines &chassis_state) { … } void GpuShaderInstrumentor::PreCallRecordCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkRayTracingPipelineCreateInfoNV *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines, const RecordObject &record_obj, PipelineStates &pipeline_states, chassis::CreateRayTracingPipelinesNV &chassis_state) { … } void GpuShaderInstrumentor::PreCallRecordCreateRayTracingPipelinesKHR( VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t count, const VkRayTracingPipelineCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines, const RecordObject &record_obj, PipelineStates &pipeline_states, chassis::CreateRayTracingPipelinesKHR &chassis_state) { … } template <typename CreateInfos, typename SafeCreateInfos> static void UtilCopyCreatePipelineFeedbackData(CreateInfos &create_info, SafeCreateInfos &safe_create_info) { … } void GpuShaderInstrumentor::PostCallRecordCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines, const RecordObject &record_obj, PipelineStates &pipeline_states, chassis::CreateGraphicsPipelines &chassis_state) { … } void GpuShaderInstrumentor::PostCallRecordCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines, const RecordObject &record_obj, PipelineStates &pipeline_states, chassis::CreateComputePipelines &chassis_state) { … } void GpuShaderInstrumentor::PostCallRecordCreateRayTracingPipelinesNV( VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkRayTracingPipelineCreateInfoNV *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines, const RecordObject &record_obj, PipelineStates &pipeline_states, chassis::CreateRayTracingPipelinesNV &chassis_state) { … } void GpuShaderInstrumentor::PostCallRecordCreateRayTracingPipelinesKHR( VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t count, const VkRayTracingPipelineCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines, const RecordObject &record_obj, PipelineStates &pipeline_states, std::shared_ptr<chassis::CreateRayTracingPipelinesKHR> chassis_state) { … } // Remove all the shader trackers associated with this destroyed pipeline. void GpuShaderInstrumentor::PreCallRecordDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator, const RecordObject &record_obj) { … } void GpuShaderInstrumentor::PreCallRecordQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence, const RecordObject &record_obj) { … } void GpuShaderInstrumentor::PreCallRecordQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2KHR *pSubmits, VkFence fence, const RecordObject &record_obj) { … } void GpuShaderInstrumentor::PreCallRecordQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence, const RecordObject &record_obj) { … } template <typename CreateInfo> VkShaderModule GetShaderModule(const CreateInfo &create_info, VkShaderStageFlagBits stage) { … } template <> VkShaderModule GetShaderModule(const VkComputePipelineCreateInfo &create_info, VkShaderStageFlagBits) { … } template <typename SafeType> void SetShaderModule(SafeType &create_info, const vku::safe_VkPipelineShaderStageCreateInfo &stage_info, VkShaderModule shader_module, uint32_t stage_ci_index) { … } template <> void SetShaderModule(vku::safe_VkComputePipelineCreateInfo &create_info, const vku::safe_VkPipelineShaderStageCreateInfo &stage_info, VkShaderModule shader_module, uint32_t stage_ci_index) { … } template <typename CreateInfo, typename StageInfo> StageInfo &GetShaderStageCI(CreateInfo &ci, VkShaderStageFlagBits stage) { … } template <> vku::safe_VkPipelineShaderStageCreateInfo &GetShaderStageCI(vku::safe_VkComputePipelineCreateInfo &ci, VkShaderStageFlagBits) { … } bool GpuShaderInstrumentor::IsSelectiveInstrumentationEnabled(const void *pNext) { … } // Instrument all SPIR-V that is sent through pipeline. This can be done in various ways // 1. VkCreateShaderModule and passed in VkShaderModule. // For this we create our own VkShaderModule with instrumented shader and manage it inside the pipeline state // 2. GPL // We Instrument each library we see, so when linking things, we can ignore those // 3. Inlined via VkPipelineShaderStageCreateInfo pNext // We just instrument the shader and update the inlined SPIR-V // 4. VK_EXT_shader_module_identifier // We will skip these as we don't know the incoming SPIR-V // Note: Shader Objects are handled in their own path as they don't use pipelines template <typename SafeCreateInfo> void GpuShaderInstrumentor::PreCallRecordPipelineCreationShaderInstrumentation( const VkAllocationCallbacks *pAllocator, vvl::Pipeline &pipeline_state, SafeCreateInfo &new_pipeline_ci, const Location &loc, chassis::ShaderInstrumentationMetadata &shader_instrumentation_metadata) { … } // Now that we have created the pipeline (and have its handle) build up the shader map for each shader we instrumented void GpuShaderInstrumentor::PostCallRecordPipelineCreationShaderInstrumentation( vvl::Pipeline &pipeline_state, chassis::ShaderInstrumentationMetadata &shader_instrumentation_metadata) { … } void GpuShaderInstrumentor::PostCallRecordPipelineCreationsRT( VkResult result, VkDeferredOperationKHR deferredOperation, const VkAllocationCallbacks *pAllocator, std::shared_ptr<chassis::CreateRayTracingPipelinesKHR> chassis_state) { … } static bool GpuValidateShader(const std::vector<uint32_t> &input, bool SetRelaxBlockLayout, bool SetScalarBlockLayout, spv_target_env target_env, std::string &error) { … } // Call the SPIR-V Optimizer to run the instrumentation pass on the shader. bool GpuShaderInstrumentor::InstrumentShader(const vvl::span<const uint32_t> &input_spirv, uint32_t unique_shader_id, bool has_bindless_descriptors, const Location &loc, std::vector<uint32_t> &out_instrumented_spirv) { … } VkDeviceAddress GpuShaderInstrumentor::GetBufferDeviceAddressHelper(VkBuffer buffer) const { … } void GpuShaderInstrumentor::InternalError(LogObjectList objlist, const Location &loc, const char *const specific_message, bool vma_fail) const { … } void GpuShaderInstrumentor::InternalWarning(LogObjectList objlist, const Location &loc, const char *const specific_message) const { … } // The lock (debug_output_mutex) is held by the caller, // because the latter has code paths that make multiple calls of this function, // and all such calls have to access the same debug reporting state to ensure consistency of output information. static std::string LookupDebugUtilsNameNoLock(const DebugReport *debug_report, const uint64_t object) { … } // Read the contents of the SPIR-V OpSource instruction and any following continuation instructions. // Split the single string into a vector of strings, one for each line, for easier processing. static void ReadOpSource(const std::vector<spirv::Instruction> &instructions, const uint32_t reported_file_id, std::vector<std::string> &opsource_lines) { … } // The task here is to search the OpSource content to find the #line directive with the // line number that is closest to, but still prior to the reported error line number and // still within the reported filename. // From this known position in the OpSource content we can add the difference between // the #line line number and the reported error line number to determine the location // in the OpSource content of the reported error line. // // Considerations: // - Look only at #line directives that specify the reported_filename since // the reported error line number refers to its location in the reported filename. // - If a #line directive does not have a filename, the file is the reported filename, or // the filename found in a prior #line directive. (This is C-preprocessor behavior) // - It is possible (e.g., inlining) for blocks of code to get shuffled out of their // original order and the #line directives are used to keep the numbering correct. This // is why we need to examine the entire contents of the source, instead of leaving early // when finding a #line line number larger than the reported error line number. // static bool GetLineAndFilename(const std::string &string, uint32_t *linenumber, std::string &filename) { … } // Generate the stage-specific part of the message. static void GenerateStageMessage(std::ostringstream &ss, uint32_t stage_id, uint32_t stage_info_0, uint32_t stage_info_1, uint32_t stage_info_2) { … } // Where we build up the error message with all the useful debug information about where the error occured std::string GpuShaderInstrumentor::GenerateDebugInfoMessage( VkCommandBuffer commandBuffer, const std::vector<spirv::Instruction> &instructions, uint32_t stage_id, uint32_t stage_info_0, uint32_t stage_info_1, uint32_t stage_info_2, uint32_t instruction_position, const gpu::GpuAssistedShaderTracker *tracker_info, VkPipelineBindPoint pipeline_bind_point, uint32_t operation_index) const { … } } // namespace gpu
Codebase Browser
chromium