From: Gabor Abraham <gabraham.u-szeged@partner.samsung.com>
Date: Mon, 25 Jul 2016 15:28:05 +0000 (+0200)
Subject: Fix api.buffer.* tests to use sparse capable queue instead the default.
X-Git-Tag: upstream/0.1.0~662^2~62
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=d99c2b6714d69c8d73679e851363027b36ee828a;p=platform%2Fupstream%2FVK-GL-CTS.git

Fix api.buffer.* tests to use sparse capable queue instead the default.
---

diff --git a/external/vulkancts/modules/vulkan/api/vktApiBufferTests.cpp b/external/vulkancts/modules/vulkan/api/vktApiBufferTests.cpp
index 19e2fc2..533d293 100644
--- a/external/vulkancts/modules/vulkan/api/vktApiBufferTests.cpp
+++ b/external/vulkancts/modules/vulkan/api/vktApiBufferTests.cpp
@@ -30,6 +30,7 @@
 #include "vkPrograms.hpp"
 #include "vkQueryUtil.hpp"
 #include "vkRefUtil.hpp"
+#include "vkPlatform.hpp"
 #include "vktTestCase.hpp"
 
 namespace vkt
@@ -57,14 +58,127 @@ class BufferTestInstance : public TestInstance
 public:
 								BufferTestInstance			(Context&				ctx,
 															 BufferCaseParameters	testCase)
-									: TestInstance	(ctx)
-									, m_testCase	(testCase)
+									: TestInstance		(ctx)
+									, m_testCase		(testCase)
+									, m_sparseContext	(createSparseContext())
 								{}
 	virtual tcu::TestStatus		iterate						(void);
 	tcu::TestStatus				bufferCreateAndAllocTest	(VkDeviceSize		size);
 
 private:
 	BufferCaseParameters		m_testCase;
+
+private:
+	// Custom context for sparse cases
+	struct SparseContext
+	{
+		SparseContext (Move<VkDevice>& device, const deUint32 queueFamilyIndex, const InstanceInterface& interface)
+		: m_device				(device)
+		, m_queueFamilyIndex	(queueFamilyIndex)
+		, m_deviceInterface		(interface, *m_device)
+		{}
+
+		Unique<VkDevice>	m_device;
+		const deUint32		m_queueFamilyIndex;
+		DeviceDriver		m_deviceInterface;
+	};
+
+	de::UniquePtr<SparseContext>	m_sparseContext;
+
+	// Wrapper functions around m_context calls to support sparse cases.
+	VkPhysicalDevice				getPhysicalDevice (void) const
+	{
+		// Same in sparse and regular case
+		return m_context.getPhysicalDevice();
+	}
+
+	VkDevice						getDevice (void) const
+	{
+		if (m_sparseContext)
+			return *(m_sparseContext->m_device);
+
+		return m_context.getDevice();
+	}
+
+	const InstanceInterface&		getInstanceInterface (void) const
+	{
+		// Same in sparse and regular case
+		return m_context.getInstanceInterface();
+	}
+
+	const DeviceInterface&			getDeviceInterface (void) const
+	{
+		if (m_sparseContext)
+			return m_sparseContext->m_deviceInterface;
+
+		return m_context.getDeviceInterface();
+	}
+
+	deUint32						getUniversalQueueFamilyIndex (void) const
+	{
+		if (m_sparseContext)
+			return m_sparseContext->m_queueFamilyIndex;
+
+		return m_context.getUniversalQueueFamilyIndex();
+	}
+
+	static deUint32					findQueueFamilyIndexWithCaps (const InstanceInterface& vkInstance, VkPhysicalDevice physicalDevice, VkQueueFlags requiredCaps)
+	{
+		const std::vector<VkQueueFamilyProperties>	queueProps	= getPhysicalDeviceQueueFamilyProperties(vkInstance, physicalDevice);
+
+		for (size_t queueNdx = 0; queueNdx < queueProps.size(); queueNdx++)
+		{
+			if ((queueProps[queueNdx].queueFlags & requiredCaps) == requiredCaps)
+				return (deUint32)queueNdx;
+		}
+
+		TCU_THROW(NotSupportedError, "No matching queue found");
+	}
+
+	// Create the sparseContext
+	SparseContext*					createSparseContext	(void) const
+	{
+		if ((m_testCase.flags & VK_BUFFER_CREATE_SPARSE_BINDING_BIT) ||
+			(m_testCase.flags & VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT) ||
+			(m_testCase.flags & VK_BUFFER_CREATE_SPARSE_ALIASED_BIT))
+		{
+			const InstanceInterface&		vk				= getInstanceInterface();
+			const VkPhysicalDevice			physicalDevice	= getPhysicalDevice();
+			const VkPhysicalDeviceFeatures	deviceFeatures	= getPhysicalDeviceFeatures(vk, physicalDevice);
+
+			const deUint32 queueIndex = findQueueFamilyIndexWithCaps(vk, physicalDevice, VK_QUEUE_GRAPHICS_BIT|VK_QUEUE_SPARSE_BINDING_BIT);
+
+			VkDeviceQueueCreateInfo			queueInfo;
+			VkDeviceCreateInfo				deviceInfo;
+			const float						queuePriority	= 1.0f;
+
+			deMemset(&queueInfo,	0, sizeof(queueInfo));
+			deMemset(&deviceInfo,	0, sizeof(deviceInfo));
+
+			queueInfo.sType							= VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+			queueInfo.pNext							= DE_NULL;
+			queueInfo.flags							= (VkDeviceQueueCreateFlags)0u;
+			queueInfo.queueFamilyIndex				= queueIndex;
+			queueInfo.queueCount					= 1u;
+			queueInfo.pQueuePriorities				= &queuePriority;
+
+			deviceInfo.sType						= VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
+			deviceInfo.pNext						= DE_NULL;
+			deviceInfo.queueCreateInfoCount			= 1u;
+			deviceInfo.pQueueCreateInfos			= &queueInfo;
+			deviceInfo.enabledExtensionCount		= 0u;
+			deviceInfo.ppEnabledExtensionNames		= DE_NULL;
+			deviceInfo.enabledLayerCount			= 0u;
+			deviceInfo.ppEnabledLayerNames			= DE_NULL;
+			deviceInfo.pEnabledFeatures				= &deviceFeatures;
+
+			Move<VkDevice>	device = createDevice(vk, physicalDevice, &deviceInfo);
+
+			return new SparseContext(device, queueIndex, vk);
+		}
+
+		return DE_NULL;
+	}
 };
 
 class BuffersTestCase : public TestCase
@@ -90,16 +204,18 @@ private:
 	BufferCaseParameters		m_testCase;
 };
 
- tcu::TestStatus BufferTestInstance::bufferCreateAndAllocTest (VkDeviceSize size)
+
+
+tcu::TestStatus BufferTestInstance::bufferCreateAndAllocTest (VkDeviceSize size)
 {
-	const VkPhysicalDevice		vkPhysicalDevice	= m_context.getPhysicalDevice();
-	const InstanceInterface&	vkInstance			= m_context.getInstanceInterface();
-	const VkDevice				vkDevice			= m_context.getDevice();
-	const DeviceInterface&		vk					= m_context.getDeviceInterface();
+	const VkPhysicalDevice		vkPhysicalDevice	= getPhysicalDevice();
+	const InstanceInterface&	vkInstance			= getInstanceInterface();
+	const VkDevice				vkDevice			= getDevice();
+	const DeviceInterface&		vk					= getDeviceInterface();
 	Move<VkBuffer>				testBuffer;
 	VkMemoryRequirements		memReqs;
 	Move<VkDeviceMemory>		memory;
-	const deUint32				queueFamilyIndex	= m_context.getUniversalQueueFamilyIndex();
+	const deUint32				queueFamilyIndex	= getUniversalQueueFamilyIndex();
 	const VkPhysicalDeviceMemoryProperties	memoryProperties = getPhysicalDeviceMemoryProperties(vkInstance, vkPhysicalDevice);
 
 	// Create buffer
@@ -239,7 +355,7 @@ private:
 
 tcu::TestStatus BufferTestInstance::iterate (void)
 {
-	const VkPhysicalDeviceFeatures&	physicalDeviceFeatures	= m_context.getDeviceFeatures();
+	const VkPhysicalDeviceFeatures&	physicalDeviceFeatures	= getPhysicalDeviceFeatures(getInstanceInterface(), getPhysicalDevice());
 
 	if ((m_testCase.flags & VK_BUFFER_CREATE_SPARSE_BINDING_BIT ) && !physicalDeviceFeatures.sparseBinding)
 		TCU_THROW(NotSupportedError, "Sparse bindings feature is not supported");
@@ -267,8 +383,8 @@ tcu::TestStatus BufferTestInstance::iterate (void)
 
 	if (m_testCase.usage & (VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT))
 	{
-		const VkPhysicalDevice					vkPhysicalDevice	= m_context.getPhysicalDevice();
-		const InstanceInterface&				vkInstance			= m_context.getInstanceInterface();
+		const VkPhysicalDevice					vkPhysicalDevice	= getPhysicalDevice();
+		const InstanceInterface&				vkInstance			= getInstanceInterface();
 		VkPhysicalDeviceProperties	props;
 
 		vkInstance.getPhysicalDeviceProperties(vkPhysicalDevice, &props);