Fix use protected memory device

To create protected buffer use the protected memory enabled
device, otherwise use the default device.

Components: Vulkan

Affects: dEQP-VK.api.buffer_memory_requirements.*

VK-GL-CTS issue: 4173

Change-Id: I4882ad753a3cd940d6a2e8d01cca7c32d92be72e

diff --git a/external/vulkancts/modules/vulkan/api/vktApiBufferMemoryRequirementsTests.cpp b/external/vulkancts/modules/vulkan/api/vktApiBufferMemoryRequirementsTests.cpp
index f181f1b..b78e4bb 100644 (file)
--- a/external/vulkancts/modules/vulkan/api/vktApiBufferMemoryRequirementsTests.cpp
+++ b/external/vulkancts/modules/vulkan/api/vktApiBufferMemoryRequirementsTests.cpp
@@ -24,6 +24,7 @@
 
 #include "vktApiBufferMemoryRequirementsTests.hpp"
 #include "vktApiBufferMemoryRequirementsTestsUtils.hpp"
+#include "vktCustomInstancesDevices.hpp"
 
 #include "vkMemUtil.hpp"
 #include "vkQueryUtil.hpp"
@@ -32,6 +33,7 @@
 #include "vkObjUtil.hpp"
 #include "deFilePath.hpp"
 #include "tcuTestLog.hpp"
+#include "tcuCommandLine.hpp"
 
 #include <algorithm>
 #include <array>
@@ -772,10 +774,44 @@ template<> void* BufferMemoryRequirementsInstance::chainVkStructure<VkVideoProfi
 }
 #endif // CTS_USES_VULKANSC
 
+static Move<VkDevice> createProtectedDevice(const Context &context)
+{
+       auto &cmdLine = context.getTestContext().getCommandLine();
+       const float queuePriority = 1.0f;
+
+       VkPhysicalDeviceProtectedMemoryFeatures protectedMemoryFeatures;
+       protectedMemoryFeatures.sType = vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
+       protectedMemoryFeatures.pNext = DE_NULL;
+       protectedMemoryFeatures.protectedMemory = VK_TRUE;
+
+       VkDeviceQueueCreateInfo queueInfo =
+       {
+               VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,     // VkStructureType                      sType;
+               DE_NULL,                                                                        // const void*                          pNext;
+               vk::VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT,       // VkDeviceQueueCreateFlags     flags;
+               context.getUniversalQueueFamilyIndex(),         // deUint32                                     queueFamilyIndex;
+               1u,                                                                                     // deUint32                                     queueCount;
+               &queuePriority                                                          // const float*                         pQueuePriorities;
+       };
+       const VkDeviceCreateInfo deviceInfo =
+       {
+               VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,   // VkStructureType                                      sType;
+               &protectedMemoryFeatures,                               // const void*                                          pNext;
+               (VkDeviceCreateFlags)0,                                 // VkDeviceCreateFlags                          flags;
+               1u,                                                                             // uint32_t                                                     queueCreateInfoCount;
+               &queueInfo,                                                             // const VkDeviceQueueCreateInfo*       pQueueCreateInfos;
+               0u,                                                                             // uint32_t                                                     enabledLayerCount;
+               DE_NULL,                                                                // const char* const*                           ppEnabledLayerNames;
+               0u,                                                                             // uint32_t                                                     enabledExtensionCount;
+               DE_NULL,                                                                // const char* const*                           ppEnabledExtensionNames;
+               DE_NULL                                                                 // const VkPhysicalDeviceFeatures*      pEnabledFeatures;
+       };
+       return createCustomDevice(cmdLine.isValidationEnabled(), context.getPlatformInterface(), context.getInstance(), context.getInstanceInterface(), context.getPhysicalDevice(), &deviceInfo);
+}
+
 TestStatus     BufferMemoryRequirementsInstance::iterate (void)
 {
        const DeviceInterface&                                                  vkd                                     = m_context.getDeviceInterface();
-       const VkDevice                                                                  device                          = m_context.getDevice();
        const deUint32                                                                  queueFamilyIndex        = m_context.getUniversalQueueFamilyIndex();
        const Method                                                                    method                          = m_config.useMethod2
                                                                                                                                                        ? &BufferMemoryRequirementsInstance::getBufferMemoryRequirements2
@@ -787,6 +823,18 @@ TestStatus BufferMemoryRequirementsInstance::iterate (void)
        std::vector<BufferUsageBitsPtr>                                 failUsageBits;
        std::vector<ExternalMemoryHandleBitsPtr>                failExtMemHandleBits;
 
+       Move<VkDevice> protectedDevice;
+       VkDevice device;
+       if (m_config.createBits->contains(VK_BUFFER_CREATE_PROTECTED_BIT))
+       {
+               protectedDevice = createProtectedDevice(m_context);
+               device = *protectedDevice;
+       }
+       else
+       {
+               device = m_context.getDevice();
+       }
+
        DE_ASSERT(!m_config.createBits->empty());
        const VkBufferCreateFlags infoCreateFlags = *m_config.createBits;
        {