Cuda interop vk13

include/nbl/video/CCUDASharedMemory.h

@@ -49,7 +49,7 @@ class CCUDASharedMemory : public core::IReferenceCounted
 
     core::smart_refctd_ptr<IDeviceMemoryAllocation> exportAsMemory(ILogicalDevice* device, IDeviceMemoryBacked* dedication = nullptr) const;
 
-    core::smart_refctd_ptr<IGPUImage>  exportAsImage(ILogicalDevice* device, asset::IImage::SCreationParams&& params) const;
+    core::smart_refctd_ptr<IGPUImage>  createAndBindImage(ILogicalDevice* device, IGPUImage::SCreationParams&& params) const;
 
 protected:
 

include/nbl/video/CVulkanDeviceMemoryBacked.h

@@ -35,11 +35,11 @@ class CVulkanDeviceMemoryBacked : public Interface
 	protected:
 		// special constructor for when memory requirements are known up-front (so far only swapchains and internal forwarding here)
 		CVulkanDeviceMemoryBacked(const CVulkanLogicalDevice* dev, Interface::SCreationParams&& _creationParams, const IDeviceMemoryBacked::SDeviceMemoryRequirements& _memReqs, const VkResource_t vkHandle);
-		CVulkanDeviceMemoryBacked(const CVulkanLogicalDevice* dev, Interface::SCreationParams&& _creationParams, const VkResource_t vkHandle) :
-			CVulkanDeviceMemoryBacked(dev,std::move(_creationParams),obtainRequirements(dev,vkHandle),vkHandle) {}
+		CVulkanDeviceMemoryBacked(const CVulkanLogicalDevice* dev, Interface::SCreationParams&& _creationParams, bool dedicatedOnly, const VkResource_t vkHandle) :
+			CVulkanDeviceMemoryBacked(dev,std::move(_creationParams), obtainRequirements(dev, dedicatedOnly, vkHandle),vkHandle) {}
 
 	private:
-		static IDeviceMemoryBacked::SDeviceMemoryRequirements obtainRequirements(const CVulkanLogicalDevice* device, const VkResource_t vkHandle);
+		static IDeviceMemoryBacked::SDeviceMemoryRequirements obtainRequirements(const CVulkanLogicalDevice* device, bool dedicatedOnly, const VkResource_t vkHandle);
 
 		core::smart_refctd_ptr<IDeviceMemoryAllocation> m_memory = nullptr;
 		size_t m_offset = 0u;

include/nbl/video/IPhysicalDevice.h

@@ -793,11 +793,12 @@ class NBL_API2 IPhysicalDevice : public core::Interface, public core::Unmovable
         SExternalImageFormatProperties getExternalImageProperties(
             asset::E_FORMAT format, 
             IGPUImage::TILING tiling, 
+            IGPUImage::E_TYPE type,
             core::bitflag<IGPUImage::E_USAGE_FLAGS> usage, 
             core::bitflag<IGPUImage::E_CREATE_FLAGS> flags, 
             IDeviceMemoryAllocation::E_EXTERNAL_HANDLE_TYPE handleType) const
         {
-            auto key = std::tuple{ format, tiling, usage, flags, handleType };
+            auto key = std::tuple{ format, tiling, type, usage, flags, handleType };
             {
                 std::shared_lock lock(m_externalImagePropertiesMutex);
                 auto it = m_externalImageProperties.find(key);
@@ -806,7 +807,7 @@ class NBL_API2 IPhysicalDevice : public core::Interface, public core::Unmovable
             }
 
             std::unique_lock lock(m_externalImagePropertiesMutex);
-            return m_externalImageProperties[key] = getExternalImageProperties_impl(format, tiling, usage, flags, handleType);
+            return m_externalImageProperties[key] = getExternalImageProperties_impl(format, tiling, type, usage, flags, handleType);
         }
 
     protected:
@@ -878,6 +879,7 @@ class NBL_API2 IPhysicalDevice : public core::Interface, public core::Unmovable
         virtual SExternalImageFormatProperties getExternalImageProperties_impl(
             asset::E_FORMAT format, 
             IGPUImage::TILING tiling, 
+            IGPUImage::E_TYPE type,
             core::bitflag<IGPUImage::E_USAGE_FLAGS> usage, 
             core::bitflag<IGPUImage::E_CREATE_FLAGS> flags, 
             IDeviceMemoryAllocation::E_EXTERNAL_HANDLE_TYPE handleType) const = 0;

src/nbl/video/CCUDASharedMemory.cpp

@@ -77,16 +77,12 @@ core::smart_refctd_ptr<IGPUBuffer> CCUDASharedMemory::exportAsBuffer(ILogicalDev
 
 #endif
 
-core::smart_refctd_ptr<IGPUImage>  CCUDASharedMemory::exportAsImage(ILogicalDevice* device, asset::IImage::SCreationParams&& params) const
+core::smart_refctd_ptr<IGPUImage>  CCUDASharedMemory::createAndBindImage(ILogicalDevice* device, IGPUImage::SCreationParams&& params) const
 {
 	if (!device || !m_device->isMatchingDevice(device->getPhysicalDevice()))
 		return nullptr;
 
-	auto img = device->createImage({
-		std::move(params), {{ .externalHandleTypes = CCUDADevice::EXTERNAL_MEMORY_HANDLE_TYPE }},
-		IGPUImage::TILING::LINEAR,
-		1 /*preinitialized*/,
-	});
+	auto img = device->createImage(std::move(params));
 
 	if (exportAsMemory(device, img.get()))
 		return img;

src/nbl/video/CVulkanBuffer.h

@@ -16,7 +16,7 @@ class CVulkanBuffer : public CVulkanDeviceMemoryBacked<IGPUBuffer>
        using base_t = CVulkanDeviceMemoryBacked<IGPUBuffer>;
 
     public:
-        inline CVulkanBuffer(const CVulkanLogicalDevice* dev, IGPUBuffer::SCreationParams&& creationParams, const VkBuffer buffer) : base_t(dev,std::move(creationParams),buffer) {}
+        inline CVulkanBuffer(const CVulkanLogicalDevice* dev, IGPUBuffer::SCreationParams&& creationParams, bool dedicatedOnly, const VkBuffer buffer) : base_t(dev,std::move(creationParams), dedicatedOnly, buffer) {}
 
         void setObjectDebugName(const char* label) const override;
 

src/nbl/video/CVulkanDeviceMemoryBacked.cpp

@@ -6,7 +6,7 @@ namespace nbl::video
 {
 
 template<class Interface>
-IDeviceMemoryBacked::SDeviceMemoryRequirements CVulkanDeviceMemoryBacked<Interface>::obtainRequirements(const CVulkanLogicalDevice* device, const VkResource_t vkHandle)
+IDeviceMemoryBacked::SDeviceMemoryRequirements CVulkanDeviceMemoryBacked<Interface>::obtainRequirements(const CVulkanLogicalDevice* device, bool dedicatedOnly, const VkResource_t vkHandle)
 {    
     const std::conditional_t<IsImage,VkImageMemoryRequirementsInfo2,VkBufferMemoryRequirementsInfo2> vk_memoryRequirementsInfo = {
         IsImage ? VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2:VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,nullptr,vkHandle
@@ -24,8 +24,8 @@ IDeviceMemoryBacked::SDeviceMemoryRequirements CVulkanDeviceMemoryBacked<Interfa
     memoryReqs.size = vk_memoryRequirements.memoryRequirements.size;
     memoryReqs.memoryTypeBits = vk_memoryRequirements.memoryRequirements.memoryTypeBits;
     memoryReqs.alignmentLog2 = std::log2(vk_memoryRequirements.memoryRequirements.alignment);
-    memoryReqs.prefersDedicatedAllocation = vk_dedicatedMemoryRequirements.prefersDedicatedAllocation;
-    memoryReqs.requiresDedicatedAllocation = vk_dedicatedMemoryRequirements.requiresDedicatedAllocation;
+    memoryReqs.prefersDedicatedAllocation  = dedicatedOnly | vk_dedicatedMemoryRequirements.prefersDedicatedAllocation;
+    memoryReqs.requiresDedicatedAllocation = dedicatedOnly | vk_dedicatedMemoryRequirements.requiresDedicatedAllocation;
     return memoryReqs;
 }
 

src/nbl/video/CVulkanLogicalDevice.cpp

@@ -378,7 +378,7 @@ core::smart_refctd_ptr<IGPUBuffer> CVulkanLogicalDevice::createBuffer_impl(IGPUB
     VkBuffer vk_buffer;
     if (m_devf.vk.vkCreateBuffer(m_vkdev,&vk_createInfo,nullptr,&vk_buffer)!=VK_SUCCESS)
         return nullptr;
-    return core::make_smart_refctd_ptr<CVulkanBuffer>(this,std::move(creationParams),vk_buffer);
+    return core::make_smart_refctd_ptr<CVulkanBuffer>(this,std::move(creationParams), dedicatedOnly, vk_buffer);
 }
 
 core::smart_refctd_ptr<IGPUBufferView> CVulkanLogicalDevice::createBufferView_impl(const asset::SBufferRange<const IGPUBuffer>& underlying, const asset::E_FORMAT _fmt)
@@ -399,17 +399,24 @@ core::smart_refctd_ptr<IGPUBufferView> CVulkanLogicalDevice::createBufferView_im
 
 core::smart_refctd_ptr<IGPUImage> CVulkanLogicalDevice::createImage_impl(IGPUImage::SCreationParams&& params)
 {
-    VkImageStencilUsageCreateInfo vk_stencilUsage = { VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, nullptr };
-    vk_stencilUsage.stencilUsage = getVkImageUsageFlagsFromImageUsageFlags(params.actualStencilUsage().value,true);
+    VkExternalMemoryImageCreateInfo  externalMemoryInfo = {
+        .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
+        .handleTypes = params.externalHandleTypes.value,
+    };
+
+    const bool external = params.externalHandleTypes.value;
+
+    VkImageStencilUsageCreateInfo vk_stencilUsage = { VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, &externalMemoryInfo };
+    vk_stencilUsage.stencilUsage = getVkImageUsageFlagsFromImageUsageFlags(params.actualStencilUsage().value, true);
 
-    std::array<VkFormat,asset::E_FORMAT::EF_COUNT> vk_formatList;
+    std::array<VkFormat, asset::E_FORMAT::EF_COUNT> vk_formatList;
     VkImageFormatListCreateInfo vk_formatListStruct = { VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, &vk_stencilUsage };
     vk_formatListStruct.viewFormatCount = 0u;
     // if only there existed a nice iterator that would let me iterate over set bits 64 faster
     if (params.viewFormats.any())
-    for (auto fmt=0; fmt<vk_formatList.size(); fmt++)
-    if (params.viewFormats.test(fmt))
-        vk_formatList[vk_formatListStruct.viewFormatCount++] = getVkFormatFromFormat(static_cast<asset::E_FORMAT>(fmt));
+        for (auto fmt = 0; fmt < vk_formatList.size(); fmt++)
+            if (params.viewFormats.test(fmt))
+                vk_formatList[vk_formatListStruct.viewFormatCount++] = getVkFormatFromFormat(static_cast<asset::E_FORMAT>(fmt));
     vk_formatListStruct.pViewFormats = vk_formatList.data();
 
     VkImageCreateInfo vk_createInfo = { VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, &vk_formatListStruct };
@@ -421,16 +428,45 @@ core::smart_refctd_ptr<IGPUImage> CVulkanLogicalDevice::createImage_impl(IGPUIma
     vk_createInfo.arrayLayers = params.arrayLayers;
     vk_createInfo.samples = static_cast<VkSampleCountFlagBits>(params.samples);
     vk_createInfo.tiling = static_cast<VkImageTiling>(params.tiling);
-    vk_createInfo.usage = getVkImageUsageFlagsFromImageUsageFlags(params.usage.value,asset::isDepthOrStencilFormat(params.format));
-    vk_createInfo.sharingMode = params.isConcurrentSharing() ? VK_SHARING_MODE_CONCURRENT:VK_SHARING_MODE_EXCLUSIVE;
+    vk_createInfo.usage = getVkImageUsageFlagsFromImageUsageFlags(params.usage.value, asset::isDepthOrStencilFormat(params.format));
+    vk_createInfo.sharingMode = params.isConcurrentSharing() ? VK_SHARING_MODE_CONCURRENT : VK_SHARING_MODE_EXCLUSIVE;
     vk_createInfo.queueFamilyIndexCount = params.queueFamilyIndexCount;
     vk_createInfo.pQueueFamilyIndices = params.queueFamilyIndices;
-    vk_createInfo.initialLayout = params.preinitialized ? VK_IMAGE_LAYOUT_PREINITIALIZED:VK_IMAGE_LAYOUT_UNDEFINED;
+    vk_createInfo.initialLayout = params.preinitialized ? VK_IMAGE_LAYOUT_PREINITIALIZED : VK_IMAGE_LAYOUT_UNDEFINED;
+
+    bool dedicatedOnly = false;
+    if (external)
+    {
+        core::bitflag<IDeviceMemoryAllocation::E_EXTERNAL_HANDLE_TYPE> requestedTypes = params.externalHandleTypes;
+        auto pd = dynamic_cast<const CVulkanPhysicalDevice*>(m_physicalDevice)->getInternalObject();
+        while (const auto idx = hlsl::findLSB(static_cast<uint32_t>(requestedTypes.value)) + 1)
+        {
+            const auto handleType = static_cast<IDeviceMemoryAllocation::E_EXTERNAL_HANDLE_TYPE>(1u << (idx - 1));
+            requestedTypes ^= handleType;
+
+            auto props = m_physicalDevice->getExternalImageProperties(params.format, params.tiling, params.type, params.usage, params.flags, handleType);
+
+            if (props.maxArrayLayers < vk_createInfo.arrayLayers || 
+                !core::bitflag<IGPUImage::E_SAMPLE_COUNT_FLAGS>(props.sampleCounts).hasFlags(params.samples) ||
+                /* props.maxResourceSize?? */
+                props.maxExtent.width < vk_createInfo.extent.width ||
+                props.maxExtent.height < vk_createInfo.extent.height ||
+                props.maxExtent.depth < vk_createInfo.extent.depth)
+            {
+                return nullptr;
+            }
+
+            if (!core::bitflag(static_cast<IDeviceMemoryAllocation::E_EXTERNAL_HANDLE_TYPE>(props.compatibleTypes)).hasFlags(params.externalHandleTypes)) // incompatibility between requested types
+                return nullptr;
+
+            dedicatedOnly |= props.dedicatedOnly;
+        }
+    }
 
     VkImage vk_image;
-    if (m_devf.vk.vkCreateImage(m_vkdev,&vk_createInfo,nullptr,&vk_image)!=VK_SUCCESS)
+    if (m_devf.vk.vkCreateImage(m_vkdev, &vk_createInfo, nullptr, &vk_image) != VK_SUCCESS)
         return nullptr;
-    return core::make_smart_refctd_ptr<CVulkanImage>(this,std::move(params),vk_image);
+    return core::make_smart_refctd_ptr<CVulkanImage>(this, std::move(params), dedicatedOnly, vk_image);
 }
 
 core::smart_refctd_ptr<IGPUImageView> CVulkanLogicalDevice::createImageView_impl(IGPUImageView::SCreationParams&& params)

src/nbl/video/CVulkanPhysicalDevice.h

@@ -136,6 +136,7 @@ class CVulkanPhysicalDevice final : public IPhysicalDevice
         SExternalImageFormatProperties getExternalImageProperties_impl(
             asset::E_FORMAT format, 
             IGPUImage::TILING tiling, 
+            IGPUImage::E_TYPE type,
             core::bitflag<IGPUImage::E_USAGE_FLAGS> usage, 
             core::bitflag<IGPUImage::E_CREATE_FLAGS> flags,  
             IDeviceMemoryAllocation::E_EXTERNAL_HANDLE_TYPE handleType) const override
@@ -150,7 +151,8 @@ class CVulkanPhysicalDevice final : public IPhysicalDevice
             VkPhysicalDeviceImageFormatInfo2 info = {
                 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
                 .pNext = &extInfo,
-                .format = static_cast<VkFormat>(format),
+                .format = getVkFormatFromFormat(format),
+                .type  = static_cast<VkImageType>(type),
                 .tiling = static_cast<VkImageTiling>(tiling),
                 .usage = usage.value,
                 .flags = flags.value,
@@ -163,7 +165,9 @@ class CVulkanPhysicalDevice final : public IPhysicalDevice
                 .pNext = &externalProps,
             };
 
-            vkGetPhysicalDeviceImageFormatProperties2(m_vkPhysicalDevice, &info, &props);
+            VkResult re = vkGetPhysicalDeviceImageFormatProperties2(m_vkPhysicalDevice, &info, &props);
+            if(VK_SUCCESS != re)
+                return {};
 
             return 
                 {