Fixes in calls to VMA_DEBUG_LOG_FORMAT, using PRIu32 for compatibility

adam-sawicki-a · adam-sawicki-a · commit 7924e27f81d7 · 2024-01-24T14:13:44.000+01:00
See #400, thanks @dneto0 and @alecazam
diff --git a/include/vk_mem_alloc.h b/include/vk_mem_alloc.h
@@ -3038,7 +3038,7 @@ static void vma_aligned_free(void* VMA_NULLABLE ptr)
 #if VMA_STATS_STRING_ENABLED
     static inline void VmaUint32ToStr(char* VMA_NOT_NULL outStr, size_t strLen, uint32_t num)
     {
-        snprintf(outStr, strLen, "%u", static_cast<unsigned int>(num));
+        snprintf(outStr, strLen, "%" PRIu32, num);
     }
     static inline void VmaUint64ToStr(char* VMA_NOT_NULL outStr, size_t strLen, uint64_t num)
     {
@@ -6510,14 +6510,14 @@ void VmaBlockMetadata::DebugLogAllocation(VkDeviceSize offset, VkDeviceSize size
         const char* name = allocation->GetName();
 
 #if VMA_STATS_STRING_ENABLED
-        VMA_LEAK_LOG_FORMAT("UNFREED ALLOCATION; Offset: %" PRIu64 "; Size: %" PRIu64 "; UserData: %p; Name: %s; Type: %s; Usage: %u",
+        VMA_LEAK_LOG_FORMAT("UNFREED ALLOCATION; Offset: %" PRIu64 "; Size: %" PRIu64 "; UserData: %p; Name: %s; Type: %s; Usage: %" PRIu32,
             offset, size, userData, name ? name : "vma_empty",
             VMA_SUBALLOCATION_TYPE_NAMES[allocation->GetSuballocationType()],
             allocation->GetBufferImageUsage());
 #else
         VMA_LEAK_LOG_FORMAT("UNFREED ALLOCATION; Offset: %" PRIu64 "; Size: %" PRIu64 "; UserData: %p; Name: %s; Type: %u",
             offset, size, userData, name ? name : "vma_empty",
-            (uint32_t)allocation->GetSuballocationType());
+            (unsigned)allocation->GetSuballocationType());
 #endif // VMA_STATS_STRING_ENABLED
     }
 
@@ -11082,7 +11082,7 @@ VkResult VmaBlockVector::AllocatePage(
                 pCurrBlock, size, alignment, createInfo.flags, createInfo.pUserData, suballocType, strategy, pAllocation);
             if (res == VK_SUCCESS)
             {
-                VMA_DEBUG_LOG_FORMAT("    Returned from last block #%u", pCurrBlock->GetId());
+                VMA_DEBUG_LOG_FORMAT("    Returned from last block #%" PRIu32, pCurrBlock->GetId());
                 IncrementallySortBlocks();
                 return VK_SUCCESS;
             }
@@ -11118,7 +11118,7 @@ VkResult VmaBlockVector::AllocatePage(
                                 pCurrBlock, size, alignment, createInfo.flags, createInfo.pUserData, suballocType, strategy, pAllocation);
                             if (res == VK_SUCCESS)
                             {
-                                VMA_DEBUG_LOG_FORMAT("    Returned from existing block #%u", pCurrBlock->GetId());
+                                VMA_DEBUG_LOG_FORMAT("    Returned from existing block #%" PRIu32, pCurrBlock->GetId());
                                 IncrementallySortBlocks();
                                 return VK_SUCCESS;
                             }
@@ -11137,7 +11137,7 @@ VkResult VmaBlockVector::AllocatePage(
                         pCurrBlock, size, alignment, createInfo.flags, createInfo.pUserData, suballocType, strategy, pAllocation);
                     if (res == VK_SUCCESS)
                     {
-                        VMA_DEBUG_LOG_FORMAT("    Returned from existing block #%u", pCurrBlock->GetId());
+                        VMA_DEBUG_LOG_FORMAT("    Returned from existing block #%" PRIu32, pCurrBlock->GetId());
                         IncrementallySortBlocks();
                         return VK_SUCCESS;
                     }
@@ -11154,7 +11154,7 @@ VkResult VmaBlockVector::AllocatePage(
                 VkResult res = AllocateFromBlock(pCurrBlock, size, alignment, createInfo.flags, createInfo.pUserData, suballocType, strategy, pAllocation);
                 if (res == VK_SUCCESS)
                 {
-                    VMA_DEBUG_LOG_FORMAT("    Returned from existing block #%u", pCurrBlock->GetId());
+                    VMA_DEBUG_LOG_FORMAT("    Returned from existing block #%" PRIu32, pCurrBlock->GetId());
                     IncrementallySortBlocks();
                     return VK_SUCCESS;
                 }
@@ -11221,7 +11221,7 @@ VkResult VmaBlockVector::AllocatePage(
                 pBlock, size, alignment, createInfo.flags, createInfo.pUserData, suballocType, strategy, pAllocation);
             if (res == VK_SUCCESS)
             {
-                VMA_DEBUG_LOG_FORMAT("    Created new block #%u Size=%" PRIu64, pBlock->GetId(), newBlockSize);
+                VMA_DEBUG_LOG_FORMAT("    Created new block #%" PRIu32 " Size=%" PRIu64, pBlock->GetId(), newBlockSize);
                 IncrementallySortBlocks();
                 return VK_SUCCESS;
             }
@@ -11270,7 +11270,7 @@ void VmaBlockVector::Free(const VmaAllocation hAllocation)
         pBlock->PostFree(m_hAllocator);
         VMA_HEAVY_ASSERT(pBlock->Validate());
 
-        VMA_DEBUG_LOG_FORMAT("  Freed from MemoryTypeIndex=%u", m_MemoryTypeIndex);
+        VMA_DEBUG_LOG_FORMAT("  Freed from MemoryTypeIndex=%" PRIu32, m_MemoryTypeIndex);
 
         const bool canDeleteBlock = m_Blocks.size() > m_MinBlockCount;
         // pBlock became empty after this deallocation.
@@ -11303,7 +11303,7 @@ void VmaBlockVector::Free(const VmaAllocation hAllocation)
     // lock, for performance reason.
     if (pBlockToDelete != VMA_NULL)
     {
-        VMA_DEBUG_LOG_FORMAT("    Deleted empty block #%u", pBlockToDelete->GetId());
+        VMA_DEBUG_LOG_FORMAT("    Deleted empty block #%" PRIu32, pBlockToDelete->GetId());
         pBlockToDelete->Destroy(m_hAllocator);
         vma_delete(m_hAllocator, pBlockToDelete);
     }
@@ -13102,7 +13102,7 @@ VkResult VmaAllocator_T::AllocateMemoryOfType(
     VmaAllocation* pAllocations)
 {
     VMA_ASSERT(pAllocations != VMA_NULL);
-    VMA_DEBUG_LOG_FORMAT("  AllocateMemory: MemoryTypeIndex=%u, AllocationCount=%zu, Size=%" PRIu64, memTypeIndex, allocationCount, size);
+    VMA_DEBUG_LOG_FORMAT("  AllocateMemory: MemoryTypeIndex=%" PRIu32 ", AllocationCount=%zu, Size=%" PRIu64, memTypeIndex, allocationCount, size);
 
     VmaAllocationCreateInfo finalCreateInfo = createInfo;
     VkResult res = CalcMemTypeParams(
@@ -13348,7 +13348,7 @@ VkResult VmaAllocator_T::AllocateDedicatedMemory(
         {
             dedicatedAllocations.Register(pAllocations[allocIndex]);
         }
-        VMA_DEBUG_LOG_FORMAT("    Allocated DedicatedMemory Count=%zu, MemoryTypeIndex=#%u", allocationCount, memTypeIndex);
+        VMA_DEBUG_LOG_FORMAT("    Allocated DedicatedMemory Count=%zu, MemoryTypeIndex=#%" PRIu32, allocationCount, memTypeIndex);
     }
     else
     {
@@ -13925,7 +13925,7 @@ void VmaAllocator_T::GetAllocationInfo2(VmaAllocation hAllocation, VmaAllocation
 
 VkResult VmaAllocator_T::CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool)
 {
-    VMA_DEBUG_LOG_FORMAT("  CreatePool: MemoryTypeIndex=%u, flags=%u", pCreateInfo->memoryTypeIndex, pCreateInfo->flags);
+    VMA_DEBUG_LOG_FORMAT("  CreatePool: MemoryTypeIndex=%" PRIu32 ", flags=%" PRIu32, pCreateInfo->memoryTypeIndex, pCreateInfo->flags);
 
     VmaPoolCreateInfo newCreateInfo = *pCreateInfo;
 
@@ -14442,7 +14442,7 @@ void VmaAllocator_T::FreeDedicatedMemory(const VmaAllocation allocation)
     m_Budget.RemoveAllocation(MemoryTypeIndexToHeapIndex(allocation->GetMemoryTypeIndex()), allocation->GetSize());
     m_AllocationObjectAllocator.Free(allocation);
 
-    VMA_DEBUG_LOG_FORMAT("    Freed DedicatedMemory MemoryTypeIndex=%u", memTypeIndex);
+    VMA_DEBUG_LOG_FORMAT("    Freed DedicatedMemory MemoryTypeIndex=%" PRIu32, memTypeIndex);
 }
 
 uint32_t VmaAllocator_T::CalculateGpuDefragmentationMemoryTypeBits() const

Original file line number	Diff line number	Diff line change
`@@ -3038,7 +3038,7 @@ static void vma_aligned_free(void* VMA_NULLABLE ptr)`
`3038`	`3038`	`#if VMA_STATS_STRING_ENABLED`
`3039`	`3039`	`static inline void VmaUint32ToStr(char* VMA_NOT_NULL outStr, size_t strLen, uint32_t num)`
`3040`	`3040`	`{`
`3041`		`- snprintf(outStr, strLen, "%u", static_cast<unsigned int>(num));`
	`3041`	`+ snprintf(outStr, strLen, "%" PRIu32, num);`
`3042`	`3042`	`}`
`3043`	`3043`	`static inline void VmaUint64ToStr(char* VMA_NOT_NULL outStr, size_t strLen, uint64_t num)`
`3044`	`3044`	`{`
`@@ -6510,14 +6510,14 @@ void VmaBlockMetadata::DebugLogAllocation(VkDeviceSize offset, VkDeviceSize size`
`6510`	`6510`	`const char* name = allocation->GetName();`
`6511`	`6511`
`6512`	`6512`	`#if VMA_STATS_STRING_ENABLED`
`6513`		`- VMA_LEAK_LOG_FORMAT("UNFREED ALLOCATION; Offset: %" PRIu64 "; Size: %" PRIu64 "; UserData: %p; Name: %s; Type: %s; Usage: %u",`
	`6513`	`+ VMA_LEAK_LOG_FORMAT("UNFREED ALLOCATION; Offset: %" PRIu64 "; Size: %" PRIu64 "; UserData: %p; Name: %s; Type: %s; Usage: %" PRIu32,`
`6514`	`6514`	`offset, size, userData, name ? name : "vma_empty",`
`6515`	`6515`	`VMA_SUBALLOCATION_TYPE_NAMES[allocation->GetSuballocationType()],`
`6516`	`6516`	`allocation->GetBufferImageUsage());`
`6517`	`6517`	`#else`
`6518`	`6518`	`VMA_LEAK_LOG_FORMAT("UNFREED ALLOCATION; Offset: %" PRIu64 "; Size: %" PRIu64 "; UserData: %p; Name: %s; Type: %u",`
`6519`	`6519`	`offset, size, userData, name ? name : "vma_empty",`
`6520`		`- (uint32_t)allocation->GetSuballocationType());`
	`6520`	`+ (unsigned)allocation->GetSuballocationType());`
`6521`	`6521`	`#endif // VMA_STATS_STRING_ENABLED`
`6522`	`6522`	`}`
`6523`	`6523`
`@@ -11082,7 +11082,7 @@ VkResult VmaBlockVector::AllocatePage(`
`11082`	`11082`	`pCurrBlock, size, alignment, createInfo.flags, createInfo.pUserData, suballocType, strategy, pAllocation);`
`11083`	`11083`	`if (res == VK_SUCCESS)`
`11084`	`11084`	`{`
`11085`		`- VMA_DEBUG_LOG_FORMAT(" Returned from last block #%u", pCurrBlock->GetId());`
	`11085`	`+ VMA_DEBUG_LOG_FORMAT(" Returned from last block #%" PRIu32, pCurrBlock->GetId());`
`11086`	`11086`	`IncrementallySortBlocks();`
`11087`	`11087`	`return VK_SUCCESS;`
`11088`	`11088`	`}`
`@@ -11118,7 +11118,7 @@ VkResult VmaBlockVector::AllocatePage(`
`11118`	`11118`	`pCurrBlock, size, alignment, createInfo.flags, createInfo.pUserData, suballocType, strategy, pAllocation);`
`11119`	`11119`	`if (res == VK_SUCCESS)`
`11120`	`11120`	`{`
`11121`		`- VMA_DEBUG_LOG_FORMAT(" Returned from existing block #%u", pCurrBlock->GetId());`
	`11121`	`+ VMA_DEBUG_LOG_FORMAT(" Returned from existing block #%" PRIu32, pCurrBlock->GetId());`
`11122`	`11122`	`IncrementallySortBlocks();`
`11123`	`11123`	`return VK_SUCCESS;`
`11124`	`11124`	`}`
`@@ -11137,7 +11137,7 @@ VkResult VmaBlockVector::AllocatePage(`
`11137`	`11137`	`pCurrBlock, size, alignment, createInfo.flags, createInfo.pUserData, suballocType, strategy, pAllocation);`
`11138`	`11138`	`if (res == VK_SUCCESS)`
`11139`	`11139`	`{`
`11140`		`- VMA_DEBUG_LOG_FORMAT(" Returned from existing block #%u", pCurrBlock->GetId());`
	`11140`	`+ VMA_DEBUG_LOG_FORMAT(" Returned from existing block #%" PRIu32, pCurrBlock->GetId());`
`11141`	`11141`	`IncrementallySortBlocks();`
`11142`	`11142`	`return VK_SUCCESS;`
`11143`	`11143`	`}`
`@@ -11154,7 +11154,7 @@ VkResult VmaBlockVector::AllocatePage(`
`11154`	`11154`	`VkResult res = AllocateFromBlock(pCurrBlock, size, alignment, createInfo.flags, createInfo.pUserData, suballocType, strategy, pAllocation);`
`11155`	`11155`	`if (res == VK_SUCCESS)`
`11156`	`11156`	`{`
`11157`		`- VMA_DEBUG_LOG_FORMAT(" Returned from existing block #%u", pCurrBlock->GetId());`
	`11157`	`+ VMA_DEBUG_LOG_FORMAT(" Returned from existing block #%" PRIu32, pCurrBlock->GetId());`
`11158`	`11158`	`IncrementallySortBlocks();`
`11159`	`11159`	`return VK_SUCCESS;`
`11160`	`11160`	`}`
`@@ -11221,7 +11221,7 @@ VkResult VmaBlockVector::AllocatePage(`
`11221`	`11221`	`pBlock, size, alignment, createInfo.flags, createInfo.pUserData, suballocType, strategy, pAllocation);`
`11222`	`11222`	`if (res == VK_SUCCESS)`
`11223`	`11223`	`{`
`11224`		`- VMA_DEBUG_LOG_FORMAT(" Created new block #%u Size=%" PRIu64, pBlock->GetId(), newBlockSize);`
	`11224`	`+ VMA_DEBUG_LOG_FORMAT(" Created new block #%" PRIu32 " Size=%" PRIu64, pBlock->GetId(), newBlockSize);`
`11225`	`11225`	`IncrementallySortBlocks();`
`11226`	`11226`	`return VK_SUCCESS;`
`11227`	`11227`	`}`
`@@ -11270,7 +11270,7 @@ void VmaBlockVector::Free(const VmaAllocation hAllocation)`
`11270`	`11270`	`pBlock->PostFree(m_hAllocator);`
`11271`	`11271`	`VMA_HEAVY_ASSERT(pBlock->Validate());`
`11272`	`11272`
`11273`		`- VMA_DEBUG_LOG_FORMAT(" Freed from MemoryTypeIndex=%u", m_MemoryTypeIndex);`
	`11273`	`+ VMA_DEBUG_LOG_FORMAT(" Freed from MemoryTypeIndex=%" PRIu32, m_MemoryTypeIndex);`
`11274`	`11274`
`11275`	`11275`	`const bool canDeleteBlock = m_Blocks.size() > m_MinBlockCount;`
`11276`	`11276`	`// pBlock became empty after this deallocation.`
`@@ -11303,7 +11303,7 @@ void VmaBlockVector::Free(const VmaAllocation hAllocation)`
`11303`	`11303`	`// lock, for performance reason.`
`11304`	`11304`	`if (pBlockToDelete != VMA_NULL)`
`11305`	`11305`	`{`
`11306`		`- VMA_DEBUG_LOG_FORMAT(" Deleted empty block #%u", pBlockToDelete->GetId());`
	`11306`	`+ VMA_DEBUG_LOG_FORMAT(" Deleted empty block #%" PRIu32, pBlockToDelete->GetId());`
`11307`	`11307`	`pBlockToDelete->Destroy(m_hAllocator);`
`11308`	`11308`	`vma_delete(m_hAllocator, pBlockToDelete);`
`11309`	`11309`	`}`
`@@ -13102,7 +13102,7 @@ VkResult VmaAllocator_T::AllocateMemoryOfType(`
`13102`	`13102`	`VmaAllocation* pAllocations)`
`13103`	`13103`	`{`
`13104`	`13104`	`VMA_ASSERT(pAllocations != VMA_NULL);`
`13105`		`- VMA_DEBUG_LOG_FORMAT(" AllocateMemory: MemoryTypeIndex=%u, AllocationCount=%zu, Size=%" PRIu64, memTypeIndex, allocationCount, size);`
	`13105`	`+ VMA_DEBUG_LOG_FORMAT(" AllocateMemory: MemoryTypeIndex=%" PRIu32 ", AllocationCount=%zu, Size=%" PRIu64, memTypeIndex, allocationCount, size);`
`13106`	`13106`
`13107`	`13107`	`VmaAllocationCreateInfo finalCreateInfo = createInfo;`
`13108`	`13108`	`VkResult res = CalcMemTypeParams(`
`@@ -13348,7 +13348,7 @@ VkResult VmaAllocator_T::AllocateDedicatedMemory(`
`13348`	`13348`	`{`
`13349`	`13349`	`dedicatedAllocations.Register(pAllocations[allocIndex]);`
`13350`	`13350`	`}`
`13351`		`- VMA_DEBUG_LOG_FORMAT(" Allocated DedicatedMemory Count=%zu, MemoryTypeIndex=#%u", allocationCount, memTypeIndex);`
	`13351`	`+ VMA_DEBUG_LOG_FORMAT(" Allocated DedicatedMemory Count=%zu, MemoryTypeIndex=#%" PRIu32, allocationCount, memTypeIndex);`
`13352`	`13352`	`}`
`13353`	`13353`	`else`
`13354`	`13354`	`{`
`@@ -13925,7 +13925,7 @@ void VmaAllocator_T::GetAllocationInfo2(VmaAllocation hAllocation, VmaAllocation`
`13925`	`13925`
`13926`	`13926`	`VkResult VmaAllocator_T::CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool)`
`13927`	`13927`	`{`
`13928`		`- VMA_DEBUG_LOG_FORMAT(" CreatePool: MemoryTypeIndex=%u, flags=%u", pCreateInfo->memoryTypeIndex, pCreateInfo->flags);`
	`13928`	`+ VMA_DEBUG_LOG_FORMAT(" CreatePool: MemoryTypeIndex=%" PRIu32 ", flags=%" PRIu32, pCreateInfo->memoryTypeIndex, pCreateInfo->flags);`
`13929`	`13929`
`13930`	`13930`	`VmaPoolCreateInfo newCreateInfo = *pCreateInfo;`
`13931`	`13931`
`@@ -14442,7 +14442,7 @@ void VmaAllocator_T::FreeDedicatedMemory(const VmaAllocation allocation)`
`14442`	`14442`	`m_Budget.RemoveAllocation(MemoryTypeIndexToHeapIndex(allocation->GetMemoryTypeIndex()), allocation->GetSize());`
`14443`	`14443`	`m_AllocationObjectAllocator.Free(allocation);`
`14444`	`14444`
`14445`		`- VMA_DEBUG_LOG_FORMAT(" Freed DedicatedMemory MemoryTypeIndex=%u", memTypeIndex);`
	`14445`	`+ VMA_DEBUG_LOG_FORMAT(" Freed DedicatedMemory MemoryTypeIndex=%" PRIu32, memTypeIndex);`
`14446`	`14446`	`}`
`14447`	`14447`
`14448`	`14448`	`uint32_t VmaAllocator_T::CalculateGpuDefragmentationMemoryTypeBits() const`