external/vulkancts/modules/vulkan/sc/vktObjectRefreshTests.cpp - third_party/vulkan-cts - Git at Google

 /*------------------------------------------------------------------------
  * Vulkan Conformance Tests
  * ------------------------
  *
  * Copyright (c) 2021 The Khronos Group Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *	  http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
  *//*!
  * \file
  * \brief Vulkan SC VK_KHR_object_refresh Tests
 *//*--------------------------------------------------------------------*/

 #include "vktObjectRefreshTests.hpp"

 #include "vkDefs.hpp"
 #include "vkRefUtil.hpp"
 #include "vkDefs.hpp"
 #include "vkDeviceUtil.hpp"
 #include "vkPlatform.hpp"
 #include "vkTypeUtil.hpp"
 #include "vkPrograms.hpp"
 #include "vkCmdUtil.hpp"
 #include "vkObjUtil.hpp"
 #include "vkMemUtil.hpp"
 #include "vktTestCaseUtil.hpp"
 #include "vkQueryUtil.hpp"

 #include <map>
 #include <vector>

 namespace vkt
 {
 namespace sc
 {
 namespace
 {

 tcu::TestStatus queryRefreshableObjects(Context& context)
 {
 	deUint32						countReported	= 0u;
 	vk::VkPhysicalDevice			physicalDevice	= context.getPhysicalDevice();
 	const vk::InstanceInterface&	vki				= context.getInstanceInterface();

 	// get number of refreshable objects
 	vk::VkResult result = vki.getPhysicalDeviceRefreshableObjectTypesKHR(physicalDevice, &countReported, DE_NULL);
 	if (result != vk::VK_SUCCESS)
 		TCU_THROW(NotSupportedError, "vkGetPhysicalDeviceRefreshableObjectTypesKHR returned invalid return code");

 	if (countReported == 0)
 		TCU_THROW(NotSupportedError, "No refreshable objects available");

 	deUint32						refreshableObjectsMaxCount	(countReported + 2);
 	std::vector<vk::VkObjectType>	refreshableObjects			(refreshableObjectsMaxCount);

 	for (deUint32 countRequested = 0; countRequested < refreshableObjectsMaxCount; ++countRequested)
 	{
 		// get refreshable objects
 		deUint32 countRetrieved = countRequested;
 		std::fill(refreshableObjects.begin(), refreshableObjects.end(), vk::VK_OBJECT_TYPE_UNKNOWN);
 		result = vki.getPhysicalDeviceRefreshableObjectTypesKHR(physicalDevice, &countRetrieved, refreshableObjects.data());

 		// verify returned code
 		if ((result != vk::VK_SUCCESS) && (result != vk::VK_INCOMPLETE))
 			TCU_THROW(NotSupportedError, "vkGetPhysicalDeviceRefreshableObjectTypesKHR returned invalid return code");

 		// verify number of retrieved objects
 		if (countRetrieved != std::min(countRequested, countReported))
 			TCU_THROW(NotSupportedError, "vkGetPhysicalDeviceRefreshableObjectTypesKHR returned invalid number of retrieved objects");

 		// verify retrieved objects
 		for (deUint32 i = 0; i < countRetrieved; ++i)
 		{
 			if (refreshableObjects[i] == vk::VK_OBJECT_TYPE_UNKNOWN)
 				TCU_THROW(NotSupportedError, "vkGetPhysicalDeviceRefreshableObjectTypesKHR returned invalid object type");
 		}
 	}

 	return tcu::TestStatus::pass("pass");
 }

 tcu::TestStatus refreshObjects(Context& context, bool individualRefresh)
 {
 	deUint32						countReported	= 0u;
 	vk::VkPhysicalDevice			physicalDevice	= context.getPhysicalDevice();
 	const vk::InstanceInterface&	vki				= context.getInstanceInterface();
 	const vk::DeviceInterface&		vkd				= context.getDeviceInterface();

 	vk::VkResult result = vki.getPhysicalDeviceRefreshableObjectTypesKHR(physicalDevice, &countReported, DE_NULL);
 	if ((result != vk::VK_SUCCESS) || (countReported == 0))
 		TCU_THROW(NotSupportedError, "vkGetPhysicalDeviceRefreshableObjectTypesKHR failed");

 	std::vector<vk::VkObjectType> refreshableObjectTypes(countReported);
 	result = vki.getPhysicalDeviceRefreshableObjectTypesKHR(physicalDevice, &countReported, refreshableObjectTypes.data());
 	if (result != vk::VK_SUCCESS)
 		TCU_THROW(NotSupportedError, "vkGetPhysicalDeviceRefreshableObjectTypesKHR failed");

 	// create all possible objects
 	const deUint32						queueFamilyIndex	= context.getUniversalQueueFamilyIndex();
 	vk::VkDevice						device				= context.getDevice();
 	vk::VkQueue							queue				= context.getUniversalQueue();
 	vk::Allocator&						allocator			= context.getDefaultAllocator();
 	vk::Move<vk::VkCommandPool>			cmdPool				= createCommandPool(vkd, device, vk::VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex);
 	vk::Move<vk::VkCommandBuffer>		cmdBuffer			= allocateCommandBuffer(vkd, device, *cmdPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY);
 	vk::Move<vk::VkFence>				fence				= createFence(vkd, device);
 	vk::Move<vk::VkSemaphore>			semaphore			= createSemaphore(vkd, device);
 	vk::Move<vk::VkEvent>				event				= createEvent(vkd, device);
 	const vk::VkQueryPoolCreateInfo		queryPoolCreateInfo
 	{
 		vk::VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,						// VkStructureType						sType;
 		DE_NULL,															// const void*							pNext;
 		0u,																	// VkQueryPoolCreateFlags				flags;
 		vk::VK_QUERY_TYPE_OCCLUSION,										// VkQueryType							queryType;
 		1u,																	// deUint32								queryCount;
 		0u,																	// VkQueryPipelineStatisticFlags		pipelineStatistics;
 	};
 	vk::Move<vk::VkQueryPool>			queryPool			= createQueryPool(vkd, device, &queryPoolCreateInfo);
 	const vk::VkBufferCreateInfo		bufferCreateInfo
 	{
 		vk::VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,												// VkStructureType						sType
 		DE_NULL,																				// const void*							pNext
 		0u,																						// VkBufferCreateFlags					flags
 		(vk::VkDeviceSize)64,																	// VkDeviceSize							size
 		vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT | vk::VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT,	// VkBufferUsageFlags					usage
 		vk::VK_SHARING_MODE_EXCLUSIVE,															// VkSharingMode						sharingMode
 		0u,																						// deUint32								queueFamilyIndexCount
 		DE_NULL																					// const deUint32*						pQueueFamilyIndices
 	};
 	vk::Move<vk::VkBuffer>				buffer				= createBuffer(vkd, device, &bufferCreateInfo);
 	const vk::VkMemoryRequirements		bufferRequirements	= getBufferMemoryRequirements(vkd, device, *buffer);
 	de::MovePtr<vk::Allocation>			bufferAllocation	= allocator.allocate(bufferRequirements, vk::MemoryRequirement::HostVisible);
 	vkd.bindBufferMemory(device, *buffer, bufferAllocation->getMemory(), 0);
 	vk::Move<vk::VkBufferView>			bufferView			= makeBufferView(vkd, device, *buffer, vk::VK_FORMAT_R32G32B32A32_SFLOAT, 0ull, VK_WHOLE_SIZE);
 	const vk::VkSamplerCreateInfo		samplerCreateInfo
 	{
 		vk::VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,							// VkStructureType						sType;
 		DE_NULL,															// const void*							pNext;
 		(vk::VkSamplerCreateFlags)0,										// VkSamplerCreateFlags					flags;
 		vk::VK_FILTER_NEAREST,												// VkFilter								magFilter;
 		vk::VK_FILTER_NEAREST,												// VkFilter								minFilter;
 		vk::VK_SAMPLER_MIPMAP_MODE_NEAREST,									// VkSamplerMipmapMode					mipmapMode;
 		vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,							// VkSamplerAddressMode					addressModeU;
 		vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,							// VkSamplerAddressMode					addressModeV;
 		vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,							// VkSamplerAddressMode					addressModeW;
 		0.0f,																// float								mipLodBias;
 		VK_FALSE,															// VkBool32								anisotropyEnable;
 		1.0f,																// float								maxAnisotropy;
 		VK_FALSE,															// VkBool32								compareEnable;
 		vk::VK_COMPARE_OP_ALWAYS,											// VkCompareOp							compareOp;
 		0.0f,																// float								minLod;
 		0.0f,																// float								maxLod;
 		vk::VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,						// VkBorderColor						borderColor;
 		VK_FALSE,															// VkBool32								unnormalizedCoordinates;
 	};
 	vk::Move<vk::VkSampler>							sampler			= createSampler(vkd, device, &samplerCreateInfo);
 	const vk::VkSamplerYcbcrConversionCreateInfo	conversionInfo
 	{
 		vk::VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,			// VkStructureType						sType;
 		DE_NULL,															// const void*							pNext;
 		vk::VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM,							// VkFormat								format;
 		vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,					// VkSamplerYcbcrModelConversion		ycbcrModel;
 		vk::VK_SAMPLER_YCBCR_RANGE_ITU_FULL,								// VkSamplerYcbcrRange					ycbcrRange;
 		{																	// VkComponentMapping					components;
 			vk::VK_COMPONENT_SWIZZLE_IDENTITY,
 			vk::VK_COMPONENT_SWIZZLE_IDENTITY,
 			vk::VK_COMPONENT_SWIZZLE_IDENTITY,
 			vk::VK_COMPONENT_SWIZZLE_IDENTITY
 		},
 		vk::VK_CHROMA_LOCATION_MIDPOINT,									// VkChromaLocation						xChromaOffset;
 		vk::VK_CHROMA_LOCATION_MIDPOINT,									// VkChromaLocation						yChromaOffset;
 		vk::VK_FILTER_NEAREST,												// VkFilter								chromaFilter;
 		DE_FALSE															// VkBool32								forceExplicitReconstruction;
 	};
 	vk::Move<vk::VkSamplerYcbcrConversion>			ycbcrConversion = vk::createSamplerYcbcrConversion(vkd, device, &conversionInfo);
 	const vk::VkImageCreateInfo						imageCreateInfo
 	{
 		vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,											// VkStructureType						sType;
 		DE_NULL,																			// const void*							pNext;
 		0u,																					// VkImageCreateFlags					flags;
 		vk::VK_IMAGE_TYPE_2D,																// VkImageType							imageType;
 		vk::VK_FORMAT_R8G8B8A8_UNORM,														// VkFormat								format;
 		{ 64, 64, 1 },																		// VkExtent3D							extent;
 		1u,																					// deUint32								mipLevels;
 		1u,																					// deUint32								arrayLayers;
 		vk::VK_SAMPLE_COUNT_1_BIT,															// VkSampleCountFlagBits				samples;
 		vk::VK_IMAGE_TILING_OPTIMAL,														// VkImageTiling						tiling;
 		vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT | vk::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,		// VkImageUsageFlags					usage;
 		vk::VK_SHARING_MODE_EXCLUSIVE,														// VkSharingMode						sharingMode;
 		1u,																					// deUint32								queueFamilyIndexCount;
 		&queueFamilyIndex,																	// const deUint32*						pQueueFamilyIndices;
 		vk::VK_IMAGE_LAYOUT_UNDEFINED,														// VkImageLayout						initialLayout;
 	};
 	vk::Move<vk::VkImage>					image				= createImage(vkd, device, &imageCreateInfo);
 	const vk::VkMemoryRequirements			imageRequirements	= getImageMemoryRequirements(vkd, device, *image);
 	de::MovePtr<vk::Allocation>				imageAllocation		= allocator.allocate(imageRequirements, vk::MemoryRequirement::Any);
 	vkd.bindImageMemory(device, *image, imageAllocation->getMemory(), imageAllocation->getOffset());
 	vk::Move<vk::VkImageView>				imageView			= makeImageView(vkd, device, *image, vk::VK_IMAGE_VIEW_TYPE_2D, vk::VK_FORMAT_R8G8B8A8_UNORM, makeImageSubresourceRange(vk::VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u));
 	vk::Move<vk::VkShaderModule>			shaderModule		= createShaderModule(vkd, device, context.getBinaryCollection().get("comp"), 0u);
 	vk::Move<vk::VkRenderPass>				renderPass			= makeRenderPass(vkd, device, vk::VK_FORMAT_R8G8B8A8_UNORM);
 	vk::Move<vk::VkFramebuffer>				framebuffer			= makeFramebuffer(vkd, device, *renderPass, *imageView, 64, 64);
 	const vk::VkPipelineCacheCreateInfo		pipelineCacheCreateInfo
 	{
 		vk::VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO,					// VkStructureType						sType;
 		DE_NULL,															// const void*							pNext;
 		vk::VK_PIPELINE_CACHE_CREATE_READ_ONLY_BIT |
 			vk::VK_PIPELINE_CACHE_CREATE_USE_APPLICATION_STORAGE_BIT,		// VkPipelineCacheCreateFlags	flags;
 		context.getResourceInterface()->getCacheDataSize(),					// deUintptr					initialDataSize;
 		context.getResourceInterface()->getCacheData()						// const void*					pInitialData;
 	};
 	vk::Move<vk::VkPipelineCache>			pipelineCache		= createPipelineCache(vkd, device, &pipelineCacheCreateInfo);
 	vk::Move<vk::VkPipelineLayout>			pipelineLayout		= makePipelineLayout(vkd, device);
 	vk::Move<vk::VkPipeline>				pipeline			= makeComputePipeline(vkd, device, *pipelineLayout, 0u, *shaderModule, 0u, DE_NULL);
 	const vk::VkDescriptorPoolSize			descriptorPoolSize
 	{
 		vk::VK_DESCRIPTOR_TYPE_SAMPLER,										// VkDescriptorType						type;
 		8																	// deUint32								descriptorCount;
 	};
 	const vk::VkDescriptorPoolCreateInfo	descriptorPoolCreateInfo
 	{
 		vk::VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,					// VkStructureType						sType;
 		NULL,																// const void*							pNext;
 		0u,																	// VkDescriptorPoolCreateFlags			flags;
 		8,																	// deUint32								maxSets;
 		1,																	// deUint32								poolSizeCount;
 		&descriptorPoolSize													// const VkDescriptorPoolSize*			pPoolSizes;
 	};
 	vk::Move<vk::VkDescriptorPool>			descriptorPool = createDescriptorPool(vkd, device, &descriptorPoolCreateInfo);
 	const vk::VkDescriptorSetLayoutBinding	descriptorSetLayoutBinding
 	{
 		0,																	// deUint32								binding;
 		vk::VK_DESCRIPTOR_TYPE_SAMPLER,										// VkDescriptorType						descriptorType;
 		1,																	// deUint32								descriptorCount;
 		vk::VK_SHADER_STAGE_ALL,											// VkShaderStageFlags					stageFlags;
 		NULL																// const VkSampler*						pImmutableSamplers;
 	};
 	const vk::VkDescriptorSetLayoutCreateInfo descriptorSetLayoutInfo
 	{
 		vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,			// VkStructureType						sType;
 		NULL,																// const void*							pNext;
 		0,																	// VkDescriptorSetLayoutCreateFlags		flags;
 		1,																	// deUint32								bindingCount;
 		&descriptorSetLayoutBinding											// const VkDescriptorSetLayoutBinding*	pBindings;
 	};
 	vk::Move<vk::VkDescriptorSetLayout>		descriptorSetLayout	= createDescriptorSetLayout(vkd, device, &descriptorSetLayoutInfo);
 	vk::Move<vk::VkDescriptorSet>			descriptorSet		= makeDescriptorSet(vkd, device, *descriptorPool, *descriptorSetLayout);

 	std::map<vk::VkObjectType, deUint64>	objectHandlesMap
 	{
 		{ vk::VK_OBJECT_TYPE_INSTANCE,						0 },
 		{ vk::VK_OBJECT_TYPE_PHYSICAL_DEVICE,				0 },
 		{ vk::VK_OBJECT_TYPE_DEVICE,						0 },
 		{ vk::VK_OBJECT_TYPE_QUEUE,							0 },
 		{ vk::VK_OBJECT_TYPE_SEMAPHORE,						semaphore.get().getInternal() },
 		{ vk::VK_OBJECT_TYPE_COMMAND_BUFFER,				0 },
 		{ vk::VK_OBJECT_TYPE_FENCE,							fence.get().getInternal() },
 		{ vk::VK_OBJECT_TYPE_DEVICE_MEMORY,					bufferAllocation->getMemory().getInternal() },
 		{ vk::VK_OBJECT_TYPE_BUFFER,						buffer.get().getInternal() },
 		{ vk::VK_OBJECT_TYPE_IMAGE,							image.get().getInternal() },
 		{ vk::VK_OBJECT_TYPE_EVENT,							event.get().getInternal() },
 		{ vk::VK_OBJECT_TYPE_QUERY_POOL,					queryPool.get().getInternal() },
 		{ vk::VK_OBJECT_TYPE_BUFFER_VIEW,					bufferView.get().getInternal() },
 		{ vk::VK_OBJECT_TYPE_IMAGE_VIEW,					imageView.get().getInternal() },
 		{ vk::VK_OBJECT_TYPE_SHADER_MODULE,					shaderModule.get().getInternal() },
 		{ vk::VK_OBJECT_TYPE_PIPELINE_CACHE,				pipelineCache.get().getInternal() },
 		{ vk::VK_OBJECT_TYPE_PIPELINE_LAYOUT,				pipelineLayout.get().getInternal() },
 		{ vk::VK_OBJECT_TYPE_RENDER_PASS,					renderPass.get().getInternal() },
 		{ vk::VK_OBJECT_TYPE_PIPELINE,						pipeline.get().getInternal() },
 		{ vk::VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT,			descriptorSetLayout.get().getInternal() },
 		{ vk::VK_OBJECT_TYPE_SAMPLER,						sampler.get().getInternal() },
 		{ vk::VK_OBJECT_TYPE_DESCRIPTOR_POOL,				descriptorPool.get().getInternal() },
 		{ vk::VK_OBJECT_TYPE_DESCRIPTOR_SET,				descriptorSet.get().getInternal() },
 		{ vk::VK_OBJECT_TYPE_FRAMEBUFFER,					framebuffer.get().getInternal() },
 		{ vk::VK_OBJECT_TYPE_COMMAND_POOL,					cmdPool.get().getInternal() },
 		{ vk::VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION,		ycbcrConversion.get().getInternal() },
 		{ vk::VK_OBJECT_TYPE_SURFACE_KHR,					0 },
 		{ vk::VK_OBJECT_TYPE_SWAPCHAIN_KHR,					0 },
 		{ vk::VK_OBJECT_TYPE_DISPLAY_KHR,					0 },
 		{ vk::VK_OBJECT_TYPE_DISPLAY_MODE_KHR,				0 },
 		{ vk::VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT,		0 }
 	};

 	const vk::VkMemoryBarrier objRefreshBarrier
 	{
 		vk::VK_STRUCTURE_TYPE_MEMORY_BARRIER,
 		DE_NULL,
 		vk::VK_ACCESS_TRANSFER_WRITE_BIT,
 		vk::VK_ACCESS_MEMORY_READ_BIT
 	};

 	// record command buffer
 	vk::beginCommandBuffer(vkd, *cmdBuffer);

 	if (individualRefresh)
 	{
 		for (const auto& object : objectHandlesMap)
 		{
 			vk::VkObjectType	objectType		= object.first;
 			deUint64			objectHandle	= object.second;

 			// skip object type if it can't be refreshed on current implementation
 			if (std::find(refreshableObjectTypes.begin(), refreshableObjectTypes.end(), objectType) == refreshableObjectTypes.end())
 				continue;

 			if (!objectHandle)
 				continue;

 			vk::VkRefreshObjectKHR		refreshObject = { objectType, objectHandle, 0 };
 			vk::VkRefreshObjectListKHR	refreshList = { vk::VK_STRUCTURE_TYPE_REFRESH_OBJECT_LIST_KHR, DE_NULL, 1, &refreshObject };
 			vkd.cmdRefreshObjectsKHR(*cmdBuffer, &refreshList);
 			vkd.cmdPipelineBarrier(*cmdBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 1, &objRefreshBarrier, 0, DE_NULL, 0, DE_NULL);
 		}
 	}
 	else
 	{
 		deUint32 countUsed = 0;
 		std::vector<vk::VkRefreshObjectKHR> objectsToRefreshList(countReported);
 		for (deUint32 i = 0 ; i < countReported ; ++i)
 		{
 			vk::VkObjectType	objectType		= refreshableObjectTypes[i];
 			deUint64			objectHandle	= objectHandlesMap.at(objectType);

 			if (!objectHandle)
 				continue;

 			objectsToRefreshList[countUsed++] =
 			{
 				objectType,
 				objectHandle,
 				0
 			};
 		}

 		vk::VkRefreshObjectListKHR refreshList = { vk::VK_STRUCTURE_TYPE_REFRESH_OBJECT_LIST_KHR, DE_NULL, countUsed, objectsToRefreshList.data() };
 		vkd.cmdRefreshObjectsKHR(*cmdBuffer, &refreshList);
 		vkd.cmdPipelineBarrier(*cmdBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 1, &objRefreshBarrier, 0, DE_NULL, 0, DE_NULL);
 	}

 	vk::endCommandBuffer(vkd, *cmdBuffer);
 	vk::submitCommandsAndWait(vkd, device, queue, *cmdBuffer);

 	return tcu::TestStatus::pass("Pass");
 }

 void createComputeSource(vk::SourceCollections& dst)
 {
 	dst.glslSources.add("comp") << glu::ComputeSource(
 		"#version 450\n"
 		"layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
 		"void main (void)\n"
 		"{\n"
 		"    vec4 dummy = vec4(1.0);\n"
 		"}\n");
 }

 tcu::TestStatus refreshIndividualObjects(Context& context)
 {
 	return refreshObjects(context, true);
 }

 tcu::TestStatus refreshAllObjects(Context& context)
 {
 	return refreshObjects(context, false);
 }

 void checkRefreshSupport(Context& context)
 {
 	context.requireDeviceFunctionality("VK_KHR_object_refresh");
 }

 } // anonymous

 tcu::TestCaseGroup* createObjectRefreshTests (tcu::TestContext& testCtx)
 {
 	de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, "object_refresh", "Tests VK_KHR_object_refresh"));

 	addFunctionCase(group.get(),				"query_refreshable_objects",	"Test VK_KHR_object_refresh extension", checkRefreshSupport, queryRefreshableObjects);
 	addFunctionCaseWithPrograms(group.get(),	"refresh_individual_objects",	"Test VK_KHR_object_refresh extension", checkRefreshSupport, createComputeSource, refreshIndividualObjects);
 	addFunctionCaseWithPrograms(group.get(),	"refresh_all_objects",			"Test VK_KHR_object_refresh extension", checkRefreshSupport, createComputeSource, refreshAllObjects);

 	return group.release();
 }

 }	// sc

 }	// vkt
	/*------------------------------------------------------------------------
	* Vulkan Conformance Tests
	* ------------------------
	*
	* Copyright (c) 2021 The Khronos Group Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	//!
	* \file
	* \brief Vulkan SC VK_KHR_object_refresh Tests
	//--------------------------------------------------------------------*/

	#include "vktObjectRefreshTests.hpp"

	#include "vkDefs.hpp"
	#include "vkRefUtil.hpp"
	#include "vkDefs.hpp"
	#include "vkDeviceUtil.hpp"
	#include "vkPlatform.hpp"
	#include "vkTypeUtil.hpp"
	#include "vkPrograms.hpp"
	#include "vkCmdUtil.hpp"
	#include "vkObjUtil.hpp"
	#include "vkMemUtil.hpp"
	#include "vktTestCaseUtil.hpp"
	#include "vkQueryUtil.hpp"

	#include <map>
	#include <vector>

	namespace vkt
	{
	namespace sc
	{
	namespace
	{

	tcu::TestStatus queryRefreshableObjects(Context& context)
	{
	deUint32 countReported = 0u;
	vk::VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
	const vk::InstanceInterface& vki = context.getInstanceInterface();

	// get number of refreshable objects
	vk::VkResult result = vki.getPhysicalDeviceRefreshableObjectTypesKHR(physicalDevice, &countReported, DE_NULL);
	if (result != vk::VK_SUCCESS)
	TCU_THROW(NotSupportedError, "vkGetPhysicalDeviceRefreshableObjectTypesKHR returned invalid return code");

	if (countReported == 0)
	TCU_THROW(NotSupportedError, "No refreshable objects available");

	deUint32 refreshableObjectsMaxCount (countReported + 2);
	std::vector<vk::VkObjectType> refreshableObjects (refreshableObjectsMaxCount);

	for (deUint32 countRequested = 0; countRequested < refreshableObjectsMaxCount; ++countRequested)
	{
	// get refreshable objects
	deUint32 countRetrieved = countRequested;
	std::fill(refreshableObjects.begin(), refreshableObjects.end(), vk::VK_OBJECT_TYPE_UNKNOWN);
	result = vki.getPhysicalDeviceRefreshableObjectTypesKHR(physicalDevice, &countRetrieved, refreshableObjects.data());

	// verify returned code
	if ((result != vk::VK_SUCCESS) && (result != vk::VK_INCOMPLETE))
	TCU_THROW(NotSupportedError, "vkGetPhysicalDeviceRefreshableObjectTypesKHR returned invalid return code");

	// verify number of retrieved objects
	if (countRetrieved != std::min(countRequested, countReported))
	TCU_THROW(NotSupportedError, "vkGetPhysicalDeviceRefreshableObjectTypesKHR returned invalid number of retrieved objects");

	// verify retrieved objects
	for (deUint32 i = 0; i < countRetrieved; ++i)
	{
	if (refreshableObjects[i] == vk::VK_OBJECT_TYPE_UNKNOWN)
	TCU_THROW(NotSupportedError, "vkGetPhysicalDeviceRefreshableObjectTypesKHR returned invalid object type");
	}
	}

	return tcu::TestStatus::pass("pass");
	}

	tcu::TestStatus refreshObjects(Context& context, bool individualRefresh)
	{
	deUint32 countReported = 0u;
	vk::VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
	const vk::InstanceInterface& vki = context.getInstanceInterface();
	const vk::DeviceInterface& vkd = context.getDeviceInterface();

	vk::VkResult result = vki.getPhysicalDeviceRefreshableObjectTypesKHR(physicalDevice, &countReported, DE_NULL);
	if ((result != vk::VK_SUCCESS) \|\| (countReported == 0))
	TCU_THROW(NotSupportedError, "vkGetPhysicalDeviceRefreshableObjectTypesKHR failed");

	std::vector<vk::VkObjectType> refreshableObjectTypes(countReported);
	result = vki.getPhysicalDeviceRefreshableObjectTypesKHR(physicalDevice, &countReported, refreshableObjectTypes.data());
	if (result != vk::VK_SUCCESS)
	TCU_THROW(NotSupportedError, "vkGetPhysicalDeviceRefreshableObjectTypesKHR failed");

	// create all possible objects
	const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
	vk::VkDevice device = context.getDevice();
	vk::VkQueue queue = context.getUniversalQueue();
	vk::Allocator& allocator = context.getDefaultAllocator();
	vk::Move<vk::VkCommandPool> cmdPool = createCommandPool(vkd, device, vk::VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex);
	vk::Move<vk::VkCommandBuffer> cmdBuffer = allocateCommandBuffer(vkd, device, *cmdPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY);
	vk::Move<vk::VkFence> fence = createFence(vkd, device);
	vk::Move<vk::VkSemaphore> semaphore = createSemaphore(vkd, device);
	vk::Move<vk::VkEvent> event = createEvent(vkd, device);
	const vk::VkQueryPoolCreateInfo queryPoolCreateInfo
	{
	vk::VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	0u, // VkQueryPoolCreateFlags flags;
	vk::VK_QUERY_TYPE_OCCLUSION, // VkQueryType queryType;
	1u, // deUint32 queryCount;
	0u, // VkQueryPipelineStatisticFlags pipelineStatistics;
	};
	vk::Move<vk::VkQueryPool> queryPool = createQueryPool(vkd, device, &queryPoolCreateInfo);
	const vk::VkBufferCreateInfo bufferCreateInfo
	{
	vk::VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType
	DE_NULL, // const void* pNext
	0u, // VkBufferCreateFlags flags
	(vk::VkDeviceSize)64, // VkDeviceSize size
	vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT \| vk::VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, // VkBufferUsageFlags usage
	vk::VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode
	0u, // deUint32 queueFamilyIndexCount
	DE_NULL // const deUint32* pQueueFamilyIndices
	};
	vk::Move<vk::VkBuffer> buffer = createBuffer(vkd, device, &bufferCreateInfo);
	const vk::VkMemoryRequirements bufferRequirements = getBufferMemoryRequirements(vkd, device, *buffer);
	de::MovePtr<vk::Allocation> bufferAllocation = allocator.allocate(bufferRequirements, vk::MemoryRequirement::HostVisible);
	vkd.bindBufferMemory(device, *buffer, bufferAllocation->getMemory(), 0);
	vk::Move<vk::VkBufferView> bufferView = makeBufferView(vkd, device, *buffer, vk::VK_FORMAT_R32G32B32A32_SFLOAT, 0ull, VK_WHOLE_SIZE);
	const vk::VkSamplerCreateInfo samplerCreateInfo
	{
	vk::VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	(vk::VkSamplerCreateFlags)0, // VkSamplerCreateFlags flags;
	vk::VK_FILTER_NEAREST, // VkFilter magFilter;
	vk::VK_FILTER_NEAREST, // VkFilter minFilter;
	vk::VK_SAMPLER_MIPMAP_MODE_NEAREST, // VkSamplerMipmapMode mipmapMode;
	vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeU;
	vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeV;
	vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeW;
	0.0f, // float mipLodBias;
	VK_FALSE, // VkBool32 anisotropyEnable;
	1.0f, // float maxAnisotropy;
	VK_FALSE, // VkBool32 compareEnable;
	vk::VK_COMPARE_OP_ALWAYS, // VkCompareOp compareOp;
	0.0f, // float minLod;
	0.0f, // float maxLod;
	vk::VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, // VkBorderColor borderColor;
	VK_FALSE, // VkBool32 unnormalizedCoordinates;
	};
	vk::Move<vk::VkSampler> sampler = createSampler(vkd, device, &samplerCreateInfo);
	const vk::VkSamplerYcbcrConversionCreateInfo conversionInfo
	{
	vk::VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	vk::VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, // VkFormat format;
	vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, // VkSamplerYcbcrModelConversion ycbcrModel;
	vk::VK_SAMPLER_YCBCR_RANGE_ITU_FULL, // VkSamplerYcbcrRange ycbcrRange;
	{ // VkComponentMapping components;
	vk::VK_COMPONENT_SWIZZLE_IDENTITY,
	vk::VK_COMPONENT_SWIZZLE_IDENTITY,
	vk::VK_COMPONENT_SWIZZLE_IDENTITY,
	vk::VK_COMPONENT_SWIZZLE_IDENTITY
	},
	vk::VK_CHROMA_LOCATION_MIDPOINT, // VkChromaLocation xChromaOffset;
	vk::VK_CHROMA_LOCATION_MIDPOINT, // VkChromaLocation yChromaOffset;
	vk::VK_FILTER_NEAREST, // VkFilter chromaFilter;
	DE_FALSE // VkBool32 forceExplicitReconstruction;
	};
	vk::Move<vk::VkSamplerYcbcrConversion> ycbcrConversion = vk::createSamplerYcbcrConversion(vkd, device, &conversionInfo);
	const vk::VkImageCreateInfo imageCreateInfo
	{
	vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	0u, // VkImageCreateFlags flags;
	vk::VK_IMAGE_TYPE_2D, // VkImageType imageType;
	vk::VK_FORMAT_R8G8B8A8_UNORM, // VkFormat format;
	{ 64, 64, 1 }, // VkExtent3D extent;
	1u, // deUint32 mipLevels;
	1u, // deUint32 arrayLayers;
	vk::VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
	vk::VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
	vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT \| vk::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, // VkImageUsageFlags usage;
	vk::VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
	1u, // deUint32 queueFamilyIndexCount;
	&queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
	vk::VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
	};
	vk::Move<vk::VkImage> image = createImage(vkd, device, &imageCreateInfo);
	const vk::VkMemoryRequirements imageRequirements = getImageMemoryRequirements(vkd, device, *image);
	de::MovePtr<vk::Allocation> imageAllocation = allocator.allocate(imageRequirements, vk::MemoryRequirement::Any);
	vkd.bindImageMemory(device, *image, imageAllocation->getMemory(), imageAllocation->getOffset());
	vk::Move<vk::VkImageView> imageView = makeImageView(vkd, device, *image, vk::VK_IMAGE_VIEW_TYPE_2D, vk::VK_FORMAT_R8G8B8A8_UNORM, makeImageSubresourceRange(vk::VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u));
	vk::Move<vk::VkShaderModule> shaderModule = createShaderModule(vkd, device, context.getBinaryCollection().get("comp"), 0u);
	vk::Move<vk::VkRenderPass> renderPass = makeRenderPass(vkd, device, vk::VK_FORMAT_R8G8B8A8_UNORM);
	vk::Move<vk::VkFramebuffer> framebuffer = makeFramebuffer(vkd, device, renderPass, imageView, 64, 64);
	const vk::VkPipelineCacheCreateInfo pipelineCacheCreateInfo
	{
	vk::VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	vk::VK_PIPELINE_CACHE_CREATE_READ_ONLY_BIT \|
	vk::VK_PIPELINE_CACHE_CREATE_USE_APPLICATION_STORAGE_BIT, // VkPipelineCacheCreateFlags flags;
	context.getResourceInterface()->getCacheDataSize(), // deUintptr initialDataSize;
	context.getResourceInterface()->getCacheData() // const void* pInitialData;
	};
	vk::Move<vk::VkPipelineCache> pipelineCache = createPipelineCache(vkd, device, &pipelineCacheCreateInfo);
	vk::Move<vk::VkPipelineLayout> pipelineLayout = makePipelineLayout(vkd, device);
	vk::Move<vk::VkPipeline> pipeline = makeComputePipeline(vkd, device, pipelineLayout, 0u, shaderModule, 0u, DE_NULL);
	const vk::VkDescriptorPoolSize descriptorPoolSize
	{
	vk::VK_DESCRIPTOR_TYPE_SAMPLER, // VkDescriptorType type;
	8 // deUint32 descriptorCount;
	};
	const vk::VkDescriptorPoolCreateInfo descriptorPoolCreateInfo
	{
	vk::VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, // VkStructureType sType;
	NULL, // const void* pNext;
	0u, // VkDescriptorPoolCreateFlags flags;
	8, // deUint32 maxSets;
	1, // deUint32 poolSizeCount;
	&descriptorPoolSize // const VkDescriptorPoolSize* pPoolSizes;
	};
	vk::Move<vk::VkDescriptorPool> descriptorPool = createDescriptorPool(vkd, device, &descriptorPoolCreateInfo);
	const vk::VkDescriptorSetLayoutBinding descriptorSetLayoutBinding
	{
	0, // deUint32 binding;
	vk::VK_DESCRIPTOR_TYPE_SAMPLER, // VkDescriptorType descriptorType;
	1, // deUint32 descriptorCount;
	vk::VK_SHADER_STAGE_ALL, // VkShaderStageFlags stageFlags;
	NULL // const VkSampler* pImmutableSamplers;
	};
	const vk::VkDescriptorSetLayoutCreateInfo descriptorSetLayoutInfo
	{
	vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, // VkStructureType sType;
	NULL, // const void* pNext;
	0, // VkDescriptorSetLayoutCreateFlags flags;
	1, // deUint32 bindingCount;
	&descriptorSetLayoutBinding // const VkDescriptorSetLayoutBinding* pBindings;
	};
	vk::Move<vk::VkDescriptorSetLayout> descriptorSetLayout = createDescriptorSetLayout(vkd, device, &descriptorSetLayoutInfo);
	vk::Move<vk::VkDescriptorSet> descriptorSet = makeDescriptorSet(vkd, device, descriptorPool, descriptorSetLayout);

	std::map<vk::VkObjectType, deUint64> objectHandlesMap
	{
	{ vk::VK_OBJECT_TYPE_INSTANCE, 0 },
	{ vk::VK_OBJECT_TYPE_PHYSICAL_DEVICE, 0 },
	{ vk::VK_OBJECT_TYPE_DEVICE, 0 },
	{ vk::VK_OBJECT_TYPE_QUEUE, 0 },
	{ vk::VK_OBJECT_TYPE_SEMAPHORE, semaphore.get().getInternal() },
	{ vk::VK_OBJECT_TYPE_COMMAND_BUFFER, 0 },
	{ vk::VK_OBJECT_TYPE_FENCE, fence.get().getInternal() },
	{ vk::VK_OBJECT_TYPE_DEVICE_MEMORY, bufferAllocation->getMemory().getInternal() },
	{ vk::VK_OBJECT_TYPE_BUFFER, buffer.get().getInternal() },
	{ vk::VK_OBJECT_TYPE_IMAGE, image.get().getInternal() },
	{ vk::VK_OBJECT_TYPE_EVENT, event.get().getInternal() },
	{ vk::VK_OBJECT_TYPE_QUERY_POOL, queryPool.get().getInternal() },
	{ vk::VK_OBJECT_TYPE_BUFFER_VIEW, bufferView.get().getInternal() },
	{ vk::VK_OBJECT_TYPE_IMAGE_VIEW, imageView.get().getInternal() },
	{ vk::VK_OBJECT_TYPE_SHADER_MODULE, shaderModule.get().getInternal() },
	{ vk::VK_OBJECT_TYPE_PIPELINE_CACHE, pipelineCache.get().getInternal() },
	{ vk::VK_OBJECT_TYPE_PIPELINE_LAYOUT, pipelineLayout.get().getInternal() },
	{ vk::VK_OBJECT_TYPE_RENDER_PASS, renderPass.get().getInternal() },
	{ vk::VK_OBJECT_TYPE_PIPELINE, pipeline.get().getInternal() },
	{ vk::VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, descriptorSetLayout.get().getInternal() },
	{ vk::VK_OBJECT_TYPE_SAMPLER, sampler.get().getInternal() },
	{ vk::VK_OBJECT_TYPE_DESCRIPTOR_POOL, descriptorPool.get().getInternal() },
	{ vk::VK_OBJECT_TYPE_DESCRIPTOR_SET, descriptorSet.get().getInternal() },
	{ vk::VK_OBJECT_TYPE_FRAMEBUFFER, framebuffer.get().getInternal() },
	{ vk::VK_OBJECT_TYPE_COMMAND_POOL, cmdPool.get().getInternal() },
	{ vk::VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, ycbcrConversion.get().getInternal() },
	{ vk::VK_OBJECT_TYPE_SURFACE_KHR, 0 },
	{ vk::VK_OBJECT_TYPE_SWAPCHAIN_KHR, 0 },
	{ vk::VK_OBJECT_TYPE_DISPLAY_KHR, 0 },
	{ vk::VK_OBJECT_TYPE_DISPLAY_MODE_KHR, 0 },
	{ vk::VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT, 0 }
	};

	const vk::VkMemoryBarrier objRefreshBarrier
	{
	vk::VK_STRUCTURE_TYPE_MEMORY_BARRIER,
	DE_NULL,
	vk::VK_ACCESS_TRANSFER_WRITE_BIT,
	vk::VK_ACCESS_MEMORY_READ_BIT
	};

	// record command buffer
	vk::beginCommandBuffer(vkd, *cmdBuffer);

	if (individualRefresh)
	{
	for (const auto& object : objectHandlesMap)
	{
	vk::VkObjectType objectType = object.first;
	deUint64 objectHandle = object.second;

	// skip object type if it can't be refreshed on current implementation
	if (std::find(refreshableObjectTypes.begin(), refreshableObjectTypes.end(), objectType) == refreshableObjectTypes.end())
	continue;

	if (!objectHandle)
	continue;

	vk::VkRefreshObjectKHR refreshObject = { objectType, objectHandle, 0 };
	vk::VkRefreshObjectListKHR refreshList = { vk::VK_STRUCTURE_TYPE_REFRESH_OBJECT_LIST_KHR, DE_NULL, 1, &refreshObject };
	vkd.cmdRefreshObjectsKHR(*cmdBuffer, &refreshList);
	vkd.cmdPipelineBarrier(*cmdBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 1, &objRefreshBarrier, 0, DE_NULL, 0, DE_NULL);
	}
	}
	else
	{
	deUint32 countUsed = 0;
	std::vector<vk::VkRefreshObjectKHR> objectsToRefreshList(countReported);
	for (deUint32 i = 0 ; i < countReported ; ++i)
	{
	vk::VkObjectType objectType = refreshableObjectTypes[i];
	deUint64 objectHandle = objectHandlesMap.at(objectType);

	if (!objectHandle)
	continue;

	objectsToRefreshList[countUsed++] =
	{
	objectType,
	objectHandle,
	0
	};
	}

	vk::VkRefreshObjectListKHR refreshList = { vk::VK_STRUCTURE_TYPE_REFRESH_OBJECT_LIST_KHR, DE_NULL, countUsed, objectsToRefreshList.data() };
	vkd.cmdRefreshObjectsKHR(*cmdBuffer, &refreshList);
	vkd.cmdPipelineBarrier(*cmdBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 1, &objRefreshBarrier, 0, DE_NULL, 0, DE_NULL);
	}

	vk::endCommandBuffer(vkd, *cmdBuffer);
	vk::submitCommandsAndWait(vkd, device, queue, *cmdBuffer);

	return tcu::TestStatus::pass("Pass");
	}

	void createComputeSource(vk::SourceCollections& dst)
	{
	dst.glslSources.add("comp") << glu::ComputeSource(
	"#version 450\n"
	"layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
	"void main (void)\n"
	"{\n"
	" vec4 dummy = vec4(1.0);\n"
	"}\n");
	}

	tcu::TestStatus refreshIndividualObjects(Context& context)
	{
	return refreshObjects(context, true);
	}

	tcu::TestStatus refreshAllObjects(Context& context)
	{
	return refreshObjects(context, false);
	}

	void checkRefreshSupport(Context& context)
	{
	context.requireDeviceFunctionality("VK_KHR_object_refresh");
	}

	} // anonymous

	tcu::TestCaseGroup* createObjectRefreshTests (tcu::TestContext& testCtx)
	{
	de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, "object_refresh", "Tests VK_KHR_object_refresh"));

	addFunctionCase(group.get(), "query_refreshable_objects", "Test VK_KHR_object_refresh extension", checkRefreshSupport, queryRefreshableObjects);
	addFunctionCaseWithPrograms(group.get(), "refresh_individual_objects", "Test VK_KHR_object_refresh extension", checkRefreshSupport, createComputeSource, refreshIndividualObjects);
	addFunctionCaseWithPrograms(group.get(), "refresh_all_objects", "Test VK_KHR_object_refresh extension", checkRefreshSupport, createComputeSource, refreshAllObjects);

	return group.release();
	}

	} // sc

	} // vkt