Home | History | Annotate | Download | only in protected_memory 
      1 /*------------------------------------------------------------------------
      2  * Vulkan Conformance Tests
      3  * ------------------------
      4  *
      5  * Copyright (c) 2017 The Khronos Group Inc.
      6  * Copyright (c) 2017 Samsung Electronics Co., Ltd.
      7  *
      8  * Licensed under the Apache License, Version 2.0 (the "License");
      9  * you may not use this file except in compliance with the License.
     10  * You may obtain a copy of the License at
     11  *
     12  *      http://www.apache.org/licenses/LICENSE-2.0
     13  *
     14  * Unless required by applicable law or agreed to in writing, software
     15  * distributed under the License is distributed on an "AS IS" BASIS,
     16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     17  * See the License for the specific language governing permissions and
     18  * limitations under the License.
     19  *
     20  *//*!
     21  * \file
     22  * \brief Protected memory storage buffer tests
     23  *//*--------------------------------------------------------------------*/
     24 
     25 #include "vktProtectedMemStorageBufferTests.hpp"
     26 
     27 #include "deRandom.hpp"
     28 #include "deStringUtil.hpp"
     29 #include "tcuTestLog.hpp"
     30 #include "tcuVector.hpp"
     31 #include "tcuStringTemplate.hpp"
     32 
     33 #include "vkPrograms.hpp"
     34 #include "vktTestCase.hpp"
     35 #include "vktTestGroupUtil.hpp"
     36 #include "vkTypeUtil.hpp"
     37 #include "vkBuilderUtil.hpp"
     38 #include "vkCmdUtil.hpp"
     39 
     40 #include "vktProtectedMemBufferValidator.hpp"
     41 #include "vktProtectedMemUtils.hpp"
     42 #include "vktProtectedMemContext.hpp"
     43 
     44 namespace vkt
     45 {
     46 namespace ProtectedMem
     47 {
     48 
     49 namespace
     50 {
     51 
     52 enum {
     53 	RENDER_HEIGHT	= 128,
     54 	RENDER_WIDTH	= 128,
     55 };
     56 
     57 enum {
     58 	RANDOM_TEST_COUNT	= 10,
     59 };
     60 
     61 enum SSBOTestType {
     62 	SSBO_READ,
     63 	SSBO_WRITE,
     64 	SSBO_ATOMIC
     65 };
     66 
     67 enum SSBOAtomicType {
     68 	ATOMIC_ADD,
     69 	ATOMIC_MIN,
     70 	ATOMIC_MAX,
     71 	ATOMIC_AND,
     72 	ATOMIC_OR,
     73 	ATOMIC_XOR,
     74 	ATOMIC_EXCHANGE,
     75 	ATOMIC_COMPSWAP
     76 };
     77 
     78 
     79 const char* getSSBOTestDescription (SSBOTestType type)
     80 {
     81 	switch (type) {
     82 		case SSBO_READ:		return "Test for read storage buffer on protected memory.";
     83 		case SSBO_WRITE:	return "Test for write storage buffer on protected memory.";
     84 		case SSBO_ATOMIC:	return "Test for atomic storage buffer on protected memory.";
     85 		default: DE_FATAL("Invalid SSBO test type"); return "";
     86 	}
     87 }
     88 
     89 const char* getSSBOTypeString (SSBOTestType type)
     90 {
     91 	switch (type) {
     92 		case SSBO_READ:		return "read";
     93 		case SSBO_WRITE:	return "write";
     94 		case SSBO_ATOMIC:	return "atomic";
     95 		default: DE_FATAL("Invalid SSBO test type"); return "";
     96 	}
     97 }
     98 
     99 const char* getShaderTypeString (const glu::ShaderType shaderType)
    100 {
    101 	switch (shaderType) {
    102 		case glu::SHADERTYPE_FRAGMENT:	return "fragment";
    103 		case glu::SHADERTYPE_COMPUTE:	return "compute";
    104 		default: DE_FATAL("Invalid shader type"); return "";
    105 	}
    106 }
    107 
    108 const char* getSSBOAtomicTypeString (SSBOAtomicType type)
    109 {
    110 	switch (type)
    111 	{
    112 		case ATOMIC_ADD:		return "add";
    113 		case ATOMIC_MIN:		return "min";
    114 		case ATOMIC_MAX:		return "max";
    115 		case ATOMIC_AND:		return "and";
    116 		case ATOMIC_OR:			return "or";
    117 		case ATOMIC_XOR:		return "xor";
    118 		case ATOMIC_EXCHANGE:	return "exchange";
    119 		case ATOMIC_COMPSWAP:	return "compswap";
    120 		default: DE_FATAL("Invalid SSBO atomic operation type"); return "";
    121 	}
    122 }
    123 
    124 void static addBufferCopyCmd (const vk::DeviceInterface&	vk,
    125 							  vk::VkCommandBuffer			cmdBuffer,
    126 							  deUint32						queueFamilyIndex,
    127 							  vk::VkBuffer					srcBuffer,
    128 							  vk::VkBuffer					dstBuffer,
    129 							  deUint32						copySize)
    130 {
    131 	const vk::VkBufferMemoryBarrier		dstWriteStartBarrier	=
    132 	{
    133 		vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,		// VkStructureType		sType
    134 		DE_NULL,											// const void*			pNext
    135 		0,													// VkAccessFlags		srcAccessMask
    136 		vk::VK_ACCESS_SHADER_WRITE_BIT,						// VkAccessFlags		dstAccessMask
    137 		queueFamilyIndex,									// uint32_t				srcQueueFamilyIndex
    138 		queueFamilyIndex,									// uint32_t				dstQueueFamilyIndex
    139 		dstBuffer,											// VkBuffer				buffer
    140 		0u,													// VkDeviceSize			offset
    141 		VK_WHOLE_SIZE,										// VkDeviceSize			size
    142 	};
    143 
    144 	vk.cmdPipelineBarrier(cmdBuffer,
    145 						  vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,	// srcStageMask
    146 						  vk::VK_PIPELINE_STAGE_VERTEX_SHADER_BIT,	// dstStageMask
    147 						  (vk::VkDependencyFlags)0,
    148 						  0, (const vk::VkMemoryBarrier*)DE_NULL,
    149 						  1, &dstWriteStartBarrier,
    150 						  0, (const vk::VkImageMemoryBarrier*)DE_NULL);
    151 
    152 	const vk::VkBufferCopy				copyRegion				=
    153 	{
    154 		0,					// VkDeviceSize	srcOffset
    155 		0,					// VkDeviceSize	dstOffset
    156 		copySize			// VkDeviceSize	size
    157 	};
    158 	vk.cmdCopyBuffer(cmdBuffer, srcBuffer, dstBuffer, 1, &copyRegion);
    159 
    160 	const vk::VkBufferMemoryBarrier		dstWriteEndBarrier		=
    161 	{
    162 		vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,		// VkStructureType		sType
    163 		DE_NULL,											// const void*			pNext
    164 		vk::VK_ACCESS_SHADER_WRITE_BIT,						// VkAccessFlags		srcAccessMask
    165 		vk::VK_ACCESS_SHADER_READ_BIT,						// VkAccessFlags		dstAccessMask
    166 		queueFamilyIndex,									// uint32_t				srcQueueFamilyIndex
    167 		queueFamilyIndex,									// uint32_t				dstQueueFamilyIndex
    168 		dstBuffer,											// VkBuffer				buffer
    169 		0u,													// VkDeviceSize			offset
    170 		VK_WHOLE_SIZE,										// VkDeviceSize			size
    171 	};
    172 	vk.cmdPipelineBarrier(cmdBuffer,
    173 						  vk::VK_PIPELINE_STAGE_VERTEX_SHADER_BIT,		// srcStageMask
    174 						  vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,	// dstStageMask
    175 						  (vk::VkDependencyFlags)0,
    176 						  0, (const vk::VkMemoryBarrier*)DE_NULL,
    177 						  1, &dstWriteEndBarrier,
    178 						  0, (const vk::VkImageMemoryBarrier*)DE_NULL);
    179 
    180 }
    181 
    182 template<typename T>
    183 class StorageBufferTestInstance : public ProtectedTestInstance
    184 {
    185 public:
    186 								StorageBufferTestInstance	(Context&					ctx,
    187 															 const SSBOTestType			testType,
    188 															 const glu::ShaderType		shaderType,
    189 															 const tcu::UVec4			testInput,
    190 															 const BufferValidator<T>&	validator);
    191 	virtual tcu::TestStatus		iterate						(void);
    192 
    193 private:
    194 	tcu::TestStatus				executeFragmentTest			(void);
    195 	tcu::TestStatus				executeComputeTest			(void);
    196 
    197 	const SSBOTestType			m_testType;
    198 	const glu::ShaderType		m_shaderType;
    199 	const tcu::UVec4			m_testInput;
    200 	const BufferValidator<T>&	m_validator;
    201 	const vk::VkFormat			m_imageFormat;
    202 };
    203 
    204 template<typename T>
    205 class StorageBufferTestCase : public TestCase
    206 {
    207 public:
    208 								StorageBufferTestCase	(tcu::TestContext&			testctx,
    209 														 const SSBOTestType			testType,
    210 														 const glu::ShaderType		shaderType,
    211 														 const char*				name,
    212 														 const tcu::UVec4			testInput,
    213 														 ValidationDataStorage<T>	validationData,
    214 														 const std::string&			extraShader = "")
    215 									: TestCase		(testctx, name, getSSBOTestDescription(testType))
    216 									, m_testType	(testType)
    217 									, m_shaderType	(shaderType)
    218 									, m_testInput	(testInput)
    219 									, m_validator	(validationData)
    220 									, m_extraShader	(extraShader)
    221 								{
    222 								}
    223 	virtual TestInstance*		createInstance			(Context& ctx) const
    224 								{
    225 									return new StorageBufferTestInstance<T>(ctx, m_testType, m_shaderType, m_testInput, m_validator);
    226 								}
    227 	virtual void				initPrograms			(vk::SourceCollections& programCollection) const;
    228 
    229 	virtual						~StorageBufferTestCase	(void) {}
    230 
    231 private:
    232 	const SSBOTestType			m_testType;
    233 	const glu::ShaderType		m_shaderType;
    234 	const tcu::UVec4			m_testInput;
    235 	const BufferValidator<T>	m_validator;
    236 	const std::string			m_extraShader;
    237 };
    238 
    239 template<typename T>
    240 StorageBufferTestInstance<T>::StorageBufferTestInstance	 (Context&					ctx,
    241 														  const SSBOTestType		testType,
    242 														  const glu::ShaderType		shaderType,
    243 														  const tcu::UVec4			testInput,
    244 														  const BufferValidator<T>&	validator)
    245 	: ProtectedTestInstance	(ctx)
    246 	, m_testType			(testType)
    247 	, m_shaderType			(shaderType)
    248 	, m_testInput			(testInput)
    249 	, m_validator			(validator)
    250 	, m_imageFormat			(vk::VK_FORMAT_R8G8B8A8_UNORM)
    251 {
    252 }
    253 
    254 template<typename T>
    255 void StorageBufferTestCase<T>::initPrograms (vk::SourceCollections& programCollection) const
    256 {
    257 	const char* vertexShader =
    258 		"#version 450\n"
    259 		"layout(location=0) out vec4 vIndex;\n"
    260 		"void main() {\n"
    261 		"    vec2 pos[4] = vec2[4]( vec2(-0.7, 0.7), vec2(0.7, 0.7), vec2(0.0, -0.7), vec2(-0.7, -0.7) );\n"
    262 		"    vIndex = vec4(gl_VertexIndex);\n"
    263 		"    gl_PointSize = 1.0;\n"
    264 		"    gl_Position = vec4(pos[gl_VertexIndex], 0.0, 1.0);\n"
    265 		"}";
    266 
    267 	//  set = 0, location = 0 -> buffer ProtectedTestBuffer (uvec4)
    268 	//  set = 0, location = 2 -> buffer ProtectedTestBufferSource (uvec4)
    269 	const char* readShaderTemplateStr =
    270 		"#version 450\n"
    271 		"${INPUT_DECLARATION}\n"
    272 		"\n"
    273 		"layout(set=0, binding=0, std140) buffer ProtectedTestBuffer\n"
    274 		"{\n"
    275 		"    highp uvec4 protectedTestResultBuffer;\n"
    276 		"};\n"
    277 		"\n"
    278 		"layout(set=0, binding=2, std140) buffer ProtectedTestBufferSource\n"
    279 		"{\n"
    280 		"    highp uvec4 protectedTestBufferSource;\n"
    281 		"};\n"
    282 		"\n"
    283 		"void main (void)\n"
    284 		"{\n"
    285 		"    protectedTestResultBuffer = protectedTestBufferSource;\n"
    286 		"    ${FRAGMENT_OUTPUT}\n"
    287 		"}\n";
    288 
    289 	//  set = 0, location = 0 -> buffer ProtectedTestBuffer (uvec4)
    290 	//  set = 0, location = 1 -> uniform Data (uvec4)
    291 	const char* writeShaderTemplateStr =
    292 		"#version 450\n"
    293 		"${INPUT_DECLARATION}\n"
    294 		"\n"
    295 		"layout(set=0, binding=0, std140) buffer ProtectedTestBuffer\n"
    296 		"{\n"
    297 		"    highp uvec4 protectedTestResultBuffer;\n"
    298 		"};\n"
    299 		"\n"
    300 		"layout(set=0, binding=1, std140) uniform Data\n"
    301 		"{\n"
    302 		"    highp uvec4 testInput;\n"
    303 		"};\n"
    304 		"\n"
    305 		"void main (void)\n"
    306 		"{\n"
    307 		"    protectedTestResultBuffer = testInput;\n"
    308 		"    ${FRAGMENT_OUTPUT}\n"
    309 		"}\n";
    310 
    311 	//  set = 0, location = 0 -> buffer ProtectedTestBuffer (uint [4])
    312 	const char* atomicTestShaderTemplateStr =
    313 		"#version 450\n"
    314 		"${INPUT_DECLARATION}\n"
    315 		"\n"
    316 		"layout(set=0, binding=0, std430) buffer ProtectedTestBuffer\n"
    317 		"{\n"
    318 		"    highp uint protectedTestResultBuffer[4];\n"
    319 		"};\n"
    320 		"\n"
    321 		"void main (void)\n"
    322 		"{\n"
    323 		"    uint i = uint(${INVOCATION_ID});\n"
    324 		"    ${ATOMIC_FUNCTION_CALL}\n"
    325 		"    ${FRAGMENT_OUTPUT}\n"
    326 		"}\n";
    327 
    328 	const char*							shaderTemplateStr;
    329 	std::map<std::string, std::string>	shaderParam;
    330 	switch (m_testType) {
    331 		case SSBO_READ:		shaderTemplateStr = readShaderTemplateStr; break;
    332 		case SSBO_WRITE:	shaderTemplateStr = writeShaderTemplateStr; break;
    333 		case SSBO_ATOMIC:	{
    334 			shaderTemplateStr = atomicTestShaderTemplateStr;
    335 			shaderParam["ATOMIC_FUNCTION_CALL"] = m_extraShader;
    336 			break;
    337 		}
    338 		default: DE_FATAL("Incorrect SSBO test type"); return;
    339 	}
    340 
    341 	if (m_shaderType == glu::SHADERTYPE_FRAGMENT)
    342 	{
    343 		shaderParam["INPUT_DECLARATION"]		= "layout(location=0) out mediump vec4 o_color;\n"
    344 												  "layout(location=0) in vec4 vIndex;\n";
    345 		shaderParam["FRAGMENT_OUTPUT"]			= "o_color = vec4( 0.0, 0.4, 1.0, 1.0 );\n";
    346 		shaderParam["INVOCATION_ID"]			= "vIndex.x";
    347 
    348 		programCollection.glslSources.add("vert") << glu::VertexSource(vertexShader);
    349 		programCollection.glslSources.add("TestShader") << glu::FragmentSource(tcu::StringTemplate(shaderTemplateStr).specialize(shaderParam));
    350 	}
    351 	else if (m_shaderType == glu::SHADERTYPE_COMPUTE)
    352 	{
    353 		shaderParam["INPUT_DECLARATION"]		= "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n";
    354 		shaderParam["FRAGMENT_OUTPUT"]			= "";
    355 		shaderParam["INVOCATION_ID"]			= "gl_GlobalInvocationID.x";
    356 		programCollection.glslSources.add("TestShader") << glu::ComputeSource(tcu::StringTemplate(shaderTemplateStr).specialize(shaderParam));
    357 	}
    358 	else
    359 		DE_FATAL("Incorrect shader type");
    360 
    361 	m_validator.initPrograms(programCollection);
    362 }
    363 
    364 template<typename T>
    365 tcu::TestStatus StorageBufferTestInstance<T>::executeFragmentTest(void)
    366 {
    367 	ProtectedContext&						ctx					(m_protectedContext);
    368 	const vk::DeviceInterface&				vk					= ctx.getDeviceInterface();
    369 	const vk::VkDevice						device				= ctx.getDevice();
    370 	const vk::VkQueue						queue				= ctx.getQueue();
    371 	const deUint32							queueFamilyIndex	= ctx.getQueueFamilyIndex();
    372 
    373 	const deUint32							testUniformSize		= sizeof(m_testInput);
    374 	de::UniquePtr<vk::BufferWithMemory>		testUniform			(makeBuffer(ctx,
    375 																		PROTECTION_DISABLED,
    376 																		queueFamilyIndex,
    377 																		testUniformSize,
    378 																		vk::VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT
    379 																		 | vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
    380 																		vk::MemoryRequirement::HostVisible));
    381 
    382 	// Set the test input uniform data
    383 	{
    384 		deMemcpy(testUniform->getAllocation().getHostPtr(), &m_testInput, testUniformSize);
    385 		vk::flushMappedMemoryRange(vk, device, testUniform->getAllocation().getMemory(), testUniform->getAllocation().getOffset(), testUniformSize);
    386 	}
    387 	const deUint32							testBufferSize		= sizeof(ValidationDataStorage<T>);
    388 	de::MovePtr<vk::BufferWithMemory>		testBuffer			(makeBuffer(ctx,
    389 																			PROTECTION_ENABLED,
    390 																			queueFamilyIndex,
    391 																			testBufferSize,
    392 																			vk::VK_BUFFER_USAGE_STORAGE_BUFFER_BIT
    393 																			 | vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT,
    394 																			vk::MemoryRequirement::Protected));
    395     de::MovePtr<vk::BufferWithMemory>		testBufferSource			(makeBuffer(ctx,
    396 																			PROTECTION_ENABLED,
    397 																			queueFamilyIndex,
    398 																			testBufferSize,
    399 																			vk::VK_BUFFER_USAGE_STORAGE_BUFFER_BIT
    400 																			 | vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT,
    401 																			vk::MemoryRequirement::Protected));
    402 
    403 	vk::Move<vk::VkShaderModule>			vertexShader		(vk::createShaderModule(vk, device, ctx.getBinaryCollection().get("vert"), 0));
    404 	vk::Unique<vk::VkShaderModule>			testShader			(vk::createShaderModule(vk, device, ctx.getBinaryCollection().get("TestShader"), 0));
    405 
    406 	// Create descriptors
    407 	vk::Unique<vk::VkDescriptorSetLayout>	descriptorSetLayout(vk::DescriptorSetLayoutBuilder()
    408 		.addSingleBinding(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, vk::VK_SHADER_STAGE_ALL)
    409 		.addSingleBinding(vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, vk::VK_SHADER_STAGE_ALL)
    410 		.addSingleBinding(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, vk::VK_SHADER_STAGE_ALL)
    411 		.build(vk, device));
    412 	vk::Unique<vk::VkDescriptorPool>		descriptorPool(vk::DescriptorPoolBuilder()
    413 		.addType(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1u)
    414 		.addType(vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1u)
    415 		.addType(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1u)
    416 		.build(vk, device, vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u));
    417 	vk::Unique<vk::VkDescriptorSet>			descriptorSet		(makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout));
    418 
    419 	// Update descriptor set information
    420 	{
    421 		vk::VkDescriptorBufferInfo	descTestBuffer			= makeDescriptorBufferInfo(**testBuffer, 0, testBufferSize);
    422 		vk::VkDescriptorBufferInfo	descTestUniform			= makeDescriptorBufferInfo(**testUniform, 0, testUniformSize);
    423 		vk::VkDescriptorBufferInfo	descTestBufferSource	= makeDescriptorBufferInfo(**testBufferSource, 0, testBufferSize);
    424 
    425 		vk::DescriptorSetUpdateBuilder()
    426 			.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(0u), vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &descTestBuffer)
    427 			.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(1u), vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &descTestUniform)
    428 			.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(2u), vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &descTestBufferSource)
    429 			.update(vk, device);
    430 	}
    431 
    432 	// Create output image
    433 	de::MovePtr<vk::ImageWithMemory>		colorImage			(createImage2D(ctx, PROTECTION_ENABLED, queueFamilyIndex,
    434 																			   RENDER_WIDTH, RENDER_HEIGHT,
    435 																			   m_imageFormat,
    436 																			   vk::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|vk::VK_IMAGE_USAGE_SAMPLED_BIT));
    437 	vk::Unique<vk::VkImageView>				colorImageView		(createImageView(ctx, **colorImage, m_imageFormat));
    438 	vk::Unique<vk::VkRenderPass>			renderPass			(createRenderPass(ctx, m_imageFormat));
    439 	vk::Unique<vk::VkFramebuffer>			framebuffer			(createFramebuffer(ctx, RENDER_WIDTH, RENDER_HEIGHT, *renderPass, *colorImageView));
    440 
    441 	// Build pipeline
    442 	vk::Unique<vk::VkPipelineLayout>		pipelineLayout		(makePipelineLayout(vk, device, *descriptorSetLayout));
    443 	vk::Unique<vk::VkCommandPool>			cmdPool				(makeCommandPool(vk, device, PROTECTION_ENABLED, queueFamilyIndex));
    444 	vk::Unique<vk::VkCommandBuffer>			cmdBuffer			(vk::allocateCommandBuffer(vk, device, *cmdPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY));
    445 
    446 	// Create pipeline
    447 	vk::Unique<vk::VkPipeline>				graphicsPipeline	(makeGraphicsPipeline(vk, device, *pipelineLayout, *renderPass,
    448 																					  *vertexShader, *testShader,
    449 																					  std::vector<vk::VkVertexInputBindingDescription>(),
    450 																					  std::vector<vk::VkVertexInputAttributeDescription>(),
    451 																					  tcu::UVec2(RENDER_WIDTH, RENDER_HEIGHT),
    452 																					  vk::VK_PRIMITIVE_TOPOLOGY_POINT_LIST));
    453 
    454 	beginCommandBuffer(vk, *cmdBuffer);
    455 
    456 	if (m_testType == SSBO_READ || m_testType == SSBO_ATOMIC)
    457 	{
    458 		vk::VkBuffer targetBuffer = (m_testType == SSBO_ATOMIC) ? **testBuffer : **testBufferSource;
    459 		addBufferCopyCmd(vk, *cmdBuffer, queueFamilyIndex, **testUniform, targetBuffer, testUniformSize);
    460 	}
    461 
    462 	// Start image barrier
    463 	{
    464 		const vk::VkImageMemoryBarrier	startImgBarrier		=
    465 		{
    466 			vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,			// sType
    467 			DE_NULL,											// pNext
    468 			0,													// srcAccessMask
    469 			vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,			// dstAccessMask
    470 			vk::VK_IMAGE_LAYOUT_UNDEFINED,						// oldLayout
    471 			vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,		// newLayout
    472 			queueFamilyIndex,									// srcQueueFamilyIndex
    473 			queueFamilyIndex,									// dstQueueFamilyIndex
    474 			**colorImage,										// image
    475 			{
    476 				vk::VK_IMAGE_ASPECT_COLOR_BIT,					// aspectMask
    477 				0u,												// baseMipLevel
    478 				1u,												// mipLevels
    479 				0u,												// baseArraySlice
    480 				1u,												// subresourceRange
    481 			}
    482 		};
    483 
    484 		vk.cmdPipelineBarrier(*cmdBuffer,
    485 							  vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,				// srcStageMask
    486 							  vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,	// dstStageMask
    487 							  (vk::VkDependencyFlags)0,
    488 							  0, (const vk::VkMemoryBarrier*)DE_NULL,
    489 							  0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
    490 							  1, &startImgBarrier);
    491 	}
    492 
    493 	beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer, vk::makeRect2D(0, 0, RENDER_WIDTH, RENDER_HEIGHT), tcu::Vec4(0.125f, 0.25f, 0.5f, 1.0f));
    494 	vk.cmdBindPipeline(*cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *graphicsPipeline);
    495 	vk.cmdBindDescriptorSets(*cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0u, 1u, &*descriptorSet, 0u, DE_NULL);
    496 
    497 	vk.cmdDraw(*cmdBuffer, 4u, 1u, 0u, 0u);
    498 	endRenderPass(vk, *cmdBuffer);
    499 
    500 	{
    501 		const vk::VkImageMemoryBarrier	endImgBarrier		=
    502 		{
    503 			vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,			// sType
    504 			DE_NULL,											// pNext
    505 			vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,			// srcAccessMask
    506 			vk::VK_ACCESS_SHADER_READ_BIT,						// dstAccessMask
    507 			vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,		// oldLayout
    508 			vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,		// newLayout
    509 			queueFamilyIndex,									// srcQueueFamilyIndex
    510 			queueFamilyIndex,									// dstQueueFamilyIndex
    511 			**colorImage,										// image
    512 			{
    513 				vk::VK_IMAGE_ASPECT_COLOR_BIT,					// aspectMask
    514 				0u,												// baseMipLevel
    515 				1u,												// mipLevels
    516 				0u,												// baseArraySlice
    517 				1u,												// subresourceRange
    518 			}
    519 		};
    520 		vk.cmdPipelineBarrier(*cmdBuffer,
    521 							  vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,	// srcStageMask
    522 							  vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,				// dstStageMask
    523 							  (vk::VkDependencyFlags)0,
    524 							  0, (const vk::VkMemoryBarrier*)DE_NULL,
    525 							  0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
    526 							  1, &endImgBarrier);
    527 	}
    528 
    529 	endCommandBuffer(vk, *cmdBuffer);
    530 
    531 	// Execute Draw
    532 	{
    533 		const vk::Unique<vk::VkFence> fence (vk::createFence(vk, device));
    534 		VK_CHECK(vk.resetFences(device, 1, &fence.get()));
    535 		VK_CHECK(queueSubmit(ctx, PROTECTION_ENABLED, queue, *cmdBuffer, *fence, ~0ull));
    536 	}
    537 
    538 	// Log inputs
    539 	ctx.getTestContext().getLog()
    540 			<< tcu::TestLog::Message << "Input values: \n"
    541 			<< "1: " << m_testInput << "\n"
    542 			<< tcu::TestLog::EndMessage;
    543 
    544 	// Validate buffer
    545 	if (m_validator.validateBuffer(ctx, **testBuffer))
    546 		return tcu::TestStatus::pass("Everything went OK");
    547 	else
    548 		return tcu::TestStatus::fail("Something went really wrong");
    549 }
    550 
    551 template<typename T>
    552 tcu::TestStatus StorageBufferTestInstance<T>::executeComputeTest(void)
    553 {
    554 	ProtectedContext&						ctx					(m_protectedContext);
    555 	const vk::DeviceInterface&				vk					= ctx.getDeviceInterface();
    556 	const vk::VkDevice						device				= ctx.getDevice();
    557 	const vk::VkQueue						queue				= ctx.getQueue();
    558 	const deUint32							queueFamilyIndex	= ctx.getQueueFamilyIndex();
    559 
    560 	const deUint32							testUniformSize		= sizeof(m_testInput);
    561 	de::UniquePtr<vk::BufferWithMemory>		testUniform			(makeBuffer(ctx,
    562 																		PROTECTION_DISABLED,
    563 																		queueFamilyIndex,
    564 																		testUniformSize,
    565 																		vk::VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT
    566 																		 | vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
    567 																		vk::MemoryRequirement::HostVisible));
    568 
    569 	// Set the test input uniform data
    570 	{
    571 		deMemcpy(testUniform->getAllocation().getHostPtr(), &m_testInput, testUniformSize);
    572 		vk::flushMappedMemoryRange(vk, device, testUniform->getAllocation().getMemory(), testUniform->getAllocation().getOffset(), testUniformSize);
    573 	}
    574 
    575 	const deUint32							testBufferSize		= sizeof(ValidationDataStorage<T>);
    576 	de::MovePtr<vk::BufferWithMemory>		testBuffer			(makeBuffer(ctx,
    577 																			PROTECTION_ENABLED,
    578 																			queueFamilyIndex,
    579 																			testBufferSize,
    580 																			vk::VK_BUFFER_USAGE_STORAGE_BUFFER_BIT
    581 																			 | vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT,
    582 																			vk::MemoryRequirement::Protected));
    583 	de::MovePtr<vk::BufferWithMemory>		testBufferSource	(makeBuffer(ctx,
    584 																			PROTECTION_ENABLED,
    585 																			queueFamilyIndex,
    586 																			testBufferSize,
    587 																			vk::VK_BUFFER_USAGE_STORAGE_BUFFER_BIT
    588 																			 | vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT,
    589 																			vk::MemoryRequirement::Protected));
    590 
    591 	vk::Unique<vk::VkShaderModule>			testShader			(vk::createShaderModule(vk, device, ctx.getBinaryCollection().get("TestShader"), 0));
    592 
    593 	// Create descriptors
    594 	vk::Unique<vk::VkDescriptorSetLayout>	descriptorSetLayout(vk::DescriptorSetLayoutBuilder()
    595 		.addSingleBinding(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, vk::VK_SHADER_STAGE_COMPUTE_BIT)
    596 		.addSingleBinding(vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, vk::VK_SHADER_STAGE_COMPUTE_BIT)
    597 		.addSingleBinding(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, vk::VK_SHADER_STAGE_COMPUTE_BIT)
    598 		.build(vk, device));
    599 	vk::Unique<vk::VkDescriptorPool>		descriptorPool(vk::DescriptorPoolBuilder()
    600 		.addType(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1u)
    601 		.addType(vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1u)
    602 		.addType(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1u)
    603 		.build(vk, device, vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u));
    604 	vk::Unique<vk::VkDescriptorSet>			descriptorSet		(makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout));
    605 
    606 	// Update descriptor set information
    607 	{
    608 		vk::VkDescriptorBufferInfo	descTestBuffer			= makeDescriptorBufferInfo(**testBuffer, 0, testBufferSize);
    609 		vk::VkDescriptorBufferInfo	descTestUniform			= makeDescriptorBufferInfo(**testUniform, 0, testUniformSize);
    610 		vk::VkDescriptorBufferInfo	descTestBufferSource	= makeDescriptorBufferInfo(**testBufferSource, 0, testBufferSize);
    611 
    612 		vk::DescriptorSetUpdateBuilder()
    613 			.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(0u), vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &descTestBuffer)
    614 			.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(1u), vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &descTestUniform)
    615 			.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(2u), vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &descTestBufferSource)
    616 			.update(vk, device);
    617 	}
    618 
    619 
    620 	// Build and execute test
    621 	{
    622 		const vk::Unique<vk::VkFence>		fence				(vk::createFence(vk, device));
    623 		vk::Unique<vk::VkPipelineLayout>	pipelineLayout		(makePipelineLayout(vk, device, *descriptorSetLayout));
    624 		vk::Unique<vk::VkPipeline>			SSBOPipeline		(makeComputePipeline(vk, device, *pipelineLayout, *testShader, DE_NULL));
    625 		vk::Unique<vk::VkCommandPool>		cmdPool				(makeCommandPool(vk, device, PROTECTION_ENABLED, queueFamilyIndex));
    626 		vk::Unique<vk::VkCommandBuffer>		cmdBuffer			(vk::allocateCommandBuffer(vk, device, *cmdPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY));
    627 		deUint32							dispatchCount		= (m_testType == SSBO_ATOMIC) ? 4u : 1u;
    628 
    629 		beginCommandBuffer(vk, *cmdBuffer);
    630 
    631 		if (m_testType == SSBO_READ || m_testType == SSBO_ATOMIC)
    632 		{
    633 			vk::VkBuffer targetBuffer = (m_testType == SSBO_ATOMIC) ? **testBuffer : **testBufferSource;
    634 			addBufferCopyCmd(vk, *cmdBuffer, queueFamilyIndex, **testUniform, targetBuffer, testUniformSize);
    635 		}
    636 
    637 		vk.cmdBindPipeline(*cmdBuffer, vk::VK_PIPELINE_BIND_POINT_COMPUTE, *SSBOPipeline);
    638 		vk.cmdBindDescriptorSets(*cmdBuffer, vk::VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &*descriptorSet, 0u, DE_NULL);
    639 
    640 		vk.cmdDispatch(*cmdBuffer, dispatchCount, 1u, 1u);
    641 
    642 		endCommandBuffer(vk, *cmdBuffer);
    643 		VK_CHECK(queueSubmit(ctx, PROTECTION_ENABLED, queue, *cmdBuffer, *fence, ~0ull));
    644 	}
    645 
    646 	ctx.getTestContext().getLog()
    647 			<< tcu::TestLog::Message << "Input values: \n"
    648 			<< "1: " << m_testInput << "\n"
    649 			<< tcu::TestLog::EndMessage;
    650 
    651 	// Validate buffer
    652 	if (m_validator.validateBuffer(ctx, **testBuffer))
    653 		return tcu::TestStatus::pass("Everything went OK");
    654 	else
    655 		return tcu::TestStatus::fail("Something went really wrong");
    656 }
    657 
    658 template<typename T>
    659 tcu::TestStatus StorageBufferTestInstance<T>::iterate(void)
    660 {
    661 	switch (m_shaderType)
    662 	{
    663 		case glu::SHADERTYPE_FRAGMENT:	return executeFragmentTest();
    664 		case glu::SHADERTYPE_COMPUTE:	return executeComputeTest();
    665 		default:
    666 			DE_FATAL("Incorrect shader type"); return tcu::TestStatus::fail("");
    667 	}
    668 }
    669 
    670 tcu::TestCaseGroup* createSpecifiedStorageBufferTests (tcu::TestContext&						testCtx,
    671 													   const std::string						groupName,
    672 													   SSBOTestType								testType,
    673 													   const glu::ShaderType					shaderType,
    674 													   const ValidationDataStorage<tcu::UVec4>	testData[],
    675 													   size_t									testCount)
    676 {
    677 	const std::string				testTypeStr		= getSSBOTypeString(testType);
    678 	const std::string				description		= "Storage buffer " + testTypeStr + " tests";
    679 	de::MovePtr<tcu::TestCaseGroup> testGroup		(new tcu::TestCaseGroup(testCtx, groupName.c_str(), description.c_str()));
    680 
    681 	for (size_t ndx = 0; ndx < testCount; ++ndx)
    682 	{
    683 		const std::string name = testTypeStr + "_" + de::toString(ndx + 1);
    684 		testGroup->addChild(new StorageBufferTestCase<tcu::UVec4>(testCtx, testType, shaderType, name.c_str(), testData[ndx].values, testData[ndx]));
    685 	}
    686 
    687 	return testGroup.release();
    688 }
    689 
    690 tcu::TestCaseGroup* createRandomizedBufferTests (tcu::TestContext& testCtx, SSBOTestType testType, const glu::ShaderType shaderType, size_t testCount)
    691 {
    692 	de::Random											rnd				(testCtx.getCommandLine().getBaseSeed());
    693 	std::vector<ValidationDataStorage<tcu::UVec4> >		testData;
    694 	testData.resize(testCount);
    695 
    696 	for (size_t ndx = 0; ndx < testCount; ++ndx)
    697 		testData[ndx].values = tcu::UVec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32());
    698 
    699 	return createSpecifiedStorageBufferTests(testCtx, "random", testType, shaderType, testData.data(), testData.size());
    700 }
    701 
    702 tcu::TestCaseGroup* createRWStorageBufferTests (tcu::TestContext&							testCtx,
    703 												const std::string							groupName,
    704 												const std::string							groupDescription,
    705 												SSBOTestType								testType,
    706 												const ValidationDataStorage<tcu::UVec4>		testData[],
    707 												size_t										testCount)
    708 {
    709 	de::MovePtr<tcu::TestCaseGroup> ssboRWTestGroup (new tcu::TestCaseGroup(testCtx, groupName.c_str(), groupDescription.c_str()));
    710 
    711 	glu::ShaderType					shaderTypes[] = {
    712 		glu::SHADERTYPE_FRAGMENT,
    713 		glu::SHADERTYPE_COMPUTE
    714 	};
    715 
    716 	for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(shaderTypes); ++shaderNdx)
    717 	{
    718 		const glu::ShaderType				shaderType			= shaderTypes[shaderNdx];
    719 		const std::string					shaderName			= getShaderTypeString(shaderType);
    720 		const std::string					shaderGroupDesc		= "Storage buffer tests for shader type: " + shaderName;
    721 		de::MovePtr<tcu::TestCaseGroup>		testShaderGroup		(new tcu::TestCaseGroup(testCtx, shaderName.c_str(), shaderGroupDesc.c_str()));
    722 
    723 		testShaderGroup->addChild(createSpecifiedStorageBufferTests(testCtx, "static", testType, shaderType, testData, testCount));
    724 		testShaderGroup->addChild(createRandomizedBufferTests(testCtx, testType, shaderType, RANDOM_TEST_COUNT));
    725 		ssboRWTestGroup->addChild(testShaderGroup.release());
    726 	}
    727 
    728 	return ssboRWTestGroup.release();
    729 }
    730 
    731 void calculateAtomicOpData (SSBOAtomicType		type,
    732 							const tcu::UVec4&	inputValue,
    733 							const deUint32		atomicArg,
    734 							std::string&		atomicCall,
    735 							tcu::UVec4&			refValue,
    736 							const deUint32		swapNdx = 0)
    737 {
    738 	switch (type)
    739 	{
    740 		case ATOMIC_ADD:
    741 		{
    742 			refValue	= inputValue + tcu::UVec4(atomicArg);
    743 			atomicCall	= "atomicAdd(protectedTestResultBuffer[i], " + de::toString(atomicArg) + "u);";
    744 			break;
    745 		}
    746 		case ATOMIC_MIN:
    747 		{
    748 			refValue	= tcu::UVec4(std::min(inputValue.x(), atomicArg), std::min(inputValue.y(), atomicArg), std::min(inputValue.z(), atomicArg), std::min(inputValue.w(), atomicArg));
    749 			atomicCall	= "atomicMin(protectedTestResultBuffer[i], " + de::toString(atomicArg) + "u);";
    750 			break;
    751 		}
    752 		case ATOMIC_MAX:
    753 		{
    754 			refValue	= tcu::UVec4(std::max(inputValue.x(), atomicArg), std::max(inputValue.y(), atomicArg), std::max(inputValue.z(), atomicArg), std::max(inputValue.w(), atomicArg));
    755 			atomicCall	= "atomicMax(protectedTestResultBuffer[i], " + de::toString(atomicArg) + "u);";
    756 			break;
    757 		}
    758 		case ATOMIC_AND:
    759 		{
    760 			refValue	= tcu::UVec4(inputValue.x() & atomicArg, inputValue.y() & atomicArg, inputValue.z() & atomicArg, inputValue.w() & atomicArg);
    761 			atomicCall	= "atomicAnd(protectedTestResultBuffer[i], " + de::toString(atomicArg) + "u);";
    762 			break;
    763 		}
    764 		case ATOMIC_OR:
    765 		{
    766 			refValue	= tcu::UVec4(inputValue.x() | atomicArg, inputValue.y() | atomicArg, inputValue.z() | atomicArg, inputValue.w() | atomicArg);
    767 			atomicCall	= "atomicOr(protectedTestResultBuffer[i], " + de::toString(atomicArg) + "u);";
    768 			break;
    769 		}
    770 		case ATOMIC_XOR:
    771 		{
    772 			refValue	= tcu::UVec4(inputValue.x() ^ atomicArg, inputValue.y() ^ atomicArg, inputValue.z() ^ atomicArg, inputValue.w() ^ atomicArg);
    773 			atomicCall	= "atomicXor(protectedTestResultBuffer[i], " + de::toString(atomicArg) + "u);";
    774 			break;
    775 		}
    776 		case ATOMIC_EXCHANGE:
    777 		{
    778 			refValue	= tcu::UVec4(atomicArg);
    779 			atomicCall	= "atomicExchange(protectedTestResultBuffer[i], " + de::toString(atomicArg) + "u);";
    780 			break;
    781 		}
    782 		case ATOMIC_COMPSWAP:
    783 		{
    784 			int			selectedNdx		= swapNdx % 4;
    785 			deUint32	selectedChange	= inputValue[selectedNdx];
    786 
    787 			refValue				= inputValue;
    788 			refValue[selectedNdx]	= atomicArg;
    789 			atomicCall				= "atomicCompSwap(protectedTestResultBuffer[i], " + de::toString(selectedChange) + "u, " + de::toString(atomicArg) + "u);";
    790 			break;
    791 		}
    792 		default: DE_FATAL("Incorrect atomic function type"); break;
    793 	}
    794 
    795 }
    796 
    797 } // anonymous
    798 
    799 tcu::TestCaseGroup* createReadStorageBufferTests (tcu::TestContext& testCtx)
    800 {
    801 	const ValidationDataStorage<tcu::UVec4> testData[] = {
    802 		{ tcu::UVec4(0u, 0u, 0u, 0u) },	{ tcu::UVec4(1u, 0u, 0u, 0u) },
    803 		{ tcu::UVec4(0u, 1u, 0u, 0u) },	{ tcu::UVec4(0u, 0u, 1u, 0u) },
    804 		{ tcu::UVec4(0u, 0u, 0u, 1u) },	{ tcu::UVec4(1u, 1u, 1u, 1u) }
    805 	};
    806 
    807 	return createRWStorageBufferTests(testCtx, "ssbo_read", "Storage Buffer Read Tests", SSBO_READ, testData, DE_LENGTH_OF_ARRAY(testData));
    808 }
    809 
    810 tcu::TestCaseGroup* createWriteStorageBufferTests (tcu::TestContext& testCtx)
    811 {
    812 	const ValidationDataStorage<tcu::UVec4> testData[] = {
    813 		{ tcu::UVec4(0u, 0u, 0u, 0u) }, { tcu::UVec4(1u, 0u, 0u, 0u) },
    814 		{ tcu::UVec4(0u, 1u, 0u, 0u) }, { tcu::UVec4(0u, 0u, 1u, 0u) },
    815 		{ tcu::UVec4(0u, 0u, 0u, 1u) }, { tcu::UVec4(1u, 1u, 1u, 1u) }
    816 	};
    817 
    818 	return createRWStorageBufferTests(testCtx, "ssbo_write", "Storage Buffer Write Tests", SSBO_WRITE, testData, DE_LENGTH_OF_ARRAY(testData));
    819 }
    820 
    821 tcu::TestCaseGroup* createAtomicStorageBufferTests (tcu::TestContext& testctx)
    822 {
    823 	struct {
    824 		const tcu::UVec4	input;
    825 		const deUint32		atomicArg;
    826 		const deUint32		swapNdx;
    827 	}								testData[]	= {
    828 		{ tcu::UVec4(0u,		1u,			2u,			3u),		10u,	0u	},
    829 		{ tcu::UVec4(10u,		20u,		30u,		40u),		3u,		2u	},
    830 		{ tcu::UVec4(800u,		400u,		230u,		999u),		50u,	3u	},
    831 		{ tcu::UVec4(100800u,	233400u,	22230u,		77999u),	800u,	1u	},
    832 	};
    833 
    834 	SSBOAtomicType					testTypes[]	= {
    835 		ATOMIC_ADD,
    836 		ATOMIC_MIN,
    837 		ATOMIC_MAX,
    838 		ATOMIC_AND,
    839 		ATOMIC_OR,
    840 		ATOMIC_XOR,
    841 		ATOMIC_EXCHANGE,
    842 		ATOMIC_COMPSWAP
    843 	};
    844 
    845 	glu::ShaderType					shaderTypes[] = {
    846 		glu::SHADERTYPE_FRAGMENT,
    847 		glu::SHADERTYPE_COMPUTE
    848 	};
    849 
    850 	de::Random						rnd				(testctx.getCommandLine().getBaseSeed());
    851 	de::MovePtr<tcu::TestCaseGroup>	ssboAtomicTests (new tcu::TestCaseGroup(testctx, "ssbo_atomic", "Storage Buffer Atomic Tests"));
    852 
    853 	for (int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(shaderTypes); ++shaderNdx)
    854 	{
    855 		const glu::ShaderType				shaderType			= shaderTypes[shaderNdx];
    856 		const std::string					shaderName			= getShaderTypeString(shaderType);
    857 		const std::string					shaderDesc			= "Storage Buffer Atomic Tests for shader type: " + shaderName;
    858 		de::MovePtr<tcu::TestCaseGroup>		atomicShaderGroup	(new tcu::TestCaseGroup(testctx, shaderName.c_str(), shaderDesc.c_str()));
    859 
    860 		for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(testTypes); ++typeNdx)
    861 		{
    862 			SSBOAtomicType					atomicType		= testTypes[typeNdx];
    863 			const std::string				atomicTypeStr	= getSSBOAtomicTypeString(atomicType);
    864 			const std::string				atomicDesc		= "Storage Buffer Atomic Tests: " + atomicTypeStr;
    865 
    866 			de::MovePtr<tcu::TestCaseGroup>	staticTests		(new tcu::TestCaseGroup(testctx, "static", (atomicDesc + " with static input").c_str()));
    867 			for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(testData); ++ndx)
    868 			{
    869 				const std::string	name		= "atomic_" + atomicTypeStr + "_" + de::toString(ndx + 1);
    870 				const tcu::UVec4&	inputValue	= testData[ndx].input;
    871 				const deUint32&		atomicArg	= testData[ndx].atomicArg;
    872 				std::string			atomicCall;
    873 				tcu::UVec4			refValue;
    874 
    875 				calculateAtomicOpData(atomicType, inputValue, atomicArg, atomicCall, refValue, testData[ndx].swapNdx);
    876 
    877 				ValidationDataStorage<tcu::UVec4>	validationData	= { refValue };
    878 				staticTests->addChild(new StorageBufferTestCase<tcu::UVec4>(testctx, SSBO_ATOMIC, shaderType, name.c_str(), inputValue, validationData, atomicCall));
    879 			}
    880 
    881 			de::MovePtr<tcu::TestCaseGroup>	randomTests		(new tcu::TestCaseGroup(testctx, "random", (atomicDesc + " with random input").c_str()));
    882 			for (int ndx = 0; ndx < RANDOM_TEST_COUNT; ndx++)
    883 			{
    884 				const std::string					name			= "atomic_" + atomicTypeStr + "_" + de::toString(ndx + 1);
    885 				deUint32							atomicArg		= rnd.getUint16();
    886 				tcu::UVec4							inputValue;
    887 				tcu::UVec4							refValue;
    888 				std::string							atomicCall;
    889 
    890 				for (int i = 0; i < 4; i++)
    891 					inputValue[i] = rnd.getUint16();
    892 
    893 				calculateAtomicOpData(atomicType, inputValue, atomicArg, atomicCall, refValue, ndx);
    894 
    895 				ValidationDataStorage<tcu::UVec4>	validationData	= { refValue };
    896 				randomTests->addChild(new StorageBufferTestCase<tcu::UVec4>(testctx, SSBO_ATOMIC, shaderType, name.c_str(), inputValue, validationData, atomicCall));
    897 
    898 			}
    899 
    900 			de::MovePtr<tcu::TestCaseGroup>	atomicTests		(new tcu::TestCaseGroup(testctx, atomicTypeStr.c_str(), atomicDesc.c_str()));
    901 			atomicTests->addChild(staticTests.release());
    902 			atomicTests->addChild(randomTests.release());
    903 			atomicShaderGroup->addChild(atomicTests.release());
    904 		}
    905 		ssboAtomicTests->addChild(atomicShaderGroup.release());
    906 	}
    907 
    908 	return ssboAtomicTests.release();
    909 }
    910 
    911 } // ProtectedMem
    912 } // vkt
    913