Home | History | Annotate | Download | only in api 
      1 /*-------------------------------------------------------------------------
      2  * Vulkan Conformance Tests
      3  * ------------------------
      4  *
      5  * Copyright (c) 2015 Google 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
     21  * \brief Object management tests
     22  *//*--------------------------------------------------------------------*/
     23 
     24 #include "vktApiObjectManagementTests.hpp"
     25 #include "vktTestCaseUtil.hpp"
     26 
     27 #include "vkDefs.hpp"
     28 #include "vkRef.hpp"
     29 #include "vkRefUtil.hpp"
     30 #include "vkQueryUtil.hpp"
     31 #include "vkMemUtil.hpp"
     32 #include "vkPrograms.hpp"
     33 #include "vkTypeUtil.hpp"
     34 #include "vkPlatform.hpp"
     35 #include "vkStrUtil.hpp"
     36 #include "vkAllocationCallbackUtil.hpp"
     37 
     38 #include "tcuVector.hpp"
     39 #include "tcuResultCollector.hpp"
     40 #include "tcuCommandLine.hpp"
     41 #include "tcuTestLog.hpp"
     42 #include "tcuPlatform.hpp"
     43 
     44 #include "deUniquePtr.hpp"
     45 #include "deSharedPtr.hpp"
     46 #include "deArrayUtil.hpp"
     47 #include "deSpinBarrier.hpp"
     48 #include "deThread.hpp"
     49 #include "deInt32.h"
     50 
     51 #include <limits>
     52 
     53 namespace vkt
     54 {
     55 namespace api
     56 {
     57 
     58 namespace
     59 {
     60 
     61 using namespace vk;
     62 
     63 using de::UniquePtr;
     64 using de::MovePtr;
     65 using de::SharedPtr;
     66 
     67 using tcu::IVec3;
     68 using tcu::UVec3;
     69 using tcu::ResultCollector;
     70 using tcu::TestStatus;
     71 using tcu::TestLog;
     72 
     73 using std::string;
     74 using std::vector;
     75 
     76 class ThreadGroupThread;
     77 
     78 /*--------------------------------------------------------------------*//*!
     79  * \brief Thread group
     80  *
     81  * Thread group manages collection of threads that are expected to be
     82  * launched simultaneously as a group.
     83  *
     84  * Shared barrier is provided for synchronizing execution. Terminating thread
     85  * early either by returning from ThreadGroupThread::runThread() or throwing
     86  * an exception is safe, and other threads will continue execution. The
     87  * thread that has been terminated is simply removed from the synchronization
     88  * group.
     89  *
     90  * TestException-based exceptions are collected and translated into a
     91  * tcu::TestStatus by using tcu::ResultCollector.
     92  *
     93  * Use cases for ThreadGroup include for example testing thread-safety of
     94  * certain API operations by poking API simultaneously from multiple
     95  * threads.
     96  *//*--------------------------------------------------------------------*/
     97 class ThreadGroup
     98 {
     99 public:
    100 							ThreadGroup			(void);
    101 							~ThreadGroup		(void);
    102 
    103 	void					add					(de::MovePtr<ThreadGroupThread> thread);
    104 	TestStatus				run					(void);
    105 
    106 private:
    107 	typedef std::vector<de::SharedPtr<ThreadGroupThread> >	ThreadVector;
    108 
    109 	ThreadVector			m_threads;
    110 	de::SpinBarrier			m_barrier;
    111 } DE_WARN_UNUSED_TYPE;
    112 
    113 class ThreadGroupThread : private de::Thread
    114 {
    115 public:
    116 							ThreadGroupThread	(void);
    117 	virtual					~ThreadGroupThread	(void);
    118 
    119 	void					start				(de::SpinBarrier* groupBarrier);
    120 
    121 	ResultCollector&		getResultCollector	(void) { return m_resultCollector; }
    122 
    123 	using de::Thread::join;
    124 
    125 protected:
    126 	virtual void			runThread			(void) = 0;
    127 
    128 	void					barrier				(void);
    129 
    130 private:
    131 							ThreadGroupThread	(const ThreadGroupThread&);
    132 	ThreadGroupThread&		operator=			(const ThreadGroupThread&);
    133 
    134 	void					run					(void);
    135 
    136 	ResultCollector			m_resultCollector;
    137 	de::SpinBarrier*		m_barrier;
    138 };
    139 
    140 // ThreadGroup
    141 
    142 ThreadGroup::ThreadGroup (void)
    143 	: m_barrier(1)
    144 {
    145 }
    146 
    147 ThreadGroup::~ThreadGroup (void)
    148 {
    149 }
    150 
    151 void ThreadGroup::add (de::MovePtr<ThreadGroupThread> thread)
    152 {
    153 	m_threads.push_back(de::SharedPtr<ThreadGroupThread>(thread.release()));
    154 }
    155 
    156 tcu::TestStatus ThreadGroup::run (void)
    157 {
    158 	tcu::ResultCollector	resultCollector;
    159 
    160 	m_barrier.reset((int)m_threads.size());
    161 
    162 	for (ThreadVector::iterator threadIter = m_threads.begin(); threadIter != m_threads.end(); ++threadIter)
    163 		(*threadIter)->start(&m_barrier);
    164 
    165 	for (ThreadVector::iterator threadIter = m_threads.begin(); threadIter != m_threads.end(); ++threadIter)
    166 	{
    167 		tcu::ResultCollector&	threadResult	= (*threadIter)->getResultCollector();
    168 		(*threadIter)->join();
    169 		resultCollector.addResult(threadResult.getResult(), threadResult.getMessage());
    170 	}
    171 
    172 	return tcu::TestStatus(resultCollector.getResult(), resultCollector.getMessage());
    173 }
    174 
    175 // ThreadGroupThread
    176 
    177 ThreadGroupThread::ThreadGroupThread (void)
    178 	: m_barrier(DE_NULL)
    179 {
    180 }
    181 
    182 ThreadGroupThread::~ThreadGroupThread (void)
    183 {
    184 }
    185 
    186 void ThreadGroupThread::start (de::SpinBarrier* groupBarrier)
    187 {
    188 	m_barrier = groupBarrier;
    189 	de::Thread::start();
    190 }
    191 
    192 void ThreadGroupThread::run (void)
    193 {
    194 	try
    195 	{
    196 		runThread();
    197 	}
    198 	catch (const tcu::TestException& e)
    199 	{
    200 		getResultCollector().addResult(e.getTestResult(), e.getMessage());
    201 	}
    202 	catch (const std::exception& e)
    203 	{
    204 		getResultCollector().addResult(QP_TEST_RESULT_FAIL, e.what());
    205 	}
    206 	catch (...)
    207 	{
    208 		getResultCollector().addResult(QP_TEST_RESULT_FAIL, "Exception");
    209 	}
    210 
    211 	m_barrier->removeThread(de::SpinBarrier::WAIT_MODE_AUTO);
    212 }
    213 
    214 inline void ThreadGroupThread::barrier (void)
    215 {
    216 	m_barrier->sync(de::SpinBarrier::WAIT_MODE_AUTO);
    217 }
    218 
    219 deUint32 getDefaultTestThreadCount (void)
    220 {
    221 	return de::clamp(deGetNumAvailableLogicalCores(), 2u, 8u);
    222 }
    223 
    224 // Utilities
    225 
    226 struct Environment
    227 {
    228 	const PlatformInterface&		vkp;
    229 	const DeviceInterface&			vkd;
    230 	VkDevice						device;
    231 	deUint32						queueFamilyIndex;
    232 	const BinaryCollection&			programBinaries;
    233 	const VkAllocationCallbacks*	allocationCallbacks;
    234 	deUint32						maxResourceConsumers;		// Maximum number of objects using same Object::Resources concurrently
    235 
    236 	Environment (Context& context, deUint32 maxResourceConsumers_)
    237 		: vkp					(context.getPlatformInterface())
    238 		, vkd					(context.getDeviceInterface())
    239 		, device				(context.getDevice())
    240 		, queueFamilyIndex		(context.getUniversalQueueFamilyIndex())
    241 		, programBinaries		(context.getBinaryCollection())
    242 		, allocationCallbacks	(DE_NULL)
    243 		, maxResourceConsumers	(maxResourceConsumers_)
    244 	{
    245 	}
    246 
    247 	Environment (const PlatformInterface&		vkp_,
    248 				 const DeviceInterface&			vkd_,
    249 				 VkDevice						device_,
    250 				 deUint32						queueFamilyIndex_,
    251 				 const BinaryCollection&		programBinaries_,
    252 				 const VkAllocationCallbacks*	allocationCallbacks_,
    253 				 deUint32						maxResourceConsumers_)
    254 		: vkp					(vkp_)
    255 		, vkd					(vkd_)
    256 		, device				(device_)
    257 		, queueFamilyIndex		(queueFamilyIndex_)
    258 		, programBinaries		(programBinaries_)
    259 		, allocationCallbacks	(allocationCallbacks_)
    260 		, maxResourceConsumers	(maxResourceConsumers_)
    261 	{
    262 	}
    263 };
    264 
    265 template<typename Case>
    266 struct Dependency
    267 {
    268 	typename Case::Resources		resources;
    269 	Unique<typename Case::Type>		object;
    270 
    271 	Dependency (const Environment& env, const typename Case::Parameters& params)
    272 		: resources	(env, params)
    273 		, object	(Case::create(env, resources, params))
    274 	{}
    275 };
    276 
    277 template<typename T>
    278 T roundUpToNextMultiple (T value, T multiple)
    279 {
    280 	if (value % multiple == 0)
    281 		return value;
    282 	else
    283 		return value + multiple - (value % multiple);
    284 }
    285 
    286 #if defined(DE_DEBUG)
    287 template<typename T>
    288 bool isPowerOfTwo (T value)
    289 {
    290 	return ((value & (value - T(1))) == 0);
    291 }
    292 #endif
    293 
    294 template<typename T>
    295 T alignToPowerOfTwo (T value, T align)
    296 {
    297 	DE_ASSERT(isPowerOfTwo(align));
    298 	return (value + align - T(1)) & ~(align - T(1));
    299 }
    300 
    301 VkDeviceSize getPageTableSize (const PlatformMemoryLimits& limits, VkDeviceSize allocationSize)
    302 {
    303 	VkDeviceSize	totalSize	= 0;
    304 
    305 	for (size_t levelNdx = 0; levelNdx < limits.devicePageTableHierarchyLevels; ++levelNdx)
    306 	{
    307 		const VkDeviceSize	coveredAddressSpaceSize	= limits.devicePageSize<<levelNdx;
    308 		const VkDeviceSize	numPagesNeeded			= alignToPowerOfTwo(allocationSize, coveredAddressSpaceSize) / coveredAddressSpaceSize;
    309 
    310 		totalSize += numPagesNeeded*limits.devicePageTableEntrySize;
    311 	}
    312 
    313 	return totalSize;
    314 }
    315 
    316 
    317 
    318 size_t getCurrentSystemMemoryUsage (const AllocationCallbackRecorder& allocRecoder)
    319 {
    320 	const size_t						systemAllocationOverhead	= sizeof(void*)*2;
    321 	AllocationCallbackValidationResults	validationResults;
    322 
    323 	validateAllocationCallbacks(allocRecoder, &validationResults);
    324 	TCU_CHECK(validationResults.violations.empty());
    325 
    326 	return getLiveSystemAllocationTotal(validationResults) + systemAllocationOverhead*validationResults.liveAllocations.size();
    327 }
    328 
    329 template<typename Object>
    330 size_t computeSystemMemoryUsage (Context& context, const typename Object::Parameters& params)
    331 {
    332 	AllocationCallbackRecorder			allocRecorder		(getSystemAllocator());
    333 	const Environment					env					(context.getPlatformInterface(),
    334 															 context.getDeviceInterface(),
    335 															 context.getDevice(),
    336 															 context.getUniversalQueueFamilyIndex(),
    337 															 context.getBinaryCollection(),
    338 															 allocRecorder.getCallbacks(),
    339 															 1u);
    340 	const typename Object::Resources	res					(env, params);
    341 	const size_t						resourceMemoryUsage	= getCurrentSystemMemoryUsage(allocRecorder);
    342 
    343 	{
    344 		Unique<typename Object::Type>	obj					(Object::create(env, res, params));
    345 		const size_t					totalMemoryUsage	= getCurrentSystemMemoryUsage(allocRecorder);
    346 
    347 		return totalMemoryUsage - resourceMemoryUsage;
    348 	}
    349 }
    350 
    351 size_t getSafeObjectCount (const PlatformMemoryLimits&	memoryLimits,
    352 						   size_t						objectSystemMemoryUsage,
    353 						   VkDeviceSize					objectDeviceMemoryUsage = 0)
    354 {
    355 	const VkDeviceSize	roundedUpDeviceMemory	= roundUpToNextMultiple(objectDeviceMemoryUsage, memoryLimits.deviceMemoryAllocationGranularity);
    356 
    357 	if (memoryLimits.totalDeviceLocalMemory > 0 && roundedUpDeviceMemory > 0)
    358 	{
    359 		if (objectSystemMemoryUsage > 0)
    360 			return de::min(memoryLimits.totalSystemMemory / objectSystemMemoryUsage,
    361 						   (size_t)(memoryLimits.totalDeviceLocalMemory / roundedUpDeviceMemory));
    362 		else
    363 			return (size_t)(memoryLimits.totalDeviceLocalMemory / roundedUpDeviceMemory);
    364 	}
    365 	else if (objectSystemMemoryUsage + roundedUpDeviceMemory > 0)
    366 	{
    367 		DE_ASSERT(roundedUpDeviceMemory <= std::numeric_limits<size_t>::max() - objectSystemMemoryUsage);
    368 		return memoryLimits.totalSystemMemory / (objectSystemMemoryUsage + (size_t)roundedUpDeviceMemory);
    369 	}
    370 	else
    371 	{
    372 		// Warning: at this point driver has probably not implemented allocation callbacks correctly
    373 		return std::numeric_limits<size_t>::max();
    374 	}
    375 }
    376 
    377 PlatformMemoryLimits getPlatformMemoryLimits (Context& context)
    378 {
    379 	PlatformMemoryLimits	memoryLimits;
    380 
    381 	context.getTestContext().getPlatform().getVulkanPlatform().getMemoryLimits(memoryLimits);
    382 
    383 	return memoryLimits;
    384 }
    385 
    386 size_t getSafeObjectCount (Context& context, size_t objectSystemMemoryUsage, VkDeviceSize objectDeviceMemorySize = 0)
    387 {
    388 	return getSafeObjectCount(getPlatformMemoryLimits(context), objectSystemMemoryUsage, objectDeviceMemorySize);
    389 }
    390 
    391 VkDeviceSize getPageTableSize (Context& context, VkDeviceSize allocationSize)
    392 {
    393 	return getPageTableSize(getPlatformMemoryLimits(context), allocationSize);
    394 }
    395 
    396 template<typename Object>
    397 deUint32 getSafeObjectCount (Context&							context,
    398 							 const typename Object::Parameters&	params,
    399 							 deUint32							hardCountLimit,
    400 							 VkDeviceSize						deviceMemoryUsage = 0)
    401 {
    402 	return (deUint32)de::min((size_t)hardCountLimit,
    403 							 getSafeObjectCount(context,
    404 												computeSystemMemoryUsage<Object>(context, params),
    405 												deviceMemoryUsage));
    406 }
    407 
    408 // Object definitions
    409 
    410 enum
    411 {
    412 	MAX_CONCURRENT_INSTANCES		= 32,
    413 	MAX_CONCURRENT_DEVICES			= 32,
    414 	MAX_CONCURRENT_SYNC_PRIMITIVES	= 100,
    415 	DEFAULT_MAX_CONCURRENT_OBJECTS	= 16*1024,
    416 };
    417 
    418 struct Instance
    419 {
    420 	typedef VkInstance Type;
    421 
    422 	struct Parameters
    423 	{
    424 		Parameters (void) {}
    425 	};
    426 
    427 	struct Resources
    428 	{
    429 		Resources (const Environment&, const Parameters&) {}
    430 	};
    431 
    432 	static deUint32 getMaxConcurrent (Context& context, const Parameters& params)
    433 	{
    434 		return getSafeObjectCount<Instance>(context, params, MAX_CONCURRENT_INSTANCES);
    435 	}
    436 
    437 	static Move<VkInstance> create (const Environment& env, const Resources&, const Parameters&)
    438 	{
    439 		const VkApplicationInfo		appInfo			=
    440 		{
    441 			VK_STRUCTURE_TYPE_APPLICATION_INFO,
    442 			DE_NULL,
    443 			DE_NULL,							// pApplicationName
    444 			0u,									// applicationVersion
    445 			DE_NULL,							// pEngineName
    446 			0u,									// engineVersion
    447 			VK_MAKE_VERSION(1,0,0)
    448 		};
    449 		const VkInstanceCreateInfo	instanceInfo	=
    450 		{
    451 			VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
    452 			DE_NULL,
    453 			(VkInstanceCreateFlags)0,
    454 			&appInfo,
    455 			0u,									// enabledLayerNameCount
    456 			DE_NULL,							// ppEnabledLayerNames
    457 			0u,									// enabledExtensionNameCount
    458 			DE_NULL,							// ppEnabledExtensionNames
    459 		};
    460 
    461 		return createInstance(env.vkp, &instanceInfo, env.allocationCallbacks);
    462 	}
    463 };
    464 
    465 struct Device
    466 {
    467 	typedef VkDevice Type;
    468 
    469 	struct Parameters
    470 	{
    471 		deUint32		deviceIndex;
    472 		VkQueueFlags	queueFlags;
    473 
    474 		Parameters (deUint32 deviceIndex_, VkQueueFlags queueFlags_)
    475 			: deviceIndex	(deviceIndex_)
    476 			, queueFlags	(queueFlags_)
    477 		{}
    478 	};
    479 
    480 	struct Resources
    481 	{
    482 		Dependency<Instance>	instance;
    483 		InstanceDriver			vki;
    484 		VkPhysicalDevice		physicalDevice;
    485 		deUint32				queueFamilyIndex;
    486 
    487 		Resources (const Environment& env, const Parameters& params)
    488 			: instance			(env, Instance::Parameters())
    489 			, vki				(env.vkp, *instance.object)
    490 			, physicalDevice	(0)
    491 			, queueFamilyIndex	(~0u)
    492 		{
    493 			{
    494 				const vector<VkPhysicalDevice>	physicalDevices	= enumeratePhysicalDevices(vki, *instance.object);
    495 
    496 				if (physicalDevices.size() <= (size_t)params.deviceIndex)
    497 					TCU_THROW(NotSupportedError, "Device not found");
    498 
    499 				physicalDevice = physicalDevices[params.deviceIndex];
    500 			}
    501 
    502 			{
    503 				const vector<VkQueueFamilyProperties>	queueProps		= getPhysicalDeviceQueueFamilyProperties(vki, physicalDevice);
    504 				bool									foundMatching	= false;
    505 
    506 				for (size_t curQueueNdx = 0; curQueueNdx < queueProps.size(); curQueueNdx++)
    507 				{
    508 					if ((queueProps[curQueueNdx].queueFlags & params.queueFlags) == params.queueFlags)
    509 					{
    510 						queueFamilyIndex	= (deUint32)curQueueNdx;
    511 						foundMatching		= true;
    512 					}
    513 				}
    514 
    515 				if (!foundMatching)
    516 					TCU_THROW(NotSupportedError, "Matching queue not found");
    517 			}
    518 		}
    519 	};
    520 
    521 	static deUint32 getMaxConcurrent (Context& context, const Parameters& params)
    522 	{
    523 		return getSafeObjectCount<Device>(context, params, MAX_CONCURRENT_DEVICES);
    524 	}
    525 
    526 	static Move<VkDevice> create (const Environment& env, const Resources& res, const Parameters&)
    527 	{
    528 		const float	queuePriority	= 1.0;
    529 
    530 		const VkDeviceQueueCreateInfo	queues[]	=
    531 		{
    532 			{
    533 				VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
    534 				DE_NULL,
    535 				(VkDeviceQueueCreateFlags)0,
    536 				res.queueFamilyIndex,
    537 				1u,									// queueCount
    538 				&queuePriority,						// pQueuePriorities
    539 			}
    540 		};
    541 		const VkDeviceCreateInfo		deviceInfo	=
    542 		{
    543 			VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
    544 			DE_NULL,
    545 			(VkDeviceCreateFlags)0,
    546 			DE_LENGTH_OF_ARRAY(queues),
    547 			queues,
    548 			0u,										// enabledLayerNameCount
    549 			DE_NULL,								// ppEnabledLayerNames
    550 			0u,										// enabledExtensionNameCount
    551 			DE_NULL,								// ppEnabledExtensionNames
    552 			DE_NULL,								// pEnabledFeatures
    553 		};
    554 
    555 		return createDevice(res.vki, res.physicalDevice, &deviceInfo, env.allocationCallbacks);
    556 	}
    557 };
    558 
    559 struct DeviceMemory
    560 {
    561 	typedef VkDeviceMemory Type;
    562 
    563 	struct Parameters
    564 	{
    565 		VkDeviceSize	size;
    566 		deUint32		memoryTypeIndex;
    567 
    568 		Parameters (VkDeviceSize size_, deUint32 memoryTypeIndex_)
    569 			: size				(size_)
    570 			, memoryTypeIndex	(memoryTypeIndex_)
    571 		{
    572 			DE_ASSERT(memoryTypeIndex < VK_MAX_MEMORY_TYPES);
    573 		}
    574 	};
    575 
    576 	struct Resources
    577 	{
    578 		Resources (const Environment&, const Parameters&) {}
    579 	};
    580 
    581 	static deUint32 getMaxConcurrent (Context& context, const Parameters& params)
    582 	{
    583 		const VkDeviceSize	deviceMemoryUsage	= params.size + getPageTableSize(context, params.size);
    584 
    585 		return getSafeObjectCount<DeviceMemory>(context,
    586 												params,
    587 												de::min(context.getDeviceProperties().limits.maxMemoryAllocationCount,
    588 														(deUint32)DEFAULT_MAX_CONCURRENT_OBJECTS),
    589 												deviceMemoryUsage);
    590 	}
    591 
    592 	static Move<VkDeviceMemory> create (const Environment& env, const Resources&, const Parameters& params)
    593 	{
    594 		const VkMemoryAllocateInfo	allocInfo	=
    595 		{
    596 			VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
    597 			DE_NULL,
    598 			params.size,
    599 			params.memoryTypeIndex
    600 		};
    601 
    602 		return allocateMemory(env.vkd, env.device, &allocInfo, env.allocationCallbacks);
    603 	}
    604 };
    605 
    606 DeviceMemory::Parameters getDeviceMemoryParameters (const VkMemoryRequirements& memReqs)
    607 {
    608 	return DeviceMemory::Parameters(memReqs.size, deCtz32(memReqs.memoryTypeBits));
    609 }
    610 
    611 DeviceMemory::Parameters getDeviceMemoryParameters (const Environment& env, VkImage image)
    612 {
    613 	return getDeviceMemoryParameters(getImageMemoryRequirements(env.vkd, env.device, image));
    614 }
    615 
    616 DeviceMemory::Parameters getDeviceMemoryParameters (const Environment& env, VkBuffer image)
    617 {
    618 	return getDeviceMemoryParameters(getBufferMemoryRequirements(env.vkd, env.device, image));
    619 }
    620 
    621 struct Buffer
    622 {
    623 	typedef VkBuffer Type;
    624 
    625 	struct Parameters
    626 	{
    627 		VkDeviceSize		size;
    628 		VkBufferUsageFlags	usage;
    629 
    630 		Parameters (VkDeviceSize		size_,
    631 					VkBufferUsageFlags	usage_)
    632 			: size	(size_)
    633 			, usage	(usage_)
    634 		{}
    635 	};
    636 
    637 	struct Resources
    638 	{
    639 		Resources (const Environment&, const Parameters&) {}
    640 	};
    641 
    642 	static deUint32 getMaxConcurrent (Context& context, const Parameters& params)
    643 	{
    644 		const Environment			env		(context, 1u);
    645 		const Resources				res		(env, params);
    646 		const Unique<VkBuffer>		buffer	(create(env, res, params));
    647 		const VkMemoryRequirements	memReqs	= getBufferMemoryRequirements(env.vkd, env.device, *buffer);
    648 
    649 		return getSafeObjectCount<Buffer>(context,
    650 										  params,
    651 										  DEFAULT_MAX_CONCURRENT_OBJECTS,
    652 										  getPageTableSize(context, memReqs.size));
    653 	}
    654 
    655 	static Move<VkBuffer> create (const Environment& env, const Resources&, const Parameters& params)
    656 	{
    657 		const VkBufferCreateInfo	bufferInfo	=
    658 		{
    659 			VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
    660 			DE_NULL,
    661 			(VkBufferCreateFlags)0,
    662 			params.size,
    663 			params.usage,
    664 			VK_SHARING_MODE_EXCLUSIVE,
    665 			1u,
    666 			&env.queueFamilyIndex
    667 		};
    668 
    669 		return createBuffer(env.vkd, env.device, &bufferInfo, env.allocationCallbacks);
    670 	}
    671 };
    672 
    673 struct BufferView
    674 {
    675 	typedef VkBufferView Type;
    676 
    677 	struct Parameters
    678 	{
    679 		Buffer::Parameters	buffer;
    680 		VkFormat			format;
    681 		VkDeviceSize		offset;
    682 		VkDeviceSize		range;
    683 
    684 		Parameters (const Buffer::Parameters&	buffer_,
    685 					VkFormat					format_,
    686 					VkDeviceSize				offset_,
    687 					VkDeviceSize				range_)
    688 			: buffer	(buffer_)
    689 			, format	(format_)
    690 			, offset	(offset_)
    691 			, range		(range_)
    692 		{}
    693 	};
    694 
    695 	struct Resources
    696 	{
    697 		Dependency<Buffer>			buffer;
    698 		Dependency<DeviceMemory>	memory;
    699 
    700 		Resources (const Environment& env, const Parameters& params)
    701 			: buffer(env, params.buffer)
    702 			, memory(env, getDeviceMemoryParameters(env, *buffer.object))
    703 		{
    704 			VK_CHECK(env.vkd.bindBufferMemory(env.device, *buffer.object, *memory.object, 0));
    705 		}
    706 	};
    707 
    708 	static deUint32 getMaxConcurrent (Context& context, const Parameters& params)
    709 	{
    710 		return getSafeObjectCount<BufferView>(context, params, DEFAULT_MAX_CONCURRENT_OBJECTS);
    711 	}
    712 
    713 	static Move<VkBufferView> create (const Environment& env, const Resources& res, const Parameters& params)
    714 	{
    715 		const VkBufferViewCreateInfo	bufferViewInfo	=
    716 		{
    717 			VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO,
    718 			DE_NULL,
    719 			(VkBufferViewCreateFlags)0,
    720 			*res.buffer.object,
    721 			params.format,
    722 			params.offset,
    723 			params.range
    724 		};
    725 
    726 		return createBufferView(env.vkd, env.device, &bufferViewInfo, env.allocationCallbacks);
    727 	}
    728 };
    729 
    730 struct Image
    731 {
    732 	typedef VkImage Type;
    733 
    734 	struct Parameters
    735 	{
    736 		VkImageCreateFlags		flags;
    737 		VkImageType				imageType;
    738 		VkFormat				format;
    739 		VkExtent3D				extent;
    740 		deUint32				mipLevels;
    741 		deUint32				arraySize;
    742 		VkSampleCountFlagBits	samples;
    743 		VkImageTiling			tiling;
    744 		VkImageUsageFlags		usage;
    745 		VkImageLayout			initialLayout;
    746 
    747 		Parameters (VkImageCreateFlags		flags_,
    748 					VkImageType				imageType_,
    749 					VkFormat				format_,
    750 					VkExtent3D				extent_,
    751 					deUint32				mipLevels_,
    752 					deUint32				arraySize_,
    753 					VkSampleCountFlagBits	samples_,
    754 					VkImageTiling			tiling_,
    755 					VkImageUsageFlags		usage_,
    756 					VkImageLayout			initialLayout_)
    757 			: flags			(flags_)
    758 			, imageType		(imageType_)
    759 			, format		(format_)
    760 			, extent		(extent_)
    761 			, mipLevels		(mipLevels_)
    762 			, arraySize		(arraySize_)
    763 			, samples		(samples_)
    764 			, tiling		(tiling_)
    765 			, usage			(usage_)
    766 			, initialLayout	(initialLayout_)
    767 		{}
    768 	};
    769 
    770 	struct Resources
    771 	{
    772 		Resources (const Environment&, const Parameters&) {}
    773 	};
    774 
    775 	static deUint32 getMaxConcurrent (Context& context, const Parameters& params)
    776 	{
    777 		const Environment			env		(context, 1u);
    778 		const Resources				res		(env, params);
    779 		const Unique<VkImage>		image	(create(env, res, params));
    780 		const VkMemoryRequirements	memReqs	= getImageMemoryRequirements(env.vkd, env.device, *image);
    781 
    782 		return getSafeObjectCount<Image>(context,
    783 										 params,
    784 										 DEFAULT_MAX_CONCURRENT_OBJECTS,
    785 										 getPageTableSize(context, memReqs.size));
    786 	}
    787 
    788 	static Move<VkImage> create (const Environment& env, const Resources&, const Parameters& params)
    789 	{
    790 		const VkImageCreateInfo		imageInfo	=
    791 		{
    792 			VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
    793 			DE_NULL,
    794 			params.flags,
    795 			params.imageType,
    796 			params.format,
    797 			params.extent,
    798 			params.mipLevels,
    799 			params.arraySize,
    800 			params.samples,
    801 			params.tiling,
    802 			params.usage,
    803 			VK_SHARING_MODE_EXCLUSIVE,		// sharingMode
    804 			1u,								// queueFamilyIndexCount
    805 			&env.queueFamilyIndex,			// pQueueFamilyIndices
    806 			params.initialLayout
    807 		};
    808 
    809 		return createImage(env.vkd, env.device, &imageInfo, env.allocationCallbacks);
    810 	}
    811 };
    812 
    813 struct ImageView
    814 {
    815 	typedef VkImageView Type;
    816 
    817 	struct Parameters
    818 	{
    819 		Image::Parameters		image;
    820 		VkImageViewType			viewType;
    821 		VkFormat				format;
    822 		VkComponentMapping		components;
    823 		VkImageSubresourceRange	subresourceRange;
    824 
    825 		Parameters (const Image::Parameters&	image_,
    826 					VkImageViewType				viewType_,
    827 					VkFormat					format_,
    828 					VkComponentMapping			components_,
    829 					VkImageSubresourceRange		subresourceRange_)
    830 			: image				(image_)
    831 			, viewType			(viewType_)
    832 			, format			(format_)
    833 			, components		(components_)
    834 			, subresourceRange	(subresourceRange_)
    835 		{}
    836 	};
    837 
    838 	struct Resources
    839 	{
    840 		Dependency<Image>			image;
    841 		Dependency<DeviceMemory>	memory;
    842 
    843 		Resources (const Environment& env, const Parameters& params)
    844 			: image	(env, params.image)
    845 			, memory(env, getDeviceMemoryParameters(env, *image.object))
    846 		{
    847 			VK_CHECK(env.vkd.bindImageMemory(env.device, *image.object, *memory.object, 0));
    848 		}
    849 	};
    850 
    851 	static deUint32 getMaxConcurrent (Context& context, const Parameters& params)
    852 	{
    853 		return getSafeObjectCount<ImageView>(context, params, DEFAULT_MAX_CONCURRENT_OBJECTS);
    854 	}
    855 
    856 	static Move<VkImageView> create (const Environment& env, const Resources& res, const Parameters& params)
    857 	{
    858 		const VkImageViewCreateInfo	imageViewInfo	=
    859 		{
    860 			VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
    861 			DE_NULL,
    862 			(VkImageViewCreateFlags)0,
    863 			*res.image.object,
    864 			params.viewType,
    865 			params.format,
    866 			params.components,
    867 			params.subresourceRange,
    868 		};
    869 
    870 		return createImageView(env.vkd, env.device, &imageViewInfo, env.allocationCallbacks);
    871 	}
    872 };
    873 
    874 struct Semaphore
    875 {
    876 	typedef VkSemaphore Type;
    877 
    878 	struct Parameters
    879 	{
    880 		VkSemaphoreCreateFlags	flags;
    881 
    882 		Parameters (VkSemaphoreCreateFlags flags_)
    883 			: flags(flags_)
    884 		{}
    885 	};
    886 
    887 	struct Resources
    888 	{
    889 		Resources (const Environment&, const Parameters&) {}
    890 	};
    891 
    892 	static deUint32 getMaxConcurrent (Context& context, const Parameters& params)
    893 	{
    894 		return getSafeObjectCount<Semaphore>(context, params, MAX_CONCURRENT_SYNC_PRIMITIVES);
    895 	}
    896 
    897 	static Move<VkSemaphore> create (const Environment& env, const Resources&, const Parameters& params)
    898 	{
    899 		const VkSemaphoreCreateInfo	semaphoreInfo	=
    900 		{
    901 			VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
    902 			DE_NULL,
    903 			params.flags
    904 		};
    905 
    906 		return createSemaphore(env.vkd, env.device, &semaphoreInfo, env.allocationCallbacks);
    907 	}
    908 };
    909 
    910 struct Fence
    911 {
    912 	typedef VkFence Type;
    913 
    914 	struct Parameters
    915 	{
    916 		VkFenceCreateFlags	flags;
    917 
    918 		Parameters (VkFenceCreateFlags flags_)
    919 			: flags(flags_)
    920 		{}
    921 	};
    922 
    923 	struct Resources
    924 	{
    925 		Resources (const Environment&, const Parameters&) {}
    926 	};
    927 
    928 	static deUint32 getMaxConcurrent (Context& context, const Parameters& params)
    929 	{
    930 		return getSafeObjectCount<Fence>(context, params, MAX_CONCURRENT_SYNC_PRIMITIVES);
    931 	}
    932 
    933 	static Move<VkFence> create (const Environment& env, const Resources&, const Parameters& params)
    934 	{
    935 		const VkFenceCreateInfo	fenceInfo	=
    936 		{
    937 			VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
    938 			DE_NULL,
    939 			params.flags
    940 		};
    941 
    942 		return createFence(env.vkd, env.device, &fenceInfo, env.allocationCallbacks);
    943 	}
    944 };
    945 
    946 struct Event
    947 {
    948 	typedef VkEvent Type;
    949 
    950 	struct Parameters
    951 	{
    952 		VkEventCreateFlags	flags;
    953 
    954 		Parameters (VkEventCreateFlags flags_)
    955 			: flags(flags_)
    956 		{}
    957 	};
    958 
    959 	struct Resources
    960 	{
    961 		Resources (const Environment&, const Parameters&) {}
    962 	};
    963 
    964 	static deUint32 getMaxConcurrent (Context& context, const Parameters& params)
    965 	{
    966 		return getSafeObjectCount<Event>(context, params, MAX_CONCURRENT_SYNC_PRIMITIVES);
    967 	}
    968 
    969 	static Move<VkEvent> create (const Environment& env, const Resources&, const Parameters& params)
    970 	{
    971 		const VkEventCreateInfo	eventInfo	=
    972 		{
    973 			VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
    974 			DE_NULL,
    975 			params.flags
    976 		};
    977 
    978 		return createEvent(env.vkd, env.device, &eventInfo, env.allocationCallbacks);
    979 	}
    980 };
    981 
    982 struct QueryPool
    983 {
    984 	typedef VkQueryPool Type;
    985 
    986 	struct Parameters
    987 	{
    988 		VkQueryType						queryType;
    989 		deUint32						entryCount;
    990 		VkQueryPipelineStatisticFlags	pipelineStatistics;
    991 
    992 		Parameters (VkQueryType						queryType_,
    993 					deUint32						entryCount_,
    994 					VkQueryPipelineStatisticFlags	pipelineStatistics_)
    995 			: queryType				(queryType_)
    996 			, entryCount			(entryCount_)
    997 			, pipelineStatistics	(pipelineStatistics_)
    998 		{}
    999 	};
   1000 
   1001 	struct Resources
   1002 	{
   1003 		Resources (const Environment&, const Parameters&) {}
   1004 	};
   1005 
   1006 	static deUint32 getMaxConcurrent (Context& context, const Parameters& params)
   1007 	{
   1008 		return getSafeObjectCount<QueryPool>(context, params, DEFAULT_MAX_CONCURRENT_OBJECTS);
   1009 	}
   1010 
   1011 	static Move<VkQueryPool> create (const Environment& env, const Resources&, const Parameters& params)
   1012 	{
   1013 		const VkQueryPoolCreateInfo	queryPoolInfo	=
   1014 		{
   1015 			VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,
   1016 			DE_NULL,
   1017 			(VkQueryPoolCreateFlags)0,
   1018 			params.queryType,
   1019 			params.entryCount,
   1020 			params.pipelineStatistics
   1021 		};
   1022 
   1023 		return createQueryPool(env.vkd, env.device, &queryPoolInfo, env.allocationCallbacks);
   1024 	}
   1025 };
   1026 
   1027 struct ShaderModule
   1028 {
   1029 	typedef VkShaderModule Type;
   1030 
   1031 	struct Parameters
   1032 	{
   1033 		VkShaderStageFlagBits	shaderStage;
   1034 		string					binaryName;
   1035 
   1036 		Parameters (VkShaderStageFlagBits	shaderStage_,
   1037 					const std::string&		binaryName_)
   1038 			: shaderStage	(shaderStage_)
   1039 			, binaryName	(binaryName_)
   1040 		{}
   1041 	};
   1042 
   1043 	struct Resources
   1044 	{
   1045 		const ProgramBinary&	binary;
   1046 
   1047 		Resources (const Environment& env, const Parameters& params)
   1048 			: binary(env.programBinaries.get(params.binaryName))
   1049 		{}
   1050 	};
   1051 
   1052 	static deUint32 getMaxConcurrent (Context& context, const Parameters& params)
   1053 	{
   1054 		return getSafeObjectCount<ShaderModule>(context, params, DEFAULT_MAX_CONCURRENT_OBJECTS);
   1055 	}
   1056 
   1057 	static const char* getSource (VkShaderStageFlagBits stage)
   1058 	{
   1059 		switch (stage)
   1060 		{
   1061 			case VK_SHADER_STAGE_VERTEX_BIT:
   1062 				return "#version 310 es\n"
   1063 					   "layout(location = 0) in highp vec4 a_position;\n"
   1064 					   "void main () { gl_Position = a_position; }\n";
   1065 
   1066 			case VK_SHADER_STAGE_FRAGMENT_BIT:
   1067 				return "#version 310 es\n"
   1068 					   "layout(location = 0) out mediump vec4 o_color;\n"
   1069 					   "void main () { o_color = vec4(1.0, 0.5, 0.25, 1.0); }";
   1070 
   1071 			case VK_SHADER_STAGE_COMPUTE_BIT:
   1072 				return "#version 310 es\n"
   1073 					   "layout(binding = 0) buffer Input { highp uint dataIn[]; };\n"
   1074 					   "layout(binding = 1) buffer Output { highp uint dataOut[]; };\n"
   1075 					   "void main (void)\n"
   1076 					   "{\n"
   1077 					   "	dataOut[gl_GlobalInvocationID.x] = ~dataIn[gl_GlobalInvocationID.x];\n"
   1078 					   "}\n";
   1079 
   1080 			default:
   1081 				DE_FATAL("Not implemented");
   1082 				return DE_NULL;
   1083 		}
   1084 	}
   1085 
   1086 	static void initPrograms (SourceCollections& dst, Parameters params)
   1087 	{
   1088 		const char* const	source	= getSource(params.shaderStage);
   1089 
   1090 		DE_ASSERT(source);
   1091 
   1092 		dst.glslSources.add(params.binaryName)
   1093 			<< glu::ShaderSource(getGluShaderType(params.shaderStage), source);
   1094 	}
   1095 
   1096 	static Move<VkShaderModule> create (const Environment& env, const Resources& res, const Parameters&)
   1097 	{
   1098 		const VkShaderModuleCreateInfo	shaderModuleInfo	=
   1099 		{
   1100 			VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
   1101 			DE_NULL,
   1102 			(VkShaderModuleCreateFlags)0,
   1103 			res.binary.getSize(),
   1104 			(const deUint32*)res.binary.getBinary(),
   1105 		};
   1106 
   1107 		return createShaderModule(env.vkd, env.device, &shaderModuleInfo, env.allocationCallbacks);
   1108 	}
   1109 };
   1110 
   1111 struct PipelineCache
   1112 {
   1113 	typedef VkPipelineCache Type;
   1114 
   1115 	struct Parameters
   1116 	{
   1117 		Parameters (void) {}
   1118 	};
   1119 
   1120 	struct Resources
   1121 	{
   1122 		Resources (const Environment&, const Parameters&) {}
   1123 	};
   1124 
   1125 	static deUint32 getMaxConcurrent (Context& context, const Parameters& params)
   1126 	{
   1127 		return getSafeObjectCount<PipelineCache>(context, params, DEFAULT_MAX_CONCURRENT_OBJECTS);
   1128 	}
   1129 
   1130 	static Move<VkPipelineCache> create (const Environment& env, const Resources&, const Parameters&)
   1131 	{
   1132 		const VkPipelineCacheCreateInfo	pipelineCacheInfo	=
   1133 		{
   1134 			VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO,
   1135 			DE_NULL,
   1136 			(VkPipelineCacheCreateFlags)0u,
   1137 			0u,								// initialDataSize
   1138 			DE_NULL,						// pInitialData
   1139 		};
   1140 
   1141 		return createPipelineCache(env.vkd, env.device, &pipelineCacheInfo, env.allocationCallbacks);
   1142 	}
   1143 };
   1144 
   1145 struct Sampler
   1146 {
   1147 	typedef VkSampler Type;
   1148 
   1149 	struct Parameters
   1150 	{
   1151 		VkFilter				magFilter;
   1152 		VkFilter				minFilter;
   1153 		VkSamplerMipmapMode		mipmapMode;
   1154 		VkSamplerAddressMode	addressModeU;
   1155 		VkSamplerAddressMode	addressModeV;
   1156 		VkSamplerAddressMode	addressModeW;
   1157 		float					mipLodBias;
   1158 		VkBool32				anisotropyEnable;
   1159 		float					maxAnisotropy;
   1160 		VkBool32				compareEnable;
   1161 		VkCompareOp				compareOp;
   1162 		float					minLod;
   1163 		float					maxLod;
   1164 		VkBorderColor			borderColor;
   1165 		VkBool32				unnormalizedCoordinates;
   1166 
   1167 		// \todo [2015-09-17 pyry] Other configurations
   1168 		Parameters (void)
   1169 			: magFilter					(VK_FILTER_NEAREST)
   1170 			, minFilter					(VK_FILTER_NEAREST)
   1171 			, mipmapMode				(VK_SAMPLER_MIPMAP_MODE_NEAREST)
   1172 			, addressModeU				(VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE)
   1173 			, addressModeV				(VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE)
   1174 			, addressModeW				(VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE)
   1175 			, mipLodBias				(0.0f)
   1176 			, anisotropyEnable			(VK_FALSE)
   1177 			, maxAnisotropy				(1.0f)
   1178 			, compareEnable				(VK_FALSE)
   1179 			, compareOp					(VK_COMPARE_OP_ALWAYS)
   1180 			, minLod					(-1000.f)
   1181 			, maxLod					(+1000.f)
   1182 			, borderColor				(VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK)
   1183 			, unnormalizedCoordinates	(VK_FALSE)
   1184 		{}
   1185 	};
   1186 
   1187 	struct Resources
   1188 	{
   1189 		Resources (const Environment&, const Parameters&) {}
   1190 	};
   1191 
   1192 	static deUint32 getMaxConcurrent (Context& context, const Parameters& params)
   1193 	{
   1194 		return getSafeObjectCount<Sampler>(context,
   1195 										   params,
   1196 										   de::min(context.getDeviceProperties().limits.maxSamplerAllocationCount,
   1197 												   (deUint32)DEFAULT_MAX_CONCURRENT_OBJECTS));
   1198 	}
   1199 
   1200 	static Move<VkSampler> create (const Environment& env, const Resources&, const Parameters& params)
   1201 	{
   1202 		const VkSamplerCreateInfo	samplerInfo	=
   1203 		{
   1204 			VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
   1205 			DE_NULL,
   1206 			(VkSamplerCreateFlags)0,
   1207 			params.magFilter,
   1208 			params.minFilter,
   1209 			params.mipmapMode,
   1210 			params.addressModeU,
   1211 			params.addressModeV,
   1212 			params.addressModeW,
   1213 			params.mipLodBias,
   1214 			params.anisotropyEnable,
   1215 			params.maxAnisotropy,
   1216 			params.compareEnable,
   1217 			params.compareOp,
   1218 			params.minLod,
   1219 			params.maxLod,
   1220 			params.borderColor,
   1221 			params.unnormalizedCoordinates
   1222 		};
   1223 
   1224 		return createSampler(env.vkd, env.device, &samplerInfo, env.allocationCallbacks);
   1225 	}
   1226 };
   1227 
   1228 struct DescriptorSetLayout
   1229 {
   1230 	typedef VkDescriptorSetLayout Type;
   1231 
   1232 	struct Parameters
   1233 	{
   1234 		struct Binding
   1235 		{
   1236 			deUint32			binding;
   1237 			VkDescriptorType	descriptorType;
   1238 			deUint32			descriptorCount;
   1239 			VkShaderStageFlags	stageFlags;
   1240 			bool				useImmutableSampler;
   1241 
   1242 			Binding (deUint32			binding_,
   1243 					 VkDescriptorType	descriptorType_,
   1244 					 deUint32			descriptorCount_,
   1245 					 VkShaderStageFlags	stageFlags_,
   1246 					 bool				useImmutableSampler_)
   1247 				: binding				(binding_)
   1248 				, descriptorType		(descriptorType_)
   1249 				, descriptorCount		(descriptorCount_)
   1250 				, stageFlags			(stageFlags_)
   1251 				, useImmutableSampler	(useImmutableSampler_)
   1252 			{}
   1253 
   1254 			Binding (void) {}
   1255 		};
   1256 
   1257 		vector<Binding>	bindings;
   1258 
   1259 		Parameters (const vector<Binding>& bindings_)
   1260 			: bindings(bindings_)
   1261 		{}
   1262 
   1263 		static Parameters empty (void)
   1264 		{
   1265 			return Parameters(vector<Binding>());
   1266 		}
   1267 
   1268 		static Parameters single (deUint32				binding,
   1269 								  VkDescriptorType		descriptorType,
   1270 								  deUint32				descriptorCount,
   1271 								  VkShaderStageFlags	stageFlags,
   1272 								  bool					useImmutableSampler = false)
   1273 		{
   1274 			vector<Binding> bindings;
   1275 			bindings.push_back(Binding(binding, descriptorType, descriptorCount, stageFlags, useImmutableSampler));
   1276 			return Parameters(bindings);
   1277 		}
   1278 	};
   1279 
   1280 	struct Resources
   1281 	{
   1282 		vector<VkDescriptorSetLayoutBinding>	bindings;
   1283 		MovePtr<Dependency<Sampler> >			immutableSampler;
   1284 		vector<VkSampler>						immutableSamplersPtr;
   1285 
   1286 		Resources (const Environment& env, const Parameters& params)
   1287 		{
   1288 			// Create immutable sampler if needed
   1289 			for (vector<Parameters::Binding>::const_iterator cur = params.bindings.begin(); cur != params.bindings.end(); cur++)
   1290 			{
   1291 				if (cur->useImmutableSampler && !immutableSampler)
   1292 				{
   1293 					immutableSampler = de::newMovePtr<Dependency<Sampler> >(env, Sampler::Parameters());
   1294 
   1295 					if (cur->useImmutableSampler && immutableSamplersPtr.size() < (size_t)cur->descriptorCount)
   1296 						immutableSamplersPtr.resize(cur->descriptorCount, *immutableSampler->object);
   1297 				}
   1298 			}
   1299 
   1300 			for (vector<Parameters::Binding>::const_iterator cur = params.bindings.begin(); cur != params.bindings.end(); cur++)
   1301 			{
   1302 				const VkDescriptorSetLayoutBinding	binding	=
   1303 				{
   1304 					cur->binding,
   1305 					cur->descriptorType,
   1306 					cur->descriptorCount,
   1307 					cur->stageFlags,
   1308 					(cur->useImmutableSampler ? &immutableSamplersPtr[0] : DE_NULL)
   1309 				};
   1310 
   1311 				bindings.push_back(binding);
   1312 			}
   1313 		}
   1314 	};
   1315 
   1316 	static deUint32 getMaxConcurrent (Context& context, const Parameters& params)
   1317 	{
   1318 		return getSafeObjectCount<DescriptorSetLayout>(context, params, DEFAULT_MAX_CONCURRENT_OBJECTS);
   1319 	}
   1320 
   1321 	static Move<VkDescriptorSetLayout> create (const Environment& env, const Resources& res, const Parameters&)
   1322 	{
   1323 		const VkDescriptorSetLayoutCreateInfo	descriptorSetLayoutInfo	=
   1324 		{
   1325 			VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
   1326 			DE_NULL,
   1327 			(VkDescriptorSetLayoutCreateFlags)0,
   1328 			(deUint32)res.bindings.size(),
   1329 			(res.bindings.empty() ? DE_NULL : &res.bindings[0])
   1330 		};
   1331 
   1332 		return createDescriptorSetLayout(env.vkd, env.device, &descriptorSetLayoutInfo, env.allocationCallbacks);
   1333 	}
   1334 };
   1335 
   1336 struct PipelineLayout
   1337 {
   1338 	typedef VkPipelineLayout Type;
   1339 
   1340 	struct Parameters
   1341 	{
   1342 		vector<DescriptorSetLayout::Parameters>	descriptorSetLayouts;
   1343 		vector<VkPushConstantRange>				pushConstantRanges;
   1344 
   1345 		Parameters (void) {}
   1346 
   1347 		static Parameters empty (void)
   1348 		{
   1349 			return Parameters();
   1350 		}
   1351 
   1352 		static Parameters singleDescriptorSet (const DescriptorSetLayout::Parameters& descriptorSetLayout)
   1353 		{
   1354 			Parameters params;
   1355 			params.descriptorSetLayouts.push_back(descriptorSetLayout);
   1356 			return params;
   1357 		}
   1358 	};
   1359 
   1360 	struct Resources
   1361 	{
   1362 		typedef SharedPtr<Dependency<DescriptorSetLayout> >	DescriptorSetLayoutDepSp;
   1363 		typedef vector<DescriptorSetLayoutDepSp>			DescriptorSetLayouts;
   1364 
   1365 		DescriptorSetLayouts			descriptorSetLayouts;
   1366 		vector<VkDescriptorSetLayout>	pSetLayouts;
   1367 
   1368 		Resources (const Environment& env, const Parameters& params)
   1369 		{
   1370 			for (vector<DescriptorSetLayout::Parameters>::const_iterator dsParams = params.descriptorSetLayouts.begin();
   1371 				 dsParams != params.descriptorSetLayouts.end();
   1372 				 ++dsParams)
   1373 			{
   1374 				descriptorSetLayouts.push_back(DescriptorSetLayoutDepSp(new Dependency<DescriptorSetLayout>(env, *dsParams)));
   1375 				pSetLayouts.push_back(*descriptorSetLayouts.back()->object);
   1376 			}
   1377 		}
   1378 	};
   1379 
   1380 	static deUint32 getMaxConcurrent (Context& context, const Parameters& params)
   1381 	{
   1382 		return getSafeObjectCount<PipelineLayout>(context, params, DEFAULT_MAX_CONCURRENT_OBJECTS);
   1383 	}
   1384 
   1385 	static Move<VkPipelineLayout> create (const Environment& env, const Resources& res, const Parameters& params)
   1386 	{
   1387 		const VkPipelineLayoutCreateInfo	pipelineLayoutInfo	=
   1388 		{
   1389 			VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
   1390 			DE_NULL,
   1391 			(VkPipelineLayoutCreateFlags)0,
   1392 			(deUint32)res.pSetLayouts.size(),
   1393 			(res.pSetLayouts.empty() ? DE_NULL : &res.pSetLayouts[0]),
   1394 			(deUint32)params.pushConstantRanges.size(),
   1395 			(params.pushConstantRanges.empty() ? DE_NULL : &params.pushConstantRanges[0]),
   1396 		};
   1397 
   1398 		return createPipelineLayout(env.vkd, env.device, &pipelineLayoutInfo, env.allocationCallbacks);
   1399 	}
   1400 };
   1401 
   1402 struct RenderPass
   1403 {
   1404 	typedef VkRenderPass Type;
   1405 
   1406 	// \todo [2015-09-17 pyry] More interesting configurations
   1407 	struct Parameters
   1408 	{
   1409 		Parameters (void) {}
   1410 	};
   1411 
   1412 	struct Resources
   1413 	{
   1414 		Resources (const Environment&, const Parameters&) {}
   1415 	};
   1416 
   1417 	static deUint32 getMaxConcurrent (Context& context, const Parameters& params)
   1418 	{
   1419 		return getSafeObjectCount<RenderPass>(context, params, DEFAULT_MAX_CONCURRENT_OBJECTS);
   1420 	}
   1421 
   1422 	static Move<VkRenderPass> create (const Environment& env, const Resources&, const Parameters&)
   1423 	{
   1424 		const VkAttachmentDescription	attachments[]		=
   1425 		{
   1426 			{
   1427 				(VkAttachmentDescriptionFlags)0,
   1428 				VK_FORMAT_R8G8B8A8_UNORM,
   1429 				VK_SAMPLE_COUNT_1_BIT,
   1430 				VK_ATTACHMENT_LOAD_OP_CLEAR,
   1431 				VK_ATTACHMENT_STORE_OP_STORE,
   1432 				VK_ATTACHMENT_LOAD_OP_DONT_CARE,
   1433 				VK_ATTACHMENT_STORE_OP_DONT_CARE,
   1434 				VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
   1435 				VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
   1436 			},
   1437 			{
   1438 				(VkAttachmentDescriptionFlags)0,
   1439 				VK_FORMAT_D16_UNORM,
   1440 				VK_SAMPLE_COUNT_1_BIT,
   1441 				VK_ATTACHMENT_LOAD_OP_CLEAR,
   1442 				VK_ATTACHMENT_STORE_OP_DONT_CARE,
   1443 				VK_ATTACHMENT_LOAD_OP_DONT_CARE,
   1444 				VK_ATTACHMENT_STORE_OP_DONT_CARE,
   1445 				VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
   1446 				VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
   1447 			}
   1448 		};
   1449 		const VkAttachmentReference		colorAttachments[]	=
   1450 		{
   1451 			{
   1452 				0u,											// attachment
   1453 				VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
   1454 			}
   1455 		};
   1456 		const VkAttachmentReference		dsAttachment		=
   1457 		{
   1458 			1u,											// attachment
   1459 			VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
   1460 		};
   1461 		const VkSubpassDescription		subpasses[]			=
   1462 		{
   1463 			{
   1464 				(VkSubpassDescriptionFlags)0,
   1465 				VK_PIPELINE_BIND_POINT_GRAPHICS,
   1466 				0u,											// inputAttachmentCount
   1467 				DE_NULL,									// pInputAttachments
   1468 				DE_LENGTH_OF_ARRAY(colorAttachments),
   1469 				colorAttachments,
   1470 				DE_NULL,									// pResolveAttachments
   1471 				&dsAttachment,
   1472 				0u,											// preserveAttachmentCount
   1473 				DE_NULL,									// pPreserveAttachments
   1474 			}
   1475 		};
   1476 		const VkRenderPassCreateInfo	renderPassInfo		=
   1477 		{
   1478 			VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
   1479 			DE_NULL,
   1480 			(VkRenderPassCreateFlags)0,
   1481 			DE_LENGTH_OF_ARRAY(attachments),
   1482 			attachments,
   1483 			DE_LENGTH_OF_ARRAY(subpasses),
   1484 			subpasses,
   1485 			0u,												// dependencyCount
   1486 			DE_NULL											// pDependencies
   1487 		};
   1488 
   1489 		return createRenderPass(env.vkd, env.device, &renderPassInfo, env.allocationCallbacks);
   1490 	}
   1491 };
   1492 
   1493 struct GraphicsPipeline
   1494 {
   1495 	typedef VkPipeline Type;
   1496 
   1497 	// \todo [2015-09-17 pyry] More interesting configurations
   1498 	struct Parameters
   1499 	{
   1500 		Parameters (void) {}
   1501 	};
   1502 
   1503 	struct Resources
   1504 	{
   1505 		Dependency<ShaderModule>	vertexShader;
   1506 		Dependency<ShaderModule>	fragmentShader;
   1507 		Dependency<PipelineLayout>	layout;
   1508 		Dependency<RenderPass>		renderPass;
   1509 		Dependency<PipelineCache>	pipelineCache;
   1510 
   1511 		Resources (const Environment& env, const Parameters&)
   1512 			: vertexShader		(env, ShaderModule::Parameters(VK_SHADER_STAGE_VERTEX_BIT, "vert"))
   1513 			, fragmentShader	(env, ShaderModule::Parameters(VK_SHADER_STAGE_FRAGMENT_BIT, "frag"))
   1514 			, layout			(env, PipelineLayout::Parameters::singleDescriptorSet(
   1515 										DescriptorSetLayout::Parameters::single(0u, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1u, VK_SHADER_STAGE_FRAGMENT_BIT, true)))
   1516 			, renderPass		(env, RenderPass::Parameters())
   1517 			, pipelineCache		(env, PipelineCache::Parameters())
   1518 		{}
   1519 	};
   1520 
   1521 	static deUint32 getMaxConcurrent (Context& context, const Parameters& params)
   1522 	{
   1523 		return getSafeObjectCount<GraphicsPipeline>(context, params, DEFAULT_MAX_CONCURRENT_OBJECTS);
   1524 	}
   1525 
   1526 	static void initPrograms (SourceCollections& dst, Parameters)
   1527 	{
   1528 		ShaderModule::initPrograms(dst, ShaderModule::Parameters(VK_SHADER_STAGE_VERTEX_BIT, "vert"));
   1529 		ShaderModule::initPrograms(dst, ShaderModule::Parameters(VK_SHADER_STAGE_FRAGMENT_BIT, "frag"));
   1530 	}
   1531 
   1532 	static Move<VkPipeline> create (const Environment& env, const Resources& res, const Parameters&)
   1533 	{
   1534 		const VkPipelineShaderStageCreateInfo			stages[]			=
   1535 		{
   1536 			{
   1537 				VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
   1538 				DE_NULL,
   1539 				(VkPipelineShaderStageCreateFlags)0,
   1540 				VK_SHADER_STAGE_VERTEX_BIT,
   1541 				*res.vertexShader.object,
   1542 				"main",
   1543 				DE_NULL,							// pSpecializationInfo
   1544 			},
   1545 			{
   1546 				VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
   1547 				DE_NULL,
   1548 				(VkPipelineShaderStageCreateFlags)0,
   1549 				VK_SHADER_STAGE_FRAGMENT_BIT,
   1550 				*res.fragmentShader.object,
   1551 				"main",
   1552 				DE_NULL,							// pSpecializationInfo
   1553 			}
   1554 		};
   1555 		const VkVertexInputBindingDescription			vertexBindings[]	=
   1556 		{
   1557 			{
   1558 				0u,									// binding
   1559 				16u,								// stride
   1560 				VK_VERTEX_INPUT_RATE_VERTEX
   1561 			}
   1562 		};
   1563 		const VkVertexInputAttributeDescription			vertexAttribs[]		=
   1564 		{
   1565 			{
   1566 				0u,									// location
   1567 				0u,									// binding
   1568 				VK_FORMAT_R32G32B32A32_SFLOAT,
   1569 				0u,									// offset
   1570 			}
   1571 		};
   1572 		const VkPipelineVertexInputStateCreateInfo		vertexInputState	=
   1573 		{
   1574 			VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
   1575 			DE_NULL,
   1576 			(VkPipelineVertexInputStateCreateFlags)0,
   1577 			DE_LENGTH_OF_ARRAY(vertexBindings),
   1578 			vertexBindings,
   1579 			DE_LENGTH_OF_ARRAY(vertexAttribs),
   1580 			vertexAttribs
   1581 		};
   1582 		const VkPipelineInputAssemblyStateCreateInfo	inputAssemblyState	=
   1583 		{
   1584 			VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
   1585 			DE_NULL,
   1586 			(VkPipelineInputAssemblyStateCreateFlags)0,
   1587 			VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
   1588 			VK_FALSE								// primitiveRestartEnable
   1589 		};
   1590 		const VkViewport								viewports[]			=
   1591 		{
   1592 			{ 0.0f, 0.0f, 64.f, 64.f, 0.0f, 1.0f }
   1593 		};
   1594 		const VkRect2D									scissors[]			=
   1595 		{
   1596 			{ { 0, 0 }, { 64, 64 } }
   1597 		};
   1598 		const VkPipelineViewportStateCreateInfo			viewportState		=
   1599 		{
   1600 			VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
   1601 			DE_NULL,
   1602 			(VkPipelineViewportStateCreateFlags)0,
   1603 			DE_LENGTH_OF_ARRAY(viewports),
   1604 			viewports,
   1605 			DE_LENGTH_OF_ARRAY(scissors),
   1606 			scissors,
   1607 		};
   1608 		const VkPipelineRasterizationStateCreateInfo	rasterState			=
   1609 		{
   1610 			VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
   1611 			DE_NULL,
   1612 			(VkPipelineRasterizationStateCreateFlags)0,
   1613 			VK_TRUE,								// depthClampEnable
   1614 			VK_FALSE,								// rasterizerDiscardEnable
   1615 			VK_POLYGON_MODE_FILL,
   1616 			VK_CULL_MODE_BACK_BIT,
   1617 			VK_FRONT_FACE_COUNTER_CLOCKWISE,
   1618 			VK_FALSE,								// depthBiasEnable
   1619 			0.0f,									// depthBiasConstantFactor
   1620 			0.0f,									// depthBiasClamp
   1621 			0.0f,									// depthBiasSlopeFactor
   1622 			1.0f,									// lineWidth
   1623 		};
   1624 		const VkPipelineMultisampleStateCreateInfo		multisampleState	=
   1625 		{
   1626 			VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
   1627 			DE_NULL,
   1628 			(VkPipelineMultisampleStateCreateFlags)0,
   1629 			VK_SAMPLE_COUNT_1_BIT,
   1630 			VK_FALSE,								// sampleShadingEnable
   1631 			1.0f,									// minSampleShading
   1632 			DE_NULL,								// pSampleMask
   1633 			VK_FALSE,								// alphaToCoverageEnable
   1634 			VK_FALSE,								// alphaToOneEnable
   1635 		};
   1636 		const VkPipelineDepthStencilStateCreateInfo		depthStencilState	=
   1637 		{
   1638 			VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
   1639 			DE_NULL,
   1640 			(VkPipelineDepthStencilStateCreateFlags)0,
   1641 			VK_TRUE,								// depthTestEnable
   1642 			VK_TRUE,								// depthWriteEnable
   1643 			VK_COMPARE_OP_LESS,						// depthCompareOp
   1644 			VK_FALSE,								// depthBoundsTestEnable
   1645 			VK_FALSE,								// stencilTestEnable
   1646 			{ VK_STENCIL_OP_KEEP, VK_STENCIL_OP_KEEP, VK_STENCIL_OP_KEEP, VK_COMPARE_OP_ALWAYS, 0u, 0u, 0u },
   1647 			{ VK_STENCIL_OP_KEEP, VK_STENCIL_OP_KEEP, VK_STENCIL_OP_KEEP, VK_COMPARE_OP_ALWAYS, 0u, 0u, 0u },
   1648 			0.0f,									// minDepthBounds
   1649 			1.0f,									// maxDepthBounds
   1650 		};
   1651 		const VkPipelineColorBlendAttachmentState		colorBlendAttState[]=
   1652 		{
   1653 			{
   1654 				VK_FALSE,							// blendEnable
   1655 				VK_BLEND_FACTOR_ONE,
   1656 				VK_BLEND_FACTOR_ZERO,
   1657 				VK_BLEND_OP_ADD,
   1658 				VK_BLEND_FACTOR_ONE,
   1659 				VK_BLEND_FACTOR_ZERO,
   1660 				VK_BLEND_OP_ADD,
   1661 				VK_COLOR_COMPONENT_R_BIT|VK_COLOR_COMPONENT_G_BIT|VK_COLOR_COMPONENT_B_BIT|VK_COLOR_COMPONENT_A_BIT
   1662 			}
   1663 		};
   1664 		const VkPipelineColorBlendStateCreateInfo		colorBlendState		=
   1665 		{
   1666 			VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
   1667 			DE_NULL,
   1668 			(VkPipelineColorBlendStateCreateFlags)0,
   1669 			VK_FALSE,								// logicOpEnable
   1670 			VK_LOGIC_OP_COPY,
   1671 			DE_LENGTH_OF_ARRAY(colorBlendAttState),
   1672 			colorBlendAttState,
   1673 			{ 0.0f, 0.0f, 0.0f, 0.0f }				// blendConstants
   1674 		};
   1675 		const VkGraphicsPipelineCreateInfo				pipelineInfo		=
   1676 		{
   1677 			VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
   1678 			DE_NULL,
   1679 			(VkPipelineCreateFlags)0,
   1680 			DE_LENGTH_OF_ARRAY(stages),
   1681 			stages,
   1682 			&vertexInputState,
   1683 			&inputAssemblyState,
   1684 			DE_NULL,								// pTessellationState
   1685 			&viewportState,
   1686 			&rasterState,
   1687 			&multisampleState,
   1688 			&depthStencilState,
   1689 			&colorBlendState,
   1690 			(const VkPipelineDynamicStateCreateInfo*)DE_NULL,
   1691 			*res.layout.object,
   1692 			*res.renderPass.object,
   1693 			0u,										// subpass
   1694 			(VkPipeline)0,							// basePipelineHandle
   1695 			0,										// basePipelineIndex
   1696 		};
   1697 
   1698 		return createGraphicsPipeline(env.vkd, env.device, *res.pipelineCache.object, &pipelineInfo, env.allocationCallbacks);
   1699 	}
   1700 };
   1701 
   1702 struct ComputePipeline
   1703 {
   1704 	typedef VkPipeline Type;
   1705 
   1706 	// \todo [2015-09-17 pyry] More interesting configurations
   1707 	struct Parameters
   1708 	{
   1709 		Parameters (void) {}
   1710 	};
   1711 
   1712 	struct Resources
   1713 	{
   1714 		Dependency<ShaderModule>	shaderModule;
   1715 		Dependency<PipelineLayout>	layout;
   1716 		Dependency<PipelineCache>	pipelineCache;
   1717 
   1718 		static DescriptorSetLayout::Parameters getDescriptorSetLayout (void)
   1719 		{
   1720 			typedef DescriptorSetLayout::Parameters::Binding Binding;
   1721 
   1722 			vector<Binding> bindings;
   1723 
   1724 			bindings.push_back(Binding(0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1u, VK_SHADER_STAGE_COMPUTE_BIT, false));
   1725 			bindings.push_back(Binding(1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1u, VK_SHADER_STAGE_COMPUTE_BIT, false));
   1726 
   1727 			return DescriptorSetLayout::Parameters(bindings);
   1728 		}
   1729 
   1730 		Resources (const Environment& env, const Parameters&)
   1731 			: shaderModule		(env, ShaderModule::Parameters(VK_SHADER_STAGE_COMPUTE_BIT, "comp"))
   1732 			, layout			(env, PipelineLayout::Parameters::singleDescriptorSet(getDescriptorSetLayout()))
   1733 			, pipelineCache		(env, PipelineCache::Parameters())
   1734 		{}
   1735 	};
   1736 
   1737 	static deUint32 getMaxConcurrent (Context& context, const Parameters& params)
   1738 	{
   1739 		return getSafeObjectCount<ComputePipeline>(context, params, DEFAULT_MAX_CONCURRENT_OBJECTS);
   1740 	}
   1741 
   1742 	static void initPrograms (SourceCollections& dst, Parameters)
   1743 	{
   1744 		ShaderModule::initPrograms(dst, ShaderModule::Parameters(VK_SHADER_STAGE_COMPUTE_BIT, "comp"));
   1745 	}
   1746 
   1747 	static Move<VkPipeline> create (const Environment& env, const Resources& res, const Parameters&)
   1748 	{
   1749 		const VkComputePipelineCreateInfo	pipelineInfo	=
   1750 		{
   1751 			VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
   1752 			DE_NULL,
   1753 			(VkPipelineCreateFlags)0,
   1754 			{
   1755 				VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
   1756 				DE_NULL,
   1757 				(VkPipelineShaderStageCreateFlags)0,
   1758 				VK_SHADER_STAGE_COMPUTE_BIT,
   1759 				*res.shaderModule.object,
   1760 				"main",
   1761 				DE_NULL					// pSpecializationInfo
   1762 			},
   1763 			*res.layout.object,
   1764 			(VkPipeline)0,				// basePipelineHandle
   1765 			0u,							// basePipelineIndex
   1766 		};
   1767 
   1768 		return createComputePipeline(env.vkd, env.device, *res.pipelineCache.object, &pipelineInfo, env.allocationCallbacks);
   1769 	}
   1770 };
   1771 
   1772 struct DescriptorPool
   1773 {
   1774 	typedef VkDescriptorPool Type;
   1775 
   1776 	struct Parameters
   1777 	{
   1778 		VkDescriptorPoolCreateFlags		flags;
   1779 		deUint32						maxSets;
   1780 		vector<VkDescriptorPoolSize>	poolSizes;
   1781 
   1782 		Parameters (VkDescriptorPoolCreateFlags				flags_,
   1783 					deUint32								maxSets_,
   1784 					const vector<VkDescriptorPoolSize>&		poolSizes_)
   1785 			: flags		(flags_)
   1786 			, maxSets	(maxSets_)
   1787 			, poolSizes	(poolSizes_)
   1788 		{}
   1789 
   1790 		static Parameters singleType (VkDescriptorPoolCreateFlags	flags,
   1791 									  deUint32						maxSets,
   1792 									  VkDescriptorType				type,
   1793 									  deUint32						count)
   1794 		{
   1795 			vector<VkDescriptorPoolSize> poolSizes;
   1796 			poolSizes.push_back(makeDescriptorPoolSize(type, count));
   1797 			return Parameters(flags, maxSets, poolSizes);
   1798 		}
   1799 	};
   1800 
   1801 	struct Resources
   1802 	{
   1803 		Resources (const Environment&, const Parameters&) {}
   1804 	};
   1805 
   1806 	static deUint32 getMaxConcurrent (Context& context, const Parameters& params)
   1807 	{
   1808 		return getSafeObjectCount<DescriptorPool>(context, params, DEFAULT_MAX_CONCURRENT_OBJECTS);
   1809 	}
   1810 
   1811 	static Move<VkDescriptorPool> create (const Environment& env, const Resources&, const Parameters& params)
   1812 	{
   1813 		const VkDescriptorPoolCreateInfo	descriptorPoolInfo	=
   1814 		{
   1815 			VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
   1816 			DE_NULL,
   1817 			params.flags,
   1818 			params.maxSets,
   1819 			(deUint32)params.poolSizes.size(),
   1820 			(params.poolSizes.empty() ? DE_NULL : &params.poolSizes[0])
   1821 		};
   1822 
   1823 		return createDescriptorPool(env.vkd, env.device, &descriptorPoolInfo, env.allocationCallbacks);
   1824 	}
   1825 };
   1826 
   1827 struct DescriptorSet
   1828 {
   1829 	typedef VkDescriptorSet Type;
   1830 
   1831 	struct Parameters
   1832 	{
   1833 		DescriptorSetLayout::Parameters	descriptorSetLayout;
   1834 
   1835 		Parameters (const DescriptorSetLayout::Parameters& descriptorSetLayout_)
   1836 			: descriptorSetLayout(descriptorSetLayout_)
   1837 		{}
   1838 	};
   1839 
   1840 	struct Resources
   1841 	{
   1842 		Dependency<DescriptorPool>		descriptorPool;
   1843 		Dependency<DescriptorSetLayout>	descriptorSetLayout;
   1844 
   1845 		static vector<VkDescriptorPoolSize> computePoolSizes (const DescriptorSetLayout::Parameters& layout, int maxSets)
   1846 		{
   1847 			deUint32						countByType[VK_DESCRIPTOR_TYPE_LAST];
   1848 			vector<VkDescriptorPoolSize>	typeCounts;
   1849 
   1850 			std::fill(DE_ARRAY_BEGIN(countByType), DE_ARRAY_END(countByType), 0u);
   1851 
   1852 			for (vector<DescriptorSetLayout::Parameters::Binding>::const_iterator cur = layout.bindings.begin();
   1853 				 cur != layout.bindings.end();
   1854 				 ++cur)
   1855 			{
   1856 				DE_ASSERT((deUint32)cur->descriptorType < VK_DESCRIPTOR_TYPE_LAST);
   1857 				countByType[cur->descriptorType] += cur->descriptorCount * maxSets;
   1858 			}
   1859 
   1860 			for (deUint32 type = 0; type < VK_DESCRIPTOR_TYPE_LAST; ++type)
   1861 			{
   1862 				if (countByType[type] > 0)
   1863 					typeCounts.push_back(makeDescriptorPoolSize((VkDescriptorType)type, countByType[type]));
   1864 			}
   1865 
   1866 			return typeCounts;
   1867 		}
   1868 
   1869 		Resources (const Environment& env, const Parameters& params)
   1870 			: descriptorPool		(env, DescriptorPool::Parameters(VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, env.maxResourceConsumers, computePoolSizes(params.descriptorSetLayout, env.maxResourceConsumers)))
   1871 			, descriptorSetLayout	(env, params.descriptorSetLayout)
   1872 		{
   1873 		}
   1874 	};
   1875 
   1876 	static deUint32 getMaxConcurrent (Context& context, const Parameters& params)
   1877 	{
   1878 		return getSafeObjectCount<DescriptorSet>(context, params, DEFAULT_MAX_CONCURRENT_OBJECTS);
   1879 	}
   1880 
   1881 	static Move<VkDescriptorSet> create (const Environment& env, const Resources& res, const Parameters&)
   1882 	{
   1883 		const VkDescriptorSetAllocateInfo	allocateInfo	=
   1884 		{
   1885 			VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
   1886 			DE_NULL,
   1887 			*res.descriptorPool.object,
   1888 			1u,
   1889 			&res.descriptorSetLayout.object.get(),
   1890 		};
   1891 
   1892 		return allocateDescriptorSet(env.vkd, env.device, &allocateInfo);
   1893 	}
   1894 };
   1895 
   1896 struct Framebuffer
   1897 {
   1898 	typedef VkFramebuffer Type;
   1899 
   1900 	struct Parameters
   1901 	{
   1902 		Parameters (void)
   1903 		{}
   1904 	};
   1905 
   1906 	struct Resources
   1907 	{
   1908 		Dependency<ImageView>	colorAttachment;
   1909 		Dependency<ImageView>	depthStencilAttachment;
   1910 		Dependency<RenderPass>	renderPass;
   1911 
   1912 		Resources (const Environment& env, const Parameters&)
   1913 			: colorAttachment			(env, ImageView::Parameters(Image::Parameters(0u, VK_IMAGE_TYPE_2D, VK_FORMAT_R8G8B8A8_UNORM,
   1914 																					  makeExtent3D(256, 256, 1),
   1915 																					  1u, 1u,
   1916 																					  VK_SAMPLE_COUNT_1_BIT,
   1917 																					  VK_IMAGE_TILING_OPTIMAL,
   1918 																					  VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
   1919 																					  VK_IMAGE_LAYOUT_UNDEFINED),
   1920 																		 VK_IMAGE_VIEW_TYPE_2D, VK_FORMAT_R8G8B8A8_UNORM,
   1921 																		 makeComponentMappingRGBA(),
   1922 																		 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u)))
   1923 			, depthStencilAttachment	(env, ImageView::Parameters(Image::Parameters(0u, VK_IMAGE_TYPE_2D, VK_FORMAT_D16_UNORM,
   1924 																					  makeExtent3D(256, 256, 1),
   1925 																					  1u, 1u,
   1926 																					  VK_SAMPLE_COUNT_1_BIT,
   1927 																					  VK_IMAGE_TILING_OPTIMAL,
   1928 																					  VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
   1929 																					  VK_IMAGE_LAYOUT_UNDEFINED),
   1930 																		 VK_IMAGE_VIEW_TYPE_2D, VK_FORMAT_D16_UNORM,
   1931 																		 makeComponentMappingRGBA(),
   1932 																		 makeImageSubresourceRange(VK_IMAGE_ASPECT_DEPTH_BIT, 0u, 1u, 0u, 1u)))
   1933 			, renderPass				(env, RenderPass::Parameters())
   1934 		{}
   1935 	};
   1936 
   1937 	static deUint32 getMaxConcurrent (Context& context, const Parameters& params)
   1938 	{
   1939 		// \todo [2016-03-23 pyry] Take into account attachment sizes
   1940 		return getSafeObjectCount<Framebuffer>(context, params, DEFAULT_MAX_CONCURRENT_OBJECTS);
   1941 	}
   1942 
   1943 	static Move<VkFramebuffer> create (const Environment& env, const Resources& res, const Parameters&)
   1944 	{
   1945 		const VkImageView				attachments[]	=
   1946 		{
   1947 			*res.colorAttachment.object,
   1948 			*res.depthStencilAttachment.object,
   1949 		};
   1950 		const VkFramebufferCreateInfo	framebufferInfo	=
   1951 		{
   1952 			VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
   1953 			DE_NULL,
   1954 			(VkFramebufferCreateFlags)0,
   1955 			*res.renderPass.object,
   1956 			(deUint32)DE_LENGTH_OF_ARRAY(attachments),
   1957 			attachments,
   1958 			256u,										// width
   1959 			256u,										// height
   1960 			1u											// layers
   1961 		};
   1962 
   1963 		return createFramebuffer(env.vkd, env.device, &framebufferInfo, env.allocationCallbacks);
   1964 	}
   1965 };
   1966 
   1967 struct CommandPool
   1968 {
   1969 	typedef VkCommandPool Type;
   1970 
   1971 	struct Parameters
   1972 	{
   1973 		VkCommandPoolCreateFlags	flags;
   1974 
   1975 		Parameters (VkCommandPoolCreateFlags flags_)
   1976 			: flags(flags_)
   1977 		{}
   1978 	};
   1979 
   1980 	struct Resources
   1981 	{
   1982 		Resources (const Environment&, const Parameters&) {}
   1983 	};
   1984 
   1985 	static deUint32 getMaxConcurrent (Context& context, const Parameters& params)
   1986 	{
   1987 		return getSafeObjectCount<CommandPool>(context, params, DEFAULT_MAX_CONCURRENT_OBJECTS);
   1988 	}
   1989 
   1990 	static Move<VkCommandPool> create (const Environment& env, const Resources&, const Parameters& params)
   1991 	{
   1992 		const VkCommandPoolCreateInfo	cmdPoolInfo	=
   1993 		{
   1994 			VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
   1995 			DE_NULL,
   1996 			params.flags,
   1997 			env.queueFamilyIndex,
   1998 		};
   1999 
   2000 		return createCommandPool(env.vkd, env.device, &cmdPoolInfo, env.allocationCallbacks);
   2001 	}
   2002 };
   2003 
   2004 struct CommandBuffer
   2005 {
   2006 	typedef VkCommandBuffer Type;
   2007 
   2008 	struct Parameters
   2009 	{
   2010 		CommandPool::Parameters		commandPool;
   2011 		VkCommandBufferLevel		level;
   2012 
   2013 		Parameters (const CommandPool::Parameters&	commandPool_,
   2014 					VkCommandBufferLevel			level_)
   2015 			: commandPool	(commandPool_)
   2016 			, level			(level_)
   2017 		{}
   2018 	};
   2019 
   2020 	struct Resources
   2021 	{
   2022 		Dependency<CommandPool>	commandPool;
   2023 
   2024 		Resources (const Environment& env, const Parameters& params)
   2025 			: commandPool(env, params.commandPool)
   2026 		{}
   2027 	};
   2028 
   2029 	static deUint32 getMaxConcurrent (Context& context, const Parameters& params)
   2030 	{
   2031 		return getSafeObjectCount<CommandBuffer>(context, params, DEFAULT_MAX_CONCURRENT_OBJECTS);
   2032 	}
   2033 
   2034 	static Move<VkCommandBuffer> create (const Environment& env, const Resources& res, const Parameters& params)
   2035 	{
   2036 		const VkCommandBufferAllocateInfo	cmdBufferInfo	=
   2037 		{
   2038 			VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
   2039 			DE_NULL,
   2040 			*res.commandPool.object,
   2041 			params.level,
   2042 			1,							// bufferCount
   2043 		};
   2044 
   2045 		return allocateCommandBuffer(env.vkd, env.device, &cmdBufferInfo);
   2046 	}
   2047 };
   2048 
   2049 // Test cases
   2050 
   2051 template<typename Object>
   2052 tcu::TestStatus createSingleTest (Context& context, typename Object::Parameters params)
   2053 {
   2054 	const Environment					env	(context, 1u);
   2055 	const typename Object::Resources	res	(env, params);
   2056 
   2057 	{
   2058 		Unique<typename Object::Type>	obj	(Object::create(env, res, params));
   2059 	}
   2060 
   2061 	return tcu::TestStatus::pass("Ok");
   2062 }
   2063 
   2064 template<typename Object>
   2065 tcu::TestStatus createMultipleUniqueResourcesTest (Context& context, typename Object::Parameters params)
   2066 {
   2067 	const Environment					env		(context, 1u);
   2068 	const typename Object::Resources	res0	(env, params);
   2069 	const typename Object::Resources	res1	(env, params);
   2070 	const typename Object::Resources	res2	(env, params);
   2071 	const typename Object::Resources	res3	(env, params);
   2072 
   2073 	{
   2074 		Unique<typename Object::Type>	obj0	(Object::create(env, res0, params));
   2075 		Unique<typename Object::Type>	obj1	(Object::create(env, res1, params));
   2076 		Unique<typename Object::Type>	obj2	(Object::create(env, res2, params));
   2077 		Unique<typename Object::Type>	obj3	(Object::create(env, res3, params));
   2078 	}
   2079 
   2080 	return tcu::TestStatus::pass("Ok");
   2081 }
   2082 
   2083 template<typename Object>
   2084 tcu::TestStatus createMultipleSharedResourcesTest (Context& context, typename Object::Parameters params)
   2085 {
   2086 	const Environment					env	(context, 4u);
   2087 	const typename Object::Resources	res	(env, params);
   2088 
   2089 	{
   2090 		Unique<typename Object::Type>	obj0	(Object::create(env, res, params));
   2091 		Unique<typename Object::Type>	obj1	(Object::create(env, res, params));
   2092 		Unique<typename Object::Type>	obj2	(Object::create(env, res, params));
   2093 		Unique<typename Object::Type>	obj3	(Object::create(env, res, params));
   2094 	}
   2095 
   2096 	return tcu::TestStatus::pass("Ok");
   2097 }
   2098 
   2099 template<typename Object>
   2100 tcu::TestStatus createMaxConcurrentTest (Context& context, typename Object::Parameters params)
   2101 {
   2102 	typedef Unique<typename Object::Type>	UniqueObject;
   2103 	typedef SharedPtr<UniqueObject>			ObjectPtr;
   2104 
   2105 	const deUint32						numObjects			= Object::getMaxConcurrent(context, params);
   2106 	const Environment					env					(context, numObjects);
   2107 	const typename Object::Resources	res					(env, params);
   2108 	vector<ObjectPtr>					objects				(numObjects);
   2109 	const deUint32						watchdogInterval	= 1024;
   2110 
   2111 	context.getTestContext().getLog()
   2112 		<< TestLog::Message << "Creating " << numObjects << " " << getTypeName<typename Object::Type>() << " objects" << TestLog::EndMessage;
   2113 
   2114 	for (deUint32 ndx = 0; ndx < numObjects; ndx++)
   2115 	{
   2116 		objects[ndx] = ObjectPtr(new UniqueObject(Object::create(env, res, params)));
   2117 
   2118 		if ((ndx > 0) && ((ndx % watchdogInterval) == 0))
   2119 			context.getTestContext().touchWatchdog();
   2120 	}
   2121 
   2122 	objects.clear();
   2123 
   2124 	return tcu::TestStatus::pass("Ok");
   2125 }
   2126 
   2127 // How many objects to create per thread
   2128 template<typename Object>	int getCreateCount				(void) { return 100;	}
   2129 
   2130 // Creating VkDevice and VkInstance can take significantly longer than other object types
   2131 template<>					int getCreateCount<Instance>	(void) { return 20;		}
   2132 template<>					int getCreateCount<Device>		(void) { return 20;		}
   2133 
   2134 template<typename Object>
   2135 class CreateThread : public ThreadGroupThread
   2136 {
   2137 public:
   2138 	CreateThread (const Environment& env, const typename Object::Resources& resources, const typename Object::Parameters& params)
   2139 		: m_env			(env)
   2140 		, m_resources	(resources)
   2141 		, m_params		(params)
   2142 	{}
   2143 
   2144 	void runThread (void)
   2145 	{
   2146 		const int	numIters			= getCreateCount<Object>();
   2147 		const int	itersBetweenSyncs	= numIters / 5;
   2148 
   2149 		DE_ASSERT(itersBetweenSyncs > 0);
   2150 
   2151 		for (int iterNdx = 0; iterNdx < numIters; iterNdx++)
   2152 		{
   2153 			// Sync every Nth iteration to make entering driver at the same time more likely
   2154 			if ((iterNdx % itersBetweenSyncs) == 0)
   2155 				barrier();
   2156 
   2157 			{
   2158 				Unique<typename Object::Type>	obj	(Object::create(m_env, m_resources, m_params));
   2159 			}
   2160 		}
   2161 	}
   2162 
   2163 private:
   2164 	const Environment&					m_env;
   2165 	const typename Object::Resources&	m_resources;
   2166 	const typename Object::Parameters&	m_params;
   2167 };
   2168 
   2169 template<typename Object>
   2170 tcu::TestStatus multithreadedCreateSharedResourcesTest (Context& context, typename Object::Parameters params)
   2171 {
   2172 	const deUint32						numThreads	= getDefaultTestThreadCount();
   2173 	const Environment					env			(context, numThreads);
   2174 	const typename Object::Resources	res			(env, params);
   2175 	ThreadGroup							threads;
   2176 
   2177 	for (deUint32 ndx = 0; ndx < numThreads; ndx++)
   2178 		threads.add(MovePtr<ThreadGroupThread>(new CreateThread<Object>(env, res, params)));
   2179 
   2180 	return threads.run();
   2181 }
   2182 
   2183 template<typename Object>
   2184 tcu::TestStatus multithreadedCreatePerThreadResourcesTest (Context& context, typename Object::Parameters params)
   2185 {
   2186 	typedef SharedPtr<typename Object::Resources>	ResPtr;
   2187 
   2188 	const deUint32		numThreads	= getDefaultTestThreadCount();
   2189 	const Environment	env			(context, 1u);
   2190 	vector<ResPtr>		resources	(numThreads);
   2191 	ThreadGroup			threads;
   2192 
   2193 	for (deUint32 ndx = 0; ndx < numThreads; ndx++)
   2194 	{
   2195 		resources[ndx] = ResPtr(new typename Object::Resources(env, params));
   2196 		threads.add(MovePtr<ThreadGroupThread>(new CreateThread<Object>(env, *resources[ndx], params)));
   2197 	}
   2198 
   2199 	return threads.run();
   2200 }
   2201 
   2202 struct EnvClone
   2203 {
   2204 	Device::Resources	deviceRes;
   2205 	Unique<VkDevice>	device;
   2206 	DeviceDriver		vkd;
   2207 	Environment			env;
   2208 
   2209 	EnvClone (const Environment& parent, const Device::Parameters& deviceParams, deUint32 maxResourceConsumers)
   2210 		: deviceRes	(parent, deviceParams)
   2211 		, device	(Device::create(parent, deviceRes, deviceParams))
   2212 		, vkd		(deviceRes.vki, *device)
   2213 		, env		(parent.vkp, vkd, *device, deviceRes.queueFamilyIndex, parent.programBinaries, parent.allocationCallbacks, maxResourceConsumers)
   2214 	{
   2215 	}
   2216 };
   2217 
   2218 Device::Parameters getDefaulDeviceParameters (Context& context)
   2219 {
   2220 	return Device::Parameters(context.getTestContext().getCommandLine().getVKDeviceId()-1u,
   2221 							  VK_QUEUE_GRAPHICS_BIT|VK_QUEUE_COMPUTE_BIT);
   2222 }
   2223 
   2224 template<typename Object>
   2225 tcu::TestStatus multithreadedCreatePerThreadDeviceTest (Context& context, typename Object::Parameters params)
   2226 {
   2227 	typedef SharedPtr<EnvClone>						EnvPtr;
   2228 	typedef SharedPtr<typename Object::Resources>	ResPtr;
   2229 
   2230 	const deUint32				numThreads		= getDefaultTestThreadCount();
   2231 	const Device::Parameters	deviceParams	= getDefaulDeviceParameters(context);
   2232 	const Environment			sharedEnv		(context, numThreads);			// For creating Device's
   2233 	vector<EnvPtr>				perThreadEnv	(numThreads);
   2234 	vector<ResPtr>				resources		(numThreads);
   2235 	ThreadGroup					threads;
   2236 
   2237 	for (deUint32 ndx = 0; ndx < numThreads; ndx++)
   2238 	{
   2239 		perThreadEnv[ndx]	= EnvPtr(new EnvClone(sharedEnv, deviceParams, 1u));
   2240 		resources[ndx]		= ResPtr(new typename Object::Resources(perThreadEnv[ndx]->env, params));
   2241 
   2242 		threads.add(MovePtr<ThreadGroupThread>(new CreateThread<Object>(perThreadEnv[ndx]->env, *resources[ndx], params)));
   2243 	}
   2244 
   2245 	return threads.run();
   2246 }
   2247 
   2248 template<typename Object>
   2249 tcu::TestStatus createSingleAllocCallbacksTest (Context& context, typename Object::Parameters params)
   2250 {
   2251 	const deUint32						noCmdScope		= (1u << VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE)
   2252 														| (1u << VK_SYSTEM_ALLOCATION_SCOPE_DEVICE)
   2253 														| (1u << VK_SYSTEM_ALLOCATION_SCOPE_CACHE)
   2254 														| (1u << VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
   2255 
   2256 	// Callbacks used by resources
   2257 	AllocationCallbackRecorder			resCallbacks	(getSystemAllocator(), 128);
   2258 
   2259 	// Root environment still uses default instance and device, created without callbacks
   2260 	const Environment					rootEnv			(context.getPlatformInterface(),
   2261 														 context.getDeviceInterface(),
   2262 														 context.getDevice(),
   2263 														 context.getUniversalQueueFamilyIndex(),
   2264 														 context.getBinaryCollection(),
   2265 														 resCallbacks.getCallbacks(),
   2266 														 1u);
   2267 
   2268 	{
   2269 		// Test env has instance & device created with callbacks
   2270 		const EnvClone						resEnv		(rootEnv, getDefaulDeviceParameters(context), 1u);
   2271 		const typename Object::Resources	res			(resEnv.env, params);
   2272 
   2273 		// Supply a separate callback recorder just for object construction
   2274 		AllocationCallbackRecorder			objCallbacks(getSystemAllocator(), 128);
   2275 		const Environment					objEnv		(resEnv.env.vkp,
   2276 														 resEnv.env.vkd,
   2277 														 resEnv.env.device,
   2278 														 resEnv.env.queueFamilyIndex,
   2279 														 resEnv.env.programBinaries,
   2280 														 objCallbacks.getCallbacks(),
   2281 														 resEnv.env.maxResourceConsumers);
   2282 
   2283 		{
   2284 			Unique<typename Object::Type>	obj	(Object::create(objEnv, res, params));
   2285 
   2286 			// Validate that no command-level allocations are live
   2287 			if (!validateAndLog(context.getTestContext().getLog(), objCallbacks, noCmdScope))
   2288 				return tcu::TestStatus::fail("Invalid allocation callback");
   2289 		}
   2290 
   2291 		// At this point all allocations made against object callbacks must have been freed
   2292 		if (!validateAndLog(context.getTestContext().getLog(), objCallbacks, 0u))
   2293 			return tcu::TestStatus::fail("Invalid allocation callback");
   2294 	}
   2295 
   2296 	if (!validateAndLog(context.getTestContext().getLog(), resCallbacks, 0u))
   2297 		return tcu::TestStatus::fail("Invalid allocation callback");
   2298 
   2299 	return tcu::TestStatus::pass("Ok");
   2300 }
   2301 
   2302 template<typename Object>	deUint32	getOomIterLimit			(void) { return 1024;	}
   2303 template<>					deUint32	getOomIterLimit<Device>	(void) { return 20;		}
   2304 
   2305 template<typename Object>
   2306 tcu::TestStatus allocCallbackFailTest (Context& context, typename Object::Parameters params)
   2307 {
   2308 	AllocationCallbackRecorder			resCallbacks		(getSystemAllocator(), 128);
   2309 	const Environment					rootEnv				(context.getPlatformInterface(),
   2310 															 context.getDeviceInterface(),
   2311 															 context.getDevice(),
   2312 															 context.getUniversalQueueFamilyIndex(),
   2313 															 context.getBinaryCollection(),
   2314 															 resCallbacks.getCallbacks(),
   2315 															 1u);
   2316 	deUint32							numPassingAllocs	= 0;
   2317 	const deUint32						cmdLineIterCount	= (deUint32)context.getTestContext().getCommandLine().getTestIterationCount();
   2318 	const deUint32						maxTries			= cmdLineIterCount != 0 ? cmdLineIterCount : getOomIterLimit<Object>();
   2319 
   2320 	{
   2321 		const EnvClone						resEnv	(rootEnv, getDefaulDeviceParameters(context), 1u);
   2322 		const typename Object::Resources	res		(resEnv.env, params);
   2323 
   2324 		// Iterate over test until object allocation succeeds
   2325 		for (; numPassingAllocs < maxTries; ++numPassingAllocs)
   2326 		{
   2327 			DeterministicFailAllocator			objAllocator(getSystemAllocator(),
   2328 															 numPassingAllocs,
   2329 															 DeterministicFailAllocator::MODE_COUNT_AND_FAIL);
   2330 			AllocationCallbackRecorder			recorder	(objAllocator.getCallbacks(), 128);
   2331 			const Environment					objEnv		(resEnv.env.vkp,
   2332 															 resEnv.env.vkd,
   2333 															 resEnv.env.device,
   2334 															 resEnv.env.queueFamilyIndex,
   2335 															 resEnv.env.programBinaries,
   2336 															 recorder.getCallbacks(),
   2337 															 resEnv.env.maxResourceConsumers);
   2338 			bool								createOk	= false;
   2339 
   2340 			context.getTestContext().getLog()
   2341 				<< TestLog::Message
   2342 				<< "Trying to create object with " << numPassingAllocs << " allocation" << (numPassingAllocs != 1 ? "s" : "") << " passing"
   2343 				<< TestLog::EndMessage;
   2344 
   2345 			try
   2346 			{
   2347 				Unique<typename Object::Type>	obj	(Object::create(objEnv, res, params));
   2348 				createOk = true;
   2349 			}
   2350 			catch (const vk::OutOfMemoryError& e)
   2351 			{
   2352 				if (e.getError() != VK_ERROR_OUT_OF_HOST_MEMORY)
   2353 				{
   2354 					context.getTestContext().getLog() << e;
   2355 					return tcu::TestStatus::fail("Got invalid error code");
   2356 				}
   2357 			}
   2358 
   2359 			if (!validateAndLog(context.getTestContext().getLog(), recorder, 0u))
   2360 				return tcu::TestStatus::fail("Invalid allocation callback");
   2361 
   2362 			if (createOk)
   2363 			{
   2364 				context.getTestContext().getLog()
   2365 					<< TestLog::Message << "Object construction succeeded! " << TestLog::EndMessage;
   2366 				break;
   2367 			}
   2368 		}
   2369 	}
   2370 
   2371 	if (!validateAndLog(context.getTestContext().getLog(), resCallbacks, 0u))
   2372 		return tcu::TestStatus::fail("Invalid allocation callback");
   2373 
   2374 	if (numPassingAllocs == 0)
   2375 		return tcu::TestStatus(QP_TEST_RESULT_QUALITY_WARNING, "Allocation callbacks not called");
   2376 	else if (numPassingAllocs == maxTries)
   2377 		return tcu::TestStatus(QP_TEST_RESULT_COMPATIBILITY_WARNING, "Max iter count reached; OOM testing incomplete");
   2378 	else
   2379 		return tcu::TestStatus::pass("Ok");
   2380 }
   2381 
   2382 // Utilities for creating groups
   2383 
   2384 template<typename Object>
   2385 struct NamedParameters
   2386 {
   2387 	const char*						name;
   2388 	typename Object::Parameters		parameters;
   2389 };
   2390 
   2391 template<typename Object>
   2392 struct CaseDescription
   2393 {
   2394 	typename FunctionInstance1<typename Object::Parameters>::Function	function;
   2395 	const NamedParameters<Object>*										paramsBegin;
   2396 	const NamedParameters<Object>*										paramsEnd;
   2397 };
   2398 
   2399 #define EMPTY_CASE_DESC(OBJECT)	\
   2400 	{ (FunctionInstance1<OBJECT::Parameters>::Function)DE_NULL, DE_NULL, DE_NULL }
   2401 
   2402 #define CASE_DESC(FUNCTION, CASES)	\
   2403 	{ FUNCTION, DE_ARRAY_BEGIN(CASES), DE_ARRAY_END(CASES)	}
   2404 
   2405 struct CaseDescriptions
   2406 {
   2407 	CaseDescription<Instance>				instance;
   2408 	CaseDescription<Device>					device;
   2409 	CaseDescription<DeviceMemory>			deviceMemory;
   2410 	CaseDescription<Buffer>					buffer;
   2411 	CaseDescription<BufferView>				bufferView;
   2412 	CaseDescription<Image>					image;
   2413 	CaseDescription<ImageView>				imageView;
   2414 	CaseDescription<Semaphore>				semaphore;
   2415 	CaseDescription<Event>					event;
   2416 	CaseDescription<Fence>					fence;
   2417 	CaseDescription<QueryPool>				queryPool;
   2418 	CaseDescription<ShaderModule>			shaderModule;
   2419 	CaseDescription<PipelineCache>			pipelineCache;
   2420 	CaseDescription<PipelineLayout>			pipelineLayout;
   2421 	CaseDescription<RenderPass>				renderPass;
   2422 	CaseDescription<GraphicsPipeline>		graphicsPipeline;
   2423 	CaseDescription<ComputePipeline>		computePipeline;
   2424 	CaseDescription<DescriptorSetLayout>	descriptorSetLayout;
   2425 	CaseDescription<Sampler>				sampler;
   2426 	CaseDescription<DescriptorPool>			descriptorPool;
   2427 	CaseDescription<DescriptorSet>			descriptorSet;
   2428 	CaseDescription<Framebuffer>			framebuffer;
   2429 	CaseDescription<CommandPool>			commandPool;
   2430 	CaseDescription<CommandBuffer>			commandBuffer;
   2431 };
   2432 
   2433 template<typename Object>
   2434 void addCases (const MovePtr<tcu::TestCaseGroup>& group, const CaseDescription<Object>& cases)
   2435 {
   2436 	for (const NamedParameters<Object>* cur = cases.paramsBegin; cur != cases.paramsEnd; ++cur)
   2437 		addFunctionCase(group.get(), cur->name, "", cases.function, cur->parameters);
   2438 }
   2439 
   2440 template<typename Object>
   2441 void addCasesWithProgs (const MovePtr<tcu::TestCaseGroup>& group, const CaseDescription<Object>& cases)
   2442 {
   2443 	for (const NamedParameters<Object>* cur = cases.paramsBegin; cur != cases.paramsEnd; ++cur)
   2444 		addFunctionCaseWithPrograms(group.get(), cur->name, "", Object::initPrograms, cases.function, cur->parameters);
   2445 }
   2446 
   2447 tcu::TestCaseGroup* createGroup (tcu::TestContext& testCtx, const char* name, const char* desc, const CaseDescriptions& cases)
   2448 {
   2449 	MovePtr<tcu::TestCaseGroup>	group	(new tcu::TestCaseGroup(testCtx, name, desc));
   2450 
   2451 	addCases			(group, cases.instance);
   2452 	addCases			(group, cases.device);
   2453 	addCases			(group, cases.deviceMemory);
   2454 	addCases			(group, cases.buffer);
   2455 	addCases			(group, cases.bufferView);
   2456 	addCases			(group, cases.image);
   2457 	addCases			(group, cases.imageView);
   2458 	addCases			(group, cases.semaphore);
   2459 	addCases			(group, cases.event);
   2460 	addCases			(group, cases.fence);
   2461 	addCases			(group, cases.queryPool);
   2462 	addCases			(group, cases.sampler);
   2463 	addCasesWithProgs	(group, cases.shaderModule);
   2464 	addCases			(group, cases.pipelineCache);
   2465 	addCases			(group, cases.pipelineLayout);
   2466 	addCases			(group, cases.renderPass);
   2467 	addCasesWithProgs	(group, cases.graphicsPipeline);
   2468 	addCasesWithProgs	(group, cases.computePipeline);
   2469 	addCases			(group, cases.descriptorSetLayout);
   2470 	addCases			(group, cases.descriptorPool);
   2471 	addCases			(group, cases.descriptorSet);
   2472 	addCases			(group, cases.framebuffer);
   2473 	addCases			(group, cases.commandPool);
   2474 	addCases			(group, cases.commandBuffer);
   2475 
   2476 	return group.release();
   2477 }
   2478 
   2479 } // anonymous
   2480 
   2481 tcu::TestCaseGroup* createObjectManagementTests (tcu::TestContext& testCtx)
   2482 {
   2483 	MovePtr<tcu::TestCaseGroup>	objectMgmtTests	(new tcu::TestCaseGroup(testCtx, "object_management", "Object management tests"));
   2484 
   2485 	const Image::Parameters		img1D			(0u, VK_IMAGE_TYPE_1D, VK_FORMAT_R8G8B8A8_UNORM, makeExtent3D(256,   1, 1), 1u,  4u, VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_SAMPLED_BIT, VK_IMAGE_LAYOUT_UNDEFINED);
   2486 	const Image::Parameters		img2D			(0u, VK_IMAGE_TYPE_2D, VK_FORMAT_R8G8B8A8_UNORM, makeExtent3D( 64,  64, 1), 1u, 12u, VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_SAMPLED_BIT|VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_LAYOUT_UNDEFINED);
   2487 	const Image::Parameters		imgCube			(VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, VK_IMAGE_TYPE_2D, VK_FORMAT_R8G8B8A8_UNORM, makeExtent3D( 64,  64, 1), 1u, 12u, VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_SAMPLED_BIT|VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_LAYOUT_UNDEFINED);
   2488 	const Image::Parameters		img3D			(0u, VK_IMAGE_TYPE_3D, VK_FORMAT_R8G8B8A8_UNORM, makeExtent3D( 64,  64, 4), 1u,  1u, VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_SAMPLED_BIT, VK_IMAGE_LAYOUT_UNDEFINED);
   2489 	const ImageView::Parameters	imgView1D		(img1D, VK_IMAGE_VIEW_TYPE_1D,			img1D.format, makeComponentMappingRGBA(), makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u));
   2490 	const ImageView::Parameters	imgView1DArr	(img1D, VK_IMAGE_VIEW_TYPE_1D_ARRAY,	img1D.format, makeComponentMappingRGBA(), makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 4u));
   2491 	const ImageView::Parameters	imgView2D		(img2D, VK_IMAGE_VIEW_TYPE_2D,			img2D.format, makeComponentMappingRGBA(), makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u));
   2492 	const ImageView::Parameters	imgView2DArr	(img2D, VK_IMAGE_VIEW_TYPE_2D_ARRAY,	img2D.format, makeComponentMappingRGBA(), makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 8u));
   2493 	const ImageView::Parameters	imgViewCube		(imgCube, VK_IMAGE_VIEW_TYPE_CUBE,		img2D.format, makeComponentMappingRGBA(), makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 6u));
   2494 	const ImageView::Parameters	imgViewCubeArr	(imgCube, VK_IMAGE_VIEW_TYPE_CUBE_ARRAY,	img2D.format, makeComponentMappingRGBA(), makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 12u));
   2495 	const ImageView::Parameters	imgView3D		(img3D, VK_IMAGE_VIEW_TYPE_3D,			img3D.format, makeComponentMappingRGBA(), makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u));
   2496 
   2497 	const DescriptorSetLayout::Parameters	singleUboDescLayout	= DescriptorSetLayout::Parameters::single(0u, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1u, VK_SHADER_STAGE_VERTEX_BIT);
   2498 
   2499 	static NamedParameters<Instance>				s_instanceCases[]			=
   2500 	{
   2501 		{ "instance",					Instance::Parameters() },
   2502 	};
   2503 	// \note Device index may change - must not be static
   2504 	const NamedParameters<Device>					s_deviceCases[]				=
   2505 	{
   2506 		{ "device",						Device::Parameters(testCtx.getCommandLine().getVKDeviceId()-1u, VK_QUEUE_GRAPHICS_BIT)	},
   2507 	};
   2508 	static const NamedParameters<DeviceMemory>			s_deviceMemCases[]				=
   2509 	{
   2510 		{ "device_memory_small",		DeviceMemory::Parameters(1024, 0u)	},
   2511 	};
   2512 	static const NamedParameters<Buffer>				s_bufferCases[]					=
   2513 	{
   2514 		{ "buffer_uniform_small",		Buffer::Parameters(1024u,			VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT),	},
   2515 		{ "buffer_uniform_large",		Buffer::Parameters(1024u*1024u*16u,	VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT),	},
   2516 		{ "buffer_storage_small",		Buffer::Parameters(1024u,			VK_BUFFER_USAGE_STORAGE_BUFFER_BIT),	},
   2517 		{ "buffer_storage_large",		Buffer::Parameters(1024u*1024u*16u,	VK_BUFFER_USAGE_STORAGE_BUFFER_BIT),	},
   2518 	};
   2519 	static const NamedParameters<BufferView>			s_bufferViewCases[]				=
   2520 	{
   2521 		{ "buffer_view_uniform_r8g8b8a8_unorm",	BufferView::Parameters(Buffer::Parameters(8192u, VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT), VK_FORMAT_R8G8B8A8_UNORM, 0u, 4096u)	},
   2522 		{ "buffer_view_storage_r8g8b8a8_unorm",	BufferView::Parameters(Buffer::Parameters(8192u, VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT), VK_FORMAT_R8G8B8A8_UNORM, 0u, 4096u)	},
   2523 	};
   2524 	static const NamedParameters<Image>					s_imageCases[]					=
   2525 	{
   2526 		{ "image_1d",					img1D		},
   2527 		{ "image_2d",					img2D		},
   2528 		{ "image_3d",					img3D		},
   2529 	};
   2530 	static const NamedParameters<ImageView>				s_imageViewCases[]				=
   2531 	{
   2532 		{ "image_view_1d",				imgView1D		},
   2533 		{ "image_view_1d_arr",			imgView1DArr	},
   2534 		{ "image_view_2d",				imgView2D		},
   2535 		{ "image_view_2d_arr",			imgView2DArr	},
   2536 		{ "image_view_cube",			imgViewCube		},
   2537 		{ "image_view_cube_arr",		imgViewCubeArr	},
   2538 		{ "image_view_3d",				imgView3D		},
   2539 	};
   2540 	static const NamedParameters<Semaphore>				s_semaphoreCases[]				=
   2541 	{
   2542 		{ "semaphore",					Semaphore::Parameters(0u),	}
   2543 	};
   2544 	static const NamedParameters<Event>					s_eventCases[]					=
   2545 	{
   2546 		{ "event",						Event::Parameters(0u)		}
   2547 	};
   2548 	static const NamedParameters<Fence>					s_fenceCases[]					=
   2549 	{
   2550 		{ "fence",						Fence::Parameters(0u)								},
   2551 		{ "fence_signaled",				Fence::Parameters(VK_FENCE_CREATE_SIGNALED_BIT)		}
   2552 	};
   2553 	static const NamedParameters<QueryPool>				s_queryPoolCases[]				=
   2554 	{
   2555 		{ "query_pool",					QueryPool::Parameters(VK_QUERY_TYPE_OCCLUSION, 1u, 0u)	}
   2556 	};
   2557 	static const NamedParameters<ShaderModule>			s_shaderModuleCases[]			=
   2558 	{
   2559 		{ "shader_module",				ShaderModule::Parameters(VK_SHADER_STAGE_COMPUTE_BIT, "test")	}
   2560 	};
   2561 	static const NamedParameters<PipelineCache>			s_pipelineCacheCases[]			=
   2562 	{
   2563 		{ "pipeline_cache",				PipelineCache::Parameters()		}
   2564 	};
   2565 	static const NamedParameters<PipelineLayout>		s_pipelineLayoutCases[]			=
   2566 	{
   2567 		{ "pipeline_layout_empty",		PipelineLayout::Parameters::empty()										},
   2568 		{ "pipeline_layout_single",		PipelineLayout::Parameters::singleDescriptorSet(singleUboDescLayout)	}
   2569 	};
   2570 	static const NamedParameters<RenderPass>			s_renderPassCases[]				=
   2571 	{
   2572 		{ "render_pass",				RenderPass::Parameters()		}
   2573 	};
   2574 	static const NamedParameters<GraphicsPipeline>		s_graphicsPipelineCases[]		=
   2575 	{
   2576 		{ "graphics_pipeline",			GraphicsPipeline::Parameters()	}
   2577 	};
   2578 	static const NamedParameters<ComputePipeline>		s_computePipelineCases[]		=
   2579 	{
   2580 		{ "compute_pipeline",			ComputePipeline::Parameters()	}
   2581 	};
   2582 	static const NamedParameters<DescriptorSetLayout>	s_descriptorSetLayoutCases[]	=
   2583 	{
   2584 		{ "descriptor_set_layout_empty",	DescriptorSetLayout::Parameters::empty()	},
   2585 		{ "descriptor_set_layout_single",	singleUboDescLayout							}
   2586 	};
   2587 	static const NamedParameters<Sampler>				s_samplerCases[]				=
   2588 	{
   2589 		{ "sampler",					Sampler::Parameters()	}
   2590 	};
   2591 	static const NamedParameters<DescriptorPool>		s_descriptorPoolCases[]			=
   2592 	{
   2593 		{ "descriptor_pool",						DescriptorPool::Parameters::singleType((VkDescriptorPoolCreateFlags)0,						4u, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 3u)	},
   2594 		{ "descriptor_pool_free_descriptor_set",	DescriptorPool::Parameters::singleType(VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,	4u, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 3u)	}
   2595 	};
   2596 	static const NamedParameters<DescriptorSet>			s_descriptorSetCases[]			=
   2597 	{
   2598 		{ "descriptor_set",				DescriptorSet::Parameters(singleUboDescLayout)	}
   2599 	};
   2600 	static const NamedParameters<Framebuffer>			s_framebufferCases[]			=
   2601 	{
   2602 		{ "framebuffer",				Framebuffer::Parameters()	}
   2603 	};
   2604 	static const NamedParameters<CommandPool>			s_commandPoolCases[]			=
   2605 	{
   2606 		{ "command_pool",				CommandPool::Parameters((VkCommandPoolCreateFlags)0)			},
   2607 		{ "command_pool_transient",		CommandPool::Parameters(VK_COMMAND_POOL_CREATE_TRANSIENT_BIT)	}
   2608 	};
   2609 	static const NamedParameters<CommandBuffer>			s_commandBufferCases[]			=
   2610 	{
   2611 		{ "command_buffer_primary",		CommandBuffer::Parameters(CommandPool::Parameters((VkCommandPoolCreateFlags)0u), VK_COMMAND_BUFFER_LEVEL_PRIMARY)	},
   2612 		{ "command_buffer_secondary",	CommandBuffer::Parameters(CommandPool::Parameters((VkCommandPoolCreateFlags)0u), VK_COMMAND_BUFFER_LEVEL_SECONDARY)	}
   2613 	};
   2614 
   2615 	static const CaseDescriptions	s_createSingleGroup	=
   2616 	{
   2617 		CASE_DESC(createSingleTest	<Instance>,					s_instanceCases),
   2618 		CASE_DESC(createSingleTest	<Device>,					s_deviceCases),
   2619 		CASE_DESC(createSingleTest	<DeviceMemory>,				s_deviceMemCases),
   2620 		CASE_DESC(createSingleTest	<Buffer>,					s_bufferCases),
   2621 		CASE_DESC(createSingleTest	<BufferView>,				s_bufferViewCases),
   2622 		CASE_DESC(createSingleTest	<Image>,					s_imageCases),
   2623 		CASE_DESC(createSingleTest	<ImageView>,				s_imageViewCases),
   2624 		CASE_DESC(createSingleTest	<Semaphore>,				s_semaphoreCases),
   2625 		CASE_DESC(createSingleTest	<Event>,					s_eventCases),
   2626 		CASE_DESC(createSingleTest	<Fence>,					s_fenceCases),
   2627 		CASE_DESC(createSingleTest	<QueryPool>,				s_queryPoolCases),
   2628 		CASE_DESC(createSingleTest	<ShaderModule>,				s_shaderModuleCases),
   2629 		CASE_DESC(createSingleTest	<PipelineCache>,			s_pipelineCacheCases),
   2630 		CASE_DESC(createSingleTest	<PipelineLayout>,			s_pipelineLayoutCases),
   2631 		CASE_DESC(createSingleTest	<RenderPass>,				s_renderPassCases),
   2632 		CASE_DESC(createSingleTest	<GraphicsPipeline>,			s_graphicsPipelineCases),
   2633 		CASE_DESC(createSingleTest	<ComputePipeline>,			s_computePipelineCases),
   2634 		CASE_DESC(createSingleTest	<DescriptorSetLayout>,		s_descriptorSetLayoutCases),
   2635 		CASE_DESC(createSingleTest	<Sampler>,					s_samplerCases),
   2636 		CASE_DESC(createSingleTest	<DescriptorPool>,			s_descriptorPoolCases),
   2637 		CASE_DESC(createSingleTest	<DescriptorSet>,			s_descriptorSetCases),
   2638 		CASE_DESC(createSingleTest	<Framebuffer>,				s_framebufferCases),
   2639 		CASE_DESC(createSingleTest	<CommandPool>,				s_commandPoolCases),
   2640 		CASE_DESC(createSingleTest	<CommandBuffer>,			s_commandBufferCases),
   2641 	};
   2642 	objectMgmtTests->addChild(createGroup(testCtx, "single", "Create single object", s_createSingleGroup));
   2643 
   2644 	static const CaseDescriptions	s_createMultipleUniqueResourcesGroup	=
   2645 	{
   2646 		CASE_DESC(createMultipleUniqueResourcesTest	<Instance>,					s_instanceCases),
   2647 		CASE_DESC(createMultipleUniqueResourcesTest	<Device>,					s_deviceCases),
   2648 		CASE_DESC(createMultipleUniqueResourcesTest	<DeviceMemory>,				s_deviceMemCases),
   2649 		CASE_DESC(createMultipleUniqueResourcesTest	<Buffer>,					s_bufferCases),
   2650 		CASE_DESC(createMultipleUniqueResourcesTest	<BufferView>,				s_bufferViewCases),
   2651 		CASE_DESC(createMultipleUniqueResourcesTest	<Image>,					s_imageCases),
   2652 		CASE_DESC(createMultipleUniqueResourcesTest	<ImageView>,				s_imageViewCases),
   2653 		CASE_DESC(createMultipleUniqueResourcesTest	<Semaphore>,				s_semaphoreCases),
   2654 		CASE_DESC(createMultipleUniqueResourcesTest	<Event>,					s_eventCases),
   2655 		CASE_DESC(createMultipleUniqueResourcesTest	<Fence>,					s_fenceCases),
   2656 		CASE_DESC(createMultipleUniqueResourcesTest	<QueryPool>,				s_queryPoolCases),
   2657 		CASE_DESC(createMultipleUniqueResourcesTest	<ShaderModule>,				s_shaderModuleCases),
   2658 		CASE_DESC(createMultipleUniqueResourcesTest	<PipelineCache>,			s_pipelineCacheCases),
   2659 		CASE_DESC(createMultipleUniqueResourcesTest	<PipelineLayout>,			s_pipelineLayoutCases),
   2660 		CASE_DESC(createMultipleUniqueResourcesTest	<RenderPass>,				s_renderPassCases),
   2661 		CASE_DESC(createMultipleUniqueResourcesTest	<GraphicsPipeline>,			s_graphicsPipelineCases),
   2662 		CASE_DESC(createMultipleUniqueResourcesTest	<ComputePipeline>,			s_computePipelineCases),
   2663 		CASE_DESC(createMultipleUniqueResourcesTest	<DescriptorSetLayout>,		s_descriptorSetLayoutCases),
   2664 		CASE_DESC(createMultipleUniqueResourcesTest	<Sampler>,					s_samplerCases),
   2665 		CASE_DESC(createMultipleUniqueResourcesTest	<DescriptorPool>,			s_descriptorPoolCases),
   2666 		CASE_DESC(createMultipleUniqueResourcesTest	<DescriptorSet>,			s_descriptorSetCases),
   2667 		CASE_DESC(createMultipleUniqueResourcesTest	<Framebuffer>,				s_framebufferCases),
   2668 		CASE_DESC(createMultipleUniqueResourcesTest	<CommandPool>,				s_commandPoolCases),
   2669 		CASE_DESC(createMultipleUniqueResourcesTest	<CommandBuffer>,			s_commandBufferCases),
   2670 	};
   2671 	objectMgmtTests->addChild(createGroup(testCtx, "multiple_unique_resources", "Multiple objects with per-object unique resources", s_createMultipleUniqueResourcesGroup));
   2672 
   2673 	static const CaseDescriptions	s_createMultipleSharedResourcesGroup	=
   2674 	{
   2675 		EMPTY_CASE_DESC(Instance), // No resources used
   2676 		CASE_DESC(createMultipleSharedResourcesTest	<Device>,					s_deviceCases),
   2677 		CASE_DESC(createMultipleSharedResourcesTest	<DeviceMemory>,				s_deviceMemCases),
   2678 		CASE_DESC(createMultipleSharedResourcesTest	<Buffer>,					s_bufferCases),
   2679 		CASE_DESC(createMultipleSharedResourcesTest	<BufferView>,				s_bufferViewCases),
   2680 		CASE_DESC(createMultipleSharedResourcesTest	<Image>,					s_imageCases),
   2681 		CASE_DESC(createMultipleSharedResourcesTest	<ImageView>,				s_imageViewCases),
   2682 		CASE_DESC(createMultipleSharedResourcesTest	<Semaphore>,				s_semaphoreCases),
   2683 		CASE_DESC(createMultipleSharedResourcesTest	<Event>,					s_eventCases),
   2684 		CASE_DESC(createMultipleSharedResourcesTest	<Fence>,					s_fenceCases),
   2685 		CASE_DESC(createMultipleSharedResourcesTest	<QueryPool>,				s_queryPoolCases),
   2686 		CASE_DESC(createMultipleSharedResourcesTest	<ShaderModule>,				s_shaderModuleCases),
   2687 		CASE_DESC(createMultipleSharedResourcesTest	<PipelineCache>,			s_pipelineCacheCases),
   2688 		CASE_DESC(createMultipleSharedResourcesTest	<PipelineLayout>,			s_pipelineLayoutCases),
   2689 		CASE_DESC(createMultipleSharedResourcesTest	<RenderPass>,				s_renderPassCases),
   2690 		CASE_DESC(createMultipleSharedResourcesTest	<GraphicsPipeline>,			s_graphicsPipelineCases),
   2691 		CASE_DESC(createMultipleSharedResourcesTest	<ComputePipeline>,			s_computePipelineCases),
   2692 		CASE_DESC(createMultipleSharedResourcesTest	<DescriptorSetLayout>,		s_descriptorSetLayoutCases),
   2693 		CASE_DESC(createMultipleSharedResourcesTest	<Sampler>,					s_samplerCases),
   2694 		CASE_DESC(createMultipleSharedResourcesTest	<DescriptorPool>,			s_descriptorPoolCases),
   2695 		CASE_DESC(createMultipleSharedResourcesTest	<DescriptorSet>,			s_descriptorSetCases),
   2696 		CASE_DESC(createMultipleSharedResourcesTest	<Framebuffer>,				s_framebufferCases),
   2697 		CASE_DESC(createMultipleSharedResourcesTest	<CommandPool>,				s_commandPoolCases),
   2698 		CASE_DESC(createMultipleSharedResourcesTest	<CommandBuffer>,			s_commandBufferCases),
   2699 	};
   2700 	objectMgmtTests->addChild(createGroup(testCtx, "multiple_shared_resources", "Multiple objects with shared resources", s_createMultipleSharedResourcesGroup));
   2701 
   2702 	static const CaseDescriptions	s_createMaxConcurrentGroup	=
   2703 	{
   2704 		CASE_DESC(createMaxConcurrentTest	<Instance>,					s_instanceCases),
   2705 		CASE_DESC(createMaxConcurrentTest	<Device>,					s_deviceCases),
   2706 		CASE_DESC(createMaxConcurrentTest	<DeviceMemory>,				s_deviceMemCases),
   2707 		CASE_DESC(createMaxConcurrentTest	<Buffer>,					s_bufferCases),
   2708 		CASE_DESC(createMaxConcurrentTest	<BufferView>,				s_bufferViewCases),
   2709 		CASE_DESC(createMaxConcurrentTest	<Image>,					s_imageCases),
   2710 		CASE_DESC(createMaxConcurrentTest	<ImageView>,				s_imageViewCases),
   2711 		CASE_DESC(createMaxConcurrentTest	<Semaphore>,				s_semaphoreCases),
   2712 		CASE_DESC(createMaxConcurrentTest	<Event>,					s_eventCases),
   2713 		CASE_DESC(createMaxConcurrentTest	<Fence>,					s_fenceCases),
   2714 		CASE_DESC(createMaxConcurrentTest	<QueryPool>,				s_queryPoolCases),
   2715 		CASE_DESC(createMaxConcurrentTest	<ShaderModule>,				s_shaderModuleCases),
   2716 		CASE_DESC(createMaxConcurrentTest	<PipelineCache>,			s_pipelineCacheCases),
   2717 		CASE_DESC(createMaxConcurrentTest	<PipelineLayout>,			s_pipelineLayoutCases),
   2718 		CASE_DESC(createMaxConcurrentTest	<RenderPass>,				s_renderPassCases),
   2719 		CASE_DESC(createMaxConcurrentTest	<GraphicsPipeline>,			s_graphicsPipelineCases),
   2720 		CASE_DESC(createMaxConcurrentTest	<ComputePipeline>,			s_computePipelineCases),
   2721 		CASE_DESC(createMaxConcurrentTest	<DescriptorSetLayout>,		s_descriptorSetLayoutCases),
   2722 		CASE_DESC(createMaxConcurrentTest	<Sampler>,					s_samplerCases),
   2723 		CASE_DESC(createMaxConcurrentTest	<DescriptorPool>,			s_descriptorPoolCases),
   2724 		CASE_DESC(createMaxConcurrentTest	<DescriptorSet>,			s_descriptorSetCases),
   2725 		CASE_DESC(createMaxConcurrentTest	<Framebuffer>,				s_framebufferCases),
   2726 		CASE_DESC(createMaxConcurrentTest	<CommandPool>,				s_commandPoolCases),
   2727 		CASE_DESC(createMaxConcurrentTest	<CommandBuffer>,			s_commandBufferCases),
   2728 	};
   2729 	objectMgmtTests->addChild(createGroup(testCtx, "max_concurrent", "Maximum number of concurrently live objects", s_createMaxConcurrentGroup));
   2730 
   2731 	static const CaseDescriptions	s_multithreadedCreatePerThreadDeviceGroup	=
   2732 	{
   2733 		EMPTY_CASE_DESC(Instance),	// Does not make sense
   2734 		EMPTY_CASE_DESC(Device),	// Does not make sense
   2735 		CASE_DESC(multithreadedCreatePerThreadDeviceTest	<DeviceMemory>,				s_deviceMemCases),
   2736 		CASE_DESC(multithreadedCreatePerThreadDeviceTest	<Buffer>,					s_bufferCases),
   2737 		CASE_DESC(multithreadedCreatePerThreadDeviceTest	<BufferView>,				s_bufferViewCases),
   2738 		CASE_DESC(multithreadedCreatePerThreadDeviceTest	<Image>,					s_imageCases),
   2739 		CASE_DESC(multithreadedCreatePerThreadDeviceTest	<ImageView>,				s_imageViewCases),
   2740 		CASE_DESC(multithreadedCreatePerThreadDeviceTest	<Semaphore>,				s_semaphoreCases),
   2741 		CASE_DESC(multithreadedCreatePerThreadDeviceTest	<Event>,					s_eventCases),
   2742 		CASE_DESC(multithreadedCreatePerThreadDeviceTest	<Fence>,					s_fenceCases),
   2743 		CASE_DESC(multithreadedCreatePerThreadDeviceTest	<QueryPool>,				s_queryPoolCases),
   2744 		CASE_DESC(multithreadedCreatePerThreadDeviceTest	<ShaderModule>,				s_shaderModuleCases),
   2745 		CASE_DESC(multithreadedCreatePerThreadDeviceTest	<PipelineCache>,			s_pipelineCacheCases),
   2746 		CASE_DESC(multithreadedCreatePerThreadDeviceTest	<PipelineLayout>,			s_pipelineLayoutCases),
   2747 		CASE_DESC(multithreadedCreatePerThreadDeviceTest	<RenderPass>,				s_renderPassCases),
   2748 		CASE_DESC(multithreadedCreatePerThreadDeviceTest	<GraphicsPipeline>,			s_graphicsPipelineCases),
   2749 		CASE_DESC(multithreadedCreatePerThreadDeviceTest	<ComputePipeline>,			s_computePipelineCases),
   2750 		CASE_DESC(multithreadedCreatePerThreadDeviceTest	<DescriptorSetLayout>,		s_descriptorSetLayoutCases),
   2751 		CASE_DESC(multithreadedCreatePerThreadDeviceTest	<Sampler>,					s_samplerCases),
   2752 		CASE_DESC(multithreadedCreatePerThreadDeviceTest	<DescriptorPool>,			s_descriptorPoolCases),
   2753 		CASE_DESC(multithreadedCreatePerThreadDeviceTest	<DescriptorSet>,			s_descriptorSetCases),
   2754 		CASE_DESC(multithreadedCreatePerThreadDeviceTest	<Framebuffer>,				s_framebufferCases),
   2755 		CASE_DESC(multithreadedCreatePerThreadDeviceTest	<CommandPool>,				s_commandPoolCases),
   2756 		CASE_DESC(multithreadedCreatePerThreadDeviceTest	<CommandBuffer>,			s_commandBufferCases),
   2757 	};
   2758 	objectMgmtTests->addChild(createGroup(testCtx, "multithreaded_per_thread_device", "Multithreaded object construction with per-thread device ", s_multithreadedCreatePerThreadDeviceGroup));
   2759 
   2760 	static const CaseDescriptions	s_multithreadedCreatePerThreadResourcesGroup	=
   2761 	{
   2762 		CASE_DESC(multithreadedCreatePerThreadResourcesTest	<Instance>,					s_instanceCases),
   2763 		CASE_DESC(multithreadedCreatePerThreadResourcesTest	<Device>,					s_deviceCases),
   2764 		CASE_DESC(multithreadedCreatePerThreadResourcesTest	<DeviceMemory>,				s_deviceMemCases),
   2765 		CASE_DESC(multithreadedCreatePerThreadResourcesTest	<Buffer>,					s_bufferCases),
   2766 		CASE_DESC(multithreadedCreatePerThreadResourcesTest	<BufferView>,				s_bufferViewCases),
   2767 		CASE_DESC(multithreadedCreatePerThreadResourcesTest	<Image>,					s_imageCases),
   2768 		CASE_DESC(multithreadedCreatePerThreadResourcesTest	<ImageView>,				s_imageViewCases),
   2769 		CASE_DESC(multithreadedCreatePerThreadResourcesTest	<Semaphore>,				s_semaphoreCases),
   2770 		CASE_DESC(multithreadedCreatePerThreadResourcesTest	<Event>,					s_eventCases),
   2771 		CASE_DESC(multithreadedCreatePerThreadResourcesTest	<Fence>,					s_fenceCases),
   2772 		CASE_DESC(multithreadedCreatePerThreadResourcesTest	<QueryPool>,				s_queryPoolCases),
   2773 		CASE_DESC(multithreadedCreatePerThreadResourcesTest	<ShaderModule>,				s_shaderModuleCases),
   2774 		CASE_DESC(multithreadedCreatePerThreadResourcesTest	<PipelineCache>,			s_pipelineCacheCases),
   2775 		CASE_DESC(multithreadedCreatePerThreadResourcesTest	<PipelineLayout>,			s_pipelineLayoutCases),
   2776 		CASE_DESC(multithreadedCreatePerThreadResourcesTest	<RenderPass>,				s_renderPassCases),
   2777 		CASE_DESC(multithreadedCreatePerThreadResourcesTest	<GraphicsPipeline>,			s_graphicsPipelineCases),
   2778 		CASE_DESC(multithreadedCreatePerThreadResourcesTest	<ComputePipeline>,			s_computePipelineCases),
   2779 		CASE_DESC(multithreadedCreatePerThreadResourcesTest	<DescriptorSetLayout>,		s_descriptorSetLayoutCases),
   2780 		CASE_DESC(multithreadedCreatePerThreadResourcesTest	<Sampler>,					s_samplerCases),
   2781 		CASE_DESC(multithreadedCreatePerThreadResourcesTest	<DescriptorPool>,			s_descriptorPoolCases),
   2782 		CASE_DESC(multithreadedCreatePerThreadResourcesTest	<DescriptorSet>,			s_descriptorSetCases),
   2783 		CASE_DESC(multithreadedCreatePerThreadResourcesTest	<Framebuffer>,				s_framebufferCases),
   2784 		CASE_DESC(multithreadedCreatePerThreadResourcesTest	<CommandPool>,				s_commandPoolCases),
   2785 		CASE_DESC(multithreadedCreatePerThreadResourcesTest	<CommandBuffer>,			s_commandBufferCases),
   2786 	};
   2787 	objectMgmtTests->addChild(createGroup(testCtx, "multithreaded_per_thread_resources", "Multithreaded object construction with per-thread resources", s_multithreadedCreatePerThreadResourcesGroup));
   2788 
   2789 	static const CaseDescriptions	s_multithreadedCreateSharedResourcesGroup	=
   2790 	{
   2791 		EMPTY_CASE_DESC(Instance),
   2792 		CASE_DESC(multithreadedCreateSharedResourcesTest	<Device>,					s_deviceCases),
   2793 		CASE_DESC(multithreadedCreateSharedResourcesTest	<DeviceMemory>,				s_deviceMemCases),
   2794 		CASE_DESC(multithreadedCreateSharedResourcesTest	<Buffer>,					s_bufferCases),
   2795 		CASE_DESC(multithreadedCreateSharedResourcesTest	<BufferView>,				s_bufferViewCases),
   2796 		CASE_DESC(multithreadedCreateSharedResourcesTest	<Image>,					s_imageCases),
   2797 		CASE_DESC(multithreadedCreateSharedResourcesTest	<ImageView>,				s_imageViewCases),
   2798 		CASE_DESC(multithreadedCreateSharedResourcesTest	<Semaphore>,				s_semaphoreCases),
   2799 		CASE_DESC(multithreadedCreateSharedResourcesTest	<Event>,					s_eventCases),
   2800 		CASE_DESC(multithreadedCreateSharedResourcesTest	<Fence>,					s_fenceCases),
   2801 		CASE_DESC(multithreadedCreateSharedResourcesTest	<QueryPool>,				s_queryPoolCases),
   2802 		CASE_DESC(multithreadedCreateSharedResourcesTest	<ShaderModule>,				s_shaderModuleCases),
   2803 		CASE_DESC(multithreadedCreateSharedResourcesTest	<PipelineCache>,			s_pipelineCacheCases),
   2804 		CASE_DESC(multithreadedCreateSharedResourcesTest	<PipelineLayout>,			s_pipelineLayoutCases),
   2805 		CASE_DESC(multithreadedCreateSharedResourcesTest	<RenderPass>,				s_renderPassCases),
   2806 		CASE_DESC(multithreadedCreateSharedResourcesTest	<GraphicsPipeline>,			s_graphicsPipelineCases),
   2807 		CASE_DESC(multithreadedCreateSharedResourcesTest	<ComputePipeline>,			s_computePipelineCases),
   2808 		CASE_DESC(multithreadedCreateSharedResourcesTest	<DescriptorSetLayout>,		s_descriptorSetLayoutCases),
   2809 		CASE_DESC(multithreadedCreateSharedResourcesTest	<Sampler>,					s_samplerCases),
   2810 		CASE_DESC(multithreadedCreateSharedResourcesTest	<DescriptorPool>,			s_descriptorPoolCases),
   2811 		EMPTY_CASE_DESC(DescriptorSet),		// \note Needs per-thread DescriptorPool
   2812 		CASE_DESC(multithreadedCreateSharedResourcesTest	<Framebuffer>,				s_framebufferCases),
   2813 		CASE_DESC(multithreadedCreateSharedResourcesTest	<CommandPool>,				s_commandPoolCases),
   2814 		EMPTY_CASE_DESC(CommandBuffer),			// \note Needs per-thread CommandPool
   2815 	};
   2816 	objectMgmtTests->addChild(createGroup(testCtx, "multithreaded_shared_resources", "Multithreaded object construction with shared resources", s_multithreadedCreateSharedResourcesGroup));
   2817 
   2818 	static const CaseDescriptions	s_createSingleAllocCallbacksGroup	=
   2819 	{
   2820 		CASE_DESC(createSingleAllocCallbacksTest	<Instance>,					s_instanceCases),
   2821 		CASE_DESC(createSingleAllocCallbacksTest	<Device>,					s_deviceCases),
   2822 		CASE_DESC(createSingleAllocCallbacksTest	<DeviceMemory>,				s_deviceMemCases),
   2823 		CASE_DESC(createSingleAllocCallbacksTest	<Buffer>,					s_bufferCases),
   2824 		CASE_DESC(createSingleAllocCallbacksTest	<BufferView>,				s_bufferViewCases),
   2825 		CASE_DESC(createSingleAllocCallbacksTest	<Image>,					s_imageCases),
   2826 		CASE_DESC(createSingleAllocCallbacksTest	<ImageView>,				s_imageViewCases),
   2827 		CASE_DESC(createSingleAllocCallbacksTest	<Semaphore>,				s_semaphoreCases),
   2828 		CASE_DESC(createSingleAllocCallbacksTest	<Event>,					s_eventCases),
   2829 		CASE_DESC(createSingleAllocCallbacksTest	<Fence>,					s_fenceCases),
   2830 		CASE_DESC(createSingleAllocCallbacksTest	<QueryPool>,				s_queryPoolCases),
   2831 		CASE_DESC(createSingleAllocCallbacksTest	<ShaderModule>,				s_shaderModuleCases),
   2832 		CASE_DESC(createSingleAllocCallbacksTest	<PipelineCache>,			s_pipelineCacheCases),
   2833 		CASE_DESC(createSingleAllocCallbacksTest	<PipelineLayout>,			s_pipelineLayoutCases),
   2834 		CASE_DESC(createSingleAllocCallbacksTest	<RenderPass>,				s_renderPassCases),
   2835 		CASE_DESC(createSingleAllocCallbacksTest	<GraphicsPipeline>,			s_graphicsPipelineCases),
   2836 		CASE_DESC(createSingleAllocCallbacksTest	<ComputePipeline>,			s_computePipelineCases),
   2837 		CASE_DESC(createSingleAllocCallbacksTest	<DescriptorSetLayout>,		s_descriptorSetLayoutCases),
   2838 		CASE_DESC(createSingleAllocCallbacksTest	<Sampler>,					s_samplerCases),
   2839 		CASE_DESC(createSingleAllocCallbacksTest	<DescriptorPool>,			s_descriptorPoolCases),
   2840 		CASE_DESC(createSingleAllocCallbacksTest	<DescriptorSet>,			s_descriptorSetCases),
   2841 		CASE_DESC(createSingleAllocCallbacksTest	<Framebuffer>,				s_framebufferCases),
   2842 		CASE_DESC(createSingleAllocCallbacksTest	<CommandPool>,				s_commandPoolCases),
   2843 		CASE_DESC(createSingleAllocCallbacksTest	<CommandBuffer>,			s_commandBufferCases),
   2844 	};
   2845 	objectMgmtTests->addChild(createGroup(testCtx, "single_alloc_callbacks", "Create single object", s_createSingleAllocCallbacksGroup));
   2846 
   2847 	static const CaseDescriptions	s_allocCallbackFailGroup	=
   2848 	{
   2849 		CASE_DESC(allocCallbackFailTest	<Instance>,					s_instanceCases),
   2850 		CASE_DESC(allocCallbackFailTest	<Device>,					s_deviceCases),
   2851 		CASE_DESC(allocCallbackFailTest	<DeviceMemory>,				s_deviceMemCases),
   2852 		CASE_DESC(allocCallbackFailTest	<Buffer>,					s_bufferCases),
   2853 		CASE_DESC(allocCallbackFailTest	<BufferView>,				s_bufferViewCases),
   2854 		CASE_DESC(allocCallbackFailTest	<Image>,					s_imageCases),
   2855 		CASE_DESC(allocCallbackFailTest	<ImageView>,				s_imageViewCases),
   2856 		CASE_DESC(allocCallbackFailTest	<Semaphore>,				s_semaphoreCases),
   2857 		CASE_DESC(allocCallbackFailTest	<Event>,					s_eventCases),
   2858 		CASE_DESC(allocCallbackFailTest	<Fence>,					s_fenceCases),
   2859 		CASE_DESC(allocCallbackFailTest	<QueryPool>,				s_queryPoolCases),
   2860 		CASE_DESC(allocCallbackFailTest	<ShaderModule>,				s_shaderModuleCases),
   2861 		CASE_DESC(allocCallbackFailTest	<PipelineCache>,			s_pipelineCacheCases),
   2862 		CASE_DESC(allocCallbackFailTest	<PipelineLayout>,			s_pipelineLayoutCases),
   2863 		CASE_DESC(allocCallbackFailTest	<RenderPass>,				s_renderPassCases),
   2864 		CASE_DESC(allocCallbackFailTest	<GraphicsPipeline>,			s_graphicsPipelineCases),
   2865 		CASE_DESC(allocCallbackFailTest	<ComputePipeline>,			s_computePipelineCases),
   2866 		CASE_DESC(allocCallbackFailTest	<DescriptorSetLayout>,		s_descriptorSetLayoutCases),
   2867 		CASE_DESC(allocCallbackFailTest	<Sampler>,					s_samplerCases),
   2868 		CASE_DESC(allocCallbackFailTest	<DescriptorPool>,			s_descriptorPoolCases),
   2869 		CASE_DESC(allocCallbackFailTest	<DescriptorSet>,			s_descriptorSetCases),
   2870 		CASE_DESC(allocCallbackFailTest	<Framebuffer>,				s_framebufferCases),
   2871 		CASE_DESC(allocCallbackFailTest	<CommandPool>,				s_commandPoolCases),
   2872 		CASE_DESC(allocCallbackFailTest	<CommandBuffer>,			s_commandBufferCases),
   2873 	};
   2874 	objectMgmtTests->addChild(createGroup(testCtx, "alloc_callback_fail", "Allocation callback failure", s_allocCallbackFailGroup));
   2875 
   2876 	return objectMgmtTests.release();
   2877 }
   2878 
   2879 } // api
   2880 } // vkt
   2881