First prototype support for VK_KHR_ray_tracing
Added symbols: vmaCreateAccelerationStructure, vmaDestroyAccelerationStructure.
diff --git a/README.md b/README.md
index e6ef0c0..07f5889 100644
--- a/README.md
+++ b/README.md
@@ -51,6 +51,7 @@
- VK_KHR_dedicated_allocation: Just enable it and it will be used automatically by the library.
- VK_AMD_device_coherent_memory
- VK_EXT_buffer_device_address / VK_KHR_buffer_device_address
+ - VK_KHR_ray_tracing
- Defragmentation of GPU and CPU memory: Let the library move data around to free some memory blocks and make your allocations better compacted.
- Lost allocations: Allocate memory with appropriate flags and let the library remove allocations that are not used for many frames to make room for new ones.
- Statistics: Obtain detailed statistics about the amount of memory used, unused, number of allocated blocks, number of allocations etc. - globally, per memory heap, and per memory type.
diff --git a/src/VmaUsage.h b/src/VmaUsage.h
index 9adcdc9..67a9750 100644
--- a/src/VmaUsage.h
+++ b/src/VmaUsage.h
@@ -29,6 +29,7 @@
#define WIN32_LEAN_AND_MEAN
#include <Windows.h>
#define VK_USE_PLATFORM_WIN32_KHR
+#define VK_ENABLE_BETA_EXTENSIONS
#else // #ifdef _WIN32
diff --git a/src/vk_mem_alloc.h b/src/vk_mem_alloc.h
index 92a126c..4f1a31b 100644
--- a/src/vk_mem_alloc.h
+++ b/src/vk_mem_alloc.h
@@ -1945,6 +1945,12 @@
#define VMA_CALL_POST
#endif
+#ifndef VMA_DECORATE_RAY_TRACING
+ #define VMA_DECORATE_RAY_TRACING(identifier) identifier##KHR
+ #define VMA_DECORATE_RAY_TRACING_CONSTANT(identifier) identifier##_KHR
+ #define VMA_DECORATE_RAY_TRACING_STRING(str) str "KHR"
+#endif
+
/** \struct VmaAllocator
\brief Represents main object of this library initialized.
@@ -2116,6 +2122,10 @@
#if VMA_MEMORY_BUDGET || VMA_VULKAN_VERSION >= 1001000
PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR;
#endif
+ VMA_DECORATE_RAY_TRACING(PFN_vkCreateAccelerationStructure) VMA_DECORATE_RAY_TRACING(vkCreateAccelerationStructure);
+ VMA_DECORATE_RAY_TRACING(PFN_vkDestroyAccelerationStructure) VMA_DECORATE_RAY_TRACING(vkDestroyAccelerationStructure);
+ VMA_DECORATE_RAY_TRACING(PFN_vkGetAccelerationStructureMemoryRequirements) VMA_DECORATE_RAY_TRACING(vkGetAccelerationStructureMemoryRequirements);
+ VMA_DECORATE_RAY_TRACING(PFN_vkBindAccelerationStructureMemory) VMA_DECORATE_RAY_TRACING(vkBindAccelerationStructureMemory);
} VmaVulkanFunctions;
/// Flags to be used in VmaRecordSettings::flags.
@@ -3663,6 +3673,27 @@
VkImage image,
VmaAllocation allocation);
+/** \brief TODO
+
+TODO
+*/
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAccelerationStructure(
+ VmaAllocator allocator,
+ const VMA_DECORATE_RAY_TRACING(VkAccelerationStructureCreateInfo)* pAccelerationStructureCreateInfo,
+ const VmaAllocationCreateInfo* pAllocationCreateInfo,
+ VMA_DECORATE_RAY_TRACING(VkAccelerationStructure)* pAccelerationStructure,
+ VmaAllocation* pAllocation,
+ VmaAllocationInfo* pAllocationInfo);
+
+/** \brief TODO
+
+TODO
+*/
+VMA_CALL_PRE void VMA_CALL_POST vmaDestroyAccelerationStructure(
+ VmaAllocator allocator,
+ VMA_DECORATE_RAY_TRACING(VkAccelerationStructure) accelerationStructrure,
+ VmaAllocation allocation);
+
#ifdef __cplusplus
}
#endif
@@ -4234,9 +4265,10 @@
VMA_SUBALLOCATION_TYPE_FREE = 0,
VMA_SUBALLOCATION_TYPE_UNKNOWN = 1,
VMA_SUBALLOCATION_TYPE_BUFFER = 2,
- VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN = 3,
- VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR = 4,
- VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL = 5,
+ VMA_SUBALLOCATION_TYPE_ACCELERATION_STRUCTURE = 3,
+ VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN = 4,
+ VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR = 5,
+ VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL = 6,
VMA_SUBALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
};
@@ -4262,6 +4294,7 @@
case VMA_SUBALLOCATION_TYPE_UNKNOWN:
return true;
case VMA_SUBALLOCATION_TYPE_BUFFER:
+ case VMA_SUBALLOCATION_TYPE_ACCELERATION_STRUCTURE:
return
suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
@@ -6437,6 +6470,12 @@
VkDeviceSize allocationLocalOffset,
VkImage hImage,
const void* pNext);
+ VkResult BindAccelerationStructureMemory(
+ const VmaAllocator hAllocator,
+ const VmaAllocation hAllocation,
+ VkDeviceSize allocationLocalOffset,
+ VMA_DECORATE_RAY_TRACING(VkAccelerationStructure) hAccelerationStructure,
+ const void* pNext);
private:
VmaPool m_hParentPool; // VK_NULL_HANDLE if not belongs to custom pool.
@@ -7410,6 +7449,10 @@
VkMemoryRequirements& memReq,
bool& requiresDedicatedAllocation,
bool& prefersDedicatedAllocation) const;
+ void GetAccelerationStructureMemoryRequirements(
+ VMA_DECORATE_RAY_TRACING(VkAccelerationStructureMemoryRequirementsType) type,
+ VMA_DECORATE_RAY_TRACING(VkAccelerationStructure) hAccelerationStructure,
+ VkMemoryRequirements& memReq) const;
// Main allocation function.
VkResult AllocateMemory(
@@ -7489,6 +7532,12 @@
VkDeviceSize memoryOffset,
VkImage image,
const void* pNext);
+ // Call to Vulkan function vkBindAccelerationStructureMemoryKHR
+ VkResult BindVulkanAccelerationStructure(
+ VkDeviceMemory memory,
+ VkDeviceSize memoryOffset,
+ VMA_DECORATE_RAY_TRACING(VkAccelerationStructure) accelerationStructure,
+ const void* pNext);
VkResult Map(VmaAllocation hAllocation, void** ppData);
void Unmap(VmaAllocation hAllocation);
@@ -7503,6 +7552,11 @@
VkDeviceSize allocationLocalOffset,
VkImage hImage,
const void* pNext);
+ VkResult BindAccelerationStructureMemory(
+ VmaAllocation hAllocation,
+ VkDeviceSize allocationLocalOffset,
+ VMA_DECORATE_RAY_TRACING(VkAccelerationStructure) hAccelerationStructure,
+ const void* pNext);
void FlushOrInvalidateAllocation(
VmaAllocation hAllocation,
@@ -8156,6 +8210,7 @@
"FREE",
"UNKNOWN",
"BUFFER",
+ "ACCELERATION_STRUCTURE",
"IMAGE_UNKNOWN",
"IMAGE_LINEAR",
"IMAGE_OPTIMAL",
@@ -11964,6 +12019,23 @@
return hAllocator->BindVulkanImage(m_hMemory, memoryOffset, hImage, pNext);
}
+VkResult VmaDeviceMemoryBlock::BindAccelerationStructureMemory(
+ const VmaAllocator hAllocator,
+ const VmaAllocation hAllocation,
+ VkDeviceSize allocationLocalOffset,
+ VMA_DECORATE_RAY_TRACING(VkAccelerationStructure) hAccelerationStructure,
+ const void* pNext)
+{
+ VMA_ASSERT(hAllocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK &&
+ hAllocation->GetBlock() == this);
+ VMA_ASSERT(allocationLocalOffset < hAllocation->GetSize() &&
+ "Invalid allocationLocalOffset. Did you forget that this offset is relative to the beginning of the allocation, not the whole memory block?");
+ const VkDeviceSize memoryOffset = hAllocation->GetOffset() + allocationLocalOffset;
+ // This lock is important so that we don't call vkBind... and/or vkMap... simultaneously on the same VkDeviceMemory from multiple threads.
+ VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
+ return hAllocator->BindVulkanAccelerationStructure(m_hMemory, memoryOffset, hAccelerationStructure, pNext);
+}
+
static void InitStatInfo(VmaStatInfo& outInfo)
{
memset(&outInfo, 0, sizeof(outInfo));
@@ -15357,6 +15429,14 @@
}
}
#endif // #if VMA_MEMORY_BUDGET
+ m_VulkanFunctions.VMA_DECORATE_RAY_TRACING(vkCreateAccelerationStructure) =
+ (VMA_DECORATE_RAY_TRACING(PFN_vkCreateAccelerationStructure))vkGetDeviceProcAddr(m_hDevice, VMA_DECORATE_RAY_TRACING_STRING("vkCreateAccelerationStructure"));
+ m_VulkanFunctions.VMA_DECORATE_RAY_TRACING(vkDestroyAccelerationStructure) =
+ (PFN_vkDestroyAccelerationStructureNV)vkGetDeviceProcAddr(m_hDevice, VMA_DECORATE_RAY_TRACING_STRING("vkDestroyAccelerationStructure"));
+ m_VulkanFunctions.VMA_DECORATE_RAY_TRACING(vkGetAccelerationStructureMemoryRequirements) =
+ (PFN_vkGetAccelerationStructureMemoryRequirementsNV)vkGetDeviceProcAddr(m_hDevice, VMA_DECORATE_RAY_TRACING_STRING("vkGetAccelerationStructureMemoryRequirements"));
+ m_VulkanFunctions.VMA_DECORATE_RAY_TRACING(vkBindAccelerationStructureMemory) =
+ (PFN_vkBindAccelerationStructureMemoryNV)vkGetDeviceProcAddr(m_hDevice, VMA_DECORATE_RAY_TRACING_STRING("vkBindAccelerationStructureMemory"));
#endif // #if VMA_STATIC_VULKAN_FUNCTIONS == 1
#define VMA_COPY_IF_NOT_NULL(funcName) \
@@ -15392,6 +15472,10 @@
#if VMA_MEMORY_BUDGET
VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceMemoryProperties2KHR);
#endif
+ VMA_COPY_IF_NOT_NULL(VMA_DECORATE_RAY_TRACING(vkCreateAccelerationStructure));
+ VMA_COPY_IF_NOT_NULL(VMA_DECORATE_RAY_TRACING(vkDestroyAccelerationStructure));
+ VMA_COPY_IF_NOT_NULL(VMA_DECORATE_RAY_TRACING(vkGetAccelerationStructureMemoryRequirements));
+ VMA_COPY_IF_NOT_NULL(VMA_DECORATE_RAY_TRACING(vkBindAccelerationStructureMemory));
}
#undef VMA_COPY_IF_NOT_NULL
@@ -15435,6 +15519,10 @@
VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties2KHR != VMA_NULL);
}
#endif
+ VMA_ASSERT(m_VulkanFunctions.VMA_DECORATE_RAY_TRACING(vkCreateAccelerationStructure) != VMA_NULL);
+ VMA_ASSERT(m_VulkanFunctions.VMA_DECORATE_RAY_TRACING(vkDestroyAccelerationStructure) != VMA_NULL);
+ VMA_ASSERT(m_VulkanFunctions.VMA_DECORATE_RAY_TRACING(vkGetAccelerationStructureMemoryRequirements) != VMA_NULL);
+ VMA_ASSERT(m_VulkanFunctions.VMA_DECORATE_RAY_TRACING(vkBindAccelerationStructureMemory) != VMA_NULL);
}
VkDeviceSize VmaAllocator_T::CalcPreferredBlockSize(uint32_t memTypeIndex)
@@ -15813,6 +15901,22 @@
}
}
+void VmaAllocator_T::GetAccelerationStructureMemoryRequirements(
+ VMA_DECORATE_RAY_TRACING(VkAccelerationStructureMemoryRequirementsType) type,
+ VMA_DECORATE_RAY_TRACING(VkAccelerationStructure) hAccelerationStructure,
+ VkMemoryRequirements& memReq) const
+{
+ VMA_DECORATE_RAY_TRACING(VkAccelerationStructureMemoryRequirementsInfo) memReqInfo = { VMA_DECORATE_RAY_TRACING_CONSTANT(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO) };
+ memReqInfo.type = VMA_DECORATE_RAY_TRACING_CONSTANT(VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT);
+ memReqInfo.accelerationStructure = hAccelerationStructure;
+
+ VkMemoryRequirements2 memReq2 = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 };
+
+ (*m_VulkanFunctions.VMA_DECORATE_RAY_TRACING(vkGetAccelerationStructureMemoryRequirements))(m_hDevice, &memReqInfo, &memReq2);
+
+ memReq = memReq2.memoryRequirements;
+}
+
VkResult VmaAllocator_T::AllocateMemory(
const VkMemoryRequirements& vkMemReq,
bool requiresDedicatedAllocation,
@@ -16583,6 +16687,20 @@
}
}
+VkResult VmaAllocator_T::BindVulkanAccelerationStructure(
+ VkDeviceMemory memory,
+ VkDeviceSize memoryOffset,
+ VMA_DECORATE_RAY_TRACING(VkAccelerationStructure) accelerationStructure,
+ const void* pNext)
+{
+ VMA_DECORATE_RAY_TRACING(VkBindAccelerationStructureMemoryInfo) bindInfo = { VMA_DECORATE_RAY_TRACING_CONSTANT(VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO) };
+ bindInfo.pNext = pNext;
+ bindInfo.accelerationStructure = accelerationStructure;
+ bindInfo.memory = memory;
+ bindInfo.memoryOffset = memoryOffset;
+ return (*m_VulkanFunctions.VMA_DECORATE_RAY_TRACING(vkBindAccelerationStructureMemory))(m_hDevice, 1, &bindInfo);
+}
+
VkResult VmaAllocator_T::Map(VmaAllocation hAllocation, void** ppData)
{
if(hAllocation->CanBecomeLost())
@@ -16681,6 +16799,31 @@
return res;
}
+VkResult VmaAllocator_T::BindAccelerationStructureMemory(
+ VmaAllocation hAllocation,
+ VkDeviceSize allocationLocalOffset,
+ VMA_DECORATE_RAY_TRACING(VkAccelerationStructure) hAccelerationStructure,
+ const void* pNext)
+{
+ VkResult res = VK_SUCCESS;
+ switch(hAllocation->GetType())
+ {
+ case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
+ res = BindVulkanAccelerationStructure(hAllocation->GetMemory(), allocationLocalOffset, hAccelerationStructure, pNext);
+ break;
+ case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
+ {
+ VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
+ VMA_ASSERT(pBlock && "Binding acceleration structure to allocation that doesn't belong to any block. Is the allocation lost?");
+ res = pBlock->BindAccelerationStructureMemory(this, hAllocation, allocationLocalOffset, hAccelerationStructure, pNext);
+ break;
+ }
+ default:
+ VMA_ASSERT(0);
+ }
+ return res;
+}
+
void VmaAllocator_T::FlushOrInvalidateAllocation(
VmaAllocation hAllocation,
VkDeviceSize offset, VkDeviceSize size,
@@ -18460,4 +18603,124 @@
}
}
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAccelerationStructure(
+ VmaAllocator allocator,
+ const VMA_DECORATE_RAY_TRACING(VkAccelerationStructureCreateInfo)* pAccelerationStructureCreateInfo,
+ const VmaAllocationCreateInfo* pAllocationCreateInfo,
+ VMA_DECORATE_RAY_TRACING(VkAccelerationStructure)* pAccelerationStructure,
+ VmaAllocation* pAllocation,
+ VmaAllocationInfo* pAllocationInfo)
+{
+ VMA_ASSERT(allocator && pAccelerationStructureCreateInfo && pAllocationCreateInfo && pAccelerationStructure && pAllocation);
+
+ VMA_DEBUG_LOG("vmaCreateAccelerationStructure");
+
+ VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+ *pAccelerationStructure = VK_NULL_HANDLE;
+ *pAllocation = VK_NULL_HANDLE;
+
+ // 1. Create VkAccelerationStructureKHR.
+ VkResult res = (*allocator->GetVulkanFunctions().VMA_DECORATE_RAY_TRACING(vkCreateAccelerationStructure))(
+ allocator->m_hDevice,
+ pAccelerationStructureCreateInfo,
+ allocator->GetAllocationCallbacks(),
+ pAccelerationStructure);
+ if(res >= 0)
+ {
+ // 2. vkGetAccelerationStructureMemoryRequirements.
+ VkMemoryRequirements vkMemReq = {};
+ const bool requiresDedicatedAllocation = false;
+ const bool prefersDedicatedAllocation = false;
+ allocator->GetAccelerationStructureMemoryRequirements(
+ VMA_DECORATE_RAY_TRACING_CONSTANT(VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT),
+ *pAccelerationStructure, vkMemReq);
+
+ // 3. Allocate memory using allocator.
+ res = allocator->AllocateMemory(
+ vkMemReq,
+ requiresDedicatedAllocation,
+ prefersDedicatedAllocation,
+ VK_NULL_HANDLE, // dedicatedBuffer
+ UINT32_MAX, // dedicatedBufferUsage
+ VK_NULL_HANDLE, // dedicatedImage
+ *pAllocationCreateInfo,
+ VMA_SUBALLOCATION_TYPE_ACCELERATION_STRUCTURE,
+ 1, // allocationCount
+ pAllocation);
+
+#if VMA_RECORDING_ENABLED
+ if(allocator->GetRecorder() != VMA_NULL)
+ {
+ // TODO
+ }
+#endif
+
+ if(res >= 0)
+ {
+ // 3. Bind acceleration structure with memory.
+ if((pAllocationCreateInfo->flags & VMA_ALLOCATION_CREATE_DONT_BIND_BIT) == 0)
+ {
+ res = allocator->BindAccelerationStructureMemory(*pAllocation, 0, *pAccelerationStructure, VMA_NULL);
+ }
+ if(res >= 0)
+ {
+ // All steps succeeded.
+ if(pAllocationInfo != VMA_NULL)
+ {
+ allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
+ }
+
+ return VK_SUCCESS;
+ }
+ allocator->FreeMemory(
+ 1, // allocationCount
+ pAllocation);
+ *pAllocation = VK_NULL_HANDLE;
+ (*allocator->GetVulkanFunctions().VMA_DECORATE_RAY_TRACING(vkDestroyAccelerationStructure))(allocator->m_hDevice, *pAccelerationStructure, allocator->GetAllocationCallbacks());
+ *pAccelerationStructure = VK_NULL_HANDLE;
+ return res;
+ }
+ (*allocator->GetVulkanFunctions().VMA_DECORATE_RAY_TRACING(vkDestroyAccelerationStructure))(allocator->m_hDevice, *pAccelerationStructure, allocator->GetAllocationCallbacks());
+ *pAccelerationStructure = VK_NULL_HANDLE;
+ return res;
+ }
+ return res;
+}
+
+VMA_CALL_PRE void VMA_CALL_POST vmaDestroyAccelerationStructure(
+ VmaAllocator allocator,
+ VMA_DECORATE_RAY_TRACING(VkAccelerationStructure) accelerationStructure,
+ VmaAllocation allocation)
+{
+ VMA_ASSERT(allocator);
+
+ if(accelerationStructure == VK_NULL_HANDLE && allocation == VK_NULL_HANDLE)
+ {
+ return;
+ }
+
+ VMA_DEBUG_LOG("vmaDestroyAccelerationStructure");
+
+ VMA_DEBUG_GLOBAL_MUTEX_LOCK
+
+#if VMA_RECORDING_ENABLED
+ if(allocator->GetRecorder() != VMA_NULL)
+ {
+ // TODO
+ }
+#endif
+
+ if(accelerationStructure != VK_NULL_HANDLE)
+ {
+ (*allocator->GetVulkanFunctions().VMA_DECORATE_RAY_TRACING(vkDestroyAccelerationStructure))(allocator->m_hDevice, accelerationStructure, allocator->GetAllocationCallbacks());
+ }
+ if(allocation != VK_NULL_HANDLE)
+ {
+ allocator->FreeMemory(
+ 1, // allocationCount
+ &allocation);
+ }
+}
+
#endif // #ifdef VMA_IMPLEMENTATION
