Select correct memory heap index for memory import

When importing memory, the application (CTS) should follow
the spec rules about memory imports. I.e. The application must use the
same memory heap index for the import that has been used for the
exported memory. In addition, the application can't
import a buffer or image to a heap that does not support CPU mapping and
expect the memory to be CPU mappable/accessible.

This change modifies the export memory routines, now, returning the
index of the heap memory used for the export. Then the import routines are
modified to use those indexes for the memory import operations.

Components: Vulkan

Affects:
    dEQP-VK.api.external.memory.*
    dEQP-VK.synchronization.cross_instance.*

VK-GL-CTS issue: 585

Change-Id: I48ab85b7fd2b67655163f055fb03e8f2a3a42fd6

diff --git a/external/vulkancts/modules/vulkan/api/vktApiExternalMemoryTests.cpp b/external/vulkancts/modules/vulkan/api/vktApiExternalMemoryTests.cpp
index c7be6dc..13dffec 100644 (file)
--- a/external/vulkancts/modules/vulkan/api/vktApiExternalMemoryTests.cpp
+++ b/external/vulkancts/modules/vulkan/api/vktApiExternalMemoryTests.cpp
@@ -2648,9 +2648,10 @@ tcu::TestStatus testMemoryWin32Create (Context& context, MemoryTestConfig config
        checkBufferSupport(vki, physicalDevice, config.externalType, 0u, usage, config.dedicated);
 
        // \note Buffer is only allocated to get memory requirements
-       const vk::Unique<vk::VkBuffer>                          buffer                          (createExternalBuffer(vkd, *device, queueFamilyIndex, config.externalType, bufferSize, 0u, usage));
-       const vk::VkMemoryRequirements                          requirements            (getBufferMemoryRequirements(vkd, *device, *buffer));
-       const vk::VkExportMemoryWin32HandleInfoKHR      win32Info                       =
+       deUint32                                                                        exportedMemoryTypeIndex = ~0U;
+       const vk::Unique<vk::VkBuffer>                          buffer                                  (createExternalBuffer(vkd, *device, queueFamilyIndex, config.externalType, bufferSize, 0u, usage));
+       const vk::VkMemoryRequirements                          requirements                    (getBufferMemoryRequirements(vkd, *device, *buffer));
+       const vk::VkExportMemoryWin32HandleInfoKHR      win32Info                               =
        {
                vk::VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
                DE_NULL,
@@ -2665,12 +2666,14 @@ tcu::TestStatus testMemoryWin32Create (Context& context, MemoryTestConfig config
                &win32Info,
                (vk::VkExternalMemoryHandleTypeFlagsKHR)config.externalType
        };
+
+       exportedMemoryTypeIndex = chooseMemoryType(requirements.memoryTypeBits & compatibleMemTypes);
        const vk::VkMemoryAllocateInfo                          info                            =
        {
                vk::VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
                &exportInfo,
                requirements.size,
-               chooseMemoryType(requirements.memoryTypeBits & compatibleMemTypes)
+               exportedMemoryTypeIndex
        };
        const vk::Unique<vk::VkDeviceMemory>            memory                          (vk::allocateMemory(vkd, *device, &info));
        NativeHandle                                                            handleA;
@@ -2681,7 +2684,7 @@ tcu::TestStatus testMemoryWin32Create (Context& context, MemoryTestConfig config
        getMemoryNative(vkd, *device, *memory, config.externalType, handleA);
 
        {
-               const vk::Unique<vk::VkDeviceMemory>    memoryA (importMemory(vkd, *device, requirements, config.externalType, handleA));
+               const vk::Unique<vk::VkDeviceMemory>    memoryA (importMemory(vkd, *device, requirements, config.externalType, exportedMemoryTypeIndex, handleA));
 
                if (config.hostVisible)
                {
@@ -2723,10 +2726,11 @@ tcu::TestStatus testMemoryImportTwice (Context& context, MemoryTestConfig config
 
        checkBufferSupport(vki, physicalDevice, config.externalType, 0u, usage, config.dedicated);
 
+       deUint32                                                                exportedMemoryTypeIndex = ~0U;
        // \note Buffer is only allocated to get memory requirements
-       const vk::Unique<vk::VkBuffer>                  buffer                          (createExternalBuffer(vkd, *device, queueFamilyIndex, config.externalType, bufferSize, 0u, usage));
-       const vk::VkMemoryRequirements                  requirements            (getBufferMemoryRequirements(vkd, *device, *buffer));
-       const vk::Unique<vk::VkDeviceMemory>    memory                          (allocateExportableMemory(vki, physicalDevice, vkd, *device, requirements, config.externalType, config.hostVisible, config.dedicated ? *buffer : (vk::VkBuffer)0));
+       const vk::Unique<vk::VkBuffer>                  buffer                                  (createExternalBuffer(vkd, *device, queueFamilyIndex, config.externalType, bufferSize, 0u, usage));
+       const vk::VkMemoryRequirements                  requirements                    (getBufferMemoryRequirements(vkd, *device, *buffer));
+       const vk::Unique<vk::VkDeviceMemory>    memory                                  (allocateExportableMemory(vki, physicalDevice, vkd, *device, requirements, config.externalType, config.hostVisible, config.dedicated ? *buffer : (vk::VkBuffer)0, exportedMemoryTypeIndex));
        NativeHandle                                                    handleA;
 
        if (config.hostVisible)
@@ -2736,8 +2740,8 @@ tcu::TestStatus testMemoryImportTwice (Context& context, MemoryTestConfig config
 
        {
                NativeHandle                                                    handleB (handleA);
-               const vk::Unique<vk::VkDeviceMemory>    memoryA (importMemory(vkd, *device, requirements, config.externalType, handleA));
-               const vk::Unique<vk::VkDeviceMemory>    memoryB (importMemory(vkd, *device, requirements, config.externalType, handleB));
+               const vk::Unique<vk::VkDeviceMemory>    memoryA (importMemory(vkd, *device, requirements, config.externalType, exportedMemoryTypeIndex, handleA));
+               const vk::Unique<vk::VkDeviceMemory>    memoryB (importMemory(vkd, *device, requirements, config.externalType, exportedMemoryTypeIndex, handleB));
 
                if (config.hostVisible)
                {
@@ -2773,10 +2777,11 @@ tcu::TestStatus testMemoryMultimpleImports (Context& context, MemoryTestConfig c
 
        checkBufferSupport(vki, physicalDevice, config.externalType, 0u, usage, config.dedicated);
 
+       deUint32                                                                exportedMemoryTypeIndex = ~0U;
        // \note Buffer is only allocated to get memory requirements
-       const vk::Unique<vk::VkBuffer>                  buffer                          (createExternalBuffer(vkd, *device, queueFamilyIndex, config.externalType, bufferSize, 0u, usage));
-       const vk::VkMemoryRequirements                  requirements            (getBufferMemoryRequirements(vkd, *device, *buffer));
-       const vk::Unique<vk::VkDeviceMemory>    memory                          (allocateExportableMemory(vki, physicalDevice, vkd, *device, requirements, config.externalType, config.hostVisible, config.dedicated ? *buffer : (vk::VkBuffer)0));
+       const vk::Unique<vk::VkBuffer>                  buffer                                  (createExternalBuffer(vkd, *device, queueFamilyIndex, config.externalType, bufferSize, 0u, usage));
+       const vk::VkMemoryRequirements                  requirements                    (getBufferMemoryRequirements(vkd, *device, *buffer));
+       const vk::Unique<vk::VkDeviceMemory>    memory                                  (allocateExportableMemory(vki, physicalDevice, vkd, *device, requirements, config.externalType, config.hostVisible, config.dedicated ? *buffer : (vk::VkBuffer)0, exportedMemoryTypeIndex));
        NativeHandle                                                    handleA;
 
        getMemoryNative(vkd, *device, *memory, config.externalType, handleA);
@@ -2784,7 +2789,7 @@ tcu::TestStatus testMemoryMultimpleImports (Context& context, MemoryTestConfig c
        for (size_t ndx = 0; ndx < count; ndx++)
        {
                NativeHandle                                                    handleB (handleA);
-               const vk::Unique<vk::VkDeviceMemory>    memoryB (importMemory(vkd, *device, requirements, config.externalType, handleB));
+               const vk::Unique<vk::VkDeviceMemory>    memoryB (importMemory(vkd, *device, requirements, config.externalType, exportedMemoryTypeIndex, handleB));
        }
 
        return tcu::TestStatus::pass("Pass");
@@ -2805,10 +2810,11 @@ tcu::TestStatus testMemoryMultimpleExports (Context& context, MemoryTestConfig c
 
        checkBufferSupport(vki, physicalDevice, config.externalType, 0u, usage, config.dedicated);
 
+       deUint32                                                                exportedMemoryTypeIndex = ~0U;
        // \note Buffer is only allocated to get memory requirements
-       const vk::Unique<vk::VkBuffer>                  buffer                          (createExternalBuffer(vkd, *device, queueFamilyIndex, config.externalType, bufferSize, 0u, usage));
-       const vk::VkMemoryRequirements                  requirements            (getBufferMemoryRequirements(vkd, *device, *buffer));
-       const vk::Unique<vk::VkDeviceMemory>    memory                          (allocateExportableMemory(vki, physicalDevice, vkd, *device, requirements, config.externalType, config.hostVisible, config.dedicated ? *buffer : (vk::VkBuffer)0));
+       const vk::Unique<vk::VkBuffer>                  buffer                                  (createExternalBuffer(vkd, *device, queueFamilyIndex, config.externalType, bufferSize, 0u, usage));
+       const vk::VkMemoryRequirements                  requirements                    (getBufferMemoryRequirements(vkd, *device, *buffer));
+       const vk::Unique<vk::VkDeviceMemory>    memory                                  (allocateExportableMemory(vki, physicalDevice, vkd, *device, requirements, config.externalType, config.hostVisible, config.dedicated ? *buffer : (vk::VkBuffer)0, exportedMemoryTypeIndex));
 
        for (size_t ndx = 0; ndx < count; ndx++)
        {
@@ -2840,10 +2846,11 @@ tcu::TestStatus testMemoryFdDup (Context& context, MemoryTestConfig config)
 
                checkBufferSupport(vki, physicalDevice, config.externalType, 0u, usage, config.dedicated);
 
+               deUint32                                                                exportedMemoryTypeIndex = ~0U;
                // \note Buffer is only allocated to get memory requirements
-               const vk::Unique<vk::VkBuffer>                  buffer                  (createExternalBuffer(vkd, *device, queueFamilyIndex, config.externalType, bufferSize, 0u, usage));
-               const vk::VkMemoryRequirements                  requirements    (getBufferMemoryRequirements(vkd, *device, *buffer));
-               const vk::Unique<vk::VkDeviceMemory>    memory                  (allocateExportableMemory(vki, physicalDevice, vkd, *device, requirements, config.externalType, config.hostVisible, config.dedicated ? *buffer : (vk::VkBuffer)0));
+               const vk::Unique<vk::VkBuffer>                  buffer                                  (createExternalBuffer(vkd, *device, queueFamilyIndex, config.externalType, bufferSize, 0u, usage));
+               const vk::VkMemoryRequirements                  requirements                    (getBufferMemoryRequirements(vkd, *device, *buffer));
+               const vk::Unique<vk::VkDeviceMemory>    memory                                  (allocateExportableMemory(vki, physicalDevice, vkd, *device, requirements, config.externalType, config.hostVisible, config.dedicated ? *buffer : (vk::VkBuffer)0, exportedMemoryTypeIndex));
 
                if (config.hostVisible)
                        writeHostMemory(vkd, *device, *memory, testData.size(), &testData[0]);
@@ -2857,7 +2864,7 @@ tcu::TestStatus testMemoryFdDup (Context& context, MemoryTestConfig config)
                TCU_CHECK_MSG(newFd.getFd() >= 0, "Failed to call dup() for memorys fd");
 
                {
-                       const vk::Unique<vk::VkDeviceMemory>    newMemory       (importMemory(vkd, *device, requirements, config.externalType, newFd));
+                       const vk::Unique<vk::VkDeviceMemory>    newMemory       (importMemory(vkd, *device, requirements, config.externalType, exportedMemoryTypeIndex, newFd));
 
                        if (config.hostVisible)
                        {
@@ -2900,10 +2907,11 @@ tcu::TestStatus testMemoryFdDup2 (Context& context, MemoryTestConfig config)
 
                checkBufferSupport(vki, physicalDevice, config.externalType, 0u, usage, config.dedicated);
 
+               deUint32                                                                exportedMemoryTypeIndex = ~0U;
                // \note Buffer is only allocated to get memory requirements
-               const vk::Unique<vk::VkBuffer>                  buffer                  (createExternalBuffer(vkd, *device, queueFamilyIndex, config.externalType, bufferSize, 0u, usage));
-               const vk::VkMemoryRequirements                  requirements    (getBufferMemoryRequirements(vkd, *device, *buffer));
-               const vk::Unique<vk::VkDeviceMemory>    memory                  (allocateExportableMemory(vki, physicalDevice, vkd, *device, requirements, config.externalType, config.hostVisible, config.dedicated ? *buffer : (vk::VkBuffer)0));
+               const vk::Unique<vk::VkBuffer>                  buffer                                  (createExternalBuffer(vkd, *device, queueFamilyIndex, config.externalType, bufferSize, 0u, usage));
+               const vk::VkMemoryRequirements                  requirements                    (getBufferMemoryRequirements(vkd, *device, *buffer));
+               const vk::Unique<vk::VkDeviceMemory>    memory                                  (allocateExportableMemory(vki, physicalDevice, vkd, *device, requirements, config.externalType, config.hostVisible, config.dedicated ? *buffer : (vk::VkBuffer)0, exportedMemoryTypeIndex));
 
                if (config.hostVisible)
                        writeHostMemory(vkd, *device, *memory, testData.size(), &testData[0]);
@@ -2918,7 +2926,7 @@ tcu::TestStatus testMemoryFdDup2 (Context& context, MemoryTestConfig config)
                TCU_CHECK_MSG(newFd >= 0, "Failed to call dup2() for memorys fd");
 
                {
-                       const vk::Unique<vk::VkDeviceMemory>    newMemory       (importMemory(vkd, *device, requirements, config.externalType, secondFd));
+                       const vk::Unique<vk::VkDeviceMemory>    newMemory       (importMemory(vkd, *device, requirements, config.externalType, exportedMemoryTypeIndex, secondFd));
 
                        if (config.hostVisible)
                        {
@@ -2961,10 +2969,11 @@ tcu::TestStatus testMemoryFdDup3 (Context& context, MemoryTestConfig config)
 
                checkBufferSupport(vki, physicalDevice, config.externalType, 0u, usage, config.dedicated);
 
+               deUint32                                                                exportedMemoryTypeIndex = ~0U;
                // \note Buffer is only allocated to get memory requirements
-               const vk::Unique<vk::VkBuffer>                  buffer                  (createExternalBuffer(vkd, *device, queueFamilyIndex, config.externalType, bufferSize, 0u, usage));
-               const vk::VkMemoryRequirements                  requirements    (getBufferMemoryRequirements(vkd, *device, *buffer));
-               const vk::Unique<vk::VkDeviceMemory>    memory                  (allocateExportableMemory(vki, physicalDevice, vkd, *device, requirements, config.externalType, config.hostVisible, config.dedicated ? *buffer : (vk::VkBuffer)0));
+               const vk::Unique<vk::VkBuffer>                  buffer                                  (createExternalBuffer(vkd, *device, queueFamilyIndex, config.externalType, bufferSize, 0u, usage));
+               const vk::VkMemoryRequirements                  requirements                    (getBufferMemoryRequirements(vkd, *device, *buffer));
+               const vk::Unique<vk::VkDeviceMemory>    memory                                  (allocateExportableMemory(vki, physicalDevice, vkd, *device, requirements, config.externalType, config.hostVisible, config.dedicated ? *buffer : (vk::VkBuffer)0, exportedMemoryTypeIndex));
 
                if (config.hostVisible)
                        writeHostMemory(vkd, *device, *memory, testData.size(), &testData[0]);
@@ -2979,7 +2988,7 @@ tcu::TestStatus testMemoryFdDup3 (Context& context, MemoryTestConfig config)
                TCU_CHECK_MSG(newFd >= 0, "Failed to call dup3() for memorys fd");
 
                {
-                       const vk::Unique<vk::VkDeviceMemory>    newMemory       (importMemory(vkd, *device, requirements, config.externalType, secondFd));
+                       const vk::Unique<vk::VkDeviceMemory>    newMemory       (importMemory(vkd, *device, requirements, config.externalType, exportedMemoryTypeIndex, secondFd));
 
                        if (config.hostVisible)
                        {
@@ -3022,10 +3031,11 @@ tcu::TestStatus testMemoryFdSendOverSocket (Context& context, MemoryTestConfig c
 
                checkBufferSupport(vki, physicalDevice, config.externalType, 0u, usage, config.dedicated);
 
+               deUint32                                                                exportedMemoryTypeIndex = ~0U;
                // \note Buffer is only allocated to get memory requirements
-               const vk::Unique<vk::VkBuffer>                  buffer                          (createExternalBuffer(vkd, *device, queueFamilyIndex, config.externalType, bufferSize, 0u, usage));
-               const vk::VkMemoryRequirements                  requirements            (getBufferMemoryRequirements(vkd, *device, *buffer));
-               const vk::Unique<vk::VkDeviceMemory>    memory                          (allocateExportableMemory(vki, physicalDevice, vkd, *device, requirements, config.externalType, config.hostVisible, config.dedicated ? *buffer : (vk::VkBuffer)0));
+               const vk::Unique<vk::VkBuffer>                  buffer                                  (createExternalBuffer(vkd, *device, queueFamilyIndex, config.externalType, bufferSize, 0u, usage));
+               const vk::VkMemoryRequirements                  requirements                    (getBufferMemoryRequirements(vkd, *device, *buffer));
+               const vk::Unique<vk::VkDeviceMemory>    memory                                  (allocateExportableMemory(vki, physicalDevice, vkd, *device, requirements, config.externalType, config.hostVisible, config.dedicated ? *buffer : (vk::VkBuffer)0, exportedMemoryTypeIndex));
 
                if (config.hostVisible)
                        writeHostMemory(vkd, *device, *memory, testData.size(), &testData[0]);
@@ -3116,7 +3126,7 @@ tcu::TestStatus testMemoryFdSendOverSocket (Context& context, MemoryTestConfig c
                                                TCU_CHECK_MSG(newFd.getFd() >= 0, "Didn't receive valid fd from socket");
 
                                                {
-                                                       const vk::Unique<vk::VkDeviceMemory> newMemory (importMemory(vkd, *device, requirements, config.externalType, newFd));
+                                                       const vk::Unique<vk::VkDeviceMemory> newMemory (importMemory(vkd, *device, requirements, config.externalType, exportedMemoryTypeIndex, newFd));
 
                                                        if (config.hostVisible)
                                                        {
@@ -3170,10 +3180,11 @@ tcu::TestStatus testBufferBindExportImportBind (Context&                                context,
 
        checkBufferSupport(vki, physicalDevice, config.externalType, 0u, usage, config.dedicated);
 
+       deUint32                                                                exportedMemoryTypeIndex = ~0U;
        // \note Buffer is only allocated to get memory requirements
-       const vk::Unique<vk::VkBuffer>                  bufferA                         (createExternalBuffer(vkd, *device, queueFamilyIndex, config.externalType, bufferSize, 0u, usage));
-       const vk::VkMemoryRequirements                  requirements            (getBufferMemoryRequirements(vkd, *device, *bufferA));
-       const vk::Unique<vk::VkDeviceMemory>    memoryA                         (allocateExportableMemory(vkd, *device, requirements, config.externalType, config.dedicated ? *bufferA : (vk::VkBuffer)0));
+       const vk::Unique<vk::VkBuffer>                  bufferA                                 (createExternalBuffer(vkd, *device, queueFamilyIndex, config.externalType, bufferSize, 0u, usage));
+       const vk::VkMemoryRequirements                  requirements                    (getBufferMemoryRequirements(vkd, *device, *bufferA));
+       const vk::Unique<vk::VkDeviceMemory>    memoryA                                 (allocateExportableMemory(vkd, *device, requirements, config.externalType, config.dedicated ? *bufferA : (vk::VkBuffer)0, exportedMemoryTypeIndex));
        NativeHandle                                                    handle;
 
        VK_CHECK(vkd.bindBufferMemory(*device, *bufferA, *memoryA, 0u));
@@ -3181,7 +3192,7 @@ tcu::TestStatus testBufferBindExportImportBind (Context&                          context,
        getMemoryNative(vkd, *device, *memoryA, config.externalType, handle);
 
        {
-               const vk::Unique<vk::VkDeviceMemory>    memoryB (importMemory(vkd, *device, requirements, config.externalType, handle));
+               const vk::Unique<vk::VkDeviceMemory>    memoryB (importMemory(vkd, *device, requirements, config.externalType, exportedMemoryTypeIndex, handle));
                const vk::Unique<vk::VkBuffer>                  bufferB (createExternalBuffer(vkd, *device, queueFamilyIndex, config.externalType, bufferSize, 0u, usage));
 
                VK_CHECK(vkd.bindBufferMemory(*device, *bufferB, *memoryB, 0u));
@@ -3205,17 +3216,18 @@ tcu::TestStatus testBufferExportBindImportBind (Context&                                context,
 
        checkBufferSupport(vki, physicalDevice, config.externalType, 0u, usage, config.dedicated);
 
+       deUint32                                                                exportedMemoryTypeIndex = ~0U;
        // \note Buffer is only allocated to get memory requirements
-       const vk::Unique<vk::VkBuffer>                  bufferA                         (createExternalBuffer(vkd, *device, queueFamilyIndex, config.externalType, bufferSize, 0u, usage));
-       const vk::VkMemoryRequirements                  requirements            (getBufferMemoryRequirements(vkd, *device, *bufferA));
-       const vk::Unique<vk::VkDeviceMemory>    memoryA                         (allocateExportableMemory(vkd, *device, requirements, config.externalType, config.dedicated ? *bufferA : (vk::VkBuffer)0));
+       const vk::Unique<vk::VkBuffer>                  bufferA                                 (createExternalBuffer(vkd, *device, queueFamilyIndex, config.externalType, bufferSize, 0u, usage));
+       const vk::VkMemoryRequirements                  requirements                    (getBufferMemoryRequirements(vkd, *device, *bufferA));
+       const vk::Unique<vk::VkDeviceMemory>    memoryA                                 (allocateExportableMemory(vkd, *device, requirements, config.externalType, config.dedicated ? *bufferA : (vk::VkBuffer)0, exportedMemoryTypeIndex));
        NativeHandle                                                    handle;
 
        getMemoryNative(vkd, *device, *memoryA, config.externalType, handle);
        VK_CHECK(vkd.bindBufferMemory(*device, *bufferA, *memoryA, 0u));
 
        {
-               const vk::Unique<vk::VkDeviceMemory>    memoryB (importMemory(vkd, *device, requirements, config.externalType, handle));
+               const vk::Unique<vk::VkDeviceMemory>    memoryB (importMemory(vkd, *device, requirements, config.externalType, exportedMemoryTypeIndex, handle));
                const vk::Unique<vk::VkBuffer>                  bufferB (createExternalBuffer(vkd, *device, queueFamilyIndex, config.externalType, bufferSize, 0u, usage));
 
                VK_CHECK(vkd.bindBufferMemory(*device, *bufferB, *memoryB, 0u));
@@ -3239,16 +3251,17 @@ tcu::TestStatus testBufferExportImportBindBind (Context&                                context,
 
        checkBufferSupport(vki, physicalDevice, config.externalType, 0u, usage, config.dedicated);
 
+       deUint32                                                                exportedMemoryTypeIndex = ~0U;
        // \note Buffer is only allocated to get memory requirements
-       const vk::Unique<vk::VkBuffer>                  bufferA                         (createExternalBuffer(vkd, *device, queueFamilyIndex, config.externalType, bufferSize, 0u, usage));
-       const vk::VkMemoryRequirements                  requirements            (getBufferMemoryRequirements(vkd, *device, *bufferA));
-       const vk::Unique<vk::VkDeviceMemory>    memoryA                         (allocateExportableMemory(vkd, *device, requirements, config.externalType, config.dedicated ? *bufferA : (vk::VkBuffer)0));
+       const vk::Unique<vk::VkBuffer>                  bufferA                                 (createExternalBuffer(vkd, *device, queueFamilyIndex, config.externalType, bufferSize, 0u, usage));
+       const vk::VkMemoryRequirements                  requirements                    (getBufferMemoryRequirements(vkd, *device, *bufferA));
+       const vk::Unique<vk::VkDeviceMemory>    memoryA                                 (allocateExportableMemory(vkd, *device, requirements, config.externalType, config.dedicated ? *bufferA : (vk::VkBuffer)0, exportedMemoryTypeIndex));
        NativeHandle                                                    handle;
 
        getMemoryNative(vkd, *device, *memoryA, config.externalType, handle);
 
        {
-               const vk::Unique<vk::VkDeviceMemory>    memoryB (importMemory(vkd, *device, requirements, config.externalType, handle));
+               const vk::Unique<vk::VkDeviceMemory>    memoryB (importMemory(vkd, *device, requirements, config.externalType, exportedMemoryTypeIndex, handle));
                const vk::Unique<vk::VkBuffer>                  bufferB (createExternalBuffer(vkd, *device, queueFamilyIndex, config.externalType, bufferSize, 0u, usage));
 
                VK_CHECK(vkd.bindBufferMemory(*device, *bufferA, *memoryA, 0u));
@@ -3439,9 +3452,10 @@ tcu::TestStatus testImageBindExportImportBind (Context&                                  context,
 
        checkImageSupport(vki, physicalDevice, config.externalType, 0u, usage, format, tiling, config.dedicated);
 
-       const vk::Unique<vk::VkImage>                   imageA                          (createExternalImage(vkd, *device, queueFamilyIndex, config.externalType, format, width, height, tiling, 0u, usage));
-       const vk::VkMemoryRequirements                  requirements            (getImageMemoryRequirements(vkd, *device, *imageA));
-       const vk::Unique<vk::VkDeviceMemory>    memoryA                         (allocateExportableMemory(vkd, *device, requirements, config.externalType, config.dedicated ? *imageA : (vk::VkImage)0));
+       deUint32                                                                exportedMemoryTypeIndex = ~0U;
+       const vk::Unique<vk::VkImage>                   imageA                                  (createExternalImage(vkd, *device, queueFamilyIndex, config.externalType, format, width, height, tiling, 0u, usage));
+       const vk::VkMemoryRequirements                  requirements                    (getImageMemoryRequirements(vkd, *device, *imageA));
+       const vk::Unique<vk::VkDeviceMemory>    memoryA                                 (allocateExportableMemory(vkd, *device, requirements, config.externalType, config.dedicated ? *imageA : (vk::VkImage)0, exportedMemoryTypeIndex));
        NativeHandle                                                    handle;
 
        VK_CHECK(vkd.bindImageMemory(*device, *imageA, *memoryA, 0u));
@@ -3449,7 +3463,7 @@ tcu::TestStatus testImageBindExportImportBind (Context&                                   context,
        getMemoryNative(vkd, *device, *memoryA, config.externalType, handle);
 
        {
-               const vk::Unique<vk::VkDeviceMemory>    memoryB (importMemory(vkd, *device, requirements, config.externalType, handle));
+               const vk::Unique<vk::VkDeviceMemory>    memoryB (importMemory(vkd, *device, requirements, config.externalType, exportedMemoryTypeIndex, handle));
                const vk::Unique<vk::VkImage>                   imageB  (createExternalImage(vkd, *device, queueFamilyIndex, config.externalType, format, width, height, tiling, 0u, usage));
 
                VK_CHECK(vkd.bindImageMemory(*device, *imageB, *memoryB, 0u));
@@ -3476,16 +3490,17 @@ tcu::TestStatus testImageExportBindImportBind (Context&                                 context,
 
        checkImageSupport(vki, physicalDevice, config.externalType, 0u, usage, format, tiling, config.dedicated);
 
-       const vk::Unique<vk::VkImage>                   imageA                          (createExternalImage(vkd, *device, queueFamilyIndex, config.externalType, format, width, height, tiling, 0u, usage));
-       const vk::VkMemoryRequirements                  requirements            (getImageMemoryRequirements(vkd, *device, *imageA));
-       const vk::Unique<vk::VkDeviceMemory>    memoryA                         (allocateExportableMemory(vkd, *device, requirements, config.externalType, config.dedicated ? *imageA : (vk::VkImage)0));
+       deUint32                                                                exportedMemoryTypeIndex = ~0U;
+       const vk::Unique<vk::VkImage>                   imageA                                  (createExternalImage(vkd, *device, queueFamilyIndex, config.externalType, format, width, height, tiling, 0u, usage));
+       const vk::VkMemoryRequirements                  requirements                    (getImageMemoryRequirements(vkd, *device, *imageA));
+       const vk::Unique<vk::VkDeviceMemory>    memoryA                                 (allocateExportableMemory(vkd, *device, requirements, config.externalType, config.dedicated ? *imageA : (vk::VkImage)0, exportedMemoryTypeIndex));
        NativeHandle                                                    handle;
 
        getMemoryNative(vkd, *device, *memoryA, config.externalType, handle);
        VK_CHECK(vkd.bindImageMemory(*device, *imageA, *memoryA, 0u));
 
        {
-               const vk::Unique<vk::VkDeviceMemory>    memoryB (importMemory(vkd, *device, requirements, config.externalType, handle));
+               const vk::Unique<vk::VkDeviceMemory>    memoryB (importMemory(vkd, *device, requirements, config.externalType, exportedMemoryTypeIndex, handle));
                const vk::Unique<vk::VkImage>                   imageB  (createExternalImage(vkd, *device, queueFamilyIndex, config.externalType, format, width, height, tiling, 0u, usage));
 
                VK_CHECK(vkd.bindImageMemory(*device, *imageB, *memoryB, 0u));
@@ -3512,16 +3527,17 @@ tcu::TestStatus testImageExportImportBindBind (Context&                                 context,
 
        checkImageSupport(vki, physicalDevice, config.externalType, 0u, usage, format, tiling, config.dedicated);
 
+       deUint32                                                                exportedMemoryTypeIndex = ~0U;
        // \note Image is only allocated to get memory requirements
-       const vk::Unique<vk::VkImage>                   imageA                          (createExternalImage(vkd, *device, queueFamilyIndex, config.externalType, format, width, height, tiling, 0u, usage));
-       const vk::VkMemoryRequirements                  requirements            (getImageMemoryRequirements(vkd, *device, *imageA));
-       const vk::Unique<vk::VkDeviceMemory>    memoryA                         (allocateExportableMemory(vkd, *device, requirements, config.externalType, config.dedicated ? *imageA : (vk::VkImage)0));
+       const vk::Unique<vk::VkImage>                   imageA                                  (createExternalImage(vkd, *device, queueFamilyIndex, config.externalType, format, width, height, tiling, 0u, usage));
+       const vk::VkMemoryRequirements                  requirements                    (getImageMemoryRequirements(vkd, *device, *imageA));
+       const vk::Unique<vk::VkDeviceMemory>    memoryA                                 (allocateExportableMemory(vkd, *device, requirements, config.externalType, config.dedicated ? *imageA : (vk::VkImage)0, exportedMemoryTypeIndex));
        NativeHandle                                                    handle;
 
        getMemoryNative(vkd, *device, *memoryA, config.externalType, handle);
 
        {
-               const vk::Unique<vk::VkDeviceMemory>    memoryB (importMemory(vkd, *device, requirements, config.externalType, handle));
+               const vk::Unique<vk::VkDeviceMemory>    memoryB (importMemory(vkd, *device, requirements, config.externalType, exportedMemoryTypeIndex, handle));
                const vk::Unique<vk::VkImage>                   imageB  (createExternalImage(vkd, *device, queueFamilyIndex, config.externalType, format, width, height, tiling, 0u, usage));
 
                VK_CHECK(vkd.bindImageMemory(*device, *imageA, *memoryA, 0u));

diff --git a/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationCrossInstanceSharingTests.cpp b/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationCrossInstanceSharingTests.cpp
index 784e6ca..b8cfaf6 100644 (file)
--- a/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationCrossInstanceSharingTests.cpp
+++ b/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationCrossInstanceSharingTests.cpp
@@ -351,6 +351,7 @@ de::MovePtr<vk::Allocation> allocateAndBindMemory (const vk::DeviceInterface&
                                                                                                   vk::VkDevice                                                                 device,
                                                                                                   vk::VkBuffer                                                                 buffer,
                                                                                                   vk::VkExternalMemoryHandleTypeFlagBitsKHR    externalType,
+                                                                                                  deUint32&                                                                    exportedMemoryTypeIndex,
                                                                                                   bool                                                                                 dedicated,
                                                                                                   bool                                                                                 getMemReq2Supported)
 {
@@ -390,7 +391,7 @@ de::MovePtr<vk::Allocation> allocateAndBindMemory (const vk::DeviceInterface&
        }
 
 
-       vk::Move<vk::VkDeviceMemory> memory = allocateExportableMemory(vkd, device, memoryRequirements, externalType, dedicated ? buffer : (vk::VkBuffer)0);
+       vk::Move<vk::VkDeviceMemory> memory = allocateExportableMemory(vkd, device, memoryRequirements, externalType, dedicated ? buffer : (vk::VkBuffer)0, exportedMemoryTypeIndex);
        VK_CHECK(vkd.bindBufferMemory(device, buffer, *memory, 0u));
 
        return de::MovePtr<vk::Allocation>(new SimpleAllocation(vkd, device, memory.disown()));
@@ -400,6 +401,7 @@ de::MovePtr<vk::Allocation> allocateAndBindMemory (const vk::DeviceInterface&
                                                                                                   vk::VkDevice                                                                 device,
                                                                                                   vk::VkImage                                                                  image,
                                                                                                   vk::VkExternalMemoryHandleTypeFlagBitsKHR    externalType,
+                                                                                                  deUint32&                                                                    exportedMemoryTypeIndex,
                                                                                                   bool                                                                                 dedicated,
                                                                                                   bool                                                                                 getMemReq2Supported)
 {
@@ -436,7 +438,7 @@ de::MovePtr<vk::Allocation> allocateAndBindMemory (const vk::DeviceInterface&
                vkd.getImageMemoryRequirements(device, image, &memoryRequirements);
        }
 
-       vk::Move<vk::VkDeviceMemory> memory = allocateExportableMemory(vkd, device, memoryRequirements, externalType, dedicated ? image : (vk::VkImage)0);
+       vk::Move<vk::VkDeviceMemory> memory = allocateExportableMemory(vkd, device, memoryRequirements, externalType, dedicated ? image : (vk::VkImage)0, exportedMemoryTypeIndex);
        VK_CHECK(vkd.bindImageMemory(device, image, *memory, 0u));
 
        return de::MovePtr<vk::Allocation>(new SimpleAllocation(vkd, device, memory.disown()));
@@ -449,6 +451,7 @@ de::MovePtr<Resource> createResource (const vk::DeviceInterface&                            vkd,
                                                                          const OperationSupport&                                       readOp,
                                                                          const OperationSupport&                                       writeOp,
                                                                          vk::VkExternalMemoryHandleTypeFlagBitsKHR     externalType,
+                                                                         deUint32&                                                                     exportedMemoryTypeIndex,
                                                                          bool                                                                          dedicated,
                                                                          bool                                                                          getMemReq2Supported)
 {
@@ -503,7 +506,7 @@ de::MovePtr<Resource> createResource (const vk::DeviceInterface&                            vkd,
                };
 
                vk::Move<vk::VkImage>                   image           = vk::createImage(vkd, device, &createInfo);
-               de::MovePtr<vk::Allocation>             allocation      = allocateAndBindMemory(vkd, device, *image, externalType, dedicated, getMemReq2Supported);
+               de::MovePtr<vk::Allocation>             allocation      = allocateAndBindMemory(vkd, device, *image, externalType, exportedMemoryTypeIndex, dedicated, getMemReq2Supported);
 
                return de::MovePtr<Resource>(new Resource(image, allocation, extent, resourceDesc.imageType, resourceDesc.imageFormat, subresourceRange, subresourceLayers));
        }
@@ -531,7 +534,7 @@ de::MovePtr<Resource> createResource (const vk::DeviceInterface&                            vkd,
                        &queueFamilyIndices[0]
                };
                vk::Move<vk::VkBuffer>          buffer          = vk::createBuffer(vkd, device, &createInfo);
-               de::MovePtr<vk::Allocation>     allocation      = allocateAndBindMemory(vkd, device, *buffer, externalType, dedicated, getMemReq2Supported);
+               de::MovePtr<vk::Allocation>     allocation      = allocateAndBindMemory(vkd, device, *buffer, externalType, exportedMemoryTypeIndex, dedicated, getMemReq2Supported);
 
                return de::MovePtr<Resource>(new Resource(resourceDesc.type, buffer, allocation, offset, size));
        }
@@ -542,12 +545,13 @@ de::MovePtr<vk::Allocation> importAndBindMemory (const vk::DeviceInterface&
                                                                                                 vk::VkBuffer                                                           buffer,
                                                                                                 NativeHandle&                                                          nativeHandle,
                                                                                                 vk::VkExternalMemoryHandleTypeFlagBitsKHR      externalType,
+                                                                                                deUint32                                                                       exportedMemoryTypeIndex,
                                                                                                 bool                                                                           dedicated)
 {
        const vk::VkMemoryRequirements  requirements    = vk::getBufferMemoryRequirements(vkd, device, buffer);
        vk::Move<vk::VkDeviceMemory>    memory                  = dedicated
-                                                                                                       ? importDedicatedMemory(vkd, device, buffer, requirements, externalType, nativeHandle)
-                                                                                                       : importMemory(vkd, device, requirements, externalType, nativeHandle);
+                                                                                                       ? importDedicatedMemory(vkd, device, buffer, requirements, externalType, exportedMemoryTypeIndex, nativeHandle)
+                                                                                                       : importMemory(vkd, device, requirements, externalType, exportedMemoryTypeIndex, nativeHandle);
 
        VK_CHECK(vkd.bindBufferMemory(device, buffer, *memory, 0u));
 
@@ -559,12 +563,13 @@ de::MovePtr<vk::Allocation> importAndBindMemory (const vk::DeviceInterface&
                                                                                                 vk::VkImage                                                            image,
                                                                                                 NativeHandle&                                                          nativeHandle,
                                                                                                 vk::VkExternalMemoryHandleTypeFlagBitsKHR      externalType,
+                                                                                                deUint32                                                                       exportedMemoryTypeIndex,
                                                                                                 bool                                                                           dedicated)
 {
        const vk::VkMemoryRequirements  requirements    = vk::getImageMemoryRequirements(vkd, device, image);
        vk::Move<vk::VkDeviceMemory>    memory                  = dedicated
-                                                                                                       ? importDedicatedMemory(vkd, device, image, requirements, externalType, nativeHandle)
-                                                                                                       : importMemory(vkd, device, requirements, externalType, nativeHandle);
+                                                                                                       ? importDedicatedMemory(vkd, device, image, requirements, externalType, exportedMemoryTypeIndex, nativeHandle)
+                                                                                                       : importMemory(vkd, device, requirements, externalType, exportedMemoryTypeIndex, nativeHandle);
        VK_CHECK(vkd.bindImageMemory(device, image, *memory, 0u));
 
        return de::MovePtr<vk::Allocation>(new SimpleAllocation(vkd, device, memory.disown()));
@@ -578,6 +583,7 @@ de::MovePtr<Resource> importResource (const vk::DeviceInterface&                            vkd,
                                                                          const OperationSupport&                                       writeOp,
                                                                          NativeHandle&                                                         nativeHandle,
                                                                          vk::VkExternalMemoryHandleTypeFlagBitsKHR     externalType,
+                                                                         deUint32                                                                      exportedMemoryTypeIndex,
                                                                          bool                                                                          dedicated)
 {
        if (resourceDesc.type == RESOURCE_TYPE_IMAGE)
@@ -631,7 +637,7 @@ de::MovePtr<Resource> importResource (const vk::DeviceInterface&                            vkd,
                };
 
                vk::Move<vk::VkImage>                   image           = vk::createImage(vkd, device, &createInfo);
-               de::MovePtr<vk::Allocation>             allocation      = importAndBindMemory(vkd, device, *image, nativeHandle, externalType, dedicated);
+               de::MovePtr<vk::Allocation>             allocation      = importAndBindMemory(vkd, device, *image, nativeHandle, externalType, exportedMemoryTypeIndex, dedicated);
 
                return de::MovePtr<Resource>(new Resource(image, allocation, extent, resourceDesc.imageType, resourceDesc.imageFormat, subresourceRange, subresourceLayers));
        }
@@ -659,7 +665,7 @@ de::MovePtr<Resource> importResource (const vk::DeviceInterface&                            vkd,
                        &queueFamilyIndices[0]
                };
                vk::Move<vk::VkBuffer>          buffer          = vk::createBuffer(vkd, device, &createInfo);
-               de::MovePtr<vk::Allocation>     allocation      = importAndBindMemory(vkd, device, *buffer, nativeHandle, externalType, dedicated);
+               de::MovePtr<vk::Allocation>     allocation      = importAndBindMemory(vkd, device, *buffer, nativeHandle, externalType, exportedMemoryTypeIndex, dedicated);
 
                return de::MovePtr<Resource>(new Resource(resourceDesc.type, buffer, allocation, offset, size));
        }
@@ -986,12 +992,13 @@ tcu::TestStatus SharingTestInstance::iterate (void)
        const vk::Unique<vk::VkSemaphore>               semaphoreA                      (createExportableSemaphore(m_vkdA, *m_deviceA, m_semaphoreHandleType));
        const vk::Unique<vk::VkSemaphore>               semaphoreB                      (createSemaphore(m_vkdB, *m_deviceB));
 
-       const de::UniquePtr<Resource>                   resourceA                       (createResource(m_vkdA, *m_deviceA, m_config.resource, m_queueFamilyIndicesA, *m_supportReadOp, *m_supportWriteOp, m_memoryHandleType, m_config.dedicated, m_getMemReq2Supported));
+       deUint32                                                                exportedMemoryTypeIndex = ~0U;
+       const de::UniquePtr<Resource>                   resourceA                       (createResource(m_vkdA, *m_deviceA, m_config.resource, m_queueFamilyIndicesA, *m_supportReadOp, *m_supportWriteOp, m_memoryHandleType, exportedMemoryTypeIndex, m_config.dedicated, m_getMemReq2Supported));
 
        NativeHandle                                                    nativeMemoryHandle;
        getMemoryNative(m_vkdA, *m_deviceA, resourceA->getMemory(), m_memoryHandleType, nativeMemoryHandle);
 
-       const de::UniquePtr<Resource>                   resourceB                       (importResource(m_vkdB, *m_deviceB, m_config.resource, m_queueFamilyIndicesB, *m_supportReadOp, *m_supportWriteOp, nativeMemoryHandle, m_memoryHandleType, m_config.dedicated));
+       const de::UniquePtr<Resource>                   resourceB                       (importResource(m_vkdB, *m_deviceB, m_config.resource, m_queueFamilyIndicesB, *m_supportReadOp, *m_supportWriteOp, nativeMemoryHandle, m_memoryHandleType, exportedMemoryTypeIndex, m_config.dedicated));
 
        try
        {

diff --git a/external/vulkancts/modules/vulkan/vktExternalMemoryUtil.cpp b/external/vulkancts/modules/vulkan/vktExternalMemoryUtil.cpp
index 315f707..070249c 100644 (file)
--- a/external/vulkancts/modules/vulkan/vktExternalMemoryUtil.cpp
+++ b/external/vulkancts/modules/vulkan/vktExternalMemoryUtil.cpp
@@ -757,8 +757,10 @@ vk::Move<vk::VkDeviceMemory> allocateExportableMemory (const vk::DeviceInterface
                                                                                                           vk::VkDevice                                                                 device,
                                                                                                           const vk::VkMemoryRequirements&                              requirements,
                                                                                                           vk::VkExternalMemoryHandleTypeFlagBitsKHR    externalType,
-                                                                                                          vk::VkBuffer                                                                 buffer)
+                                                                                                          vk::VkBuffer                                                                 buffer,
+                                                                                                          deUint32&                                    exportedMemoryTypeIndex)
 {
+       exportedMemoryTypeIndex = chooseMemoryType(requirements.memoryTypeBits);
        const vk::VkMemoryDedicatedAllocateInfoKHR      dedicatedInfo   =
        {
                vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR,
@@ -778,7 +780,7 @@ vk::Move<vk::VkDeviceMemory> allocateExportableMemory (const vk::DeviceInterface
                vk::VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
                &exportInfo,
                requirements.size,
-               chooseMemoryType(requirements.memoryTypeBits)
+               exportedMemoryTypeIndex
        };
        return vk::allocateMemory(vkd, device, &info);
 }
@@ -787,8 +789,10 @@ vk::Move<vk::VkDeviceMemory> allocateExportableMemory (const vk::DeviceInterface
                                                                                                           vk::VkDevice                                                                 device,
                                                                                                           const vk::VkMemoryRequirements&                              requirements,
                                                                                                           vk::VkExternalMemoryHandleTypeFlagBitsKHR    externalType,
-                                                                                                          vk::VkImage                                                                  image)
+                                                                                                          vk::VkImage                                                                  image,
+                                                                                                          deUint32&                                    exportedMemoryTypeIndex)
 {
+       exportedMemoryTypeIndex = chooseMemoryType(requirements.memoryTypeBits);
        const vk::VkMemoryDedicatedAllocateInfoKHR      dedicatedInfo   =
        {
                vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR,
@@ -808,7 +812,7 @@ vk::Move<vk::VkDeviceMemory> allocateExportableMemory (const vk::DeviceInterface
                vk::VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
                &exportInfo,
                requirements.size,
-               chooseMemoryType(requirements.memoryTypeBits)
+               exportedMemoryTypeIndex
        };
        return vk::allocateMemory(vkd, device, &info);
 }
@@ -820,7 +824,8 @@ vk::Move<vk::VkDeviceMemory> allocateExportableMemory (const vk::InstanceInterfa
                                                                                                           const vk::VkMemoryRequirements&                              requirements,
                                                                                                           vk::VkExternalMemoryHandleTypeFlagBitsKHR    externalType,
                                                                                                           bool                                                                                 hostVisible,
-                                                                                                          vk::VkBuffer                                                                 buffer)
+                                                                                                          vk::VkBuffer                                                                 buffer,
+                                                                                                          deUint32&                                                                    exportedMemoryTypeIndex)
 {
        const vk::VkPhysicalDeviceMemoryProperties properties = vk::getPhysicalDeviceMemoryProperties(vki, physicalDevice);
 
@@ -850,6 +855,8 @@ vk::Move<vk::VkDeviceMemory> allocateExportableMemory (const vk::InstanceInterfa
                                requirements.size,
                                memoryTypeIndex
                        };
+
+                       exportedMemoryTypeIndex = memoryTypeIndex;
                        return vk::allocateMemory(vkd, device, &info);
                }
        }
@@ -863,6 +870,7 @@ static vk::Move<vk::VkDeviceMemory> importMemory (const vk::DeviceInterface&
                                                                                                  vk::VkImage                                                           image,
                                                                                                  const vk::VkMemoryRequirements&                       requirements,
                                                                                                  vk::VkExternalMemoryHandleTypeFlagBitsKHR     externalType,
+                                                                                                 deUint32                                                                      memoryTypeIndex,
                                                                                                  NativeHandle&                                                         handle)
 {
        const bool      isDedicated             = !!buffer || !!image;
@@ -890,7 +898,7 @@ static vk::Move<vk::VkDeviceMemory> importMemory (const vk::DeviceInterface&
                        vk::VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
                        (isDedicated ? (const void*)&dedicatedInfo : (const void*)&importInfo),
                        requirements.size,
-                       chooseMemoryType(requirements.memoryTypeBits)
+                       (memoryTypeIndex == ~0U) ? chooseMemoryType(requirements.memoryTypeBits) : memoryTypeIndex
                };
                vk::Move<vk::VkDeviceMemory> memory (vk::allocateMemory(vkd, device, &info));
 
@@ -921,7 +929,7 @@ static vk::Move<vk::VkDeviceMemory> importMemory (const vk::DeviceInterface&
                        vk::VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
                        (isDedicated ? (const void*)&dedicatedInfo : (const void*)&importInfo),
                        requirements.size,
-                       chooseMemoryType(requirements.memoryTypeBits)
+                       (memoryTypeIndex == ~0U) ? chooseMemoryType(requirements.memoryTypeBits)  : memoryTypeIndex
                };
                vk::Move<vk::VkDeviceMemory> memory (vk::allocateMemory(vkd, device, &info));
 
@@ -940,9 +948,10 @@ vk::Move<vk::VkDeviceMemory> importMemory (const vk::DeviceInterface&                                      vkd,
                                                                                   vk::VkDevice                                                                 device,
                                                                                   const vk::VkMemoryRequirements&                              requirements,
                                                                                   vk::VkExternalMemoryHandleTypeFlagBitsKHR    externalType,
+                                                                                  deUint32                                                                             memoryTypeIndex,
                                                                                   NativeHandle&                                                                handle)
 {
-       return importMemory(vkd, device, (vk::VkBuffer)0, (vk::VkImage)0, requirements, externalType, handle);
+       return importMemory(vkd, device, (vk::VkBuffer)0, (vk::VkImage)0, requirements, externalType, memoryTypeIndex, handle);
 }
 
 vk::Move<vk::VkDeviceMemory> importDedicatedMemory (const vk::DeviceInterface&                                 vkd,
@@ -950,9 +959,10 @@ vk::Move<vk::VkDeviceMemory> importDedicatedMemory (const vk::DeviceInterface&
                                                                                                        vk::VkBuffer                                                            buffer,
                                                                                                        const vk::VkMemoryRequirements&                         requirements,
                                                                                                        vk::VkExternalMemoryHandleTypeFlagBitsKHR       externalType,
+                                                                                                       deUint32                                                                        memoryTypeIndex,
                                                                                                        NativeHandle&                                                           handle)
 {
-       return importMemory(vkd, device, buffer, (vk::VkImage)0, requirements, externalType, handle);
+       return importMemory(vkd, device, buffer, (vk::VkImage)0, requirements, externalType, memoryTypeIndex, handle);
 }
 
 vk::Move<vk::VkDeviceMemory> importDedicatedMemory (const vk::DeviceInterface&                                 vkd,
@@ -960,9 +970,10 @@ vk::Move<vk::VkDeviceMemory> importDedicatedMemory (const vk::DeviceInterface&
                                                                                                        vk::VkImage                                                                     image,
                                                                                                        const vk::VkMemoryRequirements&                         requirements,
                                                                                                        vk::VkExternalMemoryHandleTypeFlagBitsKHR       externalType,
+                                                                                                       deUint32                                                                        memoryTypeIndex,
                                                                                                        NativeHandle&                                                           handle)
 {
-       return importMemory(vkd, device, (vk::VkBuffer)0, image, requirements, externalType, handle);
+       return importMemory(vkd, device, (vk::VkBuffer)0, image, requirements, externalType, memoryTypeIndex, handle);
 }
 
 vk::Move<vk::VkBuffer> createExternalBuffer (const vk::DeviceInterface&                                        vkd,

diff --git a/external/vulkancts/modules/vulkan/vktExternalMemoryUtil.hpp b/external/vulkancts/modules/vulkan/vktExternalMemoryUtil.hpp
index 4bc1098..7180a8c 100644 (file)
--- a/external/vulkancts/modules/vulkan/vktExternalMemoryUtil.hpp
+++ b/external/vulkancts/modules/vulkan/vktExternalMemoryUtil.hpp
@@ -160,21 +160,24 @@ vk::Move<vk::VkFence>                     createAndImportFence                            (const vk::DeviceInterface&
 vk::Move<vk::VkDeviceMemory>   allocateExportableMemory                        (const vk::DeviceInterface&                                     vkd,
                                                                                                                                         vk::VkDevice                                                           device,
                                                                                                                                         const vk::VkMemoryRequirements&                        requirements,
-                                                                                                                                        vk::VkExternalMemoryHandleTypeFlagBitsKHR      externalType);
+                                                                                                                                        vk::VkExternalMemoryHandleTypeFlagBitsKHR      externalType,
+                                                                                                                                        deUint32&                                                                      exportedMemoryTypeIndex);
 
 // If buffer is not null use dedicated allocation
 vk::Move<vk::VkDeviceMemory>   allocateExportableMemory                        (const vk::DeviceInterface&                                     vkd,
                                                                                                                                         vk::VkDevice                                                           device,
                                                                                                                                         const vk::VkMemoryRequirements&                        requirements,
                                                                                                                                         vk::VkExternalMemoryHandleTypeFlagBitsKHR      externalType,
-                                                                                                                                        vk::VkBuffer                                                           buffer);
+                                                                                                                                        vk::VkBuffer                                                           buffer,
+                                                                                                                                        deUint32&                                                                      exportedMemoryTypeIndex);
 
 // If image is not null use dedicated allocation
 vk::Move<vk::VkDeviceMemory>   allocateExportableMemory                        (const vk::DeviceInterface&                                     vkd,
                                                                                                                                         vk::VkDevice                                                           device,
                                                                                                                                         const vk::VkMemoryRequirements&                        requirements,
                                                                                                                                         vk::VkExternalMemoryHandleTypeFlagBitsKHR      externalType,
-                                                                                                                                        vk::VkImage                                                            image);
+                                                                                                                                        vk::VkImage                                                            image,
+                                                                                                                                        deUint32&                                                                      exportedMemoryTypeIndex);
 
 // \note hostVisible argument is strict. Setting it to false will cause NotSupportedError to be thrown if non-host visible memory doesn't exist.
 // If buffer is not null use dedicated allocation
@@ -185,12 +188,14 @@ vk::Move<vk::VkDeviceMemory>      allocateExportableMemory                        (const vk::InstanceInter
                                                                                                                                         const vk::VkMemoryRequirements&                        requirements,
                                                                                                                                         vk::VkExternalMemoryHandleTypeFlagBitsKHR      externalType,
                                                                                                                                         bool                                                                           hostVisible,
-                                                                                                                                        vk::VkBuffer                                                           buffer);
+                                                                                                                                        vk::VkBuffer                                                           buffer,
+                                                                                                                                        deUint32&                                                                      exportedMemoryTypeIndex);
 
 vk::Move<vk::VkDeviceMemory>   importMemory                                            (const vk::DeviceInterface&                                     vkd,
                                                                                                                                         vk::VkDevice                                                           device,
                                                                                                                                         const vk::VkMemoryRequirements&                        requirements,
                                                                                                                                         vk::VkExternalMemoryHandleTypeFlagBitsKHR      externalType,
+                                                                                                                                        deUint32                                                                       memoryTypeIndex,
                                                                                                                                         NativeHandle&                                                          handle);
 
 vk::Move<vk::VkDeviceMemory>   importDedicatedMemory                           (const vk::DeviceInterface&                                     vkd,
@@ -198,6 +203,7 @@ vk::Move<vk::VkDeviceMemory>        importDedicatedMemory                           (const vk::DeviceInterface
                                                                                                                                         vk::VkBuffer                                                           buffer,
                                                                                                                                         const vk::VkMemoryRequirements&                        requirements,
                                                                                                                                         vk::VkExternalMemoryHandleTypeFlagBitsKHR      externalType,
+                                                                                                                                        deUint32                                                                       memoryTypeIndex,
                                                                                                                                         NativeHandle&                                                          handle);
 
 vk::Move<vk::VkDeviceMemory>   importDedicatedMemory                           (const vk::DeviceInterface&                                     vkd,
@@ -205,6 +211,7 @@ vk::Move<vk::VkDeviceMemory>        importDedicatedMemory                           (const vk::DeviceInterface
                                                                                                                                         vk::VkImage                                                            image,
                                                                                                                                         const vk::VkMemoryRequirements&                        requirements,
                                                                                                                                         vk::VkExternalMemoryHandleTypeFlagBitsKHR      externalType,
+                                                                                                                                        deUint32                                                                       memoryTypeIndex,
                                                                                                                                         NativeHandle&                                                          handle);
 
 vk::Move<vk::VkBuffer>                 createExternalBuffer                            (const vk::DeviceInterface&                                     vkd,