| /* Copyright (c) 2018-2019 The Khronos Group Inc. |
| * Copyright (c) 2018-2019 Valve Corporation |
| * Copyright (c) 2018-2019 LunarG, Inc. |
| * Copyright (C) 2018-2019 Google 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. |
| * |
| */ |
| |
| // Allow use of STL min and max functions in Windows |
| #define NOMINMAX |
| |
| #include "chassis.h" |
| #include "core_validation.h" |
| #include "gpu_validation.h" |
| #include "shader_validation.h" |
| #include "spirv-tools/libspirv.h" |
| #include "spirv-tools/optimizer.hpp" |
| #include "spirv-tools/instrument.hpp" |
| #include <SPIRV/spirv.hpp> |
| #include <algorithm> |
| #include <regex> |
| |
| // This is the number of bindings in the debug descriptor set. |
| static const uint32_t kNumBindingsInSet = 1; |
| |
| // Implementation for Device Memory Manager class |
| GpuDeviceMemoryManager::GpuDeviceMemoryManager(layer_data *dev_data, uint32_t data_size) { |
| uint32_t align = static_cast<uint32_t>(dev_data->GetPDProperties()->limits.minStorageBufferOffsetAlignment); |
| if (0 == align) { |
| align = 1; |
| } |
| record_size_ = data_size; |
| // Round the requested size up to the next multiple of the storage buffer offset alignment |
| // so that we can address each block in the storage buffer using the offset. |
| block_size_ = ((record_size_ + align - 1) / align) * align; |
| blocks_per_chunk_ = kItemsPerChunk; |
| chunk_size_ = blocks_per_chunk_ * block_size_; |
| dev_data_ = dev_data; |
| } |
| |
| GpuDeviceMemoryManager::~GpuDeviceMemoryManager() { |
| for (auto &chunk : chunk_list_) { |
| FreeMemoryChunk(chunk); |
| } |
| chunk_list_.clear(); |
| } |
| |
| VkResult GpuDeviceMemoryManager::GetBlock(GpuDeviceMemoryBlock *block) { |
| assert(block->buffer == VK_NULL_HANDLE); // avoid possible overwrite/leak of an allocated block |
| VkResult result = VK_SUCCESS; |
| MemoryChunk *pChunk = nullptr; |
| // Look for a chunk with available offsets. |
| for (auto &chunk : chunk_list_) { |
| if (!chunk.available_offsets.empty()) { |
| pChunk = &chunk; |
| break; |
| } |
| } |
| // If no chunks with available offsets, allocate device memory and set up offsets. |
| if (pChunk == nullptr) { |
| MemoryChunk new_chunk; |
| result = AllocMemoryChunk(new_chunk); |
| if (result == VK_SUCCESS) { |
| new_chunk.available_offsets.resize(blocks_per_chunk_); |
| for (uint32_t offset = 0, i = 0; i < blocks_per_chunk_; offset += block_size_, ++i) { |
| new_chunk.available_offsets[i] = offset; |
| } |
| chunk_list_.push_front(std::move(new_chunk)); |
| pChunk = &chunk_list_.front(); |
| } else { |
| // Indicate failure |
| block->buffer = VK_NULL_HANDLE; |
| block->memory = VK_NULL_HANDLE; |
| return result; |
| } |
| } |
| // Give the requester an available offset |
| block->buffer = pChunk->buffer; |
| block->memory = pChunk->memory; |
| block->offset = pChunk->available_offsets.back(); |
| pChunk->available_offsets.pop_back(); |
| return result; |
| } |
| |
| void GpuDeviceMemoryManager::PutBackBlock(VkBuffer buffer, VkDeviceMemory memory, uint32_t offset) { |
| GpuDeviceMemoryBlock block = {buffer, memory, offset}; |
| PutBackBlock(block); |
| } |
| |
| void GpuDeviceMemoryManager::PutBackBlock(GpuDeviceMemoryBlock &block) { |
| // Find the chunk belonging to the allocated offset and make the offset available again |
| auto chunk = std::find_if(std::begin(chunk_list_), std::end(chunk_list_), |
| [&block](const MemoryChunk &c) { return c.buffer == block.buffer; }); |
| if (chunk_list_.end() == chunk) { |
| assert(false); |
| } else { |
| chunk->available_offsets.push_back(block.offset); |
| if (chunk->available_offsets.size() == blocks_per_chunk_) { |
| // All offsets have been returned |
| FreeMemoryChunk(*chunk); |
| chunk_list_.erase(chunk); |
| } |
| } |
| } |
| |
| void ResetBlock(GpuDeviceMemoryBlock &block) { |
| block.buffer = VK_NULL_HANDLE; |
| block.memory = VK_NULL_HANDLE; |
| block.offset = 0; |
| } |
| |
| bool BlockUsed(GpuDeviceMemoryBlock &block) { return (block.buffer != VK_NULL_HANDLE) && (block.memory != VK_NULL_HANDLE); } |
| |
| bool GpuDeviceMemoryManager::MemoryTypeFromProperties(uint32_t typeBits, VkFlags requirements_mask, uint32_t *typeIndex) { |
| // Search memtypes to find first index with those properties |
| const VkPhysicalDeviceMemoryProperties *props = dev_data_->GetPhysicalDeviceMemoryProperties(); |
| for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++) { |
| if ((typeBits & 1) == 1) { |
| // Type is available, does it match user properties? |
| if ((props->memoryTypes[i].propertyFlags & requirements_mask) == requirements_mask) { |
| *typeIndex = i; |
| return true; |
| } |
| } |
| typeBits >>= 1; |
| } |
| // No memory types matched, return failure |
| return false; |
| } |
| |
| VkResult GpuDeviceMemoryManager::AllocMemoryChunk(MemoryChunk &chunk) { |
| VkBuffer buffer; |
| VkDeviceMemory memory; |
| VkBufferCreateInfo buffer_create_info = {}; |
| VkMemoryRequirements mem_reqs = {}; |
| VkMemoryAllocateInfo mem_alloc = {}; |
| VkResult result = VK_SUCCESS; |
| bool pass; |
| void *pData; |
| const auto *dispatch_table = dev_data_->GetDispatchTable(); |
| |
| buffer_create_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; |
| buffer_create_info.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT; |
| buffer_create_info.size = chunk_size_; |
| result = dispatch_table->CreateBuffer(dev_data_->GetDevice(), &buffer_create_info, NULL, &buffer); |
| if (result != VK_SUCCESS) { |
| return result; |
| } |
| |
| dispatch_table->GetBufferMemoryRequirements(dev_data_->GetDevice(), buffer, &mem_reqs); |
| |
| mem_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; |
| mem_alloc.pNext = NULL; |
| mem_alloc.allocationSize = mem_reqs.size; |
| pass = MemoryTypeFromProperties(mem_reqs.memoryTypeBits, |
| VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, |
| &mem_alloc.memoryTypeIndex); |
| if (!pass) { |
| dispatch_table->DestroyBuffer(dev_data_->GetDevice(), buffer, NULL); |
| return result; |
| } |
| result = dispatch_table->AllocateMemory(dev_data_->GetDevice(), &mem_alloc, NULL, &memory); |
| if (result != VK_SUCCESS) { |
| dispatch_table->DestroyBuffer(dev_data_->GetDevice(), buffer, NULL); |
| return result; |
| } |
| |
| result = dispatch_table->BindBufferMemory(dev_data_->GetDevice(), buffer, memory, 0); |
| if (result != VK_SUCCESS) { |
| dispatch_table->DestroyBuffer(dev_data_->GetDevice(), buffer, NULL); |
| dispatch_table->FreeMemory(dev_data_->GetDevice(), memory, NULL); |
| return result; |
| } |
| |
| result = dispatch_table->MapMemory(dev_data_->GetDevice(), memory, 0, mem_alloc.allocationSize, 0, &pData); |
| if (result == VK_SUCCESS) { |
| memset(pData, 0, chunk_size_); |
| dispatch_table->UnmapMemory(dev_data_->GetDevice(), memory); |
| } else { |
| dispatch_table->DestroyBuffer(dev_data_->GetDevice(), buffer, NULL); |
| dispatch_table->FreeMemory(dev_data_->GetDevice(), memory, NULL); |
| return result; |
| } |
| chunk.buffer = buffer; |
| chunk.memory = memory; |
| return result; |
| } |
| |
| void GpuDeviceMemoryManager::FreeMemoryChunk(MemoryChunk &chunk) { |
| dev_data_->GetDispatchTable()->DestroyBuffer(dev_data_->GetDevice(), chunk.buffer, NULL); |
| dev_data_->GetDispatchTable()->FreeMemory(dev_data_->GetDevice(), chunk.memory, NULL); |
| } |
| |
| void GpuDeviceMemoryManager::FreeAllBlocks() { |
| for (auto &chunk : chunk_list_) { |
| FreeMemoryChunk(chunk); |
| } |
| chunk_list_.clear(); |
| } |
| |
| // Implementation for Descriptor Set Manager class |
| GpuDescriptorSetManager::GpuDescriptorSetManager(layer_data *dev_data) { dev_data_ = dev_data; } |
| |
| GpuDescriptorSetManager::~GpuDescriptorSetManager() { |
| for (auto &pool : desc_pool_map_) { |
| dev_data_->GetDispatchTable()->DestroyDescriptorPool(dev_data_->GetDevice(), pool.first, NULL); |
| } |
| desc_pool_map_.clear(); |
| } |
| |
| VkResult GpuDescriptorSetManager::GetDescriptorSets(uint32_t count, VkDescriptorPool *pool, |
| std::vector<VkDescriptorSet> *desc_sets) { |
| auto gpu_state = dev_data_->GetGpuValidationState(); |
| const uint32_t default_pool_size = kItemsPerChunk; |
| VkResult result = VK_SUCCESS; |
| VkDescriptorPool pool_to_use = VK_NULL_HANDLE; |
| |
| if (0 == count) { |
| return result; |
| } |
| desc_sets->clear(); |
| desc_sets->resize(count); |
| |
| for (auto &pool : desc_pool_map_) { |
| if (pool.second.used + count < pool.second.size) { |
| pool_to_use = pool.first; |
| break; |
| } |
| } |
| if (VK_NULL_HANDLE == pool_to_use) { |
| uint32_t pool_count = default_pool_size; |
| if (count > default_pool_size) { |
| pool_count = count; |
| } |
| const VkDescriptorPoolSize size_counts = { |
| VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, |
| pool_count * kNumBindingsInSet, |
| }; |
| VkDescriptorPoolCreateInfo desc_pool_info = {}; |
| desc_pool_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; |
| desc_pool_info.pNext = NULL; |
| desc_pool_info.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT; |
| desc_pool_info.maxSets = pool_count; |
| desc_pool_info.poolSizeCount = 1; |
| desc_pool_info.pPoolSizes = &size_counts; |
| result = dev_data_->GetDispatchTable()->CreateDescriptorPool(dev_data_->GetDevice(), &desc_pool_info, NULL, &pool_to_use); |
| assert(result == VK_SUCCESS); |
| if (result != VK_SUCCESS) { |
| return result; |
| } |
| desc_pool_map_[pool_to_use].size = desc_pool_info.maxSets; |
| desc_pool_map_[pool_to_use].used = 0; |
| } |
| std::vector<VkDescriptorSetLayout> desc_layouts(count, gpu_state->debug_desc_layout); |
| |
| VkDescriptorSetAllocateInfo alloc_info = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, NULL, pool_to_use, count, |
| desc_layouts.data()}; |
| |
| result = dev_data_->GetDispatchTable()->AllocateDescriptorSets(dev_data_->GetDevice(), &alloc_info, desc_sets->data()); |
| assert(result == VK_SUCCESS); |
| if (result != VK_SUCCESS) { |
| return result; |
| } |
| *pool = pool_to_use; |
| desc_pool_map_[pool_to_use].used += count; |
| return result; |
| } |
| |
| void GpuDescriptorSetManager::PutBackDescriptorSet(VkDescriptorPool desc_pool, VkDescriptorSet desc_set) { |
| auto iter = desc_pool_map_.find(desc_pool); |
| if (iter != desc_pool_map_.end()) { |
| VkResult result = dev_data_->GetDispatchTable()->FreeDescriptorSets(dev_data_->GetDevice(), desc_pool, 1, &desc_set); |
| assert(result == VK_SUCCESS); |
| if (result != VK_SUCCESS) { |
| return; |
| } |
| desc_pool_map_[desc_pool].used--; |
| if (0 == desc_pool_map_[desc_pool].used) { |
| dev_data_->GetDispatchTable()->DestroyDescriptorPool(dev_data_->GetDevice(), desc_pool, NULL); |
| desc_pool_map_.erase(desc_pool); |
| } |
| } |
| return; |
| } |
| |
| void GpuDescriptorSetManager::DestroyDescriptorPools() { |
| for (auto &pool : desc_pool_map_) { |
| dev_data_->GetDispatchTable()->DestroyDescriptorPool(dev_data_->GetDevice(), pool.first, NULL); |
| } |
| desc_pool_map_.clear(); |
| } |
| |
| // Convenience function for reporting problems with setting up GPU Validation. |
| void CoreChecks::ReportSetupProblem(const layer_data *dev_data, VkDebugReportObjectTypeEXT object_type, uint64_t object_handle, |
| const char *const specific_message) { |
| log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle, "UNASSIGNED-GPU-Assisted Validation Error. ", |
| "Detail: (%s)", specific_message); |
| } |
| |
| // Turn on necessary device features. |
| void CoreChecks::GpuPreCallRecordCreateDevice(VkPhysicalDevice gpu, std::unique_ptr<safe_VkDeviceCreateInfo> &create_info, |
| VkPhysicalDeviceFeatures *supported_features) { |
| if (supported_features->fragmentStoresAndAtomics || supported_features->vertexPipelineStoresAndAtomics) { |
| VkPhysicalDeviceFeatures new_features = {}; |
| if (create_info->pEnabledFeatures) { |
| new_features = *create_info->pEnabledFeatures; |
| } |
| new_features.fragmentStoresAndAtomics = supported_features->fragmentStoresAndAtomics; |
| new_features.vertexPipelineStoresAndAtomics = supported_features->vertexPipelineStoresAndAtomics; |
| delete create_info->pEnabledFeatures; |
| create_info->pEnabledFeatures = new VkPhysicalDeviceFeatures(new_features); |
| } |
| } |
| |
| // Perform initializations that can be done at Create Device time. |
| void CoreChecks::GpuPostCallRecordCreateDevice(layer_data *dev_data) { |
| auto gpu_state = GetGpuValidationState(); |
| const auto *dispatch_table = GetDispatchTable(); |
| |
| gpu_state->aborted = false; |
| gpu_state->reserve_binding_slot = false; |
| gpu_state->barrier_command_pool = VK_NULL_HANDLE; |
| gpu_state->barrier_command_buffer = VK_NULL_HANDLE; |
| |
| if (GetPDProperties()->apiVersion < VK_API_VERSION_1_1) { |
| ReportSetupProblem(dev_data, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, HandleToUint64(GetDevice()), |
| "GPU-Assisted validation requires Vulkan 1.1 or later. GPU-Assisted Validation disabled."); |
| gpu_state->aborted = true; |
| return; |
| } |
| // Some devices have extremely high limits here, so set a reasonable max because we have to pad |
| // the pipeline layout with dummy descriptor set layouts. |
| gpu_state->adjusted_max_desc_sets = GetPDProperties()->limits.maxBoundDescriptorSets; |
| gpu_state->adjusted_max_desc_sets = std::min(33U, gpu_state->adjusted_max_desc_sets); |
| |
| // We can't do anything if there is only one. |
| // Device probably not a legit Vulkan device, since there should be at least 4. Protect ourselves. |
| if (gpu_state->adjusted_max_desc_sets == 1) { |
| ReportSetupProblem(dev_data, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, HandleToUint64(GetDevice()), |
| "Device can bind only a single descriptor set. GPU-Assisted Validation disabled."); |
| gpu_state->aborted = true; |
| return; |
| } |
| gpu_state->desc_set_bind_index = gpu_state->adjusted_max_desc_sets - 1; |
| log_msg(GetReportData(), VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, |
| HandleToUint64(GetDevice()), "UNASSIGNED-GPU-Assisted Validation. ", "Shaders using descriptor set at index %d. ", |
| gpu_state->desc_set_bind_index); |
| |
| std::unique_ptr<GpuDeviceMemoryManager> memory_manager( |
| new GpuDeviceMemoryManager(dev_data, sizeof(uint32_t) * (spvtools::kInstMaxOutCnt + 1))); |
| std::unique_ptr<GpuDescriptorSetManager> desc_set_manager(new GpuDescriptorSetManager(dev_data)); |
| |
| // The descriptor indexing checks require only the first "output" binding. |
| const VkDescriptorSetLayoutBinding debug_desc_layout_bindings[kNumBindingsInSet] = { |
| { |
| 0, // output |
| VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, |
| 1, |
| VK_SHADER_STAGE_ALL_GRAPHICS, |
| NULL, |
| }, |
| }; |
| |
| const VkDescriptorSetLayoutCreateInfo debug_desc_layout_info = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, NULL, 0, |
| kNumBindingsInSet, debug_desc_layout_bindings}; |
| |
| const VkDescriptorSetLayoutCreateInfo dummy_desc_layout_info = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, NULL, 0, 0, |
| NULL}; |
| |
| VkResult result = |
| dispatch_table->CreateDescriptorSetLayout(GetDevice(), &debug_desc_layout_info, NULL, &gpu_state->debug_desc_layout); |
| |
| // This is a layout used to "pad" a pipeline layout to fill in any gaps to the selected bind index. |
| VkResult result2 = |
| dispatch_table->CreateDescriptorSetLayout(GetDevice(), &dummy_desc_layout_info, NULL, &gpu_state->dummy_desc_layout); |
| assert((result == VK_SUCCESS) && (result2 == VK_SUCCESS)); |
| if ((result != VK_SUCCESS) || (result2 != VK_SUCCESS)) { |
| ReportSetupProblem(dev_data, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, HandleToUint64(GetDevice()), |
| "Unable to create descriptor set layout. GPU-Assisted Validation disabled."); |
| if (result == VK_SUCCESS) { |
| dispatch_table->DestroyDescriptorSetLayout(GetDevice(), gpu_state->debug_desc_layout, NULL); |
| } |
| if (result2 == VK_SUCCESS) { |
| dispatch_table->DestroyDescriptorSetLayout(GetDevice(), gpu_state->dummy_desc_layout, NULL); |
| } |
| gpu_state->debug_desc_layout = VK_NULL_HANDLE; |
| gpu_state->dummy_desc_layout = VK_NULL_HANDLE; |
| gpu_state->aborted = true; |
| return; |
| } |
| gpu_state->memory_manager = std::move(memory_manager); |
| gpu_state->desc_set_manager = std::move(desc_set_manager); |
| } |
| |
| // Clean up device-related resources |
| void CoreChecks::GpuPreCallRecordDestroyDevice(layer_data *dev_data) { |
| auto gpu_state = GetGpuValidationState(); |
| |
| if (gpu_state->barrier_command_buffer) { |
| GetDispatchTable()->FreeCommandBuffers(GetDevice(), gpu_state->barrier_command_pool, 1, &gpu_state->barrier_command_buffer); |
| gpu_state->barrier_command_buffer = VK_NULL_HANDLE; |
| } |
| if (gpu_state->barrier_command_pool) { |
| GetDispatchTable()->DestroyCommandPool(GetDevice(), gpu_state->barrier_command_pool, NULL); |
| gpu_state->barrier_command_pool = VK_NULL_HANDLE; |
| } |
| if (gpu_state->debug_desc_layout) { |
| GetDispatchTable()->DestroyDescriptorSetLayout(GetDevice(), gpu_state->debug_desc_layout, NULL); |
| gpu_state->debug_desc_layout = VK_NULL_HANDLE; |
| } |
| if (gpu_state->dummy_desc_layout) { |
| GetDispatchTable()->DestroyDescriptorSetLayout(GetDevice(), gpu_state->dummy_desc_layout, NULL); |
| gpu_state->dummy_desc_layout = VK_NULL_HANDLE; |
| } |
| gpu_state->memory_manager->FreeAllBlocks(); |
| gpu_state->desc_set_manager->DestroyDescriptorPools(); |
| } |
| |
| // Modify the pipeline layout to include our debug descriptor set and any needed padding with the dummy descriptor set. |
| bool CoreChecks::GpuPreCallCreatePipelineLayout(layer_data *device_data, const VkPipelineLayoutCreateInfo *pCreateInfo, |
| const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout, |
| std::vector<VkDescriptorSetLayout> *new_layouts, |
| VkPipelineLayoutCreateInfo *modified_create_info) { |
| auto gpu_state = GetGpuValidationState(); |
| if (gpu_state->aborted) { |
| return false; |
| } |
| |
| if (modified_create_info->setLayoutCount >= gpu_state->adjusted_max_desc_sets) { |
| std::ostringstream strm; |
| strm << "Pipeline Layout conflict with validation's descriptor set at slot " << gpu_state->desc_set_bind_index << ". " |
| << "Application has too many descriptor sets in the pipeline layout to continue with gpu validation. " |
| << "Validation is not modifying the pipeline layout. " |
| << "Instrumented shaders are replaced with non-instrumented shaders."; |
| ReportSetupProblem(device_data, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, HandleToUint64(GetDevice()), strm.str().c_str()); |
| } else { |
| // Modify the pipeline layout by: |
| // 1. Copying the caller's descriptor set desc_layouts |
| // 2. Fill in dummy descriptor layouts up to the max binding |
| // 3. Fill in with the debug descriptor layout at the max binding slot |
| new_layouts->reserve(gpu_state->adjusted_max_desc_sets); |
| new_layouts->insert(new_layouts->end(), &pCreateInfo->pSetLayouts[0], |
| &pCreateInfo->pSetLayouts[pCreateInfo->setLayoutCount]); |
| for (uint32_t i = pCreateInfo->setLayoutCount; i < gpu_state->adjusted_max_desc_sets - 1; ++i) { |
| new_layouts->push_back(gpu_state->dummy_desc_layout); |
| } |
| new_layouts->push_back(gpu_state->debug_desc_layout); |
| modified_create_info->pSetLayouts = new_layouts->data(); |
| modified_create_info->setLayoutCount = gpu_state->adjusted_max_desc_sets; |
| } |
| return true; |
| } |
| |
| // Clean up GPU validation after the CreatePipelineLayout call is made |
| void CoreChecks::GpuPostCallCreatePipelineLayout(layer_data *device_data, VkResult result) { |
| auto gpu_state = GetGpuValidationState(); |
| // Clean up GPU validation |
| if (result != VK_SUCCESS) { |
| ReportSetupProblem(device_data, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, HandleToUint64(GetDevice()), |
| "Unable to create pipeline layout. Device could become unstable."); |
| gpu_state->aborted = true; |
| } |
| } |
| |
| // Free the device memory and descriptor set associated with a command buffer. |
| void CoreChecks::GpuPreCallRecordFreeCommandBuffers(layer_data *dev_data, uint32_t commandBufferCount, |
| const VkCommandBuffer *pCommandBuffers) { |
| auto gpu_state = GetGpuValidationState(); |
| if (gpu_state->aborted) { |
| return; |
| } |
| for (uint32_t i = 0; i < commandBufferCount; ++i) { |
| auto cb_node = GetCBNode(pCommandBuffers[i]); |
| if (cb_node) { |
| for (auto &buffer_info : cb_node->gpu_buffer_list) { |
| if (BlockUsed(buffer_info.mem_block)) { |
| gpu_state->memory_manager->PutBackBlock(buffer_info.mem_block); |
| ResetBlock(buffer_info.mem_block); |
| } |
| if (buffer_info.desc_set != VK_NULL_HANDLE) { |
| gpu_state->desc_set_manager->PutBackDescriptorSet(buffer_info.desc_pool, buffer_info.desc_set); |
| } |
| } |
| cb_node->gpu_buffer_list.clear(); |
| } |
| } |
| } |
| |
| // Just gives a warning about a possible deadlock. |
| void CoreChecks::GpuPreCallValidateCmdWaitEvents(layer_data *dev_data, VkPipelineStageFlags sourceStageMask) { |
| if (sourceStageMask & VK_PIPELINE_STAGE_HOST_BIT) { |
| ReportSetupProblem(dev_data, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, HandleToUint64(GetDevice()), |
| "CmdWaitEvents recorded with VK_PIPELINE_STAGE_HOST_BIT set. " |
| "GPU_Assisted validation waits on queue completion. " |
| "This wait could block the host's signaling of this event, resulting in deadlock."); |
| } |
| } |
| |
| // Examine the pipelines to see if they use the debug descriptor set binding index. |
| // If any do, create new non-instrumented shader modules and use them to replace the instrumented |
| // shaders in the pipeline. Return the (possibly) modified create infos to the caller. |
| std::vector<safe_VkGraphicsPipelineCreateInfo> CoreChecks::GpuPreCallRecordCreateGraphicsPipelines( |
| layer_data *dev_data, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo *pCreateInfos, |
| const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines, std::vector<std::unique_ptr<PIPELINE_STATE>> &pipe_state) { |
| auto gpu_state = GetGpuValidationState(); |
| |
| std::vector<safe_VkGraphicsPipelineCreateInfo> new_pipeline_create_infos; |
| std::vector<unsigned int> pipeline_uses_debug_index(count); |
| |
| // Walk through all the pipelines, make a copy of each and flag each pipeline that contains a shader that uses the debug |
| // descriptor set index. |
| for (uint32_t pipeline = 0; pipeline < count; ++pipeline) { |
| new_pipeline_create_infos.push_back(pipe_state[pipeline]->graphicsPipelineCI); |
| if (pipe_state[pipeline]->active_slots.find(gpu_state->desc_set_bind_index) != pipe_state[pipeline]->active_slots.end()) { |
| pipeline_uses_debug_index[pipeline] = 1; |
| } |
| } |
| |
| // See if any pipeline has shaders using the debug descriptor set index |
| if (std::all_of(pipeline_uses_debug_index.begin(), pipeline_uses_debug_index.end(), [](unsigned int i) { return i == 0; })) { |
| // None of the shaders in all the pipelines use the debug descriptor set index, so use the pipelines |
| // as they stand with the instrumented shaders. |
| return new_pipeline_create_infos; |
| } |
| |
| // At least one pipeline has a shader that uses the debug descriptor set index. |
| for (uint32_t pipeline = 0; pipeline < count; ++pipeline) { |
| if (pipeline_uses_debug_index[pipeline]) { |
| for (uint32_t stage = 0; stage < pCreateInfos[pipeline].stageCount; ++stage) { |
| const shader_module *shader = GetShaderModuleState(pCreateInfos[pipeline].pStages[stage].module); |
| VkShaderModuleCreateInfo create_info = {}; |
| VkShaderModule shader_module; |
| create_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; |
| create_info.pCode = shader->words.data(); |
| create_info.codeSize = shader->words.size() * sizeof(uint32_t); |
| VkResult result = GetDispatchTable()->CreateShaderModule(GetDevice(), &create_info, pAllocator, &shader_module); |
| if (result == VK_SUCCESS) { |
| new_pipeline_create_infos[pipeline].pStages[stage].module = shader_module; |
| } else { |
| ReportSetupProblem(dev_data, VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT, |
| HandleToUint64(pCreateInfos[pipeline].pStages[stage].module), |
| "Unable to replace instrumented shader with non-instrumented one. " |
| "Device could become unstable."); |
| } |
| } |
| } |
| } |
| return new_pipeline_create_infos; |
| } |
| |
| // For every pipeline: |
| // - For every shader in a pipeline: |
| // - If the shader had to be replaced in PreCallRecord (because the pipeline is using the debug desc set index): |
| // - Destroy it since it has been bound into the pipeline by now. This is our only chance to delete it. |
| // - Track the shader in the shader_map |
| // - Save the shader binary if it contains debug code |
| void CoreChecks::GpuPostCallRecordCreateGraphicsPipelines(layer_data *dev_data, const uint32_t count, |
| const VkGraphicsPipelineCreateInfo *pCreateInfos, |
| const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) { |
| auto gpu_state = GetGpuValidationState(); |
| for (uint32_t pipeline = 0; pipeline < count; ++pipeline) { |
| auto pipeline_state = GetPipelineState(pPipelines[pipeline]); |
| if (nullptr == pipeline_state) continue; |
| for (uint32_t stage = 0; stage < pipeline_state->graphicsPipelineCI.stageCount; ++stage) { |
| if (pipeline_state->active_slots.find(gpu_state->desc_set_bind_index) != pipeline_state->active_slots.end()) { |
| GetDispatchTable()->DestroyShaderModule(GetDevice(), pCreateInfos->pStages[stage].module, pAllocator); |
| } |
| auto shader_state = GetShaderModuleState(pipeline_state->graphicsPipelineCI.pStages[stage].module); |
| std::vector<unsigned int> code; |
| // Save the shader binary if debug info is present. |
| // The core_validation ShaderModule tracker saves the binary too, but discards it when the ShaderModule |
| // is destroyed. Applications may destroy ShaderModules after they are placed in a pipeline and before |
| // the pipeline is used, so we have to keep another copy. |
| if (shader_state && shader_state->has_valid_spirv) { // really checking for presense of SPIR-V code. |
| for (auto insn : *shader_state) { |
| if (insn.opcode() == spv::OpLine) { |
| code = shader_state->words; |
| break; |
| } |
| } |
| } |
| gpu_state->shader_map[shader_state->gpu_validation_shader_id].pipeline = pipeline_state->pipeline; |
| // Be careful to use the originally bound (instrumented) shader here, even if PreCallRecord had to back it |
| // out with a non-instrumented shader. The non-instrumented shader (found in pCreateInfo) was destroyed above. |
| gpu_state->shader_map[shader_state->gpu_validation_shader_id].shader_module = |
| pipeline_state->graphicsPipelineCI.pStages[stage].module; |
| gpu_state->shader_map[shader_state->gpu_validation_shader_id].pgm = std::move(code); |
| } |
| } |
| } |
| |
| // Remove all the shader trackers associated with this destroyed pipeline. |
| void CoreChecks::GpuPreCallRecordDestroyPipeline(layer_data *dev_data, const VkPipeline pipeline) { |
| auto gpu_state = GetGpuValidationState(); |
| for (auto it = gpu_state->shader_map.begin(); it != gpu_state->shader_map.end();) { |
| if (it->second.pipeline == pipeline) { |
| it = gpu_state->shader_map.erase(it); |
| } else { |
| ++it; |
| } |
| } |
| } |
| |
| // Call the SPIR-V Optimizer to run the instrumentation pass on the shader. |
| bool CoreChecks::GpuInstrumentShader(layer_data *dev_data, const VkShaderModuleCreateInfo *pCreateInfo, |
| std::vector<unsigned int> &new_pgm, uint32_t *unique_shader_id) { |
| auto gpu_state = GetGpuValidationState(); |
| if (gpu_state->aborted) return false; |
| if (pCreateInfo->pCode[0] != spv::MagicNumber) return false; |
| |
| // Load original shader SPIR-V |
| uint32_t num_words = static_cast<uint32_t>(pCreateInfo->codeSize / 4); |
| new_pgm.clear(); |
| new_pgm.reserve(num_words); |
| new_pgm.insert(new_pgm.end(), &pCreateInfo->pCode[0], &pCreateInfo->pCode[num_words]); |
| |
| // Call the optimizer to instrument the shader. |
| // Use the unique_shader_module_id as a shader ID so we can look up its handle later in the shader_map. |
| using namespace spvtools; |
| spv_target_env target_env = SPV_ENV_VULKAN_1_1; |
| Optimizer optimizer(target_env); |
| optimizer.RegisterPass(CreateInstBindlessCheckPass(gpu_state->desc_set_bind_index, gpu_state->unique_shader_module_id)); |
| optimizer.RegisterPass(CreateAggressiveDCEPass()); |
| bool pass = optimizer.Run(new_pgm.data(), new_pgm.size(), &new_pgm); |
| if (!pass) { |
| ReportSetupProblem(dev_data, VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT, VK_NULL_HANDLE, |
| "Failure to instrument shader. Proceeding with non-instrumented shader."); |
| } |
| *unique_shader_id = gpu_state->unique_shader_module_id++; |
| return pass; |
| } |
| |
| // Create the instrumented shader data to provide to the driver. |
| bool CoreChecks::GpuPreCallCreateShaderModule(layer_data *dev_data, const VkShaderModuleCreateInfo *pCreateInfo, |
| const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule, |
| uint32_t *unique_shader_id, VkShaderModuleCreateInfo *instrumented_create_info, |
| std::vector<unsigned int> *instrumented_pgm) { |
| bool pass = GpuInstrumentShader(dev_data, pCreateInfo, *instrumented_pgm, unique_shader_id); |
| if (pass) { |
| instrumented_create_info->pCode = instrumented_pgm->data(); |
| instrumented_create_info->codeSize = instrumented_pgm->size() * sizeof(unsigned int); |
| } |
| return pass; |
| } |
| |
| // Generate the stage-specific part of the message. |
| static void GenerateStageMessage(const uint32_t *debug_record, std::string &msg) { |
| using namespace spvtools; |
| std::ostringstream strm; |
| switch (debug_record[kInstCommonOutStageIdx]) { |
| case 0: { |
| strm << "Stage = Vertex. Vertex Index = " << debug_record[kInstVertOutVertexIndex] |
| << " Instance Index = " << debug_record[kInstVertOutInstanceIndex] << ". "; |
| } break; |
| case 1: { |
| strm << "Stage = Tessellation Control. Invocation ID = " << debug_record[kInstTessOutInvocationId] << ". "; |
| } break; |
| case 2: { |
| strm << "Stage = Tessellation Eval. Invocation ID = " << debug_record[kInstTessOutInvocationId] << ". "; |
| } break; |
| case 3: { |
| strm << "Stage = Geometry. Primitive ID = " << debug_record[kInstGeomOutPrimitiveId] |
| << " Invocation ID = " << debug_record[kInstGeomOutInvocationId] << ". "; |
| } break; |
| case 4: { |
| strm << "Stage = Fragment. Fragment coord (x,y) = (" |
| << *reinterpret_cast<const float *>(&debug_record[kInstFragOutFragCoordX]) << ", " |
| << *reinterpret_cast<const float *>(&debug_record[kInstFragOutFragCoordY]) << "). "; |
| } break; |
| case 5: { |
| strm << "Stage = Compute. Global invocation ID = " << debug_record[kInstCompOutGlobalInvocationId] << ". "; |
| } break; |
| default: { |
| strm << "Internal Error (unexpected stage = " << debug_record[kInstCommonOutStageIdx] << "). "; |
| assert(false); |
| } break; |
| } |
| msg = strm.str(); |
| } |
| |
| // Generate the part of the message describing the violation. |
| static void GenerateValidationMessage(const uint32_t *debug_record, std::string &msg, std::string &vuid_msg) { |
| using namespace spvtools; |
| std::ostringstream strm; |
| switch (debug_record[kInstValidationOutError]) { |
| case 0: { |
| strm << "Index of " << debug_record[kInstBindlessOutDescIndex] << " used to index descriptor array of length " |
| << debug_record[kInstBindlessOutDescBound] << ". "; |
| vuid_msg = "UNASSIGNED-Descriptor index out of bounds"; |
| } break; |
| case 1: { |
| strm << "Descriptor index " << debug_record[kInstBindlessOutDescIndex] << " is uninitialized. "; |
| vuid_msg = "UNASSIGNED-Descriptor uninitialized"; |
| } break; |
| default: { |
| strm << "Internal Error (unexpected error type = " << debug_record[kInstValidationOutError] << "). "; |
| vuid_msg = "UNASSIGNED-Internal Error"; |
| assert(false); |
| } break; |
| } |
| msg = strm.str(); |
| } |
| |
| static std::string LookupDebugUtilsName(const debug_report_data *report_data, const uint64_t object) { |
| auto object_label = report_data->DebugReportGetUtilsObjectName(object); |
| if (object_label != "") { |
| object_label = "(" + object_label + ")"; |
| } |
| return object_label; |
| } |
| |
| // Generate message from the common portion of the debug report record. |
| static void GenerateCommonMessage(const debug_report_data *report_data, const GLOBAL_CB_NODE *cb_node, const uint32_t *debug_record, |
| const VkShaderModule shader_module_handle, const VkPipeline pipeline_handle, |
| const uint32_t draw_index, std::string &msg) { |
| using namespace spvtools; |
| std::ostringstream strm; |
| if (shader_module_handle == VK_NULL_HANDLE) { |
| strm << std::hex << std::showbase << "Internal Error: Unable to locate information for shader used in command buffer " |
| << LookupDebugUtilsName(report_data, HandleToUint64(cb_node->commandBuffer)) << "(" |
| << HandleToUint64(cb_node->commandBuffer) << "). "; |
| assert(true); |
| } else { |
| strm << std::hex << std::showbase << "Command buffer " |
| << LookupDebugUtilsName(report_data, HandleToUint64(cb_node->commandBuffer)) << "(" |
| << HandleToUint64(cb_node->commandBuffer) << "). " |
| << "Draw Index " << draw_index << ". " |
| << "Pipeline " << LookupDebugUtilsName(report_data, HandleToUint64(pipeline_handle)) << "(" |
| << HandleToUint64(pipeline_handle) << "). " |
| << "Shader Module " << LookupDebugUtilsName(report_data, HandleToUint64(shader_module_handle)) << "(" |
| << HandleToUint64(shader_module_handle) << "). "; |
| } |
| strm << std::dec << std::noshowbase; |
| strm << "Shader Instruction Index = " << debug_record[kInstCommonOutInstructionIdx] << ". "; |
| msg = strm.str(); |
| } |
| |
| // 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 shader_module &shader, const uint32_t reported_file_id, std::vector<std::string> &opsource_lines) { |
| for (auto insn : shader) { |
| if ((insn.opcode() == spv::OpSource) && (insn.len() >= 5) && (insn.word(3) == reported_file_id)) { |
| std::istringstream in_stream; |
| std::string cur_line; |
| in_stream.str((char *)&insn.word(4)); |
| while (std::getline(in_stream, cur_line)) { |
| opsource_lines.push_back(cur_line); |
| } |
| while ((++insn).opcode() == spv::OpSourceContinued) { |
| in_stream.str((char *)&insn.word(1)); |
| while (std::getline(in_stream, cur_line)) { |
| opsource_lines.push_back(cur_line); |
| } |
| } |
| break; |
| } |
| } |
| } |
| |
| // 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. |
| // |
| |
| // GCC 4.8 has a problem with std::regex that is fixed in GCC 4.9. Provide fallback code for 4.8 |
| #define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) |
| |
| #if defined(__GNUC__) && GCC_VERSION < 40900 |
| static bool GetLineAndFilename(const std::string string, uint32_t *linenumber, std::string &filename) { |
| // # line <linenumber> "<filename>" or |
| // #line <linenumber> "<filename>" |
| std::vector<std::string> tokens; |
| std::stringstream stream(string); |
| std::string temp; |
| uint32_t line_index = 0; |
| |
| while (stream >> temp) tokens.push_back(temp); |
| auto size = tokens.size(); |
| if (size > 1) { |
| if (tokens[0] == "#" && tokens[1] == "line") { |
| line_index = 2; |
| } else if (tokens[0] == "#line") { |
| line_index = 1; |
| } |
| } |
| if (0 == line_index) return false; |
| *linenumber = std::stoul(tokens[line_index]); |
| uint32_t filename_index = line_index + 1; |
| // Remove enclosing double quotes around filename |
| if (size > filename_index) filename = tokens[filename_index].substr(1, tokens[filename_index].size() - 2); |
| return true; |
| } |
| #else |
| static bool GetLineAndFilename(const std::string string, uint32_t *linenumber, std::string &filename) { |
| static const std::regex line_regex( // matches #line directives |
| "^" // beginning of line |
| "\\s*" // optional whitespace |
| "#" // required text |
| "\\s*" // optional whitespace |
| "line" // required text |
| "\\s+" // required whitespace |
| "([0-9]+)" // required first capture - line number |
| "(\\s+)?" // optional second capture - whitespace |
| "(\".+\")?" // optional third capture - quoted filename with at least one char inside |
| ".*"); // rest of line (needed when using std::regex_match since the entire line is tested) |
| |
| std::smatch captures; |
| |
| bool found_line = std::regex_match(string, captures, line_regex); |
| if (!found_line) return false; |
| |
| // filename is optional and considered found only if the whitespace and the filename are captured |
| if (captures[2].matched && captures[3].matched) { |
| // Remove enclosing double quotes. The regex guarantees the quotes and at least one char. |
| filename = captures[3].str().substr(1, captures[3].str().size() - 2); |
| } |
| *linenumber = std::stoul(captures[1]); |
| return true; |
| } |
| #endif // GCC_VERSION |
| |
| // Extract the filename, line number, and column number from the correct OpLine and build a message string from it. |
| // Scan the source (from OpSource) to find the line of source at the reported line number and place it in another message string. |
| static void GenerateSourceMessages(const std::vector<unsigned int> &pgm, const uint32_t *debug_record, std::string &filename_msg, |
| std::string &source_msg) { |
| using namespace spvtools; |
| std::ostringstream filename_stream; |
| std::ostringstream source_stream; |
| shader_module shader; |
| shader.words = pgm; |
| // Find the OpLine just before the failing instruction indicated by the debug info. |
| // SPIR-V can only be iterated in the forward direction due to its opcode/length encoding. |
| uint32_t instruction_index = 0; |
| uint32_t reported_file_id = 0; |
| uint32_t reported_line_number = 0; |
| uint32_t reported_column_number = 0; |
| if (shader.words.size() > 0) { |
| for (auto insn : shader) { |
| if (insn.opcode() == spv::OpLine) { |
| reported_file_id = insn.word(1); |
| reported_line_number = insn.word(2); |
| reported_column_number = insn.word(3); |
| } |
| if (instruction_index == debug_record[kInstCommonOutInstructionIdx]) { |
| break; |
| } |
| instruction_index++; |
| } |
| } |
| // Create message with file information obtained from the OpString pointed to by the discovered OpLine. |
| std::string reported_filename; |
| if (reported_file_id == 0) { |
| filename_stream |
| << "Unable to find SPIR-V OpLine for source information. Build shader with debug info to get source information."; |
| } else { |
| bool found_opstring = false; |
| for (auto insn : shader) { |
| if ((insn.opcode() == spv::OpString) && (insn.len() >= 3) && (insn.word(1) == reported_file_id)) { |
| found_opstring = true; |
| reported_filename = (char *)&insn.word(2); |
| if (reported_filename.empty()) { |
| filename_stream << "Shader validation error occurred at line " << reported_line_number; |
| } else { |
| filename_stream << "Shader validation error occurred in file: " << reported_filename << " at line " |
| << reported_line_number; |
| } |
| if (reported_column_number > 0) { |
| filename_stream << ", column " << reported_column_number; |
| } |
| filename_stream << "."; |
| break; |
| } |
| } |
| if (!found_opstring) { |
| filename_stream << "Unable to find SPIR-V OpString for file id " << reported_file_id << " from OpLine instruction."; |
| } |
| } |
| filename_msg = filename_stream.str(); |
| |
| // Create message to display source code line containing error. |
| if ((reported_file_id != 0)) { |
| // Read the source code and split it up into separate lines. |
| std::vector<std::string> opsource_lines; |
| ReadOpSource(shader, reported_file_id, opsource_lines); |
| // Find the line in the OpSource content that corresponds to the reported error file and line. |
| if (!opsource_lines.empty()) { |
| uint32_t saved_line_number = 0; |
| std::string current_filename = reported_filename; // current "preprocessor" filename state. |
| std::vector<std::string>::size_type saved_opsource_offset = 0; |
| bool found_best_line = false; |
| for (auto it = opsource_lines.begin(); it != opsource_lines.end(); ++it) { |
| uint32_t parsed_line_number; |
| std::string parsed_filename; |
| bool found_line = GetLineAndFilename(*it, &parsed_line_number, parsed_filename); |
| if (!found_line) continue; |
| |
| bool found_filename = parsed_filename.size() > 0; |
| if (found_filename) { |
| current_filename = parsed_filename; |
| } |
| if ((!found_filename) || (current_filename == reported_filename)) { |
| // Update the candidate best line directive, if the current one is prior and closer to the reported line |
| if (reported_line_number >= parsed_line_number) { |
| if (!found_best_line || |
| (reported_line_number - parsed_line_number <= reported_line_number - saved_line_number)) { |
| saved_line_number = parsed_line_number; |
| saved_opsource_offset = std::distance(opsource_lines.begin(), it); |
| found_best_line = true; |
| } |
| } |
| } |
| } |
| if (found_best_line) { |
| assert(reported_line_number >= saved_line_number); |
| std::vector<std::string>::size_type opsource_index = |
| (reported_line_number - saved_line_number) + 1 + saved_opsource_offset; |
| if (opsource_index < opsource_lines.size()) { |
| source_stream << "\n" << reported_line_number << ": " << opsource_lines[opsource_index].c_str(); |
| } else { |
| source_stream << "Internal error: calculated source line of " << opsource_index << " for source size of " |
| << opsource_lines.size() << " lines."; |
| } |
| } else { |
| source_stream << "Unable to find suitable #line directive in SPIR-V OpSource."; |
| } |
| } else { |
| source_stream << "Unable to find SPIR-V OpSource."; |
| } |
| } |
| source_msg = source_stream.str(); |
| } |
| |
| // Pull together all the information from the debug record to build the error message strings, |
| // and then assemble them into a single message string. |
| // Retrieve the shader program referenced by the unique shader ID provided in the debug record. |
| // We had to keep a copy of the shader program with the same lifecycle as the pipeline to make |
| // sure it is available when the pipeline is submitted. (The ShaderModule tracking object also |
| // keeps a copy, but it can be destroyed after the pipeline is created and before it is submitted.) |
| // |
| void CoreChecks::AnalyzeAndReportError(const layer_data *dev_data, GLOBAL_CB_NODE *cb_node, VkQueue queue, uint32_t draw_index, |
| uint32_t *const debug_output_buffer) { |
| using namespace spvtools; |
| const uint32_t total_words = debug_output_buffer[0]; |
| // A zero here means that the shader instrumentation didn't write anything. |
| // If you have nothing to say, don't say it here. |
| if (0 == total_words) { |
| return; |
| } |
| // The first word in the debug output buffer is the number of words that would have |
| // been written by the shader instrumentation, if there was enough room in the buffer we provided. |
| // The number of words actually written by the shaders is determined by the size of the buffer |
| // we provide via the descriptor. So, we process only the number of words that can fit in the |
| // buffer. |
| // Each "report" written by the shader instrumentation is considered a "record". This function |
| // is hard-coded to process only one record because it expects the buffer to be large enough to |
| // hold only one record. If there is a desire to process more than one record, this function needs |
| // to be modified to loop over records and the buffer size increased. |
| auto gpu_state = GetGpuValidationState(); |
| std::string validation_message; |
| std::string stage_message; |
| std::string common_message; |
| std::string filename_message; |
| std::string source_message; |
| std::string vuid_msg; |
| VkShaderModule shader_module_handle = VK_NULL_HANDLE; |
| VkPipeline pipeline_handle = VK_NULL_HANDLE; |
| std::vector<unsigned int> pgm; |
| // The first record starts at this offset after the total_words. |
| const uint32_t *debug_record = &debug_output_buffer[kDebugOutputDataOffset]; |
| // Lookup the VkShaderModule handle and SPIR-V code used to create the shader, using the unique shader ID value returned |
| // by the instrumented shader. |
| auto it = gpu_state->shader_map.find(debug_record[kInstCommonOutShaderId]); |
| if (it != gpu_state->shader_map.end()) { |
| shader_module_handle = it->second.shader_module; |
| pipeline_handle = it->second.pipeline; |
| pgm = it->second.pgm; |
| } |
| GenerateValidationMessage(debug_record, validation_message, vuid_msg); |
| GenerateStageMessage(debug_record, stage_message); |
| GenerateCommonMessage(report_data, cb_node, debug_record, shader_module_handle, pipeline_handle, draw_index, common_message); |
| GenerateSourceMessages(pgm, debug_record, filename_message, source_message); |
| log_msg(GetReportData(), VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, HandleToUint64(queue), |
| vuid_msg.c_str(), "%s %s %s %s%s", validation_message.c_str(), common_message.c_str(), stage_message.c_str(), |
| filename_message.c_str(), source_message.c_str()); |
| // The debug record at word kInstCommonOutSize is the number of words in the record |
| // written by the shader. Clear the entire record plus the total_words word at the start. |
| const uint32_t words_to_clear = 1 + std::min(debug_record[kInstCommonOutSize], (uint32_t)kInstMaxOutCnt); |
| memset(debug_output_buffer, 0, sizeof(uint32_t) * words_to_clear); |
| } |
| |
| // For the given command buffer, map its debug data buffers and read their contents for analysis. |
| void CoreChecks::ProcessInstrumentationBuffer(const layer_data *dev_data, VkQueue queue, GLOBAL_CB_NODE *cb_node) { |
| auto gpu_state = GetGpuValidationState(); |
| if (cb_node && cb_node->hasDrawCmd && cb_node->gpu_buffer_list.size() > 0) { |
| VkResult result; |
| char *pData; |
| uint32_t draw_index = 0; |
| for (auto &buffer_info : cb_node->gpu_buffer_list) { |
| uint32_t block_offset = buffer_info.mem_block.offset; |
| uint32_t block_size = gpu_state->memory_manager->GetBlockSize(); |
| uint32_t offset_to_data = 0; |
| const uint32_t map_align = std::max(1U, static_cast<uint32_t>(GetPDProperties()->limits.minMemoryMapAlignment)); |
| |
| // Adjust the offset to the alignment required for mapping. |
| block_offset = (block_offset / map_align) * map_align; |
| offset_to_data = buffer_info.mem_block.offset - block_offset; |
| block_size += offset_to_data; |
| result = GetDispatchTable()->MapMemory(cb_node->device, buffer_info.mem_block.memory, block_offset, block_size, 0, |
| (void **)&pData); |
| // Analyze debug output buffer |
| if (result == VK_SUCCESS) { |
| AnalyzeAndReportError(dev_data, cb_node, queue, draw_index, (uint32_t *)(pData + offset_to_data)); |
| GetDispatchTable()->UnmapMemory(cb_node->device, buffer_info.mem_block.memory); |
| } |
| draw_index++; |
| } |
| } |
| } |
| |
| // Submit a memory barrier on graphics queues. |
| // Lazy-create and record the needed command buffer. |
| void CoreChecks::SubmitBarrier(layer_data *dev_data, VkQueue queue) { |
| auto gpu_state = GetGpuValidationState(); |
| const auto *dispatch_table = GetDispatchTable(); |
| uint32_t queue_family_index = 0; |
| |
| auto it = dev_data->queueMap.find(queue); |
| if (it != dev_data->queueMap.end()) { |
| queue_family_index = it->second.queueFamilyIndex; |
| } |
| |
| // Pay attention only to queues that support graphics. |
| // This ensures that the command buffer pool is created so that it can be used on a graphics queue. |
| VkQueueFlags queue_flags = GetPhysicalDeviceState()->queue_family_properties[queue_family_index].queueFlags; |
| if (!(queue_flags & VK_QUEUE_GRAPHICS_BIT)) { |
| return; |
| } |
| |
| // Lazy-allocate and record the command buffer. |
| if (gpu_state->barrier_command_buffer == VK_NULL_HANDLE) { |
| VkResult result; |
| VkCommandPoolCreateInfo pool_create_info = {}; |
| pool_create_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; |
| pool_create_info.queueFamilyIndex = queue_family_index; |
| result = dispatch_table->CreateCommandPool(GetDevice(), &pool_create_info, nullptr, &gpu_state->barrier_command_pool); |
| if (result != VK_SUCCESS) { |
| ReportSetupProblem(dev_data, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, HandleToUint64(GetDevice()), |
| "Unable to create command pool for barrier CB."); |
| gpu_state->barrier_command_pool = VK_NULL_HANDLE; |
| return; |
| } |
| |
| VkCommandBufferAllocateInfo command_buffer_alloc_info = {}; |
| command_buffer_alloc_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; |
| command_buffer_alloc_info.commandPool = gpu_state->barrier_command_pool; |
| command_buffer_alloc_info.commandBufferCount = 1; |
| command_buffer_alloc_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; |
| result = |
| dispatch_table->AllocateCommandBuffers(GetDevice(), &command_buffer_alloc_info, &gpu_state->barrier_command_buffer); |
| if (result != VK_SUCCESS) { |
| ReportSetupProblem(dev_data, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, HandleToUint64(GetDevice()), |
| "Unable to create barrier command buffer."); |
| dispatch_table->DestroyCommandPool(GetDevice(), gpu_state->barrier_command_pool, nullptr); |
| gpu_state->barrier_command_pool = VK_NULL_HANDLE; |
| gpu_state->barrier_command_buffer = VK_NULL_HANDLE; |
| return; |
| } |
| |
| // Hook up command buffer dispatch |
| *((const void **)gpu_state->barrier_command_buffer) = *(void **)(GetDevice()); |
| |
| // Record a global memory barrier to force availability of device memory operations to the host domain. |
| VkCommandBufferBeginInfo command_buffer_begin_info = {}; |
| command_buffer_begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; |
| result = dispatch_table->BeginCommandBuffer(gpu_state->barrier_command_buffer, &command_buffer_begin_info); |
| |
| if (result == VK_SUCCESS) { |
| VkMemoryBarrier memory_barrier = {}; |
| memory_barrier.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER; |
| memory_barrier.srcAccessMask = VK_ACCESS_MEMORY_WRITE_BIT; |
| memory_barrier.dstAccessMask = VK_ACCESS_HOST_READ_BIT; |
| |
| dispatch_table->CmdPipelineBarrier(gpu_state->barrier_command_buffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, |
| VK_PIPELINE_STAGE_HOST_BIT, 0, 1, &memory_barrier, 0, nullptr, 0, nullptr); |
| dispatch_table->EndCommandBuffer(gpu_state->barrier_command_buffer); |
| } |
| } |
| |
| if (gpu_state->barrier_command_buffer) { |
| VkSubmitInfo submit_info = {}; |
| submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; |
| submit_info.commandBufferCount = 1; |
| submit_info.pCommandBuffers = &gpu_state->barrier_command_buffer; |
| dispatch_table->QueueSubmit(queue, 1, &submit_info, VK_NULL_HANDLE); |
| } |
| } |
| |
| // Issue a memory barrier to make GPU-written data available to host. |
| // Wait for the queue to complete execution. |
| // Check the debug buffers for all the command buffers that were submitted. |
| void CoreChecks::GpuPostCallQueueSubmit(layer_data *dev_data, VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, |
| VkFence fence) { |
| auto gpu_state = GetGpuValidationState(); |
| if (gpu_state->aborted) return; |
| |
| SubmitBarrier(dev_data, queue); |
| |
| dev_data->device_dispatch_table.QueueWaitIdle(queue); |
| |
| for (uint32_t submit_idx = 0; submit_idx < submitCount; submit_idx++) { |
| const VkSubmitInfo *submit = &pSubmits[submit_idx]; |
| for (uint32_t i = 0; i < submit->commandBufferCount; i++) { |
| auto cb_node = GetCBNode(submit->pCommandBuffers[i]); |
| ProcessInstrumentationBuffer(dev_data, queue, cb_node); |
| for (auto secondaryCmdBuffer : cb_node->linkedCommandBuffers) { |
| ProcessInstrumentationBuffer(dev_data, queue, secondaryCmdBuffer); |
| } |
| } |
| } |
| } |
| |
| void CoreChecks::GpuAllocateValidationResources(layer_data *dev_data, const VkCommandBuffer cmd_buffer, |
| const VkPipelineBindPoint bind_point) { |
| VkResult result; |
| |
| if (!(GetEnables()->gpu_validation)) return; |
| |
| auto gpu_state = GetGpuValidationState(); |
| if (gpu_state->aborted) return; |
| |
| std::vector<VkDescriptorSet> desc_sets; |
| VkDescriptorPool desc_pool = VK_NULL_HANDLE; |
| result = gpu_state->desc_set_manager->GetDescriptorSets(1, &desc_pool, &desc_sets); |
| assert(result == VK_SUCCESS); |
| if (result != VK_SUCCESS) { |
| ReportSetupProblem(dev_data, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, HandleToUint64(GetDevice()), |
| "Unable to allocate descriptor sets. Device could become unstable."); |
| gpu_state->aborted = true; |
| return; |
| } |
| |
| VkDescriptorBufferInfo desc_buffer_info = {}; |
| desc_buffer_info.range = gpu_state->memory_manager->GetBlockSize(); |
| |
| auto cb_node = GetCBNode(cmd_buffer); |
| if (!cb_node) { |
| ReportSetupProblem(dev_data, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, HandleToUint64(GetDevice()), |
| "Unrecognized command buffer"); |
| gpu_state->aborted = true; |
| return; |
| } |
| |
| GpuDeviceMemoryBlock block = {}; |
| result = gpu_state->memory_manager->GetBlock(&block); |
| if (result != VK_SUCCESS) { |
| ReportSetupProblem(dev_data, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, HandleToUint64(GetDevice()), |
| "Unable to allocate device memory. Device could become unstable."); |
| gpu_state->aborted = true; |
| return; |
| } |
| |
| // Record buffer and memory info in CB state tracking |
| cb_node->gpu_buffer_list.emplace_back(block, desc_sets[0], desc_pool); |
| |
| // Write the descriptor |
| desc_buffer_info.buffer = block.buffer; |
| desc_buffer_info.offset = block.offset; |
| |
| VkWriteDescriptorSet desc_write = {}; |
| desc_write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; |
| desc_write.descriptorCount = 1; |
| desc_write.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; |
| desc_write.pBufferInfo = &desc_buffer_info; |
| desc_write.dstSet = desc_sets[0]; |
| GetDispatchTable()->UpdateDescriptorSets(GetDevice(), 1, &desc_write, 0, NULL); |
| |
| auto iter = cb_node->lastBound.find(VK_PIPELINE_BIND_POINT_GRAPHICS); // find() allows read-only access to cb_state |
| if (iter != cb_node->lastBound.end()) { |
| auto pipeline_state = iter->second.pipeline_state; |
| if (pipeline_state && (pipeline_state->pipeline_layout.set_layouts.size() <= gpu_state->desc_set_bind_index)) { |
| GetDispatchTable()->CmdBindDescriptorSets(cmd_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, |
| pipeline_state->pipeline_layout.layout, gpu_state->desc_set_bind_index, 1, |
| desc_sets.data(), 0, nullptr); |
| } |
| } else { |
| ReportSetupProblem(dev_data, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, HandleToUint64(GetDevice()), |
| "Unable to find pipeline state"); |
| gpu_state->aborted = true; |
| return; |
| } |
| } |
