• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*------------------------------------------------------------------------
2  * Vulkan Conformance Tests
3  * ------------------------
4  *
5  * Copyright (c) 2016 The Khronos Group Inc.
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  *      http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  *
19  *//*!
20  * \file  vktSparseResourcesMipmapSparseResidency.cpp
21  * \brief Sparse partially resident images with mipmaps tests
22  *//*--------------------------------------------------------------------*/
23 
24 #include "vktSparseResourcesMipmapSparseResidency.hpp"
25 #include "vktSparseResourcesTestsUtil.hpp"
26 #include "vktSparseResourcesBase.hpp"
27 #include "vktTestCaseUtil.hpp"
28 
29 #include "vkDefs.hpp"
30 #include "vkRef.hpp"
31 #include "vkRefUtil.hpp"
32 #include "vkPlatform.hpp"
33 #include "vkPrograms.hpp"
34 #include "vkMemUtil.hpp"
35 #include "vkBarrierUtil.hpp"
36 #include "vkBuilderUtil.hpp"
37 #include "vkImageUtil.hpp"
38 #include "vkQueryUtil.hpp"
39 #include "vkTypeUtil.hpp"
40 #include "vkCmdUtil.hpp"
41 
42 #include "deUniquePtr.hpp"
43 #include "deStringUtil.hpp"
44 
45 #include <string>
46 #include <vector>
47 
48 using namespace vk;
49 
50 namespace vkt
51 {
52 namespace sparse
53 {
54 namespace
55 {
56 
57 class MipmapSparseResidencyCase : public TestCase
58 {
59 public:
60 	MipmapSparseResidencyCase		(tcu::TestContext&	testCtx,
61 									 const std::string&	name,
62 									 const std::string&	description,
63 									 const ImageType	imageType,
64 									 const tcu::UVec3&	imageSize,
65 									 const VkFormat		format,
66 									 const bool			useDeviceGroups);
67 
68 	TestInstance*	createInstance				(Context&					context) const;
69 	virtual void	checkSupport				(Context&					context) const;
70 
71 private:
72 	const bool			m_useDeviceGroups;
73 	const ImageType		m_imageType;
74 	const tcu::UVec3	m_imageSize;
75 	const VkFormat		m_format;
76 };
77 
MipmapSparseResidencyCase(tcu::TestContext & testCtx,const std::string & name,const std::string & description,const ImageType imageType,const tcu::UVec3 & imageSize,const VkFormat format,const bool useDeviceGroups)78 MipmapSparseResidencyCase::MipmapSparseResidencyCase	(tcu::TestContext&	testCtx,
79 														 const std::string&	name,
80 														 const std::string&	description,
81 														 const ImageType	imageType,
82 														 const tcu::UVec3&	imageSize,
83 														 const VkFormat		format,
84 														 const bool			useDeviceGroups)
85 	: TestCase			(testCtx, name, description)
86 	, m_useDeviceGroups	(useDeviceGroups)
87 	, m_imageType		(imageType)
88 	, m_imageSize		(imageSize)
89 	, m_format			(format)
90 {
91 }
92 
checkSupport(Context & context) const93 void MipmapSparseResidencyCase::checkSupport (Context& context) const
94 {
95 	const InstanceInterface&	instance		= context.getInstanceInterface();
96 	const VkPhysicalDevice		physicalDevice	= context.getPhysicalDevice();
97 
98 	// Check if image size does not exceed device limits
99 	if (!isImageSizeSupported(instance, physicalDevice, m_imageType, m_imageSize))
100 		TCU_THROW(NotSupportedError, "Image size not supported for device");
101 
102 	// Check if device supports sparse operations for image type
103 	if (!checkSparseSupportForImageType(instance, physicalDevice, m_imageType))
104 		TCU_THROW(NotSupportedError, "Sparse residency for image type is not supported");
105 }
106 
107 class MipmapSparseResidencyInstance : public SparseResourcesBaseInstance
108 {
109 public:
110 	MipmapSparseResidencyInstance	(Context&			context,
111 									 const ImageType	imageType,
112 									 const tcu::UVec3&	imageSize,
113 									 const VkFormat		format,
114 									 const bool			useDeviceGroups);
115 
116 
117 	tcu::TestStatus	iterate			(void);
118 
119 private:
120 	const bool			m_useDeviceGroups;
121 	const ImageType		m_imageType;
122 	const tcu::UVec3	m_imageSize;
123 	const VkFormat		m_format;
124 };
125 
MipmapSparseResidencyInstance(Context & context,const ImageType imageType,const tcu::UVec3 & imageSize,const VkFormat format,const bool useDeviceGroups)126 MipmapSparseResidencyInstance::MipmapSparseResidencyInstance	(Context&			context,
127 																 const ImageType	imageType,
128 																 const tcu::UVec3&	imageSize,
129 																 const VkFormat		format,
130 																 const bool			useDeviceGroups)
131 	: SparseResourcesBaseInstance	(context, useDeviceGroups)
132 	, m_useDeviceGroups				(useDeviceGroups)
133 	, m_imageType					(imageType)
134 	, m_imageSize					(imageSize)
135 	, m_format						(format)
136 {
137 }
138 
iterate(void)139 tcu::TestStatus MipmapSparseResidencyInstance::iterate (void)
140 {
141 	const InstanceInterface&	instance		= m_context.getInstanceInterface();
142 	{
143 		// Create logical device supporting both sparse and compute operations
144 		QueueRequirementsVec queueRequirements;
145 		queueRequirements.push_back(QueueRequirements(VK_QUEUE_SPARSE_BINDING_BIT, 1u));
146 		queueRequirements.push_back(QueueRequirements(VK_QUEUE_COMPUTE_BIT, 1u));
147 
148 		createDeviceSupportingQueues(queueRequirements);
149 	}
150 
151 	const VkPhysicalDevice		physicalDevice	= getPhysicalDevice();
152 	VkImageCreateInfo			imageSparseInfo;
153 	std::vector<DeviceMemorySp>	deviceMemUniquePtrVec;
154 
155 	const DeviceInterface&			deviceInterface		= getDeviceInterface();
156 	const Queue&					sparseQueue			= getQueue(VK_QUEUE_SPARSE_BINDING_BIT, 0);
157 	const Queue&					computeQueue		= getQueue(VK_QUEUE_COMPUTE_BIT, 0);
158 	const PlanarFormatDescription	formatDescription	= getPlanarFormatDescription(m_format);
159 
160 	// Go through all physical devices
161 	for (deUint32 physDevID = 0; physDevID < m_numPhysicalDevices; physDevID++)
162 	{
163 		const deUint32	firstDeviceID			= physDevID;
164 		const deUint32	secondDeviceID			= (firstDeviceID + 1) % m_numPhysicalDevices;
165 
166 		imageSparseInfo.sType					= VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
167 		imageSparseInfo.pNext					= DE_NULL;
168 		imageSparseInfo.flags					= VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT | VK_IMAGE_CREATE_SPARSE_BINDING_BIT;
169 		imageSparseInfo.imageType				= mapImageType(m_imageType);
170 		imageSparseInfo.format					= m_format;
171 		imageSparseInfo.extent					= makeExtent3D(getLayerSize(m_imageType, m_imageSize));
172 		imageSparseInfo.arrayLayers				= getNumLayers(m_imageType, m_imageSize);
173 		imageSparseInfo.samples					= VK_SAMPLE_COUNT_1_BIT;
174 		imageSparseInfo.tiling					= VK_IMAGE_TILING_OPTIMAL;
175 		imageSparseInfo.initialLayout			= VK_IMAGE_LAYOUT_UNDEFINED;
176 		imageSparseInfo.usage					= VK_IMAGE_USAGE_TRANSFER_DST_BIT |
177 												  VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
178 		imageSparseInfo.sharingMode				= VK_SHARING_MODE_EXCLUSIVE;
179 		imageSparseInfo.queueFamilyIndexCount	= 0u;
180 		imageSparseInfo.pQueueFamilyIndices		= DE_NULL;
181 
182 		if (m_imageType == IMAGE_TYPE_CUBE || m_imageType == IMAGE_TYPE_CUBE_ARRAY)
183 		{
184 			imageSparseInfo.flags |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
185 		}
186 
187 		// Check if device supports sparse operations for image format
188 		if (!checkSparseSupportForImageFormat(instance, physicalDevice, imageSparseInfo))
189 			TCU_THROW(NotSupportedError, "The image format does not support sparse operations");
190 
191 		{
192 			VkImageFormatProperties imageFormatProperties;
193 			if (instance.getPhysicalDeviceImageFormatProperties(physicalDevice,
194 				imageSparseInfo.format,
195 				imageSparseInfo.imageType,
196 				imageSparseInfo.tiling,
197 				imageSparseInfo.usage,
198 				imageSparseInfo.flags,
199 				&imageFormatProperties) == VK_ERROR_FORMAT_NOT_SUPPORTED)
200 			{
201 				TCU_THROW(NotSupportedError, "Image format does not support sparse operations");
202 			}
203 
204 			imageSparseInfo.mipLevels = getMipmapCount(m_format, formatDescription, imageFormatProperties, imageSparseInfo.extent);
205 		}
206 
207 		// Create sparse image
208 		const Unique<VkImage>							imageSparse(createImage(deviceInterface, getDevice(), &imageSparseInfo));
209 
210 		// Create sparse image memory bind semaphore
211 		const Unique<VkSemaphore>						imageMemoryBindSemaphore(createSemaphore(deviceInterface, getDevice()));
212 
213 		std::vector<VkSparseImageMemoryRequirements>	sparseMemoryRequirements;
214 
215 		{
216 			// Get sparse image general memory requirements
217 			const VkMemoryRequirements imageMemoryRequirements = getImageMemoryRequirements(deviceInterface, getDevice(), *imageSparse);
218 
219 			// Check if required image memory size does not exceed device limits
220 			if (imageMemoryRequirements.size > getPhysicalDeviceProperties(instance, physicalDevice).limits.sparseAddressSpaceSize)
221 				TCU_THROW(NotSupportedError, "Required memory size for sparse resource exceeds device limits");
222 
223 			DE_ASSERT((imageMemoryRequirements.size % imageMemoryRequirements.alignment) == 0);
224 
225 			const deUint32							memoryType = findMatchingMemoryType(instance, getPhysicalDevice(secondDeviceID), imageMemoryRequirements, MemoryRequirement::Any);
226 
227 			if (memoryType == NO_MATCH_FOUND)
228 				return tcu::TestStatus::fail("No matching memory type found");
229 
230 			if (firstDeviceID != secondDeviceID)
231 			{
232 				VkPeerMemoryFeatureFlags	peerMemoryFeatureFlags = (VkPeerMemoryFeatureFlags)0;
233 				const deUint32				heapIndex = getHeapIndexForMemoryType(instance, getPhysicalDevice(secondDeviceID), memoryType);
234 				deviceInterface.getDeviceGroupPeerMemoryFeatures(getDevice(), heapIndex, firstDeviceID, secondDeviceID, &peerMemoryFeatureFlags);
235 
236 				if (((peerMemoryFeatureFlags & VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT) == 0) ||
237 					((peerMemoryFeatureFlags & VK_PEER_MEMORY_FEATURE_COPY_DST_BIT) == 0))
238 				{
239 					TCU_THROW(NotSupportedError, "Peer memory does not support COPY_SRC and COPY_DST");
240 				}
241 			}
242 
243 			// Get sparse image sparse memory requirements
244 			sparseMemoryRequirements = getImageSparseMemoryRequirements(deviceInterface, getDevice(), *imageSparse);
245 			DE_ASSERT(sparseMemoryRequirements.size() != 0);
246 
247 			const deUint32 metadataAspectIndex	= getSparseAspectRequirementsIndex(sparseMemoryRequirements, VK_IMAGE_ASPECT_METADATA_BIT);
248 
249 			std::vector<VkSparseImageMemoryBind>	imageResidencyMemoryBinds;
250 			std::vector<VkSparseMemoryBind>			imageMipTailMemoryBinds;
251 
252 			for (deUint32 planeNdx = 0; planeNdx < formatDescription.numPlanes; ++planeNdx)
253 			{
254 				const VkImageAspectFlags		aspect				= (formatDescription.numPlanes > 1) ? getPlaneAspect(planeNdx) : VK_IMAGE_ASPECT_COLOR_BIT;
255 				const deUint32					aspectIndex			= getSparseAspectRequirementsIndex(sparseMemoryRequirements, aspect);
256 
257 				if (aspectIndex == NO_MATCH_FOUND)
258 					TCU_THROW(NotSupportedError, "Not supported image aspect");
259 
260 				VkSparseImageMemoryRequirements	aspectRequirements	= sparseMemoryRequirements[aspectIndex];
261 
262 				DE_ASSERT((aspectRequirements.imageMipTailSize % imageMemoryRequirements.alignment) == 0);
263 
264 				VkExtent3D						imageGranularity	= aspectRequirements.formatProperties.imageGranularity;
265 
266 				// Bind memory for each layer
267 				for (deUint32 layerNdx = 0; layerNdx < imageSparseInfo.arrayLayers; ++layerNdx)
268 				{
269 					for (deUint32 mipLevelNdx = 0; mipLevelNdx < aspectRequirements.imageMipTailFirstLod; ++mipLevelNdx)
270 					{
271 						const VkExtent3D			mipExtent			= getPlaneExtent(formatDescription, imageSparseInfo.extent, planeNdx, mipLevelNdx);
272 						const tcu::UVec3			sparseBlocks		= alignedDivide(mipExtent, imageGranularity);
273 						const deUint32				numSparseBlocks		= sparseBlocks.x() * sparseBlocks.y() * sparseBlocks.z();
274 						const VkImageSubresource	subresource			= { aspect, mipLevelNdx, layerNdx };
275 
276 						const VkSparseImageMemoryBind imageMemoryBind = makeSparseImageMemoryBind(deviceInterface, getDevice(),
277 							imageMemoryRequirements.alignment * numSparseBlocks, memoryType, subresource, makeOffset3D(0u, 0u, 0u), mipExtent);
278 
279 						deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL))));
280 
281 						imageResidencyMemoryBinds.push_back(imageMemoryBind);
282 					}
283 
284 					if (!(aspectRequirements.formatProperties.flags & VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT) && aspectRequirements.imageMipTailFirstLod < imageSparseInfo.mipLevels)
285 					{
286 						const VkSparseMemoryBind imageMipTailMemoryBind = makeSparseMemoryBind(deviceInterface, getDevice(),
287 							aspectRequirements.imageMipTailSize, memoryType, aspectRequirements.imageMipTailOffset + layerNdx * aspectRequirements.imageMipTailStride);
288 
289 						deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageMipTailMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL))));
290 
291 						imageMipTailMemoryBinds.push_back(imageMipTailMemoryBind);
292 					}
293 
294 					// Metadata
295 					if (metadataAspectIndex != NO_MATCH_FOUND)
296 					{
297 						const VkSparseImageMemoryRequirements metadataAspectRequirements = sparseMemoryRequirements[metadataAspectIndex];
298 
299 						if (!(metadataAspectRequirements.formatProperties.flags & VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT))
300 						{
301 							const VkSparseMemoryBind imageMipTailMemoryBind = makeSparseMemoryBind(deviceInterface, getDevice(),
302 								metadataAspectRequirements.imageMipTailSize, memoryType,
303 								metadataAspectRequirements.imageMipTailOffset + layerNdx * metadataAspectRequirements.imageMipTailStride,
304 								VK_SPARSE_MEMORY_BIND_METADATA_BIT);
305 
306 							deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageMipTailMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL))));
307 
308 							imageMipTailMemoryBinds.push_back(imageMipTailMemoryBind);
309 						}
310 					}
311 				}
312 
313 				if ((aspectRequirements.formatProperties.flags & VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT) && aspectRequirements.imageMipTailFirstLod < imageSparseInfo.mipLevels)
314 				{
315 					const VkSparseMemoryBind imageMipTailMemoryBind = makeSparseMemoryBind(deviceInterface, getDevice(),
316 						aspectRequirements.imageMipTailSize, memoryType, aspectRequirements.imageMipTailOffset);
317 
318 					deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageMipTailMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL))));
319 
320 					imageMipTailMemoryBinds.push_back(imageMipTailMemoryBind);
321 				}
322 			}
323 
324 			// Metadata
325 			if (metadataAspectIndex != NO_MATCH_FOUND)
326 			{
327 				const VkSparseImageMemoryRequirements metadataAspectRequirements = sparseMemoryRequirements[metadataAspectIndex];
328 
329 				if (metadataAspectRequirements.formatProperties.flags & VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT)
330 				{
331 					const VkSparseMemoryBind imageMipTailMemoryBind = makeSparseMemoryBind(deviceInterface, getDevice(),
332 						metadataAspectRequirements.imageMipTailSize, memoryType, metadataAspectRequirements.imageMipTailOffset,
333 						VK_SPARSE_MEMORY_BIND_METADATA_BIT);
334 
335 					deviceMemUniquePtrVec.push_back(makeVkSharedPtr(Move<VkDeviceMemory>(check<VkDeviceMemory>(imageMipTailMemoryBind.memory), Deleter<VkDeviceMemory>(deviceInterface, getDevice(), DE_NULL))));
336 
337 					imageMipTailMemoryBinds.push_back(imageMipTailMemoryBind);
338 				}
339 			}
340 
341 			const VkDeviceGroupBindSparseInfo devGroupBindSparseInfo =
342 			{
343 				VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR,	//VkStructureType							sType;
344 				DE_NULL,												//const void*								pNext;
345 				firstDeviceID,											//deUint32									resourceDeviceIndex;
346 				secondDeviceID,											//deUint32									memoryDeviceIndex;
347 			};
348 
349 			VkBindSparseInfo bindSparseInfo =
350 			{
351 				VK_STRUCTURE_TYPE_BIND_SPARSE_INFO,						//VkStructureType							sType;
352 				m_useDeviceGroups ? &devGroupBindSparseInfo : DE_NULL,	//const void*								pNext;
353 				0u,														//deUint32									waitSemaphoreCount;
354 				DE_NULL,												//const VkSemaphore*						pWaitSemaphores;
355 				0u,														//deUint32									bufferBindCount;
356 				DE_NULL,												//const VkSparseBufferMemoryBindInfo*		pBufferBinds;
357 				0u,														//deUint32									imageOpaqueBindCount;
358 				DE_NULL,												//const VkSparseImageOpaqueMemoryBindInfo*	pImageOpaqueBinds;
359 				0u,														//deUint32									imageBindCount;
360 				DE_NULL,												//const VkSparseImageMemoryBindInfo*		pImageBinds;
361 				1u,														//deUint32									signalSemaphoreCount;
362 				&imageMemoryBindSemaphore.get()							//const VkSemaphore*						pSignalSemaphores;
363 			};
364 
365 			VkSparseImageMemoryBindInfo			imageResidencyBindInfo;
366 			VkSparseImageOpaqueMemoryBindInfo	imageMipTailBindInfo;
367 
368 			if (imageResidencyMemoryBinds.size() > 0)
369 			{
370 				imageResidencyBindInfo.image		= *imageSparse;
371 				imageResidencyBindInfo.bindCount	= static_cast<deUint32>(imageResidencyMemoryBinds.size());
372 				imageResidencyBindInfo.pBinds		= imageResidencyMemoryBinds.data();
373 
374 				bindSparseInfo.imageBindCount		= 1u;
375 				bindSparseInfo.pImageBinds			= &imageResidencyBindInfo;
376 			}
377 
378 			if (imageMipTailMemoryBinds.size() > 0)
379 			{
380 				imageMipTailBindInfo.image			= *imageSparse;
381 				imageMipTailBindInfo.bindCount		= static_cast<deUint32>(imageMipTailMemoryBinds.size());
382 				imageMipTailBindInfo.pBinds			= imageMipTailMemoryBinds.data();
383 
384 				bindSparseInfo.imageOpaqueBindCount	= 1u;
385 				bindSparseInfo.pImageOpaqueBinds	= &imageMipTailBindInfo;
386 			}
387 
388 			// Submit sparse bind commands for execution
389 			VK_CHECK(deviceInterface.queueBindSparse(sparseQueue.queueHandle, 1u, &bindSparseInfo, DE_NULL));
390 		}
391 
392 		deUint32 imageSizeInBytes = 0;
393 
394 		for (deUint32 planeNdx = 0; planeNdx < formatDescription.numPlanes; ++planeNdx)
395 			for (deUint32 mipmapNdx = 0; mipmapNdx < imageSparseInfo.mipLevels; ++mipmapNdx)
396 				imageSizeInBytes += getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, formatDescription, planeNdx, mipmapNdx, BUFFER_IMAGE_COPY_OFFSET_GRANULARITY);
397 
398 		std::vector <VkBufferImageCopy>	bufferImageCopy(formatDescription.numPlanes*imageSparseInfo.mipLevels);
399 		{
400 			deUint32 bufferOffset = 0;
401 
402 			for (deUint32 planeNdx = 0; planeNdx < formatDescription.numPlanes; ++planeNdx)
403 			{
404 				const VkImageAspectFlags aspect = (formatDescription.numPlanes > 1) ? getPlaneAspect(planeNdx) : VK_IMAGE_ASPECT_COLOR_BIT;
405 
406 				for (deUint32 mipmapNdx = 0; mipmapNdx < imageSparseInfo.mipLevels; ++mipmapNdx)
407 				{
408 					bufferImageCopy[planeNdx*imageSparseInfo.mipLevels + mipmapNdx] =
409 					{
410 						bufferOffset,																		//	VkDeviceSize				bufferOffset;
411 						0u,																					//	deUint32					bufferRowLength;
412 						0u,																					//	deUint32					bufferImageHeight;
413 						makeImageSubresourceLayers(aspect, mipmapNdx, 0u, imageSparseInfo.arrayLayers),		//	VkImageSubresourceLayers	imageSubresource;
414 						makeOffset3D(0, 0, 0),																//	VkOffset3D					imageOffset;
415 						vk::getPlaneExtent(formatDescription, imageSparseInfo.extent, planeNdx, mipmapNdx)	//	VkExtent3D					imageExtent;
416 					};
417 					bufferOffset += getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, formatDescription, planeNdx, mipmapNdx, BUFFER_IMAGE_COPY_OFFSET_GRANULARITY);
418 				}
419 			}
420 		}
421 
422 		// Create command buffer for compute and transfer operations
423 		const Unique<VkCommandPool>		commandPool(makeCommandPool(deviceInterface, getDevice(), computeQueue.queueFamilyIndex));
424 		const Unique<VkCommandBuffer>	commandBuffer(allocateCommandBuffer(deviceInterface, getDevice(), *commandPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
425 
426 		// Start recording commands
427 		beginCommandBuffer(deviceInterface, *commandBuffer);
428 
429 		const VkBufferCreateInfo		inputBufferCreateInfo	= makeBufferCreateInfo(imageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
430 		const Unique<VkBuffer>			inputBuffer				(createBuffer(deviceInterface, getDevice(), &inputBufferCreateInfo));
431 		const de::UniquePtr<Allocation>	inputBufferAlloc		(bindBuffer(deviceInterface, getDevice(), getAllocator(), *inputBuffer, MemoryRequirement::HostVisible));
432 
433 		std::vector<deUint8> referenceData(imageSizeInBytes);
434 
435 		const VkMemoryRequirements imageMemoryRequirements = getImageMemoryRequirements(deviceInterface, getDevice(), *imageSparse);
436 
437 		for (deUint32 valueNdx = 0; valueNdx < imageSizeInBytes; ++valueNdx)
438 		{
439 			referenceData[valueNdx] = static_cast<deUint8>((valueNdx % imageMemoryRequirements.alignment) + 1u);
440 		}
441 
442 		{
443 			deMemcpy(inputBufferAlloc->getHostPtr(), referenceData.data(), imageSizeInBytes);
444 			flushAlloc(deviceInterface, getDevice(), *inputBufferAlloc);
445 
446 			const VkBufferMemoryBarrier inputBufferBarrier = makeBufferMemoryBarrier
447 			(
448 				VK_ACCESS_HOST_WRITE_BIT,
449 				VK_ACCESS_TRANSFER_READ_BIT,
450 				*inputBuffer,
451 				0u,
452 				imageSizeInBytes
453 			);
454 
455 			deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 1u, &inputBufferBarrier, 0u, DE_NULL);
456 		}
457 
458 		{
459 			std::vector<VkImageMemoryBarrier> imageSparseTransferDstBarriers;
460 
461 			for (deUint32 planeNdx = 0; planeNdx < formatDescription.numPlanes; ++planeNdx)
462 			{
463 				const VkImageAspectFlags aspect = (formatDescription.numPlanes > 1) ? getPlaneAspect(planeNdx) : VK_IMAGE_ASPECT_COLOR_BIT;
464 
465 				imageSparseTransferDstBarriers.emplace_back ( makeImageMemoryBarrier
466 				(
467 					0u,
468 					VK_ACCESS_TRANSFER_WRITE_BIT,
469 					VK_IMAGE_LAYOUT_UNDEFINED,
470 					VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
471 					*imageSparse,
472 					makeImageSubresourceRange(aspect, 0u, imageSparseInfo.mipLevels, 0u, imageSparseInfo.arrayLayers),
473 					sparseQueue.queueFamilyIndex != computeQueue.queueFamilyIndex ? sparseQueue.queueFamilyIndex : VK_QUEUE_FAMILY_IGNORED,
474 					sparseQueue.queueFamilyIndex != computeQueue.queueFamilyIndex ? computeQueue.queueFamilyIndex : VK_QUEUE_FAMILY_IGNORED
475 				));
476 			}
477 			deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, static_cast<deUint32>(imageSparseTransferDstBarriers.size()), imageSparseTransferDstBarriers.data());
478 		}
479 
480 		deviceInterface.cmdCopyBufferToImage(*commandBuffer, *inputBuffer, *imageSparse, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, static_cast<deUint32>(bufferImageCopy.size()), &bufferImageCopy[0]);
481 
482 		{
483 			std::vector<VkImageMemoryBarrier> imageSparseTransferSrcBarriers;
484 
485 			for (deUint32 planeNdx = 0; planeNdx < formatDescription.numPlanes; ++planeNdx)
486 			{
487 				const VkImageAspectFlags aspect = (formatDescription.numPlanes > 1) ? getPlaneAspect(planeNdx) : VK_IMAGE_ASPECT_COLOR_BIT;
488 
489 				imageSparseTransferSrcBarriers.emplace_back(makeImageMemoryBarrier
490 				(
491 					VK_ACCESS_TRANSFER_WRITE_BIT,
492 					VK_ACCESS_TRANSFER_READ_BIT,
493 					VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
494 					VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
495 					*imageSparse,
496 					makeImageSubresourceRange(aspect, 0u, imageSparseInfo.mipLevels, 0u, imageSparseInfo.arrayLayers)
497 				));
498 			}
499 
500 			deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, static_cast<deUint32>(imageSparseTransferSrcBarriers.size()), imageSparseTransferSrcBarriers.data());
501 		}
502 
503 		const VkBufferCreateInfo		outputBufferCreateInfo	= makeBufferCreateInfo(imageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT);
504 		const Unique<VkBuffer>			outputBuffer			(createBuffer(deviceInterface, getDevice(), &outputBufferCreateInfo));
505 		const de::UniquePtr<Allocation>	outputBufferAlloc		(bindBuffer(deviceInterface, getDevice(), getAllocator(), *outputBuffer, MemoryRequirement::HostVisible));
506 
507 		deviceInterface.cmdCopyImageToBuffer(*commandBuffer, *imageSparse, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *outputBuffer, static_cast<deUint32>(bufferImageCopy.size()), bufferImageCopy.data());
508 
509 		{
510 			const VkBufferMemoryBarrier outputBufferBarrier = makeBufferMemoryBarrier
511 			(
512 				VK_ACCESS_TRANSFER_WRITE_BIT,
513 				VK_ACCESS_HOST_READ_BIT,
514 				*outputBuffer,
515 				0u,
516 				imageSizeInBytes
517 			);
518 
519 			deviceInterface.cmdPipelineBarrier(*commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u, 0u, DE_NULL, 1u, &outputBufferBarrier, 0u, DE_NULL);
520 		}
521 
522 		// End recording commands
523 		endCommandBuffer(deviceInterface, *commandBuffer);
524 
525 		const VkPipelineStageFlags stageBits[] = { VK_PIPELINE_STAGE_TRANSFER_BIT };
526 
527 		// Submit commands for execution and wait for completion
528 		submitCommandsAndWait(deviceInterface, getDevice(), computeQueue.queueHandle, *commandBuffer, 1u, &imageMemoryBindSemaphore.get(), stageBits,
529 			0, DE_NULL, m_useDeviceGroups, firstDeviceID);
530 
531 		// Retrieve data from buffer to host memory
532 		invalidateAlloc(deviceInterface, getDevice(), *outputBufferAlloc);
533 
534 		const deUint8* outputData = static_cast<const deUint8*>(outputBufferAlloc->getHostPtr());
535 
536 		// Wait for sparse queue to become idle
537 		deviceInterface.queueWaitIdle(sparseQueue.queueHandle);
538 
539 		for (deUint32 planeNdx = 0; planeNdx < formatDescription.numPlanes; ++planeNdx)
540 		{
541 			for (deUint32 mipmapNdx = 0; mipmapNdx < imageSparseInfo.mipLevels; ++mipmapNdx)
542 			{
543 				const deUint32 mipLevelSizeInBytes	= getImageMipLevelSizeInBytes(imageSparseInfo.extent, imageSparseInfo.arrayLayers, formatDescription, planeNdx, mipmapNdx);
544 				const deUint32 bufferOffset			= static_cast<deUint32>(bufferImageCopy[planeNdx*imageSparseInfo.mipLevels + mipmapNdx].bufferOffset);
545 
546 				if (deMemCmp(outputData + bufferOffset, &referenceData[bufferOffset], mipLevelSizeInBytes) != 0)
547 					return tcu::TestStatus::fail("Failed");
548 			}
549 		}
550 	}
551 	return tcu::TestStatus::pass("Passed");
552 }
553 
createInstance(Context & context) const554 TestInstance* MipmapSparseResidencyCase::createInstance (Context& context) const
555 {
556 	return new MipmapSparseResidencyInstance(context, m_imageType, m_imageSize, m_format, m_useDeviceGroups);
557 }
558 
559 } // anonymous ns
560 
createMipmapSparseResidencyTestsCommon(tcu::TestContext & testCtx,de::MovePtr<tcu::TestCaseGroup> testGroup,const bool useDeviceGroup=false)561 tcu::TestCaseGroup* createMipmapSparseResidencyTestsCommon (tcu::TestContext& testCtx, de::MovePtr<tcu::TestCaseGroup> testGroup, const bool useDeviceGroup = false)
562 {
563 	const std::vector<TestImageParameters> imageParameters =
564 	{
565 		{ IMAGE_TYPE_2D,			{ tcu::UVec3(512u, 256u, 1u),	tcu::UVec3(1024u, 128u, 1u),	tcu::UVec3(11u,  137u, 1u) },	getTestFormats(IMAGE_TYPE_2D) },
566 		{ IMAGE_TYPE_2D_ARRAY,		{ tcu::UVec3(512u, 256u, 6u),	tcu::UVec3(1024u, 128u, 8u),	tcu::UVec3(11u,  137u, 3u) },	getTestFormats(IMAGE_TYPE_2D_ARRAY) },
567 		{ IMAGE_TYPE_CUBE,			{ tcu::UVec3(256u, 256u, 1u),	tcu::UVec3(128u,  128u, 1u),	tcu::UVec3(137u, 137u, 1u) },	getTestFormats(IMAGE_TYPE_CUBE) },
568 		{ IMAGE_TYPE_CUBE_ARRAY,	{ tcu::UVec3(256u, 256u, 6u),	tcu::UVec3(128u,  128u, 8u),	tcu::UVec3(137u, 137u, 3u) },	getTestFormats(IMAGE_TYPE_CUBE_ARRAY) },
569 		{ IMAGE_TYPE_3D,			{ tcu::UVec3(256u, 256u, 16u),	tcu::UVec3(1024u, 128u, 8u),	tcu::UVec3(11u,  137u, 3u) },	getTestFormats(IMAGE_TYPE_3D) }
570 	};
571 
572 	for (size_t imageTypeNdx = 0; imageTypeNdx < imageParameters.size(); ++imageTypeNdx)
573 	{
574 		const ImageType					imageType = imageParameters[imageTypeNdx].imageType;
575 		de::MovePtr<tcu::TestCaseGroup> imageTypeGroup(new tcu::TestCaseGroup(testCtx, getImageTypeName(imageType).c_str(), ""));
576 
577 		for (size_t formatNdx = 0; formatNdx < imageParameters[imageTypeNdx].formats.size(); ++formatNdx)
578 		{
579 			VkFormat						format				= imageParameters[imageTypeNdx].formats[formatNdx].format;
580 			tcu::UVec3						imageSizeAlignment	= getImageSizeAlignment(format);
581 			de::MovePtr<tcu::TestCaseGroup> formatGroup			(new tcu::TestCaseGroup(testCtx, getImageFormatID(format).c_str(), ""));
582 
583 			for (size_t imageSizeNdx = 0; imageSizeNdx < imageParameters[imageTypeNdx].imageSizes.size(); ++imageSizeNdx)
584 			{
585 				const tcu::UVec3 imageSize = imageParameters[imageTypeNdx].imageSizes[imageSizeNdx];
586 
587 				// skip test for images with odd sizes for some YCbCr formats
588 				if ((imageSize.x() % imageSizeAlignment.x()) != 0)
589 					continue;
590 				if ((imageSize.y() % imageSizeAlignment.y()) != 0)
591 					continue;
592 
593 				std::ostringstream stream;
594 				stream << imageSize.x() << "_" << imageSize.y() << "_" << imageSize.z();
595 
596 				formatGroup->addChild(new MipmapSparseResidencyCase(testCtx, stream.str(), "", imageType, imageSize, format, useDeviceGroup));
597 			}
598 			imageTypeGroup->addChild(formatGroup.release());
599 		}
600 		testGroup->addChild(imageTypeGroup.release());
601 	}
602 
603 	return testGroup.release();
604 }
605 
createMipmapSparseResidencyTests(tcu::TestContext & testCtx)606 tcu::TestCaseGroup* createMipmapSparseResidencyTests (tcu::TestContext& testCtx)
607 {
608 	de::MovePtr<tcu::TestCaseGroup> testGroup(new tcu::TestCaseGroup(testCtx, "mipmap_sparse_residency", "Mipmap Sparse Residency"));
609 	return createMipmapSparseResidencyTestsCommon(testCtx, testGroup);
610 }
611 
createDeviceGroupMipmapSparseResidencyTests(tcu::TestContext & testCtx)612 tcu::TestCaseGroup* createDeviceGroupMipmapSparseResidencyTests (tcu::TestContext& testCtx)
613 {
614 	de::MovePtr<tcu::TestCaseGroup> testGroup(new tcu::TestCaseGroup(testCtx, "device_group_mipmap_sparse_residency", "Mipmap Sparse Residency"));
615 	return createMipmapSparseResidencyTestsCommon(testCtx, testGroup, true);
616 }
617 
618 } // sparse
619 } // vkt
620