1#ifndef _VKTSPARSERESOURCESSHADERINTRINSICSBASE_HPP
2#define _VKTSPARSERESOURCESSHADERINTRINSICSBASE_HPP
3/*------------------------------------------------------------------------
4 * Vulkan Conformance Tests
5 * ------------------------
6 *
7 * Copyright (c) 2016 The Khronos Group Inc.
8 *
9 * Licensed under the Apache License, Version 2.0 (the "License");
10 * you may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
12 *
13 *      http://www.apache.org/licenses/LICENSE-2.0
14 *
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
20 *
21 *//*!
22 * \file  vktSparseResourcesShaderIntrinsicsBase.hpp
23 * \brief Sparse Resources Shader Intrinsics Base Classes
24 *//*--------------------------------------------------------------------*/
25
26#include "tcuDefs.hpp"
27#include "vktTestCase.hpp"
28#include "vktTestCaseUtil.hpp"
29#include "vktSparseResourcesBase.hpp"
30#include "vktSparseResourcesTestsUtil.hpp"
31
32#include "vkDefs.hpp"
33#include "vkRef.hpp"
34#include "vkRefUtil.hpp"
35#include "vkPlatform.hpp"
36#include "vkPrograms.hpp"
37#include "vkRefUtil.hpp"
38#include "vkMemUtil.hpp"
39#include "vkQueryUtil.hpp"
40#include "vkBuilderUtil.hpp"
41#include "vkTypeUtil.hpp"
42#include "vkDebugReportUtil.hpp"
43#include "tcuTextureUtil.hpp"
44
45#include "deStringUtil.hpp"
46#include "deUniquePtr.hpp"
47#include "deSharedPtr.hpp"
48
49#include <string>
50#include <vector>
51
52#include <deMath.h>
53
54namespace vkt
55{
56namespace sparse
57{
58
59enum
60{
61	MEMORY_BLOCK_BOUND		= 0u,
62	MEMORY_BLOCK_NOT_BOUND	= 1u,
63	MEMORY_BLOCK_TYPE_COUNT	= 2u
64};
65
66enum
67{
68	MEMORY_BLOCK_BOUND_VALUE	 = 1u,
69	MEMORY_BLOCK_NOT_BOUND_VALUE = 2u
70};
71
72enum
73{
74	BINDING_IMAGE_SPARSE	= 0u,
75	BINDING_IMAGE_TEXELS	= 1u,
76	BINDING_IMAGE_RESIDENCY	= 2u
77};
78
79enum SpirVFunction
80{
81	SPARSE_FETCH = 0u,
82	SPARSE_READ,
83	SPARSE_SAMPLE_EXPLICIT_LOD,
84	SPARSE_SAMPLE_IMPLICIT_LOD,
85	SPARSE_GATHER,
86	SPARSE_SPIRV_FUNCTION_TYPE_LAST
87};
88
89std::string getOpTypeImageComponent			(const tcu::TextureFormat& format);
90std::string getOpTypeImageComponent			(const vk::PlanarFormatDescription& description);
91std::string getImageComponentTypeName		(const tcu::TextureFormat& format);
92std::string getImageComponentTypeName		(const vk::PlanarFormatDescription& description);
93std::string getImageComponentVec4TypeName	(const tcu::TextureFormat& format);
94std::string getImageComponentVec4TypeName	(const vk::PlanarFormatDescription& description);
95std::string getOpTypeImageSparse			(const ImageType			imageType,
96											 const tcu::TextureFormat&	format,
97											 const std::string&			componentType,
98											 const bool					requiresSampler);
99std::string getOpTypeImageSparse			(const ImageType			imageType,
100											 const vk::VkFormat			format,
101											 const std::string&			componentType,
102											 const bool					requiresSampler);
103std::string getOpTypeImageResidency			(const ImageType imageType);
104
105class SparseShaderIntrinsicsCaseBase : public TestCase
106{
107public:
108	SparseShaderIntrinsicsCaseBase			(tcu::TestContext&			testCtx,
109											 const std::string&			name,
110											 const SpirVFunction		function,
111											 const ImageType			imageType,
112											 const tcu::UVec3&			imageSize,
113											 const vk::VkFormat			format,
114											 const std::string&			operand)
115		: TestCase(testCtx, name)
116		, m_function(function)
117		, m_imageType(imageType)
118		, m_imageSize(imageSize)
119		, m_format(format)
120		, m_operand(operand)
121	{
122	}
123
124	virtual void	checkSupport					(Context&	context) const
125	{
126		const vk::InstanceInterface&	instance		= context.getInstanceInterface();
127		const vk::VkPhysicalDevice		physicalDevice	= context.getPhysicalDevice();
128
129		context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_SHADER_RESOURCE_RESIDENCY);
130
131		// Check if image size does not exceed device limits
132		if (!isImageSizeSupported(instance, physicalDevice, m_imageType, m_imageSize))
133			TCU_THROW(NotSupportedError, "Image size not supported for device");
134
135		// Check if device supports sparse operations for image type
136		if (!checkSparseSupportForImageType(instance, physicalDevice, m_imageType))
137			TCU_THROW(NotSupportedError, "Sparse residency for image type is not supported");
138
139		if ((m_operand.find("Nontemporal") != std::string::npos) &&
140			(context.getUsedApiVersion() < VK_API_VERSION_1_3))
141			TCU_THROW(NotSupportedError, "Vulkan 1.3 or higher is required for this test to run");
142	}
143
144protected:
145	const SpirVFunction			m_function;
146	const ImageType				m_imageType;
147	const tcu::UVec3			m_imageSize;
148	const vk::VkFormat			m_format;
149	const std::string			m_operand;
150};
151
152class SparseShaderIntrinsicsInstanceBase : public SparseResourcesBaseInstance
153{
154public:
155	SparseShaderIntrinsicsInstanceBase		(Context&					context,
156											 const SpirVFunction		function,
157											 const ImageType			imageType,
158											 const tcu::UVec3&			imageSize,
159											 const vk::VkFormat			format)
160		: SparseResourcesBaseInstance(context)
161		, m_function(function)
162		, m_imageType(imageType)
163		, m_imageSize(imageSize)
164		, m_format(format)
165		, m_residencyFormat(tcu::TextureFormat::R, tcu::TextureFormat::UNSIGNED_INT32)
166	{
167	}
168
169	tcu::TestStatus						iterate					(void);
170
171	virtual vk::VkImageUsageFlags		imageSparseUsageFlags	(void) const = 0;
172	virtual vk::VkImageUsageFlags		imageOutputUsageFlags	(void) const = 0;
173
174	virtual vk::VkQueueFlags			getQueueFlags			(void) const = 0;
175
176	virtual void						recordCommands			(const vk::VkCommandBuffer		commandBuffer,
177																 const vk::VkImageCreateInfo&	imageSparseInfo,
178																 const vk::VkImage				imageSparse,
179																 const vk::VkImage				imageTexels,
180																 const vk::VkImage				imageResidency) = 0;
181	virtual void			checkSupport			(vk::VkImageCreateInfo imageSparseInfo) const;
182
183protected:
184	const SpirVFunction			m_function;
185	const ImageType				m_imageType;
186	const tcu::UVec3			m_imageSize;
187	const vk::VkFormat			m_format;
188	const tcu::TextureFormat	m_residencyFormat;
189
190	typedef de::SharedPtr< vk::Unique<vk::VkPipeline> >			SharedVkPipeline;
191	std::vector<SharedVkPipeline>								pipelines;
192	vk::Move<vk::VkPipelineLayout>								pipelineLayout;
193
194	typedef de::SharedPtr< vk::Unique<vk::VkImageView> >		SharedVkImageView;
195	std::vector<SharedVkImageView>								imageSparseViews;
196	std::vector<SharedVkImageView>								imageTexelsViews;
197	std::vector<SharedVkImageView>								imageResidencyViews;
198
199	vk::Move<vk::VkDescriptorPool>								descriptorPool;
200
201	typedef de::SharedPtr< vk::Unique<vk::VkDescriptorSet> >	SharedVkDescriptorSet;
202	std::vector<SharedVkDescriptorSet>							descriptorSets;
203};
204
205} // sparse
206} // vkt
207
208#endif // _VKTSPARSERESOURCESSHADERINTRINSICSBASE_HPP
209