diff --git a/src/3rdparty/VulkanMemoryAllocator/vk_mem_alloc.h b/src/3rdparty/VulkanMemoryAllocator/vk_mem_alloc.h index a2f7a1b..fbe6f9e 100644 --- a/src/3rdparty/VulkanMemoryAllocator/vk_mem_alloc.h +++ b/src/3rdparty/VulkanMemoryAllocator/vk_mem_alloc.h @@ -3661,7 +3661,7 @@ static void VmaWriteMagicValue(void* pData, VkDeviceSize offset) { uint32_t* pDst = (uint32_t*)((char*)pData + offset); const size_t numberCount = VMA_DEBUG_MARGIN / sizeof(uint32_t); - for(size_t i = 0; i < numberCount; ++i, ++pDst) + for(size_t i = 0; i != numberCount; ++i, ++pDst) { *pDst = VMA_CORRUPTION_DETECTION_MAGIC_VALUE; } @@ -3671,7 +3671,7 @@ static bool VmaValidateMagicValue(const void* pData, VkDeviceSize offset) { const uint32_t* pSrc = (const uint32_t*)((const char*)pData + offset); const size_t numberCount = VMA_DEBUG_MARGIN / sizeof(uint32_t); - for(size_t i = 0; i < numberCount; ++i, ++pSrc) + for(size_t i = 0; i != numberCount; ++i, ++pSrc) { if(*pSrc != VMA_CORRUPTION_DETECTION_MAGIC_VALUE) { @@ -3866,7 +3866,7 @@ public: template VmaStlAllocator(const VmaStlAllocator& src) : m_pCallbacks(src.m_pCallbacks) { } T* allocate(size_t n) { return VmaAllocateArray(m_pCallbacks, n); } - void deallocate(T* p, size_t n) { VmaFree(m_pCallbacks, p); } + void deallocate(T* p, size_t /*n*/) { VmaFree(m_pCallbacks, p); } template bool operator==(const VmaStlAllocator& rhs) const @@ -5214,7 +5214,7 @@ public: virtual void FreeAtOffset(VkDeviceSize offset) = 0; // Tries to resize (grow or shrink) space for given allocation, in place. - virtual bool ResizeAllocation(const VmaAllocation alloc, VkDeviceSize newSize) { return false; } + virtual bool ResizeAllocation(const VmaAllocation /*alloc*/, VkDeviceSize /*newSize*/) { return false; } protected: const VkAllocationCallbacks* GetAllocationCallbacks() const { return m_pAllocationCallbacks; } @@ -5574,7 +5574,7 @@ public: virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount); - virtual VkResult CheckCorruption(const void* pBlockData) { return VK_ERROR_FEATURE_NOT_PRESENT; } + virtual VkResult CheckCorruption(const void* /*pBlockData*/) { return VK_ERROR_FEATURE_NOT_PRESENT; } virtual void Alloc( const VmaAllocationRequest& request, @@ -6133,7 +6133,7 @@ public: bool overlappingMoveSupported); virtual ~VmaDefragmentationAlgorithm_Fast(); - virtual void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged) { ++m_AllocationCount; } + virtual void AddAllocation(VmaAllocation /*hAlloc*/, VkBool32* /*pChanged*/) { ++m_AllocationCount; } virtual void AddAll() { m_AllAllocations = true; } virtual VkResult Defragment( @@ -6318,7 +6318,7 @@ private: // Redundant, for convenience not to fetch from m_hCustomPool->m_BlockVector or m_hAllocator->m_pBlockVectors. VmaBlockVector* const m_pBlockVector; const uint32_t m_CurrFrameIndex; - const uint32_t m_AlgorithmFlags; + /*const uint32_t m_AlgorithmFlags;*/ // Owner of this object. VmaDefragmentationAlgorithm* m_pAlgorithm; @@ -7073,6 +7073,7 @@ void VmaJsonWriter::BeginValue(bool isString) if(currItem.type == COLLECTION_TYPE_OBJECT && currItem.valueCount % 2 == 0) { + (void) isString; VMA_ASSERT(isString); } @@ -7660,7 +7661,9 @@ bool VmaBlockMetadata_Generic::Validate() const } // Margin required between allocations - every free space must be at least that large. +#if VMA_DEBUG_MARGIN VMA_VALIDATE(subAlloc.size >= VMA_DEBUG_MARGIN); +#endif } else { @@ -7806,6 +7809,7 @@ bool VmaBlockMetadata_Generic::CreateAllocationRequest( { VMA_ASSERT(allocSize > 0); VMA_ASSERT(!upperAddress); + (void) upperAddress; VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE); VMA_ASSERT(pAllocationRequest != VMA_NULL); VMA_HEAVY_ASSERT(Validate()); @@ -8033,6 +8037,7 @@ void VmaBlockMetadata_Generic::Alloc( VmaAllocation hAllocation) { VMA_ASSERT(!upperAddress); + (void) upperAddress; VMA_ASSERT(request.item != m_Suballocations.end()); VmaSuballocation& suballoc = *request.item; // Given suballocation is a free block. @@ -9609,7 +9614,7 @@ bool VmaBlockMetadata_Linear::CreateAllocationRequest( bool upperAddress, VmaSuballocationType allocType, bool canMakeOtherLost, - uint32_t strategy, + uint32_t /*strategy*/, VmaAllocationRequest* pAllocationRequest) { VMA_ASSERT(allocSize > 0); @@ -9651,10 +9656,12 @@ bool VmaBlockMetadata_Linear::CreateAllocationRequest( // Apply VMA_DEBUG_MARGIN at the end. if(VMA_DEBUG_MARGIN > 0) { +#if VMA_DEBUG_MARGIN if(resultOffset < VMA_DEBUG_MARGIN) { return false; } +#endif resultOffset -= VMA_DEBUG_MARGIN; } @@ -10542,18 +10549,19 @@ void VmaBlockMetadata_Buddy::PrintDetailedMap(class VmaJsonWriter& json) const #endif // #if VMA_STATS_STRING_ENABLED bool VmaBlockMetadata_Buddy::CreateAllocationRequest( - uint32_t currentFrameIndex, - uint32_t frameInUseCount, + uint32_t /*currentFrameIndex*/, + uint32_t /*frameInUseCount*/, VkDeviceSize bufferImageGranularity, VkDeviceSize allocSize, VkDeviceSize allocAlignment, bool upperAddress, VmaSuballocationType allocType, - bool canMakeOtherLost, - uint32_t strategy, + bool /*canMakeOtherLost*/, + uint32_t /*strategy*/, VmaAllocationRequest* pAllocationRequest) { VMA_ASSERT(!upperAddress && "VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT can be used only with linear algorithm."); + (void) upperAddress; // Simple way to respect bufferImageGranularity. May be optimized some day. // Whenever it might be an OPTIMAL image... @@ -10593,8 +10601,8 @@ bool VmaBlockMetadata_Buddy::CreateAllocationRequest( } bool VmaBlockMetadata_Buddy::MakeRequestedAllocationsLost( - uint32_t currentFrameIndex, - uint32_t frameInUseCount, + uint32_t /*currentFrameIndex*/, + uint32_t /*frameInUseCount*/, VmaAllocationRequest* pAllocationRequest) { /* @@ -10604,7 +10612,7 @@ bool VmaBlockMetadata_Buddy::MakeRequestedAllocationsLost( return pAllocationRequest->itemsToMakeLostCount == 0; } -uint32_t VmaBlockMetadata_Buddy::MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount) +uint32_t VmaBlockMetadata_Buddy::MakeAllocationsLost(uint32_t /*currentFrameIndex*/, uint32_t /*frameInUseCount*/) { /* Lost allocations are not supported in buddy allocator at the moment. @@ -10615,9 +10623,9 @@ uint32_t VmaBlockMetadata_Buddy::MakeAllocationsLost(uint32_t currentFrameIndex, void VmaBlockMetadata_Buddy::Alloc( const VmaAllocationRequest& request, - VmaSuballocationType type, + VmaSuballocationType /*type*/, VkDeviceSize allocSize, - bool upperAddress, + bool /*upperAddress*/, VmaAllocation hAllocation) { const uint32_t targetLevel = AllocSizeToLevel(allocSize); @@ -10941,7 +10949,7 @@ void VmaBlockMetadata_Buddy::PrintDetailedMapNode(class VmaJsonWriter& json, con //////////////////////////////////////////////////////////////////////////////// // class VmaDeviceMemoryBlock -VmaDeviceMemoryBlock::VmaDeviceMemoryBlock(VmaAllocator hAllocator) : +VmaDeviceMemoryBlock::VmaDeviceMemoryBlock(VmaAllocator /*hAllocator*/) : m_pMetadata(VMA_NULL), m_MemoryTypeIndex(UINT32_MAX), m_Id(0), @@ -11691,6 +11699,7 @@ VkResult VmaBlockVector::AllocatePage( if(IsCorruptionDetectionEnabled()) { VkResult res = pBestRequestBlock->WriteMagicValueAroundAllocation(m_hAllocator, bestRequest.offset, size); + (void) res; VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to write magic value."); } return VK_SUCCESS; @@ -11729,6 +11738,7 @@ void VmaBlockVector::Free( if(IsCorruptionDetectionEnabled()) { VkResult res = pBlock->ValidateMagicValueAroundAllocation(m_hAllocator, hAllocation->GetOffset(), hAllocation->GetSize()); + (void) res; VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to validate magic value."); } @@ -11894,6 +11904,7 @@ VkResult VmaBlockVector::AllocateFromBlock( if(IsCorruptionDetectionEnabled()) { VkResult res = pBlock->WriteMagicValueAroundAllocation(m_hAllocator, currRequest.offset, size); + (void) res; VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to write magic value."); } return VK_SUCCESS; @@ -11903,7 +11914,8 @@ VkResult VmaBlockVector::AllocateFromBlock( VkResult VmaBlockVector::CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex) { - VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO }; + VkMemoryAllocateInfo allocInfo = {}; + allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; allocInfo.memoryTypeIndex = m_MemoryTypeIndex; allocInfo.allocationSize = blockSize; VkDeviceMemory mem = VK_NULL_HANDLE; @@ -11991,7 +12003,8 @@ void VmaBlockVector::ApplyDefragmentationMovesCpu( if(pDefragCtx->res == VK_SUCCESS) { const VkDeviceSize nonCoherentAtomSize = m_hAllocator->m_PhysicalDeviceProperties.limits.nonCoherentAtomSize; - VkMappedMemoryRange memRange = { VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE }; + VkMappedMemoryRange memRange = {}; + memRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE; for(size_t moveIndex = 0; moveIndex < moveCount; ++moveIndex) { @@ -12076,7 +12089,8 @@ void VmaBlockVector::ApplyDefragmentationMovesGpu( // Go over all blocks. Create and bind buffer for whole block if necessary. { - VkBufferCreateInfo bufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO }; + VkBufferCreateInfo bufCreateInfo = {}; + bufCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; bufCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT; @@ -12101,8 +12115,9 @@ void VmaBlockVector::ApplyDefragmentationMovesGpu( // Go over all moves. Post data transfer commands to command buffer. if(pDefragCtx->res == VK_SUCCESS) { - const VkDeviceSize nonCoherentAtomSize = m_hAllocator->m_PhysicalDeviceProperties.limits.nonCoherentAtomSize; - VkMappedMemoryRange memRange = { VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE }; + /*const VkDeviceSize nonCoherentAtomSize = m_hAllocator->m_PhysicalDeviceProperties.limits.nonCoherentAtomSize; + VkMappedMemoryRange memRange = {}; + memRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;*/ for(size_t moveIndex = 0; moveIndex < moveCount; ++moveIndex) { @@ -12435,10 +12450,10 @@ VmaDefragmentationAlgorithm_Generic::VmaDefragmentationAlgorithm_Generic( VmaAllocator hAllocator, VmaBlockVector* pBlockVector, uint32_t currentFrameIndex, - bool overlappingMoveSupported) : + bool /*overlappingMoveSupported*/) : VmaDefragmentationAlgorithm(hAllocator, pBlockVector, currentFrameIndex), - m_AllAllocations(false), m_AllocationCount(0), + m_AllAllocations(false), m_BytesMoved(0), m_AllocationsMoved(0), m_Blocks(VmaStlAllocator(hAllocator->GetAllocationCallbacks())) @@ -12813,7 +12828,7 @@ VkResult VmaDefragmentationAlgorithm_Fast::Defragment( size_t freeSpaceOrigBlockIndex = m_BlockInfos[freeSpaceInfoIndex].origBlockIndex; VmaDeviceMemoryBlock* pFreeSpaceBlock = m_pBlockVector->GetBlock(freeSpaceOrigBlockIndex); VmaBlockMetadata_Generic* pFreeSpaceMetadata = (VmaBlockMetadata_Generic*)pFreeSpaceBlock->m_pMetadata; - VkDeviceSize freeSpaceBlockSize = pFreeSpaceMetadata->GetSize(); + /*VkDeviceSize freeSpaceBlockSize = pFreeSpaceMetadata->GetSize();*/ // Same block if(freeSpaceInfoIndex == srcBlockInfoIndex) @@ -13098,7 +13113,7 @@ VmaBlockVectorDefragmentationContext::VmaBlockVectorDefragmentationContext( VmaPool hCustomPool, VmaBlockVector* pBlockVector, uint32_t currFrameIndex, - uint32_t algorithmFlags) : + uint32_t /*algorithmFlags*/) : res(VK_SUCCESS), mutexLocked(false), blockContexts(VmaStlAllocator(hAllocator->GetAllocationCallbacks())), @@ -13106,7 +13121,7 @@ VmaBlockVectorDefragmentationContext::VmaBlockVectorDefragmentationContext( m_hCustomPool(hCustomPool), m_pBlockVector(pBlockVector), m_CurrFrameIndex(currFrameIndex), - m_AlgorithmFlags(algorithmFlags), + /*m_AlgorithmFlags(algorithmFlags),*/ m_pAlgorithm(VMA_NULL), m_Allocations(VmaStlAllocator(hAllocator->GetAllocationCallbacks())), m_AllAllocations(false) @@ -14311,19 +14326,21 @@ VkResult VmaAllocator_T::AllocateDedicatedMemory( bool map, bool isUserDataString, void* pUserData, - VkBuffer dedicatedBuffer, - VkImage dedicatedImage, + VkBuffer /*dedicatedBuffer*/, + VkImage /*dedicatedImage*/, size_t allocationCount, VmaAllocation* pAllocations) { VMA_ASSERT(allocationCount > 0 && pAllocations); - VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO }; + VkMemoryAllocateInfo allocInfo = {}; + allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; allocInfo.memoryTypeIndex = memTypeIndex; allocInfo.allocationSize = size; #if VMA_DEDICATED_ALLOCATION - VkMemoryDedicatedAllocateInfoKHR dedicatedAllocInfo = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR }; + VkMemoryDedicatedAllocateInfoKHR dedicatedAllocInfo = {}; + dedicatedAllocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR; if(m_UseKhrDedicatedAllocation) { if(dedicatedBuffer != VK_NULL_HANDLE) @@ -14341,7 +14358,7 @@ VkResult VmaAllocator_T::AllocateDedicatedMemory( #endif // #if VMA_DEDICATED_ALLOCATION size_t allocIndex; - VkResult res; + VkResult res = VK_SUCCESS; for(allocIndex = 0; allocIndex < allocationCount; ++allocIndex) { res = AllocateDedicatedMemoryPage( @@ -14460,12 +14477,15 @@ void VmaAllocator_T::GetBufferMemoryRequirements( #if VMA_DEDICATED_ALLOCATION if(m_UseKhrDedicatedAllocation) { - VkBufferMemoryRequirementsInfo2KHR memReqInfo = { VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR }; + VkBufferMemoryRequirementsInfo2KHR memReqInfo = {}; + memReqInfo.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR; memReqInfo.buffer = hBuffer; - VkMemoryDedicatedRequirementsKHR memDedicatedReq = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR }; + VkMemoryDedicatedRequirementsKHR memDedicatedReq = {}; + memDedicatedReq.sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR; - VkMemoryRequirements2KHR memReq2 = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR }; + VkMemoryRequirements2KHR memReq2 = {}; + memReq2.sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR; memReq2.pNext = &memDedicatedReq; (*m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR)(m_hDevice, &memReqInfo, &memReq2); @@ -14492,12 +14512,15 @@ void VmaAllocator_T::GetImageMemoryRequirements( #if VMA_DEDICATED_ALLOCATION if(m_UseKhrDedicatedAllocation) { - VkImageMemoryRequirementsInfo2KHR memReqInfo = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR }; + VkImageMemoryRequirementsInfo2KHR memReqInfo = {}; + memReqInfo.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR; memReqInfo.image = hImage; - VkMemoryDedicatedRequirementsKHR memDedicatedReq = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR }; + VkMemoryDedicatedRequirementsKHR memDedicatedReq = {}; + memDedicatedReq.sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR; - VkMemoryRequirements2KHR memReq2 = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR }; + VkMemoryRequirements2KHR memReq2 = {}; + memReq2.sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR; memReq2.pNext = &memDedicatedReq; (*m_VulkanFunctions.vkGetImageMemoryRequirements2KHR)(m_hDevice, &memReqInfo, &memReq2); @@ -14734,7 +14757,7 @@ VkResult VmaAllocator_T::ResizeAllocation( } else { - return VK_ERROR_OUT_OF_POOL_MEMORY; + return VkResult(-1000069000); // VK_ERROR_OUT_OF_POOL_MEMORY } default: VMA_ASSERT(0); @@ -15000,6 +15023,7 @@ void VmaAllocator_T::DestroyPool(VmaPool pool) { VmaMutexLockWrite lock(m_PoolsMutex, m_UseMutex); bool success = VmaVectorRemoveSorted(m_Pools, pool); + (void) success; VMA_ASSERT(success && "Pool not found in Allocator."); } @@ -15248,7 +15272,8 @@ void VmaAllocator_T::FlushOrInvalidateAllocation( const VkDeviceSize nonCoherentAtomSize = m_PhysicalDeviceProperties.limits.nonCoherentAtomSize; - VkMappedMemoryRange memRange = { VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE }; + VkMappedMemoryRange memRange = {}; + memRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE; memRange.memory = hAllocation->GetMemory(); switch(hAllocation->GetType()) @@ -15321,6 +15346,7 @@ void VmaAllocator_T::FreeDedicatedMemory(VmaAllocation allocation) AllocationVectorType* const pDedicatedAllocations = m_pDedicatedAllocations[memTypeIndex]; VMA_ASSERT(pDedicatedAllocations); bool success = VmaVectorRemoveSorted(*pDedicatedAllocations, allocation); + (void) success; VMA_ASSERT(success); }