xref: /third_party/vk-gl-cts/external/vulkancts/framework/vulkan/vkResourceInterface.cpp

/*-------------------------------------------------------------------------
 * Vulkan CTS Framework
 * --------------------
 *
 * 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 Defines class for handling resources ( programs, pipelines, files, etc. )
 *//*--------------------------------------------------------------------*/

#include "vkResourceInterface.hpp"
#include "vkQueryUtil.hpp"

#ifdef CTS_USES_VULKANSC
	#include <functional>
	#include <fstream>
	#include "vkSafetyCriticalUtil.hpp"
	#include "vkRefUtil.hpp"
	#include "tcuCommandLine.hpp"
	#include "vksCacheBuilder.hpp"
	#include "vksSerializer.hpp"
	#include "vkApiVersion.hpp"
	using namespace vksc_server::json;
#endif // CTS_USES_VULKANSC

namespace vk
{

ResourceInterface::ResourceInterface (tcu::TestContext& testCtx)
	: m_testCtx			(testCtx)
#ifdef CTS_USES_VULKANSC
	, m_commandPoolIndex		(0u)
	, m_resourceCounter			(0u)
	, m_statCurrent				(resetDeviceObjectReservationCreateInfo())
	, m_statMax					(resetDeviceObjectReservationCreateInfo())
	, m_enabledHandleDestroy	(true)
#endif // CTS_USES_VULKANSC
{
#ifdef CTS_USES_VULKANSC
	// pipelineCacheRequestCount does not contain one instance of createPipelineCache call that happens only in subprocess
	m_statCurrent.pipelineCacheRequestCount		= 1u;
	m_statMax.pipelineCacheRequestCount			= 1u;
#endif // CTS_USES_VULKANSC
}

ResourceInterface::~ResourceInterface ()
{
}

void ResourceInterface::initTestCase (const std::string& casePath)
{
	m_currentTestPath = casePath;
}

const std::string& ResourceInterface::getCasePath() const
{
	return m_currentTestPath;
}

#ifdef CTS_USES_VULKANSC
void ResourceInterface::initApiVersion (const deUint32 version)
{
	const ApiVersion	apiVersion	= unpackVersion(version);
	const bool			vulkanSC	= (apiVersion.variantNum == 1);

	m_version	= tcu::Maybe<deUint32>(version);
	m_vulkanSC	= vulkanSC;
}

bool ResourceInterface::isVulkanSC (void) const
{
	return m_vulkanSC.get();
}

deUint64 ResourceInterface::incResourceCounter ()
{
	return ++m_resourceCounter;
}

std::mutex& ResourceInterface::getStatMutex ()
{
	return m_mutex;
}

VkDeviceObjectReservationCreateInfo& ResourceInterface::getStatCurrent ()
{
	return m_statCurrent;
}

VkDeviceObjectReservationCreateInfo&	ResourceInterface::getStatMax ()
{
	return m_statMax;
}

const VkDeviceObjectReservationCreateInfo&	ResourceInterface::getStatMax () const
{
	return m_statMax;
}

void ResourceInterface::setHandleDestroy(bool value)
{
	m_enabledHandleDestroy = value;
}

bool ResourceInterface::isEnabledHandleDestroy() const
{
	return m_enabledHandleDestroy;
}

void ResourceInterface::removeRedundantObjects ()
{
	// At the end of the day we only need to export objects used in pipelines.
	// Rest of the objects may be removed from m_json* structures as redundant
	std::set<VkSamplerYcbcrConversion>	samplerYcbcrConversionsInPipeline;
	std::set<VkSampler>					samplersInPipeline;
	std::set<VkShaderModule>			shadersInPipeline;
	std::set<VkRenderPass>				renderPassesInPipeline;
	std::set<VkPipelineLayout>			pipelineLayoutsInPipeline;
	std::set<VkDescriptorSetLayout>		descriptorSetLayoutsInPipeline;

	Context jsonReader;

	for (auto it = begin(m_pipelineInput.pipelines); it != end(m_pipelineInput.pipelines); ++it)
	{
		if (it->pipelineContents.find("VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO") != std::string::npos)
		{
			VkGraphicsPipelineCreateInfo	gpCI;
			deMemset(&gpCI, 0, sizeof(gpCI));
			readJSON_VkGraphicsPipelineCreateInfo(jsonReader, it->pipelineContents, gpCI);

			for (deUint32 i = 0; i < gpCI.stageCount; ++i)
				shadersInPipeline.insert(gpCI.pStages[i].module);
			renderPassesInPipeline.insert(gpCI.renderPass);
			pipelineLayoutsInPipeline.insert(gpCI.layout);
		}
		else if (it->pipelineContents.find("VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO") != std::string::npos)
		{
			VkComputePipelineCreateInfo	cpCI;
			deMemset(&cpCI, 0, sizeof(cpCI));
			readJSON_VkComputePipelineCreateInfo(jsonReader, it->pipelineContents, cpCI);

			shadersInPipeline.insert(cpCI.stage.module);
			pipelineLayoutsInPipeline.insert(cpCI.layout);
		}
		else
			TCU_THROW(InternalError, "Could not recognize pipeline type");
	}
	for (auto it = begin(m_pipelineInput.shaderModules); it != end(m_pipelineInput.shaderModules); )
	{
		if (shadersInPipeline.find(it->first) == end(shadersInPipeline))
			it = m_pipelineInput.shaderModules.erase(it);
		else
			++it;
	}
	for (auto it = begin(m_pipelineInput.renderPasses); it != end(m_pipelineInput.renderPasses); )
	{
		if (renderPassesInPipeline.find(it->first) == end(renderPassesInPipeline))
			it = m_pipelineInput.renderPasses.erase(it);
		else
			++it;
	}
	for (auto it = begin(m_pipelineInput.pipelineLayouts); it != end(m_pipelineInput.pipelineLayouts); )
	{
		if (pipelineLayoutsInPipeline.find(it->first) == end(pipelineLayoutsInPipeline))
		{
			it = m_pipelineInput.pipelineLayouts.erase(it);
		}
		else
		{
			VkPipelineLayoutCreateInfo	plCI;
			deMemset(&plCI, 0, sizeof(plCI));
			readJSON_VkPipelineLayoutCreateInfo(jsonReader, it->second, plCI);
			for (deUint32 i = 0; i < plCI.setLayoutCount; ++i)
				descriptorSetLayoutsInPipeline.insert(plCI.pSetLayouts[i]);
			++it;
		}
	}
	for (auto it = begin(m_pipelineInput.descriptorSetLayouts); it != end(m_pipelineInput.descriptorSetLayouts); )
	{
		if (descriptorSetLayoutsInPipeline.find(it->first) == end(descriptorSetLayoutsInPipeline))
			it = m_pipelineInput.descriptorSetLayouts.erase(it);
		else
		{
			VkDescriptorSetLayoutCreateInfo	dsCI;
			deMemset(&dsCI, 0, sizeof(dsCI));
			readJSON_VkDescriptorSetLayoutCreateInfo(jsonReader, it->second, dsCI);

			for (deUint32 i = 0; i < dsCI.bindingCount; ++i)
			{
				if (dsCI.pBindings[i].pImmutableSamplers == NULL)
					continue;
				for (deUint32 j = 0; j < dsCI.pBindings[i].descriptorCount; ++j)
				{
					if (dsCI.pBindings[i].pImmutableSamplers[j] == DE_NULL)
						continue;
					samplersInPipeline.insert(dsCI.pBindings[i].pImmutableSamplers[j]);
				}
			}
			++it;
		}
	}

	for (auto it = begin(m_pipelineInput.samplers); it != end(m_pipelineInput.samplers); )
	{
		if (samplersInPipeline.find(it->first) == end(samplersInPipeline))
			it = m_pipelineInput.samplers.erase(it);
		else
		{
			VkSamplerCreateInfo	sCI;
			deMemset(&sCI, 0, sizeof(sCI));
			readJSON_VkSamplerCreateInfo(jsonReader, it->second, sCI);

			if (sCI.pNext != DE_NULL)
			{
				VkSamplerYcbcrConversionInfo* info = (VkSamplerYcbcrConversionInfo*)(sCI.pNext);
				if (info->sType == VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO)
					samplerYcbcrConversionsInPipeline.insert(info->conversion);
			}
			++it;
		}
	}
	for (auto it = begin(m_pipelineInput.samplerYcbcrConversions); it != end(m_pipelineInput.samplerYcbcrConversions); )
	{
		if (samplerYcbcrConversionsInPipeline.find(it->first) == end(samplerYcbcrConversionsInPipeline))
			it = m_pipelineInput.samplerYcbcrConversions.erase(it);
		else
			++it;
	}
}

void ResourceInterface::finalizeCommandBuffers ()
{
	// We have information about command buffer sizes
	// Now we have to convert it into command pool sizes
	std::map<deUint64, std::size_t> cpToIndex;
	for (std::size_t i = 0; i < m_commandPoolMemoryConsumption.size(); ++i)
		cpToIndex.insert({ m_commandPoolMemoryConsumption[i].commandPool, i });
	for (const auto& memC : m_commandBufferMemoryConsumption)
	{
		std::size_t j = cpToIndex[memC.second.commandPool];
		m_commandPoolMemoryConsumption[j].updateValues
		(
			memC.second.maxCommandPoolAllocated,
			memC.second.maxCommandPoolReservedSize,
			memC.second.maxCommandBufferAllocated
		);
		m_commandPoolMemoryConsumption[j].commandBufferCount++;
	}
	// Each m_commandPoolMemoryConsumption element must have at least one command buffer ( see DeviceDriverSC::createCommandPoolHandlerNorm() )
	// As a result we have to ensure that commandBufferRequestCount is not less than the number of command pools
	m_statMax.commandBufferRequestCount = de::max(deUint32(m_commandPoolMemoryConsumption.size()), m_statMax.commandBufferRequestCount);
}

std::vector<deUint8> ResourceInterface::exportData () const
{
	vksc_server::VulkanDataTransmittedFromMainToSubprocess vdtfmtsp(m_pipelineInput, m_statMax, m_commandPoolMemoryConsumption, m_pipelineSizes);

	return vksc_server::Serialize(vdtfmtsp);
}

void ResourceInterface::importData (std::vector<deUint8>& importText) const
{
	vksc_server::VulkanDataTransmittedFromMainToSubprocess vdtfmtsp = vksc_server::Deserialize<vksc_server::VulkanDataTransmittedFromMainToSubprocess>(importText);

	m_pipelineInput					= vdtfmtsp.pipelineCacheInput;
	m_statMax						= vdtfmtsp.memoryReservation;
	m_commandPoolMemoryConsumption	= vdtfmtsp.commandPoolMemoryConsumption;
	m_pipelineSizes					= vdtfmtsp.pipelineSizes;
}

void ResourceInterface::registerObjectHash (deUint64 handle, std::size_t hashValue) const
{
	m_objectHashes[handle] =  hashValue;
}

const std::map<deUint64,std::size_t>& ResourceInterface::getObjectHashes () const
{
	return m_objectHashes;
}

struct PipelinePoolSizeInfo
{
	deUint32					maxTestCount;
	deUint32					size;
};

void ResourceInterface::preparePipelinePoolSizes()
{
	std::map<std::string, std::vector<PipelinePoolSizeInfo>> pipelineInfoPerTest;

	// Step 1: collect information about all pipelines in each test, group by size
	for (const auto& pipeline : m_pipelineInput.pipelines)
	{
		auto it = std::find_if(begin(m_pipelineSizes), end(m_pipelineSizes), vksc_server::PipelineIdentifierEqual(pipeline.id));
		if (it == end(m_pipelineSizes))
			TCU_THROW(InternalError, "VkPipelinePoolEntrySizeCreateInfo not created for pipelineIdentifier");

		PipelinePoolSizeInfo ppsi
		{
			it->count,
			it->size
		};

		for (const auto& test : pipeline.tests)
		{
			auto pit = pipelineInfoPerTest.find(test);
			if (pit == end(pipelineInfoPerTest))
				pit = pipelineInfoPerTest.insert({ test, std::vector<PipelinePoolSizeInfo>() }).first;
			// group by the same sizes in a test
			bool found = false;
			for (size_t i = 0; i<pit->second.size(); ++i)
			{
				if (pit->second[i].size == ppsi.size)
				{
					pit->second[i].maxTestCount += ppsi.maxTestCount;
					found = true;
					break;
				}
			}
			if(!found)
				pit->second.push_back(ppsi);
		}
	}

	// Step 2: choose pipeline pool sizes
	std::vector<PipelinePoolSizeInfo> finalPoolSizes;
	for (const auto& pInfo : pipelineInfoPerTest)
	{
		for (const auto& ppsi1 : pInfo.second)
		{
			auto it = std::find_if(begin(finalPoolSizes), end(finalPoolSizes), [&ppsi1](const PipelinePoolSizeInfo& x) { return (x.size == ppsi1.size); });
			if (it != end(finalPoolSizes))
				it->maxTestCount = de::max(it->maxTestCount, ppsi1.maxTestCount);
			else
				finalPoolSizes.push_back(ppsi1);
		}
	}

	// Step 3: convert results to VkPipelinePoolSize
	m_pipelinePoolSizes.clear();
	for (const auto& ppsi : finalPoolSizes)
	{
		VkPipelinePoolSize poolSize =
		{
			VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE,	// VkStructureType	sType;
			DE_NULL,								// const void*		pNext;
			ppsi.size,								// VkDeviceSize		poolEntrySize;
			ppsi.maxTestCount						// deUint32			poolEntryCount;
		};
		m_pipelinePoolSizes.emplace_back(poolSize);
	}
}

std::vector<VkPipelinePoolSize> ResourceInterface::getPipelinePoolSizes () const
{
	return m_pipelinePoolSizes;
}

void ResourceInterface::fillPoolEntrySize (vk::VkPipelineOfflineCreateInfo&	pipelineIdentifier) const
{
	auto it = std::find_if(begin(m_pipelineSizes), end(m_pipelineSizes), vksc_server::PipelineIdentifierEqual(pipelineIdentifier));
	if( it == end(m_pipelineSizes) )
		TCU_THROW(InternalError, "VkPipelinePoolEntrySizeCreateInfo not created for pipelineIdentifier");
	pipelineIdentifier.poolEntrySize = it->size;
}

vksc_server::VulkanCommandMemoryConsumption ResourceInterface::getNextCommandPoolSize ()
{
	if (m_commandPoolMemoryConsumption.empty())
		return vksc_server::VulkanCommandMemoryConsumption();

	vksc_server::VulkanCommandMemoryConsumption result	= m_commandPoolMemoryConsumption[m_commandPoolIndex];
	// modulo operation is just a safeguard against excessive number of requests
	m_commandPoolIndex									= (m_commandPoolIndex + 1) % deUint32(m_commandPoolMemoryConsumption.size());
	return result;
}

std::size_t	ResourceInterface::getCacheDataSize () const
{
	return m_cacheData.size();
}

const deUint8* ResourceInterface::getCacheData () const
{
	return m_cacheData.data();
}

VkPipelineCache ResourceInterface::getPipelineCache(VkDevice device) const
{
	auto pit = m_pipelineCache.find(device);
	if (pit == end(m_pipelineCache))
		TCU_THROW(InternalError, "m_pipelineCache not found for this device");
	return pit->second.get()->get();
}

#endif // CTS_USES_VULKANSC

ResourceInterfaceStandard::ResourceInterfaceStandard (tcu::TestContext& testCtx)
	: ResourceInterface(testCtx)
{
}

void ResourceInterfaceStandard::initDevice (DeviceInterface& deviceInterface, VkDevice device)
{
	// ResourceInterfaceStandard is a class for running VulkanSC tests on normal Vulkan driver.
	// CTS does not have vkCreateShaderModule function defined for Vulkan SC driver, but we need this function
	// So ResourceInterfaceStandard class must have its own vkCreateShaderModule function pointer
	// Moreover - we create additional function pointers for vkCreateGraphicsPipelines, vkCreateComputePipelines, etc.
	// BTW: although ResourceInterfaceStandard exists in normal Vulkan tests - only initDevice and buildProgram functions are used by Vulkan tests
	// Other functions are called from within DeviceDriverSC which does not exist in these tests ( DeviceDriver class is used instead )
	m_createShaderModuleFunc[device]				= (CreateShaderModuleFunc)				deviceInterface.getDeviceProcAddr(device, "vkCreateShaderModule");
	m_createGraphicsPipelinesFunc[device]			= (CreateGraphicsPipelinesFunc)			deviceInterface.getDeviceProcAddr(device, "vkCreateGraphicsPipelines");
	m_createComputePipelinesFunc[device]			= (CreateComputePipelinesFunc)			deviceInterface.getDeviceProcAddr(device, "vkCreateComputePipelines");
#ifdef CTS_USES_VULKANSC
	if (m_testCtx.getCommandLine().isSubProcess())
	{
		if (m_cacheData.size() > 0)
		{
			VkPipelineCacheCreateInfo pCreateInfo =
			{
				VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO,				// VkStructureType				sType;
				DE_NULL,													// const void*					pNext;
				VK_PIPELINE_CACHE_CREATE_READ_ONLY_BIT |
					VK_PIPELINE_CACHE_CREATE_USE_APPLICATION_STORAGE_BIT,	// VkPipelineCacheCreateFlags	flags;
				m_cacheData.size(),											// deUintptr					initialDataSize;
				m_cacheData.data()											// const void*					pInitialData;
			};
			m_pipelineCache[device] = de::SharedPtr<Move<VkPipelineCache>>(new Move<VkPipelineCache>(createPipelineCache(deviceInterface, device, &pCreateInfo, DE_NULL)));
		}
	}
#endif // CTS_USES_VULKANSC
}

void ResourceInterfaceStandard::deinitDevice (VkDevice device)
{
#ifdef CTS_USES_VULKANSC
	if (m_testCtx.getCommandLine().isSubProcess())
	{
		m_pipelineCache.erase(device);
	}
#else
	DE_UNREF(device);
#endif // CTS_USES_VULKANSC
}

#ifdef CTS_USES_VULKANSC

void ResourceInterfaceStandard::registerDeviceFeatures (VkDevice							device,
														const VkDeviceCreateInfo*			pCreateInfo) const
{
	VkPhysicalDeviceFeatures2* chainedFeatures		= (VkPhysicalDeviceFeatures2*)findStructureInChain(pCreateInfo->pNext, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2);
	if (chainedFeatures != NULL)
	{
		m_deviceFeatures[device]					= writeJSON_pNextChain(pCreateInfo->pNext);
	}
	else
	{
		VkPhysicalDeviceFeatures2 deviceFeatures2	= initVulkanStructure();
		if (pCreateInfo->pEnabledFeatures != NULL)
			deviceFeatures2.features = *(pCreateInfo->pEnabledFeatures);

		deviceFeatures2.pNext						= (void *)pCreateInfo->pNext;
		m_deviceFeatures[device]					= writeJSON_VkPhysicalDeviceFeatures2(deviceFeatures2);
	}

	std::vector<std::string> extensions;
	for (deUint32 i = 0; i < pCreateInfo->enabledExtensionCount; ++i)
		extensions.push_back(pCreateInfo->ppEnabledExtensionNames[i]);
	m_deviceExtensions[device]					= extensions;
}

void ResourceInterfaceStandard::unregisterDeviceFeatures(VkDevice							device) const
{
	m_deviceFeatures.erase(device);
	m_deviceExtensions.erase(device);
}

VkResult ResourceInterfaceStandard::createShaderModule (VkDevice							device,
														const VkShaderModuleCreateInfo*		pCreateInfo,
														const VkAllocationCallbacks*		pAllocator,
														VkShaderModule*						pShaderModule,
														bool								normalMode) const
{
	if (normalMode)
	{
		if (isVulkanSC())
		{
			*pShaderModule = VkShaderModule(++m_resourceCounter);
			registerObjectHash(pShaderModule->getInternal(), calculateShaderModuleHash(*pCreateInfo, getObjectHashes()));
			return VK_SUCCESS;
		}
		else
		{
			const auto it = m_createShaderModuleFunc.find(device);
			if (it != end(m_createShaderModuleFunc))
			{
				VkResult result = it->second(device, pCreateInfo, pAllocator, pShaderModule);
				registerObjectHash(pShaderModule->getInternal(), calculateShaderModuleHash(*pCreateInfo, getObjectHashes()));
				return result;
			}
			TCU_THROW(InternalError, "vkCreateShaderModule not defined");
		}
	}

	// main process: store VkShaderModuleCreateInfo in JSON format. Shaders will be sent later for m_pipelineCache creation ( and sent through file to another process )
	*pShaderModule = VkShaderModule(++m_resourceCounter);
	registerObjectHash(pShaderModule->getInternal(), calculateShaderModuleHash(*pCreateInfo, getObjectHashes()));
	m_pipelineInput.shaderModules.insert({ *pShaderModule, writeJSON_VkShaderModuleCreateInfo(*pCreateInfo) });
	return VK_SUCCESS;
}

VkPipelineOfflineCreateInfo makeGraphicsPipelineIdentifier (const std::string& testPath, const VkGraphicsPipelineCreateInfo& gpCI, const std::map<deUint64, std::size_t>& objectHashes)
{
	DE_UNREF(testPath);
	VkPipelineOfflineCreateInfo	pipelineID		= resetPipelineOfflineCreateInfo();
	std::size_t					hashValue		= calculateGraphicsPipelineHash(gpCI, objectHashes);
	memcpy(pipelineID.pipelineIdentifier, &hashValue, sizeof(std::size_t));
	return pipelineID;
}

VkPipelineOfflineCreateInfo makeComputePipelineIdentifier (const std::string& testPath, const VkComputePipelineCreateInfo& cpCI, const std::map<deUint64, std::size_t>& objectHashes)
{
	DE_UNREF(testPath);
	VkPipelineOfflineCreateInfo	pipelineID		= resetPipelineOfflineCreateInfo();
	std::size_t					hashValue		= calculateComputePipelineHash(cpCI, objectHashes);
	memcpy(pipelineID.pipelineIdentifier, &hashValue, sizeof(std::size_t));
	return pipelineID;
}

VkResult ResourceInterfaceStandard::createGraphicsPipelines (VkDevice								device,
															 VkPipelineCache						pipelineCache,
															 deUint32								createInfoCount,
															 const VkGraphicsPipelineCreateInfo*	pCreateInfos,
															 const VkAllocationCallbacks*			pAllocator,
															 VkPipeline*							pPipelines,
															 bool									normalMode) const
{
	DE_UNREF(pipelineCache);

	// build pipeline identifiers (if required), make a copy of pCreateInfos
	std::vector<VkPipelineOfflineCreateInfo>		pipelineIDs;
	std::vector<deUint8>							idInPNextChain;
	std::vector<VkGraphicsPipelineCreateInfo>		pCreateInfoCopies;

	for (deUint32 i = 0; i < createInfoCount; ++i)
	{
		pCreateInfoCopies.push_back(pCreateInfos[i]);

		// Check if test added pipeline identifier on its own
		VkPipelineOfflineCreateInfo* idInfo = (VkPipelineOfflineCreateInfo*)findStructureInChain(pCreateInfos[i].pNext, VK_STRUCTURE_TYPE_PIPELINE_OFFLINE_CREATE_INFO);
		if (idInfo == DE_NULL)
		{
			pipelineIDs.push_back(makeGraphicsPipelineIdentifier(m_currentTestPath, pCreateInfos[i], getObjectHashes()));
			idInPNextChain.push_back(0);
		}
		else
		{
			pipelineIDs.push_back(*idInfo);
			idInPNextChain.push_back(1);
		}

		if (normalMode)
			fillPoolEntrySize(pipelineIDs.back());
	}

	// reset not used pointers, so that JSON generation does not crash
	std::vector<VkPipelineViewportStateCreateInfo>	viewportStateCopies	(createInfoCount);
	if (!normalMode)
	{
		for (deUint32 i = 0; i < createInfoCount; ++i)
		{
			bool vertexInputStateRequired		= false;
			bool inputAssemblyStateRequired		= false;
			bool tessellationStateRequired		= false;
			bool viewportStateRequired			= false;
			bool viewportStateViewportsRequired	= false;
			bool viewportStateScissorsRequired	= false;
			bool multiSampleStateRequired		= false;
			bool depthStencilStateRequired		= false;
			bool colorBlendStateRequired		= false;

			if (pCreateInfoCopies[i].pStages != DE_NULL)
			{
				for (deUint32 j = 0; j < pCreateInfoCopies[i].stageCount; ++j)
				{
					if (pCreateInfoCopies[i].pStages[j].stage == VK_SHADER_STAGE_VERTEX_BIT)
					{
						vertexInputStateRequired	= true;
						inputAssemblyStateRequired	= true;
					}
					if (pCreateInfoCopies[i].pStages[j].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT)
					{
						tessellationStateRequired	= true;
					}
				}
			}
			if (pCreateInfoCopies[i].pDynamicState != DE_NULL)
			{
				if (pCreateInfoCopies[i].pDynamicState->pDynamicStates != DE_NULL)
					for (deUint32 j = 0; j < pCreateInfoCopies[i].pDynamicState->dynamicStateCount; ++j)
					{
						if (pCreateInfoCopies[i].pDynamicState->pDynamicStates[j] == VK_DYNAMIC_STATE_VIEWPORT || pCreateInfoCopies[i].pDynamicState->pDynamicStates[j] == VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT)
						{
							viewportStateRequired			= true;
							viewportStateViewportsRequired	= true;
						}
						if (pCreateInfoCopies[i].pDynamicState->pDynamicStates[j] == VK_DYNAMIC_STATE_SCISSOR || pCreateInfoCopies[i].pDynamicState->pDynamicStates[j] == VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT)
						{
							viewportStateRequired			= true;
							viewportStateScissorsRequired	= true;
						}
						if (pCreateInfoCopies[i].pDynamicState->pDynamicStates[j] == VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT)
							viewportStateRequired = true;
					}
			}
			if (pCreateInfoCopies[i].pRasterizationState != DE_NULL)
			{
				if (pCreateInfoCopies[i].pRasterizationState->rasterizerDiscardEnable == VK_FALSE)
				{
					viewportStateRequired			= true;
					viewportStateViewportsRequired	= true;
					viewportStateScissorsRequired	= true;
					multiSampleStateRequired		= true;
					depthStencilStateRequired		= true;
					colorBlendStateRequired			= true;
				}
			}
			if (pCreateInfoCopies[i].pVertexInputState != DE_NULL && !vertexInputStateRequired)
				pCreateInfoCopies[i].pVertexInputState = DE_NULL;
			if (pCreateInfoCopies[i].pInputAssemblyState != DE_NULL && !inputAssemblyStateRequired)
				pCreateInfoCopies[i].pInputAssemblyState = DE_NULL;
			if (pCreateInfoCopies[i].pTessellationState != DE_NULL && !tessellationStateRequired)
				pCreateInfoCopies[i].pTessellationState = DE_NULL;
			if (pCreateInfoCopies[i].pViewportState != DE_NULL)
			{
				if (viewportStateRequired)
				{
					viewportStateCopies[i]		= *(pCreateInfoCopies[i].pViewportState);
					bool exchangeVP				= false;
					if (pCreateInfoCopies[i].pViewportState->pViewports != DE_NULL && !viewportStateViewportsRequired)
					{
						viewportStateCopies[i].pViewports		= DE_NULL;
						viewportStateCopies[i].viewportCount	= 0u;
						exchangeVP = true;
					}
					if (pCreateInfoCopies[i].pViewportState->pScissors != DE_NULL && !viewportStateScissorsRequired)
					{
						viewportStateCopies[i].pScissors	= DE_NULL;
						viewportStateCopies[i].scissorCount	= 0u;
						exchangeVP = true;
					}
					if (exchangeVP)
						pCreateInfoCopies[i].pViewportState = &(viewportStateCopies[i]);
				}
				else
					pCreateInfoCopies[i].pViewportState = DE_NULL;
			}
			if (pCreateInfoCopies[i].pMultisampleState != DE_NULL && !multiSampleStateRequired)
				pCreateInfoCopies[i].pMultisampleState = DE_NULL;
			if (pCreateInfoCopies[i].pDepthStencilState != DE_NULL && !depthStencilStateRequired)
				pCreateInfoCopies[i].pDepthStencilState = DE_NULL;
			if (pCreateInfoCopies[i].pColorBlendState != DE_NULL && !colorBlendStateRequired)
				pCreateInfoCopies[i].pColorBlendState = DE_NULL;
		}
	}

	// Include pipelineIdentifiers into pNext chain of pCreateInfoCopies - skip this operation if pipeline identifier was created inside test
	for (deUint32 i = 0; i < createInfoCount; ++i)
	{
		if (idInPNextChain[i] == 0)
		{
			pipelineIDs[i].pNext				= pCreateInfoCopies[i].pNext;
			pCreateInfoCopies[i].pNext			= &pipelineIDs[i];
		}
	}

	// subprocess: load graphics pipelines from OUR m_pipelineCache cache
	if (normalMode)
	{
		const auto it = m_createGraphicsPipelinesFunc.find(device);
		if (it != end(m_createGraphicsPipelinesFunc))
		{
			auto pit = m_pipelineCache.find(device);
			if ( pit != end(m_pipelineCache) )
			{
				VkPipelineCache pCache = pit->second->get();
				return it->second(device, pCache, createInfoCount, pCreateInfoCopies.data(), pAllocator, pPipelines);
			}
			TCU_THROW(InternalError, "m_pipelineCache not initialized for this device");
		}
		TCU_THROW(InternalError, "vkCreateGraphicsPipelines not defined");
	}

	// main process: store pipelines in JSON format. Pipelines will be sent later for m_pipelineCache creation ( and sent through file to another process )
	for (deUint32 i = 0; i < createInfoCount; ++i)
	{
		m_pipelineIdentifiers.insert({ pPipelines[i], pipelineIDs[i] });

		auto it = std::find_if(begin(m_pipelineInput.pipelines), end(m_pipelineInput.pipelines), vksc_server::PipelineIdentifierEqual(pipelineIDs[i]));
		pipelineIDs[i].pNext = DE_NULL;
		if (it == end(m_pipelineInput.pipelines))
		{
			const auto& featIt = m_deviceFeatures.find(device);
			if(featIt == end(m_deviceFeatures))
				TCU_THROW(InternalError, "Can't find device features for this pipeline");
			const auto& extIt = m_deviceExtensions.find(device);
			if (extIt == end(m_deviceExtensions))
				TCU_THROW(InternalError, "Can't find device extensions for this pipeline");

			m_pipelineInput.pipelines.push_back(vksc_server::VulkanJsonPipelineDescription(
				pipelineIDs[i],
				writeJSON_VkGraphicsPipelineCreateInfo(pCreateInfoCopies[i]),
				featIt->second,
				extIt->second,
				m_currentTestPath));
		}
		else
			it->add(m_currentTestPath);
	}
	return VK_SUCCESS;
}

VkResult ResourceInterfaceStandard::createComputePipelines (VkDevice								device,
															VkPipelineCache							pipelineCache,
															deUint32								createInfoCount,
															const VkComputePipelineCreateInfo*		pCreateInfos,
															const VkAllocationCallbacks*			pAllocator,
															VkPipeline*								pPipelines,
															bool									normalMode) const
{
	DE_UNREF(pipelineCache);

	// build pipeline identifiers (if required), make a copy of pCreateInfos
	std::vector<VkPipelineOfflineCreateInfo>		pipelineIDs;
	std::vector<deUint8>							idInPNextChain;
	std::vector<VkComputePipelineCreateInfo>		pCreateInfoCopies;

	for (deUint32 i = 0; i < createInfoCount; ++i)
	{
		pCreateInfoCopies.push_back(pCreateInfos[i]);

		// Check if test added pipeline identifier on its own
		VkPipelineOfflineCreateInfo* idInfo = (VkPipelineOfflineCreateInfo*)findStructureInChain(pCreateInfos[i].pNext, VK_STRUCTURE_TYPE_PIPELINE_OFFLINE_CREATE_INFO);
		if (idInfo == DE_NULL)
		{
			pipelineIDs.push_back(makeComputePipelineIdentifier(m_currentTestPath, pCreateInfos[i], getObjectHashes()));
			idInPNextChain.push_back(0);
		}
		else
		{
			pipelineIDs.push_back(*idInfo);
			idInPNextChain.push_back(1);
		}

		if (normalMode)
			fillPoolEntrySize(pipelineIDs.back());
	}

	// Include pipelineIdentifiers into pNext chain of pCreateInfoCopies - skip this operation if pipeline identifier was created inside test
	for (deUint32 i = 0; i < createInfoCount; ++i)
	{
		if (idInPNextChain[i] == 0)
		{
			pipelineIDs[i].pNext				= pCreateInfoCopies[i].pNext;
			pCreateInfoCopies[i].pNext			= &pipelineIDs[i];
		}
	}

	// subprocess: load compute pipelines from OUR pipeline cache
	if (normalMode)
	{
		const auto it = m_createComputePipelinesFunc.find(device);
		if (it != end(m_createComputePipelinesFunc))
		{
			auto pit = m_pipelineCache.find(device);
			if ( pit != end(m_pipelineCache) )
			{
				VkPipelineCache pCache = pit->second->get();
				return it->second(device, pCache, createInfoCount, pCreateInfoCopies.data(), pAllocator, pPipelines);
			}
			TCU_THROW(InternalError, "m_pipelineCache not initialized for this device");
		}
		TCU_THROW(InternalError, "vkCreateComputePipelines not defined");
	}

	// main process: store pipelines in JSON format. Pipelines will be sent later for m_pipelineCache creation ( and sent through file to another process )
	for (deUint32 i = 0; i < createInfoCount; ++i)
	{
		m_pipelineIdentifiers.insert({ pPipelines[i], pipelineIDs[i] });

		auto it = std::find_if(begin(m_pipelineInput.pipelines), end(m_pipelineInput.pipelines), vksc_server::PipelineIdentifierEqual(pipelineIDs[i]));
		pipelineIDs[i].pNext = DE_NULL;
		if (it == end(m_pipelineInput.pipelines))
		{
			const auto& featIt = m_deviceFeatures.find(device);
			if (featIt == end(m_deviceFeatures))
				TCU_THROW(InternalError, "Can't find device features for this pipeline");
			const auto& extIt = m_deviceExtensions.find(device);
			if (extIt == end(m_deviceExtensions))
				TCU_THROW(InternalError, "Can't find device extensions for this pipeline");

			m_pipelineInput.pipelines.push_back(vksc_server::VulkanJsonPipelineDescription(
				pipelineIDs[i],
				writeJSON_VkComputePipelineCreateInfo(pCreateInfoCopies[i]),
				featIt->second,
				extIt->second,
				m_currentTestPath));
		}
		else
			it->add(m_currentTestPath);
	}
	return VK_SUCCESS;
}

void ResourceInterfaceStandard::destroyPipeline (VkDevice								device,
												 VkPipeline								pipeline,
												 const VkAllocationCallbacks*			pAllocator) const
{
	DE_UNREF(device);
	DE_UNREF(pAllocator);

	auto it = m_pipelineIdentifiers.find(pipeline);
	if(it==end(m_pipelineIdentifiers))
		TCU_THROW(InternalError, "Can't find pipeline");

	auto pit = std::find_if(begin(m_pipelineInput.pipelines), end(m_pipelineInput.pipelines), vksc_server::PipelineIdentifierEqual(it->second));
	if (pit == end(m_pipelineInput.pipelines))
		TCU_THROW(InternalError, "Can't find pipeline identifier");
	pit->remove();
}

void ResourceInterfaceStandard::createRenderPass (VkDevice								device,
												  const VkRenderPassCreateInfo*			pCreateInfo,
												  const VkAllocationCallbacks*			pAllocator,
												  VkRenderPass*							pRenderPass) const
{
	DE_UNREF(device);
	DE_UNREF(pAllocator);
	m_pipelineInput.renderPasses.insert({ *pRenderPass,  writeJSON_VkRenderPassCreateInfo(*pCreateInfo) });
}

void ResourceInterfaceStandard::createRenderPass2 (VkDevice								device,
												   const VkRenderPassCreateInfo2*		pCreateInfo,
												   const VkAllocationCallbacks*			pAllocator,
												   VkRenderPass*						pRenderPass) const
{
	DE_UNREF(device);
	DE_UNREF(pAllocator);
	m_pipelineInput.renderPasses.insert({ *pRenderPass,  writeJSON_VkRenderPassCreateInfo2(*pCreateInfo) });
}

void ResourceInterfaceStandard::createPipelineLayout (VkDevice								device,
													  const VkPipelineLayoutCreateInfo*		pCreateInfo,
													  const VkAllocationCallbacks*			pAllocator,
													  VkPipelineLayout*						pPipelineLayout) const
{
	DE_UNREF(device);
	DE_UNREF(pAllocator);
	m_pipelineInput.pipelineLayouts.insert({*pPipelineLayout, writeJSON_VkPipelineLayoutCreateInfo(*pCreateInfo) });
}

void ResourceInterfaceStandard::createDescriptorSetLayout (VkDevice									device,
														   const VkDescriptorSetLayoutCreateInfo*	pCreateInfo,
														   const VkAllocationCallbacks*				pAllocator,
														   VkDescriptorSetLayout*					pSetLayout) const
{
	DE_UNREF(device);
	DE_UNREF(pAllocator);
	m_pipelineInput.descriptorSetLayouts.insert({ *pSetLayout, writeJSON_VkDescriptorSetLayoutCreateInfo(*pCreateInfo) });
}

void ResourceInterfaceStandard::createSampler (VkDevice							device,
											   const VkSamplerCreateInfo*		pCreateInfo,
											   const VkAllocationCallbacks*		pAllocator,
											   VkSampler*						pSampler) const
{
	DE_UNREF(device);
	DE_UNREF(pAllocator);
	m_pipelineInput.samplers.insert({ *pSampler,  writeJSON_VkSamplerCreateInfo(*pCreateInfo) });
}

void ResourceInterfaceStandard::createSamplerYcbcrConversion (VkDevice									device,
															  const VkSamplerYcbcrConversionCreateInfo*	pCreateInfo,
															  const VkAllocationCallbacks*				pAllocator,
															  VkSamplerYcbcrConversion*					pYcbcrConversion) const
{
	DE_UNREF(device);
	DE_UNREF(pAllocator);
	m_pipelineInput.samplerYcbcrConversions.insert({ *pYcbcrConversion,  writeJSON_VkSamplerYcbcrConversionCreateInfo(*pCreateInfo) });
}

void ResourceInterfaceStandard::createCommandPool (VkDevice										device,
												   const VkCommandPoolCreateInfo*				pCreateInfo,
												   const VkAllocationCallbacks*					pAllocator,
												   VkCommandPool*								pCommandPool) const
{
	DE_UNREF(device);
	DE_UNREF(pCreateInfo);
	DE_UNREF(pAllocator);
	m_commandPoolMemoryConsumption.push_back(vksc_server::VulkanCommandMemoryConsumption(pCommandPool->getInternal()));
}

void ResourceInterfaceStandard::allocateCommandBuffers (VkDevice								device,
														const VkCommandBufferAllocateInfo*		pAllocateInfo,
														VkCommandBuffer*						pCommandBuffers) const
{
	DE_UNREF(device);
	for (deUint32 i = 0; i < pAllocateInfo->commandBufferCount; ++i)
	{
		m_commandBufferMemoryConsumption.insert({ pCommandBuffers[i], vksc_server::VulkanCommandMemoryConsumption(pAllocateInfo->commandPool.getInternal()) });
	}
}

void ResourceInterfaceStandard::increaseCommandBufferSize (VkCommandBuffer						commandBuffer,
														   VkDeviceSize							commandSize) const
{
	auto it = m_commandBufferMemoryConsumption.find(commandBuffer);
	if (it == end(m_commandBufferMemoryConsumption))
		TCU_THROW(InternalError, "Unregistered command buffer");

	it->second.updateValues(commandSize, commandSize, commandSize);
}

void ResourceInterfaceStandard::resetCommandPool (VkDevice								device,
												  VkCommandPool							commandPool,
												  VkCommandPoolResetFlags				flags) const
{
	DE_UNREF(device);
	DE_UNREF(flags);

	for (auto& memC : m_commandBufferMemoryConsumption)
	{
		if (memC.second.commandPool == commandPool.getInternal())
			memC.second.resetValues();
	}
}

void ResourceInterfaceStandard::importPipelineCacheData (const PlatformInterface&			vkp,
														 VkInstance							instance,
														 const InstanceInterface&			vki,
														 VkPhysicalDevice					physicalDevice,
														 deUint32							queueIndex)
{
	if(!std::string(m_testCtx.getCommandLine().getPipelineCompilerPath()).empty())
	{
		m_cacheData = vksc_server::buildOfflinePipelineCache(m_pipelineInput,
															 std::string( m_testCtx.getCommandLine().getPipelineCompilerPath()),
															 std::string( m_testCtx.getCommandLine().getPipelineCompilerDataDir()),
															 std::string( m_testCtx.getCommandLine().getPipelineCompilerArgs()),
															 std::string( m_testCtx.getCommandLine().getPipelineCompilerOutputFile()),
															 std::string( m_testCtx.getCommandLine().getPipelineCompilerLogFile()),
															 std::string( m_testCtx.getCommandLine().getPipelineCompilerFilePrefix()) );
	}
	else
	{
		m_cacheData = vksc_server::buildPipelineCache(m_pipelineInput, vkp, instance, vki, physicalDevice, queueIndex);
	}

	VkPhysicalDeviceVulkanSC10Properties	vulkanSC10Properties	= initVulkanStructure();
	VkPhysicalDeviceProperties2				deviceProperties2		= initVulkanStructure(&vulkanSC10Properties);
	vki.getPhysicalDeviceProperties2(physicalDevice, &deviceProperties2);

	m_pipelineSizes	= vksc_server::extractSizesFromPipelineCache( m_pipelineInput, m_cacheData, deUint32(m_testCtx.getCommandLine().getPipelineDefaultSize()), vulkanSC10Properties.recyclePipelineMemory == VK_TRUE);
	preparePipelinePoolSizes();
}

void ResourceInterfaceStandard::resetObjects ()
{
	m_pipelineInput							= {};
	m_objectHashes.clear();
	m_commandPoolMemoryConsumption.clear();
	m_commandPoolIndex						= 0u;
	m_commandBufferMemoryConsumption.clear();
	m_resourceCounter						= 0u;
	m_statCurrent							= resetDeviceObjectReservationCreateInfo();
	m_statMax								= resetDeviceObjectReservationCreateInfo();
	// pipelineCacheRequestCount does not contain one instance of createPipelineCache call that happens only in subprocess
	m_statCurrent.pipelineCacheRequestCount	= 1u;
	m_statMax.pipelineCacheRequestCount		= 1u;
	m_cacheData.clear();
	m_pipelineIdentifiers.clear();
	m_pipelineSizes.clear();
	m_pipelinePoolSizes.clear();
	runGarbageCollection();
}

void ResourceInterfaceStandard::resetPipelineCaches ()
{
	if (m_testCtx.getCommandLine().isSubProcess())
	{
		m_pipelineCache.clear();
	}
}

#endif // CTS_USES_VULKANSC

vk::ProgramBinary* ResourceInterfaceStandard::compileProgram (const vk::ProgramIdentifier&	progId,
															  const vk::GlslSource&			source,
															  glu::ShaderProgramInfo*		buildInfo,
															  const tcu::CommandLine&		commandLine)
{
	DE_UNREF(progId);
	return vk::buildProgram(source, buildInfo, commandLine);
}

vk::ProgramBinary* ResourceInterfaceStandard::compileProgram (const vk::ProgramIdentifier&	progId,
															  const vk::HlslSource&			source,
															  glu::ShaderProgramInfo*		buildInfo,
															  const tcu::CommandLine&		commandLine)
{
	DE_UNREF(progId);
	return vk::buildProgram(source, buildInfo, commandLine);
}

vk::ProgramBinary* ResourceInterfaceStandard::compileProgram (const vk::ProgramIdentifier&	progId,
															  const vk::SpirVAsmSource&		source,
															  vk::SpirVProgramInfo*			buildInfo,
															  const tcu::CommandLine&		commandLine)
{
	DE_UNREF(progId);
	return vk::assembleProgram(source, buildInfo, commandLine);
}

#ifdef CTS_USES_VULKANSC

ResourceInterfaceVKSC::ResourceInterfaceVKSC (tcu::TestContext& testCtx)
	: ResourceInterfaceStandard(testCtx)
{
		m_address = std::string(testCtx.getCommandLine().getServerAddress());
}

vksc_server::Server* ResourceInterfaceVKSC::getServer ()
{
	if (!m_server)
	{
		m_server = std::make_shared<vksc_server::Server>(m_address);
	}
	return m_server.get();
}

bool ResourceInterfaceVKSC::noServer () const
{
	return m_address.empty();
}

vk::ProgramBinary* ResourceInterfaceVKSC::compileProgram (const vk::ProgramIdentifier&	progId,
														  const vk::GlslSource&			source,
														  glu::ShaderProgramInfo*		buildInfo,
														  const tcu::CommandLine&		commandLine)
{
	if (noServer()) return ResourceInterfaceStandard::compileProgram(progId, source, buildInfo, commandLine);

	DE_UNREF(progId);
	DE_UNREF(buildInfo);

	vksc_server::CompileShaderRequest request;
	request.source.active = "glsl";
	request.source.glsl = source;
	request.commandLine = commandLine.getInitialCmdLine();
	vksc_server::CompileShaderResponse response;
	getServer()->SendRequest(request, response);

	return new ProgramBinary(PROGRAM_FORMAT_SPIRV, response.binary.size(), response.binary.data());
}

vk::ProgramBinary* ResourceInterfaceVKSC::compileProgram (const vk::ProgramIdentifier&	progId,
														  const vk::HlslSource&			source,
														  glu::ShaderProgramInfo*		buildInfo,
														  const tcu::CommandLine&		commandLine)
{
	if (noServer()) return ResourceInterfaceStandard::compileProgram(progId, source, buildInfo, commandLine);

	DE_UNREF(progId);
	DE_UNREF(buildInfo);

	vksc_server::CompileShaderRequest request;
	request.source.active = "hlsl";
	request.source.hlsl = source;
	request.commandLine = commandLine.getInitialCmdLine();
	vksc_server::CompileShaderResponse response;
	getServer()->SendRequest(request, response);

	return new ProgramBinary(PROGRAM_FORMAT_SPIRV, response.binary.size(), response.binary.data());
}

vk::ProgramBinary* ResourceInterfaceVKSC::compileProgram (const vk::ProgramIdentifier&	progId,
														  const vk::SpirVAsmSource&		source,
														  vk::SpirVProgramInfo*			buildInfo,
														  const tcu::CommandLine&		commandLine)
{
	if (noServer()) return ResourceInterfaceStandard::compileProgram(progId, source, buildInfo, commandLine);

	DE_UNREF(progId);
	DE_UNREF(buildInfo);

	vksc_server::CompileShaderRequest request;
	request.source.active = "spirv";
	request.source.spirv = source;
	request.commandLine = commandLine.getInitialCmdLine();
	vksc_server::CompileShaderResponse response;
	getServer()->SendRequest(request, response);

	return new ProgramBinary(PROGRAM_FORMAT_SPIRV, response.binary.size(), response.binary.data());
}

VkResult ResourceInterfaceVKSC::createShaderModule (VkDevice							device,
													const VkShaderModuleCreateInfo*		pCreateInfo,
													const VkAllocationCallbacks*		pAllocator,
													VkShaderModule*						pShaderModule,
													bool								normalMode) const
{
	if (noServer() || !normalMode || !isVulkanSC())
		return ResourceInterfaceStandard::createShaderModule(device, pCreateInfo, pAllocator, pShaderModule, normalMode);

	// We will reach this place only in one case:
	// - server exists
	// - subprocess asks for creation of VkShaderModule which will be later ignored, because it will receive the whole pipeline from server
	// ( Are there any tests which receive VkShaderModule and do not use it in any pipeline ? )
	*pShaderModule = VkShaderModule(++m_resourceCounter);
	registerObjectHash(pShaderModule->getInternal(), calculateShaderModuleHash(*pCreateInfo, getObjectHashes()));
	return VK_SUCCESS;
}


void ResourceInterfaceVKSC::importPipelineCacheData (const PlatformInterface&			vkp,
													 VkInstance							instance,
													 const InstanceInterface&			vki,
													 VkPhysicalDevice					physicalDevice,
													 deUint32							queueIndex)
{
	if (noServer())
	{
		ResourceInterfaceStandard::importPipelineCacheData(vkp, instance, vki, physicalDevice, queueIndex);
		return;
	}

	vksc_server::CreateCacheRequest request;
	request.input						= m_pipelineInput;
	std::vector<int>	caseFraction	= m_testCtx.getCommandLine().getCaseFraction();
	request.caseFraction				= caseFraction.empty() ? -1 : caseFraction[0];

	vksc_server::CreateCacheResponse response;
	getServer()->SendRequest(request, response);

	if (response.status)
	{
		m_cacheData = std::move(response.binary);

		VkPhysicalDeviceVulkanSC10Properties	vulkanSC10Properties	= initVulkanStructure();
		VkPhysicalDeviceProperties2				deviceProperties2		= initVulkanStructure(&vulkanSC10Properties);
		vki.getPhysicalDeviceProperties2(physicalDevice, &deviceProperties2);

		m_pipelineSizes	= vksc_server::extractSizesFromPipelineCache( m_pipelineInput, m_cacheData, deUint32(m_testCtx.getCommandLine().getPipelineDefaultSize()), vulkanSC10Properties.recyclePipelineMemory == VK_TRUE);
		preparePipelinePoolSizes();
	}
	else { TCU_THROW(InternalError, "Server did not return pipeline cache data when requested (check server log for details)"); }
}

MultithreadedDestroyGuard::MultithreadedDestroyGuard (de::SharedPtr<vk::ResourceInterface> resourceInterface)
	: m_resourceInterface{ resourceInterface }
{
	if (m_resourceInterface.get() != DE_NULL)
		m_resourceInterface->setHandleDestroy(false);
}

MultithreadedDestroyGuard::~MultithreadedDestroyGuard ()
{
	if (m_resourceInterface.get() != DE_NULL)
		m_resourceInterface->setHandleDestroy(true);
}

#endif // CTS_USES_VULKANSC


} // namespace vk