Added "E_MEMORY_ALLOCATE_FLAGS" and necessary validations and deductions.

Author: Erfan-Ahmadi

include/nbl/video/IDriverMemoryAllocation.h

@@ -89,6 +89,15 @@ class IDriverMemoryAllocation : public virtual core::IReferenceCounted
             EMCF_CACHED=0x08u, ///< whether mapping is cached, i.e. if cpu reads go through cache, this is relevant to Vulkan only and is transparent to program operation.
         };
 
+        //! Memory allocate flags
+        enum E_MEMORY_ALLOCATE_FLAGS
+        {
+            EMAF_NONE = 0x00000000,
+            EMAF_DEVICE_MASK_BIT = 0x00000001,
+            EMAF_DEVICE_ADDRESS_BIT = 0x00000002,
+            EMAF_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000004,
+        };
+
         E_API_TYPE getAPIType() const;
 
         //! Where the memory was actually allocated
@@ -117,6 +126,9 @@ class IDriverMemoryAllocation : public virtual core::IReferenceCounted
 
         //!
         inline E_MAPPING_CPU_ACCESS_FLAG getCurrentMappingCaps() const {return currentMappingAccess;}
+        
+        //!
+        inline core::bitflag<E_MEMORY_ALLOCATE_FLAGS> getAllocateFlags() const {return allocateFlags;}
 
         inline bool isCurrentlyMapped() const { return mappedPtr != nullptr; }
 
@@ -143,15 +155,16 @@ class IDriverMemoryAllocation : public virtual core::IReferenceCounted
             currentMappingAccess = access;
         }
 
-        IDriverMemoryAllocation(const ILogicalDevice* originDevice)
+        IDriverMemoryAllocation(const ILogicalDevice* originDevice, core::bitflag<E_MEMORY_ALLOCATE_FLAGS> flags = E_MEMORY_ALLOCATE_FLAGS::EMAF_NONE)
             : m_originDevice(originDevice), mappedPtr(nullptr), mappedRange(0,0),
-            currentMappingAccess(EMCAF_NO_MAPPING_ACCESS)
+            currentMappingAccess(EMCAF_NO_MAPPING_ACCESS), allocateFlags(flags)
         {}
 
         const ILogicalDevice* m_originDevice = nullptr;
         uint8_t* mappedPtr;
         MemoryRange                 mappedRange;
         E_MAPPING_CPU_ACCESS_FLAG   currentMappingAccess;
+        core::bitflag<E_MEMORY_ALLOCATE_FLAGS> allocateFlags;
 };
 
 } // end namespace nbl::video

include/nbl/video/ILogicalDevice.h

@@ -248,7 +248,7 @@ class ILogicalDevice : public core::IReferenceCounted
         //! Should be just as fast to play around with on the CPU as regular malloc'ed memory, but slowest to access with GPU
         virtual core::smart_refctd_ptr<IDriverMemoryAllocation> allocateCPUSideGPUVisibleMemory(const IDriverMemoryBacked::SDriverMemoryRequirements& additionalReqs) { return nullptr; }
 
-        virtual core::smart_refctd_ptr<IDriverMemoryAllocation> allocateGPUMemory(const IDriverMemoryBacked::SDriverMemoryRequirements& reqs) { return nullptr; }
+        virtual core::smart_refctd_ptr<IDriverMemoryAllocation> allocateGPUMemory(const IDriverMemoryBacked::SDriverMemoryRequirements& reqs, core::bitflag<IDriverMemoryAllocation::E_MEMORY_ALLOCATE_FLAGS> allocateFlags = IDriverMemoryAllocation::EMAF_NONE) { return nullptr; }
 
         //! For memory allocations without the video::IDriverMemoryAllocation::EMCF_COHERENT mapping capability flag you need to call this for the CPU writes to become GPU visible
         void flushMappedMemoryRanges(uint32_t memoryRangeCount, const video::IDriverMemoryAllocation::MappedMemoryRange* pMemoryRanges)

src/nbl/video/CVulkanLogicalDevice.cpp

@@ -146,7 +146,8 @@ core::smart_refctd_ptr<IDriverMemoryAllocation> CVulkanLogicalDevice::allocateCP
 }
 
 core::smart_refctd_ptr<IDriverMemoryAllocation> CVulkanLogicalDevice::allocateGPUMemory(
-    const IDriverMemoryBacked::SDriverMemoryRequirements& reqs)
+    const IDriverMemoryBacked::SDriverMemoryRequirements& reqs,
+    core::bitflag<IDriverMemoryAllocation::E_MEMORY_ALLOCATE_FLAGS> allocateFlags)
 {
     VkMemoryPropertyFlags desiredMemoryProperties = static_cast<VkMemoryPropertyFlags>(0u);
 
@@ -182,17 +183,25 @@ core::smart_refctd_ptr<IDriverMemoryAllocation> CVulkanLogicalDevice::allocateGP
     for (uint32_t i = 0u; i < compatibleMemoryTypeCount; ++i)
     {
         // Todo(achal): Make use of requiresDedicatedAllocation and prefersDedicatedAllocation
+        VkMemoryAllocateFlagsInfo vk_allocateFlags = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, nullptr };
+        if (allocateFlags.hasValue(IDriverMemoryAllocation::EMAF_DEVICE_MASK_BIT))
+            vk_allocateFlags.flags |= VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT;
+        else if(allocateFlags.hasValue(IDriverMemoryAllocation::EMAF_DEVICE_ADDRESS_BIT))
+            vk_allocateFlags.flags |= VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT;
+        else if (allocateFlags.hasValue(IDriverMemoryAllocation::EMAF_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT))
+            vk_allocateFlags.flags |= VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT;
+        vk_allocateFlags.deviceMask = 0u; // unused
 
         VkMemoryAllocateInfo vk_allocateInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
-        vk_allocateInfo.pNext = nullptr; // No extensions for now
+        vk_allocateInfo.pNext = &vk_allocateFlags; // No extensions for now
         vk_allocateInfo.allocationSize = reqs.vulkanReqs.size;
         vk_allocateInfo.memoryTypeIndex = compatibleMemoryTypeIndices[i];
 
         VkDeviceMemory vk_deviceMemory;
         if (m_devf.vk.vkAllocateMemory(m_vkdev, &vk_allocateInfo, nullptr, &vk_deviceMemory) == VK_SUCCESS)
         {
             // Todo(achal): Change dedicate to not always be false
-            return core::make_smart_refctd_ptr<CVulkanMemoryAllocation>(this, reqs.vulkanReqs.size, false, vk_deviceMemory);
+            return core::make_smart_refctd_ptr<CVulkanMemoryAllocation>(this, reqs.vulkanReqs.size, false, vk_deviceMemory, allocateFlags);
         }
     }
 

src/nbl/video/CVulkanLogicalDevice.h

@@ -514,6 +514,17 @@ class CVulkanLogicalDevice final : public ILogicalDevice
             if ((bindInfo.buffer->getAPIType() != EAT_VULKAN) || (bindInfo.memory->getAPIType() != EAT_VULKAN))
                 continue;
 
+            if (bindInfo.buffer->getCachedCreationParams().usage.hasValue(asset::IBuffer::EUF_SHADER_DEVICE_ADDRESS_BIT))
+            {
+                if(!bindInfo.memory->getAllocateFlags().hasValue(IDriverMemoryAllocation::EMAF_DEVICE_ADDRESS_BIT))
+                {
+                    // TODO(erfan): Log-> if buffer was created with EUF_SHADER_DEVICE_ADDRESS_BIT set, memory must have been allocated with the EMAF_DEVICE_ADDRESS_BIT bit.
+                    _NBL_DEBUG_BREAK_IF(false);
+                    anyFailed = true;
+                    continue;
+                }
+            }
+
             CVulkanBuffer* vulkanBuffer = static_cast<CVulkanBuffer*>(bindInfo.buffer);
             vulkanBuffer->setMemoryAndOffset(
                 core::smart_refctd_ptr<IDriverMemoryAllocation>(bindInfo.memory), bindInfo.offset);
@@ -523,6 +534,7 @@ class CVulkanLogicalDevice final : public ILogicalDevice
             if (m_devf.vk.vkBindBufferMemory(m_vkdev, vk_buffer, vk_memory, static_cast<VkDeviceSize>(pBindInfos[i].offset)) != VK_SUCCESS)
             {
                 // Todo(achal): Log which one failed
+                _NBL_DEBUG_BREAK_IF(false);
                 anyFailed = true;
             }
         }   
@@ -591,8 +603,13 @@ class CVulkanLogicalDevice final : public ILogicalDevice
         memoryReqs.memoryHeapLocation = additionalMemoryReqs.memoryHeapLocation;
         memoryReqs.mappingCapability = additionalMemoryReqs.mappingCapability;
 
+        core::bitflag<IDriverMemoryAllocation::E_MEMORY_ALLOCATE_FLAGS> allocateFlags;
+
+        if(creationParams.usage.hasValue(asset::IBuffer::EUF_SHADER_DEVICE_ADDRESS_BIT))
+            allocateFlags |= IDriverMemoryAllocation::EMAF_DEVICE_ADDRESS_BIT;
+
         core::smart_refctd_ptr<video::IDriverMemoryAllocation> bufferMemory =
-            allocateGPUMemory(memoryReqs);
+            allocateGPUMemory(memoryReqs, allocateFlags);
 
         if (!bufferMemory)
             return nullptr;
@@ -910,7 +927,7 @@ class CVulkanLogicalDevice final : public ILogicalDevice
         const IDriverMemoryBacked::SDriverMemoryRequirements& additionalReqs) override;
 
     core::smart_refctd_ptr<IDriverMemoryAllocation> allocateGPUMemory(
-        const IDriverMemoryBacked::SDriverMemoryRequirements& reqs) override;
+        const IDriverMemoryBacked::SDriverMemoryRequirements& reqs, core::bitflag<IDriverMemoryAllocation::E_MEMORY_ALLOCATE_FLAGS> allocateFlags = IDriverMemoryAllocation::EMAF_NONE) override;
 
     core::smart_refctd_ptr<IGPUSampler> createGPUSampler(const IGPUSampler::SParams& _params) override
     {

src/nbl/video/CVulkanMemoryAllocation.h

@@ -12,8 +12,8 @@ class ILogicalDevice;
 class CVulkanMemoryAllocation : public IDriverMemoryAllocation
 {
 public:
-    CVulkanMemoryAllocation(ILogicalDevice* dev, size_t size, bool isDedicated, VkDeviceMemory deviceMemoryHandle)
-        : IDriverMemoryAllocation(dev), m_size(size), m_isDedicated(isDedicated), m_deviceMemoryHandle(deviceMemoryHandle)
+    CVulkanMemoryAllocation(ILogicalDevice* dev, size_t size, bool isDedicated, VkDeviceMemory deviceMemoryHandle, core::bitflag<IDriverMemoryAllocation::E_MEMORY_ALLOCATE_FLAGS> flags = E_MEMORY_ALLOCATE_FLAGS::EMAF_NONE)
+        : IDriverMemoryAllocation(dev, flags), m_size(size), m_isDedicated(isDedicated), m_deviceMemoryHandle(deviceMemoryHandle)
     {}
 
     ~CVulkanMemoryAllocation();